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