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