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