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