[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.48 and 1.58

version 1.48, 2008/11/07 00:20:18 version 1.58, 2014/07/25 07:12:55
Line 116  __KERNEL_RCSID(0, "$NetBSD$");
Line 116  __KERNEL_RCSID(0, "$NetBSD$");
 #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 <net/if.h>  #include <net/if.h>
   
Line 136  __KERNEL_RCSID(0, "$NetBSD$");
Line 137  __KERNEL_RCSID(0, "$NetBSD$");
  * This structure is used to keep track of in6_multi chains which belong to   * This structure is used to keep track of in6_multi chains which belong to
  * deleted interface addresses.   * deleted interface addresses.
  */   */
 static LIST_HEAD(, multi6_kludge) in6_mk; /* XXX BSS initialization */  static LIST_HEAD(, multi6_kludge) in6_mk = LIST_HEAD_INITIALIZER(in6_mk);
   
 struct multi6_kludge {  struct multi6_kludge {
         LIST_ENTRY(multi6_kludge) mk_entry;          LIST_ENTRY(multi6_kludge) mk_entry;
Line 182  mld_init(void)
Line 183  mld_init(void)
         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((void *)&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. */
Line 289  mld_start_listening(struct in6_multi *in
Line 290  mld_start_listening(struct in6_multi *in
                 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 324  mld_stop_listening(struct in6_multi *in6
Line 325  mld_stop_listening(struct in6_multi *in6
 void  void
 mld_input(struct mbuf *m, int off)  mld_input(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 = m->m_pkthdr.rcvif;
         struct in6_multi *in6m = NULL;          struct in6_multi *in6m = NULL;
Line 443  mld_input(struct mbuf *m, int off)
Line 444  mld_input(struct mbuf *m, int off)
                         } else if (in6m->in6m_timer == IN6M_TIMER_UNDEF ||                          } else if (in6m->in6m_timer == IN6M_TIMER_UNDEF ||
                             mld_timerresid(in6m) > timer) {                              mld_timerresid(in6m) > timer) {
                                 in6m->in6m_timer =                                  in6m->in6m_timer =
                                    1 + (arc4random() % timer) * hz / 1000;                                     1 + (cprng_fast32() % timer) * hz / 1000;
                                 mld_starttimer(in6m);                                  mld_starttimer(in6m);
                         }                          }
                 }                  }
Line 556  mld_sendpkt(struct in6_multi *in6m, int 
Line 557  mld_sendpkt(struct in6_multi *in6m, int 
         }          }
   
         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);
 }  }
   
 static struct mld_hdr *  static struct mld_hdr *
Line 616  in6_addmulti(struct in6_addr *maddr6, st
Line 617  in6_addmulti(struct in6_addr *maddr6, st
         int *errorp, int timer)          int *errorp, int timer)
 {  {
         struct  in6_ifaddr *ia;          struct  in6_ifaddr *ia;
         struct  in6_ifreq ifr;          struct  sockaddr_in6 sin6;
         struct  in6_multi *in6m;          struct  in6_multi *in6m;
         int     s = splsoftnet();          int     s = splsoftnet();
   
Line 637  in6_addmulti(struct in6_addr *maddr6, st
Line 638  in6_addmulti(struct in6_addr *maddr6, st
                  * 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);                          splx(s);
                         *errorp = ENOBUFS;                          *errorp = ENOBUFS;
                         return (NULL);                          return (NULL);
                 }                  }
   
                 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;
Line 664  in6_addmulti(struct in6_addr *maddr6, st
Line 664  in6_addmulti(struct in6_addr *maddr6, st
                  * 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.
                  */                   */
                 sockaddr_in6_init(&ifr.ifr_addr, maddr6, 0, 0, 0);                  sockaddr_in6_init(&sin6, maddr6, 0, 0, 0);
                 *errorp = (*ifp->if_ioctl)(ifp, SIOCADDMULTI, &ifr);                  *errorp = if_mcast_op(ifp, SIOCADDMULTI, sin6tosa(&sin6));
                 if (*errorp) {                  if (*errorp) {
                         LIST_REMOVE(in6m, in6m_entry);                          LIST_REMOVE(in6m, in6m_entry);
                         free(in6m, M_IPMADDR);                          free(in6m, M_IPMADDR);
Line 701  in6_addmulti(struct in6_addr *maddr6, st
Line 701  in6_addmulti(struct in6_addr *maddr6, st
 void  void
 in6_delmulti(struct in6_multi *in6m)  in6_delmulti(struct in6_multi *in6m)
 {  {
         struct  in6_ifreq ifr;          struct  sockaddr_in6 sin6;
         struct  in6_ifaddr *ia;          struct  in6_ifaddr *ia;
         int     s = splsoftnet();          int     s = splsoftnet();
   
Line 739  in6_delmulti(struct in6_multi *in6m)
Line 739  in6_delmulti(struct in6_multi *in6m)
                  * Notify the network driver to update its multicast                   * Notify the network driver to update its multicast
                  * reception filter.                   * reception filter.
                  */                   */
                 sockaddr_in6_init(&ifr.ifr_addr, &in6m->in6m_addr, 0, 0, 0);                  sockaddr_in6_init(&sin6, &in6m->in6m_addr, 0, 0, 0);
                 (*in6m->in6m_ifp->if_ioctl)(in6m->in6m_ifp, SIOCDELMULTI, &ifr);                  if_mcast_op(in6m->in6m_ifp, SIOCDELMULTI, sin6tosa(&sin6));
                 callout_destroy(&in6m->in6m_timer_ch);                  callout_destroy(&in6m->in6m_timer_ch);
                 free(in6m, M_IPMADDR);                  free(in6m, M_IPMADDR);
         }          }
Line 754  in6_joingroup(struct ifnet *ifp, struct 
Line 754  in6_joingroup(struct ifnet *ifp, struct 
 {  {
         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, timer);
         if (!imm->i6mm_maddr) {          if (!imm->i6mm_maddr) {
                 /* *errorp is already set */                  /* *errorp is already set */
Line 870  in6_createmkludge(struct ifnet *ifp)
Line 869  in6_createmkludge(struct ifnet *ifp)
                         return;                          return;
         }          }
   
         mk = malloc(sizeof(*mk), M_IPMADDR, M_WAITOK);          mk = malloc(sizeof(*mk), M_IPMADDR, M_ZERO|M_WAITOK);
   
         memset(mk, 0, sizeof(*mk));  
         LIST_INIT(&mk->mk_head);          LIST_INIT(&mk->mk_head);
         mk->mk_ifp = ifp;          mk->mk_ifp = ifp;
         LIST_INSERT_HEAD(&in6_mk, mk, mk_entry);          LIST_INSERT_HEAD(&in6_mk, mk, mk_entry);
Line 899  in6_purgemkludge(struct ifnet *ifp)
Line 897  in6_purgemkludge(struct ifnet *ifp)
         LIST_REMOVE(mk, mk_entry);          LIST_REMOVE(mk, mk_entry);
         free(mk, M_IPMADDR);          free(mk, M_IPMADDR);
 }  }
   
   static int
   in6_mkludge_sysctl(SYSCTLFN_ARGS)
   {
           struct multi6_kludge *mk;
           struct in6_multi *in6m;
           int error;
           uint32_t tmp;
           size_t written;
   
           if (namelen != 1)
                   return EINVAL;
   
           if (oldp == NULL) {
                   *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
   in6_multicast_sysctl(SYSCTLFN_ARGS)
   {
           struct ifnet *ifp;
           struct ifaddr *ifa;
           struct in6_ifaddr *ifa6;
           struct in6_multi *in6m;
           uint32_t tmp;
           int error;
           size_t written;
   
           if (namelen != 1)
                   return EINVAL;
   
           ifp = if_byindex(name[0]);
           if (ifp == NULL)
                   return ENODEV;
   
           if (oldp == NULL) {
                   *oldlenp = 0;
                   IFADDR_FOREACH(ifa, ifp) {
                           if (ifa->ifa_addr == NULL)
                                   continue;
                           if (ifa->ifa_addr->sa_family != AF_INET6)
                                   continue;
                           ifa6 = (struct in6_ifaddr *)ifa;
                           LIST_FOREACH(in6m, &ifa6->ia6_multiaddrs, in6m_entry) {
                                   *oldlenp += 2 * sizeof(struct in6_addr) +
                                       sizeof(uint32_t);
                           }
                   }
                   return 0;
           }
   
           error = 0;
           written = 0;
           IFADDR_FOREACH(ifa, ifp) {
                   if (ifa->ifa_addr == NULL)
                           continue;
                   if (ifa->ifa_addr->sa_family != AF_INET6)
                           continue;
                   ifa6 = (struct in6_ifaddr *)ifa;
                   LIST_FOREACH(in6m, &ifa6->ia6_multiaddrs, in6m_entry) {
                           if (written + 2 * sizeof(struct in6_addr) +
                               sizeof(uint32_t) > *oldlenp)
                                   goto done;
                           error = sysctl_copyout(l, &ifa6->ia_addr.sin6_addr,
                               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);
                   }
           }
   done:
           *oldlenp = written;
           return error;
   }
   
   SYSCTL_SETUP(sysctl_in6_mklude_setup, "sysctl net.inet6.multicast_kludge subtree setup")
   {
   
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT,
                          CTLTYPE_NODE, "multicast",
                          SYSCTL_DESCR("Multicast information"),
                          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.48  
changed lines
  Added in v.1.58

CVSweb <webmaster@jp.NetBSD.org>