[mirror_ubuntu-kernels.git] / net / rose / rose_in.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *
 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
 *
 * Most of this code is based on the SDL diagrams published in the 7th ARRL
 * Computer Networking Conference papers. The diagrams have mistakes in them,
 * but are mostly correct. Before you modify the code could you read the SDL
 * diagrams as the code is not obvious and probably very easy to break.
 */
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/kernel.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/sockios.h>
#include <linux/net.h>
#include <net/ax25.h>
#include <linux/inet.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <net/sock.h>
#include <net/tcp_states.h>
#include <linux/fcntl.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <net/rose.h>

/*
 * State machine for state 1, Awaiting Call Accepted State.
 * The handling of the timer(s) is in file rose_timer.c.
 * Handling of state 0 and connection release is in af_rose.c.
 */
static int rose_state1_machine(struct sock *sk, struct sk_buff *skb, int frametype)
{
	struct rose_sock *rose = rose_sk(sk);

	switch (frametype) {
	case ROSE_CALL_ACCEPTED:
		rose_stop_timer(sk);
		rose_start_idletimer(sk);
		rose->condition = 0x00;
		rose->vs        = 0;
		rose->va        = 0;
		rose->vr        = 0;
		rose->vl        = 0;
		rose->state     = ROSE_STATE_3;
		sk->sk_state	= TCP_ESTABLISHED;
		if (!sock_flag(sk, SOCK_DEAD))
			sk->sk_state_change(sk);
		break;

	case ROSE_CLEAR_REQUEST:
		rose_write_internal(sk, ROSE_CLEAR_CONFIRMATION);
		rose_disconnect(sk, ECONNREFUSED, skb->data[3], skb->data[4]);
		rose->neighbour->use--;
		break;

	default:
		break;
	}

	return 0;
}

/*
 * State machine for state 2, Awaiting Clear Confirmation State.
 * The handling of the timer(s) is in file rose_timer.c
 * Handling of state 0 and connection release is in af_rose.c.
 */
static int rose_state2_machine(struct sock *sk, struct sk_buff *skb, int frametype)
{
	struct rose_sock *rose = rose_sk(sk);

	switch (frametype) {
	case ROSE_CLEAR_REQUEST:
		rose_write_internal(sk, ROSE_CLEAR_CONFIRMATION);
		rose_disconnect(sk, 0, skb->data[3], skb->data[4]);
		rose->neighbour->use--;
		break;

	case ROSE_CLEAR_CONFIRMATION:
		rose_disconnect(sk, 0, -1, -1);
		rose->neighbour->use--;
		break;

	default:
		break;
	}

	return 0;
}

/*
 * State machine for state 3, Connected State.
 * The handling of the timer(s) is in file rose_timer.c
 * Handling of state 0 and connection release is in af_rose.c.
 */
static int rose_state3_machine(struct sock *sk, struct sk_buff *skb, int frametype, int ns, int nr, int q, int d, int m)
{
	struct rose_sock *rose = rose_sk(sk);
	int queued = 0;

	switch (frametype) {
	case ROSE_RESET_REQUEST:
		rose_stop_timer(sk);
		rose_start_idletimer(sk);
		rose_write_internal(sk, ROSE_RESET_CONFIRMATION);
		rose->condition = 0x00;
		rose->vs        = 0;
		rose->vr        = 0;
		rose->va        = 0;
		rose->vl        = 0;
		rose_requeue_frames(sk);
		break;

	case ROSE_CLEAR_REQUEST:
		rose_write_internal(sk, ROSE_CLEAR_CONFIRMATION);
		rose_disconnect(sk, 0, skb->data[3], skb->data[4]);
		rose->neighbour->use--;
		break;

	case ROSE_RR:
	case ROSE_RNR:
		if (!rose_validate_nr(sk, nr)) {
			rose_write_internal(sk, ROSE_RESET_REQUEST);
			rose->condition = 0x00;
			rose->vs        = 0;
			rose->vr        = 0;
			rose->va        = 0;
			rose->vl        = 0;
			rose->state     = ROSE_STATE_4;
			rose_start_t2timer(sk);
			rose_stop_idletimer(sk);
		} else {
			rose_frames_acked(sk, nr);
			if (frametype == ROSE_RNR) {
				rose->condition |= ROSE_COND_PEER_RX_BUSY;
			} else {
				rose->condition &= ~ROSE_COND_PEER_RX_BUSY;
			}
		}
		break;

	case ROSE_DATA:	/* XXX */
		rose->condition &= ~ROSE_COND_PEER_RX_BUSY;
		if (!rose_validate_nr(sk, nr)) {
			rose_write_internal(sk, ROSE_RESET_REQUEST);
			rose->condition = 0x00;
			rose->vs        = 0;
			rose->vr        = 0;
			rose->va        = 0;
			rose->vl        = 0;
			rose->state     = ROSE_STATE_4;
			rose_start_t2timer(sk);
			rose_stop_idletimer(sk);
			break;
		}
		rose_frames_acked(sk, nr);
		if (ns == rose->vr) {
			rose_start_idletimer(sk);
			if (sk_filter_trim_cap(sk, skb, ROSE_MIN_LEN) == 0 &&
			    __sock_queue_rcv_skb(sk, skb) == 0) {
				rose->vr = (rose->vr + 1) % ROSE_MODULUS;
				queued = 1;
			} else {
				/* Should never happen ! */
				rose_write_internal(sk, ROSE_RESET_REQUEST);
				rose->condition = 0x00;
				rose->vs        = 0;
				rose->vr        = 0;
				rose->va        = 0;
				rose->vl        = 0;
				rose->state     = ROSE_STATE_4;
				rose_start_t2timer(sk);
				rose_stop_idletimer(sk);
				break;
			}
			if (atomic_read(&sk->sk_rmem_alloc) >
			    (sk->sk_rcvbuf >> 1))
				rose->condition |= ROSE_COND_OWN_RX_BUSY;
		}
		/*
		 * If the window is full, ack the frame, else start the
		 * acknowledge hold back timer.
		 */
		if (((rose->vl + sysctl_rose_window_size) % ROSE_MODULUS) == rose->vr) {
			rose->condition &= ~ROSE_COND_ACK_PENDING;
			rose_stop_timer(sk);
			rose_enquiry_response(sk);
		} else {
			rose->condition |= ROSE_COND_ACK_PENDING;
			rose_start_hbtimer(sk);
		}
		break;

	default:
		printk(KERN_WARNING "ROSE: unknown %02X in state 3\n", frametype);
		break;
	}

	return queued;
}

/*
 * State machine for state 4, Awaiting Reset Confirmation State.
 * The handling of the timer(s) is in file rose_timer.c
 * Handling of state 0 and connection release is in af_rose.c.
 */
static int rose_state4_machine(struct sock *sk, struct sk_buff *skb, int frametype)
{
	struct rose_sock *rose = rose_sk(sk);

	switch (frametype) {
	case ROSE_RESET_REQUEST:
		rose_write_internal(sk, ROSE_RESET_CONFIRMATION);
		fallthrough;
	case ROSE_RESET_CONFIRMATION:
		rose_stop_timer(sk);
		rose_start_idletimer(sk);
		rose->condition = 0x00;
		rose->va        = 0;
		rose->vr        = 0;
		rose->vs        = 0;
		rose->vl        = 0;
		rose->state     = ROSE_STATE_3;
		rose_requeue_frames(sk);
		break;

	case ROSE_CLEAR_REQUEST:
		rose_write_internal(sk, ROSE_CLEAR_CONFIRMATION);
		rose_disconnect(sk, 0, skb->data[3], skb->data[4]);
		rose->neighbour->use--;
		break;

	default:
		break;
	}

	return 0;
}

/*
 * State machine for state 5, Awaiting Call Acceptance State.
 * The handling of the timer(s) is in file rose_timer.c
 * Handling of state 0 and connection release is in af_rose.c.
 */
static int rose_state5_machine(struct sock *sk, struct sk_buff *skb, int frametype)
{
	if (frametype == ROSE_CLEAR_REQUEST) {
		rose_write_internal(sk, ROSE_CLEAR_CONFIRMATION);
		rose_disconnect(sk, 0, skb->data[3], skb->data[4]);
		rose_sk(sk)->neighbour->use--;
	}

	return 0;
}

/* Higher level upcall for a LAPB frame */
int rose_process_rx_frame(struct sock *sk, struct sk_buff *skb)
{
	struct rose_sock *rose = rose_sk(sk);
	int queued = 0, frametype, ns, nr, q, d, m;

	if (rose->state == ROSE_STATE_0)
		return 0;

	frametype = rose_decode(skb, &ns, &nr, &q, &d, &m);

	switch (rose->state) {
	case ROSE_STATE_1:
		queued = rose_state1_machine(sk, skb, frametype);
		break;
	case ROSE_STATE_2:
		queued = rose_state2_machine(sk, skb, frametype);
		break;
	case ROSE_STATE_3:
		queued = rose_state3_machine(sk, skb, frametype, ns, nr, q, d, m);
		break;
	case ROSE_STATE_4:
		queued = rose_state4_machine(sk, skb, frametype);
		break;
	case ROSE_STATE_5:
		queued = rose_state5_machine(sk, skb, frametype);
		break;
	}

	rose_kick(sk);

	return queued;
}
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4	2	/*
1da177e4 LT	3	*
	4	* Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
	5	*
	6	* Most of this code is based on the SDL diagrams published in the 7th ARRL
	7	* Computer Networking Conference papers. The diagrams have mistakes in them,
	8	* but are mostly correct. Before you modify the code could you read the SDL
	9	* diagrams as the code is not obvious and probably very easy to break.
	10	*/
	11	#include <linux/errno.h>
	12	#include <linux/types.h>
	13	#include <linux/socket.h>
	14	#include <linux/in.h>
	15	#include <linux/kernel.h>
1da177e4 LT	16	#include <linux/timer.h>
	17	#include <linux/string.h>
	18	#include <linux/sockios.h>
	19	#include <linux/net.h>
	20	#include <net/ax25.h>
	21	#include <linux/inet.h>
	22	#include <linux/netdevice.h>
	23	#include <linux/skbuff.h>
	24	#include <net/sock.h>
c752f073	25	#include <net/tcp_states.h>
1da177e4 LT	26	#include <linux/fcntl.h>
	27	#include <linux/mm.h>
	28	#include <linux/interrupt.h>
	29	#include <net/rose.h>
	30
	31	/*
	32	* State machine for state 1, Awaiting Call Accepted State.
	33	* The handling of the timer(s) is in file rose_timer.c.
	34	* Handling of state 0 and connection release is in af_rose.c.
	35	*/
	36	static int rose_state1_machine(struct sock sk, struct sk_buff skb, int frametype)
	37	{
	38	struct rose_sock *rose = rose_sk(sk);
	39
	40	switch (frametype) {
	41	case ROSE_CALL_ACCEPTED:
	42	rose_stop_timer(sk);
	43	rose_start_idletimer(sk);
	44	rose->condition = 0x00;
	45	rose->vs = 0;
	46	rose->va = 0;
	47	rose->vr = 0;
	48	rose->vl = 0;
	49	rose->state = ROSE_STATE_3;
	50	sk->sk_state = TCP_ESTABLISHED;
	51	if (!sock_flag(sk, SOCK_DEAD))
	52	sk->sk_state_change(sk);
	53	break;
	54
	55	case ROSE_CLEAR_REQUEST:
	56	rose_write_internal(sk, ROSE_CLEAR_CONFIRMATION);
	57	rose_disconnect(sk, ECONNREFUSED, skb->data[3], skb->data[4]);
	58	rose->neighbour->use--;
	59	break;
	60
	61	default:
	62	break;
	63	}
	64
	65	return 0;
	66	}
	67
	68	/*
	69	* State machine for state 2, Awaiting Clear Confirmation State.
	70	* The handling of the timer(s) is in file rose_timer.c
	71	* Handling of state 0 and connection release is in af_rose.c.
	72	*/
	73	static int rose_state2_machine(struct sock sk, struct sk_buff skb, int frametype)
	74	{
	75	struct rose_sock *rose = rose_sk(sk);
	76
	77	switch (frametype) {
	78	case ROSE_CLEAR_REQUEST:
	79	rose_write_internal(sk, ROSE_CLEAR_CONFIRMATION);
	80	rose_disconnect(sk, 0, skb->data[3], skb->data[4]);
	81	rose->neighbour->use--;
	82	break;
	83
	84	case ROSE_CLEAR_CONFIRMATION:
	85	rose_disconnect(sk, 0, -1, -1);
	86	rose->neighbour->use--;
	87	break;
	88
	89	default:
90	break;
91	}
92
93	return 0;
94	}
95
96	/*
97	* State machine for state 3, Connected State.
98	* The handling of the timer(s) is in file rose_timer.c
99	* Handling of state 0 and connection release is in af_rose.c.
100	*/
101	static int rose_state3_machine(struct sock sk, struct sk_buff skb, int frametype, int ns, int nr, int q, int d, int m)
102	{
103	struct rose_sock *rose = rose_sk(sk);
104	int queued = 0;
105
106	switch (frametype) {
107	case ROSE_RESET_REQUEST:
108	rose_stop_timer(sk);
109	rose_start_idletimer(sk);
110	rose_write_internal(sk, ROSE_RESET_CONFIRMATION);
111	rose->condition = 0x00;
112	rose->vs = 0;
113	rose->vr = 0;
114	rose->va = 0;
115	rose->vl = 0;
116	rose_requeue_frames(sk);
117	break;
118
119	case ROSE_CLEAR_REQUEST:
120	rose_write_internal(sk, ROSE_CLEAR_CONFIRMATION);
121	rose_disconnect(sk, 0, skb->data[3], skb->data[4]);
122	rose->neighbour->use--;
123	break;
124
125	case ROSE_RR:
126	case ROSE_RNR:
127	if (!rose_validate_nr(sk, nr)) {
128	rose_write_internal(sk, ROSE_RESET_REQUEST);
129	rose->condition = 0x00;
130	rose->vs = 0;
131	rose->vr = 0;
132	rose->va = 0;
133	rose->vl = 0;
134	rose->state = ROSE_STATE_4;
135	rose_start_t2timer(sk);
136	rose_stop_idletimer(sk);
137	} else {
138	rose_frames_acked(sk, nr);
139	if (frametype == ROSE_RNR) {
140	rose->condition \|= ROSE_COND_PEER_RX_BUSY;
141	} else {
142	rose->condition &= ~ROSE_COND_PEER_RX_BUSY;
143	}
144	}
145	break;
146
147	case ROSE_DATA: /* XXX */
148	rose->condition &= ~ROSE_COND_PEER_RX_BUSY;
149	if (!rose_validate_nr(sk, nr)) {
150	rose_write_internal(sk, ROSE_RESET_REQUEST);
151	rose->condition = 0x00;
152	rose->vs = 0;
153	rose->vr = 0;
154	rose->va = 0;
155	rose->vl = 0;
156	rose->state = ROSE_STATE_4;
157	rose_start_t2timer(sk);
158	rose_stop_idletimer(sk);
159	break;
160	}
161	rose_frames_acked(sk, nr);
162	if (ns == rose->vr) {
163	rose_start_idletimer(sk);
f4979fce WB	164	if (sk_filter_trim_cap(sk, skb, ROSE_MIN_LEN) == 0 &&
f4979fce WB	165	__sock_queue_rcv_skb(sk, skb) == 0) {
1da177e4 LT	166	rose->vr = (rose->vr + 1) % ROSE_MODULUS;
	167	queued = 1;
	168	} else {
	169	/* Should never happen ! */
	170	rose_write_internal(sk, ROSE_RESET_REQUEST);
	171	rose->condition = 0x00;
	172	rose->vs = 0;
	173	rose->vr = 0;
	174	rose->va = 0;
	175	rose->vl = 0;
	176	rose->state = ROSE_STATE_4;
	177	rose_start_t2timer(sk);
	178	rose_stop_idletimer(sk);
	179	break;
	180	}
	181	if (atomic_read(&sk->sk_rmem_alloc) >
95b7d924	182	(sk->sk_rcvbuf >> 1))
1da177e4 LT	183	rose->condition \|= ROSE_COND_OWN_RX_BUSY;
	184	}
	185	/*
	186	* If the window is full, ack the frame, else start the
	187	* acknowledge hold back timer.
	188	*/
	189	if (((rose->vl + sysctl_rose_window_size) % ROSE_MODULUS) == rose->vr) {
	190	rose->condition &= ~ROSE_COND_ACK_PENDING;
	191	rose_stop_timer(sk);
	192	rose_enquiry_response(sk);
	193	} else {
	194	rose->condition \|= ROSE_COND_ACK_PENDING;
	195	rose_start_hbtimer(sk);
	196	}
	197	break;
	198
	199	default:
	200	printk(KERN_WARNING "ROSE: unknown %02X in state 3\n", frametype);
	201	break;
	202	}
	203
	204	return queued;
	205	}
	206
	207	/*
	208	* State machine for state 4, Awaiting Reset Confirmation State.
	209	* The handling of the timer(s) is in file rose_timer.c
	210	* Handling of state 0 and connection release is in af_rose.c.
	211	*/
	212	static int rose_state4_machine(struct sock sk, struct sk_buff skb, int frametype)
	213	{
	214	struct rose_sock *rose = rose_sk(sk);
	215
	216	switch (frametype) {
	217	case ROSE_RESET_REQUEST:
	218	rose_write_internal(sk, ROSE_RESET_CONFIRMATION);
df561f66	219	fallthrough;
1da177e4 LT	220	case ROSE_RESET_CONFIRMATION:
	221	rose_stop_timer(sk);
	222	rose_start_idletimer(sk);
	223	rose->condition = 0x00;
	224	rose->va = 0;
	225	rose->vr = 0;
	226	rose->vs = 0;
	227	rose->vl = 0;
	228	rose->state = ROSE_STATE_3;
	229	rose_requeue_frames(sk);
	230	break;
	231
	232	case ROSE_CLEAR_REQUEST:
	233	rose_write_internal(sk, ROSE_CLEAR_CONFIRMATION);
	234	rose_disconnect(sk, 0, skb->data[3], skb->data[4]);
	235	rose->neighbour->use--;
	236	break;
	237
	238	default:
	239	break;
	240	}
	241
	242	return 0;
	243	}
	244
	245	/*
	246	* State machine for state 5, Awaiting Call Acceptance State.
	247	* The handling of the timer(s) is in file rose_timer.c
	248	* Handling of state 0 and connection release is in af_rose.c.
	249	*/
	250	static int rose_state5_machine(struct sock sk, struct sk_buff skb, int frametype)
	251	{
	252	if (frametype == ROSE_CLEAR_REQUEST) {
	253	rose_write_internal(sk, ROSE_CLEAR_CONFIRMATION);
	254	rose_disconnect(sk, 0, skb->data[3], skb->data[4]);
	255	rose_sk(sk)->neighbour->use--;
	256	}
	257
	258	return 0;
	259	}
	260
	261	/* Higher level upcall for a LAPB frame */
	262	int rose_process_rx_frame(struct sock sk, struct sk_buff skb)
	263	{
	264	struct rose_sock *rose = rose_sk(sk);
	265	int queued = 0, frametype, ns, nr, q, d, m;
	266
	267	if (rose->state == ROSE_STATE_0)
	268	return 0;
	269
	270	frametype = rose_decode(skb, &ns, &nr, &q, &d, &m);
	271
	272	switch (rose->state) {
	273	case ROSE_STATE_1:
	274	queued = rose_state1_machine(sk, skb, frametype);
	275	break;
	276	case ROSE_STATE_2:
	277	queued = rose_state2_machine(sk, skb, frametype);
	278	break;
	279	case ROSE_STATE_3:
	280	queued = rose_state3_machine(sk, skb, frametype, ns, nr, q, d, m);
	281	break;
	282	case ROSE_STATE_4:
	283	queued = rose_state4_machine(sk, skb, frametype);
284	break;
285	case ROSE_STATE_5:
286	queued = rose_state5_machine(sk, skb, frametype);
287	break;
288	}
289
290	rose_kick(sk);
291
292	return queued;
293	}