net/llc/llc_c_ev.c

   1 /*
   2  * llc_c_ev.c - Connection component state transition event qualifiers
   3  *
   4  * A 'state' consists of a number of possible event matching functions,
   5  * the actions associated with each being executed when that event is
   6  * matched; a 'state machine' accepts events in a serial fashion from an
   7  * event queue. Each event is passed to each successive event matching
   8  * function until a match is made (the event matching function returns
   9  * success, or '0') or the list of event matching functions is exhausted.
  10  * If a match is made, the actions associated with the event are executed
  11  * and the state is changed to that event's transition state. Before some
  12  * events are recognized, even after a match has been made, a certain
  13  * number of 'event qualifier' functions must also be executed. If these
  14  * all execute successfully, then the event is finally executed.
  15  *
  16  * These event functions must return 0 for success, to show a matched
  17  * event, of 1 if the event does not match. Event qualifier functions
  18  * must return a 0 for success or a non-zero for failure. Each function
  19  * is simply responsible for verifying one single thing and returning
  20  * either a success or failure.
  21  *
  22  * All of followed event functions are described in 802.2 LLC Protocol
  23  * standard document except two functions that we added that will explain
  24  * in their comments, at below.
  25  *
  26  * Copyright (c) 1997 by Procom Technology, Inc.
  27  *               2001-2003 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  28  *
  29  * This program can be redistributed or modified under the terms of the
  30  * GNU General Public License as published by the Free Software Foundation.
  31  * This program is distributed without any warranty or implied warranty
  32  * of merchantability or fitness for a particular purpose.
  33  *
  34  * See the GNU General Public License for more details.
  35  */
  36 #include <linux/netdevice.h>
  37 #include <net/llc_conn.h>
  38 #include <net/llc_sap.h>
  39 #include <net/sock.h>
  40 #include <net/llc_c_ac.h>
  41 #include <net/llc_c_ev.h>
  42 #include <net/llc_pdu.h>
  43
  44 #if 1
  45 #define dprintk(args...) printk(KERN_DEBUG args)
  46 #else
  47 #define dprintk(args...)
  48 #endif
  49
  50 /**
  51  *      llc_util_ns_inside_rx_window - check if sequence number is in rx window
  52  *      @ns: sequence number of received pdu.
  53  *      @vr: sequence number which receiver expects to receive.
  54  *      @rw: receive window size of receiver.
  55  *
  56  *      Checks if sequence number of received PDU is in range of receive
  57  *      window. Returns 0 for success, 1 otherwise
  58  */
  59 static u16 llc_util_ns_inside_rx_window(u8 ns, u8 vr, u8 rw)
  60 {
  61         return !llc_circular_between(vr, ns,
  62                                      (vr + rw - 1) % LLC_2_SEQ_NBR_MODULO);
  63 }
  64
  65 /**
  66  *      llc_util_nr_inside_tx_window - check if sequence number is in tx window
  67  *      @sk: current connection.
  68  *      @nr: N(R) of received PDU.
  69  *
  70  *      This routine checks if N(R) of received PDU is in range of transmit
  71  *      window; on the other hand checks if received PDU acknowledges some
  72  *      outstanding PDUs that are in transmit window. Returns 0 for success, 1
  73  *      otherwise.
  74  */
  75 static u16 llc_util_nr_inside_tx_window(struct sock *sk, u8 nr)
  76 {
  77         u8 nr1, nr2;
  78         struct sk_buff *skb;
  79         struct llc_pdu_sn *pdu;
  80         struct llc_sock *llc = llc_sk(sk);
  81         int rc = 0;
  82
  83         if (llc->dev->flags & IFF_LOOPBACK)
  84                 goto out;
  85         rc = 1;
  86         if (skb_queue_empty(&llc->pdu_unack_q))
  87                 goto out;
  88         skb = skb_peek(&llc->pdu_unack_q);
  89         pdu = llc_pdu_sn_hdr(skb);
  90         nr1 = LLC_I_GET_NS(pdu);
  91         skb = skb_peek_tail(&llc->pdu_unack_q);
  92         pdu = llc_pdu_sn_hdr(skb);
  93         nr2 = LLC_I_GET_NS(pdu);
  94         rc = !llc_circular_between(nr1, nr, (nr2 + 1) % LLC_2_SEQ_NBR_MODULO);
  95 out:
  96         return rc;
  97 }
  98
  99 int llc_conn_ev_conn_req(struct sock *sk, struct sk_buff *skb)
 100 {
 101         const struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 102
 103         return ev->prim == LLC_CONN_PRIM &&
 104                ev->prim_type == LLC_PRIM_TYPE_REQ ? 0 : 1;
 105 }
 106
 107 int llc_conn_ev_data_req(struct sock *sk, struct sk_buff *skb)
 108 {
 109         const struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 110
 111         return ev->prim == LLC_DATA_PRIM &&
 112                ev->prim_type == LLC_PRIM_TYPE_REQ ? 0 : 1;
 113 }
 114
 115 int llc_conn_ev_disc_req(struct sock *sk, struct sk_buff *skb)
 116 {
 117         const struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 118
 119         return ev->prim == LLC_DISC_PRIM &&
 120                ev->prim_type == LLC_PRIM_TYPE_REQ ? 0 : 1;
 121 }
 122
 123 int llc_conn_ev_rst_req(struct sock *sk, struct sk_buff *skb)
 124 {
 125         const struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 126
 127         return ev->prim == LLC_RESET_PRIM &&
 128                ev->prim_type == LLC_PRIM_TYPE_REQ ? 0 : 1;
 129 }
 130
 131 int llc_conn_ev_local_busy_detected(struct sock *sk, struct sk_buff *skb)
 132 {
 133         const struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 134
 135         return ev->type == LLC_CONN_EV_TYPE_SIMPLE &&
 136                ev->prim_type == LLC_CONN_EV_LOCAL_BUSY_DETECTED ? 0 : 1;
 137 }
 138
 139 int llc_conn_ev_local_busy_cleared(struct sock *sk, struct sk_buff *skb)
 140 {
 141         const struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 142
 143         return ev->type == LLC_CONN_EV_TYPE_SIMPLE &&
 144                ev->prim_type == LLC_CONN_EV_LOCAL_BUSY_CLEARED ? 0 : 1;
 145 }
 146
 147 int llc_conn_ev_rx_bad_pdu(struct sock *sk, struct sk_buff *skb)
 148 {
 149         return 1;
 150 }
 151
 152 int llc_conn_ev_rx_disc_cmd_pbit_set_x(struct sock *sk, struct sk_buff *skb)
 153 {
 154         const struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
 155
 156         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_U(pdu) &&
 157                LLC_U_PDU_CMD(pdu) == LLC_2_PDU_CMD_DISC ? 0 : 1;
 158 }
 159
 160 int llc_conn_ev_rx_dm_rsp_fbit_set_x(struct sock *sk, struct sk_buff *skb)
 161 {
 162         const struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
 163
 164         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_U(pdu) &&
 165                LLC_U_PDU_RSP(pdu) == LLC_2_PDU_RSP_DM ? 0 : 1;
 166 }
 167
 168 int llc_conn_ev_rx_frmr_rsp_fbit_set_x(struct sock *sk, struct sk_buff *skb)
 169 {
 170         const struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
 171
 172         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_U(pdu) &&
 173                LLC_U_PDU_RSP(pdu) == LLC_2_PDU_RSP_FRMR ? 0 : 1;
 174 }
 175
 176 int llc_conn_ev_rx_i_cmd_pbit_set_0(struct sock *sk, struct sk_buff *skb)
 177 {
 178         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 179
 180         return llc_conn_space(sk, skb) &&
 181                LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_I(pdu) &&
 182                LLC_I_PF_IS_0(pdu) &&
 183                LLC_I_GET_NS(pdu) == llc_sk(sk)->vR ? 0 : 1;
 184 }
 185
 186 int llc_conn_ev_rx_i_cmd_pbit_set_1(struct sock *sk, struct sk_buff *skb)
 187 {
 188         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 189
 190         return llc_conn_space(sk, skb) &&
 191                LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_I(pdu) &&
 192                LLC_I_PF_IS_1(pdu) &&
 193                LLC_I_GET_NS(pdu) == llc_sk(sk)->vR ? 0 : 1;
 194 }
 195
 196 int llc_conn_ev_rx_i_cmd_pbit_set_0_unexpd_ns(struct sock *sk,
 197                                               struct sk_buff *skb)
 198 {
 199         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 200         const u8 vr = llc_sk(sk)->vR;
 201         const u8 ns = LLC_I_GET_NS(pdu);
 202
 203         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_I(pdu) &&
 204                LLC_I_PF_IS_0(pdu) && ns != vr &&
 205                !llc_util_ns_inside_rx_window(ns, vr, llc_sk(sk)->rw) ? 0 : 1;
 206 }
 207
 208 int llc_conn_ev_rx_i_cmd_pbit_set_1_unexpd_ns(struct sock *sk,
 209                                               struct sk_buff *skb)
 210 {
 211         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 212         const u8 vr = llc_sk(sk)->vR;
 213         const u8 ns = LLC_I_GET_NS(pdu);
 214
 215         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_I(pdu) &&
 216                LLC_I_PF_IS_1(pdu) && ns != vr &&
 217                !llc_util_ns_inside_rx_window(ns, vr, llc_sk(sk)->rw) ? 0 : 1;
 218 }
 219
 220 int llc_conn_ev_rx_i_cmd_pbit_set_x_inval_ns(struct sock *sk,
 221                                              struct sk_buff *skb)
 222 {
 223         const struct llc_pdu_sn * pdu = llc_pdu_sn_hdr(skb);
 224         const u8 vr = llc_sk(sk)->vR;
 225         const u8 ns = LLC_I_GET_NS(pdu);
 226         const u16 rc = LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_I(pdu) &&
 227                 ns != vr &&
 228                  llc_util_ns_inside_rx_window(ns, vr, llc_sk(sk)->rw) ? 0 : 1;
 229         if (!rc)
 230                 dprintk("%s: matched, state=%d, ns=%d, vr=%d\n",
 231                         __FUNCTION__, llc_sk(sk)->state, ns, vr);
 232         return rc;
 233 }
 234
 235 int llc_conn_ev_rx_i_rsp_fbit_set_0(struct sock *sk, struct sk_buff *skb)
 236 {
 237         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 238
 239         return llc_conn_space(sk, skb) &&
 240                LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_I(pdu) &&
 241                LLC_I_PF_IS_0(pdu) &&
 242                LLC_I_GET_NS(pdu) == llc_sk(sk)->vR ? 0 : 1;
 243 }
 244
 245 int llc_conn_ev_rx_i_rsp_fbit_set_1(struct sock *sk, struct sk_buff *skb)
 246 {
 247         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 248
 249         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_I(pdu) &&
 250                LLC_I_PF_IS_1(pdu) &&
 251                LLC_I_GET_NS(pdu) == llc_sk(sk)->vR ? 0 : 1;
 252 }
 253
 254 int llc_conn_ev_rx_i_rsp_fbit_set_x(struct sock *sk, struct sk_buff *skb)
 255 {
 256         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 257
 258         return llc_conn_space(sk, skb) &&
 259                LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_I(pdu) &&
 260                LLC_I_GET_NS(pdu) == llc_sk(sk)->vR ? 0 : 1;
 261 }
 262
 263 int llc_conn_ev_rx_i_rsp_fbit_set_0_unexpd_ns(struct sock *sk,
 264                                               struct sk_buff *skb)
 265 {
 266         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 267         const u8 vr = llc_sk(sk)->vR;
 268         const u8 ns = LLC_I_GET_NS(pdu);
 269
 270         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_I(pdu) &&
 271                LLC_I_PF_IS_0(pdu) && ns != vr &&
 272                !llc_util_ns_inside_rx_window(ns, vr, llc_sk(sk)->rw) ? 0 : 1;
 273 }
 274
 275 int llc_conn_ev_rx_i_rsp_fbit_set_1_unexpd_ns(struct sock *sk,
 276                                               struct sk_buff *skb)
 277 {
 278         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 279         const u8 vr = llc_sk(sk)->vR;
 280         const u8 ns = LLC_I_GET_NS(pdu);
 281
 282         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_I(pdu) &&
 283                LLC_I_PF_IS_1(pdu) && ns != vr &&
 284                !llc_util_ns_inside_rx_window(ns, vr, llc_sk(sk)->rw) ? 0 : 1;
 285 }
 286
 287 int llc_conn_ev_rx_i_rsp_fbit_set_x_unexpd_ns(struct sock *sk,
 288                                               struct sk_buff *skb)
 289 {
 290         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 291         const u8 vr = llc_sk(sk)->vR;
 292         const u8 ns = LLC_I_GET_NS(pdu);
 293
 294         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_I(pdu) && ns != vr &&
 295                !llc_util_ns_inside_rx_window(ns, vr, llc_sk(sk)->rw) ? 0 : 1;
 296 }
 297
 298 int llc_conn_ev_rx_i_rsp_fbit_set_x_inval_ns(struct sock *sk,
 299                                              struct sk_buff *skb)
 300 {
 301         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 302         const u8 vr = llc_sk(sk)->vR;
 303         const u8 ns = LLC_I_GET_NS(pdu);
 304         const u16 rc = LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_I(pdu) &&
 305                 ns != vr &&
 306                  llc_util_ns_inside_rx_window(ns, vr, llc_sk(sk)->rw) ? 0 : 1;
 307         if (!rc)
 308                 dprintk("%s: matched, state=%d, ns=%d, vr=%d\n",
 309                         __FUNCTION__, llc_sk(sk)->state, ns, vr);
 310         return rc;
 311 }
 312
 313 int llc_conn_ev_rx_rej_cmd_pbit_set_0(struct sock *sk, struct sk_buff *skb)
 314 {
 315         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 316
 317         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
 318                LLC_S_PF_IS_0(pdu) &&
 319                LLC_S_PDU_CMD(pdu) == LLC_2_PDU_CMD_REJ ? 0 : 1;
 320 }
 321
 322 int llc_conn_ev_rx_rej_cmd_pbit_set_1(struct sock *sk, struct sk_buff *skb)
 323 {
 324         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 325
 326         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
 327                LLC_S_PF_IS_1(pdu) &&
 328                LLC_S_PDU_CMD(pdu) == LLC_2_PDU_CMD_REJ ? 0 : 1;
 329 }
 330
 331 int llc_conn_ev_rx_rej_rsp_fbit_set_0(struct sock *sk, struct sk_buff *skb)
 332 {
 333         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 334
 335         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
 336                LLC_S_PF_IS_0(pdu) &&
 337                LLC_S_PDU_RSP(pdu) == LLC_2_PDU_RSP_REJ ? 0 : 1;
 338 }
 339
 340 int llc_conn_ev_rx_rej_rsp_fbit_set_1(struct sock *sk, struct sk_buff *skb)
 341 {
 342         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 343
 344         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
 345                LLC_S_PF_IS_1(pdu) &&
 346                LLC_S_PDU_RSP(pdu) == LLC_2_PDU_RSP_REJ ? 0 : 1;
 347 }
 348
 349 int llc_conn_ev_rx_rej_rsp_fbit_set_x(struct sock *sk, struct sk_buff *skb)
 350 {
 351         const struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
 352
 353         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
 354                LLC_S_PDU_RSP(pdu) == LLC_2_PDU_RSP_REJ ? 0 : 1;
 355 }
 356
 357 int llc_conn_ev_rx_rnr_cmd_pbit_set_0(struct sock *sk, struct sk_buff *skb)
 358 {
 359         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 360
 361         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
 362                LLC_S_PF_IS_0(pdu) &&
 363                LLC_S_PDU_CMD(pdu) == LLC_2_PDU_CMD_RNR ? 0 : 1;
 364 }
 365
 366 int llc_conn_ev_rx_rnr_cmd_pbit_set_1(struct sock *sk, struct sk_buff *skb)
 367 {
 368         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 369
 370         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
 371                LLC_S_PF_IS_1(pdu) &&
 372                LLC_S_PDU_CMD(pdu) == LLC_2_PDU_CMD_RNR ? 0 : 1;
 373 }
 374
 375 int llc_conn_ev_rx_rnr_rsp_fbit_set_0(struct sock *sk, struct sk_buff *skb)
 376 {
 377         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 378
 379         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
 380                LLC_S_PF_IS_0(pdu) &&
 381                LLC_S_PDU_RSP(pdu) == LLC_2_PDU_RSP_RNR ? 0 : 1;
 382 }
 383
 384 int llc_conn_ev_rx_rnr_rsp_fbit_set_1(struct sock *sk, struct sk_buff *skb)
 385 {
 386         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 387
 388         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
 389                LLC_S_PF_IS_1(pdu) &&
 390                LLC_S_PDU_RSP(pdu) == LLC_2_PDU_RSP_RNR ? 0 : 1;
 391 }
 392
 393 int llc_conn_ev_rx_rr_cmd_pbit_set_0(struct sock *sk, struct sk_buff *skb)
 394 {
 395         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 396
 397         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
 398                LLC_S_PF_IS_0(pdu) &&
 399                LLC_S_PDU_CMD(pdu) == LLC_2_PDU_CMD_RR ? 0 : 1;
 400 }
 401
 402 int llc_conn_ev_rx_rr_cmd_pbit_set_1(struct sock *sk, struct sk_buff *skb)
 403 {
 404         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 405
 406         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
 407                LLC_S_PF_IS_1(pdu) &&
 408                LLC_S_PDU_CMD(pdu) == LLC_2_PDU_CMD_RR ? 0 : 1;
 409 }
 410
 411 int llc_conn_ev_rx_rr_rsp_fbit_set_0(struct sock *sk, struct sk_buff *skb)
 412 {
 413         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 414
 415         return llc_conn_space(sk, skb) &&
 416                LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
 417                LLC_S_PF_IS_0(pdu) &&
 418                LLC_S_PDU_RSP(pdu) == LLC_2_PDU_RSP_RR ? 0 : 1;
 419 }
 420
 421 int llc_conn_ev_rx_rr_rsp_fbit_set_1(struct sock *sk, struct sk_buff *skb)
 422 {
 423         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 424
 425         return llc_conn_space(sk, skb) &&
 426                LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
 427                LLC_S_PF_IS_1(pdu) &&
 428                LLC_S_PDU_RSP(pdu) == LLC_2_PDU_RSP_RR ? 0 : 1;
 429 }
 430
 431 int llc_conn_ev_rx_sabme_cmd_pbit_set_x(struct sock *sk, struct sk_buff *skb)
 432 {
 433         const struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
 434
 435         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_U(pdu) &&
 436                LLC_U_PDU_CMD(pdu) == LLC_2_PDU_CMD_SABME ? 0 : 1;
 437 }
 438
 439 int llc_conn_ev_rx_ua_rsp_fbit_set_x(struct sock *sk, struct sk_buff *skb)
 440 {
 441         struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
 442
 443         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_U(pdu) &&
 444                LLC_U_PDU_RSP(pdu) == LLC_2_PDU_RSP_UA ? 0 : 1;
 445 }
 446
 447 int llc_conn_ev_rx_xxx_cmd_pbit_set_1(struct sock *sk, struct sk_buff *skb)
 448 {
 449         u16 rc = 1;
 450         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 451
 452         if (LLC_PDU_IS_CMD(pdu)) {
 453                 if (LLC_PDU_TYPE_IS_I(pdu) || LLC_PDU_TYPE_IS_S(pdu)) {
 454                         if (LLC_I_PF_IS_1(pdu))
 455                                 rc = 0;
 456                 } else if (LLC_PDU_TYPE_IS_U(pdu) && LLC_U_PF_IS_1(pdu))
 457                         rc = 0;
 458         }
 459         return rc;
 460 }
 461
 462 int llc_conn_ev_rx_xxx_cmd_pbit_set_x(struct sock *sk, struct sk_buff *skb)
 463 {
 464         u16 rc = 1;
 465         const struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
 466
 467         if (LLC_PDU_IS_CMD(pdu)) {
 468                 if (LLC_PDU_TYPE_IS_I(pdu) || LLC_PDU_TYPE_IS_S(pdu))
 469                         rc = 0;
 470                 else if (LLC_PDU_TYPE_IS_U(pdu))
 471                         switch (LLC_U_PDU_CMD(pdu)) {
 472                         case LLC_2_PDU_CMD_SABME:
 473                         case LLC_2_PDU_CMD_DISC:
 474                                 rc = 0;
 475                                 break;
 476                         }
 477         }
 478         return rc;
 479 }
 480
 481 int llc_conn_ev_rx_xxx_rsp_fbit_set_x(struct sock *sk, struct sk_buff *skb)
 482 {
 483         u16 rc = 1;
 484         const struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
 485
 486         if (LLC_PDU_IS_RSP(pdu)) {
 487                 if (LLC_PDU_TYPE_IS_I(pdu) || LLC_PDU_TYPE_IS_S(pdu))
 488                         rc = 0;
 489                 else if (LLC_PDU_TYPE_IS_U(pdu))
 490                         switch (LLC_U_PDU_RSP(pdu)) {
 491                         case LLC_2_PDU_RSP_UA:
 492                         case LLC_2_PDU_RSP_DM:
 493                         case LLC_2_PDU_RSP_FRMR:
 494                                 rc = 0;
 495                                 break;
 496                         }
 497         }
 498
 499         return rc;
 500 }
 501
 502 int llc_conn_ev_rx_zzz_cmd_pbit_set_x_inval_nr(struct sock *sk,
 503                                                struct sk_buff *skb)
 504 {
 505         u16 rc = 1;
 506         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 507         const u8 vs = llc_sk(sk)->vS;
 508         const u8 nr = LLC_I_GET_NR(pdu);
 509
 510         if (LLC_PDU_IS_CMD(pdu) &&
 511             (LLC_PDU_TYPE_IS_I(pdu) || LLC_PDU_TYPE_IS_S(pdu)) &&
 512             nr != vs && llc_util_nr_inside_tx_window(sk, nr)) {
 513                 dprintk("%s: matched, state=%d, vs=%d, nr=%d\n",
 514                         __FUNCTION__, llc_sk(sk)->state, vs, nr);
 515                 rc = 0;
 516         }
 517         return rc;
 518 }
 519
 520 int llc_conn_ev_rx_zzz_rsp_fbit_set_x_inval_nr(struct sock *sk,
 521                                                struct sk_buff *skb)
 522 {
 523         u16 rc = 1;
 524         const struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
 525         const u8 vs = llc_sk(sk)->vS;
 526         const u8 nr = LLC_I_GET_NR(pdu);
 527
 528         if (LLC_PDU_IS_RSP(pdu) &&
 529             (LLC_PDU_TYPE_IS_I(pdu) || LLC_PDU_TYPE_IS_S(pdu)) &&
 530             nr != vs && llc_util_nr_inside_tx_window(sk, nr)) {
 531                 rc = 0;
 532                 dprintk("%s: matched, state=%d, vs=%d, nr=%d\n",
 533                         __FUNCTION__, llc_sk(sk)->state, vs, nr);
 534         }
 535         return rc;
 536 }
 537
 538 int llc_conn_ev_rx_any_frame(struct sock *sk, struct sk_buff *skb)
 539 {
 540         return 0;
 541 }
 542
 543 int llc_conn_ev_p_tmr_exp(struct sock *sk, struct sk_buff *skb)
 544 {
 545         const struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 546
 547         return ev->type != LLC_CONN_EV_TYPE_P_TMR;
 548 }
 549
 550 int llc_conn_ev_ack_tmr_exp(struct sock *sk, struct sk_buff *skb)
 551 {
 552         const struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 553
 554         return ev->type != LLC_CONN_EV_TYPE_ACK_TMR;
 555 }
 556
 557 int llc_conn_ev_rej_tmr_exp(struct sock *sk, struct sk_buff *skb)
 558 {
 559         const struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 560
 561         return ev->type != LLC_CONN_EV_TYPE_REJ_TMR;
 562 }
 563
 564 int llc_conn_ev_busy_tmr_exp(struct sock *sk, struct sk_buff *skb)
 565 {
 566         const struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 567
 568         return ev->type != LLC_CONN_EV_TYPE_BUSY_TMR;
 569 }
 570
 571 int llc_conn_ev_init_p_f_cycle(struct sock *sk, struct sk_buff *skb)
 572 {
 573         return 1;
 574 }
 575
 576 int llc_conn_ev_tx_buffer_full(struct sock *sk, struct sk_buff *skb)
 577 {
 578         const struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 579
 580         return ev->type == LLC_CONN_EV_TYPE_SIMPLE &&
 581                ev->prim_type == LLC_CONN_EV_TX_BUFF_FULL ? 0 : 1;
 582 }
 583
 584 /* Event qualifier functions
 585  *
 586  * these functions simply verify the value of a state flag associated with
 587  * the connection and return either a 0 for success or a non-zero value
 588  * for not-success; verify the event is the type we expect
 589  */
 590 int llc_conn_ev_qlfy_data_flag_eq_1(struct sock *sk, struct sk_buff *skb)
 591 {
 592         return llc_sk(sk)->data_flag != 1;
 593 }
 594
 595 int llc_conn_ev_qlfy_data_flag_eq_0(struct sock *sk, struct sk_buff *skb)
 596 {
 597         return llc_sk(sk)->data_flag;
 598 }
 599
 600 int llc_conn_ev_qlfy_data_flag_eq_2(struct sock *sk, struct sk_buff *skb)
 601 {
 602         return llc_sk(sk)->data_flag != 2;
 603 }
 604
 605 int llc_conn_ev_qlfy_p_flag_eq_1(struct sock *sk, struct sk_buff *skb)
 606 {
 607         return llc_sk(sk)->p_flag != 1;
 608 }
 609
 610 /**
 611  *      conn_ev_qlfy_last_frame_eq_1 - checks if frame is last in tx window
 612  *      @sk: current connection structure.
 613  *      @skb: current event.
 614  *
 615  *      This function determines when frame which is sent, is last frame of
 616  *      transmit window, if it is then this function return zero else return
 617  *      one.  This function is used for sending last frame of transmit window
 618  *      as I-format command with p-bit set to one. Returns 0 if frame is last
 619  *      frame, 1 otherwise.
 620  */
 621 int llc_conn_ev_qlfy_last_frame_eq_1(struct sock *sk, struct sk_buff *skb)
 622 {
 623         return !(skb_queue_len(&llc_sk(sk)->pdu_unack_q) + 1 == llc_sk(sk)->k);
 624 }
 625
 626 /**
 627  *      conn_ev_qlfy_last_frame_eq_0 - checks if frame isn't last in tx window
 628  *      @sk: current connection structure.
 629  *      @skb: current event.
 630  *
 631  *      This function determines when frame which is sent, isn't last frame of
 632  *      transmit window, if it isn't then this function return zero else return
 633  *      one. Returns 0 if frame isn't last frame, 1 otherwise.
 634  */
 635 int llc_conn_ev_qlfy_last_frame_eq_0(struct sock *sk, struct sk_buff *skb)
 636 {
 637         return skb_queue_len(&llc_sk(sk)->pdu_unack_q) + 1 == llc_sk(sk)->k;
 638 }
 639
 640 int llc_conn_ev_qlfy_p_flag_eq_0(struct sock *sk, struct sk_buff *skb)
 641 {
 642         return llc_sk(sk)->p_flag;
 643 }
 644
 645 int llc_conn_ev_qlfy_p_flag_eq_f(struct sock *sk, struct sk_buff *skb)
 646 {
 647         u8 f_bit;
 648
 649         llc_pdu_decode_pf_bit(skb, &f_bit);
 650         return llc_sk(sk)->p_flag == f_bit ? 0 : 1;
 651 }
 652
 653 int llc_conn_ev_qlfy_remote_busy_eq_0(struct sock *sk, struct sk_buff *skb)
 654 {
 655         return llc_sk(sk)->remote_busy_flag;
 656 }
 657
 658 int llc_conn_ev_qlfy_remote_busy_eq_1(struct sock *sk, struct sk_buff *skb)
 659 {
 660         return !llc_sk(sk)->remote_busy_flag;
 661 }
 662
 663 int llc_conn_ev_qlfy_retry_cnt_lt_n2(struct sock *sk, struct sk_buff *skb)
 664 {
 665         return !(llc_sk(sk)->retry_count < llc_sk(sk)->n2);
 666 }
 667
 668 int llc_conn_ev_qlfy_retry_cnt_gte_n2(struct sock *sk, struct sk_buff *skb)
 669 {
 670         return !(llc_sk(sk)->retry_count >= llc_sk(sk)->n2);
 671 }
 672
 673 int llc_conn_ev_qlfy_s_flag_eq_1(struct sock *sk, struct sk_buff *skb)
 674 {
 675         return !llc_sk(sk)->s_flag;
 676 }
 677
 678 int llc_conn_ev_qlfy_s_flag_eq_0(struct sock *sk, struct sk_buff *skb)
 679 {
 680         return llc_sk(sk)->s_flag;
 681 }
 682
 683 int llc_conn_ev_qlfy_cause_flag_eq_1(struct sock *sk, struct sk_buff *skb)
 684 {
 685         return !llc_sk(sk)->cause_flag;
 686 }
 687
 688 int llc_conn_ev_qlfy_cause_flag_eq_0(struct sock *sk, struct sk_buff *skb)
 689 {
 690         return llc_sk(sk)->cause_flag;
 691 }
 692
 693 int llc_conn_ev_qlfy_set_status_conn(struct sock *sk, struct sk_buff *skb)
 694 {
 695         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 696
 697         ev->status = LLC_STATUS_CONN;
 698         return 0;
 699 }
 700
 701 int llc_conn_ev_qlfy_set_status_disc(struct sock *sk, struct sk_buff *skb)
 702 {
 703         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 704
 705         ev->status = LLC_STATUS_DISC;
 706         return 0;
 707 }
 708
 709 int llc_conn_ev_qlfy_set_status_failed(struct sock *sk, struct sk_buff *skb)
 710 {
 711         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 712
 713         ev->status = LLC_STATUS_FAILED;
 714         return 0;
 715 }
 716
 717 int llc_conn_ev_qlfy_set_status_remote_busy(struct sock *sk,
 718                                             struct sk_buff *skb)
 719 {
 720         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 721
 722         ev->status = LLC_STATUS_REMOTE_BUSY;
 723         return 0;
 724 }
 725
 726 int llc_conn_ev_qlfy_set_status_refuse(struct sock *sk, struct sk_buff *skb)
 727 {
 728         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 729
 730         ev->status = LLC_STATUS_REFUSE;
 731         return 0;
 732 }
 733
 734 int llc_conn_ev_qlfy_set_status_conflict(struct sock *sk, struct sk_buff *skb)
 735 {
 736         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 737
 738         ev->status = LLC_STATUS_CONFLICT;
 739         return 0;
 740 }
 741
 742 int llc_conn_ev_qlfy_set_status_rst_done(struct sock *sk, struct sk_buff *skb)
 743 {
 744         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
 745
 746         ev->status = LLC_STATUS_RESET_DONE;
 747         return 0;
 748 }