[mirror_frr.git] / babeld / kernel.c

// SPDX-License-Identifier: MIT
/*
Copyright 2007, 2008 by Grégoire Henry, Julien Cristau and Juliusz Chroboczek
Copyright 2011, 2012 by Matthieu Boutier and Juliusz Chroboczek
*/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <sys/time.h>
#include <sys/param.h>
#include <time.h>

#include "babeld.h"


#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>

#include <zebra.h>
#include "prefix.h"
#include "zclient.h"
#include "kernel.h"
#include "privs.h"
#include "command.h"
#include "vty.h"
#include "memory.h"
#include "frrevent.h"
#include "nexthop.h"

#include "util.h"
#include "babel_interface.h"
#include "babel_zebra.h"


static int
zebra_route(int add, int familt, const unsigned char *pref, unsigned short plen,
            const unsigned char *gate, int ifindex, unsigned int metric);

int
kernel_interface_operational(struct interface *interface)
{
    return if_is_operative(interface);
}

int
kernel_interface_mtu(struct interface *interface)
{
    return MIN(interface->mtu, interface->mtu6);
}

int
kernel_interface_wireless(struct interface *interface)
{
    return 0;
}

int
kernel_route(enum babel_kernel_routes operation, const unsigned char *pref,
	     unsigned short plen, const unsigned char *gate, int ifindex,
	     unsigned int metric, const unsigned char *newgate, int newifindex,
             unsigned int newmetric)
{
    int rc;
    int family;

    /* Check that the protocol family is consistent. */
    if(plen >= 96 && v4mapped(pref)) {
        if(!v4mapped(gate)) {
            errno = EINVAL;
            return -1;
        }
        family = AF_INET;
    } else {
        if(v4mapped(gate)) {
            errno = EINVAL;
            return -1;
        }
        family = AF_INET6;
    }

    switch (operation) {
        case ROUTE_ADD:
            return zebra_route(1, family, pref, plen, gate, ifindex, metric);
        case ROUTE_FLUSH:
            return zebra_route(0, family, pref, plen, gate, ifindex, metric);
        case ROUTE_MODIFY:
            if(newmetric == metric && memcmp(newgate, gate, 16) == 0 &&
               newifindex == ifindex)
                return 0;
            debugf(BABEL_DEBUG_ROUTE, "Modify route: delete old; add new.");
            rc = zebra_route(0, family, pref, plen, gate, ifindex, metric);
            if (rc < 0)
                return -1;

            rc = zebra_route(1, family, pref, plen, newgate, newifindex,
                             newmetric);
            return rc;
    }

    return 0;
}

static int
zebra_route(int add, int family, const unsigned char *pref, unsigned short plen,
            const unsigned char *gate, int ifindex, unsigned int metric)
{
    struct zapi_route api;               /* quagga's communication system */
    struct prefix quagga_prefix;         /* quagga's prefix */
    union g_addr babel_prefix_addr;      /* babeld's prefix addr */
    struct zapi_nexthop *api_nh;         /* next router to go - no ECMP */

    api_nh = &api.nexthops[0];

    /* convert to be understandable by quagga */
    /* convert given addresses */
    switch (family) {
    case AF_INET:
        uchar_to_inaddr(&babel_prefix_addr.ipv4, pref);
        break;
    case AF_INET6:
        uchar_to_in6addr(&babel_prefix_addr.ipv6, pref);
        break;
    }

    /* make prefix structure */
    memset (&quagga_prefix, 0, sizeof(quagga_prefix));
    quagga_prefix.family = family;
    switch (family) {
    case AF_INET:
        IPV4_ADDR_COPY (&quagga_prefix.u.prefix4, &babel_prefix_addr.ipv4);
        /* our plen is for v4mapped's addr */
        quagga_prefix.prefixlen = plen - 96;
        break;
    case AF_INET6:
        IPV6_ADDR_COPY (&quagga_prefix.u.prefix6, &babel_prefix_addr.ipv6);
        quagga_prefix.prefixlen = plen;
        break;
    }
    apply_mask(&quagga_prefix);

    memset(&api, 0, sizeof(api));
    api.type  = ZEBRA_ROUTE_BABEL;
    api.safi = SAFI_UNICAST;
    api.vrf_id = VRF_DEFAULT;
    api.prefix = quagga_prefix;

    if(metric >= KERNEL_INFINITY) {
	zapi_route_set_blackhole(&api, BLACKHOLE_REJECT);
    } else {
        SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
        api.nexthop_num = 1;
        api_nh->ifindex = ifindex;
	api_nh->vrf_id = VRF_DEFAULT;
	switch (family) {
        case AF_INET:
            uchar_to_inaddr(&api_nh->gate.ipv4, gate);
	    if (IPV4_ADDR_SAME(&api_nh->gate.ipv4, &quagga_prefix.u.prefix4)
		&& quagga_prefix.prefixlen == IPV4_MAX_BITLEN) {
		    api_nh->type = NEXTHOP_TYPE_IFINDEX;
	    } else {
		    api_nh->type = NEXTHOP_TYPE_IPV4_IFINDEX;
            }
            break;
        case AF_INET6:
            uchar_to_in6addr(&api_nh->gate.ipv6, gate);
            /* difference to IPv4: always leave the linklocal as nexthop */
            api_nh->type = NEXTHOP_TYPE_IPV6_IFINDEX;
            break;
        }
        SET_FLAG(api.message, ZAPI_MESSAGE_METRIC);
        api.metric = metric;
    }

    debugf(BABEL_DEBUG_ROUTE, "%s route (%s) to zebra",
           add ? "adding" : "removing",
           (family == AF_INET) ? "ipv4" : "ipv6");
    return zclient_route_send (add ? ZEBRA_ROUTE_ADD : ZEBRA_ROUTE_DELETE,
                               zclient, &api);
}

int
if_eui64(int ifindex, unsigned char *eui)
{
    struct interface *ifp = if_lookup_by_index(ifindex, VRF_DEFAULT);
    if (ifp == NULL) {
        return -1;
    }

    uint8_t len = (uint8_t)ifp->hw_addr_len;
    char *tmp = (void*) ifp->hw_addr;

    if (len == 8) {
        memcpy(eui, tmp, 8);
        eui[0] ^= 2;
    } else if (len == 6) {
        memcpy(eui,   tmp,   3);
        eui[3] = 0xFF;
        eui[4] = 0xFE;
        memcpy(eui+5, tmp+3, 3);
    } else {
        return -1;
    }
    return 0;
}

/* Like gettimeofday, but returns monotonic time.  If POSIX clocks are not
   available, falls back to gettimeofday but enforces monotonicity. */
void
gettime(struct timeval *tv)
{
    monotime(tv);
}

/* If /dev/urandom doesn't exist, this will fail with ENOENT, which the
   caller will deal with gracefully. */

int
read_random_bytes(void *buf, size_t len)
{
    int fd;
    int rc;

    fd = open("/dev/urandom", O_RDONLY);
    if(fd < 0) {
        rc = -1;
    } else {
        rc = read(fd, buf, len);
        if(rc < 0 || (unsigned) rc < len)
            rc = -1;
        close(fd);
    }
    return rc;
}
Commit	Line	Data
acddc0ed	1	// SPDX-License-Identifier: MIT
ca10883e DS	2	/*
	3	Copyright 2007, 2008 by Grégoire Henry, Julien Cristau and Juliusz Chroboczek
	4	Copyright 2011, 2012 by Matthieu Boutier and Juliusz Chroboczek
ca10883e DS	5	*/
ca10883e DS	6
b45ac5f5 DL	7	#ifdef HAVE_CONFIG_H
	8	#include "config.h"
	9	#endif
	10
ca10883e DS	11	#include <sys/time.h>
	12	#include <sys/param.h>
	13	#include <time.h>
	14
	15	#include "babeld.h"
	16
	17
	18	#include <sys/types.h>
	19	#include <sys/socket.h>
	20	#include <netinet/in.h>
	21	#include <netdb.h>
	22	#include <arpa/inet.h>
	23
	24	#include <zebra.h>
	25	#include "prefix.h"
	26	#include "zclient.h"
	27	#include "kernel.h"
	28	#include "privs.h"
	29	#include "command.h"
	30	#include "vty.h"
	31	#include "memory.h"
24a58196	32	#include "frrevent.h"
98c02f4c	33	#include "nexthop.h"
ca10883e DS	34
	35	#include "util.h"
	36	#include "babel_interface.h"
	37	#include "babel_zebra.h"
	38
	39
	40	static int
c8f9e916 RW	41	zebra_route(int add, int familt, const unsigned char *pref, unsigned short plen,
c8f9e916 RW	42	const unsigned char *gate, int ifindex, unsigned int metric);
ca10883e DS	43
	44	int
	45	kernel_interface_operational(struct interface *interface)
	46	{
	47	return if_is_operative(interface);
	48	}
	49
	50	int
	51	kernel_interface_mtu(struct interface *interface)
	52	{
	53	return MIN(interface->mtu, interface->mtu6);
	54	}
	55
	56	int
	57	kernel_interface_wireless(struct interface *interface)
	58	{
	59	return 0;
	60	}
	61
	62	int
e8c8f2e0 DS	63	kernel_route(enum babel_kernel_routes operation, const unsigned char *pref,
	64	unsigned short plen, const unsigned char *gate, int ifindex,
	65	unsigned int metric, const unsigned char *newgate, int newifindex,
ca10883e DS	66	unsigned int newmetric)
	67	{
	68	int rc;
c8f9e916	69	int family;
ca10883e DS	70
	71	/* Check that the protocol family is consistent. */
	72	if(plen >= 96 && v4mapped(pref)) {
	73	if(!v4mapped(gate)) {
	74	errno = EINVAL;
	75	return -1;
	76	}
c8f9e916	77	family = AF_INET;
ca10883e DS	78	} else {
	79	if(v4mapped(gate)) {
	80	errno = EINVAL;
	81	return -1;
	82	}
c8f9e916	83	family = AF_INET6;
ca10883e DS	84	}
	85
	86	switch (operation) {
	87	case ROUTE_ADD:
c8f9e916	88	return zebra_route(1, family, pref, plen, gate, ifindex, metric);
ca10883e	89	case ROUTE_FLUSH:
c8f9e916	90	return zebra_route(0, family, pref, plen, gate, ifindex, metric);
ca10883e DS	91	case ROUTE_MODIFY:
	92	if(newmetric == metric && memcmp(newgate, gate, 16) == 0 &&
	93	newifindex == ifindex)
	94	return 0;
	95	debugf(BABEL_DEBUG_ROUTE, "Modify route: delete old; add new.");
c8f9e916	96	rc = zebra_route(0, family, pref, plen, gate, ifindex, metric);
ca10883e DS	97	if (rc < 0)
	98	return -1;
	99
c8f9e916 RW	100	rc = zebra_route(1, family, pref, plen, newgate, newifindex,
c8f9e916 RW	101	newmetric);
ca10883e	102	return rc;
ca10883e	103	}
e8c8f2e0 DS	104
e8c8f2e0 DS	105	return 0;
ca10883e DS	106	}
	107
	108	static int
c8f9e916 RW	109	zebra_route(int add, int family, const unsigned char *pref, unsigned short plen,
c8f9e916 RW	110	const unsigned char *gate, int ifindex, unsigned int metric)
ca10883e	111	{
98c02f4c DS	112	struct zapi_route api; /* quagga's communication system */
98c02f4c DS	113	struct prefix quagga_prefix; /* quagga's prefix */
c8f9e916 RW	114	union g_addr babel_prefix_addr; /* babeld's prefix addr */
c8f9e916 RW	115	struct zapi_nexthop api_nh; / next router to go - no ECMP */
bb1b9c47 RW	116
bb1b9c47 RW	117	api_nh = &api.nexthops[0];
ca10883e DS	118
	119	/* convert to be understandable by quagga */
	120	/* convert given addresses */
c8f9e916 RW	121	switch (family) {
	122	case AF_INET:
	123	uchar_to_inaddr(&babel_prefix_addr.ipv4, pref);
	124	break;
	125	case AF_INET6:
	126	uchar_to_in6addr(&babel_prefix_addr.ipv6, pref);
	127	break;
ca10883e DS	128	}
ca10883e DS	129
ca10883e DS	130	/* make prefix structure */
ca10883e DS	131	memset (&quagga_prefix, 0, sizeof(quagga_prefix));
c8f9e916 RW	132	quagga_prefix.family = family;
	133	switch (family) {
	134	case AF_INET:
	135	IPV4_ADDR_COPY (&quagga_prefix.u.prefix4, &babel_prefix_addr.ipv4);
	136	/* our plen is for v4mapped's addr */
	137	quagga_prefix.prefixlen = plen - 96;
	138	break;
	139	case AF_INET6:
	140	IPV6_ADDR_COPY (&quagga_prefix.u.prefix6, &babel_prefix_addr.ipv6);
	141	quagga_prefix.prefixlen = plen;
	142	break;
	143	}
98c02f4c	144	apply_mask(&quagga_prefix);
ca10883e	145
e4d9c771	146	memset(&api, 0, sizeof(api));
ca10883e	147	api.type = ZEBRA_ROUTE_BABEL;
ca10883e	148	api.safi = SAFI_UNICAST;
e4d9c771	149	api.vrf_id = VRF_DEFAULT;
bb1b9c47	150	api.prefix = quagga_prefix;
e4d9c771	151
ca10883e	152	if(metric >= KERNEL_INFINITY) {
09a484dd	153	zapi_route_set_blackhole(&api, BLACKHOLE_REJECT);
ca10883e DS	154	} else {
	155	SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
	156	api.nexthop_num = 1;
bb1b9c47	157	api_nh->ifindex = ifindex;
4a7371e9 DS	158	api_nh->vrf_id = VRF_DEFAULT;
4a7371e9 DS	159	switch (family) {
c8f9e916 RW	160	case AF_INET:
c8f9e916 RW	161	uchar_to_inaddr(&api_nh->gate.ipv4, gate);
12256b84 DA	162	if (IPV4_ADDR_SAME(&api_nh->gate.ipv4, &quagga_prefix.u.prefix4)
	163	&& quagga_prefix.prefixlen == IPV4_MAX_BITLEN) {
	164	api_nh->type = NEXTHOP_TYPE_IFINDEX;
	165	} else {
	166	api_nh->type = NEXTHOP_TYPE_IPV4_IFINDEX;
c8f9e916 RW	167	}
	168	break;
	169	case AF_INET6:
	170	uchar_to_in6addr(&api_nh->gate.ipv6, gate);
	171	/* difference to IPv4: always leave the linklocal as nexthop */
	172	api_nh->type = NEXTHOP_TYPE_IPV6_IFINDEX;
	173	break;
	174	}
ca10883e DS	175	SET_FLAG(api.message, ZAPI_MESSAGE_METRIC);
	176	api.metric = metric;
	177	}
	178
c8f9e916 RW	179	debugf(BABEL_DEBUG_ROUTE, "%s route (%s) to zebra",
	180	add ? "adding" : "removing",
	181	(family == AF_INET) ? "ipv4" : "ipv6");
0e51b4a3 RW	182	return zclient_route_send (add ? ZEBRA_ROUTE_ADD : ZEBRA_ROUTE_DELETE,
0e51b4a3 RW	183	zclient, &api);
ca10883e DS	184	}
	185
	186	int
edb1d4a0	187	if_eui64(int ifindex, unsigned char *eui)
ca10883e DS	188	{
	189	struct interface *ifp = if_lookup_by_index(ifindex, VRF_DEFAULT);
	190	if (ifp == NULL) {
	191	return -1;
	192	}
7217de2d	193
d7c0a89a	194	uint8_t len = (uint8_t)ifp->hw_addr_len;
ca10883e	195	char tmp = (void) ifp->hw_addr;
7217de2d	196
ca10883e DS	197	if (len == 8) {
	198	memcpy(eui, tmp, 8);
	199	eui[0] ^= 2;
	200	} else if (len == 6) {
	201	memcpy(eui, tmp, 3);
	202	eui[3] = 0xFF;
	203	eui[4] = 0xFE;
	204	memcpy(eui+5, tmp+3, 3);
	205	} else {
	206	return -1;
	207	}
	208	return 0;
	209	}
	210
	211	/* Like gettimeofday, but returns monotonic time. If POSIX clocks are not
	212	available, falls back to gettimeofday but enforces monotonicity. */
c392d9f4	213	void
ca10883e DS	214	gettime(struct timeval *tv)
ca10883e DS	215	{
c392d9f4	216	monotime(tv);
ca10883e DS	217	}
	218
	219	/* If /dev/urandom doesn't exist, this will fail with ENOENT, which the
	220	caller will deal with gracefully. */
	221
	222	int
	223	read_random_bytes(void *buf, size_t len)
	224	{
	225	int fd;
	226	int rc;
	227
	228	fd = open("/dev/urandom", O_RDONLY);
	229	if(fd < 0) {
	230	rc = -1;
	231	} else {
	232	rc = read(fd, buf, len);
	233	if(rc < 0 \|\| (unsigned) rc < len)
	234	rc = -1;
	235	close(fd);
	236	}
	237	return rc;
	238	}