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

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

VxWorks

开发平台：

C/C++

tcp_subr.c：源码内容
  1. /* tcp_subr.c - TCP routines */
  3. /* Copyright 1984 - 2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1982, 1986, 1988, 1990, 1993, 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_subr.c 8.2 (Berkeley) 5/24/95
  39.  */
  41. /*
  42. modification history
  43. --------------------
  44. 01e,18apr02,vvv  trigger slow-start in response to ICMP fragmentation-needed
  45.  message (SPR #75058)
  46. 01d,12oct01,rae  merge from truestack ver 01o, base 01c (SPRs 70049,
  47.                  70330, 34005, 31244, etc)
  48. 01c,31mar97,vin  modified for hash look ups for pcbs(FREEBSD 2.2.1).
  49. 01b,30oct96,vin  changed tcp_template to return mbuf * instead of tcpiphdr.
  50.  changed m_free(dtom(...)) to m_free(tp->t_template).
  51. 01a,03mar96,vin  created from BSD4.4 stuff,integrated with 02i.
  52. */
  54. /*
  55. DESCRIPTION
  56. */
  58. #include "vxWorks.h"
  59. #include "net/systm.h"
  60. #include "net/mbuf.h"
  61. #include "sys/socket.h"
  62. #include "net/socketvar.h"
  63. #include "net/protosw.h"
  64. #include "errno.h"
  66. #include "net/route.h"
  67. #include "net/if.h"
  69. #include "netinet/in.h"
  70. #include "netinet/in_pcb.h"
  71. #include "netinet/in_systm.h"
  72. #include "netinet/ip.h"
  73. #include "netinet/ip_var.h"
  74. #include "netinet/ip_icmp.h"
  75. #include "netinet/tcp.h"
  76. #include "netinet/tcp_fsm.h"
  77. #include "netinet/tcp_seq.h"
  78. #include "netinet/tcp_timer.h"
  79. #include "netinet/tcp_var.h"
  80. #include "netinet/tcpip.h"
  82. #ifdef WV_INSTRUMENTATION
  83. #ifdef INCLUDE_WVNET
  84. #include "wvNetLib.h"
  85. #endif
  86. #endif
  88. #ifdef VIRTUAL_STACK
  89. #include "netinet/vsLib.h"
  90. #else
  92. /*
  93.  * Target size of TCP PCB hash table. Will be rounded down to a prime
  94.  * number.
  95.  */
  96. #ifndef TCBHASHSIZE
  97. #define TCBHASHSIZE     128
  98. #endif
  100. /* patchable/settable parameters for tcp */
  101. int  tcp_mssdflt = TCP_MSS;
  102. int  tcp_rttdflt = TCPTV_SRTTDFLT / PR_SLOWHZ;
  103. int tcp_do_rfc1323 = 1;
  104. u_short tcp_pcbhashsize = TCBHASHSIZE;
  106. extern struct inpcb * tcp_last_inpcb;
  108. #endif /* VIRTUAL_STACK */
  109. extern void _remque();
  110. extern int random();
  112. #ifdef WV_INSTRUMENTATION
  113. #ifdef INCLUDE_WVNET
  114.     /* Set common fields of event identifiers for this module. */
  116. LOCAL UCHAR wvNetModuleId = WV_NET_TCPSUBR_MODULE;  /* Value for tcp_subr.c */
  117. LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;     /* Available event filter */
  119. LOCAL ULONG wvNetEventId;       /* Event identifier: see wvNetLib.h */
  120. #endif    /* INCLUDE_WVNET */
  121. #endif
  124. /* globals */
  126. unsigned long (*pTcpRandHook)(void) = (unsigned long (*)(void))random;
  128. /*******************************************************************************
  129. *
  130. * tcpRandHookAdd - Changes pTcpRandHook to a user defined functioned
  131. *
  132. * The user supplies a random number generator to tcp_init via pTcpRandHook.
  133. *
  134. * RETURNS: OK if the function pointer is not null.
  135. */
  136. int tcpRandHookAdd
  137.     (
  138.     FUNCPTR pTcpRandFunc
  139.     )
  140.     {
  141.     if (pTcpRandFunc != NULL)
  142. {
  143.         pTcpRandHook = (unsigned long (*)(void))pTcpRandFunc;
  144. return (OK);
  145. }
  146.     else
  147.      return (ERROR);
  148.     }
  150. /*******************************************************************************
  151. *
  152. * tcpRandHookDelete - Changes pTcpRandHook back to the default setting
  153. *
  154. * This routine is not needed.
  155. *
  156. */
  158. void tcpRandHookDelete (void)
  159.     {
  160.     /*
  161.      * XXX
  162.      * Since random() returns 31bit random number, the highest bit
  163.      * is not set, therefore casting unsigned long will not affect
  164.      * against caller badly.    
  165.      */
  166.     pTcpRandHook = (unsigned long (*)(void))random; /* XXX */
  167.     }
  170. /*
  171.  * Tcp initialization
  172.  */
  173. void
  174. tcp_init()
  175. {
  176. #ifdef WV_INSTRUMENTATION
  177. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  178.     WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_VERBOSE, 39, 9,
  179.                      WV_NETEVENT_TCPINIT_START)
  180. #endif  /* INCLUDE_WVNET */
  181. #endif
  183. tcp_iss = pTcpRandHook();
  184.         LIST_INIT(&tcb);
  185.         tcbinfo.listhead = &tcb;
  186.         tcbinfo.hashbase = hashinit(tcp_pcbhashsize, MT_PCB, &tcbinfo.hashmask);
  187. if (max_protohdr < sizeof(struct tcpiphdr))
  188. max_protohdr = sizeof(struct tcpiphdr);
  189. if (max_linkhdr + sizeof(struct tcpiphdr) > CL_SIZE_128)
  190.             {
  191. #ifdef WV_INSTRUMENTATION
  192. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  193.         WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_EMERGENCY, 30, 1,
  194.                          WV_NETEVENT_TCPINIT_HDRPANIC)
  195. #endif  /* INCLUDE_WVNET */
  196. #endif
  198.             panic("tcp_init");
  199.             }
  200. }
  202. /*
  203.  * Create template to be used to send tcp packets on a connection.
  204.  * Call after host entry created, allocates an mbuf and fills
  205.  * in a skeletal tcp/ip header, minimizing the amount of work
  206.  * necessary when the connection is used.
  207.  */
  208. struct mbuf *
  209. tcp_template(tp)
  210. struct tcpcb *tp;
  211. {
  212. register struct inpcb *inp = tp->t_inpcb;
  213. register struct mbuf *m;
  214. register struct tcpiphdr *n;
  216. if ((m = tp->t_template) == NULL) {
  217. m = mBufClGet (M_DONTWAIT, MT_HEADER, sizeof (struct tcpiphdr),
  218.        TRUE); 
  219. if (m == NULL)
  220. return (0);
  221. m->m_len = sizeof (struct tcpiphdr);
  222. }
  223. n = mtod (m, struct tcpiphdr *);
  224. n->ti_next = n->ti_prev = 0;
  225. n->ti_x1 = 0;
  226. n->ti_pr = IPPROTO_TCP;
  227. n->ti_len = htons(sizeof (struct tcpiphdr) - sizeof (struct ip));
  228. n->ti_src = inp->inp_laddr;
  229. n->ti_dst = inp->inp_faddr;
  230. n->ti_sport = inp->inp_lport;
  231. n->ti_dport = inp->inp_fport;
  232. n->ti_seq = 0;
  233. n->ti_ack = 0;
  234. n->ti_x2 = 0;
  235. n->ti_off = 5;
  236. n->ti_flags = 0;
  237. n->ti_win = 0;
  238. n->ti_sum = 0;
  239. n->ti_urp = 0;
  240. return (m);
  241. }
  243. /*
  244.  * Send a single message to the TCP at address specified by
  245.  * the given TCP/IP header.  If m == 0, then we make a copy
  246.  * of the tcpiphdr at ti and send directly to the addressed host.
  247.  * This is used to force keep alive messages out using the TCP
  248.  * template for a connection tp->t_template.  If flags are given
  249.  * then we send a message back to the TCP which originated the
  250.  * segment ti, and discard the mbuf containing it and any other
  251.  * attached mbufs.
  252.  *
  253.  * In any case the ack and sequence number of the transmitted
  254.  * segment are as specified by the parameters.
  255.  */
  256. void
  257. tcp_respond(tp, ti, m, ack, seq, flags)
  258. struct tcpcb *tp;
  259. register struct tcpiphdr *ti;
  260. register struct mbuf *m;
  261. tcp_seq ack, seq;
  262. int flags;
  263. {
  264. register int tlen;
  265. int win = 0;
  266. struct route *ro = 0;
  268. if (tp) {
  269. #ifdef WV_INSTRUMENTATION
  270. #ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */
  271.     WV_NET_PORTOUT_EVENT_4 (NET_CORE_EVENT, WV_NET_NOTICE, 20, 2,
  272.                             tp->t_inpcb->inp_lport, tp->t_inpcb->inp_fport,
  273.                             WV_NETEVENT_TCPRESPOND_START, WV_NET_SEND,
  274.                             tp->t_inpcb->inp_socket->so_fd, ack, seq, flags)
  275. #endif  /* INCLUDE_WVNET */
  276. #endif
  277. win = sbspace(&tp->t_inpcb->inp_socket->so_rcv);
  278. ro = &tp->t_inpcb->inp_route;
  279. }
  280. if (m == 0) {
  281. m = mHdrClGet(M_DONTWAIT, MT_HEADER, CL_SIZE_128, TRUE);
  282. if (m == NULL)
  283. return;
  284. #ifdef TCP_COMPAT_42
  285. tlen = 1;
  286. #else
  287. tlen = 0;
  288. #endif
  289. m->m_data += max_linkhdr;
  290. *mtod(m, struct tcpiphdr *) = *ti;
  291. ti = mtod(m, struct tcpiphdr *);
  292. flags = TH_ACK;
  293. } else {
  294. m_freem(m->m_next);
  295. m->m_next = 0;
  296. m->m_data = (caddr_t)ti;
  297. m->m_len = sizeof (struct tcpiphdr);
  298. tlen = 0;
  299. #define xchg(a,b,type) { type t; t=a; a=b; b=t; }
  300. xchg(ti->ti_dst.s_addr, ti->ti_src.s_addr, u_long);
  301. xchg(ti->ti_dport, ti->ti_sport, u_short);
  302. #undef xchg
  303. }
  304. ti->ti_len = htons((u_short)(sizeof (struct tcphdr) + tlen));
  305. tlen += sizeof (struct tcpiphdr);
  306. m->m_len = tlen;
  307. m->m_pkthdr.len = tlen;
  308. m->m_pkthdr.rcvif = (struct ifnet *) 0;
  309. ti->ti_next = ti->ti_prev = 0;
  310. ti->ti_x1 = 0;
  311. ti->ti_seq = htonl(seq);
  312. ti->ti_ack = htonl(ack);
  313. ti->ti_x2 = 0;
  314. ti->ti_off = sizeof (struct tcphdr) >> 2;
  315. ti->ti_flags = flags;
  316. if (tp)
  317. ti->ti_win = htons((u_short) (win >> tp->rcv_scale));
  318. else
  319. ti->ti_win = htons((u_short)win);
  320. ti->ti_urp = 0;
  321. ti->ti_sum = 0;
  322. ti->ti_sum = in_cksum(m, tlen);
  323. ((struct ip *)ti)->ip_len = tlen;
  324. ((struct ip *)ti)->ip_ttl = ip_defttl;
  325. if (tp)
  326.     ((struct ip *)ti)->ip_tos = tp->t_inpcb->inp_ip.ip_tos;
  328. (void) ip_output(m, NULL, ro, 0, NULL);
  329. }
  331. /*
  332.  * Create a new TCP control block, making an
  333.  * empty reassembly queue and hooking it to the argument
  334.  * protocol control block.
  335.  */
  336. struct tcpcb *
  337. tcp_newtcpcb(inp)
  338. struct inpcb *inp;
  339. {
  340. register struct tcpcb *tp;
  342. MALLOC(tp, struct tcpcb *, sizeof(*tp), MT_PCB, M_DONTWAIT);
  343. if (tp == NULL)
  344. return ((struct tcpcb *)0);
  345. bzero((char *) tp, sizeof(struct tcpcb));
  346. tp->seg_next = tp->seg_prev = (struct tcpiphdr *)tp;
  347. tp->t_maxseg = tp->t_maxsize = tcp_mssdflt;
  349. tp->t_flags = tcp_do_rfc1323 ? (TF_REQ_SCALE|TF_REQ_TSTMP) : 0;
  350. tp->t_inpcb = inp;
  351. /*
  352.  * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no
  353.  * rtt estimate.  Set rttvar so that srtt + 2 * rttvar gives
  354.  * reasonable initial retransmit time.
  355.  */
  356. tp->t_srtt = TCPTV_SRTTBASE;
  357. tp->t_rttvar = tcp_rttdflt * PR_SLOWHZ << 2;
  358. tp->t_rttmin = TCPTV_MIN;
  359. TCPT_RANGESET(tp->t_rxtcur, 
  360.     ((TCPTV_SRTTBASE >> 2) + (TCPTV_SRTTDFLT << 2)) >> 1,
  361.     TCPTV_MIN, TCPTV_REXMTMAX);
  362. tp->snd_cwnd = TCP_MAXWIN << TCP_MAX_WINSHIFT;
  363. tp->snd_ssthresh = TCP_MAXWIN << TCP_MAX_WINSHIFT;
  364. inp->inp_ip.ip_ttl = ip_defttl;
  365. inp->inp_ppcb = (caddr_t)tp;
  366. return (tp);
  367. }
  369. /*
  370.  * Drop a TCP connection, reporting
  371.  * the specified error.  If connection is synchronized,
  372.  * then send a RST to peer.
  373.  */
  374. struct tcpcb *
  375. tcp_drop(tp, error)
  376. register struct tcpcb *tp;
  377. int error;
  378. {
  379. struct socket *so = tp->t_inpcb->inp_socket;
  381. #ifdef WV_INSTRUMENTATION
  382. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  383.     WV_NET_PORTOUT_MARKER_1 (NET_AUX_EVENT, WV_NET_INFO, 38, 3,
  384.                             tp->t_inpcb->inp_lport, tp->t_inpcb->inp_fport,
  385.                             WV_NETEVENT_TCPDROP_START, so->so_fd)
  386. #endif  /* INCLUDE_WVNET */
  387. #endif
  389. if (TCPS_HAVERCVDSYN(tp->t_state)) {
  390. tp->t_state = TCPS_CLOSED;
  391. (void) tcp_output(tp);
  392. tcpstat.tcps_drops++;
  393. } else
  394. tcpstat.tcps_conndrops++;
  395. if (error == ETIMEDOUT && tp->t_softerror)
  396. error = tp->t_softerror;
  397. so->so_error = error;
  398. return (tcp_close(tp));
  399. }
  401. /*
  402.  * Close a TCP control block:
  403.  * discard all space held by the tcp
  404.  * discard internet protocol block
  405.  * wake up any sleepers
  406.  */
  407. struct tcpcb *
  408. tcp_close(tp)
  409. register struct tcpcb *tp;
  410. {
  411. register struct tcpiphdr *t;
  412. struct inpcb *inp = tp->t_inpcb;
  413. struct socket *so = inp->inp_socket;
  414. register struct mbuf *m;
  416. register struct rtentry *rt;
  418. #ifdef WV_INSTRUMENTATION
  419. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  420.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_INFO, 39, 4,
  421.                      WV_NETEVENT_TCPCLOSE_START, so->so_fd)
  422. #endif  /* INCLUDE_WVNET */
  423. #endif
  425. /*
  426.  * If we sent enough data to get some meaningful characteristics,
  427.  * save them in the routing entry.  'Enough' is arbitrarily 
  428.  * defined as the sendpipesize (default 4K) * 16.  This would
  429.  * give us 16 rtt samples assuming we only get one sample per
  430.  * window (the usual case on a long haul net).  16 samples is
  431.  * enough for the srtt filter to converge to within 5% of the correct
  432.  * value; fewer samples and we could save a very bogus rtt.
  433.  *
  434.  * Don't update the default route's characteristics and don't
  435.  * update anything that the user "locked".
  436.  */
  437. if (SEQ_LT(tp->iss + so->so_snd.sb_hiwat * 16, tp->snd_max) &&
  438.     (rt = inp->inp_route.ro_rt) &&
  439.     ((struct sockaddr_in *)rt_key(rt))->sin_addr.s_addr != INADDR_ANY) {
  440. register u_long i = 0;
  442. if ((rt->rt_rmx.rmx_locks & RTV_RTT) == 0) {
  443. i = tp->t_srtt *
  444.     (RTM_RTTUNIT / (PR_SLOWHZ * TCP_RTT_SCALE));
  445. if (rt->rt_rmx.rmx_rtt && i)
  446. /*
  447.  * filter this update to half the old & half
  448.  * the new values, converting scale.
  449.  * See route.h and tcp_var.h for a
  450.  * description of the scaling constants.
  451.  */
  452. rt->rt_rmx.rmx_rtt =
  453.     (rt->rt_rmx.rmx_rtt + i) / 2;
  454. else
  455. rt->rt_rmx.rmx_rtt = i;
  456. }
  457. if ((rt->rt_rmx.rmx_locks & RTV_RTTVAR) == 0) {
  458. i = tp->t_rttvar *
  459.     (RTM_RTTUNIT / (PR_SLOWHZ * TCP_RTTVAR_SCALE));
  460. if (rt->rt_rmx.rmx_rttvar && i)
  461. rt->rt_rmx.rmx_rttvar =
  462.     (rt->rt_rmx.rmx_rttvar + i) / 2;
  463. else
  464. rt->rt_rmx.rmx_rttvar = i;
  465. }
  466. /*
  467.  * update the pipelimit (ssthresh) if it has been updated
  468.  * already or if a pipesize was specified & the threshhold
  469.  * got below half the pipesize.  I.e., wait for bad news
  470.  * before we start updating, then update on both good
  471.  * and bad news.
  472.                  *
  473.                  * Update the slow start threshold when all of the
  474.                  * following conditions apply:
  475.                  *   1) The value is not locked (via a routing socket).
  476.                  *   2) Some packet loss occurred during the connection
  477.                  *       (snd_ssthresh is not zero)
  478.                  *   3) Packet loss also occurred during an earlier
  479.                  *      connection (rmx_ssthresh is not zero). This
  480.                  *      condition also applies if a user set a value
  481.                  *      in advance via a routing socket.
  482.                  *
  483.                  * If none of the above conditions apply, the system
  484.                  * still updates the slow start threshold if the
  485.                  * value for this connection's packet loss is less
  486.                  * than half the rmx_sendpipe value set via a routing
  487.                  * socket. If that pipe size is available, the update
  488.                  * occurs even if no packet loss happened.
  489.  */
  491. if (((rt->rt_rmx.rmx_locks & RTV_SSTHRESH) == 0 &&
  492.        (i = tp->snd_ssthresh) && rt->rt_rmx.rmx_ssthresh) ||
  493.     i < (rt->rt_rmx.rmx_sendpipe / 2)) {
  494. /*
  495.  * convert the limit from user data bytes to
  496.  * packets then to packet data bytes.
  497.  */
  498. i = (i + tp->t_maxseg / 2) / tp->t_maxseg;
  499. if (i < 2)
  500. i = 2;
  501. i *= (u_long)(tp->t_maxseg + sizeof (struct tcpiphdr));
  502. if (rt->rt_rmx.rmx_ssthresh)
  503. rt->rt_rmx.rmx_ssthresh =
  504.     (rt->rt_rmx.rmx_ssthresh + i) / 2;
  505. else
  506. rt->rt_rmx.rmx_ssthresh = i;
  507. }
  508. }
  510. /* free the reassembly queue, if any */
  511. t = tp->seg_next;
  512. while (t != (struct tcpiphdr *)tp) {
  513. t = (struct tcpiphdr *)t->ti_next;
  514. m = REASS_MBUF((struct tcpiphdr *)t->ti_prev);
  515. remque(t->ti_prev);
  516. m_freem(m);
  517. }
  518. if (tp->t_template)
  519. (void) m_free(tp->t_template);
  520. FREE(tp, MT_PCB); 
  521. inp->inp_ppcb = 0;
  522. soisdisconnected(so);
  523. /* clobber input pcb cache if we're closing the cached connection */
  524. if (inp == tcp_last_inpcb)
  525.             tcp_last_inpcb = NULL;
  526. in_pcbdetach(inp);
  527. tcpstat.tcps_closed++;
  528. return ((struct tcpcb *)0);
  529. }
  531. void
  532. tcp_drain()
  533. {
  535. }
  537. /*
  538.  * Notify a tcp user of an asynchronous error;
  539.  * store error as soft error, but wake up user
  540.  * (for now, won't do anything until can select for soft error).
  541.  */
  542. void tcp_notify
  543.     (
  544.     struct inpcb *inp, 
  545.     int error
  546.     )
  547.     {
  548.     register struct tcpcb *tp = (struct tcpcb *)inp->inp_ppcb;
  549.     register struct socket *so = inp->inp_socket;
  551.     /*
  552.      * Ignore some errors if we are hooked up.
  553.      * If connection hasn't completed, has retransmitted several times,
  554.      * and receives a second error, give up now.  This is better
  555.      * than waiting a long time to establish a connection that
  556.      * can never complete.
  557.      */
  559.     if (tp->t_state == TCPS_ESTABLISHED &&
  560.         (error == EHOSTUNREACH || error == ENETUNREACH ||
  561.          error == EHOSTDOWN))
  562.         {
  563. #ifdef WV_INSTRUMENTATION
  564. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  565.         WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_INFO, 40, 5,
  566.                          WV_NETEVENT_TCPNOTIFY_IGNORE, so->so_fd, error)
  567. #endif  /* INCLUDE_WVNET */
  568. #endif
  570.         return;
  571.         }
  572.     else if (tp->t_state < TCPS_ESTABLISHED && tp->t_rxtshift > 3 &&
  573.              tp->t_softerror)
  574.         {
  575. #ifdef WV_INSTRUMENTATION
  576. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  577.         WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_INFO, 41, 6,
  578.                          WV_NETEVENT_TCPNOTIFY_KILL, so->so_fd, error)
  579. #endif  /* INCLUDE_WVNET */
  580. #endif
  582.         so->so_error = error;
  583.         }
  584.     else 
  585.         {
  586. #ifdef WV_INSTRUMENTATION
  587. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  588.         WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_INFO, 42, 7,
  589.                          WV_NETEVENT_TCPNOTIFY_ERROR, so->so_fd, error)
  590. #endif  /* INCLUDE_WVNET */
  591. #endif
  593.         tp->t_softerror = error;
  594.         }
  596.     if (so->so_timeoSem)
  597.         wakeup(so->so_timeoSem);
  599.     sorwakeup(so);
  600.     sowwakeup(so);
  601.     }
  604. void
  605. tcp_ctlinput(cmd, sa, ip)
  606. int cmd;
  607. struct sockaddr *sa;
  608. register struct ip *ip;
  609. {
  610. register struct tcphdr *th;
  611. extern struct in_addr zeroin_addr;
  612. extern u_char inetctlerrmap[];
  613. void (*notify) (struct inpcb *, int) = tcp_notify;
  615. #ifdef WV_INSTRUMENTATION
  616. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  617.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_INFO, 43, 8,
  618.                      WV_NETEVENT_TCPCTLIN_START, cmd)
  619. #endif  /* INCLUDE_WVNET */
  620. #endif
  622. if (cmd == PRC_QUENCH)
  623. notify = tcp_quench;
  624.         else if (cmd == PRC_MSGSIZE)
  625.                 notify = tcp_updatemtu;
  626. else if (!PRC_IS_REDIRECT(cmd) &&
  627.  ((unsigned)cmd > PRC_NCMDS || inetctlerrmap[cmd] == 0))
  628. return;
  629. if (ip) {
  630. th = (struct tcphdr *)((caddr_t)ip + (ip->ip_hl << 2));
  631. in_pcbnotify(&tcb, sa, th->th_dport, ip->ip_src, th->th_sport,
  632. cmd, notify);
  633. } else
  634. in_pcbnotify(&tcb, sa, 0, zeroin_addr, 0, cmd, notify);
  635. }
  637. /*
  638.  * When a source quench is received, close congestion window
  639.  * to one segment.  We will gradually open it again as we proceed.
  640.  */
  641. void
  642. tcp_quench(inp, error)
  643. struct inpcb *inp;
  644. int error;
  645. {
  646. struct tcpcb *tp = intotcpcb(inp);
  648. if (tp)
  649. tp->snd_cwnd = tp->t_maxseg;
  650. }
  652. /*
  653.  * Look-up the routing entry to the peer of this inpcb.  If no route
  654.  * is found and it cannot be allocated the return NULL.  This routine
  655.  * is called by TCP routines that access the rmx structure.
  656.  */
  657. struct rtentry *
  658. tcp_rtlookup(inp)
  659.         struct inpcb *inp;
  660. {
  661.         struct route *ro;
  662.         struct rtentry *rt;
  664.         ro = &inp->inp_route;
  665.         rt = ro->ro_rt;
  666.         if (rt == NULL || !(rt->rt_flags & RTF_UP)) {
  667.                 /* No route yet, so try to acquire one */
  668.                 if (inp->inp_faddr.s_addr != INADDR_ANY) {
  669.                         ro->ro_dst.sa_family = AF_INET;
  670.                         ro->ro_dst.sa_len = sizeof(ro->ro_dst);
  671.                         ((struct sockaddr_in *) &ro->ro_dst)->sin_addr =
  672.                                 inp->inp_faddr;
  673.                         TOS_SET (&ro->ro_dst, inp->inp_ip.ip_tos);
  674.                         rtalloc(ro);
  675.                         rt = ro->ro_rt;
  676.                 }
  677.         }
  678.         return rt;
  679. }
  682. /*
  683.  * When an ICMP error "need fragmentation" message causes the stack to
  684.  * update the MSS based on the (already updated) path MTU estimate and
  685.  * signal TCP to send data so that the dropped packet is detected. This 
  686.  * routine duplicates some code from the tcp_mss() routine in tcp_input.c
  687.  */
  689. void tcp_updatemtu
  690.     (
  691.     struct inpcb * inp,
  692.     int error
  693.     )
  694.     {
  695.     struct tcpcb *tp = intotcpcb(inp);
  696.     struct rtentry *rt;
  697.     struct socket *so = inp->inp_socket;
  698.     int mss;
  699.     int maxseg;
  700.     int cwnd = 0;
  702.     if (tp)
  703.         {
  704.         rt = tcp_rtlookup (inp);
  705.         if ( (rt == NULL) || (rt->rt_rmx.rmx_locks & RTV_MTU))
  706.             {
  707.             /*
  708.              * New path MTU estimate unavailable or discovery process
  709.              * ended - set segment size to default value if less than
  710.              * current estimate.
  711.              */
  713.             tp->t_maxsize = min (tp->t_maxsize, tcp_mssdflt);
  714.             tp->t_maxseg = min (so->so_snd.sb_hiwat, tp->t_maxsize);
  715.             return;
  716.             }
  718.         maxseg = rt->rt_rmx.rmx_mtu - sizeof(struct tcpiphdr);
  720.         mss = rt->rt_rmx.rmx_mss;
  722.         /*
  723.          * The following comparison violates the TCP specification by
  724.          * permitting IP datagrams larger than the mandatory default
  725.          * if the peer has not sent the initial SYN (which assigns the
  726.          * MSS value). Although TCP is forbidden to exceed the default
  727.          * unless explicitly allowed by the MSS option from a peer, that
  728.          * behavior would probably prevent path MTU discovery from occurring
  729.          * since the default is already less than many typical MTU sizes.
  730.          *
  731.          * Avoiding the conservative default might not have a significant
  732.          * impact. Any unexpectedly large segments will only occur when
  733.          * sending an initial SYN which includes options and/or data to a
  734.          * host which has never been connected. Once the remote peer sends
  735.          * a return SYN (during the connection handshake), the system will
  736.          * record a MSS value and reduce the maximum segment size if
  737.          * necessary. If that remote peer ignores the generally recommended
  738.          * "liberal acceptance" policy and discards the segment which its
  739.          * network layer successfully received, the failed connection attempts
  740.          * will reveal the problem.
  741.          */
  743.         if (mss)
  744.             {
  745.             /*
  746.              * If necessary, reduce the path MTU estimate according to the
  747.              * known segment size which the peer is required to accept.
  748.              */
  750.             maxseg = min (maxseg, mss);
  751.             }
  753.         /*
  754.          * Do not allow ICMP error messages to increase the maximum
  755.          * segment size above the initial value determined in the
  756.          * tcp_mss() routine.
  757.          */
  759.         if (tp->t_maxsize <= maxseg)
  760.             return;
  761.         tp->t_maxsize = maxseg;
  763.         /* Update the mss to ignore newly received options? */
  765.         if ((tp->t_flags & (TF_REQ_TSTMP|TF_NOOPT)) == TF_REQ_TSTMP &&
  766.             (tp->t_flags & TF_RCVD_TSTMP) == TF_RCVD_TSTMP)
  767.             maxseg -= TCPOLEN_TSTAMP_APPA;
  769. #if     (MCLBYTES & (MCLBYTES - 1)) == 0
  770.         if (maxseg > MCLBYTES)
  771.             maxseg &= ~(MCLBYTES-1);
  772. #else
  773.         if (maxseg > MCLBYTES)
  774.             maxseg = maxseg / MCLBYTES * MCLBYTES;
  775. #endif
  776.         if (so->so_snd.sb_hiwat < maxseg)
  777.             maxseg = so->so_snd.sb_hiwat;
  779.         tp->t_maxseg = maxseg;
  781.         tp->t_rtt = 0;
  782.         tp->snd_nxt = tp->snd_una;
  784.         /*
  785.  * If tcp_updatemtu was called in response to an ICMP fragmentation-
  786.  * needed message (error = EMSGSIZE), trigger slow-start without 
  787.  * changing the congestion window. Temporarily set cwnd to 1 segment 
  788.  * and then restore it to original value after tcp_output. tcp_updatemtu
  789.  * is also called from tcp_output but in that case error is 0. We do
  790.  * not want to trigger slow-start for that scenario.
  791.  */
  793.         if (error == EMSGSIZE)
  794.     {
  795.     cwnd = tp->snd_cwnd;
  796.     tp->snd_cwnd = maxseg;
  797.     }
  799.         tcp_output(tp);
  801. if (error == EMSGSIZE)
  802.     tp->snd_cwnd = cwnd;
  803.         }
  804.     }