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

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

/***
  This file is part of systemd.

  Copyright 2013 Tom Gundersen <teg@jklm.no>

  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 "util.h"
#include "conf-parser.h"
#include "netlink-util.h"

#include "networkd.h"
#include "networkd-route.h"

int route_new_static(Network *network, unsigned section, Route **ret) {
        _cleanup_route_free_ Route *route = NULL;

        if (section) {
                route = hashmap_get(network->routes_by_section,
                                    UINT_TO_PTR(section));
                if (route) {
                        *ret = route;
                        route = NULL;

                        return 0;
                }
        }

        route = new0(Route, 1);
        if (!route)
                return -ENOMEM;

        route->family = AF_UNSPEC;
        route->scope = RT_SCOPE_UNIVERSE;
        route->protocol = RTPROT_STATIC;

        route->network = network;

        LIST_PREPEND(routes, network->static_routes, route);

        if (section) {
                route->section = section;
                hashmap_put(network->routes_by_section,
                            UINT_TO_PTR(route->section), route);
        }

        *ret = route;
        route = NULL;

        return 0;
}

int route_new_dynamic(Route **ret, unsigned char rtm_protocol) {
        _cleanup_route_free_ Route *route = NULL;

        route = new0(Route, 1);
        if (!route)
                return -ENOMEM;

        route->family = AF_UNSPEC;
        route->scope = RT_SCOPE_UNIVERSE;
        route->protocol = rtm_protocol;

        *ret = route;
        route = NULL;

        return 0;
}

void route_free(Route *route) {
        if (!route)
                return;

        if (route->network) {
                LIST_REMOVE(routes, route->network->static_routes, route);

                if (route->section)
                        hashmap_remove(route->network->routes_by_section,
                                       UINT_TO_PTR(route->section));
        }

        free(route);
}

int route_drop(Route *route, Link *link,
               sd_netlink_message_handler_t callback) {
        _cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
        int r;

        assert(link);
        assert(link->manager);
        assert(link->manager->rtnl);
        assert(link->ifindex > 0);
        assert(route->family == AF_INET || route->family == AF_INET6);

        r = sd_rtnl_message_new_route(link->manager->rtnl, &req,
                                      RTM_DELROUTE, route->family,
                                      route->protocol);
        if (r < 0)
                return log_error_errno(r, "Could not create RTM_DELROUTE message: %m");

        if (!in_addr_is_null(route->family, &route->in_addr)) {
                if (route->family == AF_INET)
                        r = sd_netlink_message_append_in_addr(req, RTA_GATEWAY, &route->in_addr.in);
                else if (route->family == AF_INET6)
                        r = sd_netlink_message_append_in6_addr(req, RTA_GATEWAY, &route->in_addr.in6);
                if (r < 0)
                        return log_error_errno(r, "Could not append RTA_GATEWAY attribute: %m");
        }

        if (route->dst_prefixlen) {
                if (route->family == AF_INET)
                        r = sd_netlink_message_append_in_addr(req, RTA_DST, &route->dst_addr.in);
                else if (route->family == AF_INET6)
                        r = sd_netlink_message_append_in6_addr(req, RTA_DST, &route->dst_addr.in6);
                if (r < 0)
                        return log_error_errno(r, "Could not append RTA_DST attribute: %m");

                r = sd_rtnl_message_route_set_dst_prefixlen(req, route->dst_prefixlen);
                if (r < 0)
                        return log_error_errno(r, "Could not set destination prefix length: %m");
        }

        if (route->src_prefixlen) {
                if (route->family == AF_INET)
                        r = sd_netlink_message_append_in_addr(req, RTA_SRC, &route->src_addr.in);
                else if (route->family == AF_INET6)
                        r = sd_netlink_message_append_in6_addr(req, RTA_SRC, &route->src_addr.in6);
                if (r < 0)
                        return log_error_errno(r, "Could not append RTA_DST attribute: %m");

                r = sd_rtnl_message_route_set_src_prefixlen(req, route->src_prefixlen);
                if (r < 0)
                        return log_error_errno(r, "Could not set source prefix length: %m");
        }

        if (!in_addr_is_null(route->family, &route->prefsrc_addr)) {
                if (route->family == AF_INET)
                        r = sd_netlink_message_append_in_addr(req, RTA_PREFSRC, &route->prefsrc_addr.in);
                else if (route->family == AF_INET6)
                        r = sd_netlink_message_append_in6_addr(req, RTA_PREFSRC, &route->prefsrc_addr.in6);
                if (r < 0)
                        return log_error_errno(r, "Could not append RTA_PREFSRC attribute: %m");
        }

        r = sd_rtnl_message_route_set_scope(req, route->scope);
        if (r < 0)
                return log_error_errno(r, "Could not set scope: %m");

        r = sd_netlink_message_append_u32(req, RTA_PRIORITY, route->metrics);
        if (r < 0)
                return log_error_errno(r, "Could not append RTA_PRIORITY attribute: %m");

        r = sd_netlink_message_append_u32(req, RTA_OIF, link->ifindex);
        if (r < 0)
                return log_error_errno(r, "Could not append RTA_OIF attribute: %m");

        r = sd_netlink_call_async(link->manager->rtnl, req, callback, link, 0, NULL);
        if (r < 0)
                return log_error_errno(r, "Could not send rtnetlink message: %m");

        link_ref(link);

        return 0;
}

int route_configure(Route *route, Link *link,
                    sd_netlink_message_handler_t callback) {
        _cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
        int r;

        assert(link);
        assert(link->manager);
        assert(link->manager->rtnl);
        assert(link->ifindex > 0);
        assert(route->family == AF_INET || route->family == AF_INET6);

        r = sd_rtnl_message_new_route(link->manager->rtnl, &req,
                                      RTM_NEWROUTE, route->family,
                                      route->protocol);
        if (r < 0)
                return log_error_errno(r, "Could not create RTM_NEWROUTE message: %m");

        if (!in_addr_is_null(route->family, &route->in_addr)) {
                if (route->family == AF_INET)
                        r = sd_netlink_message_append_in_addr(req, RTA_GATEWAY, &route->in_addr.in);
                else if (route->family == AF_INET6)
                        r = sd_netlink_message_append_in6_addr(req, RTA_GATEWAY, &route->in_addr.in6);
                if (r < 0)
                        return log_error_errno(r, "Could not append RTA_GATEWAY attribute: %m");
        }

        if (route->dst_prefixlen) {
                if (route->family == AF_INET)
                        r = sd_netlink_message_append_in_addr(req, RTA_DST, &route->dst_addr.in);
                else if (route->family == AF_INET6)
                        r = sd_netlink_message_append_in6_addr(req, RTA_DST, &route->dst_addr.in6);
                if (r < 0)
                        return log_error_errno(r, "Could not append RTA_DST attribute: %m");

                r = sd_rtnl_message_route_set_dst_prefixlen(req, route->dst_prefixlen);
                if (r < 0)
                        return log_error_errno(r, "Could not set destination prefix length: %m");
        }

        if (route->src_prefixlen) {
                if (route->family == AF_INET)
                        r = sd_netlink_message_append_in_addr(req, RTA_SRC, &route->src_addr.in);
                else if (route->family == AF_INET6)
                        r = sd_netlink_message_append_in6_addr(req, RTA_SRC, &route->src_addr.in6);
                if (r < 0)
                        return log_error_errno(r, "Could not append RTA_SRC attribute: %m");

                r = sd_rtnl_message_route_set_src_prefixlen(req, route->src_prefixlen);
                if (r < 0)
                        return log_error_errno(r, "Could not set source prefix length: %m");
        }

        if (!in_addr_is_null(route->family, &route->prefsrc_addr)) {
                if (route->family == AF_INET)
                        r = sd_netlink_message_append_in_addr(req, RTA_PREFSRC, &route->prefsrc_addr.in);
                else if (route->family == AF_INET6)
                        r = sd_netlink_message_append_in6_addr(req, RTA_PREFSRC, &route->prefsrc_addr.in6);
                if (r < 0)
                        return log_error_errno(r, "Could not append RTA_PREFSRC attribute: %m");
        }

        r = sd_rtnl_message_route_set_scope(req, route->scope);
        if (r < 0)
                return log_error_errno(r, "Could not set scope: %m");

        r = sd_netlink_message_append_u32(req, RTA_PRIORITY, route->metrics);
        if (r < 0)
                return log_error_errno(r, "Could not append RTA_PRIORITY attribute: %m");

        r = sd_netlink_message_append_u32(req, RTA_OIF, link->ifindex);
        if (r < 0)
                return log_error_errno(r, "Could not append RTA_OIF attribute: %m");

        r = sd_netlink_call_async(link->manager->rtnl, req, callback, link, 0, NULL);
        if (r < 0)
                return log_error_errno(r, "Could not send rtnetlink message: %m");

        link_ref(link);

        return 0;
}

int config_parse_gateway(const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {

        Network *network = userdata;
        _cleanup_route_free_ Route *n = NULL;
        union in_addr_union buffer;
        int r, f;

        assert(filename);
        assert(section);
        assert(lvalue);
        assert(rvalue);
        assert(data);

        if (streq(section, "Network")) {
                /* we are not in an Route section, so treat
                 * this as the special '0' section */
                section_line = 0;
        }

        r = route_new_static(network, section_line, &n);
        if (r < 0)
                return r;

        r = in_addr_from_string_auto(rvalue, &f, &buffer);
        if (r < 0) {
                log_syntax(unit, LOG_ERR, filename, line, EINVAL,
                           "Route is invalid, ignoring assignment: %s", rvalue);
                return 0;
        }

        n->family = f;
        n->in_addr = buffer;
        n = NULL;

        return 0;
}

int config_parse_preferred_src(const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {

        Network *network = userdata;
        _cleanup_route_free_ Route *n = NULL;
        union in_addr_union buffer;
        int r, f;

        assert(filename);
        assert(section);
        assert(lvalue);
        assert(rvalue);
        assert(data);

        r = route_new_static(network, section_line, &n);
        if (r < 0)
                return r;

        r = in_addr_from_string_auto(rvalue, &f, &buffer);
        if (r < 0) {
                log_syntax(unit, LOG_ERR, filename, line, EINVAL,
                           "Preferred source is invalid, ignoring assignment: %s", rvalue);
                return 0;
        }

        n->family = f;
        n->prefsrc_addr = buffer;
        n = NULL;

        return 0;
}

int config_parse_destination(const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {

        Network *network = userdata;
        _cleanup_route_free_ Route *n = NULL;
        const char *address, *e;
        union in_addr_union buffer;
        unsigned char prefixlen;
        int r, f;

        assert(filename);
        assert(section);
        assert(lvalue);
        assert(rvalue);
        assert(data);

        r = route_new_static(network, section_line, &n);
        if (r < 0)
                return r;

        /* Destination|Source=address/prefixlen */

        /* address */
        e = strchr(rvalue, '/');
        if (e)
                address = strndupa(rvalue, e - rvalue);
        else
                address = rvalue;

        r = in_addr_from_string_auto(address, &f, &buffer);
        if (r < 0) {
                log_syntax(unit, LOG_ERR, filename, line, EINVAL,
                           "Destination is invalid, ignoring assignment: %s", address);
                return 0;
        }

        if (f != AF_INET && f != AF_INET6) {
                log_syntax(unit, LOG_ERR, filename, line, EINVAL,
                           "Unknown address family, ignoring assignment: %s", address);
                return 0;
        }

        /* prefixlen */
        if (e) {
                r = safe_atou8(e + 1, &prefixlen);
                if (r < 0) {
                        log_syntax(unit, LOG_ERR, filename, line, EINVAL,
                                   "Route destination prefix length is invalid, ignoring assignment: %s", e + 1);
                        return 0;
                }
        } else {
                switch (f) {
                        case AF_INET:
                                prefixlen = 32;
                                break;
                        case AF_INET6:
                                prefixlen = 128;
                                break;
                }
        }

        n->family = f;
        if (streq(lvalue, "Destination")) {
                n->dst_addr = buffer;
                n->dst_prefixlen = prefixlen;
        } else if (streq(lvalue, "Source")) {
                n->src_addr = buffer;
                n->src_prefixlen = prefixlen;
        } else
                assert_not_reached(lvalue);

        n = NULL;

        return 0;
}

int config_parse_route_priority(const char *unit,
                                const char *filename,
                                unsigned line,
                                const char *section,
                                unsigned section_line,
                                const char *lvalue,
                                int ltype,
                                const char *rvalue,
                                void *data,
                                void *userdata) {
        Network *network = userdata;
        _cleanup_route_free_ Route *n = NULL;
        int r;

        assert(filename);
        assert(section);
        assert(lvalue);
        assert(rvalue);
        assert(data);

        r = route_new_static(network, section_line, &n);
        if (r < 0)
                return r;

        r = config_parse_unsigned(unit, filename, line, section,
                                  section_line, lvalue, ltype,
                                  rvalue, &n->metrics, userdata);
        if (r < 0)
                return r;

        n = NULL;

        return 0;
}

int config_parse_route_scope(const char *unit,
                             const char *filename,
                             unsigned line,
                             const char *section,
                             unsigned section_line,
                             const char *lvalue,
                             int ltype,
                             const char *rvalue,
                             void *data,
                             void *userdata) {
        Network *network = userdata;
        _cleanup_route_free_ Route *n = NULL;
        int r;

        assert(filename);
        assert(section);
        assert(lvalue);
        assert(rvalue);
        assert(data);

        r = route_new_static(network, section_line, &n);
        if (r < 0)
                return r;

        if (streq(rvalue, "host"))
                n->scope = RT_SCOPE_HOST;
        else if (streq(rvalue, "link"))
                n->scope = RT_SCOPE_LINK;
        else if (streq(rvalue, "global"))
                n->scope = RT_SCOPE_UNIVERSE;
        else {
                log_syntax(unit, LOG_ERR, filename, line, EINVAL,
                           "Unknown route scope: %s", rvalue);
                return 0;
        }

        n = NULL;

        return 0;
}
Commit	Line	Data
f579559b TG	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2013 Tom Gundersen <teg@jklm.no>
	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
f579559b TG	22	#include "util.h"
f579559b TG	23	#include "conf-parser.h"
fc2f9534 LP	24	#include "netlink-util.h"
	25
	26	#include "networkd.h"
	27	#include "networkd-route.h"
f579559b	28
f048a16b	29	int route_new_static(Network network, unsigned section, Route *ret) {
f579559b TG	30	_cleanup_route_free_ Route *route = NULL;
f579559b TG	31
6ae115c1	32	if (section) {
16aa63a0 TG	33	route = hashmap_get(network->routes_by_section,
16aa63a0 TG	34	UINT_TO_PTR(section));
6ae115c1 TG	35	if (route) {
	36	*ret = route;
	37	route = NULL;
	38
	39	return 0;
	40	}
	41	}
	42
f579559b TG	43	route = new0(Route, 1);
	44	if (!route)
	45	return -ENOMEM;
	46
801bd9e8	47	route->family = AF_UNSPEC;
5c1d3fc9	48	route->scope = RT_SCOPE_UNIVERSE;
28cc555d	49	route->protocol = RTPROT_STATIC;
801bd9e8	50
f579559b TG	51	route->network = network;
f579559b TG	52
3d3d4255	53	LIST_PREPEND(routes, network->static_routes, route);
f579559b	54
6ae115c1 TG	55	if (section) {
6ae115c1 TG	56	route->section = section;
16aa63a0 TG	57	hashmap_put(network->routes_by_section,
16aa63a0 TG	58	UINT_TO_PTR(route->section), route);
6ae115c1 TG	59	}
6ae115c1 TG	60
f579559b TG	61	*ret = route;
	62	route = NULL;
	63
	64	return 0;
	65	}
	66
28cc555d	67	int route_new_dynamic(Route **ret, unsigned char rtm_protocol) {
f048a16b TG	68	_cleanup_route_free_ Route *route = NULL;
	69
	70	route = new0(Route, 1);
	71	if (!route)
	72	return -ENOMEM;
	73
801bd9e8	74	route->family = AF_UNSPEC;
5c1d3fc9	75	route->scope = RT_SCOPE_UNIVERSE;
28cc555d	76	route->protocol = rtm_protocol;
801bd9e8	77
f048a16b TG	78	*ret = route;
	79	route = NULL;
	80
	81	return 0;
	82	}
	83
f579559b TG	84	void route_free(Route *route) {
	85	if (!route)
	86	return;
	87
f048a16b	88	if (route->network) {
3d3d4255	89	LIST_REMOVE(routes, route->network->static_routes, route);
f579559b	90
f048a16b TG	91	if (route->section)
f048a16b TG	92	hashmap_remove(route->network->routes_by_section,
16aa63a0	93	UINT_TO_PTR(route->section));
f048a16b	94	}
6ae115c1	95
f579559b TG	96	free(route);
	97	}
	98
5c1d3fc9	99	int route_drop(Route route, Link link,
1c4baffc TG	100	sd_netlink_message_handler_t callback) {
1c4baffc TG	101	_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
5c1d3fc9 UTL	102	int r;
	103
	104	assert(link);
	105	assert(link->manager);
	106	assert(link->manager->rtnl);
	107	assert(link->ifindex > 0);
	108	assert(route->family == AF_INET \|\| route->family == AF_INET6);
	109
	110	r = sd_rtnl_message_new_route(link->manager->rtnl, &req,
28cc555d DW	111	RTM_DELROUTE, route->family,
28cc555d DW	112	route->protocol);
f647962d MS	113	if (r < 0)
f647962d MS	114	return log_error_errno(r, "Could not create RTM_DELROUTE message: %m");
5c1d3fc9	115
59580681 GL	116	if (!in_addr_is_null(route->family, &route->in_addr)) {
59580681 GL	117	if (route->family == AF_INET)
1c4baffc	118	r = sd_netlink_message_append_in_addr(req, RTA_GATEWAY, &route->in_addr.in);
59580681	119	else if (route->family == AF_INET6)
1c4baffc	120	r = sd_netlink_message_append_in6_addr(req, RTA_GATEWAY, &route->in_addr.in6);
f647962d MS	121	if (r < 0)
f647962d MS	122	return log_error_errno(r, "Could not append RTA_GATEWAY attribute: %m");
5c1d3fc9 UTL	123	}
	124
	125	if (route->dst_prefixlen) {
	126	if (route->family == AF_INET)
1c4baffc	127	r = sd_netlink_message_append_in_addr(req, RTA_DST, &route->dst_addr.in);
5c1d3fc9	128	else if (route->family == AF_INET6)
1c4baffc	129	r = sd_netlink_message_append_in6_addr(req, RTA_DST, &route->dst_addr.in6);
f647962d MS	130	if (r < 0)
f647962d MS	131	return log_error_errno(r, "Could not append RTA_DST attribute: %m");
5c1d3fc9 UTL	132
5c1d3fc9 UTL	133	r = sd_rtnl_message_route_set_dst_prefixlen(req, route->dst_prefixlen);
f647962d MS	134	if (r < 0)
f647962d MS	135	return log_error_errno(r, "Could not set destination prefix length: %m");
5c1d3fc9 UTL	136	}
5c1d3fc9 UTL	137
9e7e4408 TG	138	if (route->src_prefixlen) {
9e7e4408 TG	139	if (route->family == AF_INET)
1c4baffc	140	r = sd_netlink_message_append_in_addr(req, RTA_SRC, &route->src_addr.in);
9e7e4408	141	else if (route->family == AF_INET6)
1c4baffc	142	r = sd_netlink_message_append_in6_addr(req, RTA_SRC, &route->src_addr.in6);
9e7e4408 TG	143	if (r < 0)
	144	return log_error_errno(r, "Could not append RTA_DST attribute: %m");
	145
	146	r = sd_rtnl_message_route_set_src_prefixlen(req, route->src_prefixlen);
	147	if (r < 0)
	148	return log_error_errno(r, "Could not set source prefix length: %m");
	149	}
	150
46b0c76e ERB	151	if (!in_addr_is_null(route->family, &route->prefsrc_addr)) {
46b0c76e ERB	152	if (route->family == AF_INET)
1c4baffc	153	r = sd_netlink_message_append_in_addr(req, RTA_PREFSRC, &route->prefsrc_addr.in);
46b0c76e	154	else if (route->family == AF_INET6)
1c4baffc	155	r = sd_netlink_message_append_in6_addr(req, RTA_PREFSRC, &route->prefsrc_addr.in6);
f647962d MS	156	if (r < 0)
f647962d MS	157	return log_error_errno(r, "Could not append RTA_PREFSRC attribute: %m");
46b0c76e ERB	158	}
46b0c76e ERB	159
5c1d3fc9	160	r = sd_rtnl_message_route_set_scope(req, route->scope);
f647962d MS	161	if (r < 0)
f647962d MS	162	return log_error_errno(r, "Could not set scope: %m");
5c1d3fc9	163
1c4baffc	164	r = sd_netlink_message_append_u32(req, RTA_PRIORITY, route->metrics);
f647962d MS	165	if (r < 0)
f647962d MS	166	return log_error_errno(r, "Could not append RTA_PRIORITY attribute: %m");
5c1d3fc9	167
1c4baffc	168	r = sd_netlink_message_append_u32(req, RTA_OIF, link->ifindex);
f647962d MS	169	if (r < 0)
f647962d MS	170	return log_error_errno(r, "Could not append RTA_OIF attribute: %m");
5c1d3fc9	171
1c4baffc	172	r = sd_netlink_call_async(link->manager->rtnl, req, callback, link, 0, NULL);
f647962d MS	173	if (r < 0)
f647962d MS	174	return log_error_errno(r, "Could not send rtnetlink message: %m");
5c1d3fc9	175
563c69c6 TG	176	link_ref(link);
563c69c6 TG	177
5c1d3fc9 UTL	178	return 0;
	179	}
	180
f882c247	181	int route_configure(Route route, Link link,
1c4baffc TG	182	sd_netlink_message_handler_t callback) {
1c4baffc TG	183	_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
f579559b TG	184	int r;
f579559b TG	185
f579559b	186	assert(link);
f882c247 TG	187	assert(link->manager);
f882c247 TG	188	assert(link->manager->rtnl);
f579559b TG	189	assert(link->ifindex > 0);
	190	assert(route->family == AF_INET \|\| route->family == AF_INET6);
	191
151b9b96	192	r = sd_rtnl_message_new_route(link->manager->rtnl, &req,
28cc555d DW	193	RTM_NEWROUTE, route->family,
28cc555d DW	194	route->protocol);
f647962d MS	195	if (r < 0)
f647962d MS	196	return log_error_errno(r, "Could not create RTM_NEWROUTE message: %m");
f579559b	197
59580681 GL	198	if (!in_addr_is_null(route->family, &route->in_addr)) {
59580681 GL	199	if (route->family == AF_INET)
1c4baffc	200	r = sd_netlink_message_append_in_addr(req, RTA_GATEWAY, &route->in_addr.in);
59580681	201	else if (route->family == AF_INET6)
1c4baffc	202	r = sd_netlink_message_append_in6_addr(req, RTA_GATEWAY, &route->in_addr.in6);
f647962d MS	203	if (r < 0)
f647962d MS	204	return log_error_errno(r, "Could not append RTA_GATEWAY attribute: %m");
f579559b TG	205	}
f579559b TG	206
0a0dc69b TG	207	if (route->dst_prefixlen) {
0a0dc69b TG	208	if (route->family == AF_INET)
1c4baffc	209	r = sd_netlink_message_append_in_addr(req, RTA_DST, &route->dst_addr.in);
0a0dc69b	210	else if (route->family == AF_INET6)
1c4baffc	211	r = sd_netlink_message_append_in6_addr(req, RTA_DST, &route->dst_addr.in6);
f647962d MS	212	if (r < 0)
f647962d MS	213	return log_error_errno(r, "Could not append RTA_DST attribute: %m");
6ae115c1	214
ae4c67a7	215	r = sd_rtnl_message_route_set_dst_prefixlen(req, route->dst_prefixlen);
f647962d MS	216	if (r < 0)
f647962d MS	217	return log_error_errno(r, "Could not set destination prefix length: %m");
1f01fb4f TG	218	}
1f01fb4f TG	219
9e7e4408 TG	220	if (route->src_prefixlen) {
9e7e4408 TG	221	if (route->family == AF_INET)
1c4baffc	222	r = sd_netlink_message_append_in_addr(req, RTA_SRC, &route->src_addr.in);
9e7e4408	223	else if (route->family == AF_INET6)
1c4baffc	224	r = sd_netlink_message_append_in6_addr(req, RTA_SRC, &route->src_addr.in6);
9e7e4408 TG	225	if (r < 0)
	226	return log_error_errno(r, "Could not append RTA_SRC attribute: %m");
	227
	228	r = sd_rtnl_message_route_set_src_prefixlen(req, route->src_prefixlen);
	229	if (r < 0)
	230	return log_error_errno(r, "Could not set source prefix length: %m");
	231	}
	232
46b0c76e ERB	233	if (!in_addr_is_null(route->family, &route->prefsrc_addr)) {
46b0c76e ERB	234	if (route->family == AF_INET)
1c4baffc	235	r = sd_netlink_message_append_in_addr(req, RTA_PREFSRC, &route->prefsrc_addr.in);
46b0c76e	236	else if (route->family == AF_INET6)
1c4baffc	237	r = sd_netlink_message_append_in6_addr(req, RTA_PREFSRC, &route->prefsrc_addr.in6);
f647962d MS	238	if (r < 0)
f647962d MS	239	return log_error_errno(r, "Could not append RTA_PREFSRC attribute: %m");
46b0c76e ERB	240	}
46b0c76e ERB	241
5c1d3fc9	242	r = sd_rtnl_message_route_set_scope(req, route->scope);
f647962d MS	243	if (r < 0)
f647962d MS	244	return log_error_errno(r, "Could not set scope: %m");
5c1d3fc9	245
1c4baffc	246	r = sd_netlink_message_append_u32(req, RTA_PRIORITY, route->metrics);
f647962d MS	247	if (r < 0)
f647962d MS	248	return log_error_errno(r, "Could not append RTA_PRIORITY attribute: %m");
5c1d3fc9	249
1c4baffc	250	r = sd_netlink_message_append_u32(req, RTA_OIF, link->ifindex);
f647962d MS	251	if (r < 0)
f647962d MS	252	return log_error_errno(r, "Could not append RTA_OIF attribute: %m");
f579559b	253
1c4baffc	254	r = sd_netlink_call_async(link->manager->rtnl, req, callback, link, 0, NULL);
f647962d MS	255	if (r < 0)
f647962d MS	256	return log_error_errno(r, "Could not send rtnetlink message: %m");
f579559b	257
563c69c6 TG	258	link_ref(link);
563c69c6 TG	259
f579559b TG	260	return 0;
	261	}
	262
	263	int config_parse_gateway(const char *unit,
	264	const char *filename,
	265	unsigned line,
	266	const char *section,
71a61510	267	unsigned section_line,
f579559b TG	268	const char *lvalue,
	269	int ltype,
	270	const char *rvalue,
	271	void *data,
	272	void *userdata) {
44e7b949	273
6ae115c1	274	Network *network = userdata;
f579559b	275	_cleanup_route_free_ Route *n = NULL;
44e7b949 LP	276	union in_addr_union buffer;
44e7b949 LP	277	int r, f;
f579559b TG	278
f579559b TG	279	assert(filename);
6ae115c1	280	assert(section);
f579559b TG	281	assert(lvalue);
	282	assert(rvalue);
	283	assert(data);
	284
92fe133a TG	285	if (streq(section, "Network")) {
	286	/* we are not in an Route section, so treat
	287	* this as the special '0' section */
	288	section_line = 0;
	289	}
	290
f048a16b	291	r = route_new_static(network, section_line, &n);
f579559b TG	292	if (r < 0)
	293	return r;
	294
44e7b949	295	r = in_addr_from_string_auto(rvalue, &f, &buffer);
f579559b TG	296	if (r < 0) {
f579559b TG	297	log_syntax(unit, LOG_ERR, filename, line, EINVAL,
44e7b949	298	"Route is invalid, ignoring assignment: %s", rvalue);
f579559b TG	299	return 0;
	300	}
	301
44e7b949 LP	302	n->family = f;
44e7b949 LP	303	n->in_addr = buffer;
f579559b TG	304	n = NULL;
	305
	306	return 0;
	307	}
6ae115c1	308
0d07e595 JK	309	int config_parse_preferred_src(const char *unit,
	310	const char *filename,
	311	unsigned line,
	312	const char *section,
	313	unsigned section_line,
	314	const char *lvalue,
	315	int ltype,
	316	const char *rvalue,
	317	void *data,
	318	void *userdata) {
	319
	320	Network *network = userdata;
	321	_cleanup_route_free_ Route *n = NULL;
	322	union in_addr_union buffer;
	323	int r, f;
	324
	325	assert(filename);
	326	assert(section);
	327	assert(lvalue);
	328	assert(rvalue);
	329	assert(data);
	330
	331	r = route_new_static(network, section_line, &n);
	332	if (r < 0)
	333	return r;
	334
	335	r = in_addr_from_string_auto(rvalue, &f, &buffer);
	336	if (r < 0) {
	337	log_syntax(unit, LOG_ERR, filename, line, EINVAL,
	338	"Preferred source is invalid, ignoring assignment: %s", rvalue);
	339	return 0;
	340	}
	341
	342	n->family = f;
	343	n->prefsrc_addr = buffer;
	344	n = NULL;
	345
	346	return 0;
	347	}
	348
6ae115c1 TG	349	int config_parse_destination(const char *unit,
	350	const char *filename,
	351	unsigned line,
	352	const char *section,
	353	unsigned section_line,
	354	const char *lvalue,
	355	int ltype,
	356	const char *rvalue,
	357	void *data,
	358	void *userdata) {
44e7b949	359
6ae115c1 TG	360	Network *network = userdata;
6ae115c1 TG	361	_cleanup_route_free_ Route *n = NULL;
44e7b949 LP	362	const char address, e;
44e7b949 LP	363	union in_addr_union buffer;
9e7e4408	364	unsigned char prefixlen;
44e7b949	365	int r, f;
6ae115c1 TG	366
	367	assert(filename);
	368	assert(section);
	369	assert(lvalue);
	370	assert(rvalue);
	371	assert(data);
	372
f048a16b	373	r = route_new_static(network, section_line, &n);
6ae115c1 TG	374	if (r < 0)
	375	return r;
	376
9e7e4408	377	/* Destination\|Source=address/prefixlen */
6ae115c1	378
ae4c67a7	379	/* address */
6ae115c1	380	e = strchr(rvalue, '/');
44e7b949 LP	381	if (e)
	382	address = strndupa(rvalue, e - rvalue);
	383	else
	384	address = rvalue;
6ae115c1	385
44e7b949	386	r = in_addr_from_string_auto(address, &f, &buffer);
6ae115c1 TG	387	if (r < 0) {
	388	log_syntax(unit, LOG_ERR, filename, line, EINVAL,
	389	"Destination is invalid, ignoring assignment: %s", address);
	390	return 0;
	391	}
	392
935c0d26 TG	393	if (f != AF_INET && f != AF_INET6) {
	394	log_syntax(unit, LOG_ERR, filename, line, EINVAL,
	395	"Unknown address family, ignoring assignment: %s", address);
	396	return 0;
	397	}
	398
ae4c67a7 TG	399	/* prefixlen */
ae4c67a7 TG	400	if (e) {
9e7e4408	401	r = safe_atou8(e + 1, &prefixlen);
ae4c67a7 TG	402	if (r < 0) {
ae4c67a7 TG	403	log_syntax(unit, LOG_ERR, filename, line, EINVAL,
44e7b949	404	"Route destination prefix length is invalid, ignoring assignment: %s", e + 1);
ae4c67a7 TG	405	return 0;
ae4c67a7 TG	406	}
ae4c67a7	407	} else {
935c0d26	408	switch (f) {
ae4c67a7	409	case AF_INET:
9e7e4408	410	prefixlen = 32;
ae4c67a7 TG	411	break;
ae4c67a7 TG	412	case AF_INET6:
9e7e4408	413	prefixlen = 128;
ae4c67a7 TG	414	break;
	415	}
	416	}
	417
44e7b949	418	n->family = f;
9e7e4408 TG	419	if (streq(lvalue, "Destination")) {
	420	n->dst_addr = buffer;
	421	n->dst_prefixlen = prefixlen;
	422	} else if (streq(lvalue, "Source")) {
	423	n->src_addr = buffer;
	424	n->src_prefixlen = prefixlen;
	425	} else
	426	assert_not_reached(lvalue);
	427
6ae115c1 TG	428	n = NULL;
	429
	430	return 0;
	431	}
5d8e593d SS	432
	433	int config_parse_route_priority(const char *unit,
	434	const char *filename,
	435	unsigned line,
	436	const char *section,
	437	unsigned section_line,
	438	const char *lvalue,
	439	int ltype,
	440	const char *rvalue,
	441	void *data,
	442	void *userdata) {
	443	Network *network = userdata;
	444	_cleanup_route_free_ Route *n = NULL;
5d8e593d SS	445	int r;
	446
	447	assert(filename);
	448	assert(section);
	449	assert(lvalue);
	450	assert(rvalue);
	451	assert(data);
	452
	453	r = route_new_static(network, section_line, &n);
	454	if (r < 0)
	455	return r;
	456
	457	r = config_parse_unsigned(unit, filename, line, section,
	458	section_line, lvalue, ltype,
	459	rvalue, &n->metrics, userdata);
	460	if (r < 0)
	461	return r;
	462
	463	n = NULL;
	464
	465	return 0;
	466	}
769b56a3 TG	467
	468	int config_parse_route_scope(const char *unit,
	469	const char *filename,
	470	unsigned line,
	471	const char *section,
	472	unsigned section_line,
	473	const char *lvalue,
	474	int ltype,
	475	const char *rvalue,
	476	void *data,
	477	void *userdata) {
	478	Network *network = userdata;
	479	_cleanup_route_free_ Route *n = NULL;
	480	int r;
	481
	482	assert(filename);
	483	assert(section);
	484	assert(lvalue);
	485	assert(rvalue);
	486	assert(data);
	487
	488	r = route_new_static(network, section_line, &n);
	489	if (r < 0)
	490	return r;
	491
	492	if (streq(rvalue, "host"))
	493	n->scope = RT_SCOPE_HOST;
	494	else if (streq(rvalue, "link"))
	495	n->scope = RT_SCOPE_LINK;
	496	else if (streq(rvalue, "global"))
	497	n->scope = RT_SCOPE_UNIVERSE;
	498	else {
	499	log_syntax(unit, LOG_ERR, filename, line, EINVAL,
	500	"Unknown route scope: %s", rvalue);
	501	return 0;
	502	}
	503
	504	n = NULL;
	505
	506	return 0;
	507	}