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