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