8dd27fd68b
local address, that was assigned with ifconfig alias and netmask 0xffffffff, would receive duplictae udp packets. This behaviour can easily be seen by having named run, and using the alias address as the name server. This solution is not the pretiest one, but after talk with Garreth, it is seen as the most easy one.
702 lines
18 KiB
C
702 lines
18 KiB
C
/*
|
|
* Copyright (c) 1982, 1986, 1991, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* @(#)in.c 8.4 (Berkeley) 1/9/95
|
|
* $Id: in.c,v 1.20 1995/12/09 20:43:52 phk Exp $
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/errno.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/socketvar.h>
|
|
#include <sys/queue.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <net/if.h>
|
|
#include <net/route.h>
|
|
|
|
#include <netinet/in_systm.h>
|
|
#include <netinet/in.h>
|
|
#include <netinet/in_var.h>
|
|
#include <netinet/if_ether.h>
|
|
|
|
#include <netinet/igmp_var.h>
|
|
|
|
/*
|
|
* This structure is used to keep track of in_multi chains which belong to
|
|
* deleted interface addresses.
|
|
*/
|
|
static LIST_HEAD(, multi_kludge) in_mk; /* XXX BSS initialization */
|
|
|
|
struct multi_kludge {
|
|
LIST_ENTRY(multi_kludge) mk_entry;
|
|
struct ifnet *mk_ifp;
|
|
struct in_multihead mk_head;
|
|
};
|
|
|
|
static void in_socktrim __P((struct sockaddr_in *));
|
|
static int in_ifinit __P((struct ifnet *,
|
|
struct in_ifaddr *, struct sockaddr_in *, int));
|
|
static void in_ifscrub __P((struct ifnet *, struct in_ifaddr *));
|
|
|
|
static int subnetsarelocal = 1;
|
|
SYSCTL_INT(_net_inet_ip, OID_AUTO, subnets_are_local, CTLFLAG_RW,
|
|
&subnetsarelocal, 0, "");
|
|
/*
|
|
* Return 1 if an internet address is for a ``local'' host
|
|
* (one to which we have a connection). If subnetsarelocal
|
|
* is true, this includes other subnets of the local net.
|
|
* Otherwise, it includes only the directly-connected (sub)nets.
|
|
*/
|
|
int
|
|
in_localaddr(in)
|
|
struct in_addr in;
|
|
{
|
|
register u_long i = ntohl(in.s_addr);
|
|
register struct in_ifaddr *ia;
|
|
|
|
if (subnetsarelocal) {
|
|
for (ia = in_ifaddr; ia; ia = ia->ia_next)
|
|
if ((i & ia->ia_netmask) == ia->ia_net)
|
|
return (1);
|
|
} else {
|
|
for (ia = in_ifaddr; ia; ia = ia->ia_next)
|
|
if ((i & ia->ia_subnetmask) == ia->ia_subnet)
|
|
return (1);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Determine whether an IP address is in a reserved set of addresses
|
|
* that may not be forwarded, or whether datagrams to that destination
|
|
* may be forwarded.
|
|
*/
|
|
int
|
|
in_canforward(in)
|
|
struct in_addr in;
|
|
{
|
|
register u_long i = ntohl(in.s_addr);
|
|
register u_long net;
|
|
|
|
if (IN_EXPERIMENTAL(i) || IN_MULTICAST(i))
|
|
return (0);
|
|
if (IN_CLASSA(i)) {
|
|
net = i & IN_CLASSA_NET;
|
|
if (net == 0 || net == (IN_LOOPBACKNET << IN_CLASSA_NSHIFT))
|
|
return (0);
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* Trim a mask in a sockaddr
|
|
*/
|
|
static void
|
|
in_socktrim(ap)
|
|
struct sockaddr_in *ap;
|
|
{
|
|
register char *cplim = (char *) &ap->sin_addr;
|
|
register char *cp = (char *) (&ap->sin_addr + 1);
|
|
|
|
ap->sin_len = 0;
|
|
while (--cp >= cplim)
|
|
if (*cp) {
|
|
(ap)->sin_len = cp - (char *) (ap) + 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static int in_interfaces; /* number of external internet interfaces */
|
|
|
|
/*
|
|
* Generic internet control operations (ioctl's).
|
|
* Ifp is 0 if not an interface-specific ioctl.
|
|
*/
|
|
/* ARGSUSED */
|
|
int
|
|
in_control(so, cmd, data, ifp)
|
|
struct socket *so;
|
|
u_long cmd;
|
|
caddr_t data;
|
|
register struct ifnet *ifp;
|
|
{
|
|
register struct ifreq *ifr = (struct ifreq *)data;
|
|
register struct in_ifaddr *ia = 0;
|
|
register struct ifaddr *ifa;
|
|
struct in_ifaddr *oia;
|
|
struct in_aliasreq *ifra = (struct in_aliasreq *)data;
|
|
struct sockaddr_in oldaddr;
|
|
int error, hostIsNew, maskIsNew;
|
|
u_long i;
|
|
struct multi_kludge *mk;
|
|
|
|
/*
|
|
* Find address for this interface, if it exists.
|
|
*/
|
|
if (ifp)
|
|
for (ia = in_ifaddr; ia; ia = ia->ia_next)
|
|
if (ia->ia_ifp == ifp)
|
|
break;
|
|
|
|
switch (cmd) {
|
|
|
|
case SIOCAIFADDR:
|
|
case SIOCDIFADDR:
|
|
if (ifra->ifra_addr.sin_family == AF_INET) {
|
|
for (oia = ia; ia; ia = ia->ia_next) {
|
|
if (ia->ia_ifp == ifp &&
|
|
ia->ia_addr.sin_addr.s_addr ==
|
|
ifra->ifra_addr.sin_addr.s_addr)
|
|
break;
|
|
}
|
|
if ((ifp->if_flags & IFF_POINTOPOINT)
|
|
&& (cmd == SIOCAIFADDR)
|
|
&& (ifra->ifra_dstaddr.sin_addr.s_addr
|
|
== INADDR_ANY)) {
|
|
return EDESTADDRREQ;
|
|
}
|
|
}
|
|
if (cmd == SIOCDIFADDR && ia == 0)
|
|
return (EADDRNOTAVAIL);
|
|
/* FALLTHROUGH */
|
|
case SIOCSIFADDR:
|
|
case SIOCSIFNETMASK:
|
|
case SIOCSIFDSTADDR:
|
|
if ((so->so_state & SS_PRIV) == 0)
|
|
return (EPERM);
|
|
|
|
if (ifp == 0)
|
|
panic("in_control");
|
|
if (ia == (struct in_ifaddr *)0) {
|
|
oia = (struct in_ifaddr *)
|
|
malloc(sizeof *oia, M_IFADDR, M_WAITOK);
|
|
if (oia == (struct in_ifaddr *)NULL)
|
|
return (ENOBUFS);
|
|
bzero((caddr_t)oia, sizeof *oia);
|
|
ia = in_ifaddr;
|
|
if (ia) {
|
|
for ( ; ia->ia_next; ia = ia->ia_next)
|
|
continue;
|
|
ia->ia_next = oia;
|
|
} else
|
|
in_ifaddr = oia;
|
|
ia = oia;
|
|
ifa = ifp->if_addrlist;
|
|
if (ifa) {
|
|
for ( ; ifa->ifa_next; ifa = ifa->ifa_next)
|
|
continue;
|
|
ifa->ifa_next = (struct ifaddr *) ia;
|
|
} else
|
|
ifp->if_addrlist = (struct ifaddr *) ia;
|
|
ia->ia_ifa.ifa_addr = (struct sockaddr *)&ia->ia_addr;
|
|
ia->ia_ifa.ifa_dstaddr
|
|
= (struct sockaddr *)&ia->ia_dstaddr;
|
|
ia->ia_ifa.ifa_netmask
|
|
= (struct sockaddr *)&ia->ia_sockmask;
|
|
ia->ia_sockmask.sin_len = 8;
|
|
if (ifp->if_flags & IFF_BROADCAST) {
|
|
ia->ia_broadaddr.sin_len = sizeof(ia->ia_addr);
|
|
ia->ia_broadaddr.sin_family = AF_INET;
|
|
}
|
|
ia->ia_ifp = ifp;
|
|
if (!(ifp->if_flags & IFF_LOOPBACK))
|
|
in_interfaces++;
|
|
}
|
|
break;
|
|
|
|
case SIOCSIFBRDADDR:
|
|
if ((so->so_state & SS_PRIV) == 0)
|
|
return (EPERM);
|
|
/* FALLTHROUGH */
|
|
|
|
case SIOCGIFADDR:
|
|
case SIOCGIFNETMASK:
|
|
case SIOCGIFDSTADDR:
|
|
case SIOCGIFBRDADDR:
|
|
if (ia == (struct in_ifaddr *)0)
|
|
return (EADDRNOTAVAIL);
|
|
break;
|
|
}
|
|
switch (cmd) {
|
|
|
|
case SIOCGIFADDR:
|
|
*((struct sockaddr_in *)&ifr->ifr_addr) = ia->ia_addr;
|
|
break;
|
|
|
|
case SIOCGIFBRDADDR:
|
|
if ((ifp->if_flags & IFF_BROADCAST) == 0)
|
|
return (EINVAL);
|
|
*((struct sockaddr_in *)&ifr->ifr_dstaddr) = ia->ia_broadaddr;
|
|
break;
|
|
|
|
case SIOCGIFDSTADDR:
|
|
if ((ifp->if_flags & IFF_POINTOPOINT) == 0)
|
|
return (EINVAL);
|
|
*((struct sockaddr_in *)&ifr->ifr_dstaddr) = ia->ia_dstaddr;
|
|
break;
|
|
|
|
case SIOCGIFNETMASK:
|
|
*((struct sockaddr_in *)&ifr->ifr_addr) = ia->ia_sockmask;
|
|
break;
|
|
|
|
case SIOCSIFDSTADDR:
|
|
if ((ifp->if_flags & IFF_POINTOPOINT) == 0)
|
|
return (EINVAL);
|
|
oldaddr = ia->ia_dstaddr;
|
|
ia->ia_dstaddr = *(struct sockaddr_in *)&ifr->ifr_dstaddr;
|
|
if (ifp->if_ioctl && (error = (*ifp->if_ioctl)
|
|
(ifp, SIOCSIFDSTADDR, (caddr_t)ia))) {
|
|
ia->ia_dstaddr = oldaddr;
|
|
return (error);
|
|
}
|
|
if (ia->ia_flags & IFA_ROUTE) {
|
|
ia->ia_ifa.ifa_dstaddr = (struct sockaddr *)&oldaddr;
|
|
rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST);
|
|
ia->ia_ifa.ifa_dstaddr =
|
|
(struct sockaddr *)&ia->ia_dstaddr;
|
|
rtinit(&(ia->ia_ifa), (int)RTM_ADD, RTF_HOST|RTF_UP);
|
|
}
|
|
break;
|
|
|
|
case SIOCSIFBRDADDR:
|
|
if ((ifp->if_flags & IFF_BROADCAST) == 0)
|
|
return (EINVAL);
|
|
ia->ia_broadaddr = *(struct sockaddr_in *)&ifr->ifr_broadaddr;
|
|
break;
|
|
|
|
case SIOCSIFADDR:
|
|
return (in_ifinit(ifp, ia,
|
|
(struct sockaddr_in *) &ifr->ifr_addr, 1));
|
|
|
|
case SIOCSIFNETMASK:
|
|
i = ifra->ifra_addr.sin_addr.s_addr;
|
|
ia->ia_subnetmask = ntohl(ia->ia_sockmask.sin_addr.s_addr = i);
|
|
break;
|
|
|
|
case SIOCAIFADDR:
|
|
maskIsNew = 0;
|
|
hostIsNew = 1;
|
|
error = 0;
|
|
if (ia->ia_addr.sin_family == AF_INET) {
|
|
if (ifra->ifra_addr.sin_len == 0) {
|
|
ifra->ifra_addr = ia->ia_addr;
|
|
hostIsNew = 0;
|
|
} else if (ifra->ifra_addr.sin_addr.s_addr ==
|
|
ia->ia_addr.sin_addr.s_addr)
|
|
hostIsNew = 0;
|
|
}
|
|
if (ifra->ifra_mask.sin_len) {
|
|
in_ifscrub(ifp, ia);
|
|
ia->ia_sockmask = ifra->ifra_mask;
|
|
ia->ia_subnetmask =
|
|
ntohl(ia->ia_sockmask.sin_addr.s_addr);
|
|
maskIsNew = 1;
|
|
}
|
|
if ((ifp->if_flags & IFF_POINTOPOINT) &&
|
|
(ifra->ifra_dstaddr.sin_family == AF_INET)) {
|
|
in_ifscrub(ifp, ia);
|
|
ia->ia_dstaddr = ifra->ifra_dstaddr;
|
|
maskIsNew = 1; /* We lie; but the effect's the same */
|
|
}
|
|
if (ifra->ifra_addr.sin_family == AF_INET &&
|
|
(hostIsNew || maskIsNew))
|
|
error = in_ifinit(ifp, ia, &ifra->ifra_addr, 0);
|
|
if ((ifp->if_flags & IFF_BROADCAST) &&
|
|
(ifra->ifra_broadaddr.sin_family == AF_INET))
|
|
ia->ia_broadaddr = ifra->ifra_broadaddr;
|
|
return (error);
|
|
|
|
case SIOCDIFADDR:
|
|
mk = malloc(sizeof *mk, M_IPMADDR, M_WAITOK);
|
|
if (!mk)
|
|
return ENOBUFS;
|
|
|
|
in_ifscrub(ifp, ia);
|
|
if ((ifa = ifp->if_addrlist) == (struct ifaddr *)ia)
|
|
ifp->if_addrlist = ifa->ifa_next;
|
|
else {
|
|
while (ifa->ifa_next &&
|
|
(ifa->ifa_next != (struct ifaddr *)ia))
|
|
ifa = ifa->ifa_next;
|
|
if (ifa->ifa_next)
|
|
ifa->ifa_next = ((struct ifaddr *)ia)->ifa_next;
|
|
else
|
|
printf("Couldn't unlink inifaddr from ifp\n");
|
|
}
|
|
oia = ia;
|
|
if (oia == (ia = in_ifaddr))
|
|
in_ifaddr = ia->ia_next;
|
|
else {
|
|
while (ia->ia_next && (ia->ia_next != oia))
|
|
ia = ia->ia_next;
|
|
if (ia->ia_next)
|
|
ia->ia_next = oia->ia_next;
|
|
else
|
|
printf("Didn't unlink inifadr from list\n");
|
|
}
|
|
|
|
if (!oia->ia_multiaddrs.lh_first) {
|
|
IFAFREE(&oia->ia_ifa);
|
|
FREE(mk, M_IPMADDR);
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* 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 IP.
|
|
*/
|
|
IFP_TO_IA(oia->ia_ifp, ia);
|
|
if (ia) { /* there is another address */
|
|
struct in_multi *inm;
|
|
for(inm = oia->ia_multiaddrs.lh_first; inm;
|
|
inm = inm->inm_entry.le_next) {
|
|
IFAFREE(&inm->inm_ia->ia_ifa);
|
|
ia->ia_ifa.ifa_refcnt++;
|
|
inm->inm_ia = ia;
|
|
LIST_INSERT_HEAD(&ia->ia_multiaddrs, inm,
|
|
inm_entry);
|
|
}
|
|
FREE(mk, M_IPMADDR);
|
|
} else { /* last address on this if deleted, save */
|
|
struct in_multi *inm;
|
|
|
|
LIST_INIT(&mk->mk_head);
|
|
mk->mk_ifp = ifp;
|
|
|
|
for(inm = oia->ia_multiaddrs.lh_first; inm;
|
|
inm = inm->inm_entry.le_next) {
|
|
LIST_INSERT_HEAD(&mk->mk_head, inm, inm_entry);
|
|
}
|
|
|
|
if (mk->mk_head.lh_first) {
|
|
LIST_INSERT_HEAD(&in_mk, mk, mk_entry);
|
|
} else {
|
|
FREE(mk, M_IPMADDR);
|
|
}
|
|
}
|
|
|
|
IFAFREE((&oia->ia_ifa));
|
|
break;
|
|
|
|
default:
|
|
if (ifp == 0 || ifp->if_ioctl == 0)
|
|
return (EOPNOTSUPP);
|
|
return ((*ifp->if_ioctl)(ifp, cmd, data));
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Delete any existing route for an interface.
|
|
*/
|
|
static void
|
|
in_ifscrub(ifp, ia)
|
|
register struct ifnet *ifp;
|
|
register struct in_ifaddr *ia;
|
|
{
|
|
|
|
if ((ia->ia_flags & IFA_ROUTE) == 0)
|
|
return;
|
|
if (ifp->if_flags & (IFF_LOOPBACK|IFF_POINTOPOINT))
|
|
rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST);
|
|
else
|
|
rtinit(&(ia->ia_ifa), (int)RTM_DELETE, 0);
|
|
ia->ia_flags &= ~IFA_ROUTE;
|
|
}
|
|
|
|
/*
|
|
* Initialize an interface's internet address
|
|
* and routing table entry.
|
|
*/
|
|
static int
|
|
in_ifinit(ifp, ia, sin, scrub)
|
|
register struct ifnet *ifp;
|
|
register struct in_ifaddr *ia;
|
|
struct sockaddr_in *sin;
|
|
int scrub;
|
|
{
|
|
register u_long i = ntohl(sin->sin_addr.s_addr);
|
|
struct sockaddr_in oldaddr;
|
|
int s = splimp(), flags = RTF_UP, error;
|
|
struct multi_kludge *mk;
|
|
|
|
oldaddr = ia->ia_addr;
|
|
ia->ia_addr = *sin;
|
|
/*
|
|
* Give the interface a chance to initialize
|
|
* if this is its first address,
|
|
* and to validate the address if necessary.
|
|
*/
|
|
if (ifp->if_ioctl &&
|
|
(error = (*ifp->if_ioctl)(ifp, SIOCSIFADDR, (caddr_t)ia))) {
|
|
splx(s);
|
|
ia->ia_addr = oldaddr;
|
|
return (error);
|
|
}
|
|
splx(s);
|
|
if (scrub) {
|
|
ia->ia_ifa.ifa_addr = (struct sockaddr *)&oldaddr;
|
|
in_ifscrub(ifp, ia);
|
|
ia->ia_ifa.ifa_addr = (struct sockaddr *)&ia->ia_addr;
|
|
}
|
|
if (IN_CLASSA(i))
|
|
ia->ia_netmask = IN_CLASSA_NET;
|
|
else if (IN_CLASSB(i))
|
|
ia->ia_netmask = IN_CLASSB_NET;
|
|
else
|
|
ia->ia_netmask = IN_CLASSC_NET;
|
|
/*
|
|
* The subnet mask usually includes at least the standard network part,
|
|
* but may may be smaller in the case of supernetting.
|
|
* If it is set, we believe it.
|
|
*/
|
|
if (ia->ia_subnetmask == 0) {
|
|
ia->ia_subnetmask = ia->ia_netmask;
|
|
ia->ia_sockmask.sin_addr.s_addr = htonl(ia->ia_subnetmask);
|
|
} else
|
|
ia->ia_netmask &= ia->ia_subnetmask;
|
|
ia->ia_net = i & ia->ia_netmask;
|
|
ia->ia_subnet = i & ia->ia_subnetmask;
|
|
in_socktrim(&ia->ia_sockmask);
|
|
/*
|
|
* Add route for the network.
|
|
*/
|
|
ia->ia_ifa.ifa_metric = ifp->if_metric;
|
|
if (ifp->if_flags & IFF_BROADCAST) {
|
|
ia->ia_broadaddr.sin_addr.s_addr =
|
|
htonl(ia->ia_subnet | ~ia->ia_subnetmask);
|
|
ia->ia_netbroadcast.s_addr =
|
|
htonl(ia->ia_net | ~ ia->ia_netmask);
|
|
} else if (ifp->if_flags & IFF_LOOPBACK) {
|
|
ia->ia_ifa.ifa_dstaddr = ia->ia_ifa.ifa_addr;
|
|
flags |= RTF_HOST;
|
|
} else if (ifp->if_flags & IFF_POINTOPOINT) {
|
|
if (ia->ia_dstaddr.sin_family != AF_INET)
|
|
return (0);
|
|
flags |= RTF_HOST;
|
|
}
|
|
if ((error = rtinit(&(ia->ia_ifa), (int)RTM_ADD, flags)) == 0)
|
|
ia->ia_flags |= IFA_ROUTE;
|
|
|
|
LIST_INIT(&ia->ia_multiaddrs);
|
|
/*
|
|
* If the interface supports multicast, join the "all hosts"
|
|
* multicast group on that interface.
|
|
*/
|
|
if (ifp->if_flags & IFF_MULTICAST) {
|
|
struct in_addr addr;
|
|
|
|
/*
|
|
* Continuation of multicast address hack:
|
|
* 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.
|
|
*/
|
|
for(mk = in_mk.lh_first; mk; mk = mk->mk_entry.le_next) {
|
|
if(mk->mk_ifp == ifp) {
|
|
struct in_multi *inm;
|
|
|
|
for(inm = mk->mk_head.lh_first; inm;
|
|
inm = inm->inm_entry.le_next) {
|
|
IFAFREE(&inm->inm_ia->ia_ifa);
|
|
ia->ia_ifa.ifa_refcnt++;
|
|
inm->inm_ia = ia;
|
|
LIST_INSERT_HEAD(&ia->ia_multiaddrs,
|
|
inm, inm_entry);
|
|
}
|
|
LIST_REMOVE(mk, mk_entry);
|
|
free(mk, M_IPMADDR);
|
|
break;
|
|
}
|
|
}
|
|
|
|
addr.s_addr = htonl(INADDR_ALLHOSTS_GROUP);
|
|
in_addmulti(&addr, ifp);
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
|
|
/*
|
|
* Return 1 if the address might be a local broadcast address.
|
|
*/
|
|
int
|
|
in_broadcast(in, ifp)
|
|
struct in_addr in;
|
|
struct ifnet *ifp;
|
|
{
|
|
register struct ifaddr *ifa;
|
|
u_long t;
|
|
|
|
if (in.s_addr == INADDR_BROADCAST ||
|
|
in.s_addr == INADDR_ANY)
|
|
return 1;
|
|
if ((ifp->if_flags & IFF_BROADCAST) == 0)
|
|
return 0;
|
|
t = ntohl(in.s_addr);
|
|
/*
|
|
* Look through the list of addresses for a match
|
|
* with a broadcast address.
|
|
*/
|
|
#define ia ((struct in_ifaddr *)ifa)
|
|
for (ifa = ifp->if_addrlist; ifa; ifa = ifa->ifa_next)
|
|
if (ifa->ifa_addr->sa_family == AF_INET &&
|
|
(in.s_addr == ia->ia_broadaddr.sin_addr.s_addr ||
|
|
in.s_addr == ia->ia_netbroadcast.s_addr ||
|
|
/*
|
|
* Check for old-style (host 0) broadcast.
|
|
*/
|
|
t == ia->ia_subnet || t == ia->ia_net) &&
|
|
/*
|
|
* Check for an all one subnetmask. These
|
|
* only exist when an interface gets a secondary
|
|
* address.
|
|
*/
|
|
ia->ia_subnetmask != (u_long)0xffffffff)
|
|
return 1;
|
|
return (0);
|
|
#undef ia
|
|
}
|
|
/*
|
|
* Add an address to the list of IP multicast addresses for a given interface.
|
|
*/
|
|
struct in_multi *
|
|
in_addmulti(ap, ifp)
|
|
register struct in_addr *ap;
|
|
register struct ifnet *ifp;
|
|
{
|
|
register struct in_multi *inm;
|
|
struct ifreq ifr;
|
|
struct in_ifaddr *ia;
|
|
int s = splnet();
|
|
|
|
/*
|
|
* See if address already in list.
|
|
*/
|
|
IN_LOOKUP_MULTI(*ap, ifp, inm);
|
|
if (inm != NULL) {
|
|
/*
|
|
* Found it; just increment the reference count.
|
|
*/
|
|
++inm->inm_refcount;
|
|
}
|
|
else {
|
|
/*
|
|
* New address; allocate a new multicast record
|
|
* and link it into the interface's multicast list.
|
|
*/
|
|
inm = (struct in_multi *)malloc(sizeof(*inm),
|
|
M_IPMADDR, M_NOWAIT);
|
|
if (inm == NULL) {
|
|
splx(s);
|
|
return (NULL);
|
|
}
|
|
inm->inm_addr = *ap;
|
|
inm->inm_ifp = ifp;
|
|
inm->inm_refcount = 1;
|
|
IFP_TO_IA(ifp, ia);
|
|
if (ia == NULL) {
|
|
free(inm, M_IPMADDR);
|
|
splx(s);
|
|
return (NULL);
|
|
}
|
|
inm->inm_ia = ia;
|
|
ia->ia_ifa.ifa_refcnt++; /* gain a reference */
|
|
LIST_INSERT_HEAD(&ia->ia_multiaddrs, inm, inm_entry);
|
|
|
|
/*
|
|
* Ask the network driver to update its multicast reception
|
|
* filter appropriately for the new address.
|
|
*/
|
|
((struct sockaddr_in *)&ifr.ifr_addr)->sin_family = AF_INET;
|
|
((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr = *ap;
|
|
if ((ifp->if_ioctl == NULL) ||
|
|
(*ifp->if_ioctl)(ifp, SIOCADDMULTI,(caddr_t)&ifr) != 0) {
|
|
LIST_REMOVE(inm, inm_entry);
|
|
IFAFREE(&ia->ia_ifa); /* release reference */
|
|
free(inm, M_IPMADDR);
|
|
splx(s);
|
|
return (NULL);
|
|
}
|
|
/*
|
|
* Let IGMP know that we have joined a new IP multicast group.
|
|
*/
|
|
igmp_joingroup(inm);
|
|
}
|
|
splx(s);
|
|
return (inm);
|
|
}
|
|
|
|
/*
|
|
* Delete a multicast address record.
|
|
*/
|
|
void
|
|
in_delmulti(inm)
|
|
register struct in_multi *inm;
|
|
{
|
|
struct ifreq ifr;
|
|
int s = splnet();
|
|
|
|
if (--inm->inm_refcount == 0) {
|
|
/*
|
|
* No remaining claims to this record; let IGMP know that
|
|
* we are leaving the multicast group.
|
|
*/
|
|
igmp_leavegroup(inm);
|
|
/*
|
|
* Unlink from list.
|
|
*/
|
|
LIST_REMOVE(inm, inm_entry);
|
|
IFAFREE(&inm->inm_ia->ia_ifa); /* release reference */
|
|
|
|
/*
|
|
* Notify the network driver to update its multicast reception
|
|
* filter.
|
|
*/
|
|
((struct sockaddr_in *)&(ifr.ifr_addr))->sin_family = AF_INET;
|
|
((struct sockaddr_in *)&(ifr.ifr_addr))->sin_addr =
|
|
inm->inm_addr;
|
|
(*inm->inm_ifp->if_ioctl)(inm->inm_ifp, SIOCDELMULTI,
|
|
(caddr_t)&ifr);
|
|
free(inm, M_IPMADDR);
|
|
}
|
|
splx(s);
|
|
}
|