ia64/linux-2.6.18-xen.hg

view net/ax25/ax25_std_in.c @ 673:3161879fdf22

[IA64] xencomm: support XENMEM_add_to_physmap and XENMEM_remove_from_phsymap

support XENMEM_add_to_physmap and XENMEM_remove_from_phsymap.

Signed-off-by: Isaku Yamahata <yamahata@valinux.co.jp>
author Isaku Yamahata <yamahata@valinux.co.jp>
date Tue Sep 16 21:26:15 2008 +0900 (2008-09-16)
parents 831230e53067
children
line source
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 (alan@lxorguk.ukuu.org.uk)
8 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
9 * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
10 * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de)
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>
22 #include <linux/sched.h>
23 #include <linux/timer.h>
24 #include <linux/string.h>
25 #include <linux/sockios.h>
26 #include <linux/net.h>
27 #include <net/ax25.h>
28 #include <linux/inet.h>
29 #include <linux/netdevice.h>
30 #include <linux/skbuff.h>
31 #include <net/sock.h>
32 #include <net/tcp_states.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>
39 /*
40 * State machine for state 1, Awaiting Connection State.
41 * The handling of the timer(s) is in file ax25_std_timer.c.
42 * Handling of state 0 and connection release is in ax25.c.
43 */
44 static int ax25_std_state1_machine(ax25_cb *ax25, struct sk_buff *skb, int frametype, int pf, int type)
45 {
46 switch (frametype) {
47 case AX25_SABM:
48 ax25->modulus = AX25_MODULUS;
49 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
50 ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
51 break;
53 case AX25_SABME:
54 ax25->modulus = AX25_EMODULUS;
55 ax25->window = ax25->ax25_dev->values[AX25_VALUES_EWINDOW];
56 ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
57 break;
59 case AX25_DISC:
60 ax25_send_control(ax25, AX25_DM, pf, AX25_RESPONSE);
61 break;
63 case AX25_UA:
64 if (pf) {
65 ax25_calculate_rtt(ax25);
66 ax25_stop_t1timer(ax25);
67 ax25_start_t3timer(ax25);
68 ax25_start_idletimer(ax25);
69 ax25->vs = 0;
70 ax25->va = 0;
71 ax25->vr = 0;
72 ax25->state = AX25_STATE_3;
73 ax25->n2count = 0;
74 if (ax25->sk != NULL) {
75 bh_lock_sock(ax25->sk);
76 ax25->sk->sk_state = TCP_ESTABLISHED;
77 /* For WAIT_SABM connections we will produce an accept ready socket here */
78 if (!sock_flag(ax25->sk, SOCK_DEAD))
79 ax25->sk->sk_state_change(ax25->sk);
80 bh_unlock_sock(ax25->sk);
81 }
82 }
83 break;
85 case AX25_DM:
86 if (pf) {
87 if (ax25->modulus == AX25_MODULUS) {
88 ax25_disconnect(ax25, ECONNREFUSED);
89 } else {
90 ax25->modulus = AX25_MODULUS;
91 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
92 }
93 }
94 break;
96 default:
97 break;
98 }
100 return 0;
101 }
103 /*
104 * State machine for state 2, Awaiting Release State.
105 * The handling of the timer(s) is in file ax25_std_timer.c
106 * Handling of state 0 and connection release is in ax25.c.
107 */
108 static int ax25_std_state2_machine(ax25_cb *ax25, struct sk_buff *skb, int frametype, int pf, int type)
109 {
110 switch (frametype) {
111 case AX25_SABM:
112 case AX25_SABME:
113 ax25_send_control(ax25, AX25_DM, pf, AX25_RESPONSE);
114 break;
116 case AX25_DISC:
117 ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
118 ax25_disconnect(ax25, 0);
119 break;
121 case AX25_DM:
122 case AX25_UA:
123 if (pf)
124 ax25_disconnect(ax25, 0);
125 break;
127 case AX25_I:
128 case AX25_REJ:
129 case AX25_RNR:
130 case AX25_RR:
131 if (pf) ax25_send_control(ax25, AX25_DM, AX25_POLLON, AX25_RESPONSE);
132 break;
134 default:
135 break;
136 }
138 return 0;
139 }
141 /*
142 * State machine for state 3, Connected State.
143 * The handling of the timer(s) is in file ax25_std_timer.c
144 * Handling of state 0 and connection release is in ax25.c.
145 */
146 static int ax25_std_state3_machine(ax25_cb *ax25, struct sk_buff *skb, int frametype, int ns, int nr, int pf, int type)
147 {
148 int queued = 0;
150 switch (frametype) {
151 case AX25_SABM:
152 case AX25_SABME:
153 if (frametype == AX25_SABM) {
154 ax25->modulus = AX25_MODULUS;
155 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
156 } else {
157 ax25->modulus = AX25_EMODULUS;
158 ax25->window = ax25->ax25_dev->values[AX25_VALUES_EWINDOW];
159 }
160 ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
161 ax25_stop_t1timer(ax25);
162 ax25_stop_t2timer(ax25);
163 ax25_start_t3timer(ax25);
164 ax25_start_idletimer(ax25);
165 ax25->condition = 0x00;
166 ax25->vs = 0;
167 ax25->va = 0;
168 ax25->vr = 0;
169 ax25_requeue_frames(ax25);
170 break;
172 case AX25_DISC:
173 ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
174 ax25_disconnect(ax25, 0);
175 break;
177 case AX25_DM:
178 ax25_disconnect(ax25, ECONNRESET);
179 break;
181 case AX25_RR:
182 case AX25_RNR:
183 if (frametype == AX25_RR)
184 ax25->condition &= ~AX25_COND_PEER_RX_BUSY;
185 else
186 ax25->condition |= AX25_COND_PEER_RX_BUSY;
187 if (type == AX25_COMMAND && pf)
188 ax25_std_enquiry_response(ax25);
189 if (ax25_validate_nr(ax25, nr)) {
190 ax25_check_iframes_acked(ax25, nr);
191 } else {
192 ax25_std_nr_error_recovery(ax25);
193 ax25->state = AX25_STATE_1;
194 }
195 break;
197 case AX25_REJ:
198 ax25->condition &= ~AX25_COND_PEER_RX_BUSY;
199 if (type == AX25_COMMAND && pf)
200 ax25_std_enquiry_response(ax25);
201 if (ax25_validate_nr(ax25, nr)) {
202 ax25_frames_acked(ax25, nr);
203 ax25_calculate_rtt(ax25);
204 ax25_stop_t1timer(ax25);
205 ax25_start_t3timer(ax25);
206 ax25_requeue_frames(ax25);
207 } else {
208 ax25_std_nr_error_recovery(ax25);
209 ax25->state = AX25_STATE_1;
210 }
211 break;
213 case AX25_I:
214 if (!ax25_validate_nr(ax25, nr)) {
215 ax25_std_nr_error_recovery(ax25);
216 ax25->state = AX25_STATE_1;
217 break;
218 }
219 if (ax25->condition & AX25_COND_PEER_RX_BUSY) {
220 ax25_frames_acked(ax25, nr);
221 } else {
222 ax25_check_iframes_acked(ax25, nr);
223 }
224 if (ax25->condition & AX25_COND_OWN_RX_BUSY) {
225 if (pf) ax25_std_enquiry_response(ax25);
226 break;
227 }
228 if (ns == ax25->vr) {
229 ax25->vr = (ax25->vr + 1) % ax25->modulus;
230 queued = ax25_rx_iframe(ax25, skb);
231 if (ax25->condition & AX25_COND_OWN_RX_BUSY)
232 ax25->vr = ns; /* ax25->vr - 1 */
233 ax25->condition &= ~AX25_COND_REJECT;
234 if (pf) {
235 ax25_std_enquiry_response(ax25);
236 } else {
237 if (!(ax25->condition & AX25_COND_ACK_PENDING)) {
238 ax25->condition |= AX25_COND_ACK_PENDING;
239 ax25_start_t2timer(ax25);
240 }
241 }
242 } else {
243 if (ax25->condition & AX25_COND_REJECT) {
244 if (pf) ax25_std_enquiry_response(ax25);
245 } else {
246 ax25->condition |= AX25_COND_REJECT;
247 ax25_send_control(ax25, AX25_REJ, pf, AX25_RESPONSE);
248 ax25->condition &= ~AX25_COND_ACK_PENDING;
249 }
250 }
251 break;
253 case AX25_FRMR:
254 case AX25_ILLEGAL:
255 ax25_std_establish_data_link(ax25);
256 ax25->state = AX25_STATE_1;
257 break;
259 default:
260 break;
261 }
263 return queued;
264 }
266 /*
267 * State machine for state 4, Timer Recovery State.
268 * The handling of the timer(s) is in file ax25_std_timer.c
269 * Handling of state 0 and connection release is in ax25.c.
270 */
271 static int ax25_std_state4_machine(ax25_cb *ax25, struct sk_buff *skb, int frametype, int ns, int nr, int pf, int type)
272 {
273 int queued = 0;
275 switch (frametype) {
276 case AX25_SABM:
277 case AX25_SABME:
278 if (frametype == AX25_SABM) {
279 ax25->modulus = AX25_MODULUS;
280 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
281 } else {
282 ax25->modulus = AX25_EMODULUS;
283 ax25->window = ax25->ax25_dev->values[AX25_VALUES_EWINDOW];
284 }
285 ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
286 ax25_stop_t1timer(ax25);
287 ax25_stop_t2timer(ax25);
288 ax25_start_t3timer(ax25);
289 ax25_start_idletimer(ax25);
290 ax25->condition = 0x00;
291 ax25->vs = 0;
292 ax25->va = 0;
293 ax25->vr = 0;
294 ax25->state = AX25_STATE_3;
295 ax25->n2count = 0;
296 ax25_requeue_frames(ax25);
297 break;
299 case AX25_DISC:
300 ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
301 ax25_disconnect(ax25, 0);
302 break;
304 case AX25_DM:
305 ax25_disconnect(ax25, ECONNRESET);
306 break;
308 case AX25_RR:
309 case AX25_RNR:
310 if (frametype == AX25_RR)
311 ax25->condition &= ~AX25_COND_PEER_RX_BUSY;
312 else
313 ax25->condition |= AX25_COND_PEER_RX_BUSY;
314 if (type == AX25_RESPONSE && pf) {
315 ax25_stop_t1timer(ax25);
316 ax25->n2count = 0;
317 if (ax25_validate_nr(ax25, nr)) {
318 ax25_frames_acked(ax25, nr);
319 if (ax25->vs == ax25->va) {
320 ax25_start_t3timer(ax25);
321 ax25->state = AX25_STATE_3;
322 } else {
323 ax25_requeue_frames(ax25);
324 }
325 } else {
326 ax25_std_nr_error_recovery(ax25);
327 ax25->state = AX25_STATE_1;
328 }
329 break;
330 }
331 if (type == AX25_COMMAND && pf)
332 ax25_std_enquiry_response(ax25);
333 if (ax25_validate_nr(ax25, nr)) {
334 ax25_frames_acked(ax25, nr);
335 } else {
336 ax25_std_nr_error_recovery(ax25);
337 ax25->state = AX25_STATE_1;
338 }
339 break;
341 case AX25_REJ:
342 ax25->condition &= ~AX25_COND_PEER_RX_BUSY;
343 if (pf && type == AX25_RESPONSE) {
344 ax25_stop_t1timer(ax25);
345 ax25->n2count = 0;
346 if (ax25_validate_nr(ax25, nr)) {
347 ax25_frames_acked(ax25, nr);
348 if (ax25->vs == ax25->va) {
349 ax25_start_t3timer(ax25);
350 ax25->state = AX25_STATE_3;
351 } else {
352 ax25_requeue_frames(ax25);
353 }
354 } else {
355 ax25_std_nr_error_recovery(ax25);
356 ax25->state = AX25_STATE_1;
357 }
358 break;
359 }
360 if (type == AX25_COMMAND && pf)
361 ax25_std_enquiry_response(ax25);
362 if (ax25_validate_nr(ax25, nr)) {
363 ax25_frames_acked(ax25, nr);
364 ax25_requeue_frames(ax25);
365 } else {
366 ax25_std_nr_error_recovery(ax25);
367 ax25->state = AX25_STATE_1;
368 }
369 break;
371 case AX25_I:
372 if (!ax25_validate_nr(ax25, nr)) {
373 ax25_std_nr_error_recovery(ax25);
374 ax25->state = AX25_STATE_1;
375 break;
376 }
377 ax25_frames_acked(ax25, nr);
378 if (ax25->condition & AX25_COND_OWN_RX_BUSY) {
379 if (pf)
380 ax25_std_enquiry_response(ax25);
381 break;
382 }
383 if (ns == ax25->vr) {
384 ax25->vr = (ax25->vr + 1) % ax25->modulus;
385 queued = ax25_rx_iframe(ax25, skb);
386 if (ax25->condition & AX25_COND_OWN_RX_BUSY)
387 ax25->vr = ns; /* ax25->vr - 1 */
388 ax25->condition &= ~AX25_COND_REJECT;
389 if (pf) {
390 ax25_std_enquiry_response(ax25);
391 } else {
392 if (!(ax25->condition & AX25_COND_ACK_PENDING)) {
393 ax25->condition |= AX25_COND_ACK_PENDING;
394 ax25_start_t2timer(ax25);
395 }
396 }
397 } else {
398 if (ax25->condition & AX25_COND_REJECT) {
399 if (pf) ax25_std_enquiry_response(ax25);
400 } else {
401 ax25->condition |= AX25_COND_REJECT;
402 ax25_send_control(ax25, AX25_REJ, pf, AX25_RESPONSE);
403 ax25->condition &= ~AX25_COND_ACK_PENDING;
404 }
405 }
406 break;
408 case AX25_FRMR:
409 case AX25_ILLEGAL:
410 ax25_std_establish_data_link(ax25);
411 ax25->state = AX25_STATE_1;
412 break;
414 default:
415 break;
416 }
418 return queued;
419 }
421 /*
422 * Higher level upcall for a LAPB frame
423 */
424 int ax25_std_frame_in(ax25_cb *ax25, struct sk_buff *skb, int type)
425 {
426 int queued = 0, frametype, ns, nr, pf;
428 frametype = ax25_decode(ax25, skb, &ns, &nr, &pf);
430 switch (ax25->state) {
431 case AX25_STATE_1:
432 queued = ax25_std_state1_machine(ax25, skb, frametype, pf, type);
433 break;
434 case AX25_STATE_2:
435 queued = ax25_std_state2_machine(ax25, skb, frametype, pf, type);
436 break;
437 case AX25_STATE_3:
438 queued = ax25_std_state3_machine(ax25, skb, frametype, ns, nr, pf, type);
439 break;
440 case AX25_STATE_4:
441 queued = ax25_std_state4_machine(ax25, skb, frametype, ns, nr, pf, type);
442 break;
443 }
445 ax25_kick(ax25);
447 return queued;
448 }