[linux-2.6-block.git] / net / llc / llc_if.c

/*
 * llc_if.c - Defines LLC interface to upper layer
 *
 * Copyright (c) 1997 by Procom Technology, Inc.
 * 		 2001-2003 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
 *
 * This program can be redistributed or modified under the terms of the
 * GNU General Public License as published by the Free Software Foundation.
 * This program is distributed without any warranty or implied warranty
 * of merchantability or fitness for a particular purpose.
 *
 * See the GNU General Public License for more details.
 */
#include <linux/gfp.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <asm/errno.h>
#include <net/llc_if.h>
#include <net/llc_sap.h>
#include <net/llc_s_ev.h>
#include <net/llc_conn.h>
#include <net/sock.h>
#include <net/llc_c_ev.h>
#include <net/llc_c_ac.h>
#include <net/llc_c_st.h>
#include <net/tcp_states.h>

/**
 *	llc_build_and_send_pkt - Connection data sending for upper layers.
 *	@sk: connection
 *	@skb: packet to send
 *
 *	This function is called when upper layer wants to send data using
 *	connection oriented communication mode. During sending data, connection
 *	will be locked and received frames and expired timers will be queued.
 *	Returns 0 for success, -ECONNABORTED when the connection already
 *	closed and -EBUSY when sending data is not permitted in this state or
 *	LLC has send an I pdu with p bit set to 1 and is waiting for it's
 *	response.
 */
int llc_build_and_send_pkt(struct sock *sk, struct sk_buff *skb)
{
	struct llc_conn_state_ev *ev;
	int rc = -ECONNABORTED;
	struct llc_sock *llc = llc_sk(sk);

	if (unlikely(llc->state == LLC_CONN_STATE_ADM))
		goto out;
	rc = -EBUSY;
	if (unlikely(llc_data_accept_state(llc->state) || /* data_conn_refuse */
		     llc->p_flag)) {
		llc->failed_data_req = 1;
		goto out;
	}
	ev = llc_conn_ev(skb);
	ev->type      = LLC_CONN_EV_TYPE_PRIM;
	ev->prim      = LLC_DATA_PRIM;
	ev->prim_type = LLC_PRIM_TYPE_REQ;
	skb->dev      = llc->dev;
	rc = llc_conn_state_process(sk, skb);
out:
	return rc;
}

/**
 *	llc_establish_connection - Called by upper layer to establish a conn
 *	@sk: connection
 *	@lmac: local mac address
 *	@dmac: destination mac address
 *	@dsap: destination sap
 *
 *	Upper layer calls this to establish an LLC connection with a remote
 *	machine. This function packages a proper event and sends it connection
 *	component state machine. Success or failure of connection
 *	establishment will inform to upper layer via calling it's confirm
 *	function and passing proper information.
 */
int llc_establish_connection(struct sock *sk, u8 *lmac, u8 *dmac, u8 dsap)
{
	int rc = -EISCONN;
	struct llc_addr laddr, daddr;
	struct sk_buff *skb;
	struct llc_sock *llc = llc_sk(sk);
	struct sock *existing;

	laddr.lsap = llc->sap->laddr.lsap;
	daddr.lsap = dsap;
	memcpy(daddr.mac, dmac, sizeof(daddr.mac));
	memcpy(laddr.mac, lmac, sizeof(laddr.mac));
	existing = llc_lookup_established(llc->sap, &daddr, &laddr);
	if (existing) {
		if (existing->sk_state == TCP_ESTABLISHED) {
			sk = existing;
			goto out_put;
		} else
			sock_put(existing);
	}
	sock_hold(sk);
	rc = -ENOMEM;
	skb = alloc_skb(0, GFP_ATOMIC);
	if (skb) {
		struct llc_conn_state_ev *ev = llc_conn_ev(skb);

		ev->type      = LLC_CONN_EV_TYPE_PRIM;
		ev->prim      = LLC_CONN_PRIM;
		ev->prim_type = LLC_PRIM_TYPE_REQ;
		skb_set_owner_w(skb, sk);
		rc = llc_conn_state_process(sk, skb);
	}
out_put:
	sock_put(sk);
	return rc;
}

/**
 *	llc_send_disc - Called by upper layer to close a connection
 *	@sk: connection to be closed
 *
 *	Upper layer calls this when it wants to close an established LLC
 *	connection with a remote machine. This function packages a proper event
 *	and sends it to connection component state machine. Returns 0 for
 *	success, 1 otherwise.
 */
int llc_send_disc(struct sock *sk)
{
	u16 rc = 1;
	struct llc_conn_state_ev *ev;
	struct sk_buff *skb;

	sock_hold(sk);
	if (sk->sk_type != SOCK_STREAM || sk->sk_state != TCP_ESTABLISHED ||
	    llc_sk(sk)->state == LLC_CONN_STATE_ADM ||
	    llc_sk(sk)->state == LLC_CONN_OUT_OF_SVC)
		goto out;
	/*
	 * Postpone unassigning the connection from its SAP and returning the
	 * connection until all ACTIONs have been completely executed
	 */
	skb = alloc_skb(0, GFP_ATOMIC);
	if (!skb)
		goto out;
	skb_set_owner_w(skb, sk);
	sk->sk_state  = TCP_CLOSING;
	ev	      = llc_conn_ev(skb);
	ev->type      = LLC_CONN_EV_TYPE_PRIM;
	ev->prim      = LLC_DISC_PRIM;
	ev->prim_type = LLC_PRIM_TYPE_REQ;
	rc = llc_conn_state_process(sk, skb);
out:
	sock_put(sk);
	return rc;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* llc_if.c - Defines LLC interface to upper layer
	3	*
	4	* Copyright (c) 1997 by Procom Technology, Inc.
	5	* 2001-2003 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
	6	*
	7	* This program can be redistributed or modified under the terms of the
	8	* GNU General Public License as published by the Free Software Foundation.
	9	* This program is distributed without any warranty or implied warranty
	10	* of merchantability or fitness for a particular purpose.
	11	*
	12	* See the GNU General Public License for more details.
	13	*/
5a0e3ad6	14	#include <linux/gfp.h>
1da177e4 LT	15	#include <linux/module.h>
	16	#include <linux/kernel.h>
	17	#include <linux/netdevice.h>
1da177e4 LT	18	#include <asm/errno.h>
	19	#include <net/llc_if.h>
	20	#include <net/llc_sap.h>
	21	#include <net/llc_s_ev.h>
	22	#include <net/llc_conn.h>
	23	#include <net/sock.h>
	24	#include <net/llc_c_ev.h>
	25	#include <net/llc_c_ac.h>
	26	#include <net/llc_c_st.h>
c752f073	27	#include <net/tcp_states.h>
1da177e4	28
1da177e4 LT	29	/**
	30	* llc_build_and_send_pkt - Connection data sending for upper layers.
	31	* @sk: connection
	32	* @skb: packet to send
	33	*
	34	* This function is called when upper layer wants to send data using
	35	* connection oriented communication mode. During sending data, connection
	36	* will be locked and received frames and expired timers will be queued.
	37	* Returns 0 for success, -ECONNABORTED when the connection already
	38	* closed and -EBUSY when sending data is not permitted in this state or
	39	* LLC has send an I pdu with p bit set to 1 and is waiting for it's
	40	* response.
	41	*/
	42	int llc_build_and_send_pkt(struct sock sk, struct sk_buff skb)
	43	{
	44	struct llc_conn_state_ev *ev;
	45	int rc = -ECONNABORTED;
	46	struct llc_sock *llc = llc_sk(sk);
	47
249ff1c6	48	if (unlikely(llc->state == LLC_CONN_STATE_ADM))
1da177e4 LT	49	goto out;
1da177e4 LT	50	rc = -EBUSY;
249ff1c6 ACM	51	if (unlikely(llc_data_accept_state(llc->state) \|\| /* data_conn_refuse */
249ff1c6 ACM	52	llc->p_flag)) {
1da177e4 LT	53	llc->failed_data_req = 1;
	54	goto out;
	55	}
	56	ev = llc_conn_ev(skb);
	57	ev->type = LLC_CONN_EV_TYPE_PRIM;
	58	ev->prim = LLC_DATA_PRIM;
	59	ev->prim_type = LLC_PRIM_TYPE_REQ;
	60	skb->dev = llc->dev;
	61	rc = llc_conn_state_process(sk, skb);
	62	out:
	63	return rc;
	64	}
	65
	66	/**
	67	* llc_establish_connection - Called by upper layer to establish a conn
	68	* @sk: connection
	69	* @lmac: local mac address
	70	* @dmac: destination mac address
	71	* @dsap: destination sap
	72	*
	73	* Upper layer calls this to establish an LLC connection with a remote
	74	* machine. This function packages a proper event and sends it connection
	75	* component state machine. Success or failure of connection
	76	* establishment will inform to upper layer via calling it's confirm
	77	* function and passing proper information.
	78	*/
	79	int llc_establish_connection(struct sock sk, u8 lmac, u8 *dmac, u8 dsap)
	80	{
	81	int rc = -EISCONN;
	82	struct llc_addr laddr, daddr;
	83	struct sk_buff *skb;
	84	struct llc_sock *llc = llc_sk(sk);
	85	struct sock *existing;
	86
	87	laddr.lsap = llc->sap->laddr.lsap;
	88	daddr.lsap = dsap;
	89	memcpy(daddr.mac, dmac, sizeof(daddr.mac));
	90	memcpy(laddr.mac, lmac, sizeof(laddr.mac));
	91	existing = llc_lookup_established(llc->sap, &daddr, &laddr);
	92	if (existing) {
	93	if (existing->sk_state == TCP_ESTABLISHED) {
	94	sk = existing;
	95	goto out_put;
	96	} else
	97	sock_put(existing);
	98	}
	99	sock_hold(sk);
	100	rc = -ENOMEM;
	101	skb = alloc_skb(0, GFP_ATOMIC);
	102	if (skb) {
	103	struct llc_conn_state_ev *ev = llc_conn_ev(skb);
	104
	105	ev->type = LLC_CONN_EV_TYPE_PRIM;
	106	ev->prim = LLC_CONN_PRIM;
	107	ev->prim_type = LLC_PRIM_TYPE_REQ;
d389424e	108	skb_set_owner_w(skb, sk);
1da177e4 LT	109	rc = llc_conn_state_process(sk, skb);
	110	}
	111	out_put:
	112	sock_put(sk);
	113	return rc;
	114	}
	115
	116	/**
	117	* llc_send_disc - Called by upper layer to close a connection
	118	* @sk: connection to be closed
	119	*
	120	* Upper layer calls this when it wants to close an established LLC
	121	* connection with a remote machine. This function packages a proper event
	122	* and sends it to connection component state machine. Returns 0 for
	123	* success, 1 otherwise.
	124	*/
	125	int llc_send_disc(struct sock *sk)
	126	{
	127	u16 rc = 1;
	128	struct llc_conn_state_ev *ev;
	129	struct sk_buff *skb;
	130
	131	sock_hold(sk);
	132	if (sk->sk_type != SOCK_STREAM \|\| sk->sk_state != TCP_ESTABLISHED \|\|
	133	llc_sk(sk)->state == LLC_CONN_STATE_ADM \|\|
	134	llc_sk(sk)->state == LLC_CONN_OUT_OF_SVC)
	135	goto out;
	136	/*
	137	* Postpone unassigning the connection from its SAP and returning the
	138	* connection until all ACTIONs have been completely executed
	139	*/
	140	skb = alloc_skb(0, GFP_ATOMIC);
	141	if (!skb)
	142	goto out;
d389424e	143	skb_set_owner_w(skb, sk);
1da177e4 LT	144	sk->sk_state = TCP_CLOSING;
	145	ev = llc_conn_ev(skb);
	146	ev->type = LLC_CONN_EV_TYPE_PRIM;
	147	ev->prim = LLC_DISC_PRIM;
	148	ev->prim_type = LLC_PRIM_TYPE_REQ;
	149	rc = llc_conn_state_process(sk, skb);
	150	out:
	151	sock_put(sk);
	152	return rc;
	153	}
	154