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

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

/***
  This file is part of systemd.

  Copyright (C) 2014 Intel Corporation. All rights reserved.

  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 <ctype.h>
#include <net/if.h>
#include <net/ethernet.h>

#include "networkd.h"
#include "networkd-netdev.h"
#include "networkd-link.h"
#include "network-internal.h"
#include "path-util.h"
#include "conf-files.h"
#include "conf-parser.h"
#include "util.h"

/* create a new FDB entry or get an existing one. */
int fdb_entry_new_static(Network *const network,
                         const unsigned section,
                         FdbEntry **ret) {
        _cleanup_fdbentry_free_ FdbEntry *fdb_entry = NULL;
        struct ether_addr *mac_addr = NULL;

        assert(network);

        /* search entry in hashmap first. */
        if(section) {
                fdb_entry = hashmap_get(network->fdb_entries_by_section, UINT_TO_PTR(section));
                if (fdb_entry) {
                        *ret = fdb_entry;
                        fdb_entry = NULL;

                        return 0;
                }
        }

        /* allocate space for MAC address. */
        mac_addr = new0(struct ether_addr, 1);
        if (!mac_addr)
                return -ENOMEM;

        /* allocate space for and FDB entry. */
        fdb_entry = new0(FdbEntry, 1);

        if (!fdb_entry) {
                /* free previously allocated space for mac_addr. */
                free(mac_addr);
                return -ENOMEM;
        }

        /* init FDB structure. */
        fdb_entry->network = network;
        fdb_entry->mac_addr = mac_addr;

        LIST_PREPEND(static_fdb_entries, network->static_fdb_entries, fdb_entry);

        if (section) {
                fdb_entry->section = section;
                hashmap_put(network->fdb_entries_by_section,
                            UINT_TO_PTR(fdb_entry->section), fdb_entry);
        }

        /* return allocated FDB structure. */
        *ret = fdb_entry;
        fdb_entry = NULL;

        return 0;
}

static int set_fdb_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
        _cleanup_fdbentry_free_ FdbEntry *fdb_entry = userdata;
        int r;

        assert(fdb_entry);

        r = sd_rtnl_message_get_errno(m);
        if ((r < 0) && (r != (-EEXIST)))
                log_error("Could not add FDB entry for interface: %s error: %s",
                          fdb_entry->network->match_name, strerror(-r));

        return 1;
}

/* send a request to the kernel to add a FDB entry in its static MAC table. */
int fdb_entry_configure(sd_rtnl *const rtnl,
                        FdbEntry *const fdb_entry,
                        const int ifindex) {
        _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
        int r;

        assert(fdb_entry);
        assert(rtnl);

        /* create new RTM message */
        r = sd_rtnl_message_new_neigh(rtnl, &req, RTM_NEWNEIGH, ifindex, PF_BRIDGE);
        if (r < 0)
                return rtnl_log_create_error(r);

        /* only NTF_SELF flag supported. */
        r = sd_rtnl_message_neigh_set_flags(req, NTF_SELF);
        if (r < 0)
                return rtnl_log_create_error(r);

        /* only NUD_PERMANENT state supported. */
        r = sd_rtnl_message_neigh_set_state(req, NUD_NOARP | NUD_PERMANENT);
        if (r < 0)
                return rtnl_log_create_error(r);

        r = sd_rtnl_message_append_ether_addr(req, NDA_LLADDR, fdb_entry->mac_addr);
        if (r < 0)
                return rtnl_log_create_error(r);

        /* VLAN Id is optional. We'll add VLAN Id only if it's specified. */
        if (0 != fdb_entry->vlan_id) {
                r = sd_rtnl_message_append_u16(req, NDA_VLAN, fdb_entry->vlan_id);
                if (r < 0)
                        return rtnl_log_create_error(r);
        }

        /* send message to the kernel to update its internal static MAC table. */
        r = sd_rtnl_call_async(rtnl, req, set_fdb_handler, fdb_entry, 0, NULL);
        if (r < 0) {
                log_error("Could not send rtnetlink message: %s", strerror(-r));
                return r;
        }

        return 0;
}

/* remove and FDB entry. */
void fdb_entry_free(FdbEntry *fdb_entry) {
        if(!fdb_entry)
                return;

        if(fdb_entry->network) {
                LIST_REMOVE(static_fdb_entries, fdb_entry->network->static_fdb_entries,
                            fdb_entry);

                if(fdb_entry->section)
                    hashmap_remove(fdb_entry->network->fdb_entries_by_section,
                                   UINT_TO_PTR(fdb_entry->section));
        }

        free(fdb_entry->mac_addr);

        free(fdb_entry);
}

/* parse the HW address from config files. */
int config_parse_fdb_hwaddr(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_fdbentry_free_ FdbEntry *fdb_entry = NULL;
        int r;

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

        r = fdb_entry_new_static(network, section_line, &fdb_entry);
        if (r < 0) {
                log_error("Failed to allocate a new FDB entry: %s", strerror(-r));
                return r;
        }

        /* read in the MAC address for the FDB table. */
        r = sscanf(rvalue, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
                   &fdb_entry->mac_addr->ether_addr_octet[0],
                   &fdb_entry->mac_addr->ether_addr_octet[1],
                   &fdb_entry->mac_addr->ether_addr_octet[2],
                   &fdb_entry->mac_addr->ether_addr_octet[3],
                   &fdb_entry->mac_addr->ether_addr_octet[4],
                   &fdb_entry->mac_addr->ether_addr_octet[5]);

        if (ETHER_ADDR_LEN !=  r) {
                log_syntax(unit, LOG_ERR, filename, line, EINVAL,
                           "Not a valid MAC address, ignoring assignment: %s", rvalue);
                return 0;
        }

        fdb_entry = NULL;

        return 0;
}

/* parse the VLAN Id from config files. */
int config_parse_fdb_vlan_id(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_fdbentry_free_ FdbEntry *fdb_entry = NULL;
        int r;

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

        r = fdb_entry_new_static(network, section_line, &fdb_entry);
        if (r < 0) {
                log_error("Failed to allocate a new FDB entry: %s", strerror(-r));
                return r;
        }

        r = config_parse_unsigned(unit, filename, line, section,
                                  section_line, lvalue, ltype,
                                  rvalue, &fdb_entry->vlan_id, userdata);
        if (r < 0) {
                log_error("Failed to parse the unsigned integer: %s", strerror(-r));
                return r;
        }

        fdb_entry = NULL;

        return 0;
}
Commit	Line	Data
b98b483b AR	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright (C) 2014 Intel Corporation. All rights reserved.
	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 <ctype.h>
	23	#include <net/if.h>
	24	#include <net/ethernet.h>
	25
	26	#include "networkd.h"
	27	#include "networkd-netdev.h"
	28	#include "networkd-link.h"
	29	#include "network-internal.h"
	30	#include "path-util.h"
	31	#include "conf-files.h"
	32	#include "conf-parser.h"
	33	#include "util.h"
	34
	35	/* create a new FDB entry or get an existing one. */
	36	int fdb_entry_new_static(Network *const network,
	37	const unsigned section,
	38	FdbEntry **ret) {
	39	_cleanup_fdbentry_free_ FdbEntry *fdb_entry = NULL;
	40	struct ether_addr *mac_addr = NULL;
	41
	42	assert(network);
	43
	44	/* search entry in hashmap first. */
	45	if(section) {
	46	fdb_entry = hashmap_get(network->fdb_entries_by_section, UINT_TO_PTR(section));
	47	if (fdb_entry) {
	48	*ret = fdb_entry;
	49	fdb_entry = NULL;
	50
	51	return 0;
	52	}
	53	}
	54
	55	/* allocate space for MAC address. */
	56	mac_addr = new0(struct ether_addr, 1);
	57	if (!mac_addr)
	58	return -ENOMEM;
	59
	60	/* allocate space for and FDB entry. */
	61	fdb_entry = new0(FdbEntry, 1);
	62
	63	if (!fdb_entry) {
	64	/* free previously allocated space for mac_addr. */
65	free(mac_addr);
66	return -ENOMEM;
67	}
68
69	/* init FDB structure. */
70	fdb_entry->network = network;
71	fdb_entry->mac_addr = mac_addr;
72
73	LIST_PREPEND(static_fdb_entries, network->static_fdb_entries, fdb_entry);
74
75	if (section) {
76	fdb_entry->section = section;
77	hashmap_put(network->fdb_entries_by_section,
78	UINT_TO_PTR(fdb_entry->section), fdb_entry);
79	}
80
81	/* return allocated FDB structure. */
82	*ret = fdb_entry;
83	fdb_entry = NULL;
84
85	return 0;
86	}
87
88	static int set_fdb_handler(sd_rtnl rtnl, sd_rtnl_message m, void *userdata) {
89	_cleanup_fdbentry_free_ FdbEntry *fdb_entry = userdata;
90	int r;
91
92	assert(fdb_entry);
93
94	r = sd_rtnl_message_get_errno(m);
95	if ((r < 0) && (r != (-EEXIST)))
96	log_error("Could not add FDB entry for interface: %s error: %s",
97	fdb_entry->network->match_name, strerror(-r));
98
99	return 1;
100	}
101
102	/* send a request to the kernel to add a FDB entry in its static MAC table. */
103	int fdb_entry_configure(sd_rtnl *const rtnl,
104	FdbEntry *const fdb_entry,
105	const int ifindex) {
106	_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
107	int r;
108
109	assert(fdb_entry);
110	assert(rtnl);
111
112	/* create new RTM message */
113	r = sd_rtnl_message_new_neigh(rtnl, &req, RTM_NEWNEIGH, ifindex, PF_BRIDGE);
114	if (r < 0)
115	return rtnl_log_create_error(r);
116
117	/* only NTF_SELF flag supported. */
118	r = sd_rtnl_message_neigh_set_flags(req, NTF_SELF);
119	if (r < 0)
120	return rtnl_log_create_error(r);
121
122	/* only NUD_PERMANENT state supported. */
123	r = sd_rtnl_message_neigh_set_state(req, NUD_NOARP \| NUD_PERMANENT);
124	if (r < 0)
125	return rtnl_log_create_error(r);
126
127	r = sd_rtnl_message_append_ether_addr(req, NDA_LLADDR, fdb_entry->mac_addr);
128	if (r < 0)
129	return rtnl_log_create_error(r);
130
131	/* VLAN Id is optional. We'll add VLAN Id only if it's specified. */
132	if (0 != fdb_entry->vlan_id) {
133	r = sd_rtnl_message_append_u16(req, NDA_VLAN, fdb_entry->vlan_id);
134	if (r < 0)
135	return rtnl_log_create_error(r);
136	}
137
138	/* send message to the kernel to update its internal static MAC table. */
139	r = sd_rtnl_call_async(rtnl, req, set_fdb_handler, fdb_entry, 0, NULL);
140	if (r < 0) {
141	log_error("Could not send rtnetlink message: %s", strerror(-r));
142	return r;
143	}
144
145	return 0;
146	}
147
148	/* remove and FDB entry. */
149	void fdb_entry_free(FdbEntry *fdb_entry) {
150	if(!fdb_entry)
151	return;
152
153	if(fdb_entry->network) {
154	LIST_REMOVE(static_fdb_entries, fdb_entry->network->static_fdb_entries,
155	fdb_entry);
156
157	if(fdb_entry->section)
158	hashmap_remove(fdb_entry->network->fdb_entries_by_section,
159	UINT_TO_PTR(fdb_entry->section));
160	}
161
162	free(fdb_entry->mac_addr);
163
164	free(fdb_entry);
165	}
166
167	/* parse the HW address from config files. */
168	int config_parse_fdb_hwaddr(const char *unit,
169	const char *filename,
170	unsigned line,
171	const char *section,
172	unsigned section_line,
173	const char *lvalue,
174	int ltype,
175	const char *rvalue,
176	void *data,
177	void *userdata) {
178	Network *network = userdata;
179	_cleanup_fdbentry_free_ FdbEntry *fdb_entry = NULL;
180	int r;
181
182	assert(filename);
183	assert(section);
184	assert(lvalue);
185	assert(rvalue);
186	assert(data);
187
188	r = fdb_entry_new_static(network, section_line, &fdb_entry);
189	if (r < 0) {
190	log_error("Failed to allocate a new FDB entry: %s", strerror(-r));
191	return r;
192	}
193
194	/* read in the MAC address for the FDB table. */
195	r = sscanf(rvalue, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
196	&fdb_entry->mac_addr->ether_addr_octet[0],
197	&fdb_entry->mac_addr->ether_addr_octet[1],
198	&fdb_entry->mac_addr->ether_addr_octet[2],
199	&fdb_entry->mac_addr->ether_addr_octet[3],
200	&fdb_entry->mac_addr->ether_addr_octet[4],
201	&fdb_entry->mac_addr->ether_addr_octet[5]);
202
203	if (ETHER_ADDR_LEN != r) {
204	log_syntax(unit, LOG_ERR, filename, line, EINVAL,
205	"Not a valid MAC address, ignoring assignment: %s", rvalue);
206	return 0;
207	}
208
209	fdb_entry = NULL;
210
211	return 0;
212	}
213
214	/* parse the VLAN Id from config files. */
215	int config_parse_fdb_vlan_id(const char *unit,
216	const char *filename,
217	unsigned line,
218	const char *section,
219	unsigned section_line,
220	const char *lvalue,
221	int ltype,
222	const char *rvalue,
223	void *data,
224	void *userdata) {
225	Network *network = userdata;
226	_cleanup_fdbentry_free_ FdbEntry *fdb_entry = NULL;
227	int r;
228
229	assert(filename);
230	assert(section);
231	assert(lvalue);
232	assert(rvalue);
233	assert(data);
234
235	r = fdb_entry_new_static(network, section_line, &fdb_entry);
236	if (r < 0) {
237	log_error("Failed to allocate a new FDB entry: %s", strerror(-r));
238	return r;
239	}
240
241	r = config_parse_unsigned(unit, filename, line, section,
242	section_line, lvalue, ltype,
243	rvalue, &fdb_entry->vlan_id, userdata);
244	if (r < 0) {
245	log_error("Failed to parse the unsigned integer: %s", strerror(-r));
246	return r;
247	}
248
249	fdb_entry = NULL;
250
251	return 0;
252	}