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

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

VxWorks

开发平台：

C/C++

uipc_sock.c：源码内容
  1. /* uipc_sock.c - uipc socket routines */
  3. /* Copyright 1984 - 2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1982, 1986, 1988, 1990, 1993
  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.  * @(#)uipc_socket.c 8.6 (Berkeley) 5/2/95
  39.  */
  41. /*
  42. modification history
  43. --------------------
  44. 01l,05jun02,vvv  fixed Nagle for large writes (SPR #72213)
  45. 01k,12oct01,rae  merge from truestack ver 01r, base 01h (SPR #64845 etc)
  46. 01j,07feb01,spm  updated socket handling to detect memory allocation failures
  47. 01i,24sep98,ham  considered if(m->m_extSize<max_hdr) in sosend() SPR#22209.
  48. 01h,26aug98,n_s  optimized processing of uio buffer in sosend. spr #22246.
  49. 01g,26aug98,n_s  added return val check for MALLOC in socreate and for 
  50.                  mBufClGet in soreceive. spr #22238.
  51. 01f,11aug97,vin  fixed problems in sosend, adjusted space in sosend
  52. 01e,23jan97,vin  added fix for SPR7502.
  53. 01d,03dec96,vin  replaced calloc(..) with MALLOC(..), free(..) with FREE(..)
  54. 01c,22nov96,vin  added cluster support, replaced m_get with mBufClGet and
  55.  m_gethdr with mHdrClGet.
  56. 01b,29aug96,vin  added zerocopy interface. 
  57. 01a,03mar96,vin  created from BSD4.4lite2. Integrated with 02u of uipc_sock.c
  58. */
  60. #include "vxWorks.h"
  61. #include "semLib.h"
  62. #include "memLib.h"
  64. #include "errno.h"
  65. #include "net/mbuf.h"
  66. #include "net/domain.h"
  67. #include "net/protosw.h"
  68. #include "sys/socket.h"
  69. #include "sys/times.h"
  70. #include "net/socketvar.h"
  71. #include "sys/ioctl.h"
  72. #include "net/uio.h"
  73. #include "net/route.h"
  74. #include "netinet/in.h"
  75. #include "net/if.h"
  76. #include "net/systm.h"
  77. #include "selectLib.h"
  78. #include "sockLib.h"
  79. #include "netLib.h"
  81. #ifdef WV_INSTRUMENTATION
  82. #ifdef INCLUDE_WVNET
  83. #include "wvNetLib.h"
  84. #endif
  85. #endif
  87. #ifdef WV_INSTRUMENTATION
  88. #ifdef INCLUDE_WVNET
  89.     /* Set common fields of event identifiers for this module. */
  91. LOCAL UCHAR wvNetModuleId = WV_NET_UISOCK_MODULE;  /* Value for uipc_sock.c */
  92. LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;     /* Available event filter */
  94. LOCAL ULONG wvNetEventId;       /* Event identifier: see wvNetLib.h */
  95. #endif    /* INCLUDE_WVNET */
  96. #endif
  98. extern int uiomove();
  100. /*
  101.  * Socket operation routines.
  102.  * These routines are called by the routines in
  103.  * sys_socket.c or from a system process, and
  104.  * implement the semantics of socket operations by
  105.  * switching out to the protocol specific routines.
  106.  */
  107. /*ARGSUSED*/
  108. int
  109. socreate(dom, aso, type, proto)
  110. int dom;
  111. struct socket **aso;
  112. register int type;
  113. int proto;
  114. {
  115. register struct protosw *prp;
  116. register struct socket *so;
  117. register int error;
  119. #ifdef WV_INSTRUMENTATION
  120. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  121.     WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_VERBOSE, 45, 11,
  122.                      WV_NETEVENT_SOCREATE_START)
  123. #endif  /* INCLUDE_WVNET */
  124. #endif
  126. if (proto)
  127. prp = pffindproto(dom, proto, type);
  128. else
  129. prp = pffindtype(dom, type);
  130. if (prp == 0 || prp->pr_usrreq == 0)
  131.             {
  132. #ifdef WV_INSTRUMENTATION
  133. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  134.             WV_NET_MARKER_3 (NET_AUX_EVENT, WV_NET_ERROR, 43, 6,
  135.                              WV_NETEVENT_SOCREATE_SEARCHFAIL,
  136.                              dom, proto, type)
  137. #endif  /* INCLUDE_WVNET */
  138. #endif
  140.             return (EPROTONOSUPPORT);
  141.             }
  142. if (prp->pr_type != type)
  143.             {
  144. /* XXX - This event does not occur because the search routines will always
  145.  *       return a protocol switch entry which matches the given type value.
  147. #ifdef WV_INSTRUMENTATION
  148. #ifdef INCLUDE_WVNET    /@ WV_NET_ERROR event @/
  149.             WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 44, 7,
  150.                              WV_NETEVENT_SOCREATE_BADTYPE, prp->pr_type, type)
  151. #endif  /@ INCLUDE_WVNET @/
  152. #endif
  154.  * XXX - end of unused event
  155.  */
  156.             return (EPROTOTYPE);
  157.             }
  159.         MALLOC(so, struct socket *, sizeof(*so), MT_SOCKET, M_WAIT);
  160. if (so == (struct socket *) NULL)
  161.     {
  162.     return (ENOBUFS);
  163.     }
  165.         bzero((caddr_t)so, sizeof(*so));
  167. so->so_options = 0; 
  168. so->so_type = type;
  170. /* all sockets will be priveledged */
  171. so->so_state = SS_PRIV;
  172. so->so_proto = prp;
  174. /* initialize socket semaphores */
  176. so->so_timeoSem = semBCreate (SEM_Q_PRIORITY, SEM_EMPTY);
  177.         if (so->so_timeoSem == NULL)
  178.             {
  179.             so->so_state |= SS_NOFDREF;
  180.             sofree(so);
  181.             return (ENOMEM);
  182.             }
  183. so->so_rcv.sb_Sem = semBCreate (SEM_Q_PRIORITY, SEM_EMPTY);
  184.         if (so->so_rcv.sb_Sem == NULL)
  185.             {
  186.             so->so_state |= SS_NOFDREF;
  187.             sofree(so);
  188.             return (ENOMEM);
  189.             }
  190. so->so_snd.sb_Sem = semBCreate (SEM_Q_PRIORITY, SEM_EMPTY);
  191.         if (so->so_snd.sb_Sem == NULL)
  192.             {
  193.             so->so_state |= SS_NOFDREF;
  194.             sofree(so);
  195.             return (ENOMEM);
  196.             }
  198. so->so_rcv.sb_want = 0;
  199. so->so_snd.sb_want = 0;
  201. /* initialize the select stuff */
  203. selWakeupListInit (&so->so_selWakeupList);
  205.         so->selectFlag = TRUE;
  207. error =
  208.     (*prp->pr_usrreq)(so, PRU_ATTACH, (struct mbuf *)0,
  209. (struct mbuf *)(long)proto, (struct mbuf *)0);
  210. if (error) {
  211. so->so_state |= SS_NOFDREF;
  212. sofree(so);
  213. return (error);
  214. }
  215. *aso = so;
  216. return (0);
  217. }
  219. int
  220. sobind(so, nam)
  221. struct socket *so;
  222. struct mbuf *nam;
  223. {
  224. int s = splnet();
  225. int error;
  227. #ifdef WV_INSTRUMENTATION
  228. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  229.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 46, 12,
  230.                      WV_NETEVENT_SOBIND_START, so->so_fd)
  231. #endif  /* INCLUDE_WVNET */
  232. #endif
  234. error =
  235.     (*so->so_proto->pr_usrreq)(so, PRU_BIND,
  236. (struct mbuf *)0, nam, (struct mbuf *)0);
  237. splx(s);
  238. return (error);
  239. }
  241. int
  242. solisten(so, backlog)
  243. register struct socket *so;
  244. int backlog;
  245. {
  246. int s = splnet(), error;
  248. #ifdef WV_INSTRUMENTATION
  249. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  250.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 47, 13,
  251.                      WV_NETEVENT_SOLISTEN_START, so->so_fd)
  252. #endif  /* INCLUDE_WVNET */
  253. #endif
  255. error =
  256.     (*so->so_proto->pr_usrreq)(so, PRU_LISTEN,
  257. (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0);
  258. if (error) {
  259. splx(s);
  260. return (error);
  261. }
  262. if (so->so_q == 0)
  263. so->so_options |= SO_ACCEPTCONN;
  264. if (backlog < 0)
  265. backlog = 0;
  266. so->so_qlimit = min(backlog, SOMAXCONN);
  267. splx(s);
  268. return (0);
  269. }
  271. void sofree
  272.     (
  273.     register struct socket *so
  274.     )
  275.     {
  276. #ifdef WV_INSTRUMENTATION
  277. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  278.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 48, 14,
  279.                      WV_NETEVENT_SOFREE_START, so->so_fd)
  280. #endif  /* INCLUDE_WVNET */
  281. #endif
  283.     if (so->so_state & SS_NOFDREF)
  284.         {
  285.         /*
  286.          * Always remove semaphores when closing socket. Existing TCP
  287.          * connections exit after the next test, preventing correct
  288.          * reclamation of these objects.
  289.          */
  291.         if (so->so_timeoSem)
  292.             {
  293.             semDelete (so->so_timeoSem);
  294.             so->so_timeoSem = NULL;
  295.             }
  296.         if (so->so_snd.sb_Sem)
  297.             {
  298.             semDelete (so->so_snd.sb_Sem);
  299.             so->so_snd.sb_Sem = NULL;
  300.             }
  301.         if (so->so_rcv.sb_Sem)
  302.             {
  303.             semDelete (so->so_rcv.sb_Sem);
  304.             so->so_rcv.sb_Sem = NULL;
  305.             }
  307.         if (so->selectFlag)
  308.             {
  309.             selWakeupListTerm (&so->so_selWakeupList);
  310.             so->selectFlag = FALSE;
  311.             }
  312.         }
  313.  
  314.     if (so->so_pcb || (so->so_state & SS_NOFDREF) == 0)
  315.         return;
  317.     if (so->so_head)
  318.         {
  319.         if (!soqremque (so, 0) && !soqremque (so, 1))
  320.             {
  321. #ifdef WV_INSTRUMENTATION
  322. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  323.             WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_EMERGENCY, 38, 1,
  324.                              WV_NETEVENT_SOFREE_PANIC, so->so_fd)
  325. #endif  /* INCLUDE_WVNET */
  326. #endif
  328.             panic ("sofree dq");
  329.             }
  330.         so->so_head = 0;
  331.         }
  332.     sbrelease (&so->so_snd);
  333.     sorflush (so);
  335.     FREE (so, MT_SOCKET); 
  336.     }
  339. /*
  340.  * Close a socket on last file table reference removal.
  341.  * Initiate disconnect if connected.
  342.  * Free socket when disconnect complete.
  343.  */
  345. int soclose
  346.     (
  347.     register struct socket *so
  348.     )
  349.     {
  350.     int s = splnet(); /* conservative */
  351.     int error = 0;
  352.     SEL_WAKEUP_NODE *pWakeupNode;
  353.     SEL_WAKEUP_LIST *pWakeupList;
  355. #ifdef WV_INSTRUMENTATION
  356. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  357.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 49, 15,
  358.                      WV_NETEVENT_SOCLOSE_START, so->so_fd)
  359. #endif  /* INCLUDE_WVNET */
  360. #endif
  362.     if (so->so_options & SO_ACCEPTCONN)
  363.         {
  364.         while (so->so_q0)
  365.                (void) soabort(so->so_q0);
  366.         while (so->so_q)
  367.                (void) soabort(so->so_q);
  368.         }
  369.     if (so->so_pcb == 0)
  370.         goto discard;
  371.     if (so->so_state & SS_ISCONNECTED)
  372.         {
  373.         if ((so->so_state & SS_ISDISCONNECTING) == 0)
  374.             {
  375.             error = sodisconnect(so);
  376.             if (error)
  377.                 goto drop;
  378.             }
  379.         if (so->so_options & SO_LINGER)
  380.             {
  381.             if ( (so->so_state & SS_ISDISCONNECTING) &&
  382.                 (so->so_state & SS_NBIO))
  383.                 goto drop;
  384.             while (so->so_state & SS_ISCONNECTED)
  385.                 {
  386. #ifdef WV_INSTRUMENTATION
  387. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  388.                 WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_INFO, 52, 10,
  389.                                  WV_NETEVENT_SOCLOSE_WAIT, so->so_fd)
  390. #endif  /* INCLUDE_WVNET */
  391. #endif
  393.                 ksleep(so->so_timeoSem);
  394.                 }
  395.             }
  396.         }
  397. drop:
  398.     if (so->so_pcb)
  399.         {
  400.         int error2 = (*so->so_proto->pr_usrreq) (so, PRU_DETACH,
  401.                                                  (struct mbuf *)0, 
  402.                                                  (struct mbuf *)0, 
  403.                                                  (struct mbuf *)0);
  404.         if (error == 0)
  405.             error = error2;
  406.         }
  407. discard:
  409.     /* clean up the select wakeup list for this socket */
  411.     pWakeupList = &so->so_selWakeupList;
  413.     if (lstCount (&pWakeupList->wakeupList) != 0)
  414.         {
  415.         semTake (&pWakeupList->listMutex, WAIT_FOREVER);
  417.         while ((pWakeupNode =
  418.           (SEL_WAKEUP_NODE *) lstFirst (&pWakeupList->wakeupList)))
  419.     soo_unselect (so, pWakeupNode);
  421. semGive (&pWakeupList->listMutex);
  422. }
  424.     if (so->so_state & SS_NOFDREF)
  425.         {
  426. #ifdef WV_INSTRUMENTATION
  427. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  428.         WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_EMERGENCY, 39, 2,
  429.                          WV_NETEVENT_SOCLOSE_PANIC, so->so_fd)
  430. #endif  /* INCLUDE_WVNET */
  431. #endif
  432.     
  433.         panic ("soclose: NOFDREF");
  434.         }
  435.     so->so_state |= SS_NOFDREF;
  436.     sofree (so);
  437.     splx (s);
  438.     return (error);
  439.     }
  441. /*
  442.  * Must be called at splnet...
  443.  */
  444. int soabort
  445.     (
  446.     struct socket *so
  447.     )
  448.     {
  449. #ifdef WV_INSTRUMENTATION
  450. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  451.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 50, 16,
  452.                      WV_NETEVENT_SOABORT_START, so->so_fd)
  453. #endif  /* INCLUDE_WVNET */
  454. #endif
  456.     return ( (*so->so_proto->pr_usrreq) (so, PRU_ABORT, (struct mbuf *)0,
  457.                                          (struct mbuf *)0, (struct mbuf *)0));
  458.     }
  460. int
  461. soaccept(so, nam)
  462. register struct socket *so;
  463. struct mbuf *nam;
  464. {
  465. int s = splnet();
  466. int error;
  468. #ifdef WV_INSTRUMENTATION
  469. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  470.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 51, 17,
  471.                      WV_NETEVENT_SOACCEPT_START, so->so_fd)
  472. #endif  /* INCLUDE_WVNET */
  473. #endif
  475.     if ( (so->so_state & SS_NOFDREF) == 0)
  476.         {
  477. #ifdef WV_INSTRUMENTATION
  478. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  479.         WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_EMERGENCY, 40, 3,
  480.                          WV_NETEVENT_SOACCEPT_PANIC, so->so_fd)
  481. #endif  /* INCLUDE_WVNET */
  482. #endif
  484.         panic("soaccept: !NOFDREF");
  485.         }
  486.     so->so_state &= ~SS_NOFDREF;
  487.     error = (*so->so_proto->pr_usrreq)(so, PRU_ACCEPT, (struct mbuf *)0, 
  488.                                        nam, (struct mbuf *)0);
  489.     splx (s);
  490.     return (error);
  491.     }
  493. int
  494. soconnect(so, nam)
  495. register struct socket *so;
  496. struct mbuf *nam;
  497. {
  498. int s;
  499. int error;
  501. #ifdef WV_INSTRUMENTATION
  502. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  503.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 52, 18,
  504.                      WV_NETEVENT_SOCONNECT_START, so->so_fd)
  505. #endif  /* INCLUDE_WVNET */
  506. #endif
  508. if (so->so_options & SO_ACCEPTCONN)
  509.             {
  510. #ifdef WV_INSTRUMENTATION
  511. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  512.             WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_ERROR, 45, 8,
  513.                              WV_NETEVENT_SOCONNECT_BADSOCK, so->so_fd)
  514. #endif  /* INCLUDE_WVNET */
  515. #endif
  517.             return (EOPNOTSUPP);
  518.             }
  520. s = splnet();
  521. /*
  522.  * If protocol is connection-based, can only connect once.
  523.  * Otherwise, if connected, try to disconnect first.
  524.  * This allows user to disconnect by connecting to, e.g.,
  525.  * a null address.
  526.  */
  527. if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING) &&
  528.     ((so->so_proto->pr_flags & PR_CONNREQUIRED) ||
  529.     (error = sodisconnect(so))))
  530. error = EISCONN;
  531. else
  532. error = (*so->so_proto->pr_usrreq)(so, PRU_CONNECT,
  533.     (struct mbuf *)0, nam, (struct mbuf *)0);
  534. splx(s);
  535. return (error);
  536. }
  538. int
  539. soconnect2(so1, so2)
  540. register struct socket *so1;
  541. struct socket *so2;
  542. {
  543. int s = splnet();
  544. int error;
  546. /*
  547.  * XXX - This event cannot currently occur: the socket operation which uses
  548.  *       the soconnect2() routine is not supported by VxWorks
  550. #ifdef WV_INSTRUMENTATION
  551. #ifdef INCLUDE_WVNET    /@ WV_NET_VERBOSE event @/
  552.     WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_VERBOSE, 53, 19,
  553.                      WV_NETEVENT_SOCONNECT2_START, so1->so_fd, so2->so_fd)
  554. #endif  /@ INCLUDE_WVNET @/
  555. #endif
  557.  * XXX - end of unused event
  558.  */
  560. error = (*so1->so_proto->pr_usrreq)(so1, PRU_CONNECT2,
  561.     (struct mbuf *)0, (struct mbuf *)so2, (struct mbuf *)0);
  562. splx(s);
  563. return (error);
  564. }
  566. int
  567. sodisconnect(so)
  568. register struct socket *so;
  569. {
  570. int s = splnet();
  571. int error;
  573. if ((so->so_state & SS_ISCONNECTED) == 0) {
  574. error = ENOTCONN;
  575. goto bad;
  576. }
  577. if (so->so_state & SS_ISDISCONNECTING) {
  578. error = EALREADY;
  579. goto bad;
  580. }
  581. error = (*so->so_proto->pr_usrreq)(so, PRU_DISCONNECT,
  582.     (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0);
  583. bad:
  584. splx(s);
  586. #ifdef WV_INSTRUMENTATION
  587. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  588.     WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 46, 9,
  589.                      WV_NETEVENT_SODISCONN_STATUS, so->so_fd, error)
  590. #endif  /* INCLUDE_WVNET */
  591. #endif
  593. return (error);
  594. }
  596. #define SBLOCKWAIT(f) (((f) & MSG_DONTWAIT) ? M_DONTWAIT : M_WAIT)
  597. /*
  598.  * Send on a socket.
  599.  * If send must go all at once and message is larger than
  600.  * send buffering, then hard error.
  601.  * Lock against other senders.
  602.  * If must go all at once and not enough room now, then
  603.  * inform user that this would block and do nothing.
  604.  * Otherwise, if nonblocking, send as much as possible.
  605.  * The data to be sent is described by "uio" if nonzero,
  606.  * otherwise by the mbuf chain "top" (which must be null
  607.  * if uio is not).  Data provided in mbuf chain must be small
  608.  * enough to send all at once.
  609.  *
  610.  * Returns nonzero on error, timeout or signal; callers
  611.  * must check for short counts if EINTR/ERESTART are returned.
  612.  * Data and control buffers are freed on return.
  613.  *
  614.  * WRS mods removed sblock and sbunlock and replaced with splnet and splx
  615.  * which should serve the purpose.
  616.  * Removed null check of uio so that blocking can be implemented for zbufs
  617.  * also. 
  618.  * CAVEAT: the zbuf length cannot be more than the socket high water mark.
  619.  * The user should implement his flow control. 
  620.  * So this call would block only if zbuf length is bigger the space available
  621.  * in the socket buffer and less than the socket higt water mark. 
  622.  * Added a flag canWait which is set to M_DONTWAIT if the socket option SS_NBIO
  623.  * is set. This prevents blocking if the user chose SS_NBIO and for some reason
  624.  * if the system runs out of mbufs. canWait defaults to M_WAIT -(vinai).
  625.  */
  626. int
  627. sosend(so, addr, uio, top, control, flags)
  628. register struct socket *so;
  629. struct mbuf *addr;
  630. struct uio *uio;
  631. struct mbuf *top;
  632. struct mbuf *control;
  633. int flags;
  634. {
  635. struct mbuf **mp;
  636. register struct mbuf *m;
  637. register long space, len, resid;
  638. int clen = 0, error, s, dontroute;
  639. int atomic = sosendallatonce(so) || top;
  640. register int canWait;
  641. int outcount = 0;
  643. if (uio)
  644. resid = uio->uio_resid;
  645. else
  646. resid = top->m_pkthdr.len;
  647. /*
  648.  * In theory resid should be unsigned.
  649.  * However, space must be signed, as it might be less than 0
  650.  * if we over-committed, and we must use a signed comparison
  651.  * of space and resid.  On the other hand, a negative resid
  652.  * causes us to loop sending 0-length segments to the protocol.
  653.  */
  654. if (resid < 0)
  655. return (EINVAL);
  656. dontroute =
  657.     (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
  658.     (so->so_proto->pr_flags & PR_ATOMIC);
  660. if (control)
  661. clen = control->m_len;
  663. canWait = (so->so_state & SS_NBIO) ? M_DONTWAIT : M_WAIT;
  665. #define snderr(errno) { error = errno; splx(s); goto out; }
  667. s = splnet();
  668. restart:
  669. do {
  670. if (so->so_state & SS_CANTSENDMORE)
  671. snderr(EPIPE);
  672. if (so->so_error)
  673. snderr(so->so_error);
  674. if ((so->so_state & SS_ISCONNECTED) == 0) {
  675. if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
  676. if ((so->so_state & SS_ISCONFIRMING) == 0 &&
  677.     !(resid == 0 && clen != 0))
  678. snderr(ENOTCONN);
  679. } else if (addr == 0)
  680. snderr(EDESTADDRREQ);
  681. }
  682. space = sbspace(&so->so_snd);
  683. if (flags & MSG_OOB)
  684. space += 1024;
  685. if (atomic && ((resid > so->so_snd.sb_hiwat) ||
  686.     (clen > so->so_snd.sb_hiwat)))
  687. snderr(EMSGSIZE);
  688. if (space < resid + clen && 
  689.     (atomic || space < so->so_snd.sb_lowat || space < clen)) {
  690. if (so->so_state & SS_NBIO)
  691.     {
  692.     if (flags & MSG_MBUF)
  693. top = NULL; /* don't free the zero copy mbuf */
  694.     snderr(EWOULDBLOCK);
  695.     }
  696. sbwait(&so->so_snd);
  697. goto restart;
  698. }
  699. mp = &top;
  700. space -= clen;
  701. do {
  702.     if (uio == NULL) {
  703. /*
  704.  * Data is prepackaged in "top".
  705.  */
  706. resid = 0;
  707. if (flags & MSG_EOR)
  708. top->m_flags |= M_EOR;
  709.     } else do {
  710.         len = min(resid, space);
  712. if (top == 0) {
  713.         m = mBufClGet(canWait, MT_DATA, len + max_hdr,
  714.       FALSE);
  715. if (m == NULL)
  716.     snderr(ENOBUFS);
  717. len = min(len, m->m_extSize);
  719. m->m_flags |= M_PKTHDR;
  720. m->m_pkthdr.len = 0;
  721. m->m_pkthdr.rcvif = (struct ifnet *)0;
  722.                                 /*
  723.                                  * the assumption here is that max_hdr is
  724.                                  * always less than the minimum cluster size
  725.                                  * available.  Or don't set len, namely use
  726.                                  * len which set by min() above.
  727.                                  */
  728.                                 if (atomic && m->m_extSize > max_hdr) {
  729.                                  len = min((m->m_extSize - max_hdr),
  730.                                                   len);
  731.                                         m->m_data += max_hdr;
  732.                                 }
  733. }
  734. else
  735.     {
  736.     m = mBufClGet(canWait, MT_DATA, len, FALSE);
  737.     if (m == NULL)
  738. snderr(ENOBUFS);
  739.     len = min(len, m->m_extSize);
  740.     }
  741.                    
  742. space -= (m->m_extSize + MSIZE);
  743. error = uiomove(mtod(m, caddr_t), (int)len, uio);
  744. resid = uio->uio_resid;
  745. m->m_len = len;
  746. *mp = m;
  747. top->m_pkthdr.len += len;
  748. if (error)
  749. goto release;
  750. mp = &m->m_next;
  751. if (resid <= 0) {
  752. if (flags & MSG_EOR)
  753. top->m_flags |= M_EOR;
  754. break;
  755. }
  756.     } while (space > 0 && atomic);
  757.     if (dontroute)
  758.     so->so_options |= SO_DONTROUTE;
  760.                     if (!sosendallatonce (so))
  761. {
  762.         top->m_flags &= ~M_EOB;
  763.         if (((resid == 0) || (space <= 0)) && (outcount > 0))
  764.     top->m_flags |= M_EOB;
  765.                         outcount++;
  766.                         if (resid)
  767.     top->m_flags &= ~M_EOB;
  768.                         }
  770.     error = (*so->so_proto->pr_usrreq)(so,
  771. (flags & MSG_OOB) ? PRU_SENDOOB : PRU_SEND,
  772. top, addr, control);
  773.     if (dontroute)
  774.     so->so_options &= ~SO_DONTROUTE;
  775.     clen = 0;
  776.     control = 0;
  777.     top = 0;
  778.     mp = &top;
  779.     if (error)
  780. goto release;
  781. } while (resid && space > 0);
  782. } while (resid);
  784. release:
  785. splx(s);
  786. out:
  787. if (top)
  788. m_freem(top);
  789. if (control)
  790. m_freem(control);
  792. if (error != 0)
  793.             {
  794. #ifdef WV_INSTRUMENTATION
  795. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  796.             WV_NET_EVENT_2 (NET_CORE_EVENT, WV_NET_CRITICAL, 34, 4,
  797.                             WV_NETEVENT_SOSEND_FAIL, WV_NET_SEND,
  798.                             so->so_fd, error)
  799. #endif  /* INCLUDE_WVNET */
  800. #endif
  802.     netErrnoSet (error);
  803.             }
  804. #ifdef WV_INSTRUMENTATION
  805. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  806.         else
  807.             {
  808.             WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_VERBOSE, 54, 20,
  809.                             WV_NETEVENT_SOSEND_FINISH, WV_NET_SEND, so->so_fd)
  810.             }
  811. #endif  /* INCLUDE_WVNET */
  812. #endif
  814. return (error);
  815. }
  817. /*
  818.  * Implement receive operations on a socket.
  819.  * We depend on the way that records are added to the sockbuf
  820.  * by sbappend*.  In particular, each record (mbufs linked through m_next)
  821.  * must begin with an address if the protocol so specifies,
  822.  * followed by an optional mbuf or mbufs containing ancillary data,
  823.  * and then zero or more mbufs of data.
  824.  * In order to avoid blocking network interrupts for the entire time here,
  825.  * we splx() while doing the actual copy to user space.
  826.  * Although the sockbuf is locked, new data may still be appended,
  827.  * and thus we must maintain consistency of the sockbuf during that time.
  828.  *
  829.  * The caller may receive the data as a single mbuf chain by supplying
  830.  * an mbuf **mp0 for use in returning the chain.  The uio is then used
  831.  * only for the count in uio_resid.
  832.  *
  833.  * WRS mods: implement zero copy if out of band data is requested.
  834.  */
  835. int
  836. soreceive(so, paddr, uio, mp0, controlp, flagsp)
  837. register struct socket *so;
  838. struct mbuf **paddr;
  839. struct uio *uio;
  840. struct mbuf **mp0;
  841. struct mbuf **controlp;
  842. int *flagsp;
  843. {
  844. register struct mbuf *m, **mp;
  845. register int flags, len, error = 0, s, offset;
  846. struct protosw *pr = so->so_proto;
  847. struct mbuf *nextrecord;
  848. int moff, type = 0;
  849. int orig_resid = uio->uio_resid;
  851. mp = mp0;
  852. if (paddr)
  853. *paddr = 0;
  854. if (controlp)
  855. *controlp = 0;
  856. if (flagsp)
  857. flags = *flagsp &~ MSG_EOR;
  858. else
  859. flags = 0;
  861. /* this is the zero copy ptr To ptr to mbuf passed */
  862. if (mp)
  863. *mp = (struct mbuf *)0;
  865. if (flags & MSG_OOB) {
  866. m = mBufClGet(M_WAIT, MT_DATA, CL_SIZE_128, TRUE);
  867. if (m == (struct mbuf *) NULL)
  868.     {
  869.     return (ENOBUFS);
  870.     }
  872. error = (*pr->pr_usrreq)(so, PRU_RCVOOB, m,
  873.     (struct mbuf *)(long)(flags & MSG_PEEK), (struct mbuf *)0);
  874. if (error)
  875. goto bad;
  877. if (mp) do {  /* if zero copy interface */
  878.     uio->uio_resid -= m->m_len; 
  879.     *mp = m; 
  880.     mp = &m->m_next; 
  881.     m = m->m_next; 
  882. } while (*mp);  
  883. else do { /* if not zero copy iface */
  884. error = uiomove(mtod(m, caddr_t),
  885.     (int) min(uio->uio_resid, m->m_len), uio);
  886. m = m_free(m);
  887. } while (uio->uio_resid && error == 0 && m);
  888. bad:
  889. if (m)
  890. m_freem(m);
  891. netErrnoSet (error);
  892. return (error);
  893. }
  895. if (so->so_state & SS_ISCONFIRMING && uio->uio_resid)
  896. (*pr->pr_usrreq)(so, PRU_RCVD, (struct mbuf *)0,
  897.     (struct mbuf *)0, (struct mbuf *)0);
  899. s = splnet();
  901. restart:
  902. m = so->so_rcv.sb_mb;
  904. /*
  905.  * If we have less data than requested, block awaiting more
  906.  * (subject to any timeout) if:
  907.  *   1. the current count is less than the low water mark, or
  908.  *   2. MSG_WAITALL is set, and it is possible to do the entire
  909.  * receive operation at once if we block (resid <= hiwat), or
  910.  *   3. MSG_DONTWAIT is not set.
  911.  * If MSG_WAITALL is set but resid is larger than the receive buffer,
  912.  * we have to do the receive in sections, and thus risk returning
  913.  * a short count if a timeout or signal occurs after we start.
  914.  */
  915. if ( m == 0 ||
  916.              ( ((flags & MSG_DONTWAIT) == 0) &&
  917.        (so->so_rcv.sb_cc < uio->uio_resid) &&
  918.        (so->so_rcv.sb_cc < so->so_rcv.sb_lowat)
  919.              ) ||
  920.      ( (flags & MSG_WAITALL) &&
  921.                (uio->uio_resid <= so->so_rcv.sb_hiwat) &&
  922.        (m->m_nextpkt == 0) &&
  923.                ((pr->pr_flags & PR_ATOMIC) == 0)
  924.              ) 
  925.            ) {
  926. #ifdef DIAGNOSTIC
  927. if (m == 0 && so->so_rcv.sb_cc)
  928. panic("receive 1");
  929. #endif
  930. if (so->so_error) {
  931. if (m)
  932. goto dontblock;
  933. error = so->so_error;
  934. if ((flags & MSG_PEEK) == 0)
  935. so->so_error = 0;
  936. goto release;
  937. }
  938. if (so->so_state & SS_CANTRCVMORE) {
  939. if (m)
  940. goto dontblock;
  941. else
  942. goto release;
  943. }
  944. for (; m; m = m->m_next)
  945. if (m->m_type == MT_OOBDATA  || (m->m_flags & M_EOR)) {
  946. m = so->so_rcv.sb_mb;
  947. goto dontblock;
  948. }
  949. if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 &&
  950.     (so->so_proto->pr_flags & PR_CONNREQUIRED)) {
  951. error = ENOTCONN;
  952. goto release;
  953. }
  954. if (uio->uio_resid == 0)
  955. goto release;
  956. if ((so->so_state & SS_NBIO) || (flags & MSG_DONTWAIT)) {
  957. error = EWOULDBLOCK;
  958. goto release;
  959. }
  960. sbwait(&so->so_rcv);
  961. goto restart;
  962. }
  963. dontblock:
  964. nextrecord = m->m_nextpkt;
  965. if (pr->pr_flags & PR_ADDR) {
  966. #ifdef DIAGNOSTIC
  967. if (m->m_type != MT_SONAME)
  968. panic("receive 1a");
  969. #endif
  970. orig_resid = 0;
  971. if (flags & MSG_PEEK) {
  972. if (paddr)
  973. *paddr = m_copy(m, 0, m->m_len);
  974. m = m->m_next;
  975. } else {
  976. sbfree(&so->so_rcv, m);
  977. if (paddr) {
  978. *paddr = m;
  979. so->so_rcv.sb_mb = m->m_next;
  980. m->m_next = 0;
  981. m = so->so_rcv.sb_mb;
  982. } else {
  983. so->so_rcv.sb_mb = m_free(m);
  984. m = so->so_rcv.sb_mb;
  985. }
  986. }
  987. }
  988. while (m && m->m_type == MT_CONTROL && error == 0) {
  989. if (flags & MSG_PEEK) {
  990. if (controlp)
  991. *controlp = m_copy(m, 0, m->m_len);
  992. m = m->m_next;
  993. } else {
  994. sbfree(&so->so_rcv, m);
  995. if (controlp) {
  996. if (pr->pr_domain->dom_externalize &&
  997.     mtod(m, struct cmsghdr *)->cmsg_type ==
  998.     SCM_RIGHTS)
  999.    error = (*pr->pr_domain->dom_externalize)(m);
  1000. *controlp = m;
  1001. so->so_rcv.sb_mb = m->m_next;
  1002. m->m_next = 0;
  1003. m = so->so_rcv.sb_mb;
  1004. } else {
  1005. so->so_rcv.sb_mb = m_free(m);
  1006. m = so->so_rcv.sb_mb;
  1007. }
  1008. }
  1009. if (controlp) {
  1010. orig_resid = 0;
  1011. controlp = &(*controlp)->m_next;
  1012. }
  1013. }
  1014. if (m) {
  1015. if ((flags & MSG_PEEK) == 0)
  1016. m->m_nextpkt = nextrecord;
  1017. type = m->m_type;
  1018. if (type == MT_OOBDATA)
  1019. flags |= MSG_OOB;
  1020. }
  1021. moff = 0;
  1022. offset = 0;
  1023. while (m && uio->uio_resid > 0 && error == 0) {
  1024. if (m->m_type == MT_OOBDATA) {
  1025. if (type != MT_OOBDATA)
  1026. break;
  1027. } else if (type == MT_OOBDATA)
  1028. break;
  1029. #ifdef DIAGNOSTIC
  1030. else if (m->m_type != MT_DATA && m->m_type != MT_HEADER)
  1031. panic("receive 3");
  1032. #endif
  1033. so->so_state &= ~SS_RCVATMARK;
  1034. len = uio->uio_resid;
  1035. if (so->so_oobmark && len > so->so_oobmark - offset)
  1036. len = so->so_oobmark - offset;
  1037. if (len > m->m_len - moff)
  1038. len = m->m_len - moff;
  1039. /*
  1040.  * If mp is set, just pass back the mbufs.
  1041.  * Otherwise copy them out via the uio, then free.
  1042.  * Sockbuf must be consistent here (points to current mbuf,
  1043.  * it points to next record) when we drop priority;
  1044.  * we must note any additions to the sockbuf when we
  1045.  * block interrupts again.
  1046.  */
  1047. if (mp == 0) {
  1048. error = uiomove(mtod(m, caddr_t) + moff, (int)len, uio);
  1049. } else
  1050. uio->uio_resid -= len;
  1051. if (len == m->m_len - moff) {
  1052. if (m->m_flags & M_EOR)
  1053. flags |= MSG_EOR;
  1054. if (flags & MSG_PEEK) {
  1055. m = m->m_next;
  1056. moff = 0;
  1057. } else {
  1058. nextrecord = m->m_nextpkt;
  1059. sbfree(&so->so_rcv, m);
  1060. if (mp) {
  1061. *mp = m;
  1062. mp = &m->m_next;
  1063. so->so_rcv.sb_mb = m = m->m_next;
  1064. *mp = (struct mbuf *)0;
  1065. } else {
  1066. so->so_rcv.sb_mb = m_free(m);
  1067. m = so->so_rcv.sb_mb;
  1068. }
  1069. if (m)
  1070. m->m_nextpkt = nextrecord;
  1071. }
  1072. } else {
  1073. if (flags & MSG_PEEK)
  1074. moff += len;
  1075. else {
  1076. if (mp)
  1077.                                     {
  1078.     *mp = m_copym(m, 0, len, M_WAIT);
  1079.                                     if (*mp == NULL)
  1080.                                         {
  1081.                                         error = ENOBUFS;
  1082.                                         goto release;
  1083.                                         }
  1084.                                     }
  1085. m->m_data += len;
  1086. m->m_len -= len;
  1087. so->so_rcv.sb_cc -= len;
  1088. }
  1089. }
  1090. if (so->so_oobmark) {
  1091. if ((flags & MSG_PEEK) == 0) {
  1092. so->so_oobmark -= len;
  1093. if (so->so_oobmark == 0) {
  1094. so->so_state |= SS_RCVATMARK;
  1095. break;
  1096. }
  1097. } else {
  1098. offset += len;
  1099. if (offset == so->so_oobmark)
  1100. break;
  1101. }
  1102. }
  1103. if (flags & MSG_EOR)
  1104. break;
  1105. /*
  1106.  * If the MSG_WAITALL flag is set (for non-atomic socket),
  1107.  * we must not quit until "uio->uio_resid == 0" or an error
  1108.  * termination.  If a signal/timeout occurs, return
  1109.  * with a short count but without error.
  1110.  * Keep sockbuf locked against other readers.
  1111.  */
  1112. while (flags & MSG_WAITALL && m == 0 && uio->uio_resid > 0 &&
  1113.     !sosendallatonce(so) && !nextrecord) {
  1114. if (so->so_error || so->so_state & SS_CANTRCVMORE)
  1115. break;
  1116. sbwait(&so->so_rcv);
  1118. if ((m = so->so_rcv.sb_mb))
  1119. nextrecord = m->m_nextpkt;
  1120. }
  1121. }
  1123. if (m && pr->pr_flags & PR_ATOMIC) {
  1124. flags |= MSG_TRUNC;
  1125. if ((flags & MSG_PEEK) == 0)
  1126. (void) sbdroprecord(&so->so_rcv);
  1127. }
  1128. if ((flags & MSG_PEEK) == 0) {
  1129. if (m == 0)
  1130. so->so_rcv.sb_mb = nextrecord;
  1131. if (pr->pr_flags & PR_WANTRCVD && so->so_pcb)
  1132. (*pr->pr_usrreq)(so, PRU_RCVD, (struct mbuf *)0,
  1133.     (struct mbuf *)(long)flags, (struct mbuf *)0,
  1134.     (struct mbuf *)0);
  1135. }
  1136. if (orig_resid == uio->uio_resid && orig_resid &&
  1137.     (flags & MSG_EOR) == 0 && (so->so_state & SS_CANTRCVMORE) == 0) {
  1138. goto restart;
  1139. }
  1141. if (flagsp)
  1142. *flagsp |= flags;
  1143. release:
  1144. splx(s);
  1146. if (error != 0)
  1147.             {
  1148. #ifdef WV_INSTRUMENTATION
  1149. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  1150.             WV_NET_EVENT_2 (NET_CORE_EVENT, WV_NET_CRITICAL, 35, 5,
  1151.                             WV_NETEVENT_SORECV_FAIL, WV_NET_RECV,
  1152.                             so->so_fd, error)
  1153. #endif  /* INCLUDE_WVNET */
  1154. #endif
  1156.     netErrnoSet (error);
  1157.             }
  1158. #ifdef WV_INSTRUMENTATION
  1159. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  1160.         else
  1161.             {
  1162.             WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_VERBOSE, 55, 21,
  1163.                             WV_NETEVENT_SORECV_FINISH, WV_NET_RECV, so->so_fd)
  1164.             }
  1165. #endif  /* INCLUDE_WVNET */
  1166. #endif
  1168. return (error);
  1169. }
  1171. int
  1172. soshutdown(so, how)
  1173. register struct socket *so;
  1174. register int how;
  1175. {
  1176. register struct protosw *pr = so->so_proto;
  1178. #ifdef WV_INSTRUMENTATION
  1179. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  1180.     WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_VERBOSE, 56, 22,
  1181.                      WV_NETEVENT_SOSHUTDOWN_START, so->so_fd, how)
  1182. #endif  /* INCLUDE_WVNET */
  1183. #endif
  1185. how++;
  1186. if (how & 1) /* <=> FREAD of BSD44 */
  1187. sorflush(so);
  1188. if (how & 2) /* <=> FWRITE of BSD44 */
  1189. return ((*pr->pr_usrreq)(so, PRU_SHUTDOWN,
  1190.     (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0));
  1191. return (0);
  1192. }
  1194. void
  1195. sorflush(so)
  1196. register struct socket *so;
  1197. {
  1198. register struct sockbuf *sb = &so->so_rcv;
  1199. register struct protosw *pr = so->so_proto;
  1200. register int s;
  1201. struct sockbuf asb;
  1203. sb->sb_flags |= SB_NOINTR;
  1204. s = splimp();
  1205. socantrcvmore(so);
  1206. asb = *sb;
  1207.         if (sb->sb_Sem)
  1208.             {
  1209.     semDelete (sb->sb_Sem);
  1210.             sb->sb_Sem = NULL;
  1211.             }
  1212. bzero((caddr_t)sb, sizeof (*sb));
  1213. splx(s);
  1214. if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose)
  1215. (*pr->pr_domain->dom_dispose)(asb.sb_mb);
  1216. sbrelease(&asb);
  1217. }
  1219. int
  1220. sosetopt(so, level, optname, m0)
  1221. register struct socket *so;
  1222. int level, optname;
  1223. struct mbuf *m0;
  1224. {
  1225. int error = 0;
  1226. register struct mbuf *m = m0;
  1228. if (level != SOL_SOCKET) {
  1229. if (so->so_proto && so->so_proto->pr_ctloutput)
  1230. return ((*so->so_proto->pr_ctloutput)
  1231.   (PRCO_SETOPT, so, level, optname, &m0));
  1232. error = ENOPROTOOPT;
  1233. } else {
  1234. switch (optname) {
  1236. case SO_LINGER:
  1237. if (m == NULL || m->m_len != sizeof (struct linger)) {
  1238. error = EINVAL;
  1239. goto bad;
  1240. }
  1241. so->so_linger = mtod(m, struct linger *)->l_linger;
  1242. /* fall thru... */
  1244. case SO_DEBUG:
  1245. case SO_KEEPALIVE:
  1246. case SO_DONTROUTE:
  1247. case SO_USELOOPBACK:
  1248. case SO_BROADCAST:
  1249. case SO_REUSEADDR:
  1250. case SO_REUSEPORT:
  1251. case SO_OOBINLINE:
  1252.                 case SO_USEPATHMTU:
  1253. if (m == NULL || m->m_len < sizeof (int)) {
  1254. error = EINVAL;
  1255. goto bad;
  1256. }
  1257. if (*mtod(m, int *))
  1258. so->so_options |= optname;
  1259. else
  1260. so->so_options &= ~optname;
  1261. break;
  1263. case SO_SNDBUF:
  1264. case SO_RCVBUF:
  1265. case SO_SNDLOWAT:
  1266. case SO_RCVLOWAT:
  1267. if (m == NULL || m->m_len < sizeof (int)) {
  1268. error = EINVAL;
  1269. goto bad;
  1270. }
  1271. switch (optname) {
  1273. case SO_SNDBUF:
  1274. case SO_RCVBUF:
  1275. if (sbreserve(optname == SO_SNDBUF ?
  1276.     &so->so_snd : &so->so_rcv,
  1277.     (u_long) *mtod(m, int *)) == 0) {
  1278. error = ENOBUFS;
  1279. goto bad;
  1280. }
  1281. break;
  1283. case SO_SNDLOWAT:
  1284. so->so_snd.sb_lowat = *mtod(m, int *);
  1285. break;
  1286. case SO_RCVLOWAT:
  1287. so->so_rcv.sb_lowat = *mtod(m, int *);
  1288. break;
  1289. }
  1290. break;
  1292. case SO_SNDTIMEO:
  1293. case SO_RCVTIMEO:
  1294.     {
  1295. switch (optname) {
  1297. case SO_SNDTIMEO:
  1298. so->so_snd.sb_timeo = *mtod(m, int *);
  1299. break;
  1300. case SO_RCVTIMEO:
  1301. so->so_rcv.sb_timeo = *mtod(m, int *);
  1302. break;
  1303. }
  1304. break;
  1305.     }
  1307. #ifdef VIRTUAL_STACK
  1308.                 case SO_VSID:
  1309.                     so->vsid = *mtod(m, int *);
  1310.                     break;
  1311. #endif /* VIRTUAL_STACK */
  1313. default:
  1314. error = ENOPROTOOPT;
  1315. break;
  1316. }
  1317. if (error == 0 && so->so_proto && so->so_proto->pr_ctloutput) {
  1318. (void) ((*so->so_proto->pr_ctloutput)
  1319.   (PRCO_SETOPT, so, level, optname, &m0));
  1320. m = NULL; /* freed by protocol */
  1321. }
  1322. }
  1323. bad:
  1324. if (m)
  1325. (void) m_free(m);
  1326. return (error);
  1327. }
  1329. int
  1330. sogetopt(so, level, optname, mp)
  1331. register struct socket *so;
  1332. int level, optname;
  1333. struct mbuf **mp;
  1334. {
  1335. register struct mbuf *m;
  1337. if (level != SOL_SOCKET) {
  1338. if (so->so_proto && so->so_proto->pr_ctloutput) {
  1339. return ((*so->so_proto->pr_ctloutput)
  1340.   (PRCO_GETOPT, so, level, optname, mp));
  1341. } else
  1342. return (ENOPROTOOPT);
  1343. } else {
  1344. m = mBufClGet(M_WAIT, MT_SOOPTS, CL_SIZE_128, TRUE);
  1345.                 if (m == (struct mbuf *) NULL)
  1346.                     return (ENOBUFS);
  1348. m->m_len = sizeof (int);
  1350. switch (optname) {
  1352. case SO_LINGER:
  1353. m->m_len = sizeof (struct linger);
  1354. mtod(m, struct linger *)->l_onoff =
  1355. so->so_options & SO_LINGER;
  1356. mtod(m, struct linger *)->l_linger = so->so_linger;
  1357. break;
  1359. case SO_USELOOPBACK:
  1360. case SO_DONTROUTE:
  1361. case SO_DEBUG:
  1362. case SO_KEEPALIVE:
  1363. case SO_REUSEADDR:
  1364. case SO_REUSEPORT:
  1365. case SO_BROADCAST:
  1366. case SO_OOBINLINE:
  1367. *mtod(m, int *) = so->so_options & optname;
  1368. break;
  1370. case SO_TYPE:
  1371. *mtod(m, int *) = so->so_type;
  1372. break;
  1374. case SO_ERROR:
  1375. *mtod(m, int *) = so->so_error;
  1376. so->so_error = 0;
  1377. break;
  1379. case SO_SNDBUF:
  1380. *mtod(m, int *) = so->so_snd.sb_hiwat;
  1381. break;
  1383. case SO_RCVBUF:
  1384. *mtod(m, int *) = so->so_rcv.sb_hiwat;
  1385. break;
  1387. case SO_SNDLOWAT:
  1388. *mtod(m, int *) = so->so_snd.sb_lowat;
  1389. break;
  1391. case SO_RCVLOWAT:
  1392. *mtod(m, int *) = so->so_rcv.sb_lowat;
  1393. break;
  1395. case SO_SNDTIMEO:
  1396. case SO_RCVTIMEO:
  1397.         *mtod(m, int *) = (optname == SO_SNDTIMEO ?
  1398.      so->so_snd.sb_timeo : so->so_rcv.sb_timeo);
  1399. break;
  1401. #ifdef VIRTUAL_STACK
  1402.                 case SO_VSID:
  1403.                         *mtod(m, int *) = so->vsid;
  1404.                         break;
  1405. #endif /* VIRTUAL_STACK */
  1407. default:
  1408. (void)m_free(m);
  1409. return (ENOPROTOOPT);
  1410. }
  1411. *mp = m;
  1412. return (0);
  1413. }
  1414. }
  1416. void
  1417. sohasoutofband(so)
  1418. register struct socket *so;
  1419. {
  1420. #ifdef UNIXBSD44 /* support for out of band data later on */
  1421. /* 
  1422.    This can be done by maintaining a taskId in the
  1423.    in the socket structure and posting a SIGURG to
  1424.    the task which would invoke the signal handler
  1425.    for SIGURG if that signal is registered properly
  1426.    The taskId should be created in the socket structure
  1427.    at the time of the creation of the socket.
  1428.    */
  1429. struct proc *p;
  1431. if (so->so_pgid < 0)
  1432. gsignal(-so->so_pgid, SIGURG);
  1433. else if (so->so_pgid > 0 && (p = pfind(so->so_pgid)) != 0)
  1434. psignal(p, SIGURG);
  1435. selwakeup(&so->so_rcv.sb_sel);
  1436. #endif /* UNIXBSD44 */
  1437. }
  1439. int uiomove(cp, n, uio)
  1440.     register caddr_t cp;
  1441.     register int n;
  1442.     register struct uio *uio;
  1443.     {
  1444.     register struct iovec *iov;
  1445.     u_int cnt;
  1446.     int error = 0;
  1448. #ifdef DIAGNOSTIC
  1449.     if (uio->uio_rw != UIO_READ && uio->uio_rw != UIO_WRITE)
  1450. panic("uiomove: mode");
  1451.     if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != curproc)
  1452. panic("uiomove proc");
  1453. #endif
  1454.     while (n > 0 && uio->uio_resid) 
  1455. {
  1456. iov = uio->uio_iov;
  1457. cnt = iov->iov_len;
  1459. if (cnt == 0)
  1460.     {
  1461.     uio->uio_iov++;
  1462.     uio->uio_iovcnt--;
  1463.     continue;
  1464.     }
  1466. if (cnt > n)
  1467.     cnt = n;
  1469. if (uio->uio_rw == UIO_READ)
  1470.     bcopy((caddr_t)cp, iov->iov_base, cnt);
  1471. else
  1472.     bcopy(iov->iov_base, (caddr_t)cp, cnt);
  1474. iov->iov_base += cnt;
  1475. iov->iov_len -= cnt;
  1476. uio->uio_resid -= cnt;
  1477. uio->uio_offset += cnt;
  1478. cp += cnt;
  1479. n -= cnt;
  1480. }
  1482.     return (error);
  1483.     }