[thirdparty/systemd.git] / src / network / networkd-tunnel.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
    This file is part of systemd.

    Copyright 2014 Susant Sahani <susant@redhat.com>

    systemd is free software; you can redistribute it and/or modify it
    under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation; either version 2.1 of the License, or
    (at your option) any later version.

    systemd is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <netinet/ether.h>
#include <arpa/inet.h>
#include <net/if.h>
#include <linux/ip.h>
#include <linux/if_tunnel.h>
#include <libkmod.h>

#include "sd-rtnl.h"
#include "networkd.h"
#include "network-internal.h"
#include "util.h"


static int netdev_fill_ipip_rtnl_message(Link *link, sd_rtnl_message *m) {
        NetDev *netdev;
        int r;

        assert(link);
        assert(link->network);
        assert(link->network->tunnel);
        assert(m);

        netdev = link->network->tunnel;

        r = sd_rtnl_message_append_string(m, IFLA_IFNAME, netdev->ifname);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_IFNAME, attribute: %s",
                                 strerror(-r));
                return r;
        }

        if(netdev->mtu) {
                r = sd_rtnl_message_append_u32(m, IFLA_MTU, netdev->mtu);
                if (r < 0) {
                        log_error_netdev(netdev,
                                         "Could not append IFLA_MTU attribute: %s",
                                         strerror(-r));
                        return r;
                }
        }

        r = sd_rtnl_message_open_container(m, IFLA_LINKINFO);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_LINKINFO attribute: %s",
                                 strerror(-r));
                return r;
        }

        r = sd_rtnl_message_open_container_union(m, IFLA_INFO_DATA,
                                                 netdev_kind_to_string(netdev->kind));
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_INFO_DATA attribute: %s",
                                 strerror(-r));
                return r;
        }

        r = sd_rtnl_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_IPTUN_LINK attribute: %s",
                                 strerror(-r));
                return r;
        }

        r = sd_rtnl_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &netdev->tunnel_local);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_IPTUN_LOCAL attribute: %s",
                                 strerror(-r));
                return r;
        }

        r = sd_rtnl_message_append_in_addr(m, IFLA_IPTUN_REMOTE, &netdev->tunnel_remote);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_IPTUN_REMOTE attribute: %s",
                                 strerror(-r));
                return r;
        }

        r = sd_rtnl_message_append_u8(m, IFLA_IPTUN_TTL, netdev->tunnel_ttl);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_IPTUN_TTL  attribute: %s",
                                 strerror(-r));
                return r;
        }

        r = sd_rtnl_message_close_container(m);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_INFO_DATA attribute: %s",
                                 strerror(-r));
                return r;
        }

        r = sd_rtnl_message_close_container(m);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_LINKINFO attribute: %s",
                                 strerror(-r));
                return r;
        }

        return r;
}

static int netdev_fill_sit_rtnl_message(Link *link, sd_rtnl_message *m) {
        NetDev *netdev;
        int r;

        assert(link);
        assert(link->network);
        assert(link->network->tunnel);
        assert(m);

        netdev = link->network->tunnel;

        r = sd_rtnl_message_append_string(m, IFLA_IFNAME, netdev->ifname);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_IFNAME, attribute: %s",
                                 strerror(-r));
                return r;
        }

        if(netdev->mtu) {
                r = sd_rtnl_message_append_u32(m, IFLA_MTU, netdev->mtu);
                if (r < 0) {
                        log_error_netdev(netdev,
                                         "Could not append IFLA_MTU attribute: %s",
                                         strerror(-r));
                        return r;
                }
        }

        r = sd_rtnl_message_open_container(m, IFLA_LINKINFO);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_LINKINFO attribute: %s",
                                 strerror(-r));
                return r;
        }

        r = sd_rtnl_message_open_container_union(m, IFLA_INFO_DATA,
                                                 netdev_kind_to_string(netdev->kind));
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_INFO_DATA attribute: %s",
                                 strerror(-r));
                return r;
        }

        r = sd_rtnl_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_IPTUN_LINK attribute: %s",
                                 strerror(-r));
                return r;
        }

        r = sd_rtnl_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &netdev->tunnel_local);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_IPTUN_LOCAL attribute: %s",
                                 strerror(-r));
                return r;
        }

        r = sd_rtnl_message_append_in_addr(m, IFLA_IPTUN_REMOTE, &netdev->tunnel_remote);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_IPTUN_REMOTE attribute: %s",
                                 strerror(-r));
                return r;
        }

        r = sd_rtnl_message_append_u8(m, IFLA_IPTUN_TOS, netdev->tunnel_tos);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_IPTUN_TOS attribute: %s",
                                 strerror(-r));
                return r;
        }

        r = sd_rtnl_message_close_container(m);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_INFO_DATA attribute: %s",
                                 strerror(-r));
                return r;
        }

        r = sd_rtnl_message_close_container(m);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not append IFLA_LINKINFO attribute: %s",
                                 strerror(-r));
                return r;
        }

        return r;
}

int netdev_create_tunnel(Link *link, sd_rtnl_message_handler_t callback) {
        _cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
        NetDev *netdev;
        int r;

        assert(link);
        assert(link->network);
        assert(link->network->tunnel);

        netdev = link->network->tunnel;

        assert(netdev);
        assert(netdev->ifname);
        assert(netdev->manager);
        assert(netdev->manager->rtnl);
        assert(netdev->manager->kmod_ctx);

        /* Load kernel module first */
        switch(netdev->kind) {
        case NETDEV_KIND_IPIP:
        case NETDEV_KIND_GRE:
        case NETDEV_KIND_SIT:
                r = load_module(netdev->manager->kmod_ctx,
                                netdev_kind_to_string(netdev->kind));
                if (r < 0) {
                        log_error_netdev(netdev,
                                         "Could not load Kernel module: %s . Ignoring",
                                         netdev_kind_to_string(netdev->kind));
                        return r;
                }
                break;
        default:
                return -ENOTSUP;
        }

        r = sd_rtnl_message_new_link(netdev->manager->rtnl, &m, RTM_NEWLINK, 0);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not allocate RTM_NEWLINK message: %s",
                                 strerror(-r));
                return r;
        }

        switch(netdev->kind) {
        case NETDEV_KIND_IPIP:
                r = netdev_fill_ipip_rtnl_message(link, m);
                if(r < 0)
                        return r;
                break;
        case NETDEV_KIND_SIT:
                r = netdev_fill_sit_rtnl_message(link, m);
                if(r < 0)
                        return r;
                break;
        case NETDEV_KIND_GRE:
        default:
                return -ENOTSUP;
        }

        r = sd_rtnl_call_async(netdev->manager->rtnl, m, callback, netdev, 0, NULL);
        if (r < 0) {
                log_error_netdev(netdev,
                                 "Could not send rtnetlink message: %s", strerror(-r));
                return r;
        }

        log_debug_netdev(netdev, "Creating tunnel netdev: %s",
                         netdev_kind_to_string(netdev->kind));

        netdev->state = NETDEV_STATE_CREATING;

        return 0;
}
Commit	Line	Data
7951dea2 SS	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2014 Susant Sahani <susant@redhat.com>
	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU Lesser General Public License as published by
	10	the Free Software Foundation; either version 2.1 of the License, or
	11	(at your option) any later version.
	12
	13	systemd 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	Lesser General Public License for more details.
	17
	18	You should have received a copy of the GNU Lesser General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <netinet/ether.h>
	23	#include <arpa/inet.h>
	24	#include <net/if.h>
	25	#include <linux/ip.h>
	26	#include <linux/if_tunnel.h>
	27	#include <libkmod.h>
	28
	29	#include "sd-rtnl.h"
	30	#include "networkd.h"
	31	#include "network-internal.h"
	32	#include "util.h"
	33
	34
	35	static int netdev_fill_ipip_rtnl_message(Link link, sd_rtnl_message m) {
	36	NetDev *netdev;
	37	int r;
	38
	39	assert(link);
	40	assert(link->network);
	41	assert(link->network->tunnel);
	42	assert(m);
	43
	44	netdev = link->network->tunnel;
	45
af4e9e2c	46	r = sd_rtnl_message_append_string(m, IFLA_IFNAME, netdev->ifname);
7951dea2 SS	47	if (r < 0) {
	48	log_error_netdev(netdev,
	49	"Could not append IFLA_IFNAME, attribute: %s",
	50	strerror(-r));
	51	return r;
	52	}
	53
	54	if(netdev->mtu) {
	55	r = sd_rtnl_message_append_u32(m, IFLA_MTU, netdev->mtu);
	56	if (r < 0) {
	57	log_error_netdev(netdev,
	58	"Could not append IFLA_MTU attribute: %s",
	59	strerror(-r));
	60	return r;
	61	}
	62	}
	63
	64	r = sd_rtnl_message_open_container(m, IFLA_LINKINFO);
	65	if (r < 0) {
	66	log_error_netdev(netdev,
	67	"Could not append IFLA_LINKINFO attribute: %s",
	68	strerror(-r));
	69	return r;
	70	}
	71
	72	r = sd_rtnl_message_open_container_union(m, IFLA_INFO_DATA,
	73	netdev_kind_to_string(netdev->kind));
	74	if (r < 0) {
	75	log_error_netdev(netdev,
	76	"Could not append IFLA_INFO_DATA attribute: %s",
	77	strerror(-r));
	78	return r;
	79	}
	80
	81	r = sd_rtnl_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
	82	if (r < 0) {
	83	log_error_netdev(netdev,
	84	"Could not append IFLA_IPTUN_LINK attribute: %s",
	85	strerror(-r));
	86	return r;
	87	}
	88
	89	r = sd_rtnl_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &netdev->tunnel_local);
	90	if (r < 0) {
	91	log_error_netdev(netdev,
	92	"Could not append IFLA_IPTUN_LOCAL attribute: %s",
	93	strerror(-r));
	94	return r;
	95	}
	96
	97	r = sd_rtnl_message_append_in_addr(m, IFLA_IPTUN_REMOTE, &netdev->tunnel_remote);
	98	if (r < 0) {
	99	log_error_netdev(netdev,
	100	"Could not append IFLA_IPTUN_REMOTE attribute: %s",
	101	strerror(-r));
	102	return r;
	103	}
	104
9ae70211 SS	105	r = sd_rtnl_message_append_u8(m, IFLA_IPTUN_TTL, netdev->tunnel_ttl);
	106	if (r < 0) {
	107	log_error_netdev(netdev,
	108	"Could not append IFLA_IPTUN_TTL attribute: %s",
	109	strerror(-r));
	110	return r;
	111	}
	112
7951dea2 SS	113	r = sd_rtnl_message_close_container(m);
	114	if (r < 0) {
	115	log_error_netdev(netdev,
	116	"Could not append IFLA_INFO_DATA attribute: %s",
	117	strerror(-r));
	118	return r;
	119	}
	120
	121	r = sd_rtnl_message_close_container(m);
	122	if (r < 0) {
	123	log_error_netdev(netdev,
	124	"Could not append IFLA_LINKINFO attribute: %s",
	125	strerror(-r));
	126	return r;
	127	}
	128
	129	return r;
	130	}
	131
abf446af SS	132	static int netdev_fill_sit_rtnl_message(Link link, sd_rtnl_message m) {
	133	NetDev *netdev;
	134	int r;
	135
	136	assert(link);
	137	assert(link->network);
	138	assert(link->network->tunnel);
	139	assert(m);
	140
	141	netdev = link->network->tunnel;
	142
	143	r = sd_rtnl_message_append_string(m, IFLA_IFNAME, netdev->ifname);
	144	if (r < 0) {
	145	log_error_netdev(netdev,
	146	"Could not append IFLA_IFNAME, attribute: %s",
	147	strerror(-r));
	148	return r;
	149	}
	150
	151	if(netdev->mtu) {
	152	r = sd_rtnl_message_append_u32(m, IFLA_MTU, netdev->mtu);
	153	if (r < 0) {
	154	log_error_netdev(netdev,
	155	"Could not append IFLA_MTU attribute: %s",
	156	strerror(-r));
	157	return r;
	158	}
	159	}
	160
	161	r = sd_rtnl_message_open_container(m, IFLA_LINKINFO);
	162	if (r < 0) {
	163	log_error_netdev(netdev,
	164	"Could not append IFLA_LINKINFO attribute: %s",
	165	strerror(-r));
	166	return r;
	167	}
	168
	169	r = sd_rtnl_message_open_container_union(m, IFLA_INFO_DATA,
	170	netdev_kind_to_string(netdev->kind));
	171	if (r < 0) {
	172	log_error_netdev(netdev,
	173	"Could not append IFLA_INFO_DATA attribute: %s",
	174	strerror(-r));
	175	return r;
	176	}
	177
	178	r = sd_rtnl_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
	179	if (r < 0) {
	180	log_error_netdev(netdev,
	181	"Could not append IFLA_IPTUN_LINK attribute: %s",
	182	strerror(-r));
	183	return r;
	184	}
	185
	186	r = sd_rtnl_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &netdev->tunnel_local);
	187	if (r < 0) {
	188	log_error_netdev(netdev,
	189	"Could not append IFLA_IPTUN_LOCAL attribute: %s",
	190	strerror(-r));
	191	return r;
	192	}
	193
	194	r = sd_rtnl_message_append_in_addr(m, IFLA_IPTUN_REMOTE, &netdev->tunnel_remote);
	195	if (r < 0) {
196	log_error_netdev(netdev,
197	"Could not append IFLA_IPTUN_REMOTE attribute: %s",
198	strerror(-r));
199	return r;
200	}
201
202	r = sd_rtnl_message_append_u8(m, IFLA_IPTUN_TOS, netdev->tunnel_tos);
203	if (r < 0) {
204	log_error_netdev(netdev,
205	"Could not append IFLA_IPTUN_TOS attribute: %s",
206	strerror(-r));
207	return r;
208	}
209
210	r = sd_rtnl_message_close_container(m);
211	if (r < 0) {
212	log_error_netdev(netdev,
213	"Could not append IFLA_INFO_DATA attribute: %s",
214	strerror(-r));
215	return r;
216	}
217
218	r = sd_rtnl_message_close_container(m);
219	if (r < 0) {
220	log_error_netdev(netdev,
221	"Could not append IFLA_LINKINFO attribute: %s",
222	strerror(-r));
223	return r;
224	}
225
226	return r;
227	}
228
7951dea2 SS	229	int netdev_create_tunnel(Link *link, sd_rtnl_message_handler_t callback) {
	230	_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
	231	NetDev *netdev;
	232	int r;
	233
	234	assert(link);
	235	assert(link->network);
	236	assert(link->network->tunnel);
	237
	238	netdev = link->network->tunnel;
	239
	240	assert(netdev);
af4e9e2c	241	assert(netdev->ifname);
7951dea2 SS	242	assert(netdev->manager);
	243	assert(netdev->manager->rtnl);
	244	assert(netdev->manager->kmod_ctx);
	245
	246	/* Load kernel module first */
	247	switch(netdev->kind) {
	248	case NETDEV_KIND_IPIP:
	249	case NETDEV_KIND_GRE:
	250	case NETDEV_KIND_SIT:
	251	r = load_module(netdev->manager->kmod_ctx,
	252	netdev_kind_to_string(netdev->kind));
	253	if (r < 0) {
	254	log_error_netdev(netdev,
	255	"Could not load Kernel module: %s . Ignoring",
	256	netdev_kind_to_string(netdev->kind));
	257	return r;
	258	}
	259	break;
	260	default:
	261	return -ENOTSUP;
	262	}
	263
	264	r = sd_rtnl_message_new_link(netdev->manager->rtnl, &m, RTM_NEWLINK, 0);
	265	if (r < 0) {
	266	log_error_netdev(netdev,
	267	"Could not allocate RTM_NEWLINK message: %s",
	268	strerror(-r));
	269	return r;
	270	}
	271
	272	switch(netdev->kind) {
	273	case NETDEV_KIND_IPIP:
	274	r = netdev_fill_ipip_rtnl_message(link, m);
	275	if(r < 0)
	276	return r;
	277	break;
7951dea2	278	case NETDEV_KIND_SIT:
abf446af SS	279	r = netdev_fill_sit_rtnl_message(link, m);
	280	if(r < 0)
	281	return r;
	282	break;
	283	case NETDEV_KIND_GRE:
7951dea2 SS	284	default:
	285	return -ENOTSUP;
	286	}
	287
	288	r = sd_rtnl_call_async(netdev->manager->rtnl, m, callback, netdev, 0, NULL);
	289	if (r < 0) {
	290	log_error_netdev(netdev,
	291	"Could not send rtnetlink message: %s", strerror(-r));
	292	return r;
	293	}
	294
	295	log_debug_netdev(netdev, "Creating tunnel netdev: %s",
	296	netdev_kind_to_string(netdev->kind));
	297
	298	netdev->state = NETDEV_STATE_CREATING;
	299
	300	return 0;
	301	}