开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
tcp_input.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：62k
源码类别：

VxWorks

开发平台：

C/C++

tcp_input.c：源码内容
  1. /* tcp_input.c - TCP input routines */
  3. /* Copyright 1984 - 2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1994, 1995
  8.  * The Regents of the University of California.  All rights reserved.
  9.  *
  10.  * Redistribution and use in source and binary forms, with or without
  11.  * modification, are permitted provided that the following conditions
  12.  * are met:
  13.  * 1. Redistributions of source code must retain the above copyright
  14.  *    notice, this list of conditions and the following disclaimer.
  15.  * 2. Redistributions in binary form must reproduce the above copyright
  16.  *    notice, this list of conditions and the following disclaimer in the
  17.  *    documentation and/or other materials provided with the distribution.
  18.  * 3. All advertising materials mentioning features or use of this software
  19.  *    must display the following acknowledgement:
  20.  * This product includes software developed by the University of
  21.  * California, Berkeley and its contributors.
  22.  * 4. Neither the name of the University nor the names of its contributors
  23.  *    may be used to endorse or promote products derived from this software
  24.  *    without specific prior written permission.
  25.  *
  26.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  27.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36.  * SUCH DAMAGE.
  37.  *
  38.  * @(#)tcp_input.c 8.12 (Berkeley) 5/24/95
  39.  */
  41. /*
  42. modification history
  43. --------------------
  44. 01i,06mar02,vvv  fixed tcp_input to wake application only when space in send
  45.  buffer exceeds low water mark (SPR #72177)
  46. 01h,12oct01,rae  merge from truestack ver 01n, base o1f (SPRs 69629, 70328,
  47.                  70329, WindView, cleanup)
  48. 01g,11oct00,gnn  enabled LAND fix by default.
  49. 01f,09jan98,vin  added LAND attack fix.
  50. 01e,26sep97,sgv  Removed check for PUSH flag in TCP_REASS macro
  51. 01d,07jul97,vin  fixed additional bugs. 
  52.  (timestamp echo fix Stevens VolII Sec 26.6 fig 26.20,
  53.                  connection timer bug Stevens VolII sec 28.6 fig 28.20,
  54.                  simultaneous bug fix Stevens VolII sec 28.8 fig 28.30,
  55.                  removed unnecessary code Stevens VolII sec 29.9 fig 29.22)
  56. 01c,08mar97,vin  added changes to accomodate changes in pcb structure for
  57.  hash look ups.
  58. 01c,05feb97,rjc  changes for tos routing
  59. 01b,22nov96,vin  added cluster support replaced m_get(..) with mBufClGet(..).
  60. 01a,03mar96,vin  created from BSD4.4lite2. integrated some wrs changes from
  61.  02q of tcp_input.c
  62. */
  64. #include "vxWorks.h"
  65. #include "net/systm.h"
  66. #include "net/mbuf.h"
  67. #include "net/protosw.h"
  68. #include "sys/socket.h"
  69. #include "net/socketvar.h"
  70. #include "errno.h"
  72. #include "net/if.h"
  73. #include "net/route.h"
  75. #include "netinet/in.h"
  76. #include "netinet/in_pcb.h"
  77. #include "netinet/in_systm.h"
  78. #include "netinet/ip.h"
  79. #include "netinet/ip_var.h"
  80. #include "netinet/tcp.h"
  81. #include "netinet/tcp_fsm.h"
  82. #include "netinet/tcp_seq.h"
  83. #include "netinet/tcp_timer.h"
  84. #include "netinet/tcp_var.h"
  85. #include "netinet/tcpip.h"
  86. #ifdef BSDDEBUG
  87. #include "netinet/tcp_debug.h"
  88. #endif /* BSDDEBUG */
  90. #ifdef WV_INSTRUMENTATION
  91. #ifdef INCLUDE_WVNET
  92. #include "wvNetLib.h"
  93. #endif
  94. #endif
  96. #ifdef VIRTUAL_STACK
  97. #include "netinet/vsLib.h"
  98. #else
  99. extern u_long sb_max;
  100. IMPORT int tcp_keepinit;
  101. IMPORT int tcp_mssdflt;
  102. #endif /* VIRTUAL_STACK */
  104. IMPORT unsigned long (*pTcpRandHook)(void);
  106. extern void _remque ();
  107. extern void _insque ();
  109. /* XXX LAND attack safe remove this after thorough investigation */
  110. UCHAR _landAttackSafe = 1;
  112. /*
  113.  *  MIB-II support counts the number of TCP packets sent with the Reset Flag
  114.  *  set.
  115.  */
  117. #ifndef VIRTUAL_STACK
  118. long   tcpOutRsts;
  120. tcp_seq tcp_iss; /* tcp initial send seq # */
  121. unsigned tcp_alpha, tcp_beta; /* retransmission smoothing constants */
  122. struct inpcbhead tcb;           /* head of queue of active tcpcb's */
  123. struct inpcbinfo tcbinfo;
  124. struct  tcpstat tcpstat; /* tcp statistics */
  125. int tcprexmtthresh = 3;     /* overridden during protocol initialization */
  126. struct tcpiphdr tcp_saveti;
  127. struct inpcb *tcp_last_inpcb = NULL;
  128. u_long  tcp_now; /* for RFC 1323 timestamps */
  129. #endif /* VIRTUAL_STACK */
  131. #ifdef WV_INSTRUMENTATION
  132. #ifdef INCLUDE_WVNET
  133.     /* Set common fields of event identifiers for this module. */
  135. LOCAL UCHAR wvNetModuleId = WV_NET_TCPINPUT_MODULE; /* Value for tcp_input.c */
  136. LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;     /* Available event filter */
  138. LOCAL ULONG wvNetEventId;       /* Event identifier: see wvNetLib.h */
  139. #endif    /* INCLUDE_WVNET */
  140. #endif
  142. #define TCP_PAWS_IDLE (24 * 24 * 60 * 60 * PR_SLOWHZ)
  144. /* for modulo comparisons of timestamps */
  145. #define TSTMP_LT(a,b) ((int)((a)-(b)) < 0)
  146. #define TSTMP_GEQ(a,b) ((int)((a)-(b)) >= 0)
  149. /*
  150.  * Insert segment ti into reassembly queue of tcp with
  151.  * control block tp.  Return TH_FIN if reassembly now includes
  152.  * a segment with FIN.  The macro form does the common case inline
  153.  * (segment is the next to be received on an established connection,
  154.  * and the queue is empty), avoiding linkage into and removal
  155.  * from the queue and repetition of various conversions.
  156.  * Set DELACK for segments received in order, but ack immediately
  157.  * when segments are out of order (so fast retransmit can work).
  158.  */
  159. #define TCP_REASS(tp, ti, m, so, flags) { 
  160. if ((ti)->ti_seq == (tp)->rcv_nxt && 
  161.     (tp)->seg_next == (struct tcpiphdr *)(tp) && 
  162.     (tp)->t_state == TCPS_ESTABLISHED) { 
  163. (tp)->t_flags |= TF_DELACK; 
  164. (tp)->rcv_nxt += (ti)->ti_len; 
  165. flags = (ti)->ti_flags & TH_FIN; 
  166. tcpstat.tcps_rcvpack++;
  167. tcpstat.tcps_rcvbyte += (ti)->ti_len;
  168. sbappend(&(so)->so_rcv, (m)); 
  169. sorwakeup(so); 
  170. } else { 
  171. (flags) = tcp_reass((tp), (ti), (m)); 
  172. tp->t_flags |= TF_ACKNOW; 
  173. } 
  174. }
  176. int
  177. tcp_reass(tp, ti, m)
  178. register struct tcpcb *tp;
  179. register struct tcpiphdr *ti;
  180. struct mbuf *m;
  181. {
  182. register struct tcpiphdr *q;
  183. struct socket *so = tp->t_inpcb->inp_socket;
  184. int flags;
  186. /*
  187.  * Call with ti==0 after become established to
  188.  * force pre-ESTABLISHED data up to user socket.
  189.  */
  190. if (ti == 0)
  191. goto present;
  193. /*
  194.  * Find a segment which begins after this one does.
  195.  */
  196. for (q = tp->seg_next; q != (struct tcpiphdr *)tp;
  197.     q = (struct tcpiphdr *)q->ti_next)
  198. if (SEQ_GT(q->ti_seq, ti->ti_seq))
  199. break;
  201. /*
  202.  * If there is a preceding segment, it may provide some of
  203.  * our data already.  If so, drop the data from the incoming
  204.  * segment.  If it provides all of our data, drop us.
  205.  */
  206. if ((struct tcpiphdr *)q->ti_prev != (struct tcpiphdr *)tp) {
  207. register int i;
  208. q = (struct tcpiphdr *)q->ti_prev;
  209. /* conversion to int (in i) handles seq wraparound */
  210. i = q->ti_seq + q->ti_len - ti->ti_seq;
  211. if (i > 0) {
  212. if (i >= ti->ti_len) {
  213. #ifdef WV_INSTRUMENTATION
  214. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  215.             WV_NET_PORTIN_EVENT_3 (NET_CORE_EVENT, WV_NET_INFO, 26, 8,
  216.                                tp->t_inpcb->inp_fport, tp->t_inpcb->inp_lport,
  217.                                    WV_NETEVENT_TCPIN_DUPSEG, WV_NET_RECV,
  218.                                    so->so_fd, ti->ti_seq, ti->ti_len)
  219. #endif  /* INCLUDE_WVNET */
  220. #endif
  222. tcpstat.tcps_rcvduppack++;
  223. tcpstat.tcps_rcvdupbyte += ti->ti_len;
  224. m_freem(m);
  225. return (0);
  226. }
  227. m_adj(m, i);
  228. ti->ti_len -= i;
  229. ti->ti_seq += i;
  230. }
  231. q = (struct tcpiphdr *)(q->ti_next);
  232. }
  233. tcpstat.tcps_rcvoopack++;
  234. tcpstat.tcps_rcvoobyte += ti->ti_len;
  235. REASS_MBUF(ti) = m; /* XXX */
  237. /*
  238.  * While we overlap succeeding segments trim them or,
  239.  * if they are completely covered, dequeue them.
  240.  */
  241. while (q != (struct tcpiphdr *)tp) {
  242. register int i = (ti->ti_seq + ti->ti_len) - q->ti_seq;
  243. if (i <= 0)
  244. break;
  245. if (i < q->ti_len) {
  246. q->ti_seq += i;
  247. q->ti_len -= i;
  248. m_adj(REASS_MBUF(q), i);
  249. break;
  250. }
  251. q = (struct tcpiphdr *)q->ti_next;
  252. m = REASS_MBUF((struct tcpiphdr *)q->ti_prev);
  254. #ifdef WV_INSTRUMENTATION
  255. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  256.         WV_NET_PORTIN_EVENT_4 (NET_CORE_EVENT, WV_NET_VERBOSE, 37, 20,
  257.                                tp->t_inpcb->inp_fport, tp->t_inpcb->inp_lport,
  258.                                WV_NETEVENT_TCPIN_DUPDATA, WV_NET_RECV, 
  259.                                so->so_fd, ti->ti_seq,
  260.                                ((struct tcpiphdr *)q->ti_prev)->ti_seq,
  261.                                ((struct tcpiphdr *)q->ti_prev)->ti_len)
  262. #endif  /* INCLUDE_WVNET */
  263. #endif
  265. remque(q->ti_prev);
  266. m_freem(m);
  267. }
  269. /*
  270.  * Stick new segment in its place.
  271.  */
  272. insque(ti, q->ti_prev);
  274. present:
  275. /*
  276.  * Present data to user, advancing rcv_nxt through
  277.  * completed sequence space.
  278.  */
  279. if (TCPS_HAVERCVDSYN(tp->t_state) == 0)
  280. return (0);
  281. ti = tp->seg_next;
  282. if (ti == (struct tcpiphdr *)tp || ti->ti_seq != tp->rcv_nxt)
  283. return (0);
  284. if (tp->t_state == TCPS_SYN_RECEIVED && ti->ti_len)
  285. return (0);
  286. do {
  287. tp->rcv_nxt += ti->ti_len;
  288. flags = ti->ti_flags & TH_FIN;
  289. remque(ti);
  290. m = REASS_MBUF(ti);
  291. ti = (struct tcpiphdr *)ti->ti_next;
  292. if (so->so_state & SS_CANTRCVMORE)
  293. m_freem(m);
  294. else
  295. sbappend(&so->so_rcv, m);
  296. } while (ti != (struct tcpiphdr *)tp && ti->ti_seq == tp->rcv_nxt);
  297. sorwakeup(so);
  298. return (flags);
  299. }
  301. /*
  302.  * TCP input routine, follows pages 65-76 of the
  303.  * protocol specification dated September, 1981 very closely.
  304.  */
  305. void
  306. tcp_input(m, iphlen)
  307. register struct mbuf *m;
  308. int iphlen;
  309. {
  310. register struct tcpiphdr *ti;
  311. register struct inpcb *inp;
  312. u_char *optp = NULL;
  313. int optlen = 0;
  314. int len, tlen, off;
  315. register struct tcpcb *tp = 0;
  316. register int tiflags;
  317. struct socket *so = NULL;
  318. int todrop, acked, ourfinisacked, needoutput = 0;
  319. short ostate = 0;
  320. struct in_addr laddr;
  321. int dropsocket = 0;
  322. int iss = 0;
  323. u_long tiwin, ts_val, ts_ecr;
  324. int ts_present = 0;
  326. #ifdef WV_INSTRUMENTATION
  327. #ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */
  328.         WV_NET_EVENT_0 (NET_CORE_EVENT, WV_NET_NOTICE, 18, 7,
  329.                         WV_NETEVENT_TCPIN_START, WV_NET_RECV)
  330. #endif  /* INCLUDE_WVNET */
  331. #endif
  333. tcpstat.tcps_rcvtotal++;
  334. /*
  335.  * Get IP and TCP header together in first mbuf.
  336.  * Note: IP leaves IP header in first mbuf.
  337.  */
  338. ti = mtod(m, struct tcpiphdr *);
  339. if (iphlen > sizeof (struct ip))
  340. ip_stripoptions(m, (struct mbuf *)0);
  341. if (m->m_len < sizeof (struct tcpiphdr)) {
  342. if ((m = m_pullup(m, sizeof (struct tcpiphdr))) == 0) {
  343. tcpstat.tcps_rcvshort++;
  345. #ifdef WV_INSTRUMENTATION
  346. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  347.             WV_NET_EVENT_0 (NET_CORE_EVENT, WV_NET_VERBOSE, 38, 21,
  348.                             WV_NETEVENT_TCPIN_SHORTSEG, WV_NET_RECV)
  349. #endif  /* INCLUDE_WVNET */
  350. #endif
  352. return;
  353. }
  354. ti = mtod(m, struct tcpiphdr *);
  355. }
  357. /*
  358.  * Checksum extended TCP header and data.
  359.  */
  360. tlen = ((struct ip *)ti)->ip_len;
  361. len = sizeof (struct ip) + tlen;
  362. ti->ti_next = ti->ti_prev = 0;
  363. ti->ti_x1 = 0;
  364. ti->ti_len = (u_short)tlen;
  365. HTONS(ti->ti_len);
  366. if ((ti->ti_sum = in_cksum(m, len))) {
  368. #ifdef WV_INSTRUMENTATION
  369. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  370.             WV_NET_EVENT_0 (NET_CORE_EVENT, WV_NET_CRITICAL, 30, 2,
  371.                             WV_NETEVENT_TCPIN_BADSUM, WV_NET_RECV)
  372. #endif  /* INCLUDE_WVNET */
  373. #endif
  375. tcpstat.tcps_rcvbadsum++;
  376. goto drop;
  377. }
  379. /*
  380.  * Check that TCP offset makes sense,
  381.  * pull out TCP options and adjust length. XXX
  382.  */
  383. off = ti->ti_off << 2;
  384. if (off < sizeof (struct tcphdr) || off > tlen) {
  385. #ifdef WV_INSTRUMENTATION
  386. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  387.             WV_NET_PORTIN_EVENT_1 (NET_CORE_EVENT, WV_NET_CRITICAL, 31, 3,
  388.                                    ti->ti_sport, ti->ti_dport,
  389.                                    WV_NETEVENT_TCPIN_BADSEG, WV_NET_RECV, 
  390.                                    off)
  391. #endif  /* INCLUDE_WVNET */
  392. #endif
  394. tcpstat.tcps_rcvbadoff++;
  395. goto drop;
  396. }
  397. tlen -= off;
  398. ti->ti_len = tlen;
  399. if (off > sizeof (struct tcphdr)) {
  400. if (m->m_len < sizeof(struct ip) + off) {
  401. if ((m = m_pullup(m, sizeof (struct ip) + off)) == 0) {
  402. #ifdef WV_INSTRUMENTATION
  403. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  404.                 WV_NET_PORTIN_EVENT_0 (NET_CORE_EVENT, WV_NET_VERBOSE, 38, 21,
  405.                                        ti->ti_sport, ti->ti_dport,
  406.                                        WV_NETEVENT_TCPIN_SHORTSEG, WV_NET_RECV)
  407. #endif  /* INCLUDE_WVNET */
  408. #endif
  410. tcpstat.tcps_rcvshort++;
  411. return;
  412. }
  413. ti = mtod(m, struct tcpiphdr *);
  414. }
  415. optlen = off - sizeof (struct tcphdr);
  416. optp = mtod(m, u_char *) + sizeof (struct tcpiphdr);
  417. /* 
  418.  * Do quick retrieval of timestamp options ("options
  419.  * prediction?").  If timestamp is the only option and it's
  420.  * formatted as recommended in RFC 1323 appendix A, we
  421.  * quickly get the values now and not bother calling
  422.  * tcp_dooptions(), etc.
  423.  */
  424. if ((optlen == TCPOLEN_TSTAMP_APPA ||
  425.      (optlen > TCPOLEN_TSTAMP_APPA &&
  426. optp[TCPOLEN_TSTAMP_APPA] == TCPOPT_EOL)) &&
  427.      *(u_long *)optp == htonl(TCPOPT_TSTAMP_HDR) &&
  428.      (ti->ti_flags & TH_SYN) == 0) {
  429. ts_present = 1;
  430. ts_val = ntohl(*(u_long *)(optp + 4));
  431. ts_ecr = ntohl(*(u_long *)(optp + 8));
  432. optp = NULL; /* we've parsed the options */
  433. }
  434. }
  435. tiflags = ti->ti_flags;
  437. /*
  438.  * Convert TCP protocol specific fields to host format.
  439.  */
  440. NTOHL(ti->ti_seq);
  441. NTOHL(ti->ti_ack);
  442. NTOHS(ti->ti_win);
  443. NTOHS(ti->ti_urp);
  445. /*
  446.  * Locate pcb for segment.
  447.  */
  448. findpcb:
  449. inp = tcp_last_inpcb;
  450.         if ((inp != NULL) &&
  451.             (inp->inp_lport == ti->ti_dport) &&
  452.     (inp->inp_fport == ti->ti_sport) &&
  453.     (inp->inp_faddr.s_addr == ti->ti_src.s_addr) &&
  454.             (inp->inp_laddr.s_addr == ti->ti_dst.s_addr))
  455.             {
  456.             goto pcbMatchFound;
  457.             }
  458.         else
  459.             {
  460.             ++tcpstat.tcps_pcbcachemiss;
  462.             /*
  463.              * Search the hash table of pcbs.
  464.              */
  465.             inp = in_pcblookuphash (&tcbinfo, ti->ti_src, ti->ti_sport,
  466.                                     ti->ti_dst, ti->ti_dport, 1);
  467.             /*
  468.              * ...and if that fails, drop the packet.
  469.              */
  470.             if (inp == NULL)
  471.                 {
  472. #ifdef WV_INSTRUMENTATION
  473. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  474.             WV_NET_PORTIN_EVENT_4 (NET_CORE_EVENT, WV_NET_WARNING, 11, 4,
  475.                                    ti->ti_sport, ti->ti_dport,
  476.                                    WV_NETEVENT_TCPIN_SEARCHFAIL, WV_NET_RECV, 
  477.                                    ti->ti_src.s_addr, ti->ti_sport,
  478.                                    ti->ti_dst.s_addr, ti->ti_dport)
  479. #endif  /* INCLUDE_WVNET */
  480. #endif
  482.                 /*
  483.                  * If the state is CLOSED (i.e., TCB does not exist) then
  484.                  * all data in the incoming segment is discarded.
  485.                  * If the TCB exists but is in CLOSED state, it is embryonic,
  486.                  * but should either do a listen or a connect soon.
  487.                  */
  488.                 goto dropwithreset;
  489.                 }
  490.             }
  491.         tcp_last_inpcb = inp; /* update the cache */
  493. pcbMatchFound:
  494. tp = intotcpcb(inp);
  495. if (tp == 0)
  496. goto dropwithreset;
  497. if (tp->t_state == TCPS_CLOSED)
  498. goto drop;
  500. /* Unscale the window into a 32-bit value. */
  501. if ((tiflags & TH_SYN) == 0)
  502. tiwin = ti->ti_win << tp->snd_scale;
  503. else
  504. tiwin = ti->ti_win;
  506. so = inp->inp_socket;
  507. if (so->so_options & (SO_DEBUG|SO_ACCEPTCONN)) {
  508. if (so->so_options & SO_DEBUG) {
  509. ostate = tp->t_state;
  510. tcp_saveti = *ti;
  511. }
  512. if (so->so_options & SO_ACCEPTCONN) {
  513. if ((tiflags & (TH_RST|TH_ACK|TH_SYN)) != TH_SYN) {
  514. /*
  515.  * Note: dropwithreset makes sure we don't
  516.  * send a reset in response to a RST.
  517.  */
  518. if (tiflags & TH_ACK) {
  519. tcpstat.tcps_badsyn++;
  520. goto dropwithreset;
  521. }
  522. goto drop;
  523. }
  524. so = sonewconn(so, 0);
  525. if (so == 0)
  526. goto drop;
  527. /*
  528.  * This is ugly, but ....
  529.  *
  530.  * Mark socket as temporary until we're
  531.  * committed to keeping it.  The code at
  532.  * ``drop'' and ``dropwithreset'' check the
  533.  * flag dropsocket to see if the temporary
  534.  * socket created here should be discarded.
  535.  * We mark the socket as discardable until
  536.  * we're committed to it below in TCPS_LISTEN.
  537.  */
  538. dropsocket++;
  539. inp = (struct inpcb *)so->so_pcb;
  540. inp->inp_laddr = ti->ti_dst;
  541. inp->inp_lport = ti->ti_dport;
  542.                         in_pcbrehash(inp);
  543. #ifdef SRCRT
  544. #if BSD>=43
  545. inp->inp_options = ip_srcroute();
  546. #endif
  547. #endif /* SRCRT */
  548. tp = intotcpcb(inp);
  549. tp->t_state = TCPS_LISTEN;
  551. /* Compute proper scaling value from buffer space
  552.  */
  553. while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
  554.    TCP_MAXWIN << tp->request_r_scale < so->so_rcv.sb_hiwat)
  555. tp->request_r_scale++;
  556. }
  557. }
  559. /*
  560.  * Segment received on connection.
  561.  * Reset idle time and keep-alive timer.
  562.  */
  563. tp->t_idle = 0;
  564. tp->t_timer[TCPT_KEEP] = tcp_keepidle;
  566. /*
  567.  * Process options if not in LISTEN state,
  568.  * else do it below (after getting remote address).
  569.  */
  570. if (optp && tp->t_state != TCPS_LISTEN)
  571. tcp_dooptions(tp, optp, optlen, ti,
  572. &ts_present, &ts_val, &ts_ecr);
  574. /* 
  575.  * Header prediction: check for the two common cases
  576.  * of a uni-directional data xfer.  If the packet has
  577.  * no control flags, is in-sequence, the window didn't
  578.  * change and we're not retransmitting, it's a
  579.  * candidate.  If the length is zero and the ack moved
  580.  * forward, we're the sender side of the xfer.  Just
  581.  * free the data acked & wake any higher level process
  582.  * that was blocked waiting for space.  If the length
  583.  * is non-zero and the ack didn't move, we're the
  584.  * receiver side.  If we're getting packets in-order
  585.  * (the reassembly queue is empty), add the data to
  586.  * the socket buffer and note that we need a delayed ack.
  587.  */
  588. if (tp->t_state == TCPS_ESTABLISHED &&
  589.     (tiflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ACK)) == TH_ACK &&
  590.     (!ts_present || TSTMP_GEQ(ts_val, tp->ts_recent)) &&
  591.     ti->ti_seq == tp->rcv_nxt &&
  592.     tiwin && tiwin == tp->snd_wnd &&
  593.     tp->snd_nxt == tp->snd_max) {
  595. /* 
  596.  * If last ACK falls within this segment's sequence numbers,
  597.  *  record the timestamp.
  598.  */
  599. if (ts_present && SEQ_LEQ(ti->ti_seq, tp->last_ack_sent)) {
  600. tp->ts_recent_age = tcp_now;
  601. tp->ts_recent = ts_val;
  602. }
  604. if (ti->ti_len == 0) {
  605. if (SEQ_GT(ti->ti_ack, tp->snd_una) &&
  606.     SEQ_LEQ(ti->ti_ack, tp->snd_max) &&
  607.     tp->snd_cwnd >= tp->snd_wnd) {
  608. /*
  609.  * this is a pure ack for outstanding data.
  610.  */
  611. ++tcpstat.tcps_predack;
  612. if (ts_present)
  613. tcp_xmit_timer(tp, tcp_now-ts_ecr+1);
  614. else if (tp->t_rtt &&
  615.     SEQ_GT(ti->ti_ack, tp->t_rtseq))
  616. tcp_xmit_timer(tp, tp->t_rtt);
  617. acked = ti->ti_ack - tp->snd_una;
  619. #ifdef WV_INSTRUMENTATION
  620. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  621.             WV_NET_PORTIN_EVENT_3 (NET_CORE_EVENT, WV_NET_INFO, 27, 9,
  622.                                    ti->ti_sport, ti->ti_dport,
  623.                                    WV_NETEVENT_TCPIN_PUREACK, WV_NET_RECV, 
  624.                                    so->so_fd, tp->snd_una, ti->ti_ack)
  625. #endif  /* INCLUDE_WVNET */
  626. #endif
  628. tcpstat.tcps_rcvackpack++;
  629. tcpstat.tcps_rcvackbyte += acked;
  630. sbdrop(&so->so_snd, acked);
  631. tp->snd_una = ti->ti_ack;
  632. m_freem(m);
  634. /*
  635.  * If all outstanding data are acked, stop
  636.  * retransmit timer, otherwise restart timer
  637.  * using current (possibly backed-off) value.
  638.  * If process is waiting for space,
  639.  * wakeup/selwakeup/signal.  If data
  640.  * are ready to send, let tcp_output
  641.  * decide between more output or persist.
  642.  */
  643. if (tp->snd_una == tp->snd_max)
  644. tp->t_timer[TCPT_REXMT] = 0;
  645. else if (tp->t_timer[TCPT_PERSIST] == 0)
  646. tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
  648. if ((so->so_snd.sb_want > 0) ||
  649.     (so->so_snd.sb_sel)      ||
  650.     (sowakeupHook != NULL))
  651.     {
  652.     if (sbspace (&so->so_snd) >= 
  653. so->so_snd.sb_lowat) 
  654. sowwakeup(so);
  655.     }
  656. if (so->so_snd.sb_cc)
  657. (void) tcp_output(tp);
  658. return;
  659. }
  660. } else if (ti->ti_ack == tp->snd_una &&
  661.     tp->seg_next == (struct tcpiphdr *)tp &&
  662.     ti->ti_len <= sbspace(&so->so_rcv)) {
  663. /*
  664.  * this is a pure, in-sequence data packet
  665.  * with nothing on the reassembly queue and
  666.  * we have enough buffer space to take it.
  667.  */
  669. #ifdef WV_INSTRUMENTATION
  670. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  671.         WV_NET_PORTIN_EVENT_3 (NET_CORE_EVENT, WV_NET_INFO, 28, 10,
  672.                                ti->ti_sport, ti->ti_dport,
  673.                                WV_NETEVENT_TCPIN_PUREDATA, WV_NET_RECV, 
  674.                                so->so_fd, ti->ti_seq, ti->ti_len)
  675. #endif  /* INCLUDE_WVNET */
  676. #endif
  678. ++tcpstat.tcps_preddat;
  679. tp->rcv_nxt += ti->ti_len;
  680. tcpstat.tcps_rcvpack++;
  681. tcpstat.tcps_rcvbyte += ti->ti_len;
  682. /*
  683.  * Drop TCP, IP headers and TCP options then add data
  684.  * to socket buffer.
  685.  */
  686. m->m_data += sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);
  687. m->m_len -= sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);
  688. sbappend(&so->so_rcv, m);
  689. sorwakeup(so);
  690. if (ti->ti_flags & TH_PUSH)
  691. tp->t_flags |= TF_ACKNOW;
  692. else
  693. tp->t_flags |= TF_DELACK;
  694. return;
  695. }
  696. }
  698. /*
  699.  * Drop TCP, IP headers and TCP options.
  700.  */
  701. m->m_data += sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);
  702. m->m_len  -= sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);
  704. /*
  705.  * Calculate amount of space in receive window,
  706.  * and then do TCP input processing.
  707.  * Receive window is amount of space in rcv queue,
  708.  * but not less than advertised window.
  709.  */
  710. { int win;
  712. win = sbspace(&so->so_rcv);
  713. if (win < 0)
  714. win = 0;
  715. tp->rcv_wnd = max(win, (int)(tp->rcv_adv - tp->rcv_nxt));
  716. }
  718. switch (tp->t_state) {
  720. /*
  721.  * If the state is LISTEN then ignore segment if it contains an RST.
  722.  * If the segment contains an ACK then it is bad and send a RST.
  723.  * If it does not contain a SYN then it is not interesting; drop it.
  724.  * Don't bother responding if the destination was a broadcast.
  725.  * Otherwise initialize tp->rcv_nxt, and tp->irs, select an initial
  726.  * tp->iss, and send a segment:
  727.  *     <SEQ=ISS><ACK=RCV_NXT><CTL=SYN,ACK>
  728.  * Also initialize tp->snd_nxt to tp->iss+1 and tp->snd_una to tp->iss.
  729.  * Fill in remote peer address fields if not previously specified.
  730.  * Enter SYN_RECEIVED state, and process any other fields of this
  731.  * segment in this state.
  732.  */
  733. case TCPS_LISTEN: {
  734. struct mbuf *am;
  735. register struct sockaddr_in *sin;
  737. #ifdef already_done
  738. if (tiflags & TH_RST)
  739. goto drop;
  740. if (tiflags & TH_ACK)
  741. goto dropwithreset;
  742. if ((tiflags & TH_SYN) == 0)
  743. goto drop;
  744. #endif
  745. /*
  746.  * RFC1122 4.2.3.10, p. 104: discard bcast/mcast SYN
  747.  * in_broadcast() should never return true on a received
  748.  * packet with M_BCAST not set.
  749.  */
  750. if (m->m_flags & (M_BCAST|M_MCAST) ||
  751.     IN_MULTICAST(ntohl(ti->ti_dst.s_addr)))
  752. goto drop;
  754.                 /* XXX land bug attack fix */
  755.                 if (_landAttackSafe)
  756.                     if ((ti->ti_sport == ti->ti_dport) &&
  757.                         (ti->ti_src.s_addr == ti->ti_dst.s_addr))
  758.                         goto drop;
  759.                 
  760. /* XXX */
  761. am = mBufClGet(M_DONTWAIT, MT_SONAME, CL_SIZE_128, TRUE);
  762. if (am == NULL)
  763. goto drop;
  764. am->m_len = sizeof (struct sockaddr_in);
  765. sin = mtod(am, struct sockaddr_in *);
  766. sin->sin_family = AF_INET;
  767. sin->sin_len = sizeof(*sin);
  768. sin->sin_addr = ti->ti_src;
  769. sin->sin_port = ti->ti_sport;
  770. bzero((caddr_t)sin->sin_zero, sizeof(sin->sin_zero));
  771. laddr = inp->inp_laddr;
  772. if (inp->inp_laddr.s_addr == INADDR_ANY)
  773. inp->inp_laddr = ti->ti_dst;
  774. if (in_pcbconnect(inp, am)) {
  775. inp->inp_laddr = laddr;
  776. (void) m_free(am);
  777. goto drop;
  778. }
  779. (void) m_free(am);
  780. tp->t_template = tcp_template(tp);
  781. if (tp->t_template == 0) {
  782. tp = tcp_drop(tp, ENOBUFS);
  783. dropsocket = 0; /* socket is already gone */
  784. goto drop;
  785. }
  786. if (optp)
  787. tcp_dooptions(tp, optp, optlen, ti,
  788. &ts_present, &ts_val, &ts_ecr);
  789. if (iss)
  790. tp->iss = iss;
  791. else
  792. tp->iss = tcp_iss;
  793. tcp_iss += TCP_ISSINCR/4 + ((0x0000ffff) & (pTcpRandHook() >> 16));
  794. tp->irs = ti->ti_seq;
  795. tcp_sendseqinit(tp);
  796. tcp_rcvseqinit(tp);
  797. tp->t_flags |= TF_ACKNOW;
  798. tp->t_state = TCPS_SYN_RECEIVED;
  799. tp->t_timer[TCPT_KEEP] = tcp_keepinit;
  800. dropsocket = 0; /* committed to socket */
  801. tcpstat.tcps_accepts++;
  803. #ifdef WV_INSTRUMENTATION
  804. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  805.             WV_NET_PORTIN_EVENT_3 (NET_AUX_EVENT, WV_NET_INFO, 29, 11,
  806.                                    ti->ti_sport, ti->ti_dport,
  807.                                    WV_NETEVENT_TCPIN_ACCEPT, WV_NET_RECV, 
  808.                                    so->so_fd, tp->snd_nxt, tp->rcv_nxt)
  809. #endif  /* INCLUDE_WVNET */
  810. #endif
  812. goto trimthenstep6;
  813. }
  815. /*
  816.  * If the state is SYN_SENT:
  817.  * if seg contains an ACK, but not for our SYN, drop the input.
  818.  * if seg contains a RST, then drop the connection.
  819.  * if seg does not contain SYN, then drop it.
  820.  * Otherwise this is an acceptable SYN segment
  821.  * initialize tp->rcv_nxt and tp->irs
  822.  * if seg contains ack then advance tp->snd_una
  823.  * if SYN has been acked change to ESTABLISHED else SYN_RCVD state
  824.  * arrange for segment to be acked (eventually)
  825.  * continue processing rest of data/controls, beginning with URG
  826.  */
  827. case TCPS_SYN_SENT:
  828. if ((tiflags & TH_ACK) &&
  829.     (SEQ_LEQ(ti->ti_ack, tp->iss) ||
  830.      SEQ_GT(ti->ti_ack, tp->snd_max)))
  831. goto dropwithreset;
  832. if (tiflags & TH_RST) {
  833. if (tiflags & TH_ACK)
  834. tp = tcp_drop(tp, ECONNREFUSED);
  835. goto drop;
  836. }
  837. if ((tiflags & TH_SYN) == 0)
  838. goto drop;
  839. if (tiflags & TH_ACK) {
  840. tp->snd_una = ti->ti_ack;
  841. if (SEQ_LT(tp->snd_nxt, tp->snd_una))
  842. tp->snd_nxt = tp->snd_una;
  843.                         tp->t_timer[TCPT_REXMT] = 0;
  844. }
  845. tp->irs = ti->ti_seq;
  846. tcp_rcvseqinit(tp);
  847. tp->t_flags |= TF_ACKNOW;
  848. if (tiflags & TH_ACK ) {
  849. tcpstat.tcps_connects++;
  851. #ifdef WV_INSTRUMENTATION
  852. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  853.             WV_NET_PORTIN_EVENT_3 (NET_AUX_EVENT, WV_NET_INFO, 30, 12,
  854.                                    ti->ti_sport, ti->ti_dport,
  855.                                    WV_NETEVENT_TCPIN_CONNECT, WV_NET_RECV, 
  856.                                    so->so_fd, tp->snd_nxt, tp->rcv_nxt)
  857. #endif  /* INCLUDE_WVNET */
  858. #endif
  860. soisconnected(so);
  861. tp->t_state = TCPS_ESTABLISHED;
  862. /* Do window scaling on this connection? */
  863. if ((tp->t_flags & (TF_RCVD_SCALE|TF_REQ_SCALE)) ==
  864. (TF_RCVD_SCALE|TF_REQ_SCALE)) {
  865. tp->snd_scale = tp->requested_s_scale;
  866. tp->rcv_scale = tp->request_r_scale;
  867. }
  868. (void) tcp_reass(tp, (struct tcpiphdr *)0,
  869. (struct mbuf *)0);
  870. /*
  871.  * if we didn't have to retransmit the SYN,
  872.  * use its rtt as our initial srtt & rtt var.
  873.  */
  874. if (tp->t_rtt)
  875. tcp_xmit_timer(tp, tp->t_rtt);
  876. } else
  877. tp->t_state = TCPS_SYN_RECEIVED;
  879. trimthenstep6:
  880. /*
  881.  * Advance ti->ti_seq to correspond to first data byte.
  882.  * If data, trim to stay within window,
  883.  * dropping FIN if necessary.
  884.  */
  885. ti->ti_seq++;
  886. if (ti->ti_len > tp->rcv_wnd) {
  887. todrop = ti->ti_len - tp->rcv_wnd;
  888. m_adj(m, -todrop);
  889. ti->ti_len = tp->rcv_wnd;
  890. tiflags &= ~TH_FIN;
  891. tcpstat.tcps_rcvpackafterwin++;
  892. tcpstat.tcps_rcvbyteafterwin += todrop;
  893. }
  894. tp->snd_wl1 = ti->ti_seq - 1;
  895. tp->rcv_up = ti->ti_seq;
  896. goto step6;
  897. }
  899. /*
  900.  * States other than LISTEN or SYN_SENT.
  901.  * First check timestamp, if present.
  902.  * Then check that at least some bytes of segment are within 
  903.  * receive window.  If segment begins before rcv_nxt,
  904.  * drop leading data (and SYN); if nothing left, just ack.
  905.  * 
  906.  * RFC 1323 PAWS: If we have a timestamp reply on this segment
  907.  * and it's less than ts_recent, drop it.
  908.  */
  909. if (ts_present && (tiflags & TH_RST) == 0 && tp->ts_recent &&
  910.     TSTMP_LT(ts_val, tp->ts_recent)) {
  912. /* Check to see if ts_recent is over 24 days old.  */
  913. if ((int)(tcp_now - tp->ts_recent_age) > TCP_PAWS_IDLE) {
  914. /*
  915.  * Invalidate ts_recent.  If this segment updates
  916.  * ts_recent, the age will be reset later and ts_recent
  917.  * will get a valid value.  If it does not, setting
  918.  * ts_recent to zero will at least satisfy the
  919.  * requirement that zero be placed in the timestamp
  920.  * echo reply when ts_recent isn't valid.  The
  921.  * age isn't reset until we get a valid ts_recent
  922.  * because we don't want out-of-order segments to be
  923.  * dropped when ts_recent is old.
  924.  */
  925. tp->ts_recent = 0;
  926. } else {
  927. tcpstat.tcps_rcvduppack++;
  928. tcpstat.tcps_rcvdupbyte += ti->ti_len;
  929. tcpstat.tcps_pawsdrop++;
  930. goto dropafterack;
  931. }
  932. }
  934. todrop = tp->rcv_nxt - ti->ti_seq;
  935. if (todrop > 0) {
  936. if (tiflags & TH_SYN) {
  937. tiflags &= ~TH_SYN;
  938. ti->ti_seq++;
  939. if (ti->ti_urp > 1) 
  940. ti->ti_urp--;
  941. else
  942. tiflags &= ~TH_URG;
  943. todrop--;
  944. }
  945. #if 0  /* simultaneous open bug  */              
  946. if (todrop >= ti->ti_len) {
  947. tcpstat.tcps_rcvduppack++;
  948. tcpstat.tcps_rcvdupbyte += ti->ti_len;
  949. /*
  950.  * If segment is just one to the left of the window,
  951.  * check two special cases:
  952.  * 1. Don't toss RST in response to 4.2-style keepalive.
  953.  * 2. If the only thing to drop is a FIN, we can drop
  954.  *    it, but check the ACK or we will get into FIN
  955.  *    wars if our FINs crossed (both CLOSING).
  956.  * In either case, send ACK to resynchronize,
  957.  * but keep on processing for RST or ACK.
  958.  */
  959. if ((tiflags & TH_FIN && todrop == ti->ti_len + 1)
  960. #ifdef TCP_COMPAT_42
  961.   || (tiflags & TH_RST && ti->ti_seq == tp->rcv_nxt - 1)
  962. #endif
  963.    ) {
  964. todrop = ti->ti_len;
  965. tiflags &= ~TH_FIN;
  966. } else {
  967. /*
  968.  * Handle the case when a bound socket connects
  969.  * to itself. Allow packets with a SYN and
  970.  * an ACK to continue with the processing.
  971.  */
  972. if (todrop != 0 || (tiflags & TH_ACK) == 0)
  973. goto dropafterack;
  974. }
  975. tp->t_flags |= TF_ACKNOW;
  976. } else {
  977. tcpstat.tcps_rcvpartduppack++;
  978. tcpstat.tcps_rcvpartdupbyte += todrop;
  979. }
  980. #else /* XXX  simultaneous open bug fix Steven vol II sec 28.8 fig 28.30 */
  981.                 if (todrop > ti->ti_len ||
  982.                     (todrop == ti->ti_len && (tiflags & TH_FIN) == 0)) {
  984.                     /*
  985.                      * Any valid Fin must be to the left of the window.
  986.                      * At this point the FIN must be a duplicate or
  987.                      * out of sequence; drop it.
  988.                      */
  989.                      tiflags &= ~TH_FIN;
  991.                     /*
  992.                      * Send an ACK to resynchronize and drop any data.
  993.                      * But keep on processing for RST or ACK.
  994.                      */
  995.                     tp->t_flags |= TF_ACKNOW;
  996.                     todrop = ti->ti_len;
  997.                 }
  998.                 tcpstat.tcps_rcvdupbyte += todrop;
  999.                 tcpstat.tcps_rcvduppack++;
  1000. #endif /* simultaneous open bug fix */                   
  1001. m_adj(m, todrop);
  1002. ti->ti_seq += todrop;
  1003. ti->ti_len -= todrop;
  1004. if (ti->ti_urp > todrop)
  1005. ti->ti_urp -= todrop;
  1006. else {
  1007. tiflags &= ~TH_URG;
  1008. ti->ti_urp = 0;
  1009. }
  1010. }
  1012. /*
  1013.  * If new data are received on a connection after the
  1014.  * user processes are gone, then RST the other end.
  1015.  */
  1016. if ((so->so_state & SS_NOFDREF) &&
  1017.     tp->t_state > TCPS_CLOSE_WAIT && ti->ti_len) {
  1018. tp = tcp_close(tp);
  1019. tcpstat.tcps_rcvafterclose++;
  1021. #ifdef WV_INSTRUMENTATION
  1022. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  1023.         WV_NET_PORTIN_EVENT_3 (NET_CORE_EVENT, WV_NET_INFO, 31, 13,
  1024.                                ti->ti_sport, ti->ti_dport,
  1025.                                WV_NETEVENT_TCPIN_DATACLOSED, WV_NET_RECV, 
  1026.                                so->so_fd, ti->ti_seq, ti->ti_len)
  1027. #endif  /* INCLUDE_WVNET */
  1028. #endif
  1030. goto dropwithreset;
  1031. }
  1033. /*
  1034.  * If segment ends after window, drop trailing data
  1035.  * (and PUSH and FIN); if nothing left, just ACK.
  1036.  */
  1037. todrop = (ti->ti_seq+ti->ti_len) - (tp->rcv_nxt+tp->rcv_wnd);
  1038. if (todrop > 0) {
  1039. tcpstat.tcps_rcvpackafterwin++;
  1040. if (todrop >= ti->ti_len) {
  1041. tcpstat.tcps_rcvbyteafterwin += ti->ti_len;
  1042. /*
  1043.  * If a new connection request is received
  1044.  * while in TIME_WAIT, drop the old connection
  1045.  * and start over if the sequence numbers
  1046.  * are above the previous ones.
  1047.  */
  1048. if (tiflags & TH_SYN &&
  1049.     tp->t_state == TCPS_TIME_WAIT &&
  1050.     SEQ_GT(ti->ti_seq, tp->rcv_nxt)) {
  1051. iss = tp->snd_nxt + TCP_ISSINCR;
  1052. tp = tcp_close(tp);
  1053. goto findpcb;
  1054. }
  1055. /*
  1056.  * If window is closed can only take segments at
  1057.  * window edge, and have to drop data and PUSH from
  1058.  * incoming segments.  Continue processing, but
  1059.  * remember to ack.  Otherwise, drop segment
  1060.  * and ack.
  1061.  */
  1062. if (tp->rcv_wnd == 0 && ti->ti_seq == tp->rcv_nxt) {
  1063. tp->t_flags |= TF_ACKNOW;
  1064. tcpstat.tcps_rcvwinprobe++;
  1065. } else
  1066. goto dropafterack;
  1067. } else
  1068. tcpstat.tcps_rcvbyteafterwin += todrop;
  1069. m_adj(m, -todrop);
  1070. ti->ti_len -= todrop;
  1071. tiflags &= ~(TH_PUSH|TH_FIN);
  1072. }
  1074. /*
  1075.  * If last ACK falls within this segment's sequence numbers,
  1076.  * record its timestamp.
  1077.  */
  1078. if (ts_present && TSTMP_GEQ(ts_val, tp->ts_recent) &&
  1079.             SEQ_LEQ(ti->ti_seq, tp->last_ack_sent)) {
  1080. tp->ts_recent_age = tcp_now;
  1081. tp->ts_recent = ts_val;
  1082. }
  1084. /*
  1085.  * If the RST bit is set examine the state:
  1086.  *    SYN_RECEIVED STATE:
  1087.  * If passive open, return to LISTEN state.
  1088.  * If active open, inform user that connection was refused.
  1089.  *    ESTABLISHED, FIN_WAIT_1, FIN_WAIT2, CLOSE_WAIT STATES:
  1090.  * Inform user that connection was reset, and close tcb.
  1091.  *    CLOSING, LAST_ACK, TIME_WAIT STATES
  1092.  * Close the tcb.
  1093.  */
  1094. if (tiflags&TH_RST) switch (tp->t_state) {
  1096. case TCPS_SYN_RECEIVED:
  1097. so->so_error = ECONNREFUSED;
  1098. goto close;
  1100. case TCPS_ESTABLISHED:
  1101. case TCPS_FIN_WAIT_1:
  1102. case TCPS_FIN_WAIT_2:
  1103. case TCPS_CLOSE_WAIT:
  1104. so->so_error = ECONNRESET;
  1105. close:
  1106. #ifdef WV_INSTRUMENTATION
  1107. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  1108.         WV_NET_PORTIN_EVENT_1 (NET_AUX_EVENT, WV_NET_INFO, 32, 14,
  1109.                                ti->ti_sport, ti->ti_dport,
  1110.                                WV_NETEVENT_TCPIN_RESET, WV_NET_RECV, 
  1111.                                so->so_fd)
  1112. #endif  /* INCLUDE_WVNET */
  1113. #endif
  1115. tp->t_state = TCPS_CLOSED;
  1116. tcpstat.tcps_drops++;
  1117. tp = tcp_close(tp);
  1118. goto drop;
  1120. case TCPS_CLOSING:
  1121. case TCPS_LAST_ACK:
  1122. case TCPS_TIME_WAIT:
  1123. tp = tcp_close(tp);
  1124. goto drop;
  1125. }
  1127. /*
  1128.  * If a SYN is in the window, then this is an
  1129.  * error and we send an RST and drop the connection.
  1130.  */
  1131. if (tiflags & TH_SYN) {
  1132. #ifdef WV_INSTRUMENTATION
  1133. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  1134.         WV_NET_PORTIN_EVENT_1 (NET_CORE_EVENT, WV_NET_WARNING, 12, 5,
  1135.                                ti->ti_sport, ti->ti_dport,
  1136.                                WV_NETEVENT_TCPIN_BADSYNC, WV_NET_RECV, 
  1137.                                so->so_fd)
  1138. #endif  /* INCLUDE_WVNET */
  1139. #endif
  1141. tp = tcp_drop(tp, ECONNRESET);
  1142. goto dropwithreset;
  1143. }
  1145. /*
  1146.  * If the ACK bit is off we drop the segment and return.
  1147.  */
  1148. if ((tiflags & TH_ACK) == 0)
  1149. goto drop;
  1151. /*
  1152.  * Ack processing.
  1153.  */
  1154. switch (tp->t_state) {
  1156. /*
  1157.  * In SYN_RECEIVED state if the ack ACKs our SYN then enter
  1158.  * ESTABLISHED state and continue processing, otherwise
  1159.  * send an RST.
  1160.  */
  1161. case TCPS_SYN_RECEIVED:
  1162. if (SEQ_GT(tp->snd_una, ti->ti_ack) ||
  1163.     SEQ_GT(ti->ti_ack, tp->snd_max))
  1164. goto dropwithreset;
  1166. #ifdef WV_INSTRUMENTATION
  1167. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  1168.             WV_NET_PORTIN_EVENT_3 (NET_AUX_EVENT, WV_NET_INFO, 30, 12,
  1169.                                    ti->ti_sport, ti->ti_dport,
  1170.                                    WV_NETEVENT_TCPIN_CONNECT, WV_NET_RECV, 
  1171.                                    so->so_fd, tp->snd_nxt, tp->rcv_nxt)
  1172. #endif  /* INCLUDE_WVNET */
  1173. #endif
  1175. tcpstat.tcps_connects++;
  1176. soisconnected(so);
  1177. tp->t_state = TCPS_ESTABLISHED;
  1178. /* Do window scaling? */
  1179. if ((tp->t_flags & (TF_RCVD_SCALE|TF_REQ_SCALE)) ==
  1180. (TF_RCVD_SCALE|TF_REQ_SCALE)) {
  1181. tp->snd_scale = tp->requested_s_scale;
  1182. tp->rcv_scale = tp->request_r_scale;
  1183. }
  1184. (void) tcp_reass(tp, (struct tcpiphdr *)0, (struct mbuf *)0);
  1185. tp->snd_wl1 = ti->ti_seq - 1;
  1186. /* fall into ... */
  1188. /*
  1189.  * In ESTABLISHED state: drop duplicate ACKs; ACK out of range
  1190.  * ACKs.  If the ack is in the range
  1191.  * tp->snd_una < ti->ti_ack <= tp->snd_max
  1192.  * then advance tp->snd_una to ti->ti_ack and drop
  1193.  * data from the retransmission queue.  If this ACK reflects
  1194.  * more up to date window information we update our window information.
  1195.  */
  1196. case TCPS_ESTABLISHED:
  1197. case TCPS_FIN_WAIT_1:
  1198. case TCPS_FIN_WAIT_2:
  1199. case TCPS_CLOSE_WAIT:
  1200. case TCPS_CLOSING:
  1201. case TCPS_LAST_ACK:
  1202. case TCPS_TIME_WAIT:
  1204. if (SEQ_LEQ(ti->ti_ack, tp->snd_una)) {
  1205. if (ti->ti_len == 0 && tiwin == tp->snd_wnd) {
  1206. tcpstat.tcps_rcvdupack++;
  1207. /*
  1208.  * If we have outstanding data (other than
  1209.  * a window probe), this is a completely
  1210.  * duplicate ack (ie, window info didn't
  1211.  * change), the ack is the biggest we've
  1212.  * seen and we've seen exactly our rexmt
  1213.  * threshhold of them, assume a packet
  1214.  * has been dropped and retransmit it.
  1215.  * Kludge snd_nxt & the congestion
  1216.  * window so we send only this one
  1217.  * packet.
  1218.  *
  1219.  * We know we're losing at the current
  1220.  * window size so do congestion avoidance
  1221.  * (set ssthresh to half the current window
  1222.  * and pull our congestion window back to
  1223.  * the new ssthresh).
  1224.  *
  1225.  * Dup acks mean that packets have left the
  1226.  * network (they're now cached at the receiver) 
  1227.  * so bump cwnd by the amount in the receiver
  1228.  * to keep a constant cwnd packets in the
  1229.  * network.
  1230.  */
  1231. if (tp->t_timer[TCPT_REXMT] == 0 ||
  1232.     ti->ti_ack != tp->snd_una)
  1233. tp->t_dupacks = 0;
  1234. else if (++tp->t_dupacks == tcprexmtthresh) {
  1235. tcp_seq onxt = tp->snd_nxt;
  1236. u_int win =
  1237.     min(tp->snd_wnd, tp->snd_cwnd) / 2 /
  1238. tp->t_maxseg;
  1240. if (win < 2)
  1241. win = 2;
  1242. tp->snd_ssthresh = win * tp->t_maxseg;
  1243. tp->t_timer[TCPT_REXMT] = 0;
  1244. tp->t_rtt = 0;
  1245. tp->snd_nxt = ti->ti_ack;
  1246. tp->snd_cwnd = tp->t_maxseg;
  1248. #ifdef WV_INSTRUMENTATION
  1249. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  1250.             WV_NET_PORTOUT_EVENT_2 (NET_CORE_EVENT, WV_NET_WARNING, 13, 6,
  1251.                               tp->t_inpcb->inp_lport, tp->t_inpcb->inp_fport,
  1252.                                    WV_NETEVENT_TCPIN_SENDFAIL, WV_NET_RECV, 
  1253.                                    so->so_fd, tp->t_dupacks)
  1254. #endif  /* INCLUDE_WVNET */
  1255. #endif
  1257. (void) tcp_output(tp);
  1258. tp->snd_cwnd = tp->snd_ssthresh +
  1259.        tp->t_maxseg * tp->t_dupacks;
  1260. if (SEQ_GT(onxt, tp->snd_nxt))
  1261. tp->snd_nxt = onxt;
  1262. goto drop;
  1263. } else if (tp->t_dupacks > tcprexmtthresh) {
  1264. tp->snd_cwnd += tp->t_maxseg;
  1266. #ifdef WV_INSTRUMENTATION
  1267. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  1268.             WV_NET_PORTOUT_EVENT_2 (NET_CORE_EVENT, WV_NET_WARNING, 13, 6,
  1269.                               tp->t_inpcb->inp_lport, tp->t_inpcb->inp_fport,
  1270.                                    WV_NETEVENT_TCPIN_SENDFAIL, WV_NET_RECV, 
  1271.                                    so->so_fd, tp->t_dupacks)
  1272. #endif  /* INCLUDE_WVNET */
  1273. #endif
  1275. (void) tcp_output(tp);
  1276. goto drop;
  1277. }
  1278. } else
  1279. tp->t_dupacks = 0;
  1280. break;
  1281. }
  1282. /*
  1283.  * If the congestion window was inflated to account
  1284.  * for the other side's cached packets, retract it.
  1285.  */
  1286. if (tp->t_dupacks > tcprexmtthresh &&
  1287.     tp->snd_cwnd > tp->snd_ssthresh)
  1288. tp->snd_cwnd = tp->snd_ssthresh;
  1289. tp->t_dupacks = 0;
  1290. if (SEQ_GT(ti->ti_ack, tp->snd_max)) {
  1291. tcpstat.tcps_rcvacktoomuch++;
  1292. goto dropafterack;
  1293. }
  1294. acked = ti->ti_ack - tp->snd_una;
  1295. tcpstat.tcps_rcvackpack++;
  1296. tcpstat.tcps_rcvackbyte += acked;
  1298. /*
  1299.  * If we have a timestamp reply, update smoothed
  1300.  * round trip time.  If no timestamp is present but
  1301.  * transmit timer is running and timed sequence
  1302.  * number was acked, update smoothed round trip time.
  1303.  * Since we now have an rtt measurement, cancel the
  1304.  * timer backoff (cf., Phil Karn's retransmit alg.).
  1305.  * Recompute the initial retransmit timer.
  1306.  */
  1307. if (ts_present)
  1308. tcp_xmit_timer(tp, tcp_now-ts_ecr+1);
  1309. else if (tp->t_rtt && SEQ_GT(ti->ti_ack, tp->t_rtseq))
  1310. tcp_xmit_timer(tp,tp->t_rtt);
  1312. /*
  1313.  * If all outstanding data is acked, stop retransmit
  1314.  * timer and remember to restart (more output or persist).
  1315.  * If there is more data to be acked, restart retransmit
  1316.  * timer, using current (possibly backed-off) value.
  1317.  */
  1318. if (ti->ti_ack == tp->snd_max) {
  1319. tp->t_timer[TCPT_REXMT] = 0;
  1320. needoutput = 1;
  1321. } else if (tp->t_timer[TCPT_PERSIST] == 0)
  1322. tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
  1323. /*
  1324.  * When new data is acked, open the congestion window.
  1325.  * If the window gives us less than ssthresh packets
  1326.  * in flight, open exponentially (maxseg per packet).
  1327.  * Otherwise open linearly: maxseg per window
  1328.  * (maxseg * (maxseg / cwnd) per packet).
  1329.  */
  1330. {
  1331. register u_int cw = tp->snd_cwnd;
  1332. register u_int incr = tp->t_maxseg;
  1334. if (cw > tp->snd_ssthresh)
  1335. incr = incr * incr / cw;
  1336. tp->snd_cwnd = min(cw + incr, TCP_MAXWIN<<tp->snd_scale);
  1337. }
  1338. if (acked > so->so_snd.sb_cc) {
  1339. tp->snd_wnd -= so->so_snd.sb_cc;
  1340. sbdrop(&so->so_snd, (int)so->so_snd.sb_cc);
  1341. ourfinisacked = 1;
  1342. } else {
  1343. sbdrop(&so->so_snd, acked);
  1344. tp->snd_wnd -= acked;
  1345. ourfinisacked = 0;
  1346. }
  1347. if ((so->so_snd.sb_want > 0) || (so->so_snd.sb_sel) ||
  1348.     (sowakeupHook != NULL))
  1349.     {
  1350.     if (sbspace (&so->so_snd) >= so->so_snd.sb_lowat)
  1351. sowwakeup(so);
  1352.                     }
  1354. tp->snd_una = ti->ti_ack;
  1355. if (SEQ_LT(tp->snd_nxt, tp->snd_una))
  1356. tp->snd_nxt = tp->snd_una;
  1358. switch (tp->t_state) {
  1360. /*
  1361.  * In FIN_WAIT_1 STATE in addition to the processing
  1362.  * for the ESTABLISHED state if our FIN is now acknowledged
  1363.  * then enter FIN_WAIT_2.
  1364.  */
  1365. case TCPS_FIN_WAIT_1:
  1366. if (ourfinisacked) {
  1367. /*
  1368.  * If we can't receive any more
  1369.  * data, then closing user can proceed.
  1370.  * Starting the timer is contrary to the
  1371.  * specification, but if we don't get a FIN
  1372.  * we'll hang forever.
  1373.  */
  1374. if (so->so_state & SS_CANTRCVMORE) {
  1375. soisdisconnected(so);
  1376. tp->t_timer[TCPT_2MSL] = tcp_maxidle;
  1377. }
  1379. #ifdef WV_INSTRUMENTATION
  1380. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  1381.             WV_NET_PORTIN_EVENT_1 (NET_AUX_EVENT, WV_NET_INFO, 33, 15,
  1382.                                    ti->ti_sport, ti->ti_dport,
  1383.                                    WV_NETEVENT_TCPIN_SENDCLOSED, WV_NET_RECV, 
  1384.                                    so->so_fd)
  1385. #endif  /* INCLUDE_WVNET */
  1386. #endif
  1388. tp->t_state = TCPS_FIN_WAIT_2;
  1389. }
  1390. break;
  1392.   /*
  1393.  * In CLOSING STATE in addition to the processing for
  1394.  * the ESTABLISHED state if the ACK acknowledges our FIN
  1395.  * then enter the TIME-WAIT state, otherwise ignore
  1396.  * the segment.
  1397.  */
  1398. case TCPS_CLOSING:
  1399. if (ourfinisacked) {
  1400. #ifdef WV_INSTRUMENTATION
  1401. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  1402.             WV_NET_PORTIN_EVENT_1 (NET_AUX_EVENT, WV_NET_INFO, 34, 16,
  1403.                                    ti->ti_sport, ti->ti_dport,
  1404.                                    WV_NETEVENT_TCPIN_CLOSEWAIT, WV_NET_RECV, 
  1405.                                    so->so_fd)
  1406. #endif  /* INCLUDE_WVNET */
  1407. #endif
  1409. tp->t_state = TCPS_TIME_WAIT;
  1410. tcp_canceltimers(tp);
  1411. tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
  1412. soisdisconnected(so);
  1413. }
  1414. break;
  1416. /*
  1417.  * In LAST_ACK, we may still be waiting for data to drain
  1418.  * and/or to be acked, as well as for the ack of our FIN.
  1419.  * If our FIN is now acknowledged, delete the TCB,
  1420.  * enter the closed state and return.
  1421.  */
  1422. case TCPS_LAST_ACK:
  1423. if (ourfinisacked) {
  1424. tp = tcp_close(tp);
  1425. goto drop;
  1426. }
  1427. break;
  1429. /*
  1430.  * In TIME_WAIT state the only thing that should arrive
  1431.  * is a retransmission of the remote FIN.  Acknowledge
  1432.  * it and restart the finack timer.
  1433.  */
  1434. case TCPS_TIME_WAIT:
  1435. #ifdef WV_INSTRUMENTATION
  1436. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  1437.         WV_NET_PORTIN_EVENT_2 (NET_AUX_EVENT, WV_NET_INFO, 37, 19,
  1438.                                ti->ti_sport, ti->ti_dport,
  1439.                                WV_NETEVENT_TCPIN_CLOSE_RESTART, WV_NET_RECV,
  1440.                                so->so_fd, TRUE)
  1441. #endif  /* INCLUDE_WVNET */
  1442. #endif
  1444. tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
  1445. goto dropafterack;
  1446. }
  1447. }
  1449. step6:
  1450. /*
  1451.  * Update window information.
  1452.  * Don't look at window if no ACK: TAC's send garbage on first SYN.
  1453.          *
  1454.          * More specifically, update the window when:
  1455.          *  1) The ACK flag is set, and either:
  1456.          *      a) The segment contains new data (snd_wl1 < ti_seq) OR
  1457.          *      b) The segment is a repeat (snd_wl1 == ti_seq).
  1458.          *
  1459.          *  2) In case 1b), one of the following conditions also applies:
  1460.          *      a) The segment acknowledges more data (snd_wl2 < ti_ack) OR
  1461.          *      b) No new data is acknowledged, but the window size increases.
  1462.          *
  1463.          * The wl2 == ti_ack test might be redundant since the received
  1464.          * ACK value can't realistically decrease when snd_wl1 == ti_seq.
  1465.  */
  1467. if ( (tiflags & TH_ACK) &&
  1468.     (SEQ_LT(tp->snd_wl1, ti->ti_seq) ||
  1469.                (tp->snd_wl1 == ti->ti_seq &&
  1470.           (SEQ_LT(tp->snd_wl2, ti->ti_ack) ||
  1471.                   (tp->snd_wl2 == ti->ti_ack && tiwin > tp->snd_wnd))
  1472.                )
  1473.             ))
  1474.             {
  1475. /* keep track of pure window updates */
  1476. if (ti->ti_len == 0 &&
  1477.     tp->snd_wl2 == ti->ti_ack && tiwin > tp->snd_wnd)
  1478. tcpstat.tcps_rcvwinupd++;
  1479. tp->snd_wnd = tiwin;
  1480. tp->snd_wl1 = ti->ti_seq;
  1481. tp->snd_wl2 = ti->ti_ack;
  1482. if (tp->snd_wnd > tp->max_sndwnd)
  1483. tp->max_sndwnd = tp->snd_wnd;
  1484. needoutput = 1;
  1485. }
  1487. /*
  1488.  * Process segments with URG.
  1489.  */
  1490. if ((tiflags & TH_URG) && ti->ti_urp &&
  1491.     TCPS_HAVERCVDFIN(tp->t_state) == 0) {
  1492. /*
  1493.  * This is a kludge, but if we receive and accept
  1494.  * random urgent pointers, we'll crash in
  1495.  * soreceive.  It's hard to imagine someone
  1496.  * actually wanting to send this much urgent data.
  1497.  */
  1498. if (ti->ti_urp + so->so_rcv.sb_cc > sb_max) {
  1499. ti->ti_urp = 0; /* XXX */
  1500. tiflags &= ~TH_URG; /* XXX */
  1501. goto dodata; /* XXX */
  1502. }
  1503. /*
  1504.  * If this segment advances the known urgent pointer,
  1505.  * then mark the data stream.  This should not happen
  1506.  * in CLOSE_WAIT, CLOSING, LAST_ACK or TIME_WAIT STATES since
  1507.  * a FIN has been received from the remote side. 
  1508.  * In these states we ignore the URG.
  1509.  *
  1510.  * According to RFC961 (Assigned Protocols),
  1511.  * the urgent pointer points to the last octet
  1512.  * of urgent data.  We continue, however,
  1513.  * to consider it to indicate the first octet
  1514.  * of data past the urgent section as the original 
  1515.  * spec states (in one of two places).
  1516.  */
  1517. if (SEQ_GT(ti->ti_seq+ti->ti_urp, tp->rcv_up)) {
  1518. tp->rcv_up = ti->ti_seq + ti->ti_urp;
  1519. so->so_oobmark = so->so_rcv.sb_cc +
  1520.     (tp->rcv_up - tp->rcv_nxt) - 1;
  1521. if (so->so_oobmark == 0)
  1522. so->so_state |= SS_RCVATMARK;
  1523. sohasoutofband(so);
  1524. tp->t_oobflags &= ~(TCPOOB_HAVEDATA | TCPOOB_HADDATA);
  1525. }
  1526. /*
  1527.  * Remove out of band data so doesn't get presented to user.
  1528.  * This can happen independent of advancing the URG pointer,
  1529.  * but if two URG's are pending at once, some out-of-band
  1530.  * data may creep in... ick.
  1531.  */
  1532. if (ti->ti_urp <= ti->ti_len &&
  1533.      (so->so_options & SO_OOBINLINE) == 0)
  1534. tcp_pulloutofband(so, ti, m);
  1535. } else
  1536. /*
  1537.  * If no out of band data is expected,
  1538.  * pull receive urgent pointer along
  1539.  * with the receive window.
  1540.  */
  1541. if (SEQ_GT(tp->rcv_nxt, tp->rcv_up))
  1542. tp->rcv_up = tp->rcv_nxt;
  1543. dodata: /* XXX */
  1545. /*
  1546.  * Process the segment text, merging it into the TCP sequencing queue,
  1547.  * and arranging for acknowledgment of receipt if necessary.
  1548.  * This process logically involves adjusting tp->rcv_wnd as data
  1549.  * is presented to the user (this happens in tcp_usrreq.c,
  1550.  * case PRU_RCVD).  If a FIN has already been received on this
  1551.  * connection then we just ignore the text.
  1552.  */
  1553. if ((ti->ti_len || (tiflags&TH_FIN)) &&
  1554.     TCPS_HAVERCVDFIN(tp->t_state) == 0) {
  1555. TCP_REASS(tp, ti, m, so, tiflags);
  1556. } else {
  1557. m_freem(m);
  1558. tiflags &= ~TH_FIN;
  1559. }
  1561. /*
  1562.  * If FIN is received ACK the FIN and let the user know
  1563.  * that the connection is closing.
  1564.  */
  1565. if (tiflags & TH_FIN) {
  1566. if (TCPS_HAVERCVDFIN(tp->t_state) == 0) {
  1567. socantrcvmore(so);
  1568. tp->t_flags |= TF_ACKNOW;
  1569. tp->rcv_nxt++;
  1570. }
  1571. switch (tp->t_state) {
  1573.   /*
  1574.  * In ESTABLISHED state
  1575.  * enter the CLOSE_WAIT state.
  1576.  */
  1577. case TCPS_SYN_RECEIVED:
  1578.                     break;          /* avoid SYN+FIN death */
  1579. case TCPS_ESTABLISHED:
  1581. #ifdef WV_INSTRUMENTATION
  1582. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  1583.         WV_NET_PORTIN_EVENT_1 (NET_AUX_EVENT, WV_NET_INFO, 35, 17,
  1584.                                ti->ti_sport, ti->ti_dport,
  1585.                                WV_NETEVENT_TCPIN_RECVCLOSED, WV_NET_RECV,
  1586.                                so->so_fd)
  1587. #endif  /* INCLUDE_WVNET */
  1588. #endif
  1590. tp->t_state = TCPS_CLOSE_WAIT;
  1591. break;
  1593.   /*
  1594.  * If still in FIN_WAIT_1 STATE FIN has not been acked so
  1595.  * enter the CLOSING state.
  1596.  */
  1597. case TCPS_FIN_WAIT_1:
  1598. #ifdef WV_INSTRUMENTATION
  1599. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  1600.             WV_NET_PORTIN_EVENT_1 (NET_AUX_EVENT, WV_NET_INFO, 36, 18,
  1601.                                    ti->ti_sport, ti->ti_dport,
  1602.                                    WV_NETEVENT_TCPIN_CLOSING, WV_NET_RECV,
  1603.                                    so->so_fd)
  1604. #endif  /* INCLUDE_WVNET */
  1605. #endif
  1607. tp->t_state = TCPS_CLOSING;
  1608. break;
  1610.   /*
  1611.  * In FIN_WAIT_2 state enter the TIME_WAIT state,
  1612.  * starting the time-wait timer, turning off the other 
  1613.  * standard timers.
  1614.  */
  1615. case TCPS_FIN_WAIT_2:
  1616. #ifdef WV_INSTRUMENTATION
  1617. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  1618.             WV_NET_PORTIN_EVENT_1 (NET_AUX_EVENT, WV_NET_INFO, 34, 16,
  1619.                                    ti->ti_sport, ti->ti_dport,
  1620.                                    WV_NETEVENT_TCPIN_CLOSEWAIT, WV_NET_RECV,
  1621.                                    so->so_fd)
  1622. #endif  /* INCLUDE_WVNET */
  1623. #endif
  1625. tp->t_state = TCPS_TIME_WAIT;
  1626. tcp_canceltimers(tp);
  1627. tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
  1628. soisdisconnected(so);
  1629. break;
  1631. /*
  1632.  * In TIME_WAIT state restart the 2 MSL time_wait timer.
  1633.  */
  1634. case TCPS_TIME_WAIT:
  1635. #ifdef WV_INSTRUMENTATION
  1636. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  1637.         WV_NET_PORTIN_EVENT_2 (NET_AUX_EVENT, WV_NET_INFO, 37, 19,
  1638.                                ti->ti_sport, ti->ti_dport,
  1639.                                WV_NETEVENT_TCPIN_CLOSE_RESTART, WV_NET_RECV,
  1640.                                so->so_fd, FALSE)
  1641. #endif  /* INCLUDE_WVNET */
  1642. #endif
  1644. tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
  1645. break;
  1646. }
  1647. }
  1648. if (so->so_options & SO_DEBUG)
  1649. (*tcpTraceRtn)(TA_INPUT, ostate, tp, &tcp_saveti, 0);
  1651. /*
  1652.  * Return any desired output.
  1653.  */
  1654. if (needoutput || (tp->t_flags & TF_ACKNOW))
  1655. (void) tcp_output(tp);
  1656. return;
  1658. dropafterack:
  1659. /*
  1660.  * Generate an ACK dropping incoming segment if it occupies
  1661.  * sequence space, where the ACK reflects our state.
  1662.  */
  1663. if (tiflags & TH_RST)
  1664. goto drop;
  1665. m_freem(m);
  1666. tp->t_flags |= TF_ACKNOW;
  1667. (void) tcp_output(tp);
  1668. return;
  1670. dropwithreset:
  1671. /*
  1672.  * Generate a RST, dropping incoming segment.
  1673.  * Make ACK acceptable to originator of segment.
  1674.  * Don't bother to respond if destination was broadcast/multicast.
  1675.  */
  1676. if ((tiflags & TH_RST) || m->m_flags & (M_BCAST|M_MCAST) ||
  1677.     IN_MULTICAST(ntohl(ti->ti_dst.s_addr)))
  1678. goto drop;
  1679. if (tiflags & TH_ACK)
  1680. tcp_respond(tp, ti, m, (tcp_seq)0, ti->ti_ack, TH_RST);
  1681. else {
  1682. if (tiflags & TH_SYN)
  1683. ti->ti_len++;
  1684. tcp_respond(tp, ti, m, ti->ti_seq+ti->ti_len, (tcp_seq)0,
  1685.     TH_RST|TH_ACK);
  1686. }
  1688.         /* MIB-II Count # of Resets Sent */
  1690. #ifdef VIRTUAL_STACK
  1691.          /* 
  1692.           * (Former) tcpOutRsts global renamed for virtual stacks to prevent
  1693.           * name conflict with existing structure element in m2TcpLib.c file.
  1694.           */
  1696.          tcpOutResets++;
  1697. #else
  1698.          tcpOutRsts++;
  1699. #endif
  1701. /* destroy temporarily created socket */
  1702. if (dropsocket)
  1703. (void) soabort(so);
  1704. return;
  1706. drop:
  1707. /*
  1708.  * Drop space held by incoming segment and return.
  1709.  */
  1710. if (tp && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))
  1711. (*tcpTraceRtn)(TA_DROP, ostate, tp, &tcp_saveti, 0);
  1712. m_freem(m);
  1713. /* destroy temporarily created socket */
  1714. if (dropsocket)
  1715. (void) soabort(so);
  1716. return;
  1717. }
  1719. void
  1720. tcp_dooptions(tp, cp, cnt, ti, ts_present, ts_val, ts_ecr)
  1721. struct tcpcb *tp;
  1722. u_char *cp;
  1723. int cnt;
  1724. struct tcpiphdr *ti;
  1725. int *ts_present;
  1726. u_long *ts_val, *ts_ecr;
  1727. {
  1728. u_short mss = 0;
  1729. int opt, optlen;
  1731. for (; cnt > 0; cnt -= optlen, cp += optlen) {
  1732. opt = cp[0];
  1733. if (opt == TCPOPT_EOL)
  1734. break;
  1735. if (opt == TCPOPT_NOP)
  1736. optlen = 1;
  1737. else {
  1738. optlen = cp[1];
  1739. if (optlen <= 0)
  1740. break;
  1741. }
  1742. switch (opt) {
  1744. default:
  1745. continue;
  1747. case TCPOPT_MAXSEG:
  1748. if (optlen != TCPOLEN_MAXSEG)
  1749. continue;
  1750. if (!(ti->ti_flags & TH_SYN))
  1751. continue;
  1752. bcopy((char *) cp + 2, (char *) &mss, sizeof(mss));
  1753. NTOHS(mss);
  1754. (void) tcp_mss(tp, mss); /* sets t_maxseg */
  1755. break;
  1757. case TCPOPT_WINDOW:
  1758. if (optlen != TCPOLEN_WINDOW)
  1759. continue;
  1760. if (!(ti->ti_flags & TH_SYN))
  1761. continue;
  1762. tp->t_flags |= TF_RCVD_SCALE;
  1763. tp->requested_s_scale = min(cp[2], TCP_MAX_WINSHIFT);
  1764. break;
  1766. case TCPOPT_TIMESTAMP:
  1767. if (optlen != TCPOLEN_TIMESTAMP)
  1768. continue;
  1769. *ts_present = 1;
  1770. bcopy((char *)cp + 2, (char *) ts_val, sizeof(*ts_val));
  1771. NTOHL(*ts_val);
  1772. bcopy((char *)cp + 6, (char *) ts_ecr, sizeof(*ts_ecr));
  1773. NTOHL(*ts_ecr);
  1775. /* 
  1776.  * A timestamp received in a SYN makes
  1777.  * it ok to send timestamp requests and replies.
  1778.  */
  1779. if (ti->ti_flags & TH_SYN) {
  1780. tp->t_flags |= TF_RCVD_TSTMP;
  1781. tp->ts_recent = *ts_val;
  1782. tp->ts_recent_age = tcp_now;
  1783. }
  1784. break;
  1785. }
  1786. }
  1788.         /*
  1789.          * Set peer's MSS to default if option not included. The path MTU
  1790.          * discovery processing for TCP uses this value as a ceiling to
  1791.          * avoid sending larger segments than a peer can handle.
  1792.          */
  1794.         if ( (ti->ti_flags & TH_SYN) && !mss)
  1795.             {
  1796.             if (tp->t_inpcb->inp_route.ro_rt)
  1797.                 (tp->t_inpcb->inp_route.ro_rt)->rt_rmx.rmx_mss = tcp_mssdflt;
  1798.             }
  1799. }
  1801. /*
  1802.  * Pull out of band byte out of a segment so
  1803.  * it doesn't appear in the user's data queue.
  1804.  * It is still reflected in the segment length for
  1805.  * sequencing purposes.
  1806.  */
  1807. void
  1808. tcp_pulloutofband(so, ti, m)
  1809. struct socket *so;
  1810. struct tcpiphdr *ti;
  1811. register struct mbuf *m;
  1812. {
  1813. int cnt = ti->ti_urp - 1;
  1815. while (cnt >= 0) {
  1816. if (m->m_len > cnt) {
  1817. char *cp = mtod(m, caddr_t) + cnt;
  1818. struct tcpcb *tp = sototcpcb(so);
  1820. tp->t_iobc = *cp;
  1821. tp->t_oobflags |= TCPOOB_HAVEDATA;
  1822. bcopy(cp+1, cp, (unsigned)(m->m_len - cnt - 1));
  1823. m->m_len--;
  1824. return;
  1825. }
  1826. cnt -= m->m_len;
  1827. m = m->m_next;
  1828. if (m == 0)
  1829. break;
  1830. }
  1831. #ifdef WV_INSTRUMENTATION
  1832. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  1833.         WV_NET_PORTIN_EVENT_1 (NET_CORE_EVENT, WV_NET_EMERGENCY, 27, 1,
  1834.                                ti->ti_sport, ti->ti_dport,
  1835.                                WV_NETEVENT_TCPOOB_PANIC, WV_NET_RECV,
  1836.                                so->so_fd)
  1837. #endif  /* INCLUDE_WVNET */
  1838. #endif
  1840. panic("tcp_pulloutofband");
  1841. }
  1843. /*
  1844.  * Collect new round-trip time estimate
  1845.  * and update averages and current timeout.
  1846.  */
  1847. void
  1848. tcp_xmit_timer(tp, rtt)
  1849. register struct tcpcb *tp;
  1850. short rtt;
  1851. {
  1852. register short delta;
  1854. tcpstat.tcps_rttupdated++;
  1855. if (tp->t_srtt != 0) {
  1856. /*
  1857.  * srtt is stored as fixed point with 3 bits after the
  1858.  * binary point (i.e., scaled by 8).  The following magic
  1859.  * is equivalent to the smoothing algorithm in rfc793 with
  1860.  * an alpha of .875 (srtt = rtt/8 + srtt*7/8 in fixed
  1861.  * point).  Adjust rtt to origin 0.
  1862.  */
  1863. delta = rtt - 1 - (tp->t_srtt >> TCP_RTT_SHIFT);
  1864. if ((tp->t_srtt += delta) <= 0)
  1865. tp->t_srtt = 1;
  1866. /*
  1867.  * We accumulate a smoothed rtt variance (actually, a
  1868.  * smoothed mean difference), then set the retransmit
  1869.  * timer to smoothed rtt + 4 times the smoothed variance.
  1870.  * rttvar is stored as fixed point with 2 bits after the
  1871.  * binary point (scaled by 4).  The following is
  1872.  * equivalent to rfc793 smoothing with an alpha of .75
  1873.  * (rttvar = rttvar*3/4 + |delta| / 4).  This replaces
  1874.  * rfc793's wired-in beta.
  1875.  */
  1876. if (delta < 0)
  1877. delta = -delta;
  1878. delta -= (tp->t_rttvar >> TCP_RTTVAR_SHIFT);
  1879. if ((tp->t_rttvar += delta) <= 0)
  1880. tp->t_rttvar = 1;
  1881. } else {
  1882. /* 
  1883.  * No rtt measurement yet - use the unsmoothed rtt.
  1884.  * Set the variance to half the rtt (so our first
  1885.  * retransmit happens at 3*rtt).
  1886.  */
  1887. tp->t_srtt = rtt << TCP_RTT_SHIFT;
  1888. tp->t_rttvar = rtt << (TCP_RTTVAR_SHIFT - 1);
  1889. }
  1890. tp->t_rtt = 0;
  1891. tp->t_rxtshift = 0;
  1893. /*
  1894.  * the retransmit should happen at rtt + 4 * rttvar.
  1895.  * Because of the way we do the smoothing, srtt and rttvar
  1896.  * will each average +1/2 tick of bias.  When we compute
  1897.  * the retransmit timer, we want 1/2 tick of rounding and
  1898.  * 1 extra tick because of +-1/2 tick uncertainty in the
  1899.  * firing of the timer.  The bias will give us exactly the
  1900.  * 1.5 tick we need.  But, because the bias is
  1901.  * statistical, we have to test that we don't drop below
  1902.  * the minimum feasible timer (which is 2 ticks).
  1903.  */
  1904. TCPT_RANGESET(tp->t_rxtcur, TCP_REXMTVAL(tp),
  1905.     tp->t_rttmin, TCPTV_REXMTMAX);
  1907. /*
  1908.  * We received an ack for a packet that wasn't retransmitted;
  1909.  * it is probably safe to discard any error indications we've
  1910.  * received recently.  This isn't quite right, but close enough
  1911.  * for now (a route might have failed after we sent a segment,
  1912.  * and the return path might not be symmetrical).
  1913.  */
  1914. tp->t_softerror = 0;
  1915. }
  1917. /*
  1918.  * Determine a reasonable value for maxseg size.
  1919.  * If the route is known, check route for mtu.
  1920.  * If none, use an mss that can be handled on the outgoing
  1921.  * interface without forcing IP to fragment;
  1922.  * If no route is found, route has no mtu,
  1923.  * or the destination isn't local, use a default, hopefully conservative
  1924.  * size (usually 512 or the default IP max size, but no more than the mtu
  1925.  * of the interface), as we can't discover anything about intervening
  1926.  * gateways or networks.  We also initialize the congestion/slow start
  1927.  * window to be a single segment if the destination isn't local.
  1928.  * While looking at the routing entry, we also initialize other path-dependent
  1929.  * parameters from pre-set or cached values in the routing entry.
  1930.  */
  1931. int
  1932. tcp_mss(tp, offer)
  1933. register struct tcpcb *tp;
  1934. u_int offer;
  1935. {
  1936. struct route *ro;
  1937. register struct rtentry *rt;
  1938. struct ifnet *ifp;
  1939. register int rtt, mss;
  1940. u_long bufsize;
  1941. struct inpcb *inp;
  1942. struct socket *so;
  1944. inp = tp->t_inpcb;
  1945. ro = &inp->inp_route;
  1947. if ((rt = ro->ro_rt) == (struct rtentry *)0) {
  1948. /* No route yet, so try to acquire one */
  1949. if (inp->inp_faddr.s_addr != INADDR_ANY) {
  1950. ro->ro_dst.sa_family = AF_INET;
  1951. ro->ro_dst.sa_len = sizeof(ro->ro_dst);
  1952. ((struct sockaddr_in *) &ro->ro_dst)->sin_addr =
  1953. inp->inp_faddr;
  1954. TOS_SET (&ro->ro_dst, inp->inp_ip.ip_tos);
  1955. rtalloc(ro);
  1956. }
  1957. if ((rt = ro->ro_rt) == (struct rtentry *)0)
  1958. return (tcp_mssdflt);
  1959. }
  1961. ifp = rt->rt_ifp;
  1962. so = inp->inp_socket;
  1964. /*
  1965.  * While we're here, check if there's an initial rtt
  1966.  * or rttvar.  Convert from the route-table units
  1967.  * to scaled multiples of the slow timeout timer.
  1968.  */
  1969. if (tp->t_srtt == 0 && (rtt = rt->rt_rmx.rmx_rtt)) {
  1970. /*
  1971.  * XXX the lock bit for MTU indicates that the value
  1972.  * is also a minimum value; this is subject to time.
  1973.  */
  1974. if (rt->rt_rmx.rmx_locks & RTV_RTT)
  1975. tp->t_rttmin = rtt / (RTM_RTTUNIT / PR_SLOWHZ);
  1976. tp->t_srtt = rtt / (RTM_RTTUNIT / (PR_SLOWHZ * TCP_RTT_SCALE));
  1977. if (rt->rt_rmx.rmx_rttvar)
  1978. tp->t_rttvar = rt->rt_rmx.rmx_rttvar /
  1979.     (RTM_RTTUNIT / (PR_SLOWHZ * TCP_RTTVAR_SCALE));
  1980. else
  1981. /* default variation is +- 1 rtt */
  1982. tp->t_rttvar =
  1983.     tp->t_srtt * TCP_RTTVAR_SCALE / TCP_RTT_SCALE;
  1984. TCPT_RANGESET(tp->t_rxtcur,
  1985.     ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1,
  1986.     tp->t_rttmin, TCPTV_REXMTMAX);
  1987. }
  1988. /*
  1989.  * if there's an mtu associated with the route, use it
  1990.  */
  1991. if (rt->rt_rmx.rmx_mtu)
  1992. mss = rt->rt_rmx.rmx_mtu - sizeof(struct tcpiphdr);
  1993. else
  1994. {
  1995. mss = ifp->if_mtu - sizeof(struct tcpiphdr);
  1996. if (!in_localaddr(inp->inp_faddr))
  1997. mss = min(mss, tcp_mssdflt);
  1998. }
  1999. /*
  2000.  * The current mss, t_maxseg, is initialized to the default value.
  2001.  * If we compute a smaller value, reduce the current mss.
  2002.  * If we compute a larger value, return it for use in sending
  2003.  * a max seg size option, but don't store it for use
  2004.  * unless we received an offer at least that large from peer.
  2005.  * However, do not accept offers under 32 bytes.
  2006.  */
  2007. if (offer)
  2008.             {
  2009.             rt->rt_rmx.rmx_mss = offer;    /* Save peer's MSS for path MTU. */
  2011. mss = min(mss, offer);
  2012.             }
  2014. mss = max(mss, 32); /* sanity */
  2016.         /*
  2017.          * Save the maximum allowable segment size (based on mss and mtu
  2018.          * values only) when processing MSS option from peer.
  2019.          */
  2021.         if (offer)
  2022.             tp->t_maxsize = mss;
  2024. if (mss < tp->t_maxseg || offer != 0) {
  2025. /*
  2026.  * If there's a pipesize, change the socket buffer
  2027.  * to that size.  Make the socket buffers an integral
  2028.  * number of mss units; if the mss is larger than
  2029.  * the socket buffer, decrease the mss.
  2030.  */
  2031. if ((bufsize = rt->rt_rmx.rmx_sendpipe) == 0)
  2032. bufsize = so->so_snd.sb_hiwat;
  2033. if (bufsize < mss)
  2034. mss = bufsize;
  2036.                 /*
  2037.                  * Record maximum segment size after adjusting
  2038.                  * for the send buffer size.
  2039.                  */
  2041. tp->t_maxseg = mss;
  2043. if ((bufsize = rt->rt_rmx.rmx_recvpipe) == 0)
  2044. bufsize = so->so_rcv.sb_hiwat;
  2045. }
  2046. tp->snd_cwnd = mss;
  2048. if (rt->rt_rmx.rmx_ssthresh) {
  2049. /*
  2050.  * There's some sort of gateway or interface
  2051.  * buffer limit on the path.  Use this to set
  2052.  * the slow start threshhold, but set the
  2053.  * threshold to no less than 2*mss.
  2054.  */
  2055. tp->snd_ssthresh = max(2 * mss, rt->rt_rmx.rmx_ssthresh);
  2056. }
  2057. return (mss);
  2058. }
  2060. #ifdef TCP_DEBUG /* XXX just for debugging */
  2061. void tcbShow
  2062.     (
  2063.     FAST struct inpcb *pinPcb /* pointer to the pcb control block */
  2064.     )
  2065.     {
  2066.     struct tcpcb * pTcpCb; /* pointer to tcp Control block */
  2068.     pTcpCb = (struct tcpcb *) pinPcb->inp_ppcb;
  2070.     printf ("send unacknowledged: %8un", pTcpCb->snd_una); 
  2071.     printf ("send next: %8un", pTcpCb->snd_nxt); 
  2072.     printf ("send window update seg seqnumber: %8un", pTcpCb->snd_wl1);
  2073.     printf ("send window updata seg ack number: %8un", pTcpCb->snd_wl2); 
  2074.     printf ("send window: %8un", pTcpCb->snd_wnd); 
  2075.     printf ("recv window: %8un", pTcpCb->rcv_wnd);
  2076.     printf ("recv next: %8un", pTcpCb->rcv_nxt);
  2077.     printf ("recv advertised window by other end: %8un", pTcpCb->rcv_adv);
  2078.     printf ("send highest sequence number sent: %8un", pTcpCb->snd_max);
  2079.     printf ("congestion controlled window: %8un", pTcpCb->snd_cwnd);
  2080.     printf ("congestion threshold: %8un", pTcpCb->snd_ssthresh);
  2081.     printf ("largest window peer has offered: %8un", pTcpCb->max_sndwnd);
  2082.     printf ("send scale %8un", pTcpCb->snd_scale) ;
  2083.     printf ("recv scale %8un", pTcpCb->rcv_scale) ;
  2084.     printf ("send pending window scale %8un", pTcpCb->request_r_scale) ;
  2085.     printf ("recv pending window scale %8un", pTcpCb->requested_s_scale) ;
  2086.     
  2087.     }
  2088. #endif /* XXX just for debugging */