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