This source file includes following definitions.
- print_sk
- print_skb
- sk_inuse
- get_new_socknum
- put_sock
- remove_sock
- destroy_sock
- inet_fcntl
- inet_setsockopt
- inet_getsockopt
- sock_setsockopt
- sock_getsockopt
- inet_listen
- def_callback1
- def_callback2
- inet_create
- inet_dup
- inet_release
- inet_bind
- inet_connect
- inet_socketpair
- inet_accept
- inet_getname
- inet_read
- inet_recv
- inet_write
- inet_send
- inet_sendto
- inet_recvfrom
- inet_shutdown
- inet_select
- inet_ioctl
- sock_wmalloc
- sock_rmalloc
- sock_rspace
- sock_wspace
- sock_wfree
- sock_rfree
- get_sock
- release_sock
- inet_fioctl
- inet_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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65 #include <linux/config.h>
66 #include <linux/errno.h>
67 #include <linux/types.h>
68 #include <linux/socket.h>
69 #include <linux/in.h>
70 #include <linux/kernel.h>
71 #include <linux/major.h>
72 #include <linux/sched.h>
73 #include <linux/timer.h>
74 #include <linux/string.h>
75 #include <linux/sockios.h>
76 #include <linux/net.h>
77 #include <linux/fcntl.h>
78 #include <linux/mm.h>
79 #include <linux/interrupt.h>
80
81 #include <asm/segment.h>
82 #include <asm/system.h>
83
84 #include "inet.h"
85 #include "dev.h"
86 #include "ip.h"
87 #include "protocol.h"
88 #include "arp.h"
89 #include "route.h"
90 #include "tcp.h"
91 #include "udp.h"
92 #include "skbuff.h"
93 #include "sock.h"
94 #include "raw.h"
95 #include "icmp.h"
96
97
98 int inet_debug = DBG_OFF;
99
100
101 #define min(a,b) ((a)<(b)?(a):(b))
102
103 extern struct proto packet_prot;
104
105
106 void
107 print_sk(struct sock *sk)
108 {
109 if (!sk) {
110 printk(" print_sk(NULL)\n");
111 return;
112 }
113 printk(" wmem_alloc = %lu\n", sk->wmem_alloc);
114 printk(" rmem_alloc = %lu\n", sk->rmem_alloc);
115 printk(" send_head = %p\n", sk->send_head);
116 printk(" state = %d\n",sk->state);
117 printk(" wback = %p, rqueue = %p\n", sk->wback, sk->rqueue);
118 printk(" wfront = %p\n", sk->wfront);
119 printk(" daddr = %lX, saddr = %lX\n", sk->daddr,sk->saddr);
120 printk(" num = %d", sk->num);
121 printk(" next = %p\n", sk->next);
122 printk(" send_seq = %ld, acked_seq = %ld, copied_seq = %ld\n",
123 sk->send_seq, sk->acked_seq, sk->copied_seq);
124 printk(" rcv_ack_seq = %ld, window_seq = %ld, fin_seq = %ld\n",
125 sk->rcv_ack_seq, sk->window_seq, sk->fin_seq);
126 printk(" prot = %p\n", sk->prot);
127 printk(" pair = %p, back_log = %p\n", sk->pair,sk->back_log);
128 printk(" inuse = %d , blog = %d\n", sk->inuse, sk->blog);
129 printk(" dead = %d delay_acks=%d\n", sk->dead, sk->delay_acks);
130 printk(" retransmits = %ld, timeout = %d\n", sk->retransmits, sk->timeout);
131 printk(" cong_window = %d, packets_out = %d\n", sk->cong_window,
132 sk->packets_out);
133 printk(" urg = %d shutdown=%d\n", sk->urg, sk->shutdown);
134 }
135
136
137 void
138 print_skb(struct sk_buff *skb)
139 {
140 if (!skb) {
141 printk(" print_skb(NULL)\n");
142 return;
143 }
144 printk(" prev = %p, next = %p\n", skb->prev, skb->next);
145 printk(" sk = %p link3 = %p\n", skb->sk, skb->link3);
146 printk(" mem_addr = %p, mem_len = %lu\n", skb->mem_addr, skb->mem_len);
147 printk(" used = %d free = %d\n", skb->used,skb->free);
148 }
149
150
151
152 static int
153 sk_inuse(struct proto *prot, int num)
154 {
155 struct sock *sk;
156
157 for(sk = prot->sock_array[num & (SOCK_ARRAY_SIZE -1 )];
158 sk != NULL;
159 sk=sk->next) {
160 if (sk->num == num) return(1);
161 }
162 return(0);
163 }
164
165
166 unsigned short
167 get_new_socknum(struct proto *prot, unsigned short base)
168 {
169 static int start=0;
170
171
172
173
174
175 int i, j;
176 int best = 0;
177 int size = 32767;
178 struct sock *sk;
179
180 if (base == 0) base = PROT_SOCK+1+(start % 1024);
181 if (base <= PROT_SOCK) {
182 base += PROT_SOCK+(start % 1024);
183 }
184
185
186 for(i=0; i < SOCK_ARRAY_SIZE; i++) {
187 j = 0;
188 sk = prot->sock_array[(i+base+1) &(SOCK_ARRAY_SIZE -1)];
189 while(sk != NULL) {
190 sk = sk->next;
191 j++;
192 }
193 if (j == 0) {
194 start =(i+1+start )%1024;
195 DPRINTF((DBG_INET, "get_new_socknum returning %d, start = %d\n",
196 i + base + 1, start));
197 return(i+base+1);
198 }
199 if (j < size) {
200 best = i;
201 size = j;
202 }
203 }
204
205
206 while(sk_inuse(prot, base +best+1)) {
207 best += SOCK_ARRAY_SIZE;
208 }
209 DPRINTF((DBG_INET, "get_new_socknum returning %d, start = %d\n",
210 best + base + 1, start));
211 return(best+base+1);
212 }
213
214
215 void
216 put_sock(unsigned short num, struct sock *sk)
217 {
218 struct sock *sk1;
219 struct sock *sk2;
220 int mask;
221
222 DPRINTF((DBG_INET, "put_sock(num = %d, sk = %X\n", num, sk));
223 sk->num = num;
224 sk->next = NULL;
225 num = num &(SOCK_ARRAY_SIZE -1);
226
227
228 cli();
229 if (sk->prot->sock_array[num] == NULL) {
230 sk->prot->sock_array[num] = sk;
231 sti();
232 return;
233 }
234 sti();
235 for(mask = 0xff000000; mask != 0xffffffff; mask = (mask >> 8) | mask) {
236 if ((mask & sk->saddr) &&
237 (mask & sk->saddr) != (mask & 0xffffffff)) {
238 mask = mask << 8;
239 break;
240 }
241 }
242 DPRINTF((DBG_INET, "mask = %X\n", mask));
243
244 cli();
245 sk1 = sk->prot->sock_array[num];
246 for(sk2 = sk1; sk2 != NULL; sk2=sk2->next) {
247 if (!(sk2->saddr & mask)) {
248 if (sk2 == sk1) {
249 sk->next = sk->prot->sock_array[num];
250 sk->prot->sock_array[num] = sk;
251 sti();
252 return;
253 }
254 sk->next = sk2;
255 sk1->next= sk;
256 sti();
257 return;
258 }
259 sk1 = sk2;
260 }
261
262
263 sk->next = NULL;
264 sk1->next = sk;
265 sti();
266 }
267
268
269 static void
270 remove_sock(struct sock *sk1)
271 {
272 struct sock *sk2;
273
274 DPRINTF((DBG_INET, "remove_sock(sk1=%X)\n", sk1));
275 if (!sk1) {
276 printk("sock.c: remove_sock: sk1 == NULL\n");
277 return;
278 }
279
280 if (!sk1->prot) {
281 printk("sock.c: remove_sock: sk1->prot == NULL\n");
282 return;
283 }
284
285
286 cli();
287 sk2 = sk1->prot->sock_array[sk1->num &(SOCK_ARRAY_SIZE -1)];
288 if (sk2 == sk1) {
289 sk1->prot->sock_array[sk1->num &(SOCK_ARRAY_SIZE -1)] = sk1->next;
290 sti();
291 return;
292 }
293
294 while(sk2 && sk2->next != sk1) {
295 sk2 = sk2->next;
296 }
297
298 if (sk2) {
299 sk2->next = sk1->next;
300 sti();
301 return;
302 }
303 sti();
304
305 if (sk1->num != 0) DPRINTF((DBG_INET, "remove_sock: sock not found.\n"));
306 }
307
308
309 void
310 destroy_sock(struct sock *sk)
311 {
312 struct sk_buff *skb;
313
314 DPRINTF((DBG_INET, "destroying socket %X\n", sk));
315 sk->inuse = 1;
316
317
318 if (!sk->dead)
319 sk->write_space(sk);
320
321 remove_sock(sk);
322
323
324 delete_timer(sk);
325
326
327 if (sk->send_tmp != NULL)
328 {
329 IS_SKB(sk->send_tmp);
330 kfree_skb(sk->send_tmp, FREE_WRITE);
331 }
332
333
334 for(skb = sk->wfront; skb != NULL; )
335 {
336 struct sk_buff *skb2;
337
338 skb2=(struct sk_buff *)skb->next;
339 if (skb->magic != TCP_WRITE_QUEUE_MAGIC) {
340 printk("sock.c:destroy_sock write queue with bad magic(%X)\n",
341 skb->magic);
342 break;
343 }
344 IS_SKB(skb);
345 kfree_skb(skb, FREE_WRITE);
346 skb = skb2;
347 }
348
349 sk->wfront = NULL;
350 sk->wback = NULL;
351
352 if (sk->rqueue != NULL)
353 {
354 while((skb=skb_dequeue(&sk->rqueue))!=NULL)
355 {
356
357
358
359
360 if (skb->sk != NULL && skb->sk != sk)
361 {
362 IS_SKB(skb);
363 skb->sk->dead = 1;
364 skb->sk->prot->close(skb->sk, 0);
365 }
366 IS_SKB(skb);
367 kfree_skb(skb, FREE_READ);
368 }
369 }
370 sk->rqueue = NULL;
371
372
373 for(skb = sk->send_head; skb != NULL; )
374 {
375 struct sk_buff *skb2;
376
377
378
379
380
381 cli();
382
383
384
385 if (skb->next != NULL)
386 {
387 IS_SKB(skb);
388 skb_unlink(skb);
389 }
390 skb->dev = NULL;
391 sti();
392 skb2 = (struct sk_buff *)skb->link3;
393 kfree_skb(skb, FREE_WRITE);
394 skb = skb2;
395 }
396 sk->send_head = NULL;
397
398
399 if (sk->back_log != NULL)
400 {
401
402 printk("cleaning back_log. \n");
403 cli();
404 skb = (struct sk_buff *)sk->back_log;
405 do
406 {
407 struct sk_buff *skb2;
408
409 skb2 = (struct sk_buff *)skb->next;
410 kfree_skb(skb, FREE_READ);
411 skb = skb2;
412 }
413 while(skb != sk->back_log);
414 sti();
415 }
416 sk->back_log = NULL;
417
418
419 if (sk->pair)
420 {
421 sk->pair->dead = 1;
422 sk->pair->prot->close(sk->pair, 0);
423 sk->pair = NULL;
424 }
425
426
427
428
429
430
431 if (sk->rmem_alloc == 0 && sk->wmem_alloc == 0)
432 {
433 kfree_s((void *)sk,sizeof(*sk));
434 }
435 else
436 {
437
438
439 DPRINTF((DBG_INET, "possible memory leak in socket = %X\n", sk));
440 sk->destroy = 1;
441 sk->ack_backlog = 0;
442 sk->inuse = 0;
443 reset_timer(sk, TIME_DESTROY, SOCK_DESTROY_TIME);
444 }
445 DPRINTF((DBG_INET, "leaving destroy_sock\n"));
446 }
447
448
449 static int
450 inet_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
451 {
452 struct sock *sk;
453
454 sk = (struct sock *) sock->data;
455 if (sk == NULL) {
456 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
457 return(0);
458 }
459
460 switch(cmd) {
461 case F_SETOWN:
462
463
464
465
466
467 if (!suser() && current->pgrp != -arg &&
468 current->pid != arg) return(-EPERM);
469 sk->proc = arg;
470 return(0);
471 case F_GETOWN:
472 return(sk->proc);
473 default:
474 return(-EINVAL);
475 }
476 }
477
478
479
480
481
482 static int inet_setsockopt(struct socket *sock, int level, int optname,
483 char *optval, int optlen)
484 {
485 struct sock *sk = (struct sock *) sock->data;
486 if (level == SOL_SOCKET)
487 return sock_setsockopt(sk,level,optname,optval,optlen);
488 if (sk->prot->setsockopt==NULL)
489 return(-EOPNOTSUPP);
490 else
491 return sk->prot->setsockopt(sk,level,optname,optval,optlen);
492 }
493
494
495
496
497 static int inet_getsockopt(struct socket *sock, int level, int optname,
498 char *optval, int *optlen)
499 {
500 struct sock *sk = sock->data;
501 if (level == SOL_SOCKET)
502 return sock_getsockopt(sk,level,optname,optval,optlen);
503 if(sk->prot->getsockopt==NULL)
504 return(-EOPNOTSUPP);
505 else
506 return sk->prot->getsockopt(sk,level,optname,optval,optlen);
507 }
508
509
510
511
512
513
514 int sock_setsockopt(struct sock *sk, int level, int optname,
515 char *optval, int optlen)
516 {
517 int val;
518 int err;
519 struct linger ling;
520
521 if (optval == NULL)
522 return(-EINVAL);
523
524 err=verify_area(VERIFY_READ, optval, sizeof(int));
525 if(err)
526 return err;
527
528 val = get_fs_long((unsigned long *)optval);
529 switch(optname)
530 {
531 case SO_TYPE:
532 case SO_ERROR:
533 return(-ENOPROTOOPT);
534
535 case SO_DEBUG:
536 sk->debug=val?1:0;
537 case SO_DONTROUTE:
538 return(0);
539 case SO_BROADCAST:
540 sk->broadcast=val?1:0;
541 return 0;
542 case SO_SNDBUF:
543 if(val>32767)
544 val=32767;
545 if(val<256)
546 val=256;
547 sk->sndbuf=val;
548 return 0;
549 case SO_LINGER:
550 err=verify_area(VERIFY_READ,optval,sizeof(ling));
551 if(err)
552 return err;
553 memcpy_fromfs(&ling,optval,sizeof(ling));
554 if(ling.l_onoff==0)
555 sk->linger=0;
556 else
557 {
558 sk->lingertime=ling.l_linger;
559 sk->linger=1;
560 }
561 return 0;
562 case SO_RCVBUF:
563 if(val>32767)
564 val=32767;
565 if(val<256)
566 val=256;
567 sk->rcvbuf=val;
568 return(0);
569
570 case SO_REUSEADDR:
571 if (val)
572 sk->reuse = 1;
573 else
574 sk->reuse = 0;
575 return(0);
576
577 case SO_KEEPALIVE:
578 if (val)
579 sk->keepopen = 1;
580 else
581 sk->keepopen = 0;
582 return(0);
583
584 case SO_OOBINLINE:
585 if (val)
586 sk->urginline = 1;
587 else
588 sk->urginline = 0;
589 return(0);
590
591 case SO_NO_CHECK:
592 if (val)
593 sk->no_check = 1;
594 else
595 sk->no_check = 0;
596 return(0);
597
598 case SO_PRIORITY:
599 if (val >= 0 && val < DEV_NUMBUFFS)
600 {
601 sk->priority = val;
602 }
603 else
604 {
605 return(-EINVAL);
606 }
607 return(0);
608
609 default:
610 return(-ENOPROTOOPT);
611 }
612 }
613
614
615 int sock_getsockopt(struct sock *sk, int level, int optname,
616 char *optval, int *optlen)
617 {
618 int val;
619 int err;
620 struct linger ling;
621
622 switch(optname)
623 {
624 case SO_DEBUG:
625 val = sk->debug;
626 break;
627
628 case SO_DONTROUTE:
629 val = 0;
630 break;
631
632 case SO_BROADCAST:
633 val= sk->broadcast;
634 break;
635
636 case SO_LINGER:
637 err=verify_area(VERIFY_WRITE,optval,sizeof(ling));
638 if(err)
639 return err;
640 err=verify_area(VERIFY_WRITE,optlen,sizeof(int));
641 if(err)
642 return err;
643 put_fs_long(sizeof(ling),(unsigned long *)optlen);
644 ling.l_onoff=sk->linger;
645 ling.l_linger=sk->lingertime;
646 memcpy_tofs(optval,&ling,sizeof(ling));
647 return 0;
648
649 case SO_SNDBUF:
650 val=sk->sndbuf;
651 break;
652
653 case SO_RCVBUF:
654 val =sk->rcvbuf;
655 break;
656
657 case SO_REUSEADDR:
658 val = sk->reuse;
659 break;
660
661 case SO_KEEPALIVE:
662 val = sk->keepopen;
663 break;
664
665 case SO_TYPE:
666 if (sk->prot == &tcp_prot)
667 val = SOCK_STREAM;
668 else
669 val = SOCK_DGRAM;
670 break;
671
672 case SO_ERROR:
673 val = sk->err;
674 sk->err = 0;
675 break;
676
677 case SO_OOBINLINE:
678 val = sk->urginline;
679 break;
680
681 case SO_NO_CHECK:
682 val = sk->no_check;
683 break;
684
685 case SO_PRIORITY:
686 val = sk->priority;
687 break;
688
689 default:
690 return(-ENOPROTOOPT);
691 }
692 err=verify_area(VERIFY_WRITE, optlen, sizeof(int));
693 if(err)
694 return err;
695 put_fs_long(sizeof(int),(unsigned long *) optlen);
696
697 err=verify_area(VERIFY_WRITE, optval, sizeof(int));
698 if(err)
699 return err;
700 put_fs_long(val,(unsigned long *)optval);
701
702 return(0);
703 }
704
705
706
707
708 static int
709 inet_listen(struct socket *sock, int backlog)
710 {
711 struct sock *sk;
712
713 sk = (struct sock *) sock->data;
714 if (sk == NULL) {
715 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
716 return(0);
717 }
718
719
720 if (sk->num == 0) {
721 sk->num = get_new_socknum(sk->prot, 0);
722 if (sk->num == 0) return(-EAGAIN);
723 put_sock(sk->num, sk);
724 sk->dummy_th.source = ntohs(sk->num);
725 }
726
727
728 sk->max_ack_backlog = backlog;
729 if (sk->state != TCP_LISTEN) {
730 sk->ack_backlog = 0;
731 sk->state = TCP_LISTEN;
732 }
733 return(0);
734 }
735
736
737
738
739
740
741 static void def_callback1(struct sock *sk)
742 {
743 if(!sk->dead)
744 wake_up(sk->sleep);
745 }
746
747 static void def_callback2(struct sock *sk,int len)
748 {
749 if(!sk->dead)
750 wake_up(sk->sleep);
751 }
752
753
754 static int
755 inet_create(struct socket *sock, int protocol)
756 {
757 struct sock *sk;
758 struct proto *prot;
759 int err;
760
761 sk = (struct sock *) kmalloc(sizeof(*sk), GFP_KERNEL);
762 if (sk == NULL)
763 return(-ENOMEM);
764 sk->num = 0;
765 sk->reuse = 0;
766 switch(sock->type) {
767 case SOCK_STREAM:
768 case SOCK_SEQPACKET:
769 if (protocol && protocol != IPPROTO_TCP) {
770 kfree_s((void *)sk, sizeof(*sk));
771 return(-EPROTONOSUPPORT);
772 }
773 protocol = IPPROTO_TCP;
774 sk->no_check = TCP_NO_CHECK;
775 prot = &tcp_prot;
776 break;
777
778 case SOCK_DGRAM:
779 if (protocol && protocol != IPPROTO_UDP) {
780 kfree_s((void *)sk, sizeof(*sk));
781 return(-EPROTONOSUPPORT);
782 }
783 protocol = IPPROTO_UDP;
784 sk->no_check = UDP_NO_CHECK;
785 prot=&udp_prot;
786 break;
787
788 case SOCK_RAW:
789 if (!suser()) {
790 kfree_s((void *)sk, sizeof(*sk));
791 return(-EPERM);
792 }
793 if (!protocol) {
794 kfree_s((void *)sk, sizeof(*sk));
795 return(-EPROTONOSUPPORT);
796 }
797 prot = &raw_prot;
798 sk->reuse = 1;
799 sk->no_check = 0;
800
801
802
803 sk->num = protocol;
804 break;
805
806 case SOCK_PACKET:
807 if (!suser()) {
808 kfree_s((void *)sk, sizeof(*sk));
809 return(-EPERM);
810 }
811 if (!protocol) {
812 kfree_s((void *)sk, sizeof(*sk));
813 return(-EPROTONOSUPPORT);
814 }
815 prot = &packet_prot;
816 sk->reuse = 1;
817 sk->no_check = 0;
818
819
820 sk->num = protocol;
821 break;
822
823 default:
824 kfree_s((void *)sk, sizeof(*sk));
825 return(-ESOCKTNOSUPPORT);
826 }
827 sk->socket = sock;
828 #ifdef CONFIG_TCP_NAGLE_OFF
829 sk->nonagle = 1;
830 #else
831 sk->nonagle = 0;
832 #endif
833 sk->type = sock->type;
834 sk->protocol = protocol;
835 sk->wmem_alloc = 0;
836 sk->rmem_alloc = 0;
837 sk->sndbuf = SK_WMEM_MAX;
838 sk->rcvbuf = SK_RMEM_MAX;
839 sk->pair = NULL;
840 sk->opt = NULL;
841 sk->send_seq = 0;
842 sk->acked_seq = 0;
843 sk->copied_seq = 0;
844 sk->fin_seq = 0;
845 sk->proc = 0;
846 sk->rtt = TCP_WRITE_TIME;
847 sk->mdev = 0;
848 sk->backoff = 0;
849 sk->packets_out = 0;
850 sk->cong_window = 1;
851 sk->exp_growth = 1;
852
853 sk->urginline = 0;
854 sk->intr = 0;
855 sk->linger = 0;
856 sk->destroy = 0;
857
858 sk->priority = 1;
859 sk->shutdown = 0;
860 sk->urg = 0;
861 sk->keepopen = 0;
862 sk->zapped = 0;
863 sk->done = 0;
864 sk->ack_backlog = 0;
865 sk->window = 0;
866 sk->bytes_rcv = 0;
867 sk->state = TCP_CLOSE;
868 sk->dead = 0;
869 sk->ack_timed = 0;
870 sk->send_tmp = NULL;
871 sk->mss = 0;
872 sk->debug = 0;
873
874
875 sk->max_unacked = 2048;
876
877
878
879 sk->max_ack_backlog = 0;
880 sk->inuse = 0;
881 sk->delay_acks = 0;
882 sk->wback = NULL;
883 sk->wfront = NULL;
884 sk->rqueue = NULL;
885 sk->mtu = 576;
886 sk->prot = prot;
887 sk->sleep = sock->wait;
888 sk->daddr = 0;
889 sk->saddr = my_addr();
890 sk->err = 0;
891 sk->next = NULL;
892 sk->pair = NULL;
893 sk->send_tail = NULL;
894 sk->send_head = NULL;
895 sk->timeout = 0;
896 sk->broadcast = 0;
897 sk->timer.data = (unsigned long)sk;
898 sk->timer.function = &net_timer;
899 sk->back_log = NULL;
900 sk->blog = 0;
901 sock->data =(void *) sk;
902 sk->dummy_th.doff = sizeof(sk->dummy_th)/4;
903 sk->dummy_th.res1=0;
904 sk->dummy_th.res2=0;
905 sk->dummy_th.urg_ptr = 0;
906 sk->dummy_th.fin = 0;
907 sk->dummy_th.syn = 0;
908 sk->dummy_th.rst = 0;
909 sk->dummy_th.psh = 0;
910 sk->dummy_th.ack = 0;
911 sk->dummy_th.urg = 0;
912 sk->dummy_th.dest = 0;
913
914 sk->ip_tos=0;
915 sk->ip_ttl=64;
916
917 sk->state_change = def_callback1;
918 sk->data_ready = def_callback2;
919 sk->write_space = def_callback1;
920 sk->error_report = def_callback1;
921
922 if (sk->num) {
923
924
925
926
927
928
929 put_sock(sk->num, sk);
930 sk->dummy_th.source = ntohs(sk->num);
931 }
932
933 if (sk->prot->init) {
934 err = sk->prot->init(sk);
935 if (err != 0) {
936 destroy_sock(sk);
937 return(err);
938 }
939 }
940 return(0);
941 }
942
943
944 static int
945 inet_dup(struct socket *newsock, struct socket *oldsock)
946 {
947 return(inet_create(newsock,
948 ((struct sock *)(oldsock->data))->protocol));
949 }
950
951
952
953 static int
954 inet_release(struct socket *sock, struct socket *peer)
955 {
956 struct sock *sk;
957
958 sk = (struct sock *) sock->data;
959 if (sk == NULL) return(0);
960
961 DPRINTF((DBG_INET, "inet_release(sock = %X, peer = %X)\n", sock, peer));
962 sk->state_change(sk);
963
964
965
966
967
968
969
970 if (sk->linger == 0) {
971 sk->prot->close(sk,0);
972 sk->dead = 1;
973 } else {
974 DPRINTF((DBG_INET, "sk->linger set.\n"));
975 sk->prot->close(sk, 0);
976 cli();
977 if (sk->lingertime)
978 current->timeout = jiffies + HZ*sk->lingertime;
979 while(sk->state != TCP_CLOSE && current->timeout>0) {
980 interruptible_sleep_on(sk->sleep);
981 if (current->signal & ~current->blocked) {
982 sti();
983 current->timeout=0;
984 return(-ERESTARTSYS);
985 }
986 }
987 current->timeout=0;
988 sti();
989 sk->dead = 1;
990 }
991 sk->inuse = 1;
992
993
994 release_sock(sk);
995 sock->data = NULL;
996 DPRINTF((DBG_INET, "inet_release returning\n"));
997 return(0);
998 }
999
1000
1001
1002
1003
1004
1005 static int
1006 inet_bind(struct socket *sock, struct sockaddr *uaddr,
1007 int addr_len)
1008 {
1009 struct sockaddr_in addr;
1010 struct sock *sk, *sk2;
1011 unsigned short snum;
1012 int err;
1013
1014 sk = (struct sock *) sock->data;
1015 if (sk == NULL) {
1016 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1017 return(0);
1018 }
1019
1020
1021 if (sk->state != TCP_CLOSE) return(-EIO);
1022 if (sk->num != 0) return(-EINVAL);
1023
1024 err=verify_area(VERIFY_READ, uaddr, addr_len);
1025 if(err)
1026 return err;
1027 memcpy_fromfs(&addr, uaddr, min(sizeof(addr), addr_len));
1028
1029 snum = ntohs(addr.sin_port);
1030 DPRINTF((DBG_INET, "bind sk =%X to port = %d\n", sk, snum));
1031 sk = (struct sock *) sock->data;
1032
1033
1034
1035
1036
1037
1038 if (snum == 0) {
1039 snum = get_new_socknum(sk->prot, 0);
1040 }
1041 if (snum < PROT_SOCK && !suser()) return(-EACCES);
1042
1043 if (addr.sin_addr.s_addr!=0 && chk_addr(addr.sin_addr.s_addr)!=IS_MYADDR)
1044 return(-EADDRNOTAVAIL);
1045
1046 if (chk_addr(addr.sin_addr.s_addr) || addr.sin_addr.s_addr == 0)
1047 sk->saddr = addr.sin_addr.s_addr;
1048
1049 DPRINTF((DBG_INET, "sock_array[%d] = %X:\n", snum &(SOCK_ARRAY_SIZE -1),
1050 sk->prot->sock_array[snum &(SOCK_ARRAY_SIZE -1)]));
1051
1052
1053 cli();
1054 outside_loop:
1055 for(sk2 = sk->prot->sock_array[snum & (SOCK_ARRAY_SIZE -1)];
1056 sk2 != NULL; sk2 = sk2->next) {
1057 #if 1
1058 if (sk2->num != snum) continue;
1059
1060 #endif
1061 if (sk2->dead) {
1062 destroy_sock(sk2);
1063 goto outside_loop;
1064 }
1065 if (!sk->reuse) {
1066 sti();
1067 return(-EADDRINUSE);
1068 }
1069 if (sk2->num != snum) continue;
1070 if (sk2->saddr != sk->saddr) continue;
1071 if (!sk2->reuse) {
1072 sti();
1073 return(-EADDRINUSE);
1074 }
1075 }
1076 sti();
1077
1078 remove_sock(sk);
1079 put_sock(snum, sk);
1080 sk->dummy_th.source = ntohs(sk->num);
1081 sk->daddr = 0;
1082 sk->dummy_th.dest = 0;
1083 return(0);
1084 }
1085
1086
1087 static int
1088 inet_connect(struct socket *sock, struct sockaddr * uaddr,
1089 int addr_len, int flags)
1090 {
1091 struct sock *sk;
1092 int err;
1093
1094 sock->conn = NULL;
1095 sk = (struct sock *) sock->data;
1096 if (sk == NULL) {
1097 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1098 return(0);
1099 }
1100
1101 if (sock->state == SS_CONNECTING && sk->state == TCP_ESTABLISHED)
1102 {
1103 sock->state = SS_CONNECTED;
1104
1105 return 0;
1106 }
1107
1108 if (sock->state == SS_CONNECTING && sk->protocol == IPPROTO_TCP &&
1109 (flags & O_NONBLOCK))
1110 return -EALREADY;
1111
1112 if (sock->state != SS_CONNECTING) {
1113
1114 if (sk->num == 0) {
1115 sk->num = get_new_socknum(sk->prot, 0);
1116 if (sk->num == 0)
1117 return(-EAGAIN);
1118 put_sock(sk->num, sk);
1119 sk->dummy_th.source = htons(sk->num);
1120 }
1121
1122 if (sk->prot->connect == NULL)
1123 return(-EOPNOTSUPP);
1124
1125 err = sk->prot->connect(sk, (struct sockaddr_in *)uaddr, addr_len);
1126 if (err < 0) return(err);
1127
1128 sock->state = SS_CONNECTING;
1129 }
1130
1131 if (sk->state != TCP_ESTABLISHED &&(flags & O_NONBLOCK))
1132 return(-EINPROGRESS);
1133
1134 cli();
1135 while(sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
1136 {
1137 interruptible_sleep_on(sk->sleep);
1138 if (current->signal & ~current->blocked) {
1139 sti();
1140 return(-ERESTARTSYS);
1141 }
1142
1143
1144 if(sk->err && sk->protocol == IPPROTO_TCP)
1145 {
1146 sti();
1147 sock->state = SS_UNCONNECTED;
1148 err = -sk->err;
1149 sk->err=0;
1150 return err;
1151 }
1152 }
1153 sti();
1154 sock->state = SS_CONNECTED;
1155
1156 if (sk->state != TCP_ESTABLISHED && sk->err) {
1157 sock->state = SS_UNCONNECTED;
1158 err=sk->err;
1159 sk->err=0;
1160 return(err);
1161 }
1162 return(0);
1163 }
1164
1165
1166 static int
1167 inet_socketpair(struct socket *sock1, struct socket *sock2)
1168 {
1169 return(-EOPNOTSUPP);
1170 }
1171
1172
1173 static int
1174 inet_accept(struct socket *sock, struct socket *newsock, int flags)
1175 {
1176 struct sock *sk1, *sk2;
1177 int err;
1178
1179 sk1 = (struct sock *) sock->data;
1180 if (sk1 == NULL) {
1181 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1182 return(0);
1183 }
1184
1185
1186
1187
1188
1189
1190 if (newsock->data) kfree_s(newsock->data, sizeof(struct sock));
1191 newsock->data = NULL;
1192
1193 if (sk1->prot->accept == NULL) return(-EOPNOTSUPP);
1194
1195
1196 if (sk1->pair != NULL ) {
1197 sk2 = sk1->pair;
1198 sk1->pair = NULL;
1199 } else {
1200 sk2 = sk1->prot->accept(sk1,flags);
1201 if (sk2 == NULL) {
1202 if (sk1->err <= 0)
1203 printk("Warning sock.c:sk1->err <= 0. Returning non-error.\n");
1204 err=sk1->err;
1205 sk1->err=0;
1206 return(-err);
1207 }
1208 }
1209 newsock->data = (void *)sk2;
1210 sk2->sleep = newsock->wait;
1211 newsock->conn = NULL;
1212 if (flags & O_NONBLOCK) return(0);
1213
1214 cli();
1215 while(sk2->state == TCP_SYN_RECV) {
1216 interruptible_sleep_on(sk2->sleep);
1217 if (current->signal & ~current->blocked) {
1218 sti();
1219 sk1->pair = sk2;
1220 sk2->sleep = NULL;
1221 newsock->data = NULL;
1222 return(-ERESTARTSYS);
1223 }
1224 }
1225 sti();
1226
1227 if (sk2->state != TCP_ESTABLISHED && sk2->err > 0) {
1228
1229 err = -sk2->err;
1230 sk2->err=0;
1231 destroy_sock(sk2);
1232 newsock->data = NULL;
1233 return(err);
1234 }
1235 newsock->state = SS_CONNECTED;
1236 return(0);
1237 }
1238
1239
1240 static int
1241 inet_getname(struct socket *sock, struct sockaddr *uaddr,
1242 int *uaddr_len, int peer)
1243 {
1244 struct sockaddr_in sin;
1245 struct sock *sk;
1246 int len;
1247 int err;
1248
1249
1250 err = verify_area(VERIFY_WRITE,uaddr_len,sizeof(long));
1251 if(err)
1252 return err;
1253
1254 len=get_fs_long(uaddr_len);
1255
1256 err = verify_area(VERIFY_WRITE, uaddr, len);
1257 if(err)
1258 return err;
1259
1260
1261 if (len < sizeof(sin)) return(-EINVAL);
1262
1263 sin.sin_family = AF_INET;
1264 sk = (struct sock *) sock->data;
1265 if (sk == NULL) {
1266 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1267 return(0);
1268 }
1269 if (peer) {
1270 if (!tcp_connected(sk->state)) return(-ENOTCONN);
1271 sin.sin_port = sk->dummy_th.dest;
1272 sin.sin_addr.s_addr = sk->daddr;
1273 } else {
1274 sin.sin_port = sk->dummy_th.source;
1275 if (sk->saddr == 0) sin.sin_addr.s_addr = my_addr();
1276 else sin.sin_addr.s_addr = sk->saddr;
1277 }
1278 len = sizeof(sin);
1279
1280 memcpy_tofs(uaddr, &sin, sizeof(sin));
1281
1282 put_fs_long(len, uaddr_len);
1283 return(0);
1284 }
1285
1286
1287 static int
1288 inet_read(struct socket *sock, char *ubuf, int size, int noblock)
1289 {
1290 struct sock *sk;
1291
1292 sk = (struct sock *) sock->data;
1293 if (sk == NULL) {
1294 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1295 return(0);
1296 }
1297
1298
1299 if (sk->num == 0) {
1300 sk->num = get_new_socknum(sk->prot, 0);
1301 if (sk->num == 0) return(-EAGAIN);
1302 put_sock(sk->num, sk);
1303 sk->dummy_th.source = ntohs(sk->num);
1304 }
1305 return(sk->prot->read(sk, (unsigned char *) ubuf, size, noblock,0));
1306 }
1307
1308
1309 static int
1310 inet_recv(struct socket *sock, void *ubuf, int size, int noblock,
1311 unsigned flags)
1312 {
1313 struct sock *sk;
1314
1315 sk = (struct sock *) sock->data;
1316 if (sk == NULL) {
1317 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1318 return(0);
1319 }
1320
1321
1322 if (sk->num == 0) {
1323 sk->num = get_new_socknum(sk->prot, 0);
1324 if (sk->num == 0) return(-EAGAIN);
1325 put_sock(sk->num, sk);
1326 sk->dummy_th.source = ntohs(sk->num);
1327 }
1328 return(sk->prot->read(sk, (unsigned char *) ubuf, size, noblock, flags));
1329 }
1330
1331
1332 static int
1333 inet_write(struct socket *sock, char *ubuf, int size, int noblock)
1334 {
1335 struct sock *sk;
1336
1337 sk = (struct sock *) sock->data;
1338 if (sk == NULL) {
1339 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1340 return(0);
1341 }
1342 if (sk->shutdown & SEND_SHUTDOWN) {
1343 send_sig(SIGPIPE, current, 1);
1344 return(-EPIPE);
1345 }
1346
1347
1348 if (sk->num == 0) {
1349 sk->num = get_new_socknum(sk->prot, 0);
1350 if (sk->num == 0) return(-EAGAIN);
1351 put_sock(sk->num, sk);
1352 sk->dummy_th.source = ntohs(sk->num);
1353 }
1354
1355 return(sk->prot->write(sk, (unsigned char *) ubuf, size, noblock, 0));
1356 }
1357
1358
1359 static int
1360 inet_send(struct socket *sock, void *ubuf, int size, int noblock,
1361 unsigned flags)
1362 {
1363 struct sock *sk;
1364
1365 sk = (struct sock *) sock->data;
1366 if (sk == NULL) {
1367 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1368 return(0);
1369 }
1370 if (sk->shutdown & SEND_SHUTDOWN) {
1371 send_sig(SIGPIPE, current, 1);
1372 return(-EPIPE);
1373 }
1374
1375
1376 if (sk->num == 0) {
1377 sk->num = get_new_socknum(sk->prot, 0);
1378 if (sk->num == 0) return(-EAGAIN);
1379 put_sock(sk->num, sk);
1380 sk->dummy_th.source = ntohs(sk->num);
1381 }
1382
1383 return(sk->prot->write(sk, (unsigned char *) ubuf, size, noblock, flags));
1384 }
1385
1386
1387 static int
1388 inet_sendto(struct socket *sock, void *ubuf, int size, int noblock,
1389 unsigned flags, struct sockaddr *sin, int addr_len)
1390 {
1391 struct sock *sk;
1392
1393 sk = (struct sock *) sock->data;
1394 if (sk == NULL) {
1395 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1396 return(0);
1397 }
1398 if (sk->shutdown & SEND_SHUTDOWN) {
1399 send_sig(SIGPIPE, current, 1);
1400 return(-EPIPE);
1401 }
1402
1403 if (sk->prot->sendto == NULL) return(-EOPNOTSUPP);
1404
1405
1406 if (sk->num == 0) {
1407 sk->num = get_new_socknum(sk->prot, 0);
1408 if (sk->num == 0) return(-EAGAIN);
1409 put_sock(sk->num, sk);
1410 sk->dummy_th.source = ntohs(sk->num);
1411 }
1412
1413 return(sk->prot->sendto(sk, (unsigned char *) ubuf, size, noblock, flags,
1414 (struct sockaddr_in *)sin, addr_len));
1415 }
1416
1417
1418 static int
1419 inet_recvfrom(struct socket *sock, void *ubuf, int size, int noblock,
1420 unsigned flags, struct sockaddr *sin, int *addr_len )
1421 {
1422 struct sock *sk;
1423
1424 sk = (struct sock *) sock->data;
1425 if (sk == NULL) {
1426 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1427 return(0);
1428 }
1429
1430 if (sk->prot->recvfrom == NULL) return(-EOPNOTSUPP);
1431
1432
1433 if (sk->num == 0) {
1434 sk->num = get_new_socknum(sk->prot, 0);
1435 if (sk->num == 0) return(-EAGAIN);
1436 put_sock(sk->num, sk);
1437 sk->dummy_th.source = ntohs(sk->num);
1438 }
1439
1440 return(sk->prot->recvfrom(sk, (unsigned char *) ubuf, size, noblock, flags,
1441 (struct sockaddr_in*)sin, addr_len));
1442 }
1443
1444
1445 static int
1446 inet_shutdown(struct socket *sock, int how)
1447 {
1448 struct sock *sk;
1449
1450
1451
1452
1453
1454 how++;
1455
1456
1457 if (how & ~SHUTDOWN_MASK) return(-EINVAL);
1458 sk = (struct sock *) sock->data;
1459 if (sk == NULL) {
1460 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1461 return(0);
1462 }
1463 if (sock->state == SS_CONNECTING && sk->state == TCP_ESTABLISHED)
1464 sock->state = SS_CONNECTED;
1465
1466 if (!tcp_connected(sk->state)) return(-ENOTCONN);
1467 sk->shutdown |= how;
1468 if (sk->prot->shutdown) sk->prot->shutdown(sk, how);
1469 return(0);
1470 }
1471
1472
1473 static int
1474 inet_select(struct socket *sock, int sel_type, select_table *wait )
1475 {
1476 struct sock *sk;
1477
1478 sk = (struct sock *) sock->data;
1479 if (sk == NULL) {
1480 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1481 return(0);
1482 }
1483
1484 if (sk->prot->select == NULL) {
1485 DPRINTF((DBG_INET, "select on non-selectable socket.\n"));
1486 return(0);
1487 }
1488 return(sk->prot->select(sk, sel_type, wait));
1489 }
1490
1491
1492 static int
1493 inet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1494 {
1495 struct sock *sk;
1496 int err;
1497
1498 DPRINTF((DBG_INET, "INET: in inet_ioctl\n"));
1499 sk = NULL;
1500 if (sock && (sk = (struct sock *) sock->data) == NULL) {
1501 printk("AF_INET: Warning: sock->data = NULL: %d\n" , __LINE__);
1502 return(0);
1503 }
1504
1505 switch(cmd) {
1506 case FIOSETOWN:
1507 case SIOCSPGRP:
1508 err=verify_area(VERIFY_READ,(int *)arg,sizeof(long));
1509 if(err)
1510 return err;
1511 if (sk)
1512 sk->proc = get_fs_long((int *) arg);
1513 return(0);
1514 case FIOGETOWN:
1515 case SIOCGPGRP:
1516 if (sk) {
1517 err=verify_area(VERIFY_WRITE,(void *) arg, sizeof(long));
1518 if(err)
1519 return err;
1520 put_fs_long(sk->proc,(int *)arg);
1521 }
1522 return(0);
1523 #if 0
1524 case SIOCATMARK:
1525 printk("AF_INET: ioctl(SIOCATMARK, 0x%08X)\n",(void *) arg);
1526 return(-EINVAL);
1527 #endif
1528
1529 case DDIOCSDBG:
1530 return(dbg_ioctl((void *) arg, DBG_INET));
1531
1532 case SIOCADDRT:
1533 case SIOCDELRT:
1534 return(rt_ioctl(cmd,(void *) arg));
1535
1536 case SIOCDARP:
1537 case SIOCGARP:
1538 case SIOCSARP:
1539 return(arp_ioctl(cmd,(void *) arg));
1540
1541 case IP_SET_DEV:
1542 case SIOCGIFCONF:
1543 case SIOCGIFFLAGS:
1544 case SIOCSIFFLAGS:
1545 case SIOCGIFADDR:
1546 case SIOCSIFADDR:
1547 case SIOCGIFDSTADDR:
1548 case SIOCSIFDSTADDR:
1549 case SIOCGIFBRDADDR:
1550 case SIOCSIFBRDADDR:
1551 case SIOCGIFNETMASK:
1552 case SIOCSIFNETMASK:
1553 case SIOCGIFMETRIC:
1554 case SIOCSIFMETRIC:
1555 case SIOCGIFMEM:
1556 case SIOCSIFMEM:
1557 case SIOCGIFMTU:
1558 case SIOCSIFMTU:
1559 case SIOCSIFLINK:
1560 case SIOCGIFHWADDR:
1561 return(dev_ioctl(cmd,(void *) arg));
1562
1563 default:
1564 if (!sk || !sk->prot->ioctl) return(-EINVAL);
1565 return(sk->prot->ioctl(sk, cmd, arg));
1566 }
1567
1568 return(0);
1569 }
1570
1571
1572 struct sk_buff *
1573 sock_wmalloc(struct sock *sk, unsigned long size, int force,
1574 int priority)
1575 {
1576 if (sk) {
1577 if (sk->wmem_alloc + size < sk->sndbuf || force) {
1578 cli();
1579 sk->wmem_alloc+= size;
1580 sti();
1581 return(alloc_skb(size, priority));
1582 }
1583 DPRINTF((DBG_INET, "sock_wmalloc(%X,%d,%d,%d) returning NULL\n",
1584 sk, size, force, priority));
1585 return(NULL);
1586 }
1587 return(alloc_skb(size, priority));
1588 }
1589
1590
1591 struct sk_buff *
1592 sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority)
1593 {
1594 if (sk) {
1595 if (sk->rmem_alloc + size < sk->rcvbuf || force) {
1596 void *c = alloc_skb(size, priority);
1597 cli();
1598 if (c) sk->rmem_alloc += size;
1599 sti();
1600 return(c);
1601 }
1602 DPRINTF((DBG_INET, "sock_rmalloc(%X,%d,%d,%d) returning NULL\n",
1603 sk,size,force, priority));
1604 return(NULL);
1605 }
1606 return(alloc_skb(size, priority));
1607 }
1608
1609
1610 unsigned long
1611 sock_rspace(struct sock *sk)
1612 {
1613 int amt;
1614
1615 if (sk != NULL) {
1616 if (sk->rmem_alloc >= sk->rcvbuf-2*MIN_WINDOW) return(0);
1617 amt = min((sk->rcvbuf-sk->rmem_alloc)/2-MIN_WINDOW, MAX_WINDOW);
1618 if (amt < 0) return(0);
1619 return(amt);
1620 }
1621 return(0);
1622 }
1623
1624
1625 unsigned long
1626 sock_wspace(struct sock *sk)
1627 {
1628 if (sk != NULL) {
1629 if (sk->shutdown & SEND_SHUTDOWN) return(0);
1630 if (sk->wmem_alloc >= sk->sndbuf) return(0);
1631 return(sk->sndbuf-sk->wmem_alloc );
1632 }
1633 return(0);
1634 }
1635
1636
1637 void
1638 sock_wfree(struct sock *sk, void *mem, unsigned long size)
1639 {
1640 DPRINTF((DBG_INET, "sock_wfree(sk=%X, mem=%X, size=%d)\n", sk, mem, size));
1641
1642 IS_SKB(mem);
1643 kfree_skbmem(mem, size);
1644 if (sk) {
1645 sk->wmem_alloc -= size;
1646
1647
1648 if (!sk->dead) sk->write_space(sk);
1649 if (sk->destroy && sk->wmem_alloc == 0 && sk->rmem_alloc == 0) {
1650 DPRINTF((DBG_INET,
1651 "recovered lost memory, sock = %X\n", sk));
1652 }
1653 return;
1654 }
1655 }
1656
1657
1658 void
1659 sock_rfree(struct sock *sk, void *mem, unsigned long size)
1660 {
1661 DPRINTF((DBG_INET, "sock_rfree(sk=%X, mem=%X, size=%d)\n", sk, mem, size));
1662 IS_SKB(mem);
1663 kfree_skbmem(mem, size);
1664 if (sk) {
1665 sk->rmem_alloc -= size;
1666 if (sk->destroy && sk->wmem_alloc == 0 && sk->rmem_alloc == 0) {
1667 DPRINTF((DBG_INET,
1668 "recovered lot memory, sock = %X\n", sk));
1669 }
1670 }
1671 }
1672
1673
1674
1675
1676
1677
1678 struct sock *get_sock(struct proto *prot, unsigned short num,
1679 unsigned long raddr,
1680 unsigned short rnum, unsigned long laddr)
1681 {
1682 struct sock *s;
1683 unsigned short hnum;
1684
1685 hnum = ntohs(num);
1686 DPRINTF((DBG_INET, "get_sock(prot=%X, num=%d, raddr=%X, rnum=%d, laddr=%X)\n",
1687 prot, num, raddr, rnum, laddr));
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697 for(s = prot->sock_array[hnum & (SOCK_ARRAY_SIZE - 1)];
1698 s != NULL; s = s->next)
1699 {
1700 if (s->num != hnum)
1701 continue;
1702 if(s->dead && (s->state == TCP_CLOSE))
1703 continue;
1704 if(prot == &udp_prot)
1705 return s;
1706 if(ip_addr_match(s->daddr,raddr)==0)
1707 continue;
1708 if (s->dummy_th.dest != rnum && s->dummy_th.dest != 0)
1709 continue;
1710 if(ip_addr_match(s->saddr,laddr) == 0)
1711 continue;
1712 return(s);
1713 }
1714 return(NULL);
1715 }
1716
1717
1718 void release_sock(struct sock *sk)
1719 {
1720 if (!sk) {
1721 printk("sock.c: release_sock sk == NULL\n");
1722 return;
1723 }
1724 if (!sk->prot) {
1725
1726 return;
1727 }
1728
1729 if (sk->blog) return;
1730
1731
1732 cli();
1733 sk->inuse = 1;
1734 while(sk->back_log != NULL) {
1735 struct sk_buff *skb;
1736
1737 sk->blog = 1;
1738 skb =(struct sk_buff *)sk->back_log;
1739 DPRINTF((DBG_INET, "release_sock: skb = %X:\n", skb));
1740 if (skb->next != skb) {
1741 sk->back_log = skb->next;
1742 skb->prev->next = skb->next;
1743 skb->next->prev = skb->prev;
1744 } else {
1745 sk->back_log = NULL;
1746 }
1747 sti();
1748 DPRINTF((DBG_INET, "sk->back_log = %X\n", sk->back_log));
1749 if (sk->prot->rcv) sk->prot->rcv(skb, skb->dev, sk->opt,
1750 skb->saddr, skb->len, skb->daddr, 1,
1751
1752
1753 (struct inet_protocol *)sk->pair);
1754 cli();
1755 }
1756 sk->blog = 0;
1757 sk->inuse = 0;
1758 sti();
1759 if (sk->dead && sk->state == TCP_CLOSE) {
1760
1761 reset_timer(sk, TIME_DONE, min(sk->rtt * 2, TCP_DONE_TIME));
1762 }
1763 }
1764
1765
1766 static int
1767 inet_fioctl(struct inode *inode, struct file *file,
1768 unsigned int cmd, unsigned long arg)
1769 {
1770 int minor, ret;
1771
1772
1773 minor = MINOR(inode->i_rdev);
1774 if (minor != 0) return(-ENODEV);
1775
1776
1777 switch(minor) {
1778 case 0:
1779 ret = inet_ioctl(NULL, cmd, arg);
1780 break;
1781 case 1:
1782 ret = ip_ioctl(NULL, cmd, arg);
1783 break;
1784 case 2:
1785 ret = icmp_ioctl(NULL, cmd, arg);
1786 break;
1787 case 3:
1788 ret = tcp_ioctl(NULL, cmd, arg);
1789 break;
1790 case 4:
1791 ret = udp_ioctl(NULL, cmd, arg);
1792 break;
1793 default:
1794 ret = -ENODEV;
1795 }
1796
1797 return(ret);
1798 }
1799
1800
1801
1802
1803 static struct file_operations inet_fops = {
1804 NULL,
1805 NULL,
1806 NULL,
1807 NULL,
1808 NULL,
1809 inet_fioctl,
1810 NULL,
1811 NULL,
1812 NULL
1813 };
1814
1815
1816 static struct proto_ops inet_proto_ops = {
1817 AF_INET,
1818
1819 inet_create,
1820 inet_dup,
1821 inet_release,
1822 inet_bind,
1823 inet_connect,
1824 inet_socketpair,
1825 inet_accept,
1826 inet_getname,
1827 inet_read,
1828 inet_write,
1829 inet_select,
1830 inet_ioctl,
1831 inet_listen,
1832 inet_send,
1833 inet_recv,
1834 inet_sendto,
1835 inet_recvfrom,
1836 inet_shutdown,
1837 inet_setsockopt,
1838 inet_getsockopt,
1839 inet_fcntl,
1840 };
1841
1842 extern unsigned long seq_offset;
1843
1844
1845 void inet_proto_init(struct ddi_proto *pro)
1846 {
1847 struct inet_protocol *p;
1848 int i;
1849
1850 printk("Swansea University Computer Society Net2Debugged [1.27]\n");
1851
1852 if (register_chrdev(AF_INET_MAJOR, "af_inet", &inet_fops) < 0) {
1853 printk("%s: cannot register major device %d!\n",
1854 pro->name, AF_INET_MAJOR);
1855 return;
1856 }
1857
1858
1859 (void) sock_register(inet_proto_ops.family, &inet_proto_ops);
1860
1861 seq_offset = CURRENT_TIME*250;
1862
1863
1864 for(i = 0; i < SOCK_ARRAY_SIZE; i++) {
1865 tcp_prot.sock_array[i] = NULL;
1866 udp_prot.sock_array[i] = NULL;
1867 raw_prot.sock_array[i] = NULL;
1868 }
1869 printk("IP Protocols: ");
1870 for(p = inet_protocol_base; p != NULL;) {
1871 struct inet_protocol *tmp;
1872
1873 tmp = (struct inet_protocol *) p->next;
1874 inet_add_protocol(p);
1875 printk("%s%s",p->name,tmp?", ":"\n");
1876 p = tmp;
1877 }
1878
1879
1880 dev_init();
1881
1882
1883 bh_base[INET_BH].routine = inet_bh;
1884 }