mac80211 & nl80211: add support to abort a scan request on tx
[linux-2.6.git] / net / x25 / x25_dev.c
1 /*
2  *      X.25 Packet Layer release 002
3  *
4  *      This is ALPHA test software. This code may break your machine, randomly fail to work with new
5  *      releases, misbehave and/or generally screw up. It might even work.
6  *
7  *      This code REQUIRES 2.1.15 or higher
8  *
9  *      This module:
10  *              This module is free software; you can redistribute it and/or
11  *              modify it under the terms of the GNU General Public License
12  *              as published by the Free Software Foundation; either version
13  *              2 of the License, or (at your option) any later version.
14  *
15  *      History
16  *      X.25 001        Jonathan Naylor Started coding.
17  *      2000-09-04      Henner Eisen    Prevent freeing a dangling skb.
18  */
19
20 #include <linux/kernel.h>
21 #include <linux/netdevice.h>
22 #include <linux/skbuff.h>
23 #include <linux/slab.h>
24 #include <net/sock.h>
25 #include <linux/if_arp.h>
26 #include <net/x25.h>
27 #include <net/x25device.h>
28
29 static int x25_receive_data(struct sk_buff *skb, struct x25_neigh *nb)
30 {
31         struct sock *sk;
32         unsigned short frametype;
33         unsigned int lci;
34
35         if (!pskb_may_pull(skb, X25_STD_MIN_LEN))
36                 return 0;
37
38         frametype = skb->data[2];
39         lci = ((skb->data[0] << 8) & 0xF00) + ((skb->data[1] << 0) & 0x0FF);
40
41         /*
42          *      LCI of zero is always for us, and its always a link control
43          *      frame.
44          */
45         if (lci == 0) {
46                 x25_link_control(skb, nb, frametype);
47                 return 0;
48         }
49
50         /*
51          *      Find an existing socket.
52          */
53         if ((sk = x25_find_socket(lci, nb)) != NULL) {
54                 int queued = 1;
55
56                 skb_reset_transport_header(skb);
57                 bh_lock_sock(sk);
58                 if (!sock_owned_by_user(sk)) {
59                         queued = x25_process_rx_frame(sk, skb);
60                 } else {
61                         queued = !sk_add_backlog(sk, skb);
62                 }
63                 bh_unlock_sock(sk);
64                 sock_put(sk);
65                 return queued;
66         }
67
68         /*
69          *      Is is a Call Request ? if so process it.
70          */
71         if (frametype == X25_CALL_REQUEST)
72                 return x25_rx_call_request(skb, nb, lci);
73
74         /*
75          *      Its not a Call Request, nor is it a control frame.
76          *      Can we forward it?
77          */
78
79         if (x25_forward_data(lci, nb, skb)) {
80                 if (frametype == X25_CLEAR_CONFIRMATION) {
81                         x25_clear_forward_by_lci(lci);
82                 }
83                 kfree_skb(skb);
84                 return 1;
85         }
86
87 /*
88         x25_transmit_clear_request(nb, lci, 0x0D);
89 */
90
91         if (frametype != X25_CLEAR_CONFIRMATION)
92                 printk(KERN_DEBUG "x25_receive_data(): unknown frame type %2x\n",frametype);
93
94         return 0;
95 }
96
97 int x25_lapb_receive_frame(struct sk_buff *skb, struct net_device *dev,
98                            struct packet_type *ptype, struct net_device *orig_dev)
99 {
100         struct sk_buff *nskb;
101         struct x25_neigh *nb;
102
103         if (!net_eq(dev_net(dev), &init_net))
104                 goto drop;
105
106         nskb = skb_copy(skb, GFP_ATOMIC);
107         if (!nskb)
108                 goto drop;
109         kfree_skb(skb);
110         skb = nskb;
111
112         /*
113          * Packet received from unrecognised device, throw it away.
114          */
115         nb = x25_get_neigh(dev);
116         if (!nb) {
117                 printk(KERN_DEBUG "X.25: unknown neighbour - %s\n", dev->name);
118                 goto drop;
119         }
120
121         if (!pskb_may_pull(skb, 1))
122                 return 0;
123
124         switch (skb->data[0]) {
125
126         case X25_IFACE_DATA:
127                 skb_pull(skb, 1);
128                 if (x25_receive_data(skb, nb)) {
129                         x25_neigh_put(nb);
130                         goto out;
131                 }
132                 break;
133
134         case X25_IFACE_CONNECT:
135                 x25_link_established(nb);
136                 break;
137
138         case X25_IFACE_DISCONNECT:
139                 x25_link_terminated(nb);
140                 break;
141         }
142         x25_neigh_put(nb);
143 drop:
144         kfree_skb(skb);
145 out:
146         return 0;
147 }
148
149 void x25_establish_link(struct x25_neigh *nb)
150 {
151         struct sk_buff *skb;
152         unsigned char *ptr;
153
154         switch (nb->dev->type) {
155         case ARPHRD_X25:
156                 if ((skb = alloc_skb(1, GFP_ATOMIC)) == NULL) {
157                         printk(KERN_ERR "x25_dev: out of memory\n");
158                         return;
159                 }
160                 ptr  = skb_put(skb, 1);
161                 *ptr = X25_IFACE_CONNECT;
162                 break;
163
164 #if defined(CONFIG_LLC) || defined(CONFIG_LLC_MODULE)
165         case ARPHRD_ETHER:
166                 return;
167 #endif
168         default:
169                 return;
170         }
171
172         skb->protocol = htons(ETH_P_X25);
173         skb->dev      = nb->dev;
174
175         dev_queue_xmit(skb);
176 }
177
178 void x25_terminate_link(struct x25_neigh *nb)
179 {
180         struct sk_buff *skb;
181         unsigned char *ptr;
182
183 #if defined(CONFIG_LLC) || defined(CONFIG_LLC_MODULE)
184         if (nb->dev->type == ARPHRD_ETHER)
185                 return;
186 #endif
187         if (nb->dev->type != ARPHRD_X25)
188                 return;
189
190         skb = alloc_skb(1, GFP_ATOMIC);
191         if (!skb) {
192                 printk(KERN_ERR "x25_dev: out of memory\n");
193                 return;
194         }
195
196         ptr  = skb_put(skb, 1);
197         *ptr = X25_IFACE_DISCONNECT;
198
199         skb->protocol = htons(ETH_P_X25);
200         skb->dev      = nb->dev;
201         dev_queue_xmit(skb);
202 }
203
204 void x25_send_frame(struct sk_buff *skb, struct x25_neigh *nb)
205 {
206         unsigned char *dptr;
207
208         skb_reset_network_header(skb);
209
210         switch (nb->dev->type) {
211         case ARPHRD_X25:
212                 dptr  = skb_push(skb, 1);
213                 *dptr = X25_IFACE_DATA;
214                 break;
215
216 #if defined(CONFIG_LLC) || defined(CONFIG_LLC_MODULE)
217         case ARPHRD_ETHER:
218                 kfree_skb(skb);
219                 return;
220 #endif
221         default:
222                 kfree_skb(skb);
223                 return;
224         }
225
226         skb->protocol = htons(ETH_P_X25);
227         skb->dev      = nb->dev;
228
229         dev_queue_xmit(skb);
230 }