[NET] NETNS: Omit sock->sk_net without CONFIG_NET_NS.
[linux-3.10.git] / net / ax25 / af_ax25.c
1 /*
2  * This program is free software; you can redistribute it and/or modify
3  * it under the terms of the GNU General Public License as published by
4  * the Free Software Foundation; either version 2 of the License, or
5  * (at your option) any later version.
6  *
7  * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
8  * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
9  * Copyright (C) Darryl Miles G7LED (dlm@g7led.demon.co.uk)
10  * Copyright (C) Steven Whitehouse GW7RRM (stevew@acm.org)
11  * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
12  * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de)
13  * Copyright (C) Hans Alblas PE1AYX (hans@esrac.ele.tue.nl)
14  * Copyright (C) Frederic Rible F1OAT (frible@teaser.fr)
15  */
16 #include <linux/capability.h>
17 #include <linux/module.h>
18 #include <linux/errno.h>
19 #include <linux/types.h>
20 #include <linux/socket.h>
21 #include <linux/in.h>
22 #include <linux/kernel.h>
23 #include <linux/sched.h>
24 #include <linux/timer.h>
25 #include <linux/string.h>
26 #include <linux/sockios.h>
27 #include <linux/net.h>
28 #include <net/ax25.h>
29 #include <linux/inet.h>
30 #include <linux/netdevice.h>
31 #include <linux/if_arp.h>
32 #include <linux/skbuff.h>
33 #include <net/sock.h>
34 #include <asm/uaccess.h>
35 #include <asm/system.h>
36 #include <linux/fcntl.h>
37 #include <linux/termios.h>      /* For TIOCINQ/OUTQ */
38 #include <linux/mm.h>
39 #include <linux/interrupt.h>
40 #include <linux/notifier.h>
41 #include <linux/proc_fs.h>
42 #include <linux/stat.h>
43 #include <linux/netfilter.h>
44 #include <linux/sysctl.h>
45 #include <linux/init.h>
46 #include <linux/spinlock.h>
47 #include <net/net_namespace.h>
48 #include <net/tcp_states.h>
49 #include <net/ip.h>
50 #include <net/arp.h>
51
52
53
54 HLIST_HEAD(ax25_list);
55 DEFINE_SPINLOCK(ax25_list_lock);
56
57 static const struct proto_ops ax25_proto_ops;
58
59 static void ax25_free_sock(struct sock *sk)
60 {
61         ax25_cb_put(ax25_sk(sk));
62 }
63
64 /*
65  *      Socket removal during an interrupt is now safe.
66  */
67 static void ax25_cb_del(ax25_cb *ax25)
68 {
69         if (!hlist_unhashed(&ax25->ax25_node)) {
70                 spin_lock_bh(&ax25_list_lock);
71                 hlist_del_init(&ax25->ax25_node);
72                 spin_unlock_bh(&ax25_list_lock);
73                 ax25_cb_put(ax25);
74         }
75 }
76
77 /*
78  *      Kill all bound sockets on a dropped device.
79  */
80 static void ax25_kill_by_device(struct net_device *dev)
81 {
82         ax25_dev *ax25_dev;
83         ax25_cb *s;
84         struct hlist_node *node;
85
86         if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
87                 return;
88
89         spin_lock_bh(&ax25_list_lock);
90 again:
91         ax25_for_each(s, node, &ax25_list) {
92                 if (s->ax25_dev == ax25_dev) {
93                         s->ax25_dev = NULL;
94                         spin_unlock_bh(&ax25_list_lock);
95                         ax25_disconnect(s, ENETUNREACH);
96                         spin_lock_bh(&ax25_list_lock);
97
98                         /* The entry could have been deleted from the
99                          * list meanwhile and thus the next pointer is
100                          * no longer valid.  Play it safe and restart
101                          * the scan.  Forward progress is ensured
102                          * because we set s->ax25_dev to NULL and we
103                          * are never passed a NULL 'dev' argument.
104                          */
105                         goto again;
106                 }
107         }
108         spin_unlock_bh(&ax25_list_lock);
109 }
110
111 /*
112  *      Handle device status changes.
113  */
114 static int ax25_device_event(struct notifier_block *this, unsigned long event,
115         void *ptr)
116 {
117         struct net_device *dev = (struct net_device *)ptr;
118
119         if (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                                 ax25_start_heartbeat(sax25);
321                                 sax25->state = AX25_STATE_0;
322                         }
323
324                         kfree_skb(skb);
325                 }
326                 skb_queue_purge(&ax25->sk->sk_write_queue);
327         }
328
329         if (ax25->sk != NULL) {
330                 if (atomic_read(&ax25->sk->sk_wmem_alloc) ||
331                     atomic_read(&ax25->sk->sk_rmem_alloc)) {
332                         /* Defer: outstanding buffers */
333                         setup_timer(&ax25->dtimer, ax25_destroy_timer,
334                                         (unsigned long)ax25);
335                         ax25->dtimer.expires  = jiffies + 2 * HZ;
336                         add_timer(&ax25->dtimer);
337                 } else {
338                         struct sock *sk=ax25->sk;
339                         ax25->sk=NULL;
340                         sock_put(sk);
341                 }
342         } else {
343                 ax25_cb_put(ax25);
344         }
345 }
346
347 /*
348  * dl1bke 960311: set parameters for existing AX.25 connections,
349  *                includes a KILL command to abort any connection.
350  *                VERY useful for debugging ;-)
351  */
352 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
353 {
354         struct ax25_ctl_struct ax25_ctl;
355         ax25_digi digi;
356         ax25_dev *ax25_dev;
357         ax25_cb *ax25;
358         unsigned int k;
359
360         if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
361                 return -EFAULT;
362
363         if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
364                 return -ENODEV;
365
366         if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
367                 return -EINVAL;
368
369         digi.ndigi = ax25_ctl.digi_count;
370         for (k = 0; k < digi.ndigi; k++)
371                 digi.calls[k] = ax25_ctl.digi_addr[k];
372
373         if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
374                 return -ENOTCONN;
375
376         switch (ax25_ctl.cmd) {
377         case AX25_KILL:
378                 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
379 #ifdef CONFIG_AX25_DAMA_SLAVE
380                 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
381                         ax25_dama_off(ax25);
382 #endif
383                 ax25_disconnect(ax25, ENETRESET);
384                 break;
385
386         case AX25_WINDOW:
387                 if (ax25->modulus == AX25_MODULUS) {
388                         if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
389                                 return -EINVAL;
390                 } else {
391                         if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
392                                 return -EINVAL;
393                 }
394                 ax25->window = ax25_ctl.arg;
395                 break;
396
397         case AX25_T1:
398                 if (ax25_ctl.arg < 1)
399                         return -EINVAL;
400                 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
401                 ax25->t1  = ax25_ctl.arg * HZ;
402                 break;
403
404         case AX25_T2:
405                 if (ax25_ctl.arg < 1)
406                         return -EINVAL;
407                 ax25->t2 = ax25_ctl.arg * HZ;
408                 break;
409
410         case AX25_N2:
411                 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
412                         return -EINVAL;
413                 ax25->n2count = 0;
414                 ax25->n2 = ax25_ctl.arg;
415                 break;
416
417         case AX25_T3:
418                 if (ax25_ctl.arg < 0)
419                         return -EINVAL;
420                 ax25->t3 = ax25_ctl.arg * HZ;
421                 break;
422
423         case AX25_IDLE:
424                 if (ax25_ctl.arg < 0)
425                         return -EINVAL;
426                 ax25->idle = ax25_ctl.arg * 60 * HZ;
427                 break;
428
429         case AX25_PACLEN:
430                 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
431                         return -EINVAL;
432                 ax25->paclen = ax25_ctl.arg;
433                 break;
434
435         default:
436                 return -EINVAL;
437           }
438
439         return 0;
440 }
441
442 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
443 {
444         ax25->rtt     = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
445         ax25->t1      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
446         ax25->t2      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
447         ax25->t3      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
448         ax25->n2      = ax25_dev->values[AX25_VALUES_N2];
449         ax25->paclen  = ax25_dev->values[AX25_VALUES_PACLEN];
450         ax25->idle    = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
451         ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
452
453         if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
454                 ax25->modulus = AX25_EMODULUS;
455                 ax25->window  = ax25_dev->values[AX25_VALUES_EWINDOW];
456         } else {
457                 ax25->modulus = AX25_MODULUS;
458                 ax25->window  = ax25_dev->values[AX25_VALUES_WINDOW];
459         }
460 }
461
462 /*
463  *      Fill in a created AX.25 created control block with the default
464  *      values for a particular device.
465  */
466 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
467 {
468         ax25->ax25_dev = ax25_dev;
469
470         if (ax25->ax25_dev != NULL) {
471                 ax25_fillin_cb_from_dev(ax25, ax25_dev);
472                 return;
473         }
474
475         /*
476          * No device, use kernel / AX.25 spec default values
477          */
478         ax25->rtt     = msecs_to_jiffies(AX25_DEF_T1) / 2;
479         ax25->t1      = msecs_to_jiffies(AX25_DEF_T1);
480         ax25->t2      = msecs_to_jiffies(AX25_DEF_T2);
481         ax25->t3      = msecs_to_jiffies(AX25_DEF_T3);
482         ax25->n2      = AX25_DEF_N2;
483         ax25->paclen  = AX25_DEF_PACLEN;
484         ax25->idle    = msecs_to_jiffies(AX25_DEF_IDLE);
485         ax25->backoff = AX25_DEF_BACKOFF;
486
487         if (AX25_DEF_AXDEFMODE) {
488                 ax25->modulus = AX25_EMODULUS;
489                 ax25->window  = AX25_DEF_EWINDOW;
490         } else {
491                 ax25->modulus = AX25_MODULUS;
492                 ax25->window  = AX25_DEF_WINDOW;
493         }
494 }
495
496 /*
497  * Create an empty AX.25 control block.
498  */
499 ax25_cb *ax25_create_cb(void)
500 {
501         ax25_cb *ax25;
502
503         if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
504                 return NULL;
505
506         atomic_set(&ax25->refcount, 1);
507
508         skb_queue_head_init(&ax25->write_queue);
509         skb_queue_head_init(&ax25->frag_queue);
510         skb_queue_head_init(&ax25->ack_queue);
511         skb_queue_head_init(&ax25->reseq_queue);
512
513         ax25_setup_timers(ax25);
514
515         ax25_fillin_cb(ax25, NULL);
516
517         ax25->state = AX25_STATE_0;
518
519         return ax25;
520 }
521
522 /*
523  *      Handling for system calls applied via the various interfaces to an
524  *      AX25 socket object
525  */
526
527 static int ax25_setsockopt(struct socket *sock, int level, int optname,
528         char __user *optval, int optlen)
529 {
530         struct sock *sk = sock->sk;
531         ax25_cb *ax25;
532         struct net_device *dev;
533         char devname[IFNAMSIZ];
534         int opt, res = 0;
535
536         if (level != SOL_AX25)
537                 return -ENOPROTOOPT;
538
539         if (optlen < sizeof(int))
540                 return -EINVAL;
541
542         if (get_user(opt, (int __user *)optval))
543                 return -EFAULT;
544
545         lock_sock(sk);
546         ax25 = ax25_sk(sk);
547
548         switch (optname) {
549         case AX25_WINDOW:
550                 if (ax25->modulus == AX25_MODULUS) {
551                         if (opt < 1 || opt > 7) {
552                                 res = -EINVAL;
553                                 break;
554                         }
555                 } else {
556                         if (opt < 1 || opt > 63) {
557                                 res = -EINVAL;
558                                 break;
559                         }
560                 }
561                 ax25->window = opt;
562                 break;
563
564         case AX25_T1:
565                 if (opt < 1) {
566                         res = -EINVAL;
567                         break;
568                 }
569                 ax25->rtt = (opt * HZ) >> 1;
570                 ax25->t1  = opt * HZ;
571                 break;
572
573         case AX25_T2:
574                 if (opt < 1) {
575                         res = -EINVAL;
576                         break;
577                 }
578                 ax25->t2 = opt * HZ;
579                 break;
580
581         case AX25_N2:
582                 if (opt < 1 || opt > 31) {
583                         res = -EINVAL;
584                         break;
585                 }
586                 ax25->n2 = opt;
587                 break;
588
589         case AX25_T3:
590                 if (opt < 1) {
591                         res = -EINVAL;
592                         break;
593                 }
594                 ax25->t3 = opt * HZ;
595                 break;
596
597         case AX25_IDLE:
598                 if (opt < 0) {
599                         res = -EINVAL;
600                         break;
601                 }
602                 ax25->idle = opt * 60 * HZ;
603                 break;
604
605         case AX25_BACKOFF:
606                 if (opt < 0 || opt > 2) {
607                         res = -EINVAL;
608                         break;
609                 }
610                 ax25->backoff = opt;
611                 break;
612
613         case AX25_EXTSEQ:
614                 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
615                 break;
616
617         case AX25_PIDINCL:
618                 ax25->pidincl = opt ? 1 : 0;
619                 break;
620
621         case AX25_IAMDIGI:
622                 ax25->iamdigi = opt ? 1 : 0;
623                 break;
624
625         case AX25_PACLEN:
626                 if (opt < 16 || opt > 65535) {
627                         res = -EINVAL;
628                         break;
629                 }
630                 ax25->paclen = opt;
631                 break;
632
633         case SO_BINDTODEVICE:
634                 if (optlen > IFNAMSIZ)
635                         optlen=IFNAMSIZ;
636                 if (copy_from_user(devname, optval, optlen)) {
637                 res = -EFAULT;
638                         break;
639                 }
640
641                 dev = dev_get_by_name(&init_net, devname);
642                 if (dev == NULL) {
643                         res = -ENODEV;
644                         break;
645                 }
646
647                 if (sk->sk_type == SOCK_SEQPACKET &&
648                    (sock->state != SS_UNCONNECTED ||
649                     sk->sk_state == TCP_LISTEN)) {
650                         res = -EADDRNOTAVAIL;
651                         dev_put(dev);
652                         break;
653                 }
654
655                 ax25->ax25_dev = ax25_dev_ax25dev(dev);
656                 ax25_fillin_cb(ax25, ax25->ax25_dev);
657                 break;
658
659         default:
660                 res = -ENOPROTOOPT;
661         }
662         release_sock(sk);
663
664         return res;
665 }
666
667 static int ax25_getsockopt(struct socket *sock, int level, int optname,
668         char __user *optval, int __user *optlen)
669 {
670         struct sock *sk = sock->sk;
671         ax25_cb *ax25;
672         struct ax25_dev *ax25_dev;
673         char devname[IFNAMSIZ];
674         void *valptr;
675         int val = 0;
676         int maxlen, length;
677
678         if (level != SOL_AX25)
679                 return -ENOPROTOOPT;
680
681         if (get_user(maxlen, optlen))
682                 return -EFAULT;
683
684         if (maxlen < 1)
685                 return -EFAULT;
686
687         valptr = (void *) &val;
688         length = min_t(unsigned int, maxlen, sizeof(int));
689
690         lock_sock(sk);
691         ax25 = ax25_sk(sk);
692
693         switch (optname) {
694         case AX25_WINDOW:
695                 val = ax25->window;
696                 break;
697
698         case AX25_T1:
699                 val = ax25->t1 / HZ;
700                 break;
701
702         case AX25_T2:
703                 val = ax25->t2 / HZ;
704                 break;
705
706         case AX25_N2:
707                 val = ax25->n2;
708                 break;
709
710         case AX25_T3:
711                 val = ax25->t3 / HZ;
712                 break;
713
714         case AX25_IDLE:
715                 val = ax25->idle / (60 * HZ);
716                 break;
717
718         case AX25_BACKOFF:
719                 val = ax25->backoff;
720                 break;
721
722         case AX25_EXTSEQ:
723                 val = (ax25->modulus == AX25_EMODULUS);
724                 break;
725
726         case AX25_PIDINCL:
727                 val = ax25->pidincl;
728                 break;
729
730         case AX25_IAMDIGI:
731                 val = ax25->iamdigi;
732                 break;
733
734         case AX25_PACLEN:
735                 val = ax25->paclen;
736                 break;
737
738         case SO_BINDTODEVICE:
739                 ax25_dev = ax25->ax25_dev;
740
741                 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
742                         strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
743                         length = strlen(devname) + 1;
744                 } else {
745                         *devname = '\0';
746                         length = 1;
747                 }
748
749                 valptr = (void *) devname;
750                 break;
751
752         default:
753                 release_sock(sk);
754                 return -ENOPROTOOPT;
755         }
756         release_sock(sk);
757
758         if (put_user(length, optlen))
759                 return -EFAULT;
760
761         return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
762 }
763
764 static int ax25_listen(struct socket *sock, int backlog)
765 {
766         struct sock *sk = sock->sk;
767         int res = 0;
768
769         lock_sock(sk);
770         if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
771                 sk->sk_max_ack_backlog = backlog;
772                 sk->sk_state           = TCP_LISTEN;
773                 goto out;
774         }
775         res = -EOPNOTSUPP;
776
777 out:
778         release_sock(sk);
779
780         return res;
781 }
782
783 /*
784  * XXX: when creating ax25_sock we should update the .obj_size setting
785  * below.
786  */
787 static struct proto ax25_proto = {
788         .name     = "AX25",
789         .owner    = THIS_MODULE,
790         .obj_size = sizeof(struct sock),
791 };
792
793 static int ax25_create(struct net *net, struct socket *sock, int protocol)
794 {
795         struct sock *sk;
796         ax25_cb *ax25;
797
798         if (net != &init_net)
799                 return -EAFNOSUPPORT;
800
801         switch (sock->type) {
802         case SOCK_DGRAM:
803                 if (protocol == 0 || protocol == PF_AX25)
804                         protocol = AX25_P_TEXT;
805                 break;
806
807         case SOCK_SEQPACKET:
808                 switch (protocol) {
809                 case 0:
810                 case PF_AX25:   /* For CLX */
811                         protocol = AX25_P_TEXT;
812                         break;
813                 case AX25_P_SEGMENT:
814 #ifdef CONFIG_INET
815                 case AX25_P_ARP:
816                 case AX25_P_IP:
817 #endif
818 #ifdef CONFIG_NETROM
819                 case AX25_P_NETROM:
820 #endif
821 #ifdef CONFIG_ROSE
822                 case AX25_P_ROSE:
823 #endif
824                         return -ESOCKTNOSUPPORT;
825 #ifdef CONFIG_NETROM_MODULE
826                 case AX25_P_NETROM:
827                         if (ax25_protocol_is_registered(AX25_P_NETROM))
828                                 return -ESOCKTNOSUPPORT;
829 #endif
830 #ifdef CONFIG_ROSE_MODULE
831                 case AX25_P_ROSE:
832                         if (ax25_protocol_is_registered(AX25_P_ROSE))
833                                 return -ESOCKTNOSUPPORT;
834 #endif
835                 default:
836                         break;
837                 }
838                 break;
839
840         case SOCK_RAW:
841                 break;
842         default:
843                 return -ESOCKTNOSUPPORT;
844         }
845
846         sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
847         if (sk == NULL)
848                 return -ENOMEM;
849
850         ax25 = sk->sk_protinfo = ax25_create_cb();
851         if (!ax25) {
852                 sk_free(sk);
853                 return -ENOMEM;
854         }
855
856         sock_init_data(sock, sk);
857
858         sk->sk_destruct = ax25_free_sock;
859         sock->ops    = &ax25_proto_ops;
860         sk->sk_protocol = protocol;
861
862         ax25->sk    = sk;
863
864         return 0;
865 }
866
867 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
868 {
869         struct sock *sk;
870         ax25_cb *ax25, *oax25;
871
872         sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC,       osk->sk_prot);
873         if (sk == NULL)
874                 return NULL;
875
876         if ((ax25 = ax25_create_cb()) == NULL) {
877                 sk_free(sk);
878                 return NULL;
879         }
880
881         switch (osk->sk_type) {
882         case SOCK_DGRAM:
883                 break;
884         case SOCK_SEQPACKET:
885                 break;
886         default:
887                 sk_free(sk);
888                 ax25_cb_put(ax25);
889                 return NULL;
890         }
891
892         sock_init_data(NULL, sk);
893
894         sk->sk_destruct = ax25_free_sock;
895         sk->sk_type     = osk->sk_type;
896         sk->sk_socket   = osk->sk_socket;
897         sk->sk_priority = osk->sk_priority;
898         sk->sk_protocol = osk->sk_protocol;
899         sk->sk_rcvbuf   = osk->sk_rcvbuf;
900         sk->sk_sndbuf   = osk->sk_sndbuf;
901         sk->sk_state    = TCP_ESTABLISHED;
902         sk->sk_sleep    = osk->sk_sleep;
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         newsk->sk_socket = newsock;
1365         newsk->sk_sleep  = &newsock->wait;
1366
1367         /* Now attach up the new socket */
1368         kfree_skb(skb);
1369         sk->sk_ack_backlog--;
1370         newsock->sk    = newsk;
1371         newsock->state = SS_CONNECTED;
1372
1373 out:
1374         release_sock(sk);
1375
1376         return err;
1377 }
1378
1379 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1380         int *uaddr_len, int peer)
1381 {
1382         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1383         struct sock *sk = sock->sk;
1384         unsigned char ndigi, i;
1385         ax25_cb *ax25;
1386         int err = 0;
1387
1388         lock_sock(sk);
1389         ax25 = ax25_sk(sk);
1390
1391         if (peer != 0) {
1392                 if (sk->sk_state != TCP_ESTABLISHED) {
1393                         err = -ENOTCONN;
1394                         goto out;
1395                 }
1396
1397                 fsa->fsa_ax25.sax25_family = AF_AX25;
1398                 fsa->fsa_ax25.sax25_call   = ax25->dest_addr;
1399                 fsa->fsa_ax25.sax25_ndigis = 0;
1400
1401                 if (ax25->digipeat != NULL) {
1402                         ndigi = ax25->digipeat->ndigi;
1403                         fsa->fsa_ax25.sax25_ndigis = ndigi;
1404                         for (i = 0; i < ndigi; i++)
1405                                 fsa->fsa_digipeater[i] =
1406                                                 ax25->digipeat->calls[i];
1407                 }
1408         } else {
1409                 fsa->fsa_ax25.sax25_family = AF_AX25;
1410                 fsa->fsa_ax25.sax25_call   = ax25->source_addr;
1411                 fsa->fsa_ax25.sax25_ndigis = 1;
1412                 if (ax25->ax25_dev != NULL) {
1413                         memcpy(&fsa->fsa_digipeater[0],
1414                                ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1415                 } else {
1416                         fsa->fsa_digipeater[0] = null_ax25_address;
1417                 }
1418         }
1419         *uaddr_len = sizeof (struct full_sockaddr_ax25);
1420
1421 out:
1422         release_sock(sk);
1423
1424         return err;
1425 }
1426
1427 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1428                         struct msghdr *msg, size_t len)
1429 {
1430         struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1431         struct sock *sk = sock->sk;
1432         struct sockaddr_ax25 sax;
1433         struct sk_buff *skb;
1434         ax25_digi dtmp, *dp;
1435         ax25_cb *ax25;
1436         size_t size;
1437         int lv, err, addr_len = msg->msg_namelen;
1438
1439         if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1440                 return -EINVAL;
1441
1442         lock_sock(sk);
1443         ax25 = ax25_sk(sk);
1444
1445         if (sock_flag(sk, SOCK_ZAPPED)) {
1446                 err = -EADDRNOTAVAIL;
1447                 goto out;
1448         }
1449
1450         if (sk->sk_shutdown & SEND_SHUTDOWN) {
1451                 send_sig(SIGPIPE, current, 0);
1452                 err = -EPIPE;
1453                 goto out;
1454         }
1455
1456         if (ax25->ax25_dev == NULL) {
1457                 err = -ENETUNREACH;
1458                 goto out;
1459         }
1460
1461         if (len > ax25->ax25_dev->dev->mtu) {
1462                 err = -EMSGSIZE;
1463                 goto out;
1464         }
1465
1466         if (usax != NULL) {
1467                 if (usax->sax25_family != AF_AX25) {
1468                         err = -EINVAL;
1469                         goto out;
1470                 }
1471
1472                 if (addr_len == sizeof(struct sockaddr_ax25))
1473                         /* ax25_sendmsg(): uses obsolete socket structure */
1474                         ;
1475                 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1476                         /* support for old structure may go away some time
1477                          * ax25_sendmsg(): uses old (6 digipeater)
1478                          * socket structure.
1479                          */
1480                         if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1481                             (addr_len > sizeof(struct full_sockaddr_ax25))) {
1482                                 err = -EINVAL;
1483                                 goto out;
1484                         }
1485
1486
1487                 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1488                         int ct           = 0;
1489                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1490
1491                         /* Valid number of digipeaters ? */
1492                         if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1493                                 err = -EINVAL;
1494                                 goto out;
1495                         }
1496
1497                         dtmp.ndigi      = usax->sax25_ndigis;
1498
1499                         while (ct < usax->sax25_ndigis) {
1500                                 dtmp.repeated[ct] = 0;
1501                                 dtmp.calls[ct]    = fsa->fsa_digipeater[ct];
1502                                 ct++;
1503                         }
1504
1505                         dtmp.lastrepeat = 0;
1506                 }
1507
1508                 sax = *usax;
1509                 if (sk->sk_type == SOCK_SEQPACKET &&
1510                     ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1511                         err = -EISCONN;
1512                         goto out;
1513                 }
1514                 if (usax->sax25_ndigis == 0)
1515                         dp = NULL;
1516                 else
1517                         dp = &dtmp;
1518         } else {
1519                 /*
1520                  *      FIXME: 1003.1g - if the socket is like this because
1521                  *      it has become closed (not started closed) and is VC
1522                  *      we ought to SIGPIPE, EPIPE
1523                  */
1524                 if (sk->sk_state != TCP_ESTABLISHED) {
1525                         err = -ENOTCONN;
1526                         goto out;
1527                 }
1528                 sax.sax25_family = AF_AX25;
1529                 sax.sax25_call   = ax25->dest_addr;
1530                 dp = ax25->digipeat;
1531         }
1532
1533         SOCK_DEBUG(sk, "AX.25: sendto: Addresses built.\n");
1534
1535         /* Build a packet */
1536         SOCK_DEBUG(sk, "AX.25: sendto: building packet.\n");
1537
1538         /* Assume the worst case */
1539         size = len + ax25->ax25_dev->dev->hard_header_len;
1540
1541         skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1542         if (skb == NULL)
1543                 goto out;
1544
1545         skb_reserve(skb, size - len);
1546
1547         SOCK_DEBUG(sk, "AX.25: Appending user data\n");
1548
1549         /* User data follows immediately after the AX.25 data */
1550         if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1551                 err = -EFAULT;
1552                 kfree_skb(skb);
1553                 goto out;
1554         }
1555
1556         skb_reset_network_header(skb);
1557
1558         /* Add the PID if one is not supplied by the user in the skb */
1559         if (!ax25->pidincl)
1560                 *skb_push(skb, 1) = sk->sk_protocol;
1561
1562         SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n");
1563
1564         if (sk->sk_type == SOCK_SEQPACKET) {
1565                 /* Connected mode sockets go via the LAPB machine */
1566                 if (sk->sk_state != TCP_ESTABLISHED) {
1567                         kfree_skb(skb);
1568                         err = -ENOTCONN;
1569                         goto out;
1570                 }
1571
1572                 /* Shove it onto the queue and kick */
1573                 ax25_output(ax25, ax25->paclen, skb);
1574
1575                 err = len;
1576                 goto out;
1577         }
1578
1579         skb_push(skb, 1 + ax25_addr_size(dp));
1580
1581         SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp);
1582
1583         if (dp != NULL)
1584                 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi);
1585
1586         /* Build an AX.25 header */
1587         lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1588                              dp, AX25_COMMAND, AX25_MODULUS);
1589
1590         SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv);
1591
1592         skb_set_transport_header(skb, lv);
1593
1594         SOCK_DEBUG(sk, "base=%p pos=%p\n",
1595                    skb->data, skb_transport_header(skb));
1596
1597         *skb_transport_header(skb) = AX25_UI;
1598
1599         /* Datagram frames go straight out of the door as UI */
1600         ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1601
1602         err = len;
1603
1604 out:
1605         release_sock(sk);
1606
1607         return err;
1608 }
1609
1610 static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1611         struct msghdr *msg, size_t size, int flags)
1612 {
1613         struct sock *sk = sock->sk;
1614         struct sk_buff *skb;
1615         int copied;
1616         int err = 0;
1617
1618         lock_sock(sk);
1619         /*
1620          *      This works for seqpacket too. The receiver has ordered the
1621          *      queue for us! We do one quick check first though
1622          */
1623         if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1624                 err =  -ENOTCONN;
1625                 goto out;
1626         }
1627
1628         /* Now we can treat all alike */
1629         skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1630                                 flags & MSG_DONTWAIT, &err);
1631         if (skb == NULL)
1632                 goto out;
1633
1634         if (!ax25_sk(sk)->pidincl)
1635                 skb_pull(skb, 1);               /* Remove PID */
1636
1637         skb_reset_transport_header(skb);
1638         copied = skb->len;
1639
1640         if (copied > size) {
1641                 copied = size;
1642                 msg->msg_flags |= MSG_TRUNC;
1643         }
1644
1645         skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1646
1647         if (msg->msg_namelen != 0) {
1648                 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1649                 ax25_digi digi;
1650                 ax25_address src;
1651                 const unsigned char *mac = skb_mac_header(skb);
1652
1653                 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1654                                 &digi, NULL, NULL);
1655                 sax->sax25_family = AF_AX25;
1656                 /* We set this correctly, even though we may not let the
1657                    application know the digi calls further down (because it
1658                    did NOT ask to know them).  This could get political... **/
1659                 sax->sax25_ndigis = digi.ndigi;
1660                 sax->sax25_call   = src;
1661
1662                 if (sax->sax25_ndigis != 0) {
1663                         int ct;
1664                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1665
1666                         for (ct = 0; ct < digi.ndigi; ct++)
1667                                 fsa->fsa_digipeater[ct] = digi.calls[ct];
1668                 }
1669                 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1670         }
1671
1672         skb_free_datagram(sk, skb);
1673         err = copied;
1674
1675 out:
1676         release_sock(sk);
1677
1678         return err;
1679 }
1680
1681 static int ax25_shutdown(struct socket *sk, int how)
1682 {
1683         /* FIXME - generate DM and RNR states */
1684         return -EOPNOTSUPP;
1685 }
1686
1687 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1688 {
1689         struct sock *sk = sock->sk;
1690         void __user *argp = (void __user *)arg;
1691         int res = 0;
1692
1693         lock_sock(sk);
1694         switch (cmd) {
1695         case TIOCOUTQ: {
1696                 long amount;
1697                 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
1698                 if (amount < 0)
1699                         amount = 0;
1700                 res = put_user(amount, (int __user *)argp);
1701                 break;
1702         }
1703
1704         case TIOCINQ: {
1705                 struct sk_buff *skb;
1706                 long amount = 0L;
1707                 /* These two are safe on a single CPU system as only user tasks fiddle here */
1708                 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1709                         amount = skb->len;
1710                 res = put_user(amount, (int __user *) argp);
1711                 break;
1712         }
1713
1714         case SIOCGSTAMP:
1715                 res = sock_get_timestamp(sk, argp);
1716                 break;
1717
1718         case SIOCGSTAMPNS:
1719                 res = sock_get_timestampns(sk, argp);
1720                 break;
1721
1722         case SIOCAX25ADDUID:    /* Add a uid to the uid/call map table */
1723         case SIOCAX25DELUID:    /* Delete a uid from the uid/call map table */
1724         case SIOCAX25GETUID: {
1725                 struct sockaddr_ax25 sax25;
1726                 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1727                         res = -EFAULT;
1728                         break;
1729                 }
1730                 res = ax25_uid_ioctl(cmd, &sax25);
1731                 break;
1732         }
1733
1734         case SIOCAX25NOUID: {   /* Set the default policy (default/bar) */
1735                 long amount;
1736                 if (!capable(CAP_NET_ADMIN)) {
1737                         res = -EPERM;
1738                         break;
1739                 }
1740                 if (get_user(amount, (long __user *)argp)) {
1741                         res = -EFAULT;
1742                         break;
1743                 }
1744                 if (amount > AX25_NOUID_BLOCK) {
1745                         res = -EINVAL;
1746                         break;
1747                 }
1748                 ax25_uid_policy = amount;
1749                 res = 0;
1750                 break;
1751         }
1752
1753         case SIOCADDRT:
1754         case SIOCDELRT:
1755         case SIOCAX25OPTRT:
1756                 if (!capable(CAP_NET_ADMIN)) {
1757                         res = -EPERM;
1758                         break;
1759                 }
1760                 res = ax25_rt_ioctl(cmd, argp);
1761                 break;
1762
1763         case SIOCAX25CTLCON:
1764                 if (!capable(CAP_NET_ADMIN)) {
1765                         res = -EPERM;
1766                         break;
1767                 }
1768                 res = ax25_ctl_ioctl(cmd, argp);
1769                 break;
1770
1771         case SIOCAX25GETINFO:
1772         case SIOCAX25GETINFOOLD: {
1773                 ax25_cb *ax25 = ax25_sk(sk);
1774                 struct ax25_info_struct ax25_info;
1775
1776                 ax25_info.t1        = ax25->t1   / HZ;
1777                 ax25_info.t2        = ax25->t2   / HZ;
1778                 ax25_info.t3        = ax25->t3   / HZ;
1779                 ax25_info.idle      = ax25->idle / (60 * HZ);
1780                 ax25_info.n2        = ax25->n2;
1781                 ax25_info.t1timer   = ax25_display_timer(&ax25->t1timer)   / HZ;
1782                 ax25_info.t2timer   = ax25_display_timer(&ax25->t2timer)   / HZ;
1783                 ax25_info.t3timer   = ax25_display_timer(&ax25->t3timer)   / HZ;
1784                 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1785                 ax25_info.n2count   = ax25->n2count;
1786                 ax25_info.state     = ax25->state;
1787                 ax25_info.rcv_q     = atomic_read(&sk->sk_rmem_alloc);
1788                 ax25_info.snd_q     = atomic_read(&sk->sk_wmem_alloc);
1789                 ax25_info.vs        = ax25->vs;
1790                 ax25_info.vr        = ax25->vr;
1791                 ax25_info.va        = ax25->va;
1792                 ax25_info.vs_max    = ax25->vs; /* reserved */
1793                 ax25_info.paclen    = ax25->paclen;
1794                 ax25_info.window    = ax25->window;
1795
1796                 /* old structure? */
1797                 if (cmd == SIOCAX25GETINFOOLD) {
1798                         static int warned = 0;
1799                         if (!warned) {
1800                                 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1801                                         current->comm);
1802                                 warned=1;
1803                         }
1804
1805                         if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1806                                 res = -EFAULT;
1807                                 break;
1808                         }
1809                 } else {
1810                         if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1811                                 res = -EINVAL;
1812                                 break;
1813                         }
1814                 }
1815                 res = 0;
1816                 break;
1817         }
1818
1819         case SIOCAX25ADDFWD:
1820         case SIOCAX25DELFWD: {
1821                 struct ax25_fwd_struct ax25_fwd;
1822                 if (!capable(CAP_NET_ADMIN)) {
1823                         res = -EPERM;
1824                         break;
1825                 }
1826                 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1827                         res = -EFAULT;
1828                         break;
1829                 }
1830                 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1831                 break;
1832         }
1833
1834         case SIOCGIFADDR:
1835         case SIOCSIFADDR:
1836         case SIOCGIFDSTADDR:
1837         case SIOCSIFDSTADDR:
1838         case SIOCGIFBRDADDR:
1839         case SIOCSIFBRDADDR:
1840         case SIOCGIFNETMASK:
1841         case SIOCSIFNETMASK:
1842         case SIOCGIFMETRIC:
1843         case SIOCSIFMETRIC:
1844                 res = -EINVAL;
1845                 break;
1846
1847         default:
1848                 res = -ENOIOCTLCMD;
1849                 break;
1850         }
1851         release_sock(sk);
1852
1853         return res;
1854 }
1855
1856 #ifdef CONFIG_PROC_FS
1857
1858 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1859         __acquires(ax25_list_lock)
1860 {
1861         struct ax25_cb *ax25;
1862         struct hlist_node *node;
1863         int i = 0;
1864
1865         spin_lock_bh(&ax25_list_lock);
1866         ax25_for_each(ax25, node, &ax25_list) {
1867                 if (i == *pos)
1868                         return ax25;
1869                 ++i;
1870         }
1871         return NULL;
1872 }
1873
1874 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1875 {
1876         ++*pos;
1877
1878         return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1879                             struct ax25_cb, ax25_node);
1880 }
1881
1882 static void ax25_info_stop(struct seq_file *seq, void *v)
1883         __releases(ax25_list_lock)
1884 {
1885         spin_unlock_bh(&ax25_list_lock);
1886 }
1887
1888 static int ax25_info_show(struct seq_file *seq, void *v)
1889 {
1890         ax25_cb *ax25 = v;
1891         char buf[11];
1892         int k;
1893
1894
1895         /*
1896          * New format:
1897          * 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
1898          */
1899
1900         seq_printf(seq, "%8.8lx %s %s%s ",
1901                    (long) ax25,
1902                    ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1903                    ax2asc(buf, &ax25->source_addr),
1904                    ax25->iamdigi? "*":"");
1905         seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1906
1907         for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1908                 seq_printf(seq, ",%s%s",
1909                            ax2asc(buf, &ax25->digipeat->calls[k]),
1910                            ax25->digipeat->repeated[k]? "*":"");
1911         }
1912
1913         seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1914                    ax25->state,
1915                    ax25->vs, ax25->vr, ax25->va,
1916                    ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1917                    ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1918                    ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1919                    ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1920                    ax25->idle / (60 * HZ),
1921                    ax25->n2count, ax25->n2,
1922                    ax25->rtt / HZ,
1923                    ax25->window,
1924                    ax25->paclen);
1925
1926         if (ax25->sk != NULL) {
1927                 seq_printf(seq, " %d %d %lu\n",
1928                            atomic_read(&ax25->sk->sk_wmem_alloc),
1929                            atomic_read(&ax25->sk->sk_rmem_alloc),
1930                            sock_i_ino(ax25->sk));
1931         } else {
1932                 seq_puts(seq, " * * *\n");
1933         }
1934         return 0;
1935 }
1936
1937 static const struct seq_operations ax25_info_seqops = {
1938         .start = ax25_info_start,
1939         .next = ax25_info_next,
1940         .stop = ax25_info_stop,
1941         .show = ax25_info_show,
1942 };
1943
1944 static int ax25_info_open(struct inode *inode, struct file *file)
1945 {
1946         return seq_open(file, &ax25_info_seqops);
1947 }
1948
1949 static const struct file_operations ax25_info_fops = {
1950         .owner = THIS_MODULE,
1951         .open = ax25_info_open,
1952         .read = seq_read,
1953         .llseek = seq_lseek,
1954         .release = seq_release,
1955 };
1956
1957 #endif
1958
1959 static struct net_proto_family ax25_family_ops = {
1960         .family =       PF_AX25,
1961         .create =       ax25_create,
1962         .owner  =       THIS_MODULE,
1963 };
1964
1965 static const struct proto_ops ax25_proto_ops = {
1966         .family         = PF_AX25,
1967         .owner          = THIS_MODULE,
1968         .release        = ax25_release,
1969         .bind           = ax25_bind,
1970         .connect        = ax25_connect,
1971         .socketpair     = sock_no_socketpair,
1972         .accept         = ax25_accept,
1973         .getname        = ax25_getname,
1974         .poll           = datagram_poll,
1975         .ioctl          = ax25_ioctl,
1976         .listen         = ax25_listen,
1977         .shutdown       = ax25_shutdown,
1978         .setsockopt     = ax25_setsockopt,
1979         .getsockopt     = ax25_getsockopt,
1980         .sendmsg        = ax25_sendmsg,
1981         .recvmsg        = ax25_recvmsg,
1982         .mmap           = sock_no_mmap,
1983         .sendpage       = sock_no_sendpage,
1984 };
1985
1986 /*
1987  *      Called by socket.c on kernel start up
1988  */
1989 static struct packet_type ax25_packet_type = {
1990         .type   =       __constant_htons(ETH_P_AX25),
1991         .dev    =       NULL,                           /* All devices */
1992         .func   =       ax25_kiss_rcv,
1993 };
1994
1995 static struct notifier_block ax25_dev_notifier = {
1996         .notifier_call =ax25_device_event,
1997 };
1998
1999 static int __init ax25_init(void)
2000 {
2001         int rc = proto_register(&ax25_proto, 0);
2002
2003         if (rc != 0)
2004                 goto out;
2005
2006         sock_register(&ax25_family_ops);
2007         dev_add_pack(&ax25_packet_type);
2008         register_netdevice_notifier(&ax25_dev_notifier);
2009         ax25_register_sysctl();
2010
2011         proc_net_fops_create(&init_net, "ax25_route", S_IRUGO, &ax25_route_fops);
2012         proc_net_fops_create(&init_net, "ax25", S_IRUGO, &ax25_info_fops);
2013         proc_net_fops_create(&init_net, "ax25_calls", S_IRUGO, &ax25_uid_fops);
2014 out:
2015         return rc;
2016 }
2017 module_init(ax25_init);
2018
2019
2020 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2021 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2022 MODULE_LICENSE("GPL");
2023 MODULE_ALIAS_NETPROTO(PF_AX25);
2024
2025 static void __exit ax25_exit(void)
2026 {
2027         proc_net_remove(&init_net, "ax25_route");
2028         proc_net_remove(&init_net, "ax25");
2029         proc_net_remove(&init_net, "ax25_calls");
2030         ax25_rt_free();
2031         ax25_uid_free();
2032         ax25_dev_free();
2033
2034         ax25_unregister_sysctl();
2035         unregister_netdevice_notifier(&ax25_dev_notifier);
2036
2037         dev_remove_pack(&ax25_packet_type);
2038
2039         sock_unregister(PF_AX25);
2040         proto_unregister(&ax25_proto);
2041 }
2042 module_exit(ax25_exit);