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