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