[apple/libc.git] / net / FreeBSD / sourcefilter.c

/*-
 * Copyright (c) 2007-2009 Bruce Simpson.
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD: src/lib/libc/net/sourcefilter.c,v 1.5 2009/04/29 09:58:31 bms Exp $");

/* 8120237: enable INET6 */
#define __APPLE_USE_RFC_3542

#include "namespace.h"

#include <sys/types.h>
#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/socket.h>

#include <net/if_dl.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_var.h>

#include <assert.h>
#include <errno.h>
#include <ifaddrs.h>
#include <stdlib.h>
#include <string.h>

#include "un-namespace.h"

/*
 * Advanced (Full-state) multicast group membership APIs [RFC3678]
 * Currently this module assumes IPv4 support (INET) in the base system.
 */
#ifndef INET
#define INET
#endif
/* 8120237: enable INET6 */
#ifndef INET6
#define INET6
#endif

union sockunion {
	struct sockaddr_storage	ss;
	struct sockaddr		sa;
	struct sockaddr_dl	sdl;
#ifdef INET
	struct sockaddr_in	sin;
#endif
#ifdef INET6
	struct sockaddr_in6	sin6;
#endif
};
typedef union sockunion sockunion_t;

#ifndef MIN
#define	MIN(a, b)	((a) < (b) ? (a) : (b))
#endif

/*
 * Internal: Map an IPv4 unicast address to an interface index.
 * This is quite inefficient so it is recommended applications use
 * the newer, more portable, protocol independent API.
 */
static uint32_t
__inaddr_to_index(in_addr_t ifaddr)
{
	struct ifaddrs	*ifa;
	struct ifaddrs	*ifaddrs;
	char		*ifname;
	int		 ifindex;
	sockunion_t	*psu;

	if (getifaddrs(&ifaddrs) < 0)
		return (0);

	ifindex = 0;
	ifname = NULL;

	/*
	 * Pass #1: Find the ifaddr entry corresponding to the
	 * supplied IPv4 address. We should really use the ifindex
	 * consistently for matches, however it is not available to
	 * us on this pass.
	 */
	for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
		psu = (sockunion_t *)ifa->ifa_addr;
		if (psu && psu->ss.ss_family == AF_INET &&
		    psu->sin.sin_addr.s_addr == ifaddr) {
			ifname = ifa->ifa_name;
			break;
		}
	}
	if (ifname == NULL)
		goto out;

	/*
	 * Pass #2: Find the index of the interface matching the name
	 * we obtained from looking up the IPv4 ifaddr in pass #1.
	 * There must be a better way of doing this.
	 */
	for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
		psu = (sockunion_t *)ifa->ifa_addr;
		if (psu && psu->ss.ss_family == AF_LINK &&
		    strcmp(ifa->ifa_name, ifname) == 0) {
			ifindex = psu->sdl.sdl_index;
			break;
		}
	}
	assert(ifindex != 0);

out:
	freeifaddrs(ifaddrs);
	return (ifindex);
}

/*
 * Set IPv4 source filter list in use on socket.
 *
 * Stubbed to setsourcefilter(). Performs conversion of structures which
 * may be inefficient; applications are encouraged to use the
 * protocol-independent API.
 */
int
setipv4sourcefilter(int s, struct in_addr interface, struct in_addr group,
    uint32_t fmode, uint32_t numsrc, struct in_addr *slist)
{
#ifdef INET
	sockunion_t	 tmpgroup;
	struct in_addr	*pina;
	sockunion_t	*psu, *tmpslist;
	int		 err;
	size_t		 i;
	uint32_t	 ifindex;

	assert(s != -1);

	tmpslist = NULL;

	if (!IN_MULTICAST(ntohl(group.s_addr)) ||
	    (fmode != MCAST_INCLUDE && fmode != MCAST_EXCLUDE)) {
		errno = EINVAL;
		return (-1);
	}

	ifindex = __inaddr_to_index(interface.s_addr);
	if (ifindex == 0) {
		errno = EADDRNOTAVAIL;
		return (-1);
	}

	memset(&tmpgroup, 0, sizeof(sockunion_t));
	tmpgroup.sin.sin_family = AF_INET;
	tmpgroup.sin.sin_len = sizeof(struct sockaddr_in);
	tmpgroup.sin.sin_addr = group;

	if (numsrc != 0 || slist != NULL) {
		tmpslist = calloc(numsrc, sizeof(sockunion_t));
		if (tmpslist == NULL) {
			errno = ENOMEM;
			return (-1);
		}

		pina = slist;
		psu = tmpslist;
		for (i = 0; i < numsrc; i++, pina++, psu++) {
			psu->sin.sin_family = AF_INET;
			psu->sin.sin_len = sizeof(struct sockaddr_in);
			psu->sin.sin_addr = *pina;
		}
	}

	err = setsourcefilter(s, ifindex, (struct sockaddr *)&tmpgroup,
	    sizeof(struct sockaddr_in), fmode, numsrc,
	    (struct sockaddr_storage *)tmpslist);

	if (tmpslist != NULL)
		free(tmpslist);

	return (err);
#else /* !INET */
	return (EAFNOSUPPORT);
#endif /* INET */
}

/*
 * Get IPv4 source filter list in use on socket.
 *
 * Stubbed to getsourcefilter(). Performs conversion of structures which
 * may be inefficient; applications are encouraged to use the
 * protocol-independent API.
 * An slist of NULL may be used for guessing the required buffer size.
 */
int
getipv4sourcefilter(int s, struct in_addr interface, struct in_addr group,
    uint32_t *fmode, uint32_t *numsrc, struct in_addr *slist)
{
	sockunion_t	*psu, *tmpslist;
	sockunion_t	 tmpgroup;
	struct in_addr	*pina;
	int		 err;
	size_t		 i;
	uint32_t	 ifindex, onumsrc;

	assert(s != -1);
	assert(fmode != NULL);
	assert(numsrc != NULL);

	onumsrc = *numsrc;
	*numsrc = 0;
	tmpslist = NULL;

	if (!IN_MULTICAST(ntohl(group.s_addr)) ||
	    (onumsrc != 0 && slist == NULL)) {
		errno = EINVAL;
		return (-1);
	}

	ifindex = __inaddr_to_index(interface.s_addr);
	if (ifindex == 0) {
		errno = EADDRNOTAVAIL;
		return (-1);
	}

	memset(&tmpgroup, 0, sizeof(sockunion_t));
	tmpgroup.sin.sin_family = AF_INET;
	tmpgroup.sin.sin_len = sizeof(struct sockaddr_in);
	tmpgroup.sin.sin_addr = group;

	if (onumsrc != 0 || slist != NULL) {
		tmpslist = calloc(onumsrc, sizeof(sockunion_t));
		if (tmpslist == NULL) {
			errno = ENOMEM;
			return (-1);
		}
	}

	err = getsourcefilter(s, ifindex, (struct sockaddr *)&tmpgroup,
	    sizeof(struct sockaddr_in), fmode, numsrc,
	    (struct sockaddr_storage *)tmpslist);

	if (tmpslist != NULL && *numsrc != 0) {
		pina = slist;
		psu = tmpslist;
		for (i = 0; i < MIN(onumsrc, *numsrc); i++, psu++) {
			if (psu->ss.ss_family != AF_INET)
				continue;
			*pina++ = psu->sin.sin_addr;
		}
		free(tmpslist);
	}

	return (err);
}

/*
 * Set protocol-independent source filter list in use on socket.
 */
int
setsourcefilter(int s, uint32_t interface, struct sockaddr *group,
    socklen_t grouplen, uint32_t fmode, uint32_t numsrc,
    struct sockaddr_storage *slist)
{
	struct __msfilterreq	 msfr;
	sockunion_t		*psu;
	int			 level, optname;

	if (fmode != MCAST_INCLUDE && fmode != MCAST_EXCLUDE) {
		errno = EINVAL;
		return (-1);
	}

	psu = (sockunion_t *)group;
	switch (psu->ss.ss_family) {
#ifdef INET
	case AF_INET:
		if ((grouplen != sizeof(struct sockaddr_in) ||
		    !IN_MULTICAST(ntohl(psu->sin.sin_addr.s_addr)))) {
			errno = EINVAL;
			return (-1);
		}
		level = IPPROTO_IP;
		optname = IP_MSFILTER;
		break;
#endif
#ifdef INET6
	case AF_INET6:
		if (grouplen != sizeof(struct sockaddr_in6) ||
		    !IN6_IS_ADDR_MULTICAST(&psu->sin6.sin6_addr)) {
			errno = EINVAL;
			return (-1);
		}
		level = IPPROTO_IPV6;
		optname = IPV6_MSFILTER;
		break;
#endif
	default:
		errno = EAFNOSUPPORT;
		return (-1);
	}

	memset(&msfr, 0, sizeof(msfr));
	msfr.msfr_ifindex = interface;
	msfr.msfr_fmode = fmode;
	msfr.msfr_nsrcs = numsrc;
	memcpy(&msfr.msfr_group, &psu->ss, psu->ss.ss_len);
	msfr.msfr_srcs = slist;		/* pointer */

	return (_setsockopt(s, level, optname, &msfr, sizeof(msfr)));
}

/*
 * Get protocol-independent source filter list in use on socket.
 * An slist of NULL may be used for guessing the required buffer size.
 */
int
getsourcefilter(int s, uint32_t interface, struct sockaddr *group,
    socklen_t grouplen, uint32_t *fmode, uint32_t *numsrc,
    struct sockaddr_storage *slist)
{
	struct __msfilterreq	 msfr;
	sockunion_t		*psu;
	int			 err, level, nsrcs, optlen, optname;

	if (interface == 0 || group == NULL || numsrc == NULL ||
	    fmode == NULL) {
		errno = EINVAL;
		return (-1);
	}

	nsrcs = *numsrc;
	*numsrc = 0;
	*fmode = 0;

	psu = (sockunion_t *)group;
	switch (psu->ss.ss_family) {
#ifdef INET
	case AF_INET:
		if ((grouplen != sizeof(struct sockaddr_in) ||
		    !IN_MULTICAST(ntohl(psu->sin.sin_addr.s_addr)))) {
			errno = EINVAL;
			return (-1);
		}
		level = IPPROTO_IP;
		optname = IP_MSFILTER;
		break;
#endif
#ifdef INET6
	case AF_INET6:
		if (grouplen != sizeof(struct sockaddr_in6) ||
		    !IN6_IS_ADDR_MULTICAST(&psu->sin6.sin6_addr)) {
			errno = EINVAL;
			return (-1);
		}
		level = IPPROTO_IPV6;
		optname = IPV6_MSFILTER;
		break;
#endif
	default:
		errno = EAFNOSUPPORT;
		return (-1);
		break;
	}

	optlen = sizeof(struct __msfilterreq);
	memset(&msfr, 0, optlen);
	msfr.msfr_ifindex = interface;
	msfr.msfr_fmode = 0;
	msfr.msfr_nsrcs = nsrcs;
	memcpy(&msfr.msfr_group, &psu->ss, psu->ss.ss_len);

	/*
	 * msfr_srcs is a pointer to a vector of sockaddr_storage. It
	 * may be NULL. The kernel will always return the total number
	 * of filter entries for the group in msfr.msfr_nsrcs.
	 */
	msfr.msfr_srcs = slist;
	err = _getsockopt(s, level, optname, &msfr, &optlen);
	if (err == 0) {
		*numsrc = msfr.msfr_nsrcs;
		*fmode = msfr.msfr_fmode;
	}

	return (err);
}
Commit	Line	Data
1f2f436a A	1	/*-
	2	* Copyright (c) 2007-2009 Bruce Simpson.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	*
	14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
	15	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	16	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	17	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
	18	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	19	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	20	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	21	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	22	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	23	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	24	* SUCH DAMAGE.
	25	*/
	26
	27	#include <sys/cdefs.h>
	28	__FBSDID("$FreeBSD: src/lib/libc/net/sourcefilter.c,v 1.5 2009/04/29 09:58:31 bms Exp $");
	29
ad3c9f2a A	30	/* 8120237: enable INET6 */
	31	#define __APPLE_USE_RFC_3542
	32
1f2f436a A	33	#include "namespace.h"
	34
	35	#include <sys/types.h>
	36	#include <sys/param.h>
	37	#include <sys/ioctl.h>
	38	#include <sys/socket.h>
	39
	40	#include <net/if_dl.h>
	41	#include <net/if.h>
	42	#include <netinet/in.h>
	43	#include <netinet/in_systm.h>
	44	#include <netinet/ip.h>
	45	#include <netinet/ip_var.h>
	46
	47	#include <assert.h>
	48	#include <errno.h>
	49	#include <ifaddrs.h>
	50	#include <stdlib.h>
	51	#include <string.h>
	52
	53	#include "un-namespace.h"
	54
	55	/*
	56	* Advanced (Full-state) multicast group membership APIs [RFC3678]
	57	* Currently this module assumes IPv4 support (INET) in the base system.
	58	*/
	59	#ifndef INET
	60	#define INET
	61	#endif
ad3c9f2a A	62	/* 8120237: enable INET6 */
	63	#ifndef INET6
	64	#define INET6
	65	#endif
1f2f436a A	66
	67	union sockunion {
	68	struct sockaddr_storage ss;
	69	struct sockaddr sa;
	70	struct sockaddr_dl sdl;
	71	#ifdef INET
	72	struct sockaddr_in sin;
	73	#endif
	74	#ifdef INET6
	75	struct sockaddr_in6 sin6;
	76	#endif
	77	};
	78	typedef union sockunion sockunion_t;
	79
	80	#ifndef MIN
	81	#define MIN(a, b) ((a) < (b) ? (a) : (b))
	82	#endif
	83
	84	/*
	85	* Internal: Map an IPv4 unicast address to an interface index.
	86	* This is quite inefficient so it is recommended applications use
	87	* the newer, more portable, protocol independent API.
	88	*/
	89	static uint32_t
	90	__inaddr_to_index(in_addr_t ifaddr)
	91	{
	92	struct ifaddrs *ifa;
	93	struct ifaddrs *ifaddrs;
	94	char *ifname;
	95	int ifindex;
	96	sockunion_t *psu;
	97
	98	if (getifaddrs(&ifaddrs) < 0)
	99	return (0);
	100
	101	ifindex = 0;
	102	ifname = NULL;
	103
	104	/*
	105	* Pass #1: Find the ifaddr entry corresponding to the
	106	* supplied IPv4 address. We should really use the ifindex
	107	* consistently for matches, however it is not available to
	108	* us on this pass.
	109	*/
	110	for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
	111	psu = (sockunion_t *)ifa->ifa_addr;
	112	if (psu && psu->ss.ss_family == AF_INET &&
	113	psu->sin.sin_addr.s_addr == ifaddr) {
	114	ifname = ifa->ifa_name;
	115	break;
	116	}
	117	}
	118	if (ifname == NULL)
	119	goto out;
	120
	121	/*
	122	* Pass #2: Find the index of the interface matching the name
	123	* we obtained from looking up the IPv4 ifaddr in pass #1.
	124	* There must be a better way of doing this.
	125	*/
	126	for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
	127	psu = (sockunion_t *)ifa->ifa_addr;
	128	if (psu && psu->ss.ss_family == AF_LINK &&
	129	strcmp(ifa->ifa_name, ifname) == 0) {
130	ifindex = psu->sdl.sdl_index;
131	break;
132	}
133	}
134	assert(ifindex != 0);
135
136	out:
137	freeifaddrs(ifaddrs);
138	return (ifindex);
139	}
140
141	/*
142	* Set IPv4 source filter list in use on socket.
143	*
144	* Stubbed to setsourcefilter(). Performs conversion of structures which
145	* may be inefficient; applications are encouraged to use the
146	* protocol-independent API.
147	*/
148	int
149	setipv4sourcefilter(int s, struct in_addr interface, struct in_addr group,
150	uint32_t fmode, uint32_t numsrc, struct in_addr *slist)
151	{
152	#ifdef INET
153	sockunion_t tmpgroup;
154	struct in_addr *pina;
155	sockunion_t psu, tmpslist;
156	int err;
157	size_t i;
158	uint32_t ifindex;
159
160	assert(s != -1);
161
162	tmpslist = NULL;
163
164	if (!IN_MULTICAST(ntohl(group.s_addr)) \|\|
165	(fmode != MCAST_INCLUDE && fmode != MCAST_EXCLUDE)) {
166	errno = EINVAL;
167	return (-1);
168	}
169
170	ifindex = __inaddr_to_index(interface.s_addr);
171	if (ifindex == 0) {
172	errno = EADDRNOTAVAIL;
173	return (-1);
174	}
175
176	memset(&tmpgroup, 0, sizeof(sockunion_t));
177	tmpgroup.sin.sin_family = AF_INET;
178	tmpgroup.sin.sin_len = sizeof(struct sockaddr_in);
179	tmpgroup.sin.sin_addr = group;
180
181	if (numsrc != 0 \|\| slist != NULL) {
182	tmpslist = calloc(numsrc, sizeof(sockunion_t));
183	if (tmpslist == NULL) {
184	errno = ENOMEM;
185	return (-1);
186	}
187
188	pina = slist;
189	psu = tmpslist;
190	for (i = 0; i < numsrc; i++, pina++, psu++) {
191	psu->sin.sin_family = AF_INET;
192	psu->sin.sin_len = sizeof(struct sockaddr_in);
193	psu->sin.sin_addr = *pina;
194	}
195	}
196
197	err = setsourcefilter(s, ifindex, (struct sockaddr *)&tmpgroup,
198	sizeof(struct sockaddr_in), fmode, numsrc,
199	(struct sockaddr_storage *)tmpslist);
200
201	if (tmpslist != NULL)
202	free(tmpslist);
203
204	return (err);
205	#else /* !INET */
206	return (EAFNOSUPPORT);
207	#endif /* INET */
208	}
209
210	/*
211	* Get IPv4 source filter list in use on socket.
212	*
213	* Stubbed to getsourcefilter(). Performs conversion of structures which
214	* may be inefficient; applications are encouraged to use the
215	* protocol-independent API.
216	* An slist of NULL may be used for guessing the required buffer size.
217	*/
218	int
219	getipv4sourcefilter(int s, struct in_addr interface, struct in_addr group,
220	uint32_t fmode, uint32_t numsrc, struct in_addr *slist)
221	{
222	sockunion_t psu, tmpslist;
223	sockunion_t tmpgroup;
224	struct in_addr *pina;
225	int err;
226	size_t i;
227	uint32_t ifindex, onumsrc;
228
229	assert(s != -1);
230	assert(fmode != NULL);
231	assert(numsrc != NULL);
232
233	onumsrc = *numsrc;
234	*numsrc = 0;
235	tmpslist = NULL;
236
237	if (!IN_MULTICAST(ntohl(group.s_addr)) \|\|
238	(onumsrc != 0 && slist == NULL)) {
239	errno = EINVAL;
240	return (-1);
241	}
242
243	ifindex = __inaddr_to_index(interface.s_addr);
244	if (ifindex == 0) {
245	errno = EADDRNOTAVAIL;
246	return (-1);
247	}
248
249	memset(&tmpgroup, 0, sizeof(sockunion_t));
250	tmpgroup.sin.sin_family = AF_INET;
251	tmpgroup.sin.sin_len = sizeof(struct sockaddr_in);
252	tmpgroup.sin.sin_addr = group;
253
254	if (onumsrc != 0 \|\| slist != NULL) {
255	tmpslist = calloc(onumsrc, sizeof(sockunion_t));
256	if (tmpslist == NULL) {
257	errno = ENOMEM;
258	return (-1);
259	}
260	}
261
262	err = getsourcefilter(s, ifindex, (struct sockaddr *)&tmpgroup,
263	sizeof(struct sockaddr_in), fmode, numsrc,
264	(struct sockaddr_storage *)tmpslist);
265
266	if (tmpslist != NULL && *numsrc != 0) {
267	pina = slist;
268	psu = tmpslist;
269	for (i = 0; i < MIN(onumsrc, *numsrc); i++, psu++) {
270	if (psu->ss.ss_family != AF_INET)
271	continue;
272	*pina++ = psu->sin.sin_addr;
273	}
274	free(tmpslist);
275	}
276
277	return (err);
278	}
279
280	/*
281	* Set protocol-independent source filter list in use on socket.
282	*/
283	int
284	setsourcefilter(int s, uint32_t interface, struct sockaddr *group,
285	socklen_t grouplen, uint32_t fmode, uint32_t numsrc,
286	struct sockaddr_storage *slist)
287	{
288	struct __msfilterreq msfr;
289	sockunion_t *psu;
290	int level, optname;
291
292	if (fmode != MCAST_INCLUDE && fmode != MCAST_EXCLUDE) {
293	errno = EINVAL;
294	return (-1);
295	}
296
297	psu = (sockunion_t *)group;
298	switch (psu->ss.ss_family) {
299	#ifdef INET
300	case AF_INET:
301	if ((grouplen != sizeof(struct sockaddr_in) \|\|
302	!IN_MULTICAST(ntohl(psu->sin.sin_addr.s_addr)))) {
303	errno = EINVAL;
304	return (-1);
305	}
306	level = IPPROTO_IP;
307	optname = IP_MSFILTER;
308	break;
309	#endif
310	#ifdef INET6
311	case AF_INET6:
312	if (grouplen != sizeof(struct sockaddr_in6) \|\|
313	!IN6_IS_ADDR_MULTICAST(&psu->sin6.sin6_addr)) {
314	errno = EINVAL;
315	return (-1);
316	}
317	level = IPPROTO_IPV6;
318	optname = IPV6_MSFILTER;
319	break;
320	#endif
321	default:
322	errno = EAFNOSUPPORT;
323	return (-1);
324	}
325
326	memset(&msfr, 0, sizeof(msfr));
327	msfr.msfr_ifindex = interface;
328	msfr.msfr_fmode = fmode;
329	msfr.msfr_nsrcs = numsrc;
330	memcpy(&msfr.msfr_group, &psu->ss, psu->ss.ss_len);
331	msfr.msfr_srcs = slist; /* pointer */
332
333	return (_setsockopt(s, level, optname, &msfr, sizeof(msfr)));
334	}
335
336	/*
337	* Get protocol-independent source filter list in use on socket.
338	* An slist of NULL may be used for guessing the required buffer size.
339	*/
340	int
341	getsourcefilter(int s, uint32_t interface, struct sockaddr *group,
342	socklen_t grouplen, uint32_t fmode, uint32_t numsrc,
343	struct sockaddr_storage *slist)
344	{
345	struct __msfilterreq msfr;
346	sockunion_t *psu;
347	int err, level, nsrcs, optlen, optname;
348
349	if (interface == 0 \|\| group == NULL \|\| numsrc == NULL \|\|
350	fmode == NULL) {
351	errno = EINVAL;
352	return (-1);
353	}
354
355	nsrcs = *numsrc;
356	*numsrc = 0;
357	*fmode = 0;
358
359	psu = (sockunion_t *)group;
360	switch (psu->ss.ss_family) {
361	#ifdef INET
362	case AF_INET:
363	if ((grouplen != sizeof(struct sockaddr_in) \|\|
364	!IN_MULTICAST(ntohl(psu->sin.sin_addr.s_addr)))) {
365	errno = EINVAL;
366	return (-1);
367	}
368	level = IPPROTO_IP;
369	optname = IP_MSFILTER;
370	break;
371	#endif
372	#ifdef INET6
373	case AF_INET6:
374	if (grouplen != sizeof(struct sockaddr_in6) \|\|
375	!IN6_IS_ADDR_MULTICAST(&psu->sin6.sin6_addr)) {
376	errno = EINVAL;
377	return (-1);
378	}
379	level = IPPROTO_IPV6;
380	optname = IPV6_MSFILTER;
381	break;
382	#endif
383	default:
384	errno = EAFNOSUPPORT;
385	return (-1);
386	break;
387	}
388
389	optlen = sizeof(struct __msfilterreq);
390	memset(&msfr, 0, optlen);
391	msfr.msfr_ifindex = interface;
392	msfr.msfr_fmode = 0;
393	msfr.msfr_nsrcs = nsrcs;
394	memcpy(&msfr.msfr_group, &psu->ss, psu->ss.ss_len);
395
396	/*
397	* msfr_srcs is a pointer to a vector of sockaddr_storage. It
398	* may be NULL. The kernel will always return the total number
399	* of filter entries for the group in msfr.msfr_nsrcs.
400	*/
401	msfr.msfr_srcs = slist;
402	err = _getsockopt(s, level, optname, &msfr, &optlen);
403	if (err == 0) {
404	*numsrc = msfr.msfr_nsrcs;
405	*fmode = msfr.msfr_fmode;
406	}
407
408	return (err);
409	}