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