[apple/xnu.git] / bsd / net / iptap.c

/*
 * Copyright (c) 1999-2010 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 *
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
#include <string.h>
#include <stdint.h>
#include <stdbool.h>
#include <mach/mach_types.h>
#include <kern/locks.h>
#include <sys/kernel.h>
#include <sys/param.h>
#include <sys/sockio.h>
#include <sys/socket.h>
#include <sys/queue.h>
#include <sys/cdefs.h>
#include <sys/kern_control.h>
#include <sys/uio_internal.h>
#include <sys/mbuf.h>
#include <net/if_types.h>
#include <net/if.h>
#include <net/kpi_interface.h>
#include <net/bpf.h>
#include <net/iptap.h>
#include <netinet/kpi_ipfilter.h>
#include <libkern/libkern.h>
#include <libkern/OSMalloc.h>
#include <libkern/OSAtomic.h>

#include <IOKit/IOLib.h>

#define	IPTAP_IF_NAME			"iptap"
#define IPTAP_PRINTF			printf
#define IP_TAP_NOT_USED			0

#define VALID_PACKET(type, label)\
			if (iptap_clients == 0)		\
				goto label;				\
										\
			if (type != IFT_ETHER &&	\
				type != IFT_CELLULAR)	\
				goto label

static void				*iptap_alloc(size_t);
static void				iptap_free(void *);
static errno_t			iptap_register_control(void);
static inline void		iptap_lock_shared(void);
static inline void		iptap_lock_exclusive(void);
static inline void		iptap_lock_done(void);
static void				iptap_alloc_lock(void);
static void				iptap_free_lock(void);

static void				iptap_enqueue_mbuf(struct ifnet *, protocol_family_t, struct mbuf *, u_int32_t, u_int32_t, u_int8_t);

/* kernctl callbacks */
static errno_t			iptap_ctl_connect(kern_ctl_ref, struct sockaddr_ctl *, void **);
static errno_t			iptap_ctl_disconnect(kern_ctl_ref, u_int32_t, void *);

#if IP_TAP_NOT_USED

static errno_t			iptap_deregister_control(void);

static errno_t			iptap_ctl_send(kern_ctl_ref, u_int32_t, void *, mbuf_t, int);
static errno_t			iptap_ctl_setopt(kern_ctl_ref, u_int32_t, void *, int, void *, size_t);
static errno_t			iptap_ctl_getopt(kern_ctl_ref, u_int32_t, void *, int, void *, size_t *);

#endif	/* IP_TAP_NOT_USED */

decl_lck_rw_data(static, iptap_mtx);
static lck_grp_t		*iptap_grp;
static kern_ctl_ref		iptap_kernctl;
static unsigned int		iptap_clients;
static OSMallocTag		iptap_malloc_tag;

struct iptap_client_t {
	LIST_ENTRY(iptap_client_t)		_cle;
	u_int32_t						_unit;
};

static LIST_HEAD(, iptap_client_t)	_s_iptap_clients;


__private_extern__ void
iptap_init(void) {
    
	iptap_alloc_lock();
	
	iptap_malloc_tag = OSMalloc_Tagalloc(IPTAP_CONTROL_NAME, OSMT_DEFAULT);
	if (iptap_malloc_tag == NULL) {
		iptap_free_lock();
		IPTAP_PRINTF("iptap_init failed: unable to allocate malloc tag.\n");
		return;
	}
	
	if (iptap_register_control() != 0) {
		iptap_free_lock();
		OSMalloc_Tagfree(iptap_malloc_tag);
		IPTAP_PRINTF("iptap_init failed: iptap_register_control failure.\n");
		return;
	}
	
	iptap_clients = 0;
}

__private_extern__ void
iptap_ipf_input(struct ifnet *ifp, protocol_family_t proto, struct mbuf *mp, char *frame_header)
{	
	VALID_PACKET(ifp->if_type, done);

	do {
		char *hdr = (char *)mbuf_data(mp);
		size_t start = (size_t)((char*)mbuf_datastart(mp));
		size_t o_len = mp->m_len;
		
		if (frame_header != NULL && (size_t)frame_header >= start && (size_t)frame_header <= (size_t)hdr) {
			if (mbuf_setdata(mp, frame_header, o_len + ((size_t)hdr - (size_t)frame_header)) == 0) {
				iptap_enqueue_mbuf(ifp, proto, mp, ((size_t)hdr - (size_t)frame_header), 0, IPTAP_INPUT_TAG);
				mbuf_setdata(mp, hdr, o_len);
			}
		} else {
			iptap_enqueue_mbuf(ifp, proto, mp, 0, 0, IPTAP_INPUT_TAG);
		}
		
	} while (0);

done:
	return;
}

__private_extern__ void
iptap_ipf_output(struct ifnet *ifp, protocol_family_t proto, struct mbuf *mp, u_int32_t pre, u_int32_t post)
{	
	VALID_PACKET(ifp->if_type, done);
	
	iptap_enqueue_mbuf(ifp, proto, mp, pre, post, IPTAP_OUTPUT_TAG);
	
done:
	return;
}

static void
iptap_enqueue_mbuf(struct ifnet *ifp, protocol_family_t proto, struct mbuf *mp, u_int32_t pre, u_int32_t post, u_int8_t io)
{
	errno_t err = 0;
	struct iptap_client_t *client = NULL;
	mbuf_t copy, itr = (mbuf_t)mp;
	iptap_hdr_t header;
	u_int32_t len = 0;
	
	memset(&header, 0x0, sizeof(header));
	header.version = IPTAP_VERSION_1;
	header.type = ifp->if_type;
	header.unit = ifp->if_unit;
	strlcpy(header.if_name, ifp->if_name, sizeof(header.if_name));
	header.hdr_length = sizeof(header);
	header.protocol_family = proto;
	header.frame_pre_length = pre;
	header.frame_pst_length = post;
	header.io = io;
	
	do {
		len += mbuf_len(itr);
		itr = mbuf_next(itr);
	} while (itr != NULL);
	
	iptap_lock_shared();
	
	LIST_FOREACH(client, &_s_iptap_clients, _cle) {
		
		mbuf_dup((mbuf_t)mp, MBUF_DONTWAIT, &copy);
		if (copy == NULL)
			continue;
		
		err = mbuf_prepend(&copy, sizeof(header), MBUF_DONTWAIT);
		if (err != 0) {
			if (copy != NULL) {
				mbuf_freem(copy);
				copy = NULL;
			}
			continue;
		}
		
		HTONS(header.unit);
		HTONL(header.hdr_length);
		HTONL(header.protocol_family);
		HTONL(header.frame_pre_length);
		HTONL(header.frame_pst_length);
		header.length = htonl(len);
		
		memcpy(mbuf_data(copy), &header, sizeof(header));
		
		err = ctl_enqueuembuf(iptap_kernctl, client->_unit, copy, CTL_DATA_EOR);
		if (err != 0) {
			mbuf_freem(copy);
			copy = NULL;
			IPTAP_PRINTF("iptap_enqueue_mbuf failed: %d\n", (err));
			continue;
		}
	}
	
	iptap_lock_done();
}

static void*
iptap_alloc(size_t size)
{
	size_t *mem = OSMalloc(size + sizeof(size_t), iptap_malloc_tag);
	
	if (mem) {
		*mem = size + sizeof(size_t);
		mem++;
		memset(mem, 0x0, size);
	}
	
	return (void*)mem;
}

static void
iptap_free(void *ptr)
{
	size_t *size = ptr;
	size--;
	OSFree(size, *size, iptap_malloc_tag);
	ptr = NULL;
}

static void
iptap_alloc_lock(void)
{
	lck_grp_attr_t *grp_attr;
	lck_attr_t *attr;
	
	grp_attr = lck_grp_attr_alloc_init();
	lck_grp_attr_setdefault(grp_attr);
	iptap_grp = lck_grp_alloc_init(IPTAP_IF_NAME, grp_attr);
	lck_grp_attr_free(grp_attr);
	
	attr = lck_attr_alloc_init();
	lck_attr_setdefault(attr);
	
	lck_rw_init(&iptap_mtx, iptap_grp, attr);
	lck_attr_free(attr);
}

static void
iptap_free_lock(void)
{
	lck_rw_destroy(&iptap_mtx, iptap_grp);
	lck_grp_free(iptap_grp);
	iptap_grp = NULL;
}

static inline void
iptap_lock_shared(void)
{
	lck_rw_lock_shared(&iptap_mtx);
}

static inline void
iptap_lock_exclusive(void)
{
	lck_rw_lock_exclusive(&iptap_mtx);
}

static inline void
iptap_lock_done(void)
{
	lck_rw_done(&iptap_mtx);
}

static errno_t
iptap_register_control(void)
{
	errno_t err = 0;
	struct kern_ctl_reg kern_ctl;
	
	bzero(&kern_ctl, sizeof(kern_ctl));
	strlcpy(kern_ctl.ctl_name, IPTAP_CONTROL_NAME, sizeof(kern_ctl.ctl_name));
	kern_ctl.ctl_name[sizeof(kern_ctl.ctl_name) - 1] = 0;
	kern_ctl.ctl_flags = CTL_FLAG_PRIVILEGED;
	kern_ctl.ctl_recvsize = IPTAP_BUFFERSZ;
	kern_ctl.ctl_connect = iptap_ctl_connect;
	kern_ctl.ctl_disconnect = iptap_ctl_disconnect;
	kern_ctl.ctl_send = NULL;
	kern_ctl.ctl_setopt = NULL;
	kern_ctl.ctl_getopt = NULL;
	
	err = ctl_register(&kern_ctl, &iptap_kernctl);
	
	return (err);
}

static errno_t
iptap_ctl_connect(kern_ctl_ref kctlref, struct sockaddr_ctl *sac, void **unitinfo)
{
#pragma unused(kctlref)
#pragma unused(unitinfo)
	errno_t err = 0;
	struct iptap_client_t *client = NULL;
	
	client = (struct iptap_client_t *)iptap_alloc(sizeof(struct iptap_client_t));
	if (client != NULL) {
		iptap_lock_exclusive();
		
		iptap_clients++;
		client->_unit = sac->sc_unit;
		LIST_INSERT_HEAD(&_s_iptap_clients, client, _cle);
		
		iptap_lock_done();
	} else {
		err = ENOMEM;
	}
	
	return (err == 0) ? (0) : (err);
}

static errno_t
iptap_ctl_disconnect(kern_ctl_ref kctlref, u_int32_t unit, void *unitinfo)
{
#pragma unused(kctlref)
#pragma unused(unitinfo)
	errno_t err = 0;
	struct iptap_client_t *client = NULL;
	
	iptap_lock_exclusive();
	
	LIST_FOREACH(client, &_s_iptap_clients, _cle) {
		if (client->_unit == unit) {
			iptap_clients--;
			LIST_REMOVE(client, _cle);
			break;
		}
	}
	
	iptap_lock_done();
	
	/* get rid of all the interfaces before free'ing */
	iptap_free(client);
	
	if (client == NULL)
		panic("iptap_ctl_disconnect: received a disconnect notification without a cache entry.\n");
	
	return (err == 0) ? (0) : (err);
}

#if IP_TAP_NOT_USED

__private_extern__ void
iptap_destroy(void) {
	
	if (iptap_clients != 0) {
		IPTAP_PRINTF("iptap_destroy failed: there are still outstanding clients.\n");
		return;
	}
	
	if (iptap_deregister_control() != 0) {
		IPTAP_PRINTF("iptap_destroy failed: iptap_deregister_control failed.\n");
	}
	
	OSMalloc_Tagfree(iptap_malloc_tag);
	
	iptap_free_lock();
}

static errno_t
iptap_deregister_control(void)
{
	errno_t err = 0;
	
	if (iptap_kernctl != NULL) {
		err = ctl_deregister(iptap_kernctl);
	} else {
		err = EINVAL;
	}
	
	return (err); 
}

static errno_t
iptap_ctl_send(kern_ctl_ref kctlref, u_int32_t unit, void *unitinfo, mbuf_t m, int flags)
{
#pragma unused(kctlref)
#pragma unused(unit)
#pragma unused(unitinfo)
#pragma unused(m)
#pragma unused(flags)
	return (KERN_SUCCESS);
}

static errno_t
iptap_ctl_setopt(kern_ctl_ref kctlref, u_int32_t unit, void *unitinfo, int opt, void *data, size_t len)
{	
#pragma unused(kctlref)
#pragma unused(unit)
#pragma unused(unitinfo)
#pragma unused(opt)
#pragma unused(data)
#pragma unused(len)
	return (KERN_SUCCESS);
}

static errno_t
iptap_ctl_getopt(kern_ctl_ref kctlref, u_int32_t unit, void *unitinfo, int opt, void *data, size_t *len)
{
#pragma unused(kctlref)
#pragma unused(unit)
#pragma unused(unitinfo)
#pragma unused(opt)
#pragma unused(data)
#pragma unused(len)
	return (KERN_SUCCESS);
}

#endif /* IP_TAP_NOT_USED */
Commit	Line	Data
316670eb A	1	/*
	2	* Copyright (c) 1999-2010 Apple Inc. All rights reserved.
	3	*
	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
	14	*
	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
	25	*
	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
	27	*/
	28	#include <string.h>
	29	#include <stdint.h>
	30	#include <stdbool.h>
	31	#include <mach/mach_types.h>
	32	#include <kern/locks.h>
	33	#include <sys/kernel.h>
	34	#include <sys/param.h>
	35	#include <sys/sockio.h>
	36	#include <sys/socket.h>
	37	#include <sys/queue.h>
	38	#include <sys/cdefs.h>
	39	#include <sys/kern_control.h>
	40	#include <sys/uio_internal.h>
	41	#include <sys/mbuf.h>
	42	#include <net/if_types.h>
	43	#include <net/if.h>
	44	#include <net/kpi_interface.h>
	45	#include <net/bpf.h>
	46	#include <net/iptap.h>
	47	#include <netinet/kpi_ipfilter.h>
	48	#include <libkern/libkern.h>
	49	#include <libkern/OSMalloc.h>
	50	#include <libkern/OSAtomic.h>
	51
	52	#include <IOKit/IOLib.h>
	53
	54	#define IPTAP_IF_NAME "iptap"
	55	#define IPTAP_PRINTF printf
	56	#define IP_TAP_NOT_USED 0
	57
	58	#define VALID_PACKET(type, label)\
	59	if (iptap_clients == 0) \
	60	goto label; \
	61	\
	62	if (type != IFT_ETHER && \
	63	type != IFT_CELLULAR) \
	64	goto label
65
66	static void *iptap_alloc(size_t);
67	static void iptap_free(void *);
68	static errno_t iptap_register_control(void);
69	static inline void iptap_lock_shared(void);
70	static inline void iptap_lock_exclusive(void);
71	static inline void iptap_lock_done(void);
72	static void iptap_alloc_lock(void);
73	static void iptap_free_lock(void);
74
75	static void iptap_enqueue_mbuf(struct ifnet , protocol_family_t, struct mbuf , u_int32_t, u_int32_t, u_int8_t);
76
77	/* kernctl callbacks */
78	static errno_t iptap_ctl_connect(kern_ctl_ref, struct sockaddr_ctl , void *);
79	static errno_t iptap_ctl_disconnect(kern_ctl_ref, u_int32_t, void *);
80
81	#if IP_TAP_NOT_USED
82
83	static errno_t iptap_deregister_control(void);
84
85	static errno_t iptap_ctl_send(kern_ctl_ref, u_int32_t, void *, mbuf_t, int);
86	static errno_t iptap_ctl_setopt(kern_ctl_ref, u_int32_t, void , int, void , size_t);
87	static errno_t iptap_ctl_getopt(kern_ctl_ref, u_int32_t, void , int, void , size_t *);
88
89	#endif /* IP_TAP_NOT_USED */
90
91	decl_lck_rw_data(static, iptap_mtx);
92	static lck_grp_t *iptap_grp;
93	static kern_ctl_ref iptap_kernctl;
94	static unsigned int iptap_clients;
95	static OSMallocTag iptap_malloc_tag;
96
97	struct iptap_client_t {
98	LIST_ENTRY(iptap_client_t) _cle;
99	u_int32_t _unit;
100	};
101
102	static LIST_HEAD(, iptap_client_t) _s_iptap_clients;
103
104
105	__private_extern__ void
106	iptap_init(void) {
107
108	iptap_alloc_lock();
109
110	iptap_malloc_tag = OSMalloc_Tagalloc(IPTAP_CONTROL_NAME, OSMT_DEFAULT);
111	if (iptap_malloc_tag == NULL) {
112	iptap_free_lock();
113	IPTAP_PRINTF("iptap_init failed: unable to allocate malloc tag.\n");
114	return;
115	}
116
117	if (iptap_register_control() != 0) {
118	iptap_free_lock();
119	OSMalloc_Tagfree(iptap_malloc_tag);
120	IPTAP_PRINTF("iptap_init failed: iptap_register_control failure.\n");
121	return;
122	}
123
124	iptap_clients = 0;
125	}
126
127	__private_extern__ void
128	iptap_ipf_input(struct ifnet ifp, protocol_family_t proto, struct mbuf mp, char *frame_header)
129	{
130	VALID_PACKET(ifp->if_type, done);
131
132	do {
133	char hdr = (char )mbuf_data(mp);
134	size_t start = (size_t)((char*)mbuf_datastart(mp));
135	size_t o_len = mp->m_len;
136
137	if (frame_header != NULL && (size_t)frame_header >= start && (size_t)frame_header <= (size_t)hdr) {
138	if (mbuf_setdata(mp, frame_header, o_len + ((size_t)hdr - (size_t)frame_header)) == 0) {
139	iptap_enqueue_mbuf(ifp, proto, mp, ((size_t)hdr - (size_t)frame_header), 0, IPTAP_INPUT_TAG);
140	mbuf_setdata(mp, hdr, o_len);
141	}
142	} else {
143	iptap_enqueue_mbuf(ifp, proto, mp, 0, 0, IPTAP_INPUT_TAG);
144	}
145
146	} while (0);
147
148	done:
149	return;
150	}
151
152	__private_extern__ void
153	iptap_ipf_output(struct ifnet ifp, protocol_family_t proto, struct mbuf mp, u_int32_t pre, u_int32_t post)
154	{
155	VALID_PACKET(ifp->if_type, done);
156
157	iptap_enqueue_mbuf(ifp, proto, mp, pre, post, IPTAP_OUTPUT_TAG);
158
159	done:
160	return;
161	}
162
163	static void
164	iptap_enqueue_mbuf(struct ifnet ifp, protocol_family_t proto, struct mbuf mp, u_int32_t pre, u_int32_t post, u_int8_t io)
165	{
166	errno_t err = 0;
167	struct iptap_client_t *client = NULL;
168	mbuf_t copy, itr = (mbuf_t)mp;
169	iptap_hdr_t header;
170	u_int32_t len = 0;
171
172	memset(&header, 0x0, sizeof(header));
173	header.version = IPTAP_VERSION_1;
174	header.type = ifp->if_type;
175	header.unit = ifp->if_unit;
176	strlcpy(header.if_name, ifp->if_name, sizeof(header.if_name));
177	header.hdr_length = sizeof(header);
178	header.protocol_family = proto;
179	header.frame_pre_length = pre;
180	header.frame_pst_length = post;
181	header.io = io;
182
183	do {
184	len += mbuf_len(itr);
185	itr = mbuf_next(itr);
186	} while (itr != NULL);
187
188	iptap_lock_shared();
189
190	LIST_FOREACH(client, &_s_iptap_clients, _cle) {
191
192	mbuf_dup((mbuf_t)mp, MBUF_DONTWAIT, &copy);
193	if (copy == NULL)
194	continue;
195
196	err = mbuf_prepend(&copy, sizeof(header), MBUF_DONTWAIT);
197	if (err != 0) {
198	if (copy != NULL) {
199	mbuf_freem(copy);
200	copy = NULL;
201	}
202	continue;
203	}
204
205	HTONS(header.unit);
206	HTONL(header.hdr_length);
207	HTONL(header.protocol_family);
208	HTONL(header.frame_pre_length);
209	HTONL(header.frame_pst_length);
210	header.length = htonl(len);
211
212	memcpy(mbuf_data(copy), &header, sizeof(header));
213
214	err = ctl_enqueuembuf(iptap_kernctl, client->_unit, copy, CTL_DATA_EOR);
215	if (err != 0) {
216	mbuf_freem(copy);
217	copy = NULL;
218	IPTAP_PRINTF("iptap_enqueue_mbuf failed: %d\n", (err));
219	continue;
220	}
221	}
222
223	iptap_lock_done();
224	}
225
226	static void*
227	iptap_alloc(size_t size)
228	{
229	size_t *mem = OSMalloc(size + sizeof(size_t), iptap_malloc_tag);
230
231	if (mem) {
232	*mem = size + sizeof(size_t);
233	mem++;
234	memset(mem, 0x0, size);
235	}
236
237	return (void*)mem;
238	}
239
240	static void
241	iptap_free(void *ptr)
242	{
243	size_t *size = ptr;
244	size--;
245	OSFree(size, *size, iptap_malloc_tag);
246	ptr = NULL;
247	}
248
249	static void
250	iptap_alloc_lock(void)
251	{
252	lck_grp_attr_t *grp_attr;
253	lck_attr_t *attr;
254
255	grp_attr = lck_grp_attr_alloc_init();
256	lck_grp_attr_setdefault(grp_attr);
257	iptap_grp = lck_grp_alloc_init(IPTAP_IF_NAME, grp_attr);
258	lck_grp_attr_free(grp_attr);
259
260	attr = lck_attr_alloc_init();
261	lck_attr_setdefault(attr);
262
263	lck_rw_init(&iptap_mtx, iptap_grp, attr);
264	lck_attr_free(attr);
265	}
266
267	static void
268	iptap_free_lock(void)
269	{
270	lck_rw_destroy(&iptap_mtx, iptap_grp);
271	lck_grp_free(iptap_grp);
272	iptap_grp = NULL;
273	}
274
275	static inline void
276	iptap_lock_shared(void)
277	{
278	lck_rw_lock_shared(&iptap_mtx);
279	}
280
281	static inline void
282	iptap_lock_exclusive(void)
283	{
284	lck_rw_lock_exclusive(&iptap_mtx);
285	}
286
287	static inline void
288	iptap_lock_done(void)
289	{
290	lck_rw_done(&iptap_mtx);
291	}
292
293	static errno_t
294	iptap_register_control(void)
295	{
296	errno_t err = 0;
297	struct kern_ctl_reg kern_ctl;
298
299	bzero(&kern_ctl, sizeof(kern_ctl));
300	strlcpy(kern_ctl.ctl_name, IPTAP_CONTROL_NAME, sizeof(kern_ctl.ctl_name));
301	kern_ctl.ctl_name[sizeof(kern_ctl.ctl_name) - 1] = 0;
302	kern_ctl.ctl_flags = CTL_FLAG_PRIVILEGED;
303	kern_ctl.ctl_recvsize = IPTAP_BUFFERSZ;
304	kern_ctl.ctl_connect = iptap_ctl_connect;
305	kern_ctl.ctl_disconnect = iptap_ctl_disconnect;
306	kern_ctl.ctl_send = NULL;
307	kern_ctl.ctl_setopt = NULL;
308	kern_ctl.ctl_getopt = NULL;
309
310	err = ctl_register(&kern_ctl, &iptap_kernctl);
311
312	return (err);
313	}
314
315	static errno_t
316	iptap_ctl_connect(kern_ctl_ref kctlref, struct sockaddr_ctl sac, void *unitinfo)
317	{
318	#pragma unused(kctlref)
319	#pragma unused(unitinfo)
320	errno_t err = 0;
321	struct iptap_client_t *client = NULL;
322
323	client = (struct iptap_client_t *)iptap_alloc(sizeof(struct iptap_client_t));
324	if (client != NULL) {
325	iptap_lock_exclusive();
326
327	iptap_clients++;
328	client->_unit = sac->sc_unit;
329	LIST_INSERT_HEAD(&_s_iptap_clients, client, _cle);
330
331	iptap_lock_done();
332	} else {
333	err = ENOMEM;
334	}
335
336	return (err == 0) ? (0) : (err);
337	}
338
339	static errno_t
340	iptap_ctl_disconnect(kern_ctl_ref kctlref, u_int32_t unit, void *unitinfo)
341	{
342	#pragma unused(kctlref)
343	#pragma unused(unitinfo)
344	errno_t err = 0;
345	struct iptap_client_t *client = NULL;
346
347	iptap_lock_exclusive();
348
349	LIST_FOREACH(client, &_s_iptap_clients, _cle) {
350	if (client->_unit == unit) {
351	iptap_clients--;
352	LIST_REMOVE(client, _cle);
353	break;
354	}
355	}
356
357	iptap_lock_done();
358
359	/* get rid of all the interfaces before free'ing */
360	iptap_free(client);
361
362	if (client == NULL)
363	panic("iptap_ctl_disconnect: received a disconnect notification without a cache entry.\n");
364
365	return (err == 0) ? (0) : (err);
366	}
367
368	#if IP_TAP_NOT_USED
369
370	__private_extern__ void
371	iptap_destroy(void) {
372
373	if (iptap_clients != 0) {
374	IPTAP_PRINTF("iptap_destroy failed: there are still outstanding clients.\n");
375	return;
376	}
377
378	if (iptap_deregister_control() != 0) {
379	IPTAP_PRINTF("iptap_destroy failed: iptap_deregister_control failed.\n");
380	}
381
382	OSMalloc_Tagfree(iptap_malloc_tag);
383
384	iptap_free_lock();
385	}
386
387	static errno_t
388	iptap_deregister_control(void)
389	{
390	errno_t err = 0;
391
392	if (iptap_kernctl != NULL) {
393	err = ctl_deregister(iptap_kernctl);
394	} else {
395	err = EINVAL;
396	}
397
398	return (err);
399	}
400
401	static errno_t
402	iptap_ctl_send(kern_ctl_ref kctlref, u_int32_t unit, void *unitinfo, mbuf_t m, int flags)
403	{
404	#pragma unused(kctlref)
405	#pragma unused(unit)
406	#pragma unused(unitinfo)
407	#pragma unused(m)
408	#pragma unused(flags)
409	return (KERN_SUCCESS);
410	}
411
412	static errno_t
413	iptap_ctl_setopt(kern_ctl_ref kctlref, u_int32_t unit, void unitinfo, int opt, void data, size_t len)
414	{
415	#pragma unused(kctlref)
416	#pragma unused(unit)
417	#pragma unused(unitinfo)
418	#pragma unused(opt)
419	#pragma unused(data)
420	#pragma unused(len)
421	return (KERN_SUCCESS);
422	}
423
424	static errno_t
425	iptap_ctl_getopt(kern_ctl_ref kctlref, u_int32_t unit, void unitinfo, int opt, void data, size_t *len)
426	{
427	#pragma unused(kctlref)
428	#pragma unused(unit)
429	#pragma unused(unitinfo)
430	#pragma unused(opt)
431	#pragma unused(data)
432	#pragma unused(len)
433	return (KERN_SUCCESS);
434	}
435
436	#endif /* IP_TAP_NOT_USED */
437