?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.26-rc5
[linux-2.6/openmoko-kernel/knife-kernel.git] / net / ax25 / af_ax25.c
blob2712544cf0cac124fcc2d9985d005d01968a3cec
1 /*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
8 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
9 * Copyright (C) Darryl Miles G7LED (dlm@g7led.demon.co.uk)
10 * Copyright (C) Steven Whitehouse GW7RRM (stevew@acm.org)
11 * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
12 * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de)
13 * Copyright (C) Hans Alblas PE1AYX (hans@esrac.ele.tue.nl)
14 * Copyright (C) Frederic Rible F1OAT (frible@teaser.fr)
15 */
16 #include <linux/capability.h>
17 #include <linux/module.h>
18 #include <linux/errno.h>
19 #include <linux/types.h>
20 #include <linux/socket.h>
21 #include <linux/in.h>
22 #include <linux/kernel.h>
23 #include <linux/sched.h>
24 #include <linux/timer.h>
25 #include <linux/string.h>
26 #include <linux/sockios.h>
27 #include <linux/net.h>
28 #include <net/ax25.h>
29 #include <linux/inet.h>
30 #include <linux/netdevice.h>
31 #include <linux/if_arp.h>
32 #include <linux/skbuff.h>
33 #include <net/sock.h>
34 #include <asm/uaccess.h>
35 #include <asm/system.h>
36 #include <linux/fcntl.h>
37 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
38 #include <linux/mm.h>
39 #include <linux/interrupt.h>
40 #include <linux/notifier.h>
41 #include <linux/proc_fs.h>
42 #include <linux/stat.h>
43 #include <linux/netfilter.h>
44 #include <linux/sysctl.h>
45 #include <linux/init.h>
46 #include <linux/spinlock.h>
47 #include <net/net_namespace.h>
48 #include <net/tcp_states.h>
49 #include <net/ip.h>
50 #include <net/arp.h>
51
52
53
54 HLIST_HEAD(ax25_list);
55 DEFINE_SPINLOCK(ax25_list_lock);
56
57 static const struct proto_ops ax25_proto_ops;
58
59 static void ax25_free_sock(struct sock *sk)
60 {
61 ax25_cb_put(ax25_sk(sk));
62 }
63
64 /*
65 * Socket removal during an interrupt is now safe.
66 */
67 static void ax25_cb_del(ax25_cb *ax25)
68 {
69 if (!hlist_unhashed(&ax25->ax25_node)) {
70 spin_lock_bh(&ax25_list_lock);
71 hlist_del_init(&ax25->ax25_node);
72 spin_unlock_bh(&ax25_list_lock);
73 ax25_cb_put(ax25);
74 }
75 }
76
77 /*
78 * Kill all bound sockets on a dropped device.
79 */
80 static void ax25_kill_by_device(struct net_device *dev)
81 {
82 ax25_dev *ax25_dev;
83 ax25_cb *s;
84 struct hlist_node *node;
85
86 if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
87 return;
88
89 spin_lock_bh(&ax25_list_lock);
90 again:
91 ax25_for_each(s, node, &ax25_list) {
92 if (s->ax25_dev == ax25_dev) {
93 s->ax25_dev = NULL;
94 spin_unlock_bh(&ax25_list_lock);
95 ax25_disconnect(s, ENETUNREACH);
96 spin_lock_bh(&ax25_list_lock);
97
98 /* The entry could have been deleted from the
99 * list meanwhile and thus the next pointer is
100 * no longer valid. Play it safe and restart
101 * the scan. Forward progress is ensured
102 * because we set s->ax25_dev to NULL and we
103 * are never passed a NULL 'dev' argument.
104 */
105 goto again;
106 }
107 }
108 spin_unlock_bh(&ax25_list_lock);
109 }
110
111 /*
112 * Handle device status changes.
113 */
114 static int ax25_device_event(struct notifier_block *this, unsigned long event,
115 void *ptr)
116 {
117 struct net_device *dev = (struct net_device *)ptr;
118
119 if (dev_net(dev) != &init_net)
120 return NOTIFY_DONE;
121
122 /* Reject non AX.25 devices */
123 if (dev->type != ARPHRD_AX25)
124 return NOTIFY_DONE;
125
126 switch (event) {
127 case NETDEV_UP:
128 ax25_dev_device_up(dev);
129 break;
130 case NETDEV_DOWN:
131 ax25_kill_by_device(dev);
132 ax25_rt_device_down(dev);
133 ax25_dev_device_down(dev);
134 break;
135 default:
136 break;
137 }
138
139 return NOTIFY_DONE;
140 }
141
142 /*
143 * Add a socket to the bound sockets list.
144 */
145 void ax25_cb_add(ax25_cb *ax25)
146 {
147 spin_lock_bh(&ax25_list_lock);
148 ax25_cb_hold(ax25);
149 hlist_add_head(&ax25->ax25_node, &ax25_list);
150 spin_unlock_bh(&ax25_list_lock);
151 }
152
153 /*
154 * Find a socket that wants to accept the SABM we have just
155 * received.
156 */
157 struct sock *ax25_find_listener(ax25_address *addr, int digi,
158 struct net_device *dev, int type)
159 {
160 ax25_cb *s;
161 struct hlist_node *node;
162
163 spin_lock(&ax25_list_lock);
164 ax25_for_each(s, node, &ax25_list) {
165 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
166 continue;
167 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
168 s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
169 /* If device is null we match any device */
170 if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
171 sock_hold(s->sk);
172 spin_unlock(&ax25_list_lock);
173 return s->sk;
174 }
175 }
176 }
177 spin_unlock(&ax25_list_lock);
178
179 return NULL;
180 }
181
182 /*
183 * Find an AX.25 socket given both ends.
184 */
185 struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
186 int type)
187 {
188 struct sock *sk = NULL;
189 ax25_cb *s;
190 struct hlist_node *node;
191
192 spin_lock(&ax25_list_lock);
193 ax25_for_each(s, node, &ax25_list) {
194 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
195 !ax25cmp(&s->dest_addr, dest_addr) &&
196 s->sk->sk_type == type) {
197 sk = s->sk;
198 sock_hold(sk);
199 break;
200 }
201 }
202
203 spin_unlock(&ax25_list_lock);
204
205 return sk;
206 }
207
208 /*
209 * Find an AX.25 control block given both ends. It will only pick up
210 * floating AX.25 control blocks or non Raw socket bound control blocks.
211 */
212 ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
213 ax25_digi *digi, struct net_device *dev)
214 {
215 ax25_cb *s;
216 struct hlist_node *node;
217
218 spin_lock_bh(&ax25_list_lock);
219 ax25_for_each(s, node, &ax25_list) {
220 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
221 continue;
222 if (s->ax25_dev == NULL)
223 continue;
224 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
225 if (digi != NULL && digi->ndigi != 0) {
226 if (s->digipeat == NULL)
227 continue;
228 if (ax25digicmp(s->digipeat, digi) != 0)
229 continue;
230 } else {
231 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
232 continue;
233 }
234 ax25_cb_hold(s);
235 spin_unlock_bh(&ax25_list_lock);
236
237 return s;
238 }
239 }
240 spin_unlock_bh(&ax25_list_lock);
241
242 return NULL;
243 }
244
245 EXPORT_SYMBOL(ax25_find_cb);
246
247 void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
248 {
249 ax25_cb *s;
250 struct sk_buff *copy;
251 struct hlist_node *node;
252
253 spin_lock(&ax25_list_lock);
254 ax25_for_each(s, node, &ax25_list) {
255 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
256 s->sk->sk_type == SOCK_RAW &&
257 s->sk->sk_protocol == proto &&
258 s->ax25_dev->dev == skb->dev &&
259 atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
260 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
261 continue;
262 if (sock_queue_rcv_skb(s->sk, copy) != 0)
263 kfree_skb(copy);
264 }
265 }
266 spin_unlock(&ax25_list_lock);
267 }
268
269 /*
270 * Deferred destroy.
271 */
272 void ax25_destroy_socket(ax25_cb *);
273
274 /*
275 * Handler for deferred kills.
276 */
277 static void ax25_destroy_timer(unsigned long data)
278 {
279 ax25_cb *ax25=(ax25_cb *)data;
280 struct sock *sk;
281
282 sk=ax25->sk;
283
284 bh_lock_sock(sk);
285 sock_hold(sk);
286 ax25_destroy_socket(ax25);
287 bh_unlock_sock(sk);
288 sock_put(sk);
289 }
290
291 /*
292 * This is called from user mode and the timers. Thus it protects itself
293 * against interrupt users but doesn't worry about being called during
294 * work. Once it is removed from the queue no interrupt or bottom half
295 * will touch it and we are (fairly 8-) ) safe.
296 */
297 void ax25_destroy_socket(ax25_cb *ax25)
298 {
299 struct sk_buff *skb;
300
301 ax25_cb_del(ax25);
302
303 ax25_stop_heartbeat(ax25);
304 ax25_stop_t1timer(ax25);
305 ax25_stop_t2timer(ax25);
306 ax25_stop_t3timer(ax25);
307 ax25_stop_idletimer(ax25);
308
309 ax25_clear_queues(ax25); /* Flush the queues */
310
311 if (ax25->sk != NULL) {
312 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
313 if (skb->sk != ax25->sk) {
314 /* A pending connection */
315 ax25_cb *sax25 = ax25_sk(skb->sk);
316
317 /* Queue the unaccepted socket for death */
318 sock_orphan(skb->sk);
319
320 ax25_start_heartbeat(sax25);
321 sax25->state = AX25_STATE_0;
322 }
323
324 kfree_skb(skb);
325 }
326 skb_queue_purge(&ax25->sk->sk_write_queue);
327 }
328
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);
341 }
342 } else {
343 ax25_cb_put(ax25);
344 }
345 }
346
347 /*
348 * dl1bke 960311: set parameters for existing AX.25 connections,
349 * includes a KILL command to abort any connection.
350 * VERY useful for debugging ;-)
351 */
352 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
353 {
354 struct ax25_ctl_struct ax25_ctl;
355 ax25_digi digi;
356 ax25_dev *ax25_dev;
357 ax25_cb *ax25;
358 unsigned int k;
359
360 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
361 return -EFAULT;
362
363 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
364 return -ENODEV;
365
366 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
367 return -EINVAL;
368
369 digi.ndigi = ax25_ctl.digi_count;
370 for (k = 0; k < digi.ndigi; k++)
371 digi.calls[k] = ax25_ctl.digi_addr[k];
372
373 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
374 return -ENOTCONN;
375
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;
385
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;
393 }
394 ax25->window = ax25_ctl.arg;
395 break;
396
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;
403
404 case AX25_T2:
405 if (ax25_ctl.arg < 1)
406 return -EINVAL;
407 ax25->t2 = ax25_ctl.arg * HZ;
408 break;
409
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;
416
417 case AX25_T3:
418 if (ax25_ctl.arg < 0)
419 return -EINVAL;
420 ax25->t3 = ax25_ctl.arg * HZ;
421 break;
422
423 case AX25_IDLE:
424 if (ax25_ctl.arg < 0)
425 return -EINVAL;
426 ax25->idle = ax25_ctl.arg * 60 * HZ;
427 break;
428
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;
434
435 default:
436 return -EINVAL;
437 }
438
439 return 0;
440 }
441
442 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
443 {
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];
452
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];
459 }
460 }
461
462 /*
463 * Fill in a created AX.25 created control block with the default
464 * values for a particular device.
465 */
466 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
467 {
468 ax25->ax25_dev = ax25_dev;
469
470 if (ax25->ax25_dev != NULL) {
471 ax25_fillin_cb_from_dev(ax25, ax25_dev);
472 return;
473 }
474
475 /*
476 * No device, use kernel / AX.25 spec default values
477 */
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;
486
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;
493 }
494 }
495
496 /*
497 * Create an empty AX.25 control block.
498 */
499 ax25_cb *ax25_create_cb(void)
500 {
501 ax25_cb *ax25;
502
503 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
504 return NULL;
505
506 atomic_set(&ax25->refcount, 1);
507
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);
512
513 ax25_setup_timers(ax25);
514
515 ax25_fillin_cb(ax25, NULL);
516
517 ax25->state = AX25_STATE_0;
518
519 return ax25;
520 }
521
522 /*
523 * Handling for system calls applied via the various interfaces to an
524 * AX25 socket object
525 */
526
527 static int ax25_setsockopt(struct socket *sock, int level, int optname,
528 char __user *optval, int optlen)
529 {
530 struct sock *sk = sock->sk;
531 ax25_cb *ax25;
532 struct net_device *dev;
533 char devname[IFNAMSIZ];
534 int opt, res = 0;
535
536 if (level != SOL_AX25)
537 return -ENOPROTOOPT;
538
539 if (optlen < sizeof(int))
540 return -EINVAL;
541
542 if (get_user(opt, (int __user *)optval))
543 return -EFAULT;
544
545 lock_sock(sk);
546 ax25 = ax25_sk(sk);
547
548 switch (optname) {
549 case AX25_WINDOW:
550 if (ax25->modulus == AX25_MODULUS) {
551 if (opt < 1 || opt > 7) {
552 res = -EINVAL;
553 break;
554 }
555 } else {
556 if (opt < 1 || opt > 63) {
557 res = -EINVAL;
558 break;
559 }
560 }
561 ax25->window = opt;
562 break;
563
564 case AX25_T1:
565 if (opt < 1) {
566 res = -EINVAL;
567 break;
568 }
569 ax25->rtt = (opt * HZ) >> 1;
570 ax25->t1 = opt * HZ;
571 break;
572
573 case AX25_T2:
574 if (opt < 1) {
575 res = -EINVAL;
576 break;
577 }
578 ax25->t2 = opt * HZ;
579 break;
580
581 case AX25_N2:
582 if (opt < 1 || opt > 31) {
583 res = -EINVAL;
584 break;
585 }
586 ax25->n2 = opt;
587 break;
588
589 case AX25_T3:
590 if (opt < 1) {
591 res = -EINVAL;
592 break;
593 }
594 ax25->t3 = opt * HZ;
595 break;
596
597 case AX25_IDLE:
598 if (opt < 0) {
599 res = -EINVAL;
600 break;
601 }
602 ax25->idle = opt * 60 * HZ;
603 break;
604
605 case AX25_BACKOFF:
606 if (opt < 0 || opt > 2) {
607 res = -EINVAL;
608 break;
609 }
610 ax25->backoff = opt;
611 break;
612
613 case AX25_EXTSEQ:
614 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
615 break;
616
617 case AX25_PIDINCL:
618 ax25->pidincl = opt ? 1 : 0;
619 break;
620
621 case AX25_IAMDIGI:
622 ax25->iamdigi = opt ? 1 : 0;
623 break;
624
625 case AX25_PACLEN:
626 if (opt < 16 || opt > 65535) {
627 res = -EINVAL;
628 break;
629 }
630 ax25->paclen = opt;
631 break;
632
633 case SO_BINDTODEVICE:
634 if (optlen > IFNAMSIZ)
635 optlen=IFNAMSIZ;
636 if (copy_from_user(devname, optval, optlen)) {
637 res = -EFAULT;
638 break;
639 }
640
641 dev = dev_get_by_name(&init_net, devname);
642 if (dev == NULL) {
643 res = -ENODEV;
644 break;
645 }
646
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;
653 }
654
655 ax25->ax25_dev = ax25_dev_ax25dev(dev);
656 ax25_fillin_cb(ax25, ax25->ax25_dev);
657 break;
658
659 default:
660 res = -ENOPROTOOPT;
661 }
662 release_sock(sk);
663
664 return res;
665 }
666
667 static int ax25_getsockopt(struct socket *sock, int level, int optname,
668 char __user *optval, int __user *optlen)
669 {
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;
677
678 if (level != SOL_AX25)
679 return -ENOPROTOOPT;
680
681 if (get_user(maxlen, optlen))
682 return -EFAULT;
683
684 if (maxlen < 1)
685 return -EFAULT;
686
687 valptr = (void *) &val;
688 length = min_t(unsigned int, maxlen, sizeof(int));
689
690 lock_sock(sk);
691 ax25 = ax25_sk(sk);
692
693 switch (optname) {
694 case AX25_WINDOW:
695 val = ax25->window;
696 break;
697
698 case AX25_T1:
699 val = ax25->t1 / HZ;
700 break;
701
702 case AX25_T2:
703 val = ax25->t2 / HZ;
704 break;
705
706 case AX25_N2:
707 val = ax25->n2;
708 break;
709
710 case AX25_T3:
711 val = ax25->t3 / HZ;
712 break;
713
714 case AX25_IDLE:
715 val = ax25->idle / (60 * HZ);
716 break;
717
718 case AX25_BACKOFF:
719 val = ax25->backoff;
720 break;
721
722 case AX25_EXTSEQ:
723 val = (ax25->modulus == AX25_EMODULUS);
724 break;
725
726 case AX25_PIDINCL:
727 val = ax25->pidincl;
728 break;
729
730 case AX25_IAMDIGI:
731 val = ax25->iamdigi;
732 break;
733
734 case AX25_PACLEN:
735 val = ax25->paclen;
736 break;
737
738 case SO_BINDTODEVICE:
739 ax25_dev = ax25->ax25_dev;
740
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;
747 }
748
749 valptr = (void *) devname;
750 break;
751
752 default:
753 release_sock(sk);
754 return -ENOPROTOOPT;
755 }
756 release_sock(sk);
757
758 if (put_user(length, optlen))
759 return -EFAULT;
760
761 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
762 }
763
764 static int ax25_listen(struct socket *sock, int backlog)
765 {
766 struct sock *sk = sock->sk;
767 int res = 0;
768
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;
774 }
775 res = -EOPNOTSUPP;
776
777 out:
778 release_sock(sk);
779
780 return res;
781 }
782
783 /*
784 * XXX: when creating ax25_sock we should update the .obj_size setting
785 * below.
786 */
787 static struct proto ax25_proto = {
788 .name = "AX25",
789 .owner = THIS_MODULE,
790 .obj_size = sizeof(struct sock),
791 };
792
793 static int ax25_create(struct net *net, struct socket *sock, int protocol)
794 {
795 struct sock *sk;
796 ax25_cb *ax25;
797
798 if (net != &init_net)
799 return -EAFNOSUPPORT;
800
801 switch (sock->type) {
802 case SOCK_DGRAM:
803 if (protocol == 0 || protocol == PF_AX25)
804 protocol = AX25_P_TEXT;
805 break;
806
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;
837 }
838 break;
839
840 case SOCK_RAW:
841 break;
842 default:
843 return -ESOCKTNOSUPPORT;
844 }
845
846 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
847 if (sk == NULL)
848 return -ENOMEM;
849
850 ax25 = sk->sk_protinfo = ax25_create_cb();
851 if (!ax25) {
852 sk_free(sk);
853 return -ENOMEM;
854 }
855
856 sock_init_data(sock, sk);
857
858 sk->sk_destruct = ax25_free_sock;
859 sock->ops = &ax25_proto_ops;
860 sk->sk_protocol = protocol;
861
862 ax25->sk = sk;
863
864 return 0;
865 }
866
867 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
868 {
869 struct sock *sk;
870 ax25_cb *ax25, *oax25;
871
872 sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot);
873 if (sk == NULL)
874 return NULL;
875
876 if ((ax25 = ax25_create_cb()) == NULL) {
877 sk_free(sk);
878 return NULL;
879 }
880
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;
890 }
891
892 sock_init_data(NULL, sk);
893
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);
904
905 oax25 = ax25_sk(osk);
906
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;
919
920 ax25->ax25_dev = ax25_dev;
921 ax25->source_addr = oax25->source_addr;
922
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;
930 }
931 }
932
933 sk->sk_protinfo = ax25;
934 ax25->sk = sk;
935
936 return sk;
937 }
938
939 static int ax25_release(struct socket *sock)
940 {
941 struct sock *sk = sock->sk;
942 ax25_cb *ax25;
943
944 if (sk == NULL)
945 return 0;
946
947 sock_hold(sk);
948 sock_orphan(sk);
949 lock_sock(sk);
950 ax25 = ax25_sk(sk);
951
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;
960
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;
969
970 case AX25_STATE_3:
971 case AX25_STATE_4:
972 ax25_clear_queues(ax25);
973 ax25->n2count = 0;
974
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
992 }
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;
1001
1002 default:
1003 break;
1004 }
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);
1010 }
1011
1012 sock->sk = NULL;
1013 release_sock(sk);
1014 sock_put(sk);
1015
1016 return 0;
1017 }
1018
1019 /*
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.
1024 */
1025 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1026 {
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;
1034
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.
1039 */
1040 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1041 (addr_len > sizeof(struct full_sockaddr_ax25)))
1042 return -EINVAL;
1043
1044 if (addr->fsa_ax25.sax25_family != AF_AX25)
1045 return -EINVAL;
1046
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;
1054
1055 call = addr->fsa_ax25.sax25_call;
1056 }
1057
1058 lock_sock(sk);
1059
1060 ax25 = ax25_sk(sk);
1061 if (!sock_flag(sk, SOCK_ZAPPED)) {
1062 err = -EINVAL;
1063 goto out;
1064 }
1065
1066 ax25->source_addr = call;
1067
1068 /*
1069 * User already set interface with SO_BINDTODEVICE
1070 */
1071 if (ax25->ax25_dev != NULL)
1072 goto done;
1073
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;
1079 }
1080 } else {
1081 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1082 err = -EADDRNOTAVAIL;
1083 goto out;
1084 }
1085 }
1086
1087 if (ax25_dev != NULL)
1088 ax25_fillin_cb(ax25, ax25_dev);
1089
1090 done:
1091 ax25_cb_add(ax25);
1092 sock_reset_flag(sk, SOCK_ZAPPED);
1093
1094 out:
1095 release_sock(sk);
1096
1097 return 0;
1098 }
1099
1100 /*
1101 * FIXME: nonblock behaviour looks like it may have a bug.
1102 */
1103 static int __must_check ax25_connect(struct socket *sock,
1104 struct sockaddr *uaddr, int addr_len, int flags)
1105 {
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;
1111
1112 /*
1113 * some sanity checks. code further down depends on this
1114 */
1115
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
1119 */
1120 ;
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.
1124 */
1125 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1126 (addr_len > sizeof(struct full_sockaddr_ax25)))
1127 return -EINVAL;
1128
1129
1130 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1131 return -EINVAL;
1132
1133 lock_sock(sk);
1134
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;
1141
1142 case TCP_ESTABLISHED: /* connection established */
1143 sock->state = SS_CONNECTED;
1144 goto out_release;
1145
1146 case TCP_CLOSE: /* connection refused */
1147 sock->state = SS_UNCONNECTED;
1148 err = -ECONNREFUSED;
1149 goto out_release;
1150 }
1151 }
1152
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;
1156 }
1157
1158 sk->sk_state = TCP_CLOSE;
1159 sock->state = SS_UNCONNECTED;
1160
1161 kfree(ax25->digipeat);
1162 ax25->digipeat = NULL;
1163
1164 /*
1165 * Handle digi-peaters to be used.
1166 */
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;
1173 }
1174
1175 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1176 err = -ENOBUFS;
1177 goto out_release;
1178 }
1179
1180 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1181 digi->lastrepeat = -1;
1182
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;
1190 }
1191 digi->calls[ct] = fsa->fsa_digipeater[ct];
1192 ct++;
1193 }
1194 }
1195
1196 /*
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.
1200 */
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;
1208 }
1209
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;
1217 }
1218 }
1219
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;
1227 }
1228
1229 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1230 ax25->digipeat = digi;
1231
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;
1237 }
1238
1239 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1240 sock->state = SS_CONNECTING;
1241 sk->sk_state = TCP_SYN_SENT;
1242
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;
1248
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
1259 }
1260
1261 ax25->state = AX25_STATE_1;
1262
1263 ax25_start_heartbeat(ax25);
1264
1265 /* Now the loop */
1266 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1267 err = -EINPROGRESS;
1268 goto out_release;
1269 }
1270
1271 if (sk->sk_state == TCP_SYN_SENT) {
1272 DEFINE_WAIT(wait);
1273
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;
1284 }
1285 err = -ERESTARTSYS;
1286 break;
1287 }
1288 finish_wait(sk->sk_sleep, &wait);
1289
1290 if (err)
1291 goto out_release;
1292 }
1293
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;
1299 }
1300
1301 sock->state = SS_CONNECTED;
1302
1303 err = 0;
1304 out_release:
1305 release_sock(sk);
1306
1307 return err;
1308 }
1309
1310 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1311 {
1312 struct sk_buff *skb;
1313 struct sock *newsk;
1314 DEFINE_WAIT(wait);
1315 struct sock *sk;
1316 int err = 0;
1317
1318 if (sock->state != SS_UNCONNECTED)
1319 return -EINVAL;
1320
1321 if ((sk = sock->sk) == NULL)
1322 return -EINVAL;
1323
1324 lock_sock(sk);
1325 if (sk->sk_type != SOCK_SEQPACKET) {
1326 err = -EOPNOTSUPP;
1327 goto out;
1328 }
1329
1330 if (sk->sk_state != TCP_LISTEN) {
1331 err = -EINVAL;
1332 goto out;
1333 }
1334
1335 /*
1336 * The read queue this time is holding sockets ready to use
1337 * hooked into the SABM we saved
1338 */
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;
1344
1345 if (flags & O_NONBLOCK) {
1346 err = -EWOULDBLOCK;
1347 break;
1348 }
1349 if (!signal_pending(current)) {
1350 release_sock(sk);
1351 schedule();
1352 lock_sock(sk);
1353 continue;
1354 }
1355 err = -ERESTARTSYS;
1356 break;
1357 }
1358 finish_wait(sk->sk_sleep, &wait);
1359
1360 if (err)
1361 goto out;
1362
1363 newsk = skb->sk;
1364 newsk->sk_socket = newsock;
1365 newsk->sk_sleep = &newsock->wait;
1366
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;
1372
1373 out:
1374 release_sock(sk);
1375
1376 return err;
1377 }
1378
1379 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1380 int *uaddr_len, int peer)
1381 {
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;
1387
1388 lock_sock(sk);
1389 ax25 = ax25_sk(sk);
1390
1391 if (peer != 0) {
1392 if (sk->sk_state != TCP_ESTABLISHED) {
1393 err = -ENOTCONN;
1394 goto out;
1395 }
1396
1397 fsa->fsa_ax25.sax25_family = AF_AX25;
1398 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1399 fsa->fsa_ax25.sax25_ndigis = 0;
1400
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];
1407 }
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;
1417 }
1418 }
1419 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1420
1421 out:
1422 release_sock(sk);
1423
1424 return err;
1425 }
1426
1427 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1428 struct msghdr *msg, size_t len)
1429 {
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;
1438
1439 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1440 return -EINVAL;
1441
1442 lock_sock(sk);
1443 ax25 = ax25_sk(sk);
1444
1445 if (sock_flag(sk, SOCK_ZAPPED)) {
1446 err = -EADDRNOTAVAIL;
1447 goto out;
1448 }
1449
1450 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1451 send_sig(SIGPIPE, current, 0);
1452 err = -EPIPE;
1453 goto out;
1454 }
1455
1456 if (ax25->ax25_dev == NULL) {
1457 err = -ENETUNREACH;
1458 goto out;
1459 }
1460
1461 if (len > ax25->ax25_dev->dev->mtu) {
1462 err = -EMSGSIZE;
1463 goto out;
1464 }
1465
1466 if (usax != NULL) {
1467 if (usax->sax25_family != AF_AX25) {
1468 err = -EINVAL;
1469 goto out;
1470 }
1471
1472 if (addr_len == sizeof(struct sockaddr_ax25))
1473 /* ax25_sendmsg(): uses obsolete socket structure */
1474 ;
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.
1479 */
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;
1484 }
1485
1486
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;
1490
1491 /* Valid number of digipeaters ? */
1492 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1493 err = -EINVAL;
1494 goto out;
1495 }
1496
1497 dtmp.ndigi = usax->sax25_ndigis;
1498
1499 while (ct < usax->sax25_ndigis) {
1500 dtmp.repeated[ct] = 0;
1501 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1502 ct++;
1503 }
1504
1505 dtmp.lastrepeat = 0;
1506 }
1507
1508 sax = *usax;
1509 if (sk->sk_type == SOCK_SEQPACKET &&
1510 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1511 err = -EISCONN;
1512 goto out;
1513 }
1514 if (usax->sax25_ndigis == 0)
1515 dp = NULL;
1516 else
1517 dp = &dtmp;
1518 } else {
1519 /*
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
1523 */
1524 if (sk->sk_state != TCP_ESTABLISHED) {
1525 err = -ENOTCONN;
1526 goto out;
1527 }
1528 sax.sax25_family = AF_AX25;
1529 sax.sax25_call = ax25->dest_addr;
1530 dp = ax25->digipeat;
1531 }
1532
1533 SOCK_DEBUG(sk, "AX.25: sendto: Addresses built.\n");
1534
1535 /* Build a packet */
1536 SOCK_DEBUG(sk, "AX.25: sendto: building packet.\n");
1537
1538 /* Assume the worst case */
1539 size = len + ax25->ax25_dev->dev->hard_header_len;
1540
1541 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1542 if (skb == NULL)
1543 goto out;
1544
1545 skb_reserve(skb, size - len);
1546
1547 SOCK_DEBUG(sk, "AX.25: Appending user data\n");
1548
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;
1554 }
1555
1556 skb_reset_network_header(skb);
1557
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;
1561
1562 SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n");
1563
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;
1570 }
1571
1572 /* Shove it onto the queue and kick */
1573 ax25_output(ax25, ax25->paclen, skb);
1574
1575 err = len;
1576 goto out;
1577 }
1578
1579 skb_push(skb, 1 + ax25_addr_size(dp));
1580
1581 SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp);
1582
1583 if (dp != NULL)
1584 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi);
1585
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);
1589
1590 SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv);
1591
1592 skb_set_transport_header(skb, lv);
1593
1594 SOCK_DEBUG(sk, "base=%p pos=%p\n",
1595 skb->data, skb_transport_header(skb));
1596
1597 *skb_transport_header(skb) = AX25_UI;
1598
1599 /* Datagram frames go straight out of the door as UI */
1600 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1601
1602 err = len;
1603
1604 out:
1605 release_sock(sk);
1606
1607 return err;
1608 }
1609
1610 static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1611 struct msghdr *msg, size_t size, int flags)
1612 {
1613 struct sock *sk = sock->sk;
1614 struct sk_buff *skb;
1615 int copied;
1616 int err = 0;
1617
1618 lock_sock(sk);
1619 /*
1620 * This works for seqpacket too. The receiver has ordered the
1621 * queue for us! We do one quick check first though
1622 */
1623 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1624 err = -ENOTCONN;
1625 goto out;
1626 }
1627
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;
1633
1634 if (!ax25_sk(sk)->pidincl)
1635 skb_pull(skb, 1); /* Remove PID */
1636
1637 skb_reset_transport_header(skb);
1638 copied = skb->len;
1639
1640 if (copied > size) {
1641 copied = size;
1642 msg->msg_flags |= MSG_TRUNC;
1643 }
1644
1645 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1646
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);
1652
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;
1661
1662 if (sax->sax25_ndigis != 0) {
1663 int ct;
1664 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1665
1666 for (ct = 0; ct < digi.ndigi; ct++)
1667 fsa->fsa_digipeater[ct] = digi.calls[ct];
1668 }
1669 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1670 }
1671
1672 skb_free_datagram(sk, skb);
1673 err = copied;
1674
1675 out:
1676 release_sock(sk);
1677
1678 return err;
1679 }
1680
1681 static int ax25_shutdown(struct socket *sk, int how)
1682 {
1683 /* FIXME - generate DM and RNR states */
1684 return -EOPNOTSUPP;
1685 }
1686
1687 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1688 {
1689 struct sock *sk = sock->sk;
1690 void __user *argp = (void __user *)arg;
1691 int res = 0;
1692
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;
1702 }
1703
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;
1712 }
1713
1714 case SIOCGSTAMP:
1715 res = sock_get_timestamp(sk, argp);
1716 break;
1717
1718 case SIOCGSTAMPNS:
1719 res = sock_get_timestampns(sk, argp);
1720 break;
1721
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;
1729 }
1730 res = ax25_uid_ioctl(cmd, &sax25);
1731 break;
1732 }
1733
1734 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1735 long amount;
1736 if (!capable(CAP_NET_ADMIN)) {
1737 res = -EPERM;
1738 break;
1739 }
1740 if (get_user(amount, (long __user *)argp)) {
1741 res = -EFAULT;
1742 break;
1743 }
1744 if (amount > AX25_NOUID_BLOCK) {
1745 res = -EINVAL;
1746 break;
1747 }
1748 ax25_uid_policy = amount;
1749 res = 0;
1750 break;
1751 }
1752
1753 case SIOCADDRT:
1754 case SIOCDELRT:
1755 case SIOCAX25OPTRT:
1756 if (!capable(CAP_NET_ADMIN)) {
1757 res = -EPERM;
1758 break;
1759 }
1760 res = ax25_rt_ioctl(cmd, argp);
1761 break;
1762
1763 case SIOCAX25CTLCON:
1764 if (!capable(CAP_NET_ADMIN)) {
1765 res = -EPERM;
1766 break;
1767 }
1768 res = ax25_ctl_ioctl(cmd, argp);
1769 break;
1770
1771 case SIOCAX25GETINFO:
1772 case SIOCAX25GETINFOOLD: {
1773 ax25_cb *ax25 = ax25_sk(sk);
1774 struct ax25_info_struct ax25_info;
1775
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;
1795
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;
1803 }
1804
1805 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1806 res = -EFAULT;
1807 break;
1808 }
1809 } else {
1810 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1811 res = -EINVAL;
1812 break;
1813 }
1814 }
1815 res = 0;
1816 break;
1817 }
1818
1819 case SIOCAX25ADDFWD:
1820 case SIOCAX25DELFWD: {
1821 struct ax25_fwd_struct ax25_fwd;
1822 if (!capable(CAP_NET_ADMIN)) {
1823 res = -EPERM;
1824 break;
1825 }
1826 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1827 res = -EFAULT;
1828 break;
1829 }
1830 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1831 break;
1832 }
1833
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;
1846
1847 default:
1848 res = -ENOIOCTLCMD;
1849 break;
1850 }
1851 release_sock(sk);
1852
1853 return res;
1854 }
1855
1856 #ifdef CONFIG_PROC_FS
1857
1858 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1859 __acquires(ax25_list_lock)
1860 {
1861 struct ax25_cb *ax25;
1862 struct hlist_node *node;
1863 int i = 0;
1864
1865 spin_lock_bh(&ax25_list_lock);
1866 ax25_for_each(ax25, node, &ax25_list) {
1867 if (i == *pos)
1868 return ax25;
1869 ++i;
1870 }
1871 return NULL;
1872 }
1873
1874 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1875 {
1876 ++*pos;
1877
1878 return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1879 struct ax25_cb, ax25_node);
1880 }
1881
1882 static void ax25_info_stop(struct seq_file *seq, void *v)
1883 __releases(ax25_list_lock)
1884 {
1885 spin_unlock_bh(&ax25_list_lock);
1886 }
1887
1888 static int ax25_info_show(struct seq_file *seq, void *v)
1889 {
1890 ax25_cb *ax25 = v;
1891 char buf[11];
1892 int k;
1893
1894
1895 /*
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
1898 */
1899
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));
1906
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]? "*":"");
1911 }
1912
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);
1925
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");
1933 }
1934 return 0;
1935 }
1936
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,
1942 };
1943
1944 static int ax25_info_open(struct inode *inode, struct file *file)
1945 {
1946 return seq_open(file, &ax25_info_seqops);
1947 }
1948
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,
1955 };
1956
1957 #endif
1958
1959 static struct net_proto_family ax25_family_ops = {
1960 .family = PF_AX25,
1961 .create = ax25_create,
1962 .owner = THIS_MODULE,
1963 };
1964
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,
1984 };
1985
1986 /*
1987 * Called by socket.c on kernel start up
1988 */
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,
1993 };
1994
1995 static struct notifier_block ax25_dev_notifier = {
1996 .notifier_call =ax25_device_event,
1997 };
1998
1999 static int __init ax25_init(void)
2000 {
2001 int rc = proto_register(&ax25_proto, 0);
2002
2003 if (rc != 0)
2004 goto out;
2005
2006 sock_register(&ax25_family_ops);
2007 dev_add_pack(&ax25_packet_type);
2008 register_netdevice_notifier(&ax25_dev_notifier);
2009 ax25_register_sysctl();
2010
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;
2016 }
2017 module_init(ax25_init);
2018
2019
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);
2024
2025 static void __exit ax25_exit(void)
2026 {
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();
2033
2034 ax25_unregister_sysctl();
2035 unregister_netdevice_notifier(&ax25_dev_notifier);
2036
2037 dev_remove_pack(&ax25_packet_type);
2038
2039 sock_unregister(PF_AX25);
2040 proto_unregister(&ax25_proto);
2041 }
2042 module_exit(ax25_exit);
Community contributions to the Openmoko Kernel