x86: minor cleanup of comments in processor.h
[wrt350n-kernel.git] / net / ax25 / af_ax25.c
blob48bfcc741f2595db4f8d4f674e43f6a65751f608
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.
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)
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>
54 HLIST_HEAD(ax25_list);
55 DEFINE_SPINLOCK(ax25_list_lock);
57 static const struct proto_ops ax25_proto_ops;
59 static void ax25_free_sock(struct sock *sk)
61 ax25_cb_put(ax25_sk(sk));
65 * Socket removal during an interrupt is now safe.
67 static void ax25_cb_del(ax25_cb *ax25)
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);
78 * Kill all bound sockets on a dropped device.
80 static void ax25_kill_by_device(struct net_device *dev)
82 ax25_dev *ax25_dev;
83 ax25_cb *s;
84 struct hlist_node *node;
86 if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
87 return;
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);
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.
105 goto again;
108 spin_unlock_bh(&ax25_list_lock);
112 * Handle device status changes.
114 static int ax25_device_event(struct notifier_block *this, unsigned long event,
115 void *ptr)
117 struct net_device *dev = (struct net_device *)ptr;
119 if (dev->nd_net != &init_net)
120 return NOTIFY_DONE;
122 /* Reject non AX.25 devices */
123 if (dev->type != ARPHRD_AX25)
124 return NOTIFY_DONE;
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;
139 return NOTIFY_DONE;
143 * Add a socket to the bound sockets list.
145 void ax25_cb_add(ax25_cb *ax25)
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);
154 * Find a socket that wants to accept the SABM we have just
155 * received.
157 struct sock *ax25_find_listener(ax25_address *addr, int digi,
158 struct net_device *dev, int type)
160 ax25_cb *s;
161 struct hlist_node *node;
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;
177 spin_unlock(&ax25_list_lock);
179 return NULL;
183 * Find an AX.25 socket given both ends.
185 struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
186 int type)
188 struct sock *sk = NULL;
189 ax25_cb *s;
190 struct hlist_node *node;
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;
203 spin_unlock(&ax25_list_lock);
205 return sk;
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.
212 ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
213 ax25_digi *digi, struct net_device *dev)
215 ax25_cb *s;
216 struct hlist_node *node;
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;
234 ax25_cb_hold(s);
235 spin_unlock_bh(&ax25_list_lock);
237 return s;
240 spin_unlock_bh(&ax25_list_lock);
242 return NULL;
245 EXPORT_SYMBOL(ax25_find_cb);
247 void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
249 ax25_cb *s;
250 struct sk_buff *copy;
251 struct hlist_node *node;
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);
266 spin_unlock(&ax25_list_lock);
270 * Deferred destroy.
272 void ax25_destroy_socket(ax25_cb *);
275 * Handler for deferred kills.
277 static void ax25_destroy_timer(unsigned long data)
279 ax25_cb *ax25=(ax25_cb *)data;
280 struct sock *sk;
282 sk=ax25->sk;
284 bh_lock_sock(sk);
285 sock_hold(sk);
286 ax25_destroy_socket(ax25);
287 bh_unlock_sock(sk);
288 sock_put(sk);
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.
297 void ax25_destroy_socket(ax25_cb *ax25)
299 struct sk_buff *skb;
301 ax25_cb_del(ax25);
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);
309 ax25_clear_queues(ax25); /* Flush the queues */
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);
317 /* Queue the unaccepted socket for death */
318 sock_orphan(skb->sk);
320 ax25_start_heartbeat(sax25);
321 sax25->state = AX25_STATE_0;
324 kfree_skb(skb);
326 skb_queue_purge(&ax25->sk->sk_write_queue);
329 if (ax25->sk != NULL) {
330 if (atomic_read(&ax25->sk->sk_wmem_alloc) ||
331 atomic_read(&ax25->sk->sk_rmem_alloc)) {
332 /* Defer: outstanding buffers */
333 setup_timer(&ax25->dtimer, ax25_destroy_timer,
334 (unsigned long)ax25);
335 ax25->dtimer.expires = jiffies + 2 * HZ;
336 add_timer(&ax25->dtimer);
337 } else {
338 struct sock *sk=ax25->sk;
339 ax25->sk=NULL;
340 sock_put(sk);
342 } else {
343 ax25_cb_put(ax25);
348 * dl1bke 960311: set parameters for existing AX.25 connections,
349 * includes a KILL command to abort any connection.
350 * VERY useful for debugging ;-)
352 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
354 struct ax25_ctl_struct ax25_ctl;
355 ax25_digi digi;
356 ax25_dev *ax25_dev;
357 ax25_cb *ax25;
358 unsigned int k;
360 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
361 return -EFAULT;
363 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
364 return -ENODEV;
366 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
367 return -EINVAL;
369 digi.ndigi = ax25_ctl.digi_count;
370 for (k = 0; k < digi.ndigi; k++)
371 digi.calls[k] = ax25_ctl.digi_addr[k];
373 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
374 return -ENOTCONN;
376 switch (ax25_ctl.cmd) {
377 case AX25_KILL:
378 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
379 #ifdef CONFIG_AX25_DAMA_SLAVE
380 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
381 ax25_dama_off(ax25);
382 #endif
383 ax25_disconnect(ax25, ENETRESET);
384 break;
386 case AX25_WINDOW:
387 if (ax25->modulus == AX25_MODULUS) {
388 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
389 return -EINVAL;
390 } else {
391 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
392 return -EINVAL;
394 ax25->window = ax25_ctl.arg;
395 break;
397 case AX25_T1:
398 if (ax25_ctl.arg < 1)
399 return -EINVAL;
400 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
401 ax25->t1 = ax25_ctl.arg * HZ;
402 break;
404 case AX25_T2:
405 if (ax25_ctl.arg < 1)
406 return -EINVAL;
407 ax25->t2 = ax25_ctl.arg * HZ;
408 break;
410 case AX25_N2:
411 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
412 return -EINVAL;
413 ax25->n2count = 0;
414 ax25->n2 = ax25_ctl.arg;
415 break;
417 case AX25_T3:
418 if (ax25_ctl.arg < 0)
419 return -EINVAL;
420 ax25->t3 = ax25_ctl.arg * HZ;
421 break;
423 case AX25_IDLE:
424 if (ax25_ctl.arg < 0)
425 return -EINVAL;
426 ax25->idle = ax25_ctl.arg * 60 * HZ;
427 break;
429 case AX25_PACLEN:
430 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
431 return -EINVAL;
432 ax25->paclen = ax25_ctl.arg;
433 break;
435 default:
436 return -EINVAL;
439 return 0;
442 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
444 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
445 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
446 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
447 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
448 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
449 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
450 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
451 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
453 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
454 ax25->modulus = AX25_EMODULUS;
455 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
456 } else {
457 ax25->modulus = AX25_MODULUS;
458 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
463 * Fill in a created AX.25 created control block with the default
464 * values for a particular device.
466 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
468 ax25->ax25_dev = ax25_dev;
470 if (ax25->ax25_dev != NULL) {
471 ax25_fillin_cb_from_dev(ax25, ax25_dev);
472 return;
476 * No device, use kernel / AX.25 spec default values
478 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
479 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
480 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
481 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
482 ax25->n2 = AX25_DEF_N2;
483 ax25->paclen = AX25_DEF_PACLEN;
484 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
485 ax25->backoff = AX25_DEF_BACKOFF;
487 if (AX25_DEF_AXDEFMODE) {
488 ax25->modulus = AX25_EMODULUS;
489 ax25->window = AX25_DEF_EWINDOW;
490 } else {
491 ax25->modulus = AX25_MODULUS;
492 ax25->window = AX25_DEF_WINDOW;
497 * Create an empty AX.25 control block.
499 ax25_cb *ax25_create_cb(void)
501 ax25_cb *ax25;
503 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
504 return NULL;
506 atomic_set(&ax25->refcount, 1);
508 skb_queue_head_init(&ax25->write_queue);
509 skb_queue_head_init(&ax25->frag_queue);
510 skb_queue_head_init(&ax25->ack_queue);
511 skb_queue_head_init(&ax25->reseq_queue);
513 ax25_setup_timers(ax25);
515 ax25_fillin_cb(ax25, NULL);
517 ax25->state = AX25_STATE_0;
519 return ax25;
523 * Handling for system calls applied via the various interfaces to an
524 * AX25 socket object
527 static int ax25_setsockopt(struct socket *sock, int level, int optname,
528 char __user *optval, int optlen)
530 struct sock *sk = sock->sk;
531 ax25_cb *ax25;
532 struct net_device *dev;
533 char devname[IFNAMSIZ];
534 int opt, res = 0;
536 if (level != SOL_AX25)
537 return -ENOPROTOOPT;
539 if (optlen < sizeof(int))
540 return -EINVAL;
542 if (get_user(opt, (int __user *)optval))
543 return -EFAULT;
545 lock_sock(sk);
546 ax25 = ax25_sk(sk);
548 switch (optname) {
549 case AX25_WINDOW:
550 if (ax25->modulus == AX25_MODULUS) {
551 if (opt < 1 || opt > 7) {
552 res = -EINVAL;
553 break;
555 } else {
556 if (opt < 1 || opt > 63) {
557 res = -EINVAL;
558 break;
561 ax25->window = opt;
562 break;
564 case AX25_T1:
565 if (opt < 1) {
566 res = -EINVAL;
567 break;
569 ax25->rtt = (opt * HZ) >> 1;
570 ax25->t1 = opt * HZ;
571 break;
573 case AX25_T2:
574 if (opt < 1) {
575 res = -EINVAL;
576 break;
578 ax25->t2 = opt * HZ;
579 break;
581 case AX25_N2:
582 if (opt < 1 || opt > 31) {
583 res = -EINVAL;
584 break;
586 ax25->n2 = opt;
587 break;
589 case AX25_T3:
590 if (opt < 1) {
591 res = -EINVAL;
592 break;
594 ax25->t3 = opt * HZ;
595 break;
597 case AX25_IDLE:
598 if (opt < 0) {
599 res = -EINVAL;
600 break;
602 ax25->idle = opt * 60 * HZ;
603 break;
605 case AX25_BACKOFF:
606 if (opt < 0 || opt > 2) {
607 res = -EINVAL;
608 break;
610 ax25->backoff = opt;
611 break;
613 case AX25_EXTSEQ:
614 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
615 break;
617 case AX25_PIDINCL:
618 ax25->pidincl = opt ? 1 : 0;
619 break;
621 case AX25_IAMDIGI:
622 ax25->iamdigi = opt ? 1 : 0;
623 break;
625 case AX25_PACLEN:
626 if (opt < 16 || opt > 65535) {
627 res = -EINVAL;
628 break;
630 ax25->paclen = opt;
631 break;
633 case SO_BINDTODEVICE:
634 if (optlen > IFNAMSIZ)
635 optlen=IFNAMSIZ;
636 if (copy_from_user(devname, optval, optlen)) {
637 res = -EFAULT;
638 break;
641 dev = dev_get_by_name(&init_net, devname);
642 if (dev == NULL) {
643 res = -ENODEV;
644 break;
647 if (sk->sk_type == SOCK_SEQPACKET &&
648 (sock->state != SS_UNCONNECTED ||
649 sk->sk_state == TCP_LISTEN)) {
650 res = -EADDRNOTAVAIL;
651 dev_put(dev);
652 break;
655 ax25->ax25_dev = ax25_dev_ax25dev(dev);
656 ax25_fillin_cb(ax25, ax25->ax25_dev);
657 break;
659 default:
660 res = -ENOPROTOOPT;
662 release_sock(sk);
664 return res;
667 static int ax25_getsockopt(struct socket *sock, int level, int optname,
668 char __user *optval, int __user *optlen)
670 struct sock *sk = sock->sk;
671 ax25_cb *ax25;
672 struct ax25_dev *ax25_dev;
673 char devname[IFNAMSIZ];
674 void *valptr;
675 int val = 0;
676 int maxlen, length;
678 if (level != SOL_AX25)
679 return -ENOPROTOOPT;
681 if (get_user(maxlen, optlen))
682 return -EFAULT;
684 if (maxlen < 1)
685 return -EFAULT;
687 valptr = (void *) &val;
688 length = min_t(unsigned int, maxlen, sizeof(int));
690 lock_sock(sk);
691 ax25 = ax25_sk(sk);
693 switch (optname) {
694 case AX25_WINDOW:
695 val = ax25->window;
696 break;
698 case AX25_T1:
699 val = ax25->t1 / HZ;
700 break;
702 case AX25_T2:
703 val = ax25->t2 / HZ;
704 break;
706 case AX25_N2:
707 val = ax25->n2;
708 break;
710 case AX25_T3:
711 val = ax25->t3 / HZ;
712 break;
714 case AX25_IDLE:
715 val = ax25->idle / (60 * HZ);
716 break;
718 case AX25_BACKOFF:
719 val = ax25->backoff;
720 break;
722 case AX25_EXTSEQ:
723 val = (ax25->modulus == AX25_EMODULUS);
724 break;
726 case AX25_PIDINCL:
727 val = ax25->pidincl;
728 break;
730 case AX25_IAMDIGI:
731 val = ax25->iamdigi;
732 break;
734 case AX25_PACLEN:
735 val = ax25->paclen;
736 break;
738 case SO_BINDTODEVICE:
739 ax25_dev = ax25->ax25_dev;
741 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
742 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
743 length = strlen(devname) + 1;
744 } else {
745 *devname = '\0';
746 length = 1;
749 valptr = (void *) devname;
750 break;
752 default:
753 release_sock(sk);
754 return -ENOPROTOOPT;
756 release_sock(sk);
758 if (put_user(length, optlen))
759 return -EFAULT;
761 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
764 static int ax25_listen(struct socket *sock, int backlog)
766 struct sock *sk = sock->sk;
767 int res = 0;
769 lock_sock(sk);
770 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
771 sk->sk_max_ack_backlog = backlog;
772 sk->sk_state = TCP_LISTEN;
773 goto out;
775 res = -EOPNOTSUPP;
777 out:
778 release_sock(sk);
780 return res;
784 * XXX: when creating ax25_sock we should update the .obj_size setting
785 * below.
787 static struct proto ax25_proto = {
788 .name = "AX25",
789 .owner = THIS_MODULE,
790 .obj_size = sizeof(struct sock),
793 static int ax25_create(struct net *net, struct socket *sock, int protocol)
795 struct sock *sk;
796 ax25_cb *ax25;
798 if (net != &init_net)
799 return -EAFNOSUPPORT;
801 switch (sock->type) {
802 case SOCK_DGRAM:
803 if (protocol == 0 || protocol == PF_AX25)
804 protocol = AX25_P_TEXT;
805 break;
807 case SOCK_SEQPACKET:
808 switch (protocol) {
809 case 0:
810 case PF_AX25: /* For CLX */
811 protocol = AX25_P_TEXT;
812 break;
813 case AX25_P_SEGMENT:
814 #ifdef CONFIG_INET
815 case AX25_P_ARP:
816 case AX25_P_IP:
817 #endif
818 #ifdef CONFIG_NETROM
819 case AX25_P_NETROM:
820 #endif
821 #ifdef CONFIG_ROSE
822 case AX25_P_ROSE:
823 #endif
824 return -ESOCKTNOSUPPORT;
825 #ifdef CONFIG_NETROM_MODULE
826 case AX25_P_NETROM:
827 if (ax25_protocol_is_registered(AX25_P_NETROM))
828 return -ESOCKTNOSUPPORT;
829 #endif
830 #ifdef CONFIG_ROSE_MODULE
831 case AX25_P_ROSE:
832 if (ax25_protocol_is_registered(AX25_P_ROSE))
833 return -ESOCKTNOSUPPORT;
834 #endif
835 default:
836 break;
838 break;
840 case SOCK_RAW:
841 break;
842 default:
843 return -ESOCKTNOSUPPORT;
846 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
847 if (sk == NULL)
848 return -ENOMEM;
850 ax25 = sk->sk_protinfo = ax25_create_cb();
851 if (!ax25) {
852 sk_free(sk);
853 return -ENOMEM;
856 sock_init_data(sock, sk);
858 sk->sk_destruct = ax25_free_sock;
859 sock->ops = &ax25_proto_ops;
860 sk->sk_protocol = protocol;
862 ax25->sk = sk;
864 return 0;
867 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
869 struct sock *sk;
870 ax25_cb *ax25, *oax25;
872 sk = sk_alloc(osk->sk_net, PF_AX25, GFP_ATOMIC, osk->sk_prot);
873 if (sk == NULL)
874 return NULL;
876 if ((ax25 = ax25_create_cb()) == NULL) {
877 sk_free(sk);
878 return NULL;
881 switch (osk->sk_type) {
882 case SOCK_DGRAM:
883 break;
884 case SOCK_SEQPACKET:
885 break;
886 default:
887 sk_free(sk);
888 ax25_cb_put(ax25);
889 return NULL;
892 sock_init_data(NULL, sk);
894 sk->sk_destruct = ax25_free_sock;
895 sk->sk_type = osk->sk_type;
896 sk->sk_socket = osk->sk_socket;
897 sk->sk_priority = osk->sk_priority;
898 sk->sk_protocol = osk->sk_protocol;
899 sk->sk_rcvbuf = osk->sk_rcvbuf;
900 sk->sk_sndbuf = osk->sk_sndbuf;
901 sk->sk_state = TCP_ESTABLISHED;
902 sk->sk_sleep = osk->sk_sleep;
903 sock_copy_flags(sk, osk);
905 oax25 = ax25_sk(osk);
907 ax25->modulus = oax25->modulus;
908 ax25->backoff = oax25->backoff;
909 ax25->pidincl = oax25->pidincl;
910 ax25->iamdigi = oax25->iamdigi;
911 ax25->rtt = oax25->rtt;
912 ax25->t1 = oax25->t1;
913 ax25->t2 = oax25->t2;
914 ax25->t3 = oax25->t3;
915 ax25->n2 = oax25->n2;
916 ax25->idle = oax25->idle;
917 ax25->paclen = oax25->paclen;
918 ax25->window = oax25->window;
920 ax25->ax25_dev = ax25_dev;
921 ax25->source_addr = oax25->source_addr;
923 if (oax25->digipeat != NULL) {
924 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
925 GFP_ATOMIC);
926 if (ax25->digipeat == NULL) {
927 sk_free(sk);
928 ax25_cb_put(ax25);
929 return NULL;
933 sk->sk_protinfo = ax25;
934 ax25->sk = sk;
936 return sk;
939 static int ax25_release(struct socket *sock)
941 struct sock *sk = sock->sk;
942 ax25_cb *ax25;
944 if (sk == NULL)
945 return 0;
947 sock_hold(sk);
948 sock_orphan(sk);
949 lock_sock(sk);
950 ax25 = ax25_sk(sk);
952 if (sk->sk_type == SOCK_SEQPACKET) {
953 switch (ax25->state) {
954 case AX25_STATE_0:
955 release_sock(sk);
956 ax25_disconnect(ax25, 0);
957 lock_sock(sk);
958 ax25_destroy_socket(ax25);
959 break;
961 case AX25_STATE_1:
962 case AX25_STATE_2:
963 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
964 release_sock(sk);
965 ax25_disconnect(ax25, 0);
966 lock_sock(sk);
967 ax25_destroy_socket(ax25);
968 break;
970 case AX25_STATE_3:
971 case AX25_STATE_4:
972 ax25_clear_queues(ax25);
973 ax25->n2count = 0;
975 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
976 case AX25_PROTO_STD_SIMPLEX:
977 case AX25_PROTO_STD_DUPLEX:
978 ax25_send_control(ax25,
979 AX25_DISC,
980 AX25_POLLON,
981 AX25_COMMAND);
982 ax25_stop_t2timer(ax25);
983 ax25_stop_t3timer(ax25);
984 ax25_stop_idletimer(ax25);
985 break;
986 #ifdef CONFIG_AX25_DAMA_SLAVE
987 case AX25_PROTO_DAMA_SLAVE:
988 ax25_stop_t3timer(ax25);
989 ax25_stop_idletimer(ax25);
990 break;
991 #endif
993 ax25_calculate_t1(ax25);
994 ax25_start_t1timer(ax25);
995 ax25->state = AX25_STATE_2;
996 sk->sk_state = TCP_CLOSE;
997 sk->sk_shutdown |= SEND_SHUTDOWN;
998 sk->sk_state_change(sk);
999 sock_set_flag(sk, SOCK_DESTROY);
1000 break;
1002 default:
1003 break;
1005 } else {
1006 sk->sk_state = TCP_CLOSE;
1007 sk->sk_shutdown |= SEND_SHUTDOWN;
1008 sk->sk_state_change(sk);
1009 ax25_destroy_socket(ax25);
1012 sock->sk = NULL;
1013 release_sock(sk);
1014 sock_put(sk);
1016 return 0;
1020 * We support a funny extension here so you can (as root) give any callsign
1021 * digipeated via a local address as source. This hack is obsolete now
1022 * that we've implemented support for SO_BINDTODEVICE. It is however small
1023 * and trivially backward compatible.
1025 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1027 struct sock *sk = sock->sk;
1028 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1029 ax25_dev *ax25_dev = NULL;
1030 ax25_uid_assoc *user;
1031 ax25_address call;
1032 ax25_cb *ax25;
1033 int err = 0;
1035 if (addr_len != sizeof(struct sockaddr_ax25) &&
1036 addr_len != sizeof(struct full_sockaddr_ax25))
1037 /* support for old structure may go away some time
1038 * ax25_bind(): uses old (6 digipeater) socket structure.
1040 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1041 (addr_len > sizeof(struct full_sockaddr_ax25)))
1042 return -EINVAL;
1044 if (addr->fsa_ax25.sax25_family != AF_AX25)
1045 return -EINVAL;
1047 user = ax25_findbyuid(current->euid);
1048 if (user) {
1049 call = user->call;
1050 ax25_uid_put(user);
1051 } else {
1052 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1053 return -EACCES;
1055 call = addr->fsa_ax25.sax25_call;
1058 lock_sock(sk);
1060 ax25 = ax25_sk(sk);
1061 if (!sock_flag(sk, SOCK_ZAPPED)) {
1062 err = -EINVAL;
1063 goto out;
1066 ax25->source_addr = call;
1069 * User already set interface with SO_BINDTODEVICE
1071 if (ax25->ax25_dev != NULL)
1072 goto done;
1074 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1075 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1076 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1077 err = -EADDRNOTAVAIL;
1078 goto out;
1080 } else {
1081 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1082 err = -EADDRNOTAVAIL;
1083 goto out;
1087 if (ax25_dev != NULL)
1088 ax25_fillin_cb(ax25, ax25_dev);
1090 done:
1091 ax25_cb_add(ax25);
1092 sock_reset_flag(sk, SOCK_ZAPPED);
1094 out:
1095 release_sock(sk);
1097 return 0;
1101 * FIXME: nonblock behaviour looks like it may have a bug.
1103 static int __must_check ax25_connect(struct socket *sock,
1104 struct sockaddr *uaddr, int addr_len, int flags)
1106 struct sock *sk = sock->sk;
1107 ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1108 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1109 ax25_digi *digi = NULL;
1110 int ct = 0, err = 0;
1113 * some sanity checks. code further down depends on this
1116 if (addr_len == sizeof(struct sockaddr_ax25))
1117 /* support for this will go away in early 2.5.x
1118 * ax25_connect(): uses obsolete socket structure
1121 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1122 /* support for old structure may go away some time
1123 * ax25_connect(): uses old (6 digipeater) socket structure.
1125 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1126 (addr_len > sizeof(struct full_sockaddr_ax25)))
1127 return -EINVAL;
1130 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1131 return -EINVAL;
1133 lock_sock(sk);
1135 /* deal with restarts */
1136 if (sock->state == SS_CONNECTING) {
1137 switch (sk->sk_state) {
1138 case TCP_SYN_SENT: /* still trying */
1139 err = -EINPROGRESS;
1140 goto out_release;
1142 case TCP_ESTABLISHED: /* connection established */
1143 sock->state = SS_CONNECTED;
1144 goto out_release;
1146 case TCP_CLOSE: /* connection refused */
1147 sock->state = SS_UNCONNECTED;
1148 err = -ECONNREFUSED;
1149 goto out_release;
1153 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1154 err = -EISCONN; /* No reconnect on a seqpacket socket */
1155 goto out_release;
1158 sk->sk_state = TCP_CLOSE;
1159 sock->state = SS_UNCONNECTED;
1161 kfree(ax25->digipeat);
1162 ax25->digipeat = NULL;
1165 * Handle digi-peaters to be used.
1167 if (addr_len > sizeof(struct sockaddr_ax25) &&
1168 fsa->fsa_ax25.sax25_ndigis != 0) {
1169 /* Valid number of digipeaters ? */
1170 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1171 err = -EINVAL;
1172 goto out_release;
1175 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1176 err = -ENOBUFS;
1177 goto out_release;
1180 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1181 digi->lastrepeat = -1;
1183 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1184 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1185 AX25_HBIT) && ax25->iamdigi) {
1186 digi->repeated[ct] = 1;
1187 digi->lastrepeat = ct;
1188 } else {
1189 digi->repeated[ct] = 0;
1191 digi->calls[ct] = fsa->fsa_digipeater[ct];
1192 ct++;
1197 * Must bind first - autobinding in this may or may not work. If
1198 * the socket is already bound, check to see if the device has
1199 * been filled in, error if it hasn't.
1201 if (sock_flag(sk, SOCK_ZAPPED)) {
1202 /* check if we can remove this feature. It is broken. */
1203 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1204 current->comm);
1205 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1206 kfree(digi);
1207 goto out_release;
1210 ax25_fillin_cb(ax25, ax25->ax25_dev);
1211 ax25_cb_add(ax25);
1212 } else {
1213 if (ax25->ax25_dev == NULL) {
1214 kfree(digi);
1215 err = -EHOSTUNREACH;
1216 goto out_release;
1220 if (sk->sk_type == SOCK_SEQPACKET &&
1221 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1222 ax25->ax25_dev->dev))) {
1223 kfree(digi);
1224 err = -EADDRINUSE; /* Already such a connection */
1225 ax25_cb_put(ax25t);
1226 goto out_release;
1229 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1230 ax25->digipeat = digi;
1232 /* First the easy one */
1233 if (sk->sk_type != SOCK_SEQPACKET) {
1234 sock->state = SS_CONNECTED;
1235 sk->sk_state = TCP_ESTABLISHED;
1236 goto out_release;
1239 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1240 sock->state = SS_CONNECTING;
1241 sk->sk_state = TCP_SYN_SENT;
1243 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1244 case AX25_PROTO_STD_SIMPLEX:
1245 case AX25_PROTO_STD_DUPLEX:
1246 ax25_std_establish_data_link(ax25);
1247 break;
1249 #ifdef CONFIG_AX25_DAMA_SLAVE
1250 case AX25_PROTO_DAMA_SLAVE:
1251 ax25->modulus = AX25_MODULUS;
1252 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1253 if (ax25->ax25_dev->dama.slave)
1254 ax25_ds_establish_data_link(ax25);
1255 else
1256 ax25_std_establish_data_link(ax25);
1257 break;
1258 #endif
1261 ax25->state = AX25_STATE_1;
1263 ax25_start_heartbeat(ax25);
1265 /* Now the loop */
1266 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1267 err = -EINPROGRESS;
1268 goto out_release;
1271 if (sk->sk_state == TCP_SYN_SENT) {
1272 DEFINE_WAIT(wait);
1274 for (;;) {
1275 prepare_to_wait(sk->sk_sleep, &wait,
1276 TASK_INTERRUPTIBLE);
1277 if (sk->sk_state != TCP_SYN_SENT)
1278 break;
1279 if (!signal_pending(current)) {
1280 release_sock(sk);
1281 schedule();
1282 lock_sock(sk);
1283 continue;
1285 err = -ERESTARTSYS;
1286 break;
1288 finish_wait(sk->sk_sleep, &wait);
1290 if (err)
1291 goto out_release;
1294 if (sk->sk_state != TCP_ESTABLISHED) {
1295 /* Not in ABM, not in WAIT_UA -> failed */
1296 sock->state = SS_UNCONNECTED;
1297 err = sock_error(sk); /* Always set at this point */
1298 goto out_release;
1301 sock->state = SS_CONNECTED;
1303 err = 0;
1304 out_release:
1305 release_sock(sk);
1307 return err;
1310 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1312 struct sk_buff *skb;
1313 struct sock *newsk;
1314 DEFINE_WAIT(wait);
1315 struct sock *sk;
1316 int err = 0;
1318 if (sock->state != SS_UNCONNECTED)
1319 return -EINVAL;
1321 if ((sk = sock->sk) == NULL)
1322 return -EINVAL;
1324 lock_sock(sk);
1325 if (sk->sk_type != SOCK_SEQPACKET) {
1326 err = -EOPNOTSUPP;
1327 goto out;
1330 if (sk->sk_state != TCP_LISTEN) {
1331 err = -EINVAL;
1332 goto out;
1336 * The read queue this time is holding sockets ready to use
1337 * hooked into the SABM we saved
1339 for (;;) {
1340 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1341 skb = skb_dequeue(&sk->sk_receive_queue);
1342 if (skb)
1343 break;
1345 if (flags & O_NONBLOCK) {
1346 err = -EWOULDBLOCK;
1347 break;
1349 if (!signal_pending(current)) {
1350 release_sock(sk);
1351 schedule();
1352 lock_sock(sk);
1353 continue;
1355 err = -ERESTARTSYS;
1356 break;
1358 finish_wait(sk->sk_sleep, &wait);
1360 if (err)
1361 goto out;
1363 newsk = skb->sk;
1364 newsk->sk_socket = newsock;
1365 newsk->sk_sleep = &newsock->wait;
1367 /* Now attach up the new socket */
1368 kfree_skb(skb);
1369 sk->sk_ack_backlog--;
1370 newsock->sk = newsk;
1371 newsock->state = SS_CONNECTED;
1373 out:
1374 release_sock(sk);
1376 return err;
1379 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1380 int *uaddr_len, int peer)
1382 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1383 struct sock *sk = sock->sk;
1384 unsigned char ndigi, i;
1385 ax25_cb *ax25;
1386 int err = 0;
1388 lock_sock(sk);
1389 ax25 = ax25_sk(sk);
1391 if (peer != 0) {
1392 if (sk->sk_state != TCP_ESTABLISHED) {
1393 err = -ENOTCONN;
1394 goto out;
1397 fsa->fsa_ax25.sax25_family = AF_AX25;
1398 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1399 fsa->fsa_ax25.sax25_ndigis = 0;
1401 if (ax25->digipeat != NULL) {
1402 ndigi = ax25->digipeat->ndigi;
1403 fsa->fsa_ax25.sax25_ndigis = ndigi;
1404 for (i = 0; i < ndigi; i++)
1405 fsa->fsa_digipeater[i] =
1406 ax25->digipeat->calls[i];
1408 } else {
1409 fsa->fsa_ax25.sax25_family = AF_AX25;
1410 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1411 fsa->fsa_ax25.sax25_ndigis = 1;
1412 if (ax25->ax25_dev != NULL) {
1413 memcpy(&fsa->fsa_digipeater[0],
1414 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1415 } else {
1416 fsa->fsa_digipeater[0] = null_ax25_address;
1419 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1421 out:
1422 release_sock(sk);
1424 return err;
1427 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1428 struct msghdr *msg, size_t len)
1430 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1431 struct sock *sk = sock->sk;
1432 struct sockaddr_ax25 sax;
1433 struct sk_buff *skb;
1434 ax25_digi dtmp, *dp;
1435 ax25_cb *ax25;
1436 size_t size;
1437 int lv, err, addr_len = msg->msg_namelen;
1439 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1440 return -EINVAL;
1442 lock_sock(sk);
1443 ax25 = ax25_sk(sk);
1445 if (sock_flag(sk, SOCK_ZAPPED)) {
1446 err = -EADDRNOTAVAIL;
1447 goto out;
1450 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1451 send_sig(SIGPIPE, current, 0);
1452 err = -EPIPE;
1453 goto out;
1456 if (ax25->ax25_dev == NULL) {
1457 err = -ENETUNREACH;
1458 goto out;
1461 if (len > ax25->ax25_dev->dev->mtu) {
1462 err = -EMSGSIZE;
1463 goto out;
1466 if (usax != NULL) {
1467 if (usax->sax25_family != AF_AX25) {
1468 err = -EINVAL;
1469 goto out;
1472 if (addr_len == sizeof(struct sockaddr_ax25))
1473 /* ax25_sendmsg(): uses obsolete socket structure */
1475 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1476 /* support for old structure may go away some time
1477 * ax25_sendmsg(): uses old (6 digipeater)
1478 * socket structure.
1480 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1481 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1482 err = -EINVAL;
1483 goto out;
1487 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1488 int ct = 0;
1489 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1491 /* Valid number of digipeaters ? */
1492 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1493 err = -EINVAL;
1494 goto out;
1497 dtmp.ndigi = usax->sax25_ndigis;
1499 while (ct < usax->sax25_ndigis) {
1500 dtmp.repeated[ct] = 0;
1501 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1502 ct++;
1505 dtmp.lastrepeat = 0;
1508 sax = *usax;
1509 if (sk->sk_type == SOCK_SEQPACKET &&
1510 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1511 err = -EISCONN;
1512 goto out;
1514 if (usax->sax25_ndigis == 0)
1515 dp = NULL;
1516 else
1517 dp = &dtmp;
1518 } else {
1520 * FIXME: 1003.1g - if the socket is like this because
1521 * it has become closed (not started closed) and is VC
1522 * we ought to SIGPIPE, EPIPE
1524 if (sk->sk_state != TCP_ESTABLISHED) {
1525 err = -ENOTCONN;
1526 goto out;
1528 sax.sax25_family = AF_AX25;
1529 sax.sax25_call = ax25->dest_addr;
1530 dp = ax25->digipeat;
1533 SOCK_DEBUG(sk, "AX.25: sendto: Addresses built.\n");
1535 /* Build a packet */
1536 SOCK_DEBUG(sk, "AX.25: sendto: building packet.\n");
1538 /* Assume the worst case */
1539 size = len + ax25->ax25_dev->dev->hard_header_len;
1541 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1542 if (skb == NULL)
1543 goto out;
1545 skb_reserve(skb, size - len);
1547 SOCK_DEBUG(sk, "AX.25: Appending user data\n");
1549 /* User data follows immediately after the AX.25 data */
1550 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1551 err = -EFAULT;
1552 kfree_skb(skb);
1553 goto out;
1556 skb_reset_network_header(skb);
1558 /* Add the PID if one is not supplied by the user in the skb */
1559 if (!ax25->pidincl)
1560 *skb_push(skb, 1) = sk->sk_protocol;
1562 SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n");
1564 if (sk->sk_type == SOCK_SEQPACKET) {
1565 /* Connected mode sockets go via the LAPB machine */
1566 if (sk->sk_state != TCP_ESTABLISHED) {
1567 kfree_skb(skb);
1568 err = -ENOTCONN;
1569 goto out;
1572 /* Shove it onto the queue and kick */
1573 ax25_output(ax25, ax25->paclen, skb);
1575 err = len;
1576 goto out;
1579 skb_push(skb, 1 + ax25_addr_size(dp));
1581 SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp);
1583 if (dp != NULL)
1584 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi);
1586 /* Build an AX.25 header */
1587 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1588 dp, AX25_COMMAND, AX25_MODULUS);
1590 SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv);
1592 skb_set_transport_header(skb, lv);
1594 SOCK_DEBUG(sk, "base=%p pos=%p\n",
1595 skb->data, skb_transport_header(skb));
1597 *skb_transport_header(skb) = AX25_UI;
1599 /* Datagram frames go straight out of the door as UI */
1600 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1602 err = len;
1604 out:
1605 release_sock(sk);
1607 return err;
1610 static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1611 struct msghdr *msg, size_t size, int flags)
1613 struct sock *sk = sock->sk;
1614 struct sk_buff *skb;
1615 int copied;
1616 int err = 0;
1618 lock_sock(sk);
1620 * This works for seqpacket too. The receiver has ordered the
1621 * queue for us! We do one quick check first though
1623 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1624 err = -ENOTCONN;
1625 goto out;
1628 /* Now we can treat all alike */
1629 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1630 flags & MSG_DONTWAIT, &err);
1631 if (skb == NULL)
1632 goto out;
1634 if (!ax25_sk(sk)->pidincl)
1635 skb_pull(skb, 1); /* Remove PID */
1637 skb_reset_transport_header(skb);
1638 copied = skb->len;
1640 if (copied > size) {
1641 copied = size;
1642 msg->msg_flags |= MSG_TRUNC;
1645 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1647 if (msg->msg_namelen != 0) {
1648 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1649 ax25_digi digi;
1650 ax25_address src;
1651 const unsigned char *mac = skb_mac_header(skb);
1653 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1654 &digi, NULL, NULL);
1655 sax->sax25_family = AF_AX25;
1656 /* We set this correctly, even though we may not let the
1657 application know the digi calls further down (because it
1658 did NOT ask to know them). This could get political... **/
1659 sax->sax25_ndigis = digi.ndigi;
1660 sax->sax25_call = src;
1662 if (sax->sax25_ndigis != 0) {
1663 int ct;
1664 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1666 for (ct = 0; ct < digi.ndigi; ct++)
1667 fsa->fsa_digipeater[ct] = digi.calls[ct];
1669 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1672 skb_free_datagram(sk, skb);
1673 err = copied;
1675 out:
1676 release_sock(sk);
1678 return err;
1681 static int ax25_shutdown(struct socket *sk, int how)
1683 /* FIXME - generate DM and RNR states */
1684 return -EOPNOTSUPP;
1687 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1689 struct sock *sk = sock->sk;
1690 void __user *argp = (void __user *)arg;
1691 int res = 0;
1693 lock_sock(sk);
1694 switch (cmd) {
1695 case TIOCOUTQ: {
1696 long amount;
1697 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
1698 if (amount < 0)
1699 amount = 0;
1700 res = put_user(amount, (int __user *)argp);
1701 break;
1704 case TIOCINQ: {
1705 struct sk_buff *skb;
1706 long amount = 0L;
1707 /* These two are safe on a single CPU system as only user tasks fiddle here */
1708 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1709 amount = skb->len;
1710 res = put_user(amount, (int __user *) argp);
1711 break;
1714 case SIOCGSTAMP:
1715 res = sock_get_timestamp(sk, argp);
1716 break;
1718 case SIOCGSTAMPNS:
1719 res = sock_get_timestampns(sk, argp);
1720 break;
1722 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1723 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1724 case SIOCAX25GETUID: {
1725 struct sockaddr_ax25 sax25;
1726 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1727 res = -EFAULT;
1728 break;
1730 res = ax25_uid_ioctl(cmd, &sax25);
1731 break;
1734 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1735 long amount;
1736 if (!capable(CAP_NET_ADMIN)) {
1737 res = -EPERM;
1738 break;
1740 if (get_user(amount, (long __user *)argp)) {
1741 res = -EFAULT;
1742 break;
1744 if (amount > AX25_NOUID_BLOCK) {
1745 res = -EINVAL;
1746 break;
1748 ax25_uid_policy = amount;
1749 res = 0;
1750 break;
1753 case SIOCADDRT:
1754 case SIOCDELRT:
1755 case SIOCAX25OPTRT:
1756 if (!capable(CAP_NET_ADMIN)) {
1757 res = -EPERM;
1758 break;
1760 res = ax25_rt_ioctl(cmd, argp);
1761 break;
1763 case SIOCAX25CTLCON:
1764 if (!capable(CAP_NET_ADMIN)) {
1765 res = -EPERM;
1766 break;
1768 res = ax25_ctl_ioctl(cmd, argp);
1769 break;
1771 case SIOCAX25GETINFO:
1772 case SIOCAX25GETINFOOLD: {
1773 ax25_cb *ax25 = ax25_sk(sk);
1774 struct ax25_info_struct ax25_info;
1776 ax25_info.t1 = ax25->t1 / HZ;
1777 ax25_info.t2 = ax25->t2 / HZ;
1778 ax25_info.t3 = ax25->t3 / HZ;
1779 ax25_info.idle = ax25->idle / (60 * HZ);
1780 ax25_info.n2 = ax25->n2;
1781 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1782 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1783 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1784 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1785 ax25_info.n2count = ax25->n2count;
1786 ax25_info.state = ax25->state;
1787 ax25_info.rcv_q = atomic_read(&sk->sk_rmem_alloc);
1788 ax25_info.snd_q = atomic_read(&sk->sk_wmem_alloc);
1789 ax25_info.vs = ax25->vs;
1790 ax25_info.vr = ax25->vr;
1791 ax25_info.va = ax25->va;
1792 ax25_info.vs_max = ax25->vs; /* reserved */
1793 ax25_info.paclen = ax25->paclen;
1794 ax25_info.window = ax25->window;
1796 /* old structure? */
1797 if (cmd == SIOCAX25GETINFOOLD) {
1798 static int warned = 0;
1799 if (!warned) {
1800 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1801 current->comm);
1802 warned=1;
1805 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1806 res = -EFAULT;
1807 break;
1809 } else {
1810 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1811 res = -EINVAL;
1812 break;
1815 res = 0;
1816 break;
1819 case SIOCAX25ADDFWD:
1820 case SIOCAX25DELFWD: {
1821 struct ax25_fwd_struct ax25_fwd;
1822 if (!capable(CAP_NET_ADMIN)) {
1823 res = -EPERM;
1824 break;
1826 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1827 res = -EFAULT;
1828 break;
1830 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1831 break;
1834 case SIOCGIFADDR:
1835 case SIOCSIFADDR:
1836 case SIOCGIFDSTADDR:
1837 case SIOCSIFDSTADDR:
1838 case SIOCGIFBRDADDR:
1839 case SIOCSIFBRDADDR:
1840 case SIOCGIFNETMASK:
1841 case SIOCSIFNETMASK:
1842 case SIOCGIFMETRIC:
1843 case SIOCSIFMETRIC:
1844 res = -EINVAL;
1845 break;
1847 default:
1848 res = -ENOIOCTLCMD;
1849 break;
1851 release_sock(sk);
1853 return res;
1856 #ifdef CONFIG_PROC_FS
1858 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1859 __acquires(ax25_list_lock)
1861 struct ax25_cb *ax25;
1862 struct hlist_node *node;
1863 int i = 0;
1865 spin_lock_bh(&ax25_list_lock);
1866 ax25_for_each(ax25, node, &ax25_list) {
1867 if (i == *pos)
1868 return ax25;
1869 ++i;
1871 return NULL;
1874 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1876 ++*pos;
1878 return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1879 struct ax25_cb, ax25_node);
1882 static void ax25_info_stop(struct seq_file *seq, void *v)
1883 __releases(ax25_list_lock)
1885 spin_unlock_bh(&ax25_list_lock);
1888 static int ax25_info_show(struct seq_file *seq, void *v)
1890 ax25_cb *ax25 = v;
1891 char buf[11];
1892 int k;
1896 * New format:
1897 * magic dev src_addr dest_addr,digi1,digi2,.. st vs vr va t1 t1 t2 t2 t3 t3 idle idle n2 n2 rtt window paclen Snd-Q Rcv-Q inode
1900 seq_printf(seq, "%8.8lx %s %s%s ",
1901 (long) ax25,
1902 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1903 ax2asc(buf, &ax25->source_addr),
1904 ax25->iamdigi? "*":"");
1905 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1907 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1908 seq_printf(seq, ",%s%s",
1909 ax2asc(buf, &ax25->digipeat->calls[k]),
1910 ax25->digipeat->repeated[k]? "*":"");
1913 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1914 ax25->state,
1915 ax25->vs, ax25->vr, ax25->va,
1916 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1917 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1918 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1919 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1920 ax25->idle / (60 * HZ),
1921 ax25->n2count, ax25->n2,
1922 ax25->rtt / HZ,
1923 ax25->window,
1924 ax25->paclen);
1926 if (ax25->sk != NULL) {
1927 seq_printf(seq, " %d %d %lu\n",
1928 atomic_read(&ax25->sk->sk_wmem_alloc),
1929 atomic_read(&ax25->sk->sk_rmem_alloc),
1930 sock_i_ino(ax25->sk));
1931 } else {
1932 seq_puts(seq, " * * *\n");
1934 return 0;
1937 static const struct seq_operations ax25_info_seqops = {
1938 .start = ax25_info_start,
1939 .next = ax25_info_next,
1940 .stop = ax25_info_stop,
1941 .show = ax25_info_show,
1944 static int ax25_info_open(struct inode *inode, struct file *file)
1946 return seq_open(file, &ax25_info_seqops);
1949 static const struct file_operations ax25_info_fops = {
1950 .owner = THIS_MODULE,
1951 .open = ax25_info_open,
1952 .read = seq_read,
1953 .llseek = seq_lseek,
1954 .release = seq_release,
1957 #endif
1959 static struct net_proto_family ax25_family_ops = {
1960 .family = PF_AX25,
1961 .create = ax25_create,
1962 .owner = THIS_MODULE,
1965 static const struct proto_ops ax25_proto_ops = {
1966 .family = PF_AX25,
1967 .owner = THIS_MODULE,
1968 .release = ax25_release,
1969 .bind = ax25_bind,
1970 .connect = ax25_connect,
1971 .socketpair = sock_no_socketpair,
1972 .accept = ax25_accept,
1973 .getname = ax25_getname,
1974 .poll = datagram_poll,
1975 .ioctl = ax25_ioctl,
1976 .listen = ax25_listen,
1977 .shutdown = ax25_shutdown,
1978 .setsockopt = ax25_setsockopt,
1979 .getsockopt = ax25_getsockopt,
1980 .sendmsg = ax25_sendmsg,
1981 .recvmsg = ax25_recvmsg,
1982 .mmap = sock_no_mmap,
1983 .sendpage = sock_no_sendpage,
1987 * Called by socket.c on kernel start up
1989 static struct packet_type ax25_packet_type = {
1990 .type = __constant_htons(ETH_P_AX25),
1991 .dev = NULL, /* All devices */
1992 .func = ax25_kiss_rcv,
1995 static struct notifier_block ax25_dev_notifier = {
1996 .notifier_call =ax25_device_event,
1999 static int __init ax25_init(void)
2001 int rc = proto_register(&ax25_proto, 0);
2003 if (rc != 0)
2004 goto out;
2006 sock_register(&ax25_family_ops);
2007 dev_add_pack(&ax25_packet_type);
2008 register_netdevice_notifier(&ax25_dev_notifier);
2009 ax25_register_sysctl();
2011 proc_net_fops_create(&init_net, "ax25_route", S_IRUGO, &ax25_route_fops);
2012 proc_net_fops_create(&init_net, "ax25", S_IRUGO, &ax25_info_fops);
2013 proc_net_fops_create(&init_net, "ax25_calls", S_IRUGO, &ax25_uid_fops);
2014 out:
2015 return rc;
2017 module_init(ax25_init);
2020 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2021 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2022 MODULE_LICENSE("GPL");
2023 MODULE_ALIAS_NETPROTO(PF_AX25);
2025 static void __exit ax25_exit(void)
2027 proc_net_remove(&init_net, "ax25_route");
2028 proc_net_remove(&init_net, "ax25");
2029 proc_net_remove(&init_net, "ax25_calls");
2030 ax25_rt_free();
2031 ax25_uid_free();
2032 ax25_dev_free();
2034 ax25_unregister_sysctl();
2035 unregister_netdevice_notifier(&ax25_dev_notifier);
2037 dev_remove_pack(&ax25_packet_type);
2039 sock_unregister(PF_AX25);
2040 proto_unregister(&ax25_proto);
2042 module_exit(ax25_exit);