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