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