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