File: /usr/src/linux/net/netrom/af_netrom.c
1 /*
2 * NET/ROM release 007
3 *
4 * This code REQUIRES 2.1.15 or higher/ NET3.038
5 *
6 * This module:
7 * This module is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 * History
13 * NET/ROM 001 Jonathan(G4KLX) Cloned from the AX25 code.
14 * NET/ROM 002 Darryl(G7LED) Fixes and address enhancement.
15 * Jonathan(G4KLX) Complete bind re-think.
16 * Alan(GW4PTS) Trivial tweaks into new format.
17 * NET/ROM 003 Jonathan(G4KLX) Added G8BPQ extensions.
18 * Added NET/ROM routing ioctl.
19 * Darryl(G7LED) Fix autobinding (on connect).
20 * Fixed nr_release(), set TCP_CLOSE, wakeup app
21 * context, THEN make the sock dead.
22 * Circuit ID check before allocating it on
23 * a connection.
24 * Alan(GW4PTS) sendmsg/recvmsg only. Fixed connect clear bug
25 * inherited from AX.25
26 * NET/ROM 004 Jonathan(G4KLX) Converted to module.
27 * NET/ROM 005 Jonathan(G4KLX) Linux 2.1
28 * Alan(GW4PTS) Started POSIXisms
29 * NET/ROM 006 Alan(GW4PTS) Brought in line with the ANK changes
30 * Jonathan(G4KLX) Removed hdrincl.
31 * NET/ROM 007 Jonathan(G4KLX) New timer architecture.
32 * Impmented Idle timer.
33 * Arnaldo C. Melo s/suser/capable/, micro cleanups
34 */
35
36 #include <linux/config.h>
37 #include <linux/module.h>
38 #include <linux/errno.h>
39 #include <linux/types.h>
40 #include <linux/socket.h>
41 #include <linux/in.h>
42 #include <linux/kernel.h>
43 #include <linux/sched.h>
44 #include <linux/timer.h>
45 #include <linux/string.h>
46 #include <linux/sockios.h>
47 #include <linux/net.h>
48 #include <linux/stat.h>
49 #include <net/ax25.h>
50 #include <linux/inet.h>
51 #include <linux/netdevice.h>
52 #include <linux/if_arp.h>
53 #include <linux/skbuff.h>
54 #include <net/sock.h>
55 #include <asm/uaccess.h>
56 #include <asm/system.h>
57 #include <linux/fcntl.h>
58 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
59 #include <linux/mm.h>
60 #include <linux/interrupt.h>
61 #include <linux/notifier.h>
62 #include <net/netrom.h>
63 #include <linux/proc_fs.h>
64 #include <net/ip.h>
65 #include <net/arp.h>
66 #include <linux/init.h>
67
68 int nr_ndevs = 4;
69
70 int sysctl_netrom_default_path_quality = NR_DEFAULT_QUAL;
71 int sysctl_netrom_obsolescence_count_initialiser = NR_DEFAULT_OBS;
72 int sysctl_netrom_network_ttl_initialiser = NR_DEFAULT_TTL;
73 int sysctl_netrom_transport_timeout = NR_DEFAULT_T1;
74 int sysctl_netrom_transport_maximum_tries = NR_DEFAULT_N2;
75 int sysctl_netrom_transport_acknowledge_delay = NR_DEFAULT_T2;
76 int sysctl_netrom_transport_busy_delay = NR_DEFAULT_T4;
77 int sysctl_netrom_transport_requested_window_size = NR_DEFAULT_WINDOW;
78 int sysctl_netrom_transport_no_activity_timeout = NR_DEFAULT_IDLE;
79 int sysctl_netrom_routing_control = NR_DEFAULT_ROUTING;
80 int sysctl_netrom_link_fails_count = NR_DEFAULT_FAILS;
81
82 static unsigned short circuit = 0x101;
83
84 static struct sock *volatile nr_list;
85
86 static struct proto_ops nr_proto_ops;
87
88 static void nr_free_sock(struct sock *sk)
89 {
90 sk_free(sk);
91
92 MOD_DEC_USE_COUNT;
93 }
94
95 static struct sock *nr_alloc_sock(void)
96 {
97 struct sock *sk;
98 nr_cb *nr;
99
100 if ((sk = sk_alloc(PF_NETROM, GFP_ATOMIC, 1)) == NULL)
101 return NULL;
102
103 if ((nr = kmalloc(sizeof(*nr), GFP_ATOMIC)) == NULL) {
104 sk_free(sk);
105 return NULL;
106 }
107
108 MOD_INC_USE_COUNT;
109
110 memset(nr, 0x00, sizeof(*nr));
111
112 sk->protinfo.nr = nr;
113 nr->sk = sk;
114
115 return sk;
116 }
117
118 /*
119 * Socket removal during an interrupt is now safe.
120 */
121 static void nr_remove_socket(struct sock *sk)
122 {
123 struct sock *s;
124 unsigned long flags;
125
126 save_flags(flags); cli();
127
128 if ((s = nr_list) == sk) {
129 nr_list = s->next;
130 restore_flags(flags);
131 return;
132 }
133
134 while (s != NULL && s->next != NULL) {
135 if (s->next == sk) {
136 s->next = sk->next;
137 restore_flags(flags);
138 return;
139 }
140
141 s = s->next;
142 }
143
144 restore_flags(flags);
145 }
146
147 /*
148 * Kill all bound sockets on a dropped device.
149 */
150 static void nr_kill_by_device(struct net_device *dev)
151 {
152 struct sock *s;
153
154 for (s = nr_list; s != NULL; s = s->next) {
155 if (s->protinfo.nr->device == dev)
156 nr_disconnect(s, ENETUNREACH);
157 }
158 }
159
160 /*
161 * Handle device status changes.
162 */
163 static int nr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
164 {
165 struct net_device *dev = (struct net_device *)ptr;
166
167 if (event != NETDEV_DOWN)
168 return NOTIFY_DONE;
169
170 nr_kill_by_device(dev);
171 nr_rt_device_down(dev);
172
173 return NOTIFY_DONE;
174 }
175
176 /*
177 * Add a socket to the bound sockets list.
178 */
179 static void nr_insert_socket(struct sock *sk)
180 {
181 unsigned long flags;
182
183 save_flags(flags); cli();
184
185 sk->next = nr_list;
186 nr_list = sk;
187
188 restore_flags(flags);
189 }
190
191 /*
192 * Find a socket that wants to accept the Connect Request we just
193 * received.
194 */
195 static struct sock *nr_find_listener(ax25_address *addr)
196 {
197 unsigned long flags;
198 struct sock *s;
199
200 save_flags(flags);
201 cli();
202
203 for (s = nr_list; s != NULL; s = s->next) {
204 if (ax25cmp(&s->protinfo.nr->source_addr, addr) == 0 && s->state == TCP_LISTEN) {
205 restore_flags(flags);
206 return s;
207 }
208 }
209
210 restore_flags(flags);
211 return NULL;
212 }
213
214 /*
215 * Find a connected NET/ROM socket given my circuit IDs.
216 */
217 static struct sock *nr_find_socket(unsigned char index, unsigned char id)
218 {
219 struct sock *s;
220 unsigned long flags;
221
222 save_flags(flags);
223 cli();
224
225 for (s = nr_list; s != NULL; s = s->next) {
226 if (s->protinfo.nr->my_index == index && s->protinfo.nr->my_id == id) {
227 restore_flags(flags);
228 return s;
229 }
230 }
231
232 restore_flags(flags);
233
234 return NULL;
235 }
236
237 /*
238 * Find a connected NET/ROM socket given their circuit IDs.
239 */
240 static struct sock *nr_find_peer(unsigned char index, unsigned char id, ax25_address *dest)
241 {
242 struct sock *s;
243 unsigned long flags;
244
245 save_flags(flags);
246 cli();
247
248 for (s = nr_list; s != NULL; s = s->next) {
249 if (s->protinfo.nr->your_index == index && s->protinfo.nr->your_id == id && ax25cmp(&s->protinfo.nr->dest_addr, dest) == 0) {
250 restore_flags(flags);
251 return s;
252 }
253 }
254
255 restore_flags(flags);
256
257 return NULL;
258 }
259
260 /*
261 * Find next free circuit ID.
262 */
263 static unsigned short nr_find_next_circuit(void)
264 {
265 unsigned short id = circuit;
266 unsigned char i, j;
267
268 for (;;) {
269 i = id / 256;
270 j = id % 256;
271
272 if (i != 0 && j != 0)
273 if (nr_find_socket(i, j) == NULL)
274 break;
275
276 id++;
277 }
278
279 return id;
280 }
281
282 /*
283 * Deferred destroy.
284 */
285 void nr_destroy_socket(struct sock *);
286
287 /*
288 * Handler for deferred kills.
289 */
290 static void nr_destroy_timer(unsigned long data)
291 {
292 nr_destroy_socket((struct sock *)data);
293 }
294
295 /*
296 * This is called from user mode and the timers. Thus it protects itself against
297 * interrupt users but doesn't worry about being called during work.
298 * Once it is removed from the queue no interrupt or bottom half will
299 * touch it and we are (fairly 8-) ) safe.
300 */
301 void nr_destroy_socket(struct sock *sk) /* Not static as it's used by the timer */
302 {
303 struct sk_buff *skb;
304 unsigned long flags;
305
306 save_flags(flags); cli();
307
308 nr_stop_heartbeat(sk);
309 nr_stop_t1timer(sk);
310 nr_stop_t2timer(sk);
311 nr_stop_t4timer(sk);
312 nr_stop_idletimer(sk);
313
314 nr_remove_socket(sk);
315 nr_clear_queues(sk); /* Flush the queues */
316
317 while ((skb = skb_dequeue(&sk->receive_queue)) != NULL) {
318 if (skb->sk != sk) { /* A pending connection */
319 skb->sk->dead = 1; /* Queue the unaccepted socket for death */
320 nr_start_heartbeat(skb->sk);
321 skb->sk->protinfo.nr->state = NR_STATE_0;
322 }
323
324 kfree_skb(skb);
325 }
326
327 if (atomic_read(&sk->wmem_alloc) != 0 || atomic_read(&sk->rmem_alloc) != 0) {
328 /* Defer: outstanding buffers */
329 init_timer(&sk->timer);
330 sk->timer.expires = jiffies + 10 * HZ;
331 sk->timer.function = nr_destroy_timer;
332 sk->timer.data = (unsigned long)sk;
333 add_timer(&sk->timer);
334 } else {
335 nr_free_sock(sk);
336 }
337
338 restore_flags(flags);
339 }
340
341 /*
342 * Handling for system calls applied via the various interfaces to a
343 * NET/ROM socket object.
344 */
345
346 static int nr_setsockopt(struct socket *sock, int level, int optname,
347 char *optval, int optlen)
348 {
349 struct sock *sk = sock->sk;
350 int opt;
351
352 if (level != SOL_NETROM)
353 return -ENOPROTOOPT;
354
355 if (optlen < sizeof(int))
356 return -EINVAL;
357
358 if (get_user(opt, (int *)optval))
359 return -EFAULT;
360
361 switch (optname) {
362 case NETROM_T1:
363 if (opt < 1)
364 return -EINVAL;
365 sk->protinfo.nr->t1 = opt * HZ;
366 return 0;
367
368 case NETROM_T2:
369 if (opt < 1)
370 return -EINVAL;
371 sk->protinfo.nr->t2 = opt * HZ;
372 return 0;
373
374 case NETROM_N2:
375 if (opt < 1 || opt > 31)
376 return -EINVAL;
377 sk->protinfo.nr->n2 = opt;
378 return 0;
379
380 case NETROM_T4:
381 if (opt < 1)
382 return -EINVAL;
383 sk->protinfo.nr->t4 = opt * HZ;
384 return 0;
385
386 case NETROM_IDLE:
387 if (opt < 0)
388 return -EINVAL;
389 sk->protinfo.nr->idle = opt * 60 * HZ;
390 return 0;
391
392 default:
393 return -ENOPROTOOPT;
394 }
395 }
396
397 static int nr_getsockopt(struct socket *sock, int level, int optname,
398 char *optval, int *optlen)
399 {
400 struct sock *sk = sock->sk;
401 int val = 0;
402 int len;
403
404 if (level != SOL_NETROM)
405 return -ENOPROTOOPT;
406
407 if (get_user(len, optlen))
408 return -EFAULT;
409
410 if (len < 0)
411 return -EINVAL;
412
413 switch (optname) {
414 case NETROM_T1:
415 val = sk->protinfo.nr->t1 / HZ;
416 break;
417
418 case NETROM_T2:
419 val = sk->protinfo.nr->t2 / HZ;
420 break;
421
422 case NETROM_N2:
423 val = sk->protinfo.nr->n2;
424 break;
425
426 case NETROM_T4:
427 val = sk->protinfo.nr->t4 / HZ;
428 break;
429
430 case NETROM_IDLE:
431 val = sk->protinfo.nr->idle / (60 * HZ);
432 break;
433
434 default:
435 return -ENOPROTOOPT;
436 }
437
438 len = min_t(unsigned int, len, sizeof(int));
439
440 if (put_user(len, optlen))
441 return -EFAULT;
442
443 return copy_to_user(optval, &val, len) ? -EFAULT : 0;
444 }
445
446 static int nr_listen(struct socket *sock, int backlog)
447 {
448 struct sock *sk = sock->sk;
449
450 if (sk->state != TCP_LISTEN) {
451 memset(&sk->protinfo.nr->user_addr, '\0', AX25_ADDR_LEN);
452 sk->max_ack_backlog = backlog;
453 sk->state = TCP_LISTEN;
454 return 0;
455 }
456
457 return -EOPNOTSUPP;
458 }
459
460 static int nr_create(struct socket *sock, int protocol)
461 {
462 struct sock *sk;
463 nr_cb *nr;
464
465 if (sock->type != SOCK_SEQPACKET || protocol != 0)
466 return -ESOCKTNOSUPPORT;
467
468 if ((sk = nr_alloc_sock()) == NULL)
469 return -ENOMEM;
470
471 nr = sk->protinfo.nr;
472
473 sock_init_data(sock, sk);
474
475 sock->ops = &nr_proto_ops;
476 sk->protocol = protocol;
477
478 skb_queue_head_init(&nr->ack_queue);
479 skb_queue_head_init(&nr->reseq_queue);
480 skb_queue_head_init(&nr->frag_queue);
481
482 init_timer(&nr->t1timer);
483 init_timer(&nr->t2timer);
484 init_timer(&nr->t4timer);
485 init_timer(&nr->idletimer);
486
487 nr->t1 = sysctl_netrom_transport_timeout;
488 nr->t2 = sysctl_netrom_transport_acknowledge_delay;
489 nr->n2 = sysctl_netrom_transport_maximum_tries;
490 nr->t4 = sysctl_netrom_transport_busy_delay;
491 nr->idle = sysctl_netrom_transport_no_activity_timeout;
492 nr->window = sysctl_netrom_transport_requested_window_size;
493
494 nr->bpqext = 1;
495 nr->state = NR_STATE_0;
496
497 return 0;
498 }
499
500 static struct sock *nr_make_new(struct sock *osk)
501 {
502 struct sock *sk;
503 nr_cb *nr;
504
505 if (osk->type != SOCK_SEQPACKET)
506 return NULL;
507
508 if ((sk = nr_alloc_sock()) == NULL)
509 return NULL;
510
511 nr = sk->protinfo.nr;
512
513 sock_init_data(NULL, sk);
514
515 sk->type = osk->type;
516 sk->socket = osk->socket;
517 sk->priority = osk->priority;
518 sk->protocol = osk->protocol;
519 sk->rcvbuf = osk->rcvbuf;
520 sk->sndbuf = osk->sndbuf;
521 sk->debug = osk->debug;
522 sk->state = TCP_ESTABLISHED;
523 sk->sleep = osk->sleep;
524 sk->zapped = osk->zapped;
525
526 skb_queue_head_init(&nr->ack_queue);
527 skb_queue_head_init(&nr->reseq_queue);
528 skb_queue_head_init(&nr->frag_queue);
529
530 init_timer(&nr->t1timer);
531 init_timer(&nr->t2timer);
532 init_timer(&nr->t4timer);
533 init_timer(&nr->idletimer);
534
535 nr->t1 = osk->protinfo.nr->t1;
536 nr->t2 = osk->protinfo.nr->t2;
537 nr->n2 = osk->protinfo.nr->n2;
538 nr->t4 = osk->protinfo.nr->t4;
539 nr->idle = osk->protinfo.nr->idle;
540 nr->window = osk->protinfo.nr->window;
541
542 nr->device = osk->protinfo.nr->device;
543 nr->bpqext = osk->protinfo.nr->bpqext;
544
545 return sk;
546 }
547
548 static int nr_release(struct socket *sock)
549 {
550 struct sock *sk = sock->sk;
551
552 if (sk == NULL) return 0;
553
554 switch (sk->protinfo.nr->state) {
555
556 case NR_STATE_0:
557 case NR_STATE_1:
558 case NR_STATE_2:
559 nr_disconnect(sk, 0);
560 nr_destroy_socket(sk);
561 break;
562
563 case NR_STATE_3:
564 nr_clear_queues(sk);
565 sk->protinfo.nr->n2count = 0;
566 nr_write_internal(sk, NR_DISCREQ);
567 nr_start_t1timer(sk);
568 nr_stop_t2timer(sk);
569 nr_stop_t4timer(sk);
570 nr_stop_idletimer(sk);
571 sk->protinfo.nr->state = NR_STATE_2;
572 sk->state = TCP_CLOSE;
573 sk->shutdown |= SEND_SHUTDOWN;
574 sk->state_change(sk);
575 sk->dead = 1;
576 sk->destroy = 1;
577 sk->socket = NULL;
578 break;
579
580 default:
581 sk->socket = NULL;
582 break;
583 }
584
585 sock->sk = NULL;
586
587 return 0;
588 }
589
590 static int nr_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
591 {
592 struct sock *sk = sock->sk;
593 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
594 struct net_device *dev;
595 ax25_address *user, *source;
596
597 if (sk->zapped == 0)
598 return -EINVAL;
599
600 if (addr_len < sizeof(struct sockaddr_ax25) || addr_len > sizeof(struct
601 full_sockaddr_ax25))
602 return -EINVAL;
603
604 if (addr_len < (addr->fsa_ax25.sax25_ndigis * sizeof(ax25_address) + sizeof(struct sockaddr_ax25)))
605 return -EINVAL;
606
607 if (addr->fsa_ax25.sax25_family != AF_NETROM)
608 return -EINVAL;
609
610 if ((dev = nr_dev_get(&addr->fsa_ax25.sax25_call)) == NULL) {
611 SOCK_DEBUG(sk, "NET/ROM: bind failed: invalid node callsign\n");
612 return -EADDRNOTAVAIL;
613 }
614
615 /*
616 * Only the super user can set an arbitrary user callsign.
617 */
618 if (addr->fsa_ax25.sax25_ndigis == 1) {
619 if (!capable(CAP_NET_BIND_SERVICE))
620 return -EACCES;
621 sk->protinfo.nr->user_addr = addr->fsa_digipeater[0];
622 sk->protinfo.nr->source_addr = addr->fsa_ax25.sax25_call;
623 } else {
624 source = &addr->fsa_ax25.sax25_call;
625
626 if ((user = ax25_findbyuid(current->euid)) == NULL) {
627 if (ax25_uid_policy && !capable(CAP_NET_BIND_SERVICE))
628 return -EPERM;
629 user = source;
630 }
631
632 sk->protinfo.nr->user_addr = *user;
633 sk->protinfo.nr->source_addr = *source;
634 }
635
636 sk->protinfo.nr->device = dev;
637 nr_insert_socket(sk);
638
639 sk->zapped = 0;
640 SOCK_DEBUG(sk, "NET/ROM: socket is bound\n");
641 return 0;
642 }
643
644 static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
645 int addr_len, int flags)
646 {
647 struct sock *sk = sock->sk;
648 struct sockaddr_ax25 *addr = (struct sockaddr_ax25 *)uaddr;
649 ax25_address *user, *source = NULL;
650 struct net_device *dev;
651
652 if (sk->state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
653 sock->state = SS_CONNECTED;
654 return 0; /* Connect completed during a ERESTARTSYS event */
655 }
656
657 if (sk->state == TCP_CLOSE && sock->state == SS_CONNECTING) {
658 sock->state = SS_UNCONNECTED;
659 return -ECONNREFUSED;
660 }
661
662 if (sk->state == TCP_ESTABLISHED)
663 return -EISCONN; /* No reconnect on a seqpacket socket */
664
665 sk->state = TCP_CLOSE;
666 sock->state = SS_UNCONNECTED;
667
668 if (addr_len != sizeof(struct sockaddr_ax25) && addr_len != sizeof(struct full_sockaddr_ax25))
669 return -EINVAL;
670
671 if (addr->sax25_family != AF_NETROM)
672 return -EINVAL;
673
674 if (sk->zapped) { /* Must bind first - autobinding in this may or may not work */
675 sk->zapped = 0;
676
677 if ((dev = nr_dev_first()) == NULL)
678 return -ENETUNREACH;
679
680 source = (ax25_address *)dev->dev_addr;
681
682 if ((user = ax25_findbyuid(current->euid)) == NULL) {
683 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
684 return -EPERM;
685 user = source;
686 }
687
688 sk->protinfo.nr->user_addr = *user;
689 sk->protinfo.nr->source_addr = *source;
690 sk->protinfo.nr->device = dev;
691
692 nr_insert_socket(sk); /* Finish the bind */
693 }
694
695 sk->protinfo.nr->dest_addr = addr->sax25_call;
696
697 circuit = nr_find_next_circuit();
698
699 sk->protinfo.nr->my_index = circuit / 256;
700 sk->protinfo.nr->my_id = circuit % 256;
701
702 circuit++;
703
704 /* Move to connecting socket, start sending Connect Requests */
705 sock->state = SS_CONNECTING;
706 sk->state = TCP_SYN_SENT;
707
708 nr_establish_data_link(sk);
709
710 sk->protinfo.nr->state = NR_STATE_1;
711
712 nr_start_heartbeat(sk);
713
714 /* Now the loop */
715 if (sk->state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
716 return -EINPROGRESS;
717
718 cli(); /* To avoid races on the sleep */
719
720 /*
721 * A Connect Ack with Choke or timeout or failed routing will go to closed.
722 */
723 while (sk->state == TCP_SYN_SENT) {
724 interruptible_sleep_on(sk->sleep);
725 if (signal_pending(current)) {
726 sti();
727 return -ERESTARTSYS;
728 }
729 }
730
731 if (sk->state != TCP_ESTABLISHED) {
732 sti();
733 sock->state = SS_UNCONNECTED;
734 return sock_error(sk); /* Always set at this point */
735 }
736
737 sock->state = SS_CONNECTED;
738
739 sti();
740
741 return 0;
742 }
743
744 static int nr_accept(struct socket *sock, struct socket *newsock, int flags)
745 {
746 struct sock *sk;
747 struct sock *newsk;
748 struct sk_buff *skb;
749
750 if ((sk = sock->sk) == NULL)
751 return -EINVAL;
752
753 if (sk->type != SOCK_SEQPACKET)
754 return -EOPNOTSUPP;
755
756 if (sk->state != TCP_LISTEN)
757 return -EINVAL;
758
759 /*
760 * The write queue this time is holding sockets ready to use
761 * hooked into the SABM we saved
762 */
763 do {
764 cli();
765 if ((skb = skb_dequeue(&sk->receive_queue)) == NULL) {
766 if (flags & O_NONBLOCK) {
767 sti();
768 return -EWOULDBLOCK;
769 }
770 interruptible_sleep_on(sk->sleep);
771 if (signal_pending(current)) {
772 sti();
773 return -ERESTARTSYS;
774 }
775 }
776 } while (skb == NULL);
777
778 newsk = skb->sk;
779 newsk->pair = NULL;
780 newsk->socket = newsock;
781 newsk->sleep = &newsock->wait;
782 sti();
783
784 /* Now attach up the new socket */
785 kfree_skb(skb);
786 sk->ack_backlog--;
787 newsock->sk = newsk;
788
789 return 0;
790 }
791
792 static int nr_getname(struct socket *sock, struct sockaddr *uaddr,
793 int *uaddr_len, int peer)
794 {
795 struct full_sockaddr_ax25 *sax = (struct full_sockaddr_ax25 *)uaddr;
796 struct sock *sk = sock->sk;
797
798 if (peer != 0) {
799 if (sk->state != TCP_ESTABLISHED)
800 return -ENOTCONN;
801 sax->fsa_ax25.sax25_family = AF_NETROM;
802 sax->fsa_ax25.sax25_ndigis = 1;
803 sax->fsa_ax25.sax25_call = sk->protinfo.nr->user_addr;
804 sax->fsa_digipeater[0] = sk->protinfo.nr->dest_addr;
805 *uaddr_len = sizeof(struct full_sockaddr_ax25);
806 } else {
807 sax->fsa_ax25.sax25_family = AF_NETROM;
808 sax->fsa_ax25.sax25_ndigis = 0;
809 sax->fsa_ax25.sax25_call = sk->protinfo.nr->source_addr;
810 *uaddr_len = sizeof(struct sockaddr_ax25);
811 }
812
813 return 0;
814 }
815
816 int nr_rx_frame(struct sk_buff *skb, struct net_device *dev)
817 {
818 struct sock *sk;
819 struct sock *make;
820 ax25_address *src, *dest, *user;
821 unsigned short circuit_index, circuit_id;
822 unsigned short peer_circuit_index, peer_circuit_id;
823 unsigned short frametype, flags, window, timeout;
824
825 skb->sk = NULL; /* Initially we don't know who it's for */
826
827 /*
828 * skb->data points to the netrom frame start
829 */
830
831 src = (ax25_address *)(skb->data + 0);
832 dest = (ax25_address *)(skb->data + 7);
833
834 circuit_index = skb->data[15];
835 circuit_id = skb->data[16];
836 peer_circuit_index = skb->data[17];
837 peer_circuit_id = skb->data[18];
838 frametype = skb->data[19] & 0x0F;
839 flags = skb->data[19] & 0xF0;
840
841 #ifdef CONFIG_INET
842 /*
843 * Check for an incoming IP over NET/ROM frame.
844 */
845 if (frametype == NR_PROTOEXT && circuit_index == NR_PROTO_IP && circuit_id == NR_PROTO_IP) {
846 skb_pull(skb, NR_NETWORK_LEN + NR_TRANSPORT_LEN);
847 skb->h.raw = skb->data;
848
849 return nr_rx_ip(skb, dev);
850 }
851 #endif
852
853 /*
854 * Find an existing socket connection, based on circuit ID, if it's
855 * a Connect Request base it on their circuit ID.
856 *
857 * Circuit ID 0/0 is not valid but it could still be a "reset" for a
858 * circuit that no longer exists at the other end ...
859 */
860
861 sk = NULL;
862
863 if (circuit_index == 0 && circuit_id == 0) {
864 if (frametype == NR_CONNACK && flags == NR_CHOKE_FLAG)
865 sk = nr_find_peer(peer_circuit_index, peer_circuit_id, src);
866 } else {
867 if (frametype == NR_CONNREQ)
868 sk = nr_find_peer(circuit_index, circuit_id, src);
869 else
870 sk = nr_find_socket(circuit_index, circuit_id);
871 }
872
873 if (sk != NULL) {
874 skb->h.raw = skb->data;
875
876 if (frametype == NR_CONNACK && skb->len == 22)
877 sk->protinfo.nr->bpqext = 1;
878 else
879 sk->protinfo.nr->bpqext = 0;
880
881 return nr_process_rx_frame(sk, skb);
882 }
883
884 /*
885 * Now it should be a CONNREQ.
886 */
887 if (frametype != NR_CONNREQ) {
888 /*
889 * Here it would be nice to be able to send a reset but
890 * NET/ROM doesn't have one. The following hack would
891 * have been a way to extend the protocol but apparently
892 * it kills BPQ boxes... :-(
893 */
894 #if 0
895 /*
896 * Never reply to a CONNACK/CHOKE.
897 */
898 if (frametype != NR_CONNACK || flags != NR_CHOKE_FLAG)
899 nr_transmit_refusal(skb, 1);
900 #endif
901 return 0;
902 }
903
904 sk = nr_find_listener(dest);
905
906 user = (ax25_address *)(skb->data + 21);
907
908 if (sk == NULL || sk->ack_backlog == sk->max_ack_backlog || (make = nr_make_new(sk)) == NULL) {
909 nr_transmit_refusal(skb, 0);
910 return 0;
911 }
912
913 window = skb->data[20];
914
915 skb->sk = make;
916 make->state = TCP_ESTABLISHED;
917
918 /* Fill in his circuit details */
919 make->protinfo.nr->source_addr = *dest;
920 make->protinfo.nr->dest_addr = *src;
921 make->protinfo.nr->user_addr = *user;
922
923 make->protinfo.nr->your_index = circuit_index;
924 make->protinfo.nr->your_id = circuit_id;
925
926 circuit = nr_find_next_circuit();
927
928 make->protinfo.nr->my_index = circuit / 256;
929 make->protinfo.nr->my_id = circuit % 256;
930
931 circuit++;
932
933 /* Window negotiation */
934 if (window < make->protinfo.nr->window)
935 make->protinfo.nr->window = window;
936
937 /* L4 timeout negotiation */
938 if (skb->len == 37) {
939 timeout = skb->data[36] * 256 + skb->data[35];
940 if (timeout * HZ < make->protinfo.nr->t1)
941 make->protinfo.nr->t1 = timeout * HZ;
942 make->protinfo.nr->bpqext = 1;
943 } else {
944 make->protinfo.nr->bpqext = 0;
945 }
946
947 nr_write_internal(make, NR_CONNACK);
948
949 make->protinfo.nr->condition = 0x00;
950 make->protinfo.nr->vs = 0;
951 make->protinfo.nr->va = 0;
952 make->protinfo.nr->vr = 0;
953 make->protinfo.nr->vl = 0;
954 make->protinfo.nr->state = NR_STATE_3;
955 sk->ack_backlog++;
956 make->pair = sk;
957
958 nr_insert_socket(make);
959
960 skb_queue_head(&sk->receive_queue, skb);
961
962 nr_start_heartbeat(make);
963 nr_start_idletimer(make);
964
965 if (!sk->dead)
966 sk->data_ready(sk, skb->len);
967
968 return 1;
969 }
970
971 static int nr_sendmsg(struct socket *sock, struct msghdr *msg, int len, struct scm_cookie *scm)
972 {
973 struct sock *sk = sock->sk;
974 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
975 int err;
976 struct sockaddr_ax25 sax;
977 struct sk_buff *skb;
978 unsigned char *asmptr;
979 int size;
980
981 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR))
982 return -EINVAL;
983
984 if (sk->zapped)
985 return -EADDRNOTAVAIL;
986
987 if (sk->shutdown & SEND_SHUTDOWN) {
988 send_sig(SIGPIPE, current, 0);
989 return -EPIPE;
990 }
991
992 if (sk->protinfo.nr->device == NULL)
993 return -ENETUNREACH;
994
995 if (usax) {
996 if (msg->msg_namelen < sizeof(sax))
997 return -EINVAL;
998 sax = *usax;
999 if (ax25cmp(&sk->protinfo.nr->dest_addr, &sax.sax25_call) != 0)
1000 return -EISCONN;
1001 if (sax.sax25_family != AF_NETROM)
1002 return -EINVAL;
1003 } else {
1004 if (sk->state != TCP_ESTABLISHED)
1005 return -ENOTCONN;
1006 sax.sax25_family = AF_NETROM;
1007 sax.sax25_call = sk->protinfo.nr->dest_addr;
1008 }
1009
1010 SOCK_DEBUG(sk, "NET/ROM: sendto: Addresses built.\n");
1011
1012 /* Build a packet */
1013 SOCK_DEBUG(sk, "NET/ROM: sendto: building packet.\n");
1014 size = len + AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + NR_NETWORK_LEN + NR_TRANSPORT_LEN;
1015
1016 if ((skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT, &err)) == NULL)
1017 return err;
1018
1019 skb_reserve(skb, size - len);
1020
1021 /*
1022 * Push down the NET/ROM header
1023 */
1024
1025 asmptr = skb_push(skb, NR_TRANSPORT_LEN);
1026 SOCK_DEBUG(sk, "Building NET/ROM Header.\n");
1027
1028 /* Build a NET/ROM Transport header */
1029
1030 *asmptr++ = sk->protinfo.nr->your_index;
1031 *asmptr++ = sk->protinfo.nr->your_id;
1032 *asmptr++ = 0; /* To be filled in later */
1033 *asmptr++ = 0; /* Ditto */
1034 *asmptr++ = NR_INFO;
1035 SOCK_DEBUG(sk, "Built header.\n");
1036
1037 /*
1038 * Put the data on the end
1039 */
1040
1041 skb->h.raw = skb_put(skb, len);
1042
1043 asmptr = skb->h.raw;
1044 SOCK_DEBUG(sk, "NET/ROM: Appending user data\n");
1045
1046 /* User data follows immediately after the NET/ROM transport header */
1047 memcpy_fromiovec(asmptr, msg->msg_iov, len);
1048 SOCK_DEBUG(sk, "NET/ROM: Transmitting buffer\n");
1049
1050 if (sk->state != TCP_ESTABLISHED) {
1051 kfree_skb(skb);
1052 return -ENOTCONN;
1053 }
1054
1055 nr_output(sk, skb); /* Shove it onto the queue */
1056
1057 return len;
1058 }
1059
1060 static int nr_recvmsg(struct socket *sock, struct msghdr *msg, int size,
1061 int flags, struct scm_cookie *scm)
1062 {
1063 struct sock *sk = sock->sk;
1064 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1065 int copied;
1066 struct sk_buff *skb;
1067 int er;
1068
1069 /*
1070 * This works for seqpacket too. The receiver has ordered the queue for
1071 * us! We do one quick check first though
1072 */
1073
1074 if (sk->state != TCP_ESTABLISHED)
1075 return -ENOTCONN;
1076
1077 /* Now we can treat all alike */
1078 if ((skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, flags & MSG_DONTWAIT, &er)) == NULL)
1079 return er;
1080
1081 skb->h.raw = skb->data;
1082 copied = skb->len;
1083
1084 if (copied > size) {
1085 copied = size;
1086 msg->msg_flags |= MSG_TRUNC;
1087 }
1088
1089 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1090
1091 if (sax != NULL) {
1092 sax->sax25_family = AF_NETROM;
1093 memcpy(sax->sax25_call.ax25_call, skb->data + 7, AX25_ADDR_LEN);
1094 }
1095
1096 msg->msg_namelen = sizeof(*sax);
1097
1098 skb_free_datagram(sk, skb);
1099
1100 return copied;
1101 }
1102
1103
1104 static int nr_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1105 {
1106 struct sock *sk = sock->sk;
1107
1108 switch (cmd) {
1109 case TIOCOUTQ: {
1110 long amount;
1111 amount = sk->sndbuf - atomic_read(&sk->wmem_alloc);
1112 if (amount < 0)
1113 amount = 0;
1114 return put_user(amount, (int *)arg);
1115 }
1116
1117 case TIOCINQ: {
1118 struct sk_buff *skb;
1119 long amount = 0L;
1120 /* These two are safe on a single CPU system as only user tasks fiddle here */
1121 if ((skb = skb_peek(&sk->receive_queue)) != NULL)
1122 amount = skb->len;
1123 return put_user(amount, (int *)arg);
1124 }
1125
1126 case SIOCGSTAMP:
1127 if (sk != NULL) {
1128 if (sk->stamp.tv_sec == 0)
1129 return -ENOENT;
1130 return copy_to_user((void *)arg, &sk->stamp, sizeof(struct timeval)) ? -EFAULT : 0;
1131 }
1132 return -EINVAL;
1133
1134 case SIOCGIFADDR:
1135 case SIOCSIFADDR:
1136 case SIOCGIFDSTADDR:
1137 case SIOCSIFDSTADDR:
1138 case SIOCGIFBRDADDR:
1139 case SIOCSIFBRDADDR:
1140 case SIOCGIFNETMASK:
1141 case SIOCSIFNETMASK:
1142 case SIOCGIFMETRIC:
1143 case SIOCSIFMETRIC:
1144 return -EINVAL;
1145
1146 case SIOCADDRT:
1147 case SIOCDELRT:
1148 case SIOCNRDECOBS:
1149 if (!capable(CAP_NET_ADMIN)) return -EPERM;
1150 return nr_rt_ioctl(cmd, (void *)arg);
1151
1152 default:
1153 return dev_ioctl(cmd, (void *)arg);
1154 }
1155
1156 /*NOTREACHED*/
1157 return 0;
1158 }
1159
1160 static int nr_get_info(char *buffer, char **start, off_t offset, int length)
1161 {
1162 struct sock *s;
1163 struct net_device *dev;
1164 const char *devname;
1165 int len = 0;
1166 off_t pos = 0;
1167 off_t begin = 0;
1168
1169 cli();
1170
1171 len += sprintf(buffer, "user_addr dest_node src_node dev my your st vs vr va t1 t2 t4 idle n2 wnd Snd-Q Rcv-Q inode\n");
1172
1173 for (s = nr_list; s != NULL; s = s->next) {
1174 if ((dev = s->protinfo.nr->device) == NULL)
1175 devname = "???";
1176 else
1177 devname = dev->name;
1178
1179 len += sprintf(buffer + len, "%-9s ",
1180 ax2asc(&s->protinfo.nr->user_addr));
1181 len += sprintf(buffer + len, "%-9s ",
1182 ax2asc(&s->protinfo.nr->dest_addr));
1183 len += sprintf(buffer + len, "%-9s %-3s %02X/%02X %02X/%02X %2d %3d %3d %3d %3lu/%03lu %2lu/%02lu %3lu/%03lu %3lu/%03lu %2d/%02d %3d %5d %5d %ld\n",
1184 ax2asc(&s->protinfo.nr->source_addr),
1185 devname,
1186 s->protinfo.nr->my_index,
1187 s->protinfo.nr->my_id,
1188 s->protinfo.nr->your_index,
1189 s->protinfo.nr->your_id,
1190 s->protinfo.nr->state,
1191 s->protinfo.nr->vs,
1192 s->protinfo.nr->vr,
1193 s->protinfo.nr->va,
1194 ax25_display_timer(&s->protinfo.nr->t1timer) / HZ,
1195 s->protinfo.nr->t1 / HZ,
1196 ax25_display_timer(&s->protinfo.nr->t2timer) / HZ,
1197 s->protinfo.nr->t2 / HZ,
1198 ax25_display_timer(&s->protinfo.nr->t4timer) / HZ,
1199 s->protinfo.nr->t4 / HZ,
1200 ax25_display_timer(&s->protinfo.nr->idletimer) / (60 * HZ),
1201 s->protinfo.nr->idle / (60 * HZ),
1202 s->protinfo.nr->n2count,
1203 s->protinfo.nr->n2,
1204 s->protinfo.nr->window,
1205 atomic_read(&s->wmem_alloc),
1206 atomic_read(&s->rmem_alloc),
1207 s->socket != NULL ? s->socket->inode->i_ino : 0L);
1208
1209 pos = begin + len;
1210
1211 if (pos < offset) {
1212 len = 0;
1213 begin = pos;
1214 }
1215
1216 if (pos > offset + length)
1217 break;
1218 }
1219
1220 sti();
1221
1222 *start = buffer + (offset - begin);
1223 len -= (offset - begin);
1224
1225 if (len > length) len = length;
1226
1227 return(len);
1228 }
1229
1230 static struct net_proto_family nr_family_ops = {
1231 family: PF_NETROM,
1232 create: nr_create,
1233 };
1234
1235 static struct proto_ops SOCKOPS_WRAPPED(nr_proto_ops) = {
1236 family: PF_NETROM,
1237
1238 release: nr_release,
1239 bind: nr_bind,
1240 connect: nr_connect,
1241 socketpair: sock_no_socketpair,
1242 accept: nr_accept,
1243 getname: nr_getname,
1244 poll: datagram_poll,
1245 ioctl: nr_ioctl,
1246 listen: nr_listen,
1247 shutdown: sock_no_shutdown,
1248 setsockopt: nr_setsockopt,
1249 getsockopt: nr_getsockopt,
1250 sendmsg: nr_sendmsg,
1251 recvmsg: nr_recvmsg,
1252 mmap: sock_no_mmap,
1253 sendpage: sock_no_sendpage,
1254 };
1255
1256 #include <linux/smp_lock.h>
1257 SOCKOPS_WRAP(nr_proto, PF_NETROM);
1258
1259 static struct notifier_block nr_dev_notifier = {
1260 notifier_call: nr_device_event,
1261 };
1262
1263 static struct net_device *dev_nr;
1264
1265 static char banner[] __initdata = KERN_INFO "G4KLX NET/ROM for Linux. Version 0.7 for AX25.037 Linux 2.4\n";
1266
1267 static int __init nr_proto_init(void)
1268 {
1269 int i;
1270
1271 if (nr_ndevs > 0x7fffffff/sizeof(struct net_device)) {
1272 printk(KERN_ERR "NET/ROM: nr_proto_init - nr_ndevs parameter to large\n");
1273 return -1;
1274 }
1275
1276 if ((dev_nr = kmalloc(nr_ndevs * sizeof(struct net_device), GFP_KERNEL)) == NULL) {
1277 printk(KERN_ERR "NET/ROM: nr_proto_init - unable to allocate device structure\n");
1278 return -1;
1279 }
1280
1281 memset(dev_nr, 0x00, nr_ndevs * sizeof(struct net_device));
1282
1283 for (i = 0; i < nr_ndevs; i++) {
1284 sprintf(dev_nr[i].name, "nr%d", i);
1285 dev_nr[i].init = nr_init;
1286 register_netdev(&dev_nr[i]);
1287 }
1288
1289 sock_register(&nr_family_ops);
1290 register_netdevice_notifier(&nr_dev_notifier);
1291 printk(banner);
1292
1293 ax25_protocol_register(AX25_P_NETROM, nr_route_frame);
1294 ax25_linkfail_register(nr_link_failed);
1295
1296 #ifdef CONFIG_SYSCTL
1297 nr_register_sysctl();
1298 #endif
1299
1300 nr_loopback_init();
1301
1302 proc_net_create("nr", 0, nr_get_info);
1303 proc_net_create("nr_neigh", 0, nr_neigh_get_info);
1304 proc_net_create("nr_nodes", 0, nr_nodes_get_info);
1305 return 0;
1306 }
1307
1308 module_init(nr_proto_init);
1309
1310
1311 EXPORT_NO_SYMBOLS;
1312
1313 MODULE_PARM(nr_ndevs, "i");
1314 MODULE_PARM_DESC(nr_ndevs, "number of NET/ROM devices");
1315
1316 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
1317 MODULE_DESCRIPTION("The amateur radio NET/ROM network and transport layer protocol");
1318
1319 static void __exit nr_exit(void)
1320 {
1321 int i;
1322
1323 proc_net_remove("nr");
1324 proc_net_remove("nr_neigh");
1325 proc_net_remove("nr_nodes");
1326 nr_loopback_clear();
1327
1328 nr_rt_free();
1329
1330 ax25_protocol_release(AX25_P_NETROM);
1331 ax25_linkfail_release(nr_link_failed);
1332
1333 unregister_netdevice_notifier(&nr_dev_notifier);
1334
1335 #ifdef CONFIG_SYSCTL
1336 nr_unregister_sysctl();
1337 #endif
1338 sock_unregister(PF_NETROM);
1339
1340 for (i = 0; i < nr_ndevs; i++) {
1341 if (dev_nr[i].priv != NULL) {
1342 kfree(dev_nr[i].priv);
1343 dev_nr[i].priv = NULL;
1344 unregister_netdev(&dev_nr[i]);
1345 }
1346 kfree(dev_nr[i].name);
1347 }
1348
1349 kfree(dev_nr);
1350 }
1351 module_exit(nr_exit);
1352