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