nhrpd/nhrp_interface.c

   1 /* NHRP interface
   2  * Copyright (c) 2014-2015 Timo Teräs
   3  *
   4  * This file is free software: you may copy, redistribute and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 2 of the License, or
   7  * (at your option) any later version.
   8  */
   9
  10 #ifdef HAVE_CONFIG_H
  11 #include "config.h"
  12 #endif
  13
  14 #include <net/if_arp.h>
  15 #include "zebra.h"
  16 #include "linklist.h"
  17 #include "memory.h"
  18 #include "thread.h"
  19
  20 #include "nhrpd.h"
  21 #include "os.h"
  22 #include "hash.h"
  23
  24 DEFINE_MTYPE_STATIC(NHRPD, NHRP_IF, "NHRP interface");
  25 DEFINE_MTYPE_STATIC(NHRPD, NHRP_IF_GRE, "NHRP GRE interface");
  26
  27 struct hash *nhrp_gre_list;
  28
  29 static void nhrp_interface_update_cache_config(struct interface *ifp,
  30                                                bool available,
  31                                                uint8_t family);
  32
  33 static unsigned int nhrp_gre_info_key(const void *data)
  34 {
  35         const struct nhrp_gre_info *r = data;
  36
  37         return r->ifindex;
  38 }
  39
  40 static bool nhrp_gre_info_cmp(const void *data, const void *key)
  41 {
  42         const struct nhrp_gre_info *a = data, *b = key;
  43
  44         if (a->ifindex == b->ifindex)
  45                 return true;
  46         return false;
  47 }
  48
  49 static void *nhrp_interface_gre_alloc(void *data)
  50 {
  51         struct nhrp_gre_info *a;
  52         struct nhrp_gre_info *b = data;
  53
  54         a = XMALLOC(MTYPE_NHRP_IF_GRE, sizeof(struct nhrp_gre_info));
  55         memcpy(a, b, sizeof(struct nhrp_gre_info));
  56         return a;
  57 }
  58
  59 struct nhrp_gre_info *nhrp_gre_info_alloc(struct nhrp_gre_info *p)
  60 {
  61         struct nhrp_gre_info *a;
  62
  63         a = (struct nhrp_gre_info *)hash_get(nhrp_gre_list, p,
  64                                              nhrp_interface_gre_alloc);
  65         return a;
  66 }
  67
  68 static int nhrp_if_new_hook(struct interface *ifp)
  69 {
  70         struct nhrp_interface *nifp;
  71         afi_t afi;
  72
  73         nifp = XCALLOC(MTYPE_NHRP_IF, sizeof(struct nhrp_interface));
  74
  75         ifp->info = nifp;
  76         nifp->ifp = ifp;
  77
  78         notifier_init(&nifp->notifier_list);
  79         for (afi = 0; afi < AFI_MAX; afi++) {
  80                 struct nhrp_afi_data *ad = &nifp->afi[afi];
  81                 ad->holdtime = NHRPD_DEFAULT_HOLDTIME;
  82                 list_init(&ad->nhslist_head);
  83                 list_init(&ad->mcastlist_head);
  84         }
  85
  86         return 0;
  87 }
  88
  89 static int nhrp_if_delete_hook(struct interface *ifp)
  90 {
  91         struct nhrp_interface *nifp = ifp->info;
  92
  93         debugf(NHRP_DEBUG_IF, "Deleted interface (%s)", ifp->name);
  94
  95         nhrp_cache_interface_del(ifp);
  96         nhrp_nhs_interface_del(ifp);
  97         nhrp_multicast_interface_del(ifp);
  98         nhrp_peer_interface_del(ifp);
  99
 100         if (nifp->ipsec_profile)
 101                 free(nifp->ipsec_profile);
 102         if (nifp->ipsec_fallback_profile)
 103                 free(nifp->ipsec_fallback_profile);
 104         if (nifp->source)
 105                 free(nifp->source);
 106
 107         XFREE(MTYPE_NHRP_IF, ifp->info);
 108         return 0;
 109 }
 110
 111 void nhrp_interface_init(void)
 112 {
 113         hook_register_prio(if_add, 0, nhrp_if_new_hook);
 114         hook_register_prio(if_del, 0, nhrp_if_delete_hook);
 115
 116         nhrp_gre_list = hash_create(nhrp_gre_info_key, nhrp_gre_info_cmp,
 117                                     "NHRP GRE list Hash");
 118 }
 119
 120 void nhrp_interface_update_mtu(struct interface *ifp, afi_t afi)
 121 {
 122         struct nhrp_interface *nifp = ifp->info;
 123         struct nhrp_afi_data *if_ad = &nifp->afi[afi];
 124         unsigned short new_mtu;
 125
 126         if (if_ad->configured_mtu < 0)
 127                 new_mtu = nifp->nbmaifp ? nifp->nbmaifp->mtu : 0;
 128         else
 129                 new_mtu = if_ad->configured_mtu;
 130         if (new_mtu >= 1500)
 131                 new_mtu = 0;
 132
 133         if (new_mtu != if_ad->mtu) {
 134                 debugf(NHRP_DEBUG_IF, "%s: MTU changed to %d", ifp->name,
 135                        new_mtu);
 136                 if_ad->mtu = new_mtu;
 137                 notifier_call(&nifp->notifier_list,
 138                               NOTIFY_INTERFACE_MTU_CHANGED);
 139         }
 140 }
 141
 142 static void nhrp_interface_update_source(struct interface *ifp)
 143 {
 144         struct nhrp_interface *nifp = ifp->info;
 145
 146         if (!nifp->source || !nifp->nbmaifp ||
 147             ((ifindex_t)nifp->link_idx == nifp->nbmaifp->ifindex &&
 148              (nifp->link_vrf_id == nifp->nbmaifp->vrf_id)))
 149                 return;
 150
 151         nifp->link_idx = nifp->nbmaifp->ifindex;
 152         nifp->link_vrf_id = nifp->nbmaifp->vrf_id;
 153         debugf(NHRP_DEBUG_IF, "%s: bound device index changed to %d, vr %u",
 154                ifp->name, nifp->link_idx, nifp->link_vrf_id);
 155         nhrp_send_zebra_gre_source_set(ifp, nifp->link_idx, nifp->link_vrf_id);
 156 }
 157
 158 static void nhrp_interface_interface_notifier(struct notifier_block *n,
 159                                               unsigned long cmd)
 160 {
 161         struct nhrp_interface *nifp =
 162                 container_of(n, struct nhrp_interface, nbmanifp_notifier);
 163         struct interface *nbmaifp = nifp->nbmaifp;
 164         struct nhrp_interface *nbmanifp = nbmaifp->info;
 165
 166         switch (cmd) {
 167         case NOTIFY_INTERFACE_CHANGED:
 168                 nhrp_interface_update_mtu(nifp->ifp, AFI_IP);
 169                 nhrp_interface_update_source(nifp->ifp);
 170                 break;
 171         case NOTIFY_INTERFACE_ADDRESS_CHANGED:
 172                 nifp->nbma = nbmanifp->afi[AFI_IP].addr;
 173                 nhrp_interface_update(nifp->ifp);
 174                 notifier_call(&nifp->notifier_list,
 175                               NOTIFY_INTERFACE_NBMA_CHANGED);
 176                 debugf(NHRP_DEBUG_IF, "%s: NBMA change: address %pSU",
 177                        nifp->ifp->name, &nifp->nbma);
 178                 break;
 179         }
 180 }
 181
 182 void nhrp_interface_update_nbma(struct interface *ifp,
 183                                 struct nhrp_gre_info *gre_info)
 184 {
 185         struct nhrp_interface *nifp = ifp->info, *nbmanifp = NULL;
 186         struct interface *nbmaifp = NULL;
 187         union sockunion nbma;
 188
 189         sockunion_family(&nbma) = AF_UNSPEC;
 190
 191         if (nifp->source)
 192                 nbmaifp = if_lookup_by_name(nifp->source, nifp->link_vrf_id);
 193
 194         switch (ifp->ll_type) {
 195         case ZEBRA_LLT_IPGRE: {
 196                 struct in_addr saddr = {0};
 197
 198                 if (!gre_info) {
 199                         nhrp_send_zebra_gre_request(ifp);
 200                         return;
 201                 }
 202                 nifp->i_grekey = gre_info->ikey;
 203                 nifp->o_grekey = gre_info->okey;
 204                 nifp->link_idx = gre_info->ifindex_link;
 205                 nifp->link_vrf_id = gre_info->vrfid_link;
 206                 saddr.s_addr = gre_info->vtep_ip.s_addr;
 207
 208                 debugf(NHRP_DEBUG_IF, "%s: GRE: %x %x %x", ifp->name,
 209                        nifp->i_grekey, nifp->link_idx, saddr.s_addr);
 210                 if (saddr.s_addr)
 211                         sockunion_set(&nbma, AF_INET,
 212                                       (uint8_t *)&saddr.s_addr,
 213                                       sizeof(saddr.s_addr));
 214                 else if (!nbmaifp && nifp->link_idx != IFINDEX_INTERNAL)
 215                         nbmaifp =
 216                                 if_lookup_by_index(nifp->link_idx,
 217                                                    nifp->link_vrf_id);
 218         } break;
 219         default:
 220                 break;
 221         }
 222
 223         if (nbmaifp)
 224                 nbmanifp = nbmaifp->info;
 225
 226         if (nbmaifp != nifp->nbmaifp) {
 227                 if (nifp->nbmaifp)
 228                         notifier_del(&nifp->nbmanifp_notifier);
 229                 nifp->nbmaifp = nbmaifp;
 230                 if (nbmaifp) {
 231                         notifier_add(&nifp->nbmanifp_notifier,
 232                                      &nbmanifp->notifier_list,
 233                                      nhrp_interface_interface_notifier);
 234                         debugf(NHRP_DEBUG_IF, "%s: bound to %s", ifp->name,
 235                                nbmaifp->name);
 236                 }
 237         }
 238
 239         if (nbmaifp) {
 240                 if (sockunion_family(&nbma) == AF_UNSPEC)
 241                         nbma = nbmanifp->afi[AFI_IP].addr;
 242                 nhrp_interface_update_mtu(ifp, AFI_IP);
 243                 nhrp_interface_update_source(ifp);
 244         }
 245
 246         if (!sockunion_same(&nbma, &nifp->nbma)) {
 247                 nifp->nbma = nbma;
 248                 nhrp_interface_update(nifp->ifp);
 249                 debugf(NHRP_DEBUG_IF, "%s: NBMA address changed", ifp->name);
 250                 notifier_call(&nifp->notifier_list,
 251                               NOTIFY_INTERFACE_NBMA_CHANGED);
 252         }
 253
 254         nhrp_interface_update(ifp);
 255 }
 256
 257 static void nhrp_interface_update_address(struct interface *ifp, afi_t afi,
 258                                           int force)
 259 {
 260         const int family = afi2family(afi);
 261         struct nhrp_interface *nifp = ifp->info;
 262         struct nhrp_afi_data *if_ad = &nifp->afi[afi];
 263         struct nhrp_cache *nc;
 264         struct connected *c, *best;
 265         struct listnode *cnode;
 266         union sockunion addr;
 267         char buf[PREFIX_STRLEN];
 268
 269         /* Select new best match preferring primary address */
 270         best = NULL;
 271         for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, c)) {
 272                 if (PREFIX_FAMILY(c->address) != family)
 273                         continue;
 274                 if (best == NULL) {
 275                         best = c;
 276                         continue;
 277                 }
 278                 if ((best->flags & ZEBRA_IFA_SECONDARY)
 279                     && !(c->flags & ZEBRA_IFA_SECONDARY)) {
 280                         best = c;
 281                         continue;
 282                 }
 283                 if (!(best->flags & ZEBRA_IFA_SECONDARY)
 284                     && (c->flags & ZEBRA_IFA_SECONDARY))
 285                         continue;
 286                 if (best->address->prefixlen > c->address->prefixlen) {
 287                         best = c;
 288                         continue;
 289                 }
 290                 if (best->address->prefixlen < c->address->prefixlen)
 291                         continue;
 292         }
 293
 294         /* On NHRP interfaces a host prefix is required */
 295         if (best && if_ad->configured
 296             && best->address->prefixlen != 8 * prefix_blen(best->address)) {
 297                 zlog_notice("%s: %pFX is not a host prefix", ifp->name,
 298                             best->address);
 299                 best = NULL;
 300         }
 301
 302         /* Update address if it changed */
 303         if (best)
 304                 prefix2sockunion(best->address, &addr);
 305         else
 306                 memset(&addr, 0, sizeof(addr));
 307
 308         if (!force && sockunion_same(&if_ad->addr, &addr))
 309                 return;
 310
 311         if (sockunion_family(&if_ad->addr) != AF_UNSPEC) {
 312                 nc = nhrp_cache_get(ifp, &if_ad->addr, 0);
 313                 if (nc)
 314                         nhrp_cache_update_binding(nc, NHRP_CACHE_LOCAL, -1,
 315                                                   NULL, 0, NULL, NULL);
 316         }
 317
 318         debugf(NHRP_DEBUG_KERNEL, "%s: IPv%d address changed to %s", ifp->name,
 319                afi == AFI_IP ? 4 : 6,
 320                best ? prefix2str(best->address, buf, sizeof(buf)) : "(none)");
 321         if_ad->addr = addr;
 322
 323         if (if_ad->configured && sockunion_family(&if_ad->addr) != AF_UNSPEC) {
 324                 nc = nhrp_cache_get(ifp, &addr, 1);
 325                 if (nc)
 326                         nhrp_cache_update_binding(nc, NHRP_CACHE_LOCAL, 0, NULL,
 327                                                   0, NULL, NULL);
 328         }
 329
 330         notifier_call(&nifp->notifier_list, NOTIFY_INTERFACE_ADDRESS_CHANGED);
 331 }
 332
 333 void nhrp_interface_update(struct interface *ifp)
 334 {
 335         struct nhrp_interface *nifp = ifp->info;
 336         struct nhrp_afi_data *if_ad;
 337         afi_t afi;
 338         int enabled = 0;
 339
 340         notifier_call(&nifp->notifier_list, NOTIFY_INTERFACE_CHANGED);
 341
 342         for (afi = 0; afi < AFI_MAX; afi++) {
 343                 if_ad = &nifp->afi[afi];
 344
 345                 if (sockunion_family(&nifp->nbma) == AF_UNSPEC
 346                     || ifp->ifindex == IFINDEX_INTERNAL || !if_is_up(ifp)
 347                     || !if_ad->network_id) {
 348                         if (if_ad->configured) {
 349                                 if_ad->configured = 0;
 350                                 nhrp_interface_update_address(ifp, afi, 1);
 351                         }
 352                         continue;
 353                 }
 354
 355                 if (!if_ad->configured) {
 356                         os_configure_dmvpn(ifp->ifindex, ifp->name,
 357                                            afi2family(afi));
 358                         nhrp_send_zebra_configure_arp(ifp, afi2family(afi));
 359                         if_ad->configured = 1;
 360                         nhrp_interface_update_address(ifp, afi, 1);
 361                 }
 362
 363                 enabled = 1;
 364         }
 365
 366         if (enabled != nifp->enabled) {
 367                 nifp->enabled = enabled;
 368                 notifier_call(&nifp->notifier_list,
 369                               enabled ? NOTIFY_INTERFACE_UP
 370                                       : NOTIFY_INTERFACE_DOWN);
 371         }
 372 }
 373
 374 int nhrp_ifp_create(struct interface *ifp)
 375 {
 376         debugf(NHRP_DEBUG_IF, "if-add: %s, ifindex: %u, hw_type: %d %s",
 377                ifp->name, ifp->ifindex, ifp->ll_type,
 378                if_link_type_str(ifp->ll_type));
 379
 380         nhrp_interface_update_nbma(ifp, NULL);
 381
 382         return 0;
 383 }
 384
 385 int nhrp_ifp_destroy(struct interface *ifp)
 386 {
 387         debugf(NHRP_DEBUG_IF, "if-delete: %s", ifp->name);
 388
 389         nhrp_interface_update_cache_config(ifp, false, AF_INET);
 390         nhrp_interface_update_cache_config(ifp, false, AF_INET6);
 391         nhrp_interface_update(ifp);
 392
 393         return 0;
 394 }
 395
 396 struct map_ctx {
 397         int family;
 398         bool enabled;
 399 };
 400
 401 static void interface_config_update_nhrp_map(struct nhrp_cache_config *cc,
 402                                              void *data)
 403 {
 404         struct map_ctx *ctx = data;
 405         struct interface *ifp = cc->ifp;
 406         struct nhrp_cache *c;
 407         union sockunion nbma_addr;
 408
 409         if (sockunion_family(&cc->remote_addr) != ctx->family)
 410                 return;
 411
 412         /* gre layer not ready */
 413         if (ifp->vrf_id == VRF_UNKNOWN)
 414                 return;
 415
 416         c = nhrp_cache_get(ifp, &cc->remote_addr, ctx->enabled ? 1 : 0);
 417         if (!c && !ctx->enabled)
 418                 return;
 419
 420         /* suppress */
 421         if (!ctx->enabled) {
 422                 if (c && c->map) {
 423                         nhrp_cache_update_binding(
 424                                 c, c->cur.type, -1,
 425                                 nhrp_peer_get(ifp, &nbma_addr), 0, NULL, NULL);
 426                 }
 427                 return;
 428         }
 429
 430         /* Newly created */
 431         assert(c != NULL);
 432
 433         c->map = 1;
 434         if (cc->type == NHRP_CACHE_LOCAL)
 435                 nhrp_cache_update_binding(c, NHRP_CACHE_LOCAL, 0, NULL, 0,
 436                                           NULL, NULL);
 437         else {
 438                 nhrp_cache_update_binding(c, NHRP_CACHE_STATIC, 0,
 439                                           nhrp_peer_get(ifp, &cc->nbma), 0,
 440                                           NULL, NULL);
 441         }
 442 }
 443
 444 static void nhrp_interface_update_cache_config(struct interface *ifp, bool available, uint8_t family)
 445 {
 446         struct map_ctx mapctx;
 447
 448         mapctx = (struct map_ctx){
 449                 .family = family,
 450                 .enabled = available
 451         };
 452         nhrp_cache_config_foreach(ifp, interface_config_update_nhrp_map,
 453                                   &mapctx);
 454
 455 }
 456
 457 int nhrp_ifp_up(struct interface *ifp)
 458 {
 459         debugf(NHRP_DEBUG_IF, "if-up: %s", ifp->name);
 460         nhrp_interface_update_nbma(ifp, NULL);
 461
 462         return 0;
 463 }
 464
 465 int nhrp_ifp_down(struct interface *ifp)
 466 {
 467         debugf(NHRP_DEBUG_IF, "if-down: %s", ifp->name);
 468         nhrp_interface_update(ifp);
 469
 470         return 0;
 471 }
 472
 473 int nhrp_interface_address_add(ZAPI_CALLBACK_ARGS)
 474 {
 475         struct connected *ifc;
 476
 477         ifc = zebra_interface_address_read(cmd, zclient->ibuf, vrf_id);
 478         if (ifc == NULL)
 479                 return 0;
 480
 481         debugf(NHRP_DEBUG_IF, "if-addr-add: %s: %pFX", ifc->ifp->name,
 482                ifc->address);
 483
 484         nhrp_interface_update_address(
 485                 ifc->ifp, family2afi(PREFIX_FAMILY(ifc->address)), 0);
 486         nhrp_interface_update_cache_config(ifc->ifp, true, PREFIX_FAMILY(ifc->address));
 487         return 0;
 488 }
 489
 490 int nhrp_interface_address_delete(ZAPI_CALLBACK_ARGS)
 491 {
 492         struct connected *ifc;
 493
 494         ifc = zebra_interface_address_read(cmd, zclient->ibuf, vrf_id);
 495         if (ifc == NULL)
 496                 return 0;
 497
 498         debugf(NHRP_DEBUG_IF, "if-addr-del: %s: %pFX", ifc->ifp->name,
 499                ifc->address);
 500
 501         nhrp_interface_update_address(
 502                 ifc->ifp, family2afi(PREFIX_FAMILY(ifc->address)), 0);
 503         connected_free(&ifc);
 504
 505         return 0;
 506 }
 507
 508 void nhrp_interface_notify_add(struct interface *ifp, struct notifier_block *n,
 509                                notifier_fn_t fn)
 510 {
 511         struct nhrp_interface *nifp = ifp->info;
 512         notifier_add(n, &nifp->notifier_list, fn);
 513 }
 514
 515 void nhrp_interface_notify_del(struct interface *ifp, struct notifier_block *n)
 516 {
 517         notifier_del(n);
 518 }
 519
 520 void nhrp_interface_set_protection(struct interface *ifp, const char *profile,
 521                                    const char *fallback_profile)
 522 {
 523         struct nhrp_interface *nifp = ifp->info;
 524
 525         if (nifp->ipsec_profile) {
 526                 vici_terminate_vc_by_profile_name(nifp->ipsec_profile);
 527                 nhrp_vc_reset();
 528                 free(nifp->ipsec_profile);
 529         }
 530         nifp->ipsec_profile = profile ? strdup(profile) : NULL;
 531
 532         if (nifp->ipsec_fallback_profile) {
 533                 vici_terminate_vc_by_profile_name(nifp->ipsec_fallback_profile);
 534                 nhrp_vc_reset();
 535                 free(nifp->ipsec_fallback_profile);
 536         }
 537         nifp->ipsec_fallback_profile =
 538                 fallback_profile ? strdup(fallback_profile) : NULL;
 539
 540         notifier_call(&nifp->notifier_list, NOTIFY_INTERFACE_IPSEC_CHANGED);
 541 }
 542
 543 void nhrp_interface_set_source(struct interface *ifp, const char *ifname)
 544 {
 545         struct nhrp_interface *nifp = ifp->info;
 546
 547         if (nifp->source)
 548                 free(nifp->source);
 549         nifp->source = ifname ? strdup(ifname) : NULL;
 550
 551         nhrp_interface_update_nbma(ifp, NULL);
 552 }