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