zebra/irdp_main.c

   1 /*
   2  *
   3  * Copyright (C) 2000  Robert Olsson.
   4  * Swedish University of Agricultural Sciences
   5  *
   6  * This file is part of GNU Zebra.
   7  *
   8  * GNU Zebra 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  * GNU Zebra 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
  23 /*
  24  * This work includes work with the following copywrite:
  25  *
  26  * Copyright (C) 1997, 2000 Kunihiro Ishiguro
  27  *
  28  */
  29
  30 /*
  31  * Thanks to Jens Laas at Swedish University of Agricultural Sciences
  32  * for reviewing and tests.
  33  */
  34
  35
  36 #include <zebra.h>
  37
  38 #include "if.h"
  39 #include "vty.h"
  40 #include "sockunion.h"
  41 #include "sockopt.h"
  42 #include "prefix.h"
  43 #include "command.h"
  44 #include "memory.h"
  45 #include "zebra_memory.h"
  46 #include "stream.h"
  47 #include "ioctl.h"
  48 #include "connected.h"
  49 #include "log.h"
  50 #include "zclient.h"
  51 #include "thread.h"
  52 #include "privs.h"
  53 #include "libfrr.h"
  54 #include "lib_errors.h"
  55 #include "version.h"
  56 #include "zebra/interface.h"
  57 #include "zebra/rtadv.h"
  58 #include "zebra/rib.h"
  59 #include "zebra/zserv.h"
  60 #include "zebra/redistribute.h"
  61 #include "zebra/irdp.h"
  62 #include "zebra/zebra_errors.h"
  63 #include <netinet/ip_icmp.h>
  64
  65 #include "checksum.h"
  66 #include "if.h"
  67 #include "sockunion.h"
  68 #include "log.h"
  69
  70 /* GLOBAL VARS */
  71
  72 extern struct zebra_privs_t zserv_privs;
  73
  74 struct thread *t_irdp_raw;
  75
  76 /* Timer interval of irdp. */
  77 int irdp_timer_interval = IRDP_DEFAULT_INTERVAL;
  78
  79 int irdp_sock_init(void)
  80 {
  81         int ret, i;
  82         int save_errno;
  83         int sock;
  84
  85         frr_elevate_privs(&zserv_privs) {
  86
  87                 sock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
  88                 save_errno = errno;
  89
  90         }
  91
  92         if (sock < 0) {
  93                 flog_err_sys(EC_LIB_SOCKET, "IRDP: can't create irdp socket %s",
  94                              safe_strerror(save_errno));
  95                 return sock;
  96         };
  97
  98         i = 1;
  99         ret = setsockopt(sock, IPPROTO_IP, IP_TTL, (void *)&i, sizeof(i));
 100         if (ret < 0) {
 101                 flog_err_sys(EC_LIB_SOCKET, "IRDP: can't do irdp sockopt %s",
 102                              safe_strerror(errno));
 103                 close(sock);
 104                 return ret;
 105         };
 106
 107         ret = setsockopt_ifindex(AF_INET, sock, 1);
 108         if (ret < 0) {
 109                 flog_err_sys(EC_LIB_SOCKET, "IRDP: can't do irdp sockopt %s",
 110                              safe_strerror(errno));
 111                 close(sock);
 112                 return ret;
 113         };
 114
 115         t_irdp_raw = NULL;
 116         thread_add_read(zebrad.master, irdp_read_raw, NULL, sock, &t_irdp_raw);
 117
 118         return sock;
 119 }
 120
 121
 122 static int get_pref(struct irdp_interface *irdp, struct prefix *p)
 123 {
 124         struct listnode *node;
 125         struct Adv *adv;
 126
 127         /* Use default preference or use the override pref */
 128
 129         if (irdp->AdvPrefList == NULL)
 130                 return irdp->Preference;
 131
 132         for (ALL_LIST_ELEMENTS_RO(irdp->AdvPrefList, node, adv))
 133                 if (p->u.prefix4.s_addr == adv->ip.s_addr)
 134                         return adv->pref;
 135
 136         return irdp->Preference;
 137 }
 138
 139 /* Make ICMP Router Advertisement Message. */
 140 static int make_advertisement_packet(struct interface *ifp, struct prefix *p,
 141                                      struct stream *s)
 142 {
 143         struct zebra_if *zi = ifp->info;
 144         struct irdp_interface *irdp = zi->irdp;
 145         int size;
 146         int pref;
 147         uint16_t checksum;
 148
 149         pref = get_pref(irdp, p);
 150
 151         stream_putc(s, ICMP_ROUTERADVERT); /* Type. */
 152         stream_putc(s, 0);                 /* Code. */
 153         stream_putw(s, 0);                 /* Checksum. */
 154         stream_putc(s, 1);                 /* Num address. */
 155         stream_putc(s, 2);                 /* Address Entry Size. */
 156
 157         if (irdp->flags & IF_SHUTDOWN)
 158                 stream_putw(s, 0);
 159         else
 160                 stream_putw(s, irdp->Lifetime);
 161
 162         stream_putl(s, htonl(p->u.prefix4.s_addr)); /* Router address. */
 163         stream_putl(s, pref);
 164
 165         /* in_cksum return network byte order value */
 166         size = 16;
 167         checksum = in_cksum(s->data, size);
 168         stream_putw_at(s, 2, htons(checksum));
 169
 170         return size;
 171 }
 172
 173 static void irdp_send(struct interface *ifp, struct prefix *p, struct stream *s)
 174 {
 175         struct zebra_if *zi = ifp->info;
 176         struct irdp_interface *irdp = zi->irdp;
 177         char buf[PREFIX_STRLEN];
 178         uint32_t dst;
 179         uint32_t ttl = 1;
 180
 181         if (!irdp)
 182                 return;
 183         if (!(ifp->flags & IFF_UP))
 184                 return;
 185
 186         if (irdp->flags & IF_BROADCAST)
 187                 dst = INADDR_BROADCAST;
 188         else
 189                 dst = htonl(INADDR_ALLHOSTS_GROUP);
 190
 191         if (irdp->flags & IF_DEBUG_MESSAGES)
 192                 zlog_debug("IRDP: TX Advert on %s %s Holdtime=%d Preference=%d",
 193                            ifp->name, prefix2str(p, buf, sizeof buf),
 194                            irdp->flags & IF_SHUTDOWN ? 0 : irdp->Lifetime,
 195                            get_pref(irdp, p));
 196
 197         send_packet(ifp, s, dst, p, ttl);
 198 }
 199
 200 static void irdp_advertisement(struct interface *ifp, struct prefix *p)
 201 {
 202         struct stream *s;
 203         s = stream_new(128);
 204         make_advertisement_packet(ifp, p, s);
 205         irdp_send(ifp, p, s);
 206         stream_free(s);
 207 }
 208
 209 int irdp_send_thread(struct thread *t_advert)
 210 {
 211         uint32_t timer, tmp;
 212         struct interface *ifp = THREAD_ARG(t_advert);
 213         struct zebra_if *zi = ifp->info;
 214         struct irdp_interface *irdp = zi->irdp;
 215         struct prefix *p;
 216         struct listnode *node, *nnode;
 217         struct connected *ifc;
 218
 219         if (!irdp)
 220                 return 0;
 221
 222         irdp->flags &= ~IF_SOLICIT;
 223
 224         if (ifp->connected)
 225                 for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, ifc)) {
 226                         p = ifc->address;
 227
 228                         if (p->family != AF_INET)
 229                                 continue;
 230
 231                         irdp_advertisement(ifp, p);
 232                         irdp->irdp_sent++;
 233                 }
 234
 235         tmp = irdp->MaxAdvertInterval - irdp->MinAdvertInterval;
 236         timer = random() % (tmp + 1);
 237         timer = irdp->MinAdvertInterval + timer;
 238
 239         if (irdp->irdp_sent < MAX_INITIAL_ADVERTISEMENTS
 240             && timer > MAX_INITIAL_ADVERT_INTERVAL)
 241                 timer = MAX_INITIAL_ADVERT_INTERVAL;
 242
 243         if (irdp->flags & IF_DEBUG_MISC)
 244                 zlog_debug("IRDP: New timer for %s set to %u\n", ifp->name,
 245                            timer);
 246
 247         irdp->t_advertise = NULL;
 248         thread_add_timer(zebrad.master, irdp_send_thread, ifp, timer,
 249                          &irdp->t_advertise);
 250         return 0;
 251 }
 252
 253 void irdp_advert_off(struct interface *ifp)
 254 {
 255         struct zebra_if *zi = ifp->info;
 256         struct irdp_interface *irdp = zi->irdp;
 257         struct listnode *node, *nnode;
 258         int i;
 259         struct connected *ifc;
 260         struct prefix *p;
 261
 262         if (!irdp)
 263                 return;
 264
 265         if (irdp->t_advertise)
 266                 thread_cancel(irdp->t_advertise);
 267         irdp->t_advertise = NULL;
 268
 269         if (ifp->connected)
 270                 for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, ifc)) {
 271                         p = ifc->address;
 272
 273                         /* Output some packets with Lifetime 0
 274                            we should add a wait...
 275                         */
 276
 277                         for (i = 0; i < IRDP_LAST_ADVERT_MESSAGES; i++) {
 278                                 irdp->irdp_sent++;
 279                                 irdp_advertisement(ifp, p);
 280                         }
 281                 }
 282 }
 283
 284
 285 void process_solicit(struct interface *ifp)
 286 {
 287         struct zebra_if *zi = ifp->info;
 288         struct irdp_interface *irdp = zi->irdp;
 289         uint32_t timer;
 290
 291         if (!irdp)
 292                 return;
 293
 294         /* When SOLICIT is active we reject further incoming solicits
 295            this keeps down the answering rate so we don't have think
 296            about DoS attacks here. */
 297
 298         if (irdp->flags & IF_SOLICIT)
 299                 return;
 300
 301         irdp->flags |= IF_SOLICIT;
 302         if (irdp->t_advertise)
 303                 thread_cancel(irdp->t_advertise);
 304         irdp->t_advertise = NULL;
 305
 306         timer = (random() % MAX_RESPONSE_DELAY) + 1;
 307
 308         irdp->t_advertise = NULL;
 309         thread_add_timer(zebrad.master, irdp_send_thread, ifp, timer,
 310                          &irdp->t_advertise);
 311 }
 312
 313 static int irdp_finish(void)
 314 {
 315         struct vrf *vrf;
 316         struct interface *ifp;
 317         struct zebra_if *zi;
 318         struct irdp_interface *irdp;
 319
 320         zlog_info("IRDP: Received shutdown notification.");
 321
 322         RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id)
 323                 FOR_ALL_INTERFACES (vrf, ifp) {
 324                         zi = ifp->info;
 325
 326                         if (!zi)
 327                                 continue;
 328                         irdp = zi->irdp;
 329                         if (!irdp)
 330                                 continue;
 331
 332                         if (irdp->flags & IF_ACTIVE) {
 333                                 irdp->flags |= IF_SHUTDOWN;
 334                                 irdp_advert_off(ifp);
 335                         }
 336                 }
 337         return 0;
 338 }
 339
 340 static int irdp_init(struct thread_master *master)
 341 {
 342         irdp_if_init();
 343
 344         hook_register(frr_early_fini, irdp_finish);
 345         return 0;
 346 }
 347
 348 static int irdp_module_init(void)
 349 {
 350         hook_register(frr_late_init, irdp_init);
 351         return 0;
 352 }
 353
 354 FRR_MODULE_SETUP(.name = "zebra_irdp", .version = FRR_VERSION,
 355                  .description = "zebra IRDP module", .init = irdp_module_init, )