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 */ 42static 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 */ 138static 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 */ 245static 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 */ 330static 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 */ 619static 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 */ 700void 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