?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PM / yenta: Split resume into early and late parts (rev. 4)
[linux/fpc-iii.git] / net / ax25 / af_ax25.c
blobf8969febab72f5b238e45492d2173bd0f7e70460
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 (!net_eq(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 /* 9A4GL: hack to release unaccepted sockets */
321 skb->sk->sk_state = TCP_LISTEN;
322
323 ax25_start_heartbeat(sax25);
324 sax25->state = AX25_STATE_0;
325 }
326
327 kfree_skb(skb);
328 }
329 skb_queue_purge(&ax25->sk->sk_write_queue);
330 }
331
332 if (ax25->sk != NULL) {
333 if (sk_has_allocations(ax25->sk)) {
334 /* Defer: outstanding buffers */
335 setup_timer(&ax25->dtimer, ax25_destroy_timer,
336 (unsigned long)ax25);
337 ax25->dtimer.expires = jiffies + 2 * HZ;
338 add_timer(&ax25->dtimer);
339 } else {
340 struct sock *sk=ax25->sk;
341 ax25->sk=NULL;
342 sock_put(sk);
343 }
344 } else {
345 ax25_cb_put(ax25);
346 }
347 }
348
349 /*
350 * dl1bke 960311: set parameters for existing AX.25 connections,
351 * includes a KILL command to abort any connection.
352 * VERY useful for debugging ;-)
353 */
354 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
355 {
356 struct ax25_ctl_struct ax25_ctl;
357 ax25_digi digi;
358 ax25_dev *ax25_dev;
359 ax25_cb *ax25;
360 unsigned int k;
361
362 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
363 return -EFAULT;
364
365 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
366 return -ENODEV;
367
368 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
369 return -EINVAL;
370
371 digi.ndigi = ax25_ctl.digi_count;
372 for (k = 0; k < digi.ndigi; k++)
373 digi.calls[k] = ax25_ctl.digi_addr[k];
374
375 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
376 return -ENOTCONN;
377
378 switch (ax25_ctl.cmd) {
379 case AX25_KILL:
380 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
381 #ifdef CONFIG_AX25_DAMA_SLAVE
382 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
383 ax25_dama_off(ax25);
384 #endif
385 ax25_disconnect(ax25, ENETRESET);
386 break;
387
388 case AX25_WINDOW:
389 if (ax25->modulus == AX25_MODULUS) {
390 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
391 return -EINVAL;
392 } else {
393 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
394 return -EINVAL;
395 }
396 ax25->window = ax25_ctl.arg;
397 break;
398
399 case AX25_T1:
400 if (ax25_ctl.arg < 1)
401 return -EINVAL;
402 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
403 ax25->t1 = ax25_ctl.arg * HZ;
404 break;
405
406 case AX25_T2:
407 if (ax25_ctl.arg < 1)
408 return -EINVAL;
409 ax25->t2 = ax25_ctl.arg * HZ;
410 break;
411
412 case AX25_N2:
413 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
414 return -EINVAL;
415 ax25->n2count = 0;
416 ax25->n2 = ax25_ctl.arg;
417 break;
418
419 case AX25_T3:
420 if (ax25_ctl.arg < 0)
421 return -EINVAL;
422 ax25->t3 = ax25_ctl.arg * HZ;
423 break;
424
425 case AX25_IDLE:
426 if (ax25_ctl.arg < 0)
427 return -EINVAL;
428 ax25->idle = ax25_ctl.arg * 60 * HZ;
429 break;
430
431 case AX25_PACLEN:
432 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
433 return -EINVAL;
434 ax25->paclen = ax25_ctl.arg;
435 break;
436
437 default:
438 return -EINVAL;
439 }
440
441 return 0;
442 }
443
444 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
445 {
446 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
447 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
448 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
449 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
450 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
451 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
452 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
453 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
454
455 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
456 ax25->modulus = AX25_EMODULUS;
457 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
458 } else {
459 ax25->modulus = AX25_MODULUS;
460 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
461 }
462 }
463
464 /*
465 * Fill in a created AX.25 created control block with the default
466 * values for a particular device.
467 */
468 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
469 {
470 ax25->ax25_dev = ax25_dev;
471
472 if (ax25->ax25_dev != NULL) {
473 ax25_fillin_cb_from_dev(ax25, ax25_dev);
474 return;
475 }
476
477 /*
478 * No device, use kernel / AX.25 spec default values
479 */
480 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
481 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
482 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
483 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
484 ax25->n2 = AX25_DEF_N2;
485 ax25->paclen = AX25_DEF_PACLEN;
486 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
487 ax25->backoff = AX25_DEF_BACKOFF;
488
489 if (AX25_DEF_AXDEFMODE) {
490 ax25->modulus = AX25_EMODULUS;
491 ax25->window = AX25_DEF_EWINDOW;
492 } else {
493 ax25->modulus = AX25_MODULUS;
494 ax25->window = AX25_DEF_WINDOW;
495 }
496 }
497
498 /*
499 * Create an empty AX.25 control block.
500 */
501 ax25_cb *ax25_create_cb(void)
502 {
503 ax25_cb *ax25;
504
505 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
506 return NULL;
507
508 atomic_set(&ax25->refcount, 1);
509
510 skb_queue_head_init(&ax25->write_queue);
511 skb_queue_head_init(&ax25->frag_queue);
512 skb_queue_head_init(&ax25->ack_queue);
513 skb_queue_head_init(&ax25->reseq_queue);
514
515 ax25_setup_timers(ax25);
516
517 ax25_fillin_cb(ax25, NULL);
518
519 ax25->state = AX25_STATE_0;
520
521 return ax25;
522 }
523
524 /*
525 * Handling for system calls applied via the various interfaces to an
526 * AX25 socket object
527 */
528
529 static int ax25_setsockopt(struct socket *sock, int level, int optname,
530 char __user *optval, int optlen)
531 {
532 struct sock *sk = sock->sk;
533 ax25_cb *ax25;
534 struct net_device *dev;
535 char devname[IFNAMSIZ];
536 int opt, res = 0;
537
538 if (level != SOL_AX25)
539 return -ENOPROTOOPT;
540
541 if (optlen < (int)sizeof(int))
542 return -EINVAL;
543
544 if (get_user(opt, (int __user *)optval))
545 return -EFAULT;
546
547 lock_sock(sk);
548 ax25 = ax25_sk(sk);
549
550 switch (optname) {
551 case AX25_WINDOW:
552 if (ax25->modulus == AX25_MODULUS) {
553 if (opt < 1 || opt > 7) {
554 res = -EINVAL;
555 break;
556 }
557 } else {
558 if (opt < 1 || opt > 63) {
559 res = -EINVAL;
560 break;
561 }
562 }
563 ax25->window = opt;
564 break;
565
566 case AX25_T1:
567 if (opt < 1) {
568 res = -EINVAL;
569 break;
570 }
571 ax25->rtt = (opt * HZ) >> 1;
572 ax25->t1 = opt * HZ;
573 break;
574
575 case AX25_T2:
576 if (opt < 1) {
577 res = -EINVAL;
578 break;
579 }
580 ax25->t2 = opt * HZ;
581 break;
582
583 case AX25_N2:
584 if (opt < 1 || opt > 31) {
585 res = -EINVAL;
586 break;
587 }
588 ax25->n2 = opt;
589 break;
590
591 case AX25_T3:
592 if (opt < 1) {
593 res = -EINVAL;
594 break;
595 }
596 ax25->t3 = opt * HZ;
597 break;
598
599 case AX25_IDLE:
600 if (opt < 0) {
601 res = -EINVAL;
602 break;
603 }
604 ax25->idle = opt * 60 * HZ;
605 break;
606
607 case AX25_BACKOFF:
608 if (opt < 0 || opt > 2) {
609 res = -EINVAL;
610 break;
611 }
612 ax25->backoff = opt;
613 break;
614
615 case AX25_EXTSEQ:
616 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
617 break;
618
619 case AX25_PIDINCL:
620 ax25->pidincl = opt ? 1 : 0;
621 break;
622
623 case AX25_IAMDIGI:
624 ax25->iamdigi = opt ? 1 : 0;
625 break;
626
627 case AX25_PACLEN:
628 if (opt < 16 || opt > 65535) {
629 res = -EINVAL;
630 break;
631 }
632 ax25->paclen = opt;
633 break;
634
635 case SO_BINDTODEVICE:
636 if (optlen > IFNAMSIZ)
637 optlen=IFNAMSIZ;
638 if (copy_from_user(devname, optval, optlen)) {
639 res = -EFAULT;
640 break;
641 }
642
643 dev = dev_get_by_name(&init_net, devname);
644 if (dev == NULL) {
645 res = -ENODEV;
646 break;
647 }
648
649 if (sk->sk_type == SOCK_SEQPACKET &&
650 (sock->state != SS_UNCONNECTED ||
651 sk->sk_state == TCP_LISTEN)) {
652 res = -EADDRNOTAVAIL;
653 dev_put(dev);
654 break;
655 }
656
657 ax25->ax25_dev = ax25_dev_ax25dev(dev);
658 ax25_fillin_cb(ax25, ax25->ax25_dev);
659 break;
660
661 default:
662 res = -ENOPROTOOPT;
663 }
664 release_sock(sk);
665
666 return res;
667 }
668
669 static int ax25_getsockopt(struct socket *sock, int level, int optname,
670 char __user *optval, int __user *optlen)
671 {
672 struct sock *sk = sock->sk;
673 ax25_cb *ax25;
674 struct ax25_dev *ax25_dev;
675 char devname[IFNAMSIZ];
676 void *valptr;
677 int val = 0;
678 int maxlen, length;
679
680 if (level != SOL_AX25)
681 return -ENOPROTOOPT;
682
683 if (get_user(maxlen, optlen))
684 return -EFAULT;
685
686 if (maxlen < 1)
687 return -EFAULT;
688
689 valptr = (void *) &val;
690 length = min_t(unsigned int, maxlen, sizeof(int));
691
692 lock_sock(sk);
693 ax25 = ax25_sk(sk);
694
695 switch (optname) {
696 case AX25_WINDOW:
697 val = ax25->window;
698 break;
699
700 case AX25_T1:
701 val = ax25->t1 / HZ;
702 break;
703
704 case AX25_T2:
705 val = ax25->t2 / HZ;
706 break;
707
708 case AX25_N2:
709 val = ax25->n2;
710 break;
711
712 case AX25_T3:
713 val = ax25->t3 / HZ;
714 break;
715
716 case AX25_IDLE:
717 val = ax25->idle / (60 * HZ);
718 break;
719
720 case AX25_BACKOFF:
721 val = ax25->backoff;
722 break;
723
724 case AX25_EXTSEQ:
725 val = (ax25->modulus == AX25_EMODULUS);
726 break;
727
728 case AX25_PIDINCL:
729 val = ax25->pidincl;
730 break;
731
732 case AX25_IAMDIGI:
733 val = ax25->iamdigi;
734 break;
735
736 case AX25_PACLEN:
737 val = ax25->paclen;
738 break;
739
740 case SO_BINDTODEVICE:
741 ax25_dev = ax25->ax25_dev;
742
743 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
744 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
745 length = strlen(devname) + 1;
746 } else {
747 *devname = '\0';
748 length = 1;
749 }
750
751 valptr = (void *) devname;
752 break;
753
754 default:
755 release_sock(sk);
756 return -ENOPROTOOPT;
757 }
758 release_sock(sk);
759
760 if (put_user(length, optlen))
761 return -EFAULT;
762
763 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
764 }
765
766 static int ax25_listen(struct socket *sock, int backlog)
767 {
768 struct sock *sk = sock->sk;
769 int res = 0;
770
771 lock_sock(sk);
772 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
773 sk->sk_max_ack_backlog = backlog;
774 sk->sk_state = TCP_LISTEN;
775 goto out;
776 }
777 res = -EOPNOTSUPP;
778
779 out:
780 release_sock(sk);
781
782 return res;
783 }
784
785 /*
786 * XXX: when creating ax25_sock we should update the .obj_size setting
787 * below.
788 */
789 static struct proto ax25_proto = {
790 .name = "AX25",
791 .owner = THIS_MODULE,
792 .obj_size = sizeof(struct sock),
793 };
794
795 static int ax25_create(struct net *net, struct socket *sock, int protocol)
796 {
797 struct sock *sk;
798 ax25_cb *ax25;
799
800 if (net != &init_net)
801 return -EAFNOSUPPORT;
802
803 switch (sock->type) {
804 case SOCK_DGRAM:
805 if (protocol == 0 || protocol == PF_AX25)
806 protocol = AX25_P_TEXT;
807 break;
808
809 case SOCK_SEQPACKET:
810 switch (protocol) {
811 case 0:
812 case PF_AX25: /* For CLX */
813 protocol = AX25_P_TEXT;
814 break;
815 case AX25_P_SEGMENT:
816 #ifdef CONFIG_INET
817 case AX25_P_ARP:
818 case AX25_P_IP:
819 #endif
820 #ifdef CONFIG_NETROM
821 case AX25_P_NETROM:
822 #endif
823 #ifdef CONFIG_ROSE
824 case AX25_P_ROSE:
825 #endif
826 return -ESOCKTNOSUPPORT;
827 #ifdef CONFIG_NETROM_MODULE
828 case AX25_P_NETROM:
829 if (ax25_protocol_is_registered(AX25_P_NETROM))
830 return -ESOCKTNOSUPPORT;
831 #endif
832 #ifdef CONFIG_ROSE_MODULE
833 case AX25_P_ROSE:
834 if (ax25_protocol_is_registered(AX25_P_ROSE))
835 return -ESOCKTNOSUPPORT;
836 #endif
837 default:
838 break;
839 }
840 break;
841
842 case SOCK_RAW:
843 break;
844 default:
845 return -ESOCKTNOSUPPORT;
846 }
847
848 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
849 if (sk == NULL)
850 return -ENOMEM;
851
852 ax25 = sk->sk_protinfo = ax25_create_cb();
853 if (!ax25) {
854 sk_free(sk);
855 return -ENOMEM;
856 }
857
858 sock_init_data(sock, sk);
859
860 sk->sk_destruct = ax25_free_sock;
861 sock->ops = &ax25_proto_ops;
862 sk->sk_protocol = protocol;
863
864 ax25->sk = sk;
865
866 return 0;
867 }
868
869 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
870 {
871 struct sock *sk;
872 ax25_cb *ax25, *oax25;
873
874 sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot);
875 if (sk == NULL)
876 return NULL;
877
878 if ((ax25 = ax25_create_cb()) == NULL) {
879 sk_free(sk);
880 return NULL;
881 }
882
883 switch (osk->sk_type) {
884 case SOCK_DGRAM:
885 break;
886 case SOCK_SEQPACKET:
887 break;
888 default:
889 sk_free(sk);
890 ax25_cb_put(ax25);
891 return NULL;
892 }
893
894 sock_init_data(NULL, sk);
895
896 sk->sk_type = osk->sk_type;
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 sock_copy_flags(sk, osk);
903
904 oax25 = ax25_sk(osk);
905
906 ax25->modulus = oax25->modulus;
907 ax25->backoff = oax25->backoff;
908 ax25->pidincl = oax25->pidincl;
909 ax25->iamdigi = oax25->iamdigi;
910 ax25->rtt = oax25->rtt;
911 ax25->t1 = oax25->t1;
912 ax25->t2 = oax25->t2;
913 ax25->t3 = oax25->t3;
914 ax25->n2 = oax25->n2;
915 ax25->idle = oax25->idle;
916 ax25->paclen = oax25->paclen;
917 ax25->window = oax25->window;
918
919 ax25->ax25_dev = ax25_dev;
920 ax25->source_addr = oax25->source_addr;
921
922 if (oax25->digipeat != NULL) {
923 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
924 GFP_ATOMIC);
925 if (ax25->digipeat == NULL) {
926 sk_free(sk);
927 ax25_cb_put(ax25);
928 return NULL;
929 }
930 }
931
932 sk->sk_protinfo = ax25;
933 sk->sk_destruct = ax25_free_sock;
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 sock_graft(newsk, newsock);
1365
1366 /* Now attach up the new socket */
1367 kfree_skb(skb);
1368 sk->sk_ack_backlog--;
1369 newsock->state = SS_CONNECTED;
1370
1371 out:
1372 release_sock(sk);
1373
1374 return err;
1375 }
1376
1377 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1378 int *uaddr_len, int peer)
1379 {
1380 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1381 struct sock *sk = sock->sk;
1382 unsigned char ndigi, i;
1383 ax25_cb *ax25;
1384 int err = 0;
1385
1386 lock_sock(sk);
1387 ax25 = ax25_sk(sk);
1388
1389 if (peer != 0) {
1390 if (sk->sk_state != TCP_ESTABLISHED) {
1391 err = -ENOTCONN;
1392 goto out;
1393 }
1394
1395 fsa->fsa_ax25.sax25_family = AF_AX25;
1396 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1397 fsa->fsa_ax25.sax25_ndigis = 0;
1398
1399 if (ax25->digipeat != NULL) {
1400 ndigi = ax25->digipeat->ndigi;
1401 fsa->fsa_ax25.sax25_ndigis = ndigi;
1402 for (i = 0; i < ndigi; i++)
1403 fsa->fsa_digipeater[i] =
1404 ax25->digipeat->calls[i];
1405 }
1406 } else {
1407 fsa->fsa_ax25.sax25_family = AF_AX25;
1408 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1409 fsa->fsa_ax25.sax25_ndigis = 1;
1410 if (ax25->ax25_dev != NULL) {
1411 memcpy(&fsa->fsa_digipeater[0],
1412 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1413 } else {
1414 fsa->fsa_digipeater[0] = null_ax25_address;
1415 }
1416 }
1417 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1418
1419 out:
1420 release_sock(sk);
1421
1422 return err;
1423 }
1424
1425 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1426 struct msghdr *msg, size_t len)
1427 {
1428 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1429 struct sock *sk = sock->sk;
1430 struct sockaddr_ax25 sax;
1431 struct sk_buff *skb;
1432 ax25_digi dtmp, *dp;
1433 ax25_cb *ax25;
1434 size_t size;
1435 int lv, err, addr_len = msg->msg_namelen;
1436
1437 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1438 return -EINVAL;
1439
1440 lock_sock(sk);
1441 ax25 = ax25_sk(sk);
1442
1443 if (sock_flag(sk, SOCK_ZAPPED)) {
1444 err = -EADDRNOTAVAIL;
1445 goto out;
1446 }
1447
1448 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1449 send_sig(SIGPIPE, current, 0);
1450 err = -EPIPE;
1451 goto out;
1452 }
1453
1454 if (ax25->ax25_dev == NULL) {
1455 err = -ENETUNREACH;
1456 goto out;
1457 }
1458
1459 if (len > ax25->ax25_dev->dev->mtu) {
1460 err = -EMSGSIZE;
1461 goto out;
1462 }
1463
1464 if (usax != NULL) {
1465 if (usax->sax25_family != AF_AX25) {
1466 err = -EINVAL;
1467 goto out;
1468 }
1469
1470 if (addr_len == sizeof(struct sockaddr_ax25))
1471 /* ax25_sendmsg(): uses obsolete socket structure */
1472 ;
1473 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1474 /* support for old structure may go away some time
1475 * ax25_sendmsg(): uses old (6 digipeater)
1476 * socket structure.
1477 */
1478 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1479 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1480 err = -EINVAL;
1481 goto out;
1482 }
1483
1484
1485 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1486 int ct = 0;
1487 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1488
1489 /* Valid number of digipeaters ? */
1490 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1491 err = -EINVAL;
1492 goto out;
1493 }
1494
1495 dtmp.ndigi = usax->sax25_ndigis;
1496
1497 while (ct < usax->sax25_ndigis) {
1498 dtmp.repeated[ct] = 0;
1499 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1500 ct++;
1501 }
1502
1503 dtmp.lastrepeat = 0;
1504 }
1505
1506 sax = *usax;
1507 if (sk->sk_type == SOCK_SEQPACKET &&
1508 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1509 err = -EISCONN;
1510 goto out;
1511 }
1512 if (usax->sax25_ndigis == 0)
1513 dp = NULL;
1514 else
1515 dp = &dtmp;
1516 } else {
1517 /*
1518 * FIXME: 1003.1g - if the socket is like this because
1519 * it has become closed (not started closed) and is VC
1520 * we ought to SIGPIPE, EPIPE
1521 */
1522 if (sk->sk_state != TCP_ESTABLISHED) {
1523 err = -ENOTCONN;
1524 goto out;
1525 }
1526 sax.sax25_family = AF_AX25;
1527 sax.sax25_call = ax25->dest_addr;
1528 dp = ax25->digipeat;
1529 }
1530
1531 /* Build a packet */
1532 SOCK_DEBUG(sk, "AX.25: sendto: Addresses built. Building packet.\n");
1533
1534 /* Assume the worst case */
1535 size = len + ax25->ax25_dev->dev->hard_header_len;
1536
1537 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1538 if (skb == NULL)
1539 goto out;
1540
1541 skb_reserve(skb, size - len);
1542
1543 SOCK_DEBUG(sk, "AX.25: Appending user data\n");
1544
1545 /* User data follows immediately after the AX.25 data */
1546 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1547 err = -EFAULT;
1548 kfree_skb(skb);
1549 goto out;
1550 }
1551
1552 skb_reset_network_header(skb);
1553
1554 /* Add the PID if one is not supplied by the user in the skb */
1555 if (!ax25->pidincl)
1556 *skb_push(skb, 1) = sk->sk_protocol;
1557
1558 SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n");
1559
1560 if (sk->sk_type == SOCK_SEQPACKET) {
1561 /* Connected mode sockets go via the LAPB machine */
1562 if (sk->sk_state != TCP_ESTABLISHED) {
1563 kfree_skb(skb);
1564 err = -ENOTCONN;
1565 goto out;
1566 }
1567
1568 /* Shove it onto the queue and kick */
1569 ax25_output(ax25, ax25->paclen, skb);
1570
1571 err = len;
1572 goto out;
1573 }
1574
1575 skb_push(skb, 1 + ax25_addr_size(dp));
1576
1577 SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp);
1578
1579 if (dp != NULL)
1580 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi);
1581
1582 /* Build an AX.25 header */
1583 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1584 dp, AX25_COMMAND, AX25_MODULUS);
1585
1586 SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv);
1587
1588 skb_set_transport_header(skb, lv);
1589
1590 SOCK_DEBUG(sk, "base=%p pos=%p\n",
1591 skb->data, skb_transport_header(skb));
1592
1593 *skb_transport_header(skb) = AX25_UI;
1594
1595 /* Datagram frames go straight out of the door as UI */
1596 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1597
1598 err = len;
1599
1600 out:
1601 release_sock(sk);
1602
1603 return err;
1604 }
1605
1606 static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1607 struct msghdr *msg, size_t size, int flags)
1608 {
1609 struct sock *sk = sock->sk;
1610 struct sk_buff *skb;
1611 int copied;
1612 int err = 0;
1613
1614 lock_sock(sk);
1615 /*
1616 * This works for seqpacket too. The receiver has ordered the
1617 * queue for us! We do one quick check first though
1618 */
1619 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1620 err = -ENOTCONN;
1621 goto out;
1622 }
1623
1624 /* Now we can treat all alike */
1625 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1626 flags & MSG_DONTWAIT, &err);
1627 if (skb == NULL)
1628 goto out;
1629
1630 if (!ax25_sk(sk)->pidincl)
1631 skb_pull(skb, 1); /* Remove PID */
1632
1633 skb_reset_transport_header(skb);
1634 copied = skb->len;
1635
1636 if (copied > size) {
1637 copied = size;
1638 msg->msg_flags |= MSG_TRUNC;
1639 }
1640
1641 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1642
1643 if (msg->msg_namelen != 0) {
1644 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1645 ax25_digi digi;
1646 ax25_address src;
1647 const unsigned char *mac = skb_mac_header(skb);
1648
1649 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1650 &digi, NULL, NULL);
1651 sax->sax25_family = AF_AX25;
1652 /* We set this correctly, even though we may not let the
1653 application know the digi calls further down (because it
1654 did NOT ask to know them). This could get political... **/
1655 sax->sax25_ndigis = digi.ndigi;
1656 sax->sax25_call = src;
1657
1658 if (sax->sax25_ndigis != 0) {
1659 int ct;
1660 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1661
1662 for (ct = 0; ct < digi.ndigi; ct++)
1663 fsa->fsa_digipeater[ct] = digi.calls[ct];
1664 }
1665 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1666 }
1667
1668 skb_free_datagram(sk, skb);
1669 err = copied;
1670
1671 out:
1672 release_sock(sk);
1673
1674 return err;
1675 }
1676
1677 static int ax25_shutdown(struct socket *sk, int how)
1678 {
1679 /* FIXME - generate DM and RNR states */
1680 return -EOPNOTSUPP;
1681 }
1682
1683 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1684 {
1685 struct sock *sk = sock->sk;
1686 void __user *argp = (void __user *)arg;
1687 int res = 0;
1688
1689 lock_sock(sk);
1690 switch (cmd) {
1691 case TIOCOUTQ: {
1692 long amount;
1693
1694 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1695 if (amount < 0)
1696 amount = 0;
1697 res = put_user(amount, (int __user *)argp);
1698 break;
1699 }
1700
1701 case TIOCINQ: {
1702 struct sk_buff *skb;
1703 long amount = 0L;
1704 /* These two are safe on a single CPU system as only user tasks fiddle here */
1705 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1706 amount = skb->len;
1707 res = put_user(amount, (int __user *) argp);
1708 break;
1709 }
1710
1711 case SIOCGSTAMP:
1712 res = sock_get_timestamp(sk, argp);
1713 break;
1714
1715 case SIOCGSTAMPNS:
1716 res = sock_get_timestampns(sk, argp);
1717 break;
1718
1719 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1720 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1721 case SIOCAX25GETUID: {
1722 struct sockaddr_ax25 sax25;
1723 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1724 res = -EFAULT;
1725 break;
1726 }
1727 res = ax25_uid_ioctl(cmd, &sax25);
1728 break;
1729 }
1730
1731 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1732 long amount;
1733 if (!capable(CAP_NET_ADMIN)) {
1734 res = -EPERM;
1735 break;
1736 }
1737 if (get_user(amount, (long __user *)argp)) {
1738 res = -EFAULT;
1739 break;
1740 }
1741 if (amount > AX25_NOUID_BLOCK) {
1742 res = -EINVAL;
1743 break;
1744 }
1745 ax25_uid_policy = amount;
1746 res = 0;
1747 break;
1748 }
1749
1750 case SIOCADDRT:
1751 case SIOCDELRT:
1752 case SIOCAX25OPTRT:
1753 if (!capable(CAP_NET_ADMIN)) {
1754 res = -EPERM;
1755 break;
1756 }
1757 res = ax25_rt_ioctl(cmd, argp);
1758 break;
1759
1760 case SIOCAX25CTLCON:
1761 if (!capable(CAP_NET_ADMIN)) {
1762 res = -EPERM;
1763 break;
1764 }
1765 res = ax25_ctl_ioctl(cmd, argp);
1766 break;
1767
1768 case SIOCAX25GETINFO:
1769 case SIOCAX25GETINFOOLD: {
1770 ax25_cb *ax25 = ax25_sk(sk);
1771 struct ax25_info_struct ax25_info;
1772
1773 ax25_info.t1 = ax25->t1 / HZ;
1774 ax25_info.t2 = ax25->t2 / HZ;
1775 ax25_info.t3 = ax25->t3 / HZ;
1776 ax25_info.idle = ax25->idle / (60 * HZ);
1777 ax25_info.n2 = ax25->n2;
1778 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1779 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1780 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1781 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1782 ax25_info.n2count = ax25->n2count;
1783 ax25_info.state = ax25->state;
1784 ax25_info.rcv_q = sk_rmem_alloc_get(sk);
1785 ax25_info.snd_q = sk_wmem_alloc_get(sk);
1786 ax25_info.vs = ax25->vs;
1787 ax25_info.vr = ax25->vr;
1788 ax25_info.va = ax25->va;
1789 ax25_info.vs_max = ax25->vs; /* reserved */
1790 ax25_info.paclen = ax25->paclen;
1791 ax25_info.window = ax25->window;
1792
1793 /* old structure? */
1794 if (cmd == SIOCAX25GETINFOOLD) {
1795 static int warned = 0;
1796 if (!warned) {
1797 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1798 current->comm);
1799 warned=1;
1800 }
1801
1802 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1803 res = -EFAULT;
1804 break;
1805 }
1806 } else {
1807 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1808 res = -EINVAL;
1809 break;
1810 }
1811 }
1812 res = 0;
1813 break;
1814 }
1815
1816 case SIOCAX25ADDFWD:
1817 case SIOCAX25DELFWD: {
1818 struct ax25_fwd_struct ax25_fwd;
1819 if (!capable(CAP_NET_ADMIN)) {
1820 res = -EPERM;
1821 break;
1822 }
1823 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1824 res = -EFAULT;
1825 break;
1826 }
1827 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1828 break;
1829 }
1830
1831 case SIOCGIFADDR:
1832 case SIOCSIFADDR:
1833 case SIOCGIFDSTADDR:
1834 case SIOCSIFDSTADDR:
1835 case SIOCGIFBRDADDR:
1836 case SIOCSIFBRDADDR:
1837 case SIOCGIFNETMASK:
1838 case SIOCSIFNETMASK:
1839 case SIOCGIFMETRIC:
1840 case SIOCSIFMETRIC:
1841 res = -EINVAL;
1842 break;
1843
1844 default:
1845 res = -ENOIOCTLCMD;
1846 break;
1847 }
1848 release_sock(sk);
1849
1850 return res;
1851 }
1852
1853 #ifdef CONFIG_PROC_FS
1854
1855 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1856 __acquires(ax25_list_lock)
1857 {
1858 struct ax25_cb *ax25;
1859 struct hlist_node *node;
1860 int i = 0;
1861
1862 spin_lock_bh(&ax25_list_lock);
1863 ax25_for_each(ax25, node, &ax25_list) {
1864 if (i == *pos)
1865 return ax25;
1866 ++i;
1867 }
1868 return NULL;
1869 }
1870
1871 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1872 {
1873 ++*pos;
1874
1875 return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1876 struct ax25_cb, ax25_node);
1877 }
1878
1879 static void ax25_info_stop(struct seq_file *seq, void *v)
1880 __releases(ax25_list_lock)
1881 {
1882 spin_unlock_bh(&ax25_list_lock);
1883 }
1884
1885 static int ax25_info_show(struct seq_file *seq, void *v)
1886 {
1887 ax25_cb *ax25 = v;
1888 char buf[11];
1889 int k;
1890
1891
1892 /*
1893 * New format:
1894 * 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
1895 */
1896
1897 seq_printf(seq, "%8.8lx %s %s%s ",
1898 (long) ax25,
1899 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1900 ax2asc(buf, &ax25->source_addr),
1901 ax25->iamdigi? "*":"");
1902 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1903
1904 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1905 seq_printf(seq, ",%s%s",
1906 ax2asc(buf, &ax25->digipeat->calls[k]),
1907 ax25->digipeat->repeated[k]? "*":"");
1908 }
1909
1910 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1911 ax25->state,
1912 ax25->vs, ax25->vr, ax25->va,
1913 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1914 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1915 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1916 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1917 ax25->idle / (60 * HZ),
1918 ax25->n2count, ax25->n2,
1919 ax25->rtt / HZ,
1920 ax25->window,
1921 ax25->paclen);
1922
1923 if (ax25->sk != NULL) {
1924 seq_printf(seq, " %d %d %lu\n",
1925 sk_wmem_alloc_get(ax25->sk),
1926 sk_rmem_alloc_get(ax25->sk),
1927 sock_i_ino(ax25->sk));
1928 } else {
1929 seq_puts(seq, " * * *\n");
1930 }
1931 return 0;
1932 }
1933
1934 static const struct seq_operations ax25_info_seqops = {
1935 .start = ax25_info_start,
1936 .next = ax25_info_next,
1937 .stop = ax25_info_stop,
1938 .show = ax25_info_show,
1939 };
1940
1941 static int ax25_info_open(struct inode *inode, struct file *file)
1942 {
1943 return seq_open(file, &ax25_info_seqops);
1944 }
1945
1946 static const struct file_operations ax25_info_fops = {
1947 .owner = THIS_MODULE,
1948 .open = ax25_info_open,
1949 .read = seq_read,
1950 .llseek = seq_lseek,
1951 .release = seq_release,
1952 };
1953
1954 #endif
1955
1956 static struct net_proto_family ax25_family_ops = {
1957 .family = PF_AX25,
1958 .create = ax25_create,
1959 .owner = THIS_MODULE,
1960 };
1961
1962 static const struct proto_ops ax25_proto_ops = {
1963 .family = PF_AX25,
1964 .owner = THIS_MODULE,
1965 .release = ax25_release,
1966 .bind = ax25_bind,
1967 .connect = ax25_connect,
1968 .socketpair = sock_no_socketpair,
1969 .accept = ax25_accept,
1970 .getname = ax25_getname,
1971 .poll = datagram_poll,
1972 .ioctl = ax25_ioctl,
1973 .listen = ax25_listen,
1974 .shutdown = ax25_shutdown,
1975 .setsockopt = ax25_setsockopt,
1976 .getsockopt = ax25_getsockopt,
1977 .sendmsg = ax25_sendmsg,
1978 .recvmsg = ax25_recvmsg,
1979 .mmap = sock_no_mmap,
1980 .sendpage = sock_no_sendpage,
1981 };
1982
1983 /*
1984 * Called by socket.c on kernel start up
1985 */
1986 static struct packet_type ax25_packet_type __read_mostly = {
1987 .type = cpu_to_be16(ETH_P_AX25),
1988 .func = ax25_kiss_rcv,
1989 };
1990
1991 static struct notifier_block ax25_dev_notifier = {
1992 .notifier_call =ax25_device_event,
1993 };
1994
1995 static int __init ax25_init(void)
1996 {
1997 int rc = proto_register(&ax25_proto, 0);
1998
1999 if (rc != 0)
2000 goto out;
2001
2002 sock_register(&ax25_family_ops);
2003 dev_add_pack(&ax25_packet_type);
2004 register_netdevice_notifier(&ax25_dev_notifier);
2005 ax25_register_sysctl();
2006
2007 proc_net_fops_create(&init_net, "ax25_route", S_IRUGO, &ax25_route_fops);
2008 proc_net_fops_create(&init_net, "ax25", S_IRUGO, &ax25_info_fops);
2009 proc_net_fops_create(&init_net, "ax25_calls", S_IRUGO, &ax25_uid_fops);
2010 out:
2011 return rc;
2012 }
2013 module_init(ax25_init);
2014
2015
2016 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2017 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2018 MODULE_LICENSE("GPL");
2019 MODULE_ALIAS_NETPROTO(PF_AX25);
2020
2021 static void __exit ax25_exit(void)
2022 {
2023 proc_net_remove(&init_net, "ax25_route");
2024 proc_net_remove(&init_net, "ax25");
2025 proc_net_remove(&init_net, "ax25_calls");
2026 ax25_rt_free();
2027 ax25_uid_free();
2028 ax25_dev_free();
2029
2030 ax25_unregister_sysctl();
2031 unregister_netdevice_notifier(&ax25_dev_notifier);
2032
2033 dev_remove_pack(&ax25_packet_type);
2034
2035 sock_unregister(PF_AX25);
2036 proto_unregister(&ax25_proto);
2037 }
2038 module_exit(ax25_exit);
Linux with added FPC-III support