Merge branch 'x86-cleanups-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[sfrench/cifs-2.6.git] / net / x25 / x25_link.c
1 /*
2  *      X.25 Packet Layer release 002
3  *
4  *      This is ALPHA test software. This code may break your machine,
5  *      randomly fail to work with new releases, misbehave and/or generally
6  *      screw up. It might even work.
7  *
8  *      This code REQUIRES 2.1.15 or higher
9  *
10  *      This module:
11  *              This module is free software; you can redistribute it and/or
12  *              modify it under the terms of the GNU General Public License
13  *              as published by the Free Software Foundation; either version
14  *              2 of the License, or (at your option) any later version.
15  *
16  *      History
17  *      X.25 001        Jonathan Naylor   Started coding.
18  *      X.25 002        Jonathan Naylor   New timer architecture.
19  *      mar/20/00       Daniela Squassoni Disabling/enabling of facilities
20  *                                        negotiation.
21  *      2000-09-04      Henner Eisen      dev_hold() / dev_put() for x25_neigh.
22  */
23
24 #define pr_fmt(fmt) "X25: " fmt
25
26 #include <linux/kernel.h>
27 #include <linux/jiffies.h>
28 #include <linux/timer.h>
29 #include <linux/slab.h>
30 #include <linux/netdevice.h>
31 #include <linux/skbuff.h>
32 #include <linux/uaccess.h>
33 #include <linux/init.h>
34 #include <net/x25.h>
35
36 LIST_HEAD(x25_neigh_list);
37 DEFINE_RWLOCK(x25_neigh_list_lock);
38
39 static void x25_t20timer_expiry(struct timer_list *);
40
41 static void x25_transmit_restart_confirmation(struct x25_neigh *nb);
42 static void x25_transmit_restart_request(struct x25_neigh *nb);
43
44 /*
45  *      Linux set/reset timer routines
46  */
47 static inline void x25_start_t20timer(struct x25_neigh *nb)
48 {
49         mod_timer(&nb->t20timer, jiffies + nb->t20);
50 }
51
52 static void x25_t20timer_expiry(struct timer_list *t)
53 {
54         struct x25_neigh *nb = from_timer(nb, t, t20timer);
55
56         x25_transmit_restart_request(nb);
57
58         x25_start_t20timer(nb);
59 }
60
61 static inline void x25_stop_t20timer(struct x25_neigh *nb)
62 {
63         del_timer(&nb->t20timer);
64 }
65
66 static inline int x25_t20timer_pending(struct x25_neigh *nb)
67 {
68         return timer_pending(&nb->t20timer);
69 }
70
71 /*
72  *      This handles all restart and diagnostic frames.
73  */
74 void x25_link_control(struct sk_buff *skb, struct x25_neigh *nb,
75                       unsigned short frametype)
76 {
77         struct sk_buff *skbn;
78         int confirm;
79
80         switch (frametype) {
81         case X25_RESTART_REQUEST:
82                 confirm = !x25_t20timer_pending(nb);
83                 x25_stop_t20timer(nb);
84                 nb->state = X25_LINK_STATE_3;
85                 if (confirm)
86                         x25_transmit_restart_confirmation(nb);
87                 break;
88
89         case X25_RESTART_CONFIRMATION:
90                 x25_stop_t20timer(nb);
91                 nb->state = X25_LINK_STATE_3;
92                 break;
93
94         case X25_DIAGNOSTIC:
95                 if (!pskb_may_pull(skb, X25_STD_MIN_LEN + 4))
96                         break;
97
98                 pr_warn("diagnostic #%d - %02X %02X %02X\n",
99                        skb->data[3], skb->data[4],
100                        skb->data[5], skb->data[6]);
101                 break;
102
103         default:
104                 pr_warn("received unknown %02X with LCI 000\n",
105                        frametype);
106                 break;
107         }
108
109         if (nb->state == X25_LINK_STATE_3)
110                 while ((skbn = skb_dequeue(&nb->queue)) != NULL)
111                         x25_send_frame(skbn, nb);
112 }
113
114 /*
115  *      This routine is called when a Restart Request is needed
116  */
117 static void x25_transmit_restart_request(struct x25_neigh *nb)
118 {
119         unsigned char *dptr;
120         int len = X25_MAX_L2_LEN + X25_STD_MIN_LEN + 2;
121         struct sk_buff *skb = alloc_skb(len, GFP_ATOMIC);
122
123         if (!skb)
124                 return;
125
126         skb_reserve(skb, X25_MAX_L2_LEN);
127
128         dptr = skb_put(skb, X25_STD_MIN_LEN + 2);
129
130         *dptr++ = nb->extended ? X25_GFI_EXTSEQ : X25_GFI_STDSEQ;
131         *dptr++ = 0x00;
132         *dptr++ = X25_RESTART_REQUEST;
133         *dptr++ = 0x00;
134         *dptr++ = 0;
135
136         skb->sk = NULL;
137
138         x25_send_frame(skb, nb);
139 }
140
141 /*
142  * This routine is called when a Restart Confirmation is needed
143  */
144 static void x25_transmit_restart_confirmation(struct x25_neigh *nb)
145 {
146         unsigned char *dptr;
147         int len = X25_MAX_L2_LEN + X25_STD_MIN_LEN;
148         struct sk_buff *skb = alloc_skb(len, GFP_ATOMIC);
149
150         if (!skb)
151                 return;
152
153         skb_reserve(skb, X25_MAX_L2_LEN);
154
155         dptr = skb_put(skb, X25_STD_MIN_LEN);
156
157         *dptr++ = nb->extended ? X25_GFI_EXTSEQ : X25_GFI_STDSEQ;
158         *dptr++ = 0x00;
159         *dptr++ = X25_RESTART_CONFIRMATION;
160
161         skb->sk = NULL;
162
163         x25_send_frame(skb, nb);
164 }
165
166 /*
167  *      This routine is called when a Clear Request is needed outside of the context
168  *      of a connected socket.
169  */
170 void x25_transmit_clear_request(struct x25_neigh *nb, unsigned int lci,
171                                 unsigned char cause)
172 {
173         unsigned char *dptr;
174         int len = X25_MAX_L2_LEN + X25_STD_MIN_LEN + 2;
175         struct sk_buff *skb = alloc_skb(len, GFP_ATOMIC);
176
177         if (!skb)
178                 return;
179
180         skb_reserve(skb, X25_MAX_L2_LEN);
181
182         dptr = skb_put(skb, X25_STD_MIN_LEN + 2);
183
184         *dptr++ = ((lci >> 8) & 0x0F) | (nb->extended ?
185                                          X25_GFI_EXTSEQ :
186                                          X25_GFI_STDSEQ);
187         *dptr++ = (lci >> 0) & 0xFF;
188         *dptr++ = X25_CLEAR_REQUEST;
189         *dptr++ = cause;
190         *dptr++ = 0x00;
191
192         skb->sk = NULL;
193
194         x25_send_frame(skb, nb);
195 }
196
197 void x25_transmit_link(struct sk_buff *skb, struct x25_neigh *nb)
198 {
199         switch (nb->state) {
200         case X25_LINK_STATE_0:
201                 skb_queue_tail(&nb->queue, skb);
202                 nb->state = X25_LINK_STATE_1;
203                 x25_establish_link(nb);
204                 break;
205         case X25_LINK_STATE_1:
206         case X25_LINK_STATE_2:
207                 skb_queue_tail(&nb->queue, skb);
208                 break;
209         case X25_LINK_STATE_3:
210                 x25_send_frame(skb, nb);
211                 break;
212         }
213 }
214
215 /*
216  *      Called when the link layer has become established.
217  */
218 void x25_link_established(struct x25_neigh *nb)
219 {
220         switch (nb->state) {
221         case X25_LINK_STATE_0:
222                 nb->state = X25_LINK_STATE_2;
223                 break;
224         case X25_LINK_STATE_1:
225                 x25_transmit_restart_request(nb);
226                 nb->state = X25_LINK_STATE_2;
227                 x25_start_t20timer(nb);
228                 break;
229         }
230 }
231
232 /*
233  *      Called when the link layer has terminated, or an establishment
234  *      request has failed.
235  */
236
237 void x25_link_terminated(struct x25_neigh *nb)
238 {
239         nb->state = X25_LINK_STATE_0;
240         /* Out of order: clear existing virtual calls (X.25 03/93 4.6.3) */
241         x25_kill_by_neigh(nb);
242 }
243
244 /*
245  *      Add a new device.
246  */
247 void x25_link_device_up(struct net_device *dev)
248 {
249         struct x25_neigh *nb = kmalloc(sizeof(*nb), GFP_ATOMIC);
250
251         if (!nb)
252                 return;
253
254         skb_queue_head_init(&nb->queue);
255         timer_setup(&nb->t20timer, x25_t20timer_expiry, 0);
256
257         dev_hold(dev);
258         nb->dev      = dev;
259         nb->state    = X25_LINK_STATE_0;
260         nb->extended = 0;
261         /*
262          * Enables negotiation
263          */
264         nb->global_facil_mask = X25_MASK_REVERSE |
265                                        X25_MASK_THROUGHPUT |
266                                        X25_MASK_PACKET_SIZE |
267                                        X25_MASK_WINDOW_SIZE;
268         nb->t20      = sysctl_x25_restart_request_timeout;
269         refcount_set(&nb->refcnt, 1);
270
271         write_lock_bh(&x25_neigh_list_lock);
272         list_add(&nb->node, &x25_neigh_list);
273         write_unlock_bh(&x25_neigh_list_lock);
274 }
275
276 /**
277  *      __x25_remove_neigh - remove neighbour from x25_neigh_list
278  *      @nb - neigh to remove
279  *
280  *      Remove neighbour from x25_neigh_list. If it was there.
281  *      Caller must hold x25_neigh_list_lock.
282  */
283 static void __x25_remove_neigh(struct x25_neigh *nb)
284 {
285         skb_queue_purge(&nb->queue);
286         x25_stop_t20timer(nb);
287
288         if (nb->node.next) {
289                 list_del(&nb->node);
290                 x25_neigh_put(nb);
291         }
292 }
293
294 /*
295  *      A device has been removed, remove its links.
296  */
297 void x25_link_device_down(struct net_device *dev)
298 {
299         struct x25_neigh *nb;
300         struct list_head *entry, *tmp;
301
302         write_lock_bh(&x25_neigh_list_lock);
303
304         list_for_each_safe(entry, tmp, &x25_neigh_list) {
305                 nb = list_entry(entry, struct x25_neigh, node);
306
307                 if (nb->dev == dev) {
308                         __x25_remove_neigh(nb);
309                         dev_put(dev);
310                 }
311         }
312
313         write_unlock_bh(&x25_neigh_list_lock);
314 }
315
316 /*
317  *      Given a device, return the neighbour address.
318  */
319 struct x25_neigh *x25_get_neigh(struct net_device *dev)
320 {
321         struct x25_neigh *nb, *use = NULL;
322         struct list_head *entry;
323
324         read_lock_bh(&x25_neigh_list_lock);
325         list_for_each(entry, &x25_neigh_list) {
326                 nb = list_entry(entry, struct x25_neigh, node);
327
328                 if (nb->dev == dev) {
329                         use = nb;
330                         break;
331                 }
332         }
333
334         if (use)
335                 x25_neigh_hold(use);
336         read_unlock_bh(&x25_neigh_list_lock);
337         return use;
338 }
339
340 /*
341  *      Handle the ioctls that control the subscription functions.
342  */
343 int x25_subscr_ioctl(unsigned int cmd, void __user *arg)
344 {
345         struct x25_subscrip_struct x25_subscr;
346         struct x25_neigh *nb;
347         struct net_device *dev;
348         int rc = -EINVAL;
349
350         if (cmd != SIOCX25GSUBSCRIP && cmd != SIOCX25SSUBSCRIP)
351                 goto out;
352
353         rc = -EFAULT;
354         if (copy_from_user(&x25_subscr, arg, sizeof(x25_subscr)))
355                 goto out;
356
357         rc = -EINVAL;
358         if ((dev = x25_dev_get(x25_subscr.device)) == NULL)
359                 goto out;
360
361         if ((nb = x25_get_neigh(dev)) == NULL)
362                 goto out_dev_put;
363
364         dev_put(dev);
365
366         if (cmd == SIOCX25GSUBSCRIP) {
367                 read_lock_bh(&x25_neigh_list_lock);
368                 x25_subscr.extended          = nb->extended;
369                 x25_subscr.global_facil_mask = nb->global_facil_mask;
370                 read_unlock_bh(&x25_neigh_list_lock);
371                 rc = copy_to_user(arg, &x25_subscr,
372                                   sizeof(x25_subscr)) ? -EFAULT : 0;
373         } else {
374                 rc = -EINVAL;
375                 if (!(x25_subscr.extended && x25_subscr.extended != 1)) {
376                         rc = 0;
377                         write_lock_bh(&x25_neigh_list_lock);
378                         nb->extended         = x25_subscr.extended;
379                         nb->global_facil_mask = x25_subscr.global_facil_mask;
380                         write_unlock_bh(&x25_neigh_list_lock);
381                 }
382         }
383         x25_neigh_put(nb);
384 out:
385         return rc;
386 out_dev_put:
387         dev_put(dev);
388         goto out;
389 }
390
391
392 /*
393  *      Release all memory associated with X.25 neighbour structures.
394  */
395 void __exit x25_link_free(void)
396 {
397         struct x25_neigh *nb;
398         struct list_head *entry, *tmp;
399
400         write_lock_bh(&x25_neigh_list_lock);
401
402         list_for_each_safe(entry, tmp, &x25_neigh_list) {
403                 struct net_device *dev;
404
405                 nb = list_entry(entry, struct x25_neigh, node);
406                 dev = nb->dev;
407                 __x25_remove_neigh(nb);
408                 dev_put(dev);
409         }
410         write_unlock_bh(&x25_neigh_list_lock);
411 }