[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 const char *state_file = DAEMON_VTY_DIR "/babel-state";

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 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 }
  };

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,
		)

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;
	  }
    }

    /* 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 */
    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(LIB_ERR_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(LIB_ERR_SYSTEM_CALL, "open(null): %s", safe_strerror(errno));
        exit(1);
    }

    rc = dup2(fd_null, fd);
    if(rc < 0) {
        flog_err_sys(LIB_ERR_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(LIB_ERR_SYSTEM_CALL, "open(babel-state: %s)",
		  safe_strerror(errno));
    rc = unlink(state_file);
    if(fd >= 0 && rc < 0) {
        flog_err_sys(LIB_ERR_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(LIB_ERR_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(BABEL_ERR_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(BABEL_ERR_CONFIG,
				 "ID mismatch in babel-state. id=%s; old=%s",
                                 format_eui64(myid),
                                 format_eui64(sid));
                }
            } else {
                flog_err(BABEL_ERR_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(LIB_ERR_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(BABEL_ERR_CONFIG, "write(babel-state): overflow.");
            unlink(state_file);
        } else {
            rc = write(fd, buf, rc);
            if(rc < 0) {
                flog_err(BABEL_ERR_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
	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	#include "lib_errors.h"
	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"
	49	#include "babel_errors.h"
	50
	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
	71	static const char *state_file = DAEMON_VTY_DIR "/babel-state";
	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
	77	static char babel_config_default[] = SYSCONFDIR BABEL_DEFAULT_CONFIG;
	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	};
	87
	88	struct zebra_privs_t babeld_privs =
	89	{
	90	#if defined(FRR_USER)
	91	.user = FRR_USER,
	92	#endif
	93	#if defined FRR_GROUP
	94	.group = FRR_GROUP,
	95	#endif
	96	#ifdef VTY_GROUP
	97	.vty_group = VTY_GROUP,
	98	#endif
	99	.caps_p = _caps_p,
	100	.cap_num_p = array_size(_caps_p),
	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
	139	FRR_DAEMON_INFO(babeld, BABELD,
	140	.vty_port = BABEL_VTY_PORT,
	141	.proghelp = "Implementation of the BABEL routing protocol.",
	142
	143	.signals = babel_signals,
	144	.n_signals = array_size(babel_signals),
	145
	146	.privs = &babeld_privs,
	147	)
	148
	149	int
	150	main(int argc, char **argv)
	151	{
	152	int rc;
	153
	154	frr_preinit (&babeld_di, argc, argv);
	155	frr_opt_add ("", longopts, "");
	156
	157	babel_init_random();
	158
	159	/* set the Babel's default link-local multicast address and Babel's port */
	160	parse_address("ff02:0:0:0:0:0:1:6", protocol_group, NULL);
	161	protocol_port = 6696;
	162
	163	/* get options */
	164	while(1) {
	165	int opt;
	166
	167	opt = frr_getopt (argc, argv, NULL);
	168
	169	if (opt == EOF)
	170	break;
	171
	172	switch (opt)
	173	{
	174	case 0:
	175	break;
	176	default:
	177	frr_help_exit (1);
	178	break;
	179	}
	180	}
	181
	182	/* create the threads handler */
	183	master = frr_init ();
	184
	185	/* Library inits. */
	186	babel_error_init();
	187
	188	resend_delay = BABEL_DEFAULT_RESEND_DELAY;
	189	change_smoothing_half_life(BABEL_DEFAULT_SMOOTHING_HALF_LIFE);
	190
	191	babel_replace_by_null(STDIN_FILENO);
	192
	193	/* init some quagga's dependencies, and babeld's commands */
	194	babeld_quagga_init();
	195	/* init zebra client's structure and it's commands */
	196	/* this replace kernel_setup && kernel_setup_socket */
	197	babelz_zebra_init ();
	198
	199	/* init buffer */
	200	rc = resize_receive_buffer(1500);
	201	if(rc < 0)
	202	babel_fail();
	203
	204	schedule_neighbours_check(5000, 1);
	205
	206	frr_config_fork();
	207	frr_run(master);
	208
	209	return 0;
	210	}
	211
	212	static void
	213	babel_fail(void)
	214	{
	215	exit(1);
	216	}
	217
	218	/* initialize random value, and set 'babel_now' by the way. */
	219	static void
	220	babel_init_random(void)
	221	{
	222	gettime(&babel_now);
	223	int rc;
	224	unsigned int seed;
	225
	226	rc = read_random_bytes(&seed, sizeof(seed));
	227	if(rc < 0) {
	228	flog_err_sys(LIB_ERR_SYSTEM_CALL, "read(random): %s",
	229	safe_strerror(errno));
	230	seed = 42;
	231	}
	232
	233	seed ^= (babel_now.tv_sec ^ babel_now.tv_usec);
	234	srandom(seed);
	235	}
	236
	237	/*
	238	close fd, and replace it by "/dev/null"
	239	exit if error
	240	*/
	241	static void
	242	babel_replace_by_null(int fd)
	243	{
	244	int fd_null;
	245	int rc;
	246
	247	fd_null = open("/dev/null", O_RDONLY);
	248	if(fd_null < 0) {
	249	flog_err_sys(LIB_ERR_SYSTEM_CALL, "open(null): %s", safe_strerror(errno));
	250	exit(1);
	251	}
	252
	253	rc = dup2(fd_null, fd);
	254	if(rc < 0) {
	255	flog_err_sys(LIB_ERR_SYSTEM_CALL, "dup2(null, 0): %s",
	256	safe_strerror(errno));
	257	exit(1);
	258	}
	259
	260	close(fd_null);
	261	}
	262
	263	/*
	264	Load the state file: check last babeld's running state, usefull in case of
	265	"/etc/init.d/babeld restart"
	266	*/
	267	void
	268	babel_load_state_file(void)
	269	{
	270	int fd;
	271	int rc;
	272
	273	fd = open(state_file, O_RDONLY);
	274	if(fd < 0 && errno != ENOENT)
	275	flog_err_sys(LIB_ERR_SYSTEM_CALL, "open(babel-state: %s)",
	276	safe_strerror(errno));
	277	rc = unlink(state_file);
	278	if(fd >= 0 && rc < 0) {
	279	flog_err_sys(LIB_ERR_SYSTEM_CALL, "unlink(babel-state): %s",
	280	safe_strerror(errno));
	281	/* If we couldn't unlink it, it's probably stale. */
	282	goto fini;
	283	}
	284	if(fd >= 0) {
	285	char buf[100];
	286	char buf2[100];
	287	int s;
	288	long t;
	289	rc = read(fd, buf, 99);
	290	if(rc < 0) {
	291	flog_err_sys(LIB_ERR_SYSTEM_CALL, "read(babel-state): %s",
	292	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	flog_err(BABEL_ERR_CONFIG, "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	flog_err(BABEL_ERR_CONFIG,
	311	"ID mismatch in babel-state. id=%s; old=%s",
	312	format_eui64(myid),
	313	format_eui64(sid));
	314	}
	315	} else {
	316	flog_err(BABEL_ERR_CONFIG, "Couldn't parse babel-state.");
	317	}
	318	}
	319	goto fini;
	320	}
	321	fini:
	322	if (fd >= 0)
	323	close(fd);
	324	return ;
	325	}
	326
	327	static void
	328	babel_exit_properly(void)
	329	{
	330	debugf(BABEL_DEBUG_COMMON, "Exiting...");
	331	usleep(roughly(10000));
	332	gettime(&babel_now);
	333
	334	/* Uninstall and flush all routes. */
	335	debugf(BABEL_DEBUG_COMMON, "Uninstall routes.");
	336	flush_all_routes();
	337	babel_interface_close_all();
	338	babel_zebra_close_connexion();
	339	babel_save_state_file();
	340	debugf(BABEL_DEBUG_COMMON, "Remove pid file.");
	341	debugf(BABEL_DEBUG_COMMON, "Done.");
	342	frr_fini();
	343
	344	exit(0);
	345	}
	346
	347	static void
	348	babel_save_state_file(void)
	349	{
	350	int fd;
	351	int rc;
	352
	353	debugf(BABEL_DEBUG_COMMON, "Save state file.");
	354	fd = open(state_file, O_WRONLY \| O_TRUNC \| O_CREAT, 0644);
	355	if(fd < 0) {
	356	flog_err_sys(LIB_ERR_SYSTEM_CALL, "creat(babel-state): %s",
	357	safe_strerror(errno));
	358	unlink(state_file);
	359	} else {
	360	struct timeval realnow;
	361	char buf[100];
	362	gettimeofday(&realnow, NULL);
	363	rc = snprintf(buf, 100, "%s %d %ld\n",
	364	format_eui64(myid), (int)myseqno,
	365	(long)realnow.tv_sec);
	366	if(rc < 0 \|\| rc >= 100) {
	367	flog_err(BABEL_ERR_CONFIG, "write(babel-state): overflow.");
	368	unlink(state_file);
	369	} else {
	370	rc = write(fd, buf, rc);
	371	if(rc < 0) {
	372	flog_err(BABEL_ERR_CONFIG, "write(babel-state): %s",
	373	safe_strerror(errno));
	374	unlink(state_file);
	375	}
	376	fsync(fd);
	377	}
	378	close(fd);
	379	}
	380	}
	381
	382	void
	383	show_babel_main_configuration (struct vty *vty)
	384	{
	385	vty_out (vty,
	386	"state file = %s\n"
	387	"configuration file = %s\n"
	388	"protocol information:\n"
	389	" multicast address = %s\n"
	390	" port = %d\n"
	391	"vty address = %s\n"
	392	"vty port = %d\n"
	393	"id = %s\n"
	394	"kernel_metric = %d\n",
	395	state_file,
	396	babeld_di.config_file ? babeld_di.config_file : babel_config_default,
	397	format_address(protocol_group),
	398	protocol_port,
	399	babel_vty_addr ? babel_vty_addr : "None",
	400	babel_vty_port,
	401	format_eui64(myid),
	402	kernel_metric);
	403	}