This source file includes following definitions.
- nr_remove_socket
- nr_kill_by_device
- nr_device_event
- nr_insert_socket
- nr_find_listener
- nr_find_socket
- nr_find_peer
- nr_destroy_timer
- nr_destroy_socket
- nr_fcntl
- nr_setsockopt
- nr_getsockopt
- nr_listen
- def_callback1
- def_callback2
- nr_create
- nr_make_new
- nr_dup
- nr_release
- nr_bind
- nr_connect
- nr_socketpair
- nr_accept
- nr_getname
- nr_rx_frame
- nr_sendmsg
- nr_recvmsg
- nr_shutdown
- nr_select
- nr_ioctl
- nr_get_info
- nr_proto_init
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31 #include <linux/config.h>
32 #ifdef CONFIG_NETROM
33 #include <linux/errno.h>
34 #include <linux/types.h>
35 #include <linux/socket.h>
36 #include <linux/in.h>
37 #include <linux/kernel.h>
38 #include <linux/sched.h>
39 #include <linux/timer.h>
40 #include <linux/string.h>
41 #include <linux/sockios.h>
42 #include <linux/net.h>
43 #include <linux/stat.h>
44 #include <net/ax25.h>
45 #include <linux/inet.h>
46 #include <linux/netdevice.h>
47 #include <linux/if_arp.h>
48 #include <linux/skbuff.h>
49 #include <net/sock.h>
50 #include <asm/segment.h>
51 #include <asm/system.h>
52 #include <linux/fcntl.h>
53 #include <linux/termios.h>
54 #include <linux/mm.h>
55 #include <linux/interrupt.h>
56 #include <linux/notifier.h>
57 #include <net/netrom.h>
58 #include <linux/proc_fs.h>
59 #include <net/ip.h>
60 #include <net/arp.h>
61 #include <linux/if_arp.h>
62
63 struct nr_parms_struct nr_default;
64
65 static unsigned short circuit = 0x101;
66
67 static struct sock *volatile nr_list = NULL;
68
69
70
71
72 static void nr_remove_socket(struct sock *sk)
73 {
74 struct sock *s;
75 unsigned long flags;
76
77 save_flags(flags);
78 cli();
79
80 if ((s = nr_list) == sk) {
81 nr_list = s->next;
82 restore_flags(flags);
83 return;
84 }
85
86 while (s != NULL && s->next != NULL) {
87 if (s->next == sk) {
88 s->next = sk->next;
89 restore_flags(flags);
90 return;
91 }
92
93 s = s->next;
94 }
95
96 restore_flags(flags);
97 }
98
99
100
101
102 static void nr_kill_by_device(struct device *dev)
103 {
104 struct sock *s;
105
106 for (s = nr_list; s != NULL; s = s->next) {
107 if (s->nr->device == dev) {
108 s->nr->state = NR_STATE_0;
109 s->nr->device = NULL;
110 s->state = TCP_CLOSE;
111 s->err = ENETUNREACH;
112 s->state_change(s);
113 s->dead = 1;
114 }
115 }
116 }
117
118
119
120
121 static int nr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
122 {
123 struct device *dev = (struct device *)ptr;
124
125 if (event != NETDEV_DOWN)
126 return NOTIFY_DONE;
127
128 nr_kill_by_device(dev);
129 nr_rt_device_down(dev);
130
131 return NOTIFY_DONE;
132 }
133
134
135
136
137 static void nr_insert_socket(struct sock *sk)
138 {
139 unsigned long flags;
140
141 save_flags(flags);
142 cli();
143
144 sk->next = nr_list;
145 nr_list = sk;
146
147 restore_flags(flags);
148 }
149
150
151
152
153
154 static struct sock *nr_find_listener(ax25_address *addr, int type)
155 {
156 unsigned long flags;
157 struct sock *s;
158
159 save_flags(flags);
160 cli();
161
162 for (s = nr_list; s != NULL; s = s->next) {
163 if (ax25cmp(&s->nr->source_addr, addr) == 0 && s->type == type && s->state == TCP_LISTEN) {
164 restore_flags(flags);
165 return s;
166 }
167 }
168
169 restore_flags(flags);
170 return NULL;
171 }
172
173
174
175
176 static struct sock *nr_find_socket(unsigned char index, unsigned char id, int type)
177 {
178 struct sock *s;
179 unsigned long flags;
180
181 save_flags(flags);
182 cli();
183
184 for (s = nr_list; s != NULL; s = s->next) {
185 if (s->nr->my_index == index && s->nr->my_id == id && s->type == type) {
186 restore_flags(flags);
187 return s;
188 }
189 }
190
191 restore_flags(flags);
192
193 return NULL;
194 }
195
196
197
198
199 static struct sock *nr_find_peer(unsigned char index, unsigned char id, int type)
200 {
201 struct sock *s;
202 unsigned long flags;
203
204 save_flags(flags);
205 cli();
206
207 for (s = nr_list; s != NULL; s = s->next) {
208 if (s->nr->your_index == index && s->nr->your_id == id && s->type == type) {
209 restore_flags(flags);
210 return s;
211 }
212 }
213
214 restore_flags(flags);
215
216 return NULL;
217 }
218
219
220
221
222 void nr_destory_socket(struct sock *);
223
224
225
226
227 static void nr_destroy_timer(unsigned long data)
228 {
229 nr_destroy_socket((struct sock *)data);
230 }
231
232
233
234
235
236
237
238 void nr_destroy_socket(struct sock *sk)
239 {
240 struct sk_buff *skb;
241 unsigned long flags;
242
243 save_flags(flags);
244 cli();
245
246 del_timer(&sk->timer);
247
248 nr_remove_socket(sk);
249 nr_clear_queues(sk);
250
251 while ((skb = skb_dequeue(&sk->receive_queue)) != NULL) {
252 if (skb->sk != sk) {
253 skb->sk->dead = 1;
254 nr_set_timer(skb->sk);
255 skb->sk->nr->state = NR_STATE_0;
256 }
257
258 kfree_skb(skb, FREE_READ);
259 }
260
261 if (sk->wmem_alloc || sk->rmem_alloc) {
262 init_timer(&sk->timer);
263 sk->timer.expires = jiffies + 10 * HZ;
264 sk->timer.function = nr_destroy_timer;
265 sk->timer.data = (unsigned long)sk;
266 add_timer(&sk->timer);
267 } else {
268 kfree_s(sk->nr, sizeof(*sk->nr));
269 kfree_s(sk, sizeof(*sk));
270 }
271
272 restore_flags(flags);
273 }
274
275
276
277
278
279
280 static int nr_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
281 {
282 return -EINVAL;
283 }
284
285 static int nr_setsockopt(struct socket *sock, int level, int optname,
286 char *optval, int optlen)
287 {
288 struct sock *sk;
289 int err, opt;
290
291 sk = (struct sock *)sock->data;
292
293 if (level == SOL_SOCKET)
294 return sock_setsockopt(sk, level, optname, optval, optlen);
295
296 if (level != SOL_NETROM)
297 return -EOPNOTSUPP;
298
299 if (optval == NULL)
300 return -EINVAL;
301
302 if ((err = verify_area(VERIFY_READ, optval, sizeof(int))) != 0)
303 return err;
304
305 opt = get_fs_long((unsigned long *)optval);
306
307 switch (optname) {
308 case NETROM_T1:
309 if (opt < 1)
310 return -EINVAL;
311 sk->nr->rtt = (opt * PR_SLOWHZ) / 2;
312 return 0;
313
314 case NETROM_T2:
315 if (opt < 1)
316 return -EINVAL;
317 sk->nr->t2 = opt * PR_SLOWHZ;
318 return 0;
319
320 case NETROM_N2:
321 if (opt < 1 || opt > 31)
322 return -EINVAL;
323 sk->nr->n2 = opt;
324 return 0;
325
326 case NETROM_HDRINCL:
327 sk->nr->hdrincl = opt ? 1 : 0;
328 return 0;
329
330 default:
331 return -ENOPROTOOPT;
332 }
333 }
334
335 static int nr_getsockopt(struct socket *sock, int level, int optname,
336 char *optval, int *optlen)
337 {
338 struct sock *sk;
339 int val = 0;
340 int err;
341
342 sk = (struct sock *)sock->data;
343
344 if (level == SOL_SOCKET)
345 return sock_getsockopt(sk, level, optname, optval, optlen);
346
347 if (level != SOL_NETROM)
348 return -EOPNOTSUPP;
349
350 switch (optname) {
351 case NETROM_T1:
352 val = (sk->nr->t1 * 2) / PR_SLOWHZ;
353 break;
354
355 case NETROM_T2:
356 val = sk->nr->t2 / PR_SLOWHZ;
357 break;
358
359 case NETROM_N2:
360 val = sk->nr->n2;
361 break;
362
363 case NETROM_HDRINCL:
364 val = sk->nr->hdrincl;
365 break;
366
367 default:
368 return -ENOPROTOOPT;
369 }
370
371 if ((err = verify_area(VERIFY_WRITE, optlen, sizeof(int))) != 0)
372 return err;
373
374 put_fs_long(sizeof(int), (unsigned long *)optlen);
375
376 if ((err = verify_area(VERIFY_WRITE, optval, sizeof(int))) != 0)
377 return err;
378
379 put_fs_long(val, (unsigned long *)optval);
380
381 return 0;
382 }
383
384 static int nr_listen(struct socket *sock, int backlog)
385 {
386 struct sock *sk = (struct sock *)sock->data;
387
388 if (sk->type == SOCK_SEQPACKET && sk->state != TCP_LISTEN) {
389 memset(&sk->nr->user_addr, '\0', sizeof(ax25_address));
390 sk->max_ack_backlog = backlog;
391 sk->state = TCP_LISTEN;
392 return 0;
393 }
394
395 return -EOPNOTSUPP;
396 }
397
398 static void def_callback1(struct sock *sk)
399 {
400 if (!sk->dead)
401 wake_up_interruptible(sk->sleep);
402 }
403
404 static void def_callback2(struct sock *sk, int len)
405 {
406 if (!sk->dead)
407 wake_up_interruptible(sk->sleep);
408 }
409
410 static int nr_create(struct socket *sock, int protocol)
411 {
412 struct sock *sk;
413 nr_cb *nr;
414
415 if (sock->type != SOCK_SEQPACKET || protocol != 0)
416 return -ESOCKTNOSUPPORT;
417
418 if ((sk = (struct sock *)kmalloc(sizeof(*sk), GFP_ATOMIC)) == NULL)
419 return -ENOMEM;
420
421 if ((nr = (nr_cb *)kmalloc(sizeof(*nr), GFP_ATOMIC)) == NULL) {
422 kfree_s(sk, sizeof(*sk));
423 return -ENOMEM;
424 }
425
426 skb_queue_head_init(&sk->receive_queue);
427 skb_queue_head_init(&sk->write_queue);
428 skb_queue_head_init(&sk->back_log);
429
430 init_timer(&sk->timer);
431
432 sk->socket = sock;
433 sk->type = sock->type;
434 sk->protocol = protocol;
435 sk->dead = 0;
436 sk->next = NULL;
437 sk->broadcast = 0;
438 sk->allocation = GFP_KERNEL;
439 sk->rcvbuf = SK_RMEM_MAX;
440 sk->sndbuf = SK_WMEM_MAX;
441 sk->wmem_alloc = 0;
442 sk->rmem_alloc = 0;
443 sk->inuse = 0;
444 sk->debug = 0;
445 sk->destroy = 0;
446 sk->prot = NULL;
447 sk->err = 0;
448 sk->localroute = 0;
449 sk->send_head = NULL;
450 sk->state = TCP_CLOSE;
451 sk->shutdown = 0;
452 sk->priority = SOPRI_NORMAL;
453 sk->ack_backlog = 0;
454 sk->mtu = NETROM_MTU;
455 sk->zapped = 1;
456 sk->window = nr_default.window;
457
458 sk->state_change = def_callback1;
459 sk->data_ready = def_callback2;
460 sk->write_space = def_callback1;
461 sk->error_report = def_callback1;
462
463 if (sock != NULL) {
464 sock->data = (void *)sk;
465 sk->sleep = sock->wait;
466 }
467
468 skb_queue_head_init(&nr->ack_queue);
469 skb_queue_head_init(&nr->reseq_queue);
470 skb_queue_head_init(&nr->frag_queue);
471
472 nr->my_index = 0;
473 nr->my_id = 0;
474 nr->rtt = nr_default.timeout / 2;
475 nr->t1 = nr_default.timeout;
476 nr->t2 = nr_default.ack_delay;
477 nr->n2 = nr_default.tries;
478
479 nr->t1timer = 0;
480 nr->t2timer = 0;
481 nr->t4timer = 0;
482 nr->n2count = 0;
483
484 nr->va = 0;
485 nr->vr = 0;
486 nr->vs = 0;
487 nr->vl = 0;
488
489 nr->your_index = 0;
490 nr->your_id = 0;
491
492 nr->my_index = 0;
493 nr->my_id = 0;
494
495 nr->bpqext = 1;
496 nr->fraglen = 0;
497 nr->hdrincl = 0;
498 nr->state = NR_STATE_0;
499 nr->device = NULL;
500
501 memset(&nr->source_addr, '\0', sizeof(ax25_address));
502 memset(&nr->user_addr, '\0', sizeof(ax25_address));
503 memset(&nr->dest_addr, '\0', sizeof(ax25_address));
504
505 nr->sk = sk;
506 sk->nr = nr;
507
508 return 0;
509 }
510
511 static struct sock *nr_make_new(struct sock *osk)
512 {
513 struct sock *sk;
514 nr_cb *nr;
515
516 if (osk->type != SOCK_SEQPACKET)
517 return NULL;
518
519 if ((sk = (struct sock *)kmalloc(sizeof(*sk), GFP_ATOMIC)) == NULL)
520 return NULL;
521
522 if ((nr = (nr_cb *)kmalloc(sizeof(*nr), GFP_ATOMIC)) == NULL) {
523 kfree_s(sk, sizeof(*sk));
524 return NULL;
525 }
526
527 skb_queue_head_init(&sk->receive_queue);
528 skb_queue_head_init(&sk->write_queue);
529 skb_queue_head_init(&sk->back_log);
530
531 init_timer(&sk->timer);
532
533 sk->type = osk->type;
534 sk->socket = osk->socket;
535 sk->dead = 0;
536 sk->next = NULL;
537 sk->priority = osk->priority;
538 sk->broadcast = 0;
539 sk->protocol = osk->protocol;
540 sk->rcvbuf = osk->rcvbuf;
541 sk->sndbuf = osk->sndbuf;
542 sk->wmem_alloc = 0;
543 sk->rmem_alloc = 0;
544 sk->inuse = 0;
545 sk->ack_backlog = 0;
546 sk->destroy = 0;
547 sk->prot = NULL;
548 sk->err = 0;
549 sk->localroute = 0;
550 sk->send_head = NULL;
551 sk->debug = osk->debug;
552 sk->state = TCP_ESTABLISHED;
553 sk->window = osk->window;
554 sk->shutdown = 0;
555 sk->mtu = osk->mtu;
556 sk->sleep = osk->sleep;
557 sk->zapped = osk->zapped;
558
559 sk->state_change = def_callback1;
560 sk->data_ready = def_callback2;
561 sk->write_space = def_callback1;
562 sk->error_report = def_callback1;
563
564 skb_queue_head_init(&nr->ack_queue);
565 skb_queue_head_init(&nr->reseq_queue);
566 skb_queue_head_init(&nr->frag_queue);
567
568 nr->rtt = osk->nr->rtt;
569 nr->t1 = osk->nr->t1;
570 nr->t2 = osk->nr->t2;
571 nr->n2 = osk->nr->n2;
572
573 nr->device = osk->nr->device;
574 nr->bpqext = osk->nr->bpqext;
575 nr->hdrincl = osk->nr->hdrincl;
576 nr->fraglen = 0;
577
578 nr->t1timer = 0;
579 nr->t2timer = 0;
580 nr->t4timer = 0;
581 nr->n2count = 0;
582
583 nr->va = 0;
584 nr->vr = 0;
585 nr->vs = 0;
586 nr->vl = 0;
587
588 sk->nr = nr;
589 nr->sk = sk;
590
591 return sk;
592 }
593
594 static int nr_dup(struct socket *newsock, struct socket *oldsock)
595 {
596 struct sock *sk = (struct sock *)oldsock->data;
597
598 return nr_create(newsock, sk->protocol);
599 }
600
601 static int nr_release(struct socket *sock, struct socket *peer)
602 {
603 struct sock *sk = (struct sock *)sock->data;
604
605 if (sk == NULL) return 0;
606
607 if (sk->type == SOCK_SEQPACKET) {
608 switch (sk->nr->state) {
609 case NR_STATE_0:
610 sk->state = TCP_CLOSE;
611 sk->state_change(sk);
612 sk->dead = 1;
613 nr_destroy_socket(sk);
614 break;
615
616 case NR_STATE_1:
617 sk->nr->state = NR_STATE_0;
618 sk->state = TCP_CLOSE;
619 sk->state_change(sk);
620 sk->dead = 1;
621 nr_destroy_socket(sk);
622 break;
623
624 case NR_STATE_2:
625 nr_write_internal(sk, NR_DISCACK);
626 sk->nr->state = NR_STATE_0;
627 sk->state = TCP_CLOSE;
628 sk->state_change(sk);
629 sk->dead = 1;
630 nr_destroy_socket(sk);
631 break;
632
633 case NR_STATE_3:
634 nr_clear_queues(sk);
635 sk->nr->n2count = 0;
636 nr_write_internal(sk, NR_DISCREQ);
637 sk->nr->t1timer = sk->nr->t1 = nr_calculate_t1(sk);
638 sk->nr->t2timer = 0;
639 sk->nr->t4timer = 0;
640 sk->nr->state = NR_STATE_2;
641 sk->state = TCP_CLOSE;
642 sk->state_change(sk);
643 sk->dead = 1;
644 sk->destroy = 1;
645 break;
646
647 default:
648 break;
649 }
650 } else {
651 sk->state = TCP_CLOSE;
652 sk->state_change(sk);
653 sk->dead = 1;
654 nr_destroy_socket(sk);
655 }
656
657 sock->data = NULL;
658 sk->socket = NULL;
659
660 return 0;
661 }
662
663 static int nr_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
664 {
665 struct sock *sk;
666 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
667 struct device *dev;
668 ax25_address *user, *source;
669
670 sk = (struct sock *)sock->data;
671
672 if (sk->zapped == 0)
673 return -EIO;
674
675 if (addr_len != sizeof(struct sockaddr_ax25) && addr_len != sizeof(struct full_sockaddr_ax25))
676 return -EINVAL;
677
678 if ((dev = nr_dev_get(&addr->fsa_ax25.sax25_call)) == NULL) {
679 if (sk->debug)
680 printk("NET/ROM: bind failed: invalid node callsign\n");
681 return -EADDRNOTAVAIL;
682 }
683
684
685
686
687 if (addr->fsa_ax25.sax25_ndigis == 1) {
688 if (!suser())
689 return -EPERM;
690 memcpy(&sk->nr->user_addr, &addr->fsa_digipeater[0], sizeof(ax25_address));
691 memcpy(&sk->nr->source_addr, &addr->fsa_ax25.sax25_call, sizeof(ax25_address));
692 } else {
693 source = &addr->fsa_ax25.sax25_call;
694
695 if ((user = ax25_findbyuid(current->euid)) == NULL) {
696 if (ax25_uid_policy && !suser())
697 return -EPERM;
698 user = source;
699 }
700
701 memcpy(&sk->nr->user_addr, user, sizeof(ax25_address));
702 memcpy(&sk->nr->source_addr, source, sizeof(ax25_address));
703 }
704
705 sk->nr->device = dev;
706 nr_insert_socket(sk);
707
708 sk->zapped = 0;
709
710 if (sk->debug)
711 printk("NET/ROM: socket is bound\n");
712
713 return 0;
714 }
715
716 static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
717 int addr_len, int flags)
718 {
719 struct sock *sk = (struct sock *)sock->data;
720 struct sockaddr_ax25 *addr = (struct sockaddr_ax25 *)uaddr;
721 ax25_address *user, *source = NULL;
722 struct device *dev;
723
724 if (sk->state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
725 sock->state = SS_CONNECTED;
726 return 0;
727 }
728
729 if (sk->state == TCP_CLOSE && sock->state == SS_CONNECTING) {
730 sock->state = SS_UNCONNECTED;
731 return -ECONNREFUSED;
732 }
733
734 if (sk->state == TCP_ESTABLISHED && sk->type == SOCK_SEQPACKET)
735 return -EISCONN;
736
737 sk->state = TCP_CLOSE;
738 sock->state = SS_UNCONNECTED;
739
740 if (addr_len != sizeof(struct sockaddr_ax25))
741 return -EINVAL;
742
743 if (sk->zapped) {
744 sk->zapped = 0;
745
746 if ((dev = nr_dev_first()) == NULL)
747 return -ENETUNREACH;
748
749 source = (ax25_address *)dev->dev_addr;
750
751 if ((user = ax25_findbyuid(current->euid)) == NULL) {
752 if (ax25_uid_policy && !suser())
753 return -EPERM;
754 user = source;
755 }
756
757 memcpy(&sk->nr->user_addr, user, sizeof(ax25_address));
758 memcpy(&sk->nr->source_addr, source, sizeof(ax25_address));
759
760 sk->nr->device = dev;
761
762 nr_insert_socket(sk);
763 }
764
765 memcpy(&sk->nr->dest_addr, &addr->sax25_call, sizeof(ax25_address));
766
767 while (nr_find_socket((unsigned char)circuit / 256, (unsigned char)circuit % 256, SOCK_SEQPACKET) != NULL)
768 circuit++;
769
770 sk->nr->my_index = circuit / 256;
771 sk->nr->my_id = circuit % 256;
772
773 circuit++;
774
775
776 sock->state = SS_CONNECTING;
777 sk->state = TCP_SYN_SENT;
778 nr_establish_data_link(sk);
779 sk->nr->state = NR_STATE_1;
780 nr_set_timer(sk);
781
782
783 if (sk->state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
784 return -EINPROGRESS;
785
786 cli();
787
788
789
790
791 while (sk->state == TCP_SYN_SENT) {
792 interruptible_sleep_on(sk->sleep);
793 if (current->signal & ~current->blocked) {
794 sti();
795 return -ERESTARTSYS;
796 }
797 }
798
799 if (sk->state != TCP_ESTABLISHED) {
800 sti();
801 sock->state = SS_UNCONNECTED;
802 return sock_error(sk);
803 }
804
805 sock->state = SS_CONNECTED;
806
807 sti();
808
809 return 0;
810 }
811
812 static int nr_socketpair(struct socket *sock1, struct socket *sock2)
813 {
814 return -EOPNOTSUPP;
815 }
816
817 static int nr_accept(struct socket *sock, struct socket *newsock, int flags)
818 {
819 struct sock *sk;
820 struct sock *newsk;
821 struct sk_buff *skb;
822
823 if (newsock->data)
824 kfree_s(newsock->data, sizeof(struct sock));
825
826 newsock->data = NULL;
827
828 sk = (struct sock *)sock->data;
829
830 if (sk->type != SOCK_SEQPACKET)
831 return -EOPNOTSUPP;
832
833 if (sk->state != TCP_LISTEN)
834 return -EINVAL;
835
836
837
838
839
840 do {
841 cli();
842 if ((skb = skb_dequeue(&sk->receive_queue)) == NULL) {
843 if (flags & O_NONBLOCK) {
844 sti();
845 return 0;
846 }
847 interruptible_sleep_on(sk->sleep);
848 if (current->signal & ~current->blocked) {
849 sti();
850 return -ERESTARTSYS;
851 }
852 }
853 } while (skb == NULL);
854
855 newsk = skb->sk;
856 newsk->pair = NULL;
857 sti();
858
859
860 skb->sk = NULL;
861 kfree_skb(skb, FREE_READ);
862 sk->ack_backlog--;
863 newsock->data = newsk;
864
865 return 0;
866 }
867
868 static int nr_getname(struct socket *sock, struct sockaddr *uaddr,
869 int *uaddr_len, int peer)
870 {
871 struct full_sockaddr_ax25 *sax = (struct full_sockaddr_ax25 *)uaddr;
872 struct sock *sk;
873
874 sk = (struct sock *)sock->data;
875
876 if (peer != 0) {
877 if (sk->state != TCP_ESTABLISHED)
878 return -ENOTCONN;
879 sax->fsa_ax25.sax25_family = AF_NETROM;
880 sax->fsa_ax25.sax25_ndigis = 1;
881 memcpy(&sax->fsa_ax25.sax25_call, &sk->nr->user_addr, sizeof(ax25_address));
882 memcpy(&sax->fsa_digipeater[0], &sk->nr->dest_addr, sizeof(ax25_address));
883 *uaddr_len = sizeof(struct sockaddr_ax25) + sizeof(ax25_address);
884 } else {
885 sax->fsa_ax25.sax25_family = AF_NETROM;
886 sax->fsa_ax25.sax25_ndigis = 0;
887 memcpy(&sax->fsa_ax25.sax25_call, &sk->nr->source_addr, sizeof(ax25_address));
888 *uaddr_len = sizeof(struct sockaddr_ax25);
889 }
890
891 return 0;
892 }
893
894 int nr_rx_frame(struct sk_buff *skb, struct device *dev)
895 {
896 struct sock *sk;
897 struct sock *make;
898 ax25_address *src, *dest, *user;
899 unsigned short circuit_index, circuit_id;
900 unsigned short frametype, window, timeout;
901
902
903 skb->sk = NULL;
904
905
906
907
908
909 src = (ax25_address *)(skb->data + 0);
910 dest = (ax25_address *)(skb->data + 7);
911
912 circuit_index = skb->data[15];
913 circuit_id = skb->data[16];
914 frametype = skb->data[19];
915
916 #ifdef CONFIG_INET
917
918
919
920 if ((frametype & 0x0F) == NR_PROTOEXT && circuit_index == NR_PROTO_IP && circuit_id == NR_PROTO_IP) {
921 skb_pull(skb, NR_NETWORK_LEN + NR_TRANSPORT_LEN);
922 skb->h.raw = skb->data;
923
924 return nr_rx_ip(skb, dev);
925 }
926 #endif
927
928
929
930
931
932 if (((frametype & 0x0F) != NR_CONNREQ && (sk = nr_find_socket(circuit_index, circuit_id, SOCK_SEQPACKET)) != NULL) ||
933 ((frametype & 0x0F) == NR_CONNREQ && (sk = nr_find_peer(circuit_index, circuit_id, SOCK_SEQPACKET)) != NULL)) {
934 skb->h.raw = skb->data;
935
936 if ((frametype & 0x0F) == NR_CONNACK && skb->len == 22)
937 sk->nr->bpqext = 1;
938 else
939 sk->nr->bpqext = 0;
940
941 return nr_process_rx_frame(sk, skb);
942 }
943
944 if ((frametype & 0x0F) != NR_CONNREQ)
945 return 0;
946
947 sk = nr_find_listener(dest, SOCK_SEQPACKET);
948
949 user = (ax25_address *)(skb->data + 21);
950
951 if (sk == NULL || sk->ack_backlog == sk->max_ack_backlog || (make = nr_make_new(sk)) == NULL) {
952 nr_transmit_dm(skb);
953 return 0;
954 }
955
956 window = skb->data[20];
957
958 skb->sk = make;
959 make->state = TCP_ESTABLISHED;
960
961
962 memcpy(&make->nr->source_addr, dest, sizeof(ax25_address));
963 memcpy(&make->nr->dest_addr, src, sizeof(ax25_address));
964 memcpy(&make->nr->user_addr, user, sizeof(ax25_address));
965
966 make->nr->your_index = circuit_index;
967 make->nr->your_id = circuit_id;
968
969 make->nr->my_index = circuit / 256;
970 make->nr->my_id = circuit % 256;
971
972 circuit++;
973
974
975 if (window < make->window)
976 make->window = window;
977
978
979 if (skb->len == 37) {
980 timeout = skb->data[36] * 256 + skb->data[35];
981 if (timeout * PR_SLOWHZ < make->nr->rtt * 2)
982 make->nr->rtt = (timeout * PR_SLOWHZ) / 2;
983 make->nr->bpqext = 1;
984 } else {
985 make->nr->bpqext = 0;
986 }
987
988 nr_write_internal(make, NR_CONNACK);
989
990 make->nr->condition = 0x00;
991 make->nr->vs = 0;
992 make->nr->va = 0;
993 make->nr->vr = 0;
994 make->nr->vl = 0;
995 make->nr->state = NR_STATE_3;
996 sk->ack_backlog++;
997 make->pair = sk;
998
999 nr_insert_socket(make);
1000
1001 skb_queue_head(&sk->receive_queue, skb);
1002
1003 nr_set_timer(make);
1004
1005 if (!sk->dead)
1006 sk->data_ready(sk, skb->len);
1007
1008 return 1;
1009 }
1010
1011 static int nr_sendmsg(struct socket *sock, struct msghdr *msg, int len, int noblock, int flags)
1012 {
1013 struct sock *sk = (struct sock *)sock->data;
1014 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1015 int err;
1016 struct sockaddr_ax25 sax;
1017 struct sk_buff *skb;
1018 unsigned char *asmptr;
1019 int size;
1020
1021 if (sk->err)
1022 return sock_error(sk);
1023
1024 if (flags)
1025 return -EINVAL;
1026
1027 if (sk->zapped)
1028 return -EADDRNOTAVAIL;
1029
1030 if (sk->nr->device == NULL)
1031 return -ENETUNREACH;
1032
1033 if (usax) {
1034 if (msg->msg_namelen < sizeof(sax))
1035 return -EINVAL;
1036 memcpy(&sax, usax, sizeof(sax));
1037 if (sk->type == SOCK_SEQPACKET && memcmp(&sk->nr->dest_addr, &sax.sax25_call, sizeof(ax25_address)) != 0)
1038 return -EISCONN;
1039 if (sax.sax25_family != AF_NETROM)
1040 return -EINVAL;
1041 } else {
1042 if (sk->state != TCP_ESTABLISHED)
1043 return -ENOTCONN;
1044 sax.sax25_family = AF_NETROM;
1045 memcpy(&sax.sax25_call, &sk->nr->dest_addr, sizeof(ax25_address));
1046 }
1047
1048 if (sk->debug)
1049 printk("NET/ROM: sendto: Addresses built.\n");
1050
1051
1052 if (sk->debug)
1053 printk("NET/ROM: sendto: building packet.\n");
1054
1055 size = len + AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + NR_NETWORK_LEN + NR_TRANSPORT_LEN;
1056
1057 if ((skb = sock_alloc_send_skb(sk, size, 0, 0, &err)) == NULL)
1058 return err;
1059
1060 skb->sk = sk;
1061 skb->free = 1;
1062 skb->arp = 1;
1063
1064 skb_reserve(skb, size - len);
1065
1066
1067
1068
1069
1070 asmptr = skb_push(skb, NR_TRANSPORT_LEN);
1071
1072 if (sk->debug)
1073 printk("Building NET/ROM Header.\n");
1074
1075
1076
1077 *asmptr++ = sk->nr->your_index;
1078 *asmptr++ = sk->nr->your_id;
1079 *asmptr++ = 0;
1080 *asmptr++ = 0;
1081 *asmptr++ = NR_INFO;
1082
1083 if (sk->debug)
1084 printk("Built header.\n");
1085
1086
1087
1088
1089
1090 skb->h.raw = skb_put(skb, len);
1091
1092 asmptr = skb->h.raw;
1093
1094 if (sk->debug)
1095 printk("NET/ROM: Appending user data\n");
1096
1097
1098 memcpy_fromiovec(asmptr, msg->msg_iov, len);
1099
1100 if (sk->debug)
1101 printk("NET/ROM: Transmitting buffer\n");
1102
1103 if (sk->state != TCP_ESTABLISHED) {
1104 kfree_skb(skb, FREE_WRITE);
1105 return -ENOTCONN;
1106 }
1107
1108 nr_output(sk, skb);
1109
1110 return len;
1111 }
1112
1113
1114 static int nr_recvmsg(struct socket *sock, struct msghdr *msg, int size, int noblock,
1115 int flags, int *addr_len)
1116 {
1117 struct sock *sk = (struct sock *)sock->data;
1118 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1119 int copied;
1120 struct sk_buff *skb;
1121 int er;
1122
1123 if (sk->err)
1124 return sock_error(sk);
1125
1126 if (addr_len != NULL)
1127 *addr_len = sizeof(*sax);
1128
1129
1130
1131
1132
1133 if (sk->type == SOCK_SEQPACKET && sk->state != TCP_ESTABLISHED)
1134 return -ENOTCONN;
1135
1136
1137 if ((skb = skb_recv_datagram(sk, flags, noblock, &er)) == NULL)
1138 return er;
1139
1140 if (!sk->nr->hdrincl) {
1141 skb_pull(skb, NR_NETWORK_LEN + NR_TRANSPORT_LEN);
1142 skb->h.raw = skb->data;
1143 }
1144
1145 copied = (size < skb->len) ? size : skb->len;
1146 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1147
1148 if (sax != NULL) {
1149 struct sockaddr_ax25 addr;
1150
1151 addr.sax25_family = AF_NETROM;
1152 memcpy(&addr.sax25_call, skb->data + 7, sizeof(ax25_address));
1153
1154 memcpy(sax, &addr, sizeof(*sax));
1155
1156 *addr_len = sizeof(*sax);
1157 }
1158
1159 skb_free_datagram(skb);
1160
1161 return copied;
1162 }
1163
1164 static int nr_shutdown(struct socket *sk, int how)
1165 {
1166 return -EOPNOTSUPP;
1167 }
1168
1169 static int nr_select(struct socket *sock , int sel_type, select_table *wait)
1170 {
1171 struct sock *sk = (struct sock *)sock->data;
1172
1173 return datagram_select(sk, sel_type, wait);
1174 }
1175
1176 static int nr_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1177 {
1178 struct sock *sk = (struct sock *)sock->data;
1179 int err;
1180 long amount = 0;
1181
1182 switch (cmd) {
1183 case TIOCOUTQ:
1184 if ((err = verify_area(VERIFY_WRITE, (void *)arg, sizeof(unsigned long))) != 0)
1185 return err;
1186 amount = sk->sndbuf - sk->wmem_alloc;
1187 if (amount < 0)
1188 amount = 0;
1189 put_fs_long(amount, (unsigned long *)arg);
1190 return 0;
1191
1192 case TIOCINQ:
1193 {
1194 struct sk_buff *skb;
1195
1196 if ((skb = skb_peek(&sk->receive_queue)) != NULL)
1197 amount = skb->len - 20;
1198 if ((err = verify_area(VERIFY_WRITE, (void *)arg, sizeof(unsigned long))) != 0)
1199 return err;
1200 put_fs_long(amount, (unsigned long *)arg);
1201 return 0;
1202 }
1203
1204 case SIOCGSTAMP:
1205 if (sk != NULL) {
1206 if (sk->stamp.tv_sec==0)
1207 return -ENOENT;
1208 if ((err = verify_area(VERIFY_WRITE,(void *)arg,sizeof(struct timeval))) != 0)
1209 return err;
1210 memcpy_tofs((void *)arg, &sk->stamp, sizeof(struct timeval));
1211 return 0;
1212 }
1213 return -EINVAL;
1214
1215 case SIOCGIFADDR:
1216 case SIOCSIFADDR:
1217 case SIOCGIFDSTADDR:
1218 case SIOCSIFDSTADDR:
1219 case SIOCGIFBRDADDR:
1220 case SIOCSIFBRDADDR:
1221 case SIOCGIFNETMASK:
1222 case SIOCSIFNETMASK:
1223 case SIOCGIFMETRIC:
1224 case SIOCSIFMETRIC:
1225 return -EINVAL;
1226
1227 case SIOCADDRT:
1228 case SIOCDELRT:
1229 case SIOCNRDECOBS:
1230 case SIOCNRRTCTL:
1231 if (!suser()) return -EPERM;
1232 return nr_rt_ioctl(cmd, (void *)arg);
1233
1234 case SIOCNRGETPARMS:
1235 {
1236 struct nr_parms_struct nr_parms;
1237 if ((err = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct nr_parms_struct))) != 0)
1238 return err;
1239 memcpy_fromfs(&nr_parms, (void *)arg, sizeof(struct nr_parms_struct));
1240 nr_parms = nr_default;
1241 memcpy_tofs((void *)arg, &nr_parms, sizeof(struct nr_parms_struct));
1242 return 0;
1243 }
1244
1245 case SIOCNRSETPARMS:
1246 {
1247 struct nr_parms_struct nr_parms;
1248 if (!suser()) return -EPERM;
1249 if ((err = verify_area(VERIFY_READ, (void *)arg, sizeof(struct nr_parms_struct))) != 0)
1250 return err;
1251 memcpy_fromfs(&nr_parms, (void *)arg, sizeof(struct nr_parms_struct));
1252 nr_default = nr_parms;
1253 return 0;
1254 }
1255
1256 default:
1257 return dev_ioctl(cmd, (void *)arg);
1258 }
1259
1260
1261 return(0);
1262 }
1263
1264 static int nr_get_info(char *buffer, char **start, off_t offset, int length, int dummy)
1265 {
1266 struct sock *s;
1267 struct device *dev;
1268 const char *devname;
1269 int len = 0;
1270 off_t pos = 0;
1271 off_t begin = 0;
1272
1273 cli();
1274
1275 len += sprintf(buffer, "user_addr dest_node src_node dev my your st vs vr va t1 t2 n2 rtt wnd Snd-Q Rcv-Q\n");
1276
1277 for (s = nr_list; s != NULL; s = s->next) {
1278 if ((dev = s->nr->device) == NULL)
1279 devname = "???";
1280 else
1281 devname = dev->name;
1282
1283 len += sprintf(buffer + len, "%-9s ",
1284 ax2asc(&s->nr->user_addr));
1285 len += sprintf(buffer + len, "%-9s ",
1286 ax2asc(&s->nr->dest_addr));
1287 len += sprintf(buffer + len, "%-9s %-3s %02X/%02X %02X/%02X %2d %2d %2d %2d %3d/%03d %2d/%02d %2d/%02d %3d %3d %5ld %5ld\n",
1288 ax2asc(&s->nr->source_addr),
1289 devname, s->nr->my_index, s->nr->my_id,
1290 s->nr->your_index, s->nr->your_id,
1291 s->nr->state,
1292 s->nr->vs, s->nr->vr, s->nr->va,
1293 s->nr->t1timer / PR_SLOWHZ,
1294 s->nr->t1 / PR_SLOWHZ,
1295 s->nr->t2timer / PR_SLOWHZ,
1296 s->nr->t2 / PR_SLOWHZ,
1297 s->nr->n2count, s->nr->n2,
1298 s->nr->rtt / PR_SLOWHZ,
1299 s->window,
1300 s->wmem_alloc, s->rmem_alloc);
1301
1302 pos = begin + len;
1303
1304 if (pos < offset) {
1305 len = 0;
1306 begin = pos;
1307 }
1308
1309 if (pos > offset + length)
1310 break;
1311 }
1312
1313 sti();
1314
1315 *start = buffer + (offset - begin);
1316 len -= (offset - begin);
1317
1318 if (len > length) len = length;
1319
1320 return(len);
1321 }
1322
1323 static struct proto_ops nr_proto_ops = {
1324 AF_NETROM,
1325
1326 nr_create,
1327 nr_dup,
1328 nr_release,
1329 nr_bind,
1330 nr_connect,
1331 nr_socketpair,
1332 nr_accept,
1333 nr_getname,
1334 nr_select,
1335 nr_ioctl,
1336 nr_listen,
1337 nr_shutdown,
1338 nr_setsockopt,
1339 nr_getsockopt,
1340 nr_fcntl,
1341 nr_sendmsg,
1342 nr_recvmsg
1343 };
1344
1345 static struct notifier_block nr_dev_notifier = {
1346 nr_device_event,
1347 0
1348 };
1349
1350 void nr_proto_init(struct net_proto *pro)
1351 {
1352 sock_register(nr_proto_ops.family, &nr_proto_ops);
1353 register_netdevice_notifier(&nr_dev_notifier);
1354 printk("G4KLX NET/ROM for Linux. Version 0.4 ALPHA for AX25.030 Linux 1.3.45\n");
1355
1356 nr_default.quality = NR_DEFAULT_QUAL;
1357 nr_default.obs_count = NR_DEFAULT_OBS;
1358 nr_default.ttl = NR_DEFAULT_TTL;
1359 nr_default.timeout = NR_DEFAULT_T1;
1360 nr_default.ack_delay = NR_DEFAULT_T2;
1361 nr_default.busy_delay = NR_DEFAULT_T4;
1362 nr_default.tries = NR_DEFAULT_N2;
1363 nr_default.window = NR_DEFAULT_WINDOW;
1364
1365 proc_net_register(&(struct proc_dir_entry) {
1366 PROC_NET_NR, 2, "nr",
1367 S_IFREG | S_IRUGO, 1, 0, 0,
1368 0, &proc_net_inode_operations,
1369 nr_get_info
1370 });
1371 proc_net_register(&(struct proc_dir_entry) {
1372 PROC_NET_NR_NEIGH, 8, "nr_neigh",
1373 S_IFREG | S_IRUGO, 1, 0, 0,
1374 0, &proc_net_inode_operations,
1375 nr_neigh_get_info
1376 });
1377 proc_net_register(&(struct proc_dir_entry) {
1378 PROC_NET_NR_NODES, 8, "nr_nodes",
1379 S_IFREG | S_IRUGO, 1, 0, 0,
1380 0, &proc_net_inode_operations,
1381 nr_nodes_get_info
1382 });
1383 }
1384
1385 #endif