net/ax25/ax25_std_in.c

   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>
  38
  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;
  52
  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;
  58
  59         case AX25_DISC:
  60                 ax25_send_control(ax25, AX25_DM, pf, AX25_RESPONSE);
  61                 break;
  62
  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;
  84
  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;
  95
  96         default:
  97                 break;
  98         }
  99
 100         return 0;
 101 }
 102
 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;
 115
 116         case AX25_DISC:
 117                 ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
 118                 ax25_disconnect(ax25, 0);
 119                 break;
 120
 121         case AX25_DM:
 122         case AX25_UA:
 123                 if (pf)
 124                         ax25_disconnect(ax25, 0);
 125                 break;
 126
 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;
 133
 134         default:
 135                 break;
 136         }
 137
 138         return 0;
 139 }
 140
 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;
 149
 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;
 171
 172         case AX25_DISC:
 173                 ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
 174                 ax25_disconnect(ax25, 0);
 175                 break;
 176
 177         case AX25_DM:
 178                 ax25_disconnect(ax25, ECONNRESET);
 179                 break;
 180
 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;
 196
 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;
 212
 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;
 252
 253         case AX25_FRMR:
 254         case AX25_ILLEGAL:
 255                 ax25_std_establish_data_link(ax25);
 256                 ax25->state = AX25_STATE_1;
 257                 break;
 258
 259         default:
 260                 break;
 261         }
 262
 263         return queued;
 264 }
 265
 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;
 274
 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;
 298
 299         case AX25_DISC:
 300                 ax25_send_control(ax25, AX25_UA, pf, AX25_RESPONSE);
 301                 ax25_disconnect(ax25, 0);
 302                 break;
 303
 304         case AX25_DM:
 305                 ax25_disconnect(ax25, ECONNRESET);
 306                 break;
 307
 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;
 340
 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;
 370
 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;
 407
 408         case AX25_FRMR:
 409         case AX25_ILLEGAL:
 410                 ax25_std_establish_data_link(ax25);
 411                 ax25->state = AX25_STATE_1;
 412                 break;
 413
 414         default:
 415                 break;
 416         }
 417
 418         return queued;
 419 }
 420
 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;
 427
 428         frametype = ax25_decode(ax25, skb, &ns, &nr, &pf);
 429
 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         }
 444
 445         ax25_kick(ax25);
 446
 447         return queued;
 448 }