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