?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
OMAP2/3: Add omap_type() for determining GP/EMU/HS
[linux-ginger.git] / net / ipv4 / fib_frontend.c
blobcafcc49d0993b6a6b39590f6c2246fc806eb463d
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
38 #include <net/ip.h>
39 #include <net/protocol.h>
40 #include <net/route.h>
41 #include <net/tcp.h>
42 #include <net/sock.h>
43 #include <net/icmp.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 tb->tb_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 += tb->tb_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 || local_table->tb_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 (!local_table->tb_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, u32 *itag)
234 {
235 struct in_device *in_dev;
236 struct flowi fl = { .nl_u = { .ip4_u =
237 { .daddr = src,
238 .saddr = dst,
239 .tos = tos } },
240 .iif = oif };
241 struct fib_result res;
242 int no_addr, rpf;
243 int ret;
244 struct net *net;
245
246 no_addr = rpf = 0;
247 rcu_read_lock();
248 in_dev = __in_dev_get_rcu(dev);
249 if (in_dev) {
250 no_addr = in_dev->ifa_list == NULL;
251 rpf = IN_DEV_RPFILTER(in_dev);
252 }
253 rcu_read_unlock();
254
255 if (in_dev == NULL)
256 goto e_inval;
257
258 net = dev_net(dev);
259 if (fib_lookup(net, &fl, &res))
260 goto last_resort;
261 if (res.type != RTN_UNICAST)
262 goto e_inval_res;
263 *spec_dst = FIB_RES_PREFSRC(res);
264 fib_combine_itag(itag, &res);
265 #ifdef CONFIG_IP_ROUTE_MULTIPATH
266 if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
267 #else
268 if (FIB_RES_DEV(res) == dev)
269 #endif
270 {
271 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
272 fib_res_put(&res);
273 return ret;
274 }
275 fib_res_put(&res);
276 if (no_addr)
277 goto last_resort;
278 if (rpf == 1)
279 goto e_inval;
280 fl.oif = dev->ifindex;
281
282 ret = 0;
283 if (fib_lookup(net, &fl, &res) == 0) {
284 if (res.type == RTN_UNICAST) {
285 *spec_dst = FIB_RES_PREFSRC(res);
286 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
287 }
288 fib_res_put(&res);
289 }
290 return ret;
291
292 last_resort:
293 if (rpf)
294 goto e_inval;
295 *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
296 *itag = 0;
297 return 0;
298
299 e_inval_res:
300 fib_res_put(&res);
301 e_inval:
302 return -EINVAL;
303 }
304
305 static inline __be32 sk_extract_addr(struct sockaddr *addr)
306 {
307 return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
308 }
309
310 static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
311 {
312 struct nlattr *nla;
313
314 nla = (struct nlattr *) ((char *) mx + len);
315 nla->nla_type = type;
316 nla->nla_len = nla_attr_size(4);
317 *(u32 *) nla_data(nla) = value;
318
319 return len + nla_total_size(4);
320 }
321
322 static int rtentry_to_fib_config(struct net *net, int cmd, struct rtentry *rt,
323 struct fib_config *cfg)
324 {
325 __be32 addr;
326 int plen;
327
328 memset(cfg, 0, sizeof(*cfg));
329 cfg->fc_nlinfo.nl_net = net;
330
331 if (rt->rt_dst.sa_family != AF_INET)
332 return -EAFNOSUPPORT;
333
334 /*
335 * Check mask for validity:
336 * a) it must be contiguous.
337 * b) destination must have all host bits clear.
338 * c) if application forgot to set correct family (AF_INET),
339 * reject request unless it is absolutely clear i.e.
340 * both family and mask are zero.
341 */
342 plen = 32;
343 addr = sk_extract_addr(&rt->rt_dst);
344 if (!(rt->rt_flags & RTF_HOST)) {
345 __be32 mask = sk_extract_addr(&rt->rt_genmask);
346
347 if (rt->rt_genmask.sa_family != AF_INET) {
348 if (mask || rt->rt_genmask.sa_family)
349 return -EAFNOSUPPORT;
350 }
351
352 if (bad_mask(mask, addr))
353 return -EINVAL;
354
355 plen = inet_mask_len(mask);
356 }
357
358 cfg->fc_dst_len = plen;
359 cfg->fc_dst = addr;
360
361 if (cmd != SIOCDELRT) {
362 cfg->fc_nlflags = NLM_F_CREATE;
363 cfg->fc_protocol = RTPROT_BOOT;
364 }
365
366 if (rt->rt_metric)
367 cfg->fc_priority = rt->rt_metric - 1;
368
369 if (rt->rt_flags & RTF_REJECT) {
370 cfg->fc_scope = RT_SCOPE_HOST;
371 cfg->fc_type = RTN_UNREACHABLE;
372 return 0;
373 }
374
375 cfg->fc_scope = RT_SCOPE_NOWHERE;
376 cfg->fc_type = RTN_UNICAST;
377
378 if (rt->rt_dev) {
379 char *colon;
380 struct net_device *dev;
381 char devname[IFNAMSIZ];
382
383 if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))
384 return -EFAULT;
385
386 devname[IFNAMSIZ-1] = 0;
387 colon = strchr(devname, ':');
388 if (colon)
389 *colon = 0;
390 dev = __dev_get_by_name(net, devname);
391 if (!dev)
392 return -ENODEV;
393 cfg->fc_oif = dev->ifindex;
394 if (colon) {
395 struct in_ifaddr *ifa;
396 struct in_device *in_dev = __in_dev_get_rtnl(dev);
397 if (!in_dev)
398 return -ENODEV;
399 *colon = ':';
400 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
401 if (strcmp(ifa->ifa_label, devname) == 0)
402 break;
403 if (ifa == NULL)
404 return -ENODEV;
405 cfg->fc_prefsrc = ifa->ifa_local;
406 }
407 }
408
409 addr = sk_extract_addr(&rt->rt_gateway);
410 if (rt->rt_gateway.sa_family == AF_INET && addr) {
411 cfg->fc_gw = addr;
412 if (rt->rt_flags & RTF_GATEWAY &&
413 inet_addr_type(net, addr) == RTN_UNICAST)
414 cfg->fc_scope = RT_SCOPE_UNIVERSE;
415 }
416
417 if (cmd == SIOCDELRT)
418 return 0;
419
420 if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw)
421 return -EINVAL;
422
423 if (cfg->fc_scope == RT_SCOPE_NOWHERE)
424 cfg->fc_scope = RT_SCOPE_LINK;
425
426 if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {
427 struct nlattr *mx;
428 int len = 0;
429
430 mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
431 if (mx == NULL)
432 return -ENOMEM;
433
434 if (rt->rt_flags & RTF_MTU)
435 len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);
436
437 if (rt->rt_flags & RTF_WINDOW)
438 len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);
439
440 if (rt->rt_flags & RTF_IRTT)
441 len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);
442
443 cfg->fc_mx = mx;
444 cfg->fc_mx_len = len;
445 }
446
447 return 0;
448 }
449
450 /*
451 * Handle IP routing ioctl calls. These are used to manipulate the routing tables
452 */
453
454 int ip_rt_ioctl(struct net *net, unsigned int cmd, void __user *arg)
455 {
456 struct fib_config cfg;
457 struct rtentry rt;
458 int err;
459
460 switch (cmd) {
461 case SIOCADDRT: /* Add a route */
462 case SIOCDELRT: /* Delete a route */
463 if (!capable(CAP_NET_ADMIN))
464 return -EPERM;
465
466 if (copy_from_user(&rt, arg, sizeof(rt)))
467 return -EFAULT;
468
469 rtnl_lock();
470 err = rtentry_to_fib_config(net, cmd, &rt, &cfg);
471 if (err == 0) {
472 struct fib_table *tb;
473
474 if (cmd == SIOCDELRT) {
475 tb = fib_get_table(net, cfg.fc_table);
476 if (tb)
477 err = tb->tb_delete(tb, &cfg);
478 else
479 err = -ESRCH;
480 } else {
481 tb = fib_new_table(net, cfg.fc_table);
482 if (tb)
483 err = tb->tb_insert(tb, &cfg);
484 else
485 err = -ENOBUFS;
486 }
487
488 /* allocated by rtentry_to_fib_config() */
489 kfree(cfg.fc_mx);
490 }
491 rtnl_unlock();
492 return err;
493 }
494 return -EINVAL;
495 }
496
497 const struct nla_policy rtm_ipv4_policy[RTA_MAX+1] = {
498 [RTA_DST] = { .type = NLA_U32 },
499 [RTA_SRC] = { .type = NLA_U32 },
500 [RTA_IIF] = { .type = NLA_U32 },
501 [RTA_OIF] = { .type = NLA_U32 },
502 [RTA_GATEWAY] = { .type = NLA_U32 },
503 [RTA_PRIORITY] = { .type = NLA_U32 },
504 [RTA_PREFSRC] = { .type = NLA_U32 },
505 [RTA_METRICS] = { .type = NLA_NESTED },
506 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
507 [RTA_FLOW] = { .type = NLA_U32 },
508 };
509
510 static int rtm_to_fib_config(struct net *net, struct sk_buff *skb,
511 struct nlmsghdr *nlh, struct fib_config *cfg)
512 {
513 struct nlattr *attr;
514 int err, remaining;
515 struct rtmsg *rtm;
516
517 err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);
518 if (err < 0)
519 goto errout;
520
521 memset(cfg, 0, sizeof(*cfg));
522
523 rtm = nlmsg_data(nlh);
524 cfg->fc_dst_len = rtm->rtm_dst_len;
525 cfg->fc_tos = rtm->rtm_tos;
526 cfg->fc_table = rtm->rtm_table;
527 cfg->fc_protocol = rtm->rtm_protocol;
528 cfg->fc_scope = rtm->rtm_scope;
529 cfg->fc_type = rtm->rtm_type;
530 cfg->fc_flags = rtm->rtm_flags;
531 cfg->fc_nlflags = nlh->nlmsg_flags;
532
533 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
534 cfg->fc_nlinfo.nlh = nlh;
535 cfg->fc_nlinfo.nl_net = net;
536
537 if (cfg->fc_type > RTN_MAX) {
538 err = -EINVAL;
539 goto errout;
540 }
541
542 nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
543 switch (nla_type(attr)) {
544 case RTA_DST:
545 cfg->fc_dst = nla_get_be32(attr);
546 break;
547 case RTA_OIF:
548 cfg->fc_oif = nla_get_u32(attr);
549 break;
550 case RTA_GATEWAY:
551 cfg->fc_gw = nla_get_be32(attr);
552 break;
553 case RTA_PRIORITY:
554 cfg->fc_priority = nla_get_u32(attr);
555 break;
556 case RTA_PREFSRC:
557 cfg->fc_prefsrc = nla_get_be32(attr);
558 break;
559 case RTA_METRICS:
560 cfg->fc_mx = nla_data(attr);
561 cfg->fc_mx_len = nla_len(attr);
562 break;
563 case RTA_MULTIPATH:
564 cfg->fc_mp = nla_data(attr);
565 cfg->fc_mp_len = nla_len(attr);
566 break;
567 case RTA_FLOW:
568 cfg->fc_flow = nla_get_u32(attr);
569 break;
570 case RTA_TABLE:
571 cfg->fc_table = nla_get_u32(attr);
572 break;
573 }
574 }
575
576 return 0;
577 errout:
578 return err;
579 }
580
581 static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
582 {
583 struct net *net = sock_net(skb->sk);
584 struct fib_config cfg;
585 struct fib_table *tb;
586 int err;
587
588 err = rtm_to_fib_config(net, skb, nlh, &cfg);
589 if (err < 0)
590 goto errout;
591
592 tb = fib_get_table(net, cfg.fc_table);
593 if (tb == NULL) {
594 err = -ESRCH;
595 goto errout;
596 }
597
598 err = tb->tb_delete(tb, &cfg);
599 errout:
600 return err;
601 }
602
603 static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
604 {
605 struct net *net = sock_net(skb->sk);
606 struct fib_config cfg;
607 struct fib_table *tb;
608 int err;
609
610 err = rtm_to_fib_config(net, skb, nlh, &cfg);
611 if (err < 0)
612 goto errout;
613
614 tb = fib_new_table(net, cfg.fc_table);
615 if (tb == NULL) {
616 err = -ENOBUFS;
617 goto errout;
618 }
619
620 err = tb->tb_insert(tb, &cfg);
621 errout:
622 return err;
623 }
624
625 static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
626 {
627 struct net *net = sock_net(skb->sk);
628 unsigned int h, s_h;
629 unsigned int e = 0, s_e;
630 struct fib_table *tb;
631 struct hlist_node *node;
632 struct hlist_head *head;
633 int dumped = 0;
634
635 if (nlmsg_len(cb->nlh) >= sizeof(struct rtmsg) &&
636 ((struct rtmsg *) nlmsg_data(cb->nlh))->rtm_flags & RTM_F_CLONED)
637 return ip_rt_dump(skb, cb);
638
639 s_h = cb->args[0];
640 s_e = cb->args[1];
641
642 for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
643 e = 0;
644 head = &net->ipv4.fib_table_hash[h];
645 hlist_for_each_entry(tb, node, head, tb_hlist) {
646 if (e < s_e)
647 goto next;
648 if (dumped)
649 memset(&cb->args[2], 0, sizeof(cb->args) -
650 2 * sizeof(cb->args[0]));
651 if (tb->tb_dump(tb, skb, cb) < 0)
652 goto out;
653 dumped = 1;
654 next:
655 e++;
656 }
657 }
658 out:
659 cb->args[1] = e;
660 cb->args[0] = h;
661
662 return skb->len;
663 }
664
665 /* Prepare and feed intra-kernel routing request.
666 Really, it should be netlink message, but :-( netlink
667 can be not configured, so that we feed it directly
668 to fib engine. It is legal, because all events occur
669 only when netlink is already locked.
670 */
671
672 static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)
673 {
674 struct net *net = dev_net(ifa->ifa_dev->dev);
675 struct fib_table *tb;
676 struct fib_config cfg = {
677 .fc_protocol = RTPROT_KERNEL,
678 .fc_type = type,
679 .fc_dst = dst,
680 .fc_dst_len = dst_len,
681 .fc_prefsrc = ifa->ifa_local,
682 .fc_oif = ifa->ifa_dev->dev->ifindex,
683 .fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,
684 .fc_nlinfo = {
685 .nl_net = net,
686 },
687 };
688
689 if (type == RTN_UNICAST)
690 tb = fib_new_table(net, RT_TABLE_MAIN);
691 else
692 tb = fib_new_table(net, RT_TABLE_LOCAL);
693
694 if (tb == NULL)
695 return;
696
697 cfg.fc_table = tb->tb_id;
698
699 if (type != RTN_LOCAL)
700 cfg.fc_scope = RT_SCOPE_LINK;
701 else
702 cfg.fc_scope = RT_SCOPE_HOST;
703
704 if (cmd == RTM_NEWROUTE)
705 tb->tb_insert(tb, &cfg);
706 else
707 tb->tb_delete(tb, &cfg);
708 }
709
710 void fib_add_ifaddr(struct in_ifaddr *ifa)
711 {
712 struct in_device *in_dev = ifa->ifa_dev;
713 struct net_device *dev = in_dev->dev;
714 struct in_ifaddr *prim = ifa;
715 __be32 mask = ifa->ifa_mask;
716 __be32 addr = ifa->ifa_local;
717 __be32 prefix = ifa->ifa_address&mask;
718
719 if (ifa->ifa_flags&IFA_F_SECONDARY) {
720 prim = inet_ifa_byprefix(in_dev, prefix, mask);
721 if (prim == NULL) {
722 printk(KERN_WARNING "fib_add_ifaddr: bug: prim == NULL\n");
723 return;
724 }
725 }
726
727 fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
728
729 if (!(dev->flags&IFF_UP))
730 return;
731
732 /* Add broadcast address, if it is explicitly assigned. */
733 if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))
734 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
735
736 if (!ipv4_is_zeronet(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
737 (prefix != addr || ifa->ifa_prefixlen < 32)) {
738 fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
739 RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
740
741 /* Add network specific broadcasts, when it takes a sense */
742 if (ifa->ifa_prefixlen < 31) {
743 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
744 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim);
745 }
746 }
747 }
748
749 static void fib_del_ifaddr(struct in_ifaddr *ifa)
750 {
751 struct in_device *in_dev = ifa->ifa_dev;
752 struct net_device *dev = in_dev->dev;
753 struct in_ifaddr *ifa1;
754 struct in_ifaddr *prim = ifa;
755 __be32 brd = ifa->ifa_address|~ifa->ifa_mask;
756 __be32 any = ifa->ifa_address&ifa->ifa_mask;
757 #define LOCAL_OK 1
758 #define BRD_OK 2
759 #define BRD0_OK 4
760 #define BRD1_OK 8
761 unsigned ok = 0;
762
763 if (!(ifa->ifa_flags&IFA_F_SECONDARY))
764 fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
765 RTN_UNICAST, any, ifa->ifa_prefixlen, prim);
766 else {
767 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
768 if (prim == NULL) {
769 printk(KERN_WARNING "fib_del_ifaddr: bug: prim == NULL\n");
770 return;
771 }
772 }
773
774 /* Deletion is more complicated than add.
775 We should take care of not to delete too much :-)
776
777 Scan address list to be sure that addresses are really gone.
778 */
779
780 for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
781 if (ifa->ifa_local == ifa1->ifa_local)
782 ok |= LOCAL_OK;
783 if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
784 ok |= BRD_OK;
785 if (brd == ifa1->ifa_broadcast)
786 ok |= BRD1_OK;
787 if (any == ifa1->ifa_broadcast)
788 ok |= BRD0_OK;
789 }
790
791 if (!(ok&BRD_OK))
792 fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
793 if (!(ok&BRD1_OK))
794 fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
795 if (!(ok&BRD0_OK))
796 fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
797 if (!(ok&LOCAL_OK)) {
798 fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
799
800 /* Check, that this local address finally disappeared. */
801 if (inet_addr_type(dev_net(dev), ifa->ifa_local) != RTN_LOCAL) {
802 /* And the last, but not the least thing.
803 We must flush stray FIB entries.
804
805 First of all, we scan fib_info list searching
806 for stray nexthop entries, then ignite fib_flush.
807 */
808 if (fib_sync_down_addr(dev_net(dev), ifa->ifa_local))
809 fib_flush(dev_net(dev));
810 }
811 }
812 #undef LOCAL_OK
813 #undef BRD_OK
814 #undef BRD0_OK
815 #undef BRD1_OK
816 }
817
818 static void nl_fib_lookup(struct fib_result_nl *frn, struct fib_table *tb )
819 {
820
821 struct fib_result res;
822 struct flowi fl = { .mark = frn->fl_mark,
823 .nl_u = { .ip4_u = { .daddr = frn->fl_addr,
824 .tos = frn->fl_tos,
825 .scope = frn->fl_scope } } };
826
827 #ifdef CONFIG_IP_MULTIPLE_TABLES
828 res.r = NULL;
829 #endif
830
831 frn->err = -ENOENT;
832 if (tb) {
833 local_bh_disable();
834
835 frn->tb_id = tb->tb_id;
836 frn->err = tb->tb_lookup(tb, &fl, &res);
837
838 if (!frn->err) {
839 frn->prefixlen = res.prefixlen;
840 frn->nh_sel = res.nh_sel;
841 frn->type = res.type;
842 frn->scope = res.scope;
843 fib_res_put(&res);
844 }
845 local_bh_enable();
846 }
847 }
848
849 static void nl_fib_input(struct sk_buff *skb)
850 {
851 struct net *net;
852 struct fib_result_nl *frn;
853 struct nlmsghdr *nlh;
854 struct fib_table *tb;
855 u32 pid;
856
857 net = sock_net(skb->sk);
858 nlh = nlmsg_hdr(skb);
859 if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len ||
860 nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn)))
861 return;
862
863 skb = skb_clone(skb, GFP_KERNEL);
864 if (skb == NULL)
865 return;
866 nlh = nlmsg_hdr(skb);
867
868 frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
869 tb = fib_get_table(net, frn->tb_id_in);
870
871 nl_fib_lookup(frn, tb);
872
873 pid = NETLINK_CB(skb).pid; /* pid of sending process */
874 NETLINK_CB(skb).pid = 0; /* from kernel */
875 NETLINK_CB(skb).dst_group = 0; /* unicast */
876 netlink_unicast(net->ipv4.fibnl, skb, pid, MSG_DONTWAIT);
877 }
878
879 static int nl_fib_lookup_init(struct net *net)
880 {
881 struct sock *sk;
882 sk = netlink_kernel_create(net, NETLINK_FIB_LOOKUP, 0,
883 nl_fib_input, NULL, THIS_MODULE);
884 if (sk == NULL)
885 return -EAFNOSUPPORT;
886 net->ipv4.fibnl = sk;
887 return 0;
888 }
889
890 static void nl_fib_lookup_exit(struct net *net)
891 {
892 netlink_kernel_release(net->ipv4.fibnl);
893 net->ipv4.fibnl = NULL;
894 }
895
896 static void fib_disable_ip(struct net_device *dev, int force)
897 {
898 if (fib_sync_down_dev(dev, force))
899 fib_flush(dev_net(dev));
900 rt_cache_flush(dev_net(dev), 0);
901 arp_ifdown(dev);
902 }
903
904 static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
905 {
906 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
907 struct net_device *dev = ifa->ifa_dev->dev;
908
909 switch (event) {
910 case NETDEV_UP:
911 fib_add_ifaddr(ifa);
912 #ifdef CONFIG_IP_ROUTE_MULTIPATH
913 fib_sync_up(dev);
914 #endif
915 rt_cache_flush(dev_net(dev), -1);
916 break;
917 case NETDEV_DOWN:
918 fib_del_ifaddr(ifa);
919 if (ifa->ifa_dev->ifa_list == NULL) {
920 /* Last address was deleted from this interface.
921 Disable IP.
922 */
923 fib_disable_ip(dev, 1);
924 } else {
925 rt_cache_flush(dev_net(dev), -1);
926 }
927 break;
928 }
929 return NOTIFY_DONE;
930 }
931
932 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
933 {
934 struct net_device *dev = ptr;
935 struct in_device *in_dev = __in_dev_get_rtnl(dev);
936
937 if (event == NETDEV_UNREGISTER) {
938 fib_disable_ip(dev, 2);
939 return NOTIFY_DONE;
940 }
941
942 if (!in_dev)
943 return NOTIFY_DONE;
944
945 switch (event) {
946 case NETDEV_UP:
947 for_ifa(in_dev) {
948 fib_add_ifaddr(ifa);
949 } endfor_ifa(in_dev);
950 #ifdef CONFIG_IP_ROUTE_MULTIPATH
951 fib_sync_up(dev);
952 #endif
953 rt_cache_flush(dev_net(dev), -1);
954 break;
955 case NETDEV_DOWN:
956 fib_disable_ip(dev, 0);
957 break;
958 case NETDEV_CHANGEMTU:
959 case NETDEV_CHANGE:
960 rt_cache_flush(dev_net(dev), 0);
961 break;
962 }
963 return NOTIFY_DONE;
964 }
965
966 static struct notifier_block fib_inetaddr_notifier = {
967 .notifier_call = fib_inetaddr_event,
968 };
969
970 static struct notifier_block fib_netdev_notifier = {
971 .notifier_call = fib_netdev_event,
972 };
973
974 static int __net_init ip_fib_net_init(struct net *net)
975 {
976 int err;
977 unsigned int i;
978
979 net->ipv4.fib_table_hash = kzalloc(
980 sizeof(struct hlist_head)*FIB_TABLE_HASHSZ, GFP_KERNEL);
981 if (net->ipv4.fib_table_hash == NULL)
982 return -ENOMEM;
983
984 for (i = 0; i < FIB_TABLE_HASHSZ; i++)
985 INIT_HLIST_HEAD(&net->ipv4.fib_table_hash[i]);
986
987 err = fib4_rules_init(net);
988 if (err < 0)
989 goto fail;
990 return 0;
991
992 fail:
993 kfree(net->ipv4.fib_table_hash);
994 return err;
995 }
996
997 static void __net_exit ip_fib_net_exit(struct net *net)
998 {
999 unsigned int i;
1000
1001 #ifdef CONFIG_IP_MULTIPLE_TABLES
1002 fib4_rules_exit(net);
1003 #endif
1004
1005 for (i = 0; i < FIB_TABLE_HASHSZ; i++) {
1006 struct fib_table *tb;
1007 struct hlist_head *head;
1008 struct hlist_node *node, *tmp;
1009
1010 head = &net->ipv4.fib_table_hash[i];
1011 hlist_for_each_entry_safe(tb, node, tmp, head, tb_hlist) {
1012 hlist_del(node);
1013 tb->tb_flush(tb);
1014 kfree(tb);
1015 }
1016 }
1017 kfree(net->ipv4.fib_table_hash);
1018 }
1019
1020 static int __net_init fib_net_init(struct net *net)
1021 {
1022 int error;
1023
1024 error = ip_fib_net_init(net);
1025 if (error < 0)
1026 goto out;
1027 error = nl_fib_lookup_init(net);
1028 if (error < 0)
1029 goto out_nlfl;
1030 error = fib_proc_init(net);
1031 if (error < 0)
1032 goto out_proc;
1033 out:
1034 return error;
1035
1036 out_proc:
1037 nl_fib_lookup_exit(net);
1038 out_nlfl:
1039 ip_fib_net_exit(net);
1040 goto out;
1041 }
1042
1043 static void __net_exit fib_net_exit(struct net *net)
1044 {
1045 fib_proc_exit(net);
1046 nl_fib_lookup_exit(net);
1047 ip_fib_net_exit(net);
1048 }
1049
1050 static struct pernet_operations fib_net_ops = {
1051 .init = fib_net_init,
1052 .exit = fib_net_exit,
1053 };
1054
1055 void __init ip_fib_init(void)
1056 {
1057 rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL);
1058 rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL);
1059 rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib);
1060
1061 register_pernet_subsys(&fib_net_ops);
1062 register_netdevice_notifier(&fib_netdev_notifier);
1063 register_inetaddr_notifier(&fib_inetaddr_notifier);
1064
1065 fib_hash_init();
1066 }
1067
1068 EXPORT_SYMBOL(inet_addr_type);
1069 EXPORT_SYMBOL(inet_dev_addr_type);
1070 EXPORT_SYMBOL(ip_dev_find);
Linux for Ginger Game Console