?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
b43: Eliminate compilation warning in b43_op_set_key
[linux-2.6/btrfs-unstable.git] / net / ipv4 / ipmr.c
blob21a6dc710f20a5d08866f30ecb8e1f0298c204b3
1 /*
2 * IP multicast routing support for mrouted 3.6/3.8
3 *
4 * (c) 1995 Alan Cox, <alan@lxorguk.ukuu.org.uk>
5 * Linux Consultancy and Custom Driver Development
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 * Fixes:
13 * Michael Chastain : Incorrect size of copying.
14 * Alan Cox : Added the cache manager code
15 * Alan Cox : Fixed the clone/copy bug and device race.
16 * Mike McLagan : Routing by source
17 * Malcolm Beattie : Buffer handling fixes.
18 * Alexey Kuznetsov : Double buffer free and other fixes.
19 * SVR Anand : Fixed several multicast bugs and problems.
20 * Alexey Kuznetsov : Status, optimisations and more.
21 * Brad Parker : Better behaviour on mrouted upcall
22 * overflow.
23 * Carlos Picoto : PIMv1 Support
24 * Pavlin Ivanov Radoslavov: PIMv2 Registers must checksum only PIM header
25 * Relax this requrement to work with older peers.
26 *
27 */
28
29 #include <asm/system.h>
30 #include <asm/uaccess.h>
31 #include <linux/types.h>
32 #include <linux/capability.h>
33 #include <linux/errno.h>
34 #include <linux/timer.h>
35 #include <linux/mm.h>
36 #include <linux/kernel.h>
37 #include <linux/fcntl.h>
38 #include <linux/stat.h>
39 #include <linux/socket.h>
40 #include <linux/in.h>
41 #include <linux/inet.h>
42 #include <linux/netdevice.h>
43 #include <linux/inetdevice.h>
44 #include <linux/igmp.h>
45 #include <linux/proc_fs.h>
46 #include <linux/seq_file.h>
47 #include <linux/mroute.h>
48 #include <linux/init.h>
49 #include <linux/if_ether.h>
50 #include <net/net_namespace.h>
51 #include <net/ip.h>
52 #include <net/protocol.h>
53 #include <linux/skbuff.h>
54 #include <net/route.h>
55 #include <net/sock.h>
56 #include <net/icmp.h>
57 #include <net/udp.h>
58 #include <net/raw.h>
59 #include <linux/notifier.h>
60 #include <linux/if_arp.h>
61 #include <linux/netfilter_ipv4.h>
62 #include <net/ipip.h>
63 #include <net/checksum.h>
64 #include <net/netlink.h>
65
66 #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
67 #define CONFIG_IP_PIMSM 1
68 #endif
69
70 /* Big lock, protecting vif table, mrt cache and mroute socket state.
71 Note that the changes are semaphored via rtnl_lock.
72 */
73
74 static DEFINE_RWLOCK(mrt_lock);
75
76 /*
77 * Multicast router control variables
78 */
79
80 #define VIF_EXISTS(_net, _idx) ((_net)->ipv4.vif_table[_idx].dev != NULL)
81
82 static struct mfc_cache *mfc_unres_queue; /* Queue of unresolved entries */
83
84 /* Special spinlock for queue of unresolved entries */
85 static DEFINE_SPINLOCK(mfc_unres_lock);
86
87 /* We return to original Alan's scheme. Hash table of resolved
88 entries is changed only in process context and protected
89 with weak lock mrt_lock. Queue of unresolved entries is protected
90 with strong spinlock mfc_unres_lock.
91
92 In this case data path is free of exclusive locks at all.
93 */
94
95 static struct kmem_cache *mrt_cachep __read_mostly;
96
97 static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local);
98 static int ipmr_cache_report(struct net *net,
99 struct sk_buff *pkt, vifi_t vifi, int assert);
100 static int ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm);
101
102 #ifdef CONFIG_IP_PIMSM_V2
103 static struct net_protocol pim_protocol;
104 #endif
105
106 static struct timer_list ipmr_expire_timer;
107
108 /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
109
110 static void ipmr_del_tunnel(struct net_device *dev, struct vifctl *v)
111 {
112 struct net *net = dev_net(dev);
113
114 dev_close(dev);
115
116 dev = __dev_get_by_name(net, "tunl0");
117 if (dev) {
118 const struct net_device_ops *ops = dev->netdev_ops;
119 struct ifreq ifr;
120 struct ip_tunnel_parm p;
121
122 memset(&p, 0, sizeof(p));
123 p.iph.daddr = v->vifc_rmt_addr.s_addr;
124 p.iph.saddr = v->vifc_lcl_addr.s_addr;
125 p.iph.version = 4;
126 p.iph.ihl = 5;
127 p.iph.protocol = IPPROTO_IPIP;
128 sprintf(p.name, "dvmrp%d", v->vifc_vifi);
129 ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
130
131 if (ops->ndo_do_ioctl) {
132 mm_segment_t oldfs = get_fs();
133
134 set_fs(KERNEL_DS);
135 ops->ndo_do_ioctl(dev, &ifr, SIOCDELTUNNEL);
136 set_fs(oldfs);
137 }
138 }
139 }
140
141 static
142 struct net_device *ipmr_new_tunnel(struct net *net, struct vifctl *v)
143 {
144 struct net_device *dev;
145
146 dev = __dev_get_by_name(net, "tunl0");
147
148 if (dev) {
149 const struct net_device_ops *ops = dev->netdev_ops;
150 int err;
151 struct ifreq ifr;
152 struct ip_tunnel_parm p;
153 struct in_device *in_dev;
154
155 memset(&p, 0, sizeof(p));
156 p.iph.daddr = v->vifc_rmt_addr.s_addr;
157 p.iph.saddr = v->vifc_lcl_addr.s_addr;
158 p.iph.version = 4;
159 p.iph.ihl = 5;
160 p.iph.protocol = IPPROTO_IPIP;
161 sprintf(p.name, "dvmrp%d", v->vifc_vifi);
162 ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
163
164 if (ops->ndo_do_ioctl) {
165 mm_segment_t oldfs = get_fs();
166
167 set_fs(KERNEL_DS);
168 err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL);
169 set_fs(oldfs);
170 } else
171 err = -EOPNOTSUPP;
172
173 dev = NULL;
174
175 if (err == 0 &&
176 (dev = __dev_get_by_name(net, p.name)) != NULL) {
177 dev->flags |= IFF_MULTICAST;
178
179 in_dev = __in_dev_get_rtnl(dev);
180 if (in_dev == NULL)
181 goto failure;
182
183 ipv4_devconf_setall(in_dev);
184 IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
185
186 if (dev_open(dev))
187 goto failure;
188 dev_hold(dev);
189 }
190 }
191 return dev;
192
193 failure:
194 /* allow the register to be completed before unregistering. */
195 rtnl_unlock();
196 rtnl_lock();
197
198 unregister_netdevice(dev);
199 return NULL;
200 }
201
202 #ifdef CONFIG_IP_PIMSM
203
204 static int reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
205 {
206 struct net *net = dev_net(dev);
207
208 read_lock(&mrt_lock);
209 dev->stats.tx_bytes += skb->len;
210 dev->stats.tx_packets++;
211 ipmr_cache_report(net, skb, net->ipv4.mroute_reg_vif_num,
212 IGMPMSG_WHOLEPKT);
213 read_unlock(&mrt_lock);
214 kfree_skb(skb);
215 return 0;
216 }
217
218 static const struct net_device_ops reg_vif_netdev_ops = {
219 .ndo_start_xmit = reg_vif_xmit,
220 };
221
222 static void reg_vif_setup(struct net_device *dev)
223 {
224 dev->type = ARPHRD_PIMREG;
225 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 8;
226 dev->flags = IFF_NOARP;
227 dev->netdev_ops = &reg_vif_netdev_ops,
228 dev->destructor = free_netdev;
229 }
230
231 static struct net_device *ipmr_reg_vif(void)
232 {
233 struct net_device *dev;
234 struct in_device *in_dev;
235
236 dev = alloc_netdev(0, "pimreg", reg_vif_setup);
237
238 if (dev == NULL)
239 return NULL;
240
241 if (register_netdevice(dev)) {
242 free_netdev(dev);
243 return NULL;
244 }
245 dev->iflink = 0;
246
247 rcu_read_lock();
248 if ((in_dev = __in_dev_get_rcu(dev)) == NULL) {
249 rcu_read_unlock();
250 goto failure;
251 }
252
253 ipv4_devconf_setall(in_dev);
254 IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
255 rcu_read_unlock();
256
257 if (dev_open(dev))
258 goto failure;
259
260 dev_hold(dev);
261
262 return dev;
263
264 failure:
265 /* allow the register to be completed before unregistering. */
266 rtnl_unlock();
267 rtnl_lock();
268
269 unregister_netdevice(dev);
270 return NULL;
271 }
272 #endif
273
274 /*
275 * Delete a VIF entry
276 * @notify: Set to 1, if the caller is a notifier_call
277 */
278
279 static int vif_delete(struct net *net, int vifi, int notify)
280 {
281 struct vif_device *v;
282 struct net_device *dev;
283 struct in_device *in_dev;
284
285 if (vifi < 0 || vifi >= net->ipv4.maxvif)
286 return -EADDRNOTAVAIL;
287
288 v = &net->ipv4.vif_table[vifi];
289
290 write_lock_bh(&mrt_lock);
291 dev = v->dev;
292 v->dev = NULL;
293
294 if (!dev) {
295 write_unlock_bh(&mrt_lock);
296 return -EADDRNOTAVAIL;
297 }
298
299 #ifdef CONFIG_IP_PIMSM
300 if (vifi == net->ipv4.mroute_reg_vif_num)
301 net->ipv4.mroute_reg_vif_num = -1;
302 #endif
303
304 if (vifi+1 == net->ipv4.maxvif) {
305 int tmp;
306 for (tmp=vifi-1; tmp>=0; tmp--) {
307 if (VIF_EXISTS(net, tmp))
308 break;
309 }
310 net->ipv4.maxvif = tmp+1;
311 }
312
313 write_unlock_bh(&mrt_lock);
314
315 dev_set_allmulti(dev, -1);
316
317 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
318 IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)--;
319 ip_rt_multicast_event(in_dev);
320 }
321
322 if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER) && !notify)
323 unregister_netdevice(dev);
324
325 dev_put(dev);
326 return 0;
327 }
328
329 static inline void ipmr_cache_free(struct mfc_cache *c)
330 {
331 release_net(mfc_net(c));
332 kmem_cache_free(mrt_cachep, c);
333 }
334
335 /* Destroy an unresolved cache entry, killing queued skbs
336 and reporting error to netlink readers.
337 */
338
339 static void ipmr_destroy_unres(struct mfc_cache *c)
340 {
341 struct sk_buff *skb;
342 struct nlmsgerr *e;
343 struct net *net = mfc_net(c);
344
345 atomic_dec(&net->ipv4.cache_resolve_queue_len);
346
347 while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved))) {
348 if (ip_hdr(skb)->version == 0) {
349 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
350 nlh->nlmsg_type = NLMSG_ERROR;
351 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
352 skb_trim(skb, nlh->nlmsg_len);
353 e = NLMSG_DATA(nlh);
354 e->error = -ETIMEDOUT;
355 memset(&e->msg, 0, sizeof(e->msg));
356
357 rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
358 } else
359 kfree_skb(skb);
360 }
361
362 ipmr_cache_free(c);
363 }
364
365
366 /* Single timer process for all the unresolved queue. */
367
368 static void ipmr_expire_process(unsigned long dummy)
369 {
370 unsigned long now;
371 unsigned long expires;
372 struct mfc_cache *c, **cp;
373
374 if (!spin_trylock(&mfc_unres_lock)) {
375 mod_timer(&ipmr_expire_timer, jiffies+HZ/10);
376 return;
377 }
378
379 if (mfc_unres_queue == NULL)
380 goto out;
381
382 now = jiffies;
383 expires = 10*HZ;
384 cp = &mfc_unres_queue;
385
386 while ((c=*cp) != NULL) {
387 if (time_after(c->mfc_un.unres.expires, now)) {
388 unsigned long interval = c->mfc_un.unres.expires - now;
389 if (interval < expires)
390 expires = interval;
391 cp = &c->next;
392 continue;
393 }
394
395 *cp = c->next;
396
397 ipmr_destroy_unres(c);
398 }
399
400 if (mfc_unres_queue != NULL)
401 mod_timer(&ipmr_expire_timer, jiffies + expires);
402
403 out:
404 spin_unlock(&mfc_unres_lock);
405 }
406
407 /* Fill oifs list. It is called under write locked mrt_lock. */
408
409 static void ipmr_update_thresholds(struct mfc_cache *cache, unsigned char *ttls)
410 {
411 int vifi;
412 struct net *net = mfc_net(cache);
413
414 cache->mfc_un.res.minvif = MAXVIFS;
415 cache->mfc_un.res.maxvif = 0;
416 memset(cache->mfc_un.res.ttls, 255, MAXVIFS);
417
418 for (vifi = 0; vifi < net->ipv4.maxvif; vifi++) {
419 if (VIF_EXISTS(net, vifi) &&
420 ttls[vifi] && ttls[vifi] < 255) {
421 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
422 if (cache->mfc_un.res.minvif > vifi)
423 cache->mfc_un.res.minvif = vifi;
424 if (cache->mfc_un.res.maxvif <= vifi)
425 cache->mfc_un.res.maxvif = vifi + 1;
426 }
427 }
428 }
429
430 static int vif_add(struct net *net, struct vifctl *vifc, int mrtsock)
431 {
432 int vifi = vifc->vifc_vifi;
433 struct vif_device *v = &net->ipv4.vif_table[vifi];
434 struct net_device *dev;
435 struct in_device *in_dev;
436 int err;
437
438 /* Is vif busy ? */
439 if (VIF_EXISTS(net, vifi))
440 return -EADDRINUSE;
441
442 switch (vifc->vifc_flags) {
443 #ifdef CONFIG_IP_PIMSM
444 case VIFF_REGISTER:
445 /*
446 * Special Purpose VIF in PIM
447 * All the packets will be sent to the daemon
448 */
449 if (net->ipv4.mroute_reg_vif_num >= 0)
450 return -EADDRINUSE;
451 dev = ipmr_reg_vif();
452 if (!dev)
453 return -ENOBUFS;
454 err = dev_set_allmulti(dev, 1);
455 if (err) {
456 unregister_netdevice(dev);
457 dev_put(dev);
458 return err;
459 }
460 break;
461 #endif
462 case VIFF_TUNNEL:
463 dev = ipmr_new_tunnel(net, vifc);
464 if (!dev)
465 return -ENOBUFS;
466 err = dev_set_allmulti(dev, 1);
467 if (err) {
468 ipmr_del_tunnel(dev, vifc);
469 dev_put(dev);
470 return err;
471 }
472 break;
473 case 0:
474 dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr);
475 if (!dev)
476 return -EADDRNOTAVAIL;
477 err = dev_set_allmulti(dev, 1);
478 if (err) {
479 dev_put(dev);
480 return err;
481 }
482 break;
483 default:
484 return -EINVAL;
485 }
486
487 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL)
488 return -EADDRNOTAVAIL;
489 IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)++;
490 ip_rt_multicast_event(in_dev);
491
492 /*
493 * Fill in the VIF structures
494 */
495 v->rate_limit = vifc->vifc_rate_limit;
496 v->local = vifc->vifc_lcl_addr.s_addr;
497 v->remote = vifc->vifc_rmt_addr.s_addr;
498 v->flags = vifc->vifc_flags;
499 if (!mrtsock)
500 v->flags |= VIFF_STATIC;
501 v->threshold = vifc->vifc_threshold;
502 v->bytes_in = 0;
503 v->bytes_out = 0;
504 v->pkt_in = 0;
505 v->pkt_out = 0;
506 v->link = dev->ifindex;
507 if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER))
508 v->link = dev->iflink;
509
510 /* And finish update writing critical data */
511 write_lock_bh(&mrt_lock);
512 v->dev = dev;
513 #ifdef CONFIG_IP_PIMSM
514 if (v->flags&VIFF_REGISTER)
515 net->ipv4.mroute_reg_vif_num = vifi;
516 #endif
517 if (vifi+1 > net->ipv4.maxvif)
518 net->ipv4.maxvif = vifi+1;
519 write_unlock_bh(&mrt_lock);
520 return 0;
521 }
522
523 static struct mfc_cache *ipmr_cache_find(struct net *net,
524 __be32 origin,
525 __be32 mcastgrp)
526 {
527 int line = MFC_HASH(mcastgrp, origin);
528 struct mfc_cache *c;
529
530 for (c = net->ipv4.mfc_cache_array[line]; c; c = c->next) {
531 if (c->mfc_origin==origin && c->mfc_mcastgrp==mcastgrp)
532 break;
533 }
534 return c;
535 }
536
537 /*
538 * Allocate a multicast cache entry
539 */
540 static struct mfc_cache *ipmr_cache_alloc(struct net *net)
541 {
542 struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
543 if (c == NULL)
544 return NULL;
545 c->mfc_un.res.minvif = MAXVIFS;
546 mfc_net_set(c, net);
547 return c;
548 }
549
550 static struct mfc_cache *ipmr_cache_alloc_unres(struct net *net)
551 {
552 struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
553 if (c == NULL)
554 return NULL;
555 skb_queue_head_init(&c->mfc_un.unres.unresolved);
556 c->mfc_un.unres.expires = jiffies + 10*HZ;
557 mfc_net_set(c, net);
558 return c;
559 }
560
561 /*
562 * A cache entry has gone into a resolved state from queued
563 */
564
565 static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c)
566 {
567 struct sk_buff *skb;
568 struct nlmsgerr *e;
569
570 /*
571 * Play the pending entries through our router
572 */
573
574 while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
575 if (ip_hdr(skb)->version == 0) {
576 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
577
578 if (ipmr_fill_mroute(skb, c, NLMSG_DATA(nlh)) > 0) {
579 nlh->nlmsg_len = (skb_tail_pointer(skb) -
580 (u8 *)nlh);
581 } else {
582 nlh->nlmsg_type = NLMSG_ERROR;
583 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
584 skb_trim(skb, nlh->nlmsg_len);
585 e = NLMSG_DATA(nlh);
586 e->error = -EMSGSIZE;
587 memset(&e->msg, 0, sizeof(e->msg));
588 }
589
590 rtnl_unicast(skb, mfc_net(c), NETLINK_CB(skb).pid);
591 } else
592 ip_mr_forward(skb, c, 0);
593 }
594 }
595
596 /*
597 * Bounce a cache query up to mrouted. We could use netlink for this but mrouted
598 * expects the following bizarre scheme.
599 *
600 * Called under mrt_lock.
601 */
602
603 static int ipmr_cache_report(struct net *net,
604 struct sk_buff *pkt, vifi_t vifi, int assert)
605 {
606 struct sk_buff *skb;
607 const int ihl = ip_hdrlen(pkt);
608 struct igmphdr *igmp;
609 struct igmpmsg *msg;
610 int ret;
611
612 #ifdef CONFIG_IP_PIMSM
613 if (assert == IGMPMSG_WHOLEPKT)
614 skb = skb_realloc_headroom(pkt, sizeof(struct iphdr));
615 else
616 #endif
617 skb = alloc_skb(128, GFP_ATOMIC);
618
619 if (!skb)
620 return -ENOBUFS;
621
622 #ifdef CONFIG_IP_PIMSM
623 if (assert == IGMPMSG_WHOLEPKT) {
624 /* Ugly, but we have no choice with this interface.
625 Duplicate old header, fix ihl, length etc.
626 And all this only to mangle msg->im_msgtype and
627 to set msg->im_mbz to "mbz" :-)
628 */
629 skb_push(skb, sizeof(struct iphdr));
630 skb_reset_network_header(skb);
631 skb_reset_transport_header(skb);
632 msg = (struct igmpmsg *)skb_network_header(skb);
633 memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
634 msg->im_msgtype = IGMPMSG_WHOLEPKT;
635 msg->im_mbz = 0;
636 msg->im_vif = net->ipv4.mroute_reg_vif_num;
637 ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2;
638 ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) +
639 sizeof(struct iphdr));
640 } else
641 #endif
642 {
643
644 /*
645 * Copy the IP header
646 */
647
648 skb->network_header = skb->tail;
649 skb_put(skb, ihl);
650 skb_copy_to_linear_data(skb, pkt->data, ihl);
651 ip_hdr(skb)->protocol = 0; /* Flag to the kernel this is a route add */
652 msg = (struct igmpmsg *)skb_network_header(skb);
653 msg->im_vif = vifi;
654 skb->dst = dst_clone(pkt->dst);
655
656 /*
657 * Add our header
658 */
659
660 igmp=(struct igmphdr *)skb_put(skb, sizeof(struct igmphdr));
661 igmp->type =
662 msg->im_msgtype = assert;
663 igmp->code = 0;
664 ip_hdr(skb)->tot_len = htons(skb->len); /* Fix the length */
665 skb->transport_header = skb->network_header;
666 }
667
668 if (net->ipv4.mroute_sk == NULL) {
669 kfree_skb(skb);
670 return -EINVAL;
671 }
672
673 /*
674 * Deliver to mrouted
675 */
676 ret = sock_queue_rcv_skb(net->ipv4.mroute_sk, skb);
677 if (ret < 0) {
678 if (net_ratelimit())
679 printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n");
680 kfree_skb(skb);
681 }
682
683 return ret;
684 }
685
686 /*
687 * Queue a packet for resolution. It gets locked cache entry!
688 */
689
690 static int
691 ipmr_cache_unresolved(struct net *net, vifi_t vifi, struct sk_buff *skb)
692 {
693 int err;
694 struct mfc_cache *c;
695 const struct iphdr *iph = ip_hdr(skb);
696
697 spin_lock_bh(&mfc_unres_lock);
698 for (c=mfc_unres_queue; c; c=c->next) {
699 if (net_eq(mfc_net(c), net) &&
700 c->mfc_mcastgrp == iph->daddr &&
701 c->mfc_origin == iph->saddr)
702 break;
703 }
704
705 if (c == NULL) {
706 /*
707 * Create a new entry if allowable
708 */
709
710 if (atomic_read(&net->ipv4.cache_resolve_queue_len) >= 10 ||
711 (c = ipmr_cache_alloc_unres(net)) == NULL) {
712 spin_unlock_bh(&mfc_unres_lock);
713
714 kfree_skb(skb);
715 return -ENOBUFS;
716 }
717
718 /*
719 * Fill in the new cache entry
720 */
721 c->mfc_parent = -1;
722 c->mfc_origin = iph->saddr;
723 c->mfc_mcastgrp = iph->daddr;
724
725 /*
726 * Reflect first query at mrouted.
727 */
728 err = ipmr_cache_report(net, skb, vifi, IGMPMSG_NOCACHE);
729 if (err < 0) {
730 /* If the report failed throw the cache entry
731 out - Brad Parker
732 */
733 spin_unlock_bh(&mfc_unres_lock);
734
735 ipmr_cache_free(c);
736 kfree_skb(skb);
737 return err;
738 }
739
740 atomic_inc(&net->ipv4.cache_resolve_queue_len);
741 c->next = mfc_unres_queue;
742 mfc_unres_queue = c;
743
744 mod_timer(&ipmr_expire_timer, c->mfc_un.unres.expires);
745 }
746
747 /*
748 * See if we can append the packet
749 */
750 if (c->mfc_un.unres.unresolved.qlen>3) {
751 kfree_skb(skb);
752 err = -ENOBUFS;
753 } else {
754 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
755 err = 0;
756 }
757
758 spin_unlock_bh(&mfc_unres_lock);
759 return err;
760 }
761
762 /*
763 * MFC cache manipulation by user space mroute daemon
764 */
765
766 static int ipmr_mfc_delete(struct net *net, struct mfcctl *mfc)
767 {
768 int line;
769 struct mfc_cache *c, **cp;
770
771 line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
772
773 for (cp = &net->ipv4.mfc_cache_array[line];
774 (c = *cp) != NULL; cp = &c->next) {
775 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
776 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
777 write_lock_bh(&mrt_lock);
778 *cp = c->next;
779 write_unlock_bh(&mrt_lock);
780
781 ipmr_cache_free(c);
782 return 0;
783 }
784 }
785 return -ENOENT;
786 }
787
788 static int ipmr_mfc_add(struct net *net, struct mfcctl *mfc, int mrtsock)
789 {
790 int line;
791 struct mfc_cache *uc, *c, **cp;
792
793 line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
794
795 for (cp = &net->ipv4.mfc_cache_array[line];
796 (c = *cp) != NULL; cp = &c->next) {
797 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
798 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr)
799 break;
800 }
801
802 if (c != NULL) {
803 write_lock_bh(&mrt_lock);
804 c->mfc_parent = mfc->mfcc_parent;
805 ipmr_update_thresholds(c, mfc->mfcc_ttls);
806 if (!mrtsock)
807 c->mfc_flags |= MFC_STATIC;
808 write_unlock_bh(&mrt_lock);
809 return 0;
810 }
811
812 if (!ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr))
813 return -EINVAL;
814
815 c = ipmr_cache_alloc(net);
816 if (c == NULL)
817 return -ENOMEM;
818
819 c->mfc_origin = mfc->mfcc_origin.s_addr;
820 c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr;
821 c->mfc_parent = mfc->mfcc_parent;
822 ipmr_update_thresholds(c, mfc->mfcc_ttls);
823 if (!mrtsock)
824 c->mfc_flags |= MFC_STATIC;
825
826 write_lock_bh(&mrt_lock);
827 c->next = net->ipv4.mfc_cache_array[line];
828 net->ipv4.mfc_cache_array[line] = c;
829 write_unlock_bh(&mrt_lock);
830
831 /*
832 * Check to see if we resolved a queued list. If so we
833 * need to send on the frames and tidy up.
834 */
835 spin_lock_bh(&mfc_unres_lock);
836 for (cp = &mfc_unres_queue; (uc=*cp) != NULL;
837 cp = &uc->next) {
838 if (net_eq(mfc_net(uc), net) &&
839 uc->mfc_origin == c->mfc_origin &&
840 uc->mfc_mcastgrp == c->mfc_mcastgrp) {
841 *cp = uc->next;
842 atomic_dec(&net->ipv4.cache_resolve_queue_len);
843 break;
844 }
845 }
846 if (mfc_unres_queue == NULL)
847 del_timer(&ipmr_expire_timer);
848 spin_unlock_bh(&mfc_unres_lock);
849
850 if (uc) {
851 ipmr_cache_resolve(uc, c);
852 ipmr_cache_free(uc);
853 }
854 return 0;
855 }
856
857 /*
858 * Close the multicast socket, and clear the vif tables etc
859 */
860
861 static void mroute_clean_tables(struct net *net)
862 {
863 int i;
864
865 /*
866 * Shut down all active vif entries
867 */
868 for (i = 0; i < net->ipv4.maxvif; i++) {
869 if (!(net->ipv4.vif_table[i].flags&VIFF_STATIC))
870 vif_delete(net, i, 0);
871 }
872
873 /*
874 * Wipe the cache
875 */
876 for (i=0; i<MFC_LINES; i++) {
877 struct mfc_cache *c, **cp;
878
879 cp = &net->ipv4.mfc_cache_array[i];
880 while ((c = *cp) != NULL) {
881 if (c->mfc_flags&MFC_STATIC) {
882 cp = &c->next;
883 continue;
884 }
885 write_lock_bh(&mrt_lock);
886 *cp = c->next;
887 write_unlock_bh(&mrt_lock);
888
889 ipmr_cache_free(c);
890 }
891 }
892
893 if (atomic_read(&net->ipv4.cache_resolve_queue_len) != 0) {
894 struct mfc_cache *c, **cp;
895
896 spin_lock_bh(&mfc_unres_lock);
897 cp = &mfc_unres_queue;
898 while ((c = *cp) != NULL) {
899 if (!net_eq(mfc_net(c), net)) {
900 cp = &c->next;
901 continue;
902 }
903 *cp = c->next;
904
905 ipmr_destroy_unres(c);
906 }
907 spin_unlock_bh(&mfc_unres_lock);
908 }
909 }
910
911 static void mrtsock_destruct(struct sock *sk)
912 {
913 struct net *net = sock_net(sk);
914
915 rtnl_lock();
916 if (sk == net->ipv4.mroute_sk) {
917 IPV4_DEVCONF_ALL(net, MC_FORWARDING)--;
918
919 write_lock_bh(&mrt_lock);
920 net->ipv4.mroute_sk = NULL;
921 write_unlock_bh(&mrt_lock);
922
923 mroute_clean_tables(net);
924 }
925 rtnl_unlock();
926 }
927
928 /*
929 * Socket options and virtual interface manipulation. The whole
930 * virtual interface system is a complete heap, but unfortunately
931 * that's how BSD mrouted happens to think. Maybe one day with a proper
932 * MOSPF/PIM router set up we can clean this up.
933 */
934
935 int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, int optlen)
936 {
937 int ret;
938 struct vifctl vif;
939 struct mfcctl mfc;
940 struct net *net = sock_net(sk);
941
942 if (optname != MRT_INIT) {
943 if (sk != net->ipv4.mroute_sk && !capable(CAP_NET_ADMIN))
944 return -EACCES;
945 }
946
947 switch (optname) {
948 case MRT_INIT:
949 if (sk->sk_type != SOCK_RAW ||
950 inet_sk(sk)->num != IPPROTO_IGMP)
951 return -EOPNOTSUPP;
952 if (optlen != sizeof(int))
953 return -ENOPROTOOPT;
954
955 rtnl_lock();
956 if (net->ipv4.mroute_sk) {
957 rtnl_unlock();
958 return -EADDRINUSE;
959 }
960
961 ret = ip_ra_control(sk, 1, mrtsock_destruct);
962 if (ret == 0) {
963 write_lock_bh(&mrt_lock);
964 net->ipv4.mroute_sk = sk;
965 write_unlock_bh(&mrt_lock);
966
967 IPV4_DEVCONF_ALL(net, MC_FORWARDING)++;
968 }
969 rtnl_unlock();
970 return ret;
971 case MRT_DONE:
972 if (sk != net->ipv4.mroute_sk)
973 return -EACCES;
974 return ip_ra_control(sk, 0, NULL);
975 case MRT_ADD_VIF:
976 case MRT_DEL_VIF:
977 if (optlen != sizeof(vif))
978 return -EINVAL;
979 if (copy_from_user(&vif, optval, sizeof(vif)))
980 return -EFAULT;
981 if (vif.vifc_vifi >= MAXVIFS)
982 return -ENFILE;
983 rtnl_lock();
984 if (optname == MRT_ADD_VIF) {
985 ret = vif_add(net, &vif, sk == net->ipv4.mroute_sk);
986 } else {
987 ret = vif_delete(net, vif.vifc_vifi, 0);
988 }
989 rtnl_unlock();
990 return ret;
991
992 /*
993 * Manipulate the forwarding caches. These live
994 * in a sort of kernel/user symbiosis.
995 */
996 case MRT_ADD_MFC:
997 case MRT_DEL_MFC:
998 if (optlen != sizeof(mfc))
999 return -EINVAL;
1000 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1001 return -EFAULT;
1002 rtnl_lock();
1003 if (optname == MRT_DEL_MFC)
1004 ret = ipmr_mfc_delete(net, &mfc);
1005 else
1006 ret = ipmr_mfc_add(net, &mfc, sk == net->ipv4.mroute_sk);
1007 rtnl_unlock();
1008 return ret;
1009 /*
1010 * Control PIM assert.
1011 */
1012 case MRT_ASSERT:
1013 {
1014 int v;
1015 if (get_user(v,(int __user *)optval))
1016 return -EFAULT;
1017 net->ipv4.mroute_do_assert = (v) ? 1 : 0;
1018 return 0;
1019 }
1020 #ifdef CONFIG_IP_PIMSM
1021 case MRT_PIM:
1022 {
1023 int v;
1024
1025 if (get_user(v,(int __user *)optval))
1026 return -EFAULT;
1027 v = (v) ? 1 : 0;
1028
1029 rtnl_lock();
1030 ret = 0;
1031 if (v != net->ipv4.mroute_do_pim) {
1032 net->ipv4.mroute_do_pim = v;
1033 net->ipv4.mroute_do_assert = v;
1034 #ifdef CONFIG_IP_PIMSM_V2
1035 if (net->ipv4.mroute_do_pim)
1036 ret = inet_add_protocol(&pim_protocol,
1037 IPPROTO_PIM);
1038 else
1039 ret = inet_del_protocol(&pim_protocol,
1040 IPPROTO_PIM);
1041 if (ret < 0)
1042 ret = -EAGAIN;
1043 #endif
1044 }
1045 rtnl_unlock();
1046 return ret;
1047 }
1048 #endif
1049 /*
1050 * Spurious command, or MRT_VERSION which you cannot
1051 * set.
1052 */
1053 default:
1054 return -ENOPROTOOPT;
1055 }
1056 }
1057
1058 /*
1059 * Getsock opt support for the multicast routing system.
1060 */
1061
1062 int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int __user *optlen)
1063 {
1064 int olr;
1065 int val;
1066 struct net *net = sock_net(sk);
1067
1068 if (optname != MRT_VERSION &&
1069 #ifdef CONFIG_IP_PIMSM
1070 optname!=MRT_PIM &&
1071 #endif
1072 optname!=MRT_ASSERT)
1073 return -ENOPROTOOPT;
1074
1075 if (get_user(olr, optlen))
1076 return -EFAULT;
1077
1078 olr = min_t(unsigned int, olr, sizeof(int));
1079 if (olr < 0)
1080 return -EINVAL;
1081
1082 if (put_user(olr, optlen))
1083 return -EFAULT;
1084 if (optname == MRT_VERSION)
1085 val = 0x0305;
1086 #ifdef CONFIG_IP_PIMSM
1087 else if (optname == MRT_PIM)
1088 val = net->ipv4.mroute_do_pim;
1089 #endif
1090 else
1091 val = net->ipv4.mroute_do_assert;
1092 if (copy_to_user(optval, &val, olr))
1093 return -EFAULT;
1094 return 0;
1095 }
1096
1097 /*
1098 * The IP multicast ioctl support routines.
1099 */
1100
1101 int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
1102 {
1103 struct sioc_sg_req sr;
1104 struct sioc_vif_req vr;
1105 struct vif_device *vif;
1106 struct mfc_cache *c;
1107 struct net *net = sock_net(sk);
1108
1109 switch (cmd) {
1110 case SIOCGETVIFCNT:
1111 if (copy_from_user(&vr, arg, sizeof(vr)))
1112 return -EFAULT;
1113 if (vr.vifi >= net->ipv4.maxvif)
1114 return -EINVAL;
1115 read_lock(&mrt_lock);
1116 vif = &net->ipv4.vif_table[vr.vifi];
1117 if (VIF_EXISTS(net, vr.vifi)) {
1118 vr.icount = vif->pkt_in;
1119 vr.ocount = vif->pkt_out;
1120 vr.ibytes = vif->bytes_in;
1121 vr.obytes = vif->bytes_out;
1122 read_unlock(&mrt_lock);
1123
1124 if (copy_to_user(arg, &vr, sizeof(vr)))
1125 return -EFAULT;
1126 return 0;
1127 }
1128 read_unlock(&mrt_lock);
1129 return -EADDRNOTAVAIL;
1130 case SIOCGETSGCNT:
1131 if (copy_from_user(&sr, arg, sizeof(sr)))
1132 return -EFAULT;
1133
1134 read_lock(&mrt_lock);
1135 c = ipmr_cache_find(net, sr.src.s_addr, sr.grp.s_addr);
1136 if (c) {
1137 sr.pktcnt = c->mfc_un.res.pkt;
1138 sr.bytecnt = c->mfc_un.res.bytes;
1139 sr.wrong_if = c->mfc_un.res.wrong_if;
1140 read_unlock(&mrt_lock);
1141
1142 if (copy_to_user(arg, &sr, sizeof(sr)))
1143 return -EFAULT;
1144 return 0;
1145 }
1146 read_unlock(&mrt_lock);
1147 return -EADDRNOTAVAIL;
1148 default:
1149 return -ENOIOCTLCMD;
1150 }
1151 }
1152
1153
1154 static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
1155 {
1156 struct net_device *dev = ptr;
1157 struct net *net = dev_net(dev);
1158 struct vif_device *v;
1159 int ct;
1160
1161 if (!net_eq(dev_net(dev), net))
1162 return NOTIFY_DONE;
1163
1164 if (event != NETDEV_UNREGISTER)
1165 return NOTIFY_DONE;
1166 v = &net->ipv4.vif_table[0];
1167 for (ct = 0; ct < net->ipv4.maxvif; ct++, v++) {
1168 if (v->dev == dev)
1169 vif_delete(net, ct, 1);
1170 }
1171 return NOTIFY_DONE;
1172 }
1173
1174
1175 static struct notifier_block ip_mr_notifier = {
1176 .notifier_call = ipmr_device_event,
1177 };
1178
1179 /*
1180 * Encapsulate a packet by attaching a valid IPIP header to it.
1181 * This avoids tunnel drivers and other mess and gives us the speed so
1182 * important for multicast video.
1183 */
1184
1185 static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
1186 {
1187 struct iphdr *iph;
1188 struct iphdr *old_iph = ip_hdr(skb);
1189
1190 skb_push(skb, sizeof(struct iphdr));
1191 skb->transport_header = skb->network_header;
1192 skb_reset_network_header(skb);
1193 iph = ip_hdr(skb);
1194
1195 iph->version = 4;
1196 iph->tos = old_iph->tos;
1197 iph->ttl = old_iph->ttl;
1198 iph->frag_off = 0;
1199 iph->daddr = daddr;
1200 iph->saddr = saddr;
1201 iph->protocol = IPPROTO_IPIP;
1202 iph->ihl = 5;
1203 iph->tot_len = htons(skb->len);
1204 ip_select_ident(iph, skb->dst, NULL);
1205 ip_send_check(iph);
1206
1207 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1208 nf_reset(skb);
1209 }
1210
1211 static inline int ipmr_forward_finish(struct sk_buff *skb)
1212 {
1213 struct ip_options * opt = &(IPCB(skb)->opt);
1214
1215 IP_INC_STATS_BH(dev_net(skb->dst->dev), IPSTATS_MIB_OUTFORWDATAGRAMS);
1216
1217 if (unlikely(opt->optlen))
1218 ip_forward_options(skb);
1219
1220 return dst_output(skb);
1221 }
1222
1223 /*
1224 * Processing handlers for ipmr_forward
1225 */
1226
1227 static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
1228 {
1229 struct net *net = mfc_net(c);
1230 const struct iphdr *iph = ip_hdr(skb);
1231 struct vif_device *vif = &net->ipv4.vif_table[vifi];
1232 struct net_device *dev;
1233 struct rtable *rt;
1234 int encap = 0;
1235
1236 if (vif->dev == NULL)
1237 goto out_free;
1238
1239 #ifdef CONFIG_IP_PIMSM
1240 if (vif->flags & VIFF_REGISTER) {
1241 vif->pkt_out++;
1242 vif->bytes_out += skb->len;
1243 vif->dev->stats.tx_bytes += skb->len;
1244 vif->dev->stats.tx_packets++;
1245 ipmr_cache_report(net, skb, vifi, IGMPMSG_WHOLEPKT);
1246 kfree_skb(skb);
1247 return;
1248 }
1249 #endif
1250
1251 if (vif->flags&VIFF_TUNNEL) {
1252 struct flowi fl = { .oif = vif->link,
1253 .nl_u = { .ip4_u =
1254 { .daddr = vif->remote,
1255 .saddr = vif->local,
1256 .tos = RT_TOS(iph->tos) } },
1257 .proto = IPPROTO_IPIP };
1258 if (ip_route_output_key(net, &rt, &fl))
1259 goto out_free;
1260 encap = sizeof(struct iphdr);
1261 } else {
1262 struct flowi fl = { .oif = vif->link,
1263 .nl_u = { .ip4_u =
1264 { .daddr = iph->daddr,
1265 .tos = RT_TOS(iph->tos) } },
1266 .proto = IPPROTO_IPIP };
1267 if (ip_route_output_key(net, &rt, &fl))
1268 goto out_free;
1269 }
1270
1271 dev = rt->u.dst.dev;
1272
1273 if (skb->len+encap > dst_mtu(&rt->u.dst) && (ntohs(iph->frag_off) & IP_DF)) {
1274 /* Do not fragment multicasts. Alas, IPv4 does not
1275 allow to send ICMP, so that packets will disappear
1276 to blackhole.
1277 */
1278
1279 IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
1280 ip_rt_put(rt);
1281 goto out_free;
1282 }
1283
1284 encap += LL_RESERVED_SPACE(dev) + rt->u.dst.header_len;
1285
1286 if (skb_cow(skb, encap)) {
1287 ip_rt_put(rt);
1288 goto out_free;
1289 }
1290
1291 vif->pkt_out++;
1292 vif->bytes_out += skb->len;
1293
1294 dst_release(skb->dst);
1295 skb->dst = &rt->u.dst;
1296 ip_decrease_ttl(ip_hdr(skb));
1297
1298 /* FIXME: forward and output firewalls used to be called here.
1299 * What do we do with netfilter? -- RR */
1300 if (vif->flags & VIFF_TUNNEL) {
1301 ip_encap(skb, vif->local, vif->remote);
1302 /* FIXME: extra output firewall step used to be here. --RR */
1303 vif->dev->stats.tx_packets++;
1304 vif->dev->stats.tx_bytes += skb->len;
1305 }
1306
1307 IPCB(skb)->flags |= IPSKB_FORWARDED;
1308
1309 /*
1310 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1311 * not only before forwarding, but after forwarding on all output
1312 * interfaces. It is clear, if mrouter runs a multicasting
1313 * program, it should receive packets not depending to what interface
1314 * program is joined.
1315 * If we will not make it, the program will have to join on all
1316 * interfaces. On the other hand, multihoming host (or router, but
1317 * not mrouter) cannot join to more than one interface - it will
1318 * result in receiving multiple packets.
1319 */
1320 NF_HOOK(PF_INET, NF_INET_FORWARD, skb, skb->dev, dev,
1321 ipmr_forward_finish);
1322 return;
1323
1324 out_free:
1325 kfree_skb(skb);
1326 return;
1327 }
1328
1329 static int ipmr_find_vif(struct net_device *dev)
1330 {
1331 struct net *net = dev_net(dev);
1332 int ct;
1333 for (ct = net->ipv4.maxvif-1; ct >= 0; ct--) {
1334 if (net->ipv4.vif_table[ct].dev == dev)
1335 break;
1336 }
1337 return ct;
1338 }
1339
1340 /* "local" means that we should preserve one skb (for local delivery) */
1341
1342 static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local)
1343 {
1344 int psend = -1;
1345 int vif, ct;
1346 struct net *net = mfc_net(cache);
1347
1348 vif = cache->mfc_parent;
1349 cache->mfc_un.res.pkt++;
1350 cache->mfc_un.res.bytes += skb->len;
1351
1352 /*
1353 * Wrong interface: drop packet and (maybe) send PIM assert.
1354 */
1355 if (net->ipv4.vif_table[vif].dev != skb->dev) {
1356 int true_vifi;
1357
1358 if (skb->rtable->fl.iif == 0) {
1359 /* It is our own packet, looped back.
1360 Very complicated situation...
1361
1362 The best workaround until routing daemons will be
1363 fixed is not to redistribute packet, if it was
1364 send through wrong interface. It means, that
1365 multicast applications WILL NOT work for
1366 (S,G), which have default multicast route pointing
1367 to wrong oif. In any case, it is not a good
1368 idea to use multicasting applications on router.
1369 */
1370 goto dont_forward;
1371 }
1372
1373 cache->mfc_un.res.wrong_if++;
1374 true_vifi = ipmr_find_vif(skb->dev);
1375
1376 if (true_vifi >= 0 && net->ipv4.mroute_do_assert &&
1377 /* pimsm uses asserts, when switching from RPT to SPT,
1378 so that we cannot check that packet arrived on an oif.
1379 It is bad, but otherwise we would need to move pretty
1380 large chunk of pimd to kernel. Ough... --ANK
1381 */
1382 (net->ipv4.mroute_do_pim ||
1383 cache->mfc_un.res.ttls[true_vifi] < 255) &&
1384 time_after(jiffies,
1385 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1386 cache->mfc_un.res.last_assert = jiffies;
1387 ipmr_cache_report(net, skb, true_vifi, IGMPMSG_WRONGVIF);
1388 }
1389 goto dont_forward;
1390 }
1391
1392 net->ipv4.vif_table[vif].pkt_in++;
1393 net->ipv4.vif_table[vif].bytes_in += skb->len;
1394
1395 /*
1396 * Forward the frame
1397 */
1398 for (ct = cache->mfc_un.res.maxvif-1; ct >= cache->mfc_un.res.minvif; ct--) {
1399 if (ip_hdr(skb)->ttl > cache->mfc_un.res.ttls[ct]) {
1400 if (psend != -1) {
1401 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1402 if (skb2)
1403 ipmr_queue_xmit(skb2, cache, psend);
1404 }
1405 psend = ct;
1406 }
1407 }
1408 if (psend != -1) {
1409 if (local) {
1410 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1411 if (skb2)
1412 ipmr_queue_xmit(skb2, cache, psend);
1413 } else {
1414 ipmr_queue_xmit(skb, cache, psend);
1415 return 0;
1416 }
1417 }
1418
1419 dont_forward:
1420 if (!local)
1421 kfree_skb(skb);
1422 return 0;
1423 }
1424
1425
1426 /*
1427 * Multicast packets for forwarding arrive here
1428 */
1429
1430 int ip_mr_input(struct sk_buff *skb)
1431 {
1432 struct mfc_cache *cache;
1433 struct net *net = dev_net(skb->dev);
1434 int local = skb->rtable->rt_flags&RTCF_LOCAL;
1435
1436 /* Packet is looped back after forward, it should not be
1437 forwarded second time, but still can be delivered locally.
1438 */
1439 if (IPCB(skb)->flags&IPSKB_FORWARDED)
1440 goto dont_forward;
1441
1442 if (!local) {
1443 if (IPCB(skb)->opt.router_alert) {
1444 if (ip_call_ra_chain(skb))
1445 return 0;
1446 } else if (ip_hdr(skb)->protocol == IPPROTO_IGMP){
1447 /* IGMPv1 (and broken IGMPv2 implementations sort of
1448 Cisco IOS <= 11.2(8)) do not put router alert
1449 option to IGMP packets destined to routable
1450 groups. It is very bad, because it means
1451 that we can forward NO IGMP messages.
1452 */
1453 read_lock(&mrt_lock);
1454 if (net->ipv4.mroute_sk) {
1455 nf_reset(skb);
1456 raw_rcv(net->ipv4.mroute_sk, skb);
1457 read_unlock(&mrt_lock);
1458 return 0;
1459 }
1460 read_unlock(&mrt_lock);
1461 }
1462 }
1463
1464 read_lock(&mrt_lock);
1465 cache = ipmr_cache_find(net, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
1466
1467 /*
1468 * No usable cache entry
1469 */
1470 if (cache == NULL) {
1471 int vif;
1472
1473 if (local) {
1474 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1475 ip_local_deliver(skb);
1476 if (skb2 == NULL) {
1477 read_unlock(&mrt_lock);
1478 return -ENOBUFS;
1479 }
1480 skb = skb2;
1481 }
1482
1483 vif = ipmr_find_vif(skb->dev);
1484 if (vif >= 0) {
1485 int err = ipmr_cache_unresolved(net, vif, skb);
1486 read_unlock(&mrt_lock);
1487
1488 return err;
1489 }
1490 read_unlock(&mrt_lock);
1491 kfree_skb(skb);
1492 return -ENODEV;
1493 }
1494
1495 ip_mr_forward(skb, cache, local);
1496
1497 read_unlock(&mrt_lock);
1498
1499 if (local)
1500 return ip_local_deliver(skb);
1501
1502 return 0;
1503
1504 dont_forward:
1505 if (local)
1506 return ip_local_deliver(skb);
1507 kfree_skb(skb);
1508 return 0;
1509 }
1510
1511 #ifdef CONFIG_IP_PIMSM
1512 static int __pim_rcv(struct sk_buff *skb, unsigned int pimlen)
1513 {
1514 struct net_device *reg_dev = NULL;
1515 struct iphdr *encap;
1516 struct net *net = dev_net(skb->dev);
1517
1518 encap = (struct iphdr *)(skb_transport_header(skb) + pimlen);
1519 /*
1520 Check that:
1521 a. packet is really destinted to a multicast group
1522 b. packet is not a NULL-REGISTER
1523 c. packet is not truncated
1524 */
1525 if (!ipv4_is_multicast(encap->daddr) ||
1526 encap->tot_len == 0 ||
1527 ntohs(encap->tot_len) + pimlen > skb->len)
1528 return 1;
1529
1530 read_lock(&mrt_lock);
1531 if (net->ipv4.mroute_reg_vif_num >= 0)
1532 reg_dev = net->ipv4.vif_table[net->ipv4.mroute_reg_vif_num].dev;
1533 if (reg_dev)
1534 dev_hold(reg_dev);
1535 read_unlock(&mrt_lock);
1536
1537 if (reg_dev == NULL)
1538 return 1;
1539
1540 skb->mac_header = skb->network_header;
1541 skb_pull(skb, (u8*)encap - skb->data);
1542 skb_reset_network_header(skb);
1543 skb->dev = reg_dev;
1544 skb->protocol = htons(ETH_P_IP);
1545 skb->ip_summed = 0;
1546 skb->pkt_type = PACKET_HOST;
1547 dst_release(skb->dst);
1548 skb->dst = NULL;
1549 reg_dev->stats.rx_bytes += skb->len;
1550 reg_dev->stats.rx_packets++;
1551 nf_reset(skb);
1552 netif_rx(skb);
1553 dev_put(reg_dev);
1554
1555 return 0;
1556 }
1557 #endif
1558
1559 #ifdef CONFIG_IP_PIMSM_V1
1560 /*
1561 * Handle IGMP messages of PIMv1
1562 */
1563
1564 int pim_rcv_v1(struct sk_buff * skb)
1565 {
1566 struct igmphdr *pim;
1567 struct net *net = dev_net(skb->dev);
1568
1569 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
1570 goto drop;
1571
1572 pim = igmp_hdr(skb);
1573
1574 if (!net->ipv4.mroute_do_pim ||
1575 pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
1576 goto drop;
1577
1578 if (__pim_rcv(skb, sizeof(*pim))) {
1579 drop:
1580 kfree_skb(skb);
1581 }
1582 return 0;
1583 }
1584 #endif
1585
1586 #ifdef CONFIG_IP_PIMSM_V2
1587 static int pim_rcv(struct sk_buff * skb)
1588 {
1589 struct pimreghdr *pim;
1590
1591 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
1592 goto drop;
1593
1594 pim = (struct pimreghdr *)skb_transport_header(skb);
1595 if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
1596 (pim->flags&PIM_NULL_REGISTER) ||
1597 (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
1598 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
1599 goto drop;
1600
1601 if (__pim_rcv(skb, sizeof(*pim))) {
1602 drop:
1603 kfree_skb(skb);
1604 }
1605 return 0;
1606 }
1607 #endif
1608
1609 static int
1610 ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm)
1611 {
1612 int ct;
1613 struct rtnexthop *nhp;
1614 struct net *net = mfc_net(c);
1615 struct net_device *dev = net->ipv4.vif_table[c->mfc_parent].dev;
1616 u8 *b = skb_tail_pointer(skb);
1617 struct rtattr *mp_head;
1618
1619 if (dev)
1620 RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex);
1621
1622 mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
1623
1624 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1625 if (c->mfc_un.res.ttls[ct] < 255) {
1626 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1627 goto rtattr_failure;
1628 nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1629 nhp->rtnh_flags = 0;
1630 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1631 nhp->rtnh_ifindex = net->ipv4.vif_table[ct].dev->ifindex;
1632 nhp->rtnh_len = sizeof(*nhp);
1633 }
1634 }
1635 mp_head->rta_type = RTA_MULTIPATH;
1636 mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head;
1637 rtm->rtm_type = RTN_MULTICAST;
1638 return 1;
1639
1640 rtattr_failure:
1641 nlmsg_trim(skb, b);
1642 return -EMSGSIZE;
1643 }
1644
1645 int ipmr_get_route(struct net *net,
1646 struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1647 {
1648 int err;
1649 struct mfc_cache *cache;
1650 struct rtable *rt = skb->rtable;
1651
1652 read_lock(&mrt_lock);
1653 cache = ipmr_cache_find(net, rt->rt_src, rt->rt_dst);
1654
1655 if (cache == NULL) {
1656 struct sk_buff *skb2;
1657 struct iphdr *iph;
1658 struct net_device *dev;
1659 int vif;
1660
1661 if (nowait) {
1662 read_unlock(&mrt_lock);
1663 return -EAGAIN;
1664 }
1665
1666 dev = skb->dev;
1667 if (dev == NULL || (vif = ipmr_find_vif(dev)) < 0) {
1668 read_unlock(&mrt_lock);
1669 return -ENODEV;
1670 }
1671 skb2 = skb_clone(skb, GFP_ATOMIC);
1672 if (!skb2) {
1673 read_unlock(&mrt_lock);
1674 return -ENOMEM;
1675 }
1676
1677 skb_push(skb2, sizeof(struct iphdr));
1678 skb_reset_network_header(skb2);
1679 iph = ip_hdr(skb2);
1680 iph->ihl = sizeof(struct iphdr) >> 2;
1681 iph->saddr = rt->rt_src;
1682 iph->daddr = rt->rt_dst;
1683 iph->version = 0;
1684 err = ipmr_cache_unresolved(net, vif, skb2);
1685 read_unlock(&mrt_lock);
1686 return err;
1687 }
1688
1689 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1690 cache->mfc_flags |= MFC_NOTIFY;
1691 err = ipmr_fill_mroute(skb, cache, rtm);
1692 read_unlock(&mrt_lock);
1693 return err;
1694 }
1695
1696 #ifdef CONFIG_PROC_FS
1697 /*
1698 * The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
1699 */
1700 struct ipmr_vif_iter {
1701 struct seq_net_private p;
1702 int ct;
1703 };
1704
1705 static struct vif_device *ipmr_vif_seq_idx(struct net *net,
1706 struct ipmr_vif_iter *iter,
1707 loff_t pos)
1708 {
1709 for (iter->ct = 0; iter->ct < net->ipv4.maxvif; ++iter->ct) {
1710 if (!VIF_EXISTS(net, iter->ct))
1711 continue;
1712 if (pos-- == 0)
1713 return &net->ipv4.vif_table[iter->ct];
1714 }
1715 return NULL;
1716 }
1717
1718 static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
1719 __acquires(mrt_lock)
1720 {
1721 struct net *net = seq_file_net(seq);
1722
1723 read_lock(&mrt_lock);
1724 return *pos ? ipmr_vif_seq_idx(net, seq->private, *pos - 1)
1725 : SEQ_START_TOKEN;
1726 }
1727
1728 static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1729 {
1730 struct ipmr_vif_iter *iter = seq->private;
1731 struct net *net = seq_file_net(seq);
1732
1733 ++*pos;
1734 if (v == SEQ_START_TOKEN)
1735 return ipmr_vif_seq_idx(net, iter, 0);
1736
1737 while (++iter->ct < net->ipv4.maxvif) {
1738 if (!VIF_EXISTS(net, iter->ct))
1739 continue;
1740 return &net->ipv4.vif_table[iter->ct];
1741 }
1742 return NULL;
1743 }
1744
1745 static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
1746 __releases(mrt_lock)
1747 {
1748 read_unlock(&mrt_lock);
1749 }
1750
1751 static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
1752 {
1753 struct net *net = seq_file_net(seq);
1754
1755 if (v == SEQ_START_TOKEN) {
1756 seq_puts(seq,
1757 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
1758 } else {
1759 const struct vif_device *vif = v;
1760 const char *name = vif->dev ? vif->dev->name : "none";
1761
1762 seq_printf(seq,
1763 "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
1764 vif - net->ipv4.vif_table,
1765 name, vif->bytes_in, vif->pkt_in,
1766 vif->bytes_out, vif->pkt_out,
1767 vif->flags, vif->local, vif->remote);
1768 }
1769 return 0;
1770 }
1771
1772 static const struct seq_operations ipmr_vif_seq_ops = {
1773 .start = ipmr_vif_seq_start,
1774 .next = ipmr_vif_seq_next,
1775 .stop = ipmr_vif_seq_stop,
1776 .show = ipmr_vif_seq_show,
1777 };
1778
1779 static int ipmr_vif_open(struct inode *inode, struct file *file)
1780 {
1781 return seq_open_net(inode, file, &ipmr_vif_seq_ops,
1782 sizeof(struct ipmr_vif_iter));
1783 }
1784
1785 static const struct file_operations ipmr_vif_fops = {
1786 .owner = THIS_MODULE,
1787 .open = ipmr_vif_open,
1788 .read = seq_read,
1789 .llseek = seq_lseek,
1790 .release = seq_release_net,
1791 };
1792
1793 struct ipmr_mfc_iter {
1794 struct seq_net_private p;
1795 struct mfc_cache **cache;
1796 int ct;
1797 };
1798
1799
1800 static struct mfc_cache *ipmr_mfc_seq_idx(struct net *net,
1801 struct ipmr_mfc_iter *it, loff_t pos)
1802 {
1803 struct mfc_cache *mfc;
1804
1805 it->cache = net->ipv4.mfc_cache_array;
1806 read_lock(&mrt_lock);
1807 for (it->ct = 0; it->ct < MFC_LINES; it->ct++)
1808 for (mfc = net->ipv4.mfc_cache_array[it->ct];
1809 mfc; mfc = mfc->next)
1810 if (pos-- == 0)
1811 return mfc;
1812 read_unlock(&mrt_lock);
1813
1814 it->cache = &mfc_unres_queue;
1815 spin_lock_bh(&mfc_unres_lock);
1816 for (mfc = mfc_unres_queue; mfc; mfc = mfc->next)
1817 if (net_eq(mfc_net(mfc), net) &&
1818 pos-- == 0)
1819 return mfc;
1820 spin_unlock_bh(&mfc_unres_lock);
1821
1822 it->cache = NULL;
1823 return NULL;
1824 }
1825
1826
1827 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
1828 {
1829 struct ipmr_mfc_iter *it = seq->private;
1830 struct net *net = seq_file_net(seq);
1831
1832 it->cache = NULL;
1833 it->ct = 0;
1834 return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
1835 : SEQ_START_TOKEN;
1836 }
1837
1838 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1839 {
1840 struct mfc_cache *mfc = v;
1841 struct ipmr_mfc_iter *it = seq->private;
1842 struct net *net = seq_file_net(seq);
1843
1844 ++*pos;
1845
1846 if (v == SEQ_START_TOKEN)
1847 return ipmr_mfc_seq_idx(net, seq->private, 0);
1848
1849 if (mfc->next)
1850 return mfc->next;
1851
1852 if (it->cache == &mfc_unres_queue)
1853 goto end_of_list;
1854
1855 BUG_ON(it->cache != net->ipv4.mfc_cache_array);
1856
1857 while (++it->ct < MFC_LINES) {
1858 mfc = net->ipv4.mfc_cache_array[it->ct];
1859 if (mfc)
1860 return mfc;
1861 }
1862
1863 /* exhausted cache_array, show unresolved */
1864 read_unlock(&mrt_lock);
1865 it->cache = &mfc_unres_queue;
1866 it->ct = 0;
1867
1868 spin_lock_bh(&mfc_unres_lock);
1869 mfc = mfc_unres_queue;
1870 while (mfc && !net_eq(mfc_net(mfc), net))
1871 mfc = mfc->next;
1872 if (mfc)
1873 return mfc;
1874
1875 end_of_list:
1876 spin_unlock_bh(&mfc_unres_lock);
1877 it->cache = NULL;
1878
1879 return NULL;
1880 }
1881
1882 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
1883 {
1884 struct ipmr_mfc_iter *it = seq->private;
1885 struct net *net = seq_file_net(seq);
1886
1887 if (it->cache == &mfc_unres_queue)
1888 spin_unlock_bh(&mfc_unres_lock);
1889 else if (it->cache == net->ipv4.mfc_cache_array)
1890 read_unlock(&mrt_lock);
1891 }
1892
1893 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
1894 {
1895 int n;
1896 struct net *net = seq_file_net(seq);
1897
1898 if (v == SEQ_START_TOKEN) {
1899 seq_puts(seq,
1900 "Group Origin Iif Pkts Bytes Wrong Oifs\n");
1901 } else {
1902 const struct mfc_cache *mfc = v;
1903 const struct ipmr_mfc_iter *it = seq->private;
1904
1905 seq_printf(seq, "%08lX %08lX %-3hd",
1906 (unsigned long) mfc->mfc_mcastgrp,
1907 (unsigned long) mfc->mfc_origin,
1908 mfc->mfc_parent);
1909
1910 if (it->cache != &mfc_unres_queue) {
1911 seq_printf(seq, " %8lu %8lu %8lu",
1912 mfc->mfc_un.res.pkt,
1913 mfc->mfc_un.res.bytes,
1914 mfc->mfc_un.res.wrong_if);
1915 for (n = mfc->mfc_un.res.minvif;
1916 n < mfc->mfc_un.res.maxvif; n++ ) {
1917 if (VIF_EXISTS(net, n) &&
1918 mfc->mfc_un.res.ttls[n] < 255)
1919 seq_printf(seq,
1920 " %2d:%-3d",
1921 n, mfc->mfc_un.res.ttls[n]);
1922 }
1923 } else {
1924 /* unresolved mfc_caches don't contain
1925 * pkt, bytes and wrong_if values
1926 */
1927 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
1928 }
1929 seq_putc(seq, '\n');
1930 }
1931 return 0;
1932 }
1933
1934 static const struct seq_operations ipmr_mfc_seq_ops = {
1935 .start = ipmr_mfc_seq_start,
1936 .next = ipmr_mfc_seq_next,
1937 .stop = ipmr_mfc_seq_stop,
1938 .show = ipmr_mfc_seq_show,
1939 };
1940
1941 static int ipmr_mfc_open(struct inode *inode, struct file *file)
1942 {
1943 return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
1944 sizeof(struct ipmr_mfc_iter));
1945 }
1946
1947 static const struct file_operations ipmr_mfc_fops = {
1948 .owner = THIS_MODULE,
1949 .open = ipmr_mfc_open,
1950 .read = seq_read,
1951 .llseek = seq_lseek,
1952 .release = seq_release_net,
1953 };
1954 #endif
1955
1956 #ifdef CONFIG_IP_PIMSM_V2
1957 static struct net_protocol pim_protocol = {
1958 .handler = pim_rcv,
1959 };
1960 #endif
1961
1962
1963 /*
1964 * Setup for IP multicast routing
1965 */
1966 static int __net_init ipmr_net_init(struct net *net)
1967 {
1968 int err = 0;
1969
1970 net->ipv4.vif_table = kcalloc(MAXVIFS, sizeof(struct vif_device),
1971 GFP_KERNEL);
1972 if (!net->ipv4.vif_table) {
1973 err = -ENOMEM;
1974 goto fail;
1975 }
1976
1977 /* Forwarding cache */
1978 net->ipv4.mfc_cache_array = kcalloc(MFC_LINES,
1979 sizeof(struct mfc_cache *),
1980 GFP_KERNEL);
1981 if (!net->ipv4.mfc_cache_array) {
1982 err = -ENOMEM;
1983 goto fail_mfc_cache;
1984 }
1985
1986 #ifdef CONFIG_IP_PIMSM
1987 net->ipv4.mroute_reg_vif_num = -1;
1988 #endif
1989
1990 #ifdef CONFIG_PROC_FS
1991 err = -ENOMEM;
1992 if (!proc_net_fops_create(net, "ip_mr_vif", 0, &ipmr_vif_fops))
1993 goto proc_vif_fail;
1994 if (!proc_net_fops_create(net, "ip_mr_cache", 0, &ipmr_mfc_fops))
1995 goto proc_cache_fail;
1996 #endif
1997 return 0;
1998
1999 #ifdef CONFIG_PROC_FS
2000 proc_cache_fail:
2001 proc_net_remove(net, "ip_mr_vif");
2002 proc_vif_fail:
2003 kfree(net->ipv4.mfc_cache_array);
2004 #endif
2005 fail_mfc_cache:
2006 kfree(net->ipv4.vif_table);
2007 fail:
2008 return err;
2009 }
2010
2011 static void __net_exit ipmr_net_exit(struct net *net)
2012 {
2013 #ifdef CONFIG_PROC_FS
2014 proc_net_remove(net, "ip_mr_cache");
2015 proc_net_remove(net, "ip_mr_vif");
2016 #endif
2017 kfree(net->ipv4.mfc_cache_array);
2018 kfree(net->ipv4.vif_table);
2019 }
2020
2021 static struct pernet_operations ipmr_net_ops = {
2022 .init = ipmr_net_init,
2023 .exit = ipmr_net_exit,
2024 };
2025
2026 int __init ip_mr_init(void)
2027 {
2028 int err;
2029
2030 mrt_cachep = kmem_cache_create("ip_mrt_cache",
2031 sizeof(struct mfc_cache),
2032 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
2033 NULL);
2034 if (!mrt_cachep)
2035 return -ENOMEM;
2036
2037 err = register_pernet_subsys(&ipmr_net_ops);
2038 if (err)
2039 goto reg_pernet_fail;
2040
2041 setup_timer(&ipmr_expire_timer, ipmr_expire_process, 0);
2042 err = register_netdevice_notifier(&ip_mr_notifier);
2043 if (err)
2044 goto reg_notif_fail;
2045 return 0;
2046
2047 reg_notif_fail:
2048 del_timer(&ipmr_expire_timer);
2049 unregister_pernet_subsys(&ipmr_net_ops);
2050 reg_pernet_fail:
2051 kmem_cache_destroy(mrt_cachep);
2052 return err;
2053 }
(deprecated) Btrfs devel tree