blob: 97abf934d1852931d36a18f8027d1597fa66e135 [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
50#define FFprint(a...) printk(KERN_DEBUG a)
51
David S. Miller28f7b0362007-10-10 21:32:39 -070052static struct sock *fibnl;
53
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#ifndef CONFIG_IP_MULTIPLE_TABLES
55
Linus Torvalds1da177e2005-04-16 15:20:36 -070056struct fib_table *ip_fib_local_table;
57struct fib_table *ip_fib_main_table;
58
Patrick McHardy1af5a8c2006-08-10 23:10:46 -070059#define FIB_TABLE_HASHSZ 1
60static struct hlist_head fib_table_hash[FIB_TABLE_HASHSZ];
61
Pavel Emelyanovc3e9a352007-11-06 23:34:04 -080062static void __init fib4_rules_init(void)
63{
64 ip_fib_local_table = fib_hash_init(RT_TABLE_LOCAL);
65 hlist_add_head_rcu(&ip_fib_local_table->tb_hlist, &fib_table_hash[0]);
66 ip_fib_main_table = fib_hash_init(RT_TABLE_MAIN);
67 hlist_add_head_rcu(&ip_fib_main_table->tb_hlist, &fib_table_hash[0]);
68}
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#else
70
Patrick McHardy1af5a8c2006-08-10 23:10:46 -070071#define FIB_TABLE_HASHSZ 256
72static struct hlist_head fib_table_hash[FIB_TABLE_HASHSZ];
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
Patrick McHardy1af5a8c2006-08-10 23:10:46 -070074struct fib_table *fib_new_table(u32 id)
Linus Torvalds1da177e2005-04-16 15:20:36 -070075{
76 struct fib_table *tb;
Patrick McHardy1af5a8c2006-08-10 23:10:46 -070077 unsigned int h;
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
Patrick McHardy1af5a8c2006-08-10 23:10:46 -070079 if (id == 0)
80 id = RT_TABLE_MAIN;
81 tb = fib_get_table(id);
82 if (tb)
83 return tb;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 tb = fib_hash_init(id);
85 if (!tb)
86 return NULL;
Patrick McHardy1af5a8c2006-08-10 23:10:46 -070087 h = id & (FIB_TABLE_HASHSZ - 1);
88 hlist_add_head_rcu(&tb->tb_hlist, &fib_table_hash[h]);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 return tb;
90}
91
Patrick McHardy1af5a8c2006-08-10 23:10:46 -070092struct fib_table *fib_get_table(u32 id)
93{
94 struct fib_table *tb;
95 struct hlist_node *node;
96 unsigned int h;
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
Patrick McHardy1af5a8c2006-08-10 23:10:46 -070098 if (id == 0)
99 id = RT_TABLE_MAIN;
100 h = id & (FIB_TABLE_HASHSZ - 1);
101 rcu_read_lock();
102 hlist_for_each_entry_rcu(tb, node, &fib_table_hash[h], tb_hlist) {
103 if (tb->tb_id == id) {
104 rcu_read_unlock();
105 return tb;
106 }
107 }
108 rcu_read_unlock();
109 return NULL;
110}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111#endif /* CONFIG_IP_MULTIPLE_TABLES */
112
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113static void fib_flush(void)
114{
115 int flushed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 struct fib_table *tb;
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700117 struct hlist_node *node;
118 unsigned int h;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700120 for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
121 hlist_for_each_entry(tb, node, &fib_table_hash[h], tb_hlist)
122 flushed += tb->tb_flush(tb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124
125 if (flushed)
126 rt_cache_flush(-1);
127}
128
129/*
130 * Find the first device with a given source address.
131 */
132
Al Viro60cad5d2006-09-26 22:17:09 -0700133struct net_device * ip_dev_find(__be32 addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134{
135 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
136 struct fib_result res;
137 struct net_device *dev = NULL;
Pavel Emelyanov03cf7862007-10-23 21:17:27 -0700138 struct fib_table *local_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139
140#ifdef CONFIG_IP_MULTIPLE_TABLES
141 res.r = NULL;
142#endif
143
Pavel Emelyanov03cf7862007-10-23 21:17:27 -0700144 local_table = fib_get_table(RT_TABLE_LOCAL);
145 if (!local_table || local_table->tb_lookup(local_table, &fl, &res))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 return NULL;
147 if (res.type != RTN_LOCAL)
148 goto out;
149 dev = FIB_RES_DEV(res);
150
151 if (dev)
152 dev_hold(dev);
153out:
154 fib_res_put(&res);
155 return dev;
156}
157
Al Virofd683222006-09-26 22:17:51 -0700158unsigned inet_addr_type(__be32 addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159{
160 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
161 struct fib_result res;
162 unsigned ret = RTN_BROADCAST;
Pavel Emelyanov03cf7862007-10-23 21:17:27 -0700163 struct fib_table *local_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
165 if (ZERONET(addr) || BADCLASS(addr))
166 return RTN_BROADCAST;
167 if (MULTICAST(addr))
168 return RTN_MULTICAST;
169
170#ifdef CONFIG_IP_MULTIPLE_TABLES
171 res.r = NULL;
172#endif
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900173
Pavel Emelyanov03cf7862007-10-23 21:17:27 -0700174 local_table = fib_get_table(RT_TABLE_LOCAL);
175 if (local_table) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 ret = RTN_UNICAST;
Pavel Emelyanov03cf7862007-10-23 21:17:27 -0700177 if (!local_table->tb_lookup(local_table, &fl, &res)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 ret = res.type;
179 fib_res_put(&res);
180 }
181 }
182 return ret;
183}
184
185/* Given (packet source, input interface) and optional (dst, oif, tos):
186 - (main) check, that source is valid i.e. not broadcast or our local
187 address.
188 - figure out what "logical" interface this packet arrived
189 and calculate "specific destination" address.
190 - check, that packet arrived from expected physical interface.
191 */
192
Al Virod9c9df82006-09-26 21:28:14 -0700193int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif,
194 struct net_device *dev, __be32 *spec_dst, u32 *itag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195{
196 struct in_device *in_dev;
197 struct flowi fl = { .nl_u = { .ip4_u =
198 { .daddr = src,
199 .saddr = dst,
200 .tos = tos } },
201 .iif = oif };
202 struct fib_result res;
203 int no_addr, rpf;
204 int ret;
205
206 no_addr = rpf = 0;
207 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -0700208 in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 if (in_dev) {
210 no_addr = in_dev->ifa_list == NULL;
211 rpf = IN_DEV_RPFILTER(in_dev);
212 }
213 rcu_read_unlock();
214
215 if (in_dev == NULL)
216 goto e_inval;
217
218 if (fib_lookup(&fl, &res))
219 goto last_resort;
220 if (res.type != RTN_UNICAST)
221 goto e_inval_res;
222 *spec_dst = FIB_RES_PREFSRC(res);
223 fib_combine_itag(itag, &res);
224#ifdef CONFIG_IP_ROUTE_MULTIPATH
225 if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
226#else
227 if (FIB_RES_DEV(res) == dev)
228#endif
229 {
230 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
231 fib_res_put(&res);
232 return ret;
233 }
234 fib_res_put(&res);
235 if (no_addr)
236 goto last_resort;
237 if (rpf)
238 goto e_inval;
239 fl.oif = dev->ifindex;
240
241 ret = 0;
242 if (fib_lookup(&fl, &res) == 0) {
243 if (res.type == RTN_UNICAST) {
244 *spec_dst = FIB_RES_PREFSRC(res);
245 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
246 }
247 fib_res_put(&res);
248 }
249 return ret;
250
251last_resort:
252 if (rpf)
253 goto e_inval;
254 *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
255 *itag = 0;
256 return 0;
257
258e_inval_res:
259 fib_res_put(&res);
260e_inval:
261 return -EINVAL;
262}
263
Al Viro81f7bf62006-09-27 18:40:00 -0700264static inline __be32 sk_extract_addr(struct sockaddr *addr)
Thomas Graf4e902c52006-08-17 18:14:52 -0700265{
266 return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
267}
268
269static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
270{
271 struct nlattr *nla;
272
273 nla = (struct nlattr *) ((char *) mx + len);
274 nla->nla_type = type;
275 nla->nla_len = nla_attr_size(4);
276 *(u32 *) nla_data(nla) = value;
277
278 return len + nla_total_size(4);
279}
280
281static int rtentry_to_fib_config(int cmd, struct rtentry *rt,
282 struct fib_config *cfg)
283{
Al Viro6d85c102006-09-26 22:15:46 -0700284 __be32 addr;
Thomas Graf4e902c52006-08-17 18:14:52 -0700285 int plen;
286
287 memset(cfg, 0, sizeof(*cfg));
288
289 if (rt->rt_dst.sa_family != AF_INET)
290 return -EAFNOSUPPORT;
291
292 /*
293 * Check mask for validity:
294 * a) it must be contiguous.
295 * b) destination must have all host bits clear.
296 * c) if application forgot to set correct family (AF_INET),
297 * reject request unless it is absolutely clear i.e.
298 * both family and mask are zero.
299 */
300 plen = 32;
301 addr = sk_extract_addr(&rt->rt_dst);
302 if (!(rt->rt_flags & RTF_HOST)) {
Al Viro81f7bf62006-09-27 18:40:00 -0700303 __be32 mask = sk_extract_addr(&rt->rt_genmask);
Thomas Graf4e902c52006-08-17 18:14:52 -0700304
305 if (rt->rt_genmask.sa_family != AF_INET) {
306 if (mask || rt->rt_genmask.sa_family)
307 return -EAFNOSUPPORT;
308 }
309
310 if (bad_mask(mask, addr))
311 return -EINVAL;
312
313 plen = inet_mask_len(mask);
314 }
315
316 cfg->fc_dst_len = plen;
317 cfg->fc_dst = addr;
318
319 if (cmd != SIOCDELRT) {
320 cfg->fc_nlflags = NLM_F_CREATE;
321 cfg->fc_protocol = RTPROT_BOOT;
322 }
323
324 if (rt->rt_metric)
325 cfg->fc_priority = rt->rt_metric - 1;
326
327 if (rt->rt_flags & RTF_REJECT) {
328 cfg->fc_scope = RT_SCOPE_HOST;
329 cfg->fc_type = RTN_UNREACHABLE;
330 return 0;
331 }
332
333 cfg->fc_scope = RT_SCOPE_NOWHERE;
334 cfg->fc_type = RTN_UNICAST;
335
336 if (rt->rt_dev) {
337 char *colon;
338 struct net_device *dev;
339 char devname[IFNAMSIZ];
340
341 if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))
342 return -EFAULT;
343
344 devname[IFNAMSIZ-1] = 0;
345 colon = strchr(devname, ':');
346 if (colon)
347 *colon = 0;
Eric W. Biederman881d9662007-09-17 11:56:21 -0700348 dev = __dev_get_by_name(&init_net, devname);
Thomas Graf4e902c52006-08-17 18:14:52 -0700349 if (!dev)
350 return -ENODEV;
351 cfg->fc_oif = dev->ifindex;
352 if (colon) {
353 struct in_ifaddr *ifa;
354 struct in_device *in_dev = __in_dev_get_rtnl(dev);
355 if (!in_dev)
356 return -ENODEV;
357 *colon = ':';
358 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
359 if (strcmp(ifa->ifa_label, devname) == 0)
360 break;
361 if (ifa == NULL)
362 return -ENODEV;
363 cfg->fc_prefsrc = ifa->ifa_local;
364 }
365 }
366
367 addr = sk_extract_addr(&rt->rt_gateway);
368 if (rt->rt_gateway.sa_family == AF_INET && addr) {
369 cfg->fc_gw = addr;
370 if (rt->rt_flags & RTF_GATEWAY &&
371 inet_addr_type(addr) == RTN_UNICAST)
372 cfg->fc_scope = RT_SCOPE_UNIVERSE;
373 }
374
375 if (cmd == SIOCDELRT)
376 return 0;
377
378 if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw)
379 return -EINVAL;
380
381 if (cfg->fc_scope == RT_SCOPE_NOWHERE)
382 cfg->fc_scope = RT_SCOPE_LINK;
383
384 if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {
385 struct nlattr *mx;
386 int len = 0;
387
388 mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900389 if (mx == NULL)
Thomas Graf4e902c52006-08-17 18:14:52 -0700390 return -ENOMEM;
391
392 if (rt->rt_flags & RTF_MTU)
393 len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);
394
395 if (rt->rt_flags & RTF_WINDOW)
396 len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);
397
398 if (rt->rt_flags & RTF_IRTT)
399 len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);
400
401 cfg->fc_mx = mx;
402 cfg->fc_mx_len = len;
403 }
404
405 return 0;
406}
407
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408/*
409 * Handle IP routing ioctl calls. These are used to manipulate the routing tables
410 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900411
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412int ip_rt_ioctl(unsigned int cmd, void __user *arg)
413{
Thomas Graf4e902c52006-08-17 18:14:52 -0700414 struct fib_config cfg;
415 struct rtentry rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
418 switch (cmd) {
419 case SIOCADDRT: /* Add a route */
420 case SIOCDELRT: /* Delete a route */
421 if (!capable(CAP_NET_ADMIN))
422 return -EPERM;
Thomas Graf4e902c52006-08-17 18:14:52 -0700423
424 if (copy_from_user(&rt, arg, sizeof(rt)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 return -EFAULT;
Thomas Graf4e902c52006-08-17 18:14:52 -0700426
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 rtnl_lock();
Thomas Graf4e902c52006-08-17 18:14:52 -0700428 err = rtentry_to_fib_config(cmd, &rt, &cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 if (err == 0) {
Thomas Graf4e902c52006-08-17 18:14:52 -0700430 struct fib_table *tb;
431
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 if (cmd == SIOCDELRT) {
Thomas Graf4e902c52006-08-17 18:14:52 -0700433 tb = fib_get_table(cfg.fc_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 if (tb)
Thomas Graf4e902c52006-08-17 18:14:52 -0700435 err = tb->tb_delete(tb, &cfg);
436 else
437 err = -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 } else {
Thomas Graf4e902c52006-08-17 18:14:52 -0700439 tb = fib_new_table(cfg.fc_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 if (tb)
Thomas Graf4e902c52006-08-17 18:14:52 -0700441 err = tb->tb_insert(tb, &cfg);
442 else
443 err = -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 }
Thomas Graf4e902c52006-08-17 18:14:52 -0700445
446 /* allocated by rtentry_to_fib_config() */
447 kfree(cfg.fc_mx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 }
449 rtnl_unlock();
450 return err;
451 }
452 return -EINVAL;
453}
454
Patrick McHardyef7c79e2007-06-05 12:38:30 -0700455const struct nla_policy rtm_ipv4_policy[RTA_MAX+1] = {
Thomas Graf4e902c52006-08-17 18:14:52 -0700456 [RTA_DST] = { .type = NLA_U32 },
457 [RTA_SRC] = { .type = NLA_U32 },
458 [RTA_IIF] = { .type = NLA_U32 },
459 [RTA_OIF] = { .type = NLA_U32 },
460 [RTA_GATEWAY] = { .type = NLA_U32 },
461 [RTA_PRIORITY] = { .type = NLA_U32 },
462 [RTA_PREFSRC] = { .type = NLA_U32 },
463 [RTA_METRICS] = { .type = NLA_NESTED },
Thomas Graf5176f912006-08-26 20:13:18 -0700464 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
Thomas Graf4e902c52006-08-17 18:14:52 -0700465 [RTA_PROTOINFO] = { .type = NLA_U32 },
466 [RTA_FLOW] = { .type = NLA_U32 },
Thomas Graf4e902c52006-08-17 18:14:52 -0700467};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
Thomas Graf4e902c52006-08-17 18:14:52 -0700469static int rtm_to_fib_config(struct sk_buff *skb, struct nlmsghdr *nlh,
470 struct fib_config *cfg)
471{
472 struct nlattr *attr;
473 int err, remaining;
474 struct rtmsg *rtm;
475
476 err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);
477 if (err < 0)
478 goto errout;
479
480 memset(cfg, 0, sizeof(*cfg));
481
482 rtm = nlmsg_data(nlh);
Thomas Graf4e902c52006-08-17 18:14:52 -0700483 cfg->fc_dst_len = rtm->rtm_dst_len;
Thomas Graf4e902c52006-08-17 18:14:52 -0700484 cfg->fc_tos = rtm->rtm_tos;
485 cfg->fc_table = rtm->rtm_table;
486 cfg->fc_protocol = rtm->rtm_protocol;
487 cfg->fc_scope = rtm->rtm_scope;
488 cfg->fc_type = rtm->rtm_type;
489 cfg->fc_flags = rtm->rtm_flags;
490 cfg->fc_nlflags = nlh->nlmsg_flags;
491
492 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
493 cfg->fc_nlinfo.nlh = nlh;
494
Thomas Grafa0ee18b2007-03-24 20:32:54 -0700495 if (cfg->fc_type > RTN_MAX) {
496 err = -EINVAL;
497 goto errout;
498 }
499
Thomas Graf4e902c52006-08-17 18:14:52 -0700500 nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
Thomas Graf8f4c1f92007-09-12 14:44:36 +0200501 switch (nla_type(attr)) {
Thomas Graf4e902c52006-08-17 18:14:52 -0700502 case RTA_DST:
Al Viro17fb2c62006-09-26 22:15:25 -0700503 cfg->fc_dst = nla_get_be32(attr);
Thomas Graf4e902c52006-08-17 18:14:52 -0700504 break;
Thomas Graf4e902c52006-08-17 18:14:52 -0700505 case RTA_OIF:
506 cfg->fc_oif = nla_get_u32(attr);
507 break;
508 case RTA_GATEWAY:
Al Viro17fb2c62006-09-26 22:15:25 -0700509 cfg->fc_gw = nla_get_be32(attr);
Thomas Graf4e902c52006-08-17 18:14:52 -0700510 break;
511 case RTA_PRIORITY:
512 cfg->fc_priority = nla_get_u32(attr);
513 break;
514 case RTA_PREFSRC:
Al Viro17fb2c62006-09-26 22:15:25 -0700515 cfg->fc_prefsrc = nla_get_be32(attr);
Thomas Graf4e902c52006-08-17 18:14:52 -0700516 break;
517 case RTA_METRICS:
518 cfg->fc_mx = nla_data(attr);
519 cfg->fc_mx_len = nla_len(attr);
520 break;
521 case RTA_MULTIPATH:
522 cfg->fc_mp = nla_data(attr);
523 cfg->fc_mp_len = nla_len(attr);
524 break;
525 case RTA_FLOW:
526 cfg->fc_flow = nla_get_u32(attr);
527 break;
Thomas Graf4e902c52006-08-17 18:14:52 -0700528 case RTA_TABLE:
529 cfg->fc_table = nla_get_u32(attr);
530 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 }
532 }
Thomas Graf4e902c52006-08-17 18:14:52 -0700533
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 return 0;
Thomas Graf4e902c52006-08-17 18:14:52 -0700535errout:
536 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537}
538
Thomas Graf63f34442007-03-22 11:55:17 -0700539static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540{
Thomas Graf4e902c52006-08-17 18:14:52 -0700541 struct fib_config cfg;
542 struct fib_table *tb;
543 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
Thomas Graf4e902c52006-08-17 18:14:52 -0700545 err = rtm_to_fib_config(skb, nlh, &cfg);
546 if (err < 0)
547 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548
Thomas Graf4e902c52006-08-17 18:14:52 -0700549 tb = fib_get_table(cfg.fc_table);
550 if (tb == NULL) {
551 err = -ESRCH;
552 goto errout;
553 }
554
555 err = tb->tb_delete(tb, &cfg);
556errout:
557 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558}
559
Thomas Graf63f34442007-03-22 11:55:17 -0700560static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561{
Thomas Graf4e902c52006-08-17 18:14:52 -0700562 struct fib_config cfg;
563 struct fib_table *tb;
564 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565
Thomas Graf4e902c52006-08-17 18:14:52 -0700566 err = rtm_to_fib_config(skb, nlh, &cfg);
567 if (err < 0)
568 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
Thomas Graf4e902c52006-08-17 18:14:52 -0700570 tb = fib_new_table(cfg.fc_table);
571 if (tb == NULL) {
572 err = -ENOBUFS;
573 goto errout;
574 }
575
576 err = tb->tb_insert(tb, &cfg);
577errout:
578 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579}
580
Thomas Graf63f34442007-03-22 11:55:17 -0700581static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582{
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700583 unsigned int h, s_h;
584 unsigned int e = 0, s_e;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 struct fib_table *tb;
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700586 struct hlist_node *node;
587 int dumped = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588
Thomas Grafbe403ea2006-08-17 18:15:17 -0700589 if (nlmsg_len(cb->nlh) >= sizeof(struct rtmsg) &&
590 ((struct rtmsg *) nlmsg_data(cb->nlh))->rtm_flags & RTM_F_CLONED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 return ip_rt_dump(skb, cb);
592
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700593 s_h = cb->args[0];
594 s_e = cb->args[1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700596 for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
597 e = 0;
598 hlist_for_each_entry(tb, node, &fib_table_hash[h], tb_hlist) {
599 if (e < s_e)
600 goto next;
601 if (dumped)
602 memset(&cb->args[2], 0, sizeof(cb->args) -
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900603 2 * sizeof(cb->args[0]));
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700604 if (tb->tb_dump(tb, skb, cb) < 0)
605 goto out;
606 dumped = 1;
607next:
608 e++;
609 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 }
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700611out:
612 cb->args[1] = e;
613 cb->args[0] = h;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
615 return skb->len;
616}
617
618/* Prepare and feed intra-kernel routing request.
619 Really, it should be netlink message, but :-( netlink
620 can be not configured, so that we feed it directly
621 to fib engine. It is legal, because all events occur
622 only when netlink is already locked.
623 */
624
Al Viro81f7bf62006-09-27 18:40:00 -0700625static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626{
Thomas Graf4e902c52006-08-17 18:14:52 -0700627 struct fib_table *tb;
628 struct fib_config cfg = {
629 .fc_protocol = RTPROT_KERNEL,
630 .fc_type = type,
631 .fc_dst = dst,
632 .fc_dst_len = dst_len,
633 .fc_prefsrc = ifa->ifa_local,
634 .fc_oif = ifa->ifa_dev->dev->ifindex,
635 .fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,
636 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637
638 if (type == RTN_UNICAST)
639 tb = fib_new_table(RT_TABLE_MAIN);
640 else
641 tb = fib_new_table(RT_TABLE_LOCAL);
642
643 if (tb == NULL)
644 return;
645
Thomas Graf4e902c52006-08-17 18:14:52 -0700646 cfg.fc_table = tb->tb_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647
Thomas Graf4e902c52006-08-17 18:14:52 -0700648 if (type != RTN_LOCAL)
649 cfg.fc_scope = RT_SCOPE_LINK;
650 else
651 cfg.fc_scope = RT_SCOPE_HOST;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
653 if (cmd == RTM_NEWROUTE)
Thomas Graf4e902c52006-08-17 18:14:52 -0700654 tb->tb_insert(tb, &cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 else
Thomas Graf4e902c52006-08-17 18:14:52 -0700656 tb->tb_delete(tb, &cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657}
658
Jamal Hadi Salim0ff60a42005-11-22 14:47:37 -0800659void fib_add_ifaddr(struct in_ifaddr *ifa)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660{
661 struct in_device *in_dev = ifa->ifa_dev;
662 struct net_device *dev = in_dev->dev;
663 struct in_ifaddr *prim = ifa;
Al Viroa144ea42006-09-28 18:00:55 -0700664 __be32 mask = ifa->ifa_mask;
665 __be32 addr = ifa->ifa_local;
666 __be32 prefix = ifa->ifa_address&mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667
668 if (ifa->ifa_flags&IFA_F_SECONDARY) {
669 prim = inet_ifa_byprefix(in_dev, prefix, mask);
670 if (prim == NULL) {
671 printk(KERN_DEBUG "fib_add_ifaddr: bug: prim == NULL\n");
672 return;
673 }
674 }
675
676 fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
677
678 if (!(dev->flags&IFF_UP))
679 return;
680
681 /* Add broadcast address, if it is explicitly assigned. */
Al Viroa144ea42006-09-28 18:00:55 -0700682 if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
684
685 if (!ZERONET(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
686 (prefix != addr || ifa->ifa_prefixlen < 32)) {
687 fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
688 RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
689
690 /* Add network specific broadcasts, when it takes a sense */
691 if (ifa->ifa_prefixlen < 31) {
692 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
693 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim);
694 }
695 }
696}
697
698static void fib_del_ifaddr(struct in_ifaddr *ifa)
699{
700 struct in_device *in_dev = ifa->ifa_dev;
701 struct net_device *dev = in_dev->dev;
702 struct in_ifaddr *ifa1;
703 struct in_ifaddr *prim = ifa;
Al Viroa144ea42006-09-28 18:00:55 -0700704 __be32 brd = ifa->ifa_address|~ifa->ifa_mask;
705 __be32 any = ifa->ifa_address&ifa->ifa_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706#define LOCAL_OK 1
707#define BRD_OK 2
708#define BRD0_OK 4
709#define BRD1_OK 8
710 unsigned ok = 0;
711
712 if (!(ifa->ifa_flags&IFA_F_SECONDARY))
713 fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
714 RTN_UNICAST, any, ifa->ifa_prefixlen, prim);
715 else {
716 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
717 if (prim == NULL) {
718 printk(KERN_DEBUG "fib_del_ifaddr: bug: prim == NULL\n");
719 return;
720 }
721 }
722
723 /* Deletion is more complicated than add.
724 We should take care of not to delete too much :-)
725
726 Scan address list to be sure that addresses are really gone.
727 */
728
729 for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
730 if (ifa->ifa_local == ifa1->ifa_local)
731 ok |= LOCAL_OK;
732 if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
733 ok |= BRD_OK;
734 if (brd == ifa1->ifa_broadcast)
735 ok |= BRD1_OK;
736 if (any == ifa1->ifa_broadcast)
737 ok |= BRD0_OK;
738 }
739
740 if (!(ok&BRD_OK))
741 fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
742 if (!(ok&BRD1_OK))
743 fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
744 if (!(ok&BRD0_OK))
745 fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
746 if (!(ok&LOCAL_OK)) {
747 fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
748
749 /* Check, that this local address finally disappeared. */
750 if (inet_addr_type(ifa->ifa_local) != RTN_LOCAL) {
751 /* And the last, but not the least thing.
752 We must flush stray FIB entries.
753
754 First of all, we scan fib_info list searching
755 for stray nexthop entries, then ignite fib_flush.
756 */
757 if (fib_sync_down(ifa->ifa_local, NULL, 0))
758 fib_flush();
759 }
760 }
761#undef LOCAL_OK
762#undef BRD_OK
763#undef BRD0_OK
764#undef BRD1_OK
765}
766
Robert Olsson246955f2005-06-20 13:36:39 -0700767static void nl_fib_lookup(struct fib_result_nl *frn, struct fib_table *tb )
768{
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900769
Robert Olsson246955f2005-06-20 13:36:39 -0700770 struct fib_result res;
Thomas Graf5f3008932006-11-09 15:21:41 -0800771 struct flowi fl = { .mark = frn->fl_mark,
Thomas Graf47dcf0c2006-11-09 15:20:38 -0800772 .nl_u = { .ip4_u = { .daddr = frn->fl_addr,
Robert Olsson246955f2005-06-20 13:36:39 -0700773 .tos = frn->fl_tos,
774 .scope = frn->fl_scope } } };
Alexey Kuznetsov1194ed02007-04-25 13:07:28 -0700775
Sergey Vlasov912a41a2007-04-27 02:17:19 -0700776#ifdef CONFIG_IP_MULTIPLE_TABLES
777 res.r = NULL;
778#endif
779
Alexey Kuznetsov1194ed02007-04-25 13:07:28 -0700780 frn->err = -ENOENT;
Robert Olsson246955f2005-06-20 13:36:39 -0700781 if (tb) {
782 local_bh_disable();
783
784 frn->tb_id = tb->tb_id;
785 frn->err = tb->tb_lookup(tb, &fl, &res);
786
787 if (!frn->err) {
788 frn->prefixlen = res.prefixlen;
789 frn->nh_sel = res.nh_sel;
790 frn->type = res.type;
791 frn->scope = res.scope;
Alexey Kuznetsov1194ed02007-04-25 13:07:28 -0700792 fib_res_put(&res);
Robert Olsson246955f2005-06-20 13:36:39 -0700793 }
794 local_bh_enable();
795 }
796}
797
David S. Miller28f7b0362007-10-10 21:32:39 -0700798static void nl_fib_input(struct sk_buff *skb)
Robert Olsson246955f2005-06-20 13:36:39 -0700799{
Robert Olsson246955f2005-06-20 13:36:39 -0700800 struct fib_result_nl *frn;
David S. Miller28f7b0362007-10-10 21:32:39 -0700801 struct nlmsghdr *nlh;
Robert Olsson246955f2005-06-20 13:36:39 -0700802 struct fib_table *tb;
David S. Miller28f7b0362007-10-10 21:32:39 -0700803 u32 pid;
Alexey Kuznetsov1194ed02007-04-25 13:07:28 -0700804
Arnaldo Carvalho de Melob529ccf2007-04-25 19:08:35 -0700805 nlh = nlmsg_hdr(skb);
Thomas Grafea865752005-12-01 14:30:00 -0800806 if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len ||
Denis V. Lunevd883a032007-12-21 02:01:53 -0800807 nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn)))
Thomas Grafea865752005-12-01 14:30:00 -0800808 return;
Denis V. Lunevd883a032007-12-21 02:01:53 -0800809
810 skb = skb_clone(skb, GFP_KERNEL);
811 if (skb == NULL)
812 return;
813 nlh = nlmsg_hdr(skb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900814
Robert Olsson246955f2005-06-20 13:36:39 -0700815 frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
816 tb = fib_get_table(frn->tb_id_in);
817
818 nl_fib_lookup(frn, tb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900819
Alexey Kuznetsov1194ed02007-04-25 13:07:28 -0700820 pid = NETLINK_CB(skb).pid; /* pid of sending process */
Robert Olsson246955f2005-06-20 13:36:39 -0700821 NETLINK_CB(skb).pid = 0; /* from kernel */
Patrick McHardyac6d4392005-08-14 19:29:52 -0700822 NETLINK_CB(skb).dst_group = 0; /* unicast */
Denis V. Lunevcd40b7d2007-10-10 21:15:29 -0700823 netlink_unicast(fibnl, skb, pid, MSG_DONTWAIT);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900824}
Robert Olsson246955f2005-06-20 13:36:39 -0700825
826static void nl_fib_lookup_init(void)
827{
Denis V. Lunevcd40b7d2007-10-10 21:15:29 -0700828 fibnl = netlink_kernel_create(&init_net, NETLINK_FIB_LOOKUP, 0,
829 nl_fib_input, NULL, THIS_MODULE);
Robert Olsson246955f2005-06-20 13:36:39 -0700830}
831
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832static void fib_disable_ip(struct net_device *dev, int force)
833{
834 if (fib_sync_down(0, dev, force))
835 fib_flush();
836 rt_cache_flush(0);
837 arp_ifdown(dev);
838}
839
840static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
841{
842 struct in_ifaddr *ifa = (struct in_ifaddr*)ptr;
843
844 switch (event) {
845 case NETDEV_UP:
846 fib_add_ifaddr(ifa);
847#ifdef CONFIG_IP_ROUTE_MULTIPATH
848 fib_sync_up(ifa->ifa_dev->dev);
849#endif
850 rt_cache_flush(-1);
851 break;
852 case NETDEV_DOWN:
853 fib_del_ifaddr(ifa);
Jayachandran C9fcc2e82005-10-27 15:10:01 -0700854 if (ifa->ifa_dev->ifa_list == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 /* Last address was deleted from this interface.
856 Disable IP.
857 */
858 fib_disable_ip(ifa->ifa_dev->dev, 1);
859 } else {
860 rt_cache_flush(-1);
861 }
862 break;
863 }
864 return NOTIFY_DONE;
865}
866
867static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
868{
869 struct net_device *dev = ptr;
Herbert Xue5ed6392005-10-03 14:35:55 -0700870 struct in_device *in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
Eric W. Biedermane9dc8652007-09-12 13:02:17 +0200872 if (dev->nd_net != &init_net)
873 return NOTIFY_DONE;
874
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 if (event == NETDEV_UNREGISTER) {
876 fib_disable_ip(dev, 2);
877 return NOTIFY_DONE;
878 }
879
880 if (!in_dev)
881 return NOTIFY_DONE;
882
883 switch (event) {
884 case NETDEV_UP:
885 for_ifa(in_dev) {
886 fib_add_ifaddr(ifa);
887 } endfor_ifa(in_dev);
888#ifdef CONFIG_IP_ROUTE_MULTIPATH
889 fib_sync_up(dev);
890#endif
891 rt_cache_flush(-1);
892 break;
893 case NETDEV_DOWN:
894 fib_disable_ip(dev, 0);
895 break;
896 case NETDEV_CHANGEMTU:
897 case NETDEV_CHANGE:
898 rt_cache_flush(0);
899 break;
900 }
901 return NOTIFY_DONE;
902}
903
904static struct notifier_block fib_inetaddr_notifier = {
905 .notifier_call =fib_inetaddr_event,
906};
907
908static struct notifier_block fib_netdev_notifier = {
909 .notifier_call =fib_netdev_event,
910};
911
912void __init ip_fib_init(void)
913{
Patrick McHardy1af5a8c2006-08-10 23:10:46 -0700914 unsigned int i;
915
916 for (i = 0; i < FIB_TABLE_HASHSZ; i++)
917 INIT_HLIST_HEAD(&fib_table_hash[i]);
Pavel Emelyanovc3e9a352007-11-06 23:34:04 -0800918
Thomas Grafe1ef4bf2006-08-04 03:39:22 -0700919 fib4_rules_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920
921 register_netdevice_notifier(&fib_netdev_notifier);
922 register_inetaddr_notifier(&fib_inetaddr_notifier);
Robert Olsson246955f2005-06-20 13:36:39 -0700923 nl_fib_lookup_init();
Thomas Graf63f34442007-03-22 11:55:17 -0700924
925 rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL);
926 rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL);
927 rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928}
929
930EXPORT_SYMBOL(inet_addr_type);
Sean Heftya1e87332006-06-17 20:37:28 -0700931EXPORT_SYMBOL(ip_dev_find);