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