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

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

VxWorks

开发平台：

C/C++

tcp_usrreq.c：源码内容
  1. /* tcp_usrreq.c - TCP interface routines */
  3. /* Copyright 1984 - 2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1982, 1986, 1988, 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_usrreq.c 8.5 (Berkeley) 6/21/95
  39.  */
  41. /*
  42. modification history
  43. --------------------
  44. 03i,05jun02,vvv  fixed Nagle for large writes (SPR #72213)
  45. 03h,21mar02,wap  avoid making local port of TCP connection the same as
  46.                  the foreign port (SPR #73104)
  47. 03g,12oct01,rae  merge from truestack ver 03j, base 03e
  48. 03f,14nov00,ham  remoeved tcpstates declaration(SPR 62272).
  49. 03e,26aug98,n_s  added return val check for mBufClGet in tcp_ctloutput. 
  50.                  spr #22238.
  51. 03d,07jul97,vin  in tcp_usrreq case PRU_DETACH simplified.
  52. 03c,08mar97,vin  added changes to accomodate changes in pcb structure for
  53.  hash look ups.
  54. 03b,22nov96,vin  modified for cluster support, replace m_get(..) with 
  55.  mBufClGet(..).
  56. 03a,03mar96,vin  created from BSD4.4 stuff,integrated with 02o of tcp_usrreq.c.
  57. */
  59. /*
  60. DESCRIPTION
  61. */
  63. #include "vxWorks.h"
  64. #include "net/mbuf.h"
  65. #include "sys/socket.h"
  66. #include "net/socketvar.h"
  67. #include "net/protosw.h"
  68. #include "errno.h"
  69. #include "sys/stat.h"
  71. #include "net/if.h"
  72. #include "net/route.h"
  74. #include "netinet/in.h"
  75. #include "netinet/in_pcb.h"
  76. #include "netinet/in_systm.h"
  77. #include "netinet/in_var.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. #include "netinet/tcp_debug.h"
  87. #include "net/systm.h"
  89. #ifdef WV_INSTRUMENTATION
  90. #ifdef INCLUDE_WVNET
  91. #include "wvNetLib.h"
  92. #endif
  93. #endif
  95. #ifdef VIRTUAL_STACK
  96. #include "netinet/vsLib.h"
  97. #else
  98. IMPORT int tcp_keepinit;
  99. #endif /* VIRTUAL_STACK */
  100. IMPORT unsigned long (*pTcpRandHook)(void);
  102. LOCAL void tcpTraceStub ();
  103. LOCAL void tcpReportStub ();
  104. VOIDFUNCPTR tcpTraceRtn = tcpTraceStub; /* exported */
  105. VOIDFUNCPTR tcpReportRtn = tcpReportStub; /* exported */
  107. /*
  108.  * TCP protocol interface to socket abstraction.
  109.  */
  111. #ifdef WV_INSTRUMENTATION
  112. #ifdef INCLUDE_WVNET
  113.     /* Set common fields of event identifiers for this module. */
  115. LOCAL UCHAR wvNetModuleId = WV_NET_TCPREQ_MODULE; /* Value for tcp_usrreq.c */
  116. LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;     /* Available event filter */
  118. LOCAL ULONG wvNetEventId;       /* Event identifier: see wvNetLib.h */
  119. #endif    /* INCLUDE_WVNET */
  120. #endif
  122. /*
  123.  * Process a TCP user request for TCP tb.  If this is a send request
  124.  * then m is the mbuf chain of send data.  If this is a timer expiration
  125.  * (called from the software clock routine), then timertype tells which timer.
  126.  */
  128. /*ARGSUSED*/
  129. int
  130. tcp_usrreq(so, req, m, nam, control)
  131. struct socket *so;
  132. int req;
  133. struct mbuf *m, *nam, *control;
  134. {
  135. register struct inpcb *inp;
  136. register struct tcpcb *tp = NULL;
  137. int s;
  138. int error = 0;
  139. int ostate;
  141. #ifdef WV_INSTRUMENTATION
  142. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  143.     WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_INFO, 47, 8,
  144.                      WV_NETEVENT_TCPREQ_START, so->so_fd, req)
  145. #endif  /* INCLUDE_WVNET */
  146. #endif
  148. if (req == PRU_CONTROL)
  149. return (in_control(so, (u_long)m, (caddr_t)nam,
  150. (struct ifnet *)control));
  151. if (control && control->m_len) {
  152. m_freem(control);
  153. if (m)
  154. m_freem(m);
  155. #ifdef WV_INSTRUMENTATION
  156. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  157.         WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 38, 4,
  158.                          WV_NETEVENT_TCPREQ_BADMEM, so->so_fd, req)
  159. #endif  /* INCLUDE_WVNET */
  160. #endif
  162. return (EINVAL);
  163. }
  165. s = splnet();
  166. inp = sotoinpcb(so);
  167. /*
  168.  * When a TCP is attached to a socket, then there will be
  169.  * a (struct inpcb) pointed at by the socket, and this
  170.  * structure will point at a subsidary (struct tcpcb).
  171.  */
  172. if (inp == 0 && req != PRU_ATTACH) {
  173. splx(s);
  174. #if 0
  175. /*
  176.  * The following corrects an mbuf leak under rare
  177.  * circumstances, but has not been fully tested.
  178.  */
  179. if (m && req != PRU_SENSE)
  180. m_freem(m);
  181. #else
  182. /* safer version of fix for mbuf leak */
  183. if (m && (req == PRU_SEND || req == PRU_SENDOOB))
  184. m_freem(m);
  185. #endif
  187. #ifdef WV_INSTRUMENTATION
  188. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  189.         WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 39, 5,
  190.                          WV_NETEVENT_TCPREQ_NOPCB, so->so_fd, req)
  191. #endif  /* INCLUDE_WVNET */
  192. #endif
  194. return (EINVAL); /* XXX */
  195. }
  196. if (inp) {
  197. tp = intotcpcb(inp);
  198. /* WHAT IF TP IS 0? */
  199. #ifdef KPROF
  200. tcp_acounts[tp->t_state][req]++;
  201. #endif
  202. ostate = tp->t_state;
  203. } else
  204. ostate = 0;
  205. switch (req) {
  207. /*
  208.  * TCP attaches to socket via PRU_ATTACH, reserving space,
  209.  * and an internet control block.
  210.  */
  211. case PRU_ATTACH:
  212. if (inp) {
  213. error = EISCONN;
  214. break;
  215. }
  216. error = tcp_attach(so);
  217. if (error)
  218. break;
  220.                 /* TCP sockets use path MTU discovery by default. */
  222.                 so->so_options |= SO_USEPATHMTU;
  224. if ((so->so_options & SO_LINGER) && so->so_linger == 0)
  225. so->so_linger = TCP_LINGERTIME;
  226. tp = sototcpcb(so);
  227. break;
  229. /*
  230.  * PRU_DETACH detaches the TCP protocol from the socket.
  231.  * If the protocol state is non-embryonic, then can't
  232.  * do this directly: have to initiate a PRU_DISCONNECT,
  233.  * which may finish later; embryonic TCB's can just
  234.  * be discarded here.
  235.  */
  236. case PRU_DETACH:
  237.             tp = tcp_disconnect(tp);
  238.             break;
  240. /*
  241.  * Give the socket an address.
  242.  */
  243. case PRU_BIND:
  244. error = in_pcbbind(inp, nam);
  245. if (error)
  246. break;
  247. break;
  249. /*
  250.  * Prepare to accept connections.
  251.  */
  252. case PRU_LISTEN:
  253. if (inp->inp_lport == 0)
  254. error = in_pcbbind(inp, (struct mbuf *)0);
  255. if (error == 0)
  256. tp->t_state = TCPS_LISTEN;
  257. break;
  259. /*
  260.  * Initiate connection to peer.
  261.  * Create a template for use in transmissions on this connection.
  262.  * Enter SYN_SENT state, and mark socket as connecting.
  263.  * Start keep-alive timer, and seed output sequence space.
  264.  * Send initial segment on connection.
  265.  */
  266. case PRU_CONNECT:
  267. if (inp->inp_lport == 0) {
  268. error = in_pcbbind(inp, (struct mbuf *)0);
  269. if (error)
  270. break;
  272. /*
  273.  * Avoid case where ephemeral port for local
  274.  * side of connection is the same as destination
  275.  * port for foreign side.
  276.  */
  278. if (inp->inp_lport ==
  279.     (mtod (nam, struct sockaddr_in *))->sin_port)
  280.     {
  281. inp->inp_lport = 0;
  282. error = in_pcbbind (inp, (struct mbuf *)0);
  283. if (error)
  284. break;
  285.     }
  286. }
  288. error = in_pcbconnect(inp, nam);
  289. if (error)
  290. break;
  291. tp->t_template = tcp_template(tp);
  292. if (tp->t_template == 0) {
  293. in_pcbdisconnect(inp);
  294. error = ENOBUFS;
  295. break;
  296. }
  297. /* Compute window scaling to request.  */
  298. while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
  299.     (TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.sb_hiwat)
  300. tp->request_r_scale++;
  301. soisconnecting(so);
  302. tcpstat.tcps_connattempt++;
  303. tp->t_state = TCPS_SYN_SENT;
  304.                 tp->t_timer[TCPT_KEEP] = tcp_keepinit;
  305.       tp->iss = tcp_iss;
  306. tcp_iss += TCP_ISSINCR/4 + ((0x0000ffff) & (pTcpRandHook() >> 16));
  307. tcp_sendseqinit(tp);
  308. error = tcp_output(tp);
  309. break;
  311. /*
  312.  * Create a TCP connection between two sockets.
  313.  */
  314. case PRU_CONNECT2:
  315. error = EOPNOTSUPP;
  316. break;
  318. /*
  319.  * Initiate disconnect from peer.
  320.  * If connection never passed embryonic stage, just drop;
  321.  * else if don't need to let data drain, then can just drop anyways,
  322.  * else have to begin TCP shutdown process: mark socket disconnecting,
  323.  * drain unread data, state switch to reflect user close, and
  324.  * send segment (e.g. FIN) to peer.  Socket will be really disconnected
  325.  * when peer sends FIN and acks ours.
  326.  *
  327.  * SHOULD IMPLEMENT LATER PRU_CONNECT VIA REALLOC TCPCB.
  328.  */
  329. case PRU_DISCONNECT:
  330. tp = tcp_disconnect(tp);
  331. break;
  333. /*
  334.  * Accept a connection.  Essentially all the work is
  335.  * done at higher levels; just return the address
  336.  * of the peer, storing through addr.
  337.  */
  338. case PRU_ACCEPT:
  339. in_setpeeraddr(inp, nam);
  340. break;
  342. /*
  343.  * Mark the connection as being incapable of further output.
  344.  */
  345. case PRU_SHUTDOWN:
  346. socantsendmore(so);
  347. tp = tcp_usrclosed(tp);
  348. if (tp)
  349. error = tcp_output(tp);
  350. break;
  352. /*
  353.  * After a receive, possibly send window update to peer.
  354.  */
  355. case PRU_RCVD:
  356. (void) tcp_output(tp);
  357. break;
  359. /*
  360.  * Do a send by putting data in output queue and updating urgent
  361.  * marker if URG set.  Possibly send more data.
  362.  */
  363. case PRU_SEND:
  364. if (m->m_flags & M_EOB)
  365.     {
  366.     m->m_flags &= ~M_EOB;
  367.     tp->t_flags |= TF_EOB;
  368.     }
  369. sbappend(&so->so_snd, m);
  370. error = tcp_output(tp);
  371. tp->t_flags &= ~TF_EOB;
  372. break;
  374. /*
  375.  * Abort the TCP.
  376.  */
  377. case PRU_ABORT:
  378. tp = tcp_drop(tp, ECONNABORTED);
  379. break;
  381. case PRU_SENSE:
  382. ((struct stat *) m)->st_blksize = so->so_snd.sb_hiwat;
  383. (void) splx(s);
  384. return (0);
  386. case PRU_RCVOOB:
  387. if ((so->so_oobmark == 0 &&
  388.     (so->so_state & SS_RCVATMARK) == 0) ||
  389.     so->so_options & SO_OOBINLINE ||
  390.     tp->t_oobflags & TCPOOB_HADDATA) {
  391. error = EINVAL;
  392. break;
  393. }
  394. if ((tp->t_oobflags & TCPOOB_HAVEDATA) == 0) {
  395. error = EWOULDBLOCK;
  396. break;
  397. }
  398. m->m_len = 1;
  399. *mtod(m, caddr_t) = tp->t_iobc;
  400. if (((int)nam & MSG_PEEK) == 0)
  401. tp->t_oobflags ^= (TCPOOB_HAVEDATA | TCPOOB_HADDATA);
  402. break;
  404. case PRU_SENDOOB:
  405. if (sbspace(&so->so_snd) < -512) {
  406. m_freem(m);
  407. error = ENOBUFS;
  408. break;
  409. }
  410. /*
  411.  * According to RFC961 (Assigned Protocols),
  412.  * the urgent pointer points to the last octet
  413.  * of urgent data.  We continue, however,
  414.  * to consider it to indicate the first octet
  415.  * of data past the urgent section.
  416.  * Otherwise, snd_up should be one lower.
  417.  */
  418. sbappend(&so->so_snd, m);
  419. tp->snd_up = tp->snd_una + so->so_snd.sb_cc;
  420. tp->t_force = 1;
  421. error = tcp_output(tp);
  422. tp->t_force = 0;
  423. break;
  425. case PRU_SOCKADDR:
  426. in_setsockaddr(inp, nam);
  427. break;
  429. case PRU_PEERADDR:
  430. in_setpeeraddr(inp, nam);
  431. break;
  433. /*
  434.  * TCP slow timer went off; going through this
  435.  * routine for tracing's sake.
  436.  */
  437. case PRU_SLOWTIMO:
  438. tp = tcp_timers(tp, (int)nam);
  439. req |= (int)nam << 8; /* for debug's sake */
  440. break;
  442. default:
  443. #ifdef WV_INSTRUMENTATION
  444. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  445.             WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_EMERGENCY, 31, 1,
  446.                              WV_NETEVENT_TCPREQ_PANIC, so->so_fd, req)
  447. #endif  /* INCLUDE_WVNET */
  448. #endif
  450. panic("tcp_usrreq");
  451. }
  452. #ifdef BSDDEBUG
  453. if (tp && (so->so_options & SO_DEBUG))
  454. (*tcpTraceRtn)(TA_USER, ostate, tp, (struct tcpiphdr *)0, req);
  455. #endif /* BSDDEBUG */
  456. splx(s);
  458. #ifdef WV_INSTRUMENTATION
  459. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  460.     if (error)
  461.         {
  462.         WV_NET_MARKER_3 (NET_AUX_EVENT, WV_NET_ERROR, 40, 6,
  463.                          WV_NETEVENT_TCPREQ_FAIL, so->so_fd, req, error)
  464.         }
  465. #endif  /* INCLUDE_WVNET */
  466. #endif
  468. return (error);
  469. }
  471. int
  472. tcp_ctloutput(op, so, level, optname, mp)
  473. int op;
  474. struct socket *so;
  475. int level, optname;
  476. struct mbuf **mp;
  477. {
  478. int error = 0, s;
  479. struct inpcb *inp;
  480. register struct tcpcb *tp;
  481. register struct mbuf *m;
  482. register int i;
  484. #ifdef WV_INSTRUMENTATION
  485. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  486.     WV_NET_MARKER_4 (NET_AUX_EVENT, WV_NET_INFO, 46, 7,
  487.                  WV_NETEVENT_TCPCTLOUT_START, so->so_fd, op, level, optname)
  488. #endif  /* INCLUDE_WVNET */
  489. #endif
  491. s = splnet();
  492. inp = sotoinpcb(so);
  493. if (inp == NULL) {
  494. splx(s);
  495. if (op == PRCO_SETOPT && *mp)
  496. (void) m_free(*mp);
  497. #ifdef WV_INSTRUMENTATION
  498. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  499.         WV_NET_MARKER_4 (NET_AUX_EVENT, WV_NET_CRITICAL, 32, 2,
  500.                  WV_NETEVENT_TCPCTLOUT_NOPCB, so->so_fd, op, level, optname)
  501. #endif  /* INCLUDE_WVNET */
  502. #endif
  504. return (ECONNRESET);
  505. }
  506. if (level != IPPROTO_TCP) {
  507. error = ip_ctloutput(op, so, level, optname, mp);
  508. splx(s);
  509. return (error);
  510. }
  511. tp = intotcpcb(inp);
  513. switch (op) {
  515. case PRCO_SETOPT:
  516. m = *mp;
  517. switch (optname) {
  519. case TCP_NODELAY:
  520. if (m == NULL || m->m_len < sizeof (int))
  521. error = EINVAL;
  522. else if (*mtod(m, int *))
  523. tp->t_flags |= TF_NODELAY;
  524. else
  525. tp->t_flags &= ~TF_NODELAY;
  526. break;
  528. case TCP_MAXSEG:
  529. if (m && (i = *mtod(m, int *)) > 0 && i <= tp->t_maxseg)
  530. tp->t_maxseg = i;
  531. else
  532. error = EINVAL;
  533. break;
  535. default:
  536. error = ENOPROTOOPT;
  537. break;
  538. }
  539. if (m)
  540. (void) m_free(m);
  541. break;
  543. case PRCO_GETOPT:
  544. *mp = m = mBufClGet(M_WAIT, MT_SOOPTS, CL_SIZE_128, TRUE);
  545. if (m == (struct mbuf *) NULL)
  546.     {
  547.     error = ENOBUFS;
  548.     break;
  549.     }
  550. m->m_len = sizeof(int);
  552. switch (optname) {
  553. case TCP_NODELAY:
  554. *mtod(m, int *) = tp->t_flags & TF_NODELAY;
  555. break;
  556. case TCP_MAXSEG:
  557. *mtod(m, int *) = tp->t_maxseg;
  558. break;
  559. default:
  560. error = ENOPROTOOPT;
  561. break;
  562. }
  563. break;
  564. }
  565. splx(s);
  566. return (error);
  567. }
  569. #ifndef VIRTUAL_STACK
  570. u_long tcp_sendspace = 1024*8;
  571. u_long tcp_recvspace = 1024*8;
  572. #endif
  574. /*
  575.  * Attach TCP protocol to socket, allocating
  576.  * internet protocol control block, tcp control block,
  577.  * bufer space, and entering LISTEN state if to accept connections.
  578.  */
  579. int
  580. tcp_attach(so)
  581. struct socket *so;
  582. {
  583. register struct tcpcb *tp;
  584. struct inpcb *inp;
  585. int error;
  587. #ifdef WV_INSTRUMENTATION
  588. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  589.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 41, 9,
  590.                      WV_NETEVENT_TCPATTACH_START, so->so_fd)
  591. #endif  /* INCLUDE_WVNET */
  592. #endif
  594. if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
  595. error = soreserve(so, tcp_sendspace, tcp_recvspace);
  596. if (error)
  597. return (error);
  598. }
  599. error = in_pcballoc(so, &tcbinfo);
  600. if (error)
  601. return (error);
  602. inp = sotoinpcb(so);
  603. tp = tcp_newtcpcb(inp);
  604. if (tp == 0) {
  605. int nofd = so->so_state & SS_NOFDREF; /* XXX */
  607. so->so_state &= ~SS_NOFDREF; /* don't free the socket yet */
  608. in_pcbdetach(inp);
  609. so->so_state |= nofd;
  611. #ifdef WV_INSTRUMENTATION
  612. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  613.         WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_CRITICAL, 33, 3,
  614.                          WV_NETEVENT_TCPATTACH_NOBUFS, so->so_fd)
  615. #endif  /* INCLUDE_WVNET */
  616. #endif
  618. return (ENOBUFS);
  619. }
  620. tp->t_state = TCPS_CLOSED;
  621. return (0);
  622. }
  624. /*
  625.  * Initiate (or continue) disconnect.
  626.  * If embryonic state, just send reset (once).
  627.  * If in ``let data drain'' option and linger null, just drop.
  628.  * Otherwise (hard), mark socket disconnecting and drop
  629.  * current input data; switch states based on user close, and
  630.  * send segment to peer (with FIN).
  631.  */
  632. struct tcpcb *
  633. tcp_disconnect(tp)
  634. register struct tcpcb *tp;
  635. {
  636. struct socket *so = tp->t_inpcb->inp_socket;
  638. #ifdef WV_INSTRUMENTATION
  639. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  640.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 42, 10,
  641.                      WV_NETEVENT_TCPDISCONN_START, so->so_fd)
  642. #endif  /* INCLUDE_WVNET */
  643. #endif
  645. if (tp->t_state < TCPS_ESTABLISHED)
  646. tp = tcp_close(tp);
  647. else if ((so->so_options & SO_LINGER) && so->so_linger == 0)
  648. tp = tcp_drop(tp, 0);
  649. else {
  650. soisdisconnecting(so);
  651. sbflush(&so->so_rcv);
  652. tp = tcp_usrclosed(tp);
  653. if (tp)
  654. (void) tcp_output(tp);
  655. }
  656. return (tp);
  657. }
  659. /*
  660.  * User issued close, and wish to trail through shutdown states:
  661.  * if never received SYN, just forget it.  If got a SYN from peer,
  662.  * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
  663.  * If already got a FIN from peer, then almost done; go to LAST_ACK
  664.  * state.  In all other cases, have already sent FIN to peer (e.g.
  665.  * after PRU_SHUTDOWN), and just have to play tedious game waiting
  666.  * for peer to send FIN or not respond to keep-alives, etc.
  667.  * We can let the user exit from the close as soon as the FIN is acked.
  668.  */
  669. struct tcpcb *
  670. tcp_usrclosed(tp)
  671. register struct tcpcb *tp;
  672. {
  674. switch (tp->t_state) {
  676. case TCPS_CLOSED:
  677. case TCPS_LISTEN:
  678. case TCPS_SYN_SENT:
  679. tp->t_state = TCPS_CLOSED;
  680. tp = tcp_close(tp);
  681. break;
  683. case TCPS_SYN_RECEIVED:
  684. case TCPS_ESTABLISHED:
  685. tp->t_state = TCPS_FIN_WAIT_1;
  686. break;
  688. case TCPS_CLOSE_WAIT:
  689. tp->t_state = TCPS_LAST_ACK;
  690. break;
  691. }
  692. if (tp && tp->t_state >= TCPS_FIN_WAIT_2)
  693. soisdisconnected(tp->t_inpcb->inp_socket);
  694. return (tp);
  695. }
  697. LOCAL void tcpTraceStub ()
  698.     {
  699.     }
  701. LOCAL void tcpReportStub ()
  702.     {
  703.     }