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