#include <sys/cdefs.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/protosw.h>
#include <sys/kernel.h>
#include <sys/sysctl.h>
#include <sys/mcache.h>
#include <libkern/libkern.h>
#include <kern/zalloc.h>
#include <net/if.h>
#include <net/route.h>
#include <netinet/in.h>
#include <netinet/in_var.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_var.h>
#include <netinet/igmp.h>
#include <netinet/igmp_var.h>
#include <netinet/kpi_ipfilter_var.h>
#ifdef IGMP_DEBUG
__inline__ char *
inet_ntoa(struct in_addr ina)
{
static char buf[4*sizeof "123"];
unsigned char *ucp = (unsigned char *)&ina;
snprintf(buf, sizeof(buf), "%d.%d.%d.%d",
ucp[0] & 0xff,
ucp[1] & 0xff,
ucp[2] & 0xff,
ucp[3] & 0xff);
return buf;
}
#endif
static void igi_initvar(struct igmp_ifinfo *, struct ifnet *, int);
static struct igmp_ifinfo *igi_alloc(int);
static void igi_free(struct igmp_ifinfo *);
static void igi_delete(const struct ifnet *);
static void igmp_dispatch_queue(struct igmp_ifinfo *, struct ifqueue *,
int, const int, struct ifnet *);
static void igmp_final_leave(struct in_multi *, struct igmp_ifinfo *);
static int igmp_handle_state_change(struct in_multi *,
struct igmp_ifinfo *);
static int igmp_initial_join(struct in_multi *, struct igmp_ifinfo *);
static int igmp_input_v1_query(struct ifnet *, const struct ip *,
const struct igmp *);
static int igmp_input_v2_query(struct ifnet *, const struct ip *,
const struct igmp *);
static int igmp_input_v3_query(struct ifnet *, const struct ip *,
struct igmpv3 *);
static int igmp_input_v3_group_query(struct in_multi *,
int, struct igmpv3 *);
static int igmp_input_v1_report(struct ifnet *, struct ip *,
struct igmp *);
static int igmp_input_v2_report(struct ifnet *, struct ip *,
struct igmp *);
void igmp_sendpkt(struct mbuf *, struct ifnet *);
static __inline__ int igmp_isgroupreported(const struct in_addr);
static struct mbuf *
igmp_ra_alloc(void);
#ifdef IGMP_DEBUG
static const char * igmp_rec_type_to_str(const int);
#endif
static void igmp_set_version(struct igmp_ifinfo *, const int);
static void igmp_flush_relq(struct igmp_ifinfo *);
static int igmp_v1v2_queue_report(struct in_multi *, const int);
static void igmp_v1v2_process_group_timer(struct in_multi *, const int);
static void igmp_v1v2_process_querier_timers(struct igmp_ifinfo *);
static void igmp_v2_update_group(struct in_multi *, const int);
static void igmp_v3_cancel_link_timers(struct igmp_ifinfo *);
static void igmp_v3_dispatch_general_query(struct igmp_ifinfo *);
static struct mbuf *
igmp_v3_encap_report(struct ifnet *, struct mbuf *);
static int igmp_v3_enqueue_group_record(struct ifqueue *,
struct in_multi *, const int, const int, const int);
static int igmp_v3_enqueue_filter_change(struct ifqueue *,
struct in_multi *);
static void igmp_v3_process_group_timers(struct igmp_ifinfo *,
struct ifqueue *, struct ifqueue *, struct in_multi *,
const int);
static int igmp_v3_merge_state_changes(struct in_multi *,
struct ifqueue *);
static void igmp_v3_suppress_group_record(struct in_multi *);
static int sysctl_igmp_ifinfo SYSCTL_HANDLER_ARGS;
static int sysctl_igmp_gsr SYSCTL_HANDLER_ARGS;
static int sysctl_igmp_default_version SYSCTL_HANDLER_ARGS;
struct mbuf *m_raopt;
static int interface_timers_running;
static int state_change_timers_running;
static int current_state_timers_running;
static LIST_HEAD(, igmp_ifinfo) igi_head;
static struct igmpstat_v3 igmpstat_v3 = {
.igps_version = IGPS_VERSION_3,
.igps_len = sizeof(struct igmpstat_v3),
};
static struct igmpstat igmpstat;
static struct timeval igmp_gsrdelay = {10, 0};
static int igmp_recvifkludge = 1;
static int igmp_sendra = 1;
static int igmp_sendlocal = 1;
static int igmp_v1enable = 1;
static int igmp_v2enable = 1;
static int igmp_legacysupp = 0;
static int igmp_default_version = IGMP_VERSION_3;
SYSCTL_STRUCT(_net_inet_igmp, IGMPCTL_STATS, stats, CTLFLAG_RD | CTLFLAG_LOCKED,
&igmpstat, igmpstat, "");
SYSCTL_STRUCT(_net_inet_igmp, OID_AUTO, v3stats,
CTLFLAG_RD | CTLFLAG_LOCKED, &igmpstat_v3, igmpstat_v3, "");
SYSCTL_INT(_net_inet_igmp, OID_AUTO, recvifkludge, CTLFLAG_RW | CTLFLAG_LOCKED,
&igmp_recvifkludge, 0,
"Rewrite IGMPv1/v2 reports from 0.0.0.0 to contain subnet address");
SYSCTL_INT(_net_inet_igmp, OID_AUTO, sendra, CTLFLAG_RW | CTLFLAG_LOCKED,
&igmp_sendra, 0,
"Send IP Router Alert option in IGMPv2/v3 messages");
SYSCTL_INT(_net_inet_igmp, OID_AUTO, sendlocal, CTLFLAG_RW | CTLFLAG_LOCKED,
&igmp_sendlocal, 0,
"Send IGMP membership reports for 224.0.0.0/24 groups");
SYSCTL_INT(_net_inet_igmp, OID_AUTO, v1enable, CTLFLAG_RW | CTLFLAG_LOCKED,
&igmp_v1enable, 0,
"Enable backwards compatibility with IGMPv1");
SYSCTL_INT(_net_inet_igmp, OID_AUTO, v2enable, CTLFLAG_RW | CTLFLAG_LOCKED,
&igmp_v2enable, 0,
"Enable backwards compatibility with IGMPv2");
SYSCTL_INT(_net_inet_igmp, OID_AUTO, legacysupp, CTLFLAG_RW | CTLFLAG_LOCKED,
&igmp_legacysupp, 0,
"Allow v1/v2 reports to suppress v3 group responses");
SYSCTL_PROC(_net_inet_igmp, OID_AUTO, default_version,
CTLTYPE_INT | CTLFLAG_RW,
&igmp_default_version, 0, sysctl_igmp_default_version, "I",
"Default version of IGMP to run on each interface");
SYSCTL_PROC(_net_inet_igmp, OID_AUTO, gsrdelay,
CTLTYPE_INT | CTLFLAG_RW,
&igmp_gsrdelay.tv_sec, 0, sysctl_igmp_gsr, "I",
"Rate limit for IGMPv3 Group-and-Source queries in seconds");
#ifdef IGMP_DEBUG
int igmp_debug = 0;
SYSCTL_INT(_net_inet_igmp, OID_AUTO,
debug, CTLFLAG_RW | CTLFLAG_LOCKED, &igmp_debug, 0, "");
#endif
SYSCTL_NODE(_net_inet_igmp, OID_AUTO, ifinfo, CTLFLAG_RD | CTLFLAG_LOCKED,
sysctl_igmp_ifinfo, "Per-interface IGMPv3 state");
static lck_attr_t *igmp_mtx_attr;
static lck_grp_t *igmp_mtx_grp;
static lck_grp_attr_t *igmp_mtx_grp_attr;
static decl_lck_mtx_data(, igmp_mtx);
static int igmp_timers_are_running;
#define IGI_ZONE_MAX 64
#define IGI_ZONE_NAME "igmp_ifinfo"
static unsigned int igi_size;
static struct zone *igi_zone;
#ifdef IGMP_DEBUG
static __inline char *
inet_ntoa_haddr(in_addr_t haddr)
{
struct in_addr ia;
ia.s_addr = htonl(haddr);
return (inet_ntoa(ia));
}
#endif
static int
sysctl_igmp_default_version SYSCTL_HANDLER_ARGS
{
#pragma unused(oidp, arg2)
int error;
int new;
lck_mtx_lock(&igmp_mtx);
error = SYSCTL_OUT(req, arg1, sizeof(int));
if (error || !req->newptr)
goto out_locked;
new = igmp_default_version;
error = SYSCTL_IN(req, &new, sizeof(int));
if (error)
goto out_locked;
if (new < IGMP_VERSION_1 || new > IGMP_VERSION_3) {
error = EINVAL;
goto out_locked;
}
IGMP_PRINTF(("change igmp_default_version from %d to %d\n",
igmp_default_version, new));
igmp_default_version = new;
out_locked:
lck_mtx_unlock(&igmp_mtx);
return (error);
}
static int
sysctl_igmp_gsr SYSCTL_HANDLER_ARGS
{
#pragma unused(arg1, arg2)
int error;
int i;
lck_mtx_lock(&igmp_mtx);
i = igmp_gsrdelay.tv_sec;
error = sysctl_handle_int(oidp, &i, 0, req);
if (error || !req->newptr)
goto out_locked;
if (i < -1 || i >= 60) {
error = EINVAL;
goto out_locked;
}
igmp_gsrdelay.tv_sec = i;
out_locked:
lck_mtx_unlock(&igmp_mtx);
return (error);
}
static int
sysctl_igmp_ifinfo SYSCTL_HANDLER_ARGS
{
#pragma unused(oidp)
int *name;
int error;
u_int namelen;
struct ifnet *ifp;
struct igmp_ifinfo *igi;
struct igmp_ifinfo_u igi_u;
name = (int *)arg1;
namelen = arg2;
if (req->newptr != USER_ADDR_NULL)
return (EPERM);
if (namelen != 1)
return (EINVAL);
lck_mtx_lock(&igmp_mtx);
if (name[0] <= 0 || name[0] > (u_int)if_index) {
error = ENOENT;
goto out_locked;
}
error = ENOENT;
ifnet_head_lock_shared();
ifp = ifindex2ifnet[name[0]];
ifnet_head_done();
if (ifp == NULL)
goto out_locked;
bzero(&igi_u, sizeof (igi_u));
LIST_FOREACH(igi, &igi_head, igi_link) {
IGI_LOCK(igi);
if (ifp != igi->igi_ifp) {
IGI_UNLOCK(igi);
continue;
}
igi_u.igi_ifindex = igi->igi_ifp->if_index;
igi_u.igi_version = igi->igi_version;
igi_u.igi_v1_timer = igi->igi_v1_timer;
igi_u.igi_v2_timer = igi->igi_v2_timer;
igi_u.igi_v3_timer = igi->igi_v3_timer;
igi_u.igi_flags = igi->igi_flags;
igi_u.igi_rv = igi->igi_rv;
igi_u.igi_qi = igi->igi_qi;
igi_u.igi_qri = igi->igi_qri;
igi_u.igi_uri = igi->igi_uri;
IGI_UNLOCK(igi);
error = SYSCTL_OUT(req, &igi_u, sizeof (igi_u));
break;
}
out_locked:
lck_mtx_unlock(&igmp_mtx);
return (error);
}
static void
igmp_dispatch_queue(struct igmp_ifinfo *igi, struct ifqueue *ifq, int limit,
const int loop, struct ifnet *ifp)
{
struct mbuf *m;
struct ip *ip;
if (igi != NULL)
IGI_LOCK_ASSERT_HELD(igi);
for (;;) {
IF_DEQUEUE(ifq, m);
if (m == NULL)
break;
IGMP_PRINTF(("%s: dispatch %p from %p\n", __func__, ifq, m));
ip = mtod(m, struct ip *);
if (loop)
m->m_flags |= M_IGMP_LOOP;
if (igi != NULL)
IGI_UNLOCK(igi);
igmp_sendpkt(m, ifp);
if (igi != NULL)
IGI_LOCK(igi);
if (--limit == 0)
break;
}
if (igi != NULL)
IGI_LOCK_ASSERT_HELD(igi);
}
static __inline__
int igmp_isgroupreported(const struct in_addr addr)
{
if (in_allhosts(addr) ||
((!igmp_sendlocal && IN_LOCAL_GROUP(ntohl(addr.s_addr)))))
return (0);
return (1);
}
static struct mbuf *
igmp_ra_alloc(void)
{
struct mbuf *m;
struct ipoption *p;
MGET(m, M_WAITOK, MT_DATA);
p = mtod(m, struct ipoption *);
p->ipopt_dst.s_addr = INADDR_ANY;
p->ipopt_list[0] = IPOPT_RA;
p->ipopt_list[1] = 0x04;
p->ipopt_list[2] = IPOPT_EOL;
p->ipopt_list[3] = 0x00;
m->m_len = sizeof(p->ipopt_dst) + p->ipopt_list[1];
return (m);
}
struct igmp_ifinfo *
igmp_domifattach(struct ifnet *ifp, int how)
{
struct igmp_ifinfo *igi;
IGMP_PRINTF(("%s: called for ifp %p(%s)\n",
__func__, ifp, ifp->if_name));
igi = igi_alloc(how);
if (igi == NULL)
return (NULL);
lck_mtx_lock(&igmp_mtx);
IGI_LOCK(igi);
igi_initvar(igi, ifp, 0);
igi->igi_debug |= IFD_ATTACHED;
IGI_ADDREF_LOCKED(igi);
IGI_ADDREF_LOCKED(igi);
IGI_UNLOCK(igi);
LIST_INSERT_HEAD(&igi_head, igi, igi_link);
lck_mtx_unlock(&igmp_mtx);
IGMP_PRINTF(("allocate igmp_ifinfo for ifp %p(%s)\n",
ifp, ifp->if_name));
return (igi);
}
void
igmp_domifreattach(struct igmp_ifinfo *igi)
{
struct ifnet *ifp;
lck_mtx_lock(&igmp_mtx);
IGI_LOCK(igi);
VERIFY(!(igi->igi_debug & IFD_ATTACHED));
ifp = igi->igi_ifp;
VERIFY(ifp != NULL);
igi_initvar(igi, ifp, 1);
igi->igi_debug |= IFD_ATTACHED;
IGI_ADDREF_LOCKED(igi);
IGI_UNLOCK(igi);
LIST_INSERT_HEAD(&igi_head, igi, igi_link);
lck_mtx_unlock(&igmp_mtx);
IGMP_PRINTF(("reattached igmp_ifinfo for ifp %p(%s)\n",
ifp, ifp->if_name));
}
void
igmp_domifdetach(struct ifnet *ifp)
{
IGMP_PRINTF(("%s: called for ifp %p(%s%d)\n",
__func__, ifp, ifp->if_name, ifp->if_unit));
lck_mtx_lock(&igmp_mtx);
igi_delete(ifp);
lck_mtx_unlock(&igmp_mtx);
}
static void
igi_delete(const struct ifnet *ifp)
{
struct igmp_ifinfo *igi, *tigi;
lck_mtx_assert(&igmp_mtx, LCK_MTX_ASSERT_OWNED);
LIST_FOREACH_SAFE(igi, &igi_head, igi_link, tigi) {
IGI_LOCK(igi);
if (igi->igi_ifp == ifp) {
IF_DRAIN(&igi->igi_gq);
IF_DRAIN(&igi->igi_v2q);
igmp_flush_relq(igi);
VERIFY(SLIST_EMPTY(&igi->igi_relinmhead));
igi->igi_debug &= ~IFD_ATTACHED;
IGI_UNLOCK(igi);
LIST_REMOVE(igi, igi_link);
IGI_REMREF(igi);
return;
}
IGI_UNLOCK(igi);
}
panic("%s: igmp_ifinfo not found for ifp %p\n", __func__, ifp);
}
static void
igi_initvar(struct igmp_ifinfo *igi, struct ifnet *ifp, int reattach)
{
IGI_LOCK_ASSERT_HELD(igi);
igi->igi_ifp = ifp;
igi->igi_version = igmp_default_version;
igi->igi_flags = 0;
igi->igi_rv = IGMP_RV_INIT;
igi->igi_qi = IGMP_QI_INIT;
igi->igi_qri = IGMP_QRI_INIT;
igi->igi_uri = IGMP_URI_INIT;
if (!(ifp->if_flags & IFF_MULTICAST))
igi->igi_flags |= IGIF_SILENT;
if (!reattach)
SLIST_INIT(&igi->igi_relinmhead);
igi->igi_gq.ifq_maxlen = IGMP_MAX_RESPONSE_PACKETS;
igi->igi_v2q.ifq_maxlen = IGMP_MAX_RESPONSE_PACKETS;
}
static struct igmp_ifinfo *
igi_alloc(int how)
{
struct igmp_ifinfo *igi;
igi = (how == M_WAITOK) ? zalloc(igi_zone) : zalloc_noblock(igi_zone);
if (igi != NULL) {
bzero(igi, igi_size);
lck_mtx_init(&igi->igi_lock, igmp_mtx_grp, igmp_mtx_attr);
igi->igi_debug |= IFD_ALLOC;
}
return (igi);
}
static void
igi_free(struct igmp_ifinfo *igi)
{
IGI_LOCK(igi);
if (igi->igi_debug & IFD_ATTACHED) {
panic("%s: attached igi=%p is being freed", __func__, igi);
} else if (igi->igi_ifp != NULL) {
panic("%s: ifp not NULL for igi=%p", __func__, igi);
} else if (!(igi->igi_debug & IFD_ALLOC)) {
panic("%s: igi %p cannot be freed", __func__, igi);
} else if (igi->igi_refcnt != 0) {
panic("%s: non-zero refcnt igi=%p", __func__, igi);
}
igi->igi_debug &= ~IFD_ALLOC;
IGI_UNLOCK(igi);
lck_mtx_destroy(&igi->igi_lock, igmp_mtx_grp);
zfree(igi_zone, igi);
}
void
igi_addref(struct igmp_ifinfo *igi, int locked)
{
if (!locked)
IGI_LOCK_SPIN(igi);
else
IGI_LOCK_ASSERT_HELD(igi);
if (++igi->igi_refcnt == 0) {
panic("%s: igi=%p wraparound refcnt", __func__, igi);
}
if (!locked)
IGI_UNLOCK(igi);
}
void
igi_remref(struct igmp_ifinfo *igi)
{
struct ifnet *ifp;
IGI_LOCK_SPIN(igi);
if (igi->igi_refcnt == 0) {
panic("%s: igi=%p negative refcnt", __func__, igi);
}
--igi->igi_refcnt;
if (igi->igi_refcnt > 0) {
IGI_UNLOCK(igi);
return;
}
ifp = igi->igi_ifp;
igi->igi_ifp = NULL;
IF_DRAIN(&igi->igi_gq);
IF_DRAIN(&igi->igi_v2q);
igmp_flush_relq(igi);
VERIFY(SLIST_EMPTY(&igi->igi_relinmhead));
IGI_UNLOCK(igi);
IGMP_PRINTF(("%s: freeing igmp_ifinfo for ifp %p(%s%d)\n",
__func__, ifp, ifp->if_name, ifp->if_unit));
igi_free(igi);
}
static int
igmp_input_v1_query(struct ifnet *ifp, const struct ip *ip,
const struct igmp *igmp)
{
struct igmp_ifinfo *igi;
struct in_multi *inm;
struct in_multistep step;
if (!in_allhosts(ip->ip_dst) || !in_nullhost(igmp->igmp_group)) {
IGMPSTAT_INC(igps_rcv_badqueries);
OIGMPSTAT_INC(igps_rcv_badqueries);
return (0);
}
IGMPSTAT_INC(igps_rcv_gen_queries);
igi = IGMP_IFINFO(ifp);
VERIFY(igi != NULL);
IGI_LOCK(igi);
if (igi->igi_flags & IGIF_LOOPBACK) {
IGMP_PRINTF(("ignore v1 query on IGIF_LOOPBACK ifp %p(%s%d)\n",
ifp, ifp->if_name, ifp->if_unit));
IGI_UNLOCK(igi);
return (0);
}
igmp_set_version(igi, IGMP_VERSION_1);
IGI_UNLOCK(igi);
IGMP_PRINTF(("process v1 query on ifp %p(%s%d)\n", ifp, ifp->if_name,
ifp->if_unit));
in_multihead_lock_shared();
IN_FIRST_MULTI(step, inm);
while (inm != NULL) {
INM_LOCK(inm);
if (inm->inm_ifp != ifp)
goto next;
if (inm->inm_timer != 0)
goto next;
switch (inm->inm_state) {
case IGMP_NOT_MEMBER:
case IGMP_SILENT_MEMBER:
break;
case IGMP_G_QUERY_PENDING_MEMBER:
case IGMP_SG_QUERY_PENDING_MEMBER:
case IGMP_REPORTING_MEMBER:
case IGMP_IDLE_MEMBER:
case IGMP_LAZY_MEMBER:
case IGMP_SLEEPING_MEMBER:
case IGMP_AWAKENING_MEMBER:
inm->inm_state = IGMP_REPORTING_MEMBER;
inm->inm_timer = IGMP_RANDOM_DELAY(
IGMP_V1V2_MAX_RI * PR_SLOWHZ);
current_state_timers_running = 1;
break;
case IGMP_LEAVING_MEMBER:
break;
}
next:
INM_UNLOCK(inm);
IN_NEXT_MULTI(step, inm);
}
in_multihead_lock_done();
return (0);
}
static int
igmp_input_v2_query(struct ifnet *ifp, const struct ip *ip,
const struct igmp *igmp)
{
struct igmp_ifinfo *igi;
struct in_multi *inm;
int is_general_query;
uint16_t timer;
is_general_query = 0;
if (in_nullhost(igmp->igmp_group)) {
if (!in_allhosts(ip->ip_dst))
return (0);
IGMPSTAT_INC(igps_rcv_gen_queries);
is_general_query = 1;
} else {
IGMPSTAT_INC(igps_rcv_group_queries);
}
igi = IGMP_IFINFO(ifp);
VERIFY(igi != NULL);
IGI_LOCK(igi);
if (igi->igi_flags & IGIF_LOOPBACK) {
IGMP_PRINTF(("ignore v2 query on IGIF_LOOPBACK ifp %p(%s%d)\n",
ifp, ifp->if_name, ifp->if_unit));
IGI_UNLOCK(igi);
return(0);
}
if (igi->igi_version == IGMP_VERSION_1) {
IGI_UNLOCK(igi);
return (0);
}
igmp_set_version(igi, IGMP_VERSION_2);
IGI_UNLOCK(igi);
timer = igmp->igmp_code * PR_SLOWHZ / IGMP_TIMER_SCALE;
if (timer == 0)
timer = 1;
if (is_general_query) {
struct in_multistep step;
IGMP_PRINTF(("process v2 general query on ifp %p(%s%d)\n",
ifp, ifp->if_name, ifp->if_unit));
in_multihead_lock_shared();
IN_FIRST_MULTI(step, inm);
while (inm != NULL) {
INM_LOCK(inm);
if (inm->inm_ifp == ifp)
igmp_v2_update_group(inm, timer);
INM_UNLOCK(inm);
IN_NEXT_MULTI(step, inm);
}
in_multihead_lock_done();
} else {
in_multihead_lock_shared();
IN_LOOKUP_MULTI(&igmp->igmp_group, ifp, inm);
in_multihead_lock_done();
if (inm != NULL) {
INM_LOCK(inm);
IGMP_PRINTF(("process v2 query %s on ifp %p(%s%d)\n",
inet_ntoa(igmp->igmp_group), ifp, ifp->if_name,
ifp->if_unit));
igmp_v2_update_group(inm, timer);
INM_UNLOCK(inm);
INM_REMREF(inm);
}
}
return (0);
}
static void
igmp_v2_update_group(struct in_multi *inm, const int timer)
{
IGMP_PRINTF(("%s: %s/%s%d timer=%d\n", __func__,
inet_ntoa(inm->inm_addr), inm->inm_ifp->if_name,
inm->inm_ifp->if_unit, timer));
INM_LOCK_ASSERT_HELD(inm);
switch (inm->inm_state) {
case IGMP_NOT_MEMBER:
case IGMP_SILENT_MEMBER:
break;
case IGMP_REPORTING_MEMBER:
if (inm->inm_timer != 0 &&
inm->inm_timer <= timer) {
IGMP_PRINTF(("%s: REPORTING and timer running, "
"skipping.\n", __func__));
break;
}
case IGMP_SG_QUERY_PENDING_MEMBER:
case IGMP_G_QUERY_PENDING_MEMBER:
case IGMP_IDLE_MEMBER:
case IGMP_LAZY_MEMBER:
case IGMP_AWAKENING_MEMBER:
IGMP_PRINTF(("%s: ->REPORTING\n", __func__));
inm->inm_state = IGMP_REPORTING_MEMBER;
inm->inm_timer = IGMP_RANDOM_DELAY(timer);
current_state_timers_running = 1;
break;
case IGMP_SLEEPING_MEMBER:
IGMP_PRINTF(("%s: ->AWAKENING\n", __func__));
inm->inm_state = IGMP_AWAKENING_MEMBER;
break;
case IGMP_LEAVING_MEMBER:
break;
}
}
static int
igmp_input_v3_query(struct ifnet *ifp, const struct ip *ip,
struct igmpv3 *igmpv3)
{
struct igmp_ifinfo *igi;
struct in_multi *inm;
int is_general_query;
uint32_t maxresp, nsrc, qqi;
uint16_t timer;
uint8_t qrv;
is_general_query = 0;
IGMP_PRINTF(("process v3 query on ifp %p(%s%d)\n", ifp, ifp->if_name,
ifp->if_unit));
maxresp = igmpv3->igmp_code;
if (maxresp >= 128) {
maxresp = IGMP_MANT(igmpv3->igmp_code) <<
(IGMP_EXP(igmpv3->igmp_code) + 3);
}
qrv = IGMP_QRV(igmpv3->igmp_misc);
if (qrv < 2) {
IGMP_PRINTF(("%s: clamping qrv %d to %d\n", __func__,
qrv, IGMP_RV_INIT));
qrv = IGMP_RV_INIT;
}
qqi = igmpv3->igmp_qqi;
if (qqi >= 128) {
qqi = IGMP_MANT(igmpv3->igmp_qqi) <<
(IGMP_EXP(igmpv3->igmp_qqi) + 3);
}
timer = maxresp * PR_SLOWHZ / IGMP_TIMER_SCALE;
if (timer == 0)
timer = 1;
nsrc = ntohs(igmpv3->igmp_numsrc);
if (in_nullhost(igmpv3->igmp_group)) {
IGMPSTAT_INC(igps_rcv_gen_queries);
if (!in_allhosts(ip->ip_dst) || nsrc > 0) {
IGMPSTAT_INC(igps_rcv_badqueries);
OIGMPSTAT_INC(igps_rcv_badqueries);
return (0);
}
is_general_query = 1;
} else {
if (nsrc == 0)
IGMPSTAT_INC(igps_rcv_group_queries);
else
IGMPSTAT_INC(igps_rcv_gsr_queries);
}
igi = IGMP_IFINFO(ifp);
VERIFY(igi != NULL);
IGI_LOCK(igi);
if (igi->igi_flags & IGIF_LOOPBACK) {
IGMP_PRINTF(("ignore v3 query on IGIF_LOOPBACK ifp %p(%s%d)\n",
ifp, ifp->if_name, ifp->if_unit));
IGI_UNLOCK(igi);
return (0);
}
if (igi->igi_version != IGMP_VERSION_3) {
IGMP_PRINTF(("ignore v3 query in v%d mode on ifp %p(%s%d)\n",
igi->igi_version, ifp, ifp->if_name, ifp->if_unit));
IGI_UNLOCK(igi);
return (0);
}
igmp_set_version(igi, IGMP_VERSION_3);
igi->igi_rv = qrv;
igi->igi_qi = qqi;
igi->igi_qri = maxresp;
IGMP_PRINTF(("%s: qrv %d qi %d qri %d\n", __func__, qrv, qqi,
maxresp));
if (is_general_query) {
IGMP_PRINTF(("process v3 general query on ifp %p(%s%d)\n",
ifp, ifp->if_name, ifp->if_unit));
if (igi->igi_v3_timer == 0 || igi->igi_v3_timer >= timer) {
igi->igi_v3_timer = IGMP_RANDOM_DELAY(timer);
interface_timers_running = 1;
}
IGI_UNLOCK(igi);
} else {
IGI_UNLOCK(igi);
in_multihead_lock_shared();
IN_LOOKUP_MULTI(&igmpv3->igmp_group, ifp, inm);
in_multihead_lock_done();
if (inm == NULL)
return (0);
INM_LOCK(inm);
#ifndef __APPLE__
if (nsrc > 0) {
if (!ratecheck(&inm->inm_lastgsrtv,
&igmp_gsrdelay)) {
IGMP_PRINTF(("%s: GS query throttled.\n",
__func__));
IGMPSTAT_INC(igps_drop_gsr_queries);
INM_UNLOCK(inm);
INM_REMREF(inm);
return (0);
}
}
#endif
IGMP_PRINTF(("process v3 %s query on ifp %p(%s%d)\n",
inet_ntoa(igmpv3->igmp_group), ifp, ifp->if_name,
ifp->if_unit));
IGI_LOCK(igi);
if (igi->igi_v3_timer == 0 || igi->igi_v3_timer >= timer) {
IGI_UNLOCK(igi);
igmp_input_v3_group_query(inm, timer, igmpv3);
} else {
IGI_UNLOCK(igi);
}
INM_UNLOCK(inm);
INM_REMREF(inm);
}
return (0);
}
static int
igmp_input_v3_group_query(struct in_multi *inm,
int timer, struct igmpv3 *igmpv3)
{
int retval;
uint16_t nsrc;
INM_LOCK_ASSERT_HELD(inm);
retval = 0;
switch (inm->inm_state) {
case IGMP_NOT_MEMBER:
case IGMP_SILENT_MEMBER:
case IGMP_SLEEPING_MEMBER:
case IGMP_LAZY_MEMBER:
case IGMP_AWAKENING_MEMBER:
case IGMP_IDLE_MEMBER:
case IGMP_LEAVING_MEMBER:
return (retval);
case IGMP_REPORTING_MEMBER:
case IGMP_G_QUERY_PENDING_MEMBER:
case IGMP_SG_QUERY_PENDING_MEMBER:
break;
}
nsrc = ntohs(igmpv3->igmp_numsrc);
if (nsrc == 0) {
if (inm->inm_state == IGMP_G_QUERY_PENDING_MEMBER ||
inm->inm_state == IGMP_SG_QUERY_PENDING_MEMBER) {
inm_clear_recorded(inm);
timer = min(inm->inm_timer, timer);
}
inm->inm_state = IGMP_G_QUERY_PENDING_MEMBER;
inm->inm_timer = IGMP_RANDOM_DELAY(timer);
current_state_timers_running = 1;
return (retval);
}
if (inm->inm_state == IGMP_G_QUERY_PENDING_MEMBER) {
timer = min(inm->inm_timer, timer);
inm->inm_timer = IGMP_RANDOM_DELAY(timer);
current_state_timers_running = 1;
return (retval);
}
if (inm->inm_nsrc > 0) {
const struct in_addr *ap;
int i, nrecorded;
ap = (const struct in_addr *)(igmpv3 + 1);
nrecorded = 0;
for (i = 0; i < nsrc; i++, ap++) {
retval = inm_record_source(inm, ap->s_addr);
if (retval < 0)
break;
nrecorded += retval;
}
if (nrecorded > 0) {
IGMP_PRINTF(("%s: schedule response to SG query\n",
__func__));
inm->inm_state = IGMP_SG_QUERY_PENDING_MEMBER;
inm->inm_timer = IGMP_RANDOM_DELAY(timer);
current_state_timers_running = 1;
}
}
return (retval);
}
static int
igmp_input_v1_report(struct ifnet *ifp, struct ip *ip,
struct igmp *igmp)
{
struct in_ifaddr *ia;
struct in_multi *inm;
IGMPSTAT_INC(igps_rcv_reports);
OIGMPSTAT_INC(igps_rcv_reports);
if (ifp->if_flags & IFF_LOOPBACK)
return (0);
if (!IN_MULTICAST(ntohl(igmp->igmp_group.s_addr) ||
!in_hosteq(igmp->igmp_group, ip->ip_dst))) {
IGMPSTAT_INC(igps_rcv_badreports);
OIGMPSTAT_INC(igps_rcv_badreports);
return (EINVAL);
}
if (igmp_recvifkludge && in_nullhost(ip->ip_src)) {
IFP_TO_IA(ifp, ia);
if (ia != NULL) {
IFA_LOCK(&ia->ia_ifa);
ip->ip_src.s_addr = htonl(ia->ia_subnet);
IFA_UNLOCK(&ia->ia_ifa);
IFA_REMREF(&ia->ia_ifa);
}
}
IGMP_PRINTF(("process v1 report %s on ifp %p(%s%d)\n",
inet_ntoa(igmp->igmp_group), ifp, ifp->if_name, ifp->if_unit));
in_multihead_lock_shared();
IN_LOOKUP_MULTI(&igmp->igmp_group, ifp, inm);
in_multihead_lock_done();
if (inm != NULL) {
struct igmp_ifinfo *igi;
INM_LOCK(inm);
igi = inm->inm_igi;
VERIFY(igi != NULL);
IGMPSTAT_INC(igps_rcv_ourreports);
OIGMPSTAT_INC(igps_rcv_ourreports);
IGI_LOCK(igi);
if (igi->igi_version == IGMP_VERSION_3) {
if (igmp_legacysupp)
igmp_v3_suppress_group_record(inm);
IGI_UNLOCK(igi);
INM_UNLOCK(inm);
INM_REMREF(inm);
return (0);
}
INM_LOCK_ASSERT_HELD(inm);
inm->inm_timer = 0;
switch (inm->inm_state) {
case IGMP_NOT_MEMBER:
case IGMP_SILENT_MEMBER:
break;
case IGMP_IDLE_MEMBER:
case IGMP_LAZY_MEMBER:
case IGMP_AWAKENING_MEMBER:
IGMP_PRINTF(("report suppressed for %s on ifp %p(%s%d)\n",
inet_ntoa(igmp->igmp_group), ifp, ifp->if_name,
ifp->if_unit));
case IGMP_SLEEPING_MEMBER:
inm->inm_state = IGMP_SLEEPING_MEMBER;
break;
case IGMP_REPORTING_MEMBER:
IGMP_PRINTF(("report suppressed for %s on ifp %p(%s%d)\n",
inet_ntoa(igmp->igmp_group), ifp, ifp->if_name,
ifp->if_unit));
if (igi->igi_version == IGMP_VERSION_1)
inm->inm_state = IGMP_LAZY_MEMBER;
else if (igi->igi_version == IGMP_VERSION_2)
inm->inm_state = IGMP_SLEEPING_MEMBER;
break;
case IGMP_G_QUERY_PENDING_MEMBER:
case IGMP_SG_QUERY_PENDING_MEMBER:
case IGMP_LEAVING_MEMBER:
break;
}
IGI_UNLOCK(igi);
INM_UNLOCK(inm);
INM_REMREF(inm);
}
return (0);
}
static int
igmp_input_v2_report(struct ifnet *ifp, struct ip *ip,
struct igmp *igmp)
{
struct in_ifaddr *ia;
struct in_multi *inm;
IFP_TO_IA(ifp, ia);
if (ia != NULL) {
IFA_LOCK(&ia->ia_ifa);
if (in_hosteq(ip->ip_src, IA_SIN(ia)->sin_addr)) {
IFA_UNLOCK(&ia->ia_ifa);
IFA_REMREF(&ia->ia_ifa);
return (0);
}
IFA_UNLOCK(&ia->ia_ifa);
}
IGMPSTAT_INC(igps_rcv_reports);
OIGMPSTAT_INC(igps_rcv_reports);
if (ifp->if_flags & IFF_LOOPBACK) {
if (ia != NULL)
IFA_REMREF(&ia->ia_ifa);
return (0);
}
if (!IN_MULTICAST(ntohl(igmp->igmp_group.s_addr)) ||
!in_hosteq(igmp->igmp_group, ip->ip_dst)) {
if (ia != NULL)
IFA_REMREF(&ia->ia_ifa);
IGMPSTAT_INC(igps_rcv_badreports);
OIGMPSTAT_INC(igps_rcv_badreports);
return (EINVAL);
}
if (igmp_recvifkludge && in_nullhost(ip->ip_src)) {
if (ia != NULL) {
IFA_LOCK(&ia->ia_ifa);
ip->ip_src.s_addr = htonl(ia->ia_subnet);
IFA_UNLOCK(&ia->ia_ifa);
}
}
if (ia != NULL)
IFA_REMREF(&ia->ia_ifa);
IGMP_PRINTF(("process v2 report %s on ifp %p(%s%d)\n",
inet_ntoa(igmp->igmp_group), ifp, ifp->if_name, ifp->if_unit));
in_multihead_lock_shared();
IN_LOOKUP_MULTI(&igmp->igmp_group, ifp, inm);
in_multihead_lock_done();
if (inm != NULL) {
struct igmp_ifinfo *igi;
INM_LOCK(inm);
igi = inm->inm_igi;
VERIFY(igi != NULL);
IGMPSTAT_INC(igps_rcv_ourreports);
OIGMPSTAT_INC(igps_rcv_ourreports);
IGI_LOCK(igi);
if (igi->igi_version == IGMP_VERSION_3) {
if (igmp_legacysupp)
igmp_v3_suppress_group_record(inm);
IGI_UNLOCK(igi);
INM_UNLOCK(inm);
INM_REMREF(inm);
return (0);
}
inm->inm_timer = 0;
switch (inm->inm_state) {
case IGMP_NOT_MEMBER:
case IGMP_SILENT_MEMBER:
case IGMP_SLEEPING_MEMBER:
break;
case IGMP_REPORTING_MEMBER:
case IGMP_IDLE_MEMBER:
case IGMP_AWAKENING_MEMBER:
IGMP_PRINTF(("report suppressed for %s on ifp %p(%s%d)\n",
inet_ntoa(igmp->igmp_group), ifp, ifp->if_name,
ifp->if_unit));
case IGMP_LAZY_MEMBER:
inm->inm_state = IGMP_LAZY_MEMBER;
break;
case IGMP_G_QUERY_PENDING_MEMBER:
case IGMP_SG_QUERY_PENDING_MEMBER:
case IGMP_LEAVING_MEMBER:
break;
}
IGI_UNLOCK(igi);
INM_UNLOCK(inm);
INM_REMREF(inm);
}
return (0);
}
void
igmp_input(struct mbuf *m, int off)
{
int iphlen;
struct ifnet *ifp;
struct igmp *igmp;
struct ip *ip;
int igmplen;
int minlen;
int queryver;
IGMP_PRINTF(("%s: called w/mbuf (%p,%d)\n", __func__, m, off));
ifp = m->m_pkthdr.rcvif;
IGMPSTAT_INC(igps_rcv_total);
OIGMPSTAT_INC(igps_rcv_total);
ip = mtod(m, struct ip *);
iphlen = off;
igmplen = ip->ip_len;
if (igmplen < IGMP_MINLEN) {
IGMPSTAT_INC(igps_rcv_tooshort);
OIGMPSTAT_INC(igps_rcv_tooshort);
m_freem(m);
return;
}
if (igmplen >= IGMP_V3_QUERY_MINLEN)
minlen = IGMP_V3_QUERY_MINLEN;
else
minlen = IGMP_MINLEN;
M_STRUCT_GET(igmp, struct igmp *, m, off, minlen);
if (igmp == NULL) {
IGMPSTAT_INC(igps_rcv_tooshort);
OIGMPSTAT_INC(igps_rcv_tooshort);
return;
}
m->m_data += iphlen;
m->m_len -= iphlen;
if (in_cksum(m, igmplen)) {
IGMPSTAT_INC(igps_rcv_badsum);
OIGMPSTAT_INC(igps_rcv_badsum);
m_freem(m);
return;
}
m->m_data -= iphlen;
m->m_len += iphlen;
if (igmp->igmp_type != IGMP_DVMRP && ip->ip_ttl != 1) {
IGMPSTAT_INC(igps_rcv_badttl);
m_freem(m);
return;
}
switch (igmp->igmp_type) {
case IGMP_HOST_MEMBERSHIP_QUERY:
if (igmplen == IGMP_MINLEN) {
if (igmp->igmp_code == 0)
queryver = IGMP_VERSION_1;
else
queryver = IGMP_VERSION_2;
} else if (igmplen >= IGMP_V3_QUERY_MINLEN) {
queryver = IGMP_VERSION_3;
} else {
IGMPSTAT_INC(igps_rcv_tooshort);
OIGMPSTAT_INC(igps_rcv_tooshort);
m_freem(m);
return;
}
OIGMPSTAT_INC(igps_rcv_queries);
switch (queryver) {
case IGMP_VERSION_1:
IGMPSTAT_INC(igps_rcv_v1v2_queries);
if (!igmp_v1enable)
break;
if (igmp_input_v1_query(ifp, ip, igmp) != 0) {
m_freem(m);
return;
}
break;
case IGMP_VERSION_2:
IGMPSTAT_INC(igps_rcv_v1v2_queries);
if (!igmp_v2enable)
break;
if (igmp_input_v2_query(ifp, ip, igmp) != 0) {
m_freem(m);
return;
}
break;
case IGMP_VERSION_3: {
struct igmpv3 *igmpv3;
uint16_t igmpv3len;
uint16_t srclen;
int nsrc;
IGMPSTAT_INC(igps_rcv_v3_queries);
igmpv3 = (struct igmpv3 *)igmp;
nsrc = ntohs(igmpv3->igmp_numsrc);
srclen = sizeof(struct in_addr) * nsrc;
if (igmplen < (IGMP_V3_QUERY_MINLEN + srclen)) {
IGMPSTAT_INC(igps_rcv_tooshort);
OIGMPSTAT_INC(igps_rcv_tooshort);
m_freem(m);
return;
}
igmpv3len = IGMP_V3_QUERY_MINLEN + srclen;
M_STRUCT_GET(igmpv3, struct igmpv3 *, m,
off, igmpv3len);
if (igmpv3 == NULL) {
IGMPSTAT_INC(igps_rcv_tooshort);
OIGMPSTAT_INC(igps_rcv_tooshort);
return;
}
if (igmp_input_v3_query(ifp, ip, igmpv3) != 0) {
m_freem(m);
return;
}
}
break;
}
break;
case IGMP_v1_HOST_MEMBERSHIP_REPORT:
if (!igmp_v1enable)
break;
if (igmp_input_v1_report(ifp, ip, igmp) != 0) {
m_freem(m);
return;
}
break;
case IGMP_v2_HOST_MEMBERSHIP_REPORT:
if (!igmp_v2enable)
break;
#ifndef __APPLE__
if (!ip_checkrouteralert(m))
IGMPSTAT_INC(igps_rcv_nora);
#endif
if (igmp_input_v2_report(ifp, ip, igmp) != 0) {
m_freem(m);
return;
}
break;
case IGMP_v3_HOST_MEMBERSHIP_REPORT:
#ifndef __APPLE__
if (!ip_checkrouteralert(m))
IGMPSTAT_INC(igps_rcv_nora);
#endif
break;
default:
break;
}
lck_mtx_assert(&igmp_mtx, LCK_MTX_ASSERT_NOTOWNED);
rip_input(m, off);
}
void
igmp_slowtimo(void)
{
struct ifqueue scq;
struct ifqueue qrq;
struct ifnet *ifp;
struct igmp_ifinfo *igi;
struct in_multi *inm;
int loop = 0, uri_fasthz = 0;
lck_mtx_lock(&igmp_mtx);
LIST_FOREACH(igi, &igi_head, igi_link) {
IGI_LOCK(igi);
igmp_v1v2_process_querier_timers(igi);
IGI_UNLOCK(igi);
}
if (!current_state_timers_running &&
!interface_timers_running &&
!state_change_timers_running) {
lck_mtx_unlock(&igmp_mtx);
return;
}
if (interface_timers_running) {
interface_timers_running = 0;
LIST_FOREACH(igi, &igi_head, igi_link) {
IGI_LOCK(igi);
if (igi->igi_v3_timer == 0) {
} else if (--igi->igi_v3_timer == 0) {
igmp_v3_dispatch_general_query(igi);
} else {
interface_timers_running = 1;
}
IGI_UNLOCK(igi);
}
}
if (!current_state_timers_running &&
!state_change_timers_running)
goto out_locked;
current_state_timers_running = 0;
state_change_timers_running = 0;
memset(&qrq, 0, sizeof(struct ifqueue));
qrq.ifq_maxlen = IGMP_MAX_G_GS_PACKETS;
memset(&scq, 0, sizeof(struct ifqueue));
scq.ifq_maxlen = IGMP_MAX_STATE_CHANGE_PACKETS;
LIST_FOREACH(igi, &igi_head, igi_link) {
struct in_multistep step;
IGI_LOCK(igi);
ifp = igi->igi_ifp;
loop = (igi->igi_flags & IGIF_LOOPBACK) ? 1 : 0;
uri_fasthz = IGMP_RANDOM_DELAY(igi->igi_uri * PR_SLOWHZ);
IGI_UNLOCK(igi);
in_multihead_lock_shared();
IN_FIRST_MULTI(step, inm);
while (inm != NULL) {
INM_LOCK(inm);
if (inm->inm_ifp != ifp)
goto next;
IGI_LOCK(igi);
switch (igi->igi_version) {
case IGMP_VERSION_1:
case IGMP_VERSION_2:
igmp_v1v2_process_group_timer(inm,
igi->igi_version);
break;
case IGMP_VERSION_3:
igmp_v3_process_group_timers(igi, &qrq,
&scq, inm, uri_fasthz);
break;
}
IGI_UNLOCK(igi);
next:
INM_UNLOCK(inm);
IN_NEXT_MULTI(step, inm);
}
in_multihead_lock_done();
IGI_LOCK(igi);
if (igi->igi_version == IGMP_VERSION_1 ||
igi->igi_version == IGMP_VERSION_2) {
igmp_dispatch_queue(igi, &igi->igi_v2q, 0, loop, ifp);
} else if (igi->igi_version == IGMP_VERSION_3) {
IGI_UNLOCK(igi);
igmp_dispatch_queue(NULL, &qrq, 0, loop, ifp);
igmp_dispatch_queue(NULL, &scq, 0, loop, ifp);
VERIFY(qrq.ifq_len == 0);
VERIFY(scq.ifq_len == 0);
IGI_LOCK(igi);
}
IF_DRAIN(&igi->igi_v2q);
igmp_flush_relq(igi);
VERIFY(SLIST_EMPTY(&igi->igi_relinmhead));
IGI_UNLOCK(igi);
IF_DRAIN(&qrq);
IF_DRAIN(&scq);
}
out_locked:
lck_mtx_unlock(&igmp_mtx);
}
static void
igmp_flush_relq(struct igmp_ifinfo *igi)
{
struct in_multi *inm;
again:
IGI_LOCK_ASSERT_HELD(igi);
inm = SLIST_FIRST(&igi->igi_relinmhead);
if (inm != NULL) {
int lastref;
SLIST_REMOVE_HEAD(&igi->igi_relinmhead, inm_nrele);
IGI_UNLOCK(igi);
in_multihead_lock_exclusive();
INM_LOCK(inm);
VERIFY(inm->inm_nrelecnt != 0);
inm->inm_nrelecnt--;
lastref = in_multi_detach(inm);
VERIFY(!lastref || (!(inm->inm_debug & IFD_ATTACHED) &&
inm->inm_reqcnt == 0));
INM_UNLOCK(inm);
in_multihead_lock_done();
INM_REMREF(inm);
if (lastref)
INM_REMREF(inm);
IGI_LOCK(igi);
goto again;
}
}
static void
igmp_v1v2_process_group_timer(struct in_multi *inm, const int igmp_version)
{
int report_timer_expired;
INM_LOCK_ASSERT_HELD(inm);
IGI_LOCK_ASSERT_HELD(inm->inm_igi);
if (inm->inm_timer == 0) {
report_timer_expired = 0;
} else if (--inm->inm_timer == 0) {
report_timer_expired = 1;
} else {
current_state_timers_running = 1;
return;
}
switch (inm->inm_state) {
case IGMP_NOT_MEMBER:
case IGMP_SILENT_MEMBER:
case IGMP_IDLE_MEMBER:
case IGMP_LAZY_MEMBER:
case IGMP_SLEEPING_MEMBER:
case IGMP_AWAKENING_MEMBER:
break;
case IGMP_REPORTING_MEMBER:
if (report_timer_expired) {
inm->inm_state = IGMP_IDLE_MEMBER;
(void) igmp_v1v2_queue_report(inm,
(igmp_version == IGMP_VERSION_2) ?
IGMP_v2_HOST_MEMBERSHIP_REPORT :
IGMP_v1_HOST_MEMBERSHIP_REPORT);
INM_LOCK_ASSERT_HELD(inm);
IGI_LOCK_ASSERT_HELD(inm->inm_igi);
}
break;
case IGMP_G_QUERY_PENDING_MEMBER:
case IGMP_SG_QUERY_PENDING_MEMBER:
case IGMP_LEAVING_MEMBER:
break;
}
}
static void
igmp_v3_process_group_timers(struct igmp_ifinfo *igi,
struct ifqueue *qrq, struct ifqueue *scq,
struct in_multi *inm, const int uri_fasthz)
{
int query_response_timer_expired;
int state_change_retransmit_timer_expired;
INM_LOCK_ASSERT_HELD(inm);
IGI_LOCK_ASSERT_HELD(igi);
VERIFY(igi == inm->inm_igi);
query_response_timer_expired = 0;
state_change_retransmit_timer_expired = 0;
if (inm->inm_timer == 0) {
query_response_timer_expired = 0;
} else if (--inm->inm_timer == 0) {
query_response_timer_expired = 1;
} else {
current_state_timers_running = 1;
}
if (inm->inm_sctimer == 0) {
state_change_retransmit_timer_expired = 0;
} else if (--inm->inm_sctimer == 0) {
state_change_retransmit_timer_expired = 1;
} else {
state_change_timers_running = 1;
}
if (!state_change_retransmit_timer_expired &&
!query_response_timer_expired)
return;
switch (inm->inm_state) {
case IGMP_NOT_MEMBER:
case IGMP_SILENT_MEMBER:
case IGMP_SLEEPING_MEMBER:
case IGMP_LAZY_MEMBER:
case IGMP_AWAKENING_MEMBER:
case IGMP_IDLE_MEMBER:
break;
case IGMP_G_QUERY_PENDING_MEMBER:
case IGMP_SG_QUERY_PENDING_MEMBER:
if (query_response_timer_expired) {
int retval;
retval = igmp_v3_enqueue_group_record(qrq, inm, 0, 1,
(inm->inm_state == IGMP_SG_QUERY_PENDING_MEMBER));
IGMP_PRINTF(("%s: enqueue record = %d\n",
__func__, retval));
inm->inm_state = IGMP_REPORTING_MEMBER;
inm_clear_recorded(inm);
}
case IGMP_REPORTING_MEMBER:
case IGMP_LEAVING_MEMBER:
if (state_change_retransmit_timer_expired) {
if (--inm->inm_scrv > 0) {
inm->inm_sctimer = uri_fasthz;
state_change_timers_running = 1;
}
(void) igmp_v3_merge_state_changes(inm, scq);
inm_commit(inm);
IGMP_PRINTF(("%s: T1 -> T0 for %s/%s%d\n", __func__,
inet_ntoa(inm->inm_addr), inm->inm_ifp->if_name,
inm->inm_ifp->if_unit));
if (inm->inm_state == IGMP_LEAVING_MEMBER &&
inm->inm_scrv == 0) {
inm->inm_state = IGMP_NOT_MEMBER;
VERIFY(inm->inm_nrelecnt != 0);
SLIST_INSERT_HEAD(&igi->igi_relinmhead,
inm, inm_nrele);
}
}
break;
}
}
static void
igmp_v3_suppress_group_record(struct in_multi *inm)
{
INM_LOCK_ASSERT_HELD(inm);
IGI_LOCK_ASSERT_HELD(inm->inm_igi);
VERIFY(inm->inm_igi->igi_version == IGMP_VERSION_3);
if (inm->inm_state != IGMP_G_QUERY_PENDING_MEMBER ||
inm->inm_state != IGMP_SG_QUERY_PENDING_MEMBER)
return;
if (inm->inm_state == IGMP_SG_QUERY_PENDING_MEMBER)
inm_clear_recorded(inm);
inm->inm_timer = 0;
inm->inm_state = IGMP_REPORTING_MEMBER;
}
static void
igmp_set_version(struct igmp_ifinfo *igi, const int igmp_version)
{
int old_version_timer;
IGI_LOCK_ASSERT_HELD(igi);
IGMP_PRINTF(("%s: switching to v%d on ifp %p(%s%d)\n", __func__,
igmp_version, igi->igi_ifp, igi->igi_ifp->if_name,
igi->igi_ifp->if_unit));
if (igmp_version == IGMP_VERSION_1 || igmp_version == IGMP_VERSION_2) {
old_version_timer = igi->igi_rv * igi->igi_qi + igi->igi_qri;
old_version_timer *= PR_SLOWHZ;
if (igmp_version == IGMP_VERSION_1) {
igi->igi_v1_timer = old_version_timer;
igi->igi_v2_timer = 0;
} else if (igmp_version == IGMP_VERSION_2) {
igi->igi_v1_timer = 0;
igi->igi_v2_timer = old_version_timer;
}
}
if (igi->igi_v1_timer == 0 && igi->igi_v2_timer > 0) {
if (igi->igi_version != IGMP_VERSION_2) {
igi->igi_version = IGMP_VERSION_2;
igmp_v3_cancel_link_timers(igi);
}
} else if (igi->igi_v1_timer > 0) {
if (igi->igi_version != IGMP_VERSION_1) {
igi->igi_version = IGMP_VERSION_1;
igmp_v3_cancel_link_timers(igi);
}
}
IGI_LOCK_ASSERT_HELD(igi);
}
static void
igmp_v3_cancel_link_timers(struct igmp_ifinfo *igi)
{
struct ifnet *ifp;
struct in_multi *inm;
struct in_multistep step;
IGI_LOCK_ASSERT_HELD(igi);
IGMP_PRINTF(("%s: cancel v3 timers on ifp %p(%s%d)\n", __func__,
igi->igi_ifp, igi->igi_ifp->if_name, igi->igi_ifp->if_unit));
igi->igi_v3_timer = 0;
ifp = igi->igi_ifp;
IGI_UNLOCK(igi);
in_multihead_lock_shared();
IN_FIRST_MULTI(step, inm);
while (inm != NULL) {
INM_LOCK(inm);
if (inm->inm_ifp != ifp)
goto next;
switch (inm->inm_state) {
case IGMP_NOT_MEMBER:
case IGMP_SILENT_MEMBER:
case IGMP_IDLE_MEMBER:
case IGMP_LAZY_MEMBER:
case IGMP_SLEEPING_MEMBER:
case IGMP_AWAKENING_MEMBER:
break;
case IGMP_LEAVING_MEMBER:
VERIFY(inm->inm_nrelecnt != 0);
IGI_LOCK(igi);
SLIST_INSERT_HEAD(&igi->igi_relinmhead, inm, inm_nrele);
IGI_UNLOCK(igi);
case IGMP_G_QUERY_PENDING_MEMBER:
case IGMP_SG_QUERY_PENDING_MEMBER:
inm_clear_recorded(inm);
case IGMP_REPORTING_MEMBER:
inm->inm_state = IGMP_REPORTING_MEMBER;
break;
}
inm->inm_sctimer = 0;
inm->inm_timer = 0;
IF_DRAIN(&inm->inm_scq);
next:
INM_UNLOCK(inm);
IN_NEXT_MULTI(step, inm);
}
in_multihead_lock_done();
IGI_LOCK(igi);
}
static void
igmp_v1v2_process_querier_timers(struct igmp_ifinfo *igi)
{
IGI_LOCK_ASSERT_HELD(igi);
if (igi->igi_v1_timer == 0 && igi->igi_v2_timer == 0) {
if (igi->igi_version != IGMP_VERSION_3) {
IGMP_PRINTF(("%s: transition from v%d -> v%d on %p(%s%d)\n",
__func__, igi->igi_version, IGMP_VERSION_3,
igi->igi_ifp, igi->igi_ifp->if_name,
igi->igi_ifp->if_unit));
igi->igi_version = IGMP_VERSION_3;
IF_DRAIN(&igi->igi_v2q);
}
} else if (igi->igi_v1_timer == 0 && igi->igi_v2_timer > 0) {
if (!igmp_v2enable) {
IGMP_PRINTF(("%s: transition from v%d -> v%d on %p(%s%d)\n",
__func__, igi->igi_version, IGMP_VERSION_3,
igi->igi_ifp, igi->igi_ifp->if_name,
igi->igi_ifp->if_unit));
igi->igi_v2_timer = 0;
igi->igi_version = IGMP_VERSION_3;
IF_DRAIN(&igi->igi_v2q);
} else {
--igi->igi_v2_timer;
if (igi->igi_version != IGMP_VERSION_2) {
IGMP_PRINTF(("%s: transition from v%d -> v%d on %p(%s%d)\n",
__func__, igi->igi_version, IGMP_VERSION_2,
igi->igi_ifp, igi->igi_ifp->if_name,
igi->igi_ifp->if_unit));
igi->igi_version = IGMP_VERSION_2;
IF_DRAIN(&igi->igi_gq);
}
}
} else if (igi->igi_v1_timer > 0) {
if (!igmp_v1enable) {
IGMP_PRINTF(("%s: transition from v%d -> v%d on %p(%s%d)\n",
__func__, igi->igi_version, IGMP_VERSION_3,
igi->igi_ifp, igi->igi_ifp->if_name,
igi->igi_ifp->if_unit));
igi->igi_v1_timer = 0;
igi->igi_version = IGMP_VERSION_3;
IF_DRAIN(&igi->igi_v2q);
} else {
--igi->igi_v1_timer;
}
if (igi->igi_v2_timer > 0) {
IGMP_PRINTF(("%s: cancel v2 timer on %p(%s%d)\n",
__func__, igi->igi_ifp, igi->igi_ifp->if_name,
igi->igi_ifp->if_unit));
igi->igi_v2_timer = 0;
}
}
}
static int
igmp_v1v2_queue_report(struct in_multi *inm, const int type)
{
struct ifnet *ifp;
struct igmp *igmp;
struct ip *ip;
struct mbuf *m;
int error = 0;
INM_LOCK_ASSERT_HELD(inm);
IGI_LOCK_ASSERT_HELD(inm->inm_igi);
ifp = inm->inm_ifp;
MGETHDR(m, M_DONTWAIT, MT_DATA);
if (m == NULL)
return (ENOMEM);
MH_ALIGN(m, sizeof(struct ip) + sizeof(struct igmp));
m->m_pkthdr.len = sizeof(struct ip) + sizeof(struct igmp);
m->m_data += sizeof(struct ip);
m->m_len = sizeof(struct igmp);
igmp = mtod(m, struct igmp *);
igmp->igmp_type = type;
igmp->igmp_code = 0;
igmp->igmp_group = inm->inm_addr;
igmp->igmp_cksum = 0;
igmp->igmp_cksum = in_cksum(m, sizeof(struct igmp));
m->m_data -= sizeof(struct ip);
m->m_len += sizeof(struct ip);
ip = mtod(m, struct ip *);
ip->ip_tos = 0;
ip->ip_len = sizeof(struct ip) + sizeof(struct igmp);
ip->ip_off = 0;
ip->ip_p = IPPROTO_IGMP;
ip->ip_src.s_addr = INADDR_ANY;
if (type == IGMP_HOST_LEAVE_MESSAGE)
ip->ip_dst.s_addr = htonl(INADDR_ALLRTRS_GROUP);
else
ip->ip_dst = inm->inm_addr;
m->m_flags |= M_IGMPV2;
if (inm->inm_igi->igi_flags & IGIF_LOOPBACK)
m->m_flags |= M_IGMP_LOOP;
if (IF_QFULL(&inm->inm_igi->igi_v2q)) {
IGMP_PRINTF(("%s: v1/v2 outbound queue full\n", __func__));
error = ENOMEM;
m_freem(m);
} else
IF_ENQUEUE(&inm->inm_igi->igi_v2q, m);
return (error);
}
int
igmp_change_state(struct in_multi *inm)
{
struct igmp_ifinfo *igi;
struct ifnet *ifp;
int error = 0;
INM_LOCK_ASSERT_HELD(inm);
VERIFY(inm->inm_igi != NULL);
IGI_LOCK_ASSERT_NOTHELD(inm->inm_igi);
VERIFY(inm->inm_ifma != NULL);
ifp = inm->inm_ifma->ifma_ifp;
VERIFY(inm->inm_ifp == ifp);
igi = IGMP_IFINFO(ifp);
VERIFY(igi != NULL);
if (inm->inm_st[1].iss_fmode != inm->inm_st[0].iss_fmode) {
IGMP_PRINTF(("%s: inm transition %d -> %d\n", __func__,
inm->inm_st[0].iss_fmode, inm->inm_st[1].iss_fmode));
if (inm->inm_st[0].iss_fmode == MCAST_UNDEFINED) {
IGMP_PRINTF(("%s: initial join\n", __func__));
error = igmp_initial_join(inm, igi);
goto out;
} else if (inm->inm_st[1].iss_fmode == MCAST_UNDEFINED) {
IGMP_PRINTF(("%s: final leave\n", __func__));
igmp_final_leave(inm, igi);
goto out;
}
} else {
IGMP_PRINTF(("%s: filter set change\n", __func__));
}
error = igmp_handle_state_change(inm, igi);
out:
return (error);
}
static int
igmp_initial_join(struct in_multi *inm, struct igmp_ifinfo *igi)
{
struct ifnet *ifp;
struct ifqueue *ifq;
int error, retval, syncstates;
INM_LOCK_ASSERT_HELD(inm);
IGI_LOCK_ASSERT_NOTHELD(igi);
IGMP_PRINTF(("%s: initial join %s on ifp %p(%s%d)\n",
__func__, inet_ntoa(inm->inm_addr), inm->inm_ifp,
inm->inm_ifp->if_name, inm->inm_ifp->if_unit));
error = 0;
syncstates = 1;
ifp = inm->inm_ifp;
IGI_LOCK(igi);
VERIFY(igi->igi_ifp == ifp);
if ((ifp->if_flags & IFF_LOOPBACK) ||
(igi->igi_flags & IGIF_SILENT) ||
!igmp_isgroupreported(inm->inm_addr)) {
IGMP_PRINTF(("%s: not kicking state machine for silent group\n",
__func__));
inm->inm_state = IGMP_SILENT_MEMBER;
inm->inm_timer = 0;
} else {
if (igi->igi_version == IGMP_VERSION_3 &&
inm->inm_state == IGMP_LEAVING_MEMBER) {
VERIFY(inm->inm_nrelecnt != 0);
SLIST_INSERT_HEAD(&igi->igi_relinmhead, inm, inm_nrele);
}
inm->inm_state = IGMP_REPORTING_MEMBER;
switch (igi->igi_version) {
case IGMP_VERSION_1:
case IGMP_VERSION_2:
inm->inm_state = IGMP_IDLE_MEMBER;
error = igmp_v1v2_queue_report(inm,
(igi->igi_version == IGMP_VERSION_2) ?
IGMP_v2_HOST_MEMBERSHIP_REPORT :
IGMP_v1_HOST_MEMBERSHIP_REPORT);
INM_LOCK_ASSERT_HELD(inm);
IGI_LOCK_ASSERT_HELD(igi);
if (error == 0) {
inm->inm_timer = IGMP_RANDOM_DELAY(
IGMP_V1V2_MAX_RI * PR_SLOWHZ);
current_state_timers_running = 1;
}
break;
case IGMP_VERSION_3:
syncstates = 0;
ifq = &inm->inm_scq;
IF_DRAIN(ifq);
retval = igmp_v3_enqueue_group_record(ifq, inm, 1,
0, 0);
IGMP_PRINTF(("%s: enqueue record = %d\n",
__func__, retval));
if (retval <= 0) {
error = retval * -1;
break;
}
if (igi->igi_flags & IGIF_LOOPBACK) {
inm->inm_scrv = 1;
} else {
VERIFY(igi->igi_rv > 1);
inm->inm_scrv = igi->igi_rv;
}
inm->inm_sctimer = 1;
state_change_timers_running = 1;
error = 0;
break;
}
}
IGI_UNLOCK(igi);
if (syncstates) {
inm_commit(inm);
IGMP_PRINTF(("%s: T1 -> T0 for %s/%s%d\n", __func__,
inet_ntoa(inm->inm_addr), inm->inm_ifp->if_name,
inm->inm_ifp->if_unit));
}
return (error);
}
static int
igmp_handle_state_change(struct in_multi *inm, struct igmp_ifinfo *igi)
{
struct ifnet *ifp;
int retval;
INM_LOCK_ASSERT_HELD(inm);
IGI_LOCK_ASSERT_NOTHELD(igi);
IGMP_PRINTF(("%s: state change for %s on ifp %p(%s%d)\n",
__func__, inet_ntoa(inm->inm_addr), inm->inm_ifp,
inm->inm_ifp->if_name, inm->inm_ifp->if_unit));
ifp = inm->inm_ifp;
IGI_LOCK(igi);
VERIFY(igi->igi_ifp == ifp);
if ((ifp->if_flags & IFF_LOOPBACK) ||
(igi->igi_flags & IGIF_SILENT) ||
!igmp_isgroupreported(inm->inm_addr) ||
(igi->igi_version != IGMP_VERSION_3)) {
IGI_UNLOCK(igi);
if (!igmp_isgroupreported(inm->inm_addr)) {
IGMP_PRINTF(("%s: not kicking state "
"machine for silent group\n", __func__));
}
IGMP_PRINTF(("%s: nothing to do\n", __func__));
inm_commit(inm);
IGMP_PRINTF(("%s: T1 -> T0 for %s/%s\n", __func__,
inet_ntoa(inm->inm_addr), inm->inm_ifp->if_name));
return (0);
}
IF_DRAIN(&inm->inm_scq);
retval = igmp_v3_enqueue_group_record(&inm->inm_scq, inm, 1, 0, 0);
IGMP_PRINTF(("%s: enqueue record = %d\n", __func__, retval));
if (retval <= 0) {
IGI_UNLOCK(igi);
return (-retval);
}
inm->inm_scrv = ((igi->igi_flags & IGIF_LOOPBACK) ? 1 : igi->igi_rv);
inm->inm_sctimer = 1;
state_change_timers_running = 1;
IGI_UNLOCK(igi);
return (0);
}
static void
igmp_final_leave(struct in_multi *inm, struct igmp_ifinfo *igi)
{
int syncstates = 1;
INM_LOCK_ASSERT_HELD(inm);
IGI_LOCK_ASSERT_NOTHELD(igi);
IGMP_PRINTF(("%s: final leave %s on ifp %p(%s%d)\n",
__func__, inet_ntoa(inm->inm_addr), inm->inm_ifp,
inm->inm_ifp->if_name, inm->inm_ifp->if_unit));
switch (inm->inm_state) {
case IGMP_NOT_MEMBER:
case IGMP_SILENT_MEMBER:
case IGMP_LEAVING_MEMBER:
IGMP_PRINTF(("%s: not kicking state machine for silent group\n",
__func__));
break;
case IGMP_REPORTING_MEMBER:
case IGMP_IDLE_MEMBER:
case IGMP_G_QUERY_PENDING_MEMBER:
case IGMP_SG_QUERY_PENDING_MEMBER:
IGI_LOCK(igi);
if (igi->igi_version == IGMP_VERSION_2) {
if (inm->inm_state == IGMP_G_QUERY_PENDING_MEMBER ||
inm->inm_state == IGMP_SG_QUERY_PENDING_MEMBER) {
panic("%s: IGMPv3 state reached, not IGMPv3 "
"mode\n", __func__);
}
igmp_v1v2_queue_report(inm, IGMP_HOST_LEAVE_MESSAGE);
INM_LOCK_ASSERT_HELD(inm);
IGI_LOCK_ASSERT_HELD(igi);
inm->inm_state = IGMP_NOT_MEMBER;
} else if (igi->igi_version == IGMP_VERSION_3) {
IF_DRAIN(&inm->inm_scq);
inm->inm_timer = 0;
if (igi->igi_flags & IGIF_LOOPBACK) {
inm->inm_scrv = 1;
} else {
inm->inm_scrv = igi->igi_rv;
}
IGMP_PRINTF(("%s: Leaving %s/%s%d with %d "
"pending retransmissions.\n", __func__,
inet_ntoa(inm->inm_addr),
inm->inm_ifp->if_name, inm->inm_ifp->if_unit,
inm->inm_scrv));
if (inm->inm_scrv == 0) {
inm->inm_state = IGMP_NOT_MEMBER;
inm->inm_sctimer = 0;
} else {
int retval;
INM_ADDREF_LOCKED(inm);
VERIFY(inm->inm_debug & IFD_ATTACHED);
inm->inm_reqcnt++;
VERIFY(inm->inm_reqcnt >= 1);
inm->inm_nrelecnt++;
VERIFY(inm->inm_nrelecnt != 0);
retval = igmp_v3_enqueue_group_record(
&inm->inm_scq, inm, 1, 0, 0);
KASSERT(retval != 0,
("%s: enqueue record = %d\n", __func__,
retval));
inm->inm_state = IGMP_LEAVING_MEMBER;
inm->inm_sctimer = 1;
state_change_timers_running = 1;
syncstates = 0;
}
}
IGI_UNLOCK(igi);
break;
case IGMP_LAZY_MEMBER:
case IGMP_SLEEPING_MEMBER:
case IGMP_AWAKENING_MEMBER:
break;
}
if (syncstates) {
inm_commit(inm);
IGMP_PRINTF(("%s: T1 -> T0 for %s/%s%d\n", __func__,
inet_ntoa(inm->inm_addr), inm->inm_ifp->if_name,
inm->inm_ifp->if_unit));
inm->inm_st[1].iss_fmode = MCAST_UNDEFINED;
IGMP_PRINTF(("%s: T1 now MCAST_UNDEFINED for %s/%s%d\n",
__func__, inet_ntoa(inm->inm_addr), inm->inm_ifp->if_name,
inm->inm_ifp->if_unit));
}
}
static int
igmp_v3_enqueue_group_record(struct ifqueue *ifq, struct in_multi *inm,
const int is_state_change, const int is_group_query,
const int is_source_query)
{
struct igmp_grouprec ig;
struct igmp_grouprec *pig;
struct ifnet *ifp;
struct ip_msource *ims, *nims;
struct mbuf *m0, *m, *md;
int error, is_filter_list_change;
int minrec0len, m0srcs, msrcs, nbytes, off;
int record_has_sources;
int now;
int type;
in_addr_t naddr;
uint8_t mode;
INM_LOCK_ASSERT_HELD(inm);
IGI_LOCK_ASSERT_HELD(inm->inm_igi);
error = 0;
ifp = inm->inm_ifp;
is_filter_list_change = 0;
m = NULL;
m0 = NULL;
m0srcs = 0;
msrcs = 0;
nbytes = 0;
nims = NULL;
record_has_sources = 1;
pig = NULL;
type = IGMP_DO_NOTHING;
mode = inm->inm_st[1].iss_fmode;
if (inm->inm_st[0].iss_asm > 0 && inm->inm_st[1].iss_asm > 0 &&
inm->inm_nsrc == 0)
record_has_sources = 0;
if (is_state_change) {
if (mode != inm->inm_st[0].iss_fmode) {
if (mode == MCAST_EXCLUDE) {
IGMP_PRINTF(("%s: change to EXCLUDE\n",
__func__));
type = IGMP_CHANGE_TO_EXCLUDE_MODE;
} else {
IGMP_PRINTF(("%s: change to INCLUDE\n",
__func__));
type = IGMP_CHANGE_TO_INCLUDE_MODE;
if (mode == MCAST_UNDEFINED)
record_has_sources = 0;
}
} else {
if (record_has_sources) {
is_filter_list_change = 1;
} else {
type = IGMP_DO_NOTHING;
}
}
} else {
if (mode == MCAST_EXCLUDE) {
type = IGMP_MODE_IS_EXCLUDE;
} else if (mode == MCAST_INCLUDE) {
type = IGMP_MODE_IS_INCLUDE;
VERIFY(inm->inm_st[1].iss_asm == 0);
}
}
if (is_filter_list_change)
return (igmp_v3_enqueue_filter_change(ifq, inm));
if (type == IGMP_DO_NOTHING) {
IGMP_PRINTF(("%s: nothing to do for %s/%s%d\n",
__func__, inet_ntoa(inm->inm_addr),
inm->inm_ifp->if_name, inm->inm_ifp->if_unit));
return (0);
}
minrec0len = sizeof(struct igmp_grouprec);
if (record_has_sources)
minrec0len += sizeof(in_addr_t);
IGMP_PRINTF(("%s: queueing %s for %s/%s%d\n", __func__,
igmp_rec_type_to_str(type), inet_ntoa(inm->inm_addr),
inm->inm_ifp->if_name, inm->inm_ifp->if_unit));
m0 = ifq->ifq_tail;
if (!is_group_query &&
m0 != NULL &&
(m0->m_pkthdr.vt_nrecs + 1 <= IGMP_V3_REPORT_MAXRECS) &&
(m0->m_pkthdr.len + minrec0len) <
(ifp->if_mtu - IGMP_LEADINGSPACE)) {
m0srcs = (ifp->if_mtu - m0->m_pkthdr.len -
sizeof(struct igmp_grouprec)) / sizeof(in_addr_t);
m = m0;
IGMP_PRINTF(("%s: use existing packet\n", __func__));
} else {
if (IF_QFULL(ifq)) {
IGMP_PRINTF(("%s: outbound queue full\n", __func__));
return (-ENOMEM);
}
m = NULL;
m0srcs = (ifp->if_mtu - IGMP_LEADINGSPACE -
sizeof(struct igmp_grouprec)) / sizeof(in_addr_t);
if (!is_state_change && !is_group_query) {
m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
if (m)
m->m_data += IGMP_LEADINGSPACE;
}
if (m == NULL) {
m = m_gethdr(M_DONTWAIT, MT_DATA);
if (m)
MH_ALIGN(m, IGMP_LEADINGSPACE);
}
if (m == NULL)
return (-ENOMEM);
IGMP_PRINTF(("%s: allocated first packet\n", __func__));
}
ig.ig_type = type;
ig.ig_datalen = 0;
ig.ig_numsrc = 0;
ig.ig_group = inm->inm_addr;
if (!m_append(m, sizeof(struct igmp_grouprec), (void *)&ig)) {
if (m != m0)
m_freem(m);
IGMP_PRINTF(("%s: m_append() failed.\n", __func__));
return (-ENOMEM);
}
nbytes += sizeof(struct igmp_grouprec);
if (record_has_sources) {
if (m == m0) {
md = m_last(m);
pig = (struct igmp_grouprec *)(mtod(md, uint8_t *) +
md->m_len - nbytes);
} else {
md = m_getptr(m, 0, &off);
pig = (struct igmp_grouprec *)(mtod(md, uint8_t *) +
off);
}
msrcs = 0;
RB_FOREACH_SAFE(ims, ip_msource_tree, &inm->inm_srcs, nims) {
IGMP_PRINTF(("%s: visit node %s\n", __func__,
inet_ntoa_haddr(ims->ims_haddr)));
now = ims_get_mode(inm, ims, 1);
IGMP_PRINTF(("%s: node is %d\n", __func__, now));
if ((now != mode) ||
(now == mode && mode == MCAST_UNDEFINED)) {
IGMP_PRINTF(("%s: skip node\n", __func__));
continue;
}
if (is_source_query && ims->ims_stp == 0) {
IGMP_PRINTF(("%s: skip unrecorded node\n",
__func__));
continue;
}
IGMP_PRINTF(("%s: append node\n", __func__));
naddr = htonl(ims->ims_haddr);
if (!m_append(m, sizeof(in_addr_t), (void *)&naddr)) {
if (m != m0)
m_freem(m);
IGMP_PRINTF(("%s: m_append() failed.\n",
__func__));
return (-ENOMEM);
}
nbytes += sizeof(in_addr_t);
++msrcs;
if (msrcs == m0srcs)
break;
}
IGMP_PRINTF(("%s: msrcs is %d this packet\n", __func__,
msrcs));
pig->ig_numsrc = htons(msrcs);
nbytes += (msrcs * sizeof(in_addr_t));
}
if (is_source_query && msrcs == 0) {
IGMP_PRINTF(("%s: no recorded sources to report\n", __func__));
if (m != m0)
m_freem(m);
return (0);
}
if (m != m0) {
IGMP_PRINTF(("%s: enqueueing first packet\n", __func__));
m->m_pkthdr.vt_nrecs = 1;
m->m_pkthdr.rcvif = ifp;
IF_ENQUEUE(ifq, m);
} else {
m->m_pkthdr.vt_nrecs++;
}
if (!record_has_sources)
return (nbytes);
while (nims != NULL) {
if (IF_QFULL(ifq)) {
IGMP_PRINTF(("%s: outbound queue full\n", __func__));
return (-ENOMEM);
}
m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
if (m)
m->m_data += IGMP_LEADINGSPACE;
if (m == NULL) {
m = m_gethdr(M_DONTWAIT, MT_DATA);
if (m)
MH_ALIGN(m, IGMP_LEADINGSPACE);
}
if (m == NULL)
return (-ENOMEM);
md = m_getptr(m, 0, &off);
pig = (struct igmp_grouprec *)(mtod(md, uint8_t *) + off);
IGMP_PRINTF(("%s: allocated next packet\n", __func__));
if (!m_append(m, sizeof(struct igmp_grouprec), (void *)&ig)) {
if (m != m0)
m_freem(m);
IGMP_PRINTF(("%s: m_append() failed.\n", __func__));
return (-ENOMEM);
}
m->m_pkthdr.vt_nrecs = 1;
nbytes += sizeof(struct igmp_grouprec);
m0srcs = (ifp->if_mtu - IGMP_LEADINGSPACE -
sizeof(struct igmp_grouprec)) / sizeof(in_addr_t);
msrcs = 0;
RB_FOREACH_FROM(ims, ip_msource_tree, nims) {
IGMP_PRINTF(("%s: visit node %s\n", __func__,
inet_ntoa_haddr(ims->ims_haddr)));
now = ims_get_mode(inm, ims, 1);
if ((now != mode) ||
(now == mode && mode == MCAST_UNDEFINED)) {
IGMP_PRINTF(("%s: skip node\n", __func__));
continue;
}
if (is_source_query && ims->ims_stp == 0) {
IGMP_PRINTF(("%s: skip unrecorded node\n",
__func__));
continue;
}
IGMP_PRINTF(("%s: append node\n", __func__));
naddr = htonl(ims->ims_haddr);
if (!m_append(m, sizeof(in_addr_t), (void *)&naddr)) {
if (m != m0)
m_freem(m);
IGMP_PRINTF(("%s: m_append() failed.\n",
__func__));
return (-ENOMEM);
}
++msrcs;
if (msrcs == m0srcs)
break;
}
pig->ig_numsrc = htons(msrcs);
nbytes += (msrcs * sizeof(in_addr_t));
IGMP_PRINTF(("%s: enqueueing next packet\n", __func__));
m->m_pkthdr.rcvif = ifp;
IF_ENQUEUE(ifq, m);
}
return (nbytes);
}
typedef enum {
REC_NONE = 0x00,
REC_ALLOW = 0x01,
REC_BLOCK = 0x02,
REC_FULL = REC_ALLOW | REC_BLOCK
} rectype_t;
static int
igmp_v3_enqueue_filter_change(struct ifqueue *ifq, struct in_multi *inm)
{
static const int MINRECLEN =
sizeof(struct igmp_grouprec) + sizeof(in_addr_t);
struct ifnet *ifp;
struct igmp_grouprec ig;
struct igmp_grouprec *pig;
struct ip_msource *ims, *nims;
struct mbuf *m, *m0, *md;
in_addr_t naddr;
int m0srcs, nbytes, npbytes, off, rsrcs, schanged;
int nallow, nblock;
uint8_t mode, now, then;
rectype_t crt, drt, nrt;
INM_LOCK_ASSERT_HELD(inm);
if (inm->inm_nsrc == 0 ||
(inm->inm_st[0].iss_asm > 0 && inm->inm_st[1].iss_asm > 0))
return (0);
ifp = inm->inm_ifp;
mode = inm->inm_st[1].iss_fmode;
crt = REC_NONE;
drt = REC_NONE;
nrt = REC_NONE;
m0srcs = 0;
nbytes = 0;
npbytes = 0;
rsrcs = 0;
schanged = 0;
nallow = 0;
nblock = 0;
nims = NULL;
while (drt != REC_FULL) {
do {
m0 = ifq->ifq_tail;
if (m0 != NULL &&
(m0->m_pkthdr.vt_nrecs + 1 <=
IGMP_V3_REPORT_MAXRECS) &&
(m0->m_pkthdr.len + MINRECLEN) <
(ifp->if_mtu - IGMP_LEADINGSPACE)) {
m = m0;
m0srcs = (ifp->if_mtu - m0->m_pkthdr.len -
sizeof(struct igmp_grouprec)) /
sizeof(in_addr_t);
IGMP_PRINTF(("%s: use previous packet\n",
__func__));
} else {
m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
if (m)
m->m_data += IGMP_LEADINGSPACE;
if (m == NULL) {
m = m_gethdr(M_DONTWAIT, MT_DATA);
if (m)
MH_ALIGN(m, IGMP_LEADINGSPACE);
}
if (m == NULL) {
IGMP_PRINTF(("%s: m_get*() failed\n",
__func__));
return (-ENOMEM);
}
m->m_pkthdr.vt_nrecs = 0;
m0srcs = (ifp->if_mtu - IGMP_LEADINGSPACE -
sizeof(struct igmp_grouprec)) /
sizeof(in_addr_t);
npbytes = 0;
IGMP_PRINTF(("%s: allocated new packet\n",
__func__));
}
memset(&ig, 0, sizeof(ig));
ig.ig_group = inm->inm_addr;
if (!m_append(m, sizeof(ig), (void *)&ig)) {
if (m != m0)
m_freem(m);
IGMP_PRINTF(("%s: m_append() failed\n",
__func__));
return (-ENOMEM);
}
npbytes += sizeof(struct igmp_grouprec);
if (m != m0) {
md = m_getptr(m, npbytes -
sizeof(struct igmp_grouprec), &off);
pig = (struct igmp_grouprec *)(mtod(md,
uint8_t *) + off);
} else {
md = m_last(m);
pig = (struct igmp_grouprec *)(mtod(md,
uint8_t *) + md->m_len -
sizeof(struct igmp_grouprec));
}
rsrcs = 0;
if (nims == NULL)
nims = RB_MIN(ip_msource_tree, &inm->inm_srcs);
RB_FOREACH_FROM(ims, ip_msource_tree, nims) {
IGMP_PRINTF(("%s: visit node %s\n",
__func__, inet_ntoa_haddr(ims->ims_haddr)));
now = ims_get_mode(inm, ims, 1);
then = ims_get_mode(inm, ims, 0);
IGMP_PRINTF(("%s: mode: t0 %d, t1 %d\n",
__func__, then, now));
if (now == then) {
IGMP_PRINTF(("%s: skip unchanged\n",
__func__));
continue;
}
if (mode == MCAST_EXCLUDE &&
now == MCAST_INCLUDE) {
IGMP_PRINTF(("%s: skip IN src on EX "
"group\n", __func__));
continue;
}
nrt = (rectype_t)now;
if (nrt == REC_NONE)
nrt = (rectype_t)(~mode & REC_FULL);
if (schanged++ == 0) {
crt = nrt;
} else if (crt != nrt)
continue;
naddr = htonl(ims->ims_haddr);
if (!m_append(m, sizeof(in_addr_t),
(void *)&naddr)) {
if (m != m0)
m_freem(m);
IGMP_PRINTF(("%s: m_append() failed\n",
__func__));
return (-ENOMEM);
}
nallow += !!(crt == REC_ALLOW);
nblock += !!(crt == REC_BLOCK);
if (++rsrcs == m0srcs)
break;
}
if (rsrcs == 0) {
npbytes -= sizeof(struct igmp_grouprec);
if (m != m0) {
IGMP_PRINTF(("%s: m_free(m)\n",
__func__));
m_freem(m);
} else {
IGMP_PRINTF(("%s: m_adj(m, -ig)\n",
__func__));
m_adj(m, -((int)sizeof(
struct igmp_grouprec)));
}
continue;
}
npbytes += (rsrcs * sizeof(in_addr_t));
if (crt == REC_ALLOW)
pig->ig_type = IGMP_ALLOW_NEW_SOURCES;
else if (crt == REC_BLOCK)
pig->ig_type = IGMP_BLOCK_OLD_SOURCES;
pig->ig_numsrc = htons(rsrcs);
m->m_pkthdr.vt_nrecs++;
m->m_pkthdr.rcvif = ifp;
if (m != m0)
IF_ENQUEUE(ifq, m);
nbytes += npbytes;
} while (nims != NULL);
drt |= crt;
crt = (~crt & REC_FULL);
}
IGMP_PRINTF(("%s: queued %d ALLOW_NEW, %d BLOCK_OLD\n", __func__,
nallow, nblock));
return (nbytes);
}
static int
igmp_v3_merge_state_changes(struct in_multi *inm, struct ifqueue *ifscq)
{
struct ifqueue *gq;
struct mbuf *m;
struct mbuf *m0;
struct mbuf *mt;
struct mbuf *n;
int docopy, domerge;
u_int recslen;
INM_LOCK_ASSERT_HELD(inm);
docopy = 0;
domerge = 0;
recslen = 0;
if (inm->inm_scrv > 0)
docopy = 1;
gq = &inm->inm_scq;
#ifdef IGMP_DEBUG
if (gq->ifq_head == NULL) {
IGMP_PRINTF(("%s: WARNING: queue for inm %p is empty\n",
__func__, inm));
}
#endif
m = gq->ifq_head;
while (m != NULL) {
domerge = 0;
mt = ifscq->ifq_tail;
if (mt != NULL) {
recslen = m_length(m);
if ((mt->m_pkthdr.vt_nrecs +
m->m_pkthdr.vt_nrecs <=
IGMP_V3_REPORT_MAXRECS) &&
(mt->m_pkthdr.len + recslen <=
(inm->inm_ifp->if_mtu - IGMP_LEADINGSPACE)))
domerge = 1;
}
if (!domerge && IF_QFULL(gq)) {
IGMP_PRINTF(("%s: outbound queue full, skipping whole "
"packet %p\n", __func__, m));
n = m->m_nextpkt;
if (!docopy) {
IF_REMQUEUE(gq, m);
m_freem(m);
}
m = n;
continue;
}
if (!docopy) {
IGMP_PRINTF(("%s: dequeueing %p\n", __func__, m));
n = m->m_nextpkt;
IF_REMQUEUE(gq, m);
m0 = m;
m = n;
} else {
IGMP_PRINTF(("%s: copying %p\n", __func__, m));
m0 = m_dup(m, M_NOWAIT);
if (m0 == NULL)
return (ENOMEM);
m0->m_nextpkt = NULL;
m = m->m_nextpkt;
}
if (!domerge) {
IGMP_PRINTF(("%s: queueing %p to ifscq %p)\n",
__func__, m0, ifscq));
m0->m_pkthdr.rcvif = inm->inm_ifp;
IF_ENQUEUE(ifscq, m0);
} else {
struct mbuf *mtl;
IGMP_PRINTF(("%s: merging %p with ifscq tail %p)\n",
__func__, m0, mt));
mtl = m_last(mt);
m0->m_flags &= ~M_PKTHDR;
mt->m_pkthdr.len += recslen;
mt->m_pkthdr.vt_nrecs +=
m0->m_pkthdr.vt_nrecs;
mtl->m_next = m0;
}
}
return (0);
}
static void
igmp_v3_dispatch_general_query(struct igmp_ifinfo *igi)
{
struct ifnet *ifp;
struct in_multi *inm;
struct in_multistep step;
int retval, loop;
IGI_LOCK_ASSERT_HELD(igi);
VERIFY(igi->igi_version == IGMP_VERSION_3);
ifp = igi->igi_ifp;
IGI_UNLOCK(igi);
in_multihead_lock_shared();
IN_FIRST_MULTI(step, inm);
while (inm != NULL) {
INM_LOCK(inm);
if (inm->inm_ifp != ifp)
goto next;
switch (inm->inm_state) {
case IGMP_NOT_MEMBER:
case IGMP_SILENT_MEMBER:
break;
case IGMP_REPORTING_MEMBER:
case IGMP_IDLE_MEMBER:
case IGMP_LAZY_MEMBER:
case IGMP_SLEEPING_MEMBER:
case IGMP_AWAKENING_MEMBER:
inm->inm_state = IGMP_REPORTING_MEMBER;
IGI_LOCK(igi);
retval = igmp_v3_enqueue_group_record(&igi->igi_gq,
inm, 0, 0, 0);
IGI_UNLOCK(igi);
IGMP_PRINTF(("%s: enqueue record = %d\n",
__func__, retval));
break;
case IGMP_G_QUERY_PENDING_MEMBER:
case IGMP_SG_QUERY_PENDING_MEMBER:
case IGMP_LEAVING_MEMBER:
break;
}
next:
INM_UNLOCK(inm);
IN_NEXT_MULTI(step, inm);
}
in_multihead_lock_done();
IGI_LOCK(igi);
loop = (igi->igi_flags & IGIF_LOOPBACK) ? 1 : 0;
igmp_dispatch_queue(igi, &igi->igi_gq, IGMP_MAX_RESPONSE_BURST,
loop, ifp);
IGI_LOCK_ASSERT_HELD(igi);
if (igi->igi_gq.ifq_head != NULL) {
igi->igi_v3_timer = 1 + IGMP_RANDOM_DELAY(
IGMP_RESPONSE_BURST_INTERVAL);
interface_timers_running = 1;
}
}
void
igmp_sendpkt(struct mbuf *m, struct ifnet *ifp)
{
struct ip_moptions *imo;
struct mbuf *ipopts, *m0;
int error;
struct route ro;
IGMP_PRINTF(("%s: transmit %p\n", __func__, m));
if (ifp == NULL || !ifnet_is_attached(ifp, 0)) {
IGMP_PRINTF(("%s: dropped %p as ifp u went away.\n",
__func__, m));
m_freem(m);
OSAddAtomic(1, &ipstat.ips_noroute);
return;
}
ipopts = igmp_sendra ? m_raopt : NULL;
imo = ip_allocmoptions(M_WAITOK);
if (imo == NULL) {
m_freem(m);
return;
}
imo->imo_multicast_ttl = 1;
imo->imo_multicast_vif = -1;
#if MROUTING
imo->imo_multicast_loop = (ip_mrouter != NULL);
#else
imo->imo_multicast_loop = 0;
#endif
if (m->m_flags & M_IGMP_LOOP)
imo->imo_multicast_ifp = lo_ifp;
else
imo->imo_multicast_ifp = ifp;
if (m->m_flags & M_IGMPV2) {
m0 = m;
} else {
m0 = igmp_v3_encap_report(ifp, m);
if (m0 == NULL) {
IGMP_PRINTF(("%s: dropped %p\n", __func__, m));
IMO_REMREF(imo);
atomic_add_32(&ipstat.ips_odropped, 1);
return;
}
}
m->m_flags &= ~(M_PROTOFLAGS | M_IGMP_LOOP);
m0->m_pkthdr.rcvif = lo_ifp;
#ifdef MAC
mac_netinet_igmp_send(ifp, m0);
#endif
bzero(&ro, sizeof (ro));
error = ip_output(m0, ipopts, &ro, 0, imo, NULL);
if (ro.ro_rt != NULL) {
rtfree(ro.ro_rt);
ro.ro_rt = NULL;
}
IMO_REMREF(imo);
if (error) {
IGMP_PRINTF(("%s: ip_output(%p) = %d\n", __func__, m0, error));
return;
}
IGMPSTAT_INC(igps_snd_reports);
OIGMPSTAT_INC(igps_snd_reports);
}
static struct mbuf *
igmp_v3_encap_report(struct ifnet *ifp, struct mbuf *m)
{
struct igmp_report *igmp;
struct ip *ip;
int hdrlen, igmpreclen;
VERIFY((m->m_flags & M_PKTHDR));
igmpreclen = m_length(m);
hdrlen = sizeof(struct ip) + sizeof(struct igmp_report);
if (m->m_flags & M_IGMPV3_HDR) {
igmpreclen -= hdrlen;
} else {
M_PREPEND(m, hdrlen, M_DONTWAIT);
if (m == NULL)
return (NULL);
m->m_flags |= M_IGMPV3_HDR;
}
IGMP_PRINTF(("%s: igmpreclen is %d\n", __func__, igmpreclen));
m->m_data += sizeof(struct ip);
m->m_len -= sizeof(struct ip);
igmp = mtod(m, struct igmp_report *);
igmp->ir_type = IGMP_v3_HOST_MEMBERSHIP_REPORT;
igmp->ir_rsv1 = 0;
igmp->ir_rsv2 = 0;
igmp->ir_numgrps = htons(m->m_pkthdr.vt_nrecs);
igmp->ir_cksum = 0;
igmp->ir_cksum = in_cksum(m, sizeof(struct igmp_report) + igmpreclen);
m->m_pkthdr.vt_nrecs = 0;
m->m_data -= sizeof(struct ip);
m->m_len += sizeof(struct ip);
ip = mtod(m, struct ip *);
ip->ip_tos = IPTOS_PREC_INTERNETCONTROL;
ip->ip_len = hdrlen + igmpreclen;
ip->ip_off = IP_DF;
ip->ip_p = IPPROTO_IGMP;
ip->ip_sum = 0;
ip->ip_src.s_addr = INADDR_ANY;
if (m->m_flags & M_IGMP_LOOP) {
struct in_ifaddr *ia;
IFP_TO_IA(ifp, ia);
if (ia != NULL) {
IFA_LOCK(&ia->ia_ifa);
ip->ip_src = ia->ia_addr.sin_addr;
IFA_UNLOCK(&ia->ia_ifa);
IFA_REMREF(&ia->ia_ifa);
}
}
ip->ip_dst.s_addr = htonl(INADDR_ALLRPTS_GROUP);
return (m);
}
#ifdef IGMP_DEBUG
static const char *
igmp_rec_type_to_str(const int type)
{
switch (type) {
case IGMP_CHANGE_TO_EXCLUDE_MODE:
return "TO_EX";
break;
case IGMP_CHANGE_TO_INCLUDE_MODE:
return "TO_IN";
break;
case IGMP_MODE_IS_EXCLUDE:
return "MODE_EX";
break;
case IGMP_MODE_IS_INCLUDE:
return "MODE_IN";
break;
case IGMP_ALLOW_NEW_SOURCES:
return "ALLOW_NEW";
break;
case IGMP_BLOCK_OLD_SOURCES:
return "BLOCK_OLD";
break;
default:
break;
}
return "unknown";
}
#endif
void
igmp_init(void)
{
IGMP_PRINTF(("%s: initializing\n", __func__));
igmp_timers_are_running = 0;
igmp_mtx_grp_attr = lck_grp_attr_alloc_init();
igmp_mtx_grp = lck_grp_alloc_init("igmp_mtx", igmp_mtx_grp_attr);
igmp_mtx_attr = lck_attr_alloc_init();
lck_mtx_init(&igmp_mtx, igmp_mtx_grp, igmp_mtx_attr);
LIST_INIT(&igi_head);
m_raopt = igmp_ra_alloc();
igi_size = sizeof (struct igmp_ifinfo);
igi_zone = zinit(igi_size, IGI_ZONE_MAX * igi_size,
0, IGI_ZONE_NAME);
if (igi_zone == NULL) {
panic("%s: failed allocating %s", __func__, IGI_ZONE_NAME);
}
zone_change(igi_zone, Z_EXPAND, TRUE);
zone_change(igi_zone, Z_CALLERACCT, FALSE);
}