[BACK]Return to mld6.c CVS log [TXT][DIR] 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.31 and 1.55.8.2

version 1.31, 2006/03/05 23:47:08 version 1.55.8.2, 2017/12/03 11:39:04
Line 104 
Line 104 
 #include <sys/cdefs.h>  #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD$");  __KERNEL_RCSID(0, "$NetBSD$");
   
   #ifdef _KERNEL_OPT
 #include "opt_inet.h"  #include "opt_inet.h"
   #include "opt_net_mpsafe.h"
   #endif
   
 #include <sys/param.h>  #include <sys/param.h>
 #include <sys/systm.h>  #include <sys/systm.h>
 #include <sys/mbuf.h>  #include <sys/mbuf.h>
 #include <sys/socket.h>  #include <sys/socket.h>
 #include <sys/protosw.h>  #include <sys/socketvar.h>
 #include <sys/syslog.h>  #include <sys/syslog.h>
 #include <sys/sysctl.h>  #include <sys/sysctl.h>
 #include <sys/kernel.h>  #include <sys/kernel.h>
 #include <sys/callout.h>  #include <sys/callout.h>
   #include <sys/cprng.h>
   #include <sys/rwlock.h>
   
 #include <net/if.h>  #include <net/if.h>
   
Line 125  __KERNEL_RCSID(0, "$NetBSD$");
Line 130  __KERNEL_RCSID(0, "$NetBSD$");
 #include <netinet6/ip6_var.h>  #include <netinet6/ip6_var.h>
 #include <netinet6/scope6_var.h>  #include <netinet6/scope6_var.h>
 #include <netinet/icmp6.h>  #include <netinet/icmp6.h>
   #include <netinet6/icmp6_private.h>
 #include <netinet6/mld6_var.h>  #include <netinet6/mld6_var.h>
   
 #include <net/net_osdep.h>  #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; /* XXX BSS initialization */  
   
 struct multi6_kludge {  
         LIST_ENTRY(multi6_kludge) mk_entry;  
         struct ifnet *mk_ifp;  
         struct in6_multihead mk_head;  
 };  
   
   
 /*  /*
  * Protocol constants   * Protocol constants
Line 163  static struct mld_hdr * mld_allocbuf(str
Line 158  static struct mld_hdr * mld_allocbuf(str
 static void mld_sendpkt(struct in6_multi *, int, const struct in6_addr *);  static void mld_sendpkt(struct in6_multi *, int, const struct in6_addr *);
 static void mld_starttimer(struct in6_multi *);  static void mld_starttimer(struct in6_multi *);
 static void mld_stoptimer(struct in6_multi *);  static void mld_stoptimer(struct in6_multi *);
 static void mld_timeo(struct in6_multi *);  
 static u_long mld_timerresid(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  void
 mld_init()  mld_init(void)
 {  {
         static u_int8_t hbh_buf[8];          static u_int8_t hbh_buf[8];
         struct ip6_hbh *hbh = (struct ip6_hbh *)hbh_buf;          struct ip6_hbh *hbh = (struct ip6_hbh *)hbh_buf;
Line 181  mld_init()
Line 179  mld_init()
         hbh_buf[3] = 0;          hbh_buf[3] = 0;
         hbh_buf[4] = IP6OPT_RTALERT;          hbh_buf[4] = IP6OPT_RTALERT;
         hbh_buf[5] = IP6OPT_RTALERT_LEN - 2;          hbh_buf[5] = IP6OPT_RTALERT_LEN - 2;
         bcopy((caddr_t)&rtalert_code, &hbh_buf[6], sizeof(u_int16_t));          memcpy(&hbh_buf[6], (void *)&rtalert_code, sizeof(u_int16_t));
   
         ip6_opts.ip6po_hbh = hbh;          ip6_opts.ip6po_hbh = hbh;
         /* We will specify the hoplimit by a multicast option. */          /* We will specify the hoplimit by a multicast option. */
         ip6_opts.ip6po_hlim = -1;          ip6_opts.ip6po_hlim = -1;
           ip6_opts.ip6po_prefer_tempaddr = IP6PO_TEMPADDR_NOTPREFER;
   
           rw_init(&in6_multilock);
 }  }
   
 static void  static void
 mld_starttimer(in6m)  mld_starttimer(struct in6_multi *in6m)
         struct in6_multi *in6m;  
 {  {
         struct timeval now;          struct timeval now;
   
           KASSERT(rw_write_held(&in6_multilock));
           KASSERT(in6m->in6m_timer != IN6M_TIMER_UNDEF);
   
         microtime(&now);          microtime(&now);
         in6m->in6m_timer_expire.tv_sec = now.tv_sec + in6m->in6m_timer / hz;          in6m->in6m_timer_expire.tv_sec = now.tv_sec + in6m->in6m_timer / hz;
         in6m->in6m_timer_expire.tv_usec = now.tv_usec +          in6m->in6m_timer_expire.tv_usec = now.tv_usec +
Line 204  mld_starttimer(in6m)
Line 207  mld_starttimer(in6m)
         }          }
   
         /* start or restart the timer */          /* start or restart the timer */
         callout_reset(in6m->in6m_timer_ch, in6m->in6m_timer,          callout_schedule(&in6m->in6m_timer_ch, in6m->in6m_timer);
             (void (*) __P((void *)))mld_timeo, in6m);  
 }  }
   
   /*
    * mld_stoptimer releases in6_multilock when calling callout_halt.
    * The caller must ensure in6m won't be freed while releasing the lock.
    */
 static void  static void
 mld_stoptimer(in6m)  mld_stoptimer(struct in6_multi *in6m)
         struct in6_multi *in6m;  
 {  {
   
           KASSERT(rw_write_held(&in6_multilock));
   
         if (in6m->in6m_timer == IN6M_TIMER_UNDEF)          if (in6m->in6m_timer == IN6M_TIMER_UNDEF)
                 return;                  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;          in6m->in6m_timer = IN6M_TIMER_UNDEF;
 }  }
   
 static void  static void
 mld_timeo(in6m)  mld_timeo(void *arg)
         struct in6_multi *in6m;  
 {  {
         int s = splsoftnet();          struct in6_multi *in6m = arg;
   
         in6m->in6m_timer = IN6M_TIMER_UNDEF;          KASSERT(in6m->in6m_refcount > 0);
   
         callout_stop(in6m->in6m_timer_ch);          SOFTNET_KERNEL_LOCK_UNLESS_NET_MPSAFE();
           rw_enter(&in6_multilock, RW_WRITER);
           if (in6m->in6m_timer == IN6M_TIMER_UNDEF)
                   goto out;
   
           in6m->in6m_timer = IN6M_TIMER_UNDEF;
   
         switch (in6m->in6m_state) {          switch (in6m->in6m_state) {
         case MLD_REPORTPENDING:          case MLD_REPORTPENDING:
Line 239  mld_timeo(in6m)
Line 258  mld_timeo(in6m)
                 break;                  break;
         }          }
   
         splx(s);  out:
           rw_exit(&in6_multilock);
           SOFTNET_KERNEL_UNLOCK_UNLESS_NET_MPSAFE();
 }  }
   
 static u_long  static u_long
 mld_timerresid(in6m)  mld_timerresid(struct in6_multi *in6m)
         struct in6_multi *in6m;  
 {  {
         struct timeval now, diff;          struct timeval now, diff;
   
Line 264  mld_timerresid(in6m)
Line 284  mld_timerresid(in6m)
         }          }
   
         /* return the remaining time in milliseconds */          /* return the remaining time in milliseconds */
         return (((u_long)(diff.tv_sec * 1000000 + diff.tv_usec)) / 1000);          return diff.tv_sec * 1000 + diff.tv_usec / 1000;
 }  }
   
 static void  static void
 mld_start_listening(in6m)  mld_start_listening(struct in6_multi *in6m)
         struct in6_multi *in6m;  
 {  {
         struct in6_addr all_in6;          struct in6_addr all_in6;
   
           KASSERT(rw_write_held(&in6_multilock));
   
         /*          /*
          * RFC2710 page 10:           * RFC2710 page 10:
          * The node never sends a Report or Done for the link-scope all-nodes           * The node never sends a Report or Done for the link-scope all-nodes
Line 292  mld_start_listening(in6m)
Line 313  mld_start_listening(in6m)
                 in6m->in6m_state = MLD_OTHERLISTENER;                  in6m->in6m_state = MLD_OTHERLISTENER;
         } else {          } else {
                 mld_sendpkt(in6m, MLD_LISTENER_REPORT, NULL);                  mld_sendpkt(in6m, MLD_LISTENER_REPORT, NULL);
                 in6m->in6m_timer = arc4random() %                  in6m->in6m_timer = cprng_fast32() %
                     (MLD_UNSOLICITED_REPORT_INTERVAL * hz);                      (MLD_UNSOLICITED_REPORT_INTERVAL * hz);
                 in6m->in6m_state = MLD_IREPORTEDLAST;                  in6m->in6m_state = MLD_IREPORTEDLAST;
   
Line 301  mld_start_listening(in6m)
Line 322  mld_start_listening(in6m)
 }  }
   
 static void  static void
 mld_stop_listening(in6m)  mld_stop_listening(struct in6_multi *in6m)
         struct in6_multi *in6m;  
 {  {
         struct in6_addr allnode, allrouter;          struct in6_addr allnode, allrouter;
   
           KASSERT(rw_lock_held(&in6_multilock));
   
         allnode = in6addr_linklocal_allnodes;          allnode = in6addr_linklocal_allnodes;
         if (in6_setscope(&allnode, in6m->in6m_ifp, NULL)) {          if (in6_setscope(&allnode, in6m->in6m_ifp, NULL)) {
                 /* XXX: this should not happen! */                  /* XXX: this should not happen! */
Line 326  mld_stop_listening(in6m)
Line 348  mld_stop_listening(in6m)
 }  }
   
 void  void
 mld_input(m, off)  mld_input(struct mbuf *m, int off)
         struct mbuf *m;  
         int off;  
 {  {
         struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);          struct ip6_hdr *ip6;
         struct mld_hdr *mldh;          struct mld_hdr *mldh;
         struct ifnet *ifp = m->m_pkthdr.rcvif;          struct ifnet *ifp;
         struct in6_multi *in6m = NULL;          struct in6_multi *in6m = NULL;
         struct in6_addr mld_addr, all_in6;          struct in6_addr mld_addr, all_in6;
         struct in6_ifaddr *ia;          u_long timer = 0;       /* timer value in the MLD query header */
         int timer = 0;          /* timer value in the MLD query header */          struct psref psref;
   
           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));          IP6_EXTHDR_GET(mldh, struct mld_hdr *, m, off, sizeof(*mldh));
         if (mldh == NULL) {          if (mldh == NULL) {
                 icmp6stat.icp6s_tooshort++;                  ICMP6_STATINC(ICMP6_STAT_TOOSHORT);
                 return;                  goto out_nodrop;
         }          }
   
         /* source address validation */          /* source address validation */
Line 367  mld_input(m, off)
Line 390  mld_input(m, off)
                  * though RFC3590 says "SHOULD log" if the source of a query                   * though RFC3590 says "SHOULD log" if the source of a query
                  * is the unspecified address.                   * is the unspecified address.
                  */                   */
                   char ip6bufs[INET6_ADDRSTRLEN];
                   char ip6bufm[INET6_ADDRSTRLEN];
                 log(LOG_INFO,                  log(LOG_INFO,
                     "mld_input: src %s is not link-local (grp=%s)\n",                      "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  #endif
                 m_freem(m);                  goto out;
                 return;  
         }          }
   
         /*          /*
Line 381  mld_input(m, off)
Line 406  mld_input(m, off)
         mld_addr = mldh->mld_addr;          mld_addr = mldh->mld_addr;
         if (in6_setscope(&mld_addr, ifp, NULL)) {          if (in6_setscope(&mld_addr, ifp, NULL)) {
                 /* XXX: this should not happen! */                  /* XXX: this should not happen! */
                 m_free(m);                  goto out;
                 return;  
         }          }
   
         /*          /*
Line 398  mld_input(m, off)
Line 422  mld_input(m, off)
          * if we sent the last report.           * if we sent the last report.
          */           */
         switch (mldh->mld_type) {          switch (mldh->mld_type) {
         case MLD_LISTENER_QUERY:          case MLD_LISTENER_QUERY: {
                   struct in6_multi *next;
   
                 if (ifp->if_flags & IFF_LOOPBACK)                  if (ifp->if_flags & IFF_LOOPBACK)
                         break;                          break;
   
Line 424  mld_input(m, off)
Line 450  mld_input(m, off)
                  */                   */
                 timer = ntohs(mldh->mld_maxdelay);                  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
                 for (in6m = ia->ia6_multiaddrs.lh_first;                   * while releasing the lock by having an extra reference to it.
                      in6m;                   *
                      in6m = in6m->in6m_entry.le_next)                   * 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) ||                          if (IN6_ARE_ADDR_EQUAL(&in6m->in6m_addr, &all_in6) ||
                             IPV6_ADDR_MC_SCOPE(&in6m->in6m_addr) <                              IPV6_ADDR_MC_SCOPE(&in6m->in6m_addr) <
                             IPV6_ADDR_SCOPE_LINKLOCAL)                              IPV6_ADDR_SCOPE_LINKLOCAL)
Line 445  mld_input(m, off)
Line 474  mld_input(m, off)
                                 continue;                                  continue;
   
                         if (timer == 0) {                          if (timer == 0) {
                                   in6m_ref(in6m);
   
                                 /* send a report immediately */                                  /* send a report immediately */
                                 mld_stoptimer(in6m);                                  mld_stoptimer(in6m);
                                 mld_sendpkt(in6m, MLD_LISTENER_REPORT, NULL);                                  mld_sendpkt(in6m, MLD_LISTENER_REPORT, NULL);
                                 in6m->in6m_state = MLD_IREPORTEDLAST;                                  in6m->in6m_state = MLD_IREPORTEDLAST;
   
                                   in6m_unref(in6m); /* May free in6m */
                         } else if (in6m->in6m_timer == IN6M_TIMER_UNDEF ||                          } else if (in6m->in6m_timer == IN6M_TIMER_UNDEF ||
                             mld_timerresid(in6m) > (u_long)timer) {                              mld_timerresid(in6m) > timer) {
                                 in6m->in6m_timer = arc4random() %                                  in6m->in6m_timer =
                                     (int)(((long)timer * hz) / 1000);                                     1 + (cprng_fast32() % timer) * hz / 1000;
                                 mld_starttimer(in6m);                                  mld_starttimer(in6m);
                         }                          }
                 }                  }
                   rw_exit(&in6_multilock);
                 break;                  break;
               }
   
         case MLD_LISTENER_REPORT:          case MLD_LISTENER_REPORT:
                 /*                  /*
Line 478  mld_input(m, off)
Line 513  mld_input(m, off)
                  * If we belong to the group being reported, stop                   * If we belong to the group being reported, stop
                  * our timer for that group.                   * 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) {                  if (in6m) {
                           in6m_ref(in6m);
                         mld_stoptimer(in6m); /* transit to idle state */                          mld_stoptimer(in6m); /* transit to idle state */
                         in6m->in6m_state = MLD_OTHERLISTENER; /* clear flag */                          in6m->in6m_state = MLD_OTHERLISTENER; /* clear flag */
                           in6m_unref(in6m);
                           in6m = NULL; /* in6m might be freed */
                 }                  }
                   rw_exit(&in6_multilock);
                 break;                  break;
         default:                /* this is impossible */          default:                /* this is impossible */
 #if 0  #if 0
Line 496  mld_input(m, off)
Line 536  mld_input(m, off)
                 break;                  break;
         }          }
   
   out:
         m_freem(m);          m_freem(m);
   out_nodrop:
           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  static void
 mld_sendpkt(in6m, type, dst)  mld_sendpkt(struct in6_multi *in6m, int type,
         struct in6_multi *in6m;          const struct in6_addr *dst)
         int type;  
         const struct in6_addr *dst;  
 {  {
         struct mbuf *mh;          struct mbuf *mh;
         struct mld_hdr *mldh;          struct mld_hdr *mldh;
Line 512  mld_sendpkt(in6m, type, dst)
Line 558  mld_sendpkt(in6m, type, dst)
         struct in6_ifaddr *ia = NULL;          struct in6_ifaddr *ia = NULL;
         struct ifnet *ifp = in6m->in6m_ifp;          struct ifnet *ifp = in6m->in6m_ifp;
         int ignflags;          int ignflags;
           struct psref psref;
           int bound;
   
           KASSERT(rw_write_held(&in6_multilock));
   
         /*          /*
          * At first, find a link local address on the outgoing interface           * At first, find a link local address on the outgoing interface
Line 520  mld_sendpkt(in6m, type, dst)
Line 570  mld_sendpkt(in6m, type, dst)
          * the case where we first join a link-local address.           * the case where we first join a link-local address.
          */           */
         ignflags = (IN6_IFF_NOTREADY|IN6_IFF_ANYCAST) & ~IN6_IFF_TENTATIVE;          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;                  return;
         if ((ia->ia6_flags & IN6_IFF_TENTATIVE))          }
           if ((ia->ia6_flags & IN6_IFF_TENTATIVE)) {
                   ia6_release(ia, &psref);
                 ia = NULL;                  ia = NULL;
           }
   
         /* Allocate two mbufs to store IPv6 header and MLD header */          /* Allocate two mbufs to store IPv6 header and MLD header */
         mldh = mld_allocbuf(&mh, sizeof(struct mld_hdr), in6m, type);          mldh = mld_allocbuf(&mh, sizeof(struct mld_hdr), in6m, type);
         if (mldh == NULL)          if (mldh == NULL) {
                   ia6_release(ia, &psref);
                   curlwp_bindx(bound);
                 return;                  return;
           }
   
         /* fill src/dst here */          /* fill src/dst here */
         ip6 = mtod(mh, struct ip6_hdr *);          ip6 = mtod(mh, struct ip6_hdr *);
         ip6->ip6_src = ia ? ia->ia_addr.sin6_addr : in6addr_any;          ip6->ip6_src = ia ? ia->ia_addr.sin6_addr : in6addr_any;
         ip6->ip6_dst = dst ? *dst : in6m->in6m_addr;          ip6->ip6_dst = dst ? *dst : in6m->in6m_addr;
           ia6_release(ia, &psref);
           curlwp_bindx(bound);
   
         mldh->mld_addr = in6m->in6m_addr;          mldh->mld_addr = in6m->in6m_addr;
         in6_clearscope(&mldh->mld_addr); /* XXX */          in6_clearscope(&mldh->mld_addr); /* XXX */
Line 542  mld_sendpkt(in6m, type, dst)
Line 603  mld_sendpkt(in6m, type, dst)
   
         /* construct multicast option */          /* construct multicast option */
         memset(&im6o, 0, sizeof(im6o));          memset(&im6o, 0, sizeof(im6o));
         im6o.im6o_multicast_ifp = ifp;          im6o.im6o_multicast_if_index = if_get_index(ifp);
         im6o.im6o_multicast_hlim = 1;          im6o.im6o_multicast_hlim = 1;
   
         /*          /*
Line 552  mld_sendpkt(in6m, type, dst)
Line 613  mld_sendpkt(in6m, type, dst)
         im6o.im6o_multicast_loop = (ip6_mrouter != NULL);          im6o.im6o_multicast_loop = (ip6_mrouter != NULL);
   
         /* increment output statictics */          /* increment output statictics */
         icmp6stat.icp6s_outhist[type]++;          ICMP6_STATINC(ICMP6_STAT_OUTHIST + type);
         icmp6_ifstat_inc(ifp, ifs6_out_msg);          icmp6_ifstat_inc(ifp, ifs6_out_msg);
         switch (type) {          switch (type) {
         case MLD_LISTENER_QUERY:          case MLD_LISTENER_QUERY:
Line 566  mld_sendpkt(in6m, type, dst)
Line 627  mld_sendpkt(in6m, type, dst)
                 break;                  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,          ip6_output(mh, &ip6_opts, NULL, ia ? 0 : IPV6_UNSPECSRC,
             &im6o, (struct socket *)NULL, NULL);              &im6o, NULL, NULL);
   
           rw_enter(&in6_multilock, RW_WRITER);
 }  }
   
 static struct mld_hdr *  static struct mld_hdr *
 mld_allocbuf(mh, len, in6m, type)  mld_allocbuf(struct mbuf **mh, int len, struct in6_multi *in6m,
         struct mbuf **mh;      int type)
         int len;  
         struct in6_multi *in6m;  
         int type;  
 {  {
         struct mbuf *md;          struct mbuf *md;
         struct mld_hdr *mldh;          struct mld_hdr *mldh;
Line 598  mld_allocbuf(mh, len, in6m, type)
Line 661  mld_allocbuf(mh, len, in6m, type)
         (*mh)->m_next = md;          (*mh)->m_next = md;
         md->m_next = NULL;          md->m_next = NULL;
   
         (*mh)->m_pkthdr.rcvif = NULL;          m_reset_rcvif((*mh));
         (*mh)->m_pkthdr.len = sizeof(struct ip6_hdr) + len;          (*mh)->m_pkthdr.len = sizeof(struct ip6_hdr) + len;
         (*mh)->m_len = sizeof(struct ip6_hdr);          (*mh)->m_len = sizeof(struct ip6_hdr);
         MH_ALIGN(*mh, sizeof(struct ip6_hdr));          MH_ALIGN(*mh, sizeof(struct ip6_hdr));
Line 622  mld_allocbuf(mh, len, in6m, type)
Line 685  mld_allocbuf(mh, len, in6m, type)
         return mldh;          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.   * Add an address to the list of IP6 multicast addresses for a given interface.
  */   */
 struct  in6_multi *  struct  in6_multi *
 in6_addmulti(maddr6, ifp, errorp, delay)  in6_addmulti(struct in6_addr *maddr6, struct ifnet *ifp,
         struct in6_addr *maddr6;          int *errorp, int timer)
         struct ifnet *ifp;  
         int *errorp, delay;  
 {  {
         struct  in6_ifaddr *ia;          struct  sockaddr_in6 sin6;
         struct  in6_ifreq ifr;  
         struct  in6_multi *in6m;          struct  in6_multi *in6m;
         int     s = splsoftnet();  
   
         *errorp = 0;          *errorp = 0;
   
           rw_enter(&in6_multilock, RW_WRITER);
         /*          /*
          * See if address already in list.           * See if address already in list.
          */           */
         IN6_LOOKUP_MULTI(*maddr6, ifp, in6m);          in6m = in6_lookup_multi(maddr6, ifp);
         if (in6m != NULL) {          if (in6m != NULL) {
                 /*                  /*
                  * Found it; just increment the refrence count.                   * Found it; just increment the refrence count.
Line 653  in6_addmulti(maddr6, ifp, errorp, delay)
Line 730  in6_addmulti(maddr6, ifp, errorp, delay)
                  * and link it into the interface's multicast list.                   * and link it into the interface's multicast list.
                  */                   */
                 in6m = (struct in6_multi *)                  in6m = (struct in6_multi *)
                         malloc(sizeof(*in6m), M_IPMADDR, M_NOWAIT);                          malloc(sizeof(*in6m), M_IPMADDR, M_NOWAIT|M_ZERO);
                 if (in6m == NULL) {                  if (in6m == NULL) {
                         splx(s);  
                         *errorp = ENOBUFS;                          *errorp = ENOBUFS;
                         return (NULL);                          goto out;
                 }                  }
   
                 memset(in6m, 0, sizeof(*in6m));  
                 in6m->in6m_addr = *maddr6;                  in6m->in6m_addr = *maddr6;
                 in6m->in6m_ifp = ifp;                  in6m->in6m_ifp = ifp;
                 in6m->in6m_refcount = 1;                  in6m->in6m_refcount = 1;
                 in6m->in6m_timer = IN6M_TIMER_UNDEF;                  in6m->in6m_timer = IN6M_TIMER_UNDEF;
                 in6m->in6m_timer_ch =                  callout_init(&in6m->in6m_timer_ch, CALLOUT_MPSAFE);
                     malloc(sizeof(*in6m->in6m_timer_ch), M_IPMADDR, M_NOWAIT);                  callout_setfunc(&in6m->in6m_timer_ch, mld_timeo, in6m);
                 if (in6m->in6m_timer_ch == NULL) {  
                         free(in6m, M_IPMADDR);                  LIST_INSERT_HEAD(&ifp->if_multiaddrs, in6m, in6m_entry);
                         splx(s);  
                         return (NULL);  
                 }  
                 IFP_TO_IA6(ifp, ia);  
                 if (ia == NULL) {  
                         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                   * Ask the network driver to update its multicast reception
                  * filter appropriately for the new address.                   * filter appropriately for the new address.
                  */                   */
                 memset(&ifr.ifr_addr, 0, sizeof(struct sockaddr_in6));                  sockaddr_in6_init(&sin6, maddr6, 0, 0, 0);
                 ifr.ifr_addr.sin6_family = AF_INET6;                  *errorp = if_mcast_op(ifp, SIOCADDMULTI, sin6tosa(&sin6));
                 ifr.ifr_addr.sin6_len = sizeof(struct sockaddr_in6);  
                 ifr.ifr_addr.sin6_addr = *maddr6;  
                 if (ifp->if_ioctl == NULL)  
                         *errorp = ENXIO; /* XXX: appropriate? */  
                 else  
                         *errorp = (*ifp->if_ioctl)(ifp, SIOCADDMULTI,  
                             (caddr_t)&ifr);  
                 if (*errorp) {                  if (*errorp) {
                           callout_destroy(&in6m->in6m_timer_ch);
                         LIST_REMOVE(in6m, in6m_entry);                          LIST_REMOVE(in6m, in6m_entry);
                         free(in6m, M_IPMADDR);                          free(in6m, M_IPMADDR);
                         IFAFREE(&ia->ia_ifa);                          in6m = NULL;
                         splx(s);                          goto out;
                         return (NULL);  
                 }                  }
   
                 callout_init(in6m->in6m_timer_ch);                  in6m->in6m_timer = timer;
                 in6m->in6m_timer = delay;  
                 if (in6m->in6m_timer > 0) {                  if (in6m->in6m_timer > 0) {
                         in6m->in6m_state = MLD_REPORTPENDING;                          in6m->in6m_state = MLD_REPORTPENDING;
                         mld_starttimer(in6m);                          mld_starttimer(in6m);
                           goto out;
                         splx(s);  
                         return (in6m);  
                 }                  }
   
                 /*                  /*
Line 720  in6_addmulti(maddr6, ifp, errorp, delay)
Line 772  in6_addmulti(maddr6, ifp, errorp, delay)
                  */                   */
                 mld_start_listening(in6m);                  mld_start_listening(in6m);
         }          }
         splx(s);  out:
         return (in6m);          rw_exit(&in6_multilock);
           return in6m;
   }
   
   static void
   in6m_destroy(struct in6_multi *in6m)
   {
           struct sockaddr_in6 sin6;
   
           KASSERT(rw_write_held(&in6_multilock));
           KASSERT(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);
   
           /*
            * Delete all references of this multicasting group from
            * the membership arrays
            */
           in6_purge_mcast_references(in6m);
   
           /*
            * 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);
           else
                   callout_halt(&in6m->in6m_timer_ch, NULL);
           callout_destroy(&in6m->in6m_timer_ch);
   
           free(in6m, M_IPMADDR);
 }  }
   
 /*  /*
  * Delete a multicast address record.   * Delete a multicast address record.
  */   */
 void  void
 in6_delmulti(in6m)  in6_delmulti(struct in6_multi *in6m)
         struct in6_multi *in6m;  
 {  {
         struct  in6_ifreq ifr;  
         struct  in6_ifaddr *ia;  
         int     s = splsoftnet();  
   
           KASSERT(in6m->in6m_refcount > 0);
   
           rw_enter(&in6_multilock, RW_WRITER);
           /*
            * The caller should have a reference to in6m. So we don't need to care
            * of releasing the lock in mld_stoptimer.
            */
         mld_stoptimer(in6m);          mld_stoptimer(in6m);
           if (--in6m->in6m_refcount == 0)
                   in6m_destroy(in6m);
           rw_exit(&in6_multilock);
   }
   
         if (--in6m->in6m_refcount == 0) {  /*
                 /*   * Look up the in6_multi record for a given IP6 multicast address
                  * No remaining claims to this record; let MLD6 know   * on a given interface. If no matching record is found, "in6m"
                  * that we are leaving the multicast group.   * returns NULL.
                  */   */
                 mld_stop_listening(in6m);  struct in6_multi *
   in6_lookup_multi(const struct in6_addr *addr, const struct ifnet *ifp)
   {
           struct in6_multi *in6m;
   
                 /*          KASSERT(rw_lock_held(&in6_multilock));
                  * Unlink from list.  
                  */  
                 LIST_REMOVE(in6m, in6m_entry);  
                 if (in6m->in6m_ia) {  
                         IFAFREE(&in6m->in6m_ia->ia_ifa); /* release reference */  
                 }  
   
                 /*          LIST_FOREACH(in6m, &ifp->if_multiaddrs, in6m_entry) {
                  * Delete all references of this multicasting group from                  if (IN6_ARE_ADDR_EQUAL(&in6m->in6m_addr, addr))
                  * the membership arrays                          break;
                  */          }
                 for (ia = in6_ifaddr; ia; ia = ia->ia_next) {          return in6m;
                         struct in6_multi_mship *imm;  }
                         LIST_FOREACH(imm, &ia->ia6_memberships,  
                             i6mm_chain) {  bool
                                 if (imm->i6mm_maddr == in6m)  in6_multi_group(const struct in6_addr *addr, const struct ifnet *ifp)
                                         imm->i6mm_maddr = NULL;  {
                         }          bool ingroup;
                 }  
   
           rw_enter(&in6_multilock, RW_READER);
           ingroup = in6_lookup_multi(addr, ifp) != NULL;
           rw_exit(&in6_multilock);
   
           return ingroup;
   }
   
   /*
    * Purge in6_multi records associated to the interface.
    */
   void
   in6_purge_multi(struct ifnet *ifp)
   {
           struct in6_multi *in6m, *next;
   
           rw_enter(&in6_multilock, RW_WRITER);
           LIST_FOREACH_SAFE(in6m, &ifp->if_multiaddrs, in6m_entry, next) {
                 /*                  /*
                  * Notify the network driver to update its multicast                   * Normally multicast addresses are already purged at this
                  * reception filter.                   * point. Remaining references aren't accessible via ifp,
                    * so what we can do here is to prevent ifp from being
                    * accessed via in6m by removing it from the list of ifp.
                  */                   */
                 memset(&ifr.ifr_addr, 0, sizeof(struct sockaddr_in6));                  mld_stoptimer(in6m);
                 ifr.ifr_addr.sin6_family = AF_INET6;                  LIST_REMOVE(in6m, in6m_entry);
                 ifr.ifr_addr.sin6_len = sizeof(struct sockaddr_in6);  
                 ifr.ifr_addr.sin6_addr = in6m->in6m_addr;  
                 (*in6m->in6m_ifp->if_ioctl)(in6m->in6m_ifp,  
                     SIOCDELMULTI, (caddr_t)&ifr);  
                 free(in6m->in6m_timer_ch, M_IPMADDR);  
                 free(in6m, M_IPMADDR);  
         }          }
         splx(s);          rw_exit(&in6_multilock);
   }
   
   void
   in6_multi_lock(int op)
   {
   
           rw_enter(&in6_multilock, op);
 }  }
   
   void
   in6_multi_unlock(void)
   {
   
           rw_exit(&in6_multilock);
   }
   
   bool
   in6_multi_locked(int op)
   {
   
           switch (op) {
           case RW_READER:
                   return rw_read_held(&in6_multilock);
           case RW_WRITER:
                   return rw_write_held(&in6_multilock);
           default:
                   return rw_lock_held(&in6_multilock);
           }
   }
   
 struct in6_multi_mship *  struct in6_multi_mship *
 in6_joingroup(ifp, addr, errorp, delay)  in6_joingroup(struct ifnet *ifp, struct in6_addr *addr,
         struct ifnet *ifp;          int *errorp, int timer)
         struct in6_addr *addr;  
         int *errorp, delay;  
 {  {
         struct in6_multi_mship *imm;          struct in6_multi_mship *imm;
   
         imm = malloc(sizeof(*imm), M_IPMADDR, M_NOWAIT);          imm = malloc(sizeof(*imm), M_IPMADDR, M_NOWAIT|M_ZERO);
         if (!imm) {          if (imm == NULL) {
                 *errorp = ENOBUFS;                  *errorp = ENOBUFS;
                 return NULL;                  return NULL;
         }          }
   
         memset(imm, 0, sizeof(*imm));          imm->i6mm_maddr = in6_addmulti(addr, ifp, errorp, timer);
         imm->i6mm_maddr = in6_addmulti(addr, ifp, errorp, delay);  
         if (!imm->i6mm_maddr) {          if (!imm->i6mm_maddr) {
                 /* *errorp is alrady set */                  /* *errorp is already set */
                 free(imm, M_IPMADDR);                  free(imm, M_IPMADDR);
                 return NULL;                  return NULL;
         }          }
Line 807  in6_joingroup(ifp, addr, errorp, delay)
Line 943  in6_joingroup(ifp, addr, errorp, delay)
 }  }
   
 int  int
 in6_leavegroup(imm)  in6_leavegroup(struct in6_multi_mship *imm)
         struct in6_multi_mship *imm;  
 {  {
           struct in6_multi *in6m;
   
         if (imm->i6mm_maddr) {          rw_enter(&in6_multilock, RW_READER);
                 in6_delmulti(imm->i6mm_maddr);          in6m = imm->i6mm_maddr;
           rw_exit(&in6_multilock);
           if (in6m != NULL) {
                   in6_delmulti(in6m);
         }          }
         free(imm, M_IPMADDR);          free(imm, M_IPMADDR);
         return 0;          return 0;
 }  }
   
   
 /*  /*
  * Multicast address kludge:   * DEPRECATED: keep it just to avoid breaking old sysctl users.
  * 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  static int
 in6_savemkludge(oia)  in6_mkludge_sysctl(SYSCTLFN_ARGS)
         struct in6_ifaddr *oia;  
 {  {
         struct in6_ifaddr *ia;  
         struct in6_multi *in6m, *next;  
   
         IFP_TO_IA6(oia->ia_ifp, ia);  
         if (ia) {       /* there is another address */  
                 for (in6m = oia->ia6_multiaddrs.lh_first; in6m; in6m = next) {  
                         next = in6m->in6m_entry.le_next;  
                         IFAFREE(&in6m->in6m_ia->ia_ifa);  
                         IFAREF(&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;  
   
                 for (mk = in6_mk.lh_first; mk; mk = mk->mk_entry.le_next) {  
                         if (mk->mk_ifp == oia->ia_ifp)  
                                 break;  
                 }  
                 if (mk == NULL) /* this should not happen! */  
                         panic("in6_savemkludge: no kludge space");  
   
                 for (in6m = oia->ia6_multiaddrs.lh_first; in6m; in6m = next) {          if (namelen != 1)
                         next = in6m->in6m_entry.le_next;                  return EINVAL;
                         IFAFREE(&in6m->in6m_ia->ia_ifa); /* release reference */          *oldlenp = 0;
                         in6m->in6m_ia = NULL;          return 0;
                         LIST_INSERT_HEAD(&mk->mk_head, in6m, in6m_entry);  
                 }  
         }  
 }  }
   
 /*  static int
  * Continuation of multicast address hack:  in6_multicast_sysctl(SYSCTLFN_ARGS)
  * 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(ia, ifp)  
         struct in6_ifaddr *ia;  
         struct ifnet *ifp;  
 {  {
         struct multi6_kludge *mk;          struct ifnet *ifp;
           struct ifaddr *ifa;
         for (mk = in6_mk.lh_first; mk; mk = mk->mk_entry.le_next) {          struct in6_ifaddr *ia6;
                 if (mk->mk_ifp == ifp) {          struct in6_multi *in6m;
                         struct in6_multi *in6m, *next;          uint32_t tmp;
           int error;
                         for (in6m = mk->mk_head.lh_first; in6m; in6m = next) {          size_t written;
                                 next = in6m->in6m_entry.le_next;          struct psref psref, psref_ia;
                                 in6m->in6m_ia = ia;          int bound, s;
                                 IFAREF(&ia->ia_ifa);  
                                 LIST_INSERT_HEAD(&ia->ia6_multiaddrs,          if (namelen != 1)
                                                  in6m, in6m_entry);                  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;
                   s = pserialize_read_enter();
                   IFADDR_READER_FOREACH(ifa, ifp) {
                           LIST_FOREACH(in6m, &ifp->if_multiaddrs, in6m_entry) {
                                   *oldlenp += 2 * sizeof(struct in6_addr) +
                                       sizeof(uint32_t);
                         }                          }
                         LIST_INIT(&mk->mk_head);  
                         break;  
                 }                  }
                   pserialize_read_exit(s);
                   if_put(ifp, &psref);
                   curlwp_bindx(bound);
                   rw_exit(&in6_multilock);
                   return 0;
         }          }
 }  
   
 /*          error = 0;
  * Allocate space for the kludge at interface initialization time.          written = 0;
  * Formerly, we dynamically allocated the space in in6_savemkludge() with          s = pserialize_read_enter();
  * malloc(M_WAITOK).  However, it was wrong since the function could be called          IFADDR_READER_FOREACH(ifa, ifp) {
  * under an interrupt context (software timer on address lifetime expiration).                  if (ifa->ifa_addr->sa_family != AF_INET6)
  * Also, we cannot just give up allocating the strucutre, since the group                          continue;
  * 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(ifp)  
         struct ifnet *ifp;  
 {  
         struct multi6_kludge *mk;  
   
         for (mk = in6_mk.lh_first; mk; mk = mk->mk_entry.le_next) {                  ifa_acquire(ifa, &psref_ia);
                 /* If we've already had one, do not allocate. */                  pserialize_read_exit(s);
                 if (mk->mk_ifp == ifp)  
                         return;  
         }  
   
         mk = malloc(sizeof(*mk), M_IPMADDR, M_WAITOK);                  ia6 = ifatoia6(ifa);
                   LIST_FOREACH(in6m, &ifp->if_multiaddrs, in6m_entry) {
                           if (written + 2 * sizeof(struct in6_addr) +
                               sizeof(uint32_t) > *oldlenp)
                                   goto done;
                           /*
                            * 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;
                           oldp = (char *)oldp + sizeof(struct in6_addr);
                           written += sizeof(struct in6_addr);
                           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);
                   }
   
                   s = pserialize_read_enter();
   
         memset(mk, 0, sizeof(*mk));                  break;
         LIST_INIT(&mk->mk_head);          }
         mk->mk_ifp = ifp;          pserialize_read_exit(s);
         LIST_INSERT_HEAD(&in6_mk, mk, mk_entry);  done:
           ifa_release(ifa, &psref_ia);
           if_put(ifp, &psref);
           curlwp_bindx(bound);
           rw_exit(&in6_multilock);
           *oldlenp = written;
           return error;
 }  }
   
 void  void
 in6_purgemkludge(ifp)  in6_sysctl_multicast_setup(struct sysctllog **clog)
         struct ifnet *ifp;  
 {  {
         struct multi6_kludge *mk;  
         struct in6_multi *in6m;  
   
         for (mk = in6_mk.lh_first; mk; mk = mk->mk_entry.le_next) {          sysctl_createv(clog, 0, NULL, NULL,
                 if (mk->mk_ifp != ifp)                         CTLFLAG_PERMANENT,
                         continue;                         CTLTYPE_NODE, "inet6", NULL,
                          NULL, 0, NULL, 0,
                 /* leave from all multicast groups joined */                         CTL_NET, PF_INET6, CTL_EOL);
                 while ((in6m = LIST_FIRST(&mk->mk_head)) != NULL) {  
                         in6_delmulti(in6m);          sysctl_createv(clog, 0, NULL, NULL,
                 }                         CTLFLAG_PERMANENT,
                 LIST_REMOVE(mk, mk_entry);                         CTLTYPE_NODE, "multicast",
                 free(mk, M_IPMADDR);                         SYSCTL_DESCR("Multicast information"),
                 break;                         in6_multicast_sysctl, 0, NULL, 0,
         }                         CTL_NET, PF_INET6, CTL_CREATE, CTL_EOL);
   
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT,
                          CTLTYPE_NODE, "multicast_kludge",
                          SYSCTL_DESCR("multicast kludge information"),
                          in6_mkludge_sysctl, 0, NULL, 0,
                          CTL_NET, PF_INET6, CTL_CREATE, CTL_EOL);
 }  }

Legend:
Removed from v.1.31  
changed lines
  Added in v.1.55.8.2

CVSweb <webmaster@jp.NetBSD.org>