| /*- | |
| * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995 | |
| * The Regents of the University of California. All rights reserved. | |
| * | |
| * Redistribution and use in source and binary forms, with or without | |
| * modification, are permitted provided that the following conditions | |
| * are met: | |
| * 1. Redistributions of source code must retain the above copyright | |
| * notice, this list of conditions and the following disclaimer. | |
| * 2. Redistributions in binary form must reproduce the above copyright | |
| * notice, this list of conditions and the following disclaimer in the | |
| * documentation and/or other materials provided with the distribution. | |
| * 4. Neither the name of the University nor the names of its contributors | |
| * may be used to endorse or promote products derived from this software | |
| * without specific prior written permission. | |
| * | |
| * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | |
| * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | |
| * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
| * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
| * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
| * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
| * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
| * SUCH DAMAGE. | |
| * | |
| * @(#)tcp_subr.c 8.2 (Berkeley) 5/24/95 | |
| */ | |
| #include <string.h> | |
| #include "tcp.h" | |
| #include "tcp_fsm.h" | |
| #include "tcp_seq.h" | |
| #include "tcp_timer.h" | |
| #include "tcp_var.h" | |
| #include "tcp_const.h" | |
| #include <openthread/ip6.h> | |
| #include <openthread/message.h> | |
| /* | |
| * samkumar: The V_nolocaltimewait variable corresponds to the | |
| * net.inet.tcp.nolocaltimewait option in FreeBSD. When set to 1, it skips the | |
| * TIME-WAIT state for TCP connections where both endpoints are local IP | |
| * addresses, to save resources on HTTP accelerators, database servers/clients, | |
| * etc. In TCPlp, I eliminated support for this feature, but I have kept the | |
| * code for it, commented out with "#if 0", in case we choose to bring it back | |
| * at a later time. | |
| * | |
| * See also the "#if 0" block in tcp_twstart. | |
| */ | |
| #if 0 | |
| enum tcp_timewait_consts { | |
| V_nolocaltimewait = 0 | |
| }; | |
| #endif | |
| /* | |
| * samkumar: The FreeBSD code used a separate, smaller structure, called | |
| * struct tcptw, to respresent connections in the TIME-WAIT state. In TCPlp, | |
| * we use the full struct tcpcb structure even in the TIME-WAIT state. This | |
| * consumes more memory, but switching to a different structure like | |
| * struct tcptw to save memory would be difficult because the host system or | |
| * application has allocated these structures; we can't simply "free" the | |
| * struct tcpcb. It would have to have been done via a callback or something, | |
| * and in the common case of statically allocated sockets, this would actually | |
| * result in more memory (since an application would need to allocate both the | |
| * struct tcpcb and the struct tcptw, if it uses a static allocation approach). | |
| * | |
| * Below, I've changed the function signatures to accept "struct tcpcb* tp" | |
| * instead of "struct tcptw *tw" and I have reimplemented the functions | |
| * to work using tp (of type struct tcpcb) instead of tw (of type | |
| * struct tcptw). | |
| * | |
| * Conceptually, the biggest change is in how timers are handled. The FreeBSD | |
| * code had a 2MSL timer, which was set for sockets that enter certain | |
| * "closing" states of the TCP state machine. But when the TIME-WAIT state was | |
| * entered, the state is transferred from struct tcpcb into struct tcptw. | |
| * The final timeout is handled as follows; the function tcp_tw_2msl_scan is | |
| * called periodically on the slow timer, and it iterates over a linked list | |
| * of all the struct tcptw and checks the tw->tw_time field to identify which | |
| * TIME-WAIT sockets have expired. | |
| * | |
| * In our switch to using struct tcpcb even in the TIME-WAIT state, we rely on | |
| * the timer system for struct tcpcb. I modified the 2msl callback in | |
| * tcp_timer.c to check for the TIME-WAIT case and handle it correctly. | |
| */ | |
| static void | |
| tcp_tw_2msl_reset(struct tcpcb* tp, int rearm) | |
| { | |
| /* | |
| * samkumar: This function used to set tw->tw_time to ticks + 2 * tcp_msl | |
| * and insert tw into the linked list V_twq_2msl. I've replaced this, along | |
| * with the associated locking logic, with the following call, which uses | |
| * the timer system in place for full TCBs. | |
| */ | |
| tcp_timer_activate(tp, TT_2MSL, 2 * tcp_msl); | |
| } | |
| /* | |
| * samkumar: I've rewritten this code since I need to send out packets via the | |
| * host system for TCPlp: allocating buffers from the host system, populate | |
| * them, and then pass them back to the host system. I simplified the code by | |
| * only using the logic that was fully necessary, eliminating the code for IPv4 | |
| * packets and keeping only the code for IPv6 packets. I also removed all of | |
| * the mbuf logic, instead using the logic for using the host system's | |
| * buffering. | |
| * | |
| * This rewritten code always returns 0. The original code would return | |
| * whatever is returned by ip_output or ip6_output (FreeBSD's functions for | |
| * sending out IP packets). I believe 0 indicates success, and a nonzero | |
| * value represents an error code. It seems that the return value of | |
| * tcp_twrespond is ignored by all instances of its use in TCPlp (maybe even | |
| * in all of FreeBSD), so this is a moot point. | |
| */ | |
| static int | |
| tcp_twrespond(struct tcpcb* tp, int flags) | |
| { | |
| struct tcphdr* nth; | |
| struct tcpopt to; | |
| uint32_t optlen = 0; | |
| uint8_t opt[TCP_MAXOLEN]; | |
| to.to_flags = 0; | |
| /* | |
| * Send a timestamp and echo-reply if both our side and our peer | |
| * have sent timestamps in our SYN's and this is not a RST. | |
| */ | |
| if ((tp->t_flags & TF_RCVD_TSTMP) && flags == TH_ACK) { | |
| to.to_flags |= TOF_TS; | |
| to.to_tsval = tcp_ts_getticks() + tp->ts_offset; | |
| to.to_tsecr = tp->ts_recent; | |
| } | |
| optlen = tcp_addoptions(&to, opt); | |
| otMessage* message = tcplp_sys_new_message(tp->instance); | |
| if (message == NULL) { | |
| return 0; // drop the message | |
| } | |
| if (otMessageSetLength(message, sizeof(struct tcphdr) + optlen) != OT_ERROR_NONE) { | |
| tcplp_sys_free_message(tp->instance, message); | |
| return 0; // drop the message | |
| } | |
| char outbuf[sizeof(struct tcphdr) + optlen]; | |
| nth = (struct tcphdr*) &outbuf[0]; | |
| otMessageInfo ip6info; | |
| memset(&ip6info, 0x00, sizeof(ip6info)); | |
| memcpy(&ip6info.mSockAddr, &tp->laddr, sizeof(ip6info.mSockAddr)); | |
| memcpy(&ip6info.mPeerAddr, &tp->faddr, sizeof(ip6info.mPeerAddr)); | |
| nth->th_sport = tp->lport; | |
| nth->th_dport = tp->fport; | |
| nth->th_seq = htonl(tp->snd_nxt); | |
| nth->th_ack = htonl(tp->rcv_nxt); | |
| nth->th_off_x2 = ((sizeof(struct tcphdr) + optlen) >> 2) << TH_OFF_SHIFT; | |
| nth->th_flags = flags; | |
| nth->th_win = htons(tp->tw_last_win); | |
| nth->th_urp = 0; | |
| nth->th_sum = 0; | |
| memcpy(nth + 1, opt, optlen); | |
| otMessageWrite(message, 0, outbuf, sizeof(struct tcphdr) + optlen); | |
| tcplp_sys_send_message(tp->instance, message, &ip6info); | |
| return 0; | |
| } | |
| /* | |
| * Move a TCP connection into TIME_WAIT state. | |
| * tcbinfo is locked. | |
| * inp is locked, and is unlocked before returning. | |
| */ | |
| /* | |
| * samkumar: Locking is removed (so above comments regarding locks are no | |
| * not relevant for TCPlp). Rather than allocating a struct tcptw and | |
| * discarding the struct tcpcb, this function just switches the tcpcb state | |
| * to correspond to TIME-WAIT (updating variables as appropriate). We also | |
| * eliminate the "V_nolocaltimewait" optimization. | |
| */ | |
| void | |
| tcp_twstart(struct tcpcb *tp) | |
| { | |
| int acknow; | |
| /* | |
| * samkumar: The following code, commented out using "#if 0", handles the | |
| * net.inet.tcp.nolocaltimewait option in FreeBSD. The option skips the | |
| * TIME-WAIT state for TCP connections where both endpoints are local. | |
| * I'm removing this optimization for TCPlp, but I've left the code | |
| * commented out as it's a potentially useful feature that we may choose | |
| * to restore later. | |
| * | |
| * See also the "#if 0" block near the top of this file. | |
| */ | |
| #if 0 | |
| if (V_nolocaltimewait) { | |
| int error = 0; | |
| #ifdef INET6 | |
| if (isipv6) | |
| error = in6_localaddr(&inp->in6p_faddr); | |
| #endif | |
| #if defined(INET6) && defined(INET) | |
| else | |
| #endif | |
| #ifdef INET | |
| error = in_localip(inp->inp_faddr); | |
| #endif | |
| if (error) { | |
| tp = tcp_close(tp); | |
| if (tp != NULL) | |
| INP_WUNLOCK(inp); | |
| return; | |
| } | |
| } | |
| #endif | |
| /* | |
| * For use only by DTrace. We do not reference the state | |
| * after this point so modifying it in place is not a problem. | |
| */ | |
| /* | |
| * samkumar: The above comment is not true anymore. I use this state, since | |
| * I don't associate every struct tcpcb with a struct inpcb. | |
| */ | |
| tcp_state_change(tp, TCPS_TIME_WAIT); | |
| /* | |
| * samkumar: There used to be code here to allocate a struct tcptw | |
| * using "tw = uma_zalloc(V_tcptw_zone, M_NOWAIT);" and if it fails, close | |
| * an existing TIME-WAIT connection, in LRU fashion, to allocate memory. | |
| */ | |
| /* | |
| * Recover last window size sent. | |
| */ | |
| if (SEQ_GT(tp->rcv_adv, tp->rcv_nxt)) | |
| tp->tw_last_win = (tp->rcv_adv - tp->rcv_nxt) >> tp->rcv_scale; | |
| else | |
| tp->tw_last_win = 0; | |
| /* | |
| * Set t_recent if timestamps are used on the connection. | |
| */ | |
| if ((tp->t_flags & (TF_REQ_TSTMP|TF_RCVD_TSTMP|TF_NOOPT)) == | |
| (TF_REQ_TSTMP|TF_RCVD_TSTMP)) { | |
| /* | |
| * samkumar: This used to do: | |
| * tw->t_recent = tp->ts_recent; | |
| * tw->ts_offset = tp->ts_offset; | |
| * But since we're keeping the state in tp, we don't need to do this | |
| * anymore. */ | |
| } else { | |
| tp->ts_recent = 0; | |
| tp->ts_offset = 0; | |
| } | |
| /* | |
| * samkumar: There used to be code here to populate various fields in | |
| * tw based on their values in tp, but there's no need for that now since | |
| * we can just read the values from tp. tw->tw_time was set to 0, but we | |
| * don't need to do that either since we're relying on the old timer system | |
| * anyway. | |
| */ | |
| /* XXX | |
| * If this code will | |
| * be used for fin-wait-2 state also, then we may need | |
| * a ts_recent from the last segment. | |
| */ | |
| acknow = tp->t_flags & TF_ACKNOW; | |
| /* | |
| * First, discard tcpcb state, which includes stopping its timers and | |
| * freeing it. tcp_discardcb() used to also release the inpcb, but | |
| * that work is now done in the caller. | |
| * | |
| * Note: soisdisconnected() call used to be made in tcp_discardcb(), | |
| * and might not be needed here any longer. | |
| */ | |
| /* | |
| * samkumar: Below, I removed the code to discard tp, update inpcb and | |
| * release a reference to socket, but kept the rest. I also added a call | |
| * to cancel any pending timers on the TCB (which discarding it, as the | |
| * original code did, would have done). | |
| */ | |
| tcp_cancel_timers(tp); | |
| if (acknow) | |
| tcp_twrespond(tp, TH_ACK); | |
| tcp_tw_2msl_reset(tp, 0); | |
| } | |
| /* | |
| * Returns 1 if the TIME_WAIT state was killed and we should start over, | |
| * looking for a pcb in the listen state. Returns 0 otherwise. | |
| */ | |
| /* | |
| * samkumar: Old signature was | |
| * int | |
| * tcp_twcheck(struct inpcb *inp, struct tcpopt *to, struct tcphdr *th, | |
| * struct mbuf *m, int tlen) | |
| */ | |
| int | |
| tcp_twcheck(struct tcpcb* tp, struct tcphdr *th, int tlen) | |
| { | |
| int thflags; | |
| tcp_seq seq; | |
| /* | |
| * samkumar: There used to be code here that obtains the struct tcptw from | |
| * the inpcb, and does "goto drop" if that fails. | |
| */ | |
| thflags = th->th_flags; | |
| /* | |
| * NOTE: for FIN_WAIT_2 (to be added later), | |
| * must validate sequence number before accepting RST | |
| */ | |
| /* | |
| * If the segment contains RST: | |
| * Drop the segment - see Stevens, vol. 2, p. 964 and | |
| * RFC 1337. | |
| */ | |
| if (thflags & TH_RST) | |
| goto drop; | |
| /* | |
| * samkumar: This was commented out (using #if 0) in the original FreeBSD | |
| * code. | |
| */ | |
| #if 0 | |
| /* PAWS not needed at the moment */ | |
| /* | |
| * RFC 1323 PAWS: If we have a timestamp reply on this segment | |
| * and it's less than ts_recent, drop it. | |
| */ | |
| if ((to.to_flags & TOF_TS) != 0 && tp->ts_recent && | |
| TSTMP_LT(to.to_tsval, tp->ts_recent)) { | |
| if ((thflags & TH_ACK) == 0) | |
| goto drop; | |
| goto ack; | |
| } | |
| /* | |
| * ts_recent is never updated because we never accept new segments. | |
| */ | |
| #endif | |
| /* | |
| * If a new connection request is received | |
| * while in TIME_WAIT, drop the old connection | |
| * and start over if the sequence numbers | |
| * are above the previous ones. | |
| */ | |
| if ((thflags & TH_SYN) && SEQ_GT(th->th_seq, tp->rcv_nxt)) { | |
| /* | |
| * samkumar: The FreeBSD code would call tcp_twclose(tw, 0); but we | |
| * do it as below since TCPlp represents TIME-WAIT connects as | |
| * struct tcpcb's. | |
| */ | |
| tcp_close(tp); | |
| tcplp_sys_connection_lost(tp, CONN_LOST_NORMAL); | |
| return (1); | |
| } | |
| /* | |
| * Drop the segment if it does not contain an ACK. | |
| */ | |
| if ((thflags & TH_ACK) == 0) | |
| goto drop; | |
| /* | |
| * Reset the 2MSL timer if this is a duplicate FIN. | |
| */ | |
| if (thflags & TH_FIN) { | |
| seq = th->th_seq + tlen + (thflags & TH_SYN ? 1 : 0); | |
| if (seq + 1 == tp->rcv_nxt) | |
| tcp_tw_2msl_reset(tp, 1); | |
| } | |
| /* | |
| * Acknowledge the segment if it has data or is not a duplicate ACK. | |
| */ | |
| if (thflags != TH_ACK || tlen != 0 || | |
| th->th_seq != tp->rcv_nxt || th->th_ack != tp->snd_nxt) | |
| tcp_twrespond(tp, TH_ACK); | |
| drop: | |
| return (0); | |
| } |