sock.c

An implementation of the TCP/IP protocol suite for the LINUX operating system. INET is implemented u

761   sk = (struct sock *) kmalloc(sizeof(*sk), GFP_KERNEL);
762   if (sk == NULL) 
763         return(-ENOMEM);
764   sk->num = 0;
765   sk->reuse = 0;
766   switch(sock->type) {
767         case SOCK_STREAM:
768         case SOCK_SEQPACKET:
769                 if (protocol && protocol != IPPROTO_TCP) {
770                         kfree_s((void *)sk, sizeof(*sk));
771                         return(-EPROTONOSUPPORT);
772                 }
773                 protocol = IPPROTO_TCP;
774                 sk->no_check = TCP_NO_CHECK;
775                 prot = &tcp_prot;
776                 break;
777 
778         case SOCK_DGRAM:
779                 if (protocol && protocol != IPPROTO_UDP) {
780                         kfree_s((void *)sk, sizeof(*sk));
781                         return(-EPROTONOSUPPORT);
782                 }
783                 protocol = IPPROTO_UDP;
784                 sk->no_check = UDP_NO_CHECK;
785                 prot=&udp_prot;
786                 break;
787       
788         case SOCK_RAW:
789                 if (!suser()) {
790                         kfree_s((void *)sk, sizeof(*sk));
791                         return(-EPERM);
792                 }
793                 if (!protocol) {
794                         kfree_s((void *)sk, sizeof(*sk));
795                         return(-EPROTONOSUPPORT);
796                 }
797                 prot = &raw_prot;
798                 sk->reuse = 1;
799                 sk->no_check = 0;       /*
800                                          * Doesn't matter no checksum is
801                                          * preformed anyway.
802                                          */
803                 sk->num = protocol;
804                 break;
805 
806         case SOCK_PACKET:
807                 if (!suser()) {
808                         kfree_s((void *)sk, sizeof(*sk));
809                         return(-EPERM);
810                 }
811                 if (!protocol) {
812                         kfree_s((void *)sk, sizeof(*sk));
813                         return(-EPROTONOSUPPORT);
814                 }
815                 prot = &packet_prot;
816                 sk->reuse = 1;
817                 sk->no_check = 0;       /* Doesn't matter no checksum is
818                                          * preformed anyway.
819                                          */
820                 sk->num = protocol;
821                 break;
822 
823         default:
824                 kfree_s((void *)sk, sizeof(*sk));
825                 return(-ESOCKTNOSUPPORT);
826   }
827   sk->socket = sock;
828 #ifdef CONFIG_TCP_NAGLE_OFF
829   sk->nonagle = 1;
830 #else    
831   sk->nonagle = 0;
832 #endif  
833   sk->type = sock->type;
834   sk->protocol = protocol;
835   sk->wmem_alloc = 0;
836   sk->rmem_alloc = 0;
837   sk->sndbuf = SK_WMEM_MAX;
838   sk->rcvbuf = SK_RMEM_MAX;
839   sk->pair = NULL;
840   sk->opt = NULL;
841   sk->write_seq = 0;
842   sk->acked_seq = 0;
843   sk->copied_seq = 0;
844   sk->fin_seq = 0;
845   sk->urg_seq = 0;
846   sk->urg_data = 0;
847   sk->proc = 0;
848   sk->rtt = TCP_WRITE_TIME << 3;
849   sk->rto = TCP_WRITE_TIME;
850   sk->mdev = 0;
851   sk->backoff = 0;
852   sk->packets_out = 0;
853   sk->cong_window = 1; /* start with only sending one packet at a time. */
854   sk->cong_count = 0;
855   sk->ssthresh = 0;
856   sk->max_window = 0;
857   sk->urginline = 0;
858   sk->intr = 0;
859   sk->linger = 0;
860   sk->destroy = 0;
861 
862   sk->priority = 1;
863   sk->shutdown = 0;
864   sk->keepopen = 0;
865   sk->zapped = 0;
866   sk->done = 0;
867   sk->ack_backlog = 0;
868   sk->window = 0;
869   sk->bytes_rcv = 0;
870   sk->state = TCP_CLOSE;
871   sk->dead = 0;
872   sk->ack_timed = 0;
873   sk->partial = NULL;
874   sk->user_mss = 0;
875   sk->debug = 0;
876 
877   /* this is how many unacked bytes we will accept for this socket.  */
878   sk->max_unacked = 2048; /* needs to be at most 2 full packets. */
879 
880   /* how many packets we should send before forcing an ack. 
881      if this is set to zero it is the same as sk->delay_acks = 0 */
882   sk->max_ack_backlog = 0;
883   sk->inuse = 0;
884   sk->delay_acks = 0;
885   sk->wback = NULL;
886   sk->wfront = NULL;
887   sk->rqueue = NULL;
888   sk->mtu = 576;
889   sk->prot = prot;
890   sk->sleep = sock->wait;
891   sk->daddr = 0;
892   sk->saddr = my_addr();
893   sk->err = 0;
894   sk->next = NULL;
895   sk->pair = NULL;
896   sk->send_tail = NULL;
897   sk->send_head = NULL;
898   sk->timeout = 0;
899   sk->broadcast = 0;
900   sk->timer.data = (unsigned long)sk;
901   sk->timer.function = &net_timer;
902   sk->back_log = NULL;
903   sk->blog = 0;
904   sock->data =(void *) sk;
905   sk->dummy_th.doff = sizeof(sk->dummy_th)/4;
906   sk->dummy_th.res1=0;
907   sk->dummy_th.res2=0;
908   sk->dummy_th.urg_ptr = 0;
909   sk->dummy_th.fin = 0;
910   sk->dummy_th.syn = 0;
911   sk->dummy_th.rst = 0;
912   sk->dummy_th.psh = 0;
913   sk->dummy_th.ack = 0;
914   sk->dummy_th.urg = 0;
915   sk->dummy_th.dest = 0;
916 
917   sk->ip_tos=0;
918   sk->ip_ttl=64;
919         
920   sk->state_change = def_callback1;
921   sk->data_ready = def_callback2;
922   sk->write_space = def_callback1;
923   sk->error_report = def_callback1;
924 
925   if (sk->num) {
926         /*
927          * It assumes that any protocol which allows
928          * the user to assign a number at socket
929          * creation time automatically
930          * shares.
931          */
932         put_sock(sk->num, sk);
933         sk->dummy_th.source = ntohs(sk->num);
934   }
935 
936   if (sk->prot->init) {
937         err = sk->prot->init(sk);
938         if (err != 0) {
939                 destroy_sock(sk);
940                 return(err);
941         }
942   }
943   return(0);
944 }
945 
946 
947 static int
948 inet_dup(struct socket *newsock, struct socket *oldsock)
949 {
950   return(inet_create(newsock,
951                    ((struct sock *)(oldsock->data))->protocol));
952 }
953 
954 
955 /* The peer socket should always be NULL. */
956 static int
957 inet_release(struct socket *sock, struct socket *peer)
958 {
959   struct sock *sk;
960 
961   sk = (struct sock *) sock->data;
962   if (sk == NULL) return(0);
963 
964   DPRINTF((DBG_INET, "inet_release(sock = %X, peer = %X)\n", sock, peer));
965   sk->state_change(sk);
966 
967   /* Start closing the connection.  This may take a while. */
968   /*
969    * If linger is set, we don't return until the close
970    * is complete.  Other wise we return immediately. The
971    * actually closing is done the same either way.
972    */
973   if (sk->linger == 0) {
974         sk->prot->close(sk,0);
975         sk->dead = 1;
976   } else {
977         DPRINTF((DBG_INET, "sk->linger set.\n"));
978         sk->prot->close(sk, 0);
979         cli();
980         if (sk->lingertime)
981                 current->timeout = jiffies + HZ*sk->lingertime;
982         while(sk->state != TCP_CLOSE && current->timeout>0) {
983                 interruptible_sleep_on(sk->sleep);
984                 if (current->signal & ~current->blocked) {
985                         break;
986 #if 0
987                         /* not working now - closes can't be restarted */
988                         sti();
989                         current->timeout=0;
990                         return(-ERESTARTSYS);
991 #endif
992                 }
993         }
994         current->timeout=0;
995         sti();
996         sk->dead = 1;
997   }
998   sk->inuse = 1;
999 
1000   /* This will destroy it. */
1001   release_sock(sk);
1002   sock->data = NULL;
1003   DPRINTF((DBG_INET, "inet_release returning\n"));
1004   return(0);
1005 }
1006 
1007 
1008 /* this needs to be changed to dissallow
1009    the rebinding of sockets.   What error
1010    should it return? */
1011 
1012 static int
1013 inet_bind(struct socket *sock, struct sockaddr *uaddr,
1014                int addr_len)
1015 {
1016   struct sockaddr_in addr;
1017   struct sock *sk, *sk2;
1018   unsigned short snum;
1019   int err;
1020 
1021   sk = (struct sock *) sock->data;
1022   if (sk == NULL) {
1023         printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1024         return(0);
1025   }
1026 
1027   /* check this error. */
1028   if (sk->state != TCP_CLOSE) return(-EIO);
1029   if (sk->num != 0) return(-EINVAL);
1030 
1031   err=verify_area(VERIFY_READ, uaddr, addr_len);
1032   if(err)
1033         return err;
1034   memcpy_fromfs(&addr, uaddr, min(sizeof(addr), addr_len));
1035 
1036   snum = ntohs(addr.sin_port);
1037   DPRINTF((DBG_INET, "bind sk =%X to port = %d\n", sk, snum));
1038   sk = (struct sock *) sock->data;
1039 
1040   /*
1041    * We can't just leave the socket bound wherever it is, it might
1042    * be bound to a privileged port. However, since there seems to
1043    * be a bug here, we will leave it if the port is not privileged.
1044    */
1045   if (snum == 0) {
1046         snum = get_new_socknum(sk->prot, 0);
1047   }
1048   if (snum < PROT_SOCK && !suser()) return(-EACCES);
1049 
1050   if (addr.sin_addr.s_addr!=0 && chk_addr(addr.sin_addr.s_addr)!=IS_MYADDR)
1051         return(-EADDRNOTAVAIL); /* Source address MUST be ours! */
1052         
1053   if (chk_addr(addr.sin_addr.s_addr) || addr.sin_addr.s_addr == 0)
1054                                         sk->saddr = addr.sin_addr.s_addr;
1055 
1056   DPRINTF((DBG_INET, "sock_array[%d] = %X:\n", snum &(SOCK_ARRAY_SIZE -1),
1057                         sk->prot->sock_array[snum &(SOCK_ARRAY_SIZE -1)]));
1058 
1059   /* Make sure we are allowed to bind here. */
1060   cli();
1061 outside_loop:
1062   for(sk2 = sk->prot->sock_array[snum & (SOCK_ARRAY_SIZE -1)];
1063                                         sk2 != NULL; sk2 = sk2->next) {
1064 #if     1       /* should be below! */
1065         if (sk2->num != snum) continue;
1066 /*      if (sk2->saddr != sk->saddr) continue; */
1067 #endif
1068         if (sk2->dead) {
1069                 destroy_sock(sk2);
1070                 goto outside_loop;
1071         }
1072         if (!sk->reuse) {
1073                 sti();
1074                 return(-EADDRINUSE);
1075         }
1076         if (sk2->num != snum) continue;         /* more than one */
1077         if (sk2->saddr != sk->saddr) continue;  /* socket per slot ! -FB */
1078         if (!sk2->reuse) {
1079                 sti();
1080                 return(-EADDRINUSE);
1081         }
1082   }
1083   sti();
1084 
1085   remove_sock(sk);
1086   put_sock(snum, sk);
1087   sk->dummy_th.source = ntohs(sk->num);
1088   sk->daddr = 0;
1089   sk->dummy_th.dest = 0;
1090   return(0);
1091 }
1092 
1093 
1094 static int
1095 inet_connect(struct socket *sock, struct sockaddr * uaddr,
1096                   int addr_len, int flags)
1097 {
1098   struct sock *sk;
1099   int err;
1100 
1101   sock->conn = NULL;
1102   sk = (struct sock *) sock->data;
1103   if (sk == NULL) {
1104         printk("Warning: sock->data = NULL: %d\n" ,__LINE__);
1105         return(0);
1106   }
1107 
1108   if (sock->state == SS_CONNECTING && sk->state == TCP_ESTABLISHED)
1109   {
1110         sock->state = SS_CONNECTED;
1111   /* Connection completing after a connect/EINPROGRESS/select/connect */
1112         return 0;       /* Rock and roll */
1113   }
1114 
1115   if (sock->state == SS_CONNECTING && sk->protocol == IPPROTO_TCP &&
1116         (flags & O_NONBLOCK))
1117         return -EALREADY;       /* Connecting is currently in progress */
1118         
1119   if (sock->state != SS_CONNECTING) {
1120         /* We may need to bind the socket. */
1121         if (sk->num == 0) {
1122                 sk->num = get_new_socknum(sk->prot, 0);
1123                 if (sk->num == 0) 
1124                         return(-EAGAIN);
1125                 put_sock(sk->num, sk);
1126                 sk->dummy_th.source = htons(sk->num);
1127         }
1128 
1129         if (sk->prot->connect == NULL) 
1130                 return(-EOPNOTSUPP);
1131   
1132         err = sk->prot->connect(sk, (struct sockaddr_in *)uaddr, addr_len);
1133         if (err < 0) return(err);
1134   
1135         sock->state = SS_CONNECTING;
1136   }
1137 
1138   if (sk->state != TCP_ESTABLISHED &&(flags & O_NONBLOCK)) 
1139         return(-EINPROGRESS);
1140