?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
writeback: split writeback_inodes_wb
[linux-2.6/next.git] / net / ipv4 / fib_frontend.c
blob4f0ed458c883658c37265fe6537bde2ac8b88429
1 /*
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 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
14 */
15
16 #include <linux/module.h>
17 #include <asm/uaccess.h>
18 #include <asm/system.h>
19 #include <linux/bitops.h>
20 #include <linux/capability.h>
21 #include <linux/types.h>
22 #include <linux/kernel.h>
23 #include <linux/mm.h>
24 #include <linux/string.h>
25 #include <linux/socket.h>
26 #include <linux/sockios.h>
27 #include <linux/errno.h>
28 #include <linux/in.h>
29 #include <linux/inet.h>
30 #include <linux/inetdevice.h>
31 #include <linux/netdevice.h>
32 #include <linux/if_addr.h>
33 #include <linux/if_arp.h>
34 #include <linux/skbuff.h>
35 #include <linux/init.h>
36 #include <linux/list.h>
37 #include <linux/slab.h>
38
39 #include <net/ip.h>
40 #include <net/protocol.h>
41 #include <net/route.h>
42 #include <net/tcp.h>
43 #include <net/sock.h>
44 #include <net/arp.h>
45 #include <net/ip_fib.h>
46 #include <net/rtnetlink.h>
47
48 #ifndef CONFIG_IP_MULTIPLE_TABLES
49
50 static int __net_init fib4_rules_init(struct net *net)
51 {
52 struct fib_table *local_table, *main_table;
53
54 local_table = fib_hash_table(RT_TABLE_LOCAL);
55 if (local_table == NULL)
56 return -ENOMEM;
57
58 main_table = fib_hash_table(RT_TABLE_MAIN);
59 if (main_table == NULL)
60 goto fail;
61
62 hlist_add_head_rcu(&local_table->tb_hlist,
63 &net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX]);
64 hlist_add_head_rcu(&main_table->tb_hlist,
65 &net->ipv4.fib_table_hash[TABLE_MAIN_INDEX]);
66 return 0;
67
68 fail:
69 kfree(local_table);
70 return -ENOMEM;
71 }
72 #else
73
74 struct fib_table *fib_new_table(struct net *net, u32 id)
75 {
76 struct fib_table *tb;
77 unsigned int h;
78
79 if (id == 0)
80 id = RT_TABLE_MAIN;
81 tb = fib_get_table(net, id);
82 if (tb)
83 return tb;
84
85 tb = fib_hash_table(id);
86 if (!tb)
87 return NULL;
88 h = id & (FIB_TABLE_HASHSZ - 1);
89 hlist_add_head_rcu(&tb->tb_hlist, &net->ipv4.fib_table_hash[h]);
90 return tb;
91 }
92
93 struct fib_table *fib_get_table(struct net *net, u32 id)
94 {
95 struct fib_table *tb;
96 struct hlist_node *node;
97 struct hlist_head *head;
98 unsigned int h;
99
100 if (id == 0)
101 id = RT_TABLE_MAIN;
102 h = id & (FIB_TABLE_HASHSZ - 1);
103
104 rcu_read_lock();
105 head = &net->ipv4.fib_table_hash[h];
106 hlist_for_each_entry_rcu(tb, node, head, tb_hlist) {
107 if (tb->tb_id == id) {
108 rcu_read_unlock();
109 return tb;
110 }
111 }
112 rcu_read_unlock();
113 return NULL;
114 }
115 #endif /* CONFIG_IP_MULTIPLE_TABLES */
116
117 void fib_select_default(struct net *net,
118 const struct flowi *flp, struct fib_result *res)
119 {
120 struct fib_table *tb;
121 int table = RT_TABLE_MAIN;
122 #ifdef CONFIG_IP_MULTIPLE_TABLES
123 if (res->r == NULL || res->r->action != FR_ACT_TO_TBL)
124 return;
125 table = res->r->table;
126 #endif
127 tb = fib_get_table(net, table);
128 if (FIB_RES_GW(*res) && FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK)
129 fib_table_select_default(tb, flp, res);
130 }
131
132 static void fib_flush(struct net *net)
133 {
134 int flushed = 0;
135 struct fib_table *tb;
136 struct hlist_node *node;
137 struct hlist_head *head;
138 unsigned int h;
139
140 for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
141 head = &net->ipv4.fib_table_hash[h];
142 hlist_for_each_entry(tb, node, head, tb_hlist)
143 flushed += fib_table_flush(tb);
144 }
145
146 if (flushed)
147 rt_cache_flush(net, -1);
148 }
149
150 /*
151 * Find the first device with a given source address.
152 */
153
154 struct net_device * ip_dev_find(struct net *net, __be32 addr)
155 {
156 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
157 struct fib_result res;
158 struct net_device *dev = NULL;
159 struct fib_table *local_table;
160
161 #ifdef CONFIG_IP_MULTIPLE_TABLES
162 res.r = NULL;
163 #endif
164
165 local_table = fib_get_table(net, RT_TABLE_LOCAL);
166 if (!local_table || fib_table_lookup(local_table, &fl, &res))
167 return NULL;
168 if (res.type != RTN_LOCAL)
169 goto out;
170 dev = FIB_RES_DEV(res);
171
172 if (dev)
173 dev_hold(dev);
174 out:
175 fib_res_put(&res);
176 return dev;
177 }
178
179 /*
180 * Find address type as if only "dev" was present in the system. If
181 * on_dev is NULL then all interfaces are taken into consideration.
182 */
183 static inline unsigned __inet_dev_addr_type(struct net *net,
184 const struct net_device *dev,
185 __be32 addr)
186 {
187 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
188 struct fib_result res;
189 unsigned ret = RTN_BROADCAST;
190 struct fib_table *local_table;
191
192 if (ipv4_is_zeronet(addr) || ipv4_is_lbcast(addr))
193 return RTN_BROADCAST;
194 if (ipv4_is_multicast(addr))
195 return RTN_MULTICAST;
196
197 #ifdef CONFIG_IP_MULTIPLE_TABLES
198 res.r = NULL;
199 #endif
200
201 local_table = fib_get_table(net, RT_TABLE_LOCAL);
202 if (local_table) {
203 ret = RTN_UNICAST;
204 if (!fib_table_lookup(local_table, &fl, &res)) {
205 if (!dev || dev == res.fi->fib_dev)
206 ret = res.type;
207 fib_res_put(&res);
208 }
209 }
210 return ret;
211 }
212
213 unsigned int inet_addr_type(struct net *net, __be32 addr)
214 {
215 return __inet_dev_addr_type(net, NULL, addr);
216 }
217
218 unsigned int inet_dev_addr_type(struct net *net, const struct net_device *dev,
219 __be32 addr)
220 {
221 return __inet_dev_addr_type(net, dev, addr);
222 }
223
224 /* Given (packet source, input interface) and optional (dst, oif, tos):
225 - (main) check, that source is valid i.e. not broadcast or our local
226 address.
227 - figure out what "logical" interface this packet arrived
228 and calculate "specific destination" address.
229 - check, that packet arrived from expected physical interface.
230 */
231
232 int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif,
233 struct net_device *dev, __be32 *spec_dst,
234 u32 *itag, u32 mark)
235 {
236 struct in_device *in_dev;
237 struct flowi fl = { .nl_u = { .ip4_u =
238 { .daddr = src,
239 .saddr = dst,
240 .tos = tos } },
241 .mark = mark,
242 .iif = oif };
243
244 struct fib_result res;
245 int no_addr, rpf, accept_local;
246 int ret;
247 struct net *net;
248
249 no_addr = rpf = accept_local = 0;
250 rcu_read_lock();
251 in_dev = __in_dev_get_rcu(dev);
252 if (in_dev) {
253 no_addr = in_dev->ifa_list == NULL;
254 rpf = IN_DEV_RPFILTER(in_dev);
255 accept_local = IN_DEV_ACCEPT_LOCAL(in_dev);
256 if (mark && !IN_DEV_SRC_VMARK(in_dev))
257 fl.mark = 0;
258 }
259 rcu_read_unlock();
260
261 if (in_dev == NULL)
262 goto e_inval;
263
264 net = dev_net(dev);
265 if (fib_lookup(net, &fl, &res))
266 goto last_resort;
267 if (res.type != RTN_UNICAST) {
268 if (res.type != RTN_LOCAL || !accept_local)
269 goto e_inval_res;
270 }
271 *spec_dst = FIB_RES_PREFSRC(res);
272 fib_combine_itag(itag, &res);
273 #ifdef CONFIG_IP_ROUTE_MULTIPATH
274 if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
275 #else
276 if (FIB_RES_DEV(res) == dev)
277 #endif
278 {
279 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
280 fib_res_put(&res);
281 return ret;
282 }
283 fib_res_put(&res);
284 if (no_addr)
285 goto last_resort;
286 if (rpf == 1)
287 goto e_inval;
288 fl.oif = dev->ifindex;
289
290 ret = 0;
291 if (fib_lookup(net, &fl, &res) == 0) {
292 if (res.type == RTN_UNICAST) {
293 *spec_dst = FIB_RES_PREFSRC(res);
294 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
295 }
296 fib_res_put(&res);
297 }
298 return ret;
299
300 last_resort:
301 if (rpf)
302 goto e_inval;
303 *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
304 *itag = 0;
305 return 0;
306
307 e_inval_res:
308 fib_res_put(&res);
309 e_inval:
310 return -EINVAL;
311 }
312
313 static inline __be32 sk_extract_addr(struct sockaddr *addr)
314 {
315 return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
316 }
317
318 static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
319 {
320 struct nlattr *nla;
321
322 nla = (struct nlattr *) ((char *) mx + len);
323 nla->nla_type = type;
324 nla->nla_len = nla_attr_size(4);
325 *(u32 *) nla_data(nla) = value;
326
327 return len + nla_total_size(4);
328 }
329
330 static int rtentry_to_fib_config(struct net *net, int cmd, struct rtentry *rt,
331 struct fib_config *cfg)
332 {
333 __be32 addr;
334 int plen;
335
336 memset(cfg, 0, sizeof(*cfg));
337 cfg->fc_nlinfo.nl_net = net;
338
339 if (rt->rt_dst.sa_family != AF_INET)
340 return -EAFNOSUPPORT;
341
342 /*
343 * Check mask for validity:
344 * a) it must be contiguous.
345 * b) destination must have all host bits clear.
346 * c) if application forgot to set correct family (AF_INET),
347 * reject request unless it is absolutely clear i.e.
348 * both family and mask are zero.
349 */
350 plen = 32;
351 addr = sk_extract_addr(&rt->rt_dst);
352 if (!(rt->rt_flags & RTF_HOST)) {
353 __be32 mask = sk_extract_addr(&rt->rt_genmask);
354
355 if (rt->rt_genmask.sa_family != AF_INET) {
356 if (mask || rt->rt_genmask.sa_family)
357 return -EAFNOSUPPORT;
358 }
359
360 if (bad_mask(mask, addr))
361 return -EINVAL;
362
363 plen = inet_mask_len(mask);
364 }
365
366 cfg->fc_dst_len = plen;
367 cfg->fc_dst = addr;
368
369 if (cmd != SIOCDELRT) {
370 cfg->fc_nlflags = NLM_F_CREATE;
371 cfg->fc_protocol = RTPROT_BOOT;
372 }
373
374 if (rt->rt_metric)
375 cfg->fc_priority = rt->rt_metric - 1;
376
377 if (rt->rt_flags & RTF_REJECT) {
378 cfg->fc_scope = RT_SCOPE_HOST;
379 cfg->fc_type = RTN_UNREACHABLE;
380 return 0;
381 }
382
383 cfg->fc_scope = RT_SCOPE_NOWHERE;
384 cfg->fc_type = RTN_UNICAST;
385
386 if (rt->rt_dev) {
387 char *colon;
388 struct net_device *dev;
389 char devname[IFNAMSIZ];
390
391 if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))
392 return -EFAULT;
393
394 devname[IFNAMSIZ-1] = 0;
395 colon = strchr(devname, ':');
396 if (colon)
397 *colon = 0;
398 dev = __dev_get_by_name(net, devname);
399 if (!dev)
400 return -ENODEV;
401 cfg->fc_oif = dev->ifindex;
402 if (colon) {
403 struct in_ifaddr *ifa;
404 struct in_device *in_dev = __in_dev_get_rtnl(dev);
405 if (!in_dev)
406 return -ENODEV;
407 *colon = ':';
408 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
409 if (strcmp(ifa->ifa_label, devname) == 0)
410 break;
411 if (ifa == NULL)
412 return -ENODEV;
413 cfg->fc_prefsrc = ifa->ifa_local;
414 }
415 }
416
417 addr = sk_extract_addr(&rt->rt_gateway);
418 if (rt->rt_gateway.sa_family == AF_INET && addr) {
419 cfg->fc_gw = addr;
420 if (rt->rt_flags & RTF_GATEWAY &&
421 inet_addr_type(net, addr) == RTN_UNICAST)
422 cfg->fc_scope = RT_SCOPE_UNIVERSE;
423 }
424
425 if (cmd == SIOCDELRT)
426 return 0;
427
428 if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw)
429 return -EINVAL;
430
431 if (cfg->fc_scope == RT_SCOPE_NOWHERE)
432 cfg->fc_scope = RT_SCOPE_LINK;
433
434 if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {
435 struct nlattr *mx;
436 int len = 0;
437
438 mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
439 if (mx == NULL)
440 return -ENOMEM;
441
442 if (rt->rt_flags & RTF_MTU)
443 len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);
444
445 if (rt->rt_flags & RTF_WINDOW)
446 len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);
447
448 if (rt->rt_flags & RTF_IRTT)
449 len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);
450
451 cfg->fc_mx = mx;
452 cfg->fc_mx_len = len;
453 }
454
455 return 0;
456 }
457
458 /*
459 * Handle IP routing ioctl calls. These are used to manipulate the routing tables
460 */
461
462 int ip_rt_ioctl(struct net *net, unsigned int cmd, void __user *arg)
463 {
464 struct fib_config cfg;
465 struct rtentry rt;
466 int err;
467
468 switch (cmd) {
469 case SIOCADDRT: /* Add a route */
470 case SIOCDELRT: /* Delete a route */
471 if (!capable(CAP_NET_ADMIN))
472 return -EPERM;
473
474 if (copy_from_user(&rt, arg, sizeof(rt)))
475 return -EFAULT;
476
477 rtnl_lock();
478 err = rtentry_to_fib_config(net, cmd, &rt, &cfg);
479 if (err == 0) {
480 struct fib_table *tb;
481
482 if (cmd == SIOCDELRT) {
483 tb = fib_get_table(net, cfg.fc_table);
484 if (tb)
485 err = fib_table_delete(tb, &cfg);
486 else
487 err = -ESRCH;
488 } else {
489 tb = fib_new_table(net, cfg.fc_table);
490 if (tb)
491 err = fib_table_insert(tb, &cfg);
492 else
493 err = -ENOBUFS;
494 }
495
496 /* allocated by rtentry_to_fib_config() */
497 kfree(cfg.fc_mx);
498 }
499 rtnl_unlock();
500 return err;
501 }
502 return -EINVAL;
503 }
504
505 const struct nla_policy rtm_ipv4_policy[RTA_MAX+1] = {
506 [RTA_DST] = { .type = NLA_U32 },
507 [RTA_SRC] = { .type = NLA_U32 },
508 [RTA_IIF] = { .type = NLA_U32 },
509 [RTA_OIF] = { .type = NLA_U32 },
510 [RTA_GATEWAY] = { .type = NLA_U32 },
511 [RTA_PRIORITY] = { .type = NLA_U32 },
512 [RTA_PREFSRC] = { .type = NLA_U32 },
513 [RTA_METRICS] = { .type = NLA_NESTED },
514 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
515 [RTA_FLOW] = { .type = NLA_U32 },
516 };
517
518 static int rtm_to_fib_config(struct net *net, struct sk_buff *skb,
519 struct nlmsghdr *nlh, struct fib_config *cfg)
520 {
521 struct nlattr *attr;
522 int err, remaining;
523 struct rtmsg *rtm;
524
525 err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);
526 if (err < 0)
527 goto errout;
528
529 memset(cfg, 0, sizeof(*cfg));
530
531 rtm = nlmsg_data(nlh);
532 cfg->fc_dst_len = rtm->rtm_dst_len;
533 cfg->fc_tos = rtm->rtm_tos;
534 cfg->fc_table = rtm->rtm_table;
535 cfg->fc_protocol = rtm->rtm_protocol;
536 cfg->fc_scope = rtm->rtm_scope;
537 cfg->fc_type = rtm->rtm_type;
538 cfg->fc_flags = rtm->rtm_flags;
539 cfg->fc_nlflags = nlh->nlmsg_flags;
540
541 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
542 cfg->fc_nlinfo.nlh = nlh;
543 cfg->fc_nlinfo.nl_net = net;
544
545 if (cfg->fc_type > RTN_MAX) {
546 err = -EINVAL;
547 goto errout;
548 }
549
550 nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
551 switch (nla_type(attr)) {
552 case RTA_DST:
553 cfg->fc_dst = nla_get_be32(attr);
554 break;
555 case RTA_OIF:
556 cfg->fc_oif = nla_get_u32(attr);
557 break;
558 case RTA_GATEWAY:
559 cfg->fc_gw = nla_get_be32(attr);
560 break;
561 case RTA_PRIORITY:
562 cfg->fc_priority = nla_get_u32(attr);
563 break;
564 case RTA_PREFSRC:
565 cfg->fc_prefsrc = nla_get_be32(attr);
566 break;
567 case RTA_METRICS:
568 cfg->fc_mx = nla_data(attr);
569 cfg->fc_mx_len = nla_len(attr);
570 break;
571 case RTA_MULTIPATH:
572 cfg->fc_mp = nla_data(attr);
573 cfg->fc_mp_len = nla_len(attr);
574 break;
575 case RTA_FLOW:
576 cfg->fc_flow = nla_get_u32(attr);
577 break;
578 case RTA_TABLE:
579 cfg->fc_table = nla_get_u32(attr);
580 break;
581 }
582 }
583
584 return 0;
585 errout:
586 return err;
587 }
588
589 static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
590 {
591 struct net *net = sock_net(skb->sk);
592 struct fib_config cfg;
593 struct fib_table *tb;
594 int err;
595
596 err = rtm_to_fib_config(net, skb, nlh, &cfg);
597 if (err < 0)
598 goto errout;
599
600 tb = fib_get_table(net, cfg.fc_table);
601 if (tb == NULL) {
602 err = -ESRCH;
603 goto errout;
604 }
605
606 err = fib_table_delete(tb, &cfg);
607 errout:
608 return err;
609 }
610
611 static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
612 {
613 struct net *net = sock_net(skb->sk);
614 struct fib_config cfg;
615 struct fib_table *tb;
616 int err;
617
618 err = rtm_to_fib_config(net, skb, nlh, &cfg);
619 if (err < 0)
620 goto errout;
621
622 tb = fib_new_table(net, cfg.fc_table);
623 if (tb == NULL) {
624 err = -ENOBUFS;
625 goto errout;
626 }
627
628 err = fib_table_insert(tb, &cfg);
629 errout:
630 return err;
631 }
632
633 static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
634 {
635 struct net *net = sock_net(skb->sk);
636 unsigned int h, s_h;
637 unsigned int e = 0, s_e;
638 struct fib_table *tb;
639 struct hlist_node *node;
640 struct hlist_head *head;
641 int dumped = 0;
642
643 if (nlmsg_len(cb->nlh) >= sizeof(struct rtmsg) &&
644 ((struct rtmsg *) nlmsg_data(cb->nlh))->rtm_flags & RTM_F_CLONED)
645 return ip_rt_dump(skb, cb);
646
647 s_h = cb->args[0];
648 s_e = cb->args[1];
649
650 for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
651 e = 0;
652 head = &net->ipv4.fib_table_hash[h];
653 hlist_for_each_entry(tb, node, head, tb_hlist) {
654 if (e < s_e)
655 goto next;
656 if (dumped)
657 memset(&cb->args[2], 0, sizeof(cb->args) -
658 2 * sizeof(cb->args[0]));
659 if (fib_table_dump(tb, skb, cb) < 0)
660 goto out;
661 dumped = 1;
662 next:
663 e++;
664 }
665 }
666 out:
667 cb->args[1] = e;
668 cb->args[0] = h;
669
670 return skb->len;
671 }
672
673 /* Prepare and feed intra-kernel routing request.
674 Really, it should be netlink message, but :-( netlink
675 can be not configured, so that we feed it directly
676 to fib engine. It is legal, because all events occur
677 only when netlink is already locked.
678 */
679
680 static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)
681 {
682 struct net *net = dev_net(ifa->ifa_dev->dev);
683 struct fib_table *tb;
684 struct fib_config cfg = {
685 .fc_protocol = RTPROT_KERNEL,
686 .fc_type = type,
687 .fc_dst = dst,
688 .fc_dst_len = dst_len,
689 .fc_prefsrc = ifa->ifa_local,
690 .fc_oif = ifa->ifa_dev->dev->ifindex,
691 .fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,
692 .fc_nlinfo = {
693 .nl_net = net,
694 },
695 };
696
697 if (type == RTN_UNICAST)
698 tb = fib_new_table(net, RT_TABLE_MAIN);
699 else
700 tb = fib_new_table(net, RT_TABLE_LOCAL);
701
702 if (tb == NULL)
703 return;
704
705 cfg.fc_table = tb->tb_id;
706
707 if (type != RTN_LOCAL)
708 cfg.fc_scope = RT_SCOPE_LINK;
709 else
710 cfg.fc_scope = RT_SCOPE_HOST;
711
712 if (cmd == RTM_NEWROUTE)
713 fib_table_insert(tb, &cfg);
714 else
715 fib_table_delete(tb, &cfg);
716 }
717
718 void fib_add_ifaddr(struct in_ifaddr *ifa)
719 {
720 struct in_device *in_dev = ifa->ifa_dev;
721 struct net_device *dev = in_dev->dev;
722 struct in_ifaddr *prim = ifa;
723 __be32 mask = ifa->ifa_mask;
724 __be32 addr = ifa->ifa_local;
725 __be32 prefix = ifa->ifa_address&mask;
726
727 if (ifa->ifa_flags&IFA_F_SECONDARY) {
728 prim = inet_ifa_byprefix(in_dev, prefix, mask);
729 if (prim == NULL) {
730 printk(KERN_WARNING "fib_add_ifaddr: bug: prim == NULL\n");
731 return;
732 }
733 }
734
735 fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
736
737 if (!(dev->flags&IFF_UP))
738 return;
739
740 /* Add broadcast address, if it is explicitly assigned. */
741 if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))
742 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
743
744 if (!ipv4_is_zeronet(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
745 (prefix != addr || ifa->ifa_prefixlen < 32)) {
746 fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
747 RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
748
749 /* Add network specific broadcasts, when it takes a sense */
750 if (ifa->ifa_prefixlen < 31) {
751 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
752 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim);
753 }
754 }
755 }
756
757 static void fib_del_ifaddr(struct in_ifaddr *ifa)
758 {
759 struct in_device *in_dev = ifa->ifa_dev;
760 struct net_device *dev = in_dev->dev;
761 struct in_ifaddr *ifa1;
762 struct in_ifaddr *prim = ifa;
763 __be32 brd = ifa->ifa_address|~ifa->ifa_mask;
764 __be32 any = ifa->ifa_address&ifa->ifa_mask;
765 #define LOCAL_OK 1
766 #define BRD_OK 2
767 #define BRD0_OK 4
768 #define BRD1_OK 8
769 unsigned ok = 0;
770
771 if (!(ifa->ifa_flags&IFA_F_SECONDARY))
772 fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
773 RTN_UNICAST, any, ifa->ifa_prefixlen, prim);
774 else {
775 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
776 if (prim == NULL) {
777 printk(KERN_WARNING "fib_del_ifaddr: bug: prim == NULL\n");
778 return;
779 }
780 }
781
782 /* Deletion is more complicated than add.
783 We should take care of not to delete too much :-)
784
785 Scan address list to be sure that addresses are really gone.
786 */
787
788 for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
789 if (ifa->ifa_local == ifa1->ifa_local)
790 ok |= LOCAL_OK;
791 if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
792 ok |= BRD_OK;
793 if (brd == ifa1->ifa_broadcast)
794 ok |= BRD1_OK;
795 if (any == ifa1->ifa_broadcast)
796 ok |= BRD0_OK;
797 }
798
799 if (!(ok&BRD_OK))
800 fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
801 if (!(ok&BRD1_OK))
802 fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
803 if (!(ok&BRD0_OK))
804 fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
805 if (!(ok&LOCAL_OK)) {
806 fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
807
808 /* Check, that this local address finally disappeared. */
809 if (inet_addr_type(dev_net(dev), ifa->ifa_local) != RTN_LOCAL) {
810 /* And the last, but not the least thing.
811 We must flush stray FIB entries.
812
813 First of all, we scan fib_info list searching
814 for stray nexthop entries, then ignite fib_flush.
815 */
816 if (fib_sync_down_addr(dev_net(dev), ifa->ifa_local))
817 fib_flush(dev_net(dev));
818 }
819 }
820 #undef LOCAL_OK
821 #undef BRD_OK
822 #undef BRD0_OK
823 #undef BRD1_OK
824 }
825
826 static void nl_fib_lookup(struct fib_result_nl *frn, struct fib_table *tb )
827 {
828
829 struct fib_result res;
830 struct flowi fl = { .mark = frn->fl_mark,
831 .nl_u = { .ip4_u = { .daddr = frn->fl_addr,
832 .tos = frn->fl_tos,
833 .scope = frn->fl_scope } } };
834
835 #ifdef CONFIG_IP_MULTIPLE_TABLES
836 res.r = NULL;
837 #endif
838
839 frn->err = -ENOENT;
840 if (tb) {
841 local_bh_disable();
842
843 frn->tb_id = tb->tb_id;
844 frn->err = fib_table_lookup(tb, &fl, &res);
845
846 if (!frn->err) {
847 frn->prefixlen = res.prefixlen;
848 frn->nh_sel = res.nh_sel;
849 frn->type = res.type;
850 frn->scope = res.scope;
851 fib_res_put(&res);
852 }
853 local_bh_enable();
854 }
855 }
856
857 static void nl_fib_input(struct sk_buff *skb)
858 {
859 struct net *net;
860 struct fib_result_nl *frn;
861 struct nlmsghdr *nlh;
862 struct fib_table *tb;
863 u32 pid;
864
865 net = sock_net(skb->sk);
866 nlh = nlmsg_hdr(skb);
867 if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len ||
868 nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn)))
869 return;
870
871 skb = skb_clone(skb, GFP_KERNEL);
872 if (skb == NULL)
873 return;
874 nlh = nlmsg_hdr(skb);
875
876 frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
877 tb = fib_get_table(net, frn->tb_id_in);
878
879 nl_fib_lookup(frn, tb);
880
881 pid = NETLINK_CB(skb).pid; /* pid of sending process */
882 NETLINK_CB(skb).pid = 0; /* from kernel */
883 NETLINK_CB(skb).dst_group = 0; /* unicast */
884 netlink_unicast(net->ipv4.fibnl, skb, pid, MSG_DONTWAIT);
885 }
886
887 static int __net_init nl_fib_lookup_init(struct net *net)
888 {
889 struct sock *sk;
890 sk = netlink_kernel_create(net, NETLINK_FIB_LOOKUP, 0,
891 nl_fib_input, NULL, THIS_MODULE);
892 if (sk == NULL)
893 return -EAFNOSUPPORT;
894 net->ipv4.fibnl = sk;
895 return 0;
896 }
897
898 static void nl_fib_lookup_exit(struct net *net)
899 {
900 netlink_kernel_release(net->ipv4.fibnl);
901 net->ipv4.fibnl = NULL;
902 }
903
904 static void fib_disable_ip(struct net_device *dev, int force, int delay)
905 {
906 if (fib_sync_down_dev(dev, force))
907 fib_flush(dev_net(dev));
908 rt_cache_flush(dev_net(dev), delay);
909 arp_ifdown(dev);
910 }
911
912 static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
913 {
914 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
915 struct net_device *dev = ifa->ifa_dev->dev;
916
917 switch (event) {
918 case NETDEV_UP:
919 fib_add_ifaddr(ifa);
920 #ifdef CONFIG_IP_ROUTE_MULTIPATH
921 fib_sync_up(dev);
922 #endif
923 rt_cache_flush(dev_net(dev), -1);
924 break;
925 case NETDEV_DOWN:
926 fib_del_ifaddr(ifa);
927 if (ifa->ifa_dev->ifa_list == NULL) {
928 /* Last address was deleted from this interface.
929 Disable IP.
930 */
931 fib_disable_ip(dev, 1, 0);
932 } else {
933 rt_cache_flush(dev_net(dev), -1);
934 }
935 break;
936 }
937 return NOTIFY_DONE;
938 }
939
940 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
941 {
942 struct net_device *dev = ptr;
943 struct in_device *in_dev = __in_dev_get_rtnl(dev);
944
945 if (event == NETDEV_UNREGISTER) {
946 fib_disable_ip(dev, 2, -1);
947 return NOTIFY_DONE;
948 }
949
950 if (!in_dev)
951 return NOTIFY_DONE;
952
953 switch (event) {
954 case NETDEV_UP:
955 for_ifa(in_dev) {
956 fib_add_ifaddr(ifa);
957 } endfor_ifa(in_dev);
958 #ifdef CONFIG_IP_ROUTE_MULTIPATH
959 fib_sync_up(dev);
960 #endif
961 rt_cache_flush(dev_net(dev), -1);
962 break;
963 case NETDEV_DOWN:
964 fib_disable_ip(dev, 0, 0);
965 break;
966 case NETDEV_CHANGEMTU:
967 case NETDEV_CHANGE:
968 rt_cache_flush(dev_net(dev), 0);
969 break;
970 case NETDEV_UNREGISTER_BATCH:
971 rt_cache_flush_batch();
972 break;
973 }
974 return NOTIFY_DONE;
975 }
976
977 static struct notifier_block fib_inetaddr_notifier = {
978 .notifier_call = fib_inetaddr_event,
979 };
980
981 static struct notifier_block fib_netdev_notifier = {
982 .notifier_call = fib_netdev_event,
983 };
984
985 static int __net_init ip_fib_net_init(struct net *net)
986 {
987 int err;
988 unsigned int i;
989
990 net->ipv4.fib_table_hash = kzalloc(
991 sizeof(struct hlist_head)*FIB_TABLE_HASHSZ, GFP_KERNEL);
992 if (net->ipv4.fib_table_hash == NULL)
993 return -ENOMEM;
994
995 for (i = 0; i < FIB_TABLE_HASHSZ; i++)
996 INIT_HLIST_HEAD(&net->ipv4.fib_table_hash[i]);
997
998 err = fib4_rules_init(net);
999 if (err < 0)
1000 goto fail;
1001 return 0;
1002
1003 fail:
1004 kfree(net->ipv4.fib_table_hash);
1005 return err;
1006 }
1007
1008 static void ip_fib_net_exit(struct net *net)
1009 {
1010 unsigned int i;
1011
1012 #ifdef CONFIG_IP_MULTIPLE_TABLES
1013 fib4_rules_exit(net);
1014 #endif
1015
1016 for (i = 0; i < FIB_TABLE_HASHSZ; i++) {
1017 struct fib_table *tb;
1018 struct hlist_head *head;
1019 struct hlist_node *node, *tmp;
1020
1021 head = &net->ipv4.fib_table_hash[i];
1022 hlist_for_each_entry_safe(tb, node, tmp, head, tb_hlist) {
1023 hlist_del(node);
1024 fib_table_flush(tb);
1025 kfree(tb);
1026 }
1027 }
1028 kfree(net->ipv4.fib_table_hash);
1029 }
1030
1031 static int __net_init fib_net_init(struct net *net)
1032 {
1033 int error;
1034
1035 error = ip_fib_net_init(net);
1036 if (error < 0)
1037 goto out;
1038 error = nl_fib_lookup_init(net);
1039 if (error < 0)
1040 goto out_nlfl;
1041 error = fib_proc_init(net);
1042 if (error < 0)
1043 goto out_proc;
1044 out:
1045 return error;
1046
1047 out_proc:
1048 nl_fib_lookup_exit(net);
1049 out_nlfl:
1050 ip_fib_net_exit(net);
1051 goto out;
1052 }
1053
1054 static void __net_exit fib_net_exit(struct net *net)
1055 {
1056 fib_proc_exit(net);
1057 nl_fib_lookup_exit(net);
1058 ip_fib_net_exit(net);
1059 }
1060
1061 static struct pernet_operations fib_net_ops = {
1062 .init = fib_net_init,
1063 .exit = fib_net_exit,
1064 };
1065
1066 void __init ip_fib_init(void)
1067 {
1068 rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL);
1069 rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL);
1070 rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib);
1071
1072 register_pernet_subsys(&fib_net_ops);
1073 register_netdevice_notifier(&fib_netdev_notifier);
1074 register_inetaddr_notifier(&fib_inetaddr_notifier);
1075
1076 fib_hash_init();
1077 }
1078
1079 EXPORT_SYMBOL(inet_addr_type);
1080 EXPORT_SYMBOL(inet_dev_addr_type);
1081 EXPORT_SYMBOL(ip_dev_find);
linux-next