[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.63 and 1.84

version 1.63, 2015/08/24 22:21:27 version 1.84, 2017/03/01 08:54:12
Line 106  __KERNEL_RCSID(0, "$NetBSD$");
Line 106  __KERNEL_RCSID(0, "$NetBSD$");
   
 #ifdef _KERNEL_OPT  #ifdef _KERNEL_OPT
 #include "opt_inet.h"  #include "opt_inet.h"
   #include "opt_net_mpsafe.h"
 #endif  #endif
   
 #include <sys/param.h>  #include <sys/param.h>
Line 113  __KERNEL_RCSID(0, "$NetBSD$");
Line 114  __KERNEL_RCSID(0, "$NetBSD$");
 #include <sys/mbuf.h>  #include <sys/mbuf.h>
 #include <sys/socket.h>  #include <sys/socket.h>
 #include <sys/socketvar.h>  #include <sys/socketvar.h>
 #include <sys/protosw.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>
Line 136  __KERNEL_RCSID(0, "$NetBSD$");
Line 136  __KERNEL_RCSID(0, "$NetBSD$");
   
   
 /*  /*
  * 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   * Protocol constants
  */   */
   
Line 229  mld_timeo(void *arg)
Line 216  mld_timeo(void *arg)
 {  {
         struct in6_multi *in6m = arg;          struct in6_multi *in6m = arg;
   
           /* XXX NOMPSAFE still need softnet_lock */
         mutex_enter(softnet_lock);          mutex_enter(softnet_lock);
         KERNEL_LOCK(1, NULL);          KERNEL_LOCK(1, NULL);
   
Line 336  mld_input(struct mbuf *m, int off)
Line 324  mld_input(struct mbuf *m, int off)
 {  {
         struct ip6_hdr *ip6;          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 */          u_long 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) {
                 ICMP6_STATINC(ICMP6_STAT_TOOSHORT);                  ICMP6_STATINC(ICMP6_STAT_TOOSHORT);
                 return;                  goto out_nodrop;
         }          }
   
         /* source address validation */          /* source address validation */
Line 371  mld_input(struct mbuf *m, int off)
Line 362  mld_input(struct mbuf *m, int 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 385  mld_input(struct mbuf *m, int off)
Line 378  mld_input(struct mbuf *m, int 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 402  mld_input(struct mbuf *m, int off)
Line 394  mld_input(struct mbuf *m, int 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: {
                 if (ifp->if_flags & IFF_LOOPBACK)                  if (ifp->if_flags & IFF_LOOPBACK)
                         break;                          break;
   
Line 428  mld_input(struct mbuf *m, int off)
Line 420  mld_input(struct mbuf *m, int off)
                  */                   */
                 timer = ntohs(mldh->mld_maxdelay);                  timer = ntohs(mldh->mld_maxdelay);
   
                 IFP_TO_IA6(ifp, ia);                  LIST_FOREACH(in6m, &ifp->if_multiaddrs, in6m_entry) {
                 if (ia == NULL)  
                         break;  
   
                 LIST_FOREACH(in6m, &ia->ia6_multiaddrs, in6m_entry) {  
                         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 458  mld_input(struct mbuf *m, int off)
Line 446  mld_input(struct mbuf *m, int off)
                         }                          }
                 }                  }
                 break;                  break;
               }
   
         case MLD_LISTENER_REPORT:          case MLD_LISTENER_REPORT:
                 /*                  /*
Line 479  mld_input(struct mbuf *m, int off)
Line 468  mld_input(struct mbuf *m, int 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);                  in6m = in6_lookup_multi(&mld_addr, ifp);
                 if (in6m) {                  if (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 */
Line 497  mld_input(struct mbuf *m, int off)
Line 486  mld_input(struct mbuf *m, int off)
                 break;                  break;
         }          }
   
   out:
         m_freem(m);          m_freem(m);
   out_nodrop:
           m_put_rcvif_psref(ifp, &psref);
 }  }
   
 static void  static void
Line 511  mld_sendpkt(struct in6_multi *in6m, int 
Line 503  mld_sendpkt(struct in6_multi *in6m, int 
         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;
   
         /*          /*
          * At first, find a link local address on the outgoing interface           * At first, find a link local address on the outgoing interface
Line 519  mld_sendpkt(struct in6_multi *in6m, int 
Line 513  mld_sendpkt(struct in6_multi *in6m, int 
          * 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 541  mld_sendpkt(struct in6_multi *in6m, int 
Line 546  mld_sendpkt(struct in6_multi *in6m, int 
   
         /* 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 594  mld_allocbuf(struct mbuf **mh, int len, 
Line 599  mld_allocbuf(struct mbuf **mh, int len, 
         (*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 625  struct in6_multi *
Line 630  struct in6_multi *
 in6_addmulti(struct in6_addr *maddr6, struct ifnet *ifp,  in6_addmulti(struct in6_addr *maddr6, struct ifnet *ifp,
         int *errorp, int timer)          int *errorp, int timer)
 {  {
         struct  in6_ifaddr *ia;  
         struct  sockaddr_in6 sin6;          struct  sockaddr_in6 sin6;
         struct  in6_multi *in6m;          struct  in6_multi *in6m;
         int     s = splsoftnet();          int     s = splsoftnet();
Line 635  in6_addmulti(struct in6_addr *maddr6, st
Line 639  in6_addmulti(struct in6_addr *maddr6, st
         /*          /*
          * 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 658  in6_addmulti(struct in6_addr *maddr6, st
Line 662  in6_addmulti(struct in6_addr *maddr6, st
                 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;
                 IFP_TO_IA6(ifp, ia);                  callout_init(&in6m->in6m_timer_ch, CALLOUT_MPSAFE);
                 if (ia == NULL) {                  callout_setfunc(&in6m->in6m_timer_ch, mld_timeo, in6m);
                         free(in6m, M_IPMADDR);  
                         splx(s);                  /* FIXME NOMPSAFE: need to lock */
                         *errorp = EADDRNOTAVAIL; /* appropriate? */                  LIST_INSERT_HEAD(&ifp->if_multiaddrs, in6m, in6m_entry);
                         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
Line 676  in6_addmulti(struct in6_addr *maddr6, st
Line 675  in6_addmulti(struct in6_addr *maddr6, st
                 sockaddr_in6_init(&sin6, maddr6, 0, 0, 0);                  sockaddr_in6_init(&sin6, maddr6, 0, 0, 0);
                 *errorp = if_mcast_op(ifp, SIOCADDMULTI, sin6tosa(&sin6));                  *errorp = if_mcast_op(ifp, SIOCADDMULTI, sin6tosa(&sin6));
                 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);  
                         splx(s);                          splx(s);
                         return (NULL);                          return (NULL);
                 }                  }
   
                 callout_init(&in6m->in6m_timer_ch, CALLOUT_MPSAFE);  
                 callout_setfunc(&in6m->in6m_timer_ch, mld_timeo, in6m);  
                 in6m->in6m_timer = timer;                  in6m->in6m_timer = timer;
                 if (in6m->in6m_timer > 0) {                  if (in6m->in6m_timer > 0) {
                         in6m->in6m_state = MLD_REPORTPENDING;                          in6m->in6m_state = MLD_REPORTPENDING;
Line 717  in6_delmulti(struct in6_multi *in6m)
Line 714  in6_delmulti(struct in6_multi *in6m)
         mld_stoptimer(in6m);          mld_stoptimer(in6m);
   
         if (--in6m->in6m_refcount == 0) {          if (--in6m->in6m_refcount == 0) {
                   int _s;
   
                 /*                  /*
                  * No remaining claims to this record; let MLD6 know                   * No remaining claims to this record; let MLD6 know
                  * that we are leaving the multicast group.                   * that we are leaving the multicast group.
Line 726  in6_delmulti(struct in6_multi *in6m)
Line 725  in6_delmulti(struct in6_multi *in6m)
                 /*                  /*
                  * Unlink from list.                   * Unlink from list.
                  */                   */
                   /* FIXME NOMPSAFE: need to lock */
                 LIST_REMOVE(in6m, in6m_entry);                  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                   * Delete all references of this multicasting group from
                  * the membership arrays                   * the membership arrays
                  */                   */
                 for (ia = in6_ifaddr; ia; ia = ia->ia_next) {                  _s = pserialize_read_enter();
                   IN6_ADDRLIST_READER_FOREACH(ia) {
                         struct in6_multi_mship *imm;                          struct in6_multi_mship *imm;
                         LIST_FOREACH(imm, &ia->ia6_memberships, i6mm_chain) {                          LIST_FOREACH(imm, &ia->ia6_memberships, i6mm_chain) {
                                 if (imm->i6mm_maddr == in6m)                                  if (imm->i6mm_maddr == in6m)
                                         imm->i6mm_maddr = NULL;                                          imm->i6mm_maddr = NULL;
                         }                          }
                 }                  }
                   pserialize_read_exit(_s);
   
                 /*                  /*
                  * Notify the network driver to update its multicast                   * Notify the network driver to update its multicast
Line 753  in6_delmulti(struct in6_multi *in6m)
Line 751  in6_delmulti(struct in6_multi *in6m)
   
                 /* Tell mld_timeo we're halting the timer */                  /* Tell mld_timeo we're halting the timer */
                 in6m->in6m_timer = IN6M_TIMER_UNDEF;                  in6m->in6m_timer = IN6M_TIMER_UNDEF;
                 callout_halt(&in6m->in6m_timer_ch, softnet_lock);                  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);                  callout_destroy(&in6m->in6m_timer_ch);
   
                 free(in6m, M_IPMADDR);                  free(in6m, M_IPMADDR);
Line 761  in6_delmulti(struct in6_multi *in6m)
Line 762  in6_delmulti(struct in6_multi *in6m)
         splx(s);          splx(s);
 }  }
   
   /*
    * 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;
   
           /* XXX NOMPSAFE */
           LIST_FOREACH(in6m, &ifp->if_multiaddrs, in6m_entry) {
                   if (IN6_ARE_ADDR_EQUAL(&in6m->in6m_addr, addr))
                           break;
           }
           return in6m;
   }
   
   bool
   in6_multi_group(const struct in6_addr *addr, const struct ifnet *ifp)
   {
           bool ingroup;
   
           ingroup = in6_lookup_multi(addr, ifp) != NULL;
   
           return ingroup;
   }
   
   /*
    * Purge in6_multi records associated to the interface.
    */
   void
   in6_purge_multi(struct ifnet *ifp)
   {
           struct in6_multi *in6m, *next;
   
           /* XXX NOMPSAFE */
           LIST_FOREACH_SAFE(in6m, &ifp->if_multiaddrs, in6m_entry, next) {
                   in6_delmulti(in6m);
           }
   }
   
 struct in6_multi_mship *  struct in6_multi_mship *
 in6_joingroup(struct ifnet *ifp, struct in6_addr *addr,  in6_joingroup(struct ifnet *ifp, struct in6_addr *addr,
Line 794  in6_leavegroup(struct in6_multi_mship *i
Line 836  in6_leavegroup(struct in6_multi_mship *i
         return 0;          return 0;
 }  }
   
   
 /*  
  * 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;  
         struct in6_multi *in6m;  
   
         IFP_TO_IA6(oia->ia_ifp, ia);  
         if (ia) {       /* there is another address */  
                 KASSERT(ia != oia);  
                 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) {  
                         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:   * DEPRECATED: keep it just to avoid breaking old sysctl users.
  * 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)  
 {  
         struct multi6_kludge *mk;  
         struct in6_multi *in6m;  
   
         LIST_FOREACH(mk, &in6_mk, mk_entry) {  
                 if (mk->mk_ifp == ifp)  
                         break;  
         }  
         if (mk == NULL)  
                 return;  
         while ((in6m = LIST_FIRST(&mk->mk_head)) != NULL) {  
                 LIST_REMOVE(in6m, in6m_entry);  
                 in6m->in6m_ia = ia;  
                 ifaref(&ia->ia_ifa);  
                 LIST_INSERT_HEAD(&ia->ia6_multiaddrs, in6m, in6m_entry);  
         }  
 }  
   
 /*  
  * 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)  
 {  
         struct multi6_kludge *mk;  
   
         LIST_FOREACH(mk, &in6_mk, mk_entry) {  
                 /* 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);  
   
         LIST_INIT(&mk->mk_head);  
         mk->mk_ifp = ifp;  
         LIST_INSERT_HEAD(&in6_mk, mk, mk_entry);  
 }  
   
 void  
 in6_purgemkludge(struct ifnet *ifp)  
 {  
         struct multi6_kludge *mk;  
         struct in6_multi *in6m, *next;  
   
         LIST_FOREACH(mk, &in6_mk, mk_entry) {  
                 if (mk->mk_ifp == ifp)  
                         break;  
         }  
         if (mk == NULL)  
                 return;  
   
         /* leave from all multicast groups joined */  
         for (in6m = LIST_FIRST(&mk->mk_head); in6m != NULL; in6m = next) {  
                 next = LIST_NEXT(in6m, in6m_entry);  
                 in6_delmulti(in6m);  
         }  
         LIST_REMOVE(mk, mk_entry);  
         free(mk, M_IPMADDR);  
 }  
   
 static int  static int
 in6_mkludge_sysctl(SYSCTLFN_ARGS)  in6_mkludge_sysctl(SYSCTLFN_ARGS)
 {  {
         struct multi6_kludge *mk;  
         struct in6_multi *in6m;  
         int error;  
         uint32_t tmp;  
         size_t written;  
   
         if (namelen != 1)          if (namelen != 1)
                 return EINVAL;                  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  static int
Line 971  in6_multicast_sysctl(SYSCTLFN_ARGS)
Line 854  in6_multicast_sysctl(SYSCTLFN_ARGS)
 {  {
         struct ifnet *ifp;          struct ifnet *ifp;
         struct ifaddr *ifa;          struct ifaddr *ifa;
         struct in6_ifaddr *ifa6;          struct in6_ifaddr *ia6;
         struct in6_multi *in6m;          struct in6_multi *in6m;
         uint32_t tmp;          uint32_t tmp;
         int error;          int error;
         size_t written;          size_t written;
           struct psref psref, psref_ia;
           int bound, s;
   
         if (namelen != 1)          if (namelen != 1)
                 return EINVAL;                  return EINVAL;
   
         ifp = if_byindex(name[0]);          bound = curlwp_bind();
         if (ifp == NULL)          ifp = if_get_byindex(name[0], &psref);
           if (ifp == NULL) {
                   curlwp_bindx(bound);
                 return ENODEV;                  return ENODEV;
           }
   
         if (oldp == NULL) {          if (oldp == NULL) {
                 *oldlenp = 0;                  *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) +                                  *oldlenp += 2 * sizeof(struct in6_addr) +
                                     sizeof(uint32_t);                                      sizeof(uint32_t);
                         }                          }
                 }                  }
                   pserialize_read_exit(s);
                   if_put(ifp, &psref);
                   curlwp_bindx(bound);
                 return 0;                  return 0;
         }          }
   
         error = 0;          error = 0;
         written = 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)                  if (ifa->ifa_addr->sa_family != AF_INET6)
                         continue;                          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) +                          if (written + 2 * sizeof(struct in6_addr) +
                             sizeof(uint32_t) > *oldlenp)                              sizeof(uint32_t) > *oldlenp)
                                 goto done;                                  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));                              oldp, sizeof(struct in6_addr));
                         if (error)                          if (error)
                                 goto done;                                  goto done;
Line 1031  in6_multicast_sysctl(SYSCTLFN_ARGS)
Line 927  in6_multicast_sysctl(SYSCTLFN_ARGS)
                         oldp = (char *)oldp + sizeof(tmp);                          oldp = (char *)oldp + sizeof(tmp);
                         written += sizeof(tmp);                          written += sizeof(tmp);
                 }                  }
   
                   s = pserialize_read_enter();
                   ifa_release(ifa, &psref_ia);
   
                   break;
         }          }
           pserialize_read_exit(s);
 done:  done:
           ifa_release(ifa, &psref_ia);
           if_put(ifp, &psref);
           curlwp_bindx(bound);
         *oldlenp = written;          *oldlenp = written;
         return error;          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,          sysctl_createv(clog, 0, NULL, NULL,
Legend:
Removed from v.1.63  
changed lines
  Added in v.1.84
CVSweb <webmaster@jp.NetBSD.org>