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