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