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 destroy_sock(sk);
1201 }
1202
1203 if (sk1->prot->accept == NULL) return(-EOPNOTSUPP);
1204
1205
1206 if (sk1->pair != NULL ) {
1207 sk2 = sk1->pair;
1208 sk1->pair = NULL;
1209 } else {
1210 sk2 = sk1->prot->accept(sk1,flags);
1211 if (sk2 == NULL) {
1212 if (sk1->err <= 0)
1213 printk("Warning sock.c:sk1->err <= 0. Returning non-error.\n");
1214 err=sk1->err;
1215 sk1->err=0;
1216 return(-err);
1217 }
1218 }
1219 newsock->data = (void *)sk2;
1220 sk2->sleep = newsock->wait;
1221 newsock->conn = NULL;
1222 if (flags & O_NONBLOCK) return(0);
1223
1224 cli();
1225 while(sk2->state == TCP_SYN_RECV) {
1226 interruptible_sleep_on(sk2->sleep);
1227 if (current->signal & ~current->blocked) {
1228 sti();
1229 sk1->pair = sk2;
1230 sk2->sleep = NULL;
1231 newsock->data = NULL;
1232 return(-ERESTARTSYS);
1233 }
1234 }
1235 sti();
1236
1237 if (sk2->state != TCP_ESTABLISHED && sk2->err > 0) {
1238
1239 err = -sk2->err;
1240 sk2->err=0;
1241 destroy_sock(sk2);
1242 newsock->data = NULL;
1243 return(err);
1244 }
1245 newsock->state = SS_CONNECTED;
1246 return(0);
1247 }
1248
1249
1250 static int
1251 inet_getname(struct socket *sock, struct sockaddr *uaddr,
1252 int *uaddr_len, int peer)
1253 {
1254 struct sockaddr_in sin;
1255 struct sock *sk;
1256 int len;
1257 int err;
1258
1259
1260 err = verify_area(VERIFY_WRITE,uaddr_len,sizeof(long));
1261 if(err)
1262 return err;
1263
1264 len=get_fs_long(uaddr_len);
1265
1266 err = verify_area(VERIFY_WRITE, uaddr, len);
1267 if(err)
1268 return err;
1269
1270
1271 if (len < sizeof(sin)) return(-EINVAL);
1272
1273 sin.sin_family = AF_INET;
1274 sk = (struct sock *) sock->data;
1275 if (sk == NULL) {
1276 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1277 return(0);
1278 }
1279 if (peer) {
1280 if (!tcp_connected(sk->state)) return(-ENOTCONN);
1281 sin.sin_port = sk->dummy_th.dest;
1282 sin.sin_addr.s_addr = sk->daddr;
1283 } else {
1284 sin.sin_port = sk->dummy_th.source;
1285 if (sk->saddr == 0) sin.sin_addr.s_addr = my_addr();
1286 else sin.sin_addr.s_addr = sk->saddr;
1287 }
1288 len = sizeof(sin);
1289
1290 memcpy_tofs(uaddr, &sin, sizeof(sin));
1291
1292 put_fs_long(len, uaddr_len);
1293 return(0);
1294 }
1295
1296
1297 static int
1298 inet_read(struct socket *sock, char *ubuf, int size, int noblock)
1299 {
1300 struct sock *sk;
1301
1302 sk = (struct sock *) sock->data;
1303 if (sk == NULL) {
1304 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1305 return(0);
1306 }
1307
1308
1309 if (sk->num == 0) {
1310 sk->num = get_new_socknum(sk->prot, 0);
1311 if (sk->num == 0) return(-EAGAIN);
1312 put_sock(sk->num, sk);
1313 sk->dummy_th.source = ntohs(sk->num);
1314 }
1315 return(sk->prot->read(sk, (unsigned char *) ubuf, size, noblock,0));
1316 }
1317
1318
1319 static int
1320 inet_recv(struct socket *sock, void *ubuf, int size, int noblock,
1321 unsigned flags)
1322 {
1323 struct sock *sk;
1324
1325 sk = (struct sock *) sock->data;
1326 if (sk == NULL) {
1327 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1328 return(0);
1329 }
1330
1331
1332 if (sk->num == 0) {
1333 sk->num = get_new_socknum(sk->prot, 0);
1334 if (sk->num == 0) return(-EAGAIN);
1335 put_sock(sk->num, sk);
1336 sk->dummy_th.source = ntohs(sk->num);
1337 }
1338 return(sk->prot->read(sk, (unsigned char *) ubuf, size, noblock, flags));
1339 }
1340
1341
1342 static int
1343 inet_write(struct socket *sock, char *ubuf, int size, int noblock)
1344 {
1345 struct sock *sk;
1346
1347 sk = (struct sock *) sock->data;
1348 if (sk == NULL) {
1349 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1350 return(0);
1351 }
1352 if (sk->shutdown & SEND_SHUTDOWN) {
1353 send_sig(SIGPIPE, current, 1);
1354 return(-EPIPE);
1355 }
1356
1357
1358 if (sk->num == 0) {
1359 sk->num = get_new_socknum(sk->prot, 0);
1360 if (sk->num == 0) return(-EAGAIN);
1361 put_sock(sk->num, sk);
1362 sk->dummy_th.source = ntohs(sk->num);
1363 }
1364
1365 return(sk->prot->write(sk, (unsigned char *) ubuf, size, noblock, 0));
1366 }
1367
1368
1369 static int
1370 inet_send(struct socket *sock, void *ubuf, int size, int noblock,
1371 unsigned flags)
1372 {
1373 struct sock *sk;
1374
1375 sk = (struct sock *) sock->data;
1376 if (sk == NULL) {
1377 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1378 return(0);
1379 }
1380 if (sk->shutdown & SEND_SHUTDOWN) {
1381 send_sig(SIGPIPE, current, 1);
1382 return(-EPIPE);
1383 }
1384
1385
1386 if (sk->num == 0) {
1387 sk->num = get_new_socknum(sk->prot, 0);
1388 if (sk->num == 0) return(-EAGAIN);
1389 put_sock(sk->num, sk);
1390 sk->dummy_th.source = ntohs(sk->num);
1391 }
1392
1393 return(sk->prot->write(sk, (unsigned char *) ubuf, size, noblock, flags));
1394 }
1395
1396
1397 static int
1398 inet_sendto(struct socket *sock, void *ubuf, int size, int noblock,
1399 unsigned flags, struct sockaddr *sin, int addr_len)
1400 {
1401 struct sock *sk;
1402
1403 sk = (struct sock *) sock->data;
1404 if (sk == NULL) {
1405 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1406 return(0);
1407 }
1408 if (sk->shutdown & SEND_SHUTDOWN) {
1409 send_sig(SIGPIPE, current, 1);
1410 return(-EPIPE);
1411 }
1412
1413 if (sk->prot->sendto == NULL) return(-EOPNOTSUPP);
1414
1415
1416 if (sk->num == 0) {
1417 sk->num = get_new_socknum(sk->prot, 0);
1418 if (sk->num == 0) return(-EAGAIN);
1419 put_sock(sk->num, sk);
1420 sk->dummy_th.source = ntohs(sk->num);
1421 }
1422
1423 return(sk->prot->sendto(sk, (unsigned char *) ubuf, size, noblock, flags,
1424 (struct sockaddr_in *)sin, addr_len));
1425 }
1426
1427
1428 static int
1429 inet_recvfrom(struct socket *sock, void *ubuf, int size, int noblock,
1430 unsigned flags, struct sockaddr *sin, int *addr_len )
1431 {
1432 struct sock *sk;
1433
1434 sk = (struct sock *) sock->data;
1435 if (sk == NULL) {
1436 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1437 return(0);
1438 }
1439
1440 if (sk->prot->recvfrom == NULL) return(-EOPNOTSUPP);
1441
1442
1443 if (sk->num == 0) {
1444 sk->num = get_new_socknum(sk->prot, 0);
1445 if (sk->num == 0) return(-EAGAIN);
1446 put_sock(sk->num, sk);
1447 sk->dummy_th.source = ntohs(sk->num);
1448 }
1449
1450 return(sk->prot->recvfrom(sk, (unsigned char *) ubuf, size, noblock, flags,
1451 (struct sockaddr_in*)sin, addr_len));
1452 }
1453
1454
1455 static int
1456 inet_shutdown(struct socket *sock, int how)
1457 {
1458 struct sock *sk;
1459
1460
1461
1462
1463
1464 how++;
1465
1466
1467 if (how & ~SHUTDOWN_MASK) return(-EINVAL);
1468 sk = (struct sock *) sock->data;
1469 if (sk == NULL) {
1470 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1471 return(0);
1472 }
1473 if (sock->state == SS_CONNECTING && sk->state == TCP_ESTABLISHED)
1474 sock->state = SS_CONNECTED;
1475
1476 if (!tcp_connected(sk->state)) return(-ENOTCONN);
1477 sk->shutdown |= how;
1478 if (sk->prot->shutdown) sk->prot->shutdown(sk, how);
1479 return(0);
1480 }
1481
1482
1483 static int
1484 inet_select(struct socket *sock, int sel_type, select_table *wait )
1485 {
1486 struct sock *sk;
1487
1488 sk = (struct sock *) sock->data;
1489 if (sk == NULL) {
1490 printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1491 return(0);
1492 }
1493
1494 if (sk->prot->select == NULL) {
1495 DPRINTF((DBG_INET, "select on non-selectable socket.\n"));
1496 return(0);
1497 }
1498 return(sk->prot->select(sk, sel_type, wait));
1499 }
1500
1501
1502 static int
1503 inet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1504 {
1505 struct sock *sk;
1506 int err;
1507
1508 DPRINTF((DBG_INET, "INET: in inet_ioctl\n"));
1509 sk = NULL;
1510 if (sock && (sk = (struct sock *) sock->data) == NULL) {
1511 printk("AF_INET: Warning: sock->data = NULL: %d\n" , __LINE__);
1512 return(0);
1513 }
1514
1515 switch(cmd) {
1516 case FIOSETOWN:
1517 case SIOCSPGRP:
1518 err=verify_area(VERIFY_READ,(int *)arg,sizeof(long));
1519 if(err)
1520 return err;
1521 if (sk)
1522 sk->proc = get_fs_long((int *) arg);
1523 return(0);
1524 case FIOGETOWN:
1525 case SIOCGPGRP:
1526 if (sk) {
1527 err=verify_area(VERIFY_WRITE,(void *) arg, sizeof(long));
1528 if(err)
1529 return err;
1530 put_fs_long(sk->proc,(int *)arg);
1531 }
1532 return(0);
1533 #if 0
1534 case SIOCATMARK:
1535 printk("AF_INET: ioctl(SIOCATMARK, 0x%08X)\n",(void *) arg);
1536 return(-EINVAL);
1537 #endif
1538
1539 case DDIOCSDBG:
1540 return(dbg_ioctl((void *) arg, DBG_INET));
1541
1542 case SIOCADDRT: case SIOCADDRTOLD:
1543 case SIOCDELRT: case SIOCDELRTOLD:
1544 return(rt_ioctl(cmd,(void *) arg));
1545
1546 case SIOCDARP:
1547 case SIOCGARP:
1548 case SIOCSARP:
1549 return(arp_ioctl(cmd,(void *) arg));
1550
1551 case IP_SET_DEV:
1552 case SIOCGIFCONF:
1553 case SIOCGIFFLAGS:
1554 case SIOCSIFFLAGS:
1555 case SIOCGIFADDR:
1556 case SIOCSIFADDR:
1557 case SIOCGIFDSTADDR:
1558 case SIOCSIFDSTADDR:
1559 case SIOCGIFBRDADDR:
1560 case SIOCSIFBRDADDR:
1561 case SIOCGIFNETMASK:
1562 case SIOCSIFNETMASK:
1563 case SIOCGIFMETRIC:
1564 case SIOCSIFMETRIC:
1565 case SIOCGIFMEM:
1566 case SIOCSIFMEM:
1567 case SIOCGIFMTU:
1568 case SIOCSIFMTU:
1569 case SIOCSIFLINK:
1570 case SIOCGIFHWADDR:
1571 return(dev_ioctl(cmd,(void *) arg));
1572
1573 default:
1574 if (!sk || !sk->prot->ioctl) return(-EINVAL);
1575 return(sk->prot->ioctl(sk, cmd, arg));
1576 }
1577
1578 return(0);
1579 }
1580
1581
1582 struct sk_buff *
1583 sock_wmalloc(struct sock *sk, unsigned long size, int force,
1584 int priority)
1585 {
1586 if (sk) {
1587 if (sk->wmem_alloc + size < sk->sndbuf || force) {
1588 struct sk_buff * c = alloc_skb(size, priority);
1589 if (c) {
1590 cli();
1591 sk->wmem_alloc+= size;
1592 sti();
1593 }
1594 return c;
1595 }
1596 DPRINTF((DBG_INET, "sock_wmalloc(%X,%d,%d,%d) returning NULL\n",
1597 sk, size, force, priority));
1598 return(NULL);
1599 }
1600 return(alloc_skb(size, priority));
1601 }
1602
1603
1604 struct sk_buff *
1605 sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority)
1606 {
1607 if (sk) {
1608 if (sk->rmem_alloc + size < sk->rcvbuf || force) {
1609 struct sk_buff *c = alloc_skb(size, priority);
1610 if (c) {
1611 cli();
1612 sk->rmem_alloc += size;
1613 sti();
1614 }
1615 return(c);
1616 }
1617 DPRINTF((DBG_INET, "sock_rmalloc(%X,%d,%d,%d) returning NULL\n",
1618 sk,size,force, priority));
1619 return(NULL);
1620 }
1621 return(alloc_skb(size, priority));
1622 }
1623
1624
1625 unsigned long
1626 sock_rspace(struct sock *sk)
1627 {
1628 int amt;
1629
1630 if (sk != NULL) {
1631 if (sk->rmem_alloc >= sk->rcvbuf-2*MIN_WINDOW) return(0);
1632 amt = min((sk->rcvbuf-sk->rmem_alloc)/2-MIN_WINDOW, MAX_WINDOW);
1633 if (amt < 0) return(0);
1634 return(amt);
1635 }
1636 return(0);
1637 }
1638
1639
1640 unsigned long
1641 sock_wspace(struct sock *sk)
1642 {
1643 if (sk != NULL) {
1644 if (sk->shutdown & SEND_SHUTDOWN) return(0);
1645 if (sk->wmem_alloc >= sk->sndbuf) return(0);
1646 return(sk->sndbuf-sk->wmem_alloc );
1647 }
1648 return(0);
1649 }
1650
1651
1652 void
1653 sock_wfree(struct sock *sk, void *mem, unsigned long size)
1654 {
1655 DPRINTF((DBG_INET, "sock_wfree(sk=%X, mem=%X, size=%d)\n", sk, mem, size));
1656
1657 IS_SKB(mem);
1658 kfree_skbmem(mem, size);
1659 if (sk) {
1660 sk->wmem_alloc -= size;
1661
1662
1663 if (!sk->dead) sk->write_space(sk);
1664 if (sk->destroy && sk->wmem_alloc == 0 && sk->rmem_alloc == 0) {
1665 DPRINTF((DBG_INET,
1666 "recovered lost memory, sock = %X\n", sk));
1667 }
1668 return;
1669 }
1670 }
1671
1672
1673 void
1674 sock_rfree(struct sock *sk, void *mem, unsigned long size)
1675 {
1676 DPRINTF((DBG_INET, "sock_rfree(sk=%X, mem=%X, size=%d)\n", sk, mem, size));
1677 IS_SKB(mem);
1678 kfree_skbmem(mem, size);
1679 if (sk) {
1680 sk->rmem_alloc -= size;
1681 if (sk->destroy && sk->wmem_alloc == 0 && sk->rmem_alloc == 0) {
1682 DPRINTF((DBG_INET,
1683 "recovered lot memory, sock = %X\n", sk));
1684 }
1685 }
1686 }
1687
1688
1689
1690
1691
1692
1693 struct sock *get_sock(struct proto *prot, unsigned short num,
1694 unsigned long raddr,
1695 unsigned short rnum, unsigned long laddr)
1696 {
1697 struct sock *s;
1698 unsigned short hnum;
1699
1700 hnum = ntohs(num);
1701 DPRINTF((DBG_INET, "get_sock(prot=%X, num=%d, raddr=%X, rnum=%d, laddr=%X)\n",
1702 prot, num, raddr, rnum, laddr));
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712 for(s = prot->sock_array[hnum & (SOCK_ARRAY_SIZE - 1)];
1713 s != NULL; s = s->next)
1714 {
1715 if (s->num != hnum)
1716 continue;
1717 if(s->dead && (s->state == TCP_CLOSE))
1718 continue;
1719 if(prot == &udp_prot)
1720 return s;
1721 if(ip_addr_match(s->daddr,raddr)==0)
1722 continue;
1723 if (s->dummy_th.dest != rnum && s->dummy_th.dest != 0)
1724 continue;
1725 if(ip_addr_match(s->saddr,laddr) == 0)
1726 continue;
1727 return(s);
1728 }
1729 return(NULL);
1730 }
1731
1732
1733 void release_sock(struct sock *sk)
1734 {
1735 if (!sk) {
1736 printk("sock.c: release_sock sk == NULL\n");
1737 return;
1738 }
1739 if (!sk->prot) {
1740
1741 return;
1742 }
1743
1744 if (sk->blog) return;
1745
1746
1747 cli();
1748 sk->inuse = 1;
1749 while(sk->back_log != NULL) {
1750 struct sk_buff *skb;
1751
1752 sk->blog = 1;
1753 skb =(struct sk_buff *)sk->back_log;
1754 DPRINTF((DBG_INET, "release_sock: skb = %X:\n", skb));
1755 if (skb->next != skb) {
1756 sk->back_log = skb->next;
1757 skb->prev->next = skb->next;
1758 skb->next->prev = skb->prev;
1759 } else {
1760 sk->back_log = NULL;
1761 }
1762 sti();
1763 DPRINTF((DBG_INET, "sk->back_log = %X\n", sk->back_log));
1764 if (sk->prot->rcv) sk->prot->rcv(skb, skb->dev, sk->opt,
1765 skb->saddr, skb->len, skb->daddr, 1,
1766
1767
1768 (struct inet_protocol *)sk->pair);
1769 cli();
1770 }
1771 sk->blog = 0;
1772 sk->inuse = 0;
1773 sti();
1774 if (sk->dead && sk->state == TCP_CLOSE) {
1775
1776 reset_timer(sk, TIME_DONE, min(sk->rtt * 2, TCP_DONE_TIME));
1777 }
1778 }
1779
1780
1781 static int
1782 inet_fioctl(struct inode *inode, struct file *file,
1783 unsigned int cmd, unsigned long arg)
1784 {
1785 int minor, ret;
1786
1787
1788 minor = MINOR(inode->i_rdev);
1789 if (minor != 0) return(-ENODEV);
1790
1791
1792 switch(minor) {
1793 case 0:
1794 ret = inet_ioctl(NULL, cmd, arg);
1795 break;
1796 case 1:
1797 ret = ip_ioctl(NULL, cmd, arg);
1798 break;
1799 case 2:
1800 ret = icmp_ioctl(NULL, cmd, arg);
1801 break;
1802 case 3:
1803 ret = tcp_ioctl(NULL, cmd, arg);
1804 break;
1805 case 4:
1806 ret = udp_ioctl(NULL, cmd, arg);
1807 break;
1808 default:
1809 ret = -ENODEV;
1810 }
1811
1812 return(ret);
1813 }
1814
1815
1816
1817
1818 static struct file_operations inet_fops = {
1819 NULL,
1820 NULL,
1821 NULL,
1822 NULL,
1823 NULL,
1824 inet_fioctl,
1825 NULL,
1826 NULL,
1827 NULL
1828 };
1829
1830
1831 static struct proto_ops inet_proto_ops = {
1832 AF_INET,
1833
1834 inet_create,
1835 inet_dup,
1836 inet_release,
1837 inet_bind,
1838 inet_connect,
1839 inet_socketpair,
1840 inet_accept,
1841 inet_getname,
1842 inet_read,
1843 inet_write,
1844 inet_select,
1845 inet_ioctl,
1846 inet_listen,
1847 inet_send,
1848 inet_recv,
1849 inet_sendto,
1850 inet_recvfrom,
1851 inet_shutdown,
1852 inet_setsockopt,
1853 inet_getsockopt,
1854 inet_fcntl,
1855 };
1856
1857 extern unsigned long seq_offset;
1858
1859
1860 void inet_proto_init(struct ddi_proto *pro)
1861 {
1862 struct inet_protocol *p;
1863 int i;
1864
1865 printk("Swansea University Computer Society Net2Debugged [1.30]\n");
1866
1867 if (register_chrdev(AF_INET_MAJOR, "af_inet", &inet_fops) < 0) {
1868 printk("%s: cannot register major device %d!\n",
1869 pro->name, AF_INET_MAJOR);
1870 return;
1871 }
1872
1873
1874 (void) sock_register(inet_proto_ops.family, &inet_proto_ops);
1875
1876 seq_offset = CURRENT_TIME*250;
1877
1878
1879 for(i = 0; i < SOCK_ARRAY_SIZE; i++) {
1880 tcp_prot.sock_array[i] = NULL;
1881 udp_prot.sock_array[i] = NULL;
1882 raw_prot.sock_array[i] = NULL;
1883 }
1884 printk("IP Protocols: ");
1885 for(p = inet_protocol_base; p != NULL;) {
1886 struct inet_protocol *tmp;
1887
1888 tmp = (struct inet_protocol *) p->next;
1889 inet_add_protocol(p);
1890 printk("%s%s",p->name,tmp?", ":"\n");
1891 p = tmp;
1892 }
1893
1894
1895 dev_init();
1896
1897
1898 bh_base[INET_BH].routine = inet_bh;
1899 }