ax25: netrom: rose: Fix timer oopses
[linux-3.10.git] / net / ax25 / af_ax25.c
1 /*
2  * This program is free software; you can redistribute it and/or modify
3  * it under the terms of the GNU General Public License as published by
4  * the Free Software Foundation; either version 2 of the License, or
5  * (at your option) any later version.
6  *
7  * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
8  * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
9  * Copyright (C) Darryl Miles G7LED (dlm@g7led.demon.co.uk)
10  * Copyright (C) Steven Whitehouse GW7RRM (stevew@acm.org)
11  * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
12  * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de)
13  * Copyright (C) Hans Alblas PE1AYX (hans@esrac.ele.tue.nl)
14  * Copyright (C) Frederic Rible F1OAT (frible@teaser.fr)
15  */
16 #include <linux/capability.h>
17 #include <linux/module.h>
18 #include <linux/errno.h>
19 #include <linux/types.h>
20 #include <linux/socket.h>
21 #include <linux/in.h>
22 #include <linux/kernel.h>
23 #include <linux/sched.h>
24 #include <linux/timer.h>
25 #include <linux/string.h>
26 #include <linux/sockios.h>
27 #include <linux/net.h>
28 #include <net/ax25.h>
29 #include <linux/inet.h>
30 #include <linux/netdevice.h>
31 #include <linux/if_arp.h>
32 #include <linux/skbuff.h>
33 #include <net/sock.h>
34 #include <asm/uaccess.h>
35 #include <asm/system.h>
36 #include <linux/fcntl.h>
37 #include <linux/termios.h>      /* For TIOCINQ/OUTQ */
38 #include <linux/mm.h>
39 #include <linux/interrupt.h>
40 #include <linux/notifier.h>
41 #include <linux/proc_fs.h>
42 #include <linux/stat.h>
43 #include <linux/netfilter.h>
44 #include <linux/sysctl.h>
45 #include <linux/init.h>
46 #include <linux/spinlock.h>
47 #include <net/net_namespace.h>
48 #include <net/tcp_states.h>
49 #include <net/ip.h>
50 #include <net/arp.h>
51
52
53
54 HLIST_HEAD(ax25_list);
55 DEFINE_SPINLOCK(ax25_list_lock);
56
57 static const struct proto_ops ax25_proto_ops;
58
59 static void ax25_free_sock(struct sock *sk)
60 {
61         ax25_cb_put(ax25_sk(sk));
62 }
63
64 /*
65  *      Socket removal during an interrupt is now safe.
66  */
67 static void ax25_cb_del(ax25_cb *ax25)
68 {
69         if (!hlist_unhashed(&ax25->ax25_node)) {
70                 spin_lock_bh(&ax25_list_lock);
71                 hlist_del_init(&ax25->ax25_node);
72                 spin_unlock_bh(&ax25_list_lock);
73                 ax25_cb_put(ax25);
74         }
75 }
76
77 /*
78  *      Kill all bound sockets on a dropped device.
79  */
80 static void ax25_kill_by_device(struct net_device *dev)
81 {
82         ax25_dev *ax25_dev;
83         ax25_cb *s;
84         struct hlist_node *node;
85
86         if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
87                 return;
88
89         spin_lock_bh(&ax25_list_lock);
90 again:
91         ax25_for_each(s, node, &ax25_list) {
92                 if (s->ax25_dev == ax25_dev) {
93                         s->ax25_dev = NULL;
94                         spin_unlock_bh(&ax25_list_lock);
95                         ax25_disconnect(s, ENETUNREACH);
96                         spin_lock_bh(&ax25_list_lock);
97
98                         /* The entry could have been deleted from the
99                          * list meanwhile and thus the next pointer is
100                          * no longer valid.  Play it safe and restart
101                          * the scan.  Forward progress is ensured
102                          * because we set s->ax25_dev to NULL and we
103                          * are never passed a NULL 'dev' argument.
104                          */
105                         goto again;
106                 }
107         }
108         spin_unlock_bh(&ax25_list_lock);
109 }
110
111 /*
112  *      Handle device status changes.
113  */
114 static int ax25_device_event(struct notifier_block *this, unsigned long event,
115         void *ptr)
116 {
117         struct net_device *dev = (struct net_device *)ptr;
118
119         if (!net_eq(dev_net(dev), &init_net))
120                 return NOTIFY_DONE;
121
122         /* Reject non AX.25 devices */
123         if (dev->type != ARPHRD_AX25)
124                 return NOTIFY_DONE;
125
126         switch (event) {
127         case NETDEV_UP:
128                 ax25_dev_device_up(dev);
129                 break;
130         case NETDEV_DOWN:
131                 ax25_kill_by_device(dev);
132                 ax25_rt_device_down(dev);
133                 ax25_dev_device_down(dev);
134                 break;
135         default:
136                 break;
137         }
138
139         return NOTIFY_DONE;
140 }
141
142 /*
143  *      Add a socket to the bound sockets list.
144  */
145 void ax25_cb_add(ax25_cb *ax25)
146 {
147         spin_lock_bh(&ax25_list_lock);
148         ax25_cb_hold(ax25);
149         hlist_add_head(&ax25->ax25_node, &ax25_list);
150         spin_unlock_bh(&ax25_list_lock);
151 }
152
153 /*
154  *      Find a socket that wants to accept the SABM we have just
155  *      received.
156  */
157 struct sock *ax25_find_listener(ax25_address *addr, int digi,
158         struct net_device *dev, int type)
159 {
160         ax25_cb *s;
161         struct hlist_node *node;
162
163         spin_lock(&ax25_list_lock);
164         ax25_for_each(s, node, &ax25_list) {
165                 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
166                         continue;
167                 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
168                     s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
169                         /* If device is null we match any device */
170                         if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
171                                 sock_hold(s->sk);
172                                 spin_unlock(&ax25_list_lock);
173                                 return s->sk;
174                         }
175                 }
176         }
177         spin_unlock(&ax25_list_lock);
178
179         return NULL;
180 }
181
182 /*
183  *      Find an AX.25 socket given both ends.
184  */
185 struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
186         int type)
187 {
188         struct sock *sk = NULL;
189         ax25_cb *s;
190         struct hlist_node *node;
191
192         spin_lock(&ax25_list_lock);
193         ax25_for_each(s, node, &ax25_list) {
194                 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
195                     !ax25cmp(&s->dest_addr, dest_addr) &&
196                     s->sk->sk_type == type) {
197                         sk = s->sk;
198                         sock_hold(sk);
199                         break;
200                 }
201         }
202
203         spin_unlock(&ax25_list_lock);
204
205         return sk;
206 }
207
208 /*
209  *      Find an AX.25 control block given both ends. It will only pick up
210  *      floating AX.25 control blocks or non Raw socket bound control blocks.
211  */
212 ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
213         ax25_digi *digi, struct net_device *dev)
214 {
215         ax25_cb *s;
216         struct hlist_node *node;
217
218         spin_lock_bh(&ax25_list_lock);
219         ax25_for_each(s, node, &ax25_list) {
220                 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
221                         continue;
222                 if (s->ax25_dev == NULL)
223                         continue;
224                 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
225                         if (digi != NULL && digi->ndigi != 0) {
226                                 if (s->digipeat == NULL)
227                                         continue;
228                                 if (ax25digicmp(s->digipeat, digi) != 0)
229                                         continue;
230                         } else {
231                                 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
232                                         continue;
233                         }
234                         ax25_cb_hold(s);
235                         spin_unlock_bh(&ax25_list_lock);
236
237                         return s;
238                 }
239         }
240         spin_unlock_bh(&ax25_list_lock);
241
242         return NULL;
243 }
244
245 EXPORT_SYMBOL(ax25_find_cb);
246
247 void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
248 {
249         ax25_cb *s;
250         struct sk_buff *copy;
251         struct hlist_node *node;
252
253         spin_lock(&ax25_list_lock);
254         ax25_for_each(s, node, &ax25_list) {
255                 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
256                     s->sk->sk_type == SOCK_RAW &&
257                     s->sk->sk_protocol == proto &&
258                     s->ax25_dev->dev == skb->dev &&
259                     atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
260                         if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
261                                 continue;
262                         if (sock_queue_rcv_skb(s->sk, copy) != 0)
263                                 kfree_skb(copy);
264                 }
265         }
266         spin_unlock(&ax25_list_lock);
267 }
268
269 /*
270  *      Deferred destroy.
271  */
272 void ax25_destroy_socket(ax25_cb *);
273
274 /*
275  *      Handler for deferred kills.
276  */
277 static void ax25_destroy_timer(unsigned long data)
278 {
279         ax25_cb *ax25=(ax25_cb *)data;
280         struct sock *sk;
281
282         sk=ax25->sk;
283
284         bh_lock_sock(sk);
285         sock_hold(sk);
286         ax25_destroy_socket(ax25);
287         bh_unlock_sock(sk);
288         sock_put(sk);
289 }
290
291 /*
292  *      This is called from user mode and the timers. Thus it protects itself
293  *      against interrupt users but doesn't worry about being called during
294  *      work. Once it is removed from the queue no interrupt or bottom half
295  *      will touch it and we are (fairly 8-) ) safe.
296  */
297 void ax25_destroy_socket(ax25_cb *ax25)
298 {
299         struct sk_buff *skb;
300
301         ax25_cb_del(ax25);
302
303         ax25_stop_heartbeat(ax25);
304         ax25_stop_t1timer(ax25);
305         ax25_stop_t2timer(ax25);
306         ax25_stop_t3timer(ax25);
307         ax25_stop_idletimer(ax25);
308
309         ax25_clear_queues(ax25);        /* Flush the queues */
310
311         if (ax25->sk != NULL) {
312                 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
313                         if (skb->sk != ax25->sk) {
314                                 /* A pending connection */
315                                 ax25_cb *sax25 = ax25_sk(skb->sk);
316
317                                 /* Queue the unaccepted socket for death */
318                                 sock_orphan(skb->sk);
319
320                                 /* 9A4GL: hack to release unaccepted sockets */
321                                 skb->sk->sk_state = TCP_LISTEN;
322
323                                 ax25_start_heartbeat(sax25);
324                                 sax25->state = AX25_STATE_0;
325                         }
326
327                         kfree_skb(skb);
328                 }
329                 skb_queue_purge(&ax25->sk->sk_write_queue);
330         }
331
332         if (ax25->sk != NULL) {
333                 if (sk_has_allocations(ax25->sk)) {
334                         /* Defer: outstanding buffers */
335                         setup_timer(&ax25->dtimer, ax25_destroy_timer,
336                                         (unsigned long)ax25);
337                         ax25->dtimer.expires  = jiffies + 2 * HZ;
338                         add_timer(&ax25->dtimer);
339                 } else {
340                         struct sock *sk=ax25->sk;
341                         ax25->sk=NULL;
342                         sock_put(sk);
343                 }
344         } else {
345                 ax25_cb_put(ax25);
346         }
347 }
348
349 /*
350  * dl1bke 960311: set parameters for existing AX.25 connections,
351  *                includes a KILL command to abort any connection.
352  *                VERY useful for debugging ;-)
353  */
354 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
355 {
356         struct ax25_ctl_struct ax25_ctl;
357         ax25_digi digi;
358         ax25_dev *ax25_dev;
359         ax25_cb *ax25;
360         unsigned int k;
361         int ret = 0;
362
363         if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
364                 return -EFAULT;
365
366         if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
367                 return -ENODEV;
368
369         if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
370                 return -EINVAL;
371
372         if (ax25_ctl.arg > ULONG_MAX / HZ && ax25_ctl.cmd != AX25_KILL)
373                 return -EINVAL;
374
375         digi.ndigi = ax25_ctl.digi_count;
376         for (k = 0; k < digi.ndigi; k++)
377                 digi.calls[k] = ax25_ctl.digi_addr[k];
378
379         if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
380                 return -ENOTCONN;
381
382         switch (ax25_ctl.cmd) {
383         case AX25_KILL:
384                 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
385 #ifdef CONFIG_AX25_DAMA_SLAVE
386                 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
387                         ax25_dama_off(ax25);
388 #endif
389                 ax25_disconnect(ax25, ENETRESET);
390                 break;
391
392         case AX25_WINDOW:
393                 if (ax25->modulus == AX25_MODULUS) {
394                         if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
395                                 goto einval_put;
396                 } else {
397                         if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
398                                 goto einval_put;
399                 }
400                 ax25->window = ax25_ctl.arg;
401                 break;
402
403         case AX25_T1:
404                 if (ax25_ctl.arg < 1)
405                         goto einval_put;
406                 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
407                 ax25->t1  = ax25_ctl.arg * HZ;
408                 break;
409
410         case AX25_T2:
411                 if (ax25_ctl.arg < 1)
412                         goto einval_put;
413                 ax25->t2 = ax25_ctl.arg * HZ;
414                 break;
415
416         case AX25_N2:
417                 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
418                         goto einval_put;
419                 ax25->n2count = 0;
420                 ax25->n2 = ax25_ctl.arg;
421                 break;
422
423         case AX25_T3:
424                 ax25->t3 = ax25_ctl.arg * HZ;
425                 break;
426
427         case AX25_IDLE:
428                 ax25->idle = ax25_ctl.arg * 60 * HZ;
429                 break;
430
431         case AX25_PACLEN:
432                 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
433                         goto einval_put;
434                 ax25->paclen = ax25_ctl.arg;
435                 break;
436
437         default:
438                 goto einval_put;
439           }
440
441 out_put:
442         ax25_cb_put(ax25);
443         return ret;
444
445 einval_put:
446         ret = -EINVAL;
447         goto out_put;
448 }
449
450 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
451 {
452         ax25->rtt     = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
453         ax25->t1      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
454         ax25->t2      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
455         ax25->t3      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
456         ax25->n2      = ax25_dev->values[AX25_VALUES_N2];
457         ax25->paclen  = ax25_dev->values[AX25_VALUES_PACLEN];
458         ax25->idle    = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
459         ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
460
461         if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
462                 ax25->modulus = AX25_EMODULUS;
463                 ax25->window  = ax25_dev->values[AX25_VALUES_EWINDOW];
464         } else {
465                 ax25->modulus = AX25_MODULUS;
466                 ax25->window  = ax25_dev->values[AX25_VALUES_WINDOW];
467         }
468 }
469
470 /*
471  *      Fill in a created AX.25 created control block with the default
472  *      values for a particular device.
473  */
474 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
475 {
476         ax25->ax25_dev = ax25_dev;
477
478         if (ax25->ax25_dev != NULL) {
479                 ax25_fillin_cb_from_dev(ax25, ax25_dev);
480                 return;
481         }
482
483         /*
484          * No device, use kernel / AX.25 spec default values
485          */
486         ax25->rtt     = msecs_to_jiffies(AX25_DEF_T1) / 2;
487         ax25->t1      = msecs_to_jiffies(AX25_DEF_T1);
488         ax25->t2      = msecs_to_jiffies(AX25_DEF_T2);
489         ax25->t3      = msecs_to_jiffies(AX25_DEF_T3);
490         ax25->n2      = AX25_DEF_N2;
491         ax25->paclen  = AX25_DEF_PACLEN;
492         ax25->idle    = msecs_to_jiffies(AX25_DEF_IDLE);
493         ax25->backoff = AX25_DEF_BACKOFF;
494
495         if (AX25_DEF_AXDEFMODE) {
496                 ax25->modulus = AX25_EMODULUS;
497                 ax25->window  = AX25_DEF_EWINDOW;
498         } else {
499                 ax25->modulus = AX25_MODULUS;
500                 ax25->window  = AX25_DEF_WINDOW;
501         }
502 }
503
504 /*
505  * Create an empty AX.25 control block.
506  */
507 ax25_cb *ax25_create_cb(void)
508 {
509         ax25_cb *ax25;
510
511         if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
512                 return NULL;
513
514         atomic_set(&ax25->refcount, 1);
515
516         skb_queue_head_init(&ax25->write_queue);
517         skb_queue_head_init(&ax25->frag_queue);
518         skb_queue_head_init(&ax25->ack_queue);
519         skb_queue_head_init(&ax25->reseq_queue);
520
521         ax25_setup_timers(ax25);
522
523         ax25_fillin_cb(ax25, NULL);
524
525         ax25->state = AX25_STATE_0;
526
527         return ax25;
528 }
529
530 /*
531  *      Handling for system calls applied via the various interfaces to an
532  *      AX25 socket object
533  */
534
535 static int ax25_setsockopt(struct socket *sock, int level, int optname,
536         char __user *optval, unsigned int optlen)
537 {
538         struct sock *sk = sock->sk;
539         ax25_cb *ax25;
540         struct net_device *dev;
541         char devname[IFNAMSIZ];
542         int opt, res = 0;
543
544         if (level != SOL_AX25)
545                 return -ENOPROTOOPT;
546
547         if (optlen < sizeof(int))
548                 return -EINVAL;
549
550         if (get_user(opt, (int __user *)optval))
551                 return -EFAULT;
552
553         lock_sock(sk);
554         ax25 = ax25_sk(sk);
555
556         switch (optname) {
557         case AX25_WINDOW:
558                 if (ax25->modulus == AX25_MODULUS) {
559                         if (opt < 1 || opt > 7) {
560                                 res = -EINVAL;
561                                 break;
562                         }
563                 } else {
564                         if (opt < 1 || opt > 63) {
565                                 res = -EINVAL;
566                                 break;
567                         }
568                 }
569                 ax25->window = opt;
570                 break;
571
572         case AX25_T1:
573                 if (opt < 1) {
574                         res = -EINVAL;
575                         break;
576                 }
577                 ax25->rtt = (opt * HZ) >> 1;
578                 ax25->t1  = opt * HZ;
579                 break;
580
581         case AX25_T2:
582                 if (opt < 1) {
583                         res = -EINVAL;
584                         break;
585                 }
586                 ax25->t2 = opt * HZ;
587                 break;
588
589         case AX25_N2:
590                 if (opt < 1 || opt > 31) {
591                         res = -EINVAL;
592                         break;
593                 }
594                 ax25->n2 = opt;
595                 break;
596
597         case AX25_T3:
598                 if (opt < 1) {
599                         res = -EINVAL;
600                         break;
601                 }
602                 ax25->t3 = opt * HZ;
603                 break;
604
605         case AX25_IDLE:
606                 if (opt < 0) {
607                         res = -EINVAL;
608                         break;
609                 }
610                 ax25->idle = opt * 60 * HZ;
611                 break;
612
613         case AX25_BACKOFF:
614                 if (opt < 0 || opt > 2) {
615                         res = -EINVAL;
616                         break;
617                 }
618                 ax25->backoff = opt;
619                 break;
620
621         case AX25_EXTSEQ:
622                 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
623                 break;
624
625         case AX25_PIDINCL:
626                 ax25->pidincl = opt ? 1 : 0;
627                 break;
628
629         case AX25_IAMDIGI:
630                 ax25->iamdigi = opt ? 1 : 0;
631                 break;
632
633         case AX25_PACLEN:
634                 if (opt < 16 || opt > 65535) {
635                         res = -EINVAL;
636                         break;
637                 }
638                 ax25->paclen = opt;
639                 break;
640
641         case SO_BINDTODEVICE:
642                 if (optlen > IFNAMSIZ)
643                         optlen = IFNAMSIZ;
644
645                 if (copy_from_user(devname, optval, optlen)) {
646                         res = -EFAULT;
647                         break;
648                 }
649
650                 if (sk->sk_type == SOCK_SEQPACKET &&
651                    (sock->state != SS_UNCONNECTED ||
652                     sk->sk_state == TCP_LISTEN)) {
653                         res = -EADDRNOTAVAIL;
654                         break;
655                 }
656
657                 dev = dev_get_by_name(&init_net, devname);
658                 if (!dev) {
659                         res = -ENODEV;
660                         break;
661                 }
662
663                 ax25->ax25_dev = ax25_dev_ax25dev(dev);
664                 ax25_fillin_cb(ax25, ax25->ax25_dev);
665                 dev_put(dev);
666                 break;
667
668         default:
669                 res = -ENOPROTOOPT;
670         }
671         release_sock(sk);
672
673         return res;
674 }
675
676 static int ax25_getsockopt(struct socket *sock, int level, int optname,
677         char __user *optval, int __user *optlen)
678 {
679         struct sock *sk = sock->sk;
680         ax25_cb *ax25;
681         struct ax25_dev *ax25_dev;
682         char devname[IFNAMSIZ];
683         void *valptr;
684         int val = 0;
685         int maxlen, length;
686
687         if (level != SOL_AX25)
688                 return -ENOPROTOOPT;
689
690         if (get_user(maxlen, optlen))
691                 return -EFAULT;
692
693         if (maxlen < 1)
694                 return -EFAULT;
695
696         valptr = (void *) &val;
697         length = min_t(unsigned int, maxlen, sizeof(int));
698
699         lock_sock(sk);
700         ax25 = ax25_sk(sk);
701
702         switch (optname) {
703         case AX25_WINDOW:
704                 val = ax25->window;
705                 break;
706
707         case AX25_T1:
708                 val = ax25->t1 / HZ;
709                 break;
710
711         case AX25_T2:
712                 val = ax25->t2 / HZ;
713                 break;
714
715         case AX25_N2:
716                 val = ax25->n2;
717                 break;
718
719         case AX25_T3:
720                 val = ax25->t3 / HZ;
721                 break;
722
723         case AX25_IDLE:
724                 val = ax25->idle / (60 * HZ);
725                 break;
726
727         case AX25_BACKOFF:
728                 val = ax25->backoff;
729                 break;
730
731         case AX25_EXTSEQ:
732                 val = (ax25->modulus == AX25_EMODULUS);
733                 break;
734
735         case AX25_PIDINCL:
736                 val = ax25->pidincl;
737                 break;
738
739         case AX25_IAMDIGI:
740                 val = ax25->iamdigi;
741                 break;
742
743         case AX25_PACLEN:
744                 val = ax25->paclen;
745                 break;
746
747         case SO_BINDTODEVICE:
748                 ax25_dev = ax25->ax25_dev;
749
750                 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
751                         strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
752                         length = strlen(devname) + 1;
753                 } else {
754                         *devname = '\0';
755                         length = 1;
756                 }
757
758                 valptr = (void *) devname;
759                 break;
760
761         default:
762                 release_sock(sk);
763                 return -ENOPROTOOPT;
764         }
765         release_sock(sk);
766
767         if (put_user(length, optlen))
768                 return -EFAULT;
769
770         return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
771 }
772
773 static int ax25_listen(struct socket *sock, int backlog)
774 {
775         struct sock *sk = sock->sk;
776         int res = 0;
777
778         lock_sock(sk);
779         if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
780                 sk->sk_max_ack_backlog = backlog;
781                 sk->sk_state           = TCP_LISTEN;
782                 goto out;
783         }
784         res = -EOPNOTSUPP;
785
786 out:
787         release_sock(sk);
788
789         return res;
790 }
791
792 /*
793  * XXX: when creating ax25_sock we should update the .obj_size setting
794  * below.
795  */
796 static struct proto ax25_proto = {
797         .name     = "AX25",
798         .owner    = THIS_MODULE,
799         .obj_size = sizeof(struct sock),
800 };
801
802 static int ax25_create(struct net *net, struct socket *sock, int protocol,
803                        int kern)
804 {
805         struct sock *sk;
806         ax25_cb *ax25;
807
808         if (!net_eq(net, &init_net))
809                 return -EAFNOSUPPORT;
810
811         switch (sock->type) {
812         case SOCK_DGRAM:
813                 if (protocol == 0 || protocol == PF_AX25)
814                         protocol = AX25_P_TEXT;
815                 break;
816
817         case SOCK_SEQPACKET:
818                 switch (protocol) {
819                 case 0:
820                 case PF_AX25:   /* For CLX */
821                         protocol = AX25_P_TEXT;
822                         break;
823                 case AX25_P_SEGMENT:
824 #ifdef CONFIG_INET
825                 case AX25_P_ARP:
826                 case AX25_P_IP:
827 #endif
828 #ifdef CONFIG_NETROM
829                 case AX25_P_NETROM:
830 #endif
831 #ifdef CONFIG_ROSE
832                 case AX25_P_ROSE:
833 #endif
834                         return -ESOCKTNOSUPPORT;
835 #ifdef CONFIG_NETROM_MODULE
836                 case AX25_P_NETROM:
837                         if (ax25_protocol_is_registered(AX25_P_NETROM))
838                                 return -ESOCKTNOSUPPORT;
839 #endif
840 #ifdef CONFIG_ROSE_MODULE
841                 case AX25_P_ROSE:
842                         if (ax25_protocol_is_registered(AX25_P_ROSE))
843                                 return -ESOCKTNOSUPPORT;
844 #endif
845                 default:
846                         break;
847                 }
848                 break;
849
850         case SOCK_RAW:
851                 break;
852         default:
853                 return -ESOCKTNOSUPPORT;
854         }
855
856         sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
857         if (sk == NULL)
858                 return -ENOMEM;
859
860         ax25 = sk->sk_protinfo = ax25_create_cb();
861         if (!ax25) {
862                 sk_free(sk);
863                 return -ENOMEM;
864         }
865
866         sock_init_data(sock, sk);
867
868         sk->sk_destruct = ax25_free_sock;
869         sock->ops    = &ax25_proto_ops;
870         sk->sk_protocol = protocol;
871
872         ax25->sk    = sk;
873
874         return 0;
875 }
876
877 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
878 {
879         struct sock *sk;
880         ax25_cb *ax25, *oax25;
881
882         sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC,       osk->sk_prot);
883         if (sk == NULL)
884                 return NULL;
885
886         if ((ax25 = ax25_create_cb()) == NULL) {
887                 sk_free(sk);
888                 return NULL;
889         }
890
891         switch (osk->sk_type) {
892         case SOCK_DGRAM:
893                 break;
894         case SOCK_SEQPACKET:
895                 break;
896         default:
897                 sk_free(sk);
898                 ax25_cb_put(ax25);
899                 return NULL;
900         }
901
902         sock_init_data(NULL, sk);
903
904         sk->sk_type     = osk->sk_type;
905         sk->sk_priority = osk->sk_priority;
906         sk->sk_protocol = osk->sk_protocol;
907         sk->sk_rcvbuf   = osk->sk_rcvbuf;
908         sk->sk_sndbuf   = osk->sk_sndbuf;
909         sk->sk_state    = TCP_ESTABLISHED;
910         sock_copy_flags(sk, osk);
911
912         oax25 = ax25_sk(osk);
913
914         ax25->modulus = oax25->modulus;
915         ax25->backoff = oax25->backoff;
916         ax25->pidincl = oax25->pidincl;
917         ax25->iamdigi = oax25->iamdigi;
918         ax25->rtt     = oax25->rtt;
919         ax25->t1      = oax25->t1;
920         ax25->t2      = oax25->t2;
921         ax25->t3      = oax25->t3;
922         ax25->n2      = oax25->n2;
923         ax25->idle    = oax25->idle;
924         ax25->paclen  = oax25->paclen;
925         ax25->window  = oax25->window;
926
927         ax25->ax25_dev    = ax25_dev;
928         ax25->source_addr = oax25->source_addr;
929
930         if (oax25->digipeat != NULL) {
931                 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
932                                          GFP_ATOMIC);
933                 if (ax25->digipeat == NULL) {
934                         sk_free(sk);
935                         ax25_cb_put(ax25);
936                         return NULL;
937                 }
938         }
939
940         sk->sk_protinfo = ax25;
941         sk->sk_destruct = ax25_free_sock;
942         ax25->sk    = sk;
943
944         return sk;
945 }
946
947 static int ax25_release(struct socket *sock)
948 {
949         struct sock *sk = sock->sk;
950         ax25_cb *ax25;
951
952         if (sk == NULL)
953                 return 0;
954
955         sock_hold(sk);
956         sock_orphan(sk);
957         lock_sock(sk);
958         ax25 = ax25_sk(sk);
959
960         if (sk->sk_type == SOCK_SEQPACKET) {
961                 switch (ax25->state) {
962                 case AX25_STATE_0:
963                         release_sock(sk);
964                         ax25_disconnect(ax25, 0);
965                         lock_sock(sk);
966                         ax25_destroy_socket(ax25);
967                         break;
968
969                 case AX25_STATE_1:
970                 case AX25_STATE_2:
971                         ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
972                         release_sock(sk);
973                         ax25_disconnect(ax25, 0);
974                         lock_sock(sk);
975                         ax25_destroy_socket(ax25);
976                         break;
977
978                 case AX25_STATE_3:
979                 case AX25_STATE_4:
980                         ax25_clear_queues(ax25);
981                         ax25->n2count = 0;
982
983                         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
984                         case AX25_PROTO_STD_SIMPLEX:
985                         case AX25_PROTO_STD_DUPLEX:
986                                 ax25_send_control(ax25,
987                                                   AX25_DISC,
988                                                   AX25_POLLON,
989                                                   AX25_COMMAND);
990                                 ax25_stop_t2timer(ax25);
991                                 ax25_stop_t3timer(ax25);
992                                 ax25_stop_idletimer(ax25);
993                                 break;
994 #ifdef CONFIG_AX25_DAMA_SLAVE
995                         case AX25_PROTO_DAMA_SLAVE:
996                                 ax25_stop_t3timer(ax25);
997                                 ax25_stop_idletimer(ax25);
998                                 break;
999 #endif
1000                         }
1001                         ax25_calculate_t1(ax25);
1002                         ax25_start_t1timer(ax25);
1003                         ax25->state = AX25_STATE_2;
1004                         sk->sk_state                = TCP_CLOSE;
1005                         sk->sk_shutdown            |= SEND_SHUTDOWN;
1006                         sk->sk_state_change(sk);
1007                         sock_set_flag(sk, SOCK_DESTROY);
1008                         break;
1009
1010                 default:
1011                         break;
1012                 }
1013         } else {
1014                 sk->sk_state     = TCP_CLOSE;
1015                 sk->sk_shutdown |= SEND_SHUTDOWN;
1016                 sk->sk_state_change(sk);
1017                 ax25_destroy_socket(ax25);
1018         }
1019
1020         sock->sk   = NULL;
1021         release_sock(sk);
1022         sock_put(sk);
1023
1024         return 0;
1025 }
1026
1027 /*
1028  *      We support a funny extension here so you can (as root) give any callsign
1029  *      digipeated via a local address as source. This hack is obsolete now
1030  *      that we've implemented support for SO_BINDTODEVICE. It is however small
1031  *      and trivially backward compatible.
1032  */
1033 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1034 {
1035         struct sock *sk = sock->sk;
1036         struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1037         ax25_dev *ax25_dev = NULL;
1038         ax25_uid_assoc *user;
1039         ax25_address call;
1040         ax25_cb *ax25;
1041         int err = 0;
1042
1043         if (addr_len != sizeof(struct sockaddr_ax25) &&
1044             addr_len != sizeof(struct full_sockaddr_ax25))
1045                 /* support for old structure may go away some time
1046                  * ax25_bind(): uses old (6 digipeater) socket structure.
1047                  */
1048                 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1049                     (addr_len > sizeof(struct full_sockaddr_ax25)))
1050                         return -EINVAL;
1051
1052         if (addr->fsa_ax25.sax25_family != AF_AX25)
1053                 return -EINVAL;
1054
1055         user = ax25_findbyuid(current_euid());
1056         if (user) {
1057                 call = user->call;
1058                 ax25_uid_put(user);
1059         } else {
1060                 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1061                         return -EACCES;
1062
1063                 call = addr->fsa_ax25.sax25_call;
1064         }
1065
1066         lock_sock(sk);
1067
1068         ax25 = ax25_sk(sk);
1069         if (!sock_flag(sk, SOCK_ZAPPED)) {
1070                 err = -EINVAL;
1071                 goto out;
1072         }
1073
1074         ax25->source_addr = call;
1075
1076         /*
1077          * User already set interface with SO_BINDTODEVICE
1078          */
1079         if (ax25->ax25_dev != NULL)
1080                 goto done;
1081
1082         if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1083                 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1084                     (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1085                         err = -EADDRNOTAVAIL;
1086                         goto out;
1087                 }
1088         } else {
1089                 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1090                         err = -EADDRNOTAVAIL;
1091                         goto out;
1092                 }
1093         }
1094
1095         if (ax25_dev != NULL)
1096                 ax25_fillin_cb(ax25, ax25_dev);
1097
1098 done:
1099         ax25_cb_add(ax25);
1100         sock_reset_flag(sk, SOCK_ZAPPED);
1101
1102 out:
1103         release_sock(sk);
1104
1105         return 0;
1106 }
1107
1108 /*
1109  *      FIXME: nonblock behaviour looks like it may have a bug.
1110  */
1111 static int __must_check ax25_connect(struct socket *sock,
1112         struct sockaddr *uaddr, int addr_len, int flags)
1113 {
1114         struct sock *sk = sock->sk;
1115         ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1116         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1117         ax25_digi *digi = NULL;
1118         int ct = 0, err = 0;
1119
1120         /*
1121          * some sanity checks. code further down depends on this
1122          */
1123
1124         if (addr_len == sizeof(struct sockaddr_ax25))
1125                 /* support for this will go away in early 2.5.x
1126                  * ax25_connect(): uses obsolete socket structure
1127                  */
1128                 ;
1129         else if (addr_len != sizeof(struct full_sockaddr_ax25))
1130                 /* support for old structure may go away some time
1131                  * ax25_connect(): uses old (6 digipeater) socket structure.
1132                  */
1133                 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1134                     (addr_len > sizeof(struct full_sockaddr_ax25)))
1135                         return -EINVAL;
1136
1137
1138         if (fsa->fsa_ax25.sax25_family != AF_AX25)
1139                 return -EINVAL;
1140
1141         lock_sock(sk);
1142
1143         /* deal with restarts */
1144         if (sock->state == SS_CONNECTING) {
1145                 switch (sk->sk_state) {
1146                 case TCP_SYN_SENT: /* still trying */
1147                         err = -EINPROGRESS;
1148                         goto out_release;
1149
1150                 case TCP_ESTABLISHED: /* connection established */
1151                         sock->state = SS_CONNECTED;
1152                         goto out_release;
1153
1154                 case TCP_CLOSE: /* connection refused */
1155                         sock->state = SS_UNCONNECTED;
1156                         err = -ECONNREFUSED;
1157                         goto out_release;
1158                 }
1159         }
1160
1161         if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1162                 err = -EISCONN; /* No reconnect on a seqpacket socket */
1163                 goto out_release;
1164         }
1165
1166         sk->sk_state   = TCP_CLOSE;
1167         sock->state = SS_UNCONNECTED;
1168
1169         kfree(ax25->digipeat);
1170         ax25->digipeat = NULL;
1171
1172         /*
1173          *      Handle digi-peaters to be used.
1174          */
1175         if (addr_len > sizeof(struct sockaddr_ax25) &&
1176             fsa->fsa_ax25.sax25_ndigis != 0) {
1177                 /* Valid number of digipeaters ? */
1178                 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1179                         err = -EINVAL;
1180                         goto out_release;
1181                 }
1182
1183                 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1184                         err = -ENOBUFS;
1185                         goto out_release;
1186                 }
1187
1188                 digi->ndigi      = fsa->fsa_ax25.sax25_ndigis;
1189                 digi->lastrepeat = -1;
1190
1191                 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1192                         if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1193                              AX25_HBIT) && ax25->iamdigi) {
1194                                 digi->repeated[ct] = 1;
1195                                 digi->lastrepeat   = ct;
1196                         } else {
1197                                 digi->repeated[ct] = 0;
1198                         }
1199                         digi->calls[ct] = fsa->fsa_digipeater[ct];
1200                         ct++;
1201                 }
1202         }
1203
1204         /*
1205          *      Must bind first - autobinding in this may or may not work. If
1206          *      the socket is already bound, check to see if the device has
1207          *      been filled in, error if it hasn't.
1208          */
1209         if (sock_flag(sk, SOCK_ZAPPED)) {
1210                 /* check if we can remove this feature. It is broken. */
1211                 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1212                         current->comm);
1213                 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1214                         kfree(digi);
1215                         goto out_release;
1216                 }
1217
1218                 ax25_fillin_cb(ax25, ax25->ax25_dev);
1219                 ax25_cb_add(ax25);
1220         } else {
1221                 if (ax25->ax25_dev == NULL) {
1222                         kfree(digi);
1223                         err = -EHOSTUNREACH;
1224                         goto out_release;
1225                 }
1226         }
1227
1228         if (sk->sk_type == SOCK_SEQPACKET &&
1229             (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1230                          ax25->ax25_dev->dev))) {
1231                 kfree(digi);
1232                 err = -EADDRINUSE;              /* Already such a connection */
1233                 ax25_cb_put(ax25t);
1234                 goto out_release;
1235         }
1236
1237         ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1238         ax25->digipeat  = digi;
1239
1240         /* First the easy one */
1241         if (sk->sk_type != SOCK_SEQPACKET) {
1242                 sock->state = SS_CONNECTED;
1243                 sk->sk_state   = TCP_ESTABLISHED;
1244                 goto out_release;
1245         }
1246
1247         /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1248         sock->state        = SS_CONNECTING;
1249         sk->sk_state          = TCP_SYN_SENT;
1250
1251         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1252         case AX25_PROTO_STD_SIMPLEX:
1253         case AX25_PROTO_STD_DUPLEX:
1254                 ax25_std_establish_data_link(ax25);
1255                 break;
1256
1257 #ifdef CONFIG_AX25_DAMA_SLAVE
1258         case AX25_PROTO_DAMA_SLAVE:
1259                 ax25->modulus = AX25_MODULUS;
1260                 ax25->window  = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1261                 if (ax25->ax25_dev->dama.slave)
1262                         ax25_ds_establish_data_link(ax25);
1263                 else
1264                         ax25_std_establish_data_link(ax25);
1265                 break;
1266 #endif
1267         }
1268
1269         ax25->state = AX25_STATE_1;
1270
1271         ax25_start_heartbeat(ax25);
1272
1273         /* Now the loop */
1274         if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1275                 err = -EINPROGRESS;
1276                 goto out_release;
1277         }
1278
1279         if (sk->sk_state == TCP_SYN_SENT) {
1280                 DEFINE_WAIT(wait);
1281
1282                 for (;;) {
1283                         prepare_to_wait(sk->sk_sleep, &wait,
1284                                         TASK_INTERRUPTIBLE);
1285                         if (sk->sk_state != TCP_SYN_SENT)
1286                                 break;
1287                         if (!signal_pending(current)) {
1288                                 release_sock(sk);
1289                                 schedule();
1290                                 lock_sock(sk);
1291                                 continue;
1292                         }
1293                         err = -ERESTARTSYS;
1294                         break;
1295                 }
1296                 finish_wait(sk->sk_sleep, &wait);
1297
1298                 if (err)
1299                         goto out_release;
1300         }
1301
1302         if (sk->sk_state != TCP_ESTABLISHED) {
1303                 /* Not in ABM, not in WAIT_UA -> failed */
1304                 sock->state = SS_UNCONNECTED;
1305                 err = sock_error(sk);   /* Always set at this point */
1306                 goto out_release;
1307         }
1308
1309         sock->state = SS_CONNECTED;
1310
1311         err = 0;
1312 out_release:
1313         release_sock(sk);
1314
1315         return err;
1316 }
1317
1318 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1319 {
1320         struct sk_buff *skb;
1321         struct sock *newsk;
1322         DEFINE_WAIT(wait);
1323         struct sock *sk;
1324         int err = 0;
1325
1326         if (sock->state != SS_UNCONNECTED)
1327                 return -EINVAL;
1328
1329         if ((sk = sock->sk) == NULL)
1330                 return -EINVAL;
1331
1332         lock_sock(sk);
1333         if (sk->sk_type != SOCK_SEQPACKET) {
1334                 err = -EOPNOTSUPP;
1335                 goto out;
1336         }
1337
1338         if (sk->sk_state != TCP_LISTEN) {
1339                 err = -EINVAL;
1340                 goto out;
1341         }
1342
1343         /*
1344          *      The read queue this time is holding sockets ready to use
1345          *      hooked into the SABM we saved
1346          */
1347         for (;;) {
1348                 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1349                 skb = skb_dequeue(&sk->sk_receive_queue);
1350                 if (skb)
1351                         break;
1352
1353                 if (flags & O_NONBLOCK) {
1354                         err = -EWOULDBLOCK;
1355                         break;
1356                 }
1357                 if (!signal_pending(current)) {
1358                         release_sock(sk);
1359                         schedule();
1360                         lock_sock(sk);
1361                         continue;
1362                 }
1363                 err = -ERESTARTSYS;
1364                 break;
1365         }
1366         finish_wait(sk->sk_sleep, &wait);
1367
1368         if (err)
1369                 goto out;
1370
1371         newsk            = skb->sk;
1372         sock_graft(newsk, newsock);
1373
1374         /* Now attach up the new socket */
1375         kfree_skb(skb);
1376         sk->sk_ack_backlog--;
1377         newsock->state = SS_CONNECTED;
1378
1379 out:
1380         release_sock(sk);
1381
1382         return err;
1383 }
1384
1385 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1386         int *uaddr_len, int peer)
1387 {
1388         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1389         struct sock *sk = sock->sk;
1390         unsigned char ndigi, i;
1391         ax25_cb *ax25;
1392         int err = 0;
1393
1394         lock_sock(sk);
1395         ax25 = ax25_sk(sk);
1396
1397         if (peer != 0) {
1398                 if (sk->sk_state != TCP_ESTABLISHED) {
1399                         err = -ENOTCONN;
1400                         goto out;
1401                 }
1402
1403                 fsa->fsa_ax25.sax25_family = AF_AX25;
1404                 fsa->fsa_ax25.sax25_call   = ax25->dest_addr;
1405                 fsa->fsa_ax25.sax25_ndigis = 0;
1406
1407                 if (ax25->digipeat != NULL) {
1408                         ndigi = ax25->digipeat->ndigi;
1409                         fsa->fsa_ax25.sax25_ndigis = ndigi;
1410                         for (i = 0; i < ndigi; i++)
1411                                 fsa->fsa_digipeater[i] =
1412                                                 ax25->digipeat->calls[i];
1413                 }
1414         } else {
1415                 fsa->fsa_ax25.sax25_family = AF_AX25;
1416                 fsa->fsa_ax25.sax25_call   = ax25->source_addr;
1417                 fsa->fsa_ax25.sax25_ndigis = 1;
1418                 if (ax25->ax25_dev != NULL) {
1419                         memcpy(&fsa->fsa_digipeater[0],
1420                                ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1421                 } else {
1422                         fsa->fsa_digipeater[0] = null_ax25_address;
1423                 }
1424         }
1425         *uaddr_len = sizeof (struct full_sockaddr_ax25);
1426
1427 out:
1428         release_sock(sk);
1429
1430         return err;
1431 }
1432
1433 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1434                         struct msghdr *msg, size_t len)
1435 {
1436         struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1437         struct sock *sk = sock->sk;
1438         struct sockaddr_ax25 sax;
1439         struct sk_buff *skb;
1440         ax25_digi dtmp, *dp;
1441         ax25_cb *ax25;
1442         size_t size;
1443         int lv, err, addr_len = msg->msg_namelen;
1444
1445         if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1446                 return -EINVAL;
1447
1448         lock_sock(sk);
1449         ax25 = ax25_sk(sk);
1450
1451         if (sock_flag(sk, SOCK_ZAPPED)) {
1452                 err = -EADDRNOTAVAIL;
1453                 goto out;
1454         }
1455
1456         if (sk->sk_shutdown & SEND_SHUTDOWN) {
1457                 send_sig(SIGPIPE, current, 0);
1458                 err = -EPIPE;
1459                 goto out;
1460         }
1461
1462         if (ax25->ax25_dev == NULL) {
1463                 err = -ENETUNREACH;
1464                 goto out;
1465         }
1466
1467         if (len > ax25->ax25_dev->dev->mtu) {
1468                 err = -EMSGSIZE;
1469                 goto out;
1470         }
1471
1472         if (usax != NULL) {
1473                 if (usax->sax25_family != AF_AX25) {
1474                         err = -EINVAL;
1475                         goto out;
1476                 }
1477
1478                 if (addr_len == sizeof(struct sockaddr_ax25))
1479                         /* ax25_sendmsg(): uses obsolete socket structure */
1480                         ;
1481                 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1482                         /* support for old structure may go away some time
1483                          * ax25_sendmsg(): uses old (6 digipeater)
1484                          * socket structure.
1485                          */
1486                         if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1487                             (addr_len > sizeof(struct full_sockaddr_ax25))) {
1488                                 err = -EINVAL;
1489                                 goto out;
1490                         }
1491
1492
1493                 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1494                         int ct           = 0;
1495                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1496
1497                         /* Valid number of digipeaters ? */
1498                         if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1499                                 err = -EINVAL;
1500                                 goto out;
1501                         }
1502
1503                         dtmp.ndigi      = usax->sax25_ndigis;
1504
1505                         while (ct < usax->sax25_ndigis) {
1506                                 dtmp.repeated[ct] = 0;
1507                                 dtmp.calls[ct]    = fsa->fsa_digipeater[ct];
1508                                 ct++;
1509                         }
1510
1511                         dtmp.lastrepeat = 0;
1512                 }
1513
1514                 sax = *usax;
1515                 if (sk->sk_type == SOCK_SEQPACKET &&
1516                     ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1517                         err = -EISCONN;
1518                         goto out;
1519                 }
1520                 if (usax->sax25_ndigis == 0)
1521                         dp = NULL;
1522                 else
1523                         dp = &dtmp;
1524         } else {
1525                 /*
1526                  *      FIXME: 1003.1g - if the socket is like this because
1527                  *      it has become closed (not started closed) and is VC
1528                  *      we ought to SIGPIPE, EPIPE
1529                  */
1530                 if (sk->sk_state != TCP_ESTABLISHED) {
1531                         err = -ENOTCONN;
1532                         goto out;
1533                 }
1534                 sax.sax25_family = AF_AX25;
1535                 sax.sax25_call   = ax25->dest_addr;
1536                 dp = ax25->digipeat;
1537         }
1538
1539         /* Build a packet */
1540         SOCK_DEBUG(sk, "AX.25: sendto: Addresses built. Building packet.\n");
1541
1542         /* Assume the worst case */
1543         size = len + ax25->ax25_dev->dev->hard_header_len;
1544
1545         skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1546         if (skb == NULL)
1547                 goto out;
1548
1549         skb_reserve(skb, size - len);
1550
1551         SOCK_DEBUG(sk, "AX.25: Appending user data\n");
1552
1553         /* User data follows immediately after the AX.25 data */
1554         if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1555                 err = -EFAULT;
1556                 kfree_skb(skb);
1557                 goto out;
1558         }
1559
1560         skb_reset_network_header(skb);
1561
1562         /* Add the PID if one is not supplied by the user in the skb */
1563         if (!ax25->pidincl)
1564                 *skb_push(skb, 1) = sk->sk_protocol;
1565
1566         SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n");
1567
1568         if (sk->sk_type == SOCK_SEQPACKET) {
1569                 /* Connected mode sockets go via the LAPB machine */
1570                 if (sk->sk_state != TCP_ESTABLISHED) {
1571                         kfree_skb(skb);
1572                         err = -ENOTCONN;
1573                         goto out;
1574                 }
1575
1576                 /* Shove it onto the queue and kick */
1577                 ax25_output(ax25, ax25->paclen, skb);
1578
1579                 err = len;
1580                 goto out;
1581         }
1582
1583         skb_push(skb, 1 + ax25_addr_size(dp));
1584
1585         SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp);
1586
1587         if (dp != NULL)
1588                 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi);
1589
1590         /* Build an AX.25 header */
1591         lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1592                              dp, AX25_COMMAND, AX25_MODULUS);
1593
1594         SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv);
1595
1596         skb_set_transport_header(skb, lv);
1597
1598         SOCK_DEBUG(sk, "base=%p pos=%p\n",
1599                    skb->data, skb_transport_header(skb));
1600
1601         *skb_transport_header(skb) = AX25_UI;
1602
1603         /* Datagram frames go straight out of the door as UI */
1604         ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1605
1606         err = len;
1607
1608 out:
1609         release_sock(sk);
1610
1611         return err;
1612 }
1613
1614 static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1615         struct msghdr *msg, size_t size, int flags)
1616 {
1617         struct sock *sk = sock->sk;
1618         struct sk_buff *skb;
1619         int copied;
1620         int err = 0;
1621
1622         lock_sock(sk);
1623         /*
1624          *      This works for seqpacket too. The receiver has ordered the
1625          *      queue for us! We do one quick check first though
1626          */
1627         if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1628                 err =  -ENOTCONN;
1629                 goto out;
1630         }
1631
1632         /* Now we can treat all alike */
1633         skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1634                                 flags & MSG_DONTWAIT, &err);
1635         if (skb == NULL)
1636                 goto out;
1637
1638         if (!ax25_sk(sk)->pidincl)
1639                 skb_pull(skb, 1);               /* Remove PID */
1640
1641         skb_reset_transport_header(skb);
1642         copied = skb->len;
1643
1644         if (copied > size) {
1645                 copied = size;
1646                 msg->msg_flags |= MSG_TRUNC;
1647         }
1648
1649         skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1650
1651         if (msg->msg_namelen != 0) {
1652                 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1653                 ax25_digi digi;
1654                 ax25_address src;
1655                 const unsigned char *mac = skb_mac_header(skb);
1656
1657                 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1658                                 &digi, NULL, NULL);
1659                 sax->sax25_family = AF_AX25;
1660                 /* We set this correctly, even though we may not let the
1661                    application know the digi calls further down (because it
1662                    did NOT ask to know them).  This could get political... **/
1663                 sax->sax25_ndigis = digi.ndigi;
1664                 sax->sax25_call   = src;
1665
1666                 if (sax->sax25_ndigis != 0) {
1667                         int ct;
1668                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1669
1670                         for (ct = 0; ct < digi.ndigi; ct++)
1671                                 fsa->fsa_digipeater[ct] = digi.calls[ct];
1672                 }
1673                 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1674         }
1675
1676         skb_free_datagram(sk, skb);
1677         err = copied;
1678
1679 out:
1680         release_sock(sk);
1681
1682         return err;
1683 }
1684
1685 static int ax25_shutdown(struct socket *sk, int how)
1686 {
1687         /* FIXME - generate DM and RNR states */
1688         return -EOPNOTSUPP;
1689 }
1690
1691 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1692 {
1693         struct sock *sk = sock->sk;
1694         void __user *argp = (void __user *)arg;
1695         int res = 0;
1696
1697         lock_sock(sk);
1698         switch (cmd) {
1699         case TIOCOUTQ: {
1700                 long amount;
1701
1702                 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1703                 if (amount < 0)
1704                         amount = 0;
1705                 res = put_user(amount, (int __user *)argp);
1706                 break;
1707         }
1708
1709         case TIOCINQ: {
1710                 struct sk_buff *skb;
1711                 long amount = 0L;
1712                 /* These two are safe on a single CPU system as only user tasks fiddle here */
1713                 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1714                         amount = skb->len;
1715                 res = put_user(amount, (int __user *) argp);
1716                 break;
1717         }
1718
1719         case SIOCGSTAMP:
1720                 res = sock_get_timestamp(sk, argp);
1721                 break;
1722
1723         case SIOCGSTAMPNS:
1724                 res = sock_get_timestampns(sk, argp);
1725                 break;
1726
1727         case SIOCAX25ADDUID:    /* Add a uid to the uid/call map table */
1728         case SIOCAX25DELUID:    /* Delete a uid from the uid/call map table */
1729         case SIOCAX25GETUID: {
1730                 struct sockaddr_ax25 sax25;
1731                 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1732                         res = -EFAULT;
1733                         break;
1734                 }
1735                 res = ax25_uid_ioctl(cmd, &sax25);
1736                 break;
1737         }
1738
1739         case SIOCAX25NOUID: {   /* Set the default policy (default/bar) */
1740                 long amount;
1741                 if (!capable(CAP_NET_ADMIN)) {
1742                         res = -EPERM;
1743                         break;
1744                 }
1745                 if (get_user(amount, (long __user *)argp)) {
1746                         res = -EFAULT;
1747                         break;
1748                 }
1749                 if (amount > AX25_NOUID_BLOCK) {
1750                         res = -EINVAL;
1751                         break;
1752                 }
1753                 ax25_uid_policy = amount;
1754                 res = 0;
1755                 break;
1756         }
1757
1758         case SIOCADDRT:
1759         case SIOCDELRT:
1760         case SIOCAX25OPTRT:
1761                 if (!capable(CAP_NET_ADMIN)) {
1762                         res = -EPERM;
1763                         break;
1764                 }
1765                 res = ax25_rt_ioctl(cmd, argp);
1766                 break;
1767
1768         case SIOCAX25CTLCON:
1769                 if (!capable(CAP_NET_ADMIN)) {
1770                         res = -EPERM;
1771                         break;
1772                 }
1773                 res = ax25_ctl_ioctl(cmd, argp);
1774                 break;
1775
1776         case SIOCAX25GETINFO:
1777         case SIOCAX25GETINFOOLD: {
1778                 ax25_cb *ax25 = ax25_sk(sk);
1779                 struct ax25_info_struct ax25_info;
1780
1781                 ax25_info.t1        = ax25->t1   / HZ;
1782                 ax25_info.t2        = ax25->t2   / HZ;
1783                 ax25_info.t3        = ax25->t3   / HZ;
1784                 ax25_info.idle      = ax25->idle / (60 * HZ);
1785                 ax25_info.n2        = ax25->n2;
1786                 ax25_info.t1timer   = ax25_display_timer(&ax25->t1timer)   / HZ;
1787                 ax25_info.t2timer   = ax25_display_timer(&ax25->t2timer)   / HZ;
1788                 ax25_info.t3timer   = ax25_display_timer(&ax25->t3timer)   / HZ;
1789                 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1790                 ax25_info.n2count   = ax25->n2count;
1791                 ax25_info.state     = ax25->state;
1792                 ax25_info.rcv_q     = sk_rmem_alloc_get(sk);
1793                 ax25_info.snd_q     = sk_wmem_alloc_get(sk);
1794                 ax25_info.vs        = ax25->vs;
1795                 ax25_info.vr        = ax25->vr;
1796                 ax25_info.va        = ax25->va;
1797                 ax25_info.vs_max    = ax25->vs; /* reserved */
1798                 ax25_info.paclen    = ax25->paclen;
1799                 ax25_info.window    = ax25->window;
1800
1801                 /* old structure? */
1802                 if (cmd == SIOCAX25GETINFOOLD) {
1803                         static int warned = 0;
1804                         if (!warned) {
1805                                 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1806                                         current->comm);
1807                                 warned=1;
1808                         }
1809
1810                         if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1811                                 res = -EFAULT;
1812                                 break;
1813                         }
1814                 } else {
1815                         if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1816                                 res = -EINVAL;
1817                                 break;
1818                         }
1819                 }
1820                 res = 0;
1821                 break;
1822         }
1823
1824         case SIOCAX25ADDFWD:
1825         case SIOCAX25DELFWD: {
1826                 struct ax25_fwd_struct ax25_fwd;
1827                 if (!capable(CAP_NET_ADMIN)) {
1828                         res = -EPERM;
1829                         break;
1830                 }
1831                 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1832                         res = -EFAULT;
1833                         break;
1834                 }
1835                 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1836                 break;
1837         }
1838
1839         case SIOCGIFADDR:
1840         case SIOCSIFADDR:
1841         case SIOCGIFDSTADDR:
1842         case SIOCSIFDSTADDR:
1843         case SIOCGIFBRDADDR:
1844         case SIOCSIFBRDADDR:
1845         case SIOCGIFNETMASK:
1846         case SIOCSIFNETMASK:
1847         case SIOCGIFMETRIC:
1848         case SIOCSIFMETRIC:
1849                 res = -EINVAL;
1850                 break;
1851
1852         default:
1853                 res = -ENOIOCTLCMD;
1854                 break;
1855         }
1856         release_sock(sk);
1857
1858         return res;
1859 }
1860
1861 #ifdef CONFIG_PROC_FS
1862
1863 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1864         __acquires(ax25_list_lock)
1865 {
1866         struct ax25_cb *ax25;
1867         struct hlist_node *node;
1868         int i = 0;
1869
1870         spin_lock_bh(&ax25_list_lock);
1871         ax25_for_each(ax25, node, &ax25_list) {
1872                 if (i == *pos)
1873                         return ax25;
1874                 ++i;
1875         }
1876         return NULL;
1877 }
1878
1879 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1880 {
1881         ++*pos;
1882
1883         return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1884                             struct ax25_cb, ax25_node);
1885 }
1886
1887 static void ax25_info_stop(struct seq_file *seq, void *v)
1888         __releases(ax25_list_lock)
1889 {
1890         spin_unlock_bh(&ax25_list_lock);
1891 }
1892
1893 static int ax25_info_show(struct seq_file *seq, void *v)
1894 {
1895         ax25_cb *ax25 = v;
1896         char buf[11];
1897         int k;
1898
1899
1900         /*
1901          * New format:
1902          * magic dev src_addr dest_addr,digi1,digi2,.. st vs vr va t1 t1 t2 t2 t3 t3 idle idle n2 n2 rtt window paclen Snd-Q Rcv-Q inode
1903          */
1904
1905         seq_printf(seq, "%8.8lx %s %s%s ",
1906                    (long) ax25,
1907                    ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1908                    ax2asc(buf, &ax25->source_addr),
1909                    ax25->iamdigi? "*":"");
1910         seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1911
1912         for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1913                 seq_printf(seq, ",%s%s",
1914                            ax2asc(buf, &ax25->digipeat->calls[k]),
1915                            ax25->digipeat->repeated[k]? "*":"");
1916         }
1917
1918         seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1919                    ax25->state,
1920                    ax25->vs, ax25->vr, ax25->va,
1921                    ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1922                    ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1923                    ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1924                    ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1925                    ax25->idle / (60 * HZ),
1926                    ax25->n2count, ax25->n2,
1927                    ax25->rtt / HZ,
1928                    ax25->window,
1929                    ax25->paclen);
1930
1931         if (ax25->sk != NULL) {
1932                 seq_printf(seq, " %d %d %lu\n",
1933                            sk_wmem_alloc_get(ax25->sk),
1934                            sk_rmem_alloc_get(ax25->sk),
1935                            sock_i_ino(ax25->sk));
1936         } else {
1937                 seq_puts(seq, " * * *\n");
1938         }
1939         return 0;
1940 }
1941
1942 static const struct seq_operations ax25_info_seqops = {
1943         .start = ax25_info_start,
1944         .next = ax25_info_next,
1945         .stop = ax25_info_stop,
1946         .show = ax25_info_show,
1947 };
1948
1949 static int ax25_info_open(struct inode *inode, struct file *file)
1950 {
1951         return seq_open(file, &ax25_info_seqops);
1952 }
1953
1954 static const struct file_operations ax25_info_fops = {
1955         .owner = THIS_MODULE,
1956         .open = ax25_info_open,
1957         .read = seq_read,
1958         .llseek = seq_lseek,
1959         .release = seq_release,
1960 };
1961
1962 #endif
1963
1964 static const struct net_proto_family ax25_family_ops = {
1965         .family =       PF_AX25,
1966         .create =       ax25_create,
1967         .owner  =       THIS_MODULE,
1968 };
1969
1970 static const struct proto_ops ax25_proto_ops = {
1971         .family         = PF_AX25,
1972         .owner          = THIS_MODULE,
1973         .release        = ax25_release,
1974         .bind           = ax25_bind,
1975         .connect        = ax25_connect,
1976         .socketpair     = sock_no_socketpair,
1977         .accept         = ax25_accept,
1978         .getname        = ax25_getname,
1979         .poll           = datagram_poll,
1980         .ioctl          = ax25_ioctl,
1981         .listen         = ax25_listen,
1982         .shutdown       = ax25_shutdown,
1983         .setsockopt     = ax25_setsockopt,
1984         .getsockopt     = ax25_getsockopt,
1985         .sendmsg        = ax25_sendmsg,
1986         .recvmsg        = ax25_recvmsg,
1987         .mmap           = sock_no_mmap,
1988         .sendpage       = sock_no_sendpage,
1989 };
1990
1991 /*
1992  *      Called by socket.c on kernel start up
1993  */
1994 static struct packet_type ax25_packet_type __read_mostly = {
1995         .type   =       cpu_to_be16(ETH_P_AX25),
1996         .func   =       ax25_kiss_rcv,
1997 };
1998
1999 static struct notifier_block ax25_dev_notifier = {
2000         .notifier_call =ax25_device_event,
2001 };
2002
2003 static int __init ax25_init(void)
2004 {
2005         int rc = proto_register(&ax25_proto, 0);
2006
2007         if (rc != 0)
2008                 goto out;
2009
2010         sock_register(&ax25_family_ops);
2011         dev_add_pack(&ax25_packet_type);
2012         register_netdevice_notifier(&ax25_dev_notifier);
2013         ax25_register_sysctl();
2014
2015         proc_net_fops_create(&init_net, "ax25_route", S_IRUGO, &ax25_route_fops);
2016         proc_net_fops_create(&init_net, "ax25", S_IRUGO, &ax25_info_fops);
2017         proc_net_fops_create(&init_net, "ax25_calls", S_IRUGO, &ax25_uid_fops);
2018 out:
2019         return rc;
2020 }
2021 module_init(ax25_init);
2022
2023
2024 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2025 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2026 MODULE_LICENSE("GPL");
2027 MODULE_ALIAS_NETPROTO(PF_AX25);
2028
2029 static void __exit ax25_exit(void)
2030 {
2031         proc_net_remove(&init_net, "ax25_route");
2032         proc_net_remove(&init_net, "ax25");
2033         proc_net_remove(&init_net, "ax25_calls");
2034         ax25_rt_free();
2035         ax25_uid_free();
2036         ax25_dev_free();
2037
2038         ax25_unregister_sysctl();
2039         unregister_netdevice_notifier(&ax25_dev_notifier);
2040
2041         dev_remove_pack(&ax25_packet_type);
2042
2043         sock_unregister(PF_AX25);
2044         proto_unregister(&ax25_proto);
2045 }
2046 module_exit(ax25_exit);