blob: 86ff2711fc957977f179da841a0ffc3b698e75ac [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * IPv4 Forwarding Information Base: FIB frontend.
7 *
8 * Version: $Id: fib_frontend.c,v 1.26 2001/10/31 21:55:54 davem Exp $
9 *
10 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
16 */
17
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/module.h>
19#include <asm/uaccess.h>
20#include <asm/system.h>
21#include <linux/bitops.h>
Randy Dunlap4fc268d2006-01-11 12:17:47 -080022#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/types.h>
24#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/mm.h>
26#include <linux/string.h>
27#include <linux/socket.h>
28#include <linux/sockios.h>
29#include <linux/errno.h>
30#include <linux/in.h>
31#include <linux/inet.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020032#include <linux/inetdevice.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/netdevice.h>
Thomas Graf18237302006-08-04 23:04:54 -070034#include <linux/if_addr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/if_arp.h>
36#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/init.h>
Patrick McHardy1af5a8c2006-08-10 23:10:46 -070038#include <linux/list.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
40#include <net/ip.h>
41#include <net/protocol.h>
42#include <net/route.h>
43#include <net/tcp.h>
44#include <net/sock.h>
45#include <net/icmp.h>
46#include <net/arp.h>
47#include <net/ip_fib.h>
Thomas Graf63f34442007-03-22 11:55:17 -070048#include <net/rtnetlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#ifndef CONFIG_IP_MULTIPLE_TABLES
51
Denis V. Lunev7b1a74f2008-01-10 03:22:17 -080052static int __net_init fib4_rules_init(struct net *net)
Pavel Emelyanovc3e9a352007-11-06 23:34:04 -080053{
Denis V. Lunev93456b62008-01-10 03:23:38 -080054 struct fib_table *local_table, *main_table;
55
Stephen Hemminger7f9b8052008-01-14 23:14:20 -080056 local_table = fib_hash_table(RT_TABLE_LOCAL);
Denis V. Lunev93456b62008-01-10 03:23:38 -080057 if (local_table == NULL)
Denis V. Lunevdbb50162008-01-10 03:21:49 -080058 return -ENOMEM;
59
Stephen Hemminger7f9b8052008-01-14 23:14:20 -080060 main_table = fib_hash_table(RT_TABLE_MAIN);
Denis V. Lunev93456b62008-01-10 03:23:38 -080061 if (main_table == NULL)
Denis V. Lunevdbb50162008-01-10 03:21:49 -080062 goto fail;
63
Denis V. Lunev93456b62008-01-10 03:23:38 -080064 hlist_add_head_rcu(&local_table->tb_hlist,
Denis V. Luneve4aef8a2008-01-10 03:28:24 -080065 &net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX]);
Denis V. Lunev93456b62008-01-10 03:23:38 -080066 hlist_add_head_rcu(&main_table->tb_hlist,
Denis V. Luneve4aef8a2008-01-10 03:28:24 -080067 &net->ipv4.fib_table_hash[TABLE_MAIN_INDEX]);
Denis V. Lunevdbb50162008-01-10 03:21:49 -080068 return 0;
69
70fail:
Denis V. Lunev93456b62008-01-10 03:23:38 -080071 kfree(local_table);
Denis V. Lunevdbb50162008-01-10 03:21:49 -080072 return -ENOMEM;
Pavel Emelyanovc3e9a352007-11-06 23:34:04 -080073}
Linus Torvalds1da177e2005-04-16 15:20:36 -070074#else
75
Denis V. Lunev8ad49422008-01-10 03:24:11 -080076struct fib_table *fib_new_table(struct net *net, u32 id)
Linus Torvalds1da177e2005-04-16 15:20:36 -070077{
78 struct fib_table *tb;
Patrick McHardy1af5a8c2006-08-10 23:10:46 -070079 unsigned int h;
Linus Torvalds1da177e2005-04-16 15:20:36 -070080
Patrick McHardy1af5a8c2006-08-10 23:10:46 -070081 if (id == 0)
82 id = RT_TABLE_MAIN;
Denis V. Lunev8ad49422008-01-10 03:24:11 -080083 tb = fib_get_table(net, id);
Patrick McHardy1af5a8c2006-08-10 23:10:46 -070084 if (tb)
85 return tb;
Stephen Hemminger7f9b8052008-01-14 23:14:20 -080086
87 tb = fib_hash_table(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 if (!tb)
89 return NULL;
Patrick McHardy1af5a8c2006-08-10 23:10:46 -070090 h = id & (FIB_TABLE_HASHSZ - 1);
Denis V. Luneve4aef8a2008-01-10 03:28:24 -080091 hlist_add_head_rcu(&tb->tb_hlist, &net->ipv4.fib_table_hash[h]);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 return tb;
93}
94
Denis V. Lunev8ad49422008-01-10 03:24:11 -080095struct fib_table *fib_get_table(struct net *net, u32 id)
Patrick McHardy1af5a8c2006-08-10 23:10:46 -070096{
97 struct fib_table *tb;
98 struct hlist_node *node;
Denis V. Luneve4aef8a2008-01-10 03:28:24 -080099 struct hlist_head *head;
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700100 unsigned int h;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700102 if (id == 0)
103 id = RT_TABLE_MAIN;
104 h = id & (FIB_TABLE_HASHSZ - 1);
Denis V. Luneve4aef8a2008-01-10 03:28:24 -0800105
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700106 rcu_read_lock();
Denis V. Luneve4aef8a2008-01-10 03:28:24 -0800107 head = &net->ipv4.fib_table_hash[h];
108 hlist_for_each_entry_rcu(tb, node, head, tb_hlist) {
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700109 if (tb->tb_id == id) {
110 rcu_read_unlock();
111 return tb;
112 }
113 }
114 rcu_read_unlock();
115 return NULL;
116}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117#endif /* CONFIG_IP_MULTIPLE_TABLES */
118
Denis V. Lunev010278e2008-01-22 22:04:04 -0800119void fib_select_default(struct net *net,
120 const struct flowi *flp, struct fib_result *res)
Denis V. Lunev64c2d532008-01-22 22:03:33 -0800121{
122 struct fib_table *tb;
123 int table = RT_TABLE_MAIN;
124#ifdef CONFIG_IP_MULTIPLE_TABLES
125 if (res->r == NULL || res->r->action != FR_ACT_TO_TBL)
126 return;
127 table = res->r->table;
128#endif
Denis V. Lunev010278e2008-01-22 22:04:04 -0800129 tb = fib_get_table(net, table);
Denis V. Lunev64c2d532008-01-22 22:03:33 -0800130 if (FIB_RES_GW(*res) && FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK)
131 tb->tb_select_default(tb, flp, res);
132}
133
Denis V. Luneve4aef8a2008-01-10 03:28:24 -0800134static void fib_flush(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135{
136 int flushed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 struct fib_table *tb;
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700138 struct hlist_node *node;
Denis V. Luneve4aef8a2008-01-10 03:28:24 -0800139 struct hlist_head *head;
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700140 unsigned int h;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700142 for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
Denis V. Luneve4aef8a2008-01-10 03:28:24 -0800143 head = &net->ipv4.fib_table_hash[h];
144 hlist_for_each_entry(tb, node, head, tb_hlist)
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700145 flushed += tb->tb_flush(tb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
148 if (flushed)
149 rt_cache_flush(-1);
150}
151
152/*
153 * Find the first device with a given source address.
154 */
155
Denis V. Lunev1ab35272008-01-22 22:04:30 -0800156struct net_device * ip_dev_find(struct net *net, __be32 addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157{
158 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
159 struct fib_result res;
160 struct net_device *dev = NULL;
Pavel Emelyanov03cf7862007-10-23 21:17:27 -0700161 struct fib_table *local_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
163#ifdef CONFIG_IP_MULTIPLE_TABLES
164 res.r = NULL;
165#endif
166
Denis V. Lunev1ab35272008-01-22 22:04:30 -0800167 local_table = fib_get_table(net, RT_TABLE_LOCAL);
Pavel Emelyanov03cf7862007-10-23 21:17:27 -0700168 if (!local_table || local_table->tb_lookup(local_table, &fl, &res))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 return NULL;
170 if (res.type != RTN_LOCAL)
171 goto out;
172 dev = FIB_RES_DEV(res);
173
174 if (dev)
175 dev_hold(dev);
176out:
177 fib_res_put(&res);
178 return dev;
179}
180
Laszlo Attila Toth05538112007-12-04 23:28:46 -0800181/*
182 * Find address type as if only "dev" was present in the system. If
183 * on_dev is NULL then all interfaces are taken into consideration.
184 */
Eric W. Biederman6b175b22008-01-10 03:25:28 -0800185static inline unsigned __inet_dev_addr_type(struct net *net,
186 const struct net_device *dev,
Laszlo Attila Toth05538112007-12-04 23:28:46 -0800187 __be32 addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188{
189 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
190 struct fib_result res;
191 unsigned ret = RTN_BROADCAST;
Pavel Emelyanov03cf7862007-10-23 21:17:27 -0700192 struct fib_table *local_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
Jan Engelhardt1e637c72008-01-21 03:18:08 -0800194 if (ipv4_is_zeronet(addr) || ipv4_is_lbcast(addr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 return RTN_BROADCAST;
Joe Perchesf97c1e02007-12-16 13:45:43 -0800196 if (ipv4_is_multicast(addr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 return RTN_MULTICAST;
198
199#ifdef CONFIG_IP_MULTIPLE_TABLES
200 res.r = NULL;
201#endif
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900202
Eric W. Biederman6b175b22008-01-10 03:25:28 -0800203 local_table = fib_get_table(net, RT_TABLE_LOCAL);
Pavel Emelyanov03cf7862007-10-23 21:17:27 -0700204 if (local_table) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 ret = RTN_UNICAST;
Pavel Emelyanov03cf7862007-10-23 21:17:27 -0700206 if (!local_table->tb_lookup(local_table, &fl, &res)) {
Laszlo Attila Toth05538112007-12-04 23:28:46 -0800207 if (!dev || dev == res.fi->fib_dev)
208 ret = res.type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 fib_res_put(&res);
210 }
211 }
212 return ret;
213}
214
Eric W. Biederman6b175b22008-01-10 03:25:28 -0800215unsigned int inet_addr_type(struct net *net, __be32 addr)
Laszlo Attila Toth05538112007-12-04 23:28:46 -0800216{
Eric W. Biederman6b175b22008-01-10 03:25:28 -0800217 return __inet_dev_addr_type(net, NULL, addr);
Laszlo Attila Toth05538112007-12-04 23:28:46 -0800218}
219
Eric W. Biederman6b175b22008-01-10 03:25:28 -0800220unsigned int inet_dev_addr_type(struct net *net, const struct net_device *dev,
221 __be32 addr)
Laszlo Attila Toth05538112007-12-04 23:28:46 -0800222{
Eric W. Biederman6b175b22008-01-10 03:25:28 -0800223 return __inet_dev_addr_type(net, dev, addr);
Laszlo Attila Toth05538112007-12-04 23:28:46 -0800224}
225
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226/* Given (packet source, input interface) and optional (dst, oif, tos):
227 - (main) check, that source is valid i.e. not broadcast or our local
228 address.
229 - figure out what "logical" interface this packet arrived
230 and calculate "specific destination" address.
231 - check, that packet arrived from expected physical interface.
232 */
233
Al Virod9c9df82006-09-26 21:28:14 -0700234int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif,
235 struct net_device *dev, __be32 *spec_dst, u32 *itag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236{
237 struct in_device *in_dev;
238 struct flowi fl = { .nl_u = { .ip4_u =
239 { .daddr = src,
240 .saddr = dst,
241 .tos = tos } },
242 .iif = oif };
243 struct fib_result res;
244 int no_addr, rpf;
245 int ret;
Denis V. Lunev5b707aa2008-01-21 17:33:15 -0800246 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247
248 no_addr = rpf = 0;
249 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -0700250 in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 if (in_dev) {
252 no_addr = in_dev->ifa_list == NULL;
253 rpf = IN_DEV_RPFILTER(in_dev);
254 }
255 rcu_read_unlock();
256
257 if (in_dev == NULL)
258 goto e_inval;
259
Denis V. Lunev5b707aa2008-01-21 17:33:15 -0800260 net = dev->nd_net;
261 if (fib_lookup(net, &fl, &res))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 goto last_resort;
263 if (res.type != RTN_UNICAST)
264 goto e_inval_res;
265 *spec_dst = FIB_RES_PREFSRC(res);
266 fib_combine_itag(itag, &res);
267#ifdef CONFIG_IP_ROUTE_MULTIPATH
268 if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
269#else
270 if (FIB_RES_DEV(res) == dev)
271#endif
272 {
273 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
274 fib_res_put(&res);
275 return ret;
276 }
277 fib_res_put(&res);
278 if (no_addr)
279 goto last_resort;
280 if (rpf)
281 goto e_inval;
282 fl.oif = dev->ifindex;
283
284 ret = 0;
Denis V. Lunev5b707aa2008-01-21 17:33:15 -0800285 if (fib_lookup(net, &fl, &res) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 if (res.type == RTN_UNICAST) {
287 *spec_dst = FIB_RES_PREFSRC(res);
288 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
289 }
290 fib_res_put(&res);
291 }
292 return ret;
293
294last_resort:
295 if (rpf)
296 goto e_inval;
297 *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
298 *itag = 0;
299 return 0;
300
301e_inval_res:
302 fib_res_put(&res);
303e_inval:
304 return -EINVAL;
305}
306
Al Viro81f7bf62006-09-27 18:40:00 -0700307static inline __be32 sk_extract_addr(struct sockaddr *addr)
Thomas Graf4e902c52006-08-17 18:14:52 -0700308{
309 return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
310}
311
312static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
313{
314 struct nlattr *nla;
315
316 nla = (struct nlattr *) ((char *) mx + len);
317 nla->nla_type = type;
318 nla->nla_len = nla_attr_size(4);
319 *(u32 *) nla_data(nla) = value;
320
321 return len + nla_total_size(4);
322}
323
Denis V. Lunev4b5d47d2008-01-10 03:29:23 -0800324static int rtentry_to_fib_config(struct net *net, int cmd, struct rtentry *rt,
Thomas Graf4e902c52006-08-17 18:14:52 -0700325 struct fib_config *cfg)
326{
Al Viro6d85c102006-09-26 22:15:46 -0700327 __be32 addr;
Thomas Graf4e902c52006-08-17 18:14:52 -0700328 int plen;
329
330 memset(cfg, 0, sizeof(*cfg));
Denis V. Lunev4b5d47d2008-01-10 03:29:23 -0800331 cfg->fc_nlinfo.nl_net = net;
Thomas Graf4e902c52006-08-17 18:14:52 -0700332
333 if (rt->rt_dst.sa_family != AF_INET)
334 return -EAFNOSUPPORT;
335
336 /*
337 * Check mask for validity:
338 * a) it must be contiguous.
339 * b) destination must have all host bits clear.
340 * c) if application forgot to set correct family (AF_INET),
341 * reject request unless it is absolutely clear i.e.
342 * both family and mask are zero.
343 */
344 plen = 32;
345 addr = sk_extract_addr(&rt->rt_dst);
346 if (!(rt->rt_flags & RTF_HOST)) {
Al Viro81f7bf62006-09-27 18:40:00 -0700347 __be32 mask = sk_extract_addr(&rt->rt_genmask);
Thomas Graf4e902c52006-08-17 18:14:52 -0700348
349 if (rt->rt_genmask.sa_family != AF_INET) {
350 if (mask || rt->rt_genmask.sa_family)
351 return -EAFNOSUPPORT;
352 }
353
354 if (bad_mask(mask, addr))
355 return -EINVAL;
356
357 plen = inet_mask_len(mask);
358 }
359
360 cfg->fc_dst_len = plen;
361 cfg->fc_dst = addr;
362
363 if (cmd != SIOCDELRT) {
364 cfg->fc_nlflags = NLM_F_CREATE;
365 cfg->fc_protocol = RTPROT_BOOT;
366 }
367
368 if (rt->rt_metric)
369 cfg->fc_priority = rt->rt_metric - 1;
370
371 if (rt->rt_flags & RTF_REJECT) {
372 cfg->fc_scope = RT_SCOPE_HOST;
373 cfg->fc_type = RTN_UNREACHABLE;
374 return 0;
375 }
376
377 cfg->fc_scope = RT_SCOPE_NOWHERE;
378 cfg->fc_type = RTN_UNICAST;
379
380 if (rt->rt_dev) {
381 char *colon;
382 struct net_device *dev;
383 char devname[IFNAMSIZ];
384
385 if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))
386 return -EFAULT;
387
388 devname[IFNAMSIZ-1] = 0;
389 colon = strchr(devname, ':');
390 if (colon)
391 *colon = 0;
Denis V. Lunev4b5d47d2008-01-10 03:29:23 -0800392 dev = __dev_get_by_name(net, devname);
Thomas Graf4e902c52006-08-17 18:14:52 -0700393 if (!dev)
394 return -ENODEV;
395 cfg->fc_oif = dev->ifindex;
396 if (colon) {
397 struct in_ifaddr *ifa;
398 struct in_device *in_dev = __in_dev_get_rtnl(dev);
399 if (!in_dev)
400 return -ENODEV;
401 *colon = ':';
402 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
403 if (strcmp(ifa->ifa_label, devname) == 0)
404 break;
405 if (ifa == NULL)
406 return -ENODEV;
407 cfg->fc_prefsrc = ifa->ifa_local;
408 }
409 }
410
411 addr = sk_extract_addr(&rt->rt_gateway);
412 if (rt->rt_gateway.sa_family == AF_INET && addr) {
413 cfg->fc_gw = addr;
414 if (rt->rt_flags & RTF_GATEWAY &&
Denis V. Lunev4b5d47d2008-01-10 03:29:23 -0800415 inet_addr_type(net, addr) == RTN_UNICAST)
Thomas Graf4e902c52006-08-17 18:14:52 -0700416 cfg->fc_scope = RT_SCOPE_UNIVERSE;
417 }
418
419 if (cmd == SIOCDELRT)
420 return 0;
421
422 if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw)
423 return -EINVAL;
424
425 if (cfg->fc_scope == RT_SCOPE_NOWHERE)
426 cfg->fc_scope = RT_SCOPE_LINK;
427
428 if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {
429 struct nlattr *mx;
430 int len = 0;
431
432 mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900433 if (mx == NULL)
Thomas Graf4e902c52006-08-17 18:14:52 -0700434 return -ENOMEM;
435
436 if (rt->rt_flags & RTF_MTU)
437 len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);
438
439 if (rt->rt_flags & RTF_WINDOW)
440 len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);
441
442 if (rt->rt_flags & RTF_IRTT)
443 len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);
444
445 cfg->fc_mx = mx;
446 cfg->fc_mx_len = len;
447 }
448
449 return 0;
450}
451
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452/*
453 * Handle IP routing ioctl calls. These are used to manipulate the routing tables
454 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900455
Denis V. Lunev1bad1182008-01-10 03:29:53 -0800456int ip_rt_ioctl(struct net *net, unsigned int cmd, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457{
Thomas Graf4e902c52006-08-17 18:14:52 -0700458 struct fib_config cfg;
459 struct rtentry rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461
462 switch (cmd) {
463 case SIOCADDRT: /* Add a route */
464 case SIOCDELRT: /* Delete a route */
465 if (!capable(CAP_NET_ADMIN))
466 return -EPERM;
Thomas Graf4e902c52006-08-17 18:14:52 -0700467
468 if (copy_from_user(&rt, arg, sizeof(rt)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 return -EFAULT;
Thomas Graf4e902c52006-08-17 18:14:52 -0700470
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 rtnl_lock();
Denis V. Lunev1bad1182008-01-10 03:29:53 -0800472 err = rtentry_to_fib_config(net, cmd, &rt, &cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 if (err == 0) {
Thomas Graf4e902c52006-08-17 18:14:52 -0700474 struct fib_table *tb;
475
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 if (cmd == SIOCDELRT) {
Denis V. Lunev1bad1182008-01-10 03:29:53 -0800477 tb = fib_get_table(net, cfg.fc_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 if (tb)
Thomas Graf4e902c52006-08-17 18:14:52 -0700479 err = tb->tb_delete(tb, &cfg);
480 else
481 err = -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 } else {
Denis V. Lunev1bad1182008-01-10 03:29:53 -0800483 tb = fib_new_table(net, cfg.fc_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 if (tb)
Thomas Graf4e902c52006-08-17 18:14:52 -0700485 err = tb->tb_insert(tb, &cfg);
486 else
487 err = -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 }
Thomas Graf4e902c52006-08-17 18:14:52 -0700489
490 /* allocated by rtentry_to_fib_config() */
491 kfree(cfg.fc_mx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 }
493 rtnl_unlock();
494 return err;
495 }
496 return -EINVAL;
497}
498
Patrick McHardyef7c79e2007-06-05 12:38:30 -0700499const struct nla_policy rtm_ipv4_policy[RTA_MAX+1] = {
Thomas Graf4e902c52006-08-17 18:14:52 -0700500 [RTA_DST] = { .type = NLA_U32 },
501 [RTA_SRC] = { .type = NLA_U32 },
502 [RTA_IIF] = { .type = NLA_U32 },
503 [RTA_OIF] = { .type = NLA_U32 },
504 [RTA_GATEWAY] = { .type = NLA_U32 },
505 [RTA_PRIORITY] = { .type = NLA_U32 },
506 [RTA_PREFSRC] = { .type = NLA_U32 },
507 [RTA_METRICS] = { .type = NLA_NESTED },
Thomas Graf5176f912006-08-26 20:13:18 -0700508 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
Thomas Graf4e902c52006-08-17 18:14:52 -0700509 [RTA_PROTOINFO] = { .type = NLA_U32 },
510 [RTA_FLOW] = { .type = NLA_U32 },
Thomas Graf4e902c52006-08-17 18:14:52 -0700511};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
Denis V. Lunev4b5d47d2008-01-10 03:29:23 -0800513static int rtm_to_fib_config(struct net *net, struct sk_buff *skb,
514 struct nlmsghdr *nlh, struct fib_config *cfg)
Thomas Graf4e902c52006-08-17 18:14:52 -0700515{
516 struct nlattr *attr;
517 int err, remaining;
518 struct rtmsg *rtm;
519
520 err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);
521 if (err < 0)
522 goto errout;
523
524 memset(cfg, 0, sizeof(*cfg));
525
526 rtm = nlmsg_data(nlh);
Thomas Graf4e902c52006-08-17 18:14:52 -0700527 cfg->fc_dst_len = rtm->rtm_dst_len;
Thomas Graf4e902c52006-08-17 18:14:52 -0700528 cfg->fc_tos = rtm->rtm_tos;
529 cfg->fc_table = rtm->rtm_table;
530 cfg->fc_protocol = rtm->rtm_protocol;
531 cfg->fc_scope = rtm->rtm_scope;
532 cfg->fc_type = rtm->rtm_type;
533 cfg->fc_flags = rtm->rtm_flags;
534 cfg->fc_nlflags = nlh->nlmsg_flags;
535
536 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
537 cfg->fc_nlinfo.nlh = nlh;
Denis V. Lunev4b5d47d2008-01-10 03:29:23 -0800538 cfg->fc_nlinfo.nl_net = net;
Thomas Graf4e902c52006-08-17 18:14:52 -0700539
Thomas Grafa0ee18b2007-03-24 20:32:54 -0700540 if (cfg->fc_type > RTN_MAX) {
541 err = -EINVAL;
542 goto errout;
543 }
544
Thomas Graf4e902c52006-08-17 18:14:52 -0700545 nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
Thomas Graf8f4c1f92007-09-12 14:44:36 +0200546 switch (nla_type(attr)) {
Thomas Graf4e902c52006-08-17 18:14:52 -0700547 case RTA_DST:
Al Viro17fb2c62006-09-26 22:15:25 -0700548 cfg->fc_dst = nla_get_be32(attr);
Thomas Graf4e902c52006-08-17 18:14:52 -0700549 break;
Thomas Graf4e902c52006-08-17 18:14:52 -0700550 case RTA_OIF:
551 cfg->fc_oif = nla_get_u32(attr);
552 break;
553 case RTA_GATEWAY:
Al Viro17fb2c62006-09-26 22:15:25 -0700554 cfg->fc_gw = nla_get_be32(attr);
Thomas Graf4e902c52006-08-17 18:14:52 -0700555 break;
556 case RTA_PRIORITY:
557 cfg->fc_priority = nla_get_u32(attr);
558 break;
559 case RTA_PREFSRC:
Al Viro17fb2c62006-09-26 22:15:25 -0700560 cfg->fc_prefsrc = nla_get_be32(attr);
Thomas Graf4e902c52006-08-17 18:14:52 -0700561 break;
562 case RTA_METRICS:
563 cfg->fc_mx = nla_data(attr);
564 cfg->fc_mx_len = nla_len(attr);
565 break;
566 case RTA_MULTIPATH:
567 cfg->fc_mp = nla_data(attr);
568 cfg->fc_mp_len = nla_len(attr);
569 break;
570 case RTA_FLOW:
571 cfg->fc_flow = nla_get_u32(attr);
572 break;
Thomas Graf4e902c52006-08-17 18:14:52 -0700573 case RTA_TABLE:
574 cfg->fc_table = nla_get_u32(attr);
575 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 }
577 }
Thomas Graf4e902c52006-08-17 18:14:52 -0700578
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 return 0;
Thomas Graf4e902c52006-08-17 18:14:52 -0700580errout:
581 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582}
583
Thomas Graf63f34442007-03-22 11:55:17 -0700584static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585{
Denis V. Lunevb8542722007-12-01 00:21:31 +1100586 struct net *net = skb->sk->sk_net;
Thomas Graf4e902c52006-08-17 18:14:52 -0700587 struct fib_config cfg;
588 struct fib_table *tb;
589 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
Denis V. Lunev4b5d47d2008-01-10 03:29:23 -0800591 err = rtm_to_fib_config(net, skb, nlh, &cfg);
Thomas Graf4e902c52006-08-17 18:14:52 -0700592 if (err < 0)
593 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594
Denis V. Lunev8ad49422008-01-10 03:24:11 -0800595 tb = fib_get_table(net, cfg.fc_table);
Thomas Graf4e902c52006-08-17 18:14:52 -0700596 if (tb == NULL) {
597 err = -ESRCH;
598 goto errout;
599 }
600
601 err = tb->tb_delete(tb, &cfg);
602errout:
603 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604}
605
Thomas Graf63f34442007-03-22 11:55:17 -0700606static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607{
Denis V. Lunevb8542722007-12-01 00:21:31 +1100608 struct net *net = skb->sk->sk_net;
Thomas Graf4e902c52006-08-17 18:14:52 -0700609 struct fib_config cfg;
610 struct fib_table *tb;
611 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612
Denis V. Lunev4b5d47d2008-01-10 03:29:23 -0800613 err = rtm_to_fib_config(net, skb, nlh, &cfg);
Thomas Graf4e902c52006-08-17 18:14:52 -0700614 if (err < 0)
615 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
Denis V. Lunev226b0b4a52008-01-10 03:30:24 -0800617 tb = fib_new_table(net, cfg.fc_table);
Thomas Graf4e902c52006-08-17 18:14:52 -0700618 if (tb == NULL) {
619 err = -ENOBUFS;
620 goto errout;
621 }
622
623 err = tb->tb_insert(tb, &cfg);
624errout:
625 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626}
627
Thomas Graf63f34442007-03-22 11:55:17 -0700628static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629{
Denis V. Lunevb8542722007-12-01 00:21:31 +1100630 struct net *net = skb->sk->sk_net;
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700631 unsigned int h, s_h;
632 unsigned int e = 0, s_e;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 struct fib_table *tb;
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700634 struct hlist_node *node;
Denis V. Luneve4aef8a2008-01-10 03:28:24 -0800635 struct hlist_head *head;
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700636 int dumped = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637
Thomas Grafbe403ea2006-08-17 18:15:17 -0700638 if (nlmsg_len(cb->nlh) >= sizeof(struct rtmsg) &&
639 ((struct rtmsg *) nlmsg_data(cb->nlh))->rtm_flags & RTM_F_CLONED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 return ip_rt_dump(skb, cb);
641
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700642 s_h = cb->args[0];
643 s_e = cb->args[1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700645 for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
646 e = 0;
Denis V. Luneve4aef8a2008-01-10 03:28:24 -0800647 head = &net->ipv4.fib_table_hash[h];
648 hlist_for_each_entry(tb, node, head, tb_hlist) {
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700649 if (e < s_e)
650 goto next;
651 if (dumped)
652 memset(&cb->args[2], 0, sizeof(cb->args) -
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900653 2 * sizeof(cb->args[0]));
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700654 if (tb->tb_dump(tb, skb, cb) < 0)
655 goto out;
656 dumped = 1;
657next:
658 e++;
659 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 }
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700661out:
662 cb->args[1] = e;
663 cb->args[0] = h;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
665 return skb->len;
666}
667
668/* Prepare and feed intra-kernel routing request.
669 Really, it should be netlink message, but :-( netlink
670 can be not configured, so that we feed it directly
671 to fib engine. It is legal, because all events occur
672 only when netlink is already locked.
673 */
674
Al Viro81f7bf62006-09-27 18:40:00 -0700675static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676{
Denis V. Lunev4b5d47d2008-01-10 03:29:23 -0800677 struct net *net = ifa->ifa_dev->dev->nd_net;
Thomas Graf4e902c52006-08-17 18:14:52 -0700678 struct fib_table *tb;
679 struct fib_config cfg = {
680 .fc_protocol = RTPROT_KERNEL,
681 .fc_type = type,
682 .fc_dst = dst,
683 .fc_dst_len = dst_len,
684 .fc_prefsrc = ifa->ifa_local,
685 .fc_oif = ifa->ifa_dev->dev->ifindex,
686 .fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,
Denis V. Lunev4d1169c2008-01-10 03:26:13 -0800687 .fc_nlinfo = {
Denis V. Lunev4b5d47d2008-01-10 03:29:23 -0800688 .nl_net = net,
Denis V. Lunev4d1169c2008-01-10 03:26:13 -0800689 },
Thomas Graf4e902c52006-08-17 18:14:52 -0700690 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
692 if (type == RTN_UNICAST)
Denis V. Lunev4b5d47d2008-01-10 03:29:23 -0800693 tb = fib_new_table(net, RT_TABLE_MAIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 else
Denis V. Lunev4b5d47d2008-01-10 03:29:23 -0800695 tb = fib_new_table(net, RT_TABLE_LOCAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
697 if (tb == NULL)
698 return;
699
Thomas Graf4e902c52006-08-17 18:14:52 -0700700 cfg.fc_table = tb->tb_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
Thomas Graf4e902c52006-08-17 18:14:52 -0700702 if (type != RTN_LOCAL)
703 cfg.fc_scope = RT_SCOPE_LINK;
704 else
705 cfg.fc_scope = RT_SCOPE_HOST;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706
707 if (cmd == RTM_NEWROUTE)
Thomas Graf4e902c52006-08-17 18:14:52 -0700708 tb->tb_insert(tb, &cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 else
Thomas Graf4e902c52006-08-17 18:14:52 -0700710 tb->tb_delete(tb, &cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711}
712
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800713void fib_add_ifaddr(struct in_ifaddr *ifa)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714{
715 struct in_device *in_dev = ifa->ifa_dev;
716 struct net_device *dev = in_dev->dev;
717 struct in_ifaddr *prim = ifa;
Al Viroa144ea42006-09-28 18:00:55 -0700718 __be32 mask = ifa->ifa_mask;
719 __be32 addr = ifa->ifa_local;
720 __be32 prefix = ifa->ifa_address&mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
722 if (ifa->ifa_flags&IFA_F_SECONDARY) {
723 prim = inet_ifa_byprefix(in_dev, prefix, mask);
724 if (prim == NULL) {
Stephen Hemmingera6db9012008-01-12 20:58:35 -0800725 printk(KERN_WARNING "fib_add_ifaddr: bug: prim == NULL\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 return;
727 }
728 }
729
730 fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
731
732 if (!(dev->flags&IFF_UP))
733 return;
734
735 /* Add broadcast address, if it is explicitly assigned. */
Al Viroa144ea42006-09-28 18:00:55 -0700736 if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
738
Joe Perchesf97c1e02007-12-16 13:45:43 -0800739 if (!ipv4_is_zeronet(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 (prefix != addr || ifa->ifa_prefixlen < 32)) {
741 fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
742 RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
743
744 /* Add network specific broadcasts, when it takes a sense */
745 if (ifa->ifa_prefixlen < 31) {
746 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
747 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim);
748 }
749 }
750}
751
752static void fib_del_ifaddr(struct in_ifaddr *ifa)
753{
754 struct in_device *in_dev = ifa->ifa_dev;
755 struct net_device *dev = in_dev->dev;
756 struct in_ifaddr *ifa1;
757 struct in_ifaddr *prim = ifa;
Al Viroa144ea42006-09-28 18:00:55 -0700758 __be32 brd = ifa->ifa_address|~ifa->ifa_mask;
759 __be32 any = ifa->ifa_address&ifa->ifa_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760#define LOCAL_OK 1
761#define BRD_OK 2
762#define BRD0_OK 4
763#define BRD1_OK 8
764 unsigned ok = 0;
765
766 if (!(ifa->ifa_flags&IFA_F_SECONDARY))
767 fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
768 RTN_UNICAST, any, ifa->ifa_prefixlen, prim);
769 else {
770 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
771 if (prim == NULL) {
Stephen Hemmingera6db9012008-01-12 20:58:35 -0800772 printk(KERN_WARNING "fib_del_ifaddr: bug: prim == NULL\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 return;
774 }
775 }
776
777 /* Deletion is more complicated than add.
778 We should take care of not to delete too much :-)
779
780 Scan address list to be sure that addresses are really gone.
781 */
782
783 for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
784 if (ifa->ifa_local == ifa1->ifa_local)
785 ok |= LOCAL_OK;
786 if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
787 ok |= BRD_OK;
788 if (brd == ifa1->ifa_broadcast)
789 ok |= BRD1_OK;
790 if (any == ifa1->ifa_broadcast)
791 ok |= BRD0_OK;
792 }
793
794 if (!(ok&BRD_OK))
795 fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
796 if (!(ok&BRD1_OK))
797 fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
798 if (!(ok&BRD0_OK))
799 fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
800 if (!(ok&LOCAL_OK)) {
801 fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
802
803 /* Check, that this local address finally disappeared. */
Denis V. Lunev226b0b4a52008-01-10 03:30:24 -0800804 if (inet_addr_type(dev->nd_net, ifa->ifa_local) != RTN_LOCAL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 /* And the last, but not the least thing.
806 We must flush stray FIB entries.
807
808 First of all, we scan fib_info list searching
809 for stray nexthop entries, then ignite fib_flush.
810 */
Denis V. Lunev4814bdb2008-01-31 18:50:07 -0800811 if (fib_sync_down_addr(dev->nd_net, ifa->ifa_local))
Denis V. Lunev226b0b4a52008-01-10 03:30:24 -0800812 fib_flush(dev->nd_net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 }
814 }
815#undef LOCAL_OK
816#undef BRD_OK
817#undef BRD0_OK
818#undef BRD1_OK
819}
820
Robert Olsson246955f2005-06-20 13:36:39 -0700821static void nl_fib_lookup(struct fib_result_nl *frn, struct fib_table *tb )
822{
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900823
Robert Olsson246955f2005-06-20 13:36:39 -0700824 struct fib_result res;
Thomas Graf5f3008932006-11-09 15:21:41 -0800825 struct flowi fl = { .mark = frn->fl_mark,
Thomas Graf47dcf0c2006-11-09 15:20:38 -0800826 .nl_u = { .ip4_u = { .daddr = frn->fl_addr,
Robert Olsson246955f2005-06-20 13:36:39 -0700827 .tos = frn->fl_tos,
828 .scope = frn->fl_scope } } };
Alexey Kuznetsov1194ed02007-04-25 13:07:28 -0700829
Sergey Vlasov912a41a2007-04-27 02:17:19 -0700830#ifdef CONFIG_IP_MULTIPLE_TABLES
831 res.r = NULL;
832#endif
833
Alexey Kuznetsov1194ed02007-04-25 13:07:28 -0700834 frn->err = -ENOENT;
Robert Olsson246955f2005-06-20 13:36:39 -0700835 if (tb) {
836 local_bh_disable();
837
838 frn->tb_id = tb->tb_id;
839 frn->err = tb->tb_lookup(tb, &fl, &res);
840
841 if (!frn->err) {
842 frn->prefixlen = res.prefixlen;
843 frn->nh_sel = res.nh_sel;
844 frn->type = res.type;
845 frn->scope = res.scope;
Alexey Kuznetsov1194ed02007-04-25 13:07:28 -0700846 fib_res_put(&res);
Robert Olsson246955f2005-06-20 13:36:39 -0700847 }
848 local_bh_enable();
849 }
850}
851
David S. Miller28f7b0362007-10-10 21:32:39 -0700852static void nl_fib_input(struct sk_buff *skb)
Robert Olsson246955f2005-06-20 13:36:39 -0700853{
Denis V. Lunev6bd48fc2008-01-10 03:28:55 -0800854 struct net *net;
Robert Olsson246955f2005-06-20 13:36:39 -0700855 struct fib_result_nl *frn;
David S. Miller28f7b0362007-10-10 21:32:39 -0700856 struct nlmsghdr *nlh;
Robert Olsson246955f2005-06-20 13:36:39 -0700857 struct fib_table *tb;
David S. Miller28f7b0362007-10-10 21:32:39 -0700858 u32 pid;
Alexey Kuznetsov1194ed02007-04-25 13:07:28 -0700859
Denis V. Lunev6bd48fc2008-01-10 03:28:55 -0800860 net = skb->sk->sk_net;
Arnaldo Carvalho de Melob529ccf2007-04-25 19:08:35 -0700861 nlh = nlmsg_hdr(skb);
Thomas Grafea865752005-12-01 14:30:00 -0800862 if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len ||
Denis V. Lunevd883a032007-12-21 02:01:53 -0800863 nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn)))
Thomas Grafea865752005-12-01 14:30:00 -0800864 return;
Denis V. Lunevd883a032007-12-21 02:01:53 -0800865
866 skb = skb_clone(skb, GFP_KERNEL);
867 if (skb == NULL)
868 return;
869 nlh = nlmsg_hdr(skb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900870
Robert Olsson246955f2005-06-20 13:36:39 -0700871 frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
Denis V. Lunev6bd48fc2008-01-10 03:28:55 -0800872 tb = fib_get_table(net, frn->tb_id_in);
Robert Olsson246955f2005-06-20 13:36:39 -0700873
874 nl_fib_lookup(frn, tb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900875
Alexey Kuznetsov1194ed02007-04-25 13:07:28 -0700876 pid = NETLINK_CB(skb).pid; /* pid of sending process */
Robert Olsson246955f2005-06-20 13:36:39 -0700877 NETLINK_CB(skb).pid = 0; /* from kernel */
Patrick McHardyac6d4392005-08-14 19:29:52 -0700878 NETLINK_CB(skb).dst_group = 0; /* unicast */
Denis V. Lunev6bd48fc2008-01-10 03:28:55 -0800879 netlink_unicast(net->ipv4.fibnl, skb, pid, MSG_DONTWAIT);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900880}
Robert Olsson246955f2005-06-20 13:36:39 -0700881
Denis V. Lunev7b1a74f2008-01-10 03:22:17 -0800882static int nl_fib_lookup_init(struct net *net)
Robert Olsson246955f2005-06-20 13:36:39 -0700883{
Denis V. Lunev6bd48fc2008-01-10 03:28:55 -0800884 struct sock *sk;
885 sk = netlink_kernel_create(net, NETLINK_FIB_LOOKUP, 0,
886 nl_fib_input, NULL, THIS_MODULE);
887 if (sk == NULL)
Denis V. Lunev7b1a74f2008-01-10 03:22:17 -0800888 return -EAFNOSUPPORT;
Denis V. Lunev6bd48fc2008-01-10 03:28:55 -0800889 net->ipv4.fibnl = sk;
Denis V. Lunev7b1a74f2008-01-10 03:22:17 -0800890 return 0;
891}
892
893static void nl_fib_lookup_exit(struct net *net)
894{
Denis V. Lunevb7c6ba62008-01-28 14:41:19 -0800895 netlink_kernel_release(net->ipv4.fibnl);
Denis V. Lunev775516b2008-01-18 23:55:19 -0800896 net->ipv4.fibnl = NULL;
Robert Olsson246955f2005-06-20 13:36:39 -0700897}
898
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899static void fib_disable_ip(struct net_device *dev, int force)
900{
Denis V. Lunev85326fa2008-01-31 18:48:47 -0800901 if (fib_sync_down_dev(dev, force))
Denis V. Lunev226b0b4a52008-01-10 03:30:24 -0800902 fib_flush(dev->nd_net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 rt_cache_flush(0);
904 arp_ifdown(dev);
905}
906
907static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
908{
909 struct in_ifaddr *ifa = (struct in_ifaddr*)ptr;
910
911 switch (event) {
912 case NETDEV_UP:
913 fib_add_ifaddr(ifa);
914#ifdef CONFIG_IP_ROUTE_MULTIPATH
915 fib_sync_up(ifa->ifa_dev->dev);
916#endif
917 rt_cache_flush(-1);
918 break;
919 case NETDEV_DOWN:
920 fib_del_ifaddr(ifa);
Jayachandran C9fcc2e82005-10-27 15:10:01 -0700921 if (ifa->ifa_dev->ifa_list == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 /* Last address was deleted from this interface.
923 Disable IP.
924 */
925 fib_disable_ip(ifa->ifa_dev->dev, 1);
926 } else {
927 rt_cache_flush(-1);
928 }
929 break;
930 }
931 return NOTIFY_DONE;
932}
933
934static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
935{
936 struct net_device *dev = ptr;
Herbert Xue5ed6392005-10-03 14:35:55 -0700937 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938
939 if (event == NETDEV_UNREGISTER) {
940 fib_disable_ip(dev, 2);
941 return NOTIFY_DONE;
942 }
943
944 if (!in_dev)
945 return NOTIFY_DONE;
946
947 switch (event) {
948 case NETDEV_UP:
949 for_ifa(in_dev) {
950 fib_add_ifaddr(ifa);
951 } endfor_ifa(in_dev);
952#ifdef CONFIG_IP_ROUTE_MULTIPATH
953 fib_sync_up(dev);
954#endif
955 rt_cache_flush(-1);
956 break;
957 case NETDEV_DOWN:
958 fib_disable_ip(dev, 0);
959 break;
960 case NETDEV_CHANGEMTU:
961 case NETDEV_CHANGE:
962 rt_cache_flush(0);
963 break;
964 }
965 return NOTIFY_DONE;
966}
967
968static struct notifier_block fib_inetaddr_notifier = {
969 .notifier_call =fib_inetaddr_event,
970};
971
972static struct notifier_block fib_netdev_notifier = {
973 .notifier_call =fib_netdev_event,
974};
975
Denis V. Lunev7b1a74f2008-01-10 03:22:17 -0800976static int __net_init ip_fib_net_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977{
Denis V. Lunevdce5cbe2008-01-31 18:44:53 -0800978 int err;
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700979 unsigned int i;
980
Denis V. Luneve4aef8a2008-01-10 03:28:24 -0800981 net->ipv4.fib_table_hash = kzalloc(
982 sizeof(struct hlist_head)*FIB_TABLE_HASHSZ, GFP_KERNEL);
983 if (net->ipv4.fib_table_hash == NULL)
984 return -ENOMEM;
985
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700986 for (i = 0; i < FIB_TABLE_HASHSZ; i++)
Denis V. Luneve4aef8a2008-01-10 03:28:24 -0800987 INIT_HLIST_HEAD(&net->ipv4.fib_table_hash[i]);
Pavel Emelyanovc3e9a352007-11-06 23:34:04 -0800988
Denis V. Lunevdce5cbe2008-01-31 18:44:53 -0800989 err = fib4_rules_init(net);
990 if (err < 0)
991 goto fail;
992 return 0;
993
994fail:
995 kfree(net->ipv4.fib_table_hash);
996 return err;
Denis V. Lunev7b1a74f2008-01-10 03:22:17 -0800997}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998
Denis V. Lunev7b1a74f2008-01-10 03:22:17 -0800999static void __net_exit ip_fib_net_exit(struct net *net)
1000{
1001 unsigned int i;
Thomas Graf63f34442007-03-22 11:55:17 -07001002
Denis V. Lunev7b1a74f2008-01-10 03:22:17 -08001003#ifdef CONFIG_IP_MULTIPLE_TABLES
1004 fib4_rules_exit(net);
1005#endif
1006
1007 for (i = 0; i < FIB_TABLE_HASHSZ; i++) {
1008 struct fib_table *tb;
1009 struct hlist_head *head;
1010 struct hlist_node *node, *tmp;
1011
Denis V. Luneve4aef8a2008-01-10 03:28:24 -08001012 head = &net->ipv4.fib_table_hash[i];
Denis V. Lunev7b1a74f2008-01-10 03:22:17 -08001013 hlist_for_each_entry_safe(tb, node, tmp, head, tb_hlist) {
1014 hlist_del(node);
1015 tb->tb_flush(tb);
1016 kfree(tb);
1017 }
1018 }
Denis V. Luneve4aef8a2008-01-10 03:28:24 -08001019 kfree(net->ipv4.fib_table_hash);
Denis V. Lunev7b1a74f2008-01-10 03:22:17 -08001020}
1021
1022static int __net_init fib_net_init(struct net *net)
1023{
1024 int error;
1025
Denis V. Lunev7b1a74f2008-01-10 03:22:17 -08001026 error = ip_fib_net_init(net);
1027 if (error < 0)
1028 goto out;
1029 error = nl_fib_lookup_init(net);
1030 if (error < 0)
1031 goto out_nlfl;
1032 error = fib_proc_init(net);
1033 if (error < 0)
1034 goto out_proc;
1035out:
1036 return error;
1037
1038out_proc:
1039 nl_fib_lookup_exit(net);
1040out_nlfl:
1041 ip_fib_net_exit(net);
1042 goto out;
1043}
1044
1045static void __net_exit fib_net_exit(struct net *net)
1046{
1047 fib_proc_exit(net);
1048 nl_fib_lookup_exit(net);
1049 ip_fib_net_exit(net);
1050}
1051
1052static struct pernet_operations fib_net_ops = {
1053 .init = fib_net_init,
1054 .exit = fib_net_exit,
1055};
1056
1057void __init ip_fib_init(void)
1058{
Thomas Graf63f34442007-03-22 11:55:17 -07001059 rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL);
1060 rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL);
1061 rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib);
Denis V. Lunev7b1a74f2008-01-10 03:22:17 -08001062
1063 register_pernet_subsys(&fib_net_ops);
1064 register_netdevice_notifier(&fib_netdev_notifier);
1065 register_inetaddr_notifier(&fib_inetaddr_notifier);
Stephen Hemminger7f9b8052008-01-14 23:14:20 -08001066
1067 fib_hash_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068}
1069
1070EXPORT_SYMBOL(inet_addr_type);
Laszlo Attila Toth05538112007-12-04 23:28:46 -08001071EXPORT_SYMBOL(inet_dev_addr_type);
Sean Heftya1e87332006-06-17 20:37:28 -07001072EXPORT_SYMBOL(ip_dev_find);