babeld/babel_main.c

   1 /*
   2 Copyright 2011 by Matthieu Boutier and Juliusz Chroboczek
   3
   4 Permission is hereby granted, free of charge, to any person obtaining a copy
   5 of this software and associated documentation files (the "Software"), to deal
   6 in the Software without restriction, including without limitation the rights
   7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8 copies of the Software, and to permit persons to whom the Software is
   9 furnished to do so, subject to the following conditions:
  10
  11 The above copyright notice and this permission notice shall be included in
  12 all copies or substantial portions of the Software.
  13
  14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20 THE SOFTWARE.
  21 */
  22
  23 /* include zebra library */
  24 #include <zebra.h>
  25 #include "getopt.h"
  26 #include "if.h"
  27 #include "log.h"
  28 #include "thread.h"
  29 #include "privs.h"
  30 #include "sigevent.h"
  31 #include "version.h"
  32 #include "command.h"
  33 #include "vty.h"
  34 #include "memory.h"
  35 #include "libfrr.h"
  36
  37 #include "babel_main.h"
  38 #include "babeld.h"
  39 #include "util.h"
  40 #include "kernel.h"
  41 #include "babel_interface.h"
  42 #include "neighbour.h"
  43 #include "route.h"
  44 #include "xroute.h"
  45 #include "message.h"
  46 #include "resend.h"
  47 #include "babel_zebra.h"
  48
  49 static void babel_fail(void);
  50 static void babel_init_random(void);
  51 static void babel_replace_by_null(int fd);
  52 static void babel_exit_properly(void);
  53 static void babel_save_state_file(void);
  54
  55
  56 struct thread_master *master;     /* quagga's threads handler */
  57 struct timeval babel_now;         /* current time             */
  58
  59 unsigned char myid[8];            /* unique id (mac address of an interface) */
  60 int debug = 0;
  61
  62 int resend_delay = -1;
  63
  64 const unsigned char zeroes[16] = {0};
  65 const unsigned char ones[16] =
  66     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  67      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
  68
  69 static const char *state_file = DAEMON_VTY_DIR "/babel-state";
  70
  71 unsigned char protocol_group[16]; /* babel's link-local multicast address */
  72 int protocol_port;                /* babel's port */
  73 int protocol_socket = -1;         /* socket: communicate with others babeld */
  74
  75 static char babel_config_default[] = SYSCONFDIR BABEL_DEFAULT_CONFIG;
  76 static char *babel_config_file = NULL;
  77 static char *babel_vty_addr = NULL;
  78 static int babel_vty_port = BABEL_VTY_PORT;
  79
  80 /* babeld privileges */
  81 static zebra_capabilities_t _caps_p [] =
  82 {
  83     ZCAP_NET_RAW,
  84     ZCAP_BIND
  85 };
  86
  87 static struct zebra_privs_t babeld_privs =
  88 {
  89 #if defined(FRR_USER)
  90     .user = FRR_USER,
  91 #endif
  92 #if defined FRR_GROUP
  93     .group = FRR_GROUP,
  94 #endif
  95 #ifdef VTY_GROUP
  96     .vty_group = VTY_GROUP,
  97 #endif
  98     .caps_p = _caps_p,
  99     .cap_num_p = array_size(_caps_p),
 100     .cap_num_i = 0
 101 };
 102
 103 static void
 104 babel_sigexit(void)
 105 {
 106     zlog_notice("Terminating on signal");
 107
 108     babel_exit_properly();
 109 }
 110
 111 static void
 112 babel_sigusr1 (void)
 113 {
 114     zlog_rotate ();
 115 }
 116
 117 static struct quagga_signal_t babel_signals[] =
 118   {
 119     {
 120       .signal = SIGUSR1,
 121       .handler = &babel_sigusr1,
 122     },
 123     {
 124       .signal = SIGINT,
 125       .handler = &babel_sigexit,
 126     },
 127     {
 128       .signal = SIGTERM,
 129       .handler = &babel_sigexit,
 130     },
 131   };
 132
 133 struct option longopts[] =
 134   {
 135     { 0 }
 136   };
 137
 138 FRR_DAEMON_INFO(babeld, BABELD,
 139                 .vty_port = BABEL_VTY_PORT,
 140                 .proghelp = "Implementation of the BABEL routing protocol.",
 141
 142                 .signals = babel_signals,
 143                 .n_signals = array_size(babel_signals),
 144
 145                 .privs = &babeld_privs,
 146                 )
 147
 148 int
 149 main(int argc, char **argv)
 150 {
 151     int rc;
 152
 153     frr_preinit (&babeld_di, argc, argv);
 154     frr_opt_add ("", longopts, "");
 155
 156     babel_init_random();
 157
 158     /* set the Babel's default link-local multicast address and Babel's port */
 159     parse_address("ff02:0:0:0:0:0:1:6", protocol_group, NULL);
 160     protocol_port = 6696;
 161
 162     /* get options */
 163     while(1) {
 164         int opt;
 165
 166         opt = frr_getopt (argc, argv, NULL);
 167
 168         if (opt == EOF)
 169           break;
 170
 171         switch (opt)
 172           {
 173           case 0:
 174             break;
 175           default:
 176             frr_help_exit (1);
 177             break;
 178           }
 179     }
 180
 181     /* create the threads handler */
 182     master = frr_init ();
 183
 184     /* Library inits. */
 185     zprivs_init (&babeld_privs);
 186     cmd_init (1);
 187     vty_init (master);
 188
 189     resend_delay = BABEL_DEFAULT_RESEND_DELAY;
 190     change_smoothing_half_life(BABEL_DEFAULT_SMOOTHING_HALF_LIFE);
 191
 192     babel_replace_by_null(STDIN_FILENO);
 193
 194     /* init some quagga's dependencies, and babeld's commands */
 195     babeld_quagga_init();
 196     /* init zebra client's structure and it's commands */
 197     /* this replace kernel_setup && kernel_setup_socket */
 198     babelz_zebra_init ();
 199
 200     /* Get zebra configuration file. */
 201     vty_read_config (babel_config_file, babel_config_default);
 202
 203     /* init buffer */
 204     rc = resize_receive_buffer(1500);
 205     if(rc < 0)
 206         babel_fail();
 207
 208     schedule_neighbours_check(5000, 1);
 209
 210     frr_config_fork();
 211     frr_run(master);
 212
 213     return 0;
 214 }
 215
 216 static void
 217 babel_fail(void)
 218 {
 219     exit(1);
 220 }
 221
 222 /* initialize random value, and set 'babel_now' by the way. */
 223 static void
 224 babel_init_random(void)
 225 {
 226     gettime(&babel_now);
 227     int rc;
 228     unsigned int seed;
 229
 230     rc = read_random_bytes(&seed, sizeof(seed));
 231     if(rc < 0) {
 232         zlog_err("read(random): %s", safe_strerror(errno));
 233         seed = 42;
 234     }
 235
 236     seed ^= (babel_now.tv_sec ^ babel_now.tv_usec);
 237     srandom(seed);
 238 }
 239
 240 /*
 241  close fd, and replace it by "/dev/null"
 242  exit if error
 243  */
 244 static void
 245 babel_replace_by_null(int fd)
 246 {
 247     int fd_null;
 248     int rc;
 249
 250     fd_null = open("/dev/null", O_RDONLY);
 251     if(fd_null < 0) {
 252         zlog_err("open(null): %s", safe_strerror(errno));
 253         exit(1);
 254     }
 255
 256     rc = dup2(fd_null, fd);
 257     if(rc < 0) {
 258         zlog_err("dup2(null, 0): %s", safe_strerror(errno));
 259         exit(1);
 260     }
 261
 262     close(fd_null);
 263 }
 264
 265 /*
 266  Load the state file: check last babeld's running state, usefull in case of
 267  "/etc/init.d/babeld restart"
 268  */
 269 void
 270 babel_load_state_file(void)
 271 {
 272     int fd;
 273     int rc;
 274
 275     fd = open(state_file, O_RDONLY);
 276     if(fd < 0 && errno != ENOENT)
 277         zlog_err("open(babel-state: %s)", safe_strerror(errno));
 278     rc = unlink(state_file);
 279     if(fd >= 0 && rc < 0) {
 280         zlog_err("unlink(babel-state): %s", safe_strerror(errno));
 281         /* If we couldn't unlink it, it's probably stale. */
 282         close(fd);
 283         fd = -1;
 284     }
 285     if(fd >= 0) {
 286         char buf[100];
 287         char buf2[100];
 288         int s;
 289         long t;
 290         rc = read(fd, buf, 99);
 291         if(rc < 0) {
 292             zlog_err("read(babel-state): %s", safe_strerror(errno));
 293         } else {
 294             buf[rc] = '\0';
 295             rc = sscanf(buf, "%99s %d %ld\n", buf2, &s, &t);
 296             if(rc == 3 && s >= 0 && s <= 0xFFFF) {
 297                 unsigned char sid[8];
 298                 rc = parse_eui64(buf2, sid);
 299                 if(rc < 0) {
 300                     zlog_err("Couldn't parse babel-state.");
 301                 } else {
 302                     struct timeval realnow;
 303                     debugf(BABEL_DEBUG_COMMON,
 304                            "Got %s %d %ld from babel-state.",
 305                            format_eui64(sid), s, t);
 306                     gettimeofday(&realnow, NULL);
 307                     if(memcmp(sid, myid, 8) == 0)
 308                         myseqno = seqno_plus(s, 1);
 309                     else
 310                         zlog_err("ID mismatch in babel-state. id=%s; old=%s",
 311                                  format_eui64(myid),
 312                                  format_eui64(sid));
 313                 }
 314             } else {
 315                 zlog_err("Couldn't parse babel-state.");
 316             }
 317         }
 318         close(fd);
 319         fd = -1;
 320     }
 321 }
 322
 323 static void
 324 babel_exit_properly(void)
 325 {
 326     debugf(BABEL_DEBUG_COMMON, "Exiting...");
 327     usleep(roughly(10000));
 328     gettime(&babel_now);
 329
 330     /* Uninstall and flush all routes. */
 331     debugf(BABEL_DEBUG_COMMON, "Uninstall routes.");
 332     flush_all_routes();
 333     babel_interface_close_all();
 334     babel_zebra_close_connexion();
 335     babel_save_state_file();
 336     debugf(BABEL_DEBUG_COMMON, "Remove pid file.");
 337     debugf(BABEL_DEBUG_COMMON, "Done.");
 338     frr_fini();
 339
 340     exit(0);
 341 }
 342
 343 static void
 344 babel_save_state_file(void)
 345 {
 346     int fd;
 347     int rc;
 348
 349     debugf(BABEL_DEBUG_COMMON, "Save state file.");
 350     fd = open(state_file, O_WRONLY | O_TRUNC | O_CREAT, 0644);
 351     if(fd < 0) {
 352         zlog_err("creat(babel-state): %s", safe_strerror(errno));
 353         unlink(state_file);
 354     } else {
 355         struct timeval realnow;
 356         char buf[100];
 357         gettimeofday(&realnow, NULL);
 358         rc = snprintf(buf, 100, "%s %d %ld\n",
 359                       format_eui64(myid), (int)myseqno,
 360                       (long)realnow.tv_sec);
 361         if(rc < 0 || rc >= 100) {
 362             zlog_err("write(babel-state): overflow.");
 363             unlink(state_file);
 364         } else {
 365             rc = write(fd, buf, rc);
 366             if(rc < 0) {
 367                 zlog_err("write(babel-state): %s", safe_strerror(errno));
 368                 unlink(state_file);
 369             }
 370             fsync(fd);
 371         }
 372         close(fd);
 373     }
 374 }
 375
 376 void
 377 show_babel_main_configuration (struct vty *vty)
 378 {
 379     vty_out (vty,
 380             "state file              = %s\n"
 381             "configuration file      = %s\n"
 382             "protocol informations:\n"
 383             "  multicast address     = %s\n"
 384             "  port                  = %d\n"
 385             "vty address             = %s\n"
 386             "vty port                = %d\n"
 387             "id                      = %s\n"
 388             "kernel_metric           = %d\n",
 389             state_file,
 390             babel_config_file ? babel_config_file : babel_config_default,
 391             format_address(protocol_group),
 392             protocol_port,
 393             babel_vty_addr ? babel_vty_addr : "None",
 394             babel_vty_port,
 395             format_eui64(myid),
 396             kernel_metric);
 397 }