git.oblomov.eu Git - linux-2.6/blob - 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 + 1 + LLC_2_SEQ_NBR_MODULO)
 870                         % LLC_2_SEQ_NBR_MODULO) >= llc->npta) {
 871                 llc_conn_ac_send_rr_rsp_f_set_ackpf(sk, skb);
 872                 llc->ack_must_be_send   = 0;
 873                 llc->ack_pf             = 0;
 874                 llc_conn_ac_inc_npta_value(sk, skb);
 875         }
 876         return 0;
 877 }
 878
 879 /**
 880  *      llc_conn_ac_rst_sendack_flag - resets ack_must_be_send flag
 881  *      @sk: current connection structure
 882  *      @skb: current event
 883  *
 884  *      This action resets ack_must_be_send flag of given connection, this flag
 885  *      indicates if there is any PDU which has not been acknowledged yet.
 886  *      Returns 0 for success, 1 otherwise.
 887  */
 888 int llc_conn_ac_rst_sendack_flag(struct sock *sk, struct sk_buff *skb)
 889 {
 890         llc_sk(sk)->ack_must_be_send = llc_sk(sk)->ack_pf = 0;
 891         return 0;
 892 }
 893
 894 /**
 895  *      llc_conn_ac_send_i_rsp_f_set_ackpf - acknowledge received PDUs
 896  *      @sk: current connection structure
 897  *      @skb: current event
 898  *
 899  *      Sends an I response PDU with f-bit set to ack_pf flag as acknowledge to
 900  *      all received PDUs which have not been acknowledged, yet. ack_pf flag is
 901  *      set to one if one PDU with p-bit set to one is received.  Returns 0 for
 902  *      success, 1 otherwise.
 903  */
 904 static int llc_conn_ac_send_i_rsp_f_set_ackpf(struct sock *sk,
 905                                               struct sk_buff *skb)
 906 {
 907         int rc;
 908         struct llc_sock *llc = llc_sk(sk);
 909         struct llc_sap *sap = llc->sap;
 910
 911         llc_pdu_header_init(skb, LLC_PDU_TYPE_I, sap->laddr.lsap,
 912                             llc->daddr.lsap, LLC_PDU_RSP);
 913         llc_pdu_init_as_i_cmd(skb, llc->ack_pf, llc->vS, llc->vR);
 914         rc = llc_mac_hdr_init(skb, llc->dev->dev_addr, llc->daddr.mac);
 915         if (likely(!rc)) {
 916                 llc_conn_send_pdu(sk, skb);
 917                 llc_conn_ac_inc_vs_by_1(sk, skb);
 918         }
 919         return rc;
 920 }
 921
 922 /**
 923  *      llc_conn_ac_send_i_as_ack - sends an I-format PDU to acknowledge rx PDUs
 924  *      @sk: current connection structure.
 925  *      @skb: current event.
 926  *
 927  *      This action sends an I-format PDU as acknowledge to received PDUs which
 928  *      have not been acknowledged, yet, if there is any. By using of this
 929  *      action number of acknowledgements decreases, this technic is called
 930  *      piggy backing. Returns 0 for success, 1 otherwise.
 931  */
 932 int llc_conn_ac_send_i_as_ack(struct sock *sk, struct sk_buff *skb)
 933 {
 934         struct llc_sock *llc = llc_sk(sk);
 935
 936         if (llc->ack_must_be_send) {
 937                 llc_conn_ac_send_i_rsp_f_set_ackpf(sk, skb);
 938                 llc->ack_must_be_send = 0 ;
 939                 llc->ack_pf = 0;
 940         } else
 941                 llc_conn_ac_send_i_cmd_p_set_0(sk, skb);
 942         return 0;
 943 }
 944
 945 /**
 946  *      llc_conn_ac_send_rr_rsp_f_set_ackpf - ack all rx PDUs not yet acked
 947  *      @sk: current connection structure.
 948  *      @skb: current event.
 949  *
 950  *      This action sends an RR response with f-bit set to ack_pf flag as
 951  *      acknowledge to all received PDUs which have not been acknowledged, yet,
 952  *      if there is any. ack_pf flag indicates if a PDU has been received with
 953  *      p-bit set to one. Returns 0 for success, 1 otherwise.
 954  */
 955 static int llc_conn_ac_send_rr_rsp_f_set_ackpf(struct sock *sk,
 956                                                struct sk_buff *skb)
 957 {
 958         int rc = -ENOBUFS;
 959         struct llc_sock *llc = llc_sk(sk);
 960         struct sk_buff *nskb = llc_alloc_frame(sk, llc->dev);
 961
 962         if (nskb) {
 963                 struct llc_sap *sap = llc->sap;
 964
 965                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
 966                                     llc->daddr.lsap, LLC_PDU_RSP);
 967                 llc_pdu_init_as_rr_rsp(nskb, llc->ack_pf, llc->vR);
 968                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
 969                 if (unlikely(rc))
 970                         goto free;
 971                 llc_conn_send_pdu(sk, nskb);
 972         }
 973 out:
 974         return rc;
 975 free:
 976         kfree_skb(nskb);
 977         goto out;
 978 }
 979
 980 /**
 981  *      llc_conn_ac_inc_npta_value - tries to make value of npta greater
 982  *      @sk: current connection structure.
 983  *      @skb: current event.
 984  *
 985  *      After "inc_cntr" times calling of this action, "npta" increase by one.
 986  *      this action tries to make vale of "npta" greater as possible; number of
 987  *      acknowledgements decreases by increasing of "npta". Returns 0 for
 988  *      success, 1 otherwise.
 989  */
 990 static int llc_conn_ac_inc_npta_value(struct sock *sk, struct sk_buff *skb)
 991 {
 992         struct llc_sock *llc = llc_sk(sk);
 993
 994         if (!llc->inc_cntr) {
 995                 llc->dec_step = 0;
 996                 llc->dec_cntr = llc->inc_cntr = 2;
 997                 ++llc->npta;
 998                 if (llc->npta > (u8) ~LLC_2_SEQ_NBR_MODULO)
 999                         llc->npta = (u8) ~LLC_2_SEQ_NBR_MODULO;
1000         } else
1001                 --llc->inc_cntr;
1002         return 0;
1003 }
1004
1005 /**
1006  *      llc_conn_ac_adjust_npta_by_rr - decreases "npta" by one
1007  *      @sk: current connection structure.
1008  *      @skb: current event.
1009  *
1010  *      After receiving "dec_cntr" times RR command, this action decreases
1011  *      "npta" by one. Returns 0 for success, 1 otherwise.
1012  */
1013 int llc_conn_ac_adjust_npta_by_rr(struct sock *sk, struct sk_buff *skb)
1014 {
1015         struct llc_sock *llc = llc_sk(sk);
1016
1017         if (!llc->connect_step && !llc->remote_busy_flag) {
1018                 if (!llc->dec_step) {
1019                         if (!llc->dec_cntr) {
1020                                 llc->inc_cntr = llc->dec_cntr = 2;
1021                                 if (llc->npta > 0)
1022                                         llc->npta = llc->npta - 1;
1023                         } else
1024                                 llc->dec_cntr -=1;
1025                 }
1026         } else
1027                 llc->connect_step = 0 ;
1028         return 0;
1029 }
1030
1031 /**
1032  *      llc_conn_ac_adjust_npta_by_rnr - decreases "npta" by one
1033  *      @sk: current connection structure.
1034  *      @skb: current event.
1035  *
1036  *      After receiving "dec_cntr" times RNR command, this action decreases
1037  *      "npta" by one. Returns 0 for success, 1 otherwise.
1038  */
1039 int llc_conn_ac_adjust_npta_by_rnr(struct sock *sk, struct sk_buff *skb)
1040 {
1041         struct llc_sock *llc = llc_sk(sk);
1042
1043         if (llc->remote_busy_flag)
1044                 if (!llc->dec_step) {
1045                         if (!llc->dec_cntr) {
1046                                 llc->inc_cntr = llc->dec_cntr = 2;
1047                                 if (llc->npta > 0)
1048                                         --llc->npta;
1049                         } else
1050                                 --llc->dec_cntr;
1051                 }
1052         return 0;
1053 }
1054
1055 /**
1056  *      llc_conn_ac_dec_tx_win_size - decreases tx window size
1057  *      @sk: current connection structure.
1058  *      @skb: current event.
1059  *
1060  *      After receiving of a REJ command or response, transmit window size is
1061  *      decreased by number of PDUs which are outstanding yet. Returns 0 for
1062  *      success, 1 otherwise.
1063  */
1064 int llc_conn_ac_dec_tx_win_size(struct sock *sk, struct sk_buff *skb)
1065 {
1066         struct llc_sock *llc = llc_sk(sk);
1067         u8 unacked_pdu = skb_queue_len(&llc->pdu_unack_q);
1068
1069         if (llc->k - unacked_pdu < 1)
1070                 llc->k = 1;
1071         else
1072                 llc->k -= unacked_pdu;
1073         return 0;
1074 }
1075
1076 /**
1077  *      llc_conn_ac_inc_tx_win_size - tx window size is inc by 1
1078  *      @sk: current connection structure.
1079  *      @skb: current event.
1080  *
1081  *      After receiving an RR response with f-bit set to one, transmit window
1082  *      size is increased by one. Returns 0 for success, 1 otherwise.
1083  */
1084 int llc_conn_ac_inc_tx_win_size(struct sock *sk, struct sk_buff *skb)
1085 {
1086         struct llc_sock *llc = llc_sk(sk);
1087
1088         llc->k += 1;
1089         if (llc->k > (u8) ~LLC_2_SEQ_NBR_MODULO)
1090                 llc->k = (u8) ~LLC_2_SEQ_NBR_MODULO;
1091         return 0;
1092 }
1093
1094 int llc_conn_ac_stop_all_timers(struct sock *sk, struct sk_buff *skb)
1095 {
1096         struct llc_sock *llc = llc_sk(sk);
1097
1098         del_timer(&llc->pf_cycle_timer.timer);
1099         del_timer(&llc->ack_timer.timer);
1100         del_timer(&llc->rej_sent_timer.timer);
1101         del_timer(&llc->busy_state_timer.timer);
1102         llc->ack_must_be_send = 0;
1103         llc->ack_pf = 0;
1104         return 0;
1105 }
1106
1107 int llc_conn_ac_stop_other_timers(struct sock *sk, struct sk_buff *skb)
1108 {
1109         struct llc_sock *llc = llc_sk(sk);
1110
1111         del_timer(&llc->rej_sent_timer.timer);
1112         del_timer(&llc->pf_cycle_timer.timer);
1113         del_timer(&llc->busy_state_timer.timer);
1114         llc->ack_must_be_send = 0;
1115         llc->ack_pf = 0;
1116         return 0;
1117 }
1118
1119 int llc_conn_ac_start_ack_timer(struct sock *sk, struct sk_buff *skb)
1120 {
1121         struct llc_sock *llc = llc_sk(sk);
1122
1123         mod_timer(&llc->ack_timer.timer, jiffies + llc->ack_timer.expire);
1124         return 0;
1125 }
1126
1127 int llc_conn_ac_start_rej_timer(struct sock *sk, struct sk_buff *skb)
1128 {
1129         struct llc_sock *llc = llc_sk(sk);
1130
1131         mod_timer(&llc->rej_sent_timer.timer,
1132                   jiffies + llc->rej_sent_timer.expire);
1133         return 0;
1134 }
1135
1136 int llc_conn_ac_start_ack_tmr_if_not_running(struct sock *sk,
1137                                              struct sk_buff *skb)
1138 {
1139         struct llc_sock *llc = llc_sk(sk);
1140
1141         if (!timer_pending(&llc->ack_timer.timer))
1142                 mod_timer(&llc->ack_timer.timer,
1143                           jiffies + llc->ack_timer.expire);
1144         return 0;
1145 }
1146
1147 int llc_conn_ac_stop_ack_timer(struct sock *sk, struct sk_buff *skb)
1148 {
1149         del_timer(&llc_sk(sk)->ack_timer.timer);
1150         return 0;
1151 }
1152
1153 int llc_conn_ac_stop_p_timer(struct sock *sk, struct sk_buff *skb)
1154 {
1155         struct llc_sock *llc = llc_sk(sk);
1156
1157         del_timer(&llc->pf_cycle_timer.timer);
1158         llc_conn_set_p_flag(sk, 0);
1159         return 0;
1160 }
1161
1162 int llc_conn_ac_stop_rej_timer(struct sock *sk, struct sk_buff *skb)
1163 {
1164         del_timer(&llc_sk(sk)->rej_sent_timer.timer);
1165         return 0;
1166 }
1167
1168 int llc_conn_ac_upd_nr_received(struct sock *sk, struct sk_buff *skb)
1169 {
1170         int acked;
1171         u16 unacked = 0;
1172         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
1173         struct llc_sock *llc = llc_sk(sk);
1174
1175         llc->last_nr = PDU_SUPV_GET_Nr(pdu);
1176         acked = llc_conn_remove_acked_pdus(sk, llc->last_nr, &unacked);
1177         /* On loopback we don't queue I frames in unack_pdu_q queue. */
1178         if (acked > 0 || (llc->dev->flags & IFF_LOOPBACK)) {
1179                 llc->retry_count = 0;
1180                 del_timer(&llc->ack_timer.timer);
1181                 if (llc->failed_data_req) {
1182                         /* already, we did not accept data from upper layer
1183                          * (tx_window full or unacceptable state). Now, we
1184                          * can send data and must inform to upper layer.
1185                          */
1186                         llc->failed_data_req = 0;
1187                         llc_conn_ac_data_confirm(sk, skb);
1188                 }
1189                 if (unacked)
1190                         mod_timer(&llc->ack_timer.timer,
1191                                   jiffies + llc->ack_timer.expire);
1192         } else if (llc->failed_data_req) {
1193                 u8 f_bit;
1194
1195                 llc_pdu_decode_pf_bit(skb, &f_bit);
1196                 if (f_bit == 1) {
1197                         llc->failed_data_req = 0;
1198                         llc_conn_ac_data_confirm(sk, skb);
1199                 }
1200         }
1201         return 0;
1202 }
1203
1204 int llc_conn_ac_upd_p_flag(struct sock *sk, struct sk_buff *skb)
1205 {
1206         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
1207
1208         if (LLC_PDU_IS_RSP(pdu)) {
1209                 u8 f_bit;
1210
1211                 llc_pdu_decode_pf_bit(skb, &f_bit);
1212                 if (f_bit) {
1213                         llc_conn_set_p_flag(sk, 0);
1214                         llc_conn_ac_stop_p_timer(sk, skb);
1215                 }
1216         }
1217         return 0;
1218 }
1219
1220 int llc_conn_ac_set_data_flag_2(struct sock *sk, struct sk_buff *skb)
1221 {
1222         llc_sk(sk)->data_flag = 2;
1223         return 0;
1224 }
1225
1226 int llc_conn_ac_set_data_flag_0(struct sock *sk, struct sk_buff *skb)
1227 {
1228         llc_sk(sk)->data_flag = 0;
1229         return 0;
1230 }
1231
1232 int llc_conn_ac_set_data_flag_1(struct sock *sk, struct sk_buff *skb)
1233 {
1234         llc_sk(sk)->data_flag = 1;
1235         return 0;
1236 }
1237
1238 int llc_conn_ac_set_data_flag_1_if_data_flag_eq_0(struct sock *sk,
1239                                                   struct sk_buff *skb)
1240 {
1241         if (!llc_sk(sk)->data_flag)
1242                 llc_sk(sk)->data_flag = 1;
1243         return 0;
1244 }
1245
1246 int llc_conn_ac_set_p_flag_0(struct sock *sk, struct sk_buff *skb)
1247 {
1248         llc_conn_set_p_flag(sk, 0);
1249         return 0;
1250 }
1251
1252 static int llc_conn_ac_set_p_flag_1(struct sock *sk, struct sk_buff *skb)
1253 {
1254         llc_conn_set_p_flag(sk, 1);
1255         return 0;
1256 }
1257
1258 int llc_conn_ac_set_remote_busy_0(struct sock *sk, struct sk_buff *skb)
1259 {
1260         llc_sk(sk)->remote_busy_flag = 0;
1261         return 0;
1262 }
1263
1264 int llc_conn_ac_set_cause_flag_0(struct sock *sk, struct sk_buff *skb)
1265 {
1266         llc_sk(sk)->cause_flag = 0;
1267         return 0;
1268 }
1269
1270 int llc_conn_ac_set_cause_flag_1(struct sock *sk, struct sk_buff *skb)
1271 {
1272         llc_sk(sk)->cause_flag = 1;
1273         return 0;
1274 }
1275
1276 int llc_conn_ac_set_retry_cnt_0(struct sock *sk, struct sk_buff *skb)
1277 {
1278         llc_sk(sk)->retry_count = 0;
1279         return 0;
1280 }
1281
1282 int llc_conn_ac_inc_retry_cnt_by_1(struct sock *sk, struct sk_buff *skb)
1283 {
1284         llc_sk(sk)->retry_count++;
1285         return 0;
1286 }
1287
1288 int llc_conn_ac_set_vr_0(struct sock *sk, struct sk_buff *skb)
1289 {
1290         llc_sk(sk)->vR = 0;
1291         return 0;
1292 }
1293
1294 int llc_conn_ac_inc_vr_by_1(struct sock *sk, struct sk_buff *skb)
1295 {
1296         llc_sk(sk)->vR = PDU_GET_NEXT_Vr(llc_sk(sk)->vR);
1297         return 0;
1298 }
1299
1300 int llc_conn_ac_set_vs_0(struct sock *sk, struct sk_buff *skb)
1301 {
1302         llc_sk(sk)->vS = 0;
1303         return 0;
1304 }
1305
1306 int llc_conn_ac_set_vs_nr(struct sock *sk, struct sk_buff *skb)
1307 {
1308         llc_sk(sk)->vS = llc_sk(sk)->last_nr;
1309         return 0;
1310 }
1311
1312 static int llc_conn_ac_inc_vs_by_1(struct sock *sk, struct sk_buff *skb)
1313 {
1314         llc_sk(sk)->vS = (llc_sk(sk)->vS + 1) % LLC_2_SEQ_NBR_MODULO;
1315         return 0;
1316 }
1317
1318 static void llc_conn_tmr_common_cb(unsigned long timeout_data, u8 type)
1319 {
1320         struct sock *sk = (struct sock *)timeout_data;
1321         struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
1322
1323         bh_lock_sock(sk);
1324         if (skb) {
1325                 struct llc_conn_state_ev *ev = llc_conn_ev(skb);
1326
1327                 skb_set_owner_r(skb, sk);
1328                 ev->type = type;
1329                 llc_process_tmr_ev(sk, skb);
1330         }
1331         bh_unlock_sock(sk);
1332 }
1333
1334 void llc_conn_pf_cycle_tmr_cb(unsigned long timeout_data)
1335 {
1336         llc_conn_tmr_common_cb(timeout_data, LLC_CONN_EV_TYPE_P_TMR);
1337 }
1338
1339 void llc_conn_busy_tmr_cb(unsigned long timeout_data)
1340 {
1341         llc_conn_tmr_common_cb(timeout_data, LLC_CONN_EV_TYPE_BUSY_TMR);
1342 }
1343
1344 void llc_conn_ack_tmr_cb(unsigned long timeout_data)
1345 {
1346         llc_conn_tmr_common_cb(timeout_data, LLC_CONN_EV_TYPE_ACK_TMR);
1347 }
1348
1349 void llc_conn_rej_tmr_cb(unsigned long timeout_data)
1350 {
1351         llc_conn_tmr_common_cb(timeout_data, LLC_CONN_EV_TYPE_REJ_TMR);
1352 }
1353
1354 int llc_conn_ac_rst_vs(struct sock *sk, struct sk_buff *skb)
1355 {
1356         llc_sk(sk)->X = llc_sk(sk)->vS;
1357         llc_conn_ac_set_vs_nr(sk, skb);
1358         return 0;
1359 }
1360
1361 int llc_conn_ac_upd_vs(struct sock *sk, struct sk_buff *skb)
1362 {
1363         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
1364         u8 nr = PDU_SUPV_GET_Nr(pdu);
1365
1366         if (llc_circular_between(llc_sk(sk)->vS, nr, llc_sk(sk)->X))
1367                 llc_conn_ac_set_vs_nr(sk, skb);
1368         return 0;
1369 }
1370
1371 /*
1372  * Non-standard actions; these not contained in IEEE specification; for
1373  * our own usage
1374  */
1375 /**
1376  *      llc_conn_disc - removes connection from SAP list and frees it
1377  *      @sk: closed connection
1378  *      @skb: occurred event
1379  */
1380 int llc_conn_disc(struct sock *sk, struct sk_buff *skb)
1381 {
1382         /* FIXME: this thing seems to want to die */
1383         return 0;
1384 }
1385
1386 /**
1387  *      llc_conn_reset - resets connection
1388  *      @sk : reseting connection.
1389  *      @skb: occurred event.
1390  *
1391  *      Stop all timers, empty all queues and reset all flags.
1392  */
1393 int llc_conn_reset(struct sock *sk, struct sk_buff *skb)
1394 {
1395         llc_sk_reset(sk);
1396         return 0;
1397 }
1398
1399 /**
1400  *      llc_circular_between - designates that b is between a and c or not
1401  *      @a: lower bound
1402  *      @b: element to see if is between a and b
1403  *      @c: upper bound
1404  *
1405  *      This function designates that b is between a and c or not (for example,
1406  *      0 is between 127 and 1). Returns 1 if b is between a and c, 0
1407  *      otherwise.
1408  */
1409 u8 llc_circular_between(u8 a, u8 b, u8 c)
1410 {
1411         b = b - a;
1412         c = c - a;
1413         return b <= c;
1414 }
1415
1416 /**
1417  *      llc_process_tmr_ev - timer backend
1418  *      @sk: active connection
1419  *      @skb: occurred event
1420  *
1421  *      This function is called from timer callback functions. When connection
1422  *      is busy (during sending a data frame) timer expiration event must be
1423  *      queued. Otherwise this event can be sent to connection state machine.
1424  *      Queued events will process by llc_backlog_rcv function after sending
1425  *      data frame.
1426  */
1427 static void llc_process_tmr_ev(struct sock *sk, struct sk_buff *skb)
1428 {
1429         if (llc_sk(sk)->state == LLC_CONN_OUT_OF_SVC) {
1430                 printk(KERN_WARNING "%s: timer called on closed connection\n",
1431                        __FUNCTION__);
1432                 kfree_skb(skb);
1433         } else {
1434                 if (!sock_owned_by_user(sk))
1435                         llc_conn_state_process(sk, skb);
1436                 else {
1437                         llc_set_backlog_type(skb, LLC_EVENT);
1438                         sk_add_backlog(sk, skb);
1439                 }
1440         }
1441 }