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