[linux.git] / net / ax25 / ax25_std_in.c

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Copyright (C) Alan Cox GW4PTS ([email protected])
 * Copyright (C) Jonathan Naylor G4KLX ([email protected])
 * Copyright (C) Joerg Reuter DL1BKE ([email protected])
 * Copyright (C) Hans-Joachim Hetscher DD8NE ([email protected])
 *
 * 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 <asm/uaccess.h>
#include <linux/fcntl.h>
#include <linux/mm.h>
#include <linux/interrupt.h>

/*
 *	State machine for state 1, Awaiting Connection State.
 *	The handling of the timer(s) is in file ax25_std_timer.c.
 *	Handling of state 0 and connection release is in ax25.c.
 */
static int ax25_std_state1_machine(ax25_cb *ax25, struct sk_buff *skb, int frametype, int pf, int type)
{
	switch (frametype) {
	case AX25_SABM:
		ax25->modulus = AX25_MODULUS;
		ax25->window  = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
		ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
		break;

	case AX25_SABME:
		ax25->modulus = AX25_EMODULUS;
		ax25->window  = ax25->ax25_dev->values[AX25_VALUES_EWINDOW];
		ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
		break;

	case AX25_DISC:
		ax25_send_control(ax25, AX25_DM, pf, AX25_RESPONSE);
		break;

	case AX25_UA:
		if (pf) {
			ax25_calculate_rtt(ax25);
			ax25_stop_t1timer(ax25);
			ax25_start_t3timer(ax25);
			ax25_start_idletimer(ax25);
			ax25->vs      = 0;
			ax25->va      = 0;
			ax25->vr      = 0;
			ax25->state   = AX25_STATE_3;
			ax25->n2count = 0;
			if (ax25->sk != NULL) {
				bh_lock_sock(ax25->sk);
				ax25->sk->sk_state = TCP_ESTABLISHED;
				/* For WAIT_SABM connections we will produce an accept ready socket here */
				if (!sock_flag(ax25->sk, SOCK_DEAD))
					ax25->sk->sk_state_change(ax25->sk);
				bh_unlock_sock(ax25->sk);
			}
		}
		break;

	case AX25_DM:
		if (pf) {
			if (ax25->modulus == AX25_MODULUS) {
				ax25_disconnect(ax25, ECONNREFUSED);
			} else {
				ax25->modulus = AX25_MODULUS;
				ax25->window  = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
			}
		}
		break;

	default:
		break;
	}

	return 0;
}

/*
 *	State machine for state 2, Awaiting Release State.
 *	The handling of the timer(s) is in file ax25_std_timer.c
 *	Handling of state 0 and connection release is in ax25.c.
 */
static int ax25_std_state2_machine(ax25_cb *ax25, struct sk_buff *skb, int frametype, int pf, int type)
{
	switch (frametype) {
	case AX25_SABM:
	case AX25_SABME:
		ax25_send_control(ax25, AX25_DM, pf, AX25_RESPONSE);
		break;

	case AX25_DISC:
		ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
		ax25_disconnect(ax25, 0);
		break;

	case AX25_DM:
	case AX25_UA:
		if (pf)
			ax25_disconnect(ax25, 0);
		break;

	case AX25_I:
	case AX25_REJ:
	case AX25_RNR:
	case AX25_RR:
		if (pf) ax25_send_control(ax25, AX25_DM, AX25_POLLON, AX25_RESPONSE);
		break;

	default:
		break;
	}

	return 0;
}

/*
 *	State machine for state 3, Connected State.
 *	The handling of the timer(s) is in file ax25_std_timer.c
 *	Handling of state 0 and connection release is in ax25.c.
 */
static int ax25_std_state3_machine(ax25_cb *ax25, struct sk_buff *skb, int frametype, int ns, int nr, int pf, int type)
{
	int queued = 0;

	switch (frametype) {
	case AX25_SABM:
	case AX25_SABME:
		if (frametype == AX25_SABM) {
			ax25->modulus = AX25_MODULUS;
			ax25->window  = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
		} else {
			ax25->modulus = AX25_EMODULUS;
			ax25->window  = ax25->ax25_dev->values[AX25_VALUES_EWINDOW];
		}
		ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
		ax25_stop_t1timer(ax25);
		ax25_stop_t2timer(ax25);
		ax25_start_t3timer(ax25);
		ax25_start_idletimer(ax25);
		ax25->condition = 0x00;
		ax25->vs        = 0;
		ax25->va        = 0;
		ax25->vr        = 0;
		ax25_requeue_frames(ax25);
		break;

	case AX25_DISC:
		ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
		ax25_disconnect(ax25, 0);
		break;

	case AX25_DM:
		ax25_disconnect(ax25, ECONNRESET);
		break;

	case AX25_RR:
	case AX25_RNR:
		if (frametype == AX25_RR)
			ax25->condition &= ~AX25_COND_PEER_RX_BUSY;
		else
			ax25->condition |= AX25_COND_PEER_RX_BUSY;
		if (type == AX25_COMMAND && pf)
			ax25_std_enquiry_response(ax25);
		if (ax25_validate_nr(ax25, nr)) {
			ax25_check_iframes_acked(ax25, nr);
		} else {
			ax25_std_nr_error_recovery(ax25);
			ax25->state = AX25_STATE_1;
		}
		break;

	case AX25_REJ:
		ax25->condition &= ~AX25_COND_PEER_RX_BUSY;
		if (type == AX25_COMMAND && pf)
			ax25_std_enquiry_response(ax25);
		if (ax25_validate_nr(ax25, nr)) {
			ax25_frames_acked(ax25, nr);
			ax25_calculate_rtt(ax25);
			ax25_stop_t1timer(ax25);
			ax25_start_t3timer(ax25);
			ax25_requeue_frames(ax25);
		} else {
			ax25_std_nr_error_recovery(ax25);
			ax25->state = AX25_STATE_1;
		}
		break;

	case AX25_I:
		if (!ax25_validate_nr(ax25, nr)) {
			ax25_std_nr_error_recovery(ax25);
			ax25->state = AX25_STATE_1;
			break;
		}
		if (ax25->condition & AX25_COND_PEER_RX_BUSY) {
			ax25_frames_acked(ax25, nr);
		} else {
			ax25_check_iframes_acked(ax25, nr);
		}
		if (ax25->condition & AX25_COND_OWN_RX_BUSY) {
			if (pf) ax25_std_enquiry_response(ax25);
			break;
		}
		if (ns == ax25->vr) {
			ax25->vr = (ax25->vr + 1) % ax25->modulus;
			queued = ax25_rx_iframe(ax25, skb);
			if (ax25->condition & AX25_COND_OWN_RX_BUSY)
				ax25->vr = ns;	/* ax25->vr - 1 */
			ax25->condition &= ~AX25_COND_REJECT;
			if (pf) {
				ax25_std_enquiry_response(ax25);
			} else {
				if (!(ax25->condition & AX25_COND_ACK_PENDING)) {
					ax25->condition |= AX25_COND_ACK_PENDING;
					ax25_start_t2timer(ax25);
				}
			}
		} else {
			if (ax25->condition & AX25_COND_REJECT) {
				if (pf) ax25_std_enquiry_response(ax25);
			} else {
				ax25->condition |= AX25_COND_REJECT;
				ax25_send_control(ax25, AX25_REJ, pf, AX25_RESPONSE);
				ax25->condition &= ~AX25_COND_ACK_PENDING;
			}
		}
		break;

	case AX25_FRMR:
	case AX25_ILLEGAL:
		ax25_std_establish_data_link(ax25);
		ax25->state = AX25_STATE_1;
		break;

	default:
		break;
	}

	return queued;
}

/*
 *	State machine for state 4, Timer Recovery State.
 *	The handling of the timer(s) is in file ax25_std_timer.c
 *	Handling of state 0 and connection release is in ax25.c.
 */
static int ax25_std_state4_machine(ax25_cb *ax25, struct sk_buff *skb, int frametype, int ns, int nr, int pf, int type)
{
	int queued = 0;

	switch (frametype) {
	case AX25_SABM:
	case AX25_SABME:
		if (frametype == AX25_SABM) {
			ax25->modulus = AX25_MODULUS;
			ax25->window  = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
		} else {
			ax25->modulus = AX25_EMODULUS;
			ax25->window  = ax25->ax25_dev->values[AX25_VALUES_EWINDOW];
		}
		ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
		ax25_stop_t1timer(ax25);
		ax25_stop_t2timer(ax25);
		ax25_start_t3timer(ax25);
		ax25_start_idletimer(ax25);
		ax25->condition = 0x00;
		ax25->vs        = 0;
		ax25->va        = 0;
		ax25->vr        = 0;
		ax25->state     = AX25_STATE_3;
		ax25->n2count   = 0;
		ax25_requeue_frames(ax25);
		break;

	case AX25_DISC:
		ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
		ax25_disconnect(ax25, 0);
		break;

	case AX25_DM:
		ax25_disconnect(ax25, ECONNRESET);
		break;

	case AX25_RR:
	case AX25_RNR:
		if (frametype == AX25_RR)
			ax25->condition &= ~AX25_COND_PEER_RX_BUSY;
		else
			ax25->condition |= AX25_COND_PEER_RX_BUSY;
		if (type == AX25_RESPONSE && pf) {
			ax25_stop_t1timer(ax25);
			ax25->n2count = 0;
			if (ax25_validate_nr(ax25, nr)) {
				ax25_frames_acked(ax25, nr);
				if (ax25->vs == ax25->va) {
					ax25_start_t3timer(ax25);
					ax25->state   = AX25_STATE_3;
				} else {
					ax25_requeue_frames(ax25);
				}
			} else {
				ax25_std_nr_error_recovery(ax25);
				ax25->state = AX25_STATE_1;
			}
			break;
		}
		if (type == AX25_COMMAND && pf)
			ax25_std_enquiry_response(ax25);
		if (ax25_validate_nr(ax25, nr)) {
			ax25_frames_acked(ax25, nr);
		} else {
			ax25_std_nr_error_recovery(ax25);
			ax25->state = AX25_STATE_1;
		}
		break;

	case AX25_REJ:
		ax25->condition &= ~AX25_COND_PEER_RX_BUSY;
		if (pf && type == AX25_RESPONSE) {
			ax25_stop_t1timer(ax25);
			ax25->n2count = 0;
			if (ax25_validate_nr(ax25, nr)) {
				ax25_frames_acked(ax25, nr);
				if (ax25->vs == ax25->va) {
					ax25_start_t3timer(ax25);
					ax25->state   = AX25_STATE_3;
				} else {
					ax25_requeue_frames(ax25);
				}
			} else {
				ax25_std_nr_error_recovery(ax25);
				ax25->state = AX25_STATE_1;
			}
			break;
		}
		if (type == AX25_COMMAND && pf)
			ax25_std_enquiry_response(ax25);
		if (ax25_validate_nr(ax25, nr)) {
			ax25_frames_acked(ax25, nr);
			ax25_requeue_frames(ax25);
		} else {
			ax25_std_nr_error_recovery(ax25);
			ax25->state = AX25_STATE_1;
		}
		break;

	case AX25_I:
		if (!ax25_validate_nr(ax25, nr)) {
			ax25_std_nr_error_recovery(ax25);
			ax25->state = AX25_STATE_1;
			break;
		}
		ax25_frames_acked(ax25, nr);
		if (ax25->condition & AX25_COND_OWN_RX_BUSY) {
			if (pf)
				ax25_std_enquiry_response(ax25);
			break;
		}
		if (ns == ax25->vr) {
			ax25->vr = (ax25->vr + 1) % ax25->modulus;
			queued = ax25_rx_iframe(ax25, skb);
			if (ax25->condition & AX25_COND_OWN_RX_BUSY)
				ax25->vr = ns;	/* ax25->vr - 1 */
			ax25->condition &= ~AX25_COND_REJECT;
			if (pf) {
				ax25_std_enquiry_response(ax25);
			} else {
				if (!(ax25->condition & AX25_COND_ACK_PENDING)) {
					ax25->condition |= AX25_COND_ACK_PENDING;
					ax25_start_t2timer(ax25);
				}
			}
		} else {
			if (ax25->condition & AX25_COND_REJECT) {
				if (pf) ax25_std_enquiry_response(ax25);
			} else {
				ax25->condition |= AX25_COND_REJECT;
				ax25_send_control(ax25, AX25_REJ, pf, AX25_RESPONSE);
				ax25->condition &= ~AX25_COND_ACK_PENDING;
			}
		}
		break;

	case AX25_FRMR:
	case AX25_ILLEGAL:
		ax25_std_establish_data_link(ax25);
		ax25->state = AX25_STATE_1;
		break;

	default:
		break;
	}

	return queued;
}

/*
 *	Higher level upcall for a LAPB frame
 */
int ax25_std_frame_in(ax25_cb *ax25, struct sk_buff *skb, int type)
{
	int queued = 0, frametype, ns, nr, pf;

	frametype = ax25_decode(ax25, skb, &ns, &nr, &pf);

	switch (ax25->state) {
	case AX25_STATE_1:
		queued = ax25_std_state1_machine(ax25, skb, frametype, pf, type);
		break;
	case AX25_STATE_2:
		queued = ax25_std_state2_machine(ax25, skb, frametype, pf, type);
		break;
	case AX25_STATE_3:
		queued = ax25_std_state3_machine(ax25, skb, frametype, ns, nr, pf, type);
		break;
	case AX25_STATE_4:
		queued = ax25_std_state4_machine(ax25, skb, frametype, ns, nr, pf, type);
		break;
	}

	ax25_kick(ax25);

	return queued;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* This program is free software; you can redistribute it and/or modify
	3	* it under the terms of the GNU General Public License as published by
	4	* the Free Software Foundation; either version 2 of the License, or
	5	* (at your option) any later version.
	6	*
	7	* Copyright (C) Alan Cox GW4PTS ([email protected])
	8	* Copyright (C) Jonathan Naylor G4KLX ([email protected])
	9	* Copyright (C) Joerg Reuter DL1BKE ([email protected])
	10	* Copyright (C) Hans-Joachim Hetscher DD8NE ([email protected])
	11	*
	12	* Most of this code is based on the SDL diagrams published in the 7th ARRL
	13	* Computer Networking Conference papers. The diagrams have mistakes in them,
	14	* but are mostly correct. Before you modify the code could you read the SDL
	15	* diagrams as the code is not obvious and probably very easy to break.
	16	*/
	17	#include <linux/errno.h>
	18	#include <linux/types.h>
	19	#include <linux/socket.h>
	20	#include <linux/in.h>
	21	#include <linux/kernel.h>
1da177e4 LT	22	#include <linux/timer.h>
	23	#include <linux/string.h>
	24	#include <linux/sockios.h>
	25	#include <linux/net.h>
	26	#include <net/ax25.h>
	27	#include <linux/inet.h>
	28	#include <linux/netdevice.h>
	29	#include <linux/skbuff.h>
	30	#include <net/sock.h>
c752f073	31	#include <net/tcp_states.h>
1da177e4	32	#include <asm/uaccess.h>
1da177e4 LT	33	#include <linux/fcntl.h>
	34	#include <linux/mm.h>
	35	#include <linux/interrupt.h>
	36
	37	/*
	38	* State machine for state 1, Awaiting Connection State.
	39	* The handling of the timer(s) is in file ax25_std_timer.c.
	40	* Handling of state 0 and connection release is in ax25.c.
	41	*/
	42	static int ax25_std_state1_machine(ax25_cb ax25, struct sk_buff skb, int frametype, int pf, int type)
	43	{
	44	switch (frametype) {
	45	case AX25_SABM:
	46	ax25->modulus = AX25_MODULUS;
	47	ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
	48	ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
	49	break;
	50
	51	case AX25_SABME:
	52	ax25->modulus = AX25_EMODULUS;
	53	ax25->window = ax25->ax25_dev->values[AX25_VALUES_EWINDOW];
	54	ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
	55	break;
	56
	57	case AX25_DISC:
	58	ax25_send_control(ax25, AX25_DM, pf, AX25_RESPONSE);
	59	break;
	60
	61	case AX25_UA:
	62	if (pf) {
	63	ax25_calculate_rtt(ax25);
	64	ax25_stop_t1timer(ax25);
	65	ax25_start_t3timer(ax25);
	66	ax25_start_idletimer(ax25);
	67	ax25->vs = 0;
	68	ax25->va = 0;
	69	ax25->vr = 0;
	70	ax25->state = AX25_STATE_3;
	71	ax25->n2count = 0;
	72	if (ax25->sk != NULL) {
	73	bh_lock_sock(ax25->sk);
	74	ax25->sk->sk_state = TCP_ESTABLISHED;
	75	/* For WAIT_SABM connections we will produce an accept ready socket here */
	76	if (!sock_flag(ax25->sk, SOCK_DEAD))
	77	ax25->sk->sk_state_change(ax25->sk);
	78	bh_unlock_sock(ax25->sk);
	79	}
	80	}
	81	break;
	82
	83	case AX25_DM:
	84	if (pf) {
	85	if (ax25->modulus == AX25_MODULUS) {
	86	ax25_disconnect(ax25, ECONNREFUSED);
	87	} else {
	88	ax25->modulus = AX25_MODULUS;
	89	ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
	90	}
	91	}
	92	break;
	93
	94	default:
	95	break;
	96	}
97
98	return 0;
99	}
100
101	/*
102	* State machine for state 2, Awaiting Release State.
103	* The handling of the timer(s) is in file ax25_std_timer.c
104	* Handling of state 0 and connection release is in ax25.c.
105	*/
106	static int ax25_std_state2_machine(ax25_cb ax25, struct sk_buff skb, int frametype, int pf, int type)
107	{
108	switch (frametype) {
109	case AX25_SABM:
110	case AX25_SABME:
111	ax25_send_control(ax25, AX25_DM, pf, AX25_RESPONSE);
112	break;
113
114	case AX25_DISC:
115	ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
116	ax25_disconnect(ax25, 0);
117	break;
118
119	case AX25_DM:
120	case AX25_UA:
121	if (pf)
122	ax25_disconnect(ax25, 0);
123	break;
124
125	case AX25_I:
126	case AX25_REJ:
127	case AX25_RNR:
128	case AX25_RR:
129	if (pf) ax25_send_control(ax25, AX25_DM, AX25_POLLON, AX25_RESPONSE);
130	break;
131
132	default:
133	break;
134	}
135
136	return 0;
137	}
138
139	/*
140	* State machine for state 3, Connected State.
141	* The handling of the timer(s) is in file ax25_std_timer.c
142	* Handling of state 0 and connection release is in ax25.c.
143	*/
144	static int ax25_std_state3_machine(ax25_cb ax25, struct sk_buff skb, int frametype, int ns, int nr, int pf, int type)
145	{
146	int queued = 0;
147
148	switch (frametype) {
149	case AX25_SABM:
150	case AX25_SABME:
151	if (frametype == AX25_SABM) {
152	ax25->modulus = AX25_MODULUS;
153	ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
154	} else {
155	ax25->modulus = AX25_EMODULUS;
156	ax25->window = ax25->ax25_dev->values[AX25_VALUES_EWINDOW];
157	}
158	ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
159	ax25_stop_t1timer(ax25);
160	ax25_stop_t2timer(ax25);
161	ax25_start_t3timer(ax25);
162	ax25_start_idletimer(ax25);
163	ax25->condition = 0x00;
164	ax25->vs = 0;
165	ax25->va = 0;
166	ax25->vr = 0;
167	ax25_requeue_frames(ax25);
168	break;
169
170	case AX25_DISC:
171	ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
172	ax25_disconnect(ax25, 0);
173	break;
174
175	case AX25_DM:
176	ax25_disconnect(ax25, ECONNRESET);
177	break;
178
179	case AX25_RR:
180	case AX25_RNR:
181	if (frametype == AX25_RR)
182	ax25->condition &= ~AX25_COND_PEER_RX_BUSY;
183	else
184	ax25->condition \|= AX25_COND_PEER_RX_BUSY;
185	if (type == AX25_COMMAND && pf)
186	ax25_std_enquiry_response(ax25);
187	if (ax25_validate_nr(ax25, nr)) {
188	ax25_check_iframes_acked(ax25, nr);
189	} else {
190	ax25_std_nr_error_recovery(ax25);
191	ax25->state = AX25_STATE_1;
192	}
193	break;
194
195	case AX25_REJ:
196	ax25->condition &= ~AX25_COND_PEER_RX_BUSY;
197	if (type == AX25_COMMAND && pf)
198	ax25_std_enquiry_response(ax25);
199	if (ax25_validate_nr(ax25, nr)) {
200	ax25_frames_acked(ax25, nr);
201	ax25_calculate_rtt(ax25);
202	ax25_stop_t1timer(ax25);
203	ax25_start_t3timer(ax25);
204	ax25_requeue_frames(ax25);
205	} else {
206	ax25_std_nr_error_recovery(ax25);
207	ax25->state = AX25_STATE_1;
208	}
209	break;
210
211	case AX25_I:
212	if (!ax25_validate_nr(ax25, nr)) {
213	ax25_std_nr_error_recovery(ax25);
214	ax25->state = AX25_STATE_1;
215	break;
216	}
217	if (ax25->condition & AX25_COND_PEER_RX_BUSY) {
218	ax25_frames_acked(ax25, nr);
219	} else {
220	ax25_check_iframes_acked(ax25, nr);
221	}
222	if (ax25->condition & AX25_COND_OWN_RX_BUSY) {
223	if (pf) ax25_std_enquiry_response(ax25);
224	break;
225	}
226	if (ns == ax25->vr) {
227	ax25->vr = (ax25->vr + 1) % ax25->modulus;
228	queued = ax25_rx_iframe(ax25, skb);
229	if (ax25->condition & AX25_COND_OWN_RX_BUSY)
230	ax25->vr = ns; /* ax25->vr - 1 */
231	ax25->condition &= ~AX25_COND_REJECT;
232	if (pf) {
233	ax25_std_enquiry_response(ax25);
234	} else {
235	if (!(ax25->condition & AX25_COND_ACK_PENDING)) {
236	ax25->condition \|= AX25_COND_ACK_PENDING;
237	ax25_start_t2timer(ax25);
238	}
239	}
240	} else {
241	if (ax25->condition & AX25_COND_REJECT) {
242	if (pf) ax25_std_enquiry_response(ax25);
243	} else {
244	ax25->condition \|= AX25_COND_REJECT;
245	ax25_send_control(ax25, AX25_REJ, pf, AX25_RESPONSE);
246	ax25->condition &= ~AX25_COND_ACK_PENDING;
247	}
248	}
249	break;
250
251	case AX25_FRMR:
252	case AX25_ILLEGAL:
253	ax25_std_establish_data_link(ax25);
254	ax25->state = AX25_STATE_1;
255	break;
256
257	default:
258	break;
259	}
260
261	return queued;
262	}
263
264	/*
265	* State machine for state 4, Timer Recovery State.
266	* The handling of the timer(s) is in file ax25_std_timer.c
267	* Handling of state 0 and connection release is in ax25.c.
268	*/
269	static int ax25_std_state4_machine(ax25_cb ax25, struct sk_buff skb, int frametype, int ns, int nr, int pf, int type)
270	{
271	int queued = 0;
272
273	switch (frametype) {
274	case AX25_SABM:
275	case AX25_SABME:
276	if (frametype == AX25_SABM) {
277	ax25->modulus = AX25_MODULUS;
278	ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
279	} else {
280	ax25->modulus = AX25_EMODULUS;
281	ax25->window = ax25->ax25_dev->values[AX25_VALUES_EWINDOW];
282	}
283	ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
284	ax25_stop_t1timer(ax25);
285	ax25_stop_t2timer(ax25);
286	ax25_start_t3timer(ax25);
287	ax25_start_idletimer(ax25);
288	ax25->condition = 0x00;
289	ax25->vs = 0;
290	ax25->va = 0;
291	ax25->vr = 0;
292	ax25->state = AX25_STATE_3;
293	ax25->n2count = 0;
294	ax25_requeue_frames(ax25);
295	break;
296
297	case AX25_DISC:
298	ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
299	ax25_disconnect(ax25, 0);
300	break;
301
302	case AX25_DM:
303	ax25_disconnect(ax25, ECONNRESET);
304	break;
305
306	case AX25_RR:
307	case AX25_RNR:
308	if (frametype == AX25_RR)
309	ax25->condition &= ~AX25_COND_PEER_RX_BUSY;
310	else
311	ax25->condition \|= AX25_COND_PEER_RX_BUSY;
312	if (type == AX25_RESPONSE && pf) {
313	ax25_stop_t1timer(ax25);
314	ax25->n2count = 0;
315	if (ax25_validate_nr(ax25, nr)) {
316	ax25_frames_acked(ax25, nr);
317	if (ax25->vs == ax25->va) {
318	ax25_start_t3timer(ax25);
319	ax25->state = AX25_STATE_3;
320	} else {
321	ax25_requeue_frames(ax25);
322	}
323	} else {
324	ax25_std_nr_error_recovery(ax25);
325	ax25->state = AX25_STATE_1;
326	}
327	break;
328	}
329	if (type == AX25_COMMAND && pf)
330	ax25_std_enquiry_response(ax25);
331	if (ax25_validate_nr(ax25, nr)) {
332	ax25_frames_acked(ax25, nr);
333	} else {
334	ax25_std_nr_error_recovery(ax25);
335	ax25->state = AX25_STATE_1;
336	}
337	break;
338
339	case AX25_REJ:
340	ax25->condition &= ~AX25_COND_PEER_RX_BUSY;
341	if (pf && type == AX25_RESPONSE) {
342	ax25_stop_t1timer(ax25);
343	ax25->n2count = 0;
344	if (ax25_validate_nr(ax25, nr)) {
345	ax25_frames_acked(ax25, nr);
346	if (ax25->vs == ax25->va) {
347	ax25_start_t3timer(ax25);
348	ax25->state = AX25_STATE_3;
349	} else {
350	ax25_requeue_frames(ax25);
351	}
352	} else {
353	ax25_std_nr_error_recovery(ax25);
354	ax25->state = AX25_STATE_1;
355	}
356	break;
357	}
358	if (type == AX25_COMMAND && pf)
359	ax25_std_enquiry_response(ax25);
360	if (ax25_validate_nr(ax25, nr)) {
361	ax25_frames_acked(ax25, nr);
362	ax25_requeue_frames(ax25);
363	} else {
364	ax25_std_nr_error_recovery(ax25);
365	ax25->state = AX25_STATE_1;
366	}
367	break;
368
369	case AX25_I:
370	if (!ax25_validate_nr(ax25, nr)) {
371	ax25_std_nr_error_recovery(ax25);
372	ax25->state = AX25_STATE_1;
373	break;
374	}
375	ax25_frames_acked(ax25, nr);
376	if (ax25->condition & AX25_COND_OWN_RX_BUSY) {
377	if (pf)
378	ax25_std_enquiry_response(ax25);
379	break;
380	}
381	if (ns == ax25->vr) {
382	ax25->vr = (ax25->vr + 1) % ax25->modulus;
383	queued = ax25_rx_iframe(ax25, skb);
384	if (ax25->condition & AX25_COND_OWN_RX_BUSY)
385	ax25->vr = ns; /* ax25->vr - 1 */
386	ax25->condition &= ~AX25_COND_REJECT;
387	if (pf) {
388	ax25_std_enquiry_response(ax25);
389	} else {
390	if (!(ax25->condition & AX25_COND_ACK_PENDING)) {
391	ax25->condition \|= AX25_COND_ACK_PENDING;
392	ax25_start_t2timer(ax25);
393	}
394	}
395	} else {
396	if (ax25->condition & AX25_COND_REJECT) {
397	if (pf) ax25_std_enquiry_response(ax25);
398	} else {
399	ax25->condition \|= AX25_COND_REJECT;
400	ax25_send_control(ax25, AX25_REJ, pf, AX25_RESPONSE);
401	ax25->condition &= ~AX25_COND_ACK_PENDING;
402	}
403	}
404	break;
405
406	case AX25_FRMR:
407	case AX25_ILLEGAL:
408	ax25_std_establish_data_link(ax25);
409	ax25->state = AX25_STATE_1;
410	break;
411
412	default:
413	break;
414	}
415
416	return queued;
417	}
418
419	/*
420	* Higher level upcall for a LAPB frame
421	*/
422	int ax25_std_frame_in(ax25_cb ax25, struct sk_buff skb, int type)
423	{
424	int queued = 0, frametype, ns, nr, pf;
425
426	frametype = ax25_decode(ax25, skb, &ns, &nr, &pf);
427
428	switch (ax25->state) {
429	case AX25_STATE_1:
430	queued = ax25_std_state1_machine(ax25, skb, frametype, pf, type);
431	break;
432	case AX25_STATE_2:
433	queued = ax25_std_state2_machine(ax25, skb, frametype, pf, type);
434	break;
435	case AX25_STATE_3:
436	queued = ax25_std_state3_machine(ax25, skb, frametype, ns, nr, pf, type);
437	break;
438	case AX25_STATE_4:
439	queued = ax25_std_state4_machine(ax25, skb, frametype, ns, nr, pf, type);
440	break;
441	}
442
443	ax25_kick(ax25);
444
445	return queued;
446	}