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