1 /* 2 * llc_c_ac.c - actions performed during connection state transition. 3 * 4 * Description: 5 * Functions in this module are implementation of connection component actions 6 * Details of actions can be found in IEEE-802.2 standard document. 7 * All functions have one connection and one event as input argument. All of 8 * them return 0 On success and 1 otherwise. 9 * 10 * Copyright (c) 1997 by Procom Technology, Inc. 11 * 2001-2003 by Arnaldo Carvalho de Melo <acme@conectiva.com.br> 12 * 13 * This program can be redistributed or modified under the terms of the 14 * GNU General Public License as published by the Free Software Foundation. 15 * This program is distributed without any warranty or implied warranty 16 * of merchantability or fitness for a particular purpose. 17 * 18 * See the GNU General Public License for more details. 19 */ 20 #include <linux/netdevice.h> 21 #include <net/llc_conn.h> 22 #include <net/llc_sap.h> 23 #include <net/sock.h> 24 #include <net/llc_c_ev.h> 25 #include <net/llc_c_ac.h> 26 #include <net/llc_c_st.h> 27 #include <net/llc_pdu.h> 28 #include <net/llc.h> 29 30 31 static int llc_conn_ac_inc_vs_by_1(struct sock *sk, struct sk_buff *skb); 32 static void llc_process_tmr_ev(struct sock *sk, struct sk_buff *skb); 33 static int llc_conn_ac_data_confirm(struct sock *sk, struct sk_buff *ev); 34 35 static int llc_conn_ac_inc_npta_value(struct sock *sk, struct sk_buff *skb); 36 37 static int llc_conn_ac_send_rr_rsp_f_set_ackpf(struct sock *sk, 38 struct sk_buff *skb); 39 40 static int llc_conn_ac_set_p_flag_1(struct sock *sk, struct sk_buff *skb); 41 42 #define INCORRECT 0 43 44 int llc_conn_ac_clear_remote_busy(struct sock *sk, struct sk_buff *skb) 45 { 46 struct llc_sock *llc = llc_sk(sk); 47 48 if (llc->remote_busy_flag) { 49 u8 nr; 50 struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb); 51 52 llc->remote_busy_flag = 0; 53 del_timer(&llc->busy_state_timer.timer); 54 nr = LLC_I_GET_NR(pdu); 55 llc_conn_resend_i_pdu_as_cmd(sk, nr, 0); 56 } 57 return 0; 58 } 59 60 int llc_conn_ac_conn_ind(struct sock *sk, struct sk_buff *skb) 61 { 62 struct llc_conn_state_ev *ev = llc_conn_ev(skb); 63 64 ev->ind_prim = LLC_CONN_PRIM; 65 return 0; 66 } 67 68 int llc_conn_ac_conn_confirm(struct sock *sk, struct sk_buff *skb) 69 { 70 struct llc_conn_state_ev *ev = llc_conn_ev(skb); 71 72 ev->cfm_prim = LLC_CONN_PRIM; 73 return 0; 74 } 75 76 static int llc_conn_ac_data_confirm(struct sock *sk, struct sk_buff *skb) 77 { 78 struct llc_conn_state_ev *ev = llc_conn_ev(skb); 79 80 ev->cfm_prim = LLC_DATA_PRIM; 81 return 0; 82 } 83 84 int llc_conn_ac_data_ind(struct sock *sk, struct sk_buff *skb) 85 { 86 llc_conn_rtn_pdu(sk, skb); 87 return 0; 88 } 89 90 int llc_conn_ac_disc_ind(struct sock *sk, struct sk_buff *skb) 91 { 92 struct llc_conn_state_ev *ev = llc_conn_ev(skb); 93 u8 reason = 0; 94 int rc = 0; 95 96 if (ev->type == LLC_CONN_EV_TYPE_PDU) { 97 struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb); 98 99 if (LLC_PDU_IS_RSP(pdu) && 100 LLC_PDU_TYPE_IS_U(pdu) && 101 LLC_U_PDU_RSP(pdu) == LLC_2_PDU_RSP_DM) 102 reason = LLC_DISC_REASON_RX_DM_RSP_PDU; 103 else if (LLC_PDU_IS_CMD(pdu) && 104 LLC_PDU_TYPE_IS_U(pdu) && 105 LLC_U_PDU_CMD(pdu) == LLC_2_PDU_CMD_DISC) 106 reason = LLC_DISC_REASON_RX_DISC_CMD_PDU; 107 } else if (ev->type == LLC_CONN_EV_TYPE_ACK_TMR) 108 reason = LLC_DISC_REASON_ACK_TMR_EXP; 109 else 110 rc = -EINVAL; 111 if (!rc) { 112 ev->reason = reason; 113 ev->ind_prim = LLC_DISC_PRIM; 114 } 115 return rc; 116 } 117 118 int llc_conn_ac_disc_confirm(struct sock *sk, struct sk_buff *skb) 119 { 120 struct llc_conn_state_ev *ev = llc_conn_ev(skb); 121 122 ev->reason = ev->status; 123 ev->cfm_prim = LLC_DISC_PRIM; 124 return 0; 125 } 126 127 int llc_conn_ac_rst_ind(struct sock *sk, struct sk_buff *skb) 128 { 129 u8 reason = 0; 130 int rc = 1; 131 struct llc_conn_state_ev *ev = llc_conn_ev(skb); 132 struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb); 133 struct llc_sock *llc = llc_sk(sk); 134 135 switch (ev->type) { 136 case LLC_CONN_EV_TYPE_PDU: 137 if (LLC_PDU_IS_RSP(pdu) && 138 LLC_PDU_TYPE_IS_U(pdu) && 139 LLC_U_PDU_RSP(pdu) == LLC_2_PDU_RSP_FRMR) { 140 reason = LLC_RESET_REASON_LOCAL; 141 rc = 0; 142 } else if (LLC_PDU_IS_CMD(pdu) && 143 LLC_PDU_TYPE_IS_U(pdu) && 144 LLC_U_PDU_CMD(pdu) == LLC_2_PDU_CMD_SABME) { 145 reason = LLC_RESET_REASON_REMOTE; 146 rc = 0; 147 } 148 break; 149 case LLC_CONN_EV_TYPE_ACK_TMR: 150 case LLC_CONN_EV_TYPE_P_TMR: 151 case LLC_CONN_EV_TYPE_REJ_TMR: 152 case LLC_CONN_EV_TYPE_BUSY_TMR: 153 if (llc->retry_count > llc->n2) { 154 reason = LLC_RESET_REASON_LOCAL; 155 rc = 0; 156 } 157 break; 158 } 159 if (!rc) { 160 ev->reason = reason; 161 ev->ind_prim = LLC_RESET_PRIM; 162 } 163 return rc; 164 } 165 166 int llc_conn_ac_rst_confirm(struct sock *sk, struct sk_buff *skb) 167 { 168 struct llc_conn_state_ev *ev = llc_conn_ev(skb); 169 170 ev->reason = 0; 171 ev->cfm_prim = LLC_RESET_PRIM; 172 return 0; 173 } 174 175 int llc_conn_ac_clear_remote_busy_if_f_eq_1(struct sock *sk, 176 struct sk_buff *skb) 177 { 178 struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb); 179 180 if (LLC_PDU_IS_RSP(pdu) && 181 LLC_PDU_TYPE_IS_I(pdu) && 182 LLC_I_PF_IS_1(pdu) && llc_sk(sk)->ack_pf) 183 llc_conn_ac_clear_remote_busy(sk, skb); 184 return 0; 185 } 186 187 int llc_conn_ac_stop_rej_tmr_if_data_flag_eq_2(struct sock *sk, 188 struct sk_buff *skb) 189 { 190 struct llc_sock *llc = llc_sk(sk); 191 192 if (llc->data_flag == 2) 193 del_timer(&llc->rej_sent_timer.timer); 194 return 0; 195 } 196 197 int llc_conn_ac_send_disc_cmd_p_set_x(struct sock *sk, struct sk_buff *skb) 198 { 199 int rc = -ENOBUFS; 200 struct llc_sock *llc = llc_sk(sk); 201 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U, 0); 202 203 if (nskb) { 204 struct llc_sap *sap = llc->sap; 205 206 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap, 207 llc->daddr.lsap, LLC_PDU_CMD); 208 llc_pdu_init_as_disc_cmd(nskb, 1); 209 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 210 if (unlikely(rc)) 211 goto free; 212 llc_conn_send_pdu(sk, nskb); 213 llc_conn_ac_set_p_flag_1(sk, skb); 214 } 215 out: 216 return rc; 217 free: 218 kfree_skb(nskb); 219 goto out; 220 } 221 222 int llc_conn_ac_send_dm_rsp_f_set_p(struct sock *sk, struct sk_buff *skb) 223 { 224 int rc = -ENOBUFS; 225 struct llc_sock *llc = llc_sk(sk); 226 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U, 0); 227 228 if (nskb) { 229 struct llc_sap *sap = llc->sap; 230 u8 f_bit; 231 232 llc_pdu_decode_pf_bit(skb, &f_bit); 233 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap, 234 llc->daddr.lsap, LLC_PDU_RSP); 235 llc_pdu_init_as_dm_rsp(nskb, f_bit); 236 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 237 if (unlikely(rc)) 238 goto free; 239 llc_conn_send_pdu(sk, nskb); 240 } 241 out: 242 return rc; 243 free: 244 kfree_skb(nskb); 245 goto out; 246 } 247 248 int llc_conn_ac_send_dm_rsp_f_set_1(struct sock *sk, struct sk_buff *skb) 249 { 250 int rc = -ENOBUFS; 251 struct llc_sock *llc = llc_sk(sk); 252 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U, 0); 253 254 if (nskb) { 255 struct llc_sap *sap = llc->sap; 256 257 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap, 258 llc->daddr.lsap, LLC_PDU_RSP); 259 llc_pdu_init_as_dm_rsp(nskb, 1); 260 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 261 if (unlikely(rc)) 262 goto free; 263 llc_conn_send_pdu(sk, nskb); 264 } 265 out: 266 return rc; 267 free: 268 kfree_skb(nskb); 269 goto out; 270 } 271 272 int llc_conn_ac_send_frmr_rsp_f_set_x(struct sock *sk, struct sk_buff *skb) 273 { 274 u8 f_bit; 275 int rc = -ENOBUFS; 276 struct sk_buff *nskb; 277 struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb); 278 struct llc_sock *llc = llc_sk(sk); 279 280 llc->rx_pdu_hdr = *((u32 *)pdu); 281 if (LLC_PDU_IS_CMD(pdu)) 282 llc_pdu_decode_pf_bit(skb, &f_bit); 283 else 284 f_bit = 0; 285 nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U, 286 sizeof(struct llc_frmr_info)); 287 if (nskb) { 288 struct llc_sap *sap = llc->sap; 289 290 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap, 291 llc->daddr.lsap, LLC_PDU_RSP); 292 llc_pdu_init_as_frmr_rsp(nskb, pdu, f_bit, llc->vS, 293 llc->vR, INCORRECT); 294 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 295 if (unlikely(rc)) 296 goto free; 297 llc_conn_send_pdu(sk, nskb); 298 } 299 out: 300 return rc; 301 free: 302 kfree_skb(nskb); 303 goto out; 304 } 305 306 int llc_conn_ac_resend_frmr_rsp_f_set_0(struct sock *sk, struct sk_buff *skb) 307 { 308 int rc = -ENOBUFS; 309 struct llc_sock *llc = llc_sk(sk); 310 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U, 311 sizeof(struct llc_frmr_info)); 312 313 if (nskb) { 314 struct llc_sap *sap = llc->sap; 315 struct llc_pdu_sn *pdu = (struct llc_pdu_sn *)&llc->rx_pdu_hdr; 316 317 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap, 318 llc->daddr.lsap, LLC_PDU_RSP); 319 llc_pdu_init_as_frmr_rsp(nskb, pdu, 0, llc->vS, 320 llc->vR, INCORRECT); 321 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 322 if (unlikely(rc)) 323 goto free; 324 llc_conn_send_pdu(sk, nskb); 325 } 326 out: 327 return rc; 328 free: 329 kfree_skb(nskb); 330 goto out; 331 } 332 333 int llc_conn_ac_resend_frmr_rsp_f_set_p(struct sock *sk, struct sk_buff *skb) 334 { 335 u8 f_bit; 336 int rc = -ENOBUFS; 337 struct sk_buff *nskb; 338 struct llc_sock *llc = llc_sk(sk); 339 340 llc_pdu_decode_pf_bit(skb, &f_bit); 341 nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U, 342 sizeof(struct llc_frmr_info)); 343 if (nskb) { 344 struct llc_sap *sap = llc->sap; 345 struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb); 346 347 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap, 348 llc->daddr.lsap, LLC_PDU_RSP); 349 llc_pdu_init_as_frmr_rsp(nskb, pdu, f_bit, llc->vS, 350 llc->vR, INCORRECT); 351 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 352 if (unlikely(rc)) 353 goto free; 354 llc_conn_send_pdu(sk, nskb); 355 } 356 out: 357 return rc; 358 free: 359 kfree_skb(nskb); 360 goto out; 361 } 362 363 int llc_conn_ac_send_i_cmd_p_set_1(struct sock *sk, struct sk_buff *skb) 364 { 365 int rc; 366 struct llc_sock *llc = llc_sk(sk); 367 struct llc_sap *sap = llc->sap; 368 369 llc_pdu_header_init(skb, LLC_PDU_TYPE_I, sap->laddr.lsap, 370 llc->daddr.lsap, LLC_PDU_CMD); 371 llc_pdu_init_as_i_cmd(skb, 1, llc->vS, llc->vR); 372 rc = llc_mac_hdr_init(skb, llc->dev->dev_addr, llc->daddr.mac); 373 if (likely(!rc)) { 374 llc_conn_send_pdu(sk, skb); 375 llc_conn_ac_inc_vs_by_1(sk, skb); 376 } 377 return rc; 378 } 379 380 static int llc_conn_ac_send_i_cmd_p_set_0(struct sock *sk, struct sk_buff *skb) 381 { 382 int rc; 383 struct llc_sock *llc = llc_sk(sk); 384 struct llc_sap *sap = llc->sap; 385 386 llc_pdu_header_init(skb, LLC_PDU_TYPE_I, sap->laddr.lsap, 387 llc->daddr.lsap, LLC_PDU_CMD); 388 llc_pdu_init_as_i_cmd(skb, 0, llc->vS, llc->vR); 389 rc = llc_mac_hdr_init(skb, llc->dev->dev_addr, llc->daddr.mac); 390 if (likely(!rc)) { 391 llc_conn_send_pdu(sk, skb); 392 llc_conn_ac_inc_vs_by_1(sk, skb); 393 } 394 return rc; 395 } 396 397 int llc_conn_ac_send_i_xxx_x_set_0(struct sock *sk, struct sk_buff *skb) 398 { 399 int rc; 400 struct llc_sock *llc = llc_sk(sk); 401 struct llc_sap *sap = llc->sap; 402 403 llc_pdu_header_init(skb, LLC_PDU_TYPE_I, sap->laddr.lsap, 404 llc->daddr.lsap, LLC_PDU_CMD); 405 llc_pdu_init_as_i_cmd(skb, 0, llc->vS, llc->vR); 406 rc = llc_mac_hdr_init(skb, llc->dev->dev_addr, llc->daddr.mac); 407 if (likely(!rc)) { 408 llc_conn_send_pdu(sk, skb); 409 llc_conn_ac_inc_vs_by_1(sk, skb); 410 } 411 return 0; 412 } 413 414 int llc_conn_ac_resend_i_xxx_x_set_0(struct sock *sk, struct sk_buff *skb) 415 { 416 struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb); 417 u8 nr = LLC_I_GET_NR(pdu); 418 419 llc_conn_resend_i_pdu_as_cmd(sk, nr, 0); 420 return 0; 421 } 422 423 int llc_conn_ac_resend_i_xxx_x_set_0_or_send_rr(struct sock *sk, 424 struct sk_buff *skb) 425 { 426 u8 nr; 427 struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb); 428 int rc = -ENOBUFS; 429 struct llc_sock *llc = llc_sk(sk); 430 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U, 0); 431 432 if (nskb) { 433 struct llc_sap *sap = llc->sap; 434 435 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap, 436 llc->daddr.lsap, LLC_PDU_RSP); 437 llc_pdu_init_as_rr_rsp(nskb, 0, llc->vR); 438 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 439 if (likely(!rc)) 440 llc_conn_send_pdu(sk, nskb); 441 else 442 kfree_skb(skb); 443 } 444 if (rc) { 445 nr = LLC_I_GET_NR(pdu); 446 rc = 0; 447 llc_conn_resend_i_pdu_as_cmd(sk, nr, 0); 448 } 449 return rc; 450 } 451 452 int llc_conn_ac_resend_i_rsp_f_set_1(struct sock *sk, struct sk_buff *skb) 453 { 454 struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb); 455 u8 nr = LLC_I_GET_NR(pdu); 456 457 llc_conn_resend_i_pdu_as_rsp(sk, nr, 1); 458 return 0; 459 } 460 461 int llc_conn_ac_send_rej_cmd_p_set_1(struct sock *sk, struct sk_buff *skb) 462 { 463 int rc = -ENOBUFS; 464 struct llc_sock *llc = llc_sk(sk); 465 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0); 466 467 if (nskb) { 468 struct llc_sap *sap = llc->sap; 469 470 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap, 471 llc->daddr.lsap, LLC_PDU_CMD); 472 llc_pdu_init_as_rej_cmd(nskb, 1, llc->vR); 473 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 474 if (unlikely(rc)) 475 goto free; 476 llc_conn_send_pdu(sk, nskb); 477 } 478 out: 479 return rc; 480 free: 481 kfree_skb(nskb); 482 goto out; 483 } 484 485 int llc_conn_ac_send_rej_rsp_f_set_1(struct sock *sk, struct sk_buff *skb) 486 { 487 int rc = -ENOBUFS; 488 struct llc_sock *llc = llc_sk(sk); 489 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0); 490 491 if (nskb) { 492 struct llc_sap *sap = llc->sap; 493 494 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap, 495 llc->daddr.lsap, LLC_PDU_RSP); 496 llc_pdu_init_as_rej_rsp(nskb, 1, llc->vR); 497 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 498 if (unlikely(rc)) 499 goto free; 500 llc_conn_send_pdu(sk, nskb); 501 } 502 out: 503 return rc; 504 free: 505 kfree_skb(nskb); 506 goto out; 507 } 508 509 int llc_conn_ac_send_rej_xxx_x_set_0(struct sock *sk, struct sk_buff *skb) 510 { 511 int rc = -ENOBUFS; 512 struct llc_sock *llc = llc_sk(sk); 513 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0); 514 515 if (nskb) { 516 struct llc_sap *sap = llc->sap; 517 518 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap, 519 llc->daddr.lsap, LLC_PDU_RSP); 520 llc_pdu_init_as_rej_rsp(nskb, 0, llc->vR); 521 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 522 if (unlikely(rc)) 523 goto free; 524 llc_conn_send_pdu(sk, nskb); 525 } 526 out: 527 return rc; 528 free: 529 kfree_skb(nskb); 530 goto out; 531 } 532 533 int llc_conn_ac_send_rnr_cmd_p_set_1(struct sock *sk, struct sk_buff *skb) 534 { 535 int rc = -ENOBUFS; 536 struct llc_sock *llc = llc_sk(sk); 537 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0); 538 539 if (nskb) { 540 struct llc_sap *sap = llc->sap; 541 542 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap, 543 llc->daddr.lsap, LLC_PDU_CMD); 544 llc_pdu_init_as_rnr_cmd(nskb, 1, llc->vR); 545 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 546 if (unlikely(rc)) 547 goto free; 548 llc_conn_send_pdu(sk, nskb); 549 } 550 out: 551 return rc; 552 free: 553 kfree_skb(nskb); 554 goto out; 555 } 556 557 int llc_conn_ac_send_rnr_rsp_f_set_1(struct sock *sk, struct sk_buff *skb) 558 { 559 int rc = -ENOBUFS; 560 struct llc_sock *llc = llc_sk(sk); 561 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0); 562 563 if (nskb) { 564 struct llc_sap *sap = llc->sap; 565 566 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap, 567 llc->daddr.lsap, LLC_PDU_RSP); 568 llc_pdu_init_as_rnr_rsp(nskb, 1, llc->vR); 569 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 570 if (unlikely(rc)) 571 goto free; 572 llc_conn_send_pdu(sk, nskb); 573 } 574 out: 575 return rc; 576 free: 577 kfree_skb(nskb); 578 goto out; 579 } 580 581 int llc_conn_ac_send_rnr_xxx_x_set_0(struct sock *sk, struct sk_buff *skb) 582 { 583 int rc = -ENOBUFS; 584 struct llc_sock *llc = llc_sk(sk); 585 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0); 586 587 if (nskb) { 588 struct llc_sap *sap = llc->sap; 589 590 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap, 591 llc->daddr.lsap, LLC_PDU_RSP); 592 llc_pdu_init_as_rnr_rsp(nskb, 0, llc->vR); 593 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 594 if (unlikely(rc)) 595 goto free; 596 llc_conn_send_pdu(sk, nskb); 597 } 598 out: 599 return rc; 600 free: 601 kfree_skb(nskb); 602 goto out; 603 } 604 605 int llc_conn_ac_set_remote_busy(struct sock *sk, struct sk_buff *skb) 606 { 607 struct llc_sock *llc = llc_sk(sk); 608 609 if (!llc->remote_busy_flag) { 610 llc->remote_busy_flag = 1; 611 mod_timer(&llc->busy_state_timer.timer, 612 jiffies + llc->busy_state_timer.expire); 613 } 614 return 0; 615 } 616 617 int llc_conn_ac_opt_send_rnr_xxx_x_set_0(struct sock *sk, struct sk_buff *skb) 618 { 619 int rc = -ENOBUFS; 620 struct llc_sock *llc = llc_sk(sk); 621 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0); 622 623 if (nskb) { 624 struct llc_sap *sap = llc->sap; 625 626 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap, 627 llc->daddr.lsap, LLC_PDU_RSP); 628 llc_pdu_init_as_rnr_rsp(nskb, 0, llc->vR); 629 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 630 if (unlikely(rc)) 631 goto free; 632 llc_conn_send_pdu(sk, nskb); 633 } 634 out: 635 return rc; 636 free: 637 kfree_skb(nskb); 638 goto out; 639 } 640 641 int llc_conn_ac_send_rr_cmd_p_set_1(struct sock *sk, struct sk_buff *skb) 642 { 643 int rc = -ENOBUFS; 644 struct llc_sock *llc = llc_sk(sk); 645 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0); 646 647 if (nskb) { 648 struct llc_sap *sap = llc->sap; 649 650 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap, 651 llc->daddr.lsap, LLC_PDU_CMD); 652 llc_pdu_init_as_rr_cmd(nskb, 1, llc->vR); 653 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 654 if (unlikely(rc)) 655 goto free; 656 llc_conn_send_pdu(sk, nskb); 657 } 658 out: 659 return rc; 660 free: 661 kfree_skb(nskb); 662 goto out; 663 } 664 665 int llc_conn_ac_send_rr_rsp_f_set_1(struct sock *sk, struct sk_buff *skb) 666 { 667 int rc = -ENOBUFS; 668 struct llc_sock *llc = llc_sk(sk); 669 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0); 670 671 if (nskb) { 672 struct llc_sap *sap = llc->sap; 673 u8 f_bit = 1; 674 675 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap, 676 llc->daddr.lsap, LLC_PDU_RSP); 677 llc_pdu_init_as_rr_rsp(nskb, f_bit, llc->vR); 678 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 679 if (unlikely(rc)) 680 goto free; 681 llc_conn_send_pdu(sk, nskb); 682 } 683 out: 684 return rc; 685 free: 686 kfree_skb(nskb); 687 goto out; 688 } 689 690 int llc_conn_ac_send_ack_rsp_f_set_1(struct sock *sk, struct sk_buff *skb) 691 { 692 int rc = -ENOBUFS; 693 struct llc_sock *llc = llc_sk(sk); 694 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0); 695 696 if (nskb) { 697 struct llc_sap *sap = llc->sap; 698 699 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap, 700 llc->daddr.lsap, LLC_PDU_RSP); 701 llc_pdu_init_as_rr_rsp(nskb, 1, llc->vR); 702 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 703 if (unlikely(rc)) 704 goto free; 705 llc_conn_send_pdu(sk, nskb); 706 } 707 out: 708 return rc; 709 free: 710 kfree_skb(nskb); 711 goto out; 712 } 713 714 int llc_conn_ac_send_rr_xxx_x_set_0(struct sock *sk, struct sk_buff *skb) 715 { 716 int rc = -ENOBUFS; 717 struct llc_sock *llc = llc_sk(sk); 718 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0); 719 720 if (nskb) { 721 struct llc_sap *sap = llc->sap; 722 723 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap, 724 llc->daddr.lsap, LLC_PDU_RSP); 725 llc_pdu_init_as_rr_rsp(nskb, 0, llc->vR); 726 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 727 if (unlikely(rc)) 728 goto free; 729 llc_conn_send_pdu(sk, nskb); 730 } 731 out: 732 return rc; 733 free: 734 kfree_skb(nskb); 735 goto out; 736 } 737 738 int llc_conn_ac_send_ack_xxx_x_set_0(struct sock *sk, struct sk_buff *skb) 739 { 740 int rc = -ENOBUFS; 741 struct llc_sock *llc = llc_sk(sk); 742 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0); 743 744 if (nskb) { 745 struct llc_sap *sap = llc->sap; 746 747 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap, 748 llc->daddr.lsap, LLC_PDU_RSP); 749 llc_pdu_init_as_rr_rsp(nskb, 0, llc->vR); 750 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 751 if (unlikely(rc)) 752 goto free; 753 llc_conn_send_pdu(sk, nskb); 754 } 755 out: 756 return rc; 757 free: 758 kfree_skb(nskb); 759 goto out; 760 } 761 762 void llc_conn_set_p_flag(struct sock *sk, u8 value) 763 { 764 int state_changed = llc_sk(sk)->p_flag && !value; 765 766 llc_sk(sk)->p_flag = value; 767 768 if (state_changed) 769 sk->sk_state_change(sk); 770 } 771 772 int llc_conn_ac_send_sabme_cmd_p_set_x(struct sock *sk, struct sk_buff *skb) 773 { 774 int rc = -ENOBUFS; 775 struct llc_sock *llc = llc_sk(sk); 776 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U, 0); 777 778 if (nskb) { 779 struct llc_sap *sap = llc->sap; 780 u8 *dmac = llc->daddr.mac; 781 782 if (llc->dev->flags & IFF_LOOPBACK) 783 dmac = llc->dev->dev_addr; 784 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap, 785 llc->daddr.lsap, LLC_PDU_CMD); 786 llc_pdu_init_as_sabme_cmd(nskb, 1); 787 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, dmac); 788 if (unlikely(rc)) 789 goto free; 790 llc_conn_send_pdu(sk, nskb); 791 llc_conn_set_p_flag(sk, 1); 792 } 793 out: 794 return rc; 795 free: 796 kfree_skb(nskb); 797 goto out; 798 } 799 800 int llc_conn_ac_send_ua_rsp_f_set_p(struct sock *sk, struct sk_buff *skb) 801 { 802 u8 f_bit; 803 int rc = -ENOBUFS; 804 struct llc_sock *llc = llc_sk(sk); 805 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_U, 0); 806 807 llc_pdu_decode_pf_bit(skb, &f_bit); 808 if (nskb) { 809 struct llc_sap *sap = llc->sap; 810 811 nskb->dev = llc->dev; 812 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap, 813 llc->daddr.lsap, LLC_PDU_RSP); 814 llc_pdu_init_as_ua_rsp(nskb, f_bit); 815 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 816 if (unlikely(rc)) 817 goto free; 818 llc_conn_send_pdu(sk, nskb); 819 } 820 out: 821 return rc; 822 free: 823 kfree_skb(nskb); 824 goto out; 825 } 826 827 int llc_conn_ac_set_s_flag_0(struct sock *sk, struct sk_buff *skb) 828 { 829 llc_sk(sk)->s_flag = 0; 830 return 0; 831 } 832 833 int llc_conn_ac_set_s_flag_1(struct sock *sk, struct sk_buff *skb) 834 { 835 llc_sk(sk)->s_flag = 1; 836 return 0; 837 } 838 839 int llc_conn_ac_start_p_timer(struct sock *sk, struct sk_buff *skb) 840 { 841 struct llc_sock *llc = llc_sk(sk); 842 843 llc_conn_set_p_flag(sk, 1); 844 mod_timer(&llc->pf_cycle_timer.timer, 845 jiffies + llc->pf_cycle_timer.expire); 846 return 0; 847 } 848 849 /** 850 * llc_conn_ac_send_ack_if_needed - check if ack is needed 851 * @sk: current connection structure 852 * @skb: current event 853 * 854 * Checks number of received PDUs which have not been acknowledged, yet, 855 * If number of them reaches to "npta"(Number of PDUs To Acknowledge) then 856 * sends an RR response as acknowledgement for them. Returns 0 for 857 * success, 1 otherwise. 858 */ 859 int llc_conn_ac_send_ack_if_needed(struct sock *sk, struct sk_buff *skb) 860 { 861 u8 pf_bit; 862 struct llc_sock *llc = llc_sk(sk); 863 864 llc_pdu_decode_pf_bit(skb, &pf_bit); 865 llc->ack_pf |= pf_bit & 1; 866 if (!llc->ack_must_be_send) { 867 llc->first_pdu_Ns = llc->vR; 868 llc->ack_must_be_send = 1; 869 llc->ack_pf = pf_bit & 1; 870 } 871 if (((llc->vR - llc->first_pdu_Ns + 1 + LLC_2_SEQ_NBR_MODULO) 872 % LLC_2_SEQ_NBR_MODULO) >= llc->npta) { 873 llc_conn_ac_send_rr_rsp_f_set_ackpf(sk, skb); 874 llc->ack_must_be_send = 0; 875 llc->ack_pf = 0; 876 llc_conn_ac_inc_npta_value(sk, skb); 877 } 878 return 0; 879 } 880 881 /** 882 * llc_conn_ac_rst_sendack_flag - resets ack_must_be_send flag 883 * @sk: current connection structure 884 * @skb: current event 885 * 886 * This action resets ack_must_be_send flag of given connection, this flag 887 * indicates if there is any PDU which has not been acknowledged yet. 888 * Returns 0 for success, 1 otherwise. 889 */ 890 int llc_conn_ac_rst_sendack_flag(struct sock *sk, struct sk_buff *skb) 891 { 892 llc_sk(sk)->ack_must_be_send = llc_sk(sk)->ack_pf = 0; 893 return 0; 894 } 895 896 /** 897 * llc_conn_ac_send_i_rsp_f_set_ackpf - acknowledge received PDUs 898 * @sk: current connection structure 899 * @skb: current event 900 * 901 * Sends an I response PDU with f-bit set to ack_pf flag as acknowledge to 902 * all received PDUs which have not been acknowledged, yet. ack_pf flag is 903 * set to one if one PDU with p-bit set to one is received. Returns 0 for 904 * success, 1 otherwise. 905 */ 906 static int llc_conn_ac_send_i_rsp_f_set_ackpf(struct sock *sk, 907 struct sk_buff *skb) 908 { 909 int rc; 910 struct llc_sock *llc = llc_sk(sk); 911 struct llc_sap *sap = llc->sap; 912 913 llc_pdu_header_init(skb, LLC_PDU_TYPE_I, sap->laddr.lsap, 914 llc->daddr.lsap, LLC_PDU_RSP); 915 llc_pdu_init_as_i_cmd(skb, llc->ack_pf, llc->vS, llc->vR); 916 rc = llc_mac_hdr_init(skb, llc->dev->dev_addr, llc->daddr.mac); 917 if (likely(!rc)) { 918 llc_conn_send_pdu(sk, skb); 919 llc_conn_ac_inc_vs_by_1(sk, skb); 920 } 921 return rc; 922 } 923 924 /** 925 * llc_conn_ac_send_i_as_ack - sends an I-format PDU to acknowledge rx PDUs 926 * @sk: current connection structure. 927 * @skb: current event. 928 * 929 * This action sends an I-format PDU as acknowledge to received PDUs which 930 * have not been acknowledged, yet, if there is any. By using of this 931 * action number of acknowledgements decreases, this technic is called 932 * piggy backing. Returns 0 for success, 1 otherwise. 933 */ 934 int llc_conn_ac_send_i_as_ack(struct sock *sk, struct sk_buff *skb) 935 { 936 struct llc_sock *llc = llc_sk(sk); 937 938 if (llc->ack_must_be_send) { 939 llc_conn_ac_send_i_rsp_f_set_ackpf(sk, skb); 940 llc->ack_must_be_send = 0 ; 941 llc->ack_pf = 0; 942 } else 943 llc_conn_ac_send_i_cmd_p_set_0(sk, skb); 944 return 0; 945 } 946 947 /** 948 * llc_conn_ac_send_rr_rsp_f_set_ackpf - ack all rx PDUs not yet acked 949 * @sk: current connection structure. 950 * @skb: current event. 951 * 952 * This action sends an RR response with f-bit set to ack_pf flag as 953 * acknowledge to all received PDUs which have not been acknowledged, yet, 954 * if there is any. ack_pf flag indicates if a PDU has been received with 955 * p-bit set to one. Returns 0 for success, 1 otherwise. 956 */ 957 static int llc_conn_ac_send_rr_rsp_f_set_ackpf(struct sock *sk, 958 struct sk_buff *skb) 959 { 960 int rc = -ENOBUFS; 961 struct llc_sock *llc = llc_sk(sk); 962 struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev, LLC_PDU_TYPE_S, 0); 963 964 if (nskb) { 965 struct llc_sap *sap = llc->sap; 966 967 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap, 968 llc->daddr.lsap, LLC_PDU_RSP); 969 llc_pdu_init_as_rr_rsp(nskb, llc->ack_pf, llc->vR); 970 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac); 971 if (unlikely(rc)) 972 goto free; 973 llc_conn_send_pdu(sk, nskb); 974 } 975 out: 976 return rc; 977 free: 978 kfree_skb(nskb); 979 goto out; 980 } 981 982 /** 983 * llc_conn_ac_inc_npta_value - tries to make value of npta greater 984 * @sk: current connection structure. 985 * @skb: current event. 986 * 987 * After "inc_cntr" times calling of this action, "npta" increase by one. 988 * this action tries to make vale of "npta" greater as possible; number of 989 * acknowledgements decreases by increasing of "npta". Returns 0 for 990 * success, 1 otherwise. 991 */ 992 static int llc_conn_ac_inc_npta_value(struct sock *sk, struct sk_buff *skb) 993 { 994 struct llc_sock *llc = llc_sk(sk); 995 996 if (!llc->inc_cntr) { 997 llc->dec_step = 0; 998 llc->dec_cntr = llc->inc_cntr = 2; 999 ++llc->npta; 1000 if (llc->npta > (u8) ~LLC_2_SEQ_NBR_MODULO) 1001 llc->npta = (u8) ~LLC_2_SEQ_NBR_MODULO; 1002 } else 1003 --llc->inc_cntr; 1004 return 0; 1005 } 1006 1007 /** 1008 * llc_conn_ac_adjust_npta_by_rr - decreases "npta" by one 1009 * @sk: current connection structure. 1010 * @skb: current event. 1011 * 1012 * After receiving "dec_cntr" times RR command, this action decreases 1013 * "npta" by one. Returns 0 for success, 1 otherwise. 1014 */ 1015 int llc_conn_ac_adjust_npta_by_rr(struct sock *sk, struct sk_buff *skb) 1016 { 1017 struct llc_sock *llc = llc_sk(sk); 1018 1019 if (!llc->connect_step && !llc->remote_busy_flag) { 1020 if (!llc->dec_step) { 1021 if (!llc->dec_cntr) { 1022 llc->inc_cntr = llc->dec_cntr = 2; 1023 if (llc->npta > 0) 1024 llc->npta = llc->npta - 1; 1025 } else 1026 llc->dec_cntr -=1; 1027 } 1028 } else 1029 llc->connect_step = 0 ; 1030 return 0; 1031 } 1032 1033 /** 1034 * llc_conn_ac_adjust_npta_by_rnr - decreases "npta" by one 1035 * @sk: current connection structure. 1036 * @skb: current event. 1037 * 1038 * After receiving "dec_cntr" times RNR command, this action decreases 1039 * "npta" by one. Returns 0 for success, 1 otherwise. 1040 */ 1041 int llc_conn_ac_adjust_npta_by_rnr(struct sock *sk, struct sk_buff *skb) 1042 { 1043 struct llc_sock *llc = llc_sk(sk); 1044 1045 if (llc->remote_busy_flag) 1046 if (!llc->dec_step) { 1047 if (!llc->dec_cntr) { 1048 llc->inc_cntr = llc->dec_cntr = 2; 1049 if (llc->npta > 0) 1050 --llc->npta; 1051 } else 1052 --llc->dec_cntr; 1053 } 1054 return 0; 1055 } 1056 1057 /** 1058 * llc_conn_ac_dec_tx_win_size - decreases tx window size 1059 * @sk: current connection structure. 1060 * @skb: current event. 1061 * 1062 * After receiving of a REJ command or response, transmit window size is 1063 * decreased by number of PDUs which are outstanding yet. Returns 0 for 1064 * success, 1 otherwise. 1065 */ 1066 int llc_conn_ac_dec_tx_win_size(struct sock *sk, struct sk_buff *skb) 1067 { 1068 struct llc_sock *llc = llc_sk(sk); 1069 u8 unacked_pdu = skb_queue_len(&llc->pdu_unack_q); 1070 1071 if (llc->k - unacked_pdu < 1) 1072 llc->k = 1; 1073 else 1074 llc->k -= unacked_pdu; 1075 return 0; 1076 } 1077 1078 /** 1079 * llc_conn_ac_inc_tx_win_size - tx window size is inc by 1 1080 * @sk: current connection structure. 1081 * @skb: current event. 1082 * 1083 * After receiving an RR response with f-bit set to one, transmit window 1084 * size is increased by one. Returns 0 for success, 1 otherwise. 1085 */ 1086 int llc_conn_ac_inc_tx_win_size(struct sock *sk, struct sk_buff *skb) 1087 { 1088 struct llc_sock *llc = llc_sk(sk); 1089 1090 llc->k += 1; 1091 if (llc->k > (u8) ~LLC_2_SEQ_NBR_MODULO) 1092 llc->k = (u8) ~LLC_2_SEQ_NBR_MODULO; 1093 return 0; 1094 } 1095 1096 int llc_conn_ac_stop_all_timers(struct sock *sk, struct sk_buff *skb) 1097 { 1098 struct llc_sock *llc = llc_sk(sk); 1099 1100 del_timer(&llc->pf_cycle_timer.timer); 1101 del_timer(&llc->ack_timer.timer); 1102 del_timer(&llc->rej_sent_timer.timer); 1103 del_timer(&llc->busy_state_timer.timer); 1104 llc->ack_must_be_send = 0; 1105 llc->ack_pf = 0; 1106 return 0; 1107 } 1108 1109 int llc_conn_ac_stop_other_timers(struct sock *sk, struct sk_buff *skb) 1110 { 1111 struct llc_sock *llc = llc_sk(sk); 1112 1113 del_timer(&llc->rej_sent_timer.timer); 1114 del_timer(&llc->pf_cycle_timer.timer); 1115 del_timer(&llc->busy_state_timer.timer); 1116 llc->ack_must_be_send = 0; 1117 llc->ack_pf = 0; 1118 return 0; 1119 } 1120 1121 int llc_conn_ac_start_ack_timer(struct sock *sk, struct sk_buff *skb) 1122 { 1123 struct llc_sock *llc = llc_sk(sk); 1124 1125 mod_timer(&llc->ack_timer.timer, jiffies + llc->ack_timer.expire); 1126 return 0; 1127 } 1128 1129 int llc_conn_ac_start_rej_timer(struct sock *sk, struct sk_buff *skb) 1130 { 1131 struct llc_sock *llc = llc_sk(sk); 1132 1133 mod_timer(&llc->rej_sent_timer.timer, 1134 jiffies + llc->rej_sent_timer.expire); 1135 return 0; 1136 } 1137 1138 int llc_conn_ac_start_ack_tmr_if_not_running(struct sock *sk, 1139 struct sk_buff *skb) 1140 { 1141 struct llc_sock *llc = llc_sk(sk); 1142 1143 if (!timer_pending(&llc->ack_timer.timer)) 1144 mod_timer(&llc->ack_timer.timer, 1145 jiffies + llc->ack_timer.expire); 1146 return 0; 1147 } 1148 1149 int llc_conn_ac_stop_ack_timer(struct sock *sk, struct sk_buff *skb) 1150 { 1151 del_timer(&llc_sk(sk)->ack_timer.timer); 1152 return 0; 1153 } 1154 1155 int llc_conn_ac_stop_p_timer(struct sock *sk, struct sk_buff *skb) 1156 { 1157 struct llc_sock *llc = llc_sk(sk); 1158 1159 del_timer(&llc->pf_cycle_timer.timer); 1160 llc_conn_set_p_flag(sk, 0); 1161 return 0; 1162 } 1163 1164 int llc_conn_ac_stop_rej_timer(struct sock *sk, struct sk_buff *skb) 1165 { 1166 del_timer(&llc_sk(sk)->rej_sent_timer.timer); 1167 return 0; 1168 } 1169 1170 int llc_conn_ac_upd_nr_received(struct sock *sk, struct sk_buff *skb) 1171 { 1172 int acked; 1173 u16 unacked = 0; 1174 struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb); 1175 struct llc_sock *llc = llc_sk(sk); 1176 1177 llc->last_nr = PDU_SUPV_GET_Nr(pdu); 1178 acked = llc_conn_remove_acked_pdus(sk, llc->last_nr, &unacked); 1179 /* On loopback we don't queue I frames in unack_pdu_q queue. */ 1180 if (acked > 0 || (llc->dev->flags & IFF_LOOPBACK)) { 1181 llc->retry_count = 0; 1182 del_timer(&llc->ack_timer.timer); 1183 if (llc->failed_data_req) { 1184 /* already, we did not accept data from upper layer 1185 * (tx_window full or unacceptable state). Now, we 1186 * can send data and must inform to upper layer. 1187 */ 1188 llc->failed_data_req = 0; 1189 llc_conn_ac_data_confirm(sk, skb); 1190 } 1191 if (unacked) 1192 mod_timer(&llc->ack_timer.timer, 1193 jiffies + llc->ack_timer.expire); 1194 } else if (llc->failed_data_req) { 1195 u8 f_bit; 1196 1197 llc_pdu_decode_pf_bit(skb, &f_bit); 1198 if (f_bit == 1) { 1199 llc->failed_data_req = 0; 1200 llc_conn_ac_data_confirm(sk, skb); 1201 } 1202 } 1203 return 0; 1204 } 1205 1206 int llc_conn_ac_upd_p_flag(struct sock *sk, struct sk_buff *skb) 1207 { 1208 struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb); 1209 1210 if (LLC_PDU_IS_RSP(pdu)) { 1211 u8 f_bit; 1212 1213 llc_pdu_decode_pf_bit(skb, &f_bit); 1214 if (f_bit) { 1215 llc_conn_set_p_flag(sk, 0); 1216 llc_conn_ac_stop_p_timer(sk, skb); 1217 } 1218 } 1219 return 0; 1220 } 1221 1222 int llc_conn_ac_set_data_flag_2(struct sock *sk, struct sk_buff *skb) 1223 { 1224 llc_sk(sk)->data_flag = 2; 1225 return 0; 1226 } 1227 1228 int llc_conn_ac_set_data_flag_0(struct sock *sk, struct sk_buff *skb) 1229 { 1230 llc_sk(sk)->data_flag = 0; 1231 return 0; 1232 } 1233 1234 int llc_conn_ac_set_data_flag_1(struct sock *sk, struct sk_buff *skb) 1235 { 1236 llc_sk(sk)->data_flag = 1; 1237 return 0; 1238 } 1239 1240 int llc_conn_ac_set_data_flag_1_if_data_flag_eq_0(struct sock *sk, 1241 struct sk_buff *skb) 1242 { 1243 if (!llc_sk(sk)->data_flag) 1244 llc_sk(sk)->data_flag = 1; 1245 return 0; 1246 } 1247 1248 int llc_conn_ac_set_p_flag_0(struct sock *sk, struct sk_buff *skb) 1249 { 1250 llc_conn_set_p_flag(sk, 0); 1251 return 0; 1252 } 1253 1254 static int llc_conn_ac_set_p_flag_1(struct sock *sk, struct sk_buff *skb) 1255 { 1256 llc_conn_set_p_flag(sk, 1); 1257 return 0; 1258 } 1259 1260 int llc_conn_ac_set_remote_busy_0(struct sock *sk, struct sk_buff *skb) 1261 { 1262 llc_sk(sk)->remote_busy_flag = 0; 1263 return 0; 1264 } 1265 1266 int llc_conn_ac_set_cause_flag_0(struct sock *sk, struct sk_buff *skb) 1267 { 1268 llc_sk(sk)->cause_flag = 0; 1269 return 0; 1270 } 1271 1272 int llc_conn_ac_set_cause_flag_1(struct sock *sk, struct sk_buff *skb) 1273 { 1274 llc_sk(sk)->cause_flag = 1; 1275 return 0; 1276 } 1277 1278 int llc_conn_ac_set_retry_cnt_0(struct sock *sk, struct sk_buff *skb) 1279 { 1280 llc_sk(sk)->retry_count = 0; 1281 return 0; 1282 } 1283 1284 int llc_conn_ac_inc_retry_cnt_by_1(struct sock *sk, struct sk_buff *skb) 1285 { 1286 llc_sk(sk)->retry_count++; 1287 return 0; 1288 } 1289 1290 int llc_conn_ac_set_vr_0(struct sock *sk, struct sk_buff *skb) 1291 { 1292 llc_sk(sk)->vR = 0; 1293 return 0; 1294 } 1295 1296 int llc_conn_ac_inc_vr_by_1(struct sock *sk, struct sk_buff *skb) 1297 { 1298 llc_sk(sk)->vR = PDU_GET_NEXT_Vr(llc_sk(sk)->vR); 1299 return 0; 1300 } 1301 1302 int llc_conn_ac_set_vs_0(struct sock *sk, struct sk_buff *skb) 1303 { 1304 llc_sk(sk)->vS = 0; 1305 return 0; 1306 } 1307 1308 int llc_conn_ac_set_vs_nr(struct sock *sk, struct sk_buff *skb) 1309 { 1310 llc_sk(sk)->vS = llc_sk(sk)->last_nr; 1311 return 0; 1312 } 1313 1314 static int llc_conn_ac_inc_vs_by_1(struct sock *sk, struct sk_buff *skb) 1315 { 1316 llc_sk(sk)->vS = (llc_sk(sk)->vS + 1) % LLC_2_SEQ_NBR_MODULO; 1317 return 0; 1318 } 1319 1320 static void llc_conn_tmr_common_cb(unsigned long timeout_data, u8 type) 1321 { 1322 struct sock *sk = (struct sock *)timeout_data; 1323 struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC); 1324 1325 bh_lock_sock(sk); 1326 if (skb) { 1327 struct llc_conn_state_ev *ev = llc_conn_ev(skb); 1328 1329 skb_set_owner_r(skb, sk); 1330 ev->type = type; 1331 llc_process_tmr_ev(sk, skb); 1332 } 1333 bh_unlock_sock(sk); 1334 } 1335 1336 void llc_conn_pf_cycle_tmr_cb(unsigned long timeout_data) 1337 { 1338 llc_conn_tmr_common_cb(timeout_data, LLC_CONN_EV_TYPE_P_TMR); 1339 } 1340 1341 void llc_conn_busy_tmr_cb(unsigned long timeout_data) 1342 { 1343 llc_conn_tmr_common_cb(timeout_data, LLC_CONN_EV_TYPE_BUSY_TMR); 1344 } 1345 1346 void llc_conn_ack_tmr_cb(unsigned long timeout_data) 1347 { 1348 llc_conn_tmr_common_cb(timeout_data, LLC_CONN_EV_TYPE_ACK_TMR); 1349 } 1350 1351 void llc_conn_rej_tmr_cb(unsigned long timeout_data) 1352 { 1353 llc_conn_tmr_common_cb(timeout_data, LLC_CONN_EV_TYPE_REJ_TMR); 1354 } 1355 1356 int llc_conn_ac_rst_vs(struct sock *sk, struct sk_buff *skb) 1357 { 1358 llc_sk(sk)->X = llc_sk(sk)->vS; 1359 llc_conn_ac_set_vs_nr(sk, skb); 1360 return 0; 1361 } 1362 1363 int llc_conn_ac_upd_vs(struct sock *sk, struct sk_buff *skb) 1364 { 1365 struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb); 1366 u8 nr = PDU_SUPV_GET_Nr(pdu); 1367 1368 if (llc_circular_between(llc_sk(sk)->vS, nr, llc_sk(sk)->X)) 1369 llc_conn_ac_set_vs_nr(sk, skb); 1370 return 0; 1371 } 1372 1373 /* 1374 * Non-standard actions; these not contained in IEEE specification; for 1375 * our own usage 1376 */ 1377 /** 1378 * llc_conn_disc - removes connection from SAP list and frees it 1379 * @sk: closed connection 1380 * @skb: occurred event 1381 */ 1382 int llc_conn_disc(struct sock *sk, struct sk_buff *skb) 1383 { 1384 /* FIXME: this thing seems to want to die */ 1385 return 0; 1386 } 1387 1388 /** 1389 * llc_conn_reset - resets connection 1390 * @sk : reseting connection. 1391 * @skb: occurred event. 1392 * 1393 * Stop all timers, empty all queues and reset all flags. 1394 */ 1395 int llc_conn_reset(struct sock *sk, struct sk_buff *skb) 1396 { 1397 llc_sk_reset(sk); 1398 return 0; 1399 } 1400 1401 /** 1402 * llc_circular_between - designates that b is between a and c or not 1403 * @a: lower bound 1404 * @b: element to see if is between a and b 1405 * @c: upper bound 1406 * 1407 * This function designates that b is between a and c or not (for example, 1408 * 0 is between 127 and 1). Returns 1 if b is between a and c, 0 1409 * otherwise. 1410 */ 1411 u8 llc_circular_between(u8 a, u8 b, u8 c) 1412 { 1413 b = b - a; 1414 c = c - a; 1415 return b <= c; 1416 } 1417 1418 /** 1419 * llc_process_tmr_ev - timer backend 1420 * @sk: active connection 1421 * @skb: occurred event 1422 * 1423 * This function is called from timer callback functions. When connection 1424 * is busy (during sending a data frame) timer expiration event must be 1425 * queued. Otherwise this event can be sent to connection state machine. 1426 * Queued events will process by llc_backlog_rcv function after sending 1427 * data frame. 1428 */ 1429 static void llc_process_tmr_ev(struct sock *sk, struct sk_buff *skb) 1430 { 1431 if (llc_sk(sk)->state == LLC_CONN_OUT_OF_SVC) { 1432 printk(KERN_WARNING "%s: timer called on closed connection\n", 1433 __func__); 1434 kfree_skb(skb); 1435 } else { 1436 if (!sock_owned_by_user(sk)) 1437 llc_conn_state_process(sk, skb); 1438 else { 1439 llc_set_backlog_type(skb, LLC_EVENT); 1440 sk_add_backlog(sk, skb); 1441 } 1442 } 1443 } 1444