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