net/llc/llc_c_ac.c

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