[LLC]: introduce llc_conn_tmr_common_cb, to avoid code duplication
[linux-3.10.git] / 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_ev.h>
41 #include <net/llc_pdu.h>
42
43 #if 1
44 #define dprintk(args...) printk(KERN_DEBUG args)
45 #else
46 #define dprintk(args...)
47 #endif
48
49 extern u16 llc_circular_between(u8 a, u8 b, u8 c);
50
51 /**
52  *      llc_util_ns_inside_rx_window - check if sequence number is in rx window
53  *      @ns: sequence number of received pdu.
54  *      @vr: sequence number which receiver expects to receive.
55  *      @rw: receive window size of receiver.
56  *
57  *      Checks if sequence number of received PDU is in range of receive
58  *      window. Returns 0 for success, 1 otherwise
59  */
60 static u16 llc_util_ns_inside_rx_window(u8 ns, u8 vr, u8 rw)
61 {
62         return !llc_circular_between(vr, ns,
63                                      (vr + rw - 1) % LLC_2_SEQ_NBR_MODULO);
64 }
65
66 /**
67  *      llc_util_nr_inside_tx_window - check if sequence number is in tx window
68  *      @sk: current connection.
69  *      @nr: N(R) of received PDU.
70  *
71  *      This routine checks if N(R) of received PDU is in range of transmit
72  *      window; on the other hand checks if received PDU acknowledges some
73  *      outstanding PDUs that are in transmit window. Returns 0 for success, 1
74  *      otherwise.
75  */
76 static u16 llc_util_nr_inside_tx_window(struct sock *sk, u8 nr)
77 {
78         u8 nr1, nr2;
79         struct sk_buff *skb;
80         struct llc_pdu_sn *pdu;
81         struct llc_sock *llc = llc_sk(sk);
82         int rc = 0;
83
84         if (llc->dev->flags & IFF_LOOPBACK)
85                 goto out;
86         rc = 1;
87         if (skb_queue_empty(&llc->pdu_unack_q))
88                 goto out;
89         skb = skb_peek(&llc->pdu_unack_q);
90         pdu = llc_pdu_sn_hdr(skb);
91         nr1 = LLC_I_GET_NS(pdu);
92         skb = skb_peek_tail(&llc->pdu_unack_q);
93         pdu = llc_pdu_sn_hdr(skb);
94         nr2 = LLC_I_GET_NS(pdu);
95         rc = !llc_circular_between(nr1, nr, (nr2 + 1) % LLC_2_SEQ_NBR_MODULO);
96 out:
97         return rc;
98 }
99
100 int llc_conn_ev_conn_req(struct sock *sk, struct sk_buff *skb)
101 {
102         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
103
104         return ev->prim == LLC_CONN_PRIM &&
105                ev->prim_type == LLC_PRIM_TYPE_REQ ? 0 : 1;
106 }
107
108 int llc_conn_ev_data_req(struct sock *sk, struct sk_buff *skb)
109 {
110         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
111
112         return ev->prim == LLC_DATA_PRIM &&
113                ev->prim_type == LLC_PRIM_TYPE_REQ ? 0 : 1;
114 }
115
116 int llc_conn_ev_disc_req(struct sock *sk, struct sk_buff *skb)
117 {
118         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
119
120         return ev->prim == LLC_DISC_PRIM &&
121                ev->prim_type == LLC_PRIM_TYPE_REQ ? 0 : 1;
122 }
123
124 int llc_conn_ev_rst_req(struct sock *sk, struct sk_buff *skb)
125 {
126         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
127
128         return ev->prim == LLC_RESET_PRIM &&
129                ev->prim_type == LLC_PRIM_TYPE_REQ ? 0 : 1;
130 }
131
132 int llc_conn_ev_local_busy_detected(struct sock *sk, struct sk_buff *skb)
133 {
134         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
135
136         return ev->type == LLC_CONN_EV_TYPE_SIMPLE &&
137                ev->prim_type == LLC_CONN_EV_LOCAL_BUSY_DETECTED ? 0 : 1;
138 }
139
140 int llc_conn_ev_local_busy_cleared(struct sock *sk, struct sk_buff *skb)
141 {
142         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
143
144         return ev->type == LLC_CONN_EV_TYPE_SIMPLE &&
145                ev->prim_type == LLC_CONN_EV_LOCAL_BUSY_CLEARED ? 0 : 1;
146 }
147
148 int llc_conn_ev_rx_bad_pdu(struct sock *sk, struct sk_buff *skb)
149 {
150         return 1;
151 }
152
153 int llc_conn_ev_rx_disc_cmd_pbit_set_x(struct sock *sk, struct sk_buff *skb)
154 {
155         struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
156
157         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_U(pdu) &&
158                LLC_U_PDU_CMD(pdu) == LLC_2_PDU_CMD_DISC ? 0 : 1;
159 }
160
161 int llc_conn_ev_rx_dm_rsp_fbit_set_x(struct sock *sk, struct sk_buff *skb)
162 {
163         struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
164
165         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_U(pdu) &&
166                LLC_U_PDU_RSP(pdu) == LLC_2_PDU_RSP_DM ? 0 : 1;
167 }
168
169 int llc_conn_ev_rx_frmr_rsp_fbit_set_x(struct sock *sk, struct sk_buff *skb)
170 {
171         struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
172
173         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_U(pdu) &&
174                LLC_U_PDU_RSP(pdu) == LLC_2_PDU_RSP_FRMR ? 0 : 1;
175 }
176
177 int llc_conn_ev_rx_i_cmd_pbit_set_0(struct sock *sk, struct sk_buff *skb)
178 {
179         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
180
181         return llc_conn_space(sk, skb) &&
182                LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_I(pdu) &&
183                LLC_I_PF_IS_0(pdu) &&
184                LLC_I_GET_NS(pdu) == llc_sk(sk)->vR ? 0 : 1;
185 }
186
187 int llc_conn_ev_rx_i_cmd_pbit_set_1(struct sock *sk, struct sk_buff *skb)
188 {
189         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
190
191         return llc_conn_space(sk, skb) &&
192                LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_I(pdu) &&
193                LLC_I_PF_IS_1(pdu) &&
194                LLC_I_GET_NS(pdu) == llc_sk(sk)->vR ? 0 : 1;
195 }
196
197 int llc_conn_ev_rx_i_cmd_pbit_set_0_unexpd_ns(struct sock *sk,
198                                               struct sk_buff *skb)
199 {
200         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
201         u8 vr = llc_sk(sk)->vR;
202         u8 ns = LLC_I_GET_NS(pdu);
203
204         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_I(pdu) &&
205                LLC_I_PF_IS_0(pdu) && ns != vr &&
206                !llc_util_ns_inside_rx_window(ns, vr, llc_sk(sk)->rw) ? 0 : 1;
207 }
208
209 int llc_conn_ev_rx_i_cmd_pbit_set_1_unexpd_ns(struct sock *sk,
210                                               struct sk_buff *skb)
211 {
212         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
213         u8 vr = llc_sk(sk)->vR;
214         u8 ns = LLC_I_GET_NS(pdu);
215
216         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_I(pdu) &&
217                LLC_I_PF_IS_1(pdu) && ns != vr &&
218                !llc_util_ns_inside_rx_window(ns, vr, llc_sk(sk)->rw) ? 0 : 1;
219 }
220
221 int llc_conn_ev_rx_i_cmd_pbit_set_x_inval_ns(struct sock *sk,
222                                              struct sk_buff *skb)
223 {
224         struct llc_pdu_sn * pdu = llc_pdu_sn_hdr(skb);
225         u8 vr = llc_sk(sk)->vR;
226         u8 ns = LLC_I_GET_NS(pdu);
227         u16 rc = LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_I(pdu) && 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         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         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         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         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
267         u8 vr = llc_sk(sk)->vR;
268         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         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
279         u8 vr = llc_sk(sk)->vR;
280         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         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
291         u8 vr = llc_sk(sk)->vR;
292         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         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
302         u8 vr = llc_sk(sk)->vR;
303         u8 ns = LLC_I_GET_NS(pdu);
304         u16 rc = LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_I(pdu) && ns != vr &&
305                  llc_util_ns_inside_rx_window(ns, vr, llc_sk(sk)->rw) ? 0 : 1;
306         if (!rc)
307                 dprintk("%s: matched, state=%d, ns=%d, vr=%d\n",
308                         __FUNCTION__, llc_sk(sk)->state, ns, vr);
309         return rc;
310 }
311
312 int llc_conn_ev_rx_rej_cmd_pbit_set_0(struct sock *sk, struct sk_buff *skb)
313 {
314         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
315
316         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
317                LLC_S_PF_IS_0(pdu) &&
318                LLC_S_PDU_CMD(pdu) == LLC_2_PDU_CMD_REJ ? 0 : 1;
319 }
320
321 int llc_conn_ev_rx_rej_cmd_pbit_set_1(struct sock *sk, struct sk_buff *skb)
322 {
323         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
324
325         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
326                LLC_S_PF_IS_1(pdu) &&
327                LLC_S_PDU_CMD(pdu) == LLC_2_PDU_CMD_REJ ? 0 : 1;
328 }
329
330 int llc_conn_ev_rx_rej_rsp_fbit_set_0(struct sock *sk, struct sk_buff *skb)
331 {
332         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
333
334         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
335                LLC_S_PF_IS_0(pdu) &&
336                LLC_S_PDU_RSP(pdu) == LLC_2_PDU_RSP_REJ ? 0 : 1;
337 }
338
339 int llc_conn_ev_rx_rej_rsp_fbit_set_1(struct sock *sk, struct sk_buff *skb)
340 {
341         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
342
343         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
344                LLC_S_PF_IS_1(pdu) &&
345                LLC_S_PDU_RSP(pdu) == LLC_2_PDU_RSP_REJ ? 0 : 1;
346 }
347
348 int llc_conn_ev_rx_rej_rsp_fbit_set_x(struct sock *sk, struct sk_buff *skb)
349 {
350         struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
351
352         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
353                LLC_S_PDU_RSP(pdu) == LLC_2_PDU_RSP_REJ ? 0 : 1;
354 }
355
356 int llc_conn_ev_rx_rnr_cmd_pbit_set_0(struct sock *sk, struct sk_buff *skb)
357 {
358         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
359
360         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
361                LLC_S_PF_IS_0(pdu) &&
362                LLC_S_PDU_CMD(pdu) == LLC_2_PDU_CMD_RNR ? 0 : 1;
363 }
364
365 int llc_conn_ev_rx_rnr_cmd_pbit_set_1(struct sock *sk, struct sk_buff *skb)
366 {
367         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
368
369         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
370                LLC_S_PF_IS_1(pdu) &&
371                LLC_S_PDU_CMD(pdu) == LLC_2_PDU_CMD_RNR ? 0 : 1;
372 }
373
374 int llc_conn_ev_rx_rnr_rsp_fbit_set_0(struct sock *sk, struct sk_buff *skb)
375 {
376         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
377
378         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
379                LLC_S_PF_IS_0(pdu) &&
380                LLC_S_PDU_RSP(pdu) == LLC_2_PDU_RSP_RNR ? 0 : 1;
381 }
382
383 int llc_conn_ev_rx_rnr_rsp_fbit_set_1(struct sock *sk, struct sk_buff *skb)
384 {
385         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
386
387         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
388                LLC_S_PF_IS_1(pdu) &&
389                LLC_S_PDU_RSP(pdu) == LLC_2_PDU_RSP_RNR ? 0 : 1;
390 }
391
392 int llc_conn_ev_rx_rr_cmd_pbit_set_0(struct sock *sk, struct sk_buff *skb)
393 {
394         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
395
396         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
397                LLC_S_PF_IS_0(pdu) &&
398                LLC_S_PDU_CMD(pdu) == LLC_2_PDU_CMD_RR ? 0 : 1;
399 }
400
401 int llc_conn_ev_rx_rr_cmd_pbit_set_1(struct sock *sk, struct sk_buff *skb)
402 {
403         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
404
405         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
406                LLC_S_PF_IS_1(pdu) &&
407                LLC_S_PDU_CMD(pdu) == LLC_2_PDU_CMD_RR ? 0 : 1;
408 }
409
410 int llc_conn_ev_rx_rr_rsp_fbit_set_0(struct sock *sk, struct sk_buff *skb)
411 {
412         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
413
414         return llc_conn_space(sk, skb) &&
415                LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
416                LLC_S_PF_IS_0(pdu) &&
417                LLC_S_PDU_RSP(pdu) == LLC_2_PDU_RSP_RR ? 0 : 1;
418 }
419
420 int llc_conn_ev_rx_rr_rsp_fbit_set_1(struct sock *sk, struct sk_buff *skb)
421 {
422         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
423
424         return llc_conn_space(sk, skb) &&
425                LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_S(pdu) &&
426                LLC_S_PF_IS_1(pdu) &&
427                LLC_S_PDU_RSP(pdu) == LLC_2_PDU_RSP_RR ? 0 : 1;
428 }
429
430 int llc_conn_ev_rx_sabme_cmd_pbit_set_x(struct sock *sk, struct sk_buff *skb)
431 {
432         struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
433
434         return LLC_PDU_IS_CMD(pdu) && LLC_PDU_TYPE_IS_U(pdu) &&
435                LLC_U_PDU_CMD(pdu) == LLC_2_PDU_CMD_SABME ? 0 : 1;
436 }
437
438 int llc_conn_ev_rx_ua_rsp_fbit_set_x(struct sock *sk, struct sk_buff *skb)
439 {
440         struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
441
442         return LLC_PDU_IS_RSP(pdu) && LLC_PDU_TYPE_IS_U(pdu) &&
443                LLC_U_PDU_RSP(pdu) == LLC_2_PDU_RSP_UA ? 0 : 1;
444 }
445
446 int llc_conn_ev_rx_xxx_cmd_pbit_set_1(struct sock *sk, struct sk_buff *skb)
447 {
448         u16 rc = 1;
449         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
450
451         if (LLC_PDU_IS_CMD(pdu)) {
452                 if (LLC_PDU_TYPE_IS_I(pdu) || LLC_PDU_TYPE_IS_S(pdu)) {
453                         if (LLC_I_PF_IS_1(pdu))
454                                 rc = 0;
455                 } else if (LLC_PDU_TYPE_IS_U(pdu) && LLC_U_PF_IS_1(pdu))
456                         rc = 0;
457         }
458         return rc;
459 }
460
461 int llc_conn_ev_rx_xxx_cmd_pbit_set_x(struct sock *sk, struct sk_buff *skb)
462 {
463         u16 rc = 1;
464         struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
465
466         if (LLC_PDU_IS_CMD(pdu)) {
467                 if (LLC_PDU_TYPE_IS_I(pdu) || LLC_PDU_TYPE_IS_S(pdu))
468                         rc = 0;
469                 else if (LLC_PDU_TYPE_IS_U(pdu))
470                         switch (LLC_U_PDU_CMD(pdu)) {
471                         case LLC_2_PDU_CMD_SABME:
472                         case LLC_2_PDU_CMD_DISC:
473                                 rc = 0;
474                                 break;
475                         }
476         }
477         return rc;
478 }
479
480 int llc_conn_ev_rx_xxx_rsp_fbit_set_1(struct sock *sk, struct sk_buff *skb)
481 {
482         u16 rc = 1;
483         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
484
485         if (LLC_PDU_IS_RSP(pdu)) {
486                 if (LLC_PDU_TYPE_IS_I(pdu) || LLC_PDU_TYPE_IS_S(pdu)) {
487                         if (LLC_I_PF_IS_1(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                                 if (LLC_U_PF_IS_1(pdu))
495                                         rc = 0;
496                                 break;
497                         }
498         }
499         return rc;
500 }
501
502 int llc_conn_ev_rx_xxx_rsp_fbit_set_x(struct sock *sk, struct sk_buff *skb)
503 {
504         u16 rc = 1;
505         struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
506
507         if (LLC_PDU_IS_RSP(pdu)) {
508                 if (LLC_PDU_TYPE_IS_I(pdu) || LLC_PDU_TYPE_IS_S(pdu))
509                         rc = 0;
510                 else if (LLC_PDU_TYPE_IS_U(pdu))
511                         switch (LLC_U_PDU_RSP(pdu)) {
512                         case LLC_2_PDU_RSP_UA:
513                         case LLC_2_PDU_RSP_DM:
514                         case LLC_2_PDU_RSP_FRMR:
515                                 rc = 0;
516                                 break;
517                         }
518         }
519
520         return rc;
521 }
522
523 int llc_conn_ev_rx_zzz_cmd_pbit_set_x_inval_nr(struct sock *sk,
524                                                struct sk_buff *skb)
525 {
526         u16 rc = 1;
527         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
528         u8 vs = llc_sk(sk)->vS;
529         u8 nr = LLC_I_GET_NR(pdu);
530
531         if (LLC_PDU_IS_CMD(pdu) &&
532             (LLC_PDU_TYPE_IS_I(pdu) || LLC_PDU_TYPE_IS_S(pdu)) &&
533             nr != vs && llc_util_nr_inside_tx_window(sk, nr)) {
534                 dprintk("%s: matched, state=%d, vs=%d, nr=%d\n",
535                         __FUNCTION__, llc_sk(sk)->state, vs, nr);
536                 rc = 0;
537         }
538         return rc;
539 }
540
541 int llc_conn_ev_rx_zzz_rsp_fbit_set_x_inval_nr(struct sock *sk,
542                                                struct sk_buff *skb)
543 {
544         u16 rc = 1;
545         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
546         u8 vs = llc_sk(sk)->vS;
547         u8 nr = LLC_I_GET_NR(pdu);
548
549         if (LLC_PDU_IS_RSP(pdu) &&
550             (LLC_PDU_TYPE_IS_I(pdu) || LLC_PDU_TYPE_IS_S(pdu)) &&
551             nr != vs && llc_util_nr_inside_tx_window(sk, nr)) {
552                 rc = 0;
553                 dprintk("%s: matched, state=%d, vs=%d, nr=%d\n",
554                         __FUNCTION__, llc_sk(sk)->state, vs, nr);
555         }
556         return rc;
557 }
558
559 int llc_conn_ev_rx_any_frame(struct sock *sk, struct sk_buff *skb)
560 {
561         return 0;
562 }
563
564 int llc_conn_ev_p_tmr_exp(struct sock *sk, struct sk_buff *skb)
565 {
566         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
567
568         return ev->type != LLC_CONN_EV_TYPE_P_TMR;
569 }
570
571 int llc_conn_ev_ack_tmr_exp(struct sock *sk, struct sk_buff *skb)
572 {
573         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
574
575         return ev->type != LLC_CONN_EV_TYPE_ACK_TMR;
576 }
577
578 int llc_conn_ev_rej_tmr_exp(struct sock *sk, struct sk_buff *skb)
579 {
580         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
581
582         return ev->type != LLC_CONN_EV_TYPE_REJ_TMR;
583 }
584
585 int llc_conn_ev_busy_tmr_exp(struct sock *sk, struct sk_buff *skb)
586 {
587         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
588
589         return ev->type != LLC_CONN_EV_TYPE_BUSY_TMR;
590 }
591
592 int llc_conn_ev_init_p_f_cycle(struct sock *sk, struct sk_buff *skb)
593 {
594         return 1;
595 }
596
597 int llc_conn_ev_tx_buffer_full(struct sock *sk, struct sk_buff *skb)
598 {
599         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
600
601         return ev->type == LLC_CONN_EV_TYPE_SIMPLE &&
602                ev->prim_type == LLC_CONN_EV_TX_BUFF_FULL ? 0 : 1;
603 }
604
605 /* Event qualifier functions
606  *
607  * these functions simply verify the value of a state flag associated with
608  * the connection and return either a 0 for success or a non-zero value
609  * for not-success; verify the event is the type we expect
610  */
611 int llc_conn_ev_qlfy_data_flag_eq_1(struct sock *sk, struct sk_buff *skb)
612 {
613         return llc_sk(sk)->data_flag != 1;
614 }
615
616 int llc_conn_ev_qlfy_data_flag_eq_0(struct sock *sk, struct sk_buff *skb)
617 {
618         return llc_sk(sk)->data_flag;
619 }
620
621 int llc_conn_ev_qlfy_data_flag_eq_2(struct sock *sk, struct sk_buff *skb)
622 {
623         return llc_sk(sk)->data_flag != 2;
624 }
625
626 int llc_conn_ev_qlfy_p_flag_eq_1(struct sock *sk, struct sk_buff *skb)
627 {
628         return llc_sk(sk)->p_flag != 1;
629 }
630
631 /**
632  *      conn_ev_qlfy_last_frame_eq_1 - checks if frame is last in tx window
633  *      @sk: current connection structure.
634  *      @skb: current event.
635  *
636  *      This function determines when frame which is sent, is last frame of
637  *      transmit window, if it is then this function return zero else return
638  *      one.  This function is used for sending last frame of transmit window
639  *      as I-format command with p-bit set to one. Returns 0 if frame is last
640  *      frame, 1 otherwise.
641  */
642 int llc_conn_ev_qlfy_last_frame_eq_1(struct sock *sk, struct sk_buff *skb)
643 {
644         return !(skb_queue_len(&llc_sk(sk)->pdu_unack_q) + 1 == llc_sk(sk)->k);
645 }
646
647 /**
648  *      conn_ev_qlfy_last_frame_eq_0 - checks if frame isn't last in tx window
649  *      @sk: current connection structure.
650  *      @skb: current event.
651  *
652  *      This function determines when frame which is sent, isn't last frame of
653  *      transmit window, if it isn't then this function return zero else return
654  *      one. Returns 0 if frame isn't last frame, 1 otherwise.
655  */
656 int llc_conn_ev_qlfy_last_frame_eq_0(struct sock *sk, struct sk_buff *skb)
657 {
658         return skb_queue_len(&llc_sk(sk)->pdu_unack_q) + 1 == llc_sk(sk)->k;
659 }
660
661 int llc_conn_ev_qlfy_p_flag_eq_0(struct sock *sk, struct sk_buff *skb)
662 {
663         return llc_sk(sk)->p_flag;
664 }
665
666 int llc_conn_ev_qlfy_p_flag_eq_f(struct sock *sk, struct sk_buff *skb)
667 {
668         u8 f_bit;
669
670         llc_pdu_decode_pf_bit(skb, &f_bit);
671         return llc_sk(sk)->p_flag == f_bit ? 0 : 1;
672 }
673
674 int llc_conn_ev_qlfy_remote_busy_eq_0(struct sock *sk, struct sk_buff *skb)
675 {
676         return llc_sk(sk)->remote_busy_flag;
677 }
678
679 int llc_conn_ev_qlfy_remote_busy_eq_1(struct sock *sk, struct sk_buff *skb)
680 {
681         return !llc_sk(sk)->remote_busy_flag;
682 }
683
684 int llc_conn_ev_qlfy_retry_cnt_lt_n2(struct sock *sk, struct sk_buff *skb)
685 {
686         return !(llc_sk(sk)->retry_count < llc_sk(sk)->n2);
687 }
688
689 int llc_conn_ev_qlfy_retry_cnt_gte_n2(struct sock *sk, struct sk_buff *skb)
690 {
691         return !(llc_sk(sk)->retry_count >= llc_sk(sk)->n2);
692 }
693
694 int llc_conn_ev_qlfy_s_flag_eq_1(struct sock *sk, struct sk_buff *skb)
695 {
696         return !llc_sk(sk)->s_flag;
697 }
698
699 int llc_conn_ev_qlfy_s_flag_eq_0(struct sock *sk, struct sk_buff *skb)
700 {
701         return llc_sk(sk)->s_flag;
702 }
703
704 int llc_conn_ev_qlfy_cause_flag_eq_1(struct sock *sk, struct sk_buff *skb)
705 {
706         return !llc_sk(sk)->cause_flag;
707 }
708
709 int llc_conn_ev_qlfy_cause_flag_eq_0(struct sock *sk, struct sk_buff *skb)
710 {
711         return llc_sk(sk)->cause_flag;
712 }
713
714 int llc_conn_ev_qlfy_set_status_conn(struct sock *sk, struct sk_buff *skb)
715 {
716         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
717
718         ev->status = LLC_STATUS_CONN;
719         return 0;
720 }
721
722 int llc_conn_ev_qlfy_set_status_disc(struct sock *sk, struct sk_buff *skb)
723 {
724         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
725
726         ev->status = LLC_STATUS_DISC;
727         return 0;
728 }
729
730 int llc_conn_ev_qlfy_set_status_failed(struct sock *sk, struct sk_buff *skb)
731 {
732         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
733
734         ev->status = LLC_STATUS_FAILED;
735         return 0;
736 }
737
738 int llc_conn_ev_qlfy_set_status_remote_busy(struct sock *sk,
739                                             struct sk_buff *skb)
740 {
741         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
742
743         ev->status = LLC_STATUS_REMOTE_BUSY;
744         return 0;
745 }
746
747 int llc_conn_ev_qlfy_set_status_refuse(struct sock *sk, struct sk_buff *skb)
748 {
749         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
750
751         ev->status = LLC_STATUS_REFUSE;
752         return 0;
753 }
754
755 int llc_conn_ev_qlfy_set_status_conflict(struct sock *sk, struct sk_buff *skb)
756 {
757         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
758
759         ev->status = LLC_STATUS_CONFLICT;
760         return 0;
761 }
762
763 int llc_conn_ev_qlfy_set_status_rst_done(struct sock *sk, struct sk_buff *skb)
764 {
765         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
766
767         ev->status = LLC_STATUS_RESET_DONE;
768         return 0;
769 }