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(" write_seq = %ld, acked_seq = %ld, copied_seq = %ld\n",
123 sk->write_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(" shutdown=%d\n", 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 while ((skb = tcp_dequeue_partial(sk)) != NULL)
328 {
329 IS_SKB(skb);
330 kfree_skb(skb, 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->dead && 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 = (struct sock *) 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_interruptible(sk->sleep);
745 }
746
747 static void def_callback2(struct sock *sk,int len)
748 {
749 if(!sk->dead)
750 wake_up_interruptible(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->write_seq = 0;
842 sk->acked_seq = 0;
843 sk->copied_seq = 0;
844 sk->fin_seq = 0;
845 sk->urg_seq = 0;
846 sk->urg_data = 0;
847 sk->proc = 0;
848 sk->rtt = TCP_WRITE_TIME << 3;
849 sk->rto = TCP_WRITE_TIME;
850 sk->mdev = 0;
851 sk->backoff = 0;
852 sk->packets_out = 0;
853 sk->cong_window = 1;
854 sk->cong_count = 0;
855 sk->ssthresh = 0;
856 sk->max_window = 0;
857 sk->urginline = 0;
858 sk->intr = 0;
859 sk->linger = 0;
860 sk->destroy = 0;
861
862 sk->priority = 1;
863 sk->shutdown = 0;
864 sk->keepopen = 0;
865 sk->zapped = 0;
866 sk->done = 0;
867 sk->ack_backlog = 0;
868 sk->window = 0;
869 sk->bytes_rcv = 0;
870 sk->state = TCP_CLOSE;
871 sk->dead = 0;
872 sk->ack_timed = 0;
873 sk->partial = NULL;
874 sk->user_mss = 0;
875 sk->debug = 0;
876
877
878 sk->max_unacked = 2048;
879
880
881
882 sk->max_ack_backlog = 0;
883 sk->inuse = 0;
884 sk->delay_acks = 0;
885 sk->wback = NULL;
886 sk->wfront = NULL;
887 sk->rqueue = NULL;
888 sk->mtu = 576;
889 sk->prot = prot;
890 sk->sleep = sock->wait;
891 sk->daddr = 0;
892 sk->saddr = my_addr();
893 sk->err = 0;
894 sk->next = NULL;
895 sk->pair = NULL;
896 sk->send_tail = NULL;
897 sk->send_head = NULL;
898 sk->timeout = 0;
899 sk->broadcast = 0;
900 sk->timer.data = (unsigned long)sk;
901 sk->timer.function = &net_timer;
902 sk->back_log = NULL;
903 sk->blog = 0;
904 sock->data =(void *) sk;
905 sk->dummy_th.doff = sizeof(sk->dummy_th)/4;
906 sk->dummy_th.res1=0;
907 sk->dummy_th.res2=0;
908 sk->dummy_th.urg_ptr = 0;
909 sk->dummy_th.fin = 0;
910 sk->dummy_th.syn = 0;
911 sk->dummy_th.rst = 0;
912 sk->dummy_th.psh = 0;
913 sk->dummy_th.ack = 0;
914 sk->dummy_th.urg = 0;
915 sk->dummy_th.dest = 0;
916
917 sk->ip_tos=0;
918 sk->ip_ttl=64;
919
920 sk->state_change = def_callback1;
921 sk->data_ready = def_callback2;
922 sk->write_space = def_callback1;
923 sk->error_report = def_callback1;
924
925 if (sk->num) {
926
927
928
929
930
931
932 put_sock(sk->num, sk);
933 sk->dummy_th.source = ntohs(sk->num);
934 }
935
936 if (sk->prot->init) {
937 err = sk->prot->init(sk);
938 if (err != 0) {
939 destroy_sock(sk);
940 return(err);
941 }
942 }
943 return(0);
944 }
945
946
947 static int
948 inet_dup(struct socket *newsock, struct socket *oldsock)
949 {
950 return(inet_create(newsock,
951 ((struct sock *)(oldsock->data))->protocol));
952 }
953
954
955
956 static int
957 inet_release(struct socket *sock, struct socket *peer)
958 {
959 struct sock *sk;
960
961 sk = (struct sock *) sock->data;
962 if (sk == NULL) return(0);
963
964 DPRINTF((DBG_INET, "inet_release(sock = %X, peer = %X)\n", sock, peer));
965 sk->state_change(sk);
966
967
968
969
970
971
972
973 if (sk->linger == 0) {
974 sk->prot->close(sk,0);
975 sk->dead = 1;
976 } else {
977 DPRINTF((DBG_INET, "sk->linger set.\n"));
978 sk->prot->close(sk, 0);
979 cli();
980 if (sk->lingertime)
981 current->timeout = jiffies + HZ*sk->lingertime;
982 while(sk->state != TCP_CLOSE && current->timeout>0) {
983 interruptible_sleep_on(sk->sleep);
984 if (current->signal & ~current->blocked) {
985 break;
986 #if 0
987
988 sti();
989 current->timeout=0;
990 return(-ERESTARTSYS);
991 #endif
992 }
993 }
994 current->timeout=0;
995 sti();
996 sk->dead = 1;
997 }
998 sk->inuse = 1;
999
1000
1001 release_sock(sk);
1002 sock->data = NULL;
1003 DPRINTF((DBG_INET, "inet_release returning\n"));
1004 return(0);
1005 }
1006
1007
1008
1009
1010
1011
1012 static int
1013 inet_bind(struct socket *sock, struct sockaddr *uaddr,
1014 int addr_len)
1015 {
1016 struct sockaddr_in addr;
1017 struct sock *sk, *sk2;
1018 unsigned short snum;
1019 int err;
1020
1021 sk = (struct sock *) sock->data;
1022 if (sk == NULL) {
1023 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1024 return(0);
1025 }
1026
1027
1028 if (sk->state != TCP_CLOSE) return(-EIO);
1029 if (sk->num != 0) return(-EINVAL);
1030
1031 err=verify_area(VERIFY_READ, uaddr, addr_len);
1032 if(err)
1033 return err;
1034 memcpy_fromfs(&addr, uaddr, min(sizeof(addr), addr_len));
1035
1036 snum = ntohs(addr.sin_port);
1037 DPRINTF((DBG_INET, "bind sk =%X to port = %d\n", sk, snum));
1038 sk = (struct sock *) sock->data;
1039
1040
1041
1042
1043
1044
1045 if (snum == 0) {
1046 snum = get_new_socknum(sk->prot, 0);
1047 }
1048 if (snum < PROT_SOCK && !suser()) return(-EACCES);
1049
1050 if (addr.sin_addr.s_addr!=0 && chk_addr(addr.sin_addr.s_addr)!=IS_MYADDR)
1051 return(-EADDRNOTAVAIL);
1052
1053 if (chk_addr(addr.sin_addr.s_addr) || addr.sin_addr.s_addr == 0)
1054 sk->saddr = addr.sin_addr.s_addr;
1055
1056 DPRINTF((DBG_INET, "sock_array[%d] = %X:\n", snum &(SOCK_ARRAY_SIZE -1),
1057 sk->prot->sock_array[snum &(SOCK_ARRAY_SIZE -1)]));
1058
1059
1060 cli();
1061 outside_loop:
1062 for(sk2 = sk->prot->sock_array[snum & (SOCK_ARRAY_SIZE -1)];
1063 sk2 != NULL; sk2 = sk2->next) {
1064 #if 1
1065 if (sk2->num != snum) continue;
1066
1067 #endif
1068 if (sk2->dead) {
1069 destroy_sock(sk2);
1070 goto outside_loop;
1071 }
1072 if (!sk->reuse) {
1073 sti();
1074 return(-EADDRINUSE);
1075 }
1076 if (sk2->num != snum) continue;
1077 if (sk2->saddr != sk->saddr) continue;
1078 if (!sk2->reuse) {
1079 sti();
1080 return(-EADDRINUSE);
1081 }
1082 }
1083 sti();
1084
1085 remove_sock(sk);
1086 put_sock(snum, sk);
1087 sk->dummy_th.source = ntohs(sk->num);
1088 sk->daddr = 0;
1089 sk->dummy_th.dest = 0;
1090 return(0);
1091 }
1092
1093
1094 static int
1095 inet_connect(struct socket *sock, struct sockaddr * uaddr,
1096 int addr_len, int flags)
1097 {
1098 struct sock *sk;
1099 int err;
1100
1101 sock->conn = NULL;
1102 sk = (struct sock *) sock->data;
1103 if (sk == NULL) {
1104 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1105 return(0);
1106 }
1107
1108 if (sock->state == SS_CONNECTING && sk->state == TCP_ESTABLISHED)
1109 {
1110 sock->state = SS_CONNECTED;
1111
1112 return 0;
1113 }
1114
1115 if (sock->state == SS_CONNECTING && sk->protocol == IPPROTO_TCP &&
1116 (flags & O_NONBLOCK))
1117 return -EALREADY;
1118
1119 if (sock->state != SS_CONNECTING) {
1120
1121 if (sk->num == 0) {
1122 sk->num = get_new_socknum(sk->prot, 0);
1123 if (sk->num == 0)
1124 return(-EAGAIN);
1125 put_sock(sk->num, sk);
1126 sk->dummy_th.source = htons(sk->num);
1127 }
1128
1129 if (sk->prot->connect == NULL)
1130 return(-EOPNOTSUPP);
1131
1132 err = sk->prot->connect(sk, (struct sockaddr_in *)uaddr, addr_len);
1133 if (err < 0) return(err);
1134
1135 sock->state = SS_CONNECTING;
1136 }
1137
1138 if (sk->state != TCP_ESTABLISHED &&(flags & O_NONBLOCK))
1139 return(-EINPROGRESS);
1140
1141 cli();
1142 while(sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
1143 {
1144 interruptible_sleep_on(sk->sleep);
1145 if (current->signal & ~current->blocked) {
1146 sti();
1147 return(-ERESTARTSYS);
1148 }
1149
1150
1151 if(sk->err && sk->protocol == IPPROTO_TCP)
1152 {
1153 sti();
1154 sock->state = SS_UNCONNECTED;
1155 err = -sk->err;
1156 sk->err=0;
1157 return err;
1158 }
1159 }
1160 sti();
1161 sock->state = SS_CONNECTED;
1162
1163 if (sk->state != TCP_ESTABLISHED && sk->err) {
1164 sock->state = SS_UNCONNECTED;
1165 err=sk->err;
1166 sk->err=0;
1167 return(-err);
1168 }
1169 return(0);
1170 }
1171
1172
1173 static int
1174 inet_socketpair(struct socket *sock1, struct socket *sock2)
1175 {
1176 return(-EOPNOTSUPP);
1177 }
1178
1179
1180 static int
1181 inet_accept(struct socket *sock, struct socket *newsock, int flags)
1182 {
1183 struct sock *sk1, *sk2;
1184 int err;
1185
1186 sk1 = (struct sock *) sock->data;
1187 if (sk1 == NULL) {
1188 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1189 return(0);
1190 }
1191
1192
1193
1194
1195
1196
1197 if (newsock->data) {
1198 struct sock * sk = (struct sock *) newsock->data;
1199 newsock->data = NULL;
1200 sk->dead = 1;
1201 destroy_sock(sk);
1202 }
1203
1204 if (sk1->prot->accept == NULL) return(-EOPNOTSUPP);
1205
1206
1207 if (sk1->pair != NULL ) {
1208 sk2 = sk1->pair;
1209 sk1->pair = NULL;
1210 } else {
1211 sk2 = sk1->prot->accept(sk1,flags);
1212 if (sk2 == NULL) {
1213 if (sk1->err <= 0)
1214 printk("Warning sock.c:sk1->err <= 0. Returning non-error.\n");
1215 err=sk1->err;
1216 sk1->err=0;
1217 return(-err);
1218 }
1219 }
1220 newsock->data = (void *)sk2;
1221 sk2->sleep = newsock->wait;
1222 newsock->conn = NULL;
1223 if (flags & O_NONBLOCK) return(0);
1224
1225 cli();
1226 while(sk2->state == TCP_SYN_RECV) {
1227 interruptible_sleep_on(sk2->sleep);
1228 if (current->signal & ~current->blocked) {
1229 sti();
1230 sk1->pair = sk2;
1231 sk2->sleep = NULL;
1232 newsock->data = NULL;
1233 return(-ERESTARTSYS);
1234 }
1235 }
1236 sti();
1237
1238 if (sk2->state != TCP_ESTABLISHED && sk2->err > 0) {
1239
1240 err = -sk2->err;
1241 sk2->err=0;
1242 destroy_sock(sk2);
1243 newsock->data = NULL;
1244 return(err);
1245 }
1246 newsock->state = SS_CONNECTED;
1247 return(0);
1248 }
1249
1250
1251 static int
1252 inet_getname(struct socket *sock, struct sockaddr *uaddr,
1253 int *uaddr_len, int peer)
1254 {
1255 struct sockaddr_in sin;
1256 struct sock *sk;
1257 int len;
1258 int err;
1259
1260
1261 err = verify_area(VERIFY_WRITE,uaddr_len,sizeof(long));
1262 if(err)
1263 return err;
1264
1265 len=get_fs_long(uaddr_len);
1266
1267 err = verify_area(VERIFY_WRITE, uaddr, len);
1268 if(err)
1269 return err;
1270
1271
1272 if (len < sizeof(sin)) return(-EINVAL);
1273
1274 sin.sin_family = AF_INET;
1275 sk = (struct sock *) sock->data;
1276 if (sk == NULL) {
1277 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1278 return(0);
1279 }
1280 if (peer) {
1281 if (!tcp_connected(sk->state)) return(-ENOTCONN);
1282 sin.sin_port = sk->dummy_th.dest;
1283 sin.sin_addr.s_addr = sk->daddr;
1284 } else {
1285 sin.sin_port = sk->dummy_th.source;
1286 if (sk->saddr == 0) sin.sin_addr.s_addr = my_addr();
1287 else sin.sin_addr.s_addr = sk->saddr;
1288 }
1289 len = sizeof(sin);
1290
1291 memcpy_tofs(uaddr, &sin, sizeof(sin));
1292
1293 put_fs_long(len, uaddr_len);
1294 return(0);
1295 }
1296
1297
1298 static int
1299 inet_read(struct socket *sock, char *ubuf, int size, int noblock)
1300 {
1301 struct sock *sk;
1302
1303 sk = (struct sock *) sock->data;
1304 if (sk == NULL) {
1305 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1306 return(0);
1307 }
1308
1309
1310 if (sk->num == 0) {
1311 sk->num = get_new_socknum(sk->prot, 0);
1312 if (sk->num == 0) return(-EAGAIN);
1313 put_sock(sk->num, sk);
1314 sk->dummy_th.source = ntohs(sk->num);
1315 }
1316 return(sk->prot->read(sk, (unsigned char *) ubuf, size, noblock,0));
1317 }
1318
1319
1320 static int
1321 inet_recv(struct socket *sock, void *ubuf, int size, int noblock,
1322 unsigned flags)
1323 {
1324 struct sock *sk;
1325
1326 sk = (struct sock *) sock->data;
1327 if (sk == NULL) {
1328 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1329 return(0);
1330 }
1331
1332
1333 if (sk->num == 0) {
1334 sk->num = get_new_socknum(sk->prot, 0);
1335 if (sk->num == 0) return(-EAGAIN);
1336 put_sock(sk->num, sk);
1337 sk->dummy_th.source = ntohs(sk->num);
1338 }
1339 return(sk->prot->read(sk, (unsigned char *) ubuf, size, noblock, flags));
1340 }
1341
1342
1343 static int
1344 inet_write(struct socket *sock, char *ubuf, int size, int noblock)
1345 {
1346 struct sock *sk;
1347
1348 sk = (struct sock *) sock->data;
1349 if (sk == NULL) {
1350 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1351 return(0);
1352 }
1353 if (sk->shutdown & SEND_SHUTDOWN) {
1354 send_sig(SIGPIPE, current, 1);
1355 return(-EPIPE);
1356 }
1357
1358
1359 if (sk->num == 0) {
1360 sk->num = get_new_socknum(sk->prot, 0);
1361 if (sk->num == 0) return(-EAGAIN);
1362 put_sock(sk->num, sk);
1363 sk->dummy_th.source = ntohs(sk->num);
1364 }
1365
1366 return(sk->prot->write(sk, (unsigned char *) ubuf, size, noblock, 0));
1367 }
1368
1369
1370 static int
1371 inet_send(struct socket *sock, void *ubuf, int size, int noblock,
1372 unsigned flags)
1373 {
1374 struct sock *sk;
1375
1376 sk = (struct sock *) sock->data;
1377 if (sk == NULL) {
1378 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1379 return(0);
1380 }
1381 if (sk->shutdown & SEND_SHUTDOWN) {
1382 send_sig(SIGPIPE, current, 1);
1383 return(-EPIPE);
1384 }
1385
1386
1387 if (sk->num == 0) {
1388 sk->num = get_new_socknum(sk->prot, 0);
1389 if (sk->num == 0) return(-EAGAIN);
1390 put_sock(sk->num, sk);
1391 sk->dummy_th.source = ntohs(sk->num);
1392 }
1393
1394 return(sk->prot->write(sk, (unsigned char *) ubuf, size, noblock, flags));
1395 }
1396
1397
1398 static int
1399 inet_sendto(struct socket *sock, void *ubuf, int size, int noblock,
1400 unsigned flags, struct sockaddr *sin, int addr_len)
1401 {
1402 struct sock *sk;
1403
1404 sk = (struct sock *) sock->data;
1405 if (sk == NULL) {
1406 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1407 return(0);
1408 }
1409 if (sk->shutdown & SEND_SHUTDOWN) {
1410 send_sig(SIGPIPE, current, 1);
1411 return(-EPIPE);
1412 }
1413
1414 if (sk->prot->sendto == NULL) return(-EOPNOTSUPP);
1415
1416
1417 if (sk->num == 0) {
1418 sk->num = get_new_socknum(sk->prot, 0);
1419 if (sk->num == 0) return(-EAGAIN);
1420 put_sock(sk->num, sk);
1421 sk->dummy_th.source = ntohs(sk->num);
1422 }
1423
1424 return(sk->prot->sendto(sk, (unsigned char *) ubuf, size, noblock, flags,
1425 (struct sockaddr_in *)sin, addr_len));
1426 }
1427
1428
1429 static int
1430 inet_recvfrom(struct socket *sock, void *ubuf, int size, int noblock,
1431 unsigned flags, struct sockaddr *sin, int *addr_len )
1432 {
1433 struct sock *sk;
1434
1435 sk = (struct sock *) sock->data;
1436 if (sk == NULL) {
1437 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1438 return(0);
1439 }
1440
1441 if (sk->prot->recvfrom == NULL) return(-EOPNOTSUPP);
1442
1443
1444 if (sk->num == 0) {
1445 sk->num = get_new_socknum(sk->prot, 0);
1446 if (sk->num == 0) return(-EAGAIN);
1447 put_sock(sk->num, sk);
1448 sk->dummy_th.source = ntohs(sk->num);
1449 }
1450
1451 return(sk->prot->recvfrom(sk, (unsigned char *) ubuf, size, noblock, flags,
1452 (struct sockaddr_in*)sin, addr_len));
1453 }
1454
1455
1456 static int
1457 inet_shutdown(struct socket *sock, int how)
1458 {
1459 struct sock *sk;
1460
1461
1462
1463
1464
1465 how++;
1466
1467
1468 if (how & ~SHUTDOWN_MASK) return(-EINVAL);
1469 sk = (struct sock *) sock->data;
1470 if (sk == NULL) {
1471 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1472 return(0);
1473 }
1474 if (sock->state == SS_CONNECTING && sk->state == TCP_ESTABLISHED)
1475 sock->state = SS_CONNECTED;
1476
1477 if (!tcp_connected(sk->state)) return(-ENOTCONN);
1478 sk->shutdown |= how;
1479 if (sk->prot->shutdown) sk->prot->shutdown(sk, how);
1480 return(0);
1481 }
1482
1483
1484 static int
1485 inet_select(struct socket *sock, int sel_type, select_table *wait )
1486 {
1487 struct sock *sk;
1488
1489 sk = (struct sock *) sock->data;
1490 if (sk == NULL) {
1491 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1492 return(0);
1493 }
1494
1495 if (sk->prot->select == NULL) {
1496 DPRINTF((DBG_INET, "select on non-selectable socket.\n"));
1497 return(0);
1498 }
1499 return(sk->prot->select(sk, sel_type, wait));
1500 }
1501
1502
1503 static int
1504 inet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1505 {
1506 struct sock *sk;
1507 int err;
1508
1509 DPRINTF((DBG_INET, "INET: in inet_ioctl\n"));
1510 sk = NULL;
1511 if (sock && (sk = (struct sock *) sock->data) == NULL) {
1512 printk("AF_INET: Warning: sock->data = NULL: %d\n" , __LINE__);
1513 return(0);
1514 }
1515
1516 switch(cmd) {
1517 case FIOSETOWN:
1518 case SIOCSPGRP:
1519 err=verify_area(VERIFY_READ,(int *)arg,sizeof(long));
1520 if(err)
1521 return err;
1522 if (sk)
1523 sk->proc = get_fs_long((int *) arg);
1524 return(0);
1525 case FIOGETOWN:
1526 case SIOCGPGRP:
1527 if (sk) {
1528 err=verify_area(VERIFY_WRITE,(void *) arg, sizeof(long));
1529 if(err)
1530 return err;
1531 put_fs_long(sk->proc,(int *)arg);
1532 }
1533 return(0);
1534 #if 0
1535 case SIOCATMARK:
1536 printk("AF_INET: ioctl(SIOCATMARK, 0x%08X)\n",(void *) arg);
1537 return(-EINVAL);
1538 #endif
1539
1540 case DDIOCSDBG:
1541 return(dbg_ioctl((void *) arg, DBG_INET));
1542
1543 case SIOCADDRT: case SIOCADDRTOLD:
1544 case SIOCDELRT: case SIOCDELRTOLD:
1545 return(rt_ioctl(cmd,(void *) arg));
1546
1547 case SIOCDARP:
1548 case SIOCGARP:
1549 case SIOCSARP:
1550 return(arp_ioctl(cmd,(void *) arg));
1551
1552 case IP_SET_DEV:
1553 case SIOCGIFCONF:
1554 case SIOCGIFFLAGS:
1555 case SIOCSIFFLAGS:
1556 case SIOCGIFADDR:
1557 case SIOCSIFADDR:
1558 case SIOCGIFDSTADDR:
1559 case SIOCSIFDSTADDR:
1560 case SIOCGIFBRDADDR:
1561 case SIOCSIFBRDADDR:
1562 case SIOCGIFNETMASK:
1563 case SIOCSIFNETMASK:
1564 case SIOCGIFMETRIC:
1565 case SIOCSIFMETRIC:
1566 case SIOCGIFMEM:
1567 case SIOCSIFMEM:
1568 case SIOCGIFMTU:
1569 case SIOCSIFMTU:
1570 case SIOCSIFLINK:
1571 case SIOCGIFHWADDR:
1572 return(dev_ioctl(cmd,(void *) arg));
1573
1574 default:
1575 if (!sk || !sk->prot->ioctl) return(-EINVAL);
1576 return(sk->prot->ioctl(sk, cmd, arg));
1577 }
1578
1579 return(0);
1580 }
1581
1582
1583 struct sk_buff *
1584 sock_wmalloc(struct sock *sk, unsigned long size, int force,
1585 int priority)
1586 {
1587 if (sk) {
1588 if (sk->wmem_alloc + size < sk->sndbuf || force) {
1589 struct sk_buff * c = alloc_skb(size, priority);
1590 if (c) {
1591 cli();
1592 sk->wmem_alloc+= size;
1593 sti();
1594 }
1595 return c;
1596 }
1597 DPRINTF((DBG_INET, "sock_wmalloc(%X,%d,%d,%d) returning NULL\n",
1598 sk, size, force, priority));
1599 return(NULL);
1600 }
1601 return(alloc_skb(size, priority));
1602 }
1603
1604
1605 struct sk_buff *
1606 sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority)
1607 {
1608 if (sk) {
1609 if (sk->rmem_alloc + size < sk->rcvbuf || force) {
1610 struct sk_buff *c = alloc_skb(size, priority);
1611 if (c) {
1612 cli();
1613 sk->rmem_alloc += size;
1614 sti();
1615 }
1616 return(c);
1617 }
1618 DPRINTF((DBG_INET, "sock_rmalloc(%X,%d,%d,%d) returning NULL\n",
1619 sk,size,force, priority));
1620 return(NULL);
1621 }
1622 return(alloc_skb(size, priority));
1623 }
1624
1625
1626 unsigned long
1627 sock_rspace(struct sock *sk)
1628 {
1629 int amt;
1630
1631 if (sk != NULL) {
1632 if (sk->rmem_alloc >= sk->rcvbuf-2*MIN_WINDOW) return(0);
1633 amt = min((sk->rcvbuf-sk->rmem_alloc)/2-MIN_WINDOW, MAX_WINDOW);
1634 if (amt < 0) return(0);
1635 return(amt);
1636 }
1637 return(0);
1638 }
1639
1640
1641 unsigned long
1642 sock_wspace(struct sock *sk)
1643 {
1644 if (sk != NULL) {
1645 if (sk->shutdown & SEND_SHUTDOWN) return(0);
1646 if (sk->wmem_alloc >= sk->sndbuf) return(0);
1647 return(sk->sndbuf-sk->wmem_alloc );
1648 }
1649 return(0);
1650 }
1651
1652
1653 void
1654 sock_wfree(struct sock *sk, void *mem, unsigned long size)
1655 {
1656 DPRINTF((DBG_INET, "sock_wfree(sk=%X, mem=%X, size=%d)\n", sk, mem, size));
1657
1658 IS_SKB(mem);
1659 kfree_skbmem(mem, size);
1660 if (sk) {
1661 sk->wmem_alloc -= size;
1662
1663
1664 if (!sk->dead) sk->write_space(sk);
1665 if (sk->destroy && sk->wmem_alloc == 0 && sk->rmem_alloc == 0) {
1666 DPRINTF((DBG_INET,
1667 "recovered lost memory, sock = %X\n", sk));
1668 }
1669 return;
1670 }
1671 }
1672
1673
1674 void
1675 sock_rfree(struct sock *sk, void *mem, unsigned long size)
1676 {
1677 DPRINTF((DBG_INET, "sock_rfree(sk=%X, mem=%X, size=%d)\n", sk, mem, size));
1678 IS_SKB(mem);
1679 kfree_skbmem(mem, size);
1680 if (sk) {
1681 sk->rmem_alloc -= size;
1682 if (sk->destroy && sk->wmem_alloc == 0 && sk->rmem_alloc == 0) {
1683 DPRINTF((DBG_INET,
1684 "recovered lot memory, sock = %X\n", sk));
1685 }
1686 }
1687 }
1688
1689
1690
1691
1692
1693
1694 struct sock *get_sock(struct proto *prot, unsigned short num,
1695 unsigned long raddr,
1696 unsigned short rnum, unsigned long laddr)
1697 {
1698 struct sock *s;
1699 unsigned short hnum;
1700
1701 hnum = ntohs(num);
1702 DPRINTF((DBG_INET, "get_sock(prot=%X, num=%d, raddr=%X, rnum=%d, laddr=%X)\n",
1703 prot, num, raddr, rnum, laddr));
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713 for(s = prot->sock_array[hnum & (SOCK_ARRAY_SIZE - 1)];
1714 s != NULL; s = s->next)
1715 {
1716 if (s->num != hnum)
1717 continue;
1718 if(s->dead && (s->state == TCP_CLOSE))
1719 continue;
1720 if(prot == &udp_prot)
1721 return s;
1722 if(ip_addr_match(s->daddr,raddr)==0)
1723 continue;
1724 if (s->dummy_th.dest != rnum && s->dummy_th.dest != 0)
1725 continue;
1726 if(ip_addr_match(s->saddr,laddr) == 0)
1727 continue;
1728 return(s);
1729 }
1730 return(NULL);
1731 }
1732
1733
1734 void release_sock(struct sock *sk)
1735 {
1736 if (!sk) {
1737 printk("sock.c: release_sock sk == NULL\n");
1738 return;
1739 }
1740 if (!sk->prot) {
1741
1742 return;
1743 }
1744
1745 if (sk->blog) return;
1746
1747
1748 cli();
1749 sk->inuse = 1;
1750 while(sk->back_log != NULL) {
1751 struct sk_buff *skb;
1752
1753 sk->blog = 1;
1754 skb =(struct sk_buff *)sk->back_log;
1755 DPRINTF((DBG_INET, "release_sock: skb = %X:\n", skb));
1756 if (skb->next != skb) {
1757 sk->back_log = skb->next;
1758 skb->prev->next = skb->next;
1759 skb->next->prev = skb->prev;
1760 } else {
1761 sk->back_log = NULL;
1762 }
1763 sti();
1764 DPRINTF((DBG_INET, "sk->back_log = %X\n", sk->back_log));
1765 if (sk->prot->rcv) sk->prot->rcv(skb, skb->dev, sk->opt,
1766 skb->saddr, skb->len, skb->daddr, 1,
1767
1768
1769 (struct inet_protocol *)sk->pair);
1770 cli();
1771 }
1772 sk->blog = 0;
1773 sk->inuse = 0;
1774 sti();
1775 if (sk->dead && sk->state == TCP_CLOSE) {
1776
1777 reset_timer(sk, TIME_DONE, min(sk->rtt * 2, TCP_DONE_TIME));
1778 }
1779 }
1780
1781
1782 static int
1783 inet_fioctl(struct inode *inode, struct file *file,
1784 unsigned int cmd, unsigned long arg)
1785 {
1786 int minor, ret;
1787
1788
1789 minor = MINOR(inode->i_rdev);
1790 if (minor != 0) return(-ENODEV);
1791
1792
1793 switch(minor) {
1794 case 0:
1795 ret = inet_ioctl(NULL, cmd, arg);
1796 break;
1797 case 1:
1798 ret = ip_ioctl(NULL, cmd, arg);
1799 break;
1800 case 2:
1801 ret = icmp_ioctl(NULL, cmd, arg);
1802 break;
1803 case 3:
1804 ret = tcp_ioctl(NULL, cmd, arg);
1805 break;
1806 case 4:
1807 ret = udp_ioctl(NULL, cmd, arg);
1808 break;
1809 default:
1810 ret = -ENODEV;
1811 }
1812
1813 return(ret);
1814 }
1815
1816
1817
1818
1819 static struct file_operations inet_fops = {
1820 NULL,
1821 NULL,
1822 NULL,
1823 NULL,
1824 NULL,
1825 inet_fioctl,
1826 NULL,
1827 NULL,
1828 NULL
1829 };
1830
1831
1832 static struct proto_ops inet_proto_ops = {
1833 AF_INET,
1834
1835 inet_create,
1836 inet_dup,
1837 inet_release,
1838 inet_bind,
1839 inet_connect,
1840 inet_socketpair,
1841 inet_accept,
1842 inet_getname,
1843 inet_read,
1844 inet_write,
1845 inet_select,
1846 inet_ioctl,
1847 inet_listen,
1848 inet_send,
1849 inet_recv,
1850 inet_sendto,
1851 inet_recvfrom,
1852 inet_shutdown,
1853 inet_setsockopt,
1854 inet_getsockopt,
1855 inet_fcntl,
1856 };
1857
1858 extern unsigned long seq_offset;
1859
1860
1861 void inet_proto_init(struct ddi_proto *pro)
1862 {
1863 struct inet_protocol *p;
1864 int i;
1865
1866 printk("Swansea University Computer Society Net2Debugged [1.30]\n");
1867
1868 if (register_chrdev(AF_INET_MAJOR, "af_inet", &inet_fops) < 0) {
1869 printk("%s: cannot register major device %d!\n",
1870 pro->name, AF_INET_MAJOR);
1871 return;
1872 }
1873
1874
1875 (void) sock_register(inet_proto_ops.family, &inet_proto_ops);
1876
1877 seq_offset = CURRENT_TIME*250;
1878
1879
1880 for(i = 0; i < SOCK_ARRAY_SIZE; i++) {
1881 tcp_prot.sock_array[i] = NULL;
1882 udp_prot.sock_array[i] = NULL;
1883 raw_prot.sock_array[i] = NULL;
1884 }
1885 printk("IP Protocols: ");
1886 for(p = inet_protocol_base; p != NULL;) {
1887 struct inet_protocol *tmp;
1888
1889 tmp = (struct inet_protocol *) p->next;
1890 inet_add_protocol(p);
1891 printk("%s%s",p->name,tmp?", ":"\n");
1892 p = tmp;
1893 }
1894
1895
1896 dev_init();
1897
1898
1899 bh_base[INET_BH].routine = inet_bh;
1900 }