/* tcp_usrreq.c 1.28 81/11/15 */ #include "../h/param.h" #include "../h/systm.h" #include "../h/mbuf.h" #include "../h/socket.h" #include "../h/socketvar.h" #include "../h/protosw.h" #include "../net/inet.h" #include "../net/inet_host.h" #include "../net/inet_pcb.h" #include "../net/inet_systm.h" #include "../net/imp.h" #include "../net/ip.h" #include "../net/ip_var.h" #include "../net/tcp.h" #define TCPFSTAB #ifdef TCPDEBUG #define TCPSTATES #endif #include "../net/tcp_fsm.h" #include "../net/tcp_var.h" #include "/usr/include/errno.h" /* * Tcp initialization */ tcp_init() { tcp_iss = 1; /* wrong */ tcb.inp_next = tcb.inp_prev = &tcb; } /* * Tcp finite state machine entries for timer and user generated * requests. These routines raise the ipl to that of the network * to prevent reentry. In particluar, this requires that the software * clock interrupt have lower priority than the network so that * we can enter the network from timeout routines without improperly * nesting the interrupt stack. */ /* * Tcp protocol timeout routine called every 500 ms. * Updates the timers in all active tcb's and * causes finite state machine actions if timers expire. */ tcp_slowtimo() { register struct inpcb *ip; register struct tcpcb *tp; int s = splnet(); register short *tmp; register int i; COUNT(TCP_TIMEO); /* * Search through tcb's and update active timers. */ for (ip = tcb.inp_next; ip != &tcb; ip = ip->inp_next) { tp = intotcpcb(ip); tmp = &tp->t_init; for (i = 0; i < TNTIMERS; i++) { if (*tmp && --*tmp == 0) tcp_usrreq(tp->t_inpcb->inp_socket, PRU_SLOWTIMO, 0, i); tmp++; } tp->t_xmt++; } tcp_iss += ISSINCR/2; /* increment iss */ splx(s); } /* * Cancel all timers for tcp tp. */ tcp_tcancel(tp) struct tcpcb *tp; { register short *tmp = &tp->t_init; register int i; for (i = 0; i < TNTIMERS; i++) *tmp++ = 0; } /* * Process a TCP user request for tcp tb. If this is a send request * then m is the mbuf chain of send data. If this is a timer expiration * (called from the software clock routine), then timertype tells which timer. */ tcp_usrreq(so, req, m, addr) struct socket *so; int req; struct mbuf *m; caddr_t addr; { register struct inpcb *inp = sotoinpcb(so); register struct tcpcb *tp = intotcpcb(inp); int s = splnet(); register int nstate; #ifdef TCPDEBUG struct tcp_debug tdb; #endif int error = 0; COUNT(TCP_USRREQ); /* * Make sure attached. If not, * only PRU_ATTACH is valid. */ if (tp) { nstate = tp->t_state; tp->tc_flags &= ~TC_NET_KEEP; } else if (req != PRU_ATTACH) { splx(s); return (EINVAL); } /* * Do tracing and accounting. */ #ifdef KPROF acounts[nstate][req]++; #endif #ifdef TCPDEBUG if (tp && ((tp->t_socket->so_options & SO_DEBUG) || tcpconsdebug)) { tdb_setup(tp, (struct tcpiphdr *)0, req, &tdb); tdb.td_tim = timertype; } else tdb.td_tod = 0; #endif switch (req) { case PRU_ATTACH: if (tp) error = EISCONN; else { tcp_attach(so); tp = sototcpcb(so); } if (so->so_options & SO_ACCEPTCONN) { inp->inp_lhost = in_hmake(&n_lhost); in_pcbgenport(&tcb, inp); nstate = LISTEN; } else nstate = CLOSED; break; case PRU_DETACH: tcp_detach(so); break; case PRU_CONNECT: if (tp->t_state != 0 && tp->t_state != CLOSED) goto bad; inp->inp_fhost = in_hmake((struct in_addr *)addr, &error); if (inp->inp_fhost == 0) break; tcp_sndctl(tp); nstate = SYN_SENT; soisconnecting(so); break; case PRU_DISCONNECT: if ((tp->tc_flags & TC_FIN_RCVD) == 0) goto abort; if (nstate < ESTAB) tcp_disconnect(so); else { tp->tc_flags |= TC_SND_FIN; tcp_sendctl(tp); tp->tc_flags |= TC_USR_CLOSED; soisdisconnecting(so); } break; case PRU_SHUTDOWN: switch (nstate) { case LISTEN: case SYN_SENT: nstate = CLOSED; break; case SYN_RCVD: case L_SYN_RCVD: case ESTAB: case CLOSE_WAIT: tp->tc_flags |= TC_SND_FIN; tcp_sndctl(tp); tp->tc_flags |= TC_USR_CLOSED; nstate = nstate != CLOSE_WAIT ? FIN_W1 : LAST_ACK; break; case FIN_W1: case FIN_W2: case TIME_WAIT: case CLOSING: case LAST_ACK: case RCV_WAIT: break; default: goto bad; } break; case PRU_RCVD: if (nstate < ESTAB || nstate == CLOSED) goto bad; tcp_sndwin(tp); if ((tp->tc_flags&TC_FIN_RCVD) && (tp->tc_flags&TC_USR_CLOSED) == 0 && rcv_empty(tp)) error = ESHUTDOWN; if (nstate == RCV_WAIT && rcv_empty(tp)) nstate = CLOSED; break; case PRU_SEND: switch (nstate) { case ESTAB: case CLOSE_WAIT: tcp_usrsend(tp, m); break; default: if (nstate < ESTAB) goto bad; m_freem(m); error = ENOTCONN; break; } break; abort: case PRU_ABORT: tcp_abort(tp); nstate = CLOSED; break; case PRU_CONTROL: error = EOPNOTSUPP; break; case PRU_SLOWTIMO: switch (nstate) { case 0: case CLOSED: case LISTEN: goto bad; default: nstate = tcp_timers(tp, (int)addr); } break; default: panic("tcp_usrreq"); bad: printf("tcp: bad state: tcb=%x state=%d input=%d\n", tp, tp->t_state, req); nstate = EFAILEC; break; } #ifdef TCPDEBUG if (tdb.td_tod) tdb_stuff(&tdb, nstate); #endif switch (nstate) { case CLOSED: case SAME: break; case EFAILEC: if (m) m_freem(dtom(m)); break; default: tp->t_state = nstate; break; } splx(s); return (error); } tcp_attach(so) register struct socket *so; { register struct tcpcb *tp; COUNT(TCP_ATTACH); /* * Make empty reassembly queue. */ tp->seg_next = tp->seg_prev = (struct tcpiphdr *)tp; /* * Initialize sequence numbers and round trip retransmit timer. */ tp->t_xmtime = T_REXMT; tp->snd_end = tp->seq_fin = tp->snd_nxt = tp->snd_hi = tp->snd_una = tp->iss = tcp_iss; tp->snd_off = tp->iss + 1; tcp_iss += (ISSINCR >> 1) + 1; } tcp_detach(so) register struct socket *so; { register struct tcpcb *tp = (struct tcpcb *)so->so_pcb; register struct tcpiphdr *t; register struct mbuf *m; COUNT(TCP_DETACH); wmemfree((caddr_t)tp, 1024); m_release(so->so_rcv.sb_hiwat + so->so_snd.sb_hiwat + 2 * MSIZE); } tcp_disconnect(tp) register struct tcpcb *tp; { register struct tcpiphdr *t; register struct mbuf *m; register struct socket *so; tcp_tcancel(tp); t = tp->seg_next; for (; t != (struct tcpiphdr *)tp; t = (struct tcpiphdr *)t->ti_next) m_freem(dtom(t)); tcp_drainunack(tp); if (tp->t_template) { m_free(dtom(tp->t_template)); tp->t_template = 0; } in_pcbfree(tp->t_inpcb); } tcp_abort(so) register struct socket *so; { register struct tcpcb *tp = sototcpcb(so); switch (tp->t_state) { case SYN_RCVD: case ESTAB: case FIN_W1: case FIN_W2: case CLOSE_WAIT: tp->tc_flags |= TC_SND_RST; tcp_sndnull(tp); } if (so) soisdisconnected(so); } /* * Send data queue headed by m0 into the protocol. */ tcp_usrsend(tp, m0) register struct tcpcb *tp; struct mbuf *m0; { register struct mbuf *m, *n; register struct socket *so = tp->t_inpcb->inp_socket; register off; seq_t last; COUNT(TCP_USRSEND); sbappend(&so->so_snd, m0); if (tp->t_options & TO_EOL) tp->snd_end = tp->snd_off + so->so_snd.sb_cc; if (tp->t_options & TO_URG) { tp->snd_urp = tp->snd_off + so->so_snd.sb_cc + 1; tp->tc_flags |= TC_SND_URG; } tcp_send(tp); } /* * TCP timer went off processing. */ tcp_timers(tp, timertype) register struct tcpcb *tp; int timertype; { COUNT(TCP_TIMERS); switch (timertype) { case TFINACK: /* fin-ack timer */ switch (tp->t_state) { case TIME_WAIT: /* * We can be sure our ACK of foreign FIN was rcvd, * and can close if no data left for user. */ if (rcv_empty(tp)) { tcp_disconnect(tp); return (CLOSED); } return (RCV_WAIT); /* 17 */ case CLOSING: tp->tc_flags |= TC_WAITED_2_ML; return (SAME); default: return (SAME); } case TREXMT: /* retransmission timer */ if (tp->t_rexmt_val > tp->snd_una) { /* 34 */ /* * Set so for a retransmission, increase rexmt time * in case of multiple retransmissions. */ tp->snd_nxt = tp->snd_una; tp->tc_flags |= TC_REXMT; tp->t_xmtime = tp->t_xmtime << 1; if (tp->t_xmtime > T_REMAX) tp->t_xmtime = T_REMAX; tcp_send(tp); } return (SAME); case TREXMTTL: /* retransmit too long */ if (tp->t_rtl_val > tp->snd_una) /* 36 */ tcp_error(EIO); /* URXTIMO !?! */ /* * If user has already closed, abort the connection. */ if (tp->tc_flags & TC_USR_CLOSED) { tcp_abort(tp); return (CLOSED); } return (SAME); case TPERSIST: /* persist timer */ /* * Force a byte send through closed window. */ tp->tc_flags |= TC_FORCE_ONE; tcp_send(tp); return (SAME); } panic("tcp_timers"); } tcp_sense(m) struct mbuf *m; { return (EOPNOTSUPP); } tcp_error(so, errno) struct socket *so; int errno; { COUNT(TO_USER); so->so_error = errno; sorwakeup(so); sowwakeup(so); } #ifdef TCPDEBUG /* * TCP debugging utility subroutines. * THE NAMES OF THE FIELDS USED BY THESE ROUTINES ARE STUPID. */ tdb_setup(tp, n, input, tdp) struct tcpcb *tp; register struct tcpiphdr *n; int input; register struct tcp_debug *tdp; { COUNT(TDB_SETUP); tdp->td_tod = time; tdp->td_tcb = tp; tdp->td_old = tp->t_state; tdp->td_inp = input; tdp->td_tim = 0; tdp->td_new = -1; if (n) { tdp->td_sno = n->ti_seq; tdp->td_ano = n->ti_ackno; tdp->td_wno = n->t_win; tdp->td_lno = n->ti_len; tdp->td_flg = n->ti_flags; } else tdp->td_sno = tdp->td_ano = tdp->td_wno = tdp->td_lno = tdp->td_flg = 0; } tdb_stuff(tdp, nstate) struct tcp_debug *tdp; int nstate; { COUNT(TDB_STUFF); tdp->td_new = nstate; tcp_debug[tdbx++ % TDBSIZE] = *tdp; if (tcpconsdebug & 2) tcp_prt(tdp); } tcp_prt(tdp) register struct tcp_debug *tdp; { COUNT(TCP_PRT); printf("%x ", ((int)tdp->td_tcb)&0xffffff); if (tdp->td_inp == INSEND) { printf("SEND #%x", tdp->td_sno); tdp->td_lno = ntohs(tdp->td_lno); tdp->td_wno = ntohs(tdp->td_wno); } else { if (tdp->td_inp == INRECV) printf("RCV #%x ", tdp->td_sno); printf("%s.%s", tcpstates[tdp->td_old], tcpinputs[tdp->td_inp]); if (tdp->td_inp == ISTIMER) printf("(%s)", tcptimers[tdp->td_tim]); printf(" -> %s", tcpstates[(tdp->td_new > 0) ? tdp->td_new : tdp->td_old]); if (tdp->td_new == -1) printf(" (FAILED)"); } /* GROSS... DEPENDS ON SIGN EXTENSION OF CHARACTERS */ if (tdp->td_lno) printf(" len=%d", tdp->td_lno); if (tdp->td_wno) printf(" win=%d", tdp->td_wno); if (tdp->td_flg & TH_FIN) printf(" FIN"); if (tdp->td_flg & TH_SYN) printf(" SYN"); if (tdp->td_flg & TH_RST) printf(" RST"); if (tdp->td_flg & TH_EOL) printf(" EOL"); if (tdp->td_flg & TH_ACK) printf(" ACK %x", tdp->td_ano); if (tdp->td_flg & TH_URG) printf(" URG"); printf("\n"); } #endif