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