Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux
[sfrench/cifs-2.6.git] / net / llc / llc_conn.c
1 /*
2  * llc_conn.c - Driver routines for connection component.
3  *
4  * Copyright (c) 1997 by Procom Technology, Inc.
5  *               2001-2003 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
6  *
7  * This program can be redistributed or modified under the terms of the
8  * GNU General Public License as published by the Free Software Foundation.
9  * This program is distributed without any warranty or implied warranty
10  * of merchantability or fitness for a particular purpose.
11  *
12  * See the GNU General Public License for more details.
13  */
14
15 #include <linux/init.h>
16 #include <linux/slab.h>
17 #include <net/llc_sap.h>
18 #include <net/llc_conn.h>
19 #include <net/sock.h>
20 #include <net/tcp_states.h>
21 #include <net/llc_c_ev.h>
22 #include <net/llc_c_ac.h>
23 #include <net/llc_c_st.h>
24 #include <net/llc_pdu.h>
25
26 #if 0
27 #define dprintk(args...) printk(KERN_DEBUG args)
28 #else
29 #define dprintk(args...)
30 #endif
31
32 static int llc_find_offset(int state, int ev_type);
33 static void llc_conn_send_pdus(struct sock *sk);
34 static int llc_conn_service(struct sock *sk, struct sk_buff *skb);
35 static int llc_exec_conn_trans_actions(struct sock *sk,
36                                        struct llc_conn_state_trans *trans,
37                                        struct sk_buff *ev);
38 static struct llc_conn_state_trans *llc_qualify_conn_ev(struct sock *sk,
39                                                         struct sk_buff *skb);
40
41 /* Offset table on connection states transition diagram */
42 static int llc_offset_table[NBR_CONN_STATES][NBR_CONN_EV];
43
44 int sysctl_llc2_ack_timeout = LLC2_ACK_TIME * HZ;
45 int sysctl_llc2_p_timeout = LLC2_P_TIME * HZ;
46 int sysctl_llc2_rej_timeout = LLC2_REJ_TIME * HZ;
47 int sysctl_llc2_busy_timeout = LLC2_BUSY_TIME * HZ;
48
49 /**
50  *      llc_conn_state_process - sends event to connection state machine
51  *      @sk: connection
52  *      @skb: occurred event
53  *
54  *      Sends an event to connection state machine. After processing event
55  *      (executing it's actions and changing state), upper layer will be
56  *      indicated or confirmed, if needed. Returns 0 for success, 1 for
57  *      failure. The socket lock has to be held before calling this function.
58  */
59 int llc_conn_state_process(struct sock *sk, struct sk_buff *skb)
60 {
61         int rc;
62         struct llc_sock *llc = llc_sk(skb->sk);
63         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
64
65         /*
66          * We have to hold the skb, because llc_conn_service will kfree it in
67          * the sending path and we need to look at the skb->cb, where we encode
68          * llc_conn_state_ev.
69          */
70         skb_get(skb);
71         ev->ind_prim = ev->cfm_prim = 0;
72         /*
73          * Send event to state machine
74          */
75         rc = llc_conn_service(skb->sk, skb);
76         if (unlikely(rc != 0)) {
77                 printk(KERN_ERR "%s: llc_conn_service failed\n", __func__);
78                 goto out_kfree_skb;
79         }
80
81         if (unlikely(!ev->ind_prim && !ev->cfm_prim)) {
82                 /* indicate or confirm not required */
83                 if (!skb->next)
84                         goto out_kfree_skb;
85                 goto out_skb_put;
86         }
87
88         if (unlikely(ev->ind_prim && ev->cfm_prim)) /* Paranoia */
89                 skb_get(skb);
90
91         switch (ev->ind_prim) {
92         case LLC_DATA_PRIM:
93                 llc_save_primitive(sk, skb, LLC_DATA_PRIM);
94                 if (unlikely(sock_queue_rcv_skb(sk, skb))) {
95                         /*
96                          * shouldn't happen
97                          */
98                         printk(KERN_ERR "%s: sock_queue_rcv_skb failed!\n",
99                                __func__);
100                         kfree_skb(skb);
101                 }
102                 break;
103         case LLC_CONN_PRIM:
104                 /*
105                  * Can't be sock_queue_rcv_skb, because we have to leave the
106                  * skb->sk pointing to the newly created struct sock in
107                  * llc_conn_handler. -acme
108                  */
109                 skb_queue_tail(&sk->sk_receive_queue, skb);
110                 sk->sk_state_change(sk);
111                 break;
112         case LLC_DISC_PRIM:
113                 sock_hold(sk);
114                 if (sk->sk_type == SOCK_STREAM &&
115                     sk->sk_state == TCP_ESTABLISHED) {
116                         sk->sk_shutdown       = SHUTDOWN_MASK;
117                         sk->sk_socket->state  = SS_UNCONNECTED;
118                         sk->sk_state          = TCP_CLOSE;
119                         if (!sock_flag(sk, SOCK_DEAD)) {
120                                 sock_set_flag(sk, SOCK_DEAD);
121                                 sk->sk_state_change(sk);
122                         }
123                 }
124                 kfree_skb(skb);
125                 sock_put(sk);
126                 break;
127         case LLC_RESET_PRIM:
128                 /*
129                  * FIXME:
130                  * RESET is not being notified to upper layers for now
131                  */
132                 printk(KERN_INFO "%s: received a reset ind!\n", __func__);
133                 kfree_skb(skb);
134                 break;
135         default:
136                 if (ev->ind_prim) {
137                         printk(KERN_INFO "%s: received unknown %d prim!\n",
138                                 __func__, ev->ind_prim);
139                         kfree_skb(skb);
140                 }
141                 /* No indication */
142                 break;
143         }
144
145         switch (ev->cfm_prim) {
146         case LLC_DATA_PRIM:
147                 if (!llc_data_accept_state(llc->state))
148                         sk->sk_write_space(sk);
149                 else
150                         rc = llc->failed_data_req = 1;
151                 break;
152         case LLC_CONN_PRIM:
153                 if (sk->sk_type == SOCK_STREAM &&
154                     sk->sk_state == TCP_SYN_SENT) {
155                         if (ev->status) {
156                                 sk->sk_socket->state = SS_UNCONNECTED;
157                                 sk->sk_state         = TCP_CLOSE;
158                         } else {
159                                 sk->sk_socket->state = SS_CONNECTED;
160                                 sk->sk_state         = TCP_ESTABLISHED;
161                         }
162                         sk->sk_state_change(sk);
163                 }
164                 break;
165         case LLC_DISC_PRIM:
166                 sock_hold(sk);
167                 if (sk->sk_type == SOCK_STREAM && sk->sk_state == TCP_CLOSING) {
168                         sk->sk_socket->state = SS_UNCONNECTED;
169                         sk->sk_state         = TCP_CLOSE;
170                         sk->sk_state_change(sk);
171                 }
172                 sock_put(sk);
173                 break;
174         case LLC_RESET_PRIM:
175                 /*
176                  * FIXME:
177                  * RESET is not being notified to upper layers for now
178                  */
179                 printk(KERN_INFO "%s: received a reset conf!\n", __func__);
180                 break;
181         default:
182                 if (ev->cfm_prim) {
183                         printk(KERN_INFO "%s: received unknown %d prim!\n",
184                                         __func__, ev->cfm_prim);
185                         break;
186                 }
187                 goto out_skb_put; /* No confirmation */
188         }
189 out_kfree_skb:
190         kfree_skb(skb);
191 out_skb_put:
192         kfree_skb(skb);
193         return rc;
194 }
195
196 void llc_conn_send_pdu(struct sock *sk, struct sk_buff *skb)
197 {
198         /* queue PDU to send to MAC layer */
199         skb_queue_tail(&sk->sk_write_queue, skb);
200         llc_conn_send_pdus(sk);
201 }
202
203 /**
204  *      llc_conn_rtn_pdu - sends received data pdu to upper layer
205  *      @sk: Active connection
206  *      @skb: Received data frame
207  *
208  *      Sends received data pdu to upper layer (by using indicate function).
209  *      Prepares service parameters (prim and prim_data). calling indication
210  *      function will be done in llc_conn_state_process.
211  */
212 void llc_conn_rtn_pdu(struct sock *sk, struct sk_buff *skb)
213 {
214         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
215
216         ev->ind_prim = LLC_DATA_PRIM;
217 }
218
219 /**
220  *      llc_conn_resend_i_pdu_as_cmd - resend all all unacknowledged I PDUs
221  *      @sk: active connection
222  *      @nr: NR
223  *      @first_p_bit: p_bit value of first pdu
224  *
225  *      Resend all unacknowledged I PDUs, starting with the NR; send first as
226  *      command PDU with P bit equal first_p_bit; if more than one send
227  *      subsequent as command PDUs with P bit equal zero (0).
228  */
229 void llc_conn_resend_i_pdu_as_cmd(struct sock *sk, u8 nr, u8 first_p_bit)
230 {
231         struct sk_buff *skb;
232         struct llc_pdu_sn *pdu;
233         u16 nbr_unack_pdus;
234         struct llc_sock *llc;
235         u8 howmany_resend = 0;
236
237         llc_conn_remove_acked_pdus(sk, nr, &nbr_unack_pdus);
238         if (!nbr_unack_pdus)
239                 goto out;
240         /*
241          * Process unack PDUs only if unack queue is not empty; remove
242          * appropriate PDUs, fix them up, and put them on mac_pdu_q.
243          */
244         llc = llc_sk(sk);
245
246         while ((skb = skb_dequeue(&llc->pdu_unack_q)) != NULL) {
247                 pdu = llc_pdu_sn_hdr(skb);
248                 llc_pdu_set_cmd_rsp(skb, LLC_PDU_CMD);
249                 llc_pdu_set_pf_bit(skb, first_p_bit);
250                 skb_queue_tail(&sk->sk_write_queue, skb);
251                 first_p_bit = 0;
252                 llc->vS = LLC_I_GET_NS(pdu);
253                 howmany_resend++;
254         }
255         if (howmany_resend > 0)
256                 llc->vS = (llc->vS + 1) % LLC_2_SEQ_NBR_MODULO;
257         /* any PDUs to re-send are queued up; start sending to MAC */
258         llc_conn_send_pdus(sk);
259 out:;
260 }
261
262 /**
263  *      llc_conn_resend_i_pdu_as_rsp - Resend all unacknowledged I PDUs
264  *      @sk: active connection.
265  *      @nr: NR
266  *      @first_f_bit: f_bit value of first pdu.
267  *
268  *      Resend all unacknowledged I PDUs, starting with the NR; send first as
269  *      response PDU with F bit equal first_f_bit; if more than one send
270  *      subsequent as response PDUs with F bit equal zero (0).
271  */
272 void llc_conn_resend_i_pdu_as_rsp(struct sock *sk, u8 nr, u8 first_f_bit)
273 {
274         struct sk_buff *skb;
275         u16 nbr_unack_pdus;
276         struct llc_sock *llc = llc_sk(sk);
277         u8 howmany_resend = 0;
278
279         llc_conn_remove_acked_pdus(sk, nr, &nbr_unack_pdus);
280         if (!nbr_unack_pdus)
281                 goto out;
282         /*
283          * Process unack PDUs only if unack queue is not empty; remove
284          * appropriate PDUs, fix them up, and put them on mac_pdu_q
285          */
286         while ((skb = skb_dequeue(&llc->pdu_unack_q)) != NULL) {
287                 struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
288
289                 llc_pdu_set_cmd_rsp(skb, LLC_PDU_RSP);
290                 llc_pdu_set_pf_bit(skb, first_f_bit);
291                 skb_queue_tail(&sk->sk_write_queue, skb);
292                 first_f_bit = 0;
293                 llc->vS = LLC_I_GET_NS(pdu);
294                 howmany_resend++;
295         }
296         if (howmany_resend > 0)
297                 llc->vS = (llc->vS + 1) % LLC_2_SEQ_NBR_MODULO;
298         /* any PDUs to re-send are queued up; start sending to MAC */
299         llc_conn_send_pdus(sk);
300 out:;
301 }
302
303 /**
304  *      llc_conn_remove_acked_pdus - Removes acknowledged pdus from tx queue
305  *      @sk: active connection
306  *      nr: NR
307  *      how_many_unacked: size of pdu_unack_q after removing acked pdus
308  *
309  *      Removes acknowledged pdus from transmit queue (pdu_unack_q). Returns
310  *      the number of pdus that removed from queue.
311  */
312 int llc_conn_remove_acked_pdus(struct sock *sk, u8 nr, u16 *how_many_unacked)
313 {
314         int pdu_pos, i;
315         struct sk_buff *skb;
316         struct llc_pdu_sn *pdu;
317         int nbr_acked = 0;
318         struct llc_sock *llc = llc_sk(sk);
319         int q_len = skb_queue_len(&llc->pdu_unack_q);
320
321         if (!q_len)
322                 goto out;
323         skb = skb_peek(&llc->pdu_unack_q);
324         pdu = llc_pdu_sn_hdr(skb);
325
326         /* finding position of last acked pdu in queue */
327         pdu_pos = ((int)LLC_2_SEQ_NBR_MODULO + (int)nr -
328                         (int)LLC_I_GET_NS(pdu)) % LLC_2_SEQ_NBR_MODULO;
329
330         for (i = 0; i < pdu_pos && i < q_len; i++) {
331                 skb = skb_dequeue(&llc->pdu_unack_q);
332                 kfree_skb(skb);
333                 nbr_acked++;
334         }
335 out:
336         *how_many_unacked = skb_queue_len(&llc->pdu_unack_q);
337         return nbr_acked;
338 }
339
340 /**
341  *      llc_conn_send_pdus - Sends queued PDUs
342  *      @sk: active connection
343  *
344  *      Sends queued pdus to MAC layer for transmission.
345  */
346 static void llc_conn_send_pdus(struct sock *sk)
347 {
348         struct sk_buff *skb;
349
350         while ((skb = skb_dequeue(&sk->sk_write_queue)) != NULL) {
351                 struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
352
353                 if (LLC_PDU_TYPE_IS_I(pdu) &&
354                     !(skb->dev->flags & IFF_LOOPBACK)) {
355                         struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
356
357                         skb_queue_tail(&llc_sk(sk)->pdu_unack_q, skb);
358                         if (!skb2)
359                                 break;
360                         skb = skb2;
361                 }
362                 dev_queue_xmit(skb);
363         }
364 }
365
366 /**
367  *      llc_conn_service - finds transition and changes state of connection
368  *      @sk: connection
369  *      @skb: happened event
370  *
371  *      This function finds transition that matches with happened event, then
372  *      executes related actions and finally changes state of connection.
373  *      Returns 0 for success, 1 for failure.
374  */
375 static int llc_conn_service(struct sock *sk, struct sk_buff *skb)
376 {
377         int rc = 1;
378         struct llc_sock *llc = llc_sk(sk);
379         struct llc_conn_state_trans *trans;
380
381         if (llc->state > NBR_CONN_STATES)
382                 goto out;
383         rc = 0;
384         trans = llc_qualify_conn_ev(sk, skb);
385         if (trans) {
386                 rc = llc_exec_conn_trans_actions(sk, trans, skb);
387                 if (!rc && trans->next_state != NO_STATE_CHANGE) {
388                         llc->state = trans->next_state;
389                         if (!llc_data_accept_state(llc->state))
390                                 sk->sk_state_change(sk);
391                 }
392         }
393 out:
394         return rc;
395 }
396
397 /**
398  *      llc_qualify_conn_ev - finds transition for event
399  *      @sk: connection
400  *      @skb: happened event
401  *
402  *      This function finds transition that matches with happened event.
403  *      Returns pointer to found transition on success, %NULL otherwise.
404  */
405 static struct llc_conn_state_trans *llc_qualify_conn_ev(struct sock *sk,
406                                                         struct sk_buff *skb)
407 {
408         struct llc_conn_state_trans **next_trans;
409         llc_conn_ev_qfyr_t *next_qualifier;
410         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
411         struct llc_sock *llc = llc_sk(sk);
412         struct llc_conn_state *curr_state =
413                                         &llc_conn_state_table[llc->state - 1];
414
415         /* search thru events for this state until
416          * list exhausted or until no more
417          */
418         for (next_trans = curr_state->transitions +
419                 llc_find_offset(llc->state - 1, ev->type);
420              (*next_trans)->ev; next_trans++) {
421                 if (!((*next_trans)->ev)(sk, skb)) {
422                         /* got POSSIBLE event match; the event may require
423                          * qualification based on the values of a number of
424                          * state flags; if all qualifications are met (i.e.,
425                          * if all qualifying functions return success, or 0,
426                          * then this is THE event we're looking for
427                          */
428                         for (next_qualifier = (*next_trans)->ev_qualifiers;
429                              next_qualifier && *next_qualifier &&
430                              !(*next_qualifier)(sk, skb); next_qualifier++)
431                                 /* nothing */;
432                         if (!next_qualifier || !*next_qualifier)
433                                 /* all qualifiers executed successfully; this is
434                                  * our transition; return it so we can perform
435                                  * the associated actions & change the state
436                                  */
437                                 return *next_trans;
438                 }
439         }
440         return NULL;
441 }
442
443 /**
444  *      llc_exec_conn_trans_actions - executes related actions
445  *      @sk: connection
446  *      @trans: transition that it's actions must be performed
447  *      @skb: event
448  *
449  *      Executes actions that is related to happened event. Returns 0 for
450  *      success, 1 to indicate failure of at least one action.
451  */
452 static int llc_exec_conn_trans_actions(struct sock *sk,
453                                        struct llc_conn_state_trans *trans,
454                                        struct sk_buff *skb)
455 {
456         int rc = 0;
457         llc_conn_action_t *next_action;
458
459         for (next_action = trans->ev_actions;
460              next_action && *next_action; next_action++) {
461                 int rc2 = (*next_action)(sk, skb);
462
463                 if (rc2 == 2) {
464                         rc = rc2;
465                         break;
466                 } else if (rc2)
467                         rc = 1;
468         }
469         return rc;
470 }
471
472 static inline bool llc_estab_match(const struct llc_sap *sap,
473                                    const struct llc_addr *daddr,
474                                    const struct llc_addr *laddr,
475                                    const struct sock *sk)
476 {
477         struct llc_sock *llc = llc_sk(sk);
478
479         return llc->laddr.lsap == laddr->lsap &&
480                 llc->daddr.lsap == daddr->lsap &&
481                 ether_addr_equal(llc->laddr.mac, laddr->mac) &&
482                 ether_addr_equal(llc->daddr.mac, daddr->mac);
483 }
484
485 /**
486  *      __llc_lookup_established - Finds connection for the remote/local sap/mac
487  *      @sap: SAP
488  *      @daddr: address of remote LLC (MAC + SAP)
489  *      @laddr: address of local LLC (MAC + SAP)
490  *
491  *      Search connection list of the SAP and finds connection using the remote
492  *      mac, remote sap, local mac, and local sap. Returns pointer for
493  *      connection found, %NULL otherwise.
494  *      Caller has to make sure local_bh is disabled.
495  */
496 static struct sock *__llc_lookup_established(struct llc_sap *sap,
497                                              struct llc_addr *daddr,
498                                              struct llc_addr *laddr)
499 {
500         struct sock *rc;
501         struct hlist_nulls_node *node;
502         int slot = llc_sk_laddr_hashfn(sap, laddr);
503         struct hlist_nulls_head *laddr_hb = &sap->sk_laddr_hash[slot];
504
505         rcu_read_lock();
506 again:
507         sk_nulls_for_each_rcu(rc, node, laddr_hb) {
508                 if (llc_estab_match(sap, daddr, laddr, rc)) {
509                         /* Extra checks required by SLAB_DESTROY_BY_RCU */
510                         if (unlikely(!atomic_inc_not_zero(&rc->sk_refcnt)))
511                                 goto again;
512                         if (unlikely(llc_sk(rc)->sap != sap ||
513                                      !llc_estab_match(sap, daddr, laddr, rc))) {
514                                 sock_put(rc);
515                                 continue;
516                         }
517                         goto found;
518                 }
519         }
520         rc = NULL;
521         /*
522          * if the nulls value we got at the end of this lookup is
523          * not the expected one, we must restart lookup.
524          * We probably met an item that was moved to another chain.
525          */
526         if (unlikely(get_nulls_value(node) != slot))
527                 goto again;
528 found:
529         rcu_read_unlock();
530         return rc;
531 }
532
533 struct sock *llc_lookup_established(struct llc_sap *sap,
534                                     struct llc_addr *daddr,
535                                     struct llc_addr *laddr)
536 {
537         struct sock *sk;
538
539         local_bh_disable();
540         sk = __llc_lookup_established(sap, daddr, laddr);
541         local_bh_enable();
542         return sk;
543 }
544
545 static inline bool llc_listener_match(const struct llc_sap *sap,
546                                       const struct llc_addr *laddr,
547                                       const struct sock *sk)
548 {
549         struct llc_sock *llc = llc_sk(sk);
550
551         return sk->sk_type == SOCK_STREAM && sk->sk_state == TCP_LISTEN &&
552                 llc->laddr.lsap == laddr->lsap &&
553                 ether_addr_equal(llc->laddr.mac, laddr->mac);
554 }
555
556 static struct sock *__llc_lookup_listener(struct llc_sap *sap,
557                                           struct llc_addr *laddr)
558 {
559         struct sock *rc;
560         struct hlist_nulls_node *node;
561         int slot = llc_sk_laddr_hashfn(sap, laddr);
562         struct hlist_nulls_head *laddr_hb = &sap->sk_laddr_hash[slot];
563
564         rcu_read_lock();
565 again:
566         sk_nulls_for_each_rcu(rc, node, laddr_hb) {
567                 if (llc_listener_match(sap, laddr, rc)) {
568                         /* Extra checks required by SLAB_DESTROY_BY_RCU */
569                         if (unlikely(!atomic_inc_not_zero(&rc->sk_refcnt)))
570                                 goto again;
571                         if (unlikely(llc_sk(rc)->sap != sap ||
572                                      !llc_listener_match(sap, laddr, rc))) {
573                                 sock_put(rc);
574                                 continue;
575                         }
576                         goto found;
577                 }
578         }
579         rc = NULL;
580         /*
581          * if the nulls value we got at the end of this lookup is
582          * not the expected one, we must restart lookup.
583          * We probably met an item that was moved to another chain.
584          */
585         if (unlikely(get_nulls_value(node) != slot))
586                 goto again;
587 found:
588         rcu_read_unlock();
589         return rc;
590 }
591
592 /**
593  *      llc_lookup_listener - Finds listener for local MAC + SAP
594  *      @sap: SAP
595  *      @laddr: address of local LLC (MAC + SAP)
596  *
597  *      Search connection list of the SAP and finds connection listening on
598  *      local mac, and local sap. Returns pointer for parent socket found,
599  *      %NULL otherwise.
600  *      Caller has to make sure local_bh is disabled.
601  */
602 static struct sock *llc_lookup_listener(struct llc_sap *sap,
603                                         struct llc_addr *laddr)
604 {
605         static struct llc_addr null_addr;
606         struct sock *rc = __llc_lookup_listener(sap, laddr);
607
608         if (!rc)
609                 rc = __llc_lookup_listener(sap, &null_addr);
610
611         return rc;
612 }
613
614 static struct sock *__llc_lookup(struct llc_sap *sap,
615                                  struct llc_addr *daddr,
616                                  struct llc_addr *laddr)
617 {
618         struct sock *sk = __llc_lookup_established(sap, daddr, laddr);
619
620         return sk ? : llc_lookup_listener(sap, laddr);
621 }
622
623 /**
624  *      llc_data_accept_state - designates if in this state data can be sent.
625  *      @state: state of connection.
626  *
627  *      Returns 0 if data can be sent, 1 otherwise.
628  */
629 u8 llc_data_accept_state(u8 state)
630 {
631         return state != LLC_CONN_STATE_NORMAL && state != LLC_CONN_STATE_BUSY &&
632                state != LLC_CONN_STATE_REJ;
633 }
634
635 /**
636  *      llc_find_next_offset - finds offset for next category of transitions
637  *      @state: state table.
638  *      @offset: start offset.
639  *
640  *      Finds offset of next category of transitions in transition table.
641  *      Returns the start index of next category.
642  */
643 static u16 __init llc_find_next_offset(struct llc_conn_state *state, u16 offset)
644 {
645         u16 cnt = 0;
646         struct llc_conn_state_trans **next_trans;
647
648         for (next_trans = state->transitions + offset;
649              (*next_trans)->ev; next_trans++)
650                 ++cnt;
651         return cnt;
652 }
653
654 /**
655  *      llc_build_offset_table - builds offset table of connection
656  *
657  *      Fills offset table of connection state transition table
658  *      (llc_offset_table).
659  */
660 void __init llc_build_offset_table(void)
661 {
662         struct llc_conn_state *curr_state;
663         int state, ev_type, next_offset;
664
665         for (state = 0; state < NBR_CONN_STATES; state++) {
666                 curr_state = &llc_conn_state_table[state];
667                 next_offset = 0;
668                 for (ev_type = 0; ev_type < NBR_CONN_EV; ev_type++) {
669                         llc_offset_table[state][ev_type] = next_offset;
670                         next_offset += llc_find_next_offset(curr_state,
671                                                             next_offset) + 1;
672                 }
673         }
674 }
675
676 /**
677  *      llc_find_offset - finds start offset of category of transitions
678  *      @state: state of connection
679  *      @ev_type: type of happened event
680  *
681  *      Finds start offset of desired category of transitions. Returns the
682  *      desired start offset.
683  */
684 static int llc_find_offset(int state, int ev_type)
685 {
686         int rc = 0;
687         /* at this stage, llc_offset_table[..][2] is not important. it is for
688          * init_pf_cycle and I don't know what is it.
689          */
690         switch (ev_type) {
691         case LLC_CONN_EV_TYPE_PRIM:
692                 rc = llc_offset_table[state][0]; break;
693         case LLC_CONN_EV_TYPE_PDU:
694                 rc = llc_offset_table[state][4]; break;
695         case LLC_CONN_EV_TYPE_SIMPLE:
696                 rc = llc_offset_table[state][1]; break;
697         case LLC_CONN_EV_TYPE_P_TMR:
698         case LLC_CONN_EV_TYPE_ACK_TMR:
699         case LLC_CONN_EV_TYPE_REJ_TMR:
700         case LLC_CONN_EV_TYPE_BUSY_TMR:
701                 rc = llc_offset_table[state][3]; break;
702         }
703         return rc;
704 }
705
706 /**
707  *      llc_sap_add_socket - adds a socket to a SAP
708  *      @sap: SAP
709  *      @sk: socket
710  *
711  *      This function adds a socket to the hash tables of a SAP.
712  */
713 void llc_sap_add_socket(struct llc_sap *sap, struct sock *sk)
714 {
715         struct llc_sock *llc = llc_sk(sk);
716         struct hlist_head *dev_hb = llc_sk_dev_hash(sap, llc->dev->ifindex);
717         struct hlist_nulls_head *laddr_hb = llc_sk_laddr_hash(sap, &llc->laddr);
718
719         llc_sap_hold(sap);
720         llc_sk(sk)->sap = sap;
721
722         spin_lock_bh(&sap->sk_lock);
723         sap->sk_count++;
724         sk_nulls_add_node_rcu(sk, laddr_hb);
725         hlist_add_head(&llc->dev_hash_node, dev_hb);
726         spin_unlock_bh(&sap->sk_lock);
727 }
728
729 /**
730  *      llc_sap_remove_socket - removes a socket from SAP
731  *      @sap: SAP
732  *      @sk: socket
733  *
734  *      This function removes a connection from the hash tables of a SAP if
735  *      the connection was in this list.
736  */
737 void llc_sap_remove_socket(struct llc_sap *sap, struct sock *sk)
738 {
739         struct llc_sock *llc = llc_sk(sk);
740
741         spin_lock_bh(&sap->sk_lock);
742         sk_nulls_del_node_init_rcu(sk);
743         hlist_del(&llc->dev_hash_node);
744         sap->sk_count--;
745         spin_unlock_bh(&sap->sk_lock);
746         llc_sap_put(sap);
747 }
748
749 /**
750  *      llc_conn_rcv - sends received pdus to the connection state machine
751  *      @sk: current connection structure.
752  *      @skb: received frame.
753  *
754  *      Sends received pdus to the connection state machine.
755  */
756 static int llc_conn_rcv(struct sock *sk, struct sk_buff *skb)
757 {
758         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
759
760         ev->type   = LLC_CONN_EV_TYPE_PDU;
761         ev->reason = 0;
762         return llc_conn_state_process(sk, skb);
763 }
764
765 static struct sock *llc_create_incoming_sock(struct sock *sk,
766                                              struct net_device *dev,
767                                              struct llc_addr *saddr,
768                                              struct llc_addr *daddr)
769 {
770         struct sock *newsk = llc_sk_alloc(sock_net(sk), sk->sk_family, GFP_ATOMIC,
771                                           sk->sk_prot);
772         struct llc_sock *newllc, *llc = llc_sk(sk);
773
774         if (!newsk)
775                 goto out;
776         newllc = llc_sk(newsk);
777         memcpy(&newllc->laddr, daddr, sizeof(newllc->laddr));
778         memcpy(&newllc->daddr, saddr, sizeof(newllc->daddr));
779         newllc->dev = dev;
780         dev_hold(dev);
781         llc_sap_add_socket(llc->sap, newsk);
782         llc_sap_hold(llc->sap);
783 out:
784         return newsk;
785 }
786
787 void llc_conn_handler(struct llc_sap *sap, struct sk_buff *skb)
788 {
789         struct llc_addr saddr, daddr;
790         struct sock *sk;
791
792         llc_pdu_decode_sa(skb, saddr.mac);
793         llc_pdu_decode_ssap(skb, &saddr.lsap);
794         llc_pdu_decode_da(skb, daddr.mac);
795         llc_pdu_decode_dsap(skb, &daddr.lsap);
796
797         sk = __llc_lookup(sap, &saddr, &daddr);
798         if (!sk)
799                 goto drop;
800
801         bh_lock_sock(sk);
802         /*
803          * This has to be done here and not at the upper layer ->accept
804          * method because of the way the PROCOM state machine works:
805          * it needs to set several state variables (see, for instance,
806          * llc_adm_actions_2 in net/llc/llc_c_st.c) and send a packet to
807          * the originator of the new connection, and this state has to be
808          * in the newly created struct sock private area. -acme
809          */
810         if (unlikely(sk->sk_state == TCP_LISTEN)) {
811                 struct sock *newsk = llc_create_incoming_sock(sk, skb->dev,
812                                                               &saddr, &daddr);
813                 if (!newsk)
814                         goto drop_unlock;
815                 skb_set_owner_r(skb, newsk);
816         } else {
817                 /*
818                  * Can't be skb_set_owner_r, this will be done at the
819                  * llc_conn_state_process function, later on, when we will use
820                  * skb_queue_rcv_skb to send it to upper layers, this is
821                  * another trick required to cope with how the PROCOM state
822                  * machine works. -acme
823                  */
824                 skb->sk = sk;
825         }
826         if (!sock_owned_by_user(sk))
827                 llc_conn_rcv(sk, skb);
828         else {
829                 dprintk("%s: adding to backlog...\n", __func__);
830                 llc_set_backlog_type(skb, LLC_PACKET);
831                 if (sk_add_backlog(sk, skb, sk->sk_rcvbuf))
832                         goto drop_unlock;
833         }
834 out:
835         bh_unlock_sock(sk);
836         sock_put(sk);
837         return;
838 drop:
839         kfree_skb(skb);
840         return;
841 drop_unlock:
842         kfree_skb(skb);
843         goto out;
844 }
845
846 #undef LLC_REFCNT_DEBUG
847 #ifdef LLC_REFCNT_DEBUG
848 static atomic_t llc_sock_nr;
849 #endif
850
851 /**
852  *      llc_backlog_rcv - Processes rx frames and expired timers.
853  *      @sk: LLC sock (p8022 connection)
854  *      @skb: queued rx frame or event
855  *
856  *      This function processes frames that has received and timers that has
857  *      expired during sending an I pdu (refer to data_req_handler).  frames
858  *      queue by llc_rcv function (llc_mac.c) and timers queue by timer
859  *      callback functions(llc_c_ac.c).
860  */
861 static int llc_backlog_rcv(struct sock *sk, struct sk_buff *skb)
862 {
863         int rc = 0;
864         struct llc_sock *llc = llc_sk(sk);
865
866         if (likely(llc_backlog_type(skb) == LLC_PACKET)) {
867                 if (likely(llc->state > 1)) /* not closed */
868                         rc = llc_conn_rcv(sk, skb);
869                 else
870                         goto out_kfree_skb;
871         } else if (llc_backlog_type(skb) == LLC_EVENT) {
872                 /* timer expiration event */
873                 if (likely(llc->state > 1))  /* not closed */
874                         rc = llc_conn_state_process(sk, skb);
875                 else
876                         goto out_kfree_skb;
877         } else {
878                 printk(KERN_ERR "%s: invalid skb in backlog\n", __func__);
879                 goto out_kfree_skb;
880         }
881 out:
882         return rc;
883 out_kfree_skb:
884         kfree_skb(skb);
885         goto out;
886 }
887
888 /**
889  *     llc_sk_init - Initializes a socket with default llc values.
890  *     @sk: socket to initialize.
891  *
892  *     Initializes a socket with default llc values.
893  */
894 static void llc_sk_init(struct sock *sk)
895 {
896         struct llc_sock *llc = llc_sk(sk);
897
898         llc->state    = LLC_CONN_STATE_ADM;
899         llc->inc_cntr = llc->dec_cntr = 2;
900         llc->dec_step = llc->connect_step = 1;
901
902         setup_timer(&llc->ack_timer.timer, llc_conn_ack_tmr_cb,
903                         (unsigned long)sk);
904         llc->ack_timer.expire         = sysctl_llc2_ack_timeout;
905
906         setup_timer(&llc->pf_cycle_timer.timer, llc_conn_pf_cycle_tmr_cb,
907                         (unsigned long)sk);
908         llc->pf_cycle_timer.expire         = sysctl_llc2_p_timeout;
909
910         setup_timer(&llc->rej_sent_timer.timer, llc_conn_rej_tmr_cb,
911                         (unsigned long)sk);
912         llc->rej_sent_timer.expire         = sysctl_llc2_rej_timeout;
913
914         setup_timer(&llc->busy_state_timer.timer, llc_conn_busy_tmr_cb,
915                         (unsigned long)sk);
916         llc->busy_state_timer.expire         = sysctl_llc2_busy_timeout;
917
918         llc->n2 = 2;   /* max retransmit */
919         llc->k  = 2;   /* tx win size, will adjust dynam */
920         llc->rw = 128; /* rx win size (opt and equal to
921                         * tx_win of remote LLC) */
922         skb_queue_head_init(&llc->pdu_unack_q);
923         sk->sk_backlog_rcv = llc_backlog_rcv;
924 }
925
926 /**
927  *      llc_sk_alloc - Allocates LLC sock
928  *      @family: upper layer protocol family
929  *      @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
930  *
931  *      Allocates a LLC sock and initializes it. Returns the new LLC sock
932  *      or %NULL if there's no memory available for one
933  */
934 struct sock *llc_sk_alloc(struct net *net, int family, gfp_t priority, struct proto *prot)
935 {
936         struct sock *sk = sk_alloc(net, family, priority, prot);
937
938         if (!sk)
939                 goto out;
940         llc_sk_init(sk);
941         sock_init_data(NULL, sk);
942 #ifdef LLC_REFCNT_DEBUG
943         atomic_inc(&llc_sock_nr);
944         printk(KERN_DEBUG "LLC socket %p created in %s, now we have %d alive\n", sk,
945                 __func__, atomic_read(&llc_sock_nr));
946 #endif
947 out:
948         return sk;
949 }
950
951 /**
952  *      llc_sk_free - Frees a LLC socket
953  *      @sk - socket to free
954  *
955  *      Frees a LLC socket
956  */
957 void llc_sk_free(struct sock *sk)
958 {
959         struct llc_sock *llc = llc_sk(sk);
960
961         llc->state = LLC_CONN_OUT_OF_SVC;
962         /* Stop all (possibly) running timers */
963         llc_conn_ac_stop_all_timers(sk, NULL);
964 #ifdef DEBUG_LLC_CONN_ALLOC
965         printk(KERN_INFO "%s: unackq=%d, txq=%d\n", __func__,
966                 skb_queue_len(&llc->pdu_unack_q),
967                 skb_queue_len(&sk->sk_write_queue));
968 #endif
969         skb_queue_purge(&sk->sk_receive_queue);
970         skb_queue_purge(&sk->sk_write_queue);
971         skb_queue_purge(&llc->pdu_unack_q);
972 #ifdef LLC_REFCNT_DEBUG
973         if (atomic_read(&sk->sk_refcnt) != 1) {
974                 printk(KERN_DEBUG "Destruction of LLC sock %p delayed in %s, cnt=%d\n",
975                         sk, __func__, atomic_read(&sk->sk_refcnt));
976                 printk(KERN_DEBUG "%d LLC sockets are still alive\n",
977                         atomic_read(&llc_sock_nr));
978         } else {
979                 atomic_dec(&llc_sock_nr);
980                 printk(KERN_DEBUG "LLC socket %p released in %s, %d are still alive\n", sk,
981                         __func__, atomic_read(&llc_sock_nr));
982         }
983 #endif
984         sock_put(sk);
985 }
986
987 /**
988  *      llc_sk_reset - resets a connection
989  *      @sk: LLC socket to reset
990  *
991  *      Resets a connection to the out of service state. Stops its timers
992  *      and frees any frames in the queues of the connection.
993  */
994 void llc_sk_reset(struct sock *sk)
995 {
996         struct llc_sock *llc = llc_sk(sk);
997
998         llc_conn_ac_stop_all_timers(sk, NULL);
999         skb_queue_purge(&sk->sk_write_queue);
1000         skb_queue_purge(&llc->pdu_unack_q);
1001         llc->remote_busy_flag   = 0;
1002         llc->cause_flag         = 0;
1003         llc->retry_count        = 0;
1004         llc_conn_set_p_flag(sk, 0);
1005         llc->f_flag             = 0;
1006         llc->s_flag             = 0;
1007         llc->ack_pf             = 0;
1008         llc->first_pdu_Ns       = 0;
1009         llc->ack_must_be_send   = 0;
1010         llc->dec_step           = 1;
1011         llc->inc_cntr           = 2;
1012         llc->dec_cntr           = 2;
1013         llc->X                  = 0;
1014         llc->failed_data_req    = 0 ;
1015         llc->last_nr            = 0;
1016 }