This source file includes following definitions.
- sk_inuse
- get_new_socknum
- put_sock
- remove_sock
- destroy_sock
- inet_fcntl
- inet_setsockopt
- inet_getsockopt
- inet_autobind
- inet_listen
- def_callback1
- def_callback2
- def_callback3
- inet_create
- inet_dup
- inet_release
- inet_bind
- inet_connect
- inet_socketpair
- inet_accept
- inet_getname
- inet_recvmsg
- inet_sendmsg
- inet_shutdown
- inet_select
- inet_ioctl
- get_sock
- get_sock_raw
- get_sock_mcast
- 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 #include <linux/config.h>
59 #include <linux/errno.h>
60 #include <linux/types.h>
61 #include <linux/socket.h>
62 #include <linux/in.h>
63 #include <linux/kernel.h>
64 #include <linux/major.h>
65 #include <linux/sched.h>
66 #include <linux/timer.h>
67 #include <linux/string.h>
68 #include <linux/sockios.h>
69 #include <linux/net.h>
70 #include <linux/fcntl.h>
71 #include <linux/mm.h>
72 #include <linux/interrupt.h>
73 #include <linux/proc_fs.h>
74 #include <linux/stat.h>
75
76 #include <asm/segment.h>
77 #include <asm/system.h>
78
79 #include <linux/inet.h>
80 #include <linux/netdevice.h>
81 #include <net/ip.h>
82 #include <net/protocol.h>
83 #include <net/arp.h>
84 #include <net/rarp.h>
85 #include <net/route.h>
86 #include <net/tcp.h>
87 #include <net/udp.h>
88 #include <linux/skbuff.h>
89 #include <net/sock.h>
90 #include <net/raw.h>
91 #include <net/icmp.h>
92 #include <linux/ip_fw.h>
93 #ifdef CONFIG_IP_MASQUERADE
94 #include <net/ip_masq.h>
95 #endif
96 #ifdef CONFIG_IP_ALIAS
97 #include <net/ip_alias.h>
98 #endif
99 #ifdef CONFIG_KERNELD
100 #include <linux/kerneld.h>
101 #endif
102
103 #define min(a,b) ((a)<(b)?(a):(b))
104
105 extern struct proto packet_prot;
106 extern int raw_get_info(char *, char **, off_t, int, int);
107 extern int snmp_get_info(char *, char **, off_t, int, int);
108 extern int afinet_get_info(char *, char **, off_t, int, int);
109 extern int tcp_get_info(char *, char **, off_t, int, int);
110 extern int udp_get_info(char *, char **, off_t, int, int);
111
112 int (*rarp_ioctl_hook)(unsigned int,void*) = NULL;
113
114
115
116
117
118 static int sk_inuse(struct proto *prot, int num)
119 {
120 struct sock *sk;
121
122 for(sk = prot->sock_array[num & (SOCK_ARRAY_SIZE -1 )];
123 sk != NULL; sk=sk->next)
124 {
125 if (sk->num == num)
126 return(1);
127 }
128 return(0);
129 }
130
131
132
133
134
135
136 unsigned short get_new_socknum(struct proto *prot, unsigned short base)
137 {
138 static int start=0;
139
140
141
142
143
144
145 int i, j;
146 int best = 0;
147 int size = 32767;
148 struct sock *sk;
149
150 if (base == 0)
151 base = PROT_SOCK+1+(start % 1024);
152 if (base <= PROT_SOCK)
153 {
154 base += PROT_SOCK+(start % 1024);
155 }
156
157
158
159
160
161 for(i=0; i < SOCK_ARRAY_SIZE; i++)
162 {
163 j = 0;
164 sk = prot->sock_array[(i+base+1) &(SOCK_ARRAY_SIZE -1)];
165 while(sk != NULL)
166 {
167 sk = sk->next;
168 j++;
169 }
170 if (j == 0)
171 {
172 start =(i+1+start )%1024;
173 return(i+base+1);
174 }
175 if (j < size)
176 {
177 best = i;
178 size = j;
179 }
180 }
181
182
183
184 while(sk_inuse(prot, base +best+1))
185 {
186 best += SOCK_ARRAY_SIZE;
187 }
188 return(best+base+1);
189 }
190
191
192
193
194
195 void put_sock(unsigned short num, struct sock *sk)
196 {
197 struct sock **skp, *tmp;
198 int mask;
199 unsigned long flags;
200
201 if(sk->type==SOCK_PACKET)
202 return;
203
204 sk->num = num;
205 sk->next = NULL;
206 num = num &(SOCK_ARRAY_SIZE -1);
207
208
209
210
211
212 save_flags(flags);
213 cli();
214
215 sk->prot->inuse += 1;
216 if (sk->prot->highestinuse < sk->prot->inuse)
217 sk->prot->highestinuse = sk->prot->inuse;
218
219 if (sk->prot->sock_array[num] == NULL)
220 {
221 sk->prot->sock_array[num] = sk;
222 restore_flags(flags);
223 return;
224 }
225
226 restore_flags(flags);
227 for(mask = 0xff000000; mask != 0xffffffff; mask = (mask >> 8) | mask)
228 {
229 if ((mask & sk->rcv_saddr) &&
230 (mask & sk->rcv_saddr) != (mask & 0xffffffff))
231 {
232 mask = mask << 8;
233 break;
234 }
235 }
236
237
238
239
240 skp = sk->prot->sock_array + num;
241 cli();
242 while ((tmp = *skp) != NULL) {
243 if (!(tmp->rcv_saddr & mask))
244 break;
245 skp = &tmp->next;
246 }
247 sk->next = tmp;
248 *skp = sk;
249 sti();
250 }
251
252
253
254
255
256 static void remove_sock(struct sock *sk1)
257 {
258 struct sock **p;
259 unsigned long flags;
260
261 if (sk1->type==SOCK_PACKET)
262 return;
263
264 if (!sk1->prot)
265 {
266 NETDEBUG(printk("sock.c: remove_sock: sk1->prot == NULL\n"));
267 return;
268 }
269
270
271 save_flags(flags);
272 cli();
273
274 p=&(sk1->prot->sock_array[sk1->num & (SOCK_ARRAY_SIZE -1)]);
275
276 while(*p!=NULL)
277 {
278 if(*p==sk1)
279 {
280 sk1->prot->inuse--;
281 *p=sk1->next;
282 break;
283 }
284 p=&((*p)->next);
285 }
286 restore_flags(flags);
287 }
288
289
290
291
292
293 void destroy_sock(struct sock *sk)
294 {
295 struct sk_buff *skb;
296
297 lock_sock(sk);
298
299 remove_sock(sk);
300
301
302
303
304
305
306 delete_timer(sk);
307 del_timer(&sk->retransmit_timer);
308
309
310
311
312
313 while ((skb = tcp_dequeue_partial(sk)) != NULL)
314 {
315 IS_SKB(skb);
316 kfree_skb(skb, FREE_WRITE);
317 }
318
319
320
321
322
323 while((skb = skb_dequeue(&sk->write_queue)) != NULL) {
324 IS_SKB(skb);
325 kfree_skb(skb, FREE_WRITE);
326 }
327
328
329
330
331
332 while((skb=skb_dequeue(&sk->receive_queue))!=NULL)
333 {
334
335
336
337
338 if (skb->sk != NULL && skb->sk != sk)
339 {
340 IS_SKB(skb);
341 skb->sk->prot->close(skb->sk, 0);
342 }
343 IS_SKB(skb);
344 kfree_skb(skb, FREE_READ);
345 }
346
347
348
349
350
351 cli();
352 for(skb = sk->send_head; skb != NULL; )
353 {
354 struct sk_buff *skb2;
355
356
357
358
359
360 if (skb->next && skb->prev)
361 {
362 IS_SKB(skb);
363 skb_unlink(skb);
364 }
365 skb->dev = NULL;
366 skb2 = skb->link3;
367 kfree_skb(skb, FREE_WRITE);
368 skb = skb2;
369 }
370 sk->send_head = NULL;
371 sti();
372
373
374
375
376
377 while((skb=skb_dequeue(&sk->back_log))!=NULL)
378 {
379
380 skb->sk = NULL;
381 kfree_skb(skb, FREE_READ);
382 }
383
384
385
386
387
388 if (sk->pair)
389 {
390 sk->pair->prot->close(sk->pair, 0);
391 sk->pair = NULL;
392 }
393
394
395
396
397
398
399
400 if (sk->rmem_alloc == 0 && sk->wmem_alloc == 0)
401 {
402 if(sk->opt)
403 kfree(sk->opt);
404 ip_rt_put(sk->ip_route_cache);
405
406
407
408
409 tcp_cache_zap();
410 sk_free(sk);
411 }
412 else
413 {
414
415
416 printk("Socket destroy delayed (r=%d w=%d)\n",
417 sk->rmem_alloc, sk->wmem_alloc);
418 sk->destroy = 1;
419 sk->ack_backlog = 0;
420 release_sock(sk);
421 reset_timer(sk, TIME_DESTROY, SOCK_DESTROY_TIME);
422 }
423 }
424
425
426
427
428
429
430
431 static int inet_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
432 {
433 struct sock *sk;
434
435 sk = (struct sock *) sock->data;
436
437 switch(cmd)
438 {
439 case F_SETOWN:
440
441
442
443
444
445 if (!suser() && current->pgrp != -arg &&
446 current->pid != arg) return(-EPERM);
447 sk->proc = arg;
448 return(0);
449 case F_GETOWN:
450 return(sk->proc);
451 default:
452 return(-EINVAL);
453 }
454 }
455
456
457
458
459
460 static int inet_setsockopt(struct socket *sock, int level, int optname,
461 char *optval, int optlen)
462 {
463 struct sock *sk = (struct sock *) sock->data;
464 if (level == SOL_SOCKET)
465 return sock_setsockopt(sk,level,optname,optval,optlen);
466 if (sk->prot->setsockopt==NULL)
467 return(-EOPNOTSUPP);
468 else
469 return sk->prot->setsockopt(sk,level,optname,optval,optlen);
470 }
471
472
473
474
475
476 static int inet_getsockopt(struct socket *sock, int level, int optname,
477 char *optval, int *optlen)
478 {
479 struct sock *sk = (struct sock *) sock->data;
480 if (level == SOL_SOCKET)
481 return sock_getsockopt(sk,level,optname,optval,optlen);
482 if(sk->prot->getsockopt==NULL)
483 return(-EOPNOTSUPP);
484 else
485 return sk->prot->getsockopt(sk,level,optname,optval,optlen);
486 }
487
488
489
490
491
492 static int inet_autobind(struct sock *sk)
493 {
494
495 if (sk->num == 0)
496 {
497 sk->num = get_new_socknum(sk->prot, 0);
498 if (sk->num == 0)
499 return(-EAGAIN);
500 udp_cache_zap();
501 tcp_cache_zap();
502 put_sock(sk->num, sk);
503 sk->dummy_th.source = ntohs(sk->num);
504 }
505 return 0;
506 }
507
508
509
510
511
512 static int inet_listen(struct socket *sock, int backlog)
513 {
514 struct sock *sk = (struct sock *) sock->data;
515
516 if(inet_autobind(sk)!=0)
517 return -EAGAIN;
518
519
520
521
522
523
524
525
526 if ((unsigned) backlog == 0)
527 backlog = 1;
528 if ((unsigned) backlog > SOMAXCONN)
529 backlog = SOMAXCONN;
530 sk->max_ack_backlog = backlog;
531 if (sk->state != TCP_LISTEN)
532 {
533 sk->ack_backlog = 0;
534 sk->state = TCP_LISTEN;
535 }
536 return(0);
537 }
538
539
540
541
542
543
544 static void def_callback1(struct sock *sk)
545 {
546 if(!sk->dead)
547 wake_up_interruptible(sk->sleep);
548 }
549
550 static void def_callback2(struct sock *sk,int len)
551 {
552 if(!sk->dead)
553 {
554 wake_up_interruptible(sk->sleep);
555 sock_wake_async(sk->socket, 1);
556 }
557 }
558
559 static void def_callback3(struct sock *sk)
560 {
561 if(!sk->dead && sk->wmem_alloc*2 <= sk->sndbuf)
562 {
563 wake_up_interruptible(sk->sleep);
564 sock_wake_async(sk->socket, 2);
565 }
566 }
567
568
569
570
571
572
573
574
575 static int inet_create(struct socket *sock, int protocol)
576 {
577 struct sock *sk;
578 struct proto *prot;
579 int err;
580
581 sk = sk_alloc(GFP_KERNEL);
582 if (sk == NULL)
583 return(-ENOBUFS);
584 memset(sk,0,sizeof(*sk));
585
586
587
588 switch(sock->type)
589 {
590 case SOCK_STREAM:
591 case SOCK_SEQPACKET:
592 if (protocol && protocol != IPPROTO_TCP)
593 {
594 sk_free(sk);
595 return(-EPROTONOSUPPORT);
596 }
597 protocol = IPPROTO_TCP;
598 sk->no_check = TCP_NO_CHECK;
599 prot = &tcp_prot;
600 break;
601
602 case SOCK_DGRAM:
603 if (protocol && protocol != IPPROTO_UDP)
604 {
605 sk_free(sk);
606 return(-EPROTONOSUPPORT);
607 }
608 protocol = IPPROTO_UDP;
609 sk->no_check = UDP_NO_CHECK;
610 prot=&udp_prot;
611 break;
612
613 case SOCK_RAW:
614 if (!suser())
615 {
616 sk_free(sk);
617 return(-EPERM);
618 }
619 if (!protocol)
620 {
621 sk_free(sk);
622 return(-EPROTONOSUPPORT);
623 }
624 prot = &raw_prot;
625 sk->reuse = 1;
626 sk->num = protocol;
627 break;
628
629 case SOCK_PACKET:
630 if (!suser())
631 {
632 sk_free(sk);
633 return(-EPERM);
634 }
635 if (!protocol)
636 {
637 sk_free(sk);
638 return(-EPROTONOSUPPORT);
639 }
640 prot = &packet_prot;
641 sk->reuse = 1;
642 sk->num = protocol;
643 break;
644
645 default:
646 sk_free(sk);
647 return(-ESOCKTNOSUPPORT);
648 }
649 sk->socket = sock;
650 #ifdef CONFIG_TCP_NAGLE_OFF
651 sk->nonagle = 1;
652 #endif
653 sk->type = sock->type;
654 sk->protocol = protocol;
655 sk->allocation = GFP_KERNEL;
656 sk->sndbuf = SK_WMEM_MAX;
657 sk->rcvbuf = SK_RMEM_MAX;
658 sk->rto = TCP_TIMEOUT_INIT;
659 sk->cong_window = 1;
660 sk->priority = 1;
661 sk->state = TCP_CLOSE;
662
663
664 sk->max_unacked = 2048;
665 sk->delay_acks = 1;
666 sk->max_ack_backlog = SOMAXCONN;
667 skb_queue_head_init(&sk->write_queue);
668 skb_queue_head_init(&sk->receive_queue);
669 sk->mtu = 576;
670 sk->prot = prot;
671 sk->sleep = sock->wait;
672 init_timer(&sk->timer);
673 init_timer(&sk->retransmit_timer);
674 sk->timer.data = (unsigned long)sk;
675 sk->timer.function = &net_timer;
676 skb_queue_head_init(&sk->back_log);
677 sock->data =(void *) sk;
678 sk->dummy_th.doff = sizeof(sk->dummy_th)/4;
679 sk->ip_ttl=ip_statistics.IpDefaultTTL;
680 if(sk->type==SOCK_RAW && protocol==IPPROTO_RAW)
681 sk->ip_hdrincl=1;
682 else
683 sk->ip_hdrincl=0;
684 #ifdef CONFIG_IP_MULTICAST
685 sk->ip_mc_loop=1;
686 sk->ip_mc_ttl=1;
687 *sk->ip_mc_name=0;
688 sk->ip_mc_list=NULL;
689 #endif
690
691
692
693
694
695 sk->dummy_th.ack=1;
696 sk->dummy_th.doff=sizeof(struct tcphdr)>>2;
697
698 sk->state_change = def_callback1;
699 sk->data_ready = def_callback2;
700 sk->write_space = def_callback3;
701 sk->error_report = def_callback1;
702
703 if (sk->num)
704 {
705
706
707
708
709
710
711 put_sock(sk->num, sk);
712 sk->dummy_th.source = ntohs(sk->num);
713 }
714
715 if (sk->prot->init)
716 {
717 err = sk->prot->init(sk);
718 if (err != 0)
719 {
720 destroy_sock(sk);
721 return(err);
722 }
723 }
724 return(0);
725 }
726
727
728
729
730
731
732 static int inet_dup(struct socket *newsock, struct socket *oldsock)
733 {
734 return(inet_create(newsock,((struct sock *)(oldsock->data))->protocol));
735 }
736
737
738
739
740
741
742
743 static int inet_release(struct socket *sock, struct socket *peer)
744 {
745 unsigned long timeout;
746 struct sock *sk = (struct sock *) sock->data;
747
748 if (sk == NULL)
749 return(0);
750
751 sk->state_change(sk);
752
753
754
755 #ifdef CONFIG_IP_MULTICAST
756
757 ip_mc_drop_socket(sk);
758 #endif
759
760
761
762
763
764
765
766
767 timeout = 0;
768 if (sk->linger) {
769 timeout = ~0UL;
770 if (!sk->lingertime)
771 timeout = jiffies + HZ*sk->lingertime;
772 }
773 if (current->flags & PF_EXITING)
774 timeout = 0;
775
776 sock->data = NULL;
777 sk->socket = NULL;
778
779 sk->prot->close(sk, timeout);
780 return(0);
781 }
782
783
784 static int inet_bind(struct socket *sock, struct sockaddr *uaddr,
785 int addr_len)
786 {
787 struct sockaddr_in *addr=(struct sockaddr_in *)uaddr;
788 struct sock *sk=(struct sock *)sock->data, *sk2;
789 unsigned short snum = 0 ;
790 int chk_addr_ret;
791
792
793
794
795
796 if(sk->prot->bind)
797 return sk->prot->bind(sk,uaddr, addr_len);
798
799
800 if (sk->state != TCP_CLOSE)
801 return(-EIO);
802 if(addr_len<sizeof(struct sockaddr_in))
803 return -EINVAL;
804
805 if(sock->type != SOCK_RAW)
806 {
807 if (sk->num != 0)
808 return(-EINVAL);
809
810 snum = ntohs(addr->sin_port);
811
812 #ifdef CONFIG_IP_MASQUERADE
813
814
815
816 if(snum>=PORT_MASQ_BEGIN && snum<=PORT_MASQ_END)
817 return -EADDRINUSE;
818 #endif
819
820 if (snum == 0)
821 snum = get_new_socknum(sk->prot, 0);
822 if (snum < PROT_SOCK && !suser())
823 return(-EACCES);
824 }
825
826 chk_addr_ret = ip_chk_addr(addr->sin_addr.s_addr);
827 if (addr->sin_addr.s_addr != 0 && chk_addr_ret != IS_MYADDR && chk_addr_ret != IS_MULTICAST && chk_addr_ret != IS_BROADCAST)
828 return(-EADDRNOTAVAIL);
829
830 if (chk_addr_ret || addr->sin_addr.s_addr == 0)
831 {
832
833
834
835
836
837
838
839
840 sk->rcv_saddr = addr->sin_addr.s_addr;
841 if(chk_addr_ret==IS_MULTICAST||chk_addr_ret==IS_BROADCAST)
842 sk->saddr = 0;
843 else
844 sk->saddr = addr->sin_addr.s_addr;
845 }
846 if(sock->type != SOCK_RAW)
847 {
848
849 cli();
850 for(sk2 = sk->prot->sock_array[snum & (SOCK_ARRAY_SIZE -1)];
851 sk2 != NULL; sk2 = sk2->next)
852 {
853
854
855
856
857 if (sk2->num != snum)
858 continue;
859
860
861
862
863
864
865 if (!sk2->rcv_saddr || !sk->rcv_saddr)
866 {
867
868
869
870 if(sk2->reuse && sk->reuse && sk2->state!=TCP_LISTEN)
871 continue;
872 sti();
873 return(-EADDRINUSE);
874 }
875
876
877
878
879
880 if (sk2->rcv_saddr != sk->rcv_saddr)
881 continue;
882
883
884
885
886 if (!sk->reuse)
887 {
888 sti();
889 return(-EADDRINUSE);
890 }
891
892
893
894
895
896 if (!sk2->reuse || sk2->state==TCP_LISTEN)
897 {
898 sti();
899 return(-EADDRINUSE);
900 }
901 }
902 sti();
903
904 remove_sock(sk);
905 if(sock->type==SOCK_DGRAM)
906 udp_cache_zap();
907 if(sock->type==SOCK_STREAM)
908 tcp_cache_zap();
909 put_sock(snum, sk);
910 sk->dummy_th.source = ntohs(sk->num);
911 sk->daddr = 0;
912 sk->dummy_th.dest = 0;
913 }
914 ip_rt_put(sk->ip_route_cache);
915 sk->ip_route_cache=NULL;
916 return(0);
917 }
918
919
920
921
922
923
924 static int inet_connect(struct socket *sock, struct sockaddr * uaddr,
925 int addr_len, int flags)
926 {
927 struct sock *sk=(struct sock *)sock->data;
928 int err;
929 sock->conn = NULL;
930
931 if (sock->state == SS_CONNECTING && tcp_connected(sk->state))
932 {
933 sock->state = SS_CONNECTED;
934
935 return 0;
936 }
937
938 if (sock->state == SS_CONNECTING && sk->protocol == IPPROTO_TCP && (flags & O_NONBLOCK))
939 {
940 if(sk->err!=0)
941 return sock_error(sk);
942 return -EALREADY;
943 }
944 if (sock->state != SS_CONNECTING)
945 {
946
947 if(inet_autobind(sk)!=0)
948 return(-EAGAIN);
949 if (sk->prot->connect == NULL)
950 return(-EOPNOTSUPP);
951 err = sk->prot->connect(sk, (struct sockaddr_in *)uaddr, addr_len);
952 if (err < 0)
953 return(err);
954 sock->state = SS_CONNECTING;
955 }
956
957 if (sk->state > TCP_FIN_WAIT2 && sock->state==SS_CONNECTING)
958 {
959 sock->state=SS_UNCONNECTED;
960 return sock_error(sk);
961 }
962
963 if (sk->state != TCP_ESTABLISHED &&(flags & O_NONBLOCK))
964 return(-EINPROGRESS);
965
966 cli();
967 while(sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
968 {
969 interruptible_sleep_on(sk->sleep);
970 if (current->signal & ~current->blocked)
971 {
972 sti();
973 return(-ERESTARTSYS);
974 }
975
976
977 if(sk->err && sk->protocol == IPPROTO_TCP)
978 {
979 sock->state = SS_UNCONNECTED;
980 sti();
981 return sock_error(sk);
982 }
983 }
984 sti();
985 sock->state = SS_CONNECTED;
986
987 if (sk->state != TCP_ESTABLISHED && sk->err)
988 {
989 sock->state = SS_UNCONNECTED;
990 return sock_error(sk);
991 }
992 return(0);
993 }
994
995
996 static int inet_socketpair(struct socket *sock1, struct socket *sock2)
997 {
998 return(-EOPNOTSUPP);
999 }
1000
1001
1002
1003
1004
1005
1006 static int inet_accept(struct socket *sock, struct socket *newsock, int flags)
1007 {
1008 struct sock *sk1, *sk2;
1009 int err;
1010
1011 sk1 = (struct sock *) sock->data;
1012
1013
1014
1015
1016
1017
1018
1019 if (newsock->data)
1020 {
1021 struct sock *sk=(struct sock *)newsock->data;
1022 newsock->data=NULL;
1023 destroy_sock(sk);
1024 }
1025
1026 if (sk1->prot->accept == NULL)
1027 return(-EOPNOTSUPP);
1028
1029
1030
1031
1032
1033 if (sk1->pair != NULL )
1034 {
1035 sk2 = sk1->pair;
1036 sk1->pair = NULL;
1037 }
1038 else
1039 {
1040 sk2 = sk1->prot->accept(sk1,flags);
1041 if (sk2 == NULL)
1042 {
1043 return sock_error(sk1);
1044 }
1045 }
1046 newsock->data = (void *)sk2;
1047 sk2->sleep = newsock->wait;
1048 sk2->socket = newsock;
1049 newsock->conn = NULL;
1050 if (flags & O_NONBLOCK)
1051 return(0);
1052
1053 cli();
1054 while(sk2->state == TCP_SYN_RECV)
1055 {
1056 interruptible_sleep_on(sk2->sleep);
1057 if (current->signal & ~current->blocked)
1058 {
1059 sti();
1060 sk1->pair = sk2;
1061 sk2->sleep = NULL;
1062 sk2->socket=NULL;
1063 newsock->data = NULL;
1064 return(-ERESTARTSYS);
1065 }
1066 }
1067 sti();
1068
1069 if (sk2->state != TCP_ESTABLISHED && sk2->err > 0)
1070 {
1071 err = sock_error(sk2);
1072 destroy_sock(sk2);
1073 newsock->data = NULL;
1074 return err;
1075 }
1076 newsock->state = SS_CONNECTED;
1077 return(0);
1078 }
1079
1080
1081
1082
1083
1084
1085 static int inet_getname(struct socket *sock, struct sockaddr *uaddr,
1086 int *uaddr_len, int peer)
1087 {
1088 struct sockaddr_in *sin=(struct sockaddr_in *)uaddr;
1089 struct sock *sk;
1090
1091 sin->sin_family = AF_INET;
1092 sk = (struct sock *) sock->data;
1093 if (peer)
1094 {
1095 if (!tcp_connected(sk->state))
1096 return(-ENOTCONN);
1097 sin->sin_port = sk->dummy_th.dest;
1098 sin->sin_addr.s_addr = sk->daddr;
1099 }
1100 else
1101 {
1102 __u32 addr = sk->rcv_saddr;
1103 if (!addr) {
1104 addr = sk->saddr;
1105 if (!addr)
1106 addr = ip_my_addr();
1107 }
1108 sin->sin_port = sk->dummy_th.source;
1109 sin->sin_addr.s_addr = addr;
1110 }
1111 *uaddr_len = sizeof(*sin);
1112 return(0);
1113 }
1114
1115
1116
1117 static int inet_recvmsg(struct socket *sock, struct msghdr *ubuf, int size, int noblock,
1118 int flags, int *addr_len )
1119 {
1120 struct sock *sk = (struct sock *) sock->data;
1121
1122 if (sk->prot->recvmsg == NULL)
1123 return(-EOPNOTSUPP);
1124 if(sk->err)
1125 return sock_error(sk);
1126
1127 if(inet_autobind(sk)!=0)
1128 return(-EAGAIN);
1129 return(sk->prot->recvmsg(sk, ubuf, size, noblock, flags,addr_len));
1130 }
1131
1132
1133 static int inet_sendmsg(struct socket *sock, struct msghdr *msg, int size, int noblock,
1134 int flags)
1135 {
1136 struct sock *sk = (struct sock *) sock->data;
1137 if (sk->shutdown & SEND_SHUTDOWN)
1138 {
1139 send_sig(SIGPIPE, current, 1);
1140 return(-EPIPE);
1141 }
1142 if (sk->prot->sendmsg == NULL)
1143 return(-EOPNOTSUPP);
1144 if(sk->err)
1145 return sock_error(sk);
1146
1147 if(inet_autobind(sk)!=0)
1148 return -EAGAIN;
1149 return(sk->prot->sendmsg(sk, msg, size, noblock, flags));
1150
1151 }
1152
1153
1154 static int inet_shutdown(struct socket *sock, int how)
1155 {
1156 struct sock *sk=(struct sock*)sock->data;
1157
1158
1159
1160
1161
1162 how++;
1163
1164
1165 if ((how & ~SHUTDOWN_MASK) || how==0)
1166 return(-EINVAL);
1167 if (sock->state == SS_CONNECTING && sk->state == TCP_ESTABLISHED)
1168 sock->state = SS_CONNECTED;
1169 if (!sk || !tcp_connected(sk->state))
1170 return(-ENOTCONN);
1171 sk->shutdown |= how;
1172 if (sk->prot->shutdown)
1173 sk->prot->shutdown(sk, how);
1174 return(0);
1175 }
1176
1177
1178 static int inet_select(struct socket *sock, int sel_type, select_table *wait )
1179 {
1180 struct sock *sk=(struct sock *) sock->data;
1181 if (sk->prot->select == NULL)
1182 {
1183 return(0);
1184 }
1185 return(sk->prot->select(sk, sel_type, wait));
1186 }
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198 static int inet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1199 {
1200 struct sock *sk=(struct sock *)sock->data;
1201 int err;
1202 int pid;
1203
1204 switch(cmd)
1205 {
1206 case FIOSETOWN:
1207 case SIOCSPGRP:
1208 err=verify_area(VERIFY_READ,(int *)arg,sizeof(long));
1209 if(err)
1210 return err;
1211 pid = get_user((int *) arg);
1212
1213 if (current->pid != pid && current->pgrp != -pid && !suser())
1214 return -EPERM;
1215 sk->proc = pid;
1216 return(0);
1217 case FIOGETOWN:
1218 case SIOCGPGRP:
1219 err=verify_area(VERIFY_WRITE,(void *) arg, sizeof(long));
1220 if(err)
1221 return err;
1222 put_fs_long(sk->proc,(int *)arg);
1223 return(0);
1224 case SIOCGSTAMP:
1225 if(sk->stamp.tv_sec==0)
1226 return -ENOENT;
1227 err=verify_area(VERIFY_WRITE,(void *)arg,sizeof(struct timeval));
1228 if(err)
1229 return err;
1230 memcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
1231 return 0;
1232 case SIOCADDRT:
1233 case SIOCDELRT:
1234 return(ip_rt_ioctl(cmd,(void *) arg));
1235 case SIOCDARP:
1236 case SIOCGARP:
1237 case SIOCSARP:
1238 case OLD_SIOCDARP:
1239 case OLD_SIOCGARP:
1240 case OLD_SIOCSARP:
1241 return(arp_ioctl(cmd,(void *) arg));
1242 case SIOCDRARP:
1243 case SIOCGRARP:
1244 case SIOCSRARP:
1245 #ifdef CONFIG_KERNELD
1246 if (rarp_ioctl_hook == NULL)
1247 request_module("rarp");
1248 #endif
1249 if (rarp_ioctl_hook != NULL)
1250 return(rarp_ioctl_hook(cmd,(void *) arg));
1251 case SIOCGIFCONF:
1252 case SIOCGIFFLAGS:
1253 case SIOCSIFFLAGS:
1254 case SIOCGIFADDR:
1255 case SIOCSIFADDR:
1256 case SIOCADDMULTI:
1257 case SIOCDELMULTI:
1258 case SIOCGIFDSTADDR:
1259 case SIOCSIFDSTADDR:
1260 case SIOCGIFBRDADDR:
1261 case SIOCSIFBRDADDR:
1262 case SIOCGIFNETMASK:
1263 case SIOCSIFNETMASK:
1264 case SIOCGIFMETRIC:
1265 case SIOCSIFMETRIC:
1266 case SIOCGIFMEM:
1267 case SIOCSIFMEM:
1268 case SIOCGIFMTU:
1269 case SIOCSIFMTU:
1270 case SIOCSIFLINK:
1271 case SIOCGIFHWADDR:
1272 case SIOCSIFHWADDR:
1273 case SIOCSIFMAP:
1274 case SIOCGIFMAP:
1275 case SIOCSIFSLAVE:
1276 case SIOCGIFSLAVE:
1277 return(dev_ioctl(cmd,(void *) arg));
1278
1279 default:
1280 if ((cmd >= SIOCDEVPRIVATE) &&
1281 (cmd <= (SIOCDEVPRIVATE + 15)))
1282 return(dev_ioctl(cmd,(void *) arg));
1283
1284 if (sk->prot->ioctl==NULL)
1285 return(-EINVAL);
1286 return(sk->prot->ioctl(sk, cmd, arg));
1287 }
1288
1289 return(0);
1290 }
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301 struct sock *get_sock(struct proto *prot, unsigned short num,
1302 unsigned long raddr,
1303 unsigned short rnum, unsigned long laddr)
1304 {
1305 struct sock *s;
1306 struct sock *result = NULL;
1307 int badness = -1;
1308 unsigned short hnum;
1309
1310 hnum = ntohs(num);
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321 for(s = prot->sock_array[hnum & (SOCK_ARRAY_SIZE - 1)];
1322 s != NULL; s = s->next)
1323 {
1324 int score = 0;
1325
1326 if (s->num != hnum)
1327 continue;
1328
1329 if(s->dead && (s->state == TCP_CLOSE))
1330 continue;
1331
1332 if (s->rcv_saddr) {
1333 if (s->rcv_saddr != laddr)
1334 continue;
1335 score++;
1336 }
1337
1338 if (s->daddr) {
1339 if (s->daddr != raddr)
1340 continue;
1341 score++;
1342 }
1343
1344 if (s->dummy_th.dest) {
1345 if (s->dummy_th.dest != rnum)
1346 continue;
1347 score++;
1348 }
1349
1350 if (score == 3)
1351 return s;
1352
1353 if (score <= badness)
1354 continue;
1355 result = s;
1356 badness = score;
1357 }
1358 return result;
1359 }
1360
1361
1362
1363
1364
1365 struct sock *get_sock_raw(struct sock *sk,
1366 unsigned short num,
1367 unsigned long raddr,
1368 unsigned long laddr)
1369 {
1370 struct sock *s;
1371
1372 s=sk;
1373
1374 for(; s != NULL; s = s->next)
1375 {
1376 if (s->num != num)
1377 continue;
1378 if(s->dead && (s->state == TCP_CLOSE))
1379 continue;
1380 if(s->daddr && s->daddr!=raddr)
1381 continue;
1382 if(s->rcv_saddr && s->rcv_saddr != laddr)
1383 continue;
1384 return(s);
1385 }
1386 return(NULL);
1387 }
1388
1389 #ifdef CONFIG_IP_MULTICAST
1390
1391
1392
1393
1394 struct sock *get_sock_mcast(struct sock *sk,
1395 unsigned short num,
1396 unsigned long raddr,
1397 unsigned short rnum, unsigned long laddr)
1398 {
1399 struct sock *s;
1400 unsigned short hnum;
1401
1402 hnum = ntohs(num);
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413 s=sk;
1414
1415 for(; s != NULL; s = s->next)
1416 {
1417 if (s->num != hnum)
1418 continue;
1419 if(s->dead && (s->state == TCP_CLOSE))
1420 continue;
1421 if(s->daddr && s->daddr!=raddr)
1422 continue;
1423 if (s->dummy_th.dest != rnum && s->dummy_th.dest != 0)
1424 continue;
1425 if(s->rcv_saddr && s->rcv_saddr != laddr)
1426 continue;
1427 return(s);
1428 }
1429 return(NULL);
1430 }
1431
1432 #endif
1433
1434 static struct proto_ops inet_proto_ops = {
1435 AF_INET,
1436
1437 inet_create,
1438 inet_dup,
1439 inet_release,
1440 inet_bind,
1441 inet_connect,
1442 inet_socketpair,
1443 inet_accept,
1444 inet_getname,
1445 inet_select,
1446 inet_ioctl,
1447 inet_listen,
1448 inet_shutdown,
1449 inet_setsockopt,
1450 inet_getsockopt,
1451 inet_fcntl,
1452 inet_sendmsg,
1453 inet_recvmsg
1454 };
1455
1456 extern unsigned long seq_offset;
1457
1458
1459
1460
1461
1462 void inet_proto_init(struct net_proto *pro)
1463 {
1464 struct inet_protocol *p;
1465 int i;
1466
1467
1468 printk("Swansea University Computer Society TCP/IP for NET3.034\n");
1469
1470
1471
1472
1473
1474 (void) sock_register(inet_proto_ops.family, &inet_proto_ops);
1475
1476 seq_offset = CURRENT_TIME*250;
1477
1478
1479
1480
1481
1482 for(i = 0; i < SOCK_ARRAY_SIZE; i++)
1483 {
1484 tcp_prot.sock_array[i] = NULL;
1485 udp_prot.sock_array[i] = NULL;
1486 raw_prot.sock_array[i] = NULL;
1487 }
1488 tcp_prot.inuse = 0;
1489 tcp_prot.highestinuse = 0;
1490 udp_prot.inuse = 0;
1491 udp_prot.highestinuse = 0;
1492 raw_prot.inuse = 0;
1493 raw_prot.highestinuse = 0;
1494
1495 printk("IP Protocols: ");
1496 for(p = inet_protocol_base; p != NULL;)
1497 {
1498 struct inet_protocol *tmp = (struct inet_protocol *) p->next;
1499 inet_add_protocol(p);
1500 printk("%s%s",p->name,tmp?", ":"\n");
1501 p = tmp;
1502 }
1503
1504
1505
1506
1507 arp_init();
1508
1509
1510
1511 ip_init();
1512
1513
1514
1515 icmp_init(&inet_proto_ops);
1516
1517
1518
1519 #if defined(CONFIG_IP_ACCT)||defined(CONFIG_IP_FIREWALL)|| \
1520 defined(CONFIG_IP_MASQUERADE)
1521 ip_fw_init();
1522 #endif
1523
1524
1525
1526 #if defined(CONFIG_IP_MROUTE)
1527 ip_mr_init();
1528 #endif
1529
1530
1531
1532
1533
1534 #if defined(CONFIG_IP_ALIAS)
1535 ip_alias_init();
1536 #endif
1537
1538 #ifdef CONFIG_INET_RARP
1539 rarp_ioctl_hook = rarp_ioctl;
1540 #endif
1541
1542
1543
1544
1545 #ifdef CONFIG_PROC_FS
1546
1547 #ifdef CONFIG_INET_RARP
1548 proc_net_register(&(struct proc_dir_entry) {
1549 PROC_NET_RARP, 4, "rarp",
1550 S_IFREG | S_IRUGO, 1, 0, 0,
1551 0, &proc_net_inode_operations,
1552 rarp_get_info
1553 });
1554 #endif
1555
1556 proc_net_register(&(struct proc_dir_entry) {
1557 PROC_NET_RAW, 3, "raw",
1558 S_IFREG | S_IRUGO, 1, 0, 0,
1559 0, &proc_net_inode_operations,
1560 raw_get_info
1561 });
1562 proc_net_register(&(struct proc_dir_entry) {
1563 PROC_NET_SNMP, 4, "snmp",
1564 S_IFREG | S_IRUGO, 1, 0, 0,
1565 0, &proc_net_inode_operations,
1566 snmp_get_info
1567 });
1568 proc_net_register(&(struct proc_dir_entry) {
1569 PROC_NET_SOCKSTAT, 8, "sockstat",
1570 S_IFREG | S_IRUGO, 1, 0, 0,
1571 0, &proc_net_inode_operations,
1572 afinet_get_info
1573 });
1574 proc_net_register(&(struct proc_dir_entry) {
1575 PROC_NET_TCP, 3, "tcp",
1576 S_IFREG | S_IRUGO, 1, 0, 0,
1577 0, &proc_net_inode_operations,
1578 tcp_get_info
1579 });
1580 proc_net_register(&(struct proc_dir_entry) {
1581 PROC_NET_UDP, 3, "udp",
1582 S_IFREG | S_IRUGO, 1, 0, 0,
1583 0, &proc_net_inode_operations,
1584 udp_get_info
1585 });
1586 proc_net_register(&(struct proc_dir_entry) {
1587 PROC_NET_ROUTE, 5, "route",
1588 S_IFREG | S_IRUGO, 1, 0, 0,
1589 0, &proc_net_inode_operations,
1590 rt_get_info
1591 });
1592 proc_net_register(&(struct proc_dir_entry) {
1593 PROC_NET_RTCACHE, 8, "rt_cache",
1594 S_IFREG | S_IRUGO, 1, 0, 0,
1595 0, &proc_net_inode_operations,
1596 rt_cache_get_info
1597 });
1598 #endif
1599 }