/*
 * 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 */