2 * IP multicast routing support for mrouted 3.6/3.8
4 * (c) 1995 Alan Cox, <alan@lxorguk.ukuu.org.uk>
5 * Linux Consultancy and Custom Driver Development
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.
13 * Michael Chastain : Incorrect size of copying.
14 * Alan Cox : Added the cache manager code
15 * Alan Cox : Fixed the clone/copy bug and device race.
16 * Mike McLagan : Routing by source
17 * Malcolm Beattie : Buffer handling fixes.
18 * Alexey Kuznetsov : Double buffer free and other fixes.
19 * SVR Anand : Fixed several multicast bugs and problems.
20 * Alexey Kuznetsov : Status, optimisations and more.
21 * Brad Parker : Better behaviour on mrouted upcall
23 * Carlos Picoto : PIMv1 Support
24 * Pavlin Ivanov Radoslavov: PIMv2 Registers must checksum only PIM header
25 * Relax this requirement to work with older peers.
29 #include <linux/uaccess.h>
30 #include <linux/types.h>
31 #include <linux/capability.h>
32 #include <linux/errno.h>
33 #include <linux/timer.h>
35 #include <linux/kernel.h>
36 #include <linux/fcntl.h>
37 #include <linux/stat.h>
38 #include <linux/socket.h>
40 #include <linux/inet.h>
41 #include <linux/netdevice.h>
42 #include <linux/inetdevice.h>
43 #include <linux/igmp.h>
44 #include <linux/proc_fs.h>
45 #include <linux/seq_file.h>
46 #include <linux/mroute.h>
47 #include <linux/init.h>
48 #include <linux/if_ether.h>
49 #include <linux/slab.h>
50 #include <net/net_namespace.h>
52 #include <net/protocol.h>
53 #include <linux/skbuff.h>
54 #include <net/route.h>
59 #include <linux/notifier.h>
60 #include <linux/if_arp.h>
61 #include <linux/netfilter_ipv4.h>
62 #include <linux/compat.h>
63 #include <linux/export.h>
64 #include <net/ip_tunnels.h>
65 #include <net/checksum.h>
66 #include <net/netlink.h>
67 #include <net/fib_rules.h>
68 #include <linux/netconf.h>
69 #include <net/nexthop.h>
72 struct fib_rule common
;
79 /* Big lock, protecting vif table, mrt cache and mroute socket state.
80 * Note that the changes are semaphored via rtnl_lock.
83 static DEFINE_RWLOCK(mrt_lock
);
85 /* Multicast router control variables */
87 /* Special spinlock for queue of unresolved entries */
88 static DEFINE_SPINLOCK(mfc_unres_lock
);
90 /* We return to original Alan's scheme. Hash table of resolved
91 * entries is changed only in process context and protected
92 * with weak lock mrt_lock. Queue of unresolved entries is protected
93 * with strong spinlock mfc_unres_lock.
95 * In this case data path is free of exclusive locks at all.
98 static struct kmem_cache
*mrt_cachep __read_mostly
;
100 static struct mr_table
*ipmr_new_table(struct net
*net
, u32 id
);
101 static void ipmr_free_table(struct mr_table
*mrt
);
103 static void ip_mr_forward(struct net
*net
, struct mr_table
*mrt
,
104 struct sk_buff
*skb
, struct mfc_cache
*cache
,
106 static int ipmr_cache_report(struct mr_table
*mrt
,
107 struct sk_buff
*pkt
, vifi_t vifi
, int assert);
108 static int __ipmr_fill_mroute(struct mr_table
*mrt
, struct sk_buff
*skb
,
109 struct mfc_cache
*c
, struct rtmsg
*rtm
);
110 static void mroute_netlink_event(struct mr_table
*mrt
, struct mfc_cache
*mfc
,
112 static void mroute_clean_tables(struct mr_table
*mrt
, bool all
);
113 static void ipmr_expire_process(unsigned long arg
);
115 #ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
116 #define ipmr_for_each_table(mrt, net) \
117 list_for_each_entry_rcu(mrt, &net->ipv4.mr_tables, list)
119 static struct mr_table
*ipmr_get_table(struct net
*net
, u32 id
)
121 struct mr_table
*mrt
;
123 ipmr_for_each_table(mrt
, net
) {
130 static int ipmr_fib_lookup(struct net
*net
, struct flowi4
*flp4
,
131 struct mr_table
**mrt
)
134 struct ipmr_result res
;
135 struct fib_lookup_arg arg
= {
137 .flags
= FIB_LOOKUP_NOREF
,
140 /* update flow if oif or iif point to device enslaved to l3mdev */
141 l3mdev_update_flow(net
, flowi4_to_flowi(flp4
));
143 err
= fib_rules_lookup(net
->ipv4
.mr_rules_ops
,
144 flowi4_to_flowi(flp4
), 0, &arg
);
151 static int ipmr_rule_action(struct fib_rule
*rule
, struct flowi
*flp
,
152 int flags
, struct fib_lookup_arg
*arg
)
154 struct ipmr_result
*res
= arg
->result
;
155 struct mr_table
*mrt
;
157 switch (rule
->action
) {
160 case FR_ACT_UNREACHABLE
:
162 case FR_ACT_PROHIBIT
:
164 case FR_ACT_BLACKHOLE
:
169 arg
->table
= fib_rule_get_table(rule
, arg
);
171 mrt
= ipmr_get_table(rule
->fr_net
, arg
->table
);
178 static int ipmr_rule_match(struct fib_rule
*rule
, struct flowi
*fl
, int flags
)
183 static const struct nla_policy ipmr_rule_policy
[FRA_MAX
+ 1] = {
187 static int ipmr_rule_configure(struct fib_rule
*rule
, struct sk_buff
*skb
,
188 struct fib_rule_hdr
*frh
, struct nlattr
**tb
)
193 static int ipmr_rule_compare(struct fib_rule
*rule
, struct fib_rule_hdr
*frh
,
199 static int ipmr_rule_fill(struct fib_rule
*rule
, struct sk_buff
*skb
,
200 struct fib_rule_hdr
*frh
)
208 static const struct fib_rules_ops __net_initconst ipmr_rules_ops_template
= {
209 .family
= RTNL_FAMILY_IPMR
,
210 .rule_size
= sizeof(struct ipmr_rule
),
211 .addr_size
= sizeof(u32
),
212 .action
= ipmr_rule_action
,
213 .match
= ipmr_rule_match
,
214 .configure
= ipmr_rule_configure
,
215 .compare
= ipmr_rule_compare
,
216 .fill
= ipmr_rule_fill
,
217 .nlgroup
= RTNLGRP_IPV4_RULE
,
218 .policy
= ipmr_rule_policy
,
219 .owner
= THIS_MODULE
,
222 static int __net_init
ipmr_rules_init(struct net
*net
)
224 struct fib_rules_ops
*ops
;
225 struct mr_table
*mrt
;
228 ops
= fib_rules_register(&ipmr_rules_ops_template
, net
);
232 INIT_LIST_HEAD(&net
->ipv4
.mr_tables
);
234 mrt
= ipmr_new_table(net
, RT_TABLE_DEFAULT
);
240 err
= fib_default_rule_add(ops
, 0x7fff, RT_TABLE_DEFAULT
, 0);
244 net
->ipv4
.mr_rules_ops
= ops
;
248 ipmr_free_table(mrt
);
250 fib_rules_unregister(ops
);
254 static void __net_exit
ipmr_rules_exit(struct net
*net
)
256 struct mr_table
*mrt
, *next
;
259 list_for_each_entry_safe(mrt
, next
, &net
->ipv4
.mr_tables
, list
) {
260 list_del(&mrt
->list
);
261 ipmr_free_table(mrt
);
263 fib_rules_unregister(net
->ipv4
.mr_rules_ops
);
267 #define ipmr_for_each_table(mrt, net) \
268 for (mrt = net->ipv4.mrt; mrt; mrt = NULL)
270 static struct mr_table
*ipmr_get_table(struct net
*net
, u32 id
)
272 return net
->ipv4
.mrt
;
275 static int ipmr_fib_lookup(struct net
*net
, struct flowi4
*flp4
,
276 struct mr_table
**mrt
)
278 *mrt
= net
->ipv4
.mrt
;
282 static int __net_init
ipmr_rules_init(struct net
*net
)
284 struct mr_table
*mrt
;
286 mrt
= ipmr_new_table(net
, RT_TABLE_DEFAULT
);
293 static void __net_exit
ipmr_rules_exit(struct net
*net
)
296 ipmr_free_table(net
->ipv4
.mrt
);
297 net
->ipv4
.mrt
= NULL
;
302 static inline int ipmr_hash_cmp(struct rhashtable_compare_arg
*arg
,
305 const struct mfc_cache_cmp_arg
*cmparg
= arg
->key
;
306 struct mfc_cache
*c
= (struct mfc_cache
*)ptr
;
308 return cmparg
->mfc_mcastgrp
!= c
->mfc_mcastgrp
||
309 cmparg
->mfc_origin
!= c
->mfc_origin
;
312 static const struct rhashtable_params ipmr_rht_params
= {
313 .head_offset
= offsetof(struct mfc_cache
, mnode
),
314 .key_offset
= offsetof(struct mfc_cache
, cmparg
),
315 .key_len
= sizeof(struct mfc_cache_cmp_arg
),
318 .obj_cmpfn
= ipmr_hash_cmp
,
319 .automatic_shrinking
= true,
322 static struct mr_table
*ipmr_new_table(struct net
*net
, u32 id
)
324 struct mr_table
*mrt
;
326 /* "pimreg%u" should not exceed 16 bytes (IFNAMSIZ) */
327 if (id
!= RT_TABLE_DEFAULT
&& id
>= 1000000000)
328 return ERR_PTR(-EINVAL
);
330 mrt
= ipmr_get_table(net
, id
);
334 mrt
= kzalloc(sizeof(*mrt
), GFP_KERNEL
);
336 return ERR_PTR(-ENOMEM
);
337 write_pnet(&mrt
->net
, net
);
340 rhltable_init(&mrt
->mfc_hash
, &ipmr_rht_params
);
341 INIT_LIST_HEAD(&mrt
->mfc_cache_list
);
342 INIT_LIST_HEAD(&mrt
->mfc_unres_queue
);
344 setup_timer(&mrt
->ipmr_expire_timer
, ipmr_expire_process
,
347 mrt
->mroute_reg_vif_num
= -1;
348 #ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
349 list_add_tail_rcu(&mrt
->list
, &net
->ipv4
.mr_tables
);
354 static void ipmr_free_table(struct mr_table
*mrt
)
356 del_timer_sync(&mrt
->ipmr_expire_timer
);
357 mroute_clean_tables(mrt
, true);
358 rhltable_destroy(&mrt
->mfc_hash
);
362 /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
364 static void ipmr_del_tunnel(struct net_device
*dev
, struct vifctl
*v
)
366 struct net
*net
= dev_net(dev
);
370 dev
= __dev_get_by_name(net
, "tunl0");
372 const struct net_device_ops
*ops
= dev
->netdev_ops
;
374 struct ip_tunnel_parm p
;
376 memset(&p
, 0, sizeof(p
));
377 p
.iph
.daddr
= v
->vifc_rmt_addr
.s_addr
;
378 p
.iph
.saddr
= v
->vifc_lcl_addr
.s_addr
;
381 p
.iph
.protocol
= IPPROTO_IPIP
;
382 sprintf(p
.name
, "dvmrp%d", v
->vifc_vifi
);
383 ifr
.ifr_ifru
.ifru_data
= (__force
void __user
*)&p
;
385 if (ops
->ndo_do_ioctl
) {
386 mm_segment_t oldfs
= get_fs();
389 ops
->ndo_do_ioctl(dev
, &ifr
, SIOCDELTUNNEL
);
395 /* Initialize ipmr pimreg/tunnel in_device */
396 static bool ipmr_init_vif_indev(const struct net_device
*dev
)
398 struct in_device
*in_dev
;
402 in_dev
= __in_dev_get_rtnl(dev
);
405 ipv4_devconf_setall(in_dev
);
406 neigh_parms_data_state_setall(in_dev
->arp_parms
);
407 IPV4_DEVCONF(in_dev
->cnf
, RP_FILTER
) = 0;
412 static struct net_device
*ipmr_new_tunnel(struct net
*net
, struct vifctl
*v
)
414 struct net_device
*dev
;
416 dev
= __dev_get_by_name(net
, "tunl0");
419 const struct net_device_ops
*ops
= dev
->netdev_ops
;
422 struct ip_tunnel_parm p
;
424 memset(&p
, 0, sizeof(p
));
425 p
.iph
.daddr
= v
->vifc_rmt_addr
.s_addr
;
426 p
.iph
.saddr
= v
->vifc_lcl_addr
.s_addr
;
429 p
.iph
.protocol
= IPPROTO_IPIP
;
430 sprintf(p
.name
, "dvmrp%d", v
->vifc_vifi
);
431 ifr
.ifr_ifru
.ifru_data
= (__force
void __user
*)&p
;
433 if (ops
->ndo_do_ioctl
) {
434 mm_segment_t oldfs
= get_fs();
437 err
= ops
->ndo_do_ioctl(dev
, &ifr
, SIOCADDTUNNEL
);
445 (dev
= __dev_get_by_name(net
, p
.name
)) != NULL
) {
446 dev
->flags
|= IFF_MULTICAST
;
447 if (!ipmr_init_vif_indev(dev
))
457 unregister_netdevice(dev
);
461 #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
462 static netdev_tx_t
reg_vif_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
464 struct net
*net
= dev_net(dev
);
465 struct mr_table
*mrt
;
466 struct flowi4 fl4
= {
467 .flowi4_oif
= dev
->ifindex
,
468 .flowi4_iif
= skb
->skb_iif
? : LOOPBACK_IFINDEX
,
469 .flowi4_mark
= skb
->mark
,
473 err
= ipmr_fib_lookup(net
, &fl4
, &mrt
);
479 read_lock(&mrt_lock
);
480 dev
->stats
.tx_bytes
+= skb
->len
;
481 dev
->stats
.tx_packets
++;
482 ipmr_cache_report(mrt
, skb
, mrt
->mroute_reg_vif_num
, IGMPMSG_WHOLEPKT
);
483 read_unlock(&mrt_lock
);
488 static int reg_vif_get_iflink(const struct net_device
*dev
)
493 static const struct net_device_ops reg_vif_netdev_ops
= {
494 .ndo_start_xmit
= reg_vif_xmit
,
495 .ndo_get_iflink
= reg_vif_get_iflink
,
498 static void reg_vif_setup(struct net_device
*dev
)
500 dev
->type
= ARPHRD_PIMREG
;
501 dev
->mtu
= ETH_DATA_LEN
- sizeof(struct iphdr
) - 8;
502 dev
->flags
= IFF_NOARP
;
503 dev
->netdev_ops
= ®_vif_netdev_ops
;
504 dev
->destructor
= free_netdev
;
505 dev
->features
|= NETIF_F_NETNS_LOCAL
;
508 static struct net_device
*ipmr_reg_vif(struct net
*net
, struct mr_table
*mrt
)
510 struct net_device
*dev
;
513 if (mrt
->id
== RT_TABLE_DEFAULT
)
514 sprintf(name
, "pimreg");
516 sprintf(name
, "pimreg%u", mrt
->id
);
518 dev
= alloc_netdev(0, name
, NET_NAME_UNKNOWN
, reg_vif_setup
);
523 dev_net_set(dev
, net
);
525 if (register_netdevice(dev
)) {
530 if (!ipmr_init_vif_indev(dev
))
540 unregister_netdevice(dev
);
544 /* called with rcu_read_lock() */
545 static int __pim_rcv(struct mr_table
*mrt
, struct sk_buff
*skb
,
548 struct net_device
*reg_dev
= NULL
;
551 encap
= (struct iphdr
*)(skb_transport_header(skb
) + pimlen
);
553 * a. packet is really sent to a multicast group
554 * b. packet is not a NULL-REGISTER
555 * c. packet is not truncated
557 if (!ipv4_is_multicast(encap
->daddr
) ||
558 encap
->tot_len
== 0 ||
559 ntohs(encap
->tot_len
) + pimlen
> skb
->len
)
562 read_lock(&mrt_lock
);
563 if (mrt
->mroute_reg_vif_num
>= 0)
564 reg_dev
= mrt
->vif_table
[mrt
->mroute_reg_vif_num
].dev
;
565 read_unlock(&mrt_lock
);
570 skb
->mac_header
= skb
->network_header
;
571 skb_pull(skb
, (u8
*)encap
- skb
->data
);
572 skb_reset_network_header(skb
);
573 skb
->protocol
= htons(ETH_P_IP
);
574 skb
->ip_summed
= CHECKSUM_NONE
;
576 skb_tunnel_rx(skb
, reg_dev
, dev_net(reg_dev
));
580 return NET_RX_SUCCESS
;
583 static struct net_device
*ipmr_reg_vif(struct net
*net
, struct mr_table
*mrt
)
590 * vif_delete - Delete a VIF entry
591 * @notify: Set to 1, if the caller is a notifier_call
593 static int vif_delete(struct mr_table
*mrt
, int vifi
, int notify
,
594 struct list_head
*head
)
596 struct vif_device
*v
;
597 struct net_device
*dev
;
598 struct in_device
*in_dev
;
600 if (vifi
< 0 || vifi
>= mrt
->maxvif
)
601 return -EADDRNOTAVAIL
;
603 v
= &mrt
->vif_table
[vifi
];
605 write_lock_bh(&mrt_lock
);
610 write_unlock_bh(&mrt_lock
);
611 return -EADDRNOTAVAIL
;
614 if (vifi
== mrt
->mroute_reg_vif_num
)
615 mrt
->mroute_reg_vif_num
= -1;
617 if (vifi
+ 1 == mrt
->maxvif
) {
620 for (tmp
= vifi
- 1; tmp
>= 0; tmp
--) {
621 if (VIF_EXISTS(mrt
, tmp
))
627 write_unlock_bh(&mrt_lock
);
629 dev_set_allmulti(dev
, -1);
631 in_dev
= __in_dev_get_rtnl(dev
);
633 IPV4_DEVCONF(in_dev
->cnf
, MC_FORWARDING
)--;
634 inet_netconf_notify_devconf(dev_net(dev
),
635 NETCONFA_MC_FORWARDING
,
636 dev
->ifindex
, &in_dev
->cnf
);
637 ip_rt_multicast_event(in_dev
);
640 if (v
->flags
& (VIFF_TUNNEL
| VIFF_REGISTER
) && !notify
)
641 unregister_netdevice_queue(dev
, head
);
647 static void ipmr_cache_free_rcu(struct rcu_head
*head
)
649 struct mfc_cache
*c
= container_of(head
, struct mfc_cache
, rcu
);
651 kmem_cache_free(mrt_cachep
, c
);
654 static inline void ipmr_cache_free(struct mfc_cache
*c
)
656 call_rcu(&c
->rcu
, ipmr_cache_free_rcu
);
659 /* Destroy an unresolved cache entry, killing queued skbs
660 * and reporting error to netlink readers.
662 static void ipmr_destroy_unres(struct mr_table
*mrt
, struct mfc_cache
*c
)
664 struct net
*net
= read_pnet(&mrt
->net
);
668 atomic_dec(&mrt
->cache_resolve_queue_len
);
670 while ((skb
= skb_dequeue(&c
->mfc_un
.unres
.unresolved
))) {
671 if (ip_hdr(skb
)->version
== 0) {
672 struct nlmsghdr
*nlh
= (struct nlmsghdr
*)skb_pull(skb
, sizeof(struct iphdr
));
673 nlh
->nlmsg_type
= NLMSG_ERROR
;
674 nlh
->nlmsg_len
= nlmsg_msg_size(sizeof(struct nlmsgerr
));
675 skb_trim(skb
, nlh
->nlmsg_len
);
677 e
->error
= -ETIMEDOUT
;
678 memset(&e
->msg
, 0, sizeof(e
->msg
));
680 rtnl_unicast(skb
, net
, NETLINK_CB(skb
).portid
);
689 /* Timer process for the unresolved queue. */
690 static void ipmr_expire_process(unsigned long arg
)
692 struct mr_table
*mrt
= (struct mr_table
*)arg
;
694 unsigned long expires
;
695 struct mfc_cache
*c
, *next
;
697 if (!spin_trylock(&mfc_unres_lock
)) {
698 mod_timer(&mrt
->ipmr_expire_timer
, jiffies
+HZ
/10);
702 if (list_empty(&mrt
->mfc_unres_queue
))
708 list_for_each_entry_safe(c
, next
, &mrt
->mfc_unres_queue
, list
) {
709 if (time_after(c
->mfc_un
.unres
.expires
, now
)) {
710 unsigned long interval
= c
->mfc_un
.unres
.expires
- now
;
711 if (interval
< expires
)
717 mroute_netlink_event(mrt
, c
, RTM_DELROUTE
);
718 ipmr_destroy_unres(mrt
, c
);
721 if (!list_empty(&mrt
->mfc_unres_queue
))
722 mod_timer(&mrt
->ipmr_expire_timer
, jiffies
+ expires
);
725 spin_unlock(&mfc_unres_lock
);
728 /* Fill oifs list. It is called under write locked mrt_lock. */
729 static void ipmr_update_thresholds(struct mr_table
*mrt
, struct mfc_cache
*cache
,
734 cache
->mfc_un
.res
.minvif
= MAXVIFS
;
735 cache
->mfc_un
.res
.maxvif
= 0;
736 memset(cache
->mfc_un
.res
.ttls
, 255, MAXVIFS
);
738 for (vifi
= 0; vifi
< mrt
->maxvif
; vifi
++) {
739 if (VIF_EXISTS(mrt
, vifi
) &&
740 ttls
[vifi
] && ttls
[vifi
] < 255) {
741 cache
->mfc_un
.res
.ttls
[vifi
] = ttls
[vifi
];
742 if (cache
->mfc_un
.res
.minvif
> vifi
)
743 cache
->mfc_un
.res
.minvif
= vifi
;
744 if (cache
->mfc_un
.res
.maxvif
<= vifi
)
745 cache
->mfc_un
.res
.maxvif
= vifi
+ 1;
748 cache
->mfc_un
.res
.lastuse
= jiffies
;
751 static int vif_add(struct net
*net
, struct mr_table
*mrt
,
752 struct vifctl
*vifc
, int mrtsock
)
754 int vifi
= vifc
->vifc_vifi
;
755 struct vif_device
*v
= &mrt
->vif_table
[vifi
];
756 struct net_device
*dev
;
757 struct in_device
*in_dev
;
761 if (VIF_EXISTS(mrt
, vifi
))
764 switch (vifc
->vifc_flags
) {
766 if (!ipmr_pimsm_enabled())
768 /* Special Purpose VIF in PIM
769 * All the packets will be sent to the daemon
771 if (mrt
->mroute_reg_vif_num
>= 0)
773 dev
= ipmr_reg_vif(net
, mrt
);
776 err
= dev_set_allmulti(dev
, 1);
778 unregister_netdevice(dev
);
784 dev
= ipmr_new_tunnel(net
, vifc
);
787 err
= dev_set_allmulti(dev
, 1);
789 ipmr_del_tunnel(dev
, vifc
);
794 case VIFF_USE_IFINDEX
:
796 if (vifc
->vifc_flags
== VIFF_USE_IFINDEX
) {
797 dev
= dev_get_by_index(net
, vifc
->vifc_lcl_ifindex
);
798 if (dev
&& !__in_dev_get_rtnl(dev
)) {
800 return -EADDRNOTAVAIL
;
803 dev
= ip_dev_find(net
, vifc
->vifc_lcl_addr
.s_addr
);
806 return -EADDRNOTAVAIL
;
807 err
= dev_set_allmulti(dev
, 1);
817 in_dev
= __in_dev_get_rtnl(dev
);
820 return -EADDRNOTAVAIL
;
822 IPV4_DEVCONF(in_dev
->cnf
, MC_FORWARDING
)++;
823 inet_netconf_notify_devconf(net
, NETCONFA_MC_FORWARDING
, dev
->ifindex
,
825 ip_rt_multicast_event(in_dev
);
827 /* Fill in the VIF structures */
829 v
->rate_limit
= vifc
->vifc_rate_limit
;
830 v
->local
= vifc
->vifc_lcl_addr
.s_addr
;
831 v
->remote
= vifc
->vifc_rmt_addr
.s_addr
;
832 v
->flags
= vifc
->vifc_flags
;
834 v
->flags
|= VIFF_STATIC
;
835 v
->threshold
= vifc
->vifc_threshold
;
840 v
->link
= dev
->ifindex
;
841 if (v
->flags
& (VIFF_TUNNEL
| VIFF_REGISTER
))
842 v
->link
= dev_get_iflink(dev
);
844 /* And finish update writing critical data */
845 write_lock_bh(&mrt_lock
);
847 if (v
->flags
& VIFF_REGISTER
)
848 mrt
->mroute_reg_vif_num
= vifi
;
849 if (vifi
+1 > mrt
->maxvif
)
850 mrt
->maxvif
= vifi
+1;
851 write_unlock_bh(&mrt_lock
);
855 /* called with rcu_read_lock() */
856 static struct mfc_cache
*ipmr_cache_find(struct mr_table
*mrt
,
860 struct mfc_cache_cmp_arg arg
= {
861 .mfc_mcastgrp
= mcastgrp
,
864 struct rhlist_head
*tmp
, *list
;
867 list
= rhltable_lookup(&mrt
->mfc_hash
, &arg
, ipmr_rht_params
);
868 rhl_for_each_entry_rcu(c
, tmp
, list
, mnode
)
874 /* Look for a (*,*,oif) entry */
875 static struct mfc_cache
*ipmr_cache_find_any_parent(struct mr_table
*mrt
,
878 struct mfc_cache_cmp_arg arg
= {
879 .mfc_mcastgrp
= htonl(INADDR_ANY
),
880 .mfc_origin
= htonl(INADDR_ANY
)
882 struct rhlist_head
*tmp
, *list
;
885 list
= rhltable_lookup(&mrt
->mfc_hash
, &arg
, ipmr_rht_params
);
886 rhl_for_each_entry_rcu(c
, tmp
, list
, mnode
)
887 if (c
->mfc_un
.res
.ttls
[vifi
] < 255)
893 /* Look for a (*,G) entry */
894 static struct mfc_cache
*ipmr_cache_find_any(struct mr_table
*mrt
,
895 __be32 mcastgrp
, int vifi
)
897 struct mfc_cache_cmp_arg arg
= {
898 .mfc_mcastgrp
= mcastgrp
,
899 .mfc_origin
= htonl(INADDR_ANY
)
901 struct rhlist_head
*tmp
, *list
;
902 struct mfc_cache
*c
, *proxy
;
904 if (mcastgrp
== htonl(INADDR_ANY
))
907 list
= rhltable_lookup(&mrt
->mfc_hash
, &arg
, ipmr_rht_params
);
908 rhl_for_each_entry_rcu(c
, tmp
, list
, mnode
) {
909 if (c
->mfc_un
.res
.ttls
[vifi
] < 255)
912 /* It's ok if the vifi is part of the static tree */
913 proxy
= ipmr_cache_find_any_parent(mrt
, c
->mfc_parent
);
914 if (proxy
&& proxy
->mfc_un
.res
.ttls
[vifi
] < 255)
919 return ipmr_cache_find_any_parent(mrt
, vifi
);
922 /* Look for a (S,G,iif) entry if parent != -1 */
923 static struct mfc_cache
*ipmr_cache_find_parent(struct mr_table
*mrt
,
924 __be32 origin
, __be32 mcastgrp
,
927 struct mfc_cache_cmp_arg arg
= {
928 .mfc_mcastgrp
= mcastgrp
,
929 .mfc_origin
= origin
,
931 struct rhlist_head
*tmp
, *list
;
934 list
= rhltable_lookup(&mrt
->mfc_hash
, &arg
, ipmr_rht_params
);
935 rhl_for_each_entry_rcu(c
, tmp
, list
, mnode
)
936 if (parent
== -1 || parent
== c
->mfc_parent
)
942 /* Allocate a multicast cache entry */
943 static struct mfc_cache
*ipmr_cache_alloc(void)
945 struct mfc_cache
*c
= kmem_cache_zalloc(mrt_cachep
, GFP_KERNEL
);
948 c
->mfc_un
.res
.last_assert
= jiffies
- MFC_ASSERT_THRESH
- 1;
949 c
->mfc_un
.res
.minvif
= MAXVIFS
;
954 static struct mfc_cache
*ipmr_cache_alloc_unres(void)
956 struct mfc_cache
*c
= kmem_cache_zalloc(mrt_cachep
, GFP_ATOMIC
);
959 skb_queue_head_init(&c
->mfc_un
.unres
.unresolved
);
960 c
->mfc_un
.unres
.expires
= jiffies
+ 10*HZ
;
965 /* A cache entry has gone into a resolved state from queued */
966 static void ipmr_cache_resolve(struct net
*net
, struct mr_table
*mrt
,
967 struct mfc_cache
*uc
, struct mfc_cache
*c
)
972 /* Play the pending entries through our router */
973 while ((skb
= __skb_dequeue(&uc
->mfc_un
.unres
.unresolved
))) {
974 if (ip_hdr(skb
)->version
== 0) {
975 struct nlmsghdr
*nlh
= (struct nlmsghdr
*)skb_pull(skb
, sizeof(struct iphdr
));
977 if (__ipmr_fill_mroute(mrt
, skb
, c
, nlmsg_data(nlh
)) > 0) {
978 nlh
->nlmsg_len
= skb_tail_pointer(skb
) -
981 nlh
->nlmsg_type
= NLMSG_ERROR
;
982 nlh
->nlmsg_len
= nlmsg_msg_size(sizeof(struct nlmsgerr
));
983 skb_trim(skb
, nlh
->nlmsg_len
);
985 e
->error
= -EMSGSIZE
;
986 memset(&e
->msg
, 0, sizeof(e
->msg
));
989 rtnl_unicast(skb
, net
, NETLINK_CB(skb
).portid
);
991 ip_mr_forward(net
, mrt
, skb
, c
, 0);
996 /* Bounce a cache query up to mrouted. We could use netlink for this but mrouted
997 * expects the following bizarre scheme.
999 * Called under mrt_lock.
1001 static int ipmr_cache_report(struct mr_table
*mrt
,
1002 struct sk_buff
*pkt
, vifi_t vifi
, int assert)
1004 const int ihl
= ip_hdrlen(pkt
);
1005 struct sock
*mroute_sk
;
1006 struct igmphdr
*igmp
;
1007 struct igmpmsg
*msg
;
1008 struct sk_buff
*skb
;
1011 if (assert == IGMPMSG_WHOLEPKT
)
1012 skb
= skb_realloc_headroom(pkt
, sizeof(struct iphdr
));
1014 skb
= alloc_skb(128, GFP_ATOMIC
);
1019 if (assert == IGMPMSG_WHOLEPKT
) {
1020 /* Ugly, but we have no choice with this interface.
1021 * Duplicate old header, fix ihl, length etc.
1022 * And all this only to mangle msg->im_msgtype and
1023 * to set msg->im_mbz to "mbz" :-)
1025 skb_push(skb
, sizeof(struct iphdr
));
1026 skb_reset_network_header(skb
);
1027 skb_reset_transport_header(skb
);
1028 msg
= (struct igmpmsg
*)skb_network_header(skb
);
1029 memcpy(msg
, skb_network_header(pkt
), sizeof(struct iphdr
));
1030 msg
->im_msgtype
= IGMPMSG_WHOLEPKT
;
1032 msg
->im_vif
= mrt
->mroute_reg_vif_num
;
1033 ip_hdr(skb
)->ihl
= sizeof(struct iphdr
) >> 2;
1034 ip_hdr(skb
)->tot_len
= htons(ntohs(ip_hdr(pkt
)->tot_len
) +
1035 sizeof(struct iphdr
));
1037 /* Copy the IP header */
1038 skb_set_network_header(skb
, skb
->len
);
1040 skb_copy_to_linear_data(skb
, pkt
->data
, ihl
);
1041 /* Flag to the kernel this is a route add */
1042 ip_hdr(skb
)->protocol
= 0;
1043 msg
= (struct igmpmsg
*)skb_network_header(skb
);
1045 skb_dst_set(skb
, dst_clone(skb_dst(pkt
)));
1046 /* Add our header */
1047 igmp
= (struct igmphdr
*)skb_put(skb
, sizeof(struct igmphdr
));
1048 igmp
->type
= assert;
1049 msg
->im_msgtype
= assert;
1051 ip_hdr(skb
)->tot_len
= htons(skb
->len
); /* Fix the length */
1052 skb
->transport_header
= skb
->network_header
;
1056 mroute_sk
= rcu_dereference(mrt
->mroute_sk
);
1063 /* Deliver to mrouted */
1064 ret
= sock_queue_rcv_skb(mroute_sk
, skb
);
1067 net_warn_ratelimited("mroute: pending queue full, dropping entries\n");
1074 /* Queue a packet for resolution. It gets locked cache entry! */
1075 static int ipmr_cache_unresolved(struct mr_table
*mrt
, vifi_t vifi
,
1076 struct sk_buff
*skb
)
1078 const struct iphdr
*iph
= ip_hdr(skb
);
1079 struct mfc_cache
*c
;
1083 spin_lock_bh(&mfc_unres_lock
);
1084 list_for_each_entry(c
, &mrt
->mfc_unres_queue
, list
) {
1085 if (c
->mfc_mcastgrp
== iph
->daddr
&&
1086 c
->mfc_origin
== iph
->saddr
) {
1093 /* Create a new entry if allowable */
1094 if (atomic_read(&mrt
->cache_resolve_queue_len
) >= 10 ||
1095 (c
= ipmr_cache_alloc_unres()) == NULL
) {
1096 spin_unlock_bh(&mfc_unres_lock
);
1102 /* Fill in the new cache entry */
1104 c
->mfc_origin
= iph
->saddr
;
1105 c
->mfc_mcastgrp
= iph
->daddr
;
1107 /* Reflect first query at mrouted. */
1108 err
= ipmr_cache_report(mrt
, skb
, vifi
, IGMPMSG_NOCACHE
);
1110 /* If the report failed throw the cache entry
1113 spin_unlock_bh(&mfc_unres_lock
);
1120 atomic_inc(&mrt
->cache_resolve_queue_len
);
1121 list_add(&c
->list
, &mrt
->mfc_unres_queue
);
1122 mroute_netlink_event(mrt
, c
, RTM_NEWROUTE
);
1124 if (atomic_read(&mrt
->cache_resolve_queue_len
) == 1)
1125 mod_timer(&mrt
->ipmr_expire_timer
, c
->mfc_un
.unres
.expires
);
1128 /* See if we can append the packet */
1129 if (c
->mfc_un
.unres
.unresolved
.qlen
> 3) {
1133 skb_queue_tail(&c
->mfc_un
.unres
.unresolved
, skb
);
1137 spin_unlock_bh(&mfc_unres_lock
);
1141 /* MFC cache manipulation by user space mroute daemon */
1143 static int ipmr_mfc_delete(struct mr_table
*mrt
, struct mfcctl
*mfc
, int parent
)
1145 struct mfc_cache
*c
;
1147 /* The entries are added/deleted only under RTNL */
1149 c
= ipmr_cache_find_parent(mrt
, mfc
->mfcc_origin
.s_addr
,
1150 mfc
->mfcc_mcastgrp
.s_addr
, parent
);
1154 rhltable_remove(&mrt
->mfc_hash
, &c
->mnode
, ipmr_rht_params
);
1155 list_del_rcu(&c
->list
);
1156 mroute_netlink_event(mrt
, c
, RTM_DELROUTE
);
1162 static int ipmr_mfc_add(struct net
*net
, struct mr_table
*mrt
,
1163 struct mfcctl
*mfc
, int mrtsock
, int parent
)
1165 struct mfc_cache
*uc
, *c
;
1169 if (mfc
->mfcc_parent
>= MAXVIFS
)
1172 /* The entries are added/deleted only under RTNL */
1174 c
= ipmr_cache_find_parent(mrt
, mfc
->mfcc_origin
.s_addr
,
1175 mfc
->mfcc_mcastgrp
.s_addr
, parent
);
1178 write_lock_bh(&mrt_lock
);
1179 c
->mfc_parent
= mfc
->mfcc_parent
;
1180 ipmr_update_thresholds(mrt
, c
, mfc
->mfcc_ttls
);
1182 c
->mfc_flags
|= MFC_STATIC
;
1183 write_unlock_bh(&mrt_lock
);
1184 mroute_netlink_event(mrt
, c
, RTM_NEWROUTE
);
1188 if (mfc
->mfcc_mcastgrp
.s_addr
!= htonl(INADDR_ANY
) &&
1189 !ipv4_is_multicast(mfc
->mfcc_mcastgrp
.s_addr
))
1192 c
= ipmr_cache_alloc();
1196 c
->mfc_origin
= mfc
->mfcc_origin
.s_addr
;
1197 c
->mfc_mcastgrp
= mfc
->mfcc_mcastgrp
.s_addr
;
1198 c
->mfc_parent
= mfc
->mfcc_parent
;
1199 ipmr_update_thresholds(mrt
, c
, mfc
->mfcc_ttls
);
1201 c
->mfc_flags
|= MFC_STATIC
;
1203 ret
= rhltable_insert_key(&mrt
->mfc_hash
, &c
->cmparg
, &c
->mnode
,
1206 pr_err("ipmr: rhtable insert error %d\n", ret
);
1210 list_add_tail_rcu(&c
->list
, &mrt
->mfc_cache_list
);
1211 /* Check to see if we resolved a queued list. If so we
1212 * need to send on the frames and tidy up.
1215 spin_lock_bh(&mfc_unres_lock
);
1216 list_for_each_entry(uc
, &mrt
->mfc_unres_queue
, list
) {
1217 if (uc
->mfc_origin
== c
->mfc_origin
&&
1218 uc
->mfc_mcastgrp
== c
->mfc_mcastgrp
) {
1219 list_del(&uc
->list
);
1220 atomic_dec(&mrt
->cache_resolve_queue_len
);
1225 if (list_empty(&mrt
->mfc_unres_queue
))
1226 del_timer(&mrt
->ipmr_expire_timer
);
1227 spin_unlock_bh(&mfc_unres_lock
);
1230 ipmr_cache_resolve(net
, mrt
, uc
, c
);
1231 ipmr_cache_free(uc
);
1233 mroute_netlink_event(mrt
, c
, RTM_NEWROUTE
);
1237 /* Close the multicast socket, and clear the vif tables etc */
1238 static void mroute_clean_tables(struct mr_table
*mrt
, bool all
)
1240 struct mfc_cache
*c
, *tmp
;
1244 /* Shut down all active vif entries */
1245 for (i
= 0; i
< mrt
->maxvif
; i
++) {
1246 if (!all
&& (mrt
->vif_table
[i
].flags
& VIFF_STATIC
))
1248 vif_delete(mrt
, i
, 0, &list
);
1250 unregister_netdevice_many(&list
);
1252 /* Wipe the cache */
1253 list_for_each_entry_safe(c
, tmp
, &mrt
->mfc_cache_list
, list
) {
1254 if (!all
&& (c
->mfc_flags
& MFC_STATIC
))
1256 rhltable_remove(&mrt
->mfc_hash
, &c
->mnode
, ipmr_rht_params
);
1257 list_del_rcu(&c
->list
);
1258 mroute_netlink_event(mrt
, c
, RTM_DELROUTE
);
1262 if (atomic_read(&mrt
->cache_resolve_queue_len
) != 0) {
1263 spin_lock_bh(&mfc_unres_lock
);
1264 list_for_each_entry_safe(c
, tmp
, &mrt
->mfc_unres_queue
, list
) {
1266 mroute_netlink_event(mrt
, c
, RTM_DELROUTE
);
1267 ipmr_destroy_unres(mrt
, c
);
1269 spin_unlock_bh(&mfc_unres_lock
);
1273 /* called from ip_ra_control(), before an RCU grace period,
1274 * we dont need to call synchronize_rcu() here
1276 static void mrtsock_destruct(struct sock
*sk
)
1278 struct net
*net
= sock_net(sk
);
1279 struct mr_table
*mrt
;
1282 ipmr_for_each_table(mrt
, net
) {
1283 if (sk
== rtnl_dereference(mrt
->mroute_sk
)) {
1284 IPV4_DEVCONF_ALL(net
, MC_FORWARDING
)--;
1285 inet_netconf_notify_devconf(net
, NETCONFA_MC_FORWARDING
,
1286 NETCONFA_IFINDEX_ALL
,
1287 net
->ipv4
.devconf_all
);
1288 RCU_INIT_POINTER(mrt
->mroute_sk
, NULL
);
1289 mroute_clean_tables(mrt
, false);
1295 /* Socket options and virtual interface manipulation. The whole
1296 * virtual interface system is a complete heap, but unfortunately
1297 * that's how BSD mrouted happens to think. Maybe one day with a proper
1298 * MOSPF/PIM router set up we can clean this up.
1301 int ip_mroute_setsockopt(struct sock
*sk
, int optname
, char __user
*optval
,
1302 unsigned int optlen
)
1304 struct net
*net
= sock_net(sk
);
1305 int val
, ret
= 0, parent
= 0;
1306 struct mr_table
*mrt
;
1311 /* There's one exception to the lock - MRT_DONE which needs to unlock */
1313 if (sk
->sk_type
!= SOCK_RAW
||
1314 inet_sk(sk
)->inet_num
!= IPPROTO_IGMP
) {
1319 mrt
= ipmr_get_table(net
, raw_sk(sk
)->ipmr_table
? : RT_TABLE_DEFAULT
);
1324 if (optname
!= MRT_INIT
) {
1325 if (sk
!= rcu_access_pointer(mrt
->mroute_sk
) &&
1326 !ns_capable(net
->user_ns
, CAP_NET_ADMIN
)) {
1334 if (optlen
!= sizeof(int)) {
1338 if (rtnl_dereference(mrt
->mroute_sk
)) {
1343 ret
= ip_ra_control(sk
, 1, mrtsock_destruct
);
1345 rcu_assign_pointer(mrt
->mroute_sk
, sk
);
1346 IPV4_DEVCONF_ALL(net
, MC_FORWARDING
)++;
1347 inet_netconf_notify_devconf(net
, NETCONFA_MC_FORWARDING
,
1348 NETCONFA_IFINDEX_ALL
,
1349 net
->ipv4
.devconf_all
);
1353 if (sk
!= rcu_access_pointer(mrt
->mroute_sk
)) {
1356 /* We need to unlock here because mrtsock_destruct takes
1357 * care of rtnl itself and we can't change that due to
1358 * the IP_ROUTER_ALERT setsockopt which runs without it.
1361 ret
= ip_ra_control(sk
, 0, NULL
);
1367 if (optlen
!= sizeof(vif
)) {
1371 if (copy_from_user(&vif
, optval
, sizeof(vif
))) {
1375 if (vif
.vifc_vifi
>= MAXVIFS
) {
1379 if (optname
== MRT_ADD_VIF
) {
1380 ret
= vif_add(net
, mrt
, &vif
,
1381 sk
== rtnl_dereference(mrt
->mroute_sk
));
1383 ret
= vif_delete(mrt
, vif
.vifc_vifi
, 0, NULL
);
1386 /* Manipulate the forwarding caches. These live
1387 * in a sort of kernel/user symbiosis.
1392 case MRT_ADD_MFC_PROXY
:
1393 case MRT_DEL_MFC_PROXY
:
1394 if (optlen
!= sizeof(mfc
)) {
1398 if (copy_from_user(&mfc
, optval
, sizeof(mfc
))) {
1403 parent
= mfc
.mfcc_parent
;
1404 if (optname
== MRT_DEL_MFC
|| optname
== MRT_DEL_MFC_PROXY
)
1405 ret
= ipmr_mfc_delete(mrt
, &mfc
, parent
);
1407 ret
= ipmr_mfc_add(net
, mrt
, &mfc
,
1408 sk
== rtnl_dereference(mrt
->mroute_sk
),
1411 /* Control PIM assert. */
1413 if (optlen
!= sizeof(val
)) {
1417 if (get_user(val
, (int __user
*)optval
)) {
1421 mrt
->mroute_do_assert
= val
;
1424 if (!ipmr_pimsm_enabled()) {
1428 if (optlen
!= sizeof(val
)) {
1432 if (get_user(val
, (int __user
*)optval
)) {
1438 if (val
!= mrt
->mroute_do_pim
) {
1439 mrt
->mroute_do_pim
= val
;
1440 mrt
->mroute_do_assert
= val
;
1444 if (!IS_BUILTIN(CONFIG_IP_MROUTE_MULTIPLE_TABLES
)) {
1448 if (optlen
!= sizeof(uval
)) {
1452 if (get_user(uval
, (u32 __user
*)optval
)) {
1457 if (sk
== rtnl_dereference(mrt
->mroute_sk
)) {
1460 mrt
= ipmr_new_table(net
, uval
);
1464 raw_sk(sk
)->ipmr_table
= uval
;
1467 /* Spurious command, or MRT_VERSION which you cannot set. */
1477 /* Getsock opt support for the multicast routing system. */
1478 int ip_mroute_getsockopt(struct sock
*sk
, int optname
, char __user
*optval
, int __user
*optlen
)
1482 struct net
*net
= sock_net(sk
);
1483 struct mr_table
*mrt
;
1485 if (sk
->sk_type
!= SOCK_RAW
||
1486 inet_sk(sk
)->inet_num
!= IPPROTO_IGMP
)
1489 mrt
= ipmr_get_table(net
, raw_sk(sk
)->ipmr_table
? : RT_TABLE_DEFAULT
);
1498 if (!ipmr_pimsm_enabled())
1499 return -ENOPROTOOPT
;
1500 val
= mrt
->mroute_do_pim
;
1503 val
= mrt
->mroute_do_assert
;
1506 return -ENOPROTOOPT
;
1509 if (get_user(olr
, optlen
))
1511 olr
= min_t(unsigned int, olr
, sizeof(int));
1514 if (put_user(olr
, optlen
))
1516 if (copy_to_user(optval
, &val
, olr
))
1521 /* The IP multicast ioctl support routines. */
1522 int ipmr_ioctl(struct sock
*sk
, int cmd
, void __user
*arg
)
1524 struct sioc_sg_req sr
;
1525 struct sioc_vif_req vr
;
1526 struct vif_device
*vif
;
1527 struct mfc_cache
*c
;
1528 struct net
*net
= sock_net(sk
);
1529 struct mr_table
*mrt
;
1531 mrt
= ipmr_get_table(net
, raw_sk(sk
)->ipmr_table
? : RT_TABLE_DEFAULT
);
1537 if (copy_from_user(&vr
, arg
, sizeof(vr
)))
1539 if (vr
.vifi
>= mrt
->maxvif
)
1541 read_lock(&mrt_lock
);
1542 vif
= &mrt
->vif_table
[vr
.vifi
];
1543 if (VIF_EXISTS(mrt
, vr
.vifi
)) {
1544 vr
.icount
= vif
->pkt_in
;
1545 vr
.ocount
= vif
->pkt_out
;
1546 vr
.ibytes
= vif
->bytes_in
;
1547 vr
.obytes
= vif
->bytes_out
;
1548 read_unlock(&mrt_lock
);
1550 if (copy_to_user(arg
, &vr
, sizeof(vr
)))
1554 read_unlock(&mrt_lock
);
1555 return -EADDRNOTAVAIL
;
1557 if (copy_from_user(&sr
, arg
, sizeof(sr
)))
1561 c
= ipmr_cache_find(mrt
, sr
.src
.s_addr
, sr
.grp
.s_addr
);
1563 sr
.pktcnt
= c
->mfc_un
.res
.pkt
;
1564 sr
.bytecnt
= c
->mfc_un
.res
.bytes
;
1565 sr
.wrong_if
= c
->mfc_un
.res
.wrong_if
;
1568 if (copy_to_user(arg
, &sr
, sizeof(sr
)))
1573 return -EADDRNOTAVAIL
;
1575 return -ENOIOCTLCMD
;
1579 #ifdef CONFIG_COMPAT
1580 struct compat_sioc_sg_req
{
1583 compat_ulong_t pktcnt
;
1584 compat_ulong_t bytecnt
;
1585 compat_ulong_t wrong_if
;
1588 struct compat_sioc_vif_req
{
1589 vifi_t vifi
; /* Which iface */
1590 compat_ulong_t icount
;
1591 compat_ulong_t ocount
;
1592 compat_ulong_t ibytes
;
1593 compat_ulong_t obytes
;
1596 int ipmr_compat_ioctl(struct sock
*sk
, unsigned int cmd
, void __user
*arg
)
1598 struct compat_sioc_sg_req sr
;
1599 struct compat_sioc_vif_req vr
;
1600 struct vif_device
*vif
;
1601 struct mfc_cache
*c
;
1602 struct net
*net
= sock_net(sk
);
1603 struct mr_table
*mrt
;
1605 mrt
= ipmr_get_table(net
, raw_sk(sk
)->ipmr_table
? : RT_TABLE_DEFAULT
);
1611 if (copy_from_user(&vr
, arg
, sizeof(vr
)))
1613 if (vr
.vifi
>= mrt
->maxvif
)
1615 read_lock(&mrt_lock
);
1616 vif
= &mrt
->vif_table
[vr
.vifi
];
1617 if (VIF_EXISTS(mrt
, vr
.vifi
)) {
1618 vr
.icount
= vif
->pkt_in
;
1619 vr
.ocount
= vif
->pkt_out
;
1620 vr
.ibytes
= vif
->bytes_in
;
1621 vr
.obytes
= vif
->bytes_out
;
1622 read_unlock(&mrt_lock
);
1624 if (copy_to_user(arg
, &vr
, sizeof(vr
)))
1628 read_unlock(&mrt_lock
);
1629 return -EADDRNOTAVAIL
;
1631 if (copy_from_user(&sr
, arg
, sizeof(sr
)))
1635 c
= ipmr_cache_find(mrt
, sr
.src
.s_addr
, sr
.grp
.s_addr
);
1637 sr
.pktcnt
= c
->mfc_un
.res
.pkt
;
1638 sr
.bytecnt
= c
->mfc_un
.res
.bytes
;
1639 sr
.wrong_if
= c
->mfc_un
.res
.wrong_if
;
1642 if (copy_to_user(arg
, &sr
, sizeof(sr
)))
1647 return -EADDRNOTAVAIL
;
1649 return -ENOIOCTLCMD
;
1654 static int ipmr_device_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
1656 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1657 struct net
*net
= dev_net(dev
);
1658 struct mr_table
*mrt
;
1659 struct vif_device
*v
;
1662 if (event
!= NETDEV_UNREGISTER
)
1665 ipmr_for_each_table(mrt
, net
) {
1666 v
= &mrt
->vif_table
[0];
1667 for (ct
= 0; ct
< mrt
->maxvif
; ct
++, v
++) {
1669 vif_delete(mrt
, ct
, 1, NULL
);
1675 static struct notifier_block ip_mr_notifier
= {
1676 .notifier_call
= ipmr_device_event
,
1679 /* Encapsulate a packet by attaching a valid IPIP header to it.
1680 * This avoids tunnel drivers and other mess and gives us the speed so
1681 * important for multicast video.
1683 static void ip_encap(struct net
*net
, struct sk_buff
*skb
,
1684 __be32 saddr
, __be32 daddr
)
1687 const struct iphdr
*old_iph
= ip_hdr(skb
);
1689 skb_push(skb
, sizeof(struct iphdr
));
1690 skb
->transport_header
= skb
->network_header
;
1691 skb_reset_network_header(skb
);
1695 iph
->tos
= old_iph
->tos
;
1696 iph
->ttl
= old_iph
->ttl
;
1700 iph
->protocol
= IPPROTO_IPIP
;
1702 iph
->tot_len
= htons(skb
->len
);
1703 ip_select_ident(net
, skb
, NULL
);
1706 memset(&(IPCB(skb
)->opt
), 0, sizeof(IPCB(skb
)->opt
));
1710 static inline int ipmr_forward_finish(struct net
*net
, struct sock
*sk
,
1711 struct sk_buff
*skb
)
1713 struct ip_options
*opt
= &(IPCB(skb
)->opt
);
1715 IP_INC_STATS(net
, IPSTATS_MIB_OUTFORWDATAGRAMS
);
1716 IP_ADD_STATS(net
, IPSTATS_MIB_OUTOCTETS
, skb
->len
);
1718 if (unlikely(opt
->optlen
))
1719 ip_forward_options(skb
);
1721 return dst_output(net
, sk
, skb
);
1724 /* Processing handlers for ipmr_forward */
1726 static void ipmr_queue_xmit(struct net
*net
, struct mr_table
*mrt
,
1727 struct sk_buff
*skb
, struct mfc_cache
*c
, int vifi
)
1729 const struct iphdr
*iph
= ip_hdr(skb
);
1730 struct vif_device
*vif
= &mrt
->vif_table
[vifi
];
1731 struct net_device
*dev
;
1739 if (vif
->flags
& VIFF_REGISTER
) {
1741 vif
->bytes_out
+= skb
->len
;
1742 vif
->dev
->stats
.tx_bytes
+= skb
->len
;
1743 vif
->dev
->stats
.tx_packets
++;
1744 ipmr_cache_report(mrt
, skb
, vifi
, IGMPMSG_WHOLEPKT
);
1748 if (vif
->flags
& VIFF_TUNNEL
) {
1749 rt
= ip_route_output_ports(net
, &fl4
, NULL
,
1750 vif
->remote
, vif
->local
,
1753 RT_TOS(iph
->tos
), vif
->link
);
1756 encap
= sizeof(struct iphdr
);
1758 rt
= ip_route_output_ports(net
, &fl4
, NULL
, iph
->daddr
, 0,
1761 RT_TOS(iph
->tos
), vif
->link
);
1768 if (skb
->len
+encap
> dst_mtu(&rt
->dst
) && (ntohs(iph
->frag_off
) & IP_DF
)) {
1769 /* Do not fragment multicasts. Alas, IPv4 does not
1770 * allow to send ICMP, so that packets will disappear
1773 IP_INC_STATS(net
, IPSTATS_MIB_FRAGFAILS
);
1778 encap
+= LL_RESERVED_SPACE(dev
) + rt
->dst
.header_len
;
1780 if (skb_cow(skb
, encap
)) {
1786 vif
->bytes_out
+= skb
->len
;
1789 skb_dst_set(skb
, &rt
->dst
);
1790 ip_decrease_ttl(ip_hdr(skb
));
1792 /* FIXME: forward and output firewalls used to be called here.
1793 * What do we do with netfilter? -- RR
1795 if (vif
->flags
& VIFF_TUNNEL
) {
1796 ip_encap(net
, skb
, vif
->local
, vif
->remote
);
1797 /* FIXME: extra output firewall step used to be here. --RR */
1798 vif
->dev
->stats
.tx_packets
++;
1799 vif
->dev
->stats
.tx_bytes
+= skb
->len
;
1802 IPCB(skb
)->flags
|= IPSKB_FORWARDED
;
1804 /* RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1805 * not only before forwarding, but after forwarding on all output
1806 * interfaces. It is clear, if mrouter runs a multicasting
1807 * program, it should receive packets not depending to what interface
1808 * program is joined.
1809 * If we will not make it, the program will have to join on all
1810 * interfaces. On the other hand, multihoming host (or router, but
1811 * not mrouter) cannot join to more than one interface - it will
1812 * result in receiving multiple packets.
1814 NF_HOOK(NFPROTO_IPV4
, NF_INET_FORWARD
,
1815 net
, NULL
, skb
, skb
->dev
, dev
,
1816 ipmr_forward_finish
);
1823 static int ipmr_find_vif(struct mr_table
*mrt
, struct net_device
*dev
)
1827 for (ct
= mrt
->maxvif
-1; ct
>= 0; ct
--) {
1828 if (mrt
->vif_table
[ct
].dev
== dev
)
1834 /* "local" means that we should preserve one skb (for local delivery) */
1835 static void ip_mr_forward(struct net
*net
, struct mr_table
*mrt
,
1836 struct sk_buff
*skb
, struct mfc_cache
*cache
,
1839 int true_vifi
= ipmr_find_vif(mrt
, skb
->dev
);
1843 vif
= cache
->mfc_parent
;
1844 cache
->mfc_un
.res
.pkt
++;
1845 cache
->mfc_un
.res
.bytes
+= skb
->len
;
1846 cache
->mfc_un
.res
.lastuse
= jiffies
;
1848 if (cache
->mfc_origin
== htonl(INADDR_ANY
) && true_vifi
>= 0) {
1849 struct mfc_cache
*cache_proxy
;
1851 /* For an (*,G) entry, we only check that the incomming
1852 * interface is part of the static tree.
1854 cache_proxy
= ipmr_cache_find_any_parent(mrt
, vif
);
1856 cache_proxy
->mfc_un
.res
.ttls
[true_vifi
] < 255)
1860 /* Wrong interface: drop packet and (maybe) send PIM assert. */
1861 if (mrt
->vif_table
[vif
].dev
!= skb
->dev
) {
1862 struct net_device
*mdev
;
1864 mdev
= l3mdev_master_dev_rcu(mrt
->vif_table
[vif
].dev
);
1865 if (mdev
== skb
->dev
)
1868 if (rt_is_output_route(skb_rtable(skb
))) {
1869 /* It is our own packet, looped back.
1870 * Very complicated situation...
1872 * The best workaround until routing daemons will be
1873 * fixed is not to redistribute packet, if it was
1874 * send through wrong interface. It means, that
1875 * multicast applications WILL NOT work for
1876 * (S,G), which have default multicast route pointing
1877 * to wrong oif. In any case, it is not a good
1878 * idea to use multicasting applications on router.
1883 cache
->mfc_un
.res
.wrong_if
++;
1885 if (true_vifi
>= 0 && mrt
->mroute_do_assert
&&
1886 /* pimsm uses asserts, when switching from RPT to SPT,
1887 * so that we cannot check that packet arrived on an oif.
1888 * It is bad, but otherwise we would need to move pretty
1889 * large chunk of pimd to kernel. Ough... --ANK
1891 (mrt
->mroute_do_pim
||
1892 cache
->mfc_un
.res
.ttls
[true_vifi
] < 255) &&
1894 cache
->mfc_un
.res
.last_assert
+ MFC_ASSERT_THRESH
)) {
1895 cache
->mfc_un
.res
.last_assert
= jiffies
;
1896 ipmr_cache_report(mrt
, skb
, true_vifi
, IGMPMSG_WRONGVIF
);
1902 mrt
->vif_table
[vif
].pkt_in
++;
1903 mrt
->vif_table
[vif
].bytes_in
+= skb
->len
;
1905 /* Forward the frame */
1906 if (cache
->mfc_origin
== htonl(INADDR_ANY
) &&
1907 cache
->mfc_mcastgrp
== htonl(INADDR_ANY
)) {
1908 if (true_vifi
>= 0 &&
1909 true_vifi
!= cache
->mfc_parent
&&
1911 cache
->mfc_un
.res
.ttls
[cache
->mfc_parent
]) {
1912 /* It's an (*,*) entry and the packet is not coming from
1913 * the upstream: forward the packet to the upstream
1916 psend
= cache
->mfc_parent
;
1921 for (ct
= cache
->mfc_un
.res
.maxvif
- 1;
1922 ct
>= cache
->mfc_un
.res
.minvif
; ct
--) {
1923 /* For (*,G) entry, don't forward to the incoming interface */
1924 if ((cache
->mfc_origin
!= htonl(INADDR_ANY
) ||
1926 ip_hdr(skb
)->ttl
> cache
->mfc_un
.res
.ttls
[ct
]) {
1928 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
1931 ipmr_queue_xmit(net
, mrt
, skb2
, cache
,
1940 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
1943 ipmr_queue_xmit(net
, mrt
, skb2
, cache
, psend
);
1945 ipmr_queue_xmit(net
, mrt
, skb
, cache
, psend
);
1955 static struct mr_table
*ipmr_rt_fib_lookup(struct net
*net
, struct sk_buff
*skb
)
1957 struct rtable
*rt
= skb_rtable(skb
);
1958 struct iphdr
*iph
= ip_hdr(skb
);
1959 struct flowi4 fl4
= {
1960 .daddr
= iph
->daddr
,
1961 .saddr
= iph
->saddr
,
1962 .flowi4_tos
= RT_TOS(iph
->tos
),
1963 .flowi4_oif
= (rt_is_output_route(rt
) ?
1964 skb
->dev
->ifindex
: 0),
1965 .flowi4_iif
= (rt_is_output_route(rt
) ?
1968 .flowi4_mark
= skb
->mark
,
1970 struct mr_table
*mrt
;
1973 err
= ipmr_fib_lookup(net
, &fl4
, &mrt
);
1975 return ERR_PTR(err
);
1979 /* Multicast packets for forwarding arrive here
1980 * Called with rcu_read_lock();
1982 int ip_mr_input(struct sk_buff
*skb
)
1984 struct mfc_cache
*cache
;
1985 struct net
*net
= dev_net(skb
->dev
);
1986 int local
= skb_rtable(skb
)->rt_flags
& RTCF_LOCAL
;
1987 struct mr_table
*mrt
;
1989 /* Packet is looped back after forward, it should not be
1990 * forwarded second time, but still can be delivered locally.
1992 if (IPCB(skb
)->flags
& IPSKB_FORWARDED
)
1995 mrt
= ipmr_rt_fib_lookup(net
, skb
);
1998 return PTR_ERR(mrt
);
2001 if (IPCB(skb
)->opt
.router_alert
) {
2002 if (ip_call_ra_chain(skb
))
2004 } else if (ip_hdr(skb
)->protocol
== IPPROTO_IGMP
) {
2005 /* IGMPv1 (and broken IGMPv2 implementations sort of
2006 * Cisco IOS <= 11.2(8)) do not put router alert
2007 * option to IGMP packets destined to routable
2008 * groups. It is very bad, because it means
2009 * that we can forward NO IGMP messages.
2011 struct sock
*mroute_sk
;
2013 mroute_sk
= rcu_dereference(mrt
->mroute_sk
);
2016 raw_rcv(mroute_sk
, skb
);
2022 /* already under rcu_read_lock() */
2023 cache
= ipmr_cache_find(mrt
, ip_hdr(skb
)->saddr
, ip_hdr(skb
)->daddr
);
2025 int vif
= ipmr_find_vif(mrt
, skb
->dev
);
2028 cache
= ipmr_cache_find_any(mrt
, ip_hdr(skb
)->daddr
,
2032 /* No usable cache entry */
2037 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
2038 ip_local_deliver(skb
);
2044 read_lock(&mrt_lock
);
2045 vif
= ipmr_find_vif(mrt
, skb
->dev
);
2047 int err2
= ipmr_cache_unresolved(mrt
, vif
, skb
);
2048 read_unlock(&mrt_lock
);
2052 read_unlock(&mrt_lock
);
2057 read_lock(&mrt_lock
);
2058 ip_mr_forward(net
, mrt
, skb
, cache
, local
);
2059 read_unlock(&mrt_lock
);
2062 return ip_local_deliver(skb
);
2068 return ip_local_deliver(skb
);
2073 #ifdef CONFIG_IP_PIMSM_V1
2074 /* Handle IGMP messages of PIMv1 */
2075 int pim_rcv_v1(struct sk_buff
*skb
)
2077 struct igmphdr
*pim
;
2078 struct net
*net
= dev_net(skb
->dev
);
2079 struct mr_table
*mrt
;
2081 if (!pskb_may_pull(skb
, sizeof(*pim
) + sizeof(struct iphdr
)))
2084 pim
= igmp_hdr(skb
);
2086 mrt
= ipmr_rt_fib_lookup(net
, skb
);
2089 if (!mrt
->mroute_do_pim
||
2090 pim
->group
!= PIM_V1_VERSION
|| pim
->code
!= PIM_V1_REGISTER
)
2093 if (__pim_rcv(mrt
, skb
, sizeof(*pim
))) {
2101 #ifdef CONFIG_IP_PIMSM_V2
2102 static int pim_rcv(struct sk_buff
*skb
)
2104 struct pimreghdr
*pim
;
2105 struct net
*net
= dev_net(skb
->dev
);
2106 struct mr_table
*mrt
;
2108 if (!pskb_may_pull(skb
, sizeof(*pim
) + sizeof(struct iphdr
)))
2111 pim
= (struct pimreghdr
*)skb_transport_header(skb
);
2112 if (pim
->type
!= ((PIM_VERSION
<< 4) | (PIM_TYPE_REGISTER
)) ||
2113 (pim
->flags
& PIM_NULL_REGISTER
) ||
2114 (ip_compute_csum((void *)pim
, sizeof(*pim
)) != 0 &&
2115 csum_fold(skb_checksum(skb
, 0, skb
->len
, 0))))
2118 mrt
= ipmr_rt_fib_lookup(net
, skb
);
2121 if (__pim_rcv(mrt
, skb
, sizeof(*pim
))) {
2129 static int __ipmr_fill_mroute(struct mr_table
*mrt
, struct sk_buff
*skb
,
2130 struct mfc_cache
*c
, struct rtmsg
*rtm
)
2132 struct rta_mfc_stats mfcs
;
2133 struct nlattr
*mp_attr
;
2134 struct rtnexthop
*nhp
;
2135 unsigned long lastuse
;
2138 /* If cache is unresolved, don't try to parse IIF and OIF */
2139 if (c
->mfc_parent
>= MAXVIFS
) {
2140 rtm
->rtm_flags
|= RTNH_F_UNRESOLVED
;
2144 if (VIF_EXISTS(mrt
, c
->mfc_parent
) &&
2145 nla_put_u32(skb
, RTA_IIF
, mrt
->vif_table
[c
->mfc_parent
].dev
->ifindex
) < 0)
2148 if (!(mp_attr
= nla_nest_start(skb
, RTA_MULTIPATH
)))
2151 for (ct
= c
->mfc_un
.res
.minvif
; ct
< c
->mfc_un
.res
.maxvif
; ct
++) {
2152 if (VIF_EXISTS(mrt
, ct
) && c
->mfc_un
.res
.ttls
[ct
] < 255) {
2153 if (!(nhp
= nla_reserve_nohdr(skb
, sizeof(*nhp
)))) {
2154 nla_nest_cancel(skb
, mp_attr
);
2158 nhp
->rtnh_flags
= 0;
2159 nhp
->rtnh_hops
= c
->mfc_un
.res
.ttls
[ct
];
2160 nhp
->rtnh_ifindex
= mrt
->vif_table
[ct
].dev
->ifindex
;
2161 nhp
->rtnh_len
= sizeof(*nhp
);
2165 nla_nest_end(skb
, mp_attr
);
2167 lastuse
= READ_ONCE(c
->mfc_un
.res
.lastuse
);
2168 lastuse
= time_after_eq(jiffies
, lastuse
) ? jiffies
- lastuse
: 0;
2170 mfcs
.mfcs_packets
= c
->mfc_un
.res
.pkt
;
2171 mfcs
.mfcs_bytes
= c
->mfc_un
.res
.bytes
;
2172 mfcs
.mfcs_wrong_if
= c
->mfc_un
.res
.wrong_if
;
2173 if (nla_put_64bit(skb
, RTA_MFC_STATS
, sizeof(mfcs
), &mfcs
, RTA_PAD
) ||
2174 nla_put_u64_64bit(skb
, RTA_EXPIRES
, jiffies_to_clock_t(lastuse
),
2178 rtm
->rtm_type
= RTN_MULTICAST
;
2182 int ipmr_get_route(struct net
*net
, struct sk_buff
*skb
,
2183 __be32 saddr
, __be32 daddr
,
2184 struct rtmsg
*rtm
, u32 portid
)
2186 struct mfc_cache
*cache
;
2187 struct mr_table
*mrt
;
2190 mrt
= ipmr_get_table(net
, RT_TABLE_DEFAULT
);
2195 cache
= ipmr_cache_find(mrt
, saddr
, daddr
);
2196 if (!cache
&& skb
->dev
) {
2197 int vif
= ipmr_find_vif(mrt
, skb
->dev
);
2200 cache
= ipmr_cache_find_any(mrt
, daddr
, vif
);
2203 struct sk_buff
*skb2
;
2205 struct net_device
*dev
;
2209 read_lock(&mrt_lock
);
2211 vif
= ipmr_find_vif(mrt
, dev
);
2213 read_unlock(&mrt_lock
);
2217 skb2
= skb_clone(skb
, GFP_ATOMIC
);
2219 read_unlock(&mrt_lock
);
2224 NETLINK_CB(skb2
).portid
= portid
;
2225 skb_push(skb2
, sizeof(struct iphdr
));
2226 skb_reset_network_header(skb2
);
2228 iph
->ihl
= sizeof(struct iphdr
) >> 2;
2232 err
= ipmr_cache_unresolved(mrt
, vif
, skb2
);
2233 read_unlock(&mrt_lock
);
2238 read_lock(&mrt_lock
);
2239 err
= __ipmr_fill_mroute(mrt
, skb
, cache
, rtm
);
2240 read_unlock(&mrt_lock
);
2245 static int ipmr_fill_mroute(struct mr_table
*mrt
, struct sk_buff
*skb
,
2246 u32 portid
, u32 seq
, struct mfc_cache
*c
, int cmd
,
2249 struct nlmsghdr
*nlh
;
2253 nlh
= nlmsg_put(skb
, portid
, seq
, cmd
, sizeof(*rtm
), flags
);
2257 rtm
= nlmsg_data(nlh
);
2258 rtm
->rtm_family
= RTNL_FAMILY_IPMR
;
2259 rtm
->rtm_dst_len
= 32;
2260 rtm
->rtm_src_len
= 32;
2262 rtm
->rtm_table
= mrt
->id
;
2263 if (nla_put_u32(skb
, RTA_TABLE
, mrt
->id
))
2264 goto nla_put_failure
;
2265 rtm
->rtm_type
= RTN_MULTICAST
;
2266 rtm
->rtm_scope
= RT_SCOPE_UNIVERSE
;
2267 if (c
->mfc_flags
& MFC_STATIC
)
2268 rtm
->rtm_protocol
= RTPROT_STATIC
;
2270 rtm
->rtm_protocol
= RTPROT_MROUTED
;
2273 if (nla_put_in_addr(skb
, RTA_SRC
, c
->mfc_origin
) ||
2274 nla_put_in_addr(skb
, RTA_DST
, c
->mfc_mcastgrp
))
2275 goto nla_put_failure
;
2276 err
= __ipmr_fill_mroute(mrt
, skb
, c
, rtm
);
2277 /* do not break the dump if cache is unresolved */
2278 if (err
< 0 && err
!= -ENOENT
)
2279 goto nla_put_failure
;
2281 nlmsg_end(skb
, nlh
);
2285 nlmsg_cancel(skb
, nlh
);
2289 static size_t mroute_msgsize(bool unresolved
, int maxvif
)
2292 NLMSG_ALIGN(sizeof(struct rtmsg
))
2293 + nla_total_size(4) /* RTA_TABLE */
2294 + nla_total_size(4) /* RTA_SRC */
2295 + nla_total_size(4) /* RTA_DST */
2300 + nla_total_size(4) /* RTA_IIF */
2301 + nla_total_size(0) /* RTA_MULTIPATH */
2302 + maxvif
* NLA_ALIGN(sizeof(struct rtnexthop
))
2304 + nla_total_size_64bit(sizeof(struct rta_mfc_stats
))
2310 static void mroute_netlink_event(struct mr_table
*mrt
, struct mfc_cache
*mfc
,
2313 struct net
*net
= read_pnet(&mrt
->net
);
2314 struct sk_buff
*skb
;
2317 skb
= nlmsg_new(mroute_msgsize(mfc
->mfc_parent
>= MAXVIFS
, mrt
->maxvif
),
2322 err
= ipmr_fill_mroute(mrt
, skb
, 0, 0, mfc
, cmd
, 0);
2326 rtnl_notify(skb
, net
, 0, RTNLGRP_IPV4_MROUTE
, NULL
, GFP_ATOMIC
);
2332 rtnl_set_sk_err(net
, RTNLGRP_IPV4_MROUTE
, err
);
2335 static int ipmr_rtm_dumproute(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2337 struct net
*net
= sock_net(skb
->sk
);
2338 struct mr_table
*mrt
;
2339 struct mfc_cache
*mfc
;
2340 unsigned int t
= 0, s_t
;
2341 unsigned int e
= 0, s_e
;
2347 ipmr_for_each_table(mrt
, net
) {
2350 list_for_each_entry_rcu(mfc
, &mrt
->mfc_cache_list
, list
) {
2353 if (ipmr_fill_mroute(mrt
, skb
,
2354 NETLINK_CB(cb
->skb
).portid
,
2365 spin_lock_bh(&mfc_unres_lock
);
2366 list_for_each_entry(mfc
, &mrt
->mfc_unres_queue
, list
) {
2369 if (ipmr_fill_mroute(mrt
, skb
,
2370 NETLINK_CB(cb
->skb
).portid
,
2374 spin_unlock_bh(&mfc_unres_lock
);
2380 spin_unlock_bh(&mfc_unres_lock
);
2395 static const struct nla_policy rtm_ipmr_policy
[RTA_MAX
+ 1] = {
2396 [RTA_SRC
] = { .type
= NLA_U32
},
2397 [RTA_DST
] = { .type
= NLA_U32
},
2398 [RTA_IIF
] = { .type
= NLA_U32
},
2399 [RTA_TABLE
] = { .type
= NLA_U32
},
2400 [RTA_MULTIPATH
] = { .len
= sizeof(struct rtnexthop
) },
2403 static bool ipmr_rtm_validate_proto(unsigned char rtm_protocol
)
2405 switch (rtm_protocol
) {
2407 case RTPROT_MROUTED
:
2413 static int ipmr_nla_get_ttls(const struct nlattr
*nla
, struct mfcctl
*mfcc
)
2415 struct rtnexthop
*rtnh
= nla_data(nla
);
2416 int remaining
= nla_len(nla
), vifi
= 0;
2418 while (rtnh_ok(rtnh
, remaining
)) {
2419 mfcc
->mfcc_ttls
[vifi
] = rtnh
->rtnh_hops
;
2420 if (++vifi
== MAXVIFS
)
2422 rtnh
= rtnh_next(rtnh
, &remaining
);
2425 return remaining
> 0 ? -EINVAL
: vifi
;
2428 /* returns < 0 on error, 0 for ADD_MFC and 1 for ADD_MFC_PROXY */
2429 static int rtm_to_ipmr_mfcc(struct net
*net
, struct nlmsghdr
*nlh
,
2430 struct mfcctl
*mfcc
, int *mrtsock
,
2431 struct mr_table
**mrtret
)
2433 struct net_device
*dev
= NULL
;
2434 u32 tblid
= RT_TABLE_DEFAULT
;
2435 struct mr_table
*mrt
;
2436 struct nlattr
*attr
;
2440 ret
= nlmsg_validate(nlh
, sizeof(*rtm
), RTA_MAX
, rtm_ipmr_policy
);
2443 rtm
= nlmsg_data(nlh
);
2446 if (rtm
->rtm_family
!= RTNL_FAMILY_IPMR
|| rtm
->rtm_dst_len
!= 32 ||
2447 rtm
->rtm_type
!= RTN_MULTICAST
||
2448 rtm
->rtm_scope
!= RT_SCOPE_UNIVERSE
||
2449 !ipmr_rtm_validate_proto(rtm
->rtm_protocol
))
2452 memset(mfcc
, 0, sizeof(*mfcc
));
2453 mfcc
->mfcc_parent
= -1;
2455 nlmsg_for_each_attr(attr
, nlh
, sizeof(struct rtmsg
), rem
) {
2456 switch (nla_type(attr
)) {
2458 mfcc
->mfcc_origin
.s_addr
= nla_get_be32(attr
);
2461 mfcc
->mfcc_mcastgrp
.s_addr
= nla_get_be32(attr
);
2464 dev
= __dev_get_by_index(net
, nla_get_u32(attr
));
2471 if (ipmr_nla_get_ttls(attr
, mfcc
) < 0) {
2480 tblid
= nla_get_u32(attr
);
2484 mrt
= ipmr_get_table(net
, tblid
);
2490 *mrtsock
= rtm
->rtm_protocol
== RTPROT_MROUTED
? 1 : 0;
2492 mfcc
->mfcc_parent
= ipmr_find_vif(mrt
, dev
);
2498 /* takes care of both newroute and delroute */
2499 static int ipmr_rtm_route(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
2501 struct net
*net
= sock_net(skb
->sk
);
2502 int ret
, mrtsock
, parent
;
2503 struct mr_table
*tbl
;
2508 ret
= rtm_to_ipmr_mfcc(net
, nlh
, &mfcc
, &mrtsock
, &tbl
);
2512 parent
= ret
? mfcc
.mfcc_parent
: -1;
2513 if (nlh
->nlmsg_type
== RTM_NEWROUTE
)
2514 return ipmr_mfc_add(net
, tbl
, &mfcc
, mrtsock
, parent
);
2516 return ipmr_mfc_delete(tbl
, &mfcc
, parent
);
2519 #ifdef CONFIG_PROC_FS
2520 /* The /proc interfaces to multicast routing :
2521 * /proc/net/ip_mr_cache & /proc/net/ip_mr_vif
2523 struct ipmr_vif_iter
{
2524 struct seq_net_private p
;
2525 struct mr_table
*mrt
;
2529 static struct vif_device
*ipmr_vif_seq_idx(struct net
*net
,
2530 struct ipmr_vif_iter
*iter
,
2533 struct mr_table
*mrt
= iter
->mrt
;
2535 for (iter
->ct
= 0; iter
->ct
< mrt
->maxvif
; ++iter
->ct
) {
2536 if (!VIF_EXISTS(mrt
, iter
->ct
))
2539 return &mrt
->vif_table
[iter
->ct
];
2544 static void *ipmr_vif_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2545 __acquires(mrt_lock
)
2547 struct ipmr_vif_iter
*iter
= seq
->private;
2548 struct net
*net
= seq_file_net(seq
);
2549 struct mr_table
*mrt
;
2551 mrt
= ipmr_get_table(net
, RT_TABLE_DEFAULT
);
2553 return ERR_PTR(-ENOENT
);
2557 read_lock(&mrt_lock
);
2558 return *pos
? ipmr_vif_seq_idx(net
, seq
->private, *pos
- 1)
2562 static void *ipmr_vif_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2564 struct ipmr_vif_iter
*iter
= seq
->private;
2565 struct net
*net
= seq_file_net(seq
);
2566 struct mr_table
*mrt
= iter
->mrt
;
2569 if (v
== SEQ_START_TOKEN
)
2570 return ipmr_vif_seq_idx(net
, iter
, 0);
2572 while (++iter
->ct
< mrt
->maxvif
) {
2573 if (!VIF_EXISTS(mrt
, iter
->ct
))
2575 return &mrt
->vif_table
[iter
->ct
];
2580 static void ipmr_vif_seq_stop(struct seq_file
*seq
, void *v
)
2581 __releases(mrt_lock
)
2583 read_unlock(&mrt_lock
);
2586 static int ipmr_vif_seq_show(struct seq_file
*seq
, void *v
)
2588 struct ipmr_vif_iter
*iter
= seq
->private;
2589 struct mr_table
*mrt
= iter
->mrt
;
2591 if (v
== SEQ_START_TOKEN
) {
2593 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
2595 const struct vif_device
*vif
= v
;
2596 const char *name
= vif
->dev
? vif
->dev
->name
: "none";
2599 "%2zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
2600 vif
- mrt
->vif_table
,
2601 name
, vif
->bytes_in
, vif
->pkt_in
,
2602 vif
->bytes_out
, vif
->pkt_out
,
2603 vif
->flags
, vif
->local
, vif
->remote
);
2608 static const struct seq_operations ipmr_vif_seq_ops
= {
2609 .start
= ipmr_vif_seq_start
,
2610 .next
= ipmr_vif_seq_next
,
2611 .stop
= ipmr_vif_seq_stop
,
2612 .show
= ipmr_vif_seq_show
,
2615 static int ipmr_vif_open(struct inode
*inode
, struct file
*file
)
2617 return seq_open_net(inode
, file
, &ipmr_vif_seq_ops
,
2618 sizeof(struct ipmr_vif_iter
));
2621 static const struct file_operations ipmr_vif_fops
= {
2622 .owner
= THIS_MODULE
,
2623 .open
= ipmr_vif_open
,
2625 .llseek
= seq_lseek
,
2626 .release
= seq_release_net
,
2629 struct ipmr_mfc_iter
{
2630 struct seq_net_private p
;
2631 struct mr_table
*mrt
;
2632 struct list_head
*cache
;
2635 static struct mfc_cache
*ipmr_mfc_seq_idx(struct net
*net
,
2636 struct ipmr_mfc_iter
*it
, loff_t pos
)
2638 struct mr_table
*mrt
= it
->mrt
;
2639 struct mfc_cache
*mfc
;
2642 it
->cache
= &mrt
->mfc_cache_list
;
2643 list_for_each_entry_rcu(mfc
, &mrt
->mfc_cache_list
, list
)
2648 spin_lock_bh(&mfc_unres_lock
);
2649 it
->cache
= &mrt
->mfc_unres_queue
;
2650 list_for_each_entry(mfc
, it
->cache
, list
)
2653 spin_unlock_bh(&mfc_unres_lock
);
2660 static void *ipmr_mfc_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2662 struct ipmr_mfc_iter
*it
= seq
->private;
2663 struct net
*net
= seq_file_net(seq
);
2664 struct mr_table
*mrt
;
2666 mrt
= ipmr_get_table(net
, RT_TABLE_DEFAULT
);
2668 return ERR_PTR(-ENOENT
);
2672 return *pos
? ipmr_mfc_seq_idx(net
, seq
->private, *pos
- 1)
2676 static void *ipmr_mfc_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2678 struct ipmr_mfc_iter
*it
= seq
->private;
2679 struct net
*net
= seq_file_net(seq
);
2680 struct mr_table
*mrt
= it
->mrt
;
2681 struct mfc_cache
*mfc
= v
;
2685 if (v
== SEQ_START_TOKEN
)
2686 return ipmr_mfc_seq_idx(net
, seq
->private, 0);
2688 if (mfc
->list
.next
!= it
->cache
)
2689 return list_entry(mfc
->list
.next
, struct mfc_cache
, list
);
2691 if (it
->cache
== &mrt
->mfc_unres_queue
)
2694 /* exhausted cache_array, show unresolved */
2696 it
->cache
= &mrt
->mfc_unres_queue
;
2698 spin_lock_bh(&mfc_unres_lock
);
2699 if (!list_empty(it
->cache
))
2700 return list_first_entry(it
->cache
, struct mfc_cache
, list
);
2703 spin_unlock_bh(&mfc_unres_lock
);
2709 static void ipmr_mfc_seq_stop(struct seq_file
*seq
, void *v
)
2711 struct ipmr_mfc_iter
*it
= seq
->private;
2712 struct mr_table
*mrt
= it
->mrt
;
2714 if (it
->cache
== &mrt
->mfc_unres_queue
)
2715 spin_unlock_bh(&mfc_unres_lock
);
2716 else if (it
->cache
== &mrt
->mfc_cache_list
)
2720 static int ipmr_mfc_seq_show(struct seq_file
*seq
, void *v
)
2724 if (v
== SEQ_START_TOKEN
) {
2726 "Group Origin Iif Pkts Bytes Wrong Oifs\n");
2728 const struct mfc_cache
*mfc
= v
;
2729 const struct ipmr_mfc_iter
*it
= seq
->private;
2730 const struct mr_table
*mrt
= it
->mrt
;
2732 seq_printf(seq
, "%08X %08X %-3hd",
2733 (__force u32
) mfc
->mfc_mcastgrp
,
2734 (__force u32
) mfc
->mfc_origin
,
2737 if (it
->cache
!= &mrt
->mfc_unres_queue
) {
2738 seq_printf(seq
, " %8lu %8lu %8lu",
2739 mfc
->mfc_un
.res
.pkt
,
2740 mfc
->mfc_un
.res
.bytes
,
2741 mfc
->mfc_un
.res
.wrong_if
);
2742 for (n
= mfc
->mfc_un
.res
.minvif
;
2743 n
< mfc
->mfc_un
.res
.maxvif
; n
++) {
2744 if (VIF_EXISTS(mrt
, n
) &&
2745 mfc
->mfc_un
.res
.ttls
[n
] < 255)
2748 n
, mfc
->mfc_un
.res
.ttls
[n
]);
2751 /* unresolved mfc_caches don't contain
2752 * pkt, bytes and wrong_if values
2754 seq_printf(seq
, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
2756 seq_putc(seq
, '\n');
2761 static const struct seq_operations ipmr_mfc_seq_ops
= {
2762 .start
= ipmr_mfc_seq_start
,
2763 .next
= ipmr_mfc_seq_next
,
2764 .stop
= ipmr_mfc_seq_stop
,
2765 .show
= ipmr_mfc_seq_show
,
2768 static int ipmr_mfc_open(struct inode
*inode
, struct file
*file
)
2770 return seq_open_net(inode
, file
, &ipmr_mfc_seq_ops
,
2771 sizeof(struct ipmr_mfc_iter
));
2774 static const struct file_operations ipmr_mfc_fops
= {
2775 .owner
= THIS_MODULE
,
2776 .open
= ipmr_mfc_open
,
2778 .llseek
= seq_lseek
,
2779 .release
= seq_release_net
,
2783 #ifdef CONFIG_IP_PIMSM_V2
2784 static const struct net_protocol pim_protocol
= {
2790 /* Setup for IP multicast routing */
2791 static int __net_init
ipmr_net_init(struct net
*net
)
2795 err
= ipmr_rules_init(net
);
2799 #ifdef CONFIG_PROC_FS
2801 if (!proc_create("ip_mr_vif", 0, net
->proc_net
, &ipmr_vif_fops
))
2803 if (!proc_create("ip_mr_cache", 0, net
->proc_net
, &ipmr_mfc_fops
))
2804 goto proc_cache_fail
;
2808 #ifdef CONFIG_PROC_FS
2810 remove_proc_entry("ip_mr_vif", net
->proc_net
);
2812 ipmr_rules_exit(net
);
2818 static void __net_exit
ipmr_net_exit(struct net
*net
)
2820 #ifdef CONFIG_PROC_FS
2821 remove_proc_entry("ip_mr_cache", net
->proc_net
);
2822 remove_proc_entry("ip_mr_vif", net
->proc_net
);
2824 ipmr_rules_exit(net
);
2827 static struct pernet_operations ipmr_net_ops
= {
2828 .init
= ipmr_net_init
,
2829 .exit
= ipmr_net_exit
,
2832 int __init
ip_mr_init(void)
2836 mrt_cachep
= kmem_cache_create("ip_mrt_cache",
2837 sizeof(struct mfc_cache
),
2838 0, SLAB_HWCACHE_ALIGN
| SLAB_PANIC
,
2841 err
= register_pernet_subsys(&ipmr_net_ops
);
2843 goto reg_pernet_fail
;
2845 err
= register_netdevice_notifier(&ip_mr_notifier
);
2847 goto reg_notif_fail
;
2848 #ifdef CONFIG_IP_PIMSM_V2
2849 if (inet_add_protocol(&pim_protocol
, IPPROTO_PIM
) < 0) {
2850 pr_err("%s: can't add PIM protocol\n", __func__
);
2852 goto add_proto_fail
;
2855 rtnl_register(RTNL_FAMILY_IPMR
, RTM_GETROUTE
,
2856 NULL
, ipmr_rtm_dumproute
, NULL
);
2857 rtnl_register(RTNL_FAMILY_IPMR
, RTM_NEWROUTE
,
2858 ipmr_rtm_route
, NULL
, NULL
);
2859 rtnl_register(RTNL_FAMILY_IPMR
, RTM_DELROUTE
,
2860 ipmr_rtm_route
, NULL
, NULL
);
2863 #ifdef CONFIG_IP_PIMSM_V2
2865 unregister_netdevice_notifier(&ip_mr_notifier
);
2868 unregister_pernet_subsys(&ipmr_net_ops
);
2870 kmem_cache_destroy(mrt_cachep
);