[dragonfly.git] / sys / netgraph7 / ng_atmllc.c

/*-
 * Copyright (c) 2003-2004 Benno Rice <benno@eloquent.com.au>
 * 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  ``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  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.
 *
 * $FreeBSD: src/sys/netgraph/ng_atmllc.c,v 1.3 2005/01/07 01:45:39 imp Exp $
 * $DragonFly: src/sys/netgraph7/ng_atmllc.c,v 1.2 2008/06/26 23:05:35 dillon Exp $
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/sockio.h>

#include "ng_message.h"
#include "netgraph.h"
#include "ng_atmllc.h"

#include <net/if.h>
#include <net/ethernet.h>	/* for M_HASFCS and ETHER_HDR_LEN */
#include <net/if_atm.h>		/* for struct atmllc */

#define	NG_ATMLLC_HEADER		"\252\252\3\0\200\302"
#define	NG_ATMLLC_HEADER_LEN		(sizeof(struct atmllc))
#define	NG_ATMLLC_TYPE_ETHERNET_FCS	0x0001
#define	NG_ATMLLC_TYPE_FDDI_FCS		0x0004
#define	NG_ATMLLC_TYPE_ETHERNET_NOFCS	0x0007
#define	NG_ATMLLC_TYPE_FDDI_NOFCS	0x000A

struct ng_atmllc_priv {
	hook_p		atm;
	hook_p		ether;
	hook_p		fddi;
};

/* Netgraph methods. */
static ng_constructor_t		ng_atmllc_constructor;
static ng_shutdown_t		ng_atmllc_shutdown;
static ng_rcvmsg_t		ng_atmllc_rcvmsg;
static ng_newhook_t		ng_atmllc_newhook;
static ng_rcvdata_t		ng_atmllc_rcvdata;
static ng_disconnect_t		ng_atmllc_disconnect;

static struct ng_type ng_atmllc_typestruct = {
	.version =	NG_ABI_VERSION,	
	.name =		NG_ATMLLC_NODE_TYPE,
	.constructor =	ng_atmllc_constructor,
	.rcvmsg =	ng_atmllc_rcvmsg,
	.shutdown =	ng_atmllc_shutdown,
	.newhook =	ng_atmllc_newhook,
	.rcvdata =	ng_atmllc_rcvdata,
	.disconnect =	ng_atmllc_disconnect,
};
NETGRAPH_INIT(atmllc, &ng_atmllc_typestruct);

static int
ng_atmllc_constructor(node_p node)
{
	struct	ng_atmllc_priv *priv;

	priv = kmalloc(sizeof(*priv), M_NETGRAPH,
		       M_WAITOK | M_NULLOK | M_ZERO);
	if (priv == NULL) {
		return (ENOMEM);
	}

	NG_NODE_SET_PRIVATE(node, priv);

	return (0);
}

static int
ng_atmllc_rcvmsg(node_p node, item_p item, hook_p lasthook)
{
	struct	ng_mesg *msg;
	int	error;

	error = 0;
	NGI_GET_MSG(item, msg);
	msg->header.flags |= NGF_RESP;
	NG_RESPOND_MSG(error, node, item, msg);
	return (error);
}

static int
ng_atmllc_shutdown(node_p node)
{
	struct	ng_atmllc_priv *priv;

	priv = NG_NODE_PRIVATE(node);

	kfree(priv, M_NETGRAPH);

	NG_NODE_UNREF(node);

	return (0);
}

static int
ng_atmllc_newhook(node_p node, hook_p hook, const char *name)
{
	struct	ng_atmllc_priv *priv;

	priv = NG_NODE_PRIVATE(node);

	if (strcmp(name, NG_ATMLLC_HOOK_ATM) == 0) {
		if (priv->atm != NULL) {
			return (EISCONN);
		}
		priv->atm = hook;
	} else if (strcmp(name, NG_ATMLLC_HOOK_ETHER) == 0) {
		if (priv->ether != NULL) {
			return (EISCONN);
		}
		priv->ether = hook;
	} else if (strcmp(name, NG_ATMLLC_HOOK_FDDI) == 0) {
		if (priv->fddi != NULL) {
			return (EISCONN);
		}
		priv->fddi = hook;
	} else {
		return (EINVAL);
	}

	return (0);
}

static int
ng_atmllc_rcvdata(hook_p hook, item_p item)
{
	struct	ng_atmllc_priv *priv;
	struct	mbuf *m;
	struct	atmllc *hdr;
	hook_p	outhook;
	u_int	padding;
	int	error;

	priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
	m = NGI_M(item);
	outhook = NULL;
	padding = 0;

	if (hook == priv->atm) {
		/* Ditch the psuedoheader. */
		hdr = mtod(m, struct atmllc *);
		/* m_adj(m, sizeof(struct atm_pseudohdr)); */

		/*
		 * Make sure we have the LLC and ethernet headers.
		 * The ethernet header size is slightly larger than the FDDI
		 * header, which is convenient.
		 */
		if (m->m_len < sizeof(struct atmllc) + ETHER_HDR_LEN) {
			m = m_pullup(m, sizeof(struct atmllc) + ETHER_HDR_LEN);
			if (m == NULL) {
				return (ENOMEM);
			}
		}

		/* Decode the LLC header. */
		hdr = mtod(m, struct atmllc *);
		if (ATM_LLC_TYPE(hdr) == NG_ATMLLC_TYPE_ETHERNET_NOFCS) {
			m->m_flags &= ~M_HASFCS;
			outhook = priv->ether;
			padding = 2;
		} else if (ATM_LLC_TYPE(hdr) == NG_ATMLLC_TYPE_ETHERNET_FCS) {
			m->m_flags |= M_HASFCS;
			outhook = priv->ether;
			padding = 2;
		} else if (ATM_LLC_TYPE(hdr) == NG_ATMLLC_TYPE_FDDI_NOFCS) {
			m->m_flags &= ~M_HASFCS;
			outhook = priv->fddi;
			padding = 3;
		} else if (ATM_LLC_TYPE(hdr) == NG_ATMLLC_TYPE_FDDI_FCS) {
			m->m_flags |= M_HASFCS;
			outhook = priv->fddi;
			padding = 3;
		} else {
			printf("ng_atmllc: unknown type: %x\n",
			    ATM_LLC_TYPE(hdr));
		}

		/* Remove the LLC header and any padding*/
		m_adj(m, sizeof(struct atmllc) + padding);
	} else if (hook == priv->ether) {
		/* Add the LLC header */
		M_PREPEND(m, NG_ATMLLC_HEADER_LEN + 2, MB_DONTWAIT);
		if (m == NULL) {
			printf("ng_atmllc: M_PREPEND failed\n");
			NG_FREE_ITEM(item);
			return (ENOMEM);
		}
		hdr = mtod(m, struct atmllc *);
		bzero((void *)hdr, sizeof(struct atmllc) + 2);
		bcopy(NG_ATMLLC_HEADER, hdr->llchdr, 6);
		if ((m->m_flags & M_HASFCS) != 0) {
			ATM_LLC_SETTYPE(hdr, NG_ATMLLC_TYPE_ETHERNET_FCS);
		} else {
			ATM_LLC_SETTYPE(hdr, NG_ATMLLC_TYPE_ETHERNET_NOFCS);
		}
		outhook = priv->atm;
	} else if (hook == priv->fddi) {
		/* Add the LLC header */
		M_PREPEND(m, NG_ATMLLC_HEADER_LEN + 3, MB_DONTWAIT);
		if (m == NULL) {
			printf("ng_atmllc: M_PREPEND failed\n");
			NG_FREE_ITEM(item);
			return (ENOMEM);
		}
		hdr = mtod(m, struct atmllc *);
		bzero((void *)hdr, sizeof(struct atmllc) + 3);
		bcopy(NG_ATMLLC_HEADER, hdr->llchdr, 6);
		if ((m->m_flags & M_HASFCS) != 0) {
			ATM_LLC_SETTYPE(hdr, NG_ATMLLC_TYPE_FDDI_FCS);
		} else {
			ATM_LLC_SETTYPE(hdr, NG_ATMLLC_TYPE_FDDI_NOFCS);
		}
		outhook = priv->atm;
	}

	if (outhook == NULL) {
		NG_FREE_ITEM(item);
		return (0);
	}

	NG_FWD_NEW_DATA(error, item, outhook, m);
	return (error);
}

static int
ng_atmllc_disconnect(hook_p hook)
{
	node_p	node;
	struct	ng_atmllc_priv *priv;

	node = NG_HOOK_NODE(hook);
	priv = NG_NODE_PRIVATE(node);

	if (hook == priv->atm) {
		priv->atm = NULL;
	} else if (hook == priv->ether) {
		priv->ether = NULL;
	} else if (hook == priv->fddi) {
		priv->fddi = NULL;
	}

	if (NG_NODE_NUMHOOKS(node) == 0 && NG_NODE_IS_VALID(node)) {
		ng_rmnode_self(node);
	}

	return (0);
}
Commit	Line	Data
b06ebda0 MD	1	/*-
	2	* Copyright (c) 2003-2004 Benno Rice <benno@eloquent.com.au>
	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 ``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 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	* $FreeBSD: src/sys/netgraph/ng_atmllc.c,v 1.3 2005/01/07 01:45:39 imp Exp $
5a975a3d	27	* $DragonFly: src/sys/netgraph7/ng_atmllc.c,v 1.2 2008/06/26 23:05:35 dillon Exp $
b06ebda0 MD	28	*/
	29
	30	#include <sys/param.h>
	31	#include <sys/systm.h>
	32	#include <sys/kernel.h>
	33	#include <sys/malloc.h>
	34	#include <sys/mbuf.h>
	35	#include <sys/socket.h>
	36	#include <sys/sockio.h>
	37
5a975a3d MD	38	#include "ng_message.h"
	39	#include "netgraph.h"
	40	#include "ng_atmllc.h"
b06ebda0 MD	41
	42	#include <net/if.h>
	43	#include <net/ethernet.h> /* for M_HASFCS and ETHER_HDR_LEN */
	44	#include <net/if_atm.h> /* for struct atmllc */
	45
	46	#define NG_ATMLLC_HEADER "\252\252\3\0\200\302"
	47	#define NG_ATMLLC_HEADER_LEN (sizeof(struct atmllc))
	48	#define NG_ATMLLC_TYPE_ETHERNET_FCS 0x0001
	49	#define NG_ATMLLC_TYPE_FDDI_FCS 0x0004
	50	#define NG_ATMLLC_TYPE_ETHERNET_NOFCS 0x0007
	51	#define NG_ATMLLC_TYPE_FDDI_NOFCS 0x000A
	52
	53	struct ng_atmllc_priv {
	54	hook_p atm;
	55	hook_p ether;
	56	hook_p fddi;
	57	};
	58
	59	/* Netgraph methods. */
	60	static ng_constructor_t ng_atmllc_constructor;
	61	static ng_shutdown_t ng_atmllc_shutdown;
	62	static ng_rcvmsg_t ng_atmllc_rcvmsg;
	63	static ng_newhook_t ng_atmllc_newhook;
	64	static ng_rcvdata_t ng_atmllc_rcvdata;
	65	static ng_disconnect_t ng_atmllc_disconnect;
	66
	67	static struct ng_type ng_atmllc_typestruct = {
	68	.version = NG_ABI_VERSION,
	69	.name = NG_ATMLLC_NODE_TYPE,
	70	.constructor = ng_atmllc_constructor,
	71	.rcvmsg = ng_atmllc_rcvmsg,
	72	.shutdown = ng_atmllc_shutdown,
	73	.newhook = ng_atmllc_newhook,
	74	.rcvdata = ng_atmllc_rcvdata,
	75	.disconnect = ng_atmllc_disconnect,
	76	};
	77	NETGRAPH_INIT(atmllc, &ng_atmllc_typestruct);
	78
	79	static int
	80	ng_atmllc_constructor(node_p node)
	81	{
	82	struct ng_atmllc_priv *priv;
	83
fc025606 SW	84	priv = kmalloc(sizeof(*priv), M_NETGRAPH,
fc025606 SW	85	M_WAITOK \| M_NULLOK \| M_ZERO);
b06ebda0 MD	86	if (priv == NULL) {
	87	return (ENOMEM);
	88	}
	89
	90	NG_NODE_SET_PRIVATE(node, priv);
	91
	92	return (0);
	93	}
	94
	95	static int
	96	ng_atmllc_rcvmsg(node_p node, item_p item, hook_p lasthook)
	97	{
	98	struct ng_mesg *msg;
	99	int error;
	100
	101	error = 0;
	102	NGI_GET_MSG(item, msg);
	103	msg->header.flags \|= NGF_RESP;
	104	NG_RESPOND_MSG(error, node, item, msg);
	105	return (error);
	106	}
	107
	108	static int
	109	ng_atmllc_shutdown(node_p node)
	110	{
	111	struct ng_atmllc_priv *priv;
	112
	113	priv = NG_NODE_PRIVATE(node);
	114
fc025606	115	kfree(priv, M_NETGRAPH);
b06ebda0 MD	116
	117	NG_NODE_UNREF(node);
	118
	119	return (0);
	120	}
	121
	122	static int
	123	ng_atmllc_newhook(node_p node, hook_p hook, const char *name)
	124	{
	125	struct ng_atmllc_priv *priv;
	126
	127	priv = NG_NODE_PRIVATE(node);
	128
	129	if (strcmp(name, NG_ATMLLC_HOOK_ATM) == 0) {
	130	if (priv->atm != NULL) {
	131	return (EISCONN);
	132	}
	133	priv->atm = hook;
	134	} else if (strcmp(name, NG_ATMLLC_HOOK_ETHER) == 0) {
	135	if (priv->ether != NULL) {
	136	return (EISCONN);
	137	}
	138	priv->ether = hook;
	139	} else if (strcmp(name, NG_ATMLLC_HOOK_FDDI) == 0) {
	140	if (priv->fddi != NULL) {
	141	return (EISCONN);
	142	}
	143	priv->fddi = hook;
	144	} else {
	145	return (EINVAL);
	146	}
	147
	148	return (0);
	149	}
	150
	151	static int
	152	ng_atmllc_rcvdata(hook_p hook, item_p item)
	153	{
	154	struct ng_atmllc_priv *priv;
	155	struct mbuf *m;
	156	struct atmllc *hdr;
	157	hook_p outhook;
	158	u_int padding;
	159	int error;
	160
	161	priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
	162	m = NGI_M(item);
	163	outhook = NULL;
	164	padding = 0;
	165
	166	if (hook == priv->atm) {
	167	/* Ditch the psuedoheader. */
	168	hdr = mtod(m, struct atmllc *);
	169	/* m_adj(m, sizeof(struct atm_pseudohdr)); */
	170
	171	/*
	172	* Make sure we have the LLC and ethernet headers.
	173	* The ethernet header size is slightly larger than the FDDI
	174	* header, which is convenient.
	175	*/
	176	if (m->m_len < sizeof(struct atmllc) + ETHER_HDR_LEN) {
	177	m = m_pullup(m, sizeof(struct atmllc) + ETHER_HDR_LEN);
	178	if (m == NULL) {
	179	return (ENOMEM);
180	}
181	}
182
183	/* Decode the LLC header. */
184	hdr = mtod(m, struct atmllc *);
185	if (ATM_LLC_TYPE(hdr) == NG_ATMLLC_TYPE_ETHERNET_NOFCS) {
186	m->m_flags &= ~M_HASFCS;
187	outhook = priv->ether;
188	padding = 2;
189	} else if (ATM_LLC_TYPE(hdr) == NG_ATMLLC_TYPE_ETHERNET_FCS) {
190	m->m_flags \|= M_HASFCS;
191	outhook = priv->ether;
192	padding = 2;
193	} else if (ATM_LLC_TYPE(hdr) == NG_ATMLLC_TYPE_FDDI_NOFCS) {
194	m->m_flags &= ~M_HASFCS;
195	outhook = priv->fddi;
196	padding = 3;
197	} else if (ATM_LLC_TYPE(hdr) == NG_ATMLLC_TYPE_FDDI_FCS) {
198	m->m_flags \|= M_HASFCS;
199	outhook = priv->fddi;
200	padding = 3;
201	} else {
202	printf("ng_atmllc: unknown type: %x\n",
203	ATM_LLC_TYPE(hdr));
204	}
205
206	/* Remove the LLC header and any padding*/
207	m_adj(m, sizeof(struct atmllc) + padding);
208	} else if (hook == priv->ether) {
209	/* Add the LLC header */
5a975a3d	210	M_PREPEND(m, NG_ATMLLC_HEADER_LEN + 2, MB_DONTWAIT);
b06ebda0 MD	211	if (m == NULL) {
	212	printf("ng_atmllc: M_PREPEND failed\n");
	213	NG_FREE_ITEM(item);
	214	return (ENOMEM);
	215	}
	216	hdr = mtod(m, struct atmllc *);
	217	bzero((void *)hdr, sizeof(struct atmllc) + 2);
	218	bcopy(NG_ATMLLC_HEADER, hdr->llchdr, 6);
	219	if ((m->m_flags & M_HASFCS) != 0) {
	220	ATM_LLC_SETTYPE(hdr, NG_ATMLLC_TYPE_ETHERNET_FCS);
	221	} else {
	222	ATM_LLC_SETTYPE(hdr, NG_ATMLLC_TYPE_ETHERNET_NOFCS);
	223	}
	224	outhook = priv->atm;
	225	} else if (hook == priv->fddi) {
	226	/* Add the LLC header */
5a975a3d	227	M_PREPEND(m, NG_ATMLLC_HEADER_LEN + 3, MB_DONTWAIT);
b06ebda0 MD	228	if (m == NULL) {
	229	printf("ng_atmllc: M_PREPEND failed\n");
	230	NG_FREE_ITEM(item);
	231	return (ENOMEM);
	232	}
	233	hdr = mtod(m, struct atmllc *);
	234	bzero((void *)hdr, sizeof(struct atmllc) + 3);
	235	bcopy(NG_ATMLLC_HEADER, hdr->llchdr, 6);
	236	if ((m->m_flags & M_HASFCS) != 0) {
	237	ATM_LLC_SETTYPE(hdr, NG_ATMLLC_TYPE_FDDI_FCS);
	238	} else {
	239	ATM_LLC_SETTYPE(hdr, NG_ATMLLC_TYPE_FDDI_NOFCS);
	240	}
	241	outhook = priv->atm;
	242	}
	243
	244	if (outhook == NULL) {
	245	NG_FREE_ITEM(item);
	246	return (0);
	247	}
	248
	249	NG_FWD_NEW_DATA(error, item, outhook, m);
	250	return (error);
	251	}
	252
	253	static int
	254	ng_atmllc_disconnect(hook_p hook)
	255	{
	256	node_p node;
	257	struct ng_atmllc_priv *priv;
	258
	259	node = NG_HOOK_NODE(hook);
	260	priv = NG_NODE_PRIVATE(node);
	261
	262	if (hook == priv->atm) {
	263	priv->atm = NULL;
	264	} else if (hook == priv->ether) {
	265	priv->ether = NULL;
	266	} else if (hook == priv->fddi) {
	267	priv->fddi = NULL;
	268	}
	269
	270	if (NG_NODE_NUMHOOKS(node) == 0 && NG_NODE_IS_VALID(node)) {
	271	ng_rmnode_self(node);
	272	}
	273
	274	return (0);
	275	}