home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-bin / include / sys / socketvar.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-10-12  |  8.0 KB  |  207 lines
  1. /*-
  2.  * Copyright (c) 1982, 1986, 1990 The Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  *    This product includes software developed by the University of
  16.  *    California, Berkeley and its contributors.
  17.  * 4. Neither the name of the University nor the names of its contributors
  18.  *    may be used to endorse or promote products derived from this software
  19.  *    without specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  *
  33.  *    @(#)socketvar.h    7.17 (Berkeley) 5/5/91
  34.  */
  35.  
  36. /*
  37.  * Kernel structure per socket.
  38.  * Contains send and receive buffer queues,
  39.  * handle on protocol and pointer to protocol
  40.  * private data and error information.
  41.  */
  42. struct socket {
  43.     short    so_type;        /* generic type, see socket.h */
  44.     short    so_options;        /* from socket call, see socket.h */
  45.     short    so_linger;        /* time to linger while closing */
  46.     short    so_state;        /* internal state flags SS_*, below */
  47.     caddr_t    so_pcb;            /* protocol control block */
  48.     struct    protosw *so_proto;    /* protocol handle */
  49. /*
  50.  * Variables for connection queueing.
  51.  * Socket where accepts occur is so_head in all subsidiary sockets.
  52.  * If so_head is 0, socket is not related to an accept.
  53.  * For head socket so_q0 queues partially completed connections,
  54.  * while so_q is a queue of connections ready to be accepted.
  55.  * If a connection is aborted and it has so_head set, then
  56.  * it has to be pulled out of either so_q0 or so_q.
  57.  * We allow connections to queue up based on current queue lengths
  58.  * and limit on number of queued connections for this socket.
  59.  */
  60.     struct    socket *so_head;    /* back pointer to accept socket */
  61.     struct    socket *so_q0;        /* queue of partial connections */
  62.     struct    socket *so_q;        /* queue of incoming connections */
  63.     short    so_q0len;        /* partials on so_q0 */
  64.     short    so_qlen;        /* number of connections on so_q */
  65.     short    so_qlimit;        /* max number queued connections */
  66.     short    so_timeo;        /* connection timeout */
  67.     u_short    so_error;        /* error affecting connection */
  68.     pid_t    so_pgid;        /* pgid for signals */
  69.     u_long    so_oobmark;        /* chars to oob mark */
  70. /*
  71.  * Variables for socket buffering.
  72.  */
  73.     struct    sockbuf {
  74.         u_long    sb_cc;        /* actual chars in buffer */
  75.         u_long    sb_hiwat;    /* max actual char count */
  76.         u_long    sb_mbcnt;    /* chars of mbufs used */
  77.         u_long    sb_mbmax;    /* max chars of mbufs to use */
  78.         long    sb_lowat;    /* low water mark */
  79.         struct    mbuf *sb_mb;    /* the mbuf chain */
  80.         struct    proc *sb_sel;    /* process selecting read/write */
  81.         short    sb_flags;    /* flags, see below */
  82.         short    sb_timeo;    /* timeout for read/write */
  83.     } so_rcv, so_snd;
  84. #define    SB_MAX        (64*1024)    /* default for max chars in sockbuf */
  85. #define    SB_LOCK        0x01        /* lock on data queue */
  86. #define    SB_WANT        0x02        /* someone is waiting to lock */
  87. #define    SB_WAIT        0x04        /* someone is waiting for data/space */
  88. #define    SB_SEL        0x08        /* someone is selecting */
  89. #define    SB_ASYNC    0x10        /* ASYNC I/O, need signals */
  90. #define    SB_NOTIFY    (SB_WAIT|SB_SEL|SB_ASYNC)
  91. #define    SB_COLL        0x20        /* collision selecting */
  92. #define    SB_NOINTR    0x40        /* operations not interruptible */
  93.  
  94.     caddr_t    so_tpcb;        /* Wisc. protocol control block XXX */
  95. };
  96.  
  97. /*
  98.  * Socket state bits.
  99.  */
  100. #define    SS_NOFDREF        0x001    /* no file table ref any more */
  101. #define    SS_ISCONNECTED        0x002    /* socket connected to a peer */
  102. #define    SS_ISCONNECTING        0x004    /* in process of connecting to peer */
  103. #define    SS_ISDISCONNECTING    0x008    /* in process of disconnecting */
  104. #define    SS_CANTSENDMORE        0x010    /* can't send more data to peer */
  105. #define    SS_CANTRCVMORE        0x020    /* can't receive more data from peer */
  106. #define    SS_RCVATMARK        0x040    /* at mark on input */
  107.  
  108. #define    SS_PRIV            0x080    /* privileged for broadcast, raw... */
  109. #define    SS_NBIO            0x100    /* non-blocking ops */
  110. #define    SS_ASYNC        0x200    /* async i/o notify */
  111. #define    SS_ISCONFIRMING        0x400    /* deciding to accept connection req */
  112. #define SS_BOUND        0x800    /* socket is bound to a "port" */
  113. #define SS_CANREAD        0x1000    /* can "read" from socket - affected by shutdown() */
  114. #define SS_CANWRITE        0x2000    /* can "write" from socket - affected by shutdown() */
  115. #define SS_CANREADWRITE     (SS_CANREAD | SS_CANWRITE)
  116.  
  117.  
  118. /*
  119.  * Macros for sockets and socket buffering.
  120.  */
  121.  
  122. /*
  123.  * How much space is there in a socket buffer (so->so_snd or so->so_rcv)?
  124.  * This is problematical if the fields are unsigned, as the space might
  125.  * still be negative (cc > hiwat or mbcnt > mbmax).  Should detect
  126.  * overflow and return 0.  Should use "lmin" but it doesn't exist now.
  127.  */
  128. #define    sbspace(sb) \
  129.     ((long) imin((int)((sb)->sb_hiwat - (sb)->sb_cc), \
  130.      (int)((sb)->sb_mbmax - (sb)->sb_mbcnt)))
  131.  
  132. /* do we have to send all at once on a socket? */
  133. #define    sosendallatonce(so) \
  134.     ((so)->so_proto->pr_flags & PR_ATOMIC)
  135.  
  136. /* can we read something from so? */
  137. #define    soreadable(so) \
  138.     ((so)->so_rcv.sb_cc >= (so)->so_rcv.sb_lowat || \
  139.     ((so)->so_state & SS_CANTRCVMORE) || \
  140.     (so)->so_qlen || (so)->so_error)
  141.  
  142. /* can we write something to so? */
  143. #define    sowriteable(so) \
  144.     (sbspace(&(so)->so_snd) >= (so)->so_snd.sb_lowat && \
  145.     (((so)->so_state&SS_ISCONNECTED) || \
  146.       ((so)->so_proto->pr_flags&PR_CONNREQUIRED)==0) || \
  147.      ((so)->so_state & SS_CANTSENDMORE) || \
  148.      (so)->so_error)
  149.  
  150. /* adjust counters in sb reflecting allocation of m */
  151. #define    sballoc(sb, m) { \
  152.     (sb)->sb_cc += (m)->m_len; \
  153.     (sb)->sb_mbcnt += MSIZE; \
  154.     if ((m)->m_flags & M_EXT) \
  155.         (sb)->sb_mbcnt += (m)->m_ext.ext_size; \
  156. }
  157.  
  158. /* adjust counters in sb reflecting freeing of m */
  159. #define    sbfree(sb, m) { \
  160.     (sb)->sb_cc -= (m)->m_len; \
  161.     (sb)->sb_mbcnt -= MSIZE; \
  162.     if ((m)->m_flags & M_EXT) \
  163.         (sb)->sb_mbcnt -= (m)->m_ext.ext_size; \
  164. }
  165.  
  166. /*
  167.  * Set lock on sockbuf sb; sleep if lock is already held.
  168.  * Unless SB_NOINTR is set on sockbuf, sleep is interruptible.
  169.  * Returns error without lock if sleep is interrupted.
  170.  */
  171. #define sblock(sb) ((sb)->sb_flags & SB_LOCK ? sb_lock(sb) : \
  172.         ((sb)->sb_flags |= SB_LOCK, 0))
  173.  
  174. /* release lock on sockbuf sb */
  175. #define    sbunlock(sb) { \
  176.     (sb)->sb_flags &= ~SB_LOCK; \
  177.     if ((sb)->sb_flags & SB_WANT) { \
  178.         (sb)->sb_flags &= ~SB_WANT; \
  179.         wakeup((caddr_t)&(sb)->sb_flags); \
  180.     } \
  181. }
  182.  
  183. #define    sorwakeup(so)    sowakeup((so), &(so)->so_rcv)
  184. #define    sowwakeup(so)    sowakeup((so), &(so)->so_snd)
  185.  
  186. #ifdef _KERNEL
  187. u_long    sb_max;
  188. /* to catch callers missing new second argument to sonewconn: */
  189. #define    sonewconn(head, connstatus)    sonewconn1((head), (connstatus))
  190. struct    socket *sonewconn1 __P((struct socket *head, int connstatus));
  191.  
  192. /* strings for sleep message: */
  193. extern    char netio[], netcon[], netcls[];
  194.  
  195. #if 0
  196. /*
  197.  * File operations on sockets.
  198.  */
  199. int    soo_read __P((struct file *fp, struct uio *uio, struct ucred *cred));
  200. int    soo_write __P((struct file *fp, struct uio *uio, struct ucred *cred));
  201. int    soo_ioctl __P((struct file *fp, int com, caddr_t data, struct proc *p));
  202. int    soo_select __P((struct file *fp, int which, struct proc *p));
  203. int     soo_close __P((struct file *fp, struct proc *p));
  204. #endif
  205.  
  206. #endif
  207.