1/*
2 *	LAPB release 002
3 *
4 *	This code REQUIRES 2.1.15 or higher/ NET3.038
5 *
6 *	This module:
7 *		This module is free software; you can redistribute it and/or
8 *		modify it under the terms of the GNU General Public License
9 *		as published by the Free Software Foundation; either version
10 *		2 of the License, or (at your option) any later version.
11 *
12 *	History
13 *	LAPB 001	Jonathan Naylor	Started Coding
14 *	LAPB 002	Jonathan Naylor	New timer architecture.
15 *	2000-10-29	Henner Eisen	lapb_data_indication() return status.
16 */
17
18#include <linux/module.h>
19#include <linux/errno.h>
20#include <linux/types.h>
21#include <linux/socket.h>
22#include <linux/in.h>
23#include <linux/kernel.h>
24#include <linux/sched.h>
25#include <linux/timer.h>
26#include <linux/string.h>
27#include <linux/sockios.h>
28#include <linux/net.h>
29#include <linux/inet.h>
30#include <linux/if_arp.h>
31#include <linux/skbuff.h>
32#include <net/sock.h>
33#include <asm/uaccess.h>
34#include <asm/system.h>
35#include <linux/fcntl.h>
36#include <linux/mm.h>
37#include <linux/interrupt.h>
38#include <linux/stat.h>
39#include <linux/init.h>
40#include <net/lapb.h>
41
42static lapb_cb *volatile lapb_list /* = NULL initially */;
43
44/*
45 *	Free an allocated lapb control block. This is done to centralise
46 *	the MOD count code.
47 */
48static void lapb_free_cb(lapb_cb *lapb)
49{
50	kfree(lapb);
51
52	MOD_DEC_USE_COUNT;
53}
54
55/*
56 *	Socket removal during an interrupt is now safe.
57 */
58static void lapb_remove_cb(lapb_cb *lapb)
59{
60	lapb_cb *s;
61	unsigned long flags;
62
63	save_flags(flags); cli();
64
65	if ((s = lapb_list) == lapb) {
66		lapb_list = s->next;
67		restore_flags(flags);
68		return;
69	}
70
71	while (s != NULL && s->next != NULL) {
72		if (s->next == lapb) {
73			s->next = lapb->next;
74			restore_flags(flags);
75			return;
76		}
77
78		s = s->next;
79	}
80
81	restore_flags(flags);
82}
83
84/*
85 *	Add a socket to the bound sockets list.
86 */
87static void lapb_insert_cb(lapb_cb *lapb)
88{
89	unsigned long flags;
90
91	save_flags(flags); cli();
92
93	lapb->next = lapb_list;
94	lapb_list  = lapb;
95
96	restore_flags(flags);
97}
98
99/*
100 *	Convert the integer token used by the device driver into a pointer
101 *	to a LAPB control structure.
102 */
103static lapb_cb *lapb_tokentostruct(void *token)
104{
105	lapb_cb *lapb;
106
107	for (lapb = lapb_list; lapb != NULL; lapb = lapb->next)
108		if (lapb->token == token)
109			return lapb;
110
111	return NULL;
112}
113
114/*
115 *	Create an empty LAPB control block.
116 */
117static lapb_cb *lapb_create_cb(void)
118{
119	lapb_cb *lapb;
120
121	if ((lapb = kmalloc(sizeof(*lapb), GFP_ATOMIC)) == NULL)
122		return NULL;
123
124	MOD_INC_USE_COUNT;
125
126	memset(lapb, 0x00, sizeof(*lapb));
127
128	skb_queue_head_init(&lapb->write_queue);
129	skb_queue_head_init(&lapb->ack_queue);
130
131	init_timer(&lapb->t1timer);
132	init_timer(&lapb->t2timer);
133
134	lapb->t1      = LAPB_DEFAULT_T1;
135	lapb->t2      = LAPB_DEFAULT_T2;
136	lapb->n2      = LAPB_DEFAULT_N2;
137	lapb->mode    = LAPB_DEFAULT_MODE;
138	lapb->window  = LAPB_DEFAULT_WINDOW;
139	lapb->state   = LAPB_STATE_0;
140
141	return lapb;
142}
143
144int lapb_register(void *token, struct lapb_register_struct *callbacks)
145{
146	lapb_cb *lapb;
147
148	if (lapb_tokentostruct(token) != NULL)
149		return LAPB_BADTOKEN;
150
151	if ((lapb = lapb_create_cb()) == NULL)
152		return LAPB_NOMEM;
153
154	lapb->token     = token;
155	lapb->callbacks = *callbacks;
156
157	lapb_insert_cb(lapb);
158
159	lapb_start_t1timer(lapb);
160
161	return LAPB_OK;
162}
163
164int lapb_unregister(void *token)
165{
166	lapb_cb *lapb;
167
168	if ((lapb = lapb_tokentostruct(token)) == NULL)
169		return LAPB_BADTOKEN;
170
171	lapb_stop_t1timer(lapb);
172	lapb_stop_t2timer(lapb);
173
174	lapb_clear_queues(lapb);
175
176	lapb_remove_cb(lapb);
177
178	lapb_free_cb(lapb);
179
180	return LAPB_OK;
181}
182
183int lapb_getparms(void *token, struct lapb_parms_struct *parms)
184{
185	lapb_cb *lapb;
186
187	if ((lapb = lapb_tokentostruct(token)) == NULL)
188		return LAPB_BADTOKEN;
189
190	parms->t1      = lapb->t1 / HZ;
191	parms->t2      = lapb->t2 / HZ;
192	parms->n2      = lapb->n2;
193	parms->n2count = lapb->n2count;
194	parms->state   = lapb->state;
195	parms->window  = lapb->window;
196	parms->mode    = lapb->mode;
197
198	if (!timer_pending(&lapb->t1timer))
199		parms->t1timer = 0;
200	else
201		parms->t1timer = (lapb->t1timer.expires - jiffies) / HZ;
202
203	if (!timer_pending(&lapb->t2timer))
204		parms->t2timer = 0;
205	else
206		parms->t2timer = (lapb->t2timer.expires - jiffies) / HZ;
207
208	return LAPB_OK;
209}
210
211int lapb_setparms(void *token, struct lapb_parms_struct *parms)
212{
213	lapb_cb *lapb;
214
215	if ((lapb = lapb_tokentostruct(token)) == NULL)
216		return LAPB_BADTOKEN;
217
218	if (parms->t1 < 1)
219		return LAPB_INVALUE;
220
221	if (parms->t2 < 1)
222		return LAPB_INVALUE;
223
224	if (parms->n2 < 1)
225		return LAPB_INVALUE;
226
227	if (lapb->state == LAPB_STATE_0) {
228		if (parms->mode & LAPB_EXTENDED) {
229			if (parms->window < 1 || parms->window > 127)
230				return LAPB_INVALUE;
231		} else {
232			if (parms->window < 1 || parms->window > 7)
233				return LAPB_INVALUE;
234		}
235
236		lapb->mode    = parms->mode;
237		lapb->window  = parms->window;
238	}
239
240	lapb->t1    = parms->t1 * HZ;
241	lapb->t2    = parms->t2 * HZ;
242	lapb->n2    = parms->n2;
243
244	return LAPB_OK;
245}
246
247int lapb_connect_request(void *token)
248{
249	lapb_cb *lapb;
250
251	if ((lapb = lapb_tokentostruct(token)) == NULL)
252		return LAPB_BADTOKEN;
253
254	switch (lapb->state) {
255		case LAPB_STATE_1:
256			return LAPB_OK;
257		case LAPB_STATE_3:
258		case LAPB_STATE_4:
259			return LAPB_CONNECTED;
260	}
261
262	lapb_establish_data_link(lapb);
263
264#if LAPB_DEBUG > 0
265	printk(KERN_DEBUG "lapb: (%p) S0 -> S1\n", lapb->token);
266#endif
267
268	lapb->state = LAPB_STATE_1;
269
270	return LAPB_OK;
271}
272
273int lapb_disconnect_request(void *token)
274{
275	lapb_cb *lapb;
276
277	if ((lapb = lapb_tokentostruct(token)) == NULL)
278		return LAPB_BADTOKEN;
279
280	switch (lapb->state) {
281		case LAPB_STATE_0:
282			return LAPB_NOTCONNECTED;
283
284		case LAPB_STATE_1:
285#if LAPB_DEBUG > 1
286			printk(KERN_DEBUG "lapb: (%p) S1 TX DISC(1)\n", lapb->token);
287#endif
288#if LAPB_DEBUG > 0
289			printk(KERN_DEBUG "lapb: (%p) S1 -> S0\n", lapb->token);
290#endif
291			lapb_send_control(lapb, LAPB_DISC, LAPB_POLLON, LAPB_COMMAND);
292			lapb->state = LAPB_STATE_0;
293			lapb_start_t1timer(lapb);
294			return LAPB_NOTCONNECTED;
295
296		case LAPB_STATE_2:
297			return LAPB_OK;
298	}
299
300	lapb_clear_queues(lapb);
301	lapb->n2count = 0;
302	lapb_send_control(lapb, LAPB_DISC, LAPB_POLLON, LAPB_COMMAND);
303	lapb_start_t1timer(lapb);
304	lapb_stop_t2timer(lapb);
305	lapb->state = LAPB_STATE_2;
306
307#if LAPB_DEBUG > 1
308	printk(KERN_DEBUG "lapb: (%p) S3 DISC(1)\n", lapb->token);
309#endif
310#if LAPB_DEBUG > 0
311	printk(KERN_DEBUG "lapb: (%p) S3 -> S2\n", lapb->token);
312#endif
313
314	return LAPB_OK;
315}
316
317int lapb_data_request(void *token, struct sk_buff *skb)
318{
319	lapb_cb *lapb;
320
321	if ((lapb = lapb_tokentostruct(token)) == NULL)
322		return LAPB_BADTOKEN;
323
324	if (lapb->state != LAPB_STATE_3 && lapb->state != LAPB_STATE_4)
325		return LAPB_NOTCONNECTED;
326
327	skb_queue_tail(&lapb->write_queue, skb);
328
329	lapb_kick(lapb);
330
331	return LAPB_OK;
332}
333
334int lapb_data_received(void *token, struct sk_buff *skb)
335{
336	lapb_cb *lapb;
337
338	if ((lapb = lapb_tokentostruct(token)) == NULL)
339		return LAPB_BADTOKEN;
340
341	lapb_data_input(lapb, skb);
342
343	return LAPB_OK;
344}
345
346void lapb_connect_confirmation(lapb_cb *lapb, int reason)
347{
348	if (lapb->callbacks.connect_confirmation != NULL)
349		(lapb->callbacks.connect_confirmation)(lapb->token, reason);
350}
351
352void lapb_connect_indication(lapb_cb *lapb, int reason)
353{
354	if (lapb->callbacks.connect_indication != NULL)
355		(lapb->callbacks.connect_indication)(lapb->token, reason);
356}
357
358void lapb_disconnect_confirmation(lapb_cb *lapb, int reason)
359{
360	if (lapb->callbacks.disconnect_confirmation != NULL)
361		(lapb->callbacks.disconnect_confirmation)(lapb->token, reason);
362}
363
364void lapb_disconnect_indication(lapb_cb *lapb, int reason)
365{
366	if (lapb->callbacks.disconnect_indication != NULL)
367		(lapb->callbacks.disconnect_indication)(lapb->token, reason);
368}
369
370int lapb_data_indication(lapb_cb *lapb, struct sk_buff *skb)
371{
372	if (lapb->callbacks.data_indication != NULL) {
373		return (lapb->callbacks.data_indication)(lapb->token, skb);
374	}
375	kfree_skb(skb);
376	return NET_RX_CN_HIGH; /* For now; must be != NET_RX_DROP */
377}
378
379int lapb_data_transmit(lapb_cb *lapb, struct sk_buff *skb)
380{
381	int used = 0;
382
383	if (lapb->callbacks.data_transmit != NULL) {
384		(lapb->callbacks.data_transmit)(lapb->token, skb);
385		used = 1;
386	}
387
388	return used;
389}
390
391EXPORT_SYMBOL(lapb_register);
392EXPORT_SYMBOL(lapb_unregister);
393EXPORT_SYMBOL(lapb_getparms);
394EXPORT_SYMBOL(lapb_setparms);
395EXPORT_SYMBOL(lapb_connect_request);
396EXPORT_SYMBOL(lapb_disconnect_request);
397EXPORT_SYMBOL(lapb_data_request);
398EXPORT_SYMBOL(lapb_data_received);
399
400static char banner[] __initdata = KERN_INFO "NET4: LAPB for Linux. Version 0.01 for NET4.0\n";
401
402static int __init lapb_init(void)
403{
404	printk(banner);
405	return 0;
406}
407
408MODULE_AUTHOR("Jonathan Naylor <g4klx@g4klx.demon.co.uk>");
409MODULE_DESCRIPTION("The X.25 Link Access Procedure B link layer protocol");
410MODULE_LICENSE("GPL");
411
412module_init(lapb_init);
413