[mirror_frr.git] / babeld / babel_main.c

/*
Copyright 2011 by Matthieu Boutier and Juliusz Chroboczek

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/

/* include zebra library */
#include <zebra.h>
#include "getopt.h"
#include "if.h"
#include "log.h"
#include "thread.h"
#include "privs.h"
#include "sigevent.h"
#include "version.h"
#include "command.h"
#include "vty.h"
#include "memory.h"
#include "libfrr.h"
#include "lib_errors.h"

#include "babel_main.h"
#include "babeld.h"
#include "util.h"
#include "kernel.h"
#include "babel_interface.h"
#include "neighbour.h"
#include "route.h"
#include "xroute.h"
#include "message.h"
#include "resend.h"
#include "babel_zebra.h"
#include "babel_errors.h"

static void babel_fail(void);
static void babel_init_random(void);
static void babel_replace_by_null(int fd);
static void babel_exit_properly(void);
static void babel_save_state_file(void);


struct thread_master *master;     /* quagga's threads handler */
struct timeval babel_now;         /* current time             */

unsigned char myid[8];            /* unique id (mac address of an interface) */
int debug = 0;

int resend_delay = -1;

const unsigned char zeroes[16] = {0};
const unsigned char ones[16] =
    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

static char state_file[1024];

unsigned char protocol_group[16]; /* babel's link-local multicast address */
int protocol_port;                /* babel's port */
int protocol_socket = -1;         /* socket: communicate with others babeld */

static const char babel_config_default[] = SYSCONFDIR BABEL_DEFAULT_CONFIG;
static char *babel_vty_addr = NULL;
static int babel_vty_port = BABEL_VTY_PORT;

/* babeld privileges */
static zebra_capabilities_t _caps_p [] =
{
    ZCAP_NET_RAW,
    ZCAP_BIND
};

struct zebra_privs_t babeld_privs =
{
#if defined(FRR_USER)
    .user = FRR_USER,
#endif
#if defined FRR_GROUP
    .group = FRR_GROUP,
#endif
#ifdef VTY_GROUP
    .vty_group = VTY_GROUP,
#endif
    .caps_p = _caps_p,
    .cap_num_p = array_size(_caps_p),
    .cap_num_i = 0
};

static void
babel_sigexit(void)
{
    zlog_notice("Terminating on signal");

    babel_exit_properly();
}

static void
babel_sigusr1 (void)
{
    zlog_rotate ();
}

static struct quagga_signal_t babel_signals[] =
  {
    {
      .signal = SIGUSR1,
      .handler = &babel_sigusr1,
    },
    {
      .signal = SIGINT,
      .handler = &babel_sigexit,
    },
    {
      .signal = SIGTERM,
      .handler = &babel_sigexit,
    },
  };

struct option longopts[] =
  {
    { 0 }
  };

static const struct frr_yang_module_info *const babeld_yang_modules[] =
  {
    &frr_interface_info,
  };

FRR_DAEMON_INFO(babeld, BABELD,
		.vty_port = BABEL_VTY_PORT,
		.proghelp = "Implementation of the BABEL routing protocol.",

		.signals = babel_signals,
		.n_signals = array_size(babel_signals),

		.privs = &babeld_privs,

		.yang_modules = babeld_yang_modules,
		.n_yang_modules = array_size(babeld_yang_modules),
		)

int
main(int argc, char **argv)
{
    int rc;

    frr_preinit (&babeld_di, argc, argv);
    frr_opt_add ("", longopts, "");

    babel_init_random();

    /* set the Babel's default link-local multicast address and Babel's port */
    parse_address("ff02:0:0:0:0:0:1:6", protocol_group, NULL);
    protocol_port = 6696;

    /* get options */
    while(1) {
        int opt;

	opt = frr_getopt (argc, argv, NULL);

	if (opt == EOF)
	  break;

	switch (opt)
	  {
	  case 0:
	    break;
	  default:
	    frr_help_exit (1);
	    break;
	  }
    }

    snprintf(state_file, sizeof(state_file), "%s/%s",
	     frr_vtydir, "babel-state");

    /* create the threads handler */
    master = frr_init ();

    /* Library inits. */
    babel_error_init();

    resend_delay = BABEL_DEFAULT_RESEND_DELAY;
    change_smoothing_half_life(BABEL_DEFAULT_SMOOTHING_HALF_LIFE);

    babel_replace_by_null(STDIN_FILENO);

    /* init some quagga's dependencies, and babeld's commands */
    if_zapi_callbacks(babel_ifp_create, babel_ifp_up,
		      babel_ifp_down, babel_ifp_destroy);
    babeld_quagga_init();
    /* init zebra client's structure and it's commands */
    /* this replace kernel_setup && kernel_setup_socket */
    babelz_zebra_init ();

    /* init buffer */
    rc = resize_receive_buffer(1500);
    if(rc < 0)
        babel_fail();

    schedule_neighbours_check(5000, 1);

    frr_config_fork();
    frr_run(master);

    return 0;
}

static void
babel_fail(void)
{
    exit(1);
}

/* initialize random value, and set 'babel_now' by the way. */
static void
babel_init_random(void)
{
    gettime(&babel_now);
    int rc;
    unsigned int seed;

    rc = read_random_bytes(&seed, sizeof(seed));
    if(rc < 0) {
        flog_err_sys(EC_LIB_SYSTEM_CALL, "read(random): %s",
		  safe_strerror(errno));
        seed = 42;
    }

    seed ^= (babel_now.tv_sec ^ babel_now.tv_usec);
    srandom(seed);
}

/*
 close fd, and replace it by "/dev/null"
 exit if error
 */
static void
babel_replace_by_null(int fd)
{
    int fd_null;
    int rc;

    fd_null = open("/dev/null", O_RDONLY);
    if(fd_null < 0) {
        flog_err_sys(EC_LIB_SYSTEM_CALL, "open(null): %s", safe_strerror(errno));
        exit(1);
    }

    rc = dup2(fd_null, fd);
    if(rc < 0) {
        flog_err_sys(EC_LIB_SYSTEM_CALL, "dup2(null, 0): %s",
		  safe_strerror(errno));
        exit(1);
    }

    close(fd_null);
}

/*
 Load the state file: check last babeld's running state, usefull in case of
 "/etc/init.d/babeld restart"
 */
void
babel_load_state_file(void)
{
    int fd;
    int rc;

    fd = open(state_file, O_RDONLY);
    if(fd < 0 && errno != ENOENT)
        flog_err_sys(EC_LIB_SYSTEM_CALL, "open(babel-state: %s)",
		  safe_strerror(errno));
    rc = unlink(state_file);
    if(fd >= 0 && rc < 0) {
        flog_err_sys(EC_LIB_SYSTEM_CALL, "unlink(babel-state): %s",
		  safe_strerror(errno));
        /* If we couldn't unlink it, it's probably stale. */
        goto fini;
    }
    if(fd >= 0) {
        char buf[100];
        char buf2[100];
        int s;
        long t;
        rc = read(fd, buf, 99);
        if(rc < 0) {
            flog_err_sys(EC_LIB_SYSTEM_CALL, "read(babel-state): %s",
		      safe_strerror(errno));
        } else {
            buf[rc] = '\0';
            rc = sscanf(buf, "%99s %d %ld\n", buf2, &s, &t);
            if(rc == 3 && s >= 0 && s <= 0xFFFF) {
                unsigned char sid[8];
                rc = parse_eui64(buf2, sid);
                if(rc < 0) {
                    flog_err(EC_BABEL_CONFIG, "Couldn't parse babel-state.");
                } else {
                    struct timeval realnow;
                    debugf(BABEL_DEBUG_COMMON,
                           "Got %s %d %ld from babel-state.",
                           format_eui64(sid), s, t);
                    gettimeofday(&realnow, NULL);
                    if(memcmp(sid, myid, 8) == 0)
                        myseqno = seqno_plus(s, 1);
                    else
                        flog_err(EC_BABEL_CONFIG,
				 "ID mismatch in babel-state. id=%s; old=%s",
                                 format_eui64(myid),
                                 format_eui64(sid));
                }
            } else {
                flog_err(EC_BABEL_CONFIG, "Couldn't parse babel-state.");
            }
        }
        goto fini;
    }
fini:
    if (fd >= 0)
        close(fd);
    return ;
}

static void
babel_exit_properly(void)
{
    debugf(BABEL_DEBUG_COMMON, "Exiting...");
    usleep(roughly(10000));
    gettime(&babel_now);

    /* Uninstall and flush all routes. */
    debugf(BABEL_DEBUG_COMMON, "Uninstall routes.");
    flush_all_routes();
    babel_interface_close_all();
    babel_zebra_close_connexion();
    babel_save_state_file();
    debugf(BABEL_DEBUG_COMMON, "Remove pid file.");
    debugf(BABEL_DEBUG_COMMON, "Done.");
    frr_fini();

    exit(0);
}

static void
babel_save_state_file(void)
{
    int fd;
    int rc;

    debugf(BABEL_DEBUG_COMMON, "Save state file.");
    fd = open(state_file, O_WRONLY | O_TRUNC | O_CREAT, 0644);
    if(fd < 0) {
        flog_err_sys(EC_LIB_SYSTEM_CALL, "creat(babel-state): %s",
		  safe_strerror(errno));
        unlink(state_file);
    } else {
        struct timeval realnow;
        char buf[100];
        gettimeofday(&realnow, NULL);
        rc = snprintf(buf, 100, "%s %d %ld\n",
                      format_eui64(myid), (int)myseqno,
                      (long)realnow.tv_sec);
        if(rc < 0 || rc >= 100) {
            flog_err(EC_BABEL_CONFIG, "write(babel-state): overflow.");
            unlink(state_file);
        } else {
            rc = write(fd, buf, rc);
            if(rc < 0) {
                flog_err(EC_BABEL_CONFIG, "write(babel-state): %s",
			  safe_strerror(errno));
                unlink(state_file);
            }
            fsync(fd);
        }
        close(fd);
    }
}

void
show_babel_main_configuration (struct vty *vty)
{
    vty_out (vty,
            "state file              = %s\n"
            "configuration file      = %s\n"
            "protocol information:\n"
            "  multicast address     = %s\n"
            "  port                  = %d\n"
            "vty address             = %s\n"
            "vty port                = %d\n"
            "id                      = %s\n"
            "kernel_metric           = %d\n",
            state_file,
            babeld_di.config_file ? babeld_di.config_file : babel_config_default,
            format_address(protocol_group),
            protocol_port,
            babel_vty_addr ? babel_vty_addr : "None",
            babel_vty_port,
            format_eui64(myid),
            kernel_metric);
}
Commit	Line	Data
ca10883e DS	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"
f135ba52	36	#include "lib_errors.h"
ca10883e DS	37
	38	#include "babel_main.h"
	39	#include "babeld.h"
	40	#include "util.h"
	41	#include "kernel.h"
	42	#include "babel_interface.h"
	43	#include "neighbour.h"
	44	#include "route.h"
	45	#include "xroute.h"
	46	#include "message.h"
	47	#include "resend.h"
	48	#include "babel_zebra.h"
f135ba52	49	#include "babel_errors.h"
ca10883e	50
ca10883e DS	51	static void babel_fail(void);
	52	static void babel_init_random(void);
	53	static void babel_replace_by_null(int fd);
	54	static void babel_exit_properly(void);
	55	static void babel_save_state_file(void);
	56
	57
	58	struct thread_master master; / quagga's threads handler */
	59	struct timeval babel_now; /* current time */
	60
	61	unsigned char myid[8]; /* unique id (mac address of an interface) */
	62	int debug = 0;
	63
	64	int resend_delay = -1;
	65
	66	const unsigned char zeroes[16] = {0};
	67	const unsigned char ones[16] =
	68	{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
	69	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
	70
43e587c1	71	static char state_file[1024];
ca10883e DS	72
	73	unsigned char protocol_group[16]; /* babel's link-local multicast address */
	74	int protocol_port; /* babel's port */
	75	int protocol_socket = -1; /* socket: communicate with others babeld */
	76
2b64873d	77	static const char babel_config_default[] = SYSCONFDIR BABEL_DEFAULT_CONFIG;
ca10883e DS	78	static char *babel_vty_addr = NULL;
	79	static int babel_vty_port = BABEL_VTY_PORT;
	80
	81	/* babeld privileges */
	82	static zebra_capabilities_t _caps_p [] =
	83	{
	84	ZCAP_NET_RAW,
	85	ZCAP_BIND
	86	};
900b8c58	87
346526cc	88	struct zebra_privs_t babeld_privs =
ca10883e	89	{
dd329373 DS	90	#if defined(FRR_USER)
dd329373 DS	91	.user = FRR_USER,
ca10883e	92	#endif
dd329373 DS	93	#if defined FRR_GROUP
dd329373 DS	94	.group = FRR_GROUP,
ca10883e DS	95	#endif
	96	#ifdef VTY_GROUP
	97	.vty_group = VTY_GROUP,
	98	#endif
	99	.caps_p = _caps_p,
900b8c58	100	.cap_num_p = array_size(_caps_p),
ca10883e DS	101	.cap_num_i = 0
	102	};
	103
	104	static void
	105	babel_sigexit(void)
	106	{
	107	zlog_notice("Terminating on signal");
	108
	109	babel_exit_properly();
	110	}
	111
	112	static void
	113	babel_sigusr1 (void)
	114	{
	115	zlog_rotate ();
	116	}
	117
	118	static struct quagga_signal_t babel_signals[] =
	119	{
	120	{
	121	.signal = SIGUSR1,
	122	.handler = &babel_sigusr1,
	123	},
	124	{
	125	.signal = SIGINT,
	126	.handler = &babel_sigexit,
	127	},
	128	{
	129	.signal = SIGTERM,
	130	.handler = &babel_sigexit,
	131	},
	132	};
	133
	134	struct option longopts[] =
	135	{
	136	{ 0 }
	137	};
	138
0d8c7a26	139	static const struct frr_yang_module_info *const babeld_yang_modules[] =
8fcdd0d6	140	{
a4bed468	141	&frr_interface_info,
8fcdd0d6 RW	142	};
8fcdd0d6 RW	143
ca10883e DS	144	FRR_DAEMON_INFO(babeld, BABELD,
	145	.vty_port = BABEL_VTY_PORT,
	146	.proghelp = "Implementation of the BABEL routing protocol.",
	147
	148	.signals = babel_signals,
	149	.n_signals = array_size(babel_signals),
	150
	151	.privs = &babeld_privs,
8fcdd0d6 RW	152
	153	.yang_modules = babeld_yang_modules,
	154	.n_yang_modules = array_size(babeld_yang_modules),
ca10883e DS	155	)
	156
	157	int
	158	main(int argc, char **argv)
	159	{
900b8c58	160	int rc;
ca10883e	161
900b8c58 DS	162	frr_preinit (&babeld_di, argc, argv);
900b8c58 DS	163	frr_opt_add ("", longopts, "");
f135ba52	164
ca10883e DS	165	babel_init_random();
	166
	167	/* set the Babel's default link-local multicast address and Babel's port */
	168	parse_address("ff02:0:0:0:0:0:1:6", protocol_group, NULL);
	169	protocol_port = 6696;
	170
	171	/* get options */
	172	while(1) {
	173	int opt;
	174
	175	opt = frr_getopt (argc, argv, NULL);
	176
	177	if (opt == EOF)
	178	break;
	179
	180	switch (opt)
	181	{
	182	case 0:
	183	break;
	184	default:
	185	frr_help_exit (1);
	186	break;
	187	}
	188	}
	189
3c649c71 DS	190	snprintf(state_file, sizeof(state_file), "%s/%s",
	191	frr_vtydir, "babel-state");
	192
ca10883e	193	/* create the threads handler */
900b8c58	194	master = frr_init ();
ca10883e DS	195
ca10883e DS	196	/* Library inits. */
f135ba52	197	babel_error_init();
ca10883e DS	198
	199	resend_delay = BABEL_DEFAULT_RESEND_DELAY;
	200	change_smoothing_half_life(BABEL_DEFAULT_SMOOTHING_HALF_LIFE);
	201
	202	babel_replace_by_null(STDIN_FILENO);
	203
	204	/* init some quagga's dependencies, and babeld's commands */
138c5a74 DS	205	if_zapi_callbacks(babel_ifp_create, babel_ifp_up,
138c5a74 DS	206	babel_ifp_down, babel_ifp_destroy);
ca10883e DS	207	babeld_quagga_init();
	208	/* init zebra client's structure and it's commands */
	209	/* this replace kernel_setup && kernel_setup_socket */
	210	babelz_zebra_init ();
	211
ca10883e DS	212	/* init buffer */
	213	rc = resize_receive_buffer(1500);
	214	if(rc < 0)
	215	babel_fail();
	216
	217	schedule_neighbours_check(5000, 1);
	218
900b8c58 DS	219	frr_config_fork();
	220	frr_run(master);
	221
	222	return 0;
ca10883e DS	223	}
	224
	225	static void
	226	babel_fail(void)
	227	{
	228	exit(1);
	229	}
	230
	231	/* initialize random value, and set 'babel_now' by the way. */
	232	static void
	233	babel_init_random(void)
	234	{
	235	gettime(&babel_now);
	236	int rc;
	237	unsigned int seed;
	238
	239	rc = read_random_bytes(&seed, sizeof(seed));
	240	if(rc < 0) {
450971aa	241	flog_err_sys(EC_LIB_SYSTEM_CALL, "read(random): %s",
f135ba52	242	safe_strerror(errno));
ca10883e DS	243	seed = 42;
	244	}
	245
	246	seed ^= (babel_now.tv_sec ^ babel_now.tv_usec);
	247	srandom(seed);
	248	}
	249
	250	/*
	251	close fd, and replace it by "/dev/null"
	252	exit if error
	253	*/
	254	static void
	255	babel_replace_by_null(int fd)
	256	{
	257	int fd_null;
	258	int rc;
	259
	260	fd_null = open("/dev/null", O_RDONLY);
	261	if(fd_null < 0) {
450971aa	262	flog_err_sys(EC_LIB_SYSTEM_CALL, "open(null): %s", safe_strerror(errno));
ca10883e DS	263	exit(1);
	264	}
	265
	266	rc = dup2(fd_null, fd);
	267	if(rc < 0) {
450971aa	268	flog_err_sys(EC_LIB_SYSTEM_CALL, "dup2(null, 0): %s",
f135ba52	269	safe_strerror(errno));
ca10883e DS	270	exit(1);
	271	}
	272
	273	close(fd_null);
	274	}
	275
	276	/*
	277	Load the state file: check last babeld's running state, usefull in case of
	278	"/etc/init.d/babeld restart"
	279	*/
	280	void
	281	babel_load_state_file(void)
	282	{
	283	int fd;
	284	int rc;
	285
	286	fd = open(state_file, O_RDONLY);
	287	if(fd < 0 && errno != ENOENT)
450971aa	288	flog_err_sys(EC_LIB_SYSTEM_CALL, "open(babel-state: %s)",
f135ba52	289	safe_strerror(errno));
ca10883e DS	290	rc = unlink(state_file);
ca10883e DS	291	if(fd >= 0 && rc < 0) {
450971aa	292	flog_err_sys(EC_LIB_SYSTEM_CALL, "unlink(babel-state): %s",
f135ba52	293	safe_strerror(errno));
ca10883e	294	/* If we couldn't unlink it, it's probably stale. */
c31a793b	295	goto fini;
ca10883e DS	296	}
	297	if(fd >= 0) {
	298	char buf[100];
	299	char buf2[100];
	300	int s;
	301	long t;
	302	rc = read(fd, buf, 99);
	303	if(rc < 0) {
450971aa	304	flog_err_sys(EC_LIB_SYSTEM_CALL, "read(babel-state): %s",
f135ba52	305	safe_strerror(errno));
ca10883e DS	306	} else {
	307	buf[rc] = '\0';
	308	rc = sscanf(buf, "%99s %d %ld\n", buf2, &s, &t);
	309	if(rc == 3 && s >= 0 && s <= 0xFFFF) {
	310	unsigned char sid[8];
	311	rc = parse_eui64(buf2, sid);
	312	if(rc < 0) {
5b003f31	313	flog_err(EC_BABEL_CONFIG, "Couldn't parse babel-state.");
ca10883e DS	314	} else {
	315	struct timeval realnow;
	316	debugf(BABEL_DEBUG_COMMON,
	317	"Got %s %d %ld from babel-state.",
	318	format_eui64(sid), s, t);
	319	gettimeofday(&realnow, NULL);
	320	if(memcmp(sid, myid, 8) == 0)
	321	myseqno = seqno_plus(s, 1);
	322	else
5b003f31	323	flog_err(EC_BABEL_CONFIG,
e33b116c	324	"ID mismatch in babel-state. id=%s; old=%s",
ca10883e DS	325	format_eui64(myid),
	326	format_eui64(sid));
	327	}
	328	} else {
5b003f31	329	flog_err(EC_BABEL_CONFIG, "Couldn't parse babel-state.");
ca10883e DS	330	}
ca10883e DS	331	}
c31a793b	332	goto fini;
ca10883e	333	}
c31a793b VJ	334	fini:
	335	if (fd >= 0)
	336	close(fd);
	337	return ;
ca10883e DS	338	}
	339
	340	static void
	341	babel_exit_properly(void)
	342	{
	343	debugf(BABEL_DEBUG_COMMON, "Exiting...");
	344	usleep(roughly(10000));
	345	gettime(&babel_now);
	346
	347	/* Uninstall and flush all routes. */
	348	debugf(BABEL_DEBUG_COMMON, "Uninstall routes.");
	349	flush_all_routes();
	350	babel_interface_close_all();
	351	babel_zebra_close_connexion();
	352	babel_save_state_file();
	353	debugf(BABEL_DEBUG_COMMON, "Remove pid file.");
	354	debugf(BABEL_DEBUG_COMMON, "Done.");
8879bd22	355	frr_fini();
ca10883e DS	356
	357	exit(0);
	358	}
	359
	360	static void
	361	babel_save_state_file(void)
	362	{
	363	int fd;
	364	int rc;
	365
	366	debugf(BABEL_DEBUG_COMMON, "Save state file.");
	367	fd = open(state_file, O_WRONLY \| O_TRUNC \| O_CREAT, 0644);
	368	if(fd < 0) {
450971aa	369	flog_err_sys(EC_LIB_SYSTEM_CALL, "creat(babel-state): %s",
f135ba52	370	safe_strerror(errno));
ca10883e DS	371	unlink(state_file);
	372	} else {
	373	struct timeval realnow;
	374	char buf[100];
	375	gettimeofday(&realnow, NULL);
	376	rc = snprintf(buf, 100, "%s %d %ld\n",
	377	format_eui64(myid), (int)myseqno,
	378	(long)realnow.tv_sec);
	379	if(rc < 0 \|\| rc >= 100) {
5b003f31	380	flog_err(EC_BABEL_CONFIG, "write(babel-state): overflow.");
ca10883e DS	381	unlink(state_file);
	382	} else {
	383	rc = write(fd, buf, rc);
	384	if(rc < 0) {
5b003f31	385	flog_err(EC_BABEL_CONFIG, "write(babel-state): %s",
e33b116c	386	safe_strerror(errno));
ca10883e DS	387	unlink(state_file);
	388	}
	389	fsync(fd);
	390	}
	391	close(fd);
	392	}
	393	}
	394
	395	void
	396	show_babel_main_configuration (struct vty *vty)
	397	{
181039f3	398	vty_out (vty,
cdda2010 DL	399	"state file = %s\n"
cdda2010 DL	400	"configuration file = %s\n"
0437e105	401	"protocol information:\n"
cdda2010 DL	402	" multicast address = %s\n"
	403	" port = %d\n"
	404	"vty address = %s\n"
	405	"vty port = %d\n"
	406	"id = %s\n"
181039f3	407	"kernel_metric = %d\n",
cdda2010	408	state_file,
f714218e	409	babeld_di.config_file ? babeld_di.config_file : babel_config_default,
cdda2010 DL	410	format_address(protocol_group),
cdda2010 DL	411	protocol_port,
ca10883e	412	babel_vty_addr ? babel_vty_addr : "None",
cdda2010 DL	413	babel_vty_port,
cdda2010 DL	414	format_eui64(myid),
96ade3ed	415	kernel_metric);
ca10883e	416	}