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

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

VxWorks

开发平台：

C/C++

uipc_sock2.c：源码内容
  1. /* uipc_sock2.c - uipc primitive socket routines */
  3. /* Copyright 1984 - 2001 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_socket2.c 8.2 (Berkeley) 2/14/95
  39.  */
  41. /*
  42. modification history
  43. --------------------
  44. 01g,15oct01,rae  merge from truestack ver 01m, base 01e (SPR #34005 etc.)
  45. 01f,12nov98,n_s  fixed sbcompress to work with netBufLib buffers. spr # 22966
  46. 01e,19sep97,vin  changed m_ext.ext_size to m_extSize
  47. 01d,11aug97,vin  adjusted sb_max to 5 *cc and low water mark to CL_SIZE_64
  48. 01c,03dec96,vin  changed calloc(..) to MALLOC(..) and free(..) to FREE(..)
  49.  to use network buffers.
  50. 01b,22nov96,vin  added cluster support, replace m_get(..) with mBufClGet(..). 
  51. 01a,03mar96,vin  created from BSD4.4lite2. Integrated with 02t of uipc_sock2.c
  52. */
  54. /*
  55. DESCRIPTION
  56. */
  59. #ifdef BSDUNIX44 
  61. #include <sys/param.h>
  62. #include <sys/systm.h>
  63. #include <sys/proc.h>
  64. #include <sys/file.h>
  65. #include <sys/buf.h>
  66. #include <sys/malloc.h>
  67. #include <sys/mbuf.h>
  68. #include <sys/protosw.h>
  69. #include <sys/socket.h>
  70. #include <sys/socketvar.h>
  71. #else
  73. #include "vxWorks.h"
  74. #include "semLib.h"
  75. #include "memLib.h"
  77. #include "errno.h"
  78. #include "net/mbuf.h"
  79. #include "net/protosw.h"
  80. #include "sys/socket.h"
  81. #include "net/socketvar.h"
  82. #include "net/systm.h"
  83. #include "net/unixLib.h"
  84. #include "stdio.h"
  86. #endif /* BSDUNIX44 */
  88. #ifdef VIRTUAL_STACK
  89. #include "netinet/vsLib.h"
  90. #endif    /* VIRTUAL_STACK */
  92. #ifdef WV_INSTRUMENTATION
  93. #ifdef INCLUDE_WVNET
  94. #include "wvNetLib.h"
  95. #endif
  96. #endif
  98. #ifdef WV_INSTRUMENTATION
  99. #ifdef INCLUDE_WVNET
  100.     /* Set common fields of event identifiers for this module. */
  102. LOCAL UCHAR wvNetModuleId = WV_NET_UISOCK2_MODULE; /* Value for uipc_sock2.c */
  103. LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;     /* Available event filter */
  105. LOCAL ULONG wvNetEventId;       /* Event identifier: see wvNetLib.h */
  106. #endif    /* INCLUDE_WVNET */
  107. #endif
  109. /* globals */
  111. VOIDFUNCPTR sowakeupHook = NULL; /* user callback in sowakeup() */
  113. #ifndef VIRTUAL_STACK
  114. u_long sb_max = SB_MAX; /* patchable max socket buffer size*/
  115. #endif    /* VIRTUAL_STACK */
  117. /*
  118.  * Primitive routines for operating on sockets and socket buffers
  119.  */
  121. /*
  122.  * Procedures to manipulate state flags of socket
  123.  * and do appropriate wakeups.  Normal sequence from the
  124.  * active (originating) side is that soisconnecting() is
  125.  * called during processing of connect() call,
  126.  * resulting in an eventual call to soisconnected() if/when the
  127.  * connection is established.  When the connection is torn down
  128.  * soisdisconnecting() is called during processing of disconnect() call,
  129.  * and soisdisconnected() is called when the connection to the peer
  130.  * is totally severed.  The semantics of these routines are such that
  131.  * connectionless protocols can call soisconnected() and soisdisconnected()
  132.  * only, bypassing the in-progress calls when setting up a ``connection''
  133.  * takes no time.
  134.  *
  135.  * From the passive side, a socket is created with
  136.  * two queues of sockets: so_q0 for connections in progress
  137.  * and so_q for connections already made and awaiting user acceptance.
  138.  * As a protocol is preparing incoming connections, it creates a socket
  139.  * structure queued on so_q0 by calling sonewconn().  When the connection
  140.  * is established, soisconnected() is called, and transfers the
  141.  * socket structure to so_q, making it available to accept().
  142.  * 
  143.  * If a socket is closed with sockets on either
  144.  * so_q0 or so_q, these sockets are dropped.
  145.  *
  146.  * If higher level protocols are implemented in
  147.  * the kernel, the wakeups done here will sometimes
  148.  * cause software-interrupt process scheduling.
  149.  */
  151. void
  152. soisconnecting(so)
  153. register struct socket *so;
  154. {
  156. so->so_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING);
  157. so->so_state |= SS_ISCONNECTING;
  158. }
  160. void
  161. soisconnected(so)
  162. register struct socket *so;
  163. {
  164. register struct socket *head = so->so_head;
  166. so->so_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING|SS_ISCONFIRMING);
  167. so->so_state |= SS_ISCONNECTED;
  168. if (head && soqremque(so, 0)) {
  169. soqinsque(head, so, 1);
  170. sorwakeup(head);
  171. wakeup(head->so_timeoSem);
  172. } else {
  173.         wakeup(so->so_timeoSem);
  174. sorwakeup(so);
  175. sowwakeup(so);
  176. }
  177. }
  179. void
  180. soisdisconnecting(so)
  181. register struct socket *so;
  182. {
  184. so->so_state &= ~SS_ISCONNECTING;
  185. so->so_state |= (SS_ISDISCONNECTING|SS_CANTRCVMORE|SS_CANTSENDMORE);
  186. wakeup(so->so_timeoSem);
  187. sowwakeup(so);
  188. sorwakeup(so);
  189. }
  191. void
  192. soisdisconnected(so)
  193. register struct socket *so;
  194. {
  196. so->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);
  197. so->so_state |= (SS_CANTRCVMORE|SS_CANTSENDMORE);
  198.         if (so->so_timeoSem)
  199.     wakeup(so->so_timeoSem);
  200. sowwakeup(so);
  201. sorwakeup(so);
  202. }
  204. /*
  205.  * When an attempt at a new connection is noted on a socket
  206.  * which accepts connections, sonewconn is called.  If the
  207.  * connection is possible (subject to space constraints, etc.)
  208.  * then we allocate a new structure, propoerly linked into the
  209.  * data structure of the original socket, and return this.
  210.  * Connstatus may be 0, or SO_ISCONFIRMING, or SO_ISCONNECTED.
  211.  *
  212.  * Currently, sonewconn() is defined as sonewconn1() in socketvar.h
  213.  * to catch calls that are missing the (new) second parameter.
  214.  */
  215. struct socket *
  216. sonewconn1(head, connstatus)
  217. register struct socket *head;
  218. int connstatus;
  219. {
  220. register struct socket *so;
  221. int soqueue = connstatus ? 1 : 0;
  223. if (head->so_qlen + head->so_q0len > 3 * head->so_qlimit / 2)
  224. return ((struct socket *)0);
  226.         MALLOC(so, struct socket *, sizeof(*so), MT_SOCKET, M_DONTWAIT);
  227.         if (so == NULL)
  228.                 return ((struct socket *)0);
  229.         bzero((caddr_t)so, sizeof(*so));
  230. so->so_type = head->so_type;
  231. so->so_options = head->so_options &~ SO_ACCEPTCONN;
  232. so->so_linger = head->so_linger;
  233. so->so_state = head->so_state | SS_NOFDREF;
  234. so->so_proto = head->so_proto;
  235. so->so_timeo = head->so_timeo;
  236. so->so_pgrp = head->so_pgrp;
  238. /* initialize the socket's semaphores */
  240. so->so_timeoSem = semBCreate (SEM_Q_PRIORITY, SEM_EMPTY);
  241.         if (so->so_timeoSem == NULL)
  242.             {
  243.             FREE(so, MT_SOCKET);
  244.             return ((struct socket *)0);
  245.             }
  246. so->so_rcv.sb_Sem = semBCreate (SEM_Q_PRIORITY, SEM_EMPTY);
  247.         if (so->so_rcv.sb_Sem == NULL)
  248.             {
  249.             semDelete (so->so_timeoSem);
  250.             FREE(so, MT_SOCKET);
  251.             return ((struct socket *)0);
  252.             }
  253. so->so_snd.sb_Sem = semBCreate (SEM_Q_PRIORITY, SEM_EMPTY);
  254.         if (so->so_snd.sb_Sem == NULL)
  255.             {
  256.             semDelete (so->so_timeoSem);
  257.             semDelete (so->so_rcv.sb_Sem);
  258.             FREE(so, MT_SOCKET);
  259.             return ((struct socket *)0);
  260.             }
  262.         /* initialize the select stuff */
  264. selWakeupListInit (&so->so_selWakeupList);
  265.  
  266.         so->selectFlag = TRUE;
  268. (void) soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat);
  269. soqinsque(head, so, soqueue);
  270. if ((*so->so_proto->pr_usrreq)(so, PRU_ATTACH,
  271.     (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0)) {
  272. (void) soqremque(so, soqueue);
  273. semDelete (so->so_timeoSem);
  274. semDelete (so->so_rcv.sb_Sem);
  275. semDelete (so->so_snd.sb_Sem);
  276. selWakeupListTerm (&so->so_selWakeupList);
  277. FREE(so, MT_SOCKET);
  278. return ((struct socket *)0);
  279. }
  280. if (connstatus) {
  281. sorwakeup(head);
  282. wakeup(head->so_timeoSem);
  283. so->so_state |= connstatus;
  284. }
  285. return (so);
  286. }
  288. void
  289. soqinsque(head, so, q)
  290. register struct socket *head, *so;
  291. int q;
  292. {
  294. register struct socket **prev;
  295. so->so_head = head;
  296. if (q == 0) {
  297. head->so_q0len++;
  298. so->so_q0 = 0;
  299. for (prev = &(head->so_q0); *prev; )
  300. prev = &((*prev)->so_q0);
  301. } else {
  302. head->so_qlen++;
  303. so->so_q = 0;
  304. for (prev = &(head->so_q); *prev; )
  305. prev = &((*prev)->so_q);
  306. }
  307. *prev = so;
  308. }
  310. int
  311. soqremque(so, q)
  312. register struct socket *so;
  313. int q;
  314. {
  315. register struct socket *head, *prev, *next;
  317. head = so->so_head;
  318. prev = head;
  319. for (;;) {
  320. next = q ? prev->so_q : prev->so_q0;
  321. if (next == so)
  322. break;
  323. if (next == 0)
  324. return (0);
  325. prev = next;
  326. }
  327. if (q == 0) {
  328. prev->so_q0 = next->so_q0;
  329. head->so_q0len--;
  330. } else {
  331. prev->so_q = next->so_q;
  332. head->so_qlen--;
  333. }
  334. next->so_q0 = next->so_q = 0;
  335. next->so_head = 0;
  336. return (1);
  337. }
  339. /*
  340.  * Socantsendmore indicates that no more data will be sent on the
  341.  * socket; it would normally be applied to a socket when the user
  342.  * informs the system that no more data is to be sent, by the protocol
  343.  * code (in case PRU_SHUTDOWN).  Socantrcvmore indicates that no more data
  344.  * will be received, and will normally be applied to the socket by a
  345.  * protocol when it detects that the peer will send no more data.
  346.  * Data queued for reading in the socket may yet be read.
  347.  */
  349. void
  350. socantsendmore(so)
  351. struct socket *so;
  352. {
  354. so->so_state |= SS_CANTSENDMORE;
  355. sowwakeup(so);
  356. }
  358. void
  359. socantrcvmore(so)
  360. struct socket *so;
  361. {
  363. so->so_state |= SS_CANTRCVMORE;
  364. sorwakeup(so);
  365. }
  367. /*
  368.  * Queue a process for a select on a socket buffer.
  369.  */
  371. void
  372. sbselqueue(so, sb, wakeupNode)
  373. struct socket *so;
  374.         struct sockbuf *sb;
  375. SEL_WAKEUP_NODE *wakeupNode;
  376. {
  377. if (selNodeAdd (&so->so_selWakeupList, wakeupNode) == ERROR)
  378.     return;
  380. /* this is race free ONLY if we assume we're at splnet - rdc */
  381. sb->sb_sel = (struct proc *) 1;
  382. }
  384. void
  385. sbseldequeue(so, sb, wakeupNode)
  386.     struct socket *so;
  387.     struct sockbuf *sb;
  388.     SEL_WAKEUP_NODE *wakeupNode;
  389.     {
  390.     selNodeDelete (&so->so_selWakeupList, wakeupNode);
  392.     /* this is race free ONLY if we assume we're at splnet - rdc */
  393.     if (selWakeupListLen (&so->so_selWakeupList) == 0)
  394. sb->sb_sel = (struct proc *) 0;
  395.     }
  398. /*
  399.  * Wait for data to arrive at/drain from a socket buffer.
  400.  */
  401. void sbwait
  402.     (
  403.     struct sockbuf *sb
  404.     )
  405.     {
  406.     sb->sb_want++;
  407.     sb->sb_flags |= SB_WAIT;
  409. #ifdef WV_INSTRUMENTATION
  410. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  411.     WV_NET_MARKER_0 (NET_CORE_EVENT, WV_NET_INFO, 53, 5,
  412.                      WV_NETEVENT_SBWAIT_SLEEP)
  413. #endif  /* INCLUDE_WVNET */
  414. #endif
  416.     ksleep (sb->sb_Sem);
  417.     }
  420. /* 
  421.  * Lock a sockbuf already known to be locked;
  422.  * return any error returned from sleep (EINTR).
  423.  */
  424. int
  425. sb_lock(sb)
  426. register struct sockbuf *sb;
  427. {
  429. while (sb->sb_flags & SB_LOCK) {
  430. sb->sb_flags |= SB_WANT;
  431. ksleep(sb->sb_Sem);
  432. }
  433. sb->sb_flags |= SB_LOCK;
  434. return (0);
  435. }
  437. /*
  438.  * Wakeup processes waiting on a socket buffer.
  439.  */
  441. void sbwakeup
  442.     (
  443.     struct socket *so,
  444.     register struct sockbuf *sb,
  445.     SELECT_TYPE wakeupType
  446.     )
  447.     {
  448. #ifdef WV_INSTRUMENTATION
  449. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  450.     WV_NET_MARKER_2 (NET_CORE_EVENT, WV_NET_INFO, 54, 6, 
  451.                      WV_NETEVENT_SBWAKEUP_START, so->so_fd, wakeupType)
  452. #endif  /* INCLUDE_WVNET */
  453. #endif
  455.     if (sb->sb_want > 0)
  456.         {
  457.         sb->sb_want--;
  458.         if (sb->sb_Sem)
  459.             wakeup (sb->sb_Sem);
  460.         }
  461.     else
  462.         sb->sb_want = 0;
  464.     if (sb->sb_sel)
  465.         {
  466.         /* 
  467.          * Wake up everybody on selectTask list.
  468.          * (Assume this is running in netTask context).
  469.          */
  471.         if (so->selectFlag)
  472.             selWakeupAll (&so->so_selWakeupList, wakeupType);
  473.         }
  474.     }
  477. /*
  478.  * Wakeup socket readers and writers.
  479.  */
  480. /* ARGSUSED */
  481. void sowakeup(so, sb, wakeupType)
  482. struct socket *so;
  483. struct sockbuf *sb;
  484. SELECT_TYPE wakeupType;
  485. {
  486.         sbwakeup(so, sb, wakeupType);
  488. /* user callback, instead of full signals implementation */
  490. if (sowakeupHook != NULL)
  491.      (*sowakeupHook) (so, wakeupType);
  493. #ifdef BERKELEY
  494. /* XXX one day asynchronous IO will work... -gae */
  496.         register struct proc *p;
  498.         if (so->so_state & SS_ASYNC) {
  499.                 if (so->so_pgrp < 0)
  500.                         gsignal(-so->so_pgrp, SIGIO);
  501.                 else if (so->so_pgrp > 0 && (p = pfind(so->so_pgrp)) != 0)
  502.                         psignal(p, SIGIO);
  503.         }
  504. #endif /* BERKELEY */
  505. }
  507. /*
  508.  * Socket buffer (struct sockbuf) utility routines.
  509.  *
  510.  * Each socket contains two socket buffers: one for sending data and
  511.  * one for receiving data.  Each buffer contains a queue of mbufs,
  512.  * information about the number of mbufs and amount of data in the
  513.  * queue, and other fields allowing select() statements and notification
  514.  * on data availability to be implemented.
  515.  *
  516.  * Data stored in a socket buffer is maintained as a list of records.
  517.  * Each record is a list of mbufs chained together with the m_next
  518.  * field.  Records are chained together with the m_nextpkt field. The upper
  519.  * level routine soreceive() expects the following conventions to be
  520.  * observed when placing information in the receive buffer:
  521.  *
  522.  * 1. If the protocol requires each message be preceded by the sender's
  523.  *    name, then a record containing that name must be present before
  524.  *    any associated data (mbuf's must be of type MT_SONAME).
  525.  * 2. If the protocol supports the exchange of ``access rights'' (really
  526.  *    just additional data associated with the message), and there are
  527.  *    ``rights'' to be received, then a record containing this data
  528.  *    should be present (mbuf's must be of type MT_RIGHTS).
  529.  * 3. If a name or rights record exists, then it must be followed by
  530.  *    a data record, perhaps of zero length.
  531.  *
  532.  * Before using a new socket structure it is first necessary to reserve
  533.  * buffer space to the socket, by calling sbreserve().  This should commit
  534.  * some of the available buffer space in the system buffer pool for the
  535.  * socket (currently, it does nothing but enforce limits).  The space
  536.  * should be released by calling sbrelease() when the socket is destroyed.
  537.  */
  539. int
  540. soreserve(so, sndcc, rcvcc)
  541. register struct socket *so;
  542. u_long sndcc, rcvcc;
  543. {
  545. if (sbreserve(&so->so_snd, sndcc) == 0)
  546. goto bad;
  547. if (sbreserve(&so->so_rcv, rcvcc) == 0)
  548. goto bad2;
  549. if (so->so_rcv.sb_lowat == 0)
  550. so->so_rcv.sb_lowat = 1;
  551. if (so->so_snd.sb_lowat == 0)
  552. so->so_snd.sb_lowat = CL_SIZE_64;
  553. if (so->so_snd.sb_lowat > so->so_snd.sb_hiwat)
  554. so->so_snd.sb_lowat = so->so_snd.sb_hiwat;
  555. return (0);
  556. bad2:
  557. sbrelease(&so->so_snd);
  558. bad:
  559. return (ENOBUFS);
  560. }
  562. /*
  563.  * Allot mbufs to a sockbuf.
  564.  * Attempt to scale mbmax so that mbcnt doesn't become limiting
  565.  * if buffering efficiency is near the normal case.
  566.  */
  567. int
  568. sbreserve(sb, cc)
  569. struct sockbuf *sb;
  570. u_long cc;
  571. {
  573. if (cc > sb_max * MCLBYTES / (MSIZE + MCLBYTES))
  574. return (0);
  575. sb->sb_hiwat = cc;
  576. sb->sb_mbmax = min(cc * 5, sb_max);
  577. if (sb->sb_lowat > sb->sb_hiwat)
  578. sb->sb_lowat = sb->sb_hiwat;
  579. return (1);
  580. }
  582. /*
  583.  * Free mbufs held by a socket, and reserved mbuf space.
  584.  */
  585. void
  586. sbrelease(sb)
  587. struct sockbuf *sb;
  588. {
  590. sbflush(sb);
  591. sb->sb_hiwat = sb->sb_mbmax = 0;
  592. }
  594. /*
  595.  * Routines to add and remove
  596.  * data from an mbuf queue.
  597.  *
  598.  * The routines sbappend() or sbappendrecord() are normally called to
  599.  * append new mbufs to a socket buffer, after checking that adequate
  600.  * space is available, comparing the function sbspace() with the amount
  601.  * of data to be added.  sbappendrecord() differs from sbappend() in
  602.  * that data supplied is treated as the beginning of a new record.
  603.  * To place a sender's address, optional access rights, and data in a
  604.  * socket receive buffer, sbappendaddr() should be used.  To place
  605.  * access rights and data in a socket receive buffer, sbappendrights()
  606.  * should be used.  In either case, the new data begins a new record.
  607.  * Note that unlike sbappend() and sbappendrecord(), these routines check
  608.  * for the caller that there will be enough space to store the data.
  609.  * Each fails if there is not enough space, or if it cannot find mbufs
  610.  * to store additional information in.
  611.  *
  612.  * Reliable protocols may use the socket send buffer to hold data
  613.  * awaiting acknowledgement.  Data is normally copied from a socket
  614.  * send buffer in a protocol with m_copy for output to a peer,
  615.  * and then removing the data from the socket buffer with sbdrop()
  616.  * or sbdroprecord() when the data is acknowledged by the peer.
  617.  */
  619. /*
  620.  * Append mbuf chain m to the last record in the
  621.  * socket buffer sb.  The additional space associated
  622.  * the mbuf chain is recorded in sb.  Empty mbufs are
  623.  * discarded and mbufs are compacted where possible.
  624.  */
  625. void
  626. sbappend(sb, m)
  627. struct sockbuf *sb;
  628. struct mbuf *m;
  629. {
  630. register struct mbuf *n;
  632. if (m == 0)
  633. return;
  634. if ((n = sb->sb_mb)) {
  635. while (n->m_nextpkt)
  636. n = n->m_nextpkt;
  637. do {
  638. if (n->m_flags & M_EOR) {
  639. sbappendrecord(sb, m); /* XXXXXX!!!! */
  640. return;
  641. }
  642. } while (n->m_next && (n = n->m_next));
  643. }
  644. sbcompress(sb, m, n);
  645. }
  647. #ifdef SOCKBUF_DEBUG
  648. void
  649. sbcheck(sb)
  650. register struct sockbuf *sb;
  651. {
  652. register struct mbuf *m;
  653. register int len = 0, mbcnt = 0;
  655. for (m = sb->sb_mb; m; m = m->m_next) {
  656. len += m->m_len;
  657. mbcnt += MSIZE;
  658. if (m->m_flags & M_EXT)
  659. mbcnt += m->m_extSize;
  660. if (m->m_nextpkt)
  661. panic("sbcheck nextpkt");
  662. }
  663. if (len != sb->sb_cc || mbcnt != sb->sb_mbcnt) {
  664. printf("cc %d != %d || mbcnt %d != %dn", len, sb->sb_cc,
  665.     mbcnt, sb->sb_mbcnt);
  666. panic("sbcheck");
  667. }
  668. }
  669. #endif
  671. /*
  672.  * As above, except the mbuf chain
  673.  * begins a new record.
  674.  */
  675. void
  676. sbappendrecord(sb, m0)
  677. register struct sockbuf *sb;
  678. register struct mbuf *m0;
  679. {
  680. register struct mbuf *m;
  682. if (m0 == 0)
  683. return;
  684. if ((m = sb->sb_mb) != NULL)
  685. while (m->m_nextpkt)
  686. m = m->m_nextpkt;
  687. /*
  688.  * Put the first mbuf on the queue.
  689.  * Note this permits zero length records.
  690.  */
  691. sballoc(sb, m0);
  692. if (m)
  693. m->m_nextpkt = m0;
  694. else
  695. sb->sb_mb = m0;
  696. m = m0->m_next;
  697. m0->m_next = 0;
  698. if (m && (m0->m_flags & M_EOR)) {
  699. m0->m_flags &= ~M_EOR;
  700. m->m_flags |= M_EOR;
  701. }
  702. sbcompress(sb, m, m0);
  703. }
  705. /*
  706.  * As above except that OOB data
  707.  * is inserted at the beginning of the sockbuf,
  708.  * but after any other OOB data.
  709.  */
  710. void
  711. sbinsertoob(sb, m0)
  712. register struct sockbuf *sb;
  713. register struct mbuf *m0;
  714. {
  715. register struct mbuf *m;
  716. register struct mbuf **mp;
  718. if (m0 == 0)
  719. return;
  720. for (mp = &sb->sb_mb; (m = *mp) != NULL; mp = &((*mp)->m_nextpkt)) {
  721.     again:
  722. switch (m->m_type) {
  724. case MT_OOBDATA:
  725. continue; /* WANT next train */
  727. case MT_CONTROL:
  728. if ((m = m->m_next) != NULL)
  729. goto again; /* inspect THIS train further */
  730. }
  731. break;
  732. }
  733. /*
  734.  * Put the first mbuf on the queue.
  735.  * Note this permits zero length records.
  736.  */
  737. sballoc(sb, m0);
  738. m0->m_nextpkt = *mp;
  739. *mp = m0;
  740. m = m0->m_next;
  741. m0->m_next = 0;
  742. if (m && (m0->m_flags & M_EOR)) {
  743. m0->m_flags &= ~M_EOR;
  744. m->m_flags |= M_EOR;
  745. }
  746. sbcompress(sb, m, m0);
  747. }
  749. /*
  750.  * Append address and data, and optionally, control (ancillary) data
  751.  * to the receive queue of a socket.  If present,
  752.  * m0 must include a packet header with total length.
  753.  * Returns 0 if no space in sockbuf or insufficient mbufs.
  754.  */
  755. int
  756. sbappendaddr(sb, asa, m0, control)
  757. register struct sockbuf *sb;
  758. struct sockaddr *asa;
  759. struct mbuf *m0, *control;
  760. {
  761. register struct mbuf *m, *n;
  762. int space = asa->sa_len;
  764.     if (m0 && (m0->m_flags & M_PKTHDR) == 0)
  765.         {
  766. #ifdef WV_INSTRUMENTATION
  767. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  768.         WV_NET_EVENT_0 (NET_CORE_EVENT, WV_NET_EMERGENCY, 41, 1, 
  769.                         WV_NETEVENT_SBAPPENDADDR_PANIC, WV_NET_RECV)
  770. #endif  /* INCLUDE_WVNET */
  771. #endif
  773.         panic("sbappendaddr");
  774.         }
  776. if (m0)
  777. space += m0->m_pkthdr.len;
  778. for (n = control; n; n = n->m_next) {
  779. space += n->m_len;
  780. if (n->m_next == 0) /* keep pointer to last control buf */
  781. break;
  782. }
  783. if (space > sbspace(sb))
  784. return (0);
  785. if (asa->sa_len > CL_SIZE_128)
  786. return (0);
  787. m = mBufClGet(M_DONTWAIT, MT_SONAME, CL_SIZE_128, TRUE);
  788. if (m == 0)
  789. return (0);
  790. m->m_len = asa->sa_len;
  791. bcopy((caddr_t)asa, mtod(m, caddr_t), asa->sa_len);
  792. if (n)
  793. n->m_next = m0; /* concatenate data to control */
  794. else
  795. control = m0;
  796. m->m_next = control;
  797. for (n = m; n; n = n->m_next)
  798. sballoc(sb, n);
  799. if ((n = sb->sb_mb) != NULL) {
  800. while (n->m_nextpkt)
  801. n = n->m_nextpkt;
  802. n->m_nextpkt = m;
  803. } else
  804. sb->sb_mb = m;
  805. return (1);
  806. }
  808. int
  809. sbappendcontrol(sb, m0, control)
  810. struct sockbuf *sb;
  811. struct mbuf *m0, *control;
  812. {
  813. register struct mbuf *m, *n;
  814. int space = 0;
  816.     if (control == 0)
  817.         {
  818. #ifdef WV_INSTRUMENTATION
  819. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  820.         WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_EMERGENCY, 42, 2, 
  821.                          WV_NETEVENT_SBAPPENDCTRL_PANIC)
  822. #endif  /* INCLUDE_WVNET */
  823. #endif
  825.         panic ("sbappendcontrol");
  826.         }
  828. for (m = control; ; m = m->m_next) {
  829. space += m->m_len;
  830. if (m->m_next == 0)
  831. break;
  832. }
  833. n = m; /* save pointer to last control buffer */
  834. for (m = m0; m; m = m->m_next)
  835. space += m->m_len;
  836. if (space > sbspace(sb))
  837. return (0);
  838. n->m_next = m0; /* concatenate data to control */
  839. for (m = control; m; m = m->m_next)
  840. sballoc(sb, m);
  841. if ((n = sb->sb_mb) != NULL) {
  842. while (n->m_nextpkt)
  843. n = n->m_nextpkt;
  844. n->m_nextpkt = control;
  845. } else
  846. sb->sb_mb = control;
  847. return (1);
  848. }
  850. /*
  851.  * Compress mbuf chain m into the socket
  852.  * buffer sb following mbuf n.  If n
  853.  * is null, the buffer is presumed empty.
  854.  */
  855. void
  856. sbcompress(sb, m, n)
  857. register struct sockbuf *sb;
  858. register struct mbuf *m, *n;
  859. {
  860. register int eor = 0;
  861. register struct mbuf *o;
  863. while (m) {
  864. eor |= m->m_flags & M_EOR;
  865. if (m->m_len == 0 &&
  866.     (eor == 0 ||
  867.      (((o = m->m_next) || (o = n)) &&
  868.       o->m_type == m->m_type))) {
  869. m = m_free(m);
  870. continue;
  871. }
  873. /*
  874.  * This test determines whether or not the data in <m> will
  875.  * be copied to the cluster referenced by <n>.  The conditions
  876.  * which are required for compression are:
  877.  *     1) <n> is non-NULL
  878.  *     2) <n> is not the end of a record.  M_EOR is set for
  879.  *        datagram protocols (UDP, raw IP) but not stream
  880.  *        protocols (TCP)
  881.  *     3) length of data in <m> is less than CL_SIZE_MIN.  This
  882.  *        condition optimizes buffer usage for small clusters
  883.  *        and optimizes speed for large clusters, by not 
  884.  *        copying data in those cases.
  885.  *     4) The data in <m> must fit in the remaining space in 
  886.  *        the cluster referenced by <n>
  887.  *     5) <m> and <n> must contain the same type of data
  888.  */
  890. if (n && 
  891.     (n->m_flags & M_EOR) == 0 && 
  892.     m->m_len < CL_SIZE_MIN &&
  893.     (n->m_data + n->m_len + m->m_len) < 
  894.     (n->m_extBuf + n->m_extSize) &&
  895.     n->m_type == m->m_type) 
  896.     {
  897.     bcopy(mtod(m, caddr_t), mtod(n, caddr_t) + n->m_len,
  898.   (unsigned)m->m_len);
  899.     n->m_len += m->m_len;
  900.     sb->sb_cc += m->m_len;
  901.     m = m_free(m);
  902.     continue;
  903.     }
  904. if (n)
  905. n->m_next = m;
  906. else
  907. sb->sb_mb = m;
  908. sballoc(sb, m);
  909. n = m;
  910. m->m_flags &= ~M_EOR;
  911. m = m->m_next;
  912. n->m_next = 0;
  913. }
  914. if (eor) {
  915. if (n)
  916. n->m_flags |= eor;
  917. else
  918. printf("semi-panic: sbcompressn");
  919. }
  920. }
  922. /*
  923.  * Free all mbufs in a sockbuf.
  924.  * Check that all resources are reclaimed.
  925.  */
  927. void sbflush
  928.     (
  929.     register struct sockbuf *sb
  930.     )
  931.     {
  932.     if (sb->sb_flags & SB_LOCK)
  933.         {
  934. #ifdef WV_INSTRUMENTATION
  935. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  936.         WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_EMERGENCY, 43, 3, 
  937.                          WV_NETEVENT_SBFLUSH_PANIC, 1)
  938. #endif  /* INCLUDE_WVNET */
  939. #endif
  941.         panic("sbflush");
  942.         }
  944.     while (sb->sb_mbcnt)
  945.         sbdrop (sb, (int)sb->sb_cc);
  946.     if (sb->sb_cc || sb->sb_mb)
  947.         {
  948. #ifdef WV_INSTRUMENTATION
  949. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  950.         WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_EMERGENCY, 43, 3, 
  951.                          WV_NETEVENT_SBFLUSH_PANIC, 0)
  952. #endif  /* INCLUDE_WVNET */
  953. #endif
  955.         panic ("sbflush 2");
  956.         }
  957.     }
  959. /*
  960.  * Drop data from (the front of) a sockbuf.
  961.  */
  962. void sbdrop
  963.     (
  964.     register struct sockbuf *sb,
  965.     register int len
  966.     )
  967.     {
  968.     register struct mbuf *m, *mn;
  969.     struct mbuf *next;
  971.     next = (m = sb->sb_mb) ? m->m_nextpkt : 0;
  972.     while (len > 0) 
  973.         {
  974.         if (m == 0) 
  975.             {
  976.             if (next == 0)
  977.                 {
  978. #ifdef WV_INSTRUMENTATION
  979. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  980.                 WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_EMERGENCY, 44, 4, 
  981.                                  WV_NETEVENT_SBDROP_PANIC)
  982. #endif  /* INCLUDE_WVNET */
  983. #endif
  985.                 panic ("sbdrop");
  986.                 }
  987.             m = next;
  988.             next = m->m_nextpkt;
  989.             continue;
  990.             }
  991.         if (m->m_len > len)
  992.             {
  993.             m->m_len -= len;
  994.             m->m_data += len;
  995.             sb->sb_cc -= len;
  996.             break;
  997.             }
  998.         len -= m->m_len;
  999.         sbfree (sb, m);
  1000.         mn = m_free (m);
  1001.         m = mn;
  1002.         }
  1003.     while (m && m->m_len == 0)
  1004.         {
  1005.         sbfree (sb, m);
  1006.         mn = m_free (m);
  1007.         m = mn;
  1008.         }
  1009.     if (m)
  1010.         {
  1011.         sb->sb_mb = m;
  1012.         m->m_nextpkt = next;
  1013.         }
  1014.     else
  1015.         sb->sb_mb = next;
  1016.     }
  1018. /*
  1019.  * Drop a record off the front of a sockbuf
  1020.  * and move the next record to the front.
  1021.  */
  1022. void
  1023. sbdroprecord(sb)
  1024. register struct sockbuf *sb;
  1025. {
  1026. register struct mbuf *m, *mn;
  1028. m = sb->sb_mb;
  1029. if (m) {
  1030. sb->sb_mb = m->m_nextpkt;
  1031. do {
  1032. sbfree(sb, m);
  1033. mn = m_free(m);
  1034. } while ((m = mn));
  1035. }
  1036. }