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 switch (optname) {
411 case NETROM_T1:
412 val = sk->protinfo.nr->t1 / HZ;
413 break;
414
415 case NETROM_T2:
416 val = sk->protinfo.nr->t2 / HZ;
417 break;
418
419 case NETROM_N2:
420 val = sk->protinfo.nr->n2;
421 break;
422
423 case NETROM_T4:
424 val = sk->protinfo.nr->t4 / HZ;
425 break;
426
427 case NETROM_IDLE:
428 val = sk->protinfo.nr->idle / (60 * HZ);
429 break;
430
431 default:
432 return -ENOPROTOOPT;
433 }
434
435 len = min(len, sizeof(int));
436
437 if (put_user(len, optlen))
438 return -EFAULT;
439
440 return copy_to_user(optval, &val, len) ? -EFAULT : 0;
441 }
442
443 static int nr_listen(struct socket *sock, int backlog)
444 {
445 struct sock *sk = sock->sk;
446
447 if (sk->state != TCP_LISTEN) {
448 memset(&sk->protinfo.nr->user_addr, '\0', AX25_ADDR_LEN);
449 sk->max_ack_backlog = backlog;
450 sk->state = TCP_LISTEN;
451 return 0;
452 }
453
454 return -EOPNOTSUPP;
455 }
456
457 static int nr_create(struct socket *sock, int protocol)
458 {
459 struct sock *sk;
460 nr_cb *nr;
461
462 if (sock->type != SOCK_SEQPACKET || protocol != 0)
463 return -ESOCKTNOSUPPORT;
464
465 if ((sk = nr_alloc_sock()) == NULL)
466 return -ENOMEM;
467
468 nr = sk->protinfo.nr;
469
470 sock_init_data(sock, sk);
471
472 sock->ops = &nr_proto_ops;
473 sk->protocol = protocol;
474
475 skb_queue_head_init(&nr->ack_queue);
476 skb_queue_head_init(&nr->reseq_queue);
477 skb_queue_head_init(&nr->frag_queue);
478
479 init_timer(&nr->t1timer);
480 init_timer(&nr->t2timer);
481 init_timer(&nr->t4timer);
482 init_timer(&nr->idletimer);
483
484 nr->t1 = sysctl_netrom_transport_timeout;
485 nr->t2 = sysctl_netrom_transport_acknowledge_delay;
486 nr->n2 = sysctl_netrom_transport_maximum_tries;
487 nr->t4 = sysctl_netrom_transport_busy_delay;
488 nr->idle = sysctl_netrom_transport_no_activity_timeout;
489 nr->window = sysctl_netrom_transport_requested_window_size;
490
491 nr->bpqext = 1;
492 nr->state = NR_STATE_0;
493
494 return 0;
495 }
496
497 static struct sock *nr_make_new(struct sock *osk)
498 {
499 struct sock *sk;
500 nr_cb *nr;
501
502 if (osk->type != SOCK_SEQPACKET)
503 return NULL;
504
505 if ((sk = nr_alloc_sock()) == NULL)
506 return NULL;
507
508 nr = sk->protinfo.nr;
509
510 sock_init_data(NULL, sk);
511
512 sk->type = osk->type;
513 sk->socket = osk->socket;
514 sk->priority = osk->priority;
515 sk->protocol = osk->protocol;
516 sk->rcvbuf = osk->rcvbuf;
517 sk->sndbuf = osk->sndbuf;
518 sk->debug = osk->debug;
519 sk->state = TCP_ESTABLISHED;
520 sk->sleep = osk->sleep;
521 sk->zapped = osk->zapped;
522
523 skb_queue_head_init(&nr->ack_queue);
524 skb_queue_head_init(&nr->reseq_queue);
525 skb_queue_head_init(&nr->frag_queue);
526
527 init_timer(&nr->t1timer);
528 init_timer(&nr->t2timer);
529 init_timer(&nr->t4timer);
530 init_timer(&nr->idletimer);
531
532 nr->t1 = osk->protinfo.nr->t1;
533 nr->t2 = osk->protinfo.nr->t2;
534 nr->n2 = osk->protinfo.nr->n2;
535 nr->t4 = osk->protinfo.nr->t4;
536 nr->idle = osk->protinfo.nr->idle;
537 nr->window = osk->protinfo.nr->window;
538
539 nr->device = osk->protinfo.nr->device;
540 nr->bpqext = osk->protinfo.nr->bpqext;
541
542 return sk;
543 }
544
545 static int nr_release(struct socket *sock)
546 {
547 struct sock *sk = sock->sk;
548
549 if (sk == NULL) return 0;
550
551 switch (sk->protinfo.nr->state) {
552
553 case NR_STATE_0:
554 case NR_STATE_1:
555 case NR_STATE_2:
556 nr_disconnect(sk, 0);
557 nr_destroy_socket(sk);
558 break;
559
560 case NR_STATE_3:
561 nr_clear_queues(sk);
562 sk->protinfo.nr->n2count = 0;
563 nr_write_internal(sk, NR_DISCREQ);
564 nr_start_t1timer(sk);
565 nr_stop_t2timer(sk);
566 nr_stop_t4timer(sk);
567 nr_stop_idletimer(sk);
568 sk->protinfo.nr->state = NR_STATE_2;
569 sk->state = TCP_CLOSE;
570 sk->shutdown |= SEND_SHUTDOWN;
571 sk->state_change(sk);
572 sk->dead = 1;
573 sk->destroy = 1;
574 sk->socket = NULL;
575 break;
576
577 default:
578 sk->socket = NULL;
579 break;
580 }
581
582 sock->sk = NULL;
583
584 return 0;
585 }
586
587 static int nr_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
588 {
589 struct sock *sk = sock->sk;
590 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
591 struct net_device *dev;
592 ax25_address *user, *source;
593
594 if (sk->zapped == 0)
595 return -EINVAL;
596
597 if (addr_len < sizeof(struct sockaddr_ax25) || addr_len > sizeof(struct
598 full_sockaddr_ax25))
599 return -EINVAL;
600
601 if (addr_len < (addr->fsa_ax25.sax25_ndigis * sizeof(ax25_address) + sizeof(struct sockaddr_ax25)))
602 return -EINVAL;
603
604 if (addr->fsa_ax25.sax25_family != AF_NETROM)
605 return -EINVAL;
606
607 if ((dev = nr_dev_get(&addr->fsa_ax25.sax25_call)) == NULL) {
608 SOCK_DEBUG(sk, "NET/ROM: bind failed: invalid node callsign\n");
609 return -EADDRNOTAVAIL;
610 }
611
612 /*
613 * Only the super user can set an arbitrary user callsign.
614 */
615 if (addr->fsa_ax25.sax25_ndigis == 1) {
616 if (!capable(CAP_NET_BIND_SERVICE))
617 return -EACCES;
618 sk->protinfo.nr->user_addr = addr->fsa_digipeater[0];
619 sk->protinfo.nr->source_addr = addr->fsa_ax25.sax25_call;
620 } else {
621 source = &addr->fsa_ax25.sax25_call;
622
623 if ((user = ax25_findbyuid(current->euid)) == NULL) {
624 if (ax25_uid_policy && !capable(CAP_NET_BIND_SERVICE))
625 return -EPERM;
626 user = source;
627 }
628
629 sk->protinfo.nr->user_addr = *user;
630 sk->protinfo.nr->source_addr = *source;
631 }
632
633 sk->protinfo.nr->device = dev;
634 nr_insert_socket(sk);
635
636 sk->zapped = 0;
637 SOCK_DEBUG(sk, "NET/ROM: socket is bound\n");
638 return 0;
639 }
640
641 static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
642 int addr_len, int flags)
643 {
644 struct sock *sk = sock->sk;
645 struct sockaddr_ax25 *addr = (struct sockaddr_ax25 *)uaddr;
646 ax25_address *user, *source = NULL;
647 struct net_device *dev;
648
649 if (sk->state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
650 sock->state = SS_CONNECTED;
651 return 0; /* Connect completed during a ERESTARTSYS event */
652 }
653
654 if (sk->state == TCP_CLOSE && sock->state == SS_CONNECTING) {
655 sock->state = SS_UNCONNECTED;
656 return -ECONNREFUSED;
657 }
658
659 if (sk->state == TCP_ESTABLISHED)
660 return -EISCONN; /* No reconnect on a seqpacket socket */
661
662 sk->state = TCP_CLOSE;
663 sock->state = SS_UNCONNECTED;
664
665 if (addr_len != sizeof(struct sockaddr_ax25) && addr_len != sizeof(struct full_sockaddr_ax25))
666 return -EINVAL;
667
668 if (addr->sax25_family != AF_NETROM)
669 return -EINVAL;
670
671 if (sk->zapped) { /* Must bind first - autobinding in this may or may not work */
672 sk->zapped = 0;
673
674 if ((dev = nr_dev_first()) == NULL)
675 return -ENETUNREACH;
676
677 source = (ax25_address *)dev->dev_addr;
678
679 if ((user = ax25_findbyuid(current->euid)) == NULL) {
680 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
681 return -EPERM;
682 user = source;
683 }
684
685 sk->protinfo.nr->user_addr = *user;
686 sk->protinfo.nr->source_addr = *source;
687 sk->protinfo.nr->device = dev;
688
689 nr_insert_socket(sk); /* Finish the bind */
690 }
691
692 sk->protinfo.nr->dest_addr = addr->sax25_call;
693
694 circuit = nr_find_next_circuit();
695
696 sk->protinfo.nr->my_index = circuit / 256;
697 sk->protinfo.nr->my_id = circuit % 256;
698
699 circuit++;
700
701 /* Move to connecting socket, start sending Connect Requests */
702 sock->state = SS_CONNECTING;
703 sk->state = TCP_SYN_SENT;
704
705 nr_establish_data_link(sk);
706
707 sk->protinfo.nr->state = NR_STATE_1;
708
709 nr_start_heartbeat(sk);
710
711 /* Now the loop */
712 if (sk->state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
713 return -EINPROGRESS;
714
715 cli(); /* To avoid races on the sleep */
716
717 /*
718 * A Connect Ack with Choke or timeout or failed routing will go to closed.
719 */
720 while (sk->state == TCP_SYN_SENT) {
721 interruptible_sleep_on(sk->sleep);
722 if (signal_pending(current)) {
723 sti();
724 return -ERESTARTSYS;
725 }
726 }
727
728 if (sk->state != TCP_ESTABLISHED) {
729 sti();
730 sock->state = SS_UNCONNECTED;
731 return sock_error(sk); /* Always set at this point */
732 }
733
734 sock->state = SS_CONNECTED;
735
736 sti();
737
738 return 0;
739 }
740
741 static int nr_accept(struct socket *sock, struct socket *newsock, int flags)
742 {
743 struct sock *sk;
744 struct sock *newsk;
745 struct sk_buff *skb;
746
747 if ((sk = sock->sk) == NULL)
748 return -EINVAL;
749
750 if (sk->type != SOCK_SEQPACKET)
751 return -EOPNOTSUPP;
752
753 if (sk->state != TCP_LISTEN)
754 return -EINVAL;
755
756 /*
757 * The write queue this time is holding sockets ready to use
758 * hooked into the SABM we saved
759 */
760 do {
761 cli();
762 if ((skb = skb_dequeue(&sk->receive_queue)) == NULL) {
763 if (flags & O_NONBLOCK) {
764 sti();
765 return -EWOULDBLOCK;
766 }
767 interruptible_sleep_on(sk->sleep);
768 if (signal_pending(current)) {
769 sti();
770 return -ERESTARTSYS;
771 }
772 }
773 } while (skb == NULL);
774
775 newsk = skb->sk;
776 newsk->pair = NULL;
777 newsk->socket = newsock;
778 newsk->sleep = &newsock->wait;
779 sti();
780
781 /* Now attach up the new socket */
782 kfree_skb(skb);
783 sk->ack_backlog--;
784 newsock->sk = newsk;
785
786 return 0;
787 }
788
789 static int nr_getname(struct socket *sock, struct sockaddr *uaddr,
790 int *uaddr_len, int peer)
791 {
792 struct full_sockaddr_ax25 *sax = (struct full_sockaddr_ax25 *)uaddr;
793 struct sock *sk = sock->sk;
794
795 if (peer != 0) {
796 if (sk->state != TCP_ESTABLISHED)
797 return -ENOTCONN;
798 sax->fsa_ax25.sax25_family = AF_NETROM;
799 sax->fsa_ax25.sax25_ndigis = 1;
800 sax->fsa_ax25.sax25_call = sk->protinfo.nr->user_addr;
801 sax->fsa_digipeater[0] = sk->protinfo.nr->dest_addr;
802 *uaddr_len = sizeof(struct full_sockaddr_ax25);
803 } else {
804 sax->fsa_ax25.sax25_family = AF_NETROM;
805 sax->fsa_ax25.sax25_ndigis = 0;
806 sax->fsa_ax25.sax25_call = sk->protinfo.nr->source_addr;
807 *uaddr_len = sizeof(struct sockaddr_ax25);
808 }
809
810 return 0;
811 }
812
813 int nr_rx_frame(struct sk_buff *skb, struct net_device *dev)
814 {
815 struct sock *sk;
816 struct sock *make;
817 ax25_address *src, *dest, *user;
818 unsigned short circuit_index, circuit_id;
819 unsigned short peer_circuit_index, peer_circuit_id;
820 unsigned short frametype, flags, window, timeout;
821
822 skb->sk = NULL; /* Initially we don't know who it's for */
823
824 /*
825 * skb->data points to the netrom frame start
826 */
827
828 src = (ax25_address *)(skb->data + 0);
829 dest = (ax25_address *)(skb->data + 7);
830
831 circuit_index = skb->data[15];
832 circuit_id = skb->data[16];
833 peer_circuit_index = skb->data[17];
834 peer_circuit_id = skb->data[18];
835 frametype = skb->data[19] & 0x0F;
836 flags = skb->data[19] & 0xF0;
837
838 #ifdef CONFIG_INET
839 /*
840 * Check for an incoming IP over NET/ROM frame.
841 */
842 if (frametype == NR_PROTOEXT && circuit_index == NR_PROTO_IP && circuit_id == NR_PROTO_IP) {
843 skb_pull(skb, NR_NETWORK_LEN + NR_TRANSPORT_LEN);
844 skb->h.raw = skb->data;
845
846 return nr_rx_ip(skb, dev);
847 }
848 #endif
849
850 /*
851 * Find an existing socket connection, based on circuit ID, if it's
852 * a Connect Request base it on their circuit ID.
853 *
854 * Circuit ID 0/0 is not valid but it could still be a "reset" for a
855 * circuit that no longer exists at the other end ...
856 */
857
858 sk = NULL;
859
860 if (circuit_index == 0 && circuit_id == 0) {
861 if (frametype == NR_CONNACK && flags == NR_CHOKE_FLAG)
862 sk = nr_find_peer(peer_circuit_index, peer_circuit_id, src);
863 } else {
864 if (frametype == NR_CONNREQ)
865 sk = nr_find_peer(circuit_index, circuit_id, src);
866 else
867 sk = nr_find_socket(circuit_index, circuit_id);
868 }
869
870 if (sk != NULL) {
871 skb->h.raw = skb->data;
872
873 if (frametype == NR_CONNACK && skb->len == 22)
874 sk->protinfo.nr->bpqext = 1;
875 else
876 sk->protinfo.nr->bpqext = 0;
877
878 return nr_process_rx_frame(sk, skb);
879 }
880
881 /*
882 * Now it should be a CONNREQ.
883 */
884 if (frametype != NR_CONNREQ) {
885 /*
886 * Here it would be nice to be able to send a reset but
887 * NET/ROM doesn't have one. The following hack would
888 * have been a way to extend the protocol but apparently
889 * it kills BPQ boxes... :-(
890 */
891 #if 0
892 /*
893 * Never reply to a CONNACK/CHOKE.
894 */
895 if (frametype != NR_CONNACK || flags != NR_CHOKE_FLAG)
896 nr_transmit_refusal(skb, 1);
897 #endif
898 return 0;
899 }
900
901 sk = nr_find_listener(dest);
902
903 user = (ax25_address *)(skb->data + 21);
904
905 if (sk == NULL || sk->ack_backlog == sk->max_ack_backlog || (make = nr_make_new(sk)) == NULL) {
906 nr_transmit_refusal(skb, 0);
907 return 0;
908 }
909
910 window = skb->data[20];
911
912 skb->sk = make;
913 make->state = TCP_ESTABLISHED;
914
915 /* Fill in his circuit details */
916 make->protinfo.nr->source_addr = *dest;
917 make->protinfo.nr->dest_addr = *src;
918 make->protinfo.nr->user_addr = *user;
919
920 make->protinfo.nr->your_index = circuit_index;
921 make->protinfo.nr->your_id = circuit_id;
922
923 circuit = nr_find_next_circuit();
924
925 make->protinfo.nr->my_index = circuit / 256;
926 make->protinfo.nr->my_id = circuit % 256;
927
928 circuit++;
929
930 /* Window negotiation */
931 if (window < make->protinfo.nr->window)
932 make->protinfo.nr->window = window;
933
934 /* L4 timeout negotiation */
935 if (skb->len == 37) {
936 timeout = skb->data[36] * 256 + skb->data[35];
937 if (timeout * HZ < make->protinfo.nr->t1)
938 make->protinfo.nr->t1 = timeout * HZ;
939 make->protinfo.nr->bpqext = 1;
940 } else {
941 make->protinfo.nr->bpqext = 0;
942 }
943
944 nr_write_internal(make, NR_CONNACK);
945
946 make->protinfo.nr->condition = 0x00;
947 make->protinfo.nr->vs = 0;
948 make->protinfo.nr->va = 0;
949 make->protinfo.nr->vr = 0;
950 make->protinfo.nr->vl = 0;
951 make->protinfo.nr->state = NR_STATE_3;
952 sk->ack_backlog++;
953 make->pair = sk;
954
955 nr_insert_socket(make);
956
957 skb_queue_head(&sk->receive_queue, skb);
958
959 nr_start_heartbeat(make);
960 nr_start_idletimer(make);
961
962 if (!sk->dead)
963 sk->data_ready(sk, skb->len);
964
965 return 1;
966 }
967
968 static int nr_sendmsg(struct socket *sock, struct msghdr *msg, int len, struct scm_cookie *scm)
969 {
970 struct sock *sk = sock->sk;
971 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
972 int err;
973 struct sockaddr_ax25 sax;
974 struct sk_buff *skb;
975 unsigned char *asmptr;
976 int size;
977
978 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR))
979 return -EINVAL;
980
981 if (sk->zapped)
982 return -EADDRNOTAVAIL;
983
984 if (sk->shutdown & SEND_SHUTDOWN) {
985 send_sig(SIGPIPE, current, 0);
986 return -EPIPE;
987 }
988
989 if (sk->protinfo.nr->device == NULL)
990 return -ENETUNREACH;
991
992 if (usax) {
993 if (msg->msg_namelen < sizeof(sax))
994 return -EINVAL;
995 sax = *usax;
996 if (ax25cmp(&sk->protinfo.nr->dest_addr, &sax.sax25_call) != 0)
997 return -EISCONN;
998 if (sax.sax25_family != AF_NETROM)
999 return -EINVAL;
1000 } else {
1001 if (sk->state != TCP_ESTABLISHED)
1002 return -ENOTCONN;
1003 sax.sax25_family = AF_NETROM;
1004 sax.sax25_call = sk->protinfo.nr->dest_addr;
1005 }
1006
1007 SOCK_DEBUG(sk, "NET/ROM: sendto: Addresses built.\n");
1008
1009 /* Build a packet */
1010 SOCK_DEBUG(sk, "NET/ROM: sendto: building packet.\n");
1011 size = len + AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + NR_NETWORK_LEN + NR_TRANSPORT_LEN;
1012
1013 if ((skb = sock_alloc_send_skb(sk, size, 0, msg->msg_flags & MSG_DONTWAIT, &err)) == NULL)
1014 return err;
1015
1016 skb_reserve(skb, size - len);
1017
1018 /*
1019 * Push down the NET/ROM header
1020 */
1021
1022 asmptr = skb_push(skb, NR_TRANSPORT_LEN);
1023 SOCK_DEBUG(sk, "Building NET/ROM Header.\n");
1024
1025 /* Build a NET/ROM Transport header */
1026
1027 *asmptr++ = sk->protinfo.nr->your_index;
1028 *asmptr++ = sk->protinfo.nr->your_id;
1029 *asmptr++ = 0; /* To be filled in later */
1030 *asmptr++ = 0; /* Ditto */
1031 *asmptr++ = NR_INFO;
1032 SOCK_DEBUG(sk, "Built header.\n");
1033
1034 /*
1035 * Put the data on the end
1036 */
1037
1038 skb->h.raw = skb_put(skb, len);
1039
1040 asmptr = skb->h.raw;
1041 SOCK_DEBUG(sk, "NET/ROM: Appending user data\n");
1042
1043 /* User data follows immediately after the NET/ROM transport header */
1044 memcpy_fromiovec(asmptr, msg->msg_iov, len);
1045 SOCK_DEBUG(sk, "NET/ROM: Transmitting buffer\n");
1046
1047 if (sk->state != TCP_ESTABLISHED) {
1048 kfree_skb(skb);
1049 return -ENOTCONN;
1050 }
1051
1052 nr_output(sk, skb); /* Shove it onto the queue */
1053
1054 return len;
1055 }
1056
1057 static int nr_recvmsg(struct socket *sock, struct msghdr *msg, int size,
1058 int flags, struct scm_cookie *scm)
1059 {
1060 struct sock *sk = sock->sk;
1061 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1062 int copied;
1063 struct sk_buff *skb;
1064 int er;
1065
1066 /*
1067 * This works for seqpacket too. The receiver has ordered the queue for
1068 * us! We do one quick check first though
1069 */
1070
1071 if (sk->state != TCP_ESTABLISHED)
1072 return -ENOTCONN;
1073
1074 /* Now we can treat all alike */
1075 if ((skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, flags & MSG_DONTWAIT, &er)) == NULL)
1076 return er;
1077
1078 skb->h.raw = skb->data;
1079 copied = skb->len;
1080
1081 if (copied > size) {
1082 copied = size;
1083 msg->msg_flags |= MSG_TRUNC;
1084 }
1085
1086 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1087
1088 if (sax != NULL) {
1089 sax->sax25_family = AF_NETROM;
1090 memcpy(sax->sax25_call.ax25_call, skb->data + 7, AX25_ADDR_LEN);
1091 }
1092
1093 msg->msg_namelen = sizeof(*sax);
1094
1095 skb_free_datagram(sk, skb);
1096
1097 return copied;
1098 }
1099
1100
1101 static int nr_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1102 {
1103 struct sock *sk = sock->sk;
1104
1105 switch (cmd) {
1106 case TIOCOUTQ: {
1107 long amount;
1108 amount = sk->sndbuf - atomic_read(&sk->wmem_alloc);
1109 if (amount < 0)
1110 amount = 0;
1111 return put_user(amount, (int *)arg);
1112 }
1113
1114 case TIOCINQ: {
1115 struct sk_buff *skb;
1116 long amount = 0L;
1117 /* These two are safe on a single CPU system as only user tasks fiddle here */
1118 if ((skb = skb_peek(&sk->receive_queue)) != NULL)
1119 amount = skb->len;
1120 return put_user(amount, (int *)arg);
1121 }
1122
1123 case SIOCGSTAMP:
1124 if (sk != NULL) {
1125 if (sk->stamp.tv_sec == 0)
1126 return -ENOENT;
1127 return copy_to_user((void *)arg, &sk->stamp, sizeof(struct timeval)) ? -EFAULT : 0;
1128 }
1129 return -EINVAL;
1130
1131 case SIOCGIFADDR:
1132 case SIOCSIFADDR:
1133 case SIOCGIFDSTADDR:
1134 case SIOCSIFDSTADDR:
1135 case SIOCGIFBRDADDR:
1136 case SIOCSIFBRDADDR:
1137 case SIOCGIFNETMASK:
1138 case SIOCSIFNETMASK:
1139 case SIOCGIFMETRIC:
1140 case SIOCSIFMETRIC:
1141 return -EINVAL;
1142
1143 case SIOCADDRT:
1144 case SIOCDELRT:
1145 case SIOCNRDECOBS:
1146 if (!capable(CAP_NET_ADMIN)) return -EPERM;
1147 return nr_rt_ioctl(cmd, (void *)arg);
1148
1149 default:
1150 return dev_ioctl(cmd, (void *)arg);
1151 }
1152
1153 /*NOTREACHED*/
1154 return 0;
1155 }
1156
1157 static int nr_get_info(char *buffer, char **start, off_t offset, int length)
1158 {
1159 struct sock *s;
1160 struct net_device *dev;
1161 const char *devname;
1162 int len = 0;
1163 off_t pos = 0;
1164 off_t begin = 0;
1165
1166 cli();
1167
1168 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");
1169
1170 for (s = nr_list; s != NULL; s = s->next) {
1171 if ((dev = s->protinfo.nr->device) == NULL)
1172 devname = "???";
1173 else
1174 devname = dev->name;
1175
1176 len += sprintf(buffer + len, "%-9s ",
1177 ax2asc(&s->protinfo.nr->user_addr));
1178 len += sprintf(buffer + len, "%-9s ",
1179 ax2asc(&s->protinfo.nr->dest_addr));
1180 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",
1181 ax2asc(&s->protinfo.nr->source_addr),
1182 devname,
1183 s->protinfo.nr->my_index,
1184 s->protinfo.nr->my_id,
1185 s->protinfo.nr->your_index,
1186 s->protinfo.nr->your_id,
1187 s->protinfo.nr->state,
1188 s->protinfo.nr->vs,
1189 s->protinfo.nr->vr,
1190 s->protinfo.nr->va,
1191 ax25_display_timer(&s->protinfo.nr->t1timer) / HZ,
1192 s->protinfo.nr->t1 / HZ,
1193 ax25_display_timer(&s->protinfo.nr->t2timer) / HZ,
1194 s->protinfo.nr->t2 / HZ,
1195 ax25_display_timer(&s->protinfo.nr->t4timer) / HZ,
1196 s->protinfo.nr->t4 / HZ,
1197 ax25_display_timer(&s->protinfo.nr->idletimer) / (60 * HZ),
1198 s->protinfo.nr->idle / (60 * HZ),
1199 s->protinfo.nr->n2count,
1200 s->protinfo.nr->n2,
1201 s->protinfo.nr->window,
1202 atomic_read(&s->wmem_alloc),
1203 atomic_read(&s->rmem_alloc),
1204 s->socket != NULL ? s->socket->inode->i_ino : 0L);
1205
1206 pos = begin + len;
1207
1208 if (pos < offset) {
1209 len = 0;
1210 begin = pos;
1211 }
1212
1213 if (pos > offset + length)
1214 break;
1215 }
1216
1217 sti();
1218
1219 *start = buffer + (offset - begin);
1220 len -= (offset - begin);
1221
1222 if (len > length) len = length;
1223
1224 return(len);
1225 }
1226
1227 static struct net_proto_family nr_family_ops =
1228 {
1229 PF_NETROM,
1230 nr_create
1231 };
1232
1233 static struct proto_ops SOCKOPS_WRAPPED(nr_proto_ops) = {
1234 family: PF_NETROM,
1235
1236 release: nr_release,
1237 bind: nr_bind,
1238 connect: nr_connect,
1239 socketpair: sock_no_socketpair,
1240 accept: nr_accept,
1241 getname: nr_getname,
1242 poll: datagram_poll,
1243 ioctl: nr_ioctl,
1244 listen: nr_listen,
1245 shutdown: sock_no_shutdown,
1246 setsockopt: nr_setsockopt,
1247 getsockopt: nr_getsockopt,
1248 sendmsg: nr_sendmsg,
1249 recvmsg: nr_recvmsg,
1250 mmap: sock_no_mmap,
1251 };
1252
1253 #include <linux/smp_lock.h>
1254 SOCKOPS_WRAP(nr_proto, PF_NETROM);
1255
1256 static struct notifier_block nr_dev_notifier = {
1257 nr_device_event,
1258 0
1259 };
1260
1261 static struct net_device *dev_nr;
1262
1263 static int __init nr_proto_init(void)
1264 {
1265 int i;
1266
1267 if ((dev_nr = kmalloc(nr_ndevs * sizeof(struct net_device), GFP_KERNEL)) == NULL) {
1268 printk(KERN_ERR "NET/ROM: nr_proto_init - unable to allocate device structure\n");
1269 return -1;
1270 }
1271
1272 memset(dev_nr, 0x00, nr_ndevs * sizeof(struct net_device));
1273
1274 for (i = 0; i < nr_ndevs; i++) {
1275 sprintf(dev_nr[i].name, "nr%d", i);
1276 dev_nr[i].init = nr_init;
1277 register_netdev(&dev_nr[i]);
1278 }
1279
1280 sock_register(&nr_family_ops);
1281 register_netdevice_notifier(&nr_dev_notifier);
1282 printk(KERN_INFO "G4KLX NET/ROM for Linux. Version 0.7 for AX25.037 Linux 2.4\n");
1283
1284 ax25_protocol_register(AX25_P_NETROM, nr_route_frame);
1285 ax25_linkfail_register(nr_link_failed);
1286
1287 #ifdef CONFIG_SYSCTL
1288 nr_register_sysctl();
1289 #endif
1290
1291 nr_loopback_init();
1292
1293 proc_net_create("nr", 0, nr_get_info);
1294 proc_net_create("nr_neigh", 0, nr_neigh_get_info);
1295 proc_net_create("nr_nodes", 0, nr_nodes_get_info);
1296 return 0;
1297 }
1298
1299 module_init(nr_proto_init);
1300
1301
1302 EXPORT_NO_SYMBOLS;
1303
1304 MODULE_PARM(nr_ndevs, "i");
1305 MODULE_PARM_DESC(nr_ndevs, "number of NET/ROM devices");
1306
1307 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
1308 MODULE_DESCRIPTION("The amateur radio NET/ROM network and transport layer protocol");
1309
1310 static void __exit nr_exit(void)
1311 {
1312 int i;
1313
1314 proc_net_remove("nr");
1315 proc_net_remove("nr_neigh");
1316 proc_net_remove("nr_nodes");
1317 nr_loopback_clear();
1318
1319 nr_rt_free();
1320
1321 ax25_protocol_release(AX25_P_NETROM);
1322 ax25_linkfail_release(nr_link_failed);
1323
1324 unregister_netdevice_notifier(&nr_dev_notifier);
1325
1326 #ifdef CONFIG_SYSCTL
1327 nr_unregister_sysctl();
1328 #endif
1329 sock_unregister(PF_NETROM);
1330
1331 for (i = 0; i < nr_ndevs; i++) {
1332 if (dev_nr[i].priv != NULL) {
1333 kfree(dev_nr[i].priv);
1334 dev_nr[i].priv = NULL;
1335 unregister_netdev(&dev_nr[i]);
1336 }
1337 kfree(dev_nr[i].name);
1338 }
1339
1340 kfree(dev_nr);
1341 }
1342 module_exit(nr_exit);
1343
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.