~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/ax25/ax25_ds_in.c

Version: ~ [ linux-5.8-rc3 ] ~ [ linux-5.7.5 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.48 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.129 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.185 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.228 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.228 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
  8  * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
  9  */
 10 #include <linux/errno.h>
 11 #include <linux/types.h>
 12 #include <linux/socket.h>
 13 #include <linux/in.h>
 14 #include <linux/kernel.h>
 15 #include <linux/timer.h>
 16 #include <linux/string.h>
 17 #include <linux/sockios.h>
 18 #include <linux/net.h>
 19 #include <net/ax25.h>
 20 #include <linux/inet.h>
 21 #include <linux/netdevice.h>
 22 #include <linux/skbuff.h>
 23 #include <net/sock.h>
 24 #include <net/tcp_states.h>
 25 #include <linux/uaccess.h>
 26 #include <linux/fcntl.h>
 27 #include <linux/mm.h>
 28 #include <linux/interrupt.h>
 29 
 30 /*
 31  *      State machine for state 1, Awaiting Connection State.
 32  *      The handling of the timer(s) is in file ax25_ds_timer.c.
 33  *      Handling of state 0 and connection release is in ax25.c.
 34  */
 35 static int ax25_ds_state1_machine(ax25_cb *ax25, struct sk_buff *skb, int frametype, int pf, int type)
 36 {
 37         switch (frametype) {
 38         case AX25_SABM:
 39                 ax25->modulus = AX25_MODULUS;
 40                 ax25->window  = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
 41                 ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
 42                 break;
 43 
 44         case AX25_SABME:
 45                 ax25->modulus = AX25_EMODULUS;
 46                 ax25->window  =  ax25->ax25_dev->values[AX25_VALUES_EWINDOW];
 47                 ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
 48                 break;
 49 
 50         case AX25_DISC:
 51                 ax25_send_control(ax25, AX25_DM, pf, AX25_RESPONSE);
 52                 break;
 53 
 54         case AX25_UA:
 55                 ax25_calculate_rtt(ax25);
 56                 ax25_stop_t1timer(ax25);
 57                 ax25_start_t3timer(ax25);
 58                 ax25_start_idletimer(ax25);
 59                 ax25->vs      = 0;
 60                 ax25->va      = 0;
 61                 ax25->vr      = 0;
 62                 ax25->state   = AX25_STATE_3;
 63                 ax25->n2count = 0;
 64                 if (ax25->sk != NULL) {
 65                         bh_lock_sock(ax25->sk);
 66                         ax25->sk->sk_state = TCP_ESTABLISHED;
 67                         /*
 68                          * For WAIT_SABM connections we will produce an accept
 69                          * ready socket here
 70                          */
 71                         if (!sock_flag(ax25->sk, SOCK_DEAD))
 72                                 ax25->sk->sk_state_change(ax25->sk);
 73                         bh_unlock_sock(ax25->sk);
 74                 }
 75                 ax25_dama_on(ax25);
 76 
 77                 /* according to DK4EG's spec we are required to
 78                  * send a RR RESPONSE FINAL NR=0.
 79                  */
 80 
 81                 ax25_std_enquiry_response(ax25);
 82                 break;
 83 
 84         case AX25_DM:
 85                 if (pf)
 86                         ax25_disconnect(ax25, ECONNREFUSED);
 87                 break;
 88 
 89         default:
 90                 if (pf)
 91                         ax25_send_control(ax25, AX25_SABM, AX25_POLLON, AX25_COMMAND);
 92                 break;
 93         }
 94 
 95         return 0;
 96 }
 97 
 98 /*
 99  *      State machine for state 2, Awaiting Release State.
100  *      The handling of the timer(s) is in file ax25_ds_timer.c
101  *      Handling of state 0 and connection release is in ax25.c.
102  */
103 static int ax25_ds_state2_machine(ax25_cb *ax25, struct sk_buff *skb, int frametype, int pf, int type)
104 {
105         switch (frametype) {
106         case AX25_SABM:
107         case AX25_SABME:
108                 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
109                 ax25_dama_off(ax25);
110                 break;
111 
112         case AX25_DISC:
113                 ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
114                 ax25_dama_off(ax25);
115                 ax25_disconnect(ax25, 0);
116                 break;
117 
118         case AX25_DM:
119         case AX25_UA:
120                 if (pf) {
121                         ax25_dama_off(ax25);
122                         ax25_disconnect(ax25, 0);
123                 }
124                 break;
125 
126         case AX25_I:
127         case AX25_REJ:
128         case AX25_RNR:
129         case AX25_RR:
130                 if (pf) {
131                         ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
132                         ax25_dama_off(ax25);
133                 }
134                 break;
135 
136         default:
137                 break;
138         }
139 
140         return 0;
141 }
142 
143 /*
144  *      State machine for state 3, Connected State.
145  *      The handling of the timer(s) is in file ax25_timer.c
146  *      Handling of state 0 and connection release is in ax25.c.
147  */
148 static int ax25_ds_state3_machine(ax25_cb *ax25, struct sk_buff *skb, int frametype, int ns, int nr, int pf, int type)
149 {
150         int queued = 0;
151 
152         switch (frametype) {
153         case AX25_SABM:
154         case AX25_SABME:
155                 if (frametype == AX25_SABM) {
156                         ax25->modulus   = AX25_MODULUS;
157                         ax25->window    = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
158                 } else {
159                         ax25->modulus   = AX25_EMODULUS;
160                         ax25->window    = ax25->ax25_dev->values[AX25_VALUES_EWINDOW];
161                 }
162                 ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
163                 ax25_stop_t1timer(ax25);
164                 ax25_start_t3timer(ax25);
165                 ax25_start_idletimer(ax25);
166                 ax25->condition = 0x00;
167                 ax25->vs        = 0;
168                 ax25->va        = 0;
169                 ax25->vr        = 0;
170                 ax25_requeue_frames(ax25);
171                 ax25_dama_on(ax25);
172                 break;
173 
174         case AX25_DISC:
175                 ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
176                 ax25_dama_off(ax25);
177                 ax25_disconnect(ax25, 0);
178                 break;
179 
180         case AX25_DM:
181                 ax25_dama_off(ax25);
182                 ax25_disconnect(ax25, ECONNRESET);
183                 break;
184 
185         case AX25_RR:
186         case AX25_RNR:
187                 if (frametype == AX25_RR)
188                         ax25->condition &= ~AX25_COND_PEER_RX_BUSY;
189                 else
190                         ax25->condition |= AX25_COND_PEER_RX_BUSY;
191 
192                 if (ax25_validate_nr(ax25, nr)) {
193                         if (ax25_check_iframes_acked(ax25, nr))
194                                 ax25->n2count=0;
195                         if (type == AX25_COMMAND && pf)
196                                 ax25_ds_enquiry_response(ax25);
197                 } else {
198                         ax25_ds_nr_error_recovery(ax25);
199                         ax25->state = AX25_STATE_1;
200                 }
201                 break;
202 
203         case AX25_REJ:
204                 ax25->condition &= ~AX25_COND_PEER_RX_BUSY;
205 
206                 if (ax25_validate_nr(ax25, nr)) {
207                         if (ax25->va != nr)
208                                 ax25->n2count=0;
209 
210                         ax25_frames_acked(ax25, nr);
211                         ax25_calculate_rtt(ax25);
212                         ax25_stop_t1timer(ax25);
213                         ax25_start_t3timer(ax25);
214                         ax25_requeue_frames(ax25);
215 
216                         if (type == AX25_COMMAND && pf)
217                                 ax25_ds_enquiry_response(ax25);
218                 } else {
219                         ax25_ds_nr_error_recovery(ax25);
220                         ax25->state = AX25_STATE_1;
221                 }
222                 break;
223 
224         case AX25_I:
225                 if (!ax25_validate_nr(ax25, nr)) {
226                         ax25_ds_nr_error_recovery(ax25);
227                         ax25->state = AX25_STATE_1;
228                         break;
229                 }
230                 if (ax25->condition & AX25_COND_PEER_RX_BUSY) {
231                         ax25_frames_acked(ax25, nr);
232                         ax25->n2count = 0;
233                 } else {
234                         if (ax25_check_iframes_acked(ax25, nr))
235                                 ax25->n2count = 0;
236                 }
237                 if (ax25->condition & AX25_COND_OWN_RX_BUSY) {
238                         if (pf) ax25_ds_enquiry_response(ax25);
239                         break;
240                 }
241                 if (ns == ax25->vr) {
242                         ax25->vr = (ax25->vr + 1) % ax25->modulus;
243                         queued = ax25_rx_iframe(ax25, skb);
244                         if (ax25->condition & AX25_COND_OWN_RX_BUSY)
245                                 ax25->vr = ns;  /* ax25->vr - 1 */
246                         ax25->condition &= ~AX25_COND_REJECT;
247                         if (pf) {
248                                 ax25_ds_enquiry_response(ax25);
249                         } else {
250                                 if (!(ax25->condition & AX25_COND_ACK_PENDING)) {
251                                         ax25->condition |= AX25_COND_ACK_PENDING;
252                                         ax25_start_t2timer(ax25);
253                                 }
254                         }
255                 } else {
256                         if (ax25->condition & AX25_COND_REJECT) {
257                                 if (pf) ax25_ds_enquiry_response(ax25);
258                         } else {
259                                 ax25->condition |= AX25_COND_REJECT;
260                                 ax25_ds_enquiry_response(ax25);
261                                 ax25->condition &= ~AX25_COND_ACK_PENDING;
262                         }
263                 }
264                 break;
265 
266         case AX25_FRMR:
267         case AX25_ILLEGAL:
268                 ax25_ds_establish_data_link(ax25);
269                 ax25->state = AX25_STATE_1;
270                 break;
271 
272         default:
273                 break;
274         }
275 
276         return queued;
277 }
278 
279 /*
280  *      Higher level upcall for a LAPB frame
281  */
282 int ax25_ds_frame_in(ax25_cb *ax25, struct sk_buff *skb, int type)
283 {
284         int queued = 0, frametype, ns, nr, pf;
285 
286         frametype = ax25_decode(ax25, skb, &ns, &nr, &pf);
287 
288         switch (ax25->state) {
289         case AX25_STATE_1:
290                 queued = ax25_ds_state1_machine(ax25, skb, frametype, pf, type);
291                 break;
292         case AX25_STATE_2:
293                 queued = ax25_ds_state2_machine(ax25, skb, frametype, pf, type);
294                 break;
295         case AX25_STATE_3:
296                 queued = ax25_ds_state3_machine(ax25, skb, frametype, ns, nr, pf, type);
297                 break;
298         }
299 
300         return queued;
301 }
302 
303 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp