net/lapb/lapb_in.c

   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 Naulor 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/errno.h>
  19 #include <linux/types.h>
  20 #include <linux/socket.h>
  21 #include <linux/in.h>
  22 #include <linux/kernel.h>
  23 #include <linux/timer.h>
  24 #include <linux/string.h>
  25 #include <linux/sockios.h>
  26 #include <linux/net.h>
  27 #include <linux/inet.h>
  28 #include <linux/netdevice.h>
  29 #include <linux/skbuff.h>
  30 #include <linux/slab.h>
  31 #include <net/sock.h>
  32 #include <asm/uaccess.h>
  33 #include <linux/fcntl.h>
  34 #include <linux/mm.h>
  35 #include <linux/interrupt.h>
  36 #include <net/lapb.h>
  37
  38 /*
  39  *      State machine for state 0, Disconnected State.
  40  *      The handling of the timer(s) is in file lapb_timer.c.
  41  */
  42 static void lapb_state0_machine(struct lapb_cb *lapb, struct sk_buff *skb,
  43                                 struct lapb_frame *frame)
  44 {
  45         switch (frame->type) {
  46         case LAPB_SABM:
  47 #if LAPB_DEBUG > 1
  48                 printk(KERN_DEBUG "lapb: (%p) S0 RX SABM(%d)\n",
  49                        lapb->dev, frame->pf);
  50 #endif
  51                 if (lapb->mode & LAPB_EXTENDED) {
  52 #if LAPB_DEBUG > 1
  53                         printk(KERN_DEBUG "lapb: (%p) S0 TX DM(%d)\n",
  54                                lapb->dev, frame->pf);
  55 #endif
  56                         lapb_send_control(lapb, LAPB_DM, frame->pf,
  57                                           LAPB_RESPONSE);
  58                 } else {
  59 #if LAPB_DEBUG > 1
  60                         printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
  61                                lapb->dev, frame->pf);
  62 #endif
  63 #if LAPB_DEBUG > 0
  64                         printk(KERN_DEBUG "lapb: (%p) S0 -> S3\n", lapb->dev);
  65 #endif
  66                         lapb_send_control(lapb, LAPB_UA, frame->pf,
  67                                           LAPB_RESPONSE);
  68                         lapb_stop_t1timer(lapb);
  69                         lapb_stop_t2timer(lapb);
  70                         lapb->state     = LAPB_STATE_3;
  71                         lapb->condition = 0x00;
  72                         lapb->n2count   = 0;
  73                         lapb->vs        = 0;
  74                         lapb->vr        = 0;
  75                         lapb->va        = 0;
  76                         lapb_connect_indication(lapb, LAPB_OK);
  77                 }
  78                 break;
  79
  80         case LAPB_SABME:
  81 #if LAPB_DEBUG > 1
  82                 printk(KERN_DEBUG "lapb: (%p) S0 RX SABME(%d)\n",
  83                        lapb->dev, frame->pf);
  84 #endif
  85                 if (lapb->mode & LAPB_EXTENDED) {
  86 #if LAPB_DEBUG > 1
  87                         printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
  88                                lapb->dev, frame->pf);
  89 #endif
  90 #if LAPB_DEBUG > 0
  91                         printk(KERN_DEBUG "lapb: (%p) S0 -> S3\n", lapb->dev);
  92 #endif
  93                         lapb_send_control(lapb, LAPB_UA, frame->pf,
  94                                           LAPB_RESPONSE);
  95                         lapb_stop_t1timer(lapb);
  96                         lapb_stop_t2timer(lapb);
  97                         lapb->state     = LAPB_STATE_3;
  98                         lapb->condition = 0x00;
  99                         lapb->n2count   = 0;
 100                         lapb->vs        = 0;
 101                         lapb->vr        = 0;
 102                         lapb->va        = 0;
 103                         lapb_connect_indication(lapb, LAPB_OK);
 104                 } else {
 105 #if LAPB_DEBUG > 1
 106                         printk(KERN_DEBUG "lapb: (%p) S0 TX DM(%d)\n",
 107                                lapb->dev, frame->pf);
 108 #endif
 109                         lapb_send_control(lapb, LAPB_DM, frame->pf,
 110                                           LAPB_RESPONSE);
 111                 }
 112                 break;
 113
 114         case LAPB_DISC:
 115 #if LAPB_DEBUG > 1
 116                 printk(KERN_DEBUG "lapb: (%p) S0 RX DISC(%d)\n",
 117                        lapb->dev, frame->pf);
 118                 printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
 119                        lapb->dev, frame->pf);
 120 #endif
 121                 lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE);
 122                 break;
 123
 124         default:
 125                 break;
 126         }
 127
 128         kfree_skb(skb);
 129 }
 130
 131 /*
 132  *      State machine for state 1, Awaiting Connection State.
 133  *      The handling of the timer(s) is in file lapb_timer.c.
 134  */
 135 static void lapb_state1_machine(struct lapb_cb *lapb, struct sk_buff *skb,
 136                                 struct lapb_frame *frame)
 137 {
 138         switch (frame->type) {
 139         case LAPB_SABM:
 140 #if LAPB_DEBUG > 1
 141                 printk(KERN_DEBUG "lapb: (%p) S1 RX SABM(%d)\n",
 142                        lapb->dev, frame->pf);
 143 #endif
 144                 if (lapb->mode & LAPB_EXTENDED) {
 145 #if LAPB_DEBUG > 1
 146                         printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
 147                                lapb->dev, frame->pf);
 148 #endif
 149                         lapb_send_control(lapb, LAPB_DM, frame->pf,
 150                                           LAPB_RESPONSE);
 151                 } else {
 152 #if LAPB_DEBUG > 1
 153                         printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n",
 154                                lapb->dev, frame->pf);
 155 #endif
 156                         lapb_send_control(lapb, LAPB_UA, frame->pf,
 157                                           LAPB_RESPONSE);
 158                 }
 159                 break;
 160
 161         case LAPB_SABME:
 162 #if LAPB_DEBUG > 1
 163                 printk(KERN_DEBUG "lapb: (%p) S1 RX SABME(%d)\n",
 164                        lapb->dev, frame->pf);
 165 #endif
 166                 if (lapb->mode & LAPB_EXTENDED) {
 167 #if LAPB_DEBUG > 1
 168                         printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n",
 169                                lapb->dev, frame->pf);
 170 #endif
 171                         lapb_send_control(lapb, LAPB_UA, frame->pf,
 172                                           LAPB_RESPONSE);
 173                 } else {
 174 #if LAPB_DEBUG > 1
 175                         printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
 176                                lapb->dev, frame->pf);
 177 #endif
 178                         lapb_send_control(lapb, LAPB_DM, frame->pf,
 179                                           LAPB_RESPONSE);
 180                 }
 181                 break;
 182
 183         case LAPB_DISC:
 184 #if LAPB_DEBUG > 1
 185                 printk(KERN_DEBUG "lapb: (%p) S1 RX DISC(%d)\n",
 186                        lapb->dev, frame->pf);
 187                 printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
 188                        lapb->dev, frame->pf);
 189 #endif
 190                 lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE);
 191                 break;
 192
 193         case LAPB_UA:
 194 #if LAPB_DEBUG > 1
 195                 printk(KERN_DEBUG "lapb: (%p) S1 RX UA(%d)\n",
 196                        lapb->dev, frame->pf);
 197 #endif
 198                 if (frame->pf) {
 199 #if LAPB_DEBUG > 0
 200                         printk(KERN_DEBUG "lapb: (%p) S1 -> S3\n", lapb->dev);
 201 #endif
 202                         lapb_stop_t1timer(lapb);
 203                         lapb_stop_t2timer(lapb);
 204                         lapb->state     = LAPB_STATE_3;
 205                         lapb->condition = 0x00;
 206                         lapb->n2count   = 0;
 207                         lapb->vs        = 0;
 208                         lapb->vr        = 0;
 209                         lapb->va        = 0;
 210                         lapb_connect_confirmation(lapb, LAPB_OK);
 211                 }
 212                 break;
 213
 214         case LAPB_DM:
 215 #if LAPB_DEBUG > 1
 216                 printk(KERN_DEBUG "lapb: (%p) S1 RX DM(%d)\n",
 217                        lapb->dev, frame->pf);
 218 #endif
 219                 if (frame->pf) {
 220 #if LAPB_DEBUG > 0
 221                         printk(KERN_DEBUG "lapb: (%p) S1 -> S0\n", lapb->dev);
 222 #endif
 223                         lapb_clear_queues(lapb);
 224                         lapb->state = LAPB_STATE_0;
 225                         lapb_start_t1timer(lapb);
 226                         lapb_stop_t2timer(lapb);
 227                         lapb_disconnect_indication(lapb, LAPB_REFUSED);
 228                 }
 229                 break;
 230         }
 231
 232         kfree_skb(skb);
 233 }
 234
 235 /*
 236  *      State machine for state 2, Awaiting Release State.
 237  *      The handling of the timer(s) is in file lapb_timer.c
 238  */
 239 static void lapb_state2_machine(struct lapb_cb *lapb, struct sk_buff *skb,
 240                                 struct lapb_frame *frame)
 241 {
 242         switch (frame->type) {
 243         case LAPB_SABM:
 244         case LAPB_SABME:
 245 #if LAPB_DEBUG > 1
 246                 printk(KERN_DEBUG "lapb: (%p) S2 RX {SABM,SABME}(%d)\n",
 247                        lapb->dev, frame->pf);
 248                 printk(KERN_DEBUG "lapb: (%p) S2 TX DM(%d)\n",
 249                        lapb->dev, frame->pf);
 250 #endif
 251                 lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE);
 252                 break;
 253
 254         case LAPB_DISC:
 255 #if LAPB_DEBUG > 1
 256                 printk(KERN_DEBUG "lapb: (%p) S2 RX DISC(%d)\n",
 257                        lapb->dev, frame->pf);
 258                 printk(KERN_DEBUG "lapb: (%p) S2 TX UA(%d)\n",
 259                        lapb->dev, frame->pf);
 260 #endif
 261                 lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE);
 262                 break;
 263
 264         case LAPB_UA:
 265 #if LAPB_DEBUG > 1
 266                 printk(KERN_DEBUG "lapb: (%p) S2 RX UA(%d)\n",
 267                        lapb->dev, frame->pf);
 268 #endif
 269                 if (frame->pf) {
 270 #if LAPB_DEBUG > 0
 271                         printk(KERN_DEBUG "lapb: (%p) S2 -> S0\n", lapb->dev);
 272 #endif
 273                         lapb->state = LAPB_STATE_0;
 274                         lapb_start_t1timer(lapb);
 275                         lapb_stop_t2timer(lapb);
 276                         lapb_disconnect_confirmation(lapb, LAPB_OK);
 277                 }
 278                 break;
 279
 280         case LAPB_DM:
 281 #if LAPB_DEBUG > 1
 282                 printk(KERN_DEBUG "lapb: (%p) S2 RX DM(%d)\n",
 283                        lapb->dev, frame->pf);
 284 #endif
 285                 if (frame->pf) {
 286 #if LAPB_DEBUG > 0
 287                         printk(KERN_DEBUG "lapb: (%p) S2 -> S0\n", lapb->dev);
 288 #endif
 289                         lapb->state = LAPB_STATE_0;
 290                         lapb_start_t1timer(lapb);
 291                         lapb_stop_t2timer(lapb);
 292                         lapb_disconnect_confirmation(lapb, LAPB_NOTCONNECTED);
 293                 }
 294                 break;
 295
 296         case LAPB_I:
 297         case LAPB_REJ:
 298         case LAPB_RNR:
 299         case LAPB_RR:
 300 #if LAPB_DEBUG > 1
 301                 printk(KERN_DEBUG "lapb: (%p) S2 RX {I,REJ,RNR,RR}(%d)\n",
 302                        lapb->dev, frame->pf);
 303                 printk(KERN_DEBUG "lapb: (%p) S2 RX DM(%d)\n",
 304                        lapb->dev, frame->pf);
 305 #endif
 306                 if (frame->pf)
 307                         lapb_send_control(lapb, LAPB_DM, frame->pf,
 308                                           LAPB_RESPONSE);
 309                 break;
 310         }
 311
 312         kfree_skb(skb);
 313 }
 314
 315 /*
 316  *      State machine for state 3, Connected State.
 317  *      The handling of the timer(s) is in file lapb_timer.c
 318  */
 319 static void lapb_state3_machine(struct lapb_cb *lapb, struct sk_buff *skb,
 320                                 struct lapb_frame *frame)
 321 {
 322         int queued = 0;
 323         int modulus = (lapb->mode & LAPB_EXTENDED) ? LAPB_EMODULUS :
 324                                                      LAPB_SMODULUS;
 325
 326         switch (frame->type) {
 327         case LAPB_SABM:
 328 #if LAPB_DEBUG > 1
 329                 printk(KERN_DEBUG "lapb: (%p) S3 RX SABM(%d)\n",
 330                        lapb->dev, frame->pf);
 331 #endif
 332                 if (lapb->mode & LAPB_EXTENDED) {
 333 #if LAPB_DEBUG > 1
 334                         printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n",
 335                                lapb->dev, frame->pf);
 336 #endif
 337                         lapb_send_control(lapb, LAPB_DM, frame->pf,
 338                                           LAPB_RESPONSE);
 339                 } else {
 340 #if LAPB_DEBUG > 1
 341                         printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n",
 342                                lapb->dev, frame->pf);
 343 #endif
 344                         lapb_send_control(lapb, LAPB_UA, frame->pf,
 345                                           LAPB_RESPONSE);
 346                         lapb_stop_t1timer(lapb);
 347                         lapb_stop_t2timer(lapb);
 348                         lapb->condition = 0x00;
 349                         lapb->n2count   = 0;
 350                         lapb->vs        = 0;
 351                         lapb->vr        = 0;
 352                         lapb->va        = 0;
 353                         lapb_requeue_frames(lapb);
 354                 }
 355                 break;
 356
 357         case LAPB_SABME:
 358 #if LAPB_DEBUG > 1
 359                 printk(KERN_DEBUG "lapb: (%p) S3 RX SABME(%d)\n",
 360                        lapb->dev, frame->pf);
 361 #endif
 362                 if (lapb->mode & LAPB_EXTENDED) {
 363 #if LAPB_DEBUG > 1
 364                         printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n",
 365                                lapb->dev, frame->pf);
 366 #endif
 367                         lapb_send_control(lapb, LAPB_UA, frame->pf,
 368                                           LAPB_RESPONSE);
 369                         lapb_stop_t1timer(lapb);
 370                         lapb_stop_t2timer(lapb);
 371                         lapb->condition = 0x00;
 372                         lapb->n2count   = 0;
 373                         lapb->vs        = 0;
 374                         lapb->vr        = 0;
 375                         lapb->va        = 0;
 376                         lapb_requeue_frames(lapb);
 377                 } else {
 378 #if LAPB_DEBUG > 1
 379                         printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n",
 380                                lapb->dev, frame->pf);
 381 #endif
 382                         lapb_send_control(lapb, LAPB_DM, frame->pf,
 383                                           LAPB_RESPONSE);
 384                 }
 385                 break;
 386
 387         case LAPB_DISC:
 388 #if LAPB_DEBUG > 1
 389                 printk(KERN_DEBUG "lapb: (%p) S3 RX DISC(%d)\n",
 390                        lapb->dev, frame->pf);
 391 #endif
 392 #if LAPB_DEBUG > 0
 393                 printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n", lapb->dev);
 394 #endif
 395                 lapb_clear_queues(lapb);
 396                 lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE);
 397                 lapb_start_t1timer(lapb);
 398                 lapb_stop_t2timer(lapb);
 399                 lapb->state = LAPB_STATE_0;
 400                 lapb_disconnect_indication(lapb, LAPB_OK);
 401                 break;
 402
 403         case LAPB_DM:
 404 #if LAPB_DEBUG > 1
 405                 printk(KERN_DEBUG "lapb: (%p) S3 RX DM(%d)\n",
 406                        lapb->dev, frame->pf);
 407 #endif
 408 #if LAPB_DEBUG > 0
 409                 printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n", lapb->dev);
 410 #endif
 411                 lapb_clear_queues(lapb);
 412                 lapb->state = LAPB_STATE_0;
 413                 lapb_start_t1timer(lapb);
 414                 lapb_stop_t2timer(lapb);
 415                 lapb_disconnect_indication(lapb, LAPB_NOTCONNECTED);
 416                 break;
 417
 418         case LAPB_RNR:
 419 #if LAPB_DEBUG > 1
 420                 printk(KERN_DEBUG "lapb: (%p) S3 RX RNR(%d) R%d\n",
 421                        lapb->dev, frame->pf, frame->nr);
 422 #endif
 423                 lapb->condition |= LAPB_PEER_RX_BUSY_CONDITION;
 424                 lapb_check_need_response(lapb, frame->cr, frame->pf);
 425                 if (lapb_validate_nr(lapb, frame->nr)) {
 426                         lapb_check_iframes_acked(lapb, frame->nr);
 427                 } else {
 428                         lapb->frmr_data = *frame;
 429                         lapb->frmr_type = LAPB_FRMR_Z;
 430                         lapb_transmit_frmr(lapb);
 431 #if LAPB_DEBUG > 0
 432                         printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
 433 #endif
 434                         lapb_start_t1timer(lapb);
 435                         lapb_stop_t2timer(lapb);
 436                         lapb->state   = LAPB_STATE_4;
 437                         lapb->n2count = 0;
 438                 }
 439                 break;
 440
 441         case LAPB_RR:
 442 #if LAPB_DEBUG > 1
 443                 printk(KERN_DEBUG "lapb: (%p) S3 RX RR(%d) R%d\n",
 444                        lapb->dev, frame->pf, frame->nr);
 445 #endif
 446                 lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
 447                 lapb_check_need_response(lapb, frame->cr, frame->pf);
 448                 if (lapb_validate_nr(lapb, frame->nr)) {
 449                         lapb_check_iframes_acked(lapb, frame->nr);
 450                 } else {
 451                         lapb->frmr_data = *frame;
 452                         lapb->frmr_type = LAPB_FRMR_Z;
 453                         lapb_transmit_frmr(lapb);
 454 #if LAPB_DEBUG > 0
 455                         printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
 456 #endif
 457                         lapb_start_t1timer(lapb);
 458                         lapb_stop_t2timer(lapb);
 459                         lapb->state   = LAPB_STATE_4;
 460                         lapb->n2count = 0;
 461                 }
 462                 break;
 463
 464         case LAPB_REJ:
 465 #if LAPB_DEBUG > 1
 466                 printk(KERN_DEBUG "lapb: (%p) S3 RX REJ(%d) R%d\n",
 467                        lapb->dev, frame->pf, frame->nr);
 468 #endif
 469                 lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
 470                 lapb_check_need_response(lapb, frame->cr, frame->pf);
 471                 if (lapb_validate_nr(lapb, frame->nr)) {
 472                         lapb_frames_acked(lapb, frame->nr);
 473                         lapb_stop_t1timer(lapb);
 474                         lapb->n2count = 0;
 475                         lapb_requeue_frames(lapb);
 476                 } else {
 477                         lapb->frmr_data = *frame;
 478                         lapb->frmr_type = LAPB_FRMR_Z;
 479                         lapb_transmit_frmr(lapb);
 480 #if LAPB_DEBUG > 0
 481                         printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
 482 #endif
 483                         lapb_start_t1timer(lapb);
 484                         lapb_stop_t2timer(lapb);
 485                         lapb->state   = LAPB_STATE_4;
 486                         lapb->n2count = 0;
 487                 }
 488                 break;
 489
 490         case LAPB_I:
 491 #if LAPB_DEBUG > 1
 492                 printk(KERN_DEBUG "lapb: (%p) S3 RX I(%d) S%d R%d\n",
 493                        lapb->dev, frame->pf, frame->ns, frame->nr);
 494 #endif
 495                 if (!lapb_validate_nr(lapb, frame->nr)) {
 496                         lapb->frmr_data = *frame;
 497                         lapb->frmr_type = LAPB_FRMR_Z;
 498                         lapb_transmit_frmr(lapb);
 499 #if LAPB_DEBUG > 0
 500                         printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
 501 #endif
 502                         lapb_start_t1timer(lapb);
 503                         lapb_stop_t2timer(lapb);
 504                         lapb->state   = LAPB_STATE_4;
 505                         lapb->n2count = 0;
 506                         break;
 507                 }
 508                 if (lapb->condition & LAPB_PEER_RX_BUSY_CONDITION)
 509                         lapb_frames_acked(lapb, frame->nr);
 510                 else
 511                         lapb_check_iframes_acked(lapb, frame->nr);
 512
 513                 if (frame->ns == lapb->vr) {
 514                         int cn;
 515                         cn = lapb_data_indication(lapb, skb);
 516                         queued = 1;
 517                         /*
 518                          * If upper layer has dropped the frame, we
 519                          * basically ignore any further protocol
 520                          * processing. This will cause the peer
 521                          * to re-transmit the frame later like
 522                          * a frame lost on the wire.
 523                          */
 524                         if (cn == NET_RX_DROP) {
 525                                 printk(KERN_DEBUG "LAPB: rx congestion\n");
 526                                 break;
 527                         }
 528                         lapb->vr = (lapb->vr + 1) % modulus;
 529                         lapb->condition &= ~LAPB_REJECT_CONDITION;
 530                         if (frame->pf)
 531                                 lapb_enquiry_response(lapb);
 532                         else {
 533                                 if (!(lapb->condition &
 534                                       LAPB_ACK_PENDING_CONDITION)) {
 535                                         lapb->condition |= LAPB_ACK_PENDING_CONDITION;
 536                                         lapb_start_t2timer(lapb);
 537                                 }
 538                         }
 539                 } else {
 540                         if (lapb->condition & LAPB_REJECT_CONDITION) {
 541                                 if (frame->pf)
 542                                         lapb_enquiry_response(lapb);
 543                         } else {
 544 #if LAPB_DEBUG > 1
 545                                 printk(KERN_DEBUG
 546                                        "lapb: (%p) S3 TX REJ(%d) R%d\n",
 547                                        lapb->dev, frame->pf, lapb->vr);
 548 #endif
 549                                 lapb->condition |= LAPB_REJECT_CONDITION;
 550                                 lapb_send_control(lapb, LAPB_REJ, frame->pf,
 551                                                   LAPB_RESPONSE);
 552                                 lapb->condition &= ~LAPB_ACK_PENDING_CONDITION;
 553                         }
 554                 }
 555                 break;
 556
 557         case LAPB_FRMR:
 558 #if LAPB_DEBUG > 1
 559                 printk(KERN_DEBUG "lapb: (%p) S3 RX FRMR(%d) %02X "
 560                        "%02X %02X %02X %02X\n", lapb->dev, frame->pf,
 561                        skb->data[0], skb->data[1], skb->data[2],
 562                        skb->data[3], skb->data[4]);
 563 #endif
 564                 lapb_establish_data_link(lapb);
 565 #if LAPB_DEBUG > 0
 566                 printk(KERN_DEBUG "lapb: (%p) S3 -> S1\n", lapb->dev);
 567 #endif
 568                 lapb_requeue_frames(lapb);
 569                 lapb->state = LAPB_STATE_1;
 570                 break;
 571
 572         case LAPB_ILLEGAL:
 573 #if LAPB_DEBUG > 1
 574                 printk(KERN_DEBUG "lapb: (%p) S3 RX ILLEGAL(%d)\n",
 575                        lapb->dev, frame->pf);
 576 #endif
 577                 lapb->frmr_data = *frame;
 578                 lapb->frmr_type = LAPB_FRMR_W;
 579                 lapb_transmit_frmr(lapb);
 580 #if LAPB_DEBUG > 0
 581                 printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
 582 #endif
 583                 lapb_start_t1timer(lapb);
 584                 lapb_stop_t2timer(lapb);
 585                 lapb->state   = LAPB_STATE_4;
 586                 lapb->n2count = 0;
 587                 break;
 588         }
 589
 590         if (!queued)
 591                 kfree_skb(skb);
 592 }
 593
 594 /*
 595  *      State machine for state 4, Frame Reject State.
 596  *      The handling of the timer(s) is in file lapb_timer.c.
 597  */
 598 static void lapb_state4_machine(struct lapb_cb *lapb, struct sk_buff *skb,
 599                                 struct lapb_frame *frame)
 600 {
 601         switch (frame->type) {
 602         case LAPB_SABM:
 603 #if LAPB_DEBUG > 1
 604                 printk(KERN_DEBUG "lapb: (%p) S4 RX SABM(%d)\n",
 605                        lapb->dev, frame->pf);
 606 #endif
 607                 if (lapb->mode & LAPB_EXTENDED) {
 608 #if LAPB_DEBUG > 1
 609                         printk(KERN_DEBUG "lapb: (%p) S4 TX DM(%d)\n",
 610                                lapb->dev, frame->pf);
 611 #endif
 612                         lapb_send_control(lapb, LAPB_DM, frame->pf,
 613                                           LAPB_RESPONSE);
 614                 } else {
 615 #if LAPB_DEBUG > 1
 616                         printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n",
 617                                lapb->dev, frame->pf);
 618 #endif
 619 #if LAPB_DEBUG > 0
 620                         printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n", lapb->dev);
 621 #endif
 622                         lapb_send_control(lapb, LAPB_UA, frame->pf,
 623                                           LAPB_RESPONSE);
 624                         lapb_stop_t1timer(lapb);
 625                         lapb_stop_t2timer(lapb);
 626                         lapb->state     = LAPB_STATE_3;
 627                         lapb->condition = 0x00;
 628                         lapb->n2count   = 0;
 629                         lapb->vs        = 0;
 630                         lapb->vr        = 0;
 631                         lapb->va        = 0;
 632                         lapb_connect_indication(lapb, LAPB_OK);
 633                 }
 634                 break;
 635
 636         case LAPB_SABME:
 637 #if LAPB_DEBUG > 1
 638                 printk(KERN_DEBUG "lapb: (%p) S4 RX SABME(%d)\n",
 639                        lapb->dev, frame->pf);
 640 #endif
 641                 if (lapb->mode & LAPB_EXTENDED) {
 642 #if LAPB_DEBUG > 1
 643                         printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n",
 644                                lapb->dev, frame->pf);
 645 #endif
 646 #if LAPB_DEBUG > 0
 647                         printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n", lapb->dev);
 648 #endif
 649                         lapb_send_control(lapb, LAPB_UA, frame->pf,
 650                                           LAPB_RESPONSE);
 651                         lapb_stop_t1timer(lapb);
 652                         lapb_stop_t2timer(lapb);
 653                         lapb->state     = LAPB_STATE_3;
 654                         lapb->condition = 0x00;
 655                         lapb->n2count   = 0;
 656                         lapb->vs        = 0;
 657                         lapb->vr        = 0;
 658                         lapb->va        = 0;
 659                         lapb_connect_indication(lapb, LAPB_OK);
 660                 } else {
 661 #if LAPB_DEBUG > 1
 662                         printk(KERN_DEBUG "lapb: (%p) S4 TX DM(%d)\n",
 663                                lapb->dev, frame->pf);
 664 #endif
 665                         lapb_send_control(lapb, LAPB_DM, frame->pf,
 666                                           LAPB_RESPONSE);
 667                 }
 668                 break;
 669         }
 670
 671         kfree_skb(skb);
 672 }
 673
 674 /*
 675  *      Process an incoming LAPB frame
 676  */
 677 void lapb_data_input(struct lapb_cb *lapb, struct sk_buff *skb)
 678 {
 679         struct lapb_frame frame;
 680
 681         if (lapb_decode(lapb, skb, &frame) < 0) {
 682                 kfree_skb(skb);
 683                 return;
 684         }
 685
 686         switch (lapb->state) {
 687         case LAPB_STATE_0:
 688                 lapb_state0_machine(lapb, skb, &frame); break;
 689         case LAPB_STATE_1:
 690                 lapb_state1_machine(lapb, skb, &frame); break;
 691         case LAPB_STATE_2:
 692                 lapb_state2_machine(lapb, skb, &frame); break;
 693         case LAPB_STATE_3:
 694                 lapb_state3_machine(lapb, skb, &frame); break;
 695         case LAPB_STATE_4:
 696                 lapb_state4_machine(lapb, skb, &frame); break;
 697         }
 698
 699         lapb_kick(lapb);
 700 }