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