src/sys/netinet6/mld6.c - diff

Return to mld6.c CVS log

Up to [cvs.NetBSD.org] / src / sys / netinet6

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/netinet6/mld6.c between version 1.67 and 1.91

version 1.67, 2016/06/16 03:03:33

version 1.91, 2018/02/01 07:49:19

Line 106 __KERNEL_RCSID(0, "$NetBSD$");

#ifdef _KERNEL_OPT

#include "opt_inet.h"

#include "opt_net_mpsafe.h"

#endif

#include <sys/param.h>

Line 113 __KERNEL_RCSID(0, "$NetBSD$");

Line 114 __KERNEL_RCSID(0, "$NetBSD$");

#include <sys/mbuf.h>

#include <sys/socket.h>

#include <sys/socketvar.h>

#include <sys/protosw.h>

#include <sys/syslog.h>

#include <sys/sysctl.h>

#include <sys/kernel.h>

#include <sys/callout.h>

#include <sys/cprng.h>

#include <sys/rwlock.h>

#include <net/if.h>

Line 135 __KERNEL_RCSID(0, "$NetBSD$");

Line 136 __KERNEL_RCSID(0, "$NetBSD$");

#include <net/net_osdep.h>

static krwlock_t in6_multilock __cacheline_aligned;

* This structure is used to keep track of in6_multi chains which belong to

* deleted interface addresses.

static LIST_HEAD(, multi6_kludge) in6_mk = LIST_HEAD_INITIALIZER(in6_mk);

struct multi6_kludge {

LIST_ENTRY(multi6_kludge) mk_entry;

struct ifnet *mk_ifp;

struct in6_multihead mk_head;

};

* Protocol constants

Line 163 static struct ip6_pktopts ip6_opts;

Line 153 static struct ip6_pktopts ip6_opts;

static void mld_start_listening(struct in6_multi *);

static void mld_stop_listening(struct in6_multi *);

static struct mld_hdr * mld_allocbuf(struct mbuf **, int, struct in6_multi *,

static struct mld_hdr *mld_allocbuf(struct mbuf **, struct in6_multi *, int);

int);

static void mld_sendpkt(struct in6_multi *, int, const struct in6_addr *);

static void mld_starttimer(struct in6_multi *);

static void mld_stoptimer(struct in6_multi *);

static u_long mld_timerresid(struct in6_multi *);

static void in6m_ref(struct in6_multi *);

static void in6m_unref(struct in6_multi *);

static void in6m_destroy(struct in6_multi *);

void

mld_init(void)

{

Line 191 mld_init(void)

Line 184 mld_init(void)

/* We will specify the hoplimit by a multicast option. */

ip6_opts.ip6po_hlim = -1;

ip6_opts.ip6po_prefer_tempaddr = IP6PO_TEMPADDR_NOTPREFER;

rw_init(&in6_multilock);

}

static void

Line 198 mld_starttimer(struct in6_multi *in6m)

Line 193 mld_starttimer(struct in6_multi *in6m)

{

struct timeval now;

KASSERT(rw_write_held(&in6_multilock));

KASSERT(in6m->in6m_timer != IN6M_TIMER_UNDEF);

microtime(&now);

Line 213 mld_starttimer(struct in6_multi *in6m)

Line 209 mld_starttimer(struct in6_multi *in6m)

callout_schedule(&in6m->in6m_timer_ch, in6m->in6m_timer);

}

* mld_stoptimer releases in6_multilock when calling callout_halt.

* The caller must ensure in6m won't be freed while releasing the lock.

static void

mld_stoptimer(struct in6_multi *in6m)

{

KASSERT(rw_write_held(&in6_multilock));

if (in6m->in6m_timer == IN6M_TIMER_UNDEF)

return;

callout_stop(&in6m->in6m_timer_ch);

rw_exit(&in6_multilock);

if (mutex_owned(softnet_lock))

callout_halt(&in6m->in6m_timer_ch, softnet_lock);

else

callout_halt(&in6m->in6m_timer_ch, NULL);

rw_enter(&in6_multilock, RW_WRITER);

in6m->in6m_timer = IN6M_TIMER_UNDEF;

}

Line 229 mld_timeo(void *arg)

Line 239 mld_timeo(void *arg)

{

struct in6_multi *in6m = arg;

mutex_enter(softnet_lock);

KASSERT(in6m->in6m_refcount > 0);

KERNEL_LOCK(1, NULL);

SOFTNET_KERNEL_LOCK_UNLESS_NET_MPSAFE();

rw_enter(&in6_multilock, RW_WRITER);

if (in6m->in6m_timer == IN6M_TIMER_UNDEF)

goto out;

Line 247 mld_timeo(void *arg)

Line 258 mld_timeo(void *arg)

}

out:

KERNEL_UNLOCK_ONE(NULL);

rw_exit(&in6_multilock);

mutex_exit(softnet_lock);

SOFTNET_KERNEL_UNLOCK_UNLESS_NET_MPSAFE();

}

static u_long

Line 280 mld_start_listening(struct in6_multi *in

Line 291 mld_start_listening(struct in6_multi *in

{

struct in6_addr all_in6;

KASSERT(rw_write_held(&in6_multilock));

* RFC2710 page 10:

* The node never sends a Report or Done for the link-scope all-nodes

Line 312 mld_stop_listening(struct in6_multi *in6

Line 325 mld_stop_listening(struct in6_multi *in6

{

struct in6_addr allnode, allrouter;

KASSERT(rw_lock_held(&in6_multilock));

allnode = in6addr_linklocal_allnodes;

if (in6_setscope(&allnode, in6m->in6m_ifp, NULL)) {

/* XXX: this should not happen! */

Line 339 mld_input(struct mbuf *m, int off)

Line 354 mld_input(struct mbuf *m, int off)

struct ifnet *ifp;

struct in6_multi *in6m = NULL;

struct in6_addr mld_addr, all_in6;

struct in6_ifaddr *ia;

u_long timer = 0; /* timer value in the MLD query header */

int s;

struct psref psref;

ifp = m_get_rcvif(m, &s);

ifp = m_get_rcvif_psref(m, &psref);

if (__predict_false(ifp == NULL))

goto out;

IP6_EXTHDR_GET(mldh, struct mld_hdr *, m, off, sizeof(*mldh));

if (mldh == NULL) {

ICMP6_STATINC(ICMP6_STAT_TOOSHORT);

goto out_nodrop;

}

ip6 = mtod(m, struct ip6_hdr *);

/* source address validation */

ip6 = mtod(m, struct ip6_hdr *);/* in case mpullup */

if (!IN6_IS_ADDR_LINKLOCAL(&ip6->ip6_src)) {

* RFC3590 allows the IPv6 unspecified address as the source

Line 373 mld_input(struct mbuf *m, int off)

Line 390 mld_input(struct mbuf *m, int off)

* though RFC3590 says "SHOULD log" if the source of a query

* is the unspecified address.

char ip6bufs[INET6_ADDRSTRLEN];

char ip6bufm[INET6_ADDRSTRLEN];

log(LOG_INFO,

"mld_input: src %s is not link-local (grp=%s)\n",

ip6_sprintf(&ip6->ip6_src), ip6_sprintf(&mldh->mld_addr));

IN6_PRINT(ip6bufs,&ip6->ip6_src),

IN6_PRINT(ip6bufm, &mldh->mld_addr));

#endif

goto out;

}

Line 394 mld_input(struct mbuf *m, int off)

Line 414 mld_input(struct mbuf *m, int off)

* In Non-Listener state, we simply don't have a membership record.

* In Delaying Listener state, our timer is running (in6m->in6m_timer)

* In Idle Listener state, our timer is not running

* (in6m->in6m_timer==IN6M_TIMER_UNDEF)

* The flag is in6m->in6m_state, it is set to MLD_OTHERLISTENER if

Line 402 mld_input(struct mbuf *m, int off)

Line 422 mld_input(struct mbuf *m, int off)

* if we sent the last report.

switch (mldh->mld_type) {

case MLD_LISTENER_QUERY:

case MLD_LISTENER_QUERY: {

struct in6_multi *next;

if (ifp->if_flags & IFF_LOOPBACK)

break;

Line 428 mld_input(struct mbuf *m, int off)

Line 450 mld_input(struct mbuf *m, int off)

timer = ntohs(mldh->mld_maxdelay);

IFP_TO_IA6(ifp, ia);

rw_enter(&in6_multilock, RW_WRITER);

if (ia == NULL)

break;

* mld_stoptimer and mld_sendpkt release in6_multilock

* temporarily, so we have to prevent in6m from being freed

LIST_FOREACH(in6m, &ia->ia6_multiaddrs, in6m_entry) {

* while releasing the lock by having an extra reference to it.

* Also in6_purge_multi might remove items from the list of the

* ifp while releasing the lock. Fortunately in6_purge_multi is

* never executed as long as we have a psref of the ifp.

LIST_FOREACH_SAFE(in6m, &ifp->if_multiaddrs, in6m_entry, next) {

if (IN6_ARE_ADDR_EQUAL(&in6m->in6m_addr, &all_in6) ||

IPV6_ADDR_MC_SCOPE(&in6m->in6m_addr) <

IPV6_ADDR_SCOPE_LINKLOCAL)

Line 446 mld_input(struct mbuf *m, int off)

Line 474 mld_input(struct mbuf *m, int off)

continue;

if (timer == 0) {

in6m_ref(in6m);

/* send a report immediately */

mld_stoptimer(in6m);

mld_sendpkt(in6m, MLD_LISTENER_REPORT, NULL);

in6m->in6m_state = MLD_IREPORTEDLAST;

in6m_unref(in6m); /* May free in6m */

} else if (in6m->in6m_timer == IN6M_TIMER_UNDEF ||

mld_timerresid(in6m) > timer) {

in6m->in6m_timer =

Line 457 mld_input(struct mbuf *m, int off)

Line 489 mld_input(struct mbuf *m, int off)

mld_starttimer(in6m);

}

rw_exit(&in6_multilock);

break;

}

case MLD_LISTENER_REPORT:

Line 479 mld_input(struct mbuf *m, int off)

Line 513 mld_input(struct mbuf *m, int off)

* If we belong to the group being reported, stop

* our timer for that group.

IN6_LOOKUP_MULTI(mld_addr, ifp, in6m);

rw_enter(&in6_multilock, RW_WRITER);

in6m = in6_lookup_multi(&mld_addr, ifp);

if (in6m) {

in6m_ref(in6m);

mld_stoptimer(in6m); /* transit to idle state */

in6m->in6m_state = MLD_OTHERLISTENER; /* clear flag */

in6m_unref(in6m);

in6m = NULL; /* in6m might be freed */

}

rw_exit(&in6_multilock);

break;

default: /* this is impossible */

#if 0

Line 500 mld_input(struct mbuf *m, int off)

Line 539 mld_input(struct mbuf *m, int off)

out:

m_freem(m);

out_nodrop:

m_put_rcvif(ifp, &s);

m_put_rcvif_psref(ifp, &psref);

}

* XXX mld_sendpkt must be called with in6_multilock held and

* will release in6_multilock before calling ip6_output and

* returning to avoid locking against myself in ip6_output.

static void

mld_sendpkt(struct in6_multi *in6m, int type,

mld_sendpkt(struct in6_multi *in6m, int type, const struct in6_addr *dst)

const struct in6_addr *dst)

{

struct mbuf *mh;

struct mld_hdr *mldh;

Line 514 mld_sendpkt(struct in6_multi *in6m, int

Line 557 mld_sendpkt(struct in6_multi *in6m, int

struct in6_ifaddr *ia = NULL;

struct ifnet *ifp = in6m->in6m_ifp;

int ignflags;

struct psref psref;

int bound;

KASSERT(rw_write_held(&in6_multilock));

* At first, find a link local address on the outgoing interface

Line 522 mld_sendpkt(struct in6_multi *in6m, int

Line 569 mld_sendpkt(struct in6_multi *in6m, int

* the case where we first join a link-local address.

ignflags = (IN6_IFF_NOTREADY|IN6_IFF_ANYCAST) & ~IN6_IFF_TENTATIVE;

if ((ia = in6ifa_ifpforlinklocal(ifp, ignflags)) == NULL)

bound = curlwp_bind();

ia = in6ifa_ifpforlinklocal_psref(ifp, ignflags, &psref);

if (ia == NULL) {

curlwp_bindx(bound);

return;

if ((ia->ia6_flags & IN6_IFF_TENTATIVE))

}

if ((ia->ia6_flags & IN6_IFF_TENTATIVE)) {

ia6_release(ia, &psref);

ia = NULL;

}

/* Allocate two mbufs to store IPv6 header and MLD header */

mldh = mld_allocbuf(&mh, sizeof(struct mld_hdr), in6m, type);

mldh = mld_allocbuf(&mh, in6m, type);

if (mldh == NULL)

if (mldh == NULL) {

ia6_release(ia, &psref);

curlwp_bindx(bound);

return;

}

/* fill src/dst here */

ip6 = mtod(mh, struct ip6_hdr *);

ip6->ip6_src = ia ? ia->ia_addr.sin6_addr : in6addr_any;

ip6->ip6_dst = dst ? *dst : in6m->in6m_addr;

ia6_release(ia, &psref);

curlwp_bindx(bound);

mldh->mld_addr = in6m->in6m_addr;

in6_clearscope(&mldh->mld_addr); /* XXX */

Line 544 mld_sendpkt(struct in6_multi *in6m, int

Line 602 mld_sendpkt(struct in6_multi *in6m, int

/* construct multicast option */

memset(&im6o, 0, sizeof(im6o));

im6o.im6o_multicast_ifp = ifp;

im6o.im6o_multicast_if_index = if_get_index(ifp);

im6o.im6o_multicast_hlim = 1;

Line 553 mld_sendpkt(struct in6_multi *in6m, int

Line 611 mld_sendpkt(struct in6_multi *in6m, int

im6o.im6o_multicast_loop = (ip6_mrouter != NULL);

/* increment output statictics */

/* increment output statistics */

ICMP6_STATINC(ICMP6_STAT_OUTHIST + type);

icmp6_ifstat_inc(ifp, ifs6_out_msg);

switch (type) {

Line 568 mld_sendpkt(struct in6_multi *in6m, int

Line 626 mld_sendpkt(struct in6_multi *in6m, int

break;

}

/* XXX we cannot call ip6_output with holding in6_multilock */

rw_exit(&in6_multilock);

ip6_output(mh, &ip6_opts, NULL, ia ? 0 : IPV6_UNSPECSRC,

&im6o, NULL, NULL);

rw_enter(&in6_multilock, RW_WRITER);

}

static struct mld_hdr *

mld_allocbuf(struct mbuf **mh, int len, struct in6_multi *in6m,

mld_allocbuf(struct mbuf **mh, struct in6_multi *in6m, int type)

int type)

{

struct mbuf *md;

struct mld_hdr *mldh;

Line 598 mld_allocbuf(struct mbuf **mh, int len,

Line 660 mld_allocbuf(struct mbuf **mh, int len,

md->m_next = NULL;

m_reset_rcvif((*mh));

(*mh)->m_pkthdr.len = sizeof(struct ip6_hdr) + len;

(*mh)->m_pkthdr.len = sizeof(struct ip6_hdr) + sizeof(struct mld_hdr);

(*mh)->m_len = sizeof(struct ip6_hdr);

MH_ALIGN(*mh, sizeof(struct ip6_hdr));

Line 614 mld_allocbuf(struct mbuf **mh, int len,

Line 676 mld_allocbuf(struct mbuf **mh, int len,

/* ip6_src/dst will be set by mld_sendpkt() or mld_sendbuf() */

/* fill in the MLD header as much as possible */

md->m_len = len;

md->m_len = sizeof(struct mld_hdr);

mldh = mtod(md, struct mld_hdr *);

memset(mldh, 0, len);

memset(mldh, 0, sizeof(struct mld_hdr));

mldh->mld_type = type;

return mldh;

}

static void

in6m_ref(struct in6_multi *in6m)

{

KASSERT(rw_write_held(&in6_multilock));

in6m->in6m_refcount++;

}

static void

in6m_unref(struct in6_multi *in6m)

{

KASSERT(rw_write_held(&in6_multilock));

if (--in6m->in6m_refcount == 0)

in6m_destroy(in6m);

}

* Add an address to the list of IP6 multicast addresses for a given interface.

struct in6_multi *

in6_addmulti(struct in6_addr *maddr6, struct ifnet *ifp,

in6_addmulti(struct in6_addr *maddr6, struct ifnet *ifp, int *errorp,

int *errorp, int timer)

int timer)

{

struct in6_ifaddr *ia;

struct sockaddr_in6 sin6;

struct in6_multi *in6m;

int s = splsoftnet();

*errorp = 0;

rw_enter(&in6_multilock, RW_WRITER);

* See if address already in list.

IN6_LOOKUP_MULTI(*maddr6, ifp, in6m);

in6m = in6_lookup_multi(maddr6, ifp);

if (in6m != NULL) {

* Found it; just increment the refrence count.

* Found it; just increment the reference count.

in6m->in6m_refcount++;

} else {

Line 649 in6_addmulti(struct in6_addr *maddr6, st

Line 727 in6_addmulti(struct in6_addr *maddr6, st

* New address; allocate a new multicast record

* and link it into the interface's multicast list.

in6m = (struct in6_multi *)

in6m = malloc(sizeof(*in6m), M_IPMADDR, M_NOWAIT|M_ZERO);

malloc(sizeof(*in6m), M_IPMADDR, M_NOWAIT|M_ZERO);

if (in6m == NULL) {

splx(s);

*errorp = ENOBUFS;

return (NULL);

goto out;

}

in6m->in6m_addr = *maddr6;

Line 664 in6_addmulti(struct in6_addr *maddr6, st

Line 740 in6_addmulti(struct in6_addr *maddr6, st

callout_init(&in6m->in6m_timer_ch, CALLOUT_MPSAFE);

callout_setfunc(&in6m->in6m_timer_ch, mld_timeo, in6m);

IFP_TO_IA6(ifp, ia);

LIST_INSERT_HEAD(&ifp->if_multiaddrs, in6m, in6m_entry);

if (ia == NULL) {

callout_destroy(&in6m->in6m_timer_ch);

free(in6m, M_IPMADDR);

splx(s);

*errorp = EADDRNOTAVAIL; /* appropriate? */

return (NULL);

}

in6m->in6m_ia = ia;

ifaref(&ia->ia_ifa); /* gain a reference */

LIST_INSERT_HEAD(&ia->ia6_multiaddrs, in6m, in6m_entry);

* Ask the network driver to update its multicast reception

Line 686 in6_addmulti(struct in6_addr *maddr6, st

Line 752 in6_addmulti(struct in6_addr *maddr6, st

callout_destroy(&in6m->in6m_timer_ch);

LIST_REMOVE(in6m, in6m_entry);

free(in6m, M_IPMADDR);

ifafree(&ia->ia_ifa);

in6m = NULL;

splx(s);

goto out;

return (NULL);

}

in6m->in6m_timer = timer;

if (in6m->in6m_timer > 0) {

in6m->in6m_state = MLD_REPORTPENDING;

mld_starttimer(in6m);

goto out;

splx(s);

return (in6m);

}

Line 706 in6_addmulti(struct in6_addr *maddr6, st

Line 769 in6_addmulti(struct in6_addr *maddr6, st

mld_start_listening(in6m);

}

splx(s);

out:

return (in6m);

rw_exit(&in6_multilock);

return in6m;

}

static void

* Delete a multicast address record.

in6m_destroy(struct in6_multi *in6m)

void

in6_delmulti(struct in6_multi *in6m)

{

struct sockaddr_in6 sin6;

struct in6_ifaddr *ia;

int s = splsoftnet();

mld_stoptimer(in6m);

KASSERT(rw_write_held(&in6_multilock));

KASSERT(in6m->in6m_refcount == 0);

if (--in6m->in6m_refcount == 0) {

* No remaining claims to this record; let MLD6 know

* that we are leaving the multicast group.

mld_stop_listening(in6m);

* Unlink from list.

LIST_REMOVE(in6m, in6m_entry);

if (in6m->in6m_ia != NULL) {

ifafree(&in6m->in6m_ia->ia_ifa); /* release reference */

in6m->in6m_ia = NULL;

}

* Delete all references of this multicasting group from

* the membership arrays

for (ia = in6_ifaddr; ia; ia = ia->ia_next) {

in6_purge_mcast_references(in6m);

struct in6_multi_mship *imm;

LIST_FOREACH(imm, &ia->ia6_memberships, i6mm_chain) {

if (imm->i6mm_maddr == in6m)

imm->i6mm_maddr = NULL;

}

* Notify the network driver to update its multicast

* reception filter.

sockaddr_in6_init(&sin6, &in6m->in6m_addr, 0, 0, 0);

if_mcast_op(in6m->in6m_ifp, SIOCDELMULTI, sin6tosa(&sin6));

/* Tell mld_timeo we're halting the timer */

in6m->in6m_timer = IN6M_TIMER_UNDEF;

if (mutex_owned(softnet_lock))

callout_halt(&in6m->in6m_timer_ch, softnet_lock);

callout_destroy(&in6m->in6m_timer_ch);

else

callout_halt(&in6m->in6m_timer_ch, NULL);

callout_destroy(&in6m->in6m_timer_ch);

free(in6m, M_IPMADDR);

}

splx(s);

}

struct in6_multi_mship *

* Delete a multicast address record.

in6_joingroup(struct ifnet *ifp, struct in6_addr *addr,

int *errorp, int timer)

void

in6_delmulti(struct in6_multi *in6m)

{

struct in6_multi_mship *imm;

imm = malloc(sizeof(*imm), M_IPMADDR, M_NOWAIT|M_ZERO);

KASSERT(in6m->in6m_refcount > 0);

if (imm == NULL) {

*errorp = ENOBUFS;

return NULL;

}

imm->i6mm_maddr = in6_addmulti(addr, ifp, errorp, timer);

rw_enter(&in6_multilock, RW_WRITER);

if (!imm->i6mm_maddr) {

/* *errorp is already set */

* The caller should have a reference to in6m. So we don't need to care

free(imm, M_IPMADDR);

* of releasing the lock in mld_stoptimer.

return NULL;

}

mld_stoptimer(in6m);

return imm;

if (--in6m->in6m_refcount == 0)

in6m_destroy(in6m);

rw_exit(&in6_multilock);

}

int

in6_leavegroup(struct in6_multi_mship *imm)

* Look up the in6_multi record for a given IP6 multicast address

* on a given interface. If no matching record is found, "in6m"

* returns NULL.

struct in6_multi *

in6_lookup_multi(const struct in6_addr *addr, const struct ifnet *ifp)

{

struct in6_multi *in6m;

if (imm->i6mm_maddr) {

KASSERT(rw_lock_held(&in6_multilock));

in6_delmulti(imm->i6mm_maddr);

LIST_FOREACH(in6m, &ifp->if_multiaddrs, in6m_entry) {

if (IN6_ARE_ADDR_EQUAL(&in6m->in6m_addr, addr))

break;

}

free(imm, M_IPMADDR);

return in6m;

return 0;

}

bool

in6_multi_group(const struct in6_addr *addr, const struct ifnet *ifp)

* Multicast address kludge:

* If there were any multicast addresses attached to this interface address,

* either move them to another address on this interface, or save them until

* such time as this interface is reconfigured for IPv6.

void

in6_savemkludge(struct in6_ifaddr *oia)

{

struct in6_ifaddr *ia;

bool ingroup;

struct in6_multi *in6m;

IFP_TO_IA6(oia->ia_ifp, ia);

rw_enter(&in6_multilock, RW_READER);

if (ia) { /* there is another address */

ingroup = in6_lookup_multi(addr, ifp) != NULL;

KASSERT(ia != oia);

rw_exit(&in6_multilock);

while ((in6m = LIST_FIRST(&oia->ia6_multiaddrs)) != NULL) {

LIST_REMOVE(in6m, in6m_entry);

ifaref(&ia->ia_ifa);

ifafree(&in6m->in6m_ia->ia_ifa);

in6m->in6m_ia = ia;

LIST_INSERT_HEAD(&ia->ia6_multiaddrs, in6m, in6m_entry);

}

} else { /* last address on this if deleted, save */

struct multi6_kludge *mk;

LIST_FOREACH(mk, &in6_mk, mk_entry) {

return ingroup;

if (mk->mk_ifp == oia->ia_ifp)

break;

}

if (mk == NULL) /* this should not happen! */

panic("in6_savemkludge: no kludge space");

while ((in6m = LIST_FIRST(&oia->ia6_multiaddrs)) != NULL) {

LIST_REMOVE(in6m, in6m_entry);

ifafree(&in6m->in6m_ia->ia_ifa); /* release reference */

in6m->in6m_ia = NULL;

LIST_INSERT_HEAD(&mk->mk_head, in6m, in6m_entry);

}

* Continuation of multicast address hack:

* Purge in6_multi records associated to the interface.

* If there was a multicast group list previously saved for this interface,

* then we re-attach it to the first address configured on the i/f.

void

in6_restoremkludge(struct in6_ifaddr *ia, struct ifnet *ifp)

in6_purge_multi(struct ifnet *ifp)

{

struct multi6_kludge *mk;

struct in6_multi *in6m, *next;

struct in6_multi *in6m;

LIST_FOREACH(mk, &in6_mk, mk_entry) {

rw_enter(&in6_multilock, RW_WRITER);

if (mk->mk_ifp == ifp)

LIST_FOREACH_SAFE(in6m, &ifp->if_multiaddrs, in6m_entry, next) {

break;

}

* Normally multicast addresses are already purged at this

if (mk == NULL)

* point. Remaining references aren't accessible via ifp,

return;

* so what we can do here is to prevent ifp from being

while ((in6m = LIST_FIRST(&mk->mk_head)) != NULL) {

* accessed via in6m by removing it from the list of ifp.

mld_stoptimer(in6m);

LIST_REMOVE(in6m, in6m_entry);

in6m->in6m_ia = ia;

ifaref(&ia->ia_ifa);

LIST_INSERT_HEAD(&ia->ia6_multiaddrs, in6m, in6m_entry);

}

rw_exit(&in6_multilock);

}

* Allocate space for the kludge at interface initialization time.

* Formerly, we dynamically allocated the space in in6_savemkludge() with

* malloc(M_WAITOK). However, it was wrong since the function could be called

* under an interrupt context (software timer on address lifetime expiration).

* Also, we cannot just give up allocating the strucutre, since the group

* membership structure is very complex and we need to keep it anyway.

* Of course, this function MUST NOT be called under an interrupt context.

* Specifically, it is expected to be called only from in6_ifattach(), though

* it is a global function.

void

in6_createmkludge(struct ifnet *ifp)

in6_multi_lock(int op)

{

struct multi6_kludge *mk;

LIST_FOREACH(mk, &in6_mk, mk_entry) {

rw_enter(&in6_multilock, op);

/* If we've already had one, do not allocate. */

}

if (mk->mk_ifp == ifp)

return;

}

mk = malloc(sizeof(*mk), M_IPMADDR, M_ZERO|M_WAITOK);

void

in6_multi_unlock(void)

{

LIST_INIT(&mk->mk_head);

rw_exit(&in6_multilock);

mk->mk_ifp = ifp;

LIST_INSERT_HEAD(&in6_mk, mk, mk_entry);

}

void

bool

in6_purgemkludge(struct ifnet *ifp)

in6_multi_locked(int op)

{

struct multi6_kludge *mk;

struct in6_multi *in6m, *next;

LIST_FOREACH(mk, &in6_mk, mk_entry) {

switch (op) {

if (mk->mk_ifp == ifp)

case RW_READER:

break;

return rw_read_held(&in6_multilock);

case RW_WRITER:

return rw_write_held(&in6_multilock);

default:

return rw_lock_held(&in6_multilock);

}

if (mk == NULL)

}

return;

struct in6_multi_mship *

in6_joingroup(struct ifnet *ifp, struct in6_addr *addr, int *errorp, int timer)

{

struct in6_multi_mship *imm;

imm = malloc(sizeof(*imm), M_IPMADDR, M_NOWAIT|M_ZERO);

if (imm == NULL) {

*errorp = ENOBUFS;

return NULL;

}

imm->i6mm_maddr = in6_addmulti(addr, ifp, errorp, timer);

if (!imm->i6mm_maddr) {

/* *errorp is already set */

free(imm, M_IPMADDR);

return NULL;

}

return imm;

}

int

in6_leavegroup(struct in6_multi_mship *imm)

{

struct in6_multi *in6m;

/* leave from all multicast groups joined */

rw_enter(&in6_multilock, RW_READER);

for (in6m = LIST_FIRST(&mk->mk_head); in6m != NULL; in6m = next) {

in6m = imm->i6mm_maddr;

next = LIST_NEXT(in6m, in6m_entry);

rw_exit(&in6_multilock);

if (in6m != NULL) {

in6_delmulti(in6m);

}

LIST_REMOVE(mk, mk_entry);

free(imm, M_IPMADDR);

free(mk, M_IPMADDR);

return 0;

}

* DEPRECATED: keep it just to avoid breaking old sysctl users.

static int

in6_mkludge_sysctl(SYSCTLFN_ARGS)

{

struct multi6_kludge *mk;

struct in6_multi *in6m;

int error;

uint32_t tmp;

size_t written;

if (namelen != 1)

return EINVAL;

*oldlenp = 0;

if (oldp == NULL) {

return 0;

*oldlenp = 0;

LIST_FOREACH(mk, &in6_mk, mk_entry) {

if (mk->mk_ifp->if_index == name[0])

continue;

LIST_FOREACH(in6m, &mk->mk_head, in6m_entry) {

*oldlenp += sizeof(struct in6_addr) +

sizeof(uint32_t);

}

return 0;

}

error = 0;

written = 0;

LIST_FOREACH(mk, &in6_mk, mk_entry) {

if (mk->mk_ifp->if_index == name[0])

continue;

LIST_FOREACH(in6m, &mk->mk_head, in6m_entry) {

if (written + sizeof(struct in6_addr) +

sizeof(uint32_t) > *oldlenp)

goto done;

error = sysctl_copyout(l, &in6m->in6m_addr,

oldp, sizeof(struct in6_addr));

if (error)

goto done;

oldp = (char *)oldp + sizeof(struct in6_addr);

written += sizeof(struct in6_addr);

tmp = in6m->in6m_refcount;

error = sysctl_copyout(l, &tmp, oldp, sizeof(tmp));

if (error)

goto done;

oldp = (char *)oldp + sizeof(tmp);

written += sizeof(tmp);

}

done:

*oldlenp = written;

return error;

}

static int

Line 977 in6_multicast_sysctl(SYSCTLFN_ARGS)

Line 971 in6_multicast_sysctl(SYSCTLFN_ARGS)

{

struct ifnet *ifp;

struct ifaddr *ifa;

struct in6_ifaddr *ifa6;

struct in6_ifaddr *ia6;

struct in6_multi *in6m;

uint32_t tmp;

int error;

size_t written;

struct psref psref;

struct psref psref, psref_ia;

int bound;

int bound, s;

if (namelen != 1)

return EINVAL;

rw_enter(&in6_multilock, RW_READER);

bound = curlwp_bind();

ifp = if_get_byindex(name[0], &psref);

if (ifp == NULL) {

curlwp_bindx(bound);

rw_exit(&in6_multilock);

return ENODEV;

}

if (oldp == NULL) {

*oldlenp = 0;

IFADDR_FOREACH(ifa, ifp) {

s = pserialize_read_enter();

if (ifa->ifa_addr == NULL)

IFADDR_READER_FOREACH(ifa, ifp) {

continue;

LIST_FOREACH(in6m, &ifp->if_multiaddrs, in6m_entry) {

if (ifa->ifa_addr->sa_family != AF_INET6)

continue;

ifa6 = (struct in6_ifaddr *)ifa;

LIST_FOREACH(in6m, &ifa6->ia6_multiaddrs, in6m_entry) {

*oldlenp += 2 * sizeof(struct in6_addr) +

sizeof(uint32_t);

}

pserialize_read_exit(s);

if_put(ifp, &psref);

curlwp_bindx(bound);

rw_exit(&in6_multilock);

return 0;

}

error = 0;

written = 0;

IFADDR_FOREACH(ifa, ifp) {

s = pserialize_read_enter();

if (ifa->ifa_addr == NULL)

IFADDR_READER_FOREACH(ifa, ifp) {

continue;

if (ifa->ifa_addr->sa_family != AF_INET6)

continue;

ifa6 = (struct in6_ifaddr *)ifa;

LIST_FOREACH(in6m, &ifa6->ia6_multiaddrs, in6m_entry) {

ifa_acquire(ifa, &psref_ia);

pserialize_read_exit(s);

ia6 = ifatoia6(ifa);

LIST_FOREACH(in6m, &ifp->if_multiaddrs, in6m_entry) {

if (written + 2 * sizeof(struct in6_addr) +

sizeof(uint32_t) > *oldlenp)

goto done;

error = sysctl_copyout(l, &ifa6->ia_addr.sin6_addr,

* XXX return the first IPv6 address to keep backward

* compatibility, however now multicast addresses

* don't belong to any IPv6 addresses so it should be

* unnecessary.

error = sysctl_copyout(l, &ia6->ia_addr.sin6_addr,

oldp, sizeof(struct in6_addr));

if (error)

goto done;

Line 1044 in6_multicast_sysctl(SYSCTLFN_ARGS)

Line 1048 in6_multicast_sysctl(SYSCTLFN_ARGS)

oldp = (char *)oldp + sizeof(tmp);

written += sizeof(tmp);

}

s = pserialize_read_enter();

break;

}

pserialize_read_exit(s);

done:

ifa_release(ifa, &psref_ia);

if_put(ifp, &psref);

curlwp_bindx(bound);

rw_exit(&in6_multilock);

*oldlenp = written;

return error;

}

SYSCTL_SETUP(sysctl_in6_mklude_setup, "sysctl net.inet6.multicast_kludge subtree setup")

void

in6_sysctl_multicast_setup(struct sysctllog **clog)

{

sysctl_createv(clog, 0, NULL, NULL,

CVSweb <webmaster@jp.NetBSD.org>