Loading...
1/*
2 * llc_if.c - Defines LLC interface to upper layer
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#include <linux/gfp.h>
15#include <linux/module.h>
16#include <linux/kernel.h>
17#include <linux/netdevice.h>
18#include <asm/errno.h>
19#include <net/llc_if.h>
20#include <net/llc_sap.h>
21#include <net/llc_s_ev.h>
22#include <net/llc_conn.h>
23#include <net/sock.h>
24#include <net/llc_c_ev.h>
25#include <net/llc_c_ac.h>
26#include <net/llc_c_st.h>
27#include <net/tcp_states.h>
28
29/**
30 * llc_build_and_send_pkt - Connection data sending for upper layers.
31 * @sk: connection
32 * @skb: packet to send
33 *
34 * This function is called when upper layer wants to send data using
35 * connection oriented communication mode. During sending data, connection
36 * will be locked and received frames and expired timers will be queued.
37 * Returns 0 for success, -ECONNABORTED when the connection already
38 * closed and -EBUSY when sending data is not permitted in this state or
39 * LLC has send an I pdu with p bit set to 1 and is waiting for it's
40 * response.
41 */
42int llc_build_and_send_pkt(struct sock *sk, struct sk_buff *skb)
43{
44 struct llc_conn_state_ev *ev;
45 int rc = -ECONNABORTED;
46 struct llc_sock *llc = llc_sk(sk);
47
48 if (unlikely(llc->state == LLC_CONN_STATE_ADM))
49 goto out;
50 rc = -EBUSY;
51 if (unlikely(llc_data_accept_state(llc->state) || /* data_conn_refuse */
52 llc->p_flag)) {
53 llc->failed_data_req = 1;
54 goto out;
55 }
56 ev = llc_conn_ev(skb);
57 ev->type = LLC_CONN_EV_TYPE_PRIM;
58 ev->prim = LLC_DATA_PRIM;
59 ev->prim_type = LLC_PRIM_TYPE_REQ;
60 skb->dev = llc->dev;
61 rc = llc_conn_state_process(sk, skb);
62out:
63 return rc;
64}
65
66/**
67 * llc_establish_connection - Called by upper layer to establish a conn
68 * @sk: connection
69 * @lmac: local mac address
70 * @dmac: destination mac address
71 * @dsap: destination sap
72 *
73 * Upper layer calls this to establish an LLC connection with a remote
74 * machine. This function packages a proper event and sends it connection
75 * component state machine. Success or failure of connection
76 * establishment will inform to upper layer via calling it's confirm
77 * function and passing proper information.
78 */
79int llc_establish_connection(struct sock *sk, u8 *lmac, u8 *dmac, u8 dsap)
80{
81 int rc = -EISCONN;
82 struct llc_addr laddr, daddr;
83 struct sk_buff *skb;
84 struct llc_sock *llc = llc_sk(sk);
85 struct sock *existing;
86
87 laddr.lsap = llc->sap->laddr.lsap;
88 daddr.lsap = dsap;
89 memcpy(daddr.mac, dmac, sizeof(daddr.mac));
90 memcpy(laddr.mac, lmac, sizeof(laddr.mac));
91 existing = llc_lookup_established(llc->sap, &daddr, &laddr);
92 if (existing) {
93 if (existing->sk_state == TCP_ESTABLISHED) {
94 sk = existing;
95 goto out_put;
96 } else
97 sock_put(existing);
98 }
99 sock_hold(sk);
100 rc = -ENOMEM;
101 skb = alloc_skb(0, GFP_ATOMIC);
102 if (skb) {
103 struct llc_conn_state_ev *ev = llc_conn_ev(skb);
104
105 ev->type = LLC_CONN_EV_TYPE_PRIM;
106 ev->prim = LLC_CONN_PRIM;
107 ev->prim_type = LLC_PRIM_TYPE_REQ;
108 skb_set_owner_w(skb, sk);
109 rc = llc_conn_state_process(sk, skb);
110 }
111out_put:
112 sock_put(sk);
113 return rc;
114}
115
116/**
117 * llc_send_disc - Called by upper layer to close a connection
118 * @sk: connection to be closed
119 *
120 * Upper layer calls this when it wants to close an established LLC
121 * connection with a remote machine. This function packages a proper event
122 * and sends it to connection component state machine. Returns 0 for
123 * success, 1 otherwise.
124 */
125int llc_send_disc(struct sock *sk)
126{
127 u16 rc = 1;
128 struct llc_conn_state_ev *ev;
129 struct sk_buff *skb;
130
131 sock_hold(sk);
132 if (sk->sk_type != SOCK_STREAM || sk->sk_state != TCP_ESTABLISHED ||
133 llc_sk(sk)->state == LLC_CONN_STATE_ADM ||
134 llc_sk(sk)->state == LLC_CONN_OUT_OF_SVC)
135 goto out;
136 /*
137 * Postpone unassigning the connection from its SAP and returning the
138 * connection until all ACTIONs have been completely executed
139 */
140 skb = alloc_skb(0, GFP_ATOMIC);
141 if (!skb)
142 goto out;
143 skb_set_owner_w(skb, sk);
144 sk->sk_state = TCP_CLOSING;
145 ev = llc_conn_ev(skb);
146 ev->type = LLC_CONN_EV_TYPE_PRIM;
147 ev->prim = LLC_DISC_PRIM;
148 ev->prim_type = LLC_PRIM_TYPE_REQ;
149 rc = llc_conn_state_process(sk, skb);
150out:
151 sock_put(sk);
152 return rc;
153}
154
1/*
2 * llc_if.c - Defines LLC interface to upper layer
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#include <linux/gfp.h>
15#include <linux/module.h>
16#include <linux/kernel.h>
17#include <linux/netdevice.h>
18#include <linux/errno.h>
19#include <net/llc_if.h>
20#include <net/llc_sap.h>
21#include <net/llc_s_ev.h>
22#include <net/llc_conn.h>
23#include <net/sock.h>
24#include <net/llc_c_ev.h>
25#include <net/llc_c_ac.h>
26#include <net/llc_c_st.h>
27#include <net/tcp_states.h>
28
29/**
30 * llc_build_and_send_pkt - Connection data sending for upper layers.
31 * @sk: connection
32 * @skb: packet to send
33 *
34 * This function is called when upper layer wants to send data using
35 * connection oriented communication mode. During sending data, connection
36 * will be locked and received frames and expired timers will be queued.
37 * Returns 0 for success, -ECONNABORTED when the connection already
38 * closed and -EBUSY when sending data is not permitted in this state or
39 * LLC has send an I pdu with p bit set to 1 and is waiting for it's
40 * response.
41 *
42 * This function always consumes a reference to the skb.
43 */
44int llc_build_and_send_pkt(struct sock *sk, struct sk_buff *skb)
45{
46 struct llc_conn_state_ev *ev;
47 int rc = -ECONNABORTED;
48 struct llc_sock *llc = llc_sk(sk);
49
50 if (unlikely(llc->state == LLC_CONN_STATE_ADM))
51 goto out_free;
52 rc = -EBUSY;
53 if (unlikely(llc_data_accept_state(llc->state) || /* data_conn_refuse */
54 llc->p_flag)) {
55 llc->failed_data_req = 1;
56 goto out_free;
57 }
58 ev = llc_conn_ev(skb);
59 ev->type = LLC_CONN_EV_TYPE_PRIM;
60 ev->prim = LLC_DATA_PRIM;
61 ev->prim_type = LLC_PRIM_TYPE_REQ;
62 skb->dev = llc->dev;
63 return llc_conn_state_process(sk, skb);
64
65out_free:
66 kfree_skb(skb);
67 return rc;
68}
69
70/**
71 * llc_establish_connection - Called by upper layer to establish a conn
72 * @sk: connection
73 * @lmac: local mac address
74 * @dmac: destination mac address
75 * @dsap: destination sap
76 *
77 * Upper layer calls this to establish an LLC connection with a remote
78 * machine. This function packages a proper event and sends it connection
79 * component state machine. Success or failure of connection
80 * establishment will inform to upper layer via calling it's confirm
81 * function and passing proper information.
82 */
83int llc_establish_connection(struct sock *sk, const u8 *lmac, u8 *dmac, u8 dsap)
84{
85 int rc = -EISCONN;
86 struct llc_addr laddr, daddr;
87 struct sk_buff *skb;
88 struct llc_sock *llc = llc_sk(sk);
89 struct sock *existing;
90
91 laddr.lsap = llc->sap->laddr.lsap;
92 daddr.lsap = dsap;
93 memcpy(daddr.mac, dmac, sizeof(daddr.mac));
94 memcpy(laddr.mac, lmac, sizeof(laddr.mac));
95 existing = llc_lookup_established(llc->sap, &daddr, &laddr);
96 if (existing) {
97 if (existing->sk_state == TCP_ESTABLISHED) {
98 sk = existing;
99 goto out_put;
100 } else
101 sock_put(existing);
102 }
103 sock_hold(sk);
104 rc = -ENOMEM;
105 skb = alloc_skb(0, GFP_ATOMIC);
106 if (skb) {
107 struct llc_conn_state_ev *ev = llc_conn_ev(skb);
108
109 ev->type = LLC_CONN_EV_TYPE_PRIM;
110 ev->prim = LLC_CONN_PRIM;
111 ev->prim_type = LLC_PRIM_TYPE_REQ;
112 skb_set_owner_w(skb, sk);
113 rc = llc_conn_state_process(sk, skb);
114 }
115out_put:
116 sock_put(sk);
117 return rc;
118}
119
120/**
121 * llc_send_disc - Called by upper layer to close a connection
122 * @sk: connection to be closed
123 *
124 * Upper layer calls this when it wants to close an established LLC
125 * connection with a remote machine. This function packages a proper event
126 * and sends it to connection component state machine. Returns 0 for
127 * success, 1 otherwise.
128 */
129int llc_send_disc(struct sock *sk)
130{
131 u16 rc = 1;
132 struct llc_conn_state_ev *ev;
133 struct sk_buff *skb;
134
135 sock_hold(sk);
136 if (sk->sk_type != SOCK_STREAM || sk->sk_state != TCP_ESTABLISHED ||
137 llc_sk(sk)->state == LLC_CONN_STATE_ADM ||
138 llc_sk(sk)->state == LLC_CONN_OUT_OF_SVC)
139 goto out;
140 /*
141 * Postpone unassigning the connection from its SAP and returning the
142 * connection until all ACTIONs have been completely executed
143 */
144 skb = alloc_skb(0, GFP_ATOMIC);
145 if (!skb)
146 goto out;
147 skb_set_owner_w(skb, sk);
148 sk->sk_state = TCP_CLOSING;
149 ev = llc_conn_ev(skb);
150 ev->type = LLC_CONN_EV_TYPE_PRIM;
151 ev->prim = LLC_DISC_PRIM;
152 ev->prim_type = LLC_PRIM_TYPE_REQ;
153 rc = llc_conn_state_process(sk, skb);
154out:
155 sock_put(sk);
156 return rc;
157}