1 /* tcp_usrreq.c 1.70 82/11/03 */ 2 3 #include "../h/param.h" 4 #include "../h/systm.h" 5 #include "../h/mbuf.h" 6 #include "../h/socket.h" 7 #include "../h/socketvar.h" 8 #include "../h/protosw.h" 9 10 #include "../net/if.h" 11 #include "../net/route.h" 12 #include "../netinet/in.h" 13 #include "../netinet/in_pcb.h" 14 #include "../netinet/in_systm.h" 15 #include "../netinet/ip.h" 16 #include "../netinet/ip_var.h" 17 #include "../netinet/tcp.h" 18 #include "../netinet/tcp_fsm.h" 19 #include "../netinet/tcp_seq.h" 20 #include "../netinet/tcp_timer.h" 21 #include "../netinet/tcp_var.h" 22 #include "../netinet/tcpip.h" 23 #include "../netinet/tcp_debug.h" 24 #include <errno.h> 25 26 /* 27 * TCP protocol interface to socket abstraction. 28 */ 29 extern char *tcpstates[]; 30 struct tcpcb *tcp_newtcpcb(); 31 32 /* 33 * Process a TCP user request for TCP tb. If this is a send request 34 * then m is the mbuf chain of send data. If this is a timer expiration 35 * (called from the software clock routine), then timertype tells which timer. 36 */ 37 /*ARGSUSED*/ 38 tcp_usrreq(so, req, m, nam, opt) 39 struct socket *so; 40 int req; 41 struct mbuf *m, *nam; 42 struct socketopt *opt; 43 { 44 register struct inpcb *inp = sotoinpcb(so); 45 register struct tcpcb *tp; 46 int s = splnet(); 47 int error = 0; 48 int ostate; 49 50 /* 51 * When a TCP is attached to a socket, then there will be 52 * a (struct inpcb) pointed at by the socket, and this 53 * structure will point at a subsidary (struct tcpcb). 54 */ 55 if (inp == 0 && req != PRU_ATTACH) { 56 splx(s); 57 return (EINVAL); /* XXX */ 58 } 59 if (inp) { 60 tp = intotcpcb(inp); 61 /* WHAT IF TP IS 0? */ 62 #ifdef KPROF 63 tcp_acounts[tp->t_state][req]++; 64 #endif 65 ostate = tp->t_state; 66 } else 67 ostate = 0; 68 switch (req) { 69 70 /* 71 * TCP attaches to socket via PRU_ATTACH, reserving space, 72 * and an internet control block. 73 */ 74 case PRU_ATTACH: 75 if (inp) { 76 error = EISCONN; 77 break; 78 } 79 error = tcp_attach(so); 80 if (error) 81 break; 82 if ((so->so_options & SO_DONTLINGER) == 0) 83 so->so_linger = TCP_LINGERTIME; 84 tp = sototcpcb(so); 85 break; 86 87 /* 88 * PRU_DETACH detaches the TCP protocol from the socket. 89 * If the protocol state is non-embryonic, then can't 90 * do this directly: have to initiate a PRU_DISCONNECT, 91 * which may finish later; embryonic TCB's can just 92 * be discarded here. 93 */ 94 case PRU_DETACH: 95 if (tp->t_state > TCPS_LISTEN) 96 tcp_disconnect(tp); 97 else { 98 tcp_close(tp); 99 tp = 0; 100 } 101 break; 102 103 /* 104 * Give the socket an address. 105 */ 106 case PRU_BIND: 107 error = in_pcbbind(inp, nam); 108 if (error) 109 break; 110 break; 111 112 /* 113 * Prepare to accept connections. 114 */ 115 case PRU_LISTEN: 116 if (inp->inp_lport == 0) 117 error = in_pcbbind(inp, (struct mbuf *)0); 118 if (error == 0) 119 tp->t_state = TCPS_LISTEN; 120 break; 121 122 /* 123 * Initiate connection to peer. 124 * Create a template for use in transmissions on this connection. 125 * Enter SYN_SENT state, and mark socket as connecting. 126 * Start keep-alive timer, and seed output sequence space. 127 * Send initial segment on connection. 128 */ 129 case PRU_CONNECT: 130 if (inp->inp_lport == 0) { 131 error = in_pcbbind(inp, (struct mbuf *)0); 132 if (error) 133 break; 134 } 135 error = in_pcbconnect(inp, nam); 136 if (error) 137 break; 138 tp->t_template = tcp_template(tp); 139 if (tp->t_template == 0) { 140 in_pcbdisconnect(inp); 141 error = ENOBUFS; 142 break; 143 } 144 soisconnecting(so); 145 tp->t_state = TCPS_SYN_SENT; 146 tp->t_timer[TCPT_KEEP] = TCPTV_KEEP; 147 tp->iss = tcp_iss; tcp_iss += TCP_ISSINCR/2; 148 tcp_sendseqinit(tp); 149 error = tcp_output(tp); 150 break; 151 152 /* 153 * Initiate disconnect from peer. 154 * If connection never passed embryonic stage, just drop; 155 * else if don't need to let data drain, then can just drop anyways, 156 * else have to begin TCP shutdown process: mark socket disconnecting, 157 * drain unread data, state switch to reflect user close, and 158 * send segment (e.g. FIN) to peer. Socket will be really disconnected 159 * when peer sends FIN and acks ours. 160 * 161 * SHOULD IMPLEMENT LATER PRU_CONNECT VIA REALLOC TCPCB. 162 */ 163 case PRU_DISCONNECT: 164 tcp_disconnect(tp); 165 break; 166 167 /* 168 * Accept a connection. Essentially all the work is 169 * done at higher levels; just return the address 170 * of the peer, storing through addr. 171 */ 172 case PRU_ACCEPT: { 173 struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *); 174 175 nam->m_len = sizeof (struct sockaddr_in); 176 sin->sin_family = AF_INET; 177 sin->sin_port = inp->inp_fport; 178 sin->sin_addr = inp->inp_faddr; 179 break; 180 } 181 182 /* 183 * Mark the connection as being incapable of further output. 184 */ 185 case PRU_SHUTDOWN: 186 socantsendmore(so); 187 tcp_usrclosed(tp); 188 error = tcp_output(tp); 189 break; 190 191 /* 192 * After a receive, possibly send window update to peer. 193 */ 194 case PRU_RCVD: 195 (void) tcp_output(tp); 196 break; 197 198 /* 199 * Do a send by putting data in output queue and updating urgent 200 * marker if URG set. Possibly send more data. 201 */ 202 case PRU_SEND: 203 sbappend(&so->so_snd, m); 204 #ifdef notdef 205 if (tp->t_flags & TF_PUSH) 206 tp->snd_end = tp->snd_una + so->so_snd.sb_cc; 207 #endif 208 error = tcp_output(tp); 209 break; 210 211 /* 212 * Abort the TCP. 213 */ 214 case PRU_ABORT: 215 tcp_drop(tp, ECONNABORTED); 216 break; 217 218 /* SOME AS YET UNIMPLEMENTED HOOKS */ 219 case PRU_CONTROL: 220 error = EOPNOTSUPP; 221 break; 222 223 case PRU_SENSE: 224 error = EOPNOTSUPP; 225 break; 226 /* END UNIMPLEMENTED HOOKS */ 227 228 case PRU_RCVOOB: 229 if (so->so_oobmark == 0 && 230 (so->so_state & SS_RCVATMARK) == 0) { 231 error = EINVAL; 232 break; 233 } 234 if ((tp->t_oobflags & TCPOOB_HAVEDATA) == 0) { 235 error = EWOULDBLOCK; 236 break; 237 } 238 m->m_len = 1; 239 *mtod(m, caddr_t) = tp->t_iobc; 240 break; 241 242 case PRU_SENDOOB: 243 if (sbspace(&so->so_snd) < -512) { 244 error = ENOBUFS; 245 break; 246 } 247 tp->snd_up = tp->snd_una + so->so_snd.sb_cc + 1; 248 sbappend(&so->so_snd, m); 249 tp->t_force = 1; 250 error = tcp_output(tp); 251 tp->t_force = 0; 252 break; 253 254 case PRU_SOCKADDR: 255 in_setsockaddr(inp, nam); 256 break; 257 258 /* 259 * TCP slow timer went off; going through this 260 * routine for tracing's sake. 261 */ 262 case PRU_SLOWTIMO: 263 tcp_timers(tp, (int)nam); 264 req |= (int)nam << 8; /* for debug's sake */ 265 break; 266 267 default: 268 panic("tcp_usrreq"); 269 } 270 if (tp && (so->so_options & SO_DEBUG)) 271 tcp_trace(TA_USER, ostate, tp, (struct tcpiphdr *)0, req); 272 splx(s); 273 return (error); 274 } 275 276 int tcp_sendspace = 1024*2; 277 int tcp_recvspace = 1024*2; 278 /* 279 * Attach TCP protocol to socket, allocating 280 * internet protocol control block, tcp control block, 281 * bufer space, and entering LISTEN state if to accept connections. 282 */ 283 tcp_attach(so) 284 struct socket *so; 285 { 286 register struct tcpcb *tp; 287 struct inpcb *inp; 288 int error; 289 290 error = soreserve(so, tcp_sendspace, tcp_recvspace); 291 if (error) 292 goto bad; 293 error = in_pcballoc(so, &tcb); 294 if (error) 295 goto bad; 296 inp = sotoinpcb(so); 297 tp = tcp_newtcpcb(inp); 298 if (tp == 0) { 299 error = ENOBUFS; 300 goto bad2; 301 } 302 tp->t_state = TCPS_CLOSED; 303 return (0); 304 bad2: 305 in_pcbdetach(inp); 306 bad: 307 return (error); 308 } 309 310 /* 311 * Initiate (or continue) disconnect. 312 * If embryonic state, just send reset (once). 313 * If not in ``let data drain'' option, just drop. 314 * Otherwise (hard), mark socket disconnecting and drop 315 * current input data; switch states based on user close, and 316 * send segment to peer (with FIN). 317 */ 318 tcp_disconnect(tp) 319 struct tcpcb *tp; 320 { 321 struct socket *so = tp->t_inpcb->inp_socket; 322 323 if (tp->t_state < TCPS_ESTABLISHED) 324 tcp_close(tp); 325 else if (so->so_linger == 0) 326 tcp_drop(tp, 0); 327 else { 328 soisdisconnecting(so); 329 sbflush(&so->so_rcv); 330 tcp_usrclosed(tp); 331 (void) tcp_output(tp); 332 } 333 } 334 335 /* 336 * User issued close, and wish to trail through shutdown states: 337 * if never received SYN, just forget it. If got a SYN from peer, 338 * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN. 339 * If already got a FIN from peer, then almost done; go to LAST_ACK 340 * state. In all other cases, have already sent FIN to peer (e.g. 341 * after PRU_SHUTDOWN), and just have to play tedious game waiting 342 * for peer to send FIN or not respond to keep-alives, etc. 343 * We can let the user exit from the close as soon as the FIN is acked. 344 */ 345 tcp_usrclosed(tp) 346 struct tcpcb *tp; 347 { 348 349 switch (tp->t_state) { 350 351 case TCPS_LISTEN: 352 case TCPS_SYN_SENT: 353 tp->t_state = TCPS_CLOSED; 354 tcp_close(tp); 355 break; 356 357 case TCPS_SYN_RECEIVED: 358 case TCPS_ESTABLISHED: 359 tp->t_state = TCPS_FIN_WAIT_1; 360 break; 361 362 case TCPS_CLOSE_WAIT: 363 tp->t_state = TCPS_LAST_ACK; 364 break; 365 } 366 if (tp->t_state >= TCPS_FIN_WAIT_2) 367 soisdisconnected(tp->t_inpcb->inp_socket); 368 } 369