1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * LAPB release 002 4 * 5 * This code REQUIRES 2.1.15 or higher/ NET3.038 6 * 7 * History 8 * LAPB 001 Jonathan Naulor Started Coding 9 * LAPB 002 Jonathan Naylor New timer architecture. 10 * 2000-10-29 Henner Eisen lapb_data_indication() return status. 11 */ 12 13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 15 #include <linux/errno.h> 16 #include <linux/types.h> 17 #include <linux/socket.h> 18 #include <linux/in.h> 19 #include <linux/kernel.h> 20 #include <linux/timer.h> 21 #include <linux/string.h> 22 #include <linux/sockios.h> 23 #include <linux/net.h> 24 #include <linux/inet.h> 25 #include <linux/netdevice.h> 26 #include <linux/skbuff.h> 27 #include <linux/slab.h> 28 #include <net/sock.h> 29 #include <linux/uaccess.h> 30 #include <linux/fcntl.h> 31 #include <linux/mm.h> 32 #include <linux/interrupt.h> 33 #include <net/lapb.h> 34 35 /* 36 * State machine for state 0, Disconnected State. 37 * The handling of the timer(s) is in file lapb_timer.c. 38 */ 39 static void lapb_state0_machine(struct lapb_cb *lapb, struct sk_buff *skb, 40 struct lapb_frame *frame) 41 { 42 switch (frame->type) { 43 case LAPB_SABM: 44 lapb_dbg(1, "(%p) S0 RX SABM(%d)\n", lapb->dev, frame->pf); 45 if (lapb->mode & LAPB_EXTENDED) { 46 lapb_dbg(1, "(%p) S0 TX DM(%d)\n", 47 lapb->dev, frame->pf); 48 lapb_send_control(lapb, LAPB_DM, frame->pf, 49 LAPB_RESPONSE); 50 } else { 51 lapb_dbg(1, "(%p) S0 TX UA(%d)\n", 52 lapb->dev, frame->pf); 53 lapb_dbg(0, "(%p) S0 -> S3\n", lapb->dev); 54 lapb_send_control(lapb, LAPB_UA, frame->pf, 55 LAPB_RESPONSE); 56 lapb_stop_t1timer(lapb); 57 lapb_stop_t2timer(lapb); 58 lapb->state = LAPB_STATE_3; 59 lapb->condition = 0x00; 60 lapb->n2count = 0; 61 lapb->vs = 0; 62 lapb->vr = 0; 63 lapb->va = 0; 64 lapb_connect_indication(lapb, LAPB_OK); 65 } 66 break; 67 68 case LAPB_SABME: 69 lapb_dbg(1, "(%p) S0 RX SABME(%d)\n", lapb->dev, frame->pf); 70 if (lapb->mode & LAPB_EXTENDED) { 71 lapb_dbg(1, "(%p) S0 TX UA(%d)\n", 72 lapb->dev, frame->pf); 73 lapb_dbg(0, "(%p) S0 -> S3\n", lapb->dev); 74 lapb_send_control(lapb, LAPB_UA, frame->pf, 75 LAPB_RESPONSE); 76 lapb_stop_t1timer(lapb); 77 lapb_stop_t2timer(lapb); 78 lapb->state = LAPB_STATE_3; 79 lapb->condition = 0x00; 80 lapb->n2count = 0; 81 lapb->vs = 0; 82 lapb->vr = 0; 83 lapb->va = 0; 84 lapb_connect_indication(lapb, LAPB_OK); 85 } else { 86 lapb_dbg(1, "(%p) S0 TX DM(%d)\n", 87 lapb->dev, frame->pf); 88 lapb_send_control(lapb, LAPB_DM, frame->pf, 89 LAPB_RESPONSE); 90 } 91 break; 92 93 case LAPB_DISC: 94 lapb_dbg(1, "(%p) S0 RX DISC(%d)\n", lapb->dev, frame->pf); 95 lapb_dbg(1, "(%p) S0 TX UA(%d)\n", lapb->dev, frame->pf); 96 lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE); 97 break; 98 99 default: 100 break; 101 } 102 103 kfree_skb(skb); 104 } 105 106 /* 107 * State machine for state 1, Awaiting Connection State. 108 * The handling of the timer(s) is in file lapb_timer.c. 109 */ 110 static void lapb_state1_machine(struct lapb_cb *lapb, struct sk_buff *skb, 111 struct lapb_frame *frame) 112 { 113 switch (frame->type) { 114 case LAPB_SABM: 115 lapb_dbg(1, "(%p) S1 RX SABM(%d)\n", lapb->dev, frame->pf); 116 if (lapb->mode & LAPB_EXTENDED) { 117 lapb_dbg(1, "(%p) S1 TX DM(%d)\n", 118 lapb->dev, frame->pf); 119 lapb_send_control(lapb, LAPB_DM, frame->pf, 120 LAPB_RESPONSE); 121 } else { 122 lapb_dbg(1, "(%p) S1 TX UA(%d)\n", 123 lapb->dev, frame->pf); 124 lapb_send_control(lapb, LAPB_UA, frame->pf, 125 LAPB_RESPONSE); 126 } 127 break; 128 129 case LAPB_SABME: 130 lapb_dbg(1, "(%p) S1 RX SABME(%d)\n", lapb->dev, frame->pf); 131 if (lapb->mode & LAPB_EXTENDED) { 132 lapb_dbg(1, "(%p) S1 TX UA(%d)\n", 133 lapb->dev, frame->pf); 134 lapb_send_control(lapb, LAPB_UA, frame->pf, 135 LAPB_RESPONSE); 136 } else { 137 lapb_dbg(1, "(%p) S1 TX DM(%d)\n", 138 lapb->dev, frame->pf); 139 lapb_send_control(lapb, LAPB_DM, frame->pf, 140 LAPB_RESPONSE); 141 } 142 break; 143 144 case LAPB_DISC: 145 lapb_dbg(1, "(%p) S1 RX DISC(%d)\n", lapb->dev, frame->pf); 146 lapb_dbg(1, "(%p) S1 TX DM(%d)\n", lapb->dev, frame->pf); 147 lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE); 148 break; 149 150 case LAPB_UA: 151 lapb_dbg(1, "(%p) S1 RX UA(%d)\n", lapb->dev, frame->pf); 152 if (frame->pf) { 153 lapb_dbg(0, "(%p) S1 -> S3\n", lapb->dev); 154 lapb_stop_t1timer(lapb); 155 lapb_stop_t2timer(lapb); 156 lapb->state = LAPB_STATE_3; 157 lapb->condition = 0x00; 158 lapb->n2count = 0; 159 lapb->vs = 0; 160 lapb->vr = 0; 161 lapb->va = 0; 162 lapb_connect_confirmation(lapb, LAPB_OK); 163 } 164 break; 165 166 case LAPB_DM: 167 lapb_dbg(1, "(%p) S1 RX DM(%d)\n", lapb->dev, frame->pf); 168 if (frame->pf) { 169 lapb_dbg(0, "(%p) S1 -> S0\n", lapb->dev); 170 lapb_clear_queues(lapb); 171 lapb->state = LAPB_STATE_0; 172 lapb_start_t1timer(lapb); 173 lapb_stop_t2timer(lapb); 174 lapb_disconnect_indication(lapb, LAPB_REFUSED); 175 } 176 break; 177 } 178 179 kfree_skb(skb); 180 } 181 182 /* 183 * State machine for state 2, Awaiting Release State. 184 * The handling of the timer(s) is in file lapb_timer.c 185 */ 186 static void lapb_state2_machine(struct lapb_cb *lapb, struct sk_buff *skb, 187 struct lapb_frame *frame) 188 { 189 switch (frame->type) { 190 case LAPB_SABM: 191 case LAPB_SABME: 192 lapb_dbg(1, "(%p) S2 RX {SABM,SABME}(%d)\n", 193 lapb->dev, frame->pf); 194 lapb_dbg(1, "(%p) S2 TX DM(%d)\n", lapb->dev, frame->pf); 195 lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE); 196 break; 197 198 case LAPB_DISC: 199 lapb_dbg(1, "(%p) S2 RX DISC(%d)\n", lapb->dev, frame->pf); 200 lapb_dbg(1, "(%p) S2 TX UA(%d)\n", lapb->dev, frame->pf); 201 lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE); 202 break; 203 204 case LAPB_UA: 205 lapb_dbg(1, "(%p) S2 RX UA(%d)\n", lapb->dev, frame->pf); 206 if (frame->pf) { 207 lapb_dbg(0, "(%p) S2 -> S0\n", lapb->dev); 208 lapb->state = LAPB_STATE_0; 209 lapb_start_t1timer(lapb); 210 lapb_stop_t2timer(lapb); 211 lapb_disconnect_confirmation(lapb, LAPB_OK); 212 } 213 break; 214 215 case LAPB_DM: 216 lapb_dbg(1, "(%p) S2 RX DM(%d)\n", lapb->dev, frame->pf); 217 if (frame->pf) { 218 lapb_dbg(0, "(%p) S2 -> S0\n", lapb->dev); 219 lapb->state = LAPB_STATE_0; 220 lapb_start_t1timer(lapb); 221 lapb_stop_t2timer(lapb); 222 lapb_disconnect_confirmation(lapb, LAPB_NOTCONNECTED); 223 } 224 break; 225 226 case LAPB_I: 227 case LAPB_REJ: 228 case LAPB_RNR: 229 case LAPB_RR: 230 lapb_dbg(1, "(%p) S2 RX {I,REJ,RNR,RR}(%d)\n", 231 lapb->dev, frame->pf); 232 lapb_dbg(1, "(%p) S2 RX DM(%d)\n", lapb->dev, frame->pf); 233 if (frame->pf) 234 lapb_send_control(lapb, LAPB_DM, frame->pf, 235 LAPB_RESPONSE); 236 break; 237 } 238 239 kfree_skb(skb); 240 } 241 242 /* 243 * State machine for state 3, Connected State. 244 * The handling of the timer(s) is in file lapb_timer.c 245 */ 246 static void lapb_state3_machine(struct lapb_cb *lapb, struct sk_buff *skb, 247 struct lapb_frame *frame) 248 { 249 int queued = 0; 250 int modulus = (lapb->mode & LAPB_EXTENDED) ? LAPB_EMODULUS : 251 LAPB_SMODULUS; 252 253 switch (frame->type) { 254 case LAPB_SABM: 255 lapb_dbg(1, "(%p) S3 RX SABM(%d)\n", lapb->dev, frame->pf); 256 if (lapb->mode & LAPB_EXTENDED) { 257 lapb_dbg(1, "(%p) S3 TX DM(%d)\n", 258 lapb->dev, frame->pf); 259 lapb_send_control(lapb, LAPB_DM, frame->pf, 260 LAPB_RESPONSE); 261 } else { 262 lapb_dbg(1, "(%p) S3 TX UA(%d)\n", 263 lapb->dev, frame->pf); 264 lapb_send_control(lapb, LAPB_UA, frame->pf, 265 LAPB_RESPONSE); 266 lapb_stop_t1timer(lapb); 267 lapb_stop_t2timer(lapb); 268 lapb->condition = 0x00; 269 lapb->n2count = 0; 270 lapb->vs = 0; 271 lapb->vr = 0; 272 lapb->va = 0; 273 lapb_requeue_frames(lapb); 274 } 275 break; 276 277 case LAPB_SABME: 278 lapb_dbg(1, "(%p) S3 RX SABME(%d)\n", lapb->dev, frame->pf); 279 if (lapb->mode & LAPB_EXTENDED) { 280 lapb_dbg(1, "(%p) S3 TX UA(%d)\n", 281 lapb->dev, frame->pf); 282 lapb_send_control(lapb, LAPB_UA, frame->pf, 283 LAPB_RESPONSE); 284 lapb_stop_t1timer(lapb); 285 lapb_stop_t2timer(lapb); 286 lapb->condition = 0x00; 287 lapb->n2count = 0; 288 lapb->vs = 0; 289 lapb->vr = 0; 290 lapb->va = 0; 291 lapb_requeue_frames(lapb); 292 } else { 293 lapb_dbg(1, "(%p) S3 TX DM(%d)\n", 294 lapb->dev, frame->pf); 295 lapb_send_control(lapb, LAPB_DM, frame->pf, 296 LAPB_RESPONSE); 297 } 298 break; 299 300 case LAPB_DISC: 301 lapb_dbg(1, "(%p) S3 RX DISC(%d)\n", lapb->dev, frame->pf); 302 lapb_dbg(0, "(%p) S3 -> S0\n", lapb->dev); 303 lapb_clear_queues(lapb); 304 lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE); 305 lapb_start_t1timer(lapb); 306 lapb_stop_t2timer(lapb); 307 lapb->state = LAPB_STATE_0; 308 lapb_disconnect_indication(lapb, LAPB_OK); 309 break; 310 311 case LAPB_DM: 312 lapb_dbg(1, "(%p) S3 RX DM(%d)\n", lapb->dev, frame->pf); 313 lapb_dbg(0, "(%p) S3 -> S0\n", lapb->dev); 314 lapb_clear_queues(lapb); 315 lapb->state = LAPB_STATE_0; 316 lapb_start_t1timer(lapb); 317 lapb_stop_t2timer(lapb); 318 lapb_disconnect_indication(lapb, LAPB_NOTCONNECTED); 319 break; 320 321 case LAPB_RNR: 322 lapb_dbg(1, "(%p) S3 RX RNR(%d) R%d\n", 323 lapb->dev, frame->pf, frame->nr); 324 lapb->condition |= LAPB_PEER_RX_BUSY_CONDITION; 325 lapb_check_need_response(lapb, frame->cr, frame->pf); 326 if (lapb_validate_nr(lapb, frame->nr)) { 327 lapb_check_iframes_acked(lapb, frame->nr); 328 } else { 329 lapb->frmr_data = *frame; 330 lapb->frmr_type = LAPB_FRMR_Z; 331 lapb_transmit_frmr(lapb); 332 lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev); 333 lapb_start_t1timer(lapb); 334 lapb_stop_t2timer(lapb); 335 lapb->state = LAPB_STATE_4; 336 lapb->n2count = 0; 337 } 338 break; 339 340 case LAPB_RR: 341 lapb_dbg(1, "(%p) S3 RX RR(%d) R%d\n", 342 lapb->dev, frame->pf, frame->nr); 343 lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION; 344 lapb_check_need_response(lapb, frame->cr, frame->pf); 345 if (lapb_validate_nr(lapb, frame->nr)) { 346 lapb_check_iframes_acked(lapb, frame->nr); 347 } else { 348 lapb->frmr_data = *frame; 349 lapb->frmr_type = LAPB_FRMR_Z; 350 lapb_transmit_frmr(lapb); 351 lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev); 352 lapb_start_t1timer(lapb); 353 lapb_stop_t2timer(lapb); 354 lapb->state = LAPB_STATE_4; 355 lapb->n2count = 0; 356 } 357 break; 358 359 case LAPB_REJ: 360 lapb_dbg(1, "(%p) S3 RX REJ(%d) R%d\n", 361 lapb->dev, frame->pf, frame->nr); 362 lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION; 363 lapb_check_need_response(lapb, frame->cr, frame->pf); 364 if (lapb_validate_nr(lapb, frame->nr)) { 365 lapb_frames_acked(lapb, frame->nr); 366 lapb_stop_t1timer(lapb); 367 lapb->n2count = 0; 368 lapb_requeue_frames(lapb); 369 } else { 370 lapb->frmr_data = *frame; 371 lapb->frmr_type = LAPB_FRMR_Z; 372 lapb_transmit_frmr(lapb); 373 lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev); 374 lapb_start_t1timer(lapb); 375 lapb_stop_t2timer(lapb); 376 lapb->state = LAPB_STATE_4; 377 lapb->n2count = 0; 378 } 379 break; 380 381 case LAPB_I: 382 lapb_dbg(1, "(%p) S3 RX I(%d) S%d R%d\n", 383 lapb->dev, frame->pf, frame->ns, frame->nr); 384 if (!lapb_validate_nr(lapb, frame->nr)) { 385 lapb->frmr_data = *frame; 386 lapb->frmr_type = LAPB_FRMR_Z; 387 lapb_transmit_frmr(lapb); 388 lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev); 389 lapb_start_t1timer(lapb); 390 lapb_stop_t2timer(lapb); 391 lapb->state = LAPB_STATE_4; 392 lapb->n2count = 0; 393 break; 394 } 395 if (lapb->condition & LAPB_PEER_RX_BUSY_CONDITION) 396 lapb_frames_acked(lapb, frame->nr); 397 else 398 lapb_check_iframes_acked(lapb, frame->nr); 399 400 if (frame->ns == lapb->vr) { 401 int cn; 402 cn = lapb_data_indication(lapb, skb); 403 queued = 1; 404 /* 405 * If upper layer has dropped the frame, we 406 * basically ignore any further protocol 407 * processing. This will cause the peer 408 * to re-transmit the frame later like 409 * a frame lost on the wire. 410 */ 411 if (cn == NET_RX_DROP) { 412 pr_debug("rx congestion\n"); 413 break; 414 } 415 lapb->vr = (lapb->vr + 1) % modulus; 416 lapb->condition &= ~LAPB_REJECT_CONDITION; 417 if (frame->pf) 418 lapb_enquiry_response(lapb); 419 else { 420 if (!(lapb->condition & 421 LAPB_ACK_PENDING_CONDITION)) { 422 lapb->condition |= LAPB_ACK_PENDING_CONDITION; 423 lapb_start_t2timer(lapb); 424 } 425 } 426 } else { 427 if (lapb->condition & LAPB_REJECT_CONDITION) { 428 if (frame->pf) 429 lapb_enquiry_response(lapb); 430 } else { 431 lapb_dbg(1, "(%p) S3 TX REJ(%d) R%d\n", 432 lapb->dev, frame->pf, lapb->vr); 433 lapb->condition |= LAPB_REJECT_CONDITION; 434 lapb_send_control(lapb, LAPB_REJ, frame->pf, 435 LAPB_RESPONSE); 436 lapb->condition &= ~LAPB_ACK_PENDING_CONDITION; 437 } 438 } 439 break; 440 441 case LAPB_FRMR: 442 lapb_dbg(1, "(%p) S3 RX FRMR(%d) %5ph\n", 443 lapb->dev, frame->pf, 444 skb->data); 445 lapb_establish_data_link(lapb); 446 lapb_dbg(0, "(%p) S3 -> S1\n", lapb->dev); 447 lapb_requeue_frames(lapb); 448 lapb->state = LAPB_STATE_1; 449 break; 450 451 case LAPB_ILLEGAL: 452 lapb_dbg(1, "(%p) S3 RX ILLEGAL(%d)\n", lapb->dev, frame->pf); 453 lapb->frmr_data = *frame; 454 lapb->frmr_type = LAPB_FRMR_W; 455 lapb_transmit_frmr(lapb); 456 lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev); 457 lapb_start_t1timer(lapb); 458 lapb_stop_t2timer(lapb); 459 lapb->state = LAPB_STATE_4; 460 lapb->n2count = 0; 461 break; 462 } 463 464 if (!queued) 465 kfree_skb(skb); 466 } 467 468 /* 469 * State machine for state 4, Frame Reject State. 470 * The handling of the timer(s) is in file lapb_timer.c. 471 */ 472 static void lapb_state4_machine(struct lapb_cb *lapb, struct sk_buff *skb, 473 struct lapb_frame *frame) 474 { 475 switch (frame->type) { 476 case LAPB_SABM: 477 lapb_dbg(1, "(%p) S4 RX SABM(%d)\n", lapb->dev, frame->pf); 478 if (lapb->mode & LAPB_EXTENDED) { 479 lapb_dbg(1, "(%p) S4 TX DM(%d)\n", 480 lapb->dev, frame->pf); 481 lapb_send_control(lapb, LAPB_DM, frame->pf, 482 LAPB_RESPONSE); 483 } else { 484 lapb_dbg(1, "(%p) S4 TX UA(%d)\n", 485 lapb->dev, frame->pf); 486 lapb_dbg(0, "(%p) S4 -> S3\n", lapb->dev); 487 lapb_send_control(lapb, LAPB_UA, frame->pf, 488 LAPB_RESPONSE); 489 lapb_stop_t1timer(lapb); 490 lapb_stop_t2timer(lapb); 491 lapb->state = LAPB_STATE_3; 492 lapb->condition = 0x00; 493 lapb->n2count = 0; 494 lapb->vs = 0; 495 lapb->vr = 0; 496 lapb->va = 0; 497 lapb_connect_indication(lapb, LAPB_OK); 498 } 499 break; 500 501 case LAPB_SABME: 502 lapb_dbg(1, "(%p) S4 RX SABME(%d)\n", lapb->dev, frame->pf); 503 if (lapb->mode & LAPB_EXTENDED) { 504 lapb_dbg(1, "(%p) S4 TX UA(%d)\n", 505 lapb->dev, frame->pf); 506 lapb_dbg(0, "(%p) S4 -> S3\n", lapb->dev); 507 lapb_send_control(lapb, LAPB_UA, frame->pf, 508 LAPB_RESPONSE); 509 lapb_stop_t1timer(lapb); 510 lapb_stop_t2timer(lapb); 511 lapb->state = LAPB_STATE_3; 512 lapb->condition = 0x00; 513 lapb->n2count = 0; 514 lapb->vs = 0; 515 lapb->vr = 0; 516 lapb->va = 0; 517 lapb_connect_indication(lapb, LAPB_OK); 518 } else { 519 lapb_dbg(1, "(%p) S4 TX DM(%d)\n", 520 lapb->dev, frame->pf); 521 lapb_send_control(lapb, LAPB_DM, frame->pf, 522 LAPB_RESPONSE); 523 } 524 break; 525 } 526 527 kfree_skb(skb); 528 } 529 530 /* 531 * Process an incoming LAPB frame 532 */ 533 void lapb_data_input(struct lapb_cb *lapb, struct sk_buff *skb) 534 { 535 struct lapb_frame frame; 536 537 if (lapb_decode(lapb, skb, &frame) < 0) { 538 kfree_skb(skb); 539 return; 540 } 541 542 switch (lapb->state) { 543 case LAPB_STATE_0: 544 lapb_state0_machine(lapb, skb, &frame); break; 545 case LAPB_STATE_1: 546 lapb_state1_machine(lapb, skb, &frame); break; 547 case LAPB_STATE_2: 548 lapb_state2_machine(lapb, skb, &frame); break; 549 case LAPB_STATE_3: 550 lapb_state3_machine(lapb, skb, &frame); break; 551 case LAPB_STATE_4: 552 lapb_state4_machine(lapb, skb, &frame); break; 553 } 554 555 lapb_kick(lapb); 556 } 557