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