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