The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/netinet6/mld6.c

Version: -  FREEBSD  -  FREEBSD11  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (C) 1998 WIDE Project.
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 3. Neither the name of the project nor the names of its contributors
   14  *    may be used to endorse or promote products derived from this software
   15  *    without specific prior written permission.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
   18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  *
   29  *      $KAME: mld6.c,v 1.27 2001/04/04 05:17:30 itojun Exp $
   30  */
   31 
   32 /*-
   33  * Copyright (c) 1988 Stephen Deering.
   34  * Copyright (c) 1992, 1993
   35  *      The Regents of the University of California.  All rights reserved.
   36  *
   37  * This code is derived from software contributed to Berkeley by
   38  * Stephen Deering of Stanford University.
   39  *
   40  * Redistribution and use in source and binary forms, with or without
   41  * modification, are permitted provided that the following conditions
   42  * are met:
   43  * 1. Redistributions of source code must retain the above copyright
   44  *    notice, this list of conditions and the following disclaimer.
   45  * 2. Redistributions in binary form must reproduce the above copyright
   46  *    notice, this list of conditions and the following disclaimer in the
   47  *    documentation and/or other materials provided with the distribution.
   48  * 4. Neither the name of the University nor the names of its contributors
   49  *    may be used to endorse or promote products derived from this software
   50  *    without specific prior written permission.
   51  *
   52  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   53  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   54  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   55  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   56  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   57  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   58  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   59  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   60  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   61  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   62  * SUCH DAMAGE.
   63  *
   64  *      @(#)igmp.c      8.1 (Berkeley) 7/19/93
   65  */
   66 
   67 #include <sys/cdefs.h>
   68 __FBSDID("$FreeBSD$");
   69 
   70 #include "opt_inet.h"
   71 #include "opt_inet6.h"
   72 
   73 #include <sys/param.h>
   74 #include <sys/systm.h>
   75 #include <sys/mbuf.h>
   76 #include <sys/socket.h>
   77 #include <sys/protosw.h>
   78 #include <sys/syslog.h>
   79 #include <sys/kernel.h>
   80 #include <sys/callout.h>
   81 #include <sys/malloc.h>
   82 
   83 #include <net/if.h>
   84 
   85 #include <netinet/in.h>
   86 #include <netinet/in_var.h>
   87 #include <netinet6/in6_var.h>
   88 #include <netinet/ip6.h>
   89 #include <netinet6/ip6_var.h>
   90 #include <netinet6/scope6_var.h>
   91 #include <netinet/icmp6.h>
   92 #include <netinet6/mld6_var.h>
   93 
   94 /*
   95  * Protocol constants
   96  */
   97 
   98 /* denotes that the MLD max response delay field specifies time in milliseconds */
   99 #define MLD_TIMER_SCALE 1000
  100 /*
  101  * time between repetitions of a node's initial report of interest in a
  102  * multicast address(in seconds)
  103  */
  104 #define MLD_UNSOLICITED_REPORT_INTERVAL 10
  105 
  106 static struct ip6_pktopts ip6_opts;
  107 
  108 static void mld6_sendpkt(struct in6_multi *, int, const struct in6_addr *);
  109 static void mld_starttimer(struct in6_multi *);
  110 static void mld_stoptimer(struct in6_multi *);
  111 static void mld_timeo(struct in6_multi *);
  112 static u_long mld_timerresid(struct in6_multi *);
  113 
  114 void
  115 mld6_init(void)
  116 {
  117         static u_int8_t hbh_buf[8];
  118         struct ip6_hbh *hbh = (struct ip6_hbh *)hbh_buf;
  119         u_int16_t rtalert_code = htons((u_int16_t)IP6OPT_RTALERT_MLD);
  120 
  121         /* ip6h_nxt will be fill in later */
  122         hbh->ip6h_len = 0;      /* (8 >> 3) - 1 */
  123 
  124         /* XXX: grotty hard coding... */
  125         hbh_buf[2] = IP6OPT_PADN;       /* 2 byte padding */
  126         hbh_buf[3] = 0;
  127         hbh_buf[4] = IP6OPT_ROUTER_ALERT;
  128         hbh_buf[5] = IP6OPT_RTALERT_LEN - 2;
  129         bcopy((caddr_t)&rtalert_code, &hbh_buf[6], sizeof(u_int16_t));
  130 
  131         ip6_initpktopts(&ip6_opts);
  132         ip6_opts.ip6po_hbh = hbh;
  133 }
  134 
  135 static void
  136 mld_starttimer(struct in6_multi *in6m)
  137 {
  138         struct timeval now;
  139 
  140         microtime(&now);
  141         in6m->in6m_timer_expire.tv_sec = now.tv_sec + in6m->in6m_timer / hz;
  142         in6m->in6m_timer_expire.tv_usec = now.tv_usec +
  143             (in6m->in6m_timer % hz) * (1000000 / hz);
  144         if (in6m->in6m_timer_expire.tv_usec > 1000000) {
  145                 in6m->in6m_timer_expire.tv_sec++;
  146                 in6m->in6m_timer_expire.tv_usec -= 1000000;
  147         }
  148 
  149         /* start or restart the timer */
  150         callout_reset(in6m->in6m_timer_ch, in6m->in6m_timer,
  151             (void (*)(void *))mld_timeo, in6m);
  152 }
  153 
  154 static void
  155 mld_stoptimer(struct in6_multi *in6m)
  156 {
  157         if (in6m->in6m_timer == IN6M_TIMER_UNDEF)
  158                 return;
  159 
  160         callout_stop(in6m->in6m_timer_ch);
  161         in6m->in6m_timer = IN6M_TIMER_UNDEF;
  162 }
  163 
  164 static void
  165 mld_timeo(struct in6_multi *in6m)
  166 {
  167         int s = splnet();
  168 
  169         in6m->in6m_timer = IN6M_TIMER_UNDEF;
  170 
  171         callout_stop(in6m->in6m_timer_ch);
  172 
  173         switch (in6m->in6m_state) {
  174         case MLD_REPORTPENDING:
  175                 mld6_start_listening(in6m);
  176                 break;
  177         default:
  178                 mld6_sendpkt(in6m, MLD_LISTENER_REPORT, NULL);
  179                 break;
  180         }
  181 
  182         splx(s);
  183 }
  184 
  185 static u_long
  186 mld_timerresid(struct in6_multi *in6m)
  187 {
  188         struct timeval now, diff;
  189 
  190         microtime(&now);
  191 
  192         if (now.tv_sec > in6m->in6m_timer_expire.tv_sec ||
  193             (now.tv_sec == in6m->in6m_timer_expire.tv_sec &&
  194             now.tv_usec > in6m->in6m_timer_expire.tv_usec)) {
  195                 return (0);
  196         }
  197         diff = in6m->in6m_timer_expire;
  198         diff.tv_sec -= now.tv_sec;
  199         diff.tv_usec -= now.tv_usec;
  200         if (diff.tv_usec < 0) {
  201                 diff.tv_sec--;
  202                 diff.tv_usec += 1000000;
  203         }
  204 
  205         /* return the remaining time in milliseconds */
  206         return (diff.tv_sec * 1000 + diff.tv_usec / 1000);
  207 }
  208 
  209 void
  210 mld6_start_listening(struct in6_multi *in6m)
  211 {
  212         struct in6_addr all_in6;
  213         int s = splnet();
  214 
  215         /*
  216          * RFC2710 page 10:
  217          * The node never sends a Report or Done for the link-scope all-nodes
  218          * address.
  219          * MLD messages are never sent for multicast addresses whose scope is 0
  220          * (reserved) or 1 (node-local).
  221          */
  222         all_in6 = in6addr_linklocal_allnodes;
  223         if (in6_setscope(&all_in6, in6m->in6m_ifp, NULL)) {
  224                 /* XXX: this should not happen! */
  225                 in6m->in6m_timer = 0;
  226                 in6m->in6m_state = MLD_OTHERLISTENER;
  227         }
  228         if (IN6_ARE_ADDR_EQUAL(&in6m->in6m_addr, &all_in6) ||
  229             IPV6_ADDR_MC_SCOPE(&in6m->in6m_addr) <
  230             IPV6_ADDR_SCOPE_LINKLOCAL) {
  231                 in6m->in6m_timer = 0;
  232                 in6m->in6m_state = MLD_OTHERLISTENER;
  233         } else {
  234                 mld6_sendpkt(in6m, MLD_LISTENER_REPORT, NULL);
  235                 in6m->in6m_timer = arc4random() %
  236                         MLD_UNSOLICITED_REPORT_INTERVAL * hz;
  237                 in6m->in6m_state = MLD_IREPORTEDLAST;
  238 
  239                 mld_starttimer(in6m);
  240         }
  241         splx(s);
  242 }
  243 
  244 void
  245 mld6_stop_listening(struct in6_multi *in6m)
  246 {
  247         struct in6_addr allnode, allrouter;
  248 
  249         allnode = in6addr_linklocal_allnodes;
  250         if (in6_setscope(&allnode, in6m->in6m_ifp, NULL)) {
  251                 /* XXX: this should not happen! */
  252                 return;
  253         }
  254         allrouter = in6addr_linklocal_allrouters;
  255         if (in6_setscope(&allrouter, in6m->in6m_ifp, NULL)) {
  256                 /* XXX impossible */
  257                 return;
  258         }
  259         if (in6m->in6m_state == MLD_IREPORTEDLAST &&
  260             !IN6_ARE_ADDR_EQUAL(&in6m->in6m_addr, &allnode) &&
  261             IPV6_ADDR_MC_SCOPE(&in6m->in6m_addr) >
  262             IPV6_ADDR_SCOPE_INTFACELOCAL) {
  263                 mld6_sendpkt(in6m, MLD_LISTENER_DONE, &allrouter);
  264         }
  265 }
  266 
  267 void
  268 mld6_input(struct mbuf *m, int off)
  269 {
  270         struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
  271         struct mld_hdr *mldh;
  272         struct ifnet *ifp = m->m_pkthdr.rcvif;
  273         struct in6_multi *in6m;
  274         struct in6_addr mld_addr, all_in6;
  275         struct in6_ifaddr *ia;
  276         struct ifmultiaddr *ifma;
  277         u_long timer;           /* timer value in the MLD query header */
  278 
  279 #ifndef PULLDOWN_TEST
  280         IP6_EXTHDR_CHECK(m, off, sizeof(*mldh),);
  281         mldh = (struct mld_hdr *)(mtod(m, caddr_t) + off);
  282 #else
  283         IP6_EXTHDR_GET(mldh, struct mld_hdr *, m, off, sizeof(*mldh));
  284         if (mldh == NULL) {
  285                 icmp6stat.icp6s_tooshort++;
  286                 return;
  287         }
  288 #endif
  289 
  290         /* source address validation */
  291         ip6 = mtod(m, struct ip6_hdr *); /* in case mpullup */
  292         if (!IN6_IS_ADDR_LINKLOCAL(&ip6->ip6_src)) {
  293                 char ip6bufs[INET6_ADDRSTRLEN], ip6bufg[INET6_ADDRSTRLEN];
  294                 log(LOG_ERR,
  295                     "mld6_input: src %s is not link-local (grp=%s)\n",
  296                     ip6_sprintf(ip6bufs, &ip6->ip6_src),
  297                     ip6_sprintf(ip6bufg, &mldh->mld_addr));
  298                 /*
  299                  * spec (RFC2710) does not explicitly
  300                  * specify to discard the packet from a non link-local
  301                  * source address. But we believe it's expected to do so.
  302                  * XXX: do we have to allow :: as source?
  303                  */
  304                 m_freem(m);
  305                 return;
  306         }
  307 
  308         /*
  309          * make a copy for local work (in6_setscope() may modify the 1st arg)
  310          */
  311         mld_addr = mldh->mld_addr;
  312         if (in6_setscope(&mld_addr, ifp, NULL)) {
  313                 /* XXX: this should not happen! */
  314                 m_free(m);
  315                 return;
  316         }
  317 
  318         /*
  319          * In the MLD6 specification, there are 3 states and a flag.
  320          *
  321          * In Non-Listener state, we simply don't have a membership record.
  322          * In Delaying Listener state, our timer is running (in6m->in6m_timer)
  323          * In Idle Listener state, our timer is not running
  324          * (in6m->in6m_timer==IN6M_TIMER_UNDEF)
  325          *
  326          * The flag is in6m->in6m_state, it is set to MLD_OTHERLISTENER if
  327          * we have heard a report from another member, or MLD_IREPORTEDLAST
  328          * if we sent the last report.
  329          */
  330         switch(mldh->mld_type) {
  331         case MLD_LISTENER_QUERY:
  332                 if (ifp->if_flags & IFF_LOOPBACK)
  333                         break;
  334 
  335                 if (!IN6_IS_ADDR_UNSPECIFIED(&mld_addr) &&
  336                     !IN6_IS_ADDR_MULTICAST(&mld_addr))
  337                         break;  /* print error or log stat? */
  338 
  339                 all_in6 = in6addr_linklocal_allnodes;
  340                 if (in6_setscope(&all_in6, ifp, NULL)) {
  341                         /* XXX: this should not happen! */
  342                         break;
  343                 }
  344 
  345                 /*
  346                  * - Start the timers in all of our membership records
  347                  *   that the query applies to for the interface on
  348                  *   which the query arrived excl. those that belong
  349                  *   to the "all-nodes" group (ff02::1).
  350                  * - Restart any timer that is already running but has
  351                  *   A value longer than the requested timeout.
  352                  * - Use the value specified in the query message as
  353                  *   the maximum timeout.
  354                  */
  355                 timer = ntohs(mldh->mld_maxdelay);
  356 
  357                 IFP_TO_IA6(ifp, ia);
  358                 if (ia == NULL)
  359                         break;
  360 
  361                 /*
  362                  * XXX: System timer resolution is too low to handle Max
  363                  * Response Delay, so set 1 to the internal timer even if
  364                  * the calculated value equals to zero when Max Response
  365                  * Delay is positive.
  366                  */
  367                 timer = ntohs(mldh->mld_maxdelay) * PR_FASTHZ / MLD_TIMER_SCALE;
  368                 if (timer == 0 && mldh->mld_maxdelay)
  369                         timer = 1;
  370 
  371                 IF_ADDR_LOCK(ifp);
  372                 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
  373                         if (ifma->ifma_addr->sa_family != AF_INET6)
  374                                 continue;
  375                         in6m = (struct in6_multi *)ifma->ifma_protospec;
  376 
  377                         if (IN6_ARE_ADDR_EQUAL(&in6m->in6m_addr, &all_in6) ||
  378                             IPV6_ADDR_MC_SCOPE(&in6m->in6m_addr) <
  379                             IPV6_ADDR_SCOPE_LINKLOCAL)
  380                                 continue;
  381 
  382                         if (IN6_IS_ADDR_UNSPECIFIED(&mld_addr) ||
  383                             IN6_ARE_ADDR_EQUAL(&mld_addr, &in6m->in6m_addr)) {
  384                                 if (timer == 0) {
  385                                         /* send a report immediately */
  386                                         mld_stoptimer(in6m);
  387                                         mld6_sendpkt(in6m, MLD_LISTENER_REPORT,
  388                                                 NULL);
  389                                         in6m->in6m_timer = 0; /* reset timer */
  390                                         in6m->in6m_state = MLD_IREPORTEDLAST;
  391                                 }
  392                                 else if (in6m->in6m_timer == IN6M_TIMER_UNDEF ||
  393                                     mld_timerresid(in6m) > timer) {
  394                                         in6m->in6m_timer =
  395                                            1 + (arc4random() % timer) * hz / 1000;
  396                                         mld_starttimer(in6m);
  397                                 }
  398                         }
  399                 }
  400                 IF_ADDR_UNLOCK(ifp);
  401                 break;
  402 
  403         case MLD_LISTENER_REPORT:
  404                 /*
  405                  * For fast leave to work, we have to know that we are the
  406                  * last person to send a report for this group.  Reports
  407                  * can potentially get looped back if we are a multicast
  408                  * router, so discard reports sourced by me.
  409                  * Note that it is impossible to check IFF_LOOPBACK flag of
  410                  * ifp for this purpose, since ip6_mloopback pass the physical
  411                  * interface to looutput.
  412                  */
  413                 if (m->m_flags & M_LOOP) /* XXX: grotty flag, but efficient */
  414                         break;
  415 
  416                 if (!IN6_IS_ADDR_MULTICAST(&mld_addr))
  417                         break;
  418 
  419                 /*
  420                  * If we belong to the group being reported, stop
  421                  * our timer for that group.
  422                  */
  423                 IN6_LOOKUP_MULTI(mld_addr, ifp, in6m);
  424                 if (in6m) {
  425                         in6m->in6m_timer = 0; /* transit to idle state */
  426                         in6m->in6m_state = MLD_OTHERLISTENER; /* clear flag */
  427                 }
  428                 break;
  429         default:                /* this is impossible */
  430                 log(LOG_ERR, "mld6_input: illegal type(%d)", mldh->mld_type);
  431                 break;
  432         }
  433 
  434         m_freem(m);
  435 }
  436 
  437 static void
  438 mld6_sendpkt(struct in6_multi *in6m, int type, const struct in6_addr *dst)
  439 {
  440         struct mbuf *mh, *md;
  441         struct mld_hdr *mldh;
  442         struct ip6_hdr *ip6;
  443         struct ip6_moptions im6o;
  444         struct in6_ifaddr *ia;
  445         struct ifnet *ifp = in6m->in6m_ifp;
  446         struct ifnet *outif = NULL;
  447 
  448         /*
  449          * At first, find a link local address on the outgoing interface
  450          * to use as the source address of the MLD packet.
  451          */
  452         if ((ia = in6ifa_ifpforlinklocal(ifp, IN6_IFF_NOTREADY|IN6_IFF_ANYCAST))
  453             == NULL)
  454                 return;
  455 
  456         /*
  457          * Allocate mbufs to store ip6 header and MLD header.
  458          * We allocate 2 mbufs and make chain in advance because
  459          * it is more convenient when inserting the hop-by-hop option later.
  460          */
  461         MGETHDR(mh, M_DONTWAIT, MT_HEADER);
  462         if (mh == NULL)
  463                 return;
  464         MGET(md, M_DONTWAIT, MT_DATA);
  465         if (md == NULL) {
  466                 m_free(mh);
  467                 return;
  468         }
  469         mh->m_next = md;
  470 
  471         mh->m_pkthdr.rcvif = NULL;
  472         mh->m_pkthdr.len = sizeof(struct ip6_hdr) + sizeof(struct mld_hdr);
  473         mh->m_len = sizeof(struct ip6_hdr);
  474         MH_ALIGN(mh, sizeof(struct ip6_hdr));
  475 
  476         /* fill in the ip6 header */
  477         ip6 = mtod(mh, struct ip6_hdr *);
  478         ip6->ip6_flow = 0;
  479         ip6->ip6_vfc &= ~IPV6_VERSION_MASK;
  480         ip6->ip6_vfc |= IPV6_VERSION;
  481         /* ip6_plen will be set later */
  482         ip6->ip6_nxt = IPPROTO_ICMPV6;
  483         /* ip6_hlim will be set by im6o.im6o_multicast_hlim */
  484         ip6->ip6_src = ia->ia_addr.sin6_addr;
  485         ip6->ip6_dst = dst ? *dst : in6m->in6m_addr;
  486 
  487         /* fill in the MLD header */
  488         md->m_len = sizeof(struct mld_hdr);
  489         mldh = mtod(md, struct mld_hdr *);
  490         mldh->mld_type = type;
  491         mldh->mld_code = 0;
  492         mldh->mld_cksum = 0;
  493         /* XXX: we assume the function will not be called for query messages */
  494         mldh->mld_maxdelay = 0;
  495         mldh->mld_reserved = 0;
  496         mldh->mld_addr = in6m->in6m_addr;
  497         in6_clearscope(&mldh->mld_addr); /* XXX */
  498         mldh->mld_cksum = in6_cksum(mh, IPPROTO_ICMPV6, sizeof(struct ip6_hdr),
  499                                     sizeof(struct mld_hdr));
  500 
  501         /* construct multicast option */
  502         bzero(&im6o, sizeof(im6o));
  503         im6o.im6o_multicast_ifp = ifp;
  504         im6o.im6o_multicast_hlim = 1;
  505 
  506         /*
  507          * Request loopback of the report if we are acting as a multicast
  508          * router, so that the process-level routing daemon can hear it.
  509          */
  510         im6o.im6o_multicast_loop = (ip6_mrouter != NULL);
  511 
  512         /* increment output statictics */
  513         icmp6stat.icp6s_outhist[type]++;
  514 
  515         ip6_output(mh, &ip6_opts, NULL, 0, &im6o, &outif, NULL);
  516         if (outif) {
  517                 icmp6_ifstat_inc(outif, ifs6_out_msg);
  518                 switch (type) {
  519                 case MLD_LISTENER_QUERY:
  520                         icmp6_ifstat_inc(outif, ifs6_out_mldquery);
  521                         break;
  522                 case MLD_LISTENER_REPORT:
  523                         icmp6_ifstat_inc(outif, ifs6_out_mldreport);
  524                         break;
  525                 case MLD_LISTENER_DONE:
  526                         icmp6_ifstat_inc(outif, ifs6_out_mlddone);
  527                         break;
  528                 }
  529         }
  530 }
  531 
  532 /*
  533  * Add an address to the list of IP6 multicast addresses for a given interface.
  534  * Add source addresses to the list also, if upstream router is MLDv2 capable
  535  * and the number of source is not 0.
  536  */
  537 struct in6_multi *
  538 in6_addmulti(struct in6_addr *maddr6, struct ifnet *ifp,
  539     int *errorp, int delay)
  540 {
  541         struct in6_multi *in6m;
  542 
  543         *errorp = 0;
  544         in6m = NULL;
  545 
  546         IFF_LOCKGIANT(ifp);
  547         /*IN6_MULTI_LOCK();*/
  548 
  549         IN6_LOOKUP_MULTI(*maddr6, ifp, in6m);
  550         if (in6m != NULL) {
  551                 /*
  552                  * If we already joined this group, just bump the
  553                  * refcount and return it.
  554                  */
  555                 KASSERT(in6m->in6m_refcount >= 1,
  556                     ("%s: bad refcount %d", __func__, in6m->in6m_refcount));
  557                 ++in6m->in6m_refcount;
  558         } else do {
  559                 struct in6_multi *nin6m;
  560                 struct ifmultiaddr *ifma;
  561                 struct sockaddr_in6 sa6;
  562 
  563                 bzero(&sa6, sizeof(sa6));
  564                 sa6.sin6_family = AF_INET6;
  565                 sa6.sin6_len = sizeof(struct sockaddr_in6);
  566                 sa6.sin6_addr = *maddr6;
  567 
  568                 *errorp = if_addmulti(ifp, (struct sockaddr *)&sa6, &ifma);
  569                 if (*errorp)
  570                         break;
  571 
  572                 /*
  573                  * If ifma->ifma_protospec is null, then if_addmulti() created
  574                  * a new record.  Otherwise, bump refcount, and we are done.
  575                  */
  576                 if (ifma->ifma_protospec != NULL) {
  577                         in6m = ifma->ifma_protospec;
  578                         ++in6m->in6m_refcount;
  579                         break;
  580                 }
  581 
  582                 nin6m = malloc(sizeof(*nin6m), M_IP6MADDR, M_NOWAIT | M_ZERO);
  583                 if (nin6m == NULL) {
  584                         if_delmulti_ifma(ifma);
  585                         break;
  586                 }
  587 
  588                 nin6m->in6m_addr = *maddr6;
  589                 nin6m->in6m_ifp = ifp;
  590                 nin6m->in6m_refcount = 1;
  591                 nin6m->in6m_ifma = ifma;
  592                 ifma->ifma_protospec = nin6m;
  593 
  594                 nin6m->in6m_timer_ch = malloc(sizeof(*nin6m->in6m_timer_ch),
  595                     M_IP6MADDR, M_NOWAIT);
  596                 if (nin6m->in6m_timer_ch == NULL) {
  597                         free(nin6m, M_IP6MADDR);
  598                         if_delmulti_ifma(ifma);
  599                         break;
  600                 }
  601 
  602                 LIST_INSERT_HEAD(&in6_multihead, nin6m, in6m_entry);
  603 
  604                 callout_init(nin6m->in6m_timer_ch, 0);
  605                 nin6m->in6m_timer = delay;
  606                 if (nin6m->in6m_timer > 0) {
  607                         nin6m->in6m_state = MLD_REPORTPENDING;
  608                         mld_starttimer(nin6m);
  609                 }
  610 
  611                 mld6_start_listening(nin6m);
  612 
  613                 in6m = nin6m;
  614 
  615         } while (0);
  616 
  617         /*IN6_MULTI_UNLOCK();*/
  618         IFF_UNLOCKGIANT(ifp);
  619 
  620         return (in6m);
  621 }
  622 
  623 /*
  624  * Delete a multicast address record.
  625  *
  626  * TODO: Locking, as per netinet.
  627  */
  628 void
  629 in6_delmulti(struct in6_multi *in6m)
  630 {
  631         struct ifmultiaddr *ifma;
  632 
  633         KASSERT(in6m->in6m_refcount >= 1, ("%s: freeing freed in6m", __func__));
  634 
  635         if (--in6m->in6m_refcount == 0) {
  636                 mld_stoptimer(in6m);
  637                 mld6_stop_listening(in6m);
  638 
  639                 ifma = in6m->in6m_ifma;
  640                 KASSERT(ifma->ifma_protospec == in6m,
  641                     ("%s: ifma_protospec != in6m", __func__));
  642                 ifma->ifma_protospec = NULL;
  643 
  644                 LIST_REMOVE(in6m, in6m_entry);
  645                 free(in6m->in6m_timer_ch, M_IP6MADDR);
  646                 free(in6m, M_IP6MADDR);
  647 
  648                 if_delmulti_ifma(ifma);
  649         }
  650 }

Cache object: 2ca7837a0c76eb5f617273219a7e1b7f


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.