The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/sys/socketvar.h

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * SPDX-License-Identifier: BSD-3-Clause
    3  *
    4  * Copyright (c) 1982, 1986, 1990, 1993
    5  *      The Regents of the University of California.  All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. Neither the name of the University nor the names of its contributors
   16  *    may be used to endorse or promote products derived from this software
   17  *    without specific prior written permission.
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   29  * SUCH DAMAGE.
   30  *
   31  *      @(#)socketvar.h 8.3 (Berkeley) 2/19/95
   32  *
   33  * $FreeBSD$
   34  */
   35 
   36 #ifndef _SYS_SOCKETVAR_H_
   37 #define _SYS_SOCKETVAR_H_
   38 
   39 /*
   40  * Socket generation count type.  Also used in xinpcb, xtcpcb, xunpcb.
   41  */
   42 typedef uint64_t so_gen_t;
   43 
   44 #if defined(_KERNEL) || defined(_WANT_SOCKET)
   45 #include <sys/queue.h>                  /* for TAILQ macros */
   46 #include <sys/selinfo.h>                /* for struct selinfo */
   47 #include <sys/_lock.h>
   48 #include <sys/_mutex.h>
   49 #include <sys/osd.h>
   50 #include <sys/_sx.h>
   51 #include <sys/sockbuf.h>
   52 #ifdef _KERNEL
   53 #include <sys/caprights.h>
   54 #include <sys/sockopt.h>
   55 #endif
   56 
   57 struct vnet;
   58 
   59 /*
   60  * Kernel structure per socket.
   61  * Contains send and receive buffer queues,
   62  * handle on protocol and pointer to protocol
   63  * private data and error information.
   64  */
   65 typedef int so_upcall_t(struct socket *, void *, int);
   66 typedef void so_dtor_t(struct socket *);
   67 
   68 struct socket;
   69 
   70 enum socket_qstate {
   71         SQ_NONE = 0,
   72         SQ_INCOMP = 0x0800,     /* on sol_incomp */
   73         SQ_COMP = 0x1000,       /* on sol_comp */
   74 };
   75 
   76 /*-
   77  * Locking key to struct socket:
   78  * (a) constant after allocation, no locking required.
   79  * (b) locked by SOCK_LOCK(so).
   80  * (cr) locked by SOCKBUF_LOCK(&so->so_rcv).
   81  * (cs) locked by SOCKBUF_LOCK(&so->so_snd).
   82  * (e) locked by SOLISTEN_LOCK() of corresponding listening socket.
   83  * (f) not locked since integer reads/writes are atomic.
   84  * (g) used only as a sleep/wakeup address, no value.
   85  * (h) locked by global mutex so_global_mtx.
   86  */
   87 TAILQ_HEAD(accept_queue, socket);
   88 struct socket {
   89         struct mtx      so_lock;
   90         volatile u_int  so_count;       /* (b / refcount) */
   91         struct selinfo  so_rdsel;       /* (b/cr) for so_rcv/so_comp */
   92         struct selinfo  so_wrsel;       /* (b/cs) for so_snd */
   93         short   so_type;                /* (a) generic type, see socket.h */
   94         int     so_options;             /* (b) from socket call, see socket.h */
   95         short   so_linger;              /* time to linger close(2) */
   96         short   so_state;               /* (b) internal state flags SS_* */
   97         void    *so_pcb;                /* protocol control block */
   98         struct  vnet *so_vnet;          /* (a) network stack instance */
   99         struct  protosw *so_proto;      /* (a) protocol handle */
  100         short   so_timeo;               /* (g) connection timeout */
  101         u_short so_error;               /* (f) error affecting connection */
  102         u_short so_rerror;              /* (f) error affecting connection */
  103         struct  sigio *so_sigio;        /* [sg] information for async I/O or
  104                                            out of band data (SIGURG) */
  105         struct  ucred *so_cred;         /* (a) user credentials */
  106         struct  label *so_label;        /* (b) MAC label for socket */
  107         /* NB: generation count must not be first. */
  108         so_gen_t so_gencnt;             /* (h) generation count */
  109         void    *so_emuldata;           /* (b) private data for emulators */
  110         so_dtor_t *so_dtor;             /* (b) optional destructor */
  111         struct  osd     osd;            /* Object Specific extensions */
  112         /*
  113          * so_fibnum, so_user_cookie and friends can be used to attach
  114          * some user-specified metadata to a socket, which then can be
  115          * used by the kernel for various actions.
  116          * so_user_cookie is used by ipfw/dummynet.
  117          */
  118         int so_fibnum;          /* routing domain for this socket */
  119         uint32_t so_user_cookie;
  120 
  121         int so_ts_clock;        /* type of the clock used for timestamps */
  122         uint32_t so_max_pacing_rate;    /* (f) TX rate limit in bytes/s */
  123         union {
  124                 /* Regular (data flow) socket. */
  125                 struct {
  126                         /* (cr, cs) Receive and send buffers. */
  127                         struct sockbuf          so_rcv, so_snd;
  128 
  129                         /* (e) Our place on accept queue. */
  130                         TAILQ_ENTRY(socket)     so_list;
  131                         struct socket           *so_listen;     /* (b) */
  132                         enum socket_qstate so_qstate;           /* (b) */
  133                         /* (b) cached MAC label for peer */
  134                         struct  label           *so_peerlabel;
  135                         u_long  so_oobmark;     /* chars to oob mark */
  136                 };
  137                 /*
  138                  * Listening socket, where accepts occur, is so_listen in all
  139                  * subsidiary sockets.  If so_listen is NULL, socket is not
  140                  * related to an accept.  For a listening socket itself
  141                  * sol_incomp queues partially completed connections, while
  142                  * sol_comp is a queue of connections ready to be accepted.
  143                  * If a connection is aborted and it has so_listen set, then
  144                  * it has to be pulled out of either sol_incomp or sol_comp.
  145                  * We allow connections to queue up based on current queue
  146                  * lengths and limit on number of queued connections for this
  147                  * socket.
  148                  */
  149                 struct {
  150                         /* (e) queue of partial unaccepted connections */
  151                         struct accept_queue     sol_incomp;
  152                         /* (e) queue of complete unaccepted connections */
  153                         struct accept_queue     sol_comp;
  154                         u_int   sol_qlen;    /* (e) sol_comp length */
  155                         u_int   sol_incqlen; /* (e) sol_incomp length */
  156                         u_int   sol_qlimit;  /* (e) queue limit */
  157 
  158                         /* accept_filter(9) optional data */
  159                         struct  accept_filter   *sol_accept_filter;
  160                         void    *sol_accept_filter_arg; /* saved filter args */
  161                         char    *sol_accept_filter_str; /* saved user args */
  162 
  163                         /* Optional upcall, for kernel socket. */
  164                         so_upcall_t     *sol_upcall;    /* (e) */
  165                         void            *sol_upcallarg; /* (e) */
  166 
  167                         /* Socket buffer parameters, to be copied to
  168                          * dataflow sockets, accepted from this one. */
  169                         int             sol_sbrcv_lowat;
  170                         int             sol_sbsnd_lowat;
  171                         u_int           sol_sbrcv_hiwat;
  172                         u_int           sol_sbsnd_hiwat;
  173                         short           sol_sbrcv_flags;
  174                         short           sol_sbsnd_flags;
  175                         sbintime_t      sol_sbrcv_timeo;
  176                         sbintime_t      sol_sbsnd_timeo;
  177                 };
  178         };
  179 };
  180 #endif  /* defined(_KERNEL) || defined(_WANT_SOCKET) */
  181 
  182 /*
  183  * Socket state bits.
  184  *
  185  * Historically, this bits were all kept in the so_state field.  For
  186  * locking reasons, they are now in multiple fields, as they are
  187  * locked differently.  so_state maintains basic socket state protected
  188  * by the socket lock.  so_qstate holds information about the socket
  189  * accept queues.  Each socket buffer also has a state field holding
  190  * information relevant to that socket buffer (can't send, rcv).  Many
  191  * fields will be read without locks to improve performance and avoid
  192  * lock order issues.  However, this approach must be used with caution.
  193  */
  194 #define SS_NOFDREF              0x0001  /* no file table ref any more */
  195 #define SS_ISCONNECTED          0x0002  /* socket connected to a peer */
  196 #define SS_ISCONNECTING         0x0004  /* in process of connecting to peer */
  197 #define SS_ISDISCONNECTING      0x0008  /* in process of disconnecting */
  198 #define SS_NBIO                 0x0100  /* non-blocking ops */
  199 #define SS_ASYNC                0x0200  /* async i/o notify */
  200 #define SS_ISCONFIRMING         0x0400  /* deciding to accept connection req */
  201 #define SS_ISDISCONNECTED       0x2000  /* socket disconnected from peer */
  202 
  203 /*
  204  * Protocols can mark a socket as SS_PROTOREF to indicate that, following
  205  * pru_detach, they still want the socket to persist, and will free it
  206  * themselves when they are done.  Protocols should only ever call sofree()
  207  * following setting this flag in pru_detach(), and never otherwise, as
  208  * sofree() bypasses socket reference counting.
  209  */
  210 #define SS_PROTOREF             0x4000  /* strong protocol reference */
  211 
  212 #ifdef _KERNEL
  213 
  214 #define SOCK_MTX(so)            &(so)->so_lock
  215 #define SOCK_LOCK(so)           mtx_lock(&(so)->so_lock)
  216 #define SOCK_OWNED(so)          mtx_owned(&(so)->so_lock)
  217 #define SOCK_UNLOCK(so)         mtx_unlock(&(so)->so_lock)
  218 #define SOCK_LOCK_ASSERT(so)    mtx_assert(&(so)->so_lock, MA_OWNED)
  219 #define SOCK_UNLOCK_ASSERT(so)  mtx_assert(&(so)->so_lock, MA_NOTOWNED)
  220 
  221 #define SOLISTENING(sol)        (((sol)->so_options & SO_ACCEPTCONN) != 0)
  222 #define SOLISTEN_LOCK(sol)      do {                                    \
  223         mtx_lock(&(sol)->so_lock);                                      \
  224         KASSERT(SOLISTENING(sol),                                       \
  225             ("%s: %p not listening", __func__, (sol)));                 \
  226 } while (0)
  227 #define SOLISTEN_TRYLOCK(sol)   mtx_trylock(&(sol)->so_lock)
  228 #define SOLISTEN_UNLOCK(sol)    do {                                    \
  229         KASSERT(SOLISTENING(sol),                                       \
  230             ("%s: %p not listening", __func__, (sol)));                 \
  231         mtx_unlock(&(sol)->so_lock);                                    \
  232 } while (0)
  233 #define SOLISTEN_LOCK_ASSERT(sol)       do {                            \
  234         mtx_assert(&(sol)->so_lock, MA_OWNED);                          \
  235         KASSERT(SOLISTENING(sol),                                       \
  236             ("%s: %p not listening", __func__, (sol)));                 \
  237 } while (0)
  238 
  239 /*
  240  * Macros for sockets and socket buffering.
  241  */
  242 
  243 /*
  244  * Flags to sblock().
  245  */
  246 #define SBL_WAIT        0x00000001      /* Wait if not immediately available. */
  247 #define SBL_NOINTR      0x00000002      /* Force non-interruptible sleep. */
  248 #define SBL_VALID       (SBL_WAIT | SBL_NOINTR)
  249 
  250 /*
  251  * Do we need to notify the other side when I/O is possible?
  252  */
  253 #define sb_notify(sb)   (((sb)->sb_flags & (SB_WAIT | SB_SEL | SB_ASYNC | \
  254     SB_UPCALL | SB_AIO | SB_KNOTE)) != 0)
  255 
  256 /* do we have to send all at once on a socket? */
  257 #define sosendallatonce(so) \
  258     ((so)->so_proto->pr_flags & PR_ATOMIC)
  259 
  260 /* can we read something from so? */
  261 #define soreadabledata(so) \
  262         (sbavail(&(so)->so_rcv) >= (so)->so_rcv.sb_lowat || \
  263         (so)->so_error || (so)->so_rerror)
  264 #define soreadable(so) \
  265         (soreadabledata(so) || ((so)->so_rcv.sb_state & SBS_CANTRCVMORE))
  266 
  267 /* can we write something to so? */
  268 #define sowriteable(so) \
  269     ((sbspace(&(so)->so_snd) >= (so)->so_snd.sb_lowat && \
  270         (((so)->so_state&SS_ISCONNECTED) || \
  271           ((so)->so_proto->pr_flags&PR_CONNREQUIRED)==0)) || \
  272      ((so)->so_snd.sb_state & SBS_CANTSENDMORE) || \
  273      (so)->so_error)
  274 
  275 /*
  276  * soref()/sorele() ref-count the socket structure.
  277  * soref() may be called without owning socket lock, but in that case a
  278  * caller must own something that holds socket, and so_count must be not 0.
  279  * Note that you must still explicitly close the socket, but the last ref
  280  * count will free the structure.
  281  */
  282 #define soref(so)       refcount_acquire(&(so)->so_count)
  283 #define sorele(so) do {                                                 \
  284         SOCK_LOCK_ASSERT(so);                                           \
  285         if (refcount_release(&(so)->so_count))                          \
  286                 sofree(so);                                             \
  287         else                                                            \
  288                 SOCK_UNLOCK(so);                                        \
  289 } while (0)
  290 
  291 /*
  292  * In sorwakeup() and sowwakeup(), acquire the socket buffer lock to
  293  * avoid a non-atomic test-and-wakeup.  However, sowakeup is
  294  * responsible for releasing the lock if it is called.  We unlock only
  295  * if we don't call into sowakeup.  If any code is introduced that
  296  * directly invokes the underlying sowakeup() primitives, it must
  297  * maintain the same semantics.
  298  */
  299 #define sorwakeup_locked(so) do {                                       \
  300         SOCKBUF_LOCK_ASSERT(&(so)->so_rcv);                             \
  301         if (sb_notify(&(so)->so_rcv))                                   \
  302                 sowakeup((so), &(so)->so_rcv);                          \
  303         else                                                            \
  304                 SOCKBUF_UNLOCK(&(so)->so_rcv);                          \
  305 } while (0)
  306 
  307 #define sorwakeup(so) do {                                              \
  308         SOCKBUF_LOCK(&(so)->so_rcv);                                    \
  309         sorwakeup_locked(so);                                           \
  310 } while (0)
  311 
  312 #define sowwakeup_locked(so) do {                                       \
  313         SOCKBUF_LOCK_ASSERT(&(so)->so_snd);                             \
  314         if (sb_notify(&(so)->so_snd))                                   \
  315                 sowakeup((so), &(so)->so_snd);                          \
  316         else                                                            \
  317                 SOCKBUF_UNLOCK(&(so)->so_snd);                          \
  318 } while (0)
  319 
  320 #define sowwakeup(so) do {                                              \
  321         SOCKBUF_LOCK(&(so)->so_snd);                                    \
  322         sowwakeup_locked(so);                                           \
  323 } while (0)
  324 
  325 struct accept_filter {
  326         char    accf_name[16];
  327         int     (*accf_callback)
  328                 (struct socket *so, void *arg, int waitflag);
  329         void *  (*accf_create)
  330                 (struct socket *so, char *arg);
  331         void    (*accf_destroy)
  332                 (struct socket *so);
  333         SLIST_ENTRY(accept_filter) accf_next;
  334 };
  335 
  336 #define ACCEPT_FILTER_DEFINE(modname, filtname, cb, create, destroy, ver) \
  337         static struct accept_filter modname##_filter = {                \
  338                 .accf_name = filtname,                                  \
  339                 .accf_callback = cb,                                    \
  340                 .accf_create = create,                                  \
  341                 .accf_destroy = destroy,                                \
  342         };                                                              \
  343         static moduledata_t modname##_mod = {                           \
  344                 .name = __XSTRING(modname),                             \
  345                 .evhand = accept_filt_generic_mod_event,                \
  346                 .priv = &modname##_filter,                              \
  347         };                                                              \
  348         DECLARE_MODULE(modname, modname##_mod, SI_SUB_DRIVERS,          \
  349             SI_ORDER_MIDDLE);                                           \
  350         MODULE_VERSION(modname, ver)
  351 
  352 #ifdef MALLOC_DECLARE
  353 MALLOC_DECLARE(M_ACCF);
  354 MALLOC_DECLARE(M_PCB);
  355 MALLOC_DECLARE(M_SONAME);
  356 #endif
  357 
  358 /*
  359  * Socket specific helper hook point identifiers
  360  * Do not leave holes in the sequence, hook registration is a loop.
  361  */
  362 #define HHOOK_SOCKET_OPT                0
  363 #define HHOOK_SOCKET_CREATE             1
  364 #define HHOOK_SOCKET_RCV                2
  365 #define HHOOK_SOCKET_SND                3
  366 #define HHOOK_FILT_SOREAD               4
  367 #define HHOOK_FILT_SOWRITE              5
  368 #define HHOOK_SOCKET_CLOSE              6
  369 #define HHOOK_SOCKET_LAST               HHOOK_SOCKET_CLOSE
  370 
  371 struct socket_hhook_data {
  372         struct socket   *so;
  373         struct mbuf     *m;
  374         void            *hctx;          /* hook point specific data*/
  375         int             status;
  376 };
  377 
  378 extern int      maxsockets;
  379 extern u_long   sb_max;
  380 extern so_gen_t so_gencnt;
  381 
  382 struct file;
  383 struct filecaps;
  384 struct filedesc;
  385 struct mbuf;
  386 struct sockaddr;
  387 struct ucred;
  388 struct uio;
  389 
  390 /* 'which' values for socket upcalls. */
  391 #define SO_RCV          1
  392 #define SO_SND          2
  393 
  394 /* Return values for socket upcalls. */
  395 #define SU_OK           0
  396 #define SU_ISCONNECTED  1
  397 
  398 /*
  399  * From uipc_socket and friends
  400  */
  401 int     getsockaddr(struct sockaddr **namp, caddr_t uaddr, size_t len);
  402 int     getsock_cap(struct thread *td, int fd, cap_rights_t *rightsp,
  403             struct file **fpp, u_int *fflagp, struct filecaps *havecaps);
  404 void    soabort(struct socket *so);
  405 int     soaccept(struct socket *so, struct sockaddr **nam);
  406 void    soaio_enqueue(struct task *task);
  407 void    soaio_rcv(void *context, int pending);
  408 void    soaio_snd(void *context, int pending);
  409 int     socheckuid(struct socket *so, uid_t uid);
  410 int     sobind(struct socket *so, struct sockaddr *nam, struct thread *td);
  411 int     sobindat(int fd, struct socket *so, struct sockaddr *nam,
  412             struct thread *td);
  413 int     soclose(struct socket *so);
  414 int     soconnect(struct socket *so, struct sockaddr *nam, struct thread *td);
  415 int     soconnectat(int fd, struct socket *so, struct sockaddr *nam,
  416             struct thread *td);
  417 int     soconnect2(struct socket *so1, struct socket *so2);
  418 int     socreate(int dom, struct socket **aso, int type, int proto,
  419             struct ucred *cred, struct thread *td);
  420 int     sodisconnect(struct socket *so);
  421 void    sodtor_set(struct socket *, so_dtor_t *);
  422 struct  sockaddr *sodupsockaddr(const struct sockaddr *sa, int mflags);
  423 void    sofree(struct socket *so);
  424 void    sohasoutofband(struct socket *so);
  425 int     solisten(struct socket *so, int backlog, struct thread *td);
  426 void    solisten_proto(struct socket *so, int backlog);
  427 int     solisten_proto_check(struct socket *so);
  428 int     solisten_dequeue(struct socket *, struct socket **, int);
  429 struct socket *
  430         sonewconn(struct socket *head, int connstatus);
  431 struct socket *
  432         sopeeloff(struct socket *);
  433 int     sopoll(struct socket *so, int events, struct ucred *active_cred,
  434             struct thread *td);
  435 int     sopoll_generic(struct socket *so, int events,
  436             struct ucred *active_cred, struct thread *td);
  437 int     soreceive(struct socket *so, struct sockaddr **paddr, struct uio *uio,
  438             struct mbuf **mp0, struct mbuf **controlp, int *flagsp);
  439 int     soreceive_stream(struct socket *so, struct sockaddr **paddr,
  440             struct uio *uio, struct mbuf **mp0, struct mbuf **controlp,
  441             int *flagsp);
  442 int     soreceive_dgram(struct socket *so, struct sockaddr **paddr,
  443             struct uio *uio, struct mbuf **mp0, struct mbuf **controlp,
  444             int *flagsp);
  445 int     soreceive_generic(struct socket *so, struct sockaddr **paddr,
  446             struct uio *uio, struct mbuf **mp0, struct mbuf **controlp,
  447             int *flagsp);
  448 int     soreserve(struct socket *so, u_long sndcc, u_long rcvcc);
  449 void    sorflush(struct socket *so);
  450 int     sosend(struct socket *so, struct sockaddr *addr, struct uio *uio,
  451             struct mbuf *top, struct mbuf *control, int flags,
  452             struct thread *td);
  453 int     sosend_dgram(struct socket *so, struct sockaddr *addr,
  454             struct uio *uio, struct mbuf *top, struct mbuf *control,
  455             int flags, struct thread *td);
  456 int     sosend_generic(struct socket *so, struct sockaddr *addr,
  457             struct uio *uio, struct mbuf *top, struct mbuf *control,
  458             int flags, struct thread *td);
  459 int     soshutdown(struct socket *so, int how);
  460 void    soupcall_clear(struct socket *, int);
  461 void    soupcall_set(struct socket *, int, so_upcall_t, void *);
  462 void    solisten_upcall_set(struct socket *, so_upcall_t, void *);
  463 void    sowakeup(struct socket *so, struct sockbuf *sb);
  464 void    sowakeup_aio(struct socket *so, struct sockbuf *sb);
  465 void    solisten_wakeup(struct socket *);
  466 int     selsocket(struct socket *so, int events, struct timeval *tv,
  467             struct thread *td);
  468 void    soisconnected(struct socket *so);
  469 void    soisconnecting(struct socket *so);
  470 void    soisdisconnected(struct socket *so);
  471 void    soisdisconnecting(struct socket *so);
  472 void    socantrcvmore(struct socket *so);
  473 void    socantrcvmore_locked(struct socket *so);
  474 void    socantsendmore(struct socket *so);
  475 void    socantsendmore_locked(struct socket *so);
  476 void    soroverflow(struct socket *so);
  477 void    soroverflow_locked(struct socket *so);
  478 
  479 /*
  480  * Accept filter functions (duh).
  481  */
  482 int     accept_filt_add(struct accept_filter *filt);
  483 int     accept_filt_del(char *name);
  484 struct  accept_filter *accept_filt_get(char *name);
  485 #ifdef ACCEPT_FILTER_MOD
  486 #ifdef SYSCTL_DECL
  487 SYSCTL_DECL(_net_inet_accf);
  488 #endif
  489 int     accept_filt_generic_mod_event(module_t mod, int event, void *data);
  490 #endif
  491 
  492 #endif /* _KERNEL */
  493 
  494 /*
  495  * Structure to export socket from kernel to utilities, via sysctl(3).
  496  */
  497 struct xsocket {
  498         ksize_t         xso_len;        /* length of this structure */
  499         kvaddr_t        xso_so;         /* kernel address of struct socket */
  500         kvaddr_t        so_pcb;         /* kernel address of struct inpcb */
  501         uint64_t        so_oobmark;
  502         int64_t         so_spare64[8];
  503         int32_t         xso_protocol;
  504         int32_t         xso_family;
  505         uint32_t        so_qlen;
  506         uint32_t        so_incqlen;
  507         uint32_t        so_qlimit;
  508         pid_t           so_pgid;
  509         uid_t           so_uid;
  510         int32_t         so_spare32[8];
  511         int16_t         so_type;
  512         int16_t         so_options;
  513         int16_t         so_linger;
  514         int16_t         so_state;
  515         int16_t         so_timeo;
  516         uint16_t        so_error;
  517         struct xsockbuf {
  518                 uint32_t        sb_cc;
  519                 uint32_t        sb_hiwat;
  520                 uint32_t        sb_mbcnt;
  521                 uint32_t        sb_mcnt;
  522                 uint32_t        sb_ccnt;
  523                 uint32_t        sb_mbmax;
  524                 int32_t         sb_lowat;
  525                 int32_t         sb_timeo;
  526                 int16_t         sb_flags;
  527         } so_rcv, so_snd;
  528 };
  529 
  530 #ifdef _KERNEL
  531 void    sotoxsocket(struct socket *so, struct xsocket *xso);
  532 void    sbtoxsockbuf(struct sockbuf *sb, struct xsockbuf *xsb);
  533 #endif
  534 
  535 /*
  536  * Socket buffer state bits.  Exported via libprocstat(3).
  537  */
  538 #define SBS_CANTSENDMORE        0x0010  /* can't send more data to peer */
  539 #define SBS_CANTRCVMORE         0x0020  /* can't receive more data from peer */
  540 #define SBS_RCVATMARK           0x0040  /* at mark on input */
  541 
  542 #endif /* !_SYS_SOCKETVAR_H_ */

Cache object: b11143c1439fd1704e9efc83fe2e46ac


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.