blob: aba3ff0bec9764de4dda0ea4621c096da58ecdbf [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <asm/system.h>
32#include <asm/uaccess.h>
33#include <linux/types.h>
Randy Dunlap4fc268d2006-01-11 12:17:47 -080034#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#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>
Kris Katterjohn46f25df2006-01-05 16:35:42 -080051#include <linux/if_ether.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#include <net/ip.h>
53#include <net/protocol.h>
54#include <linux/skbuff.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020055#include <net/route.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#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
Christoph Lametere18b8902006-12-06 20:33:20 -0800107static struct kmem_cache *mrt_cachep __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108
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
Herbert Xue5ed6392005-10-03 14:35:55 -0700153 in_dev = __in_dev_get_rtnl(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 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);
Patrick McHardy2941a482006-01-08 22:05:26 -0800180 ((struct net_device_stats*)netdev_priv(dev))->tx_bytes += skb->len;
181 ((struct net_device_stats*)netdev_priv(dev))->tx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 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{
Patrick McHardy2941a482006-01-08 22:05:26 -0800190 return (struct net_device_stats*)netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191}
192
193static void reg_vif_setup(struct net_device *dev)
194{
195 dev->type = ARPHRD_PIMREG;
Kris Katterjohn46f25df2006-01-05 16:35:42 -0800196 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 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 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900243
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244static 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
Herbert Xue5ed6392005-10-03 14:35:55 -0700282 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 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;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -0700301 struct nlmsgerr *e;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
303 atomic_dec(&cache_resolve_queue_len);
304
Stephen Hemminger132adf52007-03-08 20:44:43 -0800305 while ((skb=skb_dequeue(&c->mfc_un.unres.unresolved))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 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);
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -0700311 e = NLMSG_DATA(nlh);
312 e->error = -ETIMEDOUT;
313 memset(&e->msg, 0, sizeof(e->msg));
Thomas Graf2942e902006-08-15 00:30:25 -0700314
315 rtnl_unicast(skb, NETLINK_CB(skb).pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 } 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
Baruch Evend1b04c02005-07-30 17:41:59 -0700367static void ipmr_update_thresholds(struct mfc_cache *cache, unsigned char *ttls)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368{
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
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900411 case VIFF_TUNNEL:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 dev = ipmr_new_tunnel(vifc);
413 if (!dev)
414 return -ENOBUFS;
415 break;
416 case 0:
Stephen Hemminger15333062006-03-20 22:32:28 -0800417 dev = ip_dev_find(vifc->vifc_lcl_addr.s_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 if (!dev)
419 return -EADDRNOTAVAIL;
Stephen Hemminger15333062006-03-20 22:32:28 -0800420 dev_put(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 break;
422 default:
423 return -EINVAL;
424 }
425
Herbert Xue5ed6392005-10-03 14:35:55 -0700426 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 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
Al Viro114c7842006-09-27 18:39:29 -0700464static struct mfc_cache *ipmr_cache_find(__be32 origin, __be32 mcastgrp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465{
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{
Robert P. J. Dayc3762222007-02-10 01:45:03 -0800481 struct mfc_cache *c=kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
Stephen Hemminger132adf52007-03-08 20:44:43 -0800482 if (c==NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 c->mfc_un.res.minvif = MAXVIFS;
485 return c;
486}
487
488static struct mfc_cache *ipmr_cache_alloc_unres(void)
489{
Robert P. J. Dayc3762222007-02-10 01:45:03 -0800490 struct mfc_cache *c=kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
Stephen Hemminger132adf52007-03-08 20:44:43 -0800491 if (c==NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 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 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900501
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c)
503{
504 struct sk_buff *skb;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -0700505 struct nlmsgerr *e;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
507 /*
508 * Play the pending entries through our router
509 */
510
Stephen Hemminger132adf52007-03-08 20:44:43 -0800511 while ((skb=__skb_dequeue(&uc->mfc_un.unres.unresolved))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 if (skb->nh.iph->version == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 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);
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -0700521 e = NLMSG_DATA(nlh);
522 e->error = -EMSGSIZE;
523 memset(&e->msg, 0, sizeof(e->msg));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 }
Thomas Graf2942e902006-08-15 00:30:25 -0700525
526 rtnl_unicast(skb, NETLINK_CB(skb).pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 } 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 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900538
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539static 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
Stephen Hemminger132adf52007-03-08 20:44:43 -0800554 if (!skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 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 */
Arnaldo Carvalho de Melo878c8142007-03-11 22:38:29 -0300564 skb_push(skb, sizeof(struct iphdr));
565 skb_reset_network_header(skb);
566 skb->h.raw = skb->data;
Arnaldo Carvalho de Melo0272ffc2007-03-12 20:05:39 -0300567 msg = (struct igmpmsg *)skb_network_header(skb);
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700568 memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 msg->im_msgtype = IGMPMSG_WHOLEPKT;
570 msg->im_mbz = 0;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900571 msg->im_vif = reg_vif_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 skb->nh.iph->ihl = sizeof(struct iphdr) >> 2;
573 skb->nh.iph->tot_len = htons(ntohs(pkt->nh.iph->tot_len) + sizeof(struct iphdr));
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900574 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575#endif
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900576 {
577
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 /*
579 * Copy the IP header
580 */
581
582 skb->nh.iph = (struct iphdr *)skb_put(skb, ihl);
583 memcpy(skb->data,pkt->data,ihl);
584 skb->nh.iph->protocol = 0; /* Flag to the kernel this is a route add */
585 msg = (struct igmpmsg*)skb->nh.iph;
586 msg->im_vif = vifi;
587 skb->dst = dst_clone(pkt->dst);
588
589 /*
590 * Add our header
591 */
592
593 igmp=(struct igmphdr *)skb_put(skb,sizeof(struct igmphdr));
594 igmp->type =
595 msg->im_msgtype = assert;
596 igmp->code = 0;
597 skb->nh.iph->tot_len=htons(skb->len); /* Fix the length */
598 skb->h.raw = skb->nh.raw;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900599 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
601 if (mroute_socket == NULL) {
602 kfree_skb(skb);
603 return -EINVAL;
604 }
605
606 /*
607 * Deliver to mrouted
608 */
609 if ((ret=sock_queue_rcv_skb(mroute_socket,skb))<0) {
610 if (net_ratelimit())
611 printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n");
612 kfree_skb(skb);
613 }
614
615 return ret;
616}
617
618/*
619 * Queue a packet for resolution. It gets locked cache entry!
620 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900621
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622static int
623ipmr_cache_unresolved(vifi_t vifi, struct sk_buff *skb)
624{
625 int err;
626 struct mfc_cache *c;
627
628 spin_lock_bh(&mfc_unres_lock);
629 for (c=mfc_unres_queue; c; c=c->next) {
630 if (c->mfc_mcastgrp == skb->nh.iph->daddr &&
631 c->mfc_origin == skb->nh.iph->saddr)
632 break;
633 }
634
635 if (c == NULL) {
636 /*
637 * Create a new entry if allowable
638 */
639
640 if (atomic_read(&cache_resolve_queue_len)>=10 ||
641 (c=ipmr_cache_alloc_unres())==NULL) {
642 spin_unlock_bh(&mfc_unres_lock);
643
644 kfree_skb(skb);
645 return -ENOBUFS;
646 }
647
648 /*
649 * Fill in the new cache entry
650 */
651 c->mfc_parent=-1;
652 c->mfc_origin=skb->nh.iph->saddr;
653 c->mfc_mcastgrp=skb->nh.iph->daddr;
654
655 /*
656 * Reflect first query at mrouted.
657 */
658 if ((err = ipmr_cache_report(skb, vifi, IGMPMSG_NOCACHE))<0) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900659 /* If the report failed throw the cache entry
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 out - Brad Parker
661 */
662 spin_unlock_bh(&mfc_unres_lock);
663
664 kmem_cache_free(mrt_cachep, c);
665 kfree_skb(skb);
666 return err;
667 }
668
669 atomic_inc(&cache_resolve_queue_len);
670 c->next = mfc_unres_queue;
671 mfc_unres_queue = c;
672
673 mod_timer(&ipmr_expire_timer, c->mfc_un.unres.expires);
674 }
675
676 /*
677 * See if we can append the packet
678 */
679 if (c->mfc_un.unres.unresolved.qlen>3) {
680 kfree_skb(skb);
681 err = -ENOBUFS;
682 } else {
683 skb_queue_tail(&c->mfc_un.unres.unresolved,skb);
684 err = 0;
685 }
686
687 spin_unlock_bh(&mfc_unres_lock);
688 return err;
689}
690
691/*
692 * MFC cache manipulation by user space mroute daemon
693 */
694
695static int ipmr_mfc_delete(struct mfcctl *mfc)
696{
697 int line;
698 struct mfc_cache *c, **cp;
699
700 line=MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
701
702 for (cp=&mfc_cache_array[line]; (c=*cp) != NULL; cp = &c->next) {
703 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
704 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
705 write_lock_bh(&mrt_lock);
706 *cp = c->next;
707 write_unlock_bh(&mrt_lock);
708
709 kmem_cache_free(mrt_cachep, c);
710 return 0;
711 }
712 }
713 return -ENOENT;
714}
715
716static int ipmr_mfc_add(struct mfcctl *mfc, int mrtsock)
717{
718 int line;
719 struct mfc_cache *uc, *c, **cp;
720
721 line=MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
722
723 for (cp=&mfc_cache_array[line]; (c=*cp) != NULL; cp = &c->next) {
724 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
725 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr)
726 break;
727 }
728
729 if (c != NULL) {
730 write_lock_bh(&mrt_lock);
731 c->mfc_parent = mfc->mfcc_parent;
Baruch Evend1b04c02005-07-30 17:41:59 -0700732 ipmr_update_thresholds(c, mfc->mfcc_ttls);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 if (!mrtsock)
734 c->mfc_flags |= MFC_STATIC;
735 write_unlock_bh(&mrt_lock);
736 return 0;
737 }
738
Stephen Hemminger132adf52007-03-08 20:44:43 -0800739 if (!MULTICAST(mfc->mfcc_mcastgrp.s_addr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 return -EINVAL;
741
742 c=ipmr_cache_alloc();
743 if (c==NULL)
744 return -ENOMEM;
745
746 c->mfc_origin=mfc->mfcc_origin.s_addr;
747 c->mfc_mcastgrp=mfc->mfcc_mcastgrp.s_addr;
748 c->mfc_parent=mfc->mfcc_parent;
Baruch Evend1b04c02005-07-30 17:41:59 -0700749 ipmr_update_thresholds(c, mfc->mfcc_ttls);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 if (!mrtsock)
751 c->mfc_flags |= MFC_STATIC;
752
753 write_lock_bh(&mrt_lock);
754 c->next = mfc_cache_array[line];
755 mfc_cache_array[line] = c;
756 write_unlock_bh(&mrt_lock);
757
758 /*
759 * Check to see if we resolved a queued list. If so we
760 * need to send on the frames and tidy up.
761 */
762 spin_lock_bh(&mfc_unres_lock);
763 for (cp = &mfc_unres_queue; (uc=*cp) != NULL;
764 cp = &uc->next) {
765 if (uc->mfc_origin == c->mfc_origin &&
766 uc->mfc_mcastgrp == c->mfc_mcastgrp) {
767 *cp = uc->next;
768 if (atomic_dec_and_test(&cache_resolve_queue_len))
769 del_timer(&ipmr_expire_timer);
770 break;
771 }
772 }
773 spin_unlock_bh(&mfc_unres_lock);
774
775 if (uc) {
776 ipmr_cache_resolve(uc, c);
777 kmem_cache_free(mrt_cachep, uc);
778 }
779 return 0;
780}
781
782/*
783 * Close the multicast socket, and clear the vif tables etc
784 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900785
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786static void mroute_clean_tables(struct sock *sk)
787{
788 int i;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900789
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 /*
791 * Shut down all active vif entries
792 */
Stephen Hemminger132adf52007-03-08 20:44:43 -0800793 for (i=0; i<maxvif; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 if (!(vif_table[i].flags&VIFF_STATIC))
795 vif_delete(i);
796 }
797
798 /*
799 * Wipe the cache
800 */
801 for (i=0;i<MFC_LINES;i++) {
802 struct mfc_cache *c, **cp;
803
804 cp = &mfc_cache_array[i];
805 while ((c = *cp) != NULL) {
806 if (c->mfc_flags&MFC_STATIC) {
807 cp = &c->next;
808 continue;
809 }
810 write_lock_bh(&mrt_lock);
811 *cp = c->next;
812 write_unlock_bh(&mrt_lock);
813
814 kmem_cache_free(mrt_cachep, c);
815 }
816 }
817
818 if (atomic_read(&cache_resolve_queue_len) != 0) {
819 struct mfc_cache *c;
820
821 spin_lock_bh(&mfc_unres_lock);
822 while (mfc_unres_queue != NULL) {
823 c = mfc_unres_queue;
824 mfc_unres_queue = c->next;
825 spin_unlock_bh(&mfc_unres_lock);
826
827 ipmr_destroy_unres(c);
828
829 spin_lock_bh(&mfc_unres_lock);
830 }
831 spin_unlock_bh(&mfc_unres_lock);
832 }
833}
834
835static void mrtsock_destruct(struct sock *sk)
836{
837 rtnl_lock();
838 if (sk == mroute_socket) {
839 ipv4_devconf.mc_forwarding--;
840
841 write_lock_bh(&mrt_lock);
842 mroute_socket=NULL;
843 write_unlock_bh(&mrt_lock);
844
845 mroute_clean_tables(sk);
846 }
847 rtnl_unlock();
848}
849
850/*
851 * Socket options and virtual interface manipulation. The whole
852 * virtual interface system is a complete heap, but unfortunately
853 * that's how BSD mrouted happens to think. Maybe one day with a proper
854 * MOSPF/PIM router set up we can clean this up.
855 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900856
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857int ip_mroute_setsockopt(struct sock *sk,int optname,char __user *optval,int optlen)
858{
859 int ret;
860 struct vifctl vif;
861 struct mfcctl mfc;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900862
Stephen Hemminger132adf52007-03-08 20:44:43 -0800863 if (optname != MRT_INIT) {
864 if (sk != mroute_socket && !capable(CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 return -EACCES;
866 }
867
Stephen Hemminger132adf52007-03-08 20:44:43 -0800868 switch (optname) {
869 case MRT_INIT:
870 if (sk->sk_type != SOCK_RAW ||
871 inet_sk(sk)->num != IPPROTO_IGMP)
872 return -EOPNOTSUPP;
873 if (optlen!=sizeof(int))
874 return -ENOPROTOOPT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875
Stephen Hemminger132adf52007-03-08 20:44:43 -0800876 rtnl_lock();
877 if (mroute_socket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 rtnl_unlock();
Stephen Hemminger132adf52007-03-08 20:44:43 -0800879 return -EADDRINUSE;
880 }
881
882 ret = ip_ra_control(sk, 1, mrtsock_destruct);
883 if (ret == 0) {
884 write_lock_bh(&mrt_lock);
885 mroute_socket=sk;
886 write_unlock_bh(&mrt_lock);
887
888 ipv4_devconf.mc_forwarding++;
889 }
890 rtnl_unlock();
891 return ret;
892 case MRT_DONE:
893 if (sk!=mroute_socket)
894 return -EACCES;
895 return ip_ra_control(sk, 0, NULL);
896 case MRT_ADD_VIF:
897 case MRT_DEL_VIF:
898 if (optlen!=sizeof(vif))
899 return -EINVAL;
900 if (copy_from_user(&vif,optval,sizeof(vif)))
901 return -EFAULT;
902 if (vif.vifc_vifi >= MAXVIFS)
903 return -ENFILE;
904 rtnl_lock();
905 if (optname==MRT_ADD_VIF) {
906 ret = vif_add(&vif, sk==mroute_socket);
907 } else {
908 ret = vif_delete(vif.vifc_vifi);
909 }
910 rtnl_unlock();
911 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912
913 /*
914 * Manipulate the forwarding caches. These live
915 * in a sort of kernel/user symbiosis.
916 */
Stephen Hemminger132adf52007-03-08 20:44:43 -0800917 case MRT_ADD_MFC:
918 case MRT_DEL_MFC:
919 if (optlen!=sizeof(mfc))
920 return -EINVAL;
921 if (copy_from_user(&mfc,optval, sizeof(mfc)))
922 return -EFAULT;
923 rtnl_lock();
924 if (optname==MRT_DEL_MFC)
925 ret = ipmr_mfc_delete(&mfc);
926 else
927 ret = ipmr_mfc_add(&mfc, sk==mroute_socket);
928 rtnl_unlock();
929 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 /*
931 * Control PIM assert.
932 */
Stephen Hemminger132adf52007-03-08 20:44:43 -0800933 case MRT_ASSERT:
934 {
935 int v;
936 if (get_user(v,(int __user *)optval))
937 return -EFAULT;
938 mroute_do_assert=(v)?1:0;
939 return 0;
940 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941#ifdef CONFIG_IP_PIMSM
Stephen Hemminger132adf52007-03-08 20:44:43 -0800942 case MRT_PIM:
943 {
944 int v, ret;
945 if (get_user(v,(int __user *)optval))
946 return -EFAULT;
947 v = (v)?1:0;
948 rtnl_lock();
949 ret = 0;
950 if (v != mroute_do_pim) {
951 mroute_do_pim = v;
952 mroute_do_assert = v;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953#ifdef CONFIG_IP_PIMSM_V2
Stephen Hemminger132adf52007-03-08 20:44:43 -0800954 if (mroute_do_pim)
955 ret = inet_add_protocol(&pim_protocol,
956 IPPROTO_PIM);
957 else
958 ret = inet_del_protocol(&pim_protocol,
959 IPPROTO_PIM);
960 if (ret < 0)
961 ret = -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 }
Stephen Hemminger132adf52007-03-08 20:44:43 -0800964 rtnl_unlock();
965 return ret;
966 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967#endif
Stephen Hemminger132adf52007-03-08 20:44:43 -0800968 /*
969 * Spurious command, or MRT_VERSION which you cannot
970 * set.
971 */
972 default:
973 return -ENOPROTOOPT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 }
975}
976
977/*
978 * Getsock opt support for the multicast routing system.
979 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900980
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981int ip_mroute_getsockopt(struct sock *sk,int optname,char __user *optval,int __user *optlen)
982{
983 int olr;
984 int val;
985
Stephen Hemminger132adf52007-03-08 20:44:43 -0800986 if (optname!=MRT_VERSION &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987#ifdef CONFIG_IP_PIMSM
988 optname!=MRT_PIM &&
989#endif
990 optname!=MRT_ASSERT)
991 return -ENOPROTOOPT;
992
993 if (get_user(olr, optlen))
994 return -EFAULT;
995
996 olr = min_t(unsigned int, olr, sizeof(int));
997 if (olr < 0)
998 return -EINVAL;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900999
Stephen Hemminger132adf52007-03-08 20:44:43 -08001000 if (put_user(olr,optlen))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 return -EFAULT;
Stephen Hemminger132adf52007-03-08 20:44:43 -08001002 if (optname==MRT_VERSION)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 val=0x0305;
1004#ifdef CONFIG_IP_PIMSM
Stephen Hemminger132adf52007-03-08 20:44:43 -08001005 else if (optname==MRT_PIM)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 val=mroute_do_pim;
1007#endif
1008 else
1009 val=mroute_do_assert;
Stephen Hemminger132adf52007-03-08 20:44:43 -08001010 if (copy_to_user(optval,&val,olr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 return -EFAULT;
1012 return 0;
1013}
1014
1015/*
1016 * The IP multicast ioctl support routines.
1017 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001018
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
1020{
1021 struct sioc_sg_req sr;
1022 struct sioc_vif_req vr;
1023 struct vif_device *vif;
1024 struct mfc_cache *c;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001025
Stephen Hemminger132adf52007-03-08 20:44:43 -08001026 switch (cmd) {
1027 case SIOCGETVIFCNT:
1028 if (copy_from_user(&vr,arg,sizeof(vr)))
1029 return -EFAULT;
1030 if (vr.vifi>=maxvif)
1031 return -EINVAL;
1032 read_lock(&mrt_lock);
1033 vif=&vif_table[vr.vifi];
1034 if (VIF_EXISTS(vr.vifi)) {
1035 vr.icount=vif->pkt_in;
1036 vr.ocount=vif->pkt_out;
1037 vr.ibytes=vif->bytes_in;
1038 vr.obytes=vif->bytes_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 read_unlock(&mrt_lock);
Stephen Hemminger132adf52007-03-08 20:44:43 -08001040
1041 if (copy_to_user(arg,&vr,sizeof(vr)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 return -EFAULT;
Stephen Hemminger132adf52007-03-08 20:44:43 -08001043 return 0;
1044 }
1045 read_unlock(&mrt_lock);
1046 return -EADDRNOTAVAIL;
1047 case SIOCGETSGCNT:
1048 if (copy_from_user(&sr,arg,sizeof(sr)))
1049 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050
Stephen Hemminger132adf52007-03-08 20:44:43 -08001051 read_lock(&mrt_lock);
1052 c = ipmr_cache_find(sr.src.s_addr, sr.grp.s_addr);
1053 if (c) {
1054 sr.pktcnt = c->mfc_un.res.pkt;
1055 sr.bytecnt = c->mfc_un.res.bytes;
1056 sr.wrong_if = c->mfc_un.res.wrong_if;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 read_unlock(&mrt_lock);
Stephen Hemminger132adf52007-03-08 20:44:43 -08001058
1059 if (copy_to_user(arg,&sr,sizeof(sr)))
1060 return -EFAULT;
1061 return 0;
1062 }
1063 read_unlock(&mrt_lock);
1064 return -EADDRNOTAVAIL;
1065 default:
1066 return -ENOIOCTLCMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 }
1068}
1069
1070
1071static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
1072{
1073 struct vif_device *v;
1074 int ct;
1075 if (event != NETDEV_UNREGISTER)
1076 return NOTIFY_DONE;
1077 v=&vif_table[0];
Stephen Hemminger132adf52007-03-08 20:44:43 -08001078 for (ct=0;ct<maxvif;ct++,v++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 if (v->dev==ptr)
1080 vif_delete(ct);
1081 }
1082 return NOTIFY_DONE;
1083}
1084
1085
1086static struct notifier_block ip_mr_notifier={
1087 .notifier_call = ipmr_device_event,
1088};
1089
1090/*
1091 * Encapsulate a packet by attaching a valid IPIP header to it.
1092 * This avoids tunnel drivers and other mess and gives us the speed so
1093 * important for multicast video.
1094 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001095
Al Viro114c7842006-09-27 18:39:29 -07001096static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097{
Arnaldo Carvalho de Melo8856dfa2007-03-10 19:40:39 -03001098 struct iphdr *iph;
1099
1100 skb_push(skb, sizeof(struct iphdr));
1101 skb->h.ipiph = skb->nh.iph;
1102 skb_reset_network_header(skb);
1103 iph = skb->nh.iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104
1105 iph->version = 4;
1106 iph->tos = skb->nh.iph->tos;
1107 iph->ttl = skb->nh.iph->ttl;
1108 iph->frag_off = 0;
1109 iph->daddr = daddr;
1110 iph->saddr = saddr;
1111 iph->protocol = IPPROTO_IPIP;
1112 iph->ihl = 5;
1113 iph->tot_len = htons(skb->len);
1114 ip_select_ident(iph, skb->dst, NULL);
1115 ip_send_check(iph);
1116
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1118 nf_reset(skb);
1119}
1120
1121static inline int ipmr_forward_finish(struct sk_buff *skb)
1122{
1123 struct ip_options * opt = &(IPCB(skb)->opt);
1124
1125 IP_INC_STATS_BH(IPSTATS_MIB_OUTFORWDATAGRAMS);
1126
1127 if (unlikely(opt->optlen))
1128 ip_forward_options(skb);
1129
1130 return dst_output(skb);
1131}
1132
1133/*
1134 * Processing handlers for ipmr_forward
1135 */
1136
1137static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
1138{
1139 struct iphdr *iph = skb->nh.iph;
1140 struct vif_device *vif = &vif_table[vifi];
1141 struct net_device *dev;
1142 struct rtable *rt;
1143 int encap = 0;
1144
1145 if (vif->dev == NULL)
1146 goto out_free;
1147
1148#ifdef CONFIG_IP_PIMSM
1149 if (vif->flags & VIFF_REGISTER) {
1150 vif->pkt_out++;
1151 vif->bytes_out+=skb->len;
Patrick McHardy2941a482006-01-08 22:05:26 -08001152 ((struct net_device_stats*)netdev_priv(vif->dev))->tx_bytes += skb->len;
1153 ((struct net_device_stats*)netdev_priv(vif->dev))->tx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 ipmr_cache_report(skb, vifi, IGMPMSG_WHOLEPKT);
1155 kfree_skb(skb);
1156 return;
1157 }
1158#endif
1159
1160 if (vif->flags&VIFF_TUNNEL) {
1161 struct flowi fl = { .oif = vif->link,
1162 .nl_u = { .ip4_u =
1163 { .daddr = vif->remote,
1164 .saddr = vif->local,
1165 .tos = RT_TOS(iph->tos) } },
1166 .proto = IPPROTO_IPIP };
1167 if (ip_route_output_key(&rt, &fl))
1168 goto out_free;
1169 encap = sizeof(struct iphdr);
1170 } else {
1171 struct flowi fl = { .oif = vif->link,
1172 .nl_u = { .ip4_u =
1173 { .daddr = iph->daddr,
1174 .tos = RT_TOS(iph->tos) } },
1175 .proto = IPPROTO_IPIP };
1176 if (ip_route_output_key(&rt, &fl))
1177 goto out_free;
1178 }
1179
1180 dev = rt->u.dst.dev;
1181
1182 if (skb->len+encap > dst_mtu(&rt->u.dst) && (ntohs(iph->frag_off) & IP_DF)) {
1183 /* Do not fragment multicasts. Alas, IPv4 does not
1184 allow to send ICMP, so that packets will disappear
1185 to blackhole.
1186 */
1187
1188 IP_INC_STATS_BH(IPSTATS_MIB_FRAGFAILS);
1189 ip_rt_put(rt);
1190 goto out_free;
1191 }
1192
1193 encap += LL_RESERVED_SPACE(dev) + rt->u.dst.header_len;
1194
1195 if (skb_cow(skb, encap)) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001196 ip_rt_put(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 goto out_free;
1198 }
1199
1200 vif->pkt_out++;
1201 vif->bytes_out+=skb->len;
1202
1203 dst_release(skb->dst);
1204 skb->dst = &rt->u.dst;
1205 iph = skb->nh.iph;
1206 ip_decrease_ttl(iph);
1207
1208 /* FIXME: forward and output firewalls used to be called here.
1209 * What do we do with netfilter? -- RR */
1210 if (vif->flags & VIFF_TUNNEL) {
1211 ip_encap(skb, vif->local, vif->remote);
1212 /* FIXME: extra output firewall step used to be here. --RR */
Patrick McHardy2941a482006-01-08 22:05:26 -08001213 ((struct ip_tunnel *)netdev_priv(vif->dev))->stat.tx_packets++;
1214 ((struct ip_tunnel *)netdev_priv(vif->dev))->stat.tx_bytes+=skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 }
1216
1217 IPCB(skb)->flags |= IPSKB_FORWARDED;
1218
1219 /*
1220 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1221 * not only before forwarding, but after forwarding on all output
1222 * interfaces. It is clear, if mrouter runs a multicasting
1223 * program, it should receive packets not depending to what interface
1224 * program is joined.
1225 * If we will not make it, the program will have to join on all
1226 * interfaces. On the other hand, multihoming host (or router, but
1227 * not mrouter) cannot join to more than one interface - it will
1228 * result in receiving multiple packets.
1229 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001230 NF_HOOK(PF_INET, NF_IP_FORWARD, skb, skb->dev, dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 ipmr_forward_finish);
1232 return;
1233
1234out_free:
1235 kfree_skb(skb);
1236 return;
1237}
1238
1239static int ipmr_find_vif(struct net_device *dev)
1240{
1241 int ct;
1242 for (ct=maxvif-1; ct>=0; ct--) {
1243 if (vif_table[ct].dev == dev)
1244 break;
1245 }
1246 return ct;
1247}
1248
1249/* "local" means that we should preserve one skb (for local delivery) */
1250
1251static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local)
1252{
1253 int psend = -1;
1254 int vif, ct;
1255
1256 vif = cache->mfc_parent;
1257 cache->mfc_un.res.pkt++;
1258 cache->mfc_un.res.bytes += skb->len;
1259
1260 /*
1261 * Wrong interface: drop packet and (maybe) send PIM assert.
1262 */
1263 if (vif_table[vif].dev != skb->dev) {
1264 int true_vifi;
1265
1266 if (((struct rtable*)skb->dst)->fl.iif == 0) {
1267 /* It is our own packet, looped back.
1268 Very complicated situation...
1269
1270 The best workaround until routing daemons will be
1271 fixed is not to redistribute packet, if it was
1272 send through wrong interface. It means, that
1273 multicast applications WILL NOT work for
1274 (S,G), which have default multicast route pointing
1275 to wrong oif. In any case, it is not a good
1276 idea to use multicasting applications on router.
1277 */
1278 goto dont_forward;
1279 }
1280
1281 cache->mfc_un.res.wrong_if++;
1282 true_vifi = ipmr_find_vif(skb->dev);
1283
1284 if (true_vifi >= 0 && mroute_do_assert &&
1285 /* pimsm uses asserts, when switching from RPT to SPT,
1286 so that we cannot check that packet arrived on an oif.
1287 It is bad, but otherwise we would need to move pretty
1288 large chunk of pimd to kernel. Ough... --ANK
1289 */
1290 (mroute_do_pim || cache->mfc_un.res.ttls[true_vifi] < 255) &&
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001291 time_after(jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1293 cache->mfc_un.res.last_assert = jiffies;
1294 ipmr_cache_report(skb, true_vifi, IGMPMSG_WRONGVIF);
1295 }
1296 goto dont_forward;
1297 }
1298
1299 vif_table[vif].pkt_in++;
1300 vif_table[vif].bytes_in+=skb->len;
1301
1302 /*
1303 * Forward the frame
1304 */
1305 for (ct = cache->mfc_un.res.maxvif-1; ct >= cache->mfc_un.res.minvif; ct--) {
1306 if (skb->nh.iph->ttl > cache->mfc_un.res.ttls[ct]) {
1307 if (psend != -1) {
1308 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1309 if (skb2)
1310 ipmr_queue_xmit(skb2, cache, psend);
1311 }
1312 psend=ct;
1313 }
1314 }
1315 if (psend != -1) {
1316 if (local) {
1317 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1318 if (skb2)
1319 ipmr_queue_xmit(skb2, cache, psend);
1320 } else {
1321 ipmr_queue_xmit(skb, cache, psend);
1322 return 0;
1323 }
1324 }
1325
1326dont_forward:
1327 if (!local)
1328 kfree_skb(skb);
1329 return 0;
1330}
1331
1332
1333/*
1334 * Multicast packets for forwarding arrive here
1335 */
1336
1337int ip_mr_input(struct sk_buff *skb)
1338{
1339 struct mfc_cache *cache;
1340 int local = ((struct rtable*)skb->dst)->rt_flags&RTCF_LOCAL;
1341
1342 /* Packet is looped back after forward, it should not be
1343 forwarded second time, but still can be delivered locally.
1344 */
1345 if (IPCB(skb)->flags&IPSKB_FORWARDED)
1346 goto dont_forward;
1347
1348 if (!local) {
1349 if (IPCB(skb)->opt.router_alert) {
1350 if (ip_call_ra_chain(skb))
1351 return 0;
1352 } else if (skb->nh.iph->protocol == IPPROTO_IGMP){
1353 /* IGMPv1 (and broken IGMPv2 implementations sort of
1354 Cisco IOS <= 11.2(8)) do not put router alert
1355 option to IGMP packets destined to routable
1356 groups. It is very bad, because it means
1357 that we can forward NO IGMP messages.
1358 */
1359 read_lock(&mrt_lock);
1360 if (mroute_socket) {
Patrick McHardy2715bcf2005-06-21 14:06:24 -07001361 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 raw_rcv(mroute_socket, skb);
1363 read_unlock(&mrt_lock);
1364 return 0;
1365 }
1366 read_unlock(&mrt_lock);
1367 }
1368 }
1369
1370 read_lock(&mrt_lock);
1371 cache = ipmr_cache_find(skb->nh.iph->saddr, skb->nh.iph->daddr);
1372
1373 /*
1374 * No usable cache entry
1375 */
1376 if (cache==NULL) {
1377 int vif;
1378
1379 if (local) {
1380 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1381 ip_local_deliver(skb);
1382 if (skb2 == NULL) {
1383 read_unlock(&mrt_lock);
1384 return -ENOBUFS;
1385 }
1386 skb = skb2;
1387 }
1388
1389 vif = ipmr_find_vif(skb->dev);
1390 if (vif >= 0) {
1391 int err = ipmr_cache_unresolved(vif, skb);
1392 read_unlock(&mrt_lock);
1393
1394 return err;
1395 }
1396 read_unlock(&mrt_lock);
1397 kfree_skb(skb);
1398 return -ENODEV;
1399 }
1400
1401 ip_mr_forward(skb, cache, local);
1402
1403 read_unlock(&mrt_lock);
1404
1405 if (local)
1406 return ip_local_deliver(skb);
1407
1408 return 0;
1409
1410dont_forward:
1411 if (local)
1412 return ip_local_deliver(skb);
1413 kfree_skb(skb);
1414 return 0;
1415}
1416
1417#ifdef CONFIG_IP_PIMSM_V1
1418/*
1419 * Handle IGMP messages of PIMv1
1420 */
1421
1422int pim_rcv_v1(struct sk_buff * skb)
1423{
1424 struct igmphdr *pim;
1425 struct iphdr *encap;
1426 struct net_device *reg_dev = NULL;
1427
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001428 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 goto drop;
1430
1431 pim = (struct igmphdr*)skb->h.raw;
1432
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001433 if (!mroute_do_pim ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 skb->len < sizeof(*pim) + sizeof(*encap) ||
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001435 pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 goto drop;
1437
1438 encap = (struct iphdr*)(skb->h.raw + sizeof(struct igmphdr));
1439 /*
1440 Check that:
1441 a. packet is really destinted to a multicast group
1442 b. packet is not a NULL-REGISTER
1443 c. packet is not truncated
1444 */
1445 if (!MULTICAST(encap->daddr) ||
1446 encap->tot_len == 0 ||
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001447 ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 goto drop;
1449
1450 read_lock(&mrt_lock);
1451 if (reg_vif_num >= 0)
1452 reg_dev = vif_table[reg_vif_num].dev;
1453 if (reg_dev)
1454 dev_hold(reg_dev);
1455 read_unlock(&mrt_lock);
1456
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001457 if (reg_dev == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458 goto drop;
1459
1460 skb->mac.raw = skb->nh.raw;
1461 skb_pull(skb, (u8*)encap - skb->data);
Arnaldo Carvalho de Melo31c77112007-03-10 19:04:55 -03001462 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 skb->dev = reg_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 skb->protocol = htons(ETH_P_IP);
1465 skb->ip_summed = 0;
1466 skb->pkt_type = PACKET_HOST;
1467 dst_release(skb->dst);
1468 skb->dst = NULL;
Patrick McHardy2941a482006-01-08 22:05:26 -08001469 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_bytes += skb->len;
1470 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 nf_reset(skb);
1472 netif_rx(skb);
1473 dev_put(reg_dev);
1474 return 0;
1475 drop:
1476 kfree_skb(skb);
1477 return 0;
1478}
1479#endif
1480
1481#ifdef CONFIG_IP_PIMSM_V2
1482static int pim_rcv(struct sk_buff * skb)
1483{
1484 struct pimreghdr *pim;
1485 struct iphdr *encap;
1486 struct net_device *reg_dev = NULL;
1487
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001488 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 goto drop;
1490
1491 pim = (struct pimreghdr*)skb->h.raw;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001492 if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 (pim->flags&PIM_NULL_REGISTER) ||
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001494 (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
Al Virod3bc23e2006-11-14 21:24:49 -08001495 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 goto drop;
1497
1498 /* check if the inner packet is destined to mcast group */
1499 encap = (struct iphdr*)(skb->h.raw + sizeof(struct pimreghdr));
1500 if (!MULTICAST(encap->daddr) ||
1501 encap->tot_len == 0 ||
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001502 ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 goto drop;
1504
1505 read_lock(&mrt_lock);
1506 if (reg_vif_num >= 0)
1507 reg_dev = vif_table[reg_vif_num].dev;
1508 if (reg_dev)
1509 dev_hold(reg_dev);
1510 read_unlock(&mrt_lock);
1511
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001512 if (reg_dev == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513 goto drop;
1514
1515 skb->mac.raw = skb->nh.raw;
1516 skb_pull(skb, (u8*)encap - skb->data);
Arnaldo Carvalho de Melo31c77112007-03-10 19:04:55 -03001517 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 skb->dev = reg_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 skb->protocol = htons(ETH_P_IP);
1520 skb->ip_summed = 0;
1521 skb->pkt_type = PACKET_HOST;
1522 dst_release(skb->dst);
Patrick McHardy2941a482006-01-08 22:05:26 -08001523 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_bytes += skb->len;
1524 ((struct net_device_stats*)netdev_priv(reg_dev))->rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 skb->dst = NULL;
1526 nf_reset(skb);
1527 netif_rx(skb);
1528 dev_put(reg_dev);
1529 return 0;
1530 drop:
1531 kfree_skb(skb);
1532 return 0;
1533}
1534#endif
1535
1536static int
1537ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm)
1538{
1539 int ct;
1540 struct rtnexthop *nhp;
1541 struct net_device *dev = vif_table[c->mfc_parent].dev;
1542 u8 *b = skb->tail;
1543 struct rtattr *mp_head;
1544
1545 if (dev)
1546 RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex);
1547
1548 mp_head = (struct rtattr*)skb_put(skb, RTA_LENGTH(0));
1549
1550 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1551 if (c->mfc_un.res.ttls[ct] < 255) {
1552 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1553 goto rtattr_failure;
1554 nhp = (struct rtnexthop*)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1555 nhp->rtnh_flags = 0;
1556 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1557 nhp->rtnh_ifindex = vif_table[ct].dev->ifindex;
1558 nhp->rtnh_len = sizeof(*nhp);
1559 }
1560 }
1561 mp_head->rta_type = RTA_MULTIPATH;
1562 mp_head->rta_len = skb->tail - (u8*)mp_head;
1563 rtm->rtm_type = RTN_MULTICAST;
1564 return 1;
1565
1566rtattr_failure:
1567 skb_trim(skb, b - skb->data);
1568 return -EMSGSIZE;
1569}
1570
1571int ipmr_get_route(struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1572{
1573 int err;
1574 struct mfc_cache *cache;
1575 struct rtable *rt = (struct rtable*)skb->dst;
1576
1577 read_lock(&mrt_lock);
1578 cache = ipmr_cache_find(rt->rt_src, rt->rt_dst);
1579
1580 if (cache==NULL) {
Alexey Kuznetsov72287492006-07-25 16:45:12 -07001581 struct sk_buff *skb2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 struct net_device *dev;
1583 int vif;
1584
1585 if (nowait) {
1586 read_unlock(&mrt_lock);
1587 return -EAGAIN;
1588 }
1589
1590 dev = skb->dev;
1591 if (dev == NULL || (vif = ipmr_find_vif(dev)) < 0) {
1592 read_unlock(&mrt_lock);
1593 return -ENODEV;
1594 }
Alexey Kuznetsov72287492006-07-25 16:45:12 -07001595 skb2 = skb_clone(skb, GFP_ATOMIC);
1596 if (!skb2) {
1597 read_unlock(&mrt_lock);
1598 return -ENOMEM;
1599 }
1600
Arnaldo Carvalho de Meloe2d1bca2007-04-10 20:46:21 -07001601 skb_push(skb2, sizeof(struct iphdr));
1602 skb_reset_network_header(skb2);
Alexey Kuznetsov72287492006-07-25 16:45:12 -07001603 skb2->nh.iph->ihl = sizeof(struct iphdr)>>2;
1604 skb2->nh.iph->saddr = rt->rt_src;
1605 skb2->nh.iph->daddr = rt->rt_dst;
1606 skb2->nh.iph->version = 0;
1607 err = ipmr_cache_unresolved(vif, skb2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 read_unlock(&mrt_lock);
1609 return err;
1610 }
1611
1612 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1613 cache->mfc_flags |= MFC_NOTIFY;
1614 err = ipmr_fill_mroute(skb, cache, rtm);
1615 read_unlock(&mrt_lock);
1616 return err;
1617}
1618
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001619#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620/*
1621 * The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
1622 */
1623struct ipmr_vif_iter {
1624 int ct;
1625};
1626
1627static struct vif_device *ipmr_vif_seq_idx(struct ipmr_vif_iter *iter,
1628 loff_t pos)
1629{
1630 for (iter->ct = 0; iter->ct < maxvif; ++iter->ct) {
Stephen Hemminger132adf52007-03-08 20:44:43 -08001631 if (!VIF_EXISTS(iter->ct))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 continue;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001633 if (pos-- == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 return &vif_table[iter->ct];
1635 }
1636 return NULL;
1637}
1638
1639static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
1640{
1641 read_lock(&mrt_lock);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001642 return *pos ? ipmr_vif_seq_idx(seq->private, *pos - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 : SEQ_START_TOKEN;
1644}
1645
1646static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1647{
1648 struct ipmr_vif_iter *iter = seq->private;
1649
1650 ++*pos;
1651 if (v == SEQ_START_TOKEN)
1652 return ipmr_vif_seq_idx(iter, 0);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001653
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 while (++iter->ct < maxvif) {
Stephen Hemminger132adf52007-03-08 20:44:43 -08001655 if (!VIF_EXISTS(iter->ct))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 continue;
1657 return &vif_table[iter->ct];
1658 }
1659 return NULL;
1660}
1661
1662static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
1663{
1664 read_unlock(&mrt_lock);
1665}
1666
1667static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
1668{
1669 if (v == SEQ_START_TOKEN) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001670 seq_puts(seq,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
1672 } else {
1673 const struct vif_device *vif = v;
1674 const char *name = vif->dev ? vif->dev->name : "none";
1675
1676 seq_printf(seq,
1677 "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
1678 vif - vif_table,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001679 name, vif->bytes_in, vif->pkt_in,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 vif->bytes_out, vif->pkt_out,
1681 vif->flags, vif->local, vif->remote);
1682 }
1683 return 0;
1684}
1685
Stephen Hemmingerf6908082007-03-12 14:34:29 -07001686static const struct seq_operations ipmr_vif_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687 .start = ipmr_vif_seq_start,
1688 .next = ipmr_vif_seq_next,
1689 .stop = ipmr_vif_seq_stop,
1690 .show = ipmr_vif_seq_show,
1691};
1692
1693static int ipmr_vif_open(struct inode *inode, struct file *file)
1694{
1695 struct seq_file *seq;
1696 int rc = -ENOMEM;
1697 struct ipmr_vif_iter *s = kmalloc(sizeof(*s), GFP_KERNEL);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001698
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 if (!s)
1700 goto out;
1701
1702 rc = seq_open(file, &ipmr_vif_seq_ops);
1703 if (rc)
1704 goto out_kfree;
1705
1706 s->ct = 0;
1707 seq = file->private_data;
1708 seq->private = s;
1709out:
1710 return rc;
1711out_kfree:
1712 kfree(s);
1713 goto out;
1714
1715}
1716
Arjan van de Ven9a321442007-02-12 00:55:35 -08001717static const struct file_operations ipmr_vif_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 .owner = THIS_MODULE,
1719 .open = ipmr_vif_open,
1720 .read = seq_read,
1721 .llseek = seq_lseek,
1722 .release = seq_release_private,
1723};
1724
1725struct ipmr_mfc_iter {
1726 struct mfc_cache **cache;
1727 int ct;
1728};
1729
1730
1731static struct mfc_cache *ipmr_mfc_seq_idx(struct ipmr_mfc_iter *it, loff_t pos)
1732{
1733 struct mfc_cache *mfc;
1734
1735 it->cache = mfc_cache_array;
1736 read_lock(&mrt_lock);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001737 for (it->ct = 0; it->ct < MFC_LINES; it->ct++)
Stephen Hemminger132adf52007-03-08 20:44:43 -08001738 for (mfc = mfc_cache_array[it->ct]; mfc; mfc = mfc->next)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001739 if (pos-- == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 return mfc;
1741 read_unlock(&mrt_lock);
1742
1743 it->cache = &mfc_unres_queue;
1744 spin_lock_bh(&mfc_unres_lock);
Stephen Hemminger132adf52007-03-08 20:44:43 -08001745 for (mfc = mfc_unres_queue; mfc; mfc = mfc->next)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 if (pos-- == 0)
1747 return mfc;
1748 spin_unlock_bh(&mfc_unres_lock);
1749
1750 it->cache = NULL;
1751 return NULL;
1752}
1753
1754
1755static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
1756{
1757 struct ipmr_mfc_iter *it = seq->private;
1758 it->cache = NULL;
1759 it->ct = 0;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001760 return *pos ? ipmr_mfc_seq_idx(seq->private, *pos - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761 : SEQ_START_TOKEN;
1762}
1763
1764static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1765{
1766 struct mfc_cache *mfc = v;
1767 struct ipmr_mfc_iter *it = seq->private;
1768
1769 ++*pos;
1770
1771 if (v == SEQ_START_TOKEN)
1772 return ipmr_mfc_seq_idx(seq->private, 0);
1773
1774 if (mfc->next)
1775 return mfc->next;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001776
1777 if (it->cache == &mfc_unres_queue)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 goto end_of_list;
1779
1780 BUG_ON(it->cache != mfc_cache_array);
1781
1782 while (++it->ct < MFC_LINES) {
1783 mfc = mfc_cache_array[it->ct];
1784 if (mfc)
1785 return mfc;
1786 }
1787
1788 /* exhausted cache_array, show unresolved */
1789 read_unlock(&mrt_lock);
1790 it->cache = &mfc_unres_queue;
1791 it->ct = 0;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001792
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 spin_lock_bh(&mfc_unres_lock);
1794 mfc = mfc_unres_queue;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001795 if (mfc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 return mfc;
1797
1798 end_of_list:
1799 spin_unlock_bh(&mfc_unres_lock);
1800 it->cache = NULL;
1801
1802 return NULL;
1803}
1804
1805static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
1806{
1807 struct ipmr_mfc_iter *it = seq->private;
1808
1809 if (it->cache == &mfc_unres_queue)
1810 spin_unlock_bh(&mfc_unres_lock);
1811 else if (it->cache == mfc_cache_array)
1812 read_unlock(&mrt_lock);
1813}
1814
1815static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
1816{
1817 int n;
1818
1819 if (v == SEQ_START_TOKEN) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001820 seq_puts(seq,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 "Group Origin Iif Pkts Bytes Wrong Oifs\n");
1822 } else {
1823 const struct mfc_cache *mfc = v;
1824 const struct ipmr_mfc_iter *it = seq->private;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001825
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 seq_printf(seq, "%08lX %08lX %-3d %8ld %8ld %8ld",
1827 (unsigned long) mfc->mfc_mcastgrp,
1828 (unsigned long) mfc->mfc_origin,
1829 mfc->mfc_parent,
1830 mfc->mfc_un.res.pkt,
1831 mfc->mfc_un.res.bytes,
1832 mfc->mfc_un.res.wrong_if);
1833
1834 if (it->cache != &mfc_unres_queue) {
Stephen Hemminger132adf52007-03-08 20:44:43 -08001835 for (n = mfc->mfc_un.res.minvif;
1836 n < mfc->mfc_un.res.maxvif; n++ ) {
1837 if (VIF_EXISTS(n)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 && mfc->mfc_un.res.ttls[n] < 255)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001839 seq_printf(seq,
1840 " %2d:%-3d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841 n, mfc->mfc_un.res.ttls[n]);
1842 }
1843 }
1844 seq_putc(seq, '\n');
1845 }
1846 return 0;
1847}
1848
Stephen Hemmingerf6908082007-03-12 14:34:29 -07001849static const struct seq_operations ipmr_mfc_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 .start = ipmr_mfc_seq_start,
1851 .next = ipmr_mfc_seq_next,
1852 .stop = ipmr_mfc_seq_stop,
1853 .show = ipmr_mfc_seq_show,
1854};
1855
1856static int ipmr_mfc_open(struct inode *inode, struct file *file)
1857{
1858 struct seq_file *seq;
1859 int rc = -ENOMEM;
1860 struct ipmr_mfc_iter *s = kmalloc(sizeof(*s), GFP_KERNEL);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001861
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 if (!s)
1863 goto out;
1864
1865 rc = seq_open(file, &ipmr_mfc_seq_ops);
1866 if (rc)
1867 goto out_kfree;
1868
1869 seq = file->private_data;
1870 seq->private = s;
1871out:
1872 return rc;
1873out_kfree:
1874 kfree(s);
1875 goto out;
1876
1877}
1878
Arjan van de Ven9a321442007-02-12 00:55:35 -08001879static const struct file_operations ipmr_mfc_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 .owner = THIS_MODULE,
1881 .open = ipmr_mfc_open,
1882 .read = seq_read,
1883 .llseek = seq_lseek,
1884 .release = seq_release_private,
1885};
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001886#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887
1888#ifdef CONFIG_IP_PIMSM_V2
1889static struct net_protocol pim_protocol = {
1890 .handler = pim_rcv,
1891};
1892#endif
1893
1894
1895/*
1896 * Setup for IP multicast routing
1897 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001898
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899void __init ip_mr_init(void)
1900{
1901 mrt_cachep = kmem_cache_create("ip_mrt_cache",
1902 sizeof(struct mfc_cache),
Alexey Dobriyane5d679f2006-08-26 19:25:52 -07001903 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 init_timer(&ipmr_expire_timer);
1906 ipmr_expire_timer.function=ipmr_expire_process;
1907 register_netdevice_notifier(&ip_mr_notifier);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001908#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 proc_net_fops_create("ip_mr_vif", 0, &ipmr_vif_fops);
1910 proc_net_fops_create("ip_mr_cache", 0, &ipmr_mfc_fops);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001911#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912}