sys/sys/protosw.h

   1 /*-
   2  * Copyright (c) 1982, 1986, 1993
   3  *      The Regents of the University of California.  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. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  *      @(#)protosw.h   8.1 (Berkeley) 6/2/93
  30  * $FreeBSD: src/sys/sys/protosw.h,v 1.28.2.2 2001/07/03 11:02:01 ume Exp $
  31  */
  32
  33 #ifndef _SYS_PROTOSW_H_
  34 #define _SYS_PROTOSW_H_
  35
  36 #ifndef _SYS_TYPES_H_
  37 #include <sys/types.h>
  38 #endif
  39
  40 /* Forward declare these structures referenced from prototypes below. */
  41 struct mbuf;
  42 struct thread;
  43 struct sockaddr;
  44 struct socket;
  45 struct sockopt;
  46
  47 struct pr_output_info {
  48         pid_t   p_pid;
  49 };
  50
  51 #if defined(_KERNEL) || defined(_KERNEL_STRUCTURES)
  52
  53 /*
  54  * netmsg_t union of possible netmsgs typically sent to protocol threads.
  55  */
  56 typedef union netmsg *netmsg_t;
  57
  58 /*
  59  * Protocol switch table.
  60  *
  61  * Each protocol has a handle initializing one of these structures,
  62  * which is used for protocol-protocol and system-protocol communication.
  63  *
  64  * A protocol is called through the pr_init entry before any other.
  65  * Thereafter it is called every 200ms through the pr_fasttimo entry and
  66  * every 500ms through the pr_slowtimo for timer based actions.
  67  * The system will call the pr_drain entry if it is low on space and
  68  * this should throw away any non-critical data.
  69  *
  70  * Protocols pass data between themselves as chains of mbufs using
  71  * the pr_input and pr_output hooks.  Pr_input passes data up (towards
  72  * the users) and pr_output passes it down (towards the interfaces); control
  73  * information passes up and down on pr_ctlinput and pr_ctloutput.
  74  * The protocol is responsible for the space occupied by any the
  75  * arguments to these entries and must dispose it.
  76  *
  77  * In retrospect, it would be a lot nicer to use an interface
  78  * similar to the vnode VOP interface.
  79  */
  80 struct protosw {
  81         short   pr_type;                /* socket type used for */
  82         const struct domain *pr_domain; /* domain protocol a member of */
  83         short   pr_protocol;            /* protocol number */
  84         short   pr_flags;               /* see below */
  85
  86         struct lwkt_port *(*pr_initport)(void);
  87                                         /* initial msgport */
  88
  89         /*
  90          * Protocol hooks.  These are typically called directly within the
  91          * context of a protocol thread based on the toeplitz hash.
  92          *
  93          * pr_input() is called using the port supplied by the toeplitz
  94          *            hash via the netisr port function.
  95          *
  96          * pr_ctlinput() is called using the port supplied by pr_ctlport
  97          *
  98          * pr_ctloutput() and pr_output() are typically called
  99          */
 100         int     (*pr_input)(struct mbuf **, int *, int);
 101                                         /* input to protocol (from below) */
 102         int     (*pr_output)(struct mbuf *, struct socket *, ...);
 103                                         /* output to protocol (from above) */
 104         void    (*pr_ctlinput)(netmsg_t);
 105                                         /* control input (from below) */
 106         void    (*pr_ctloutput)(netmsg_t);
 107                                         /* control output (from above) */
 108         struct lwkt_port *(*pr_ctlport)(int, struct sockaddr *, void *, int *);
 109
 110         /*
 111          * Utility hooks, not called with any particular context.
 112          */
 113         void    (*pr_init) (void);      /* initialization hook */
 114         void    (*pr_fasttimo) (void);  /* fast timeout (200ms) */
 115         void    (*pr_slowtimo) (void);  /* slow timeout (500ms) */
 116         void    (*pr_drain) (void);     /* flush any excess space possible */
 117
 118         struct  pr_usrreqs *pr_usrreqs; /* messaged requests to proto thread */
 119 };
 120
 121 #endif
 122
 123 #define PR_SLOWHZ       2               /* 2 slow timeouts per second */
 124 #define PR_FASTHZ       5               /* 5 fast timeouts per second */
 125
 126 /*
 127  * Values for pr_flags.
 128  * PR_ADDR requires PR_ATOMIC;
 129  * PR_ADDR and PR_CONNREQUIRED are mutually exclusive.
 130  * PR_IMPLOPCL means that the protocol allows sendto without prior connect,
 131  *      and the protocol understands the MSG_EOF flag.  The first property is
 132  *      is only relevant if PR_CONNREQUIRED is set (otherwise sendto is allowed
 133  *      anyhow).
 134  */
 135 #define PR_ATOMIC       0x01            /* exchange atomic messages only */
 136 #define PR_ADDR         0x02            /* addresses given with messages */
 137 #define PR_CONNREQUIRED 0x04            /* connection required by protocol */
 138 #define PR_WANTRCVD     0x08            /* want PRU_RCVD calls */
 139 #define PR_RIGHTS       0x10            /* passes capabilities */
 140 #define PR_IMPLOPCL     0x20            /* implied open/close */
 141 #define PR_LASTHDR      0x40            /* enforce ipsec policy; last header */
 142 #define PR_UNUSED07     0x80            /* was: allow addresses during delivery (SCTP) */
 143 #define PR_MPSAFE       0x0100          /* protocal is MPSAFE */
 144 #define PR_SYNC_PORT    0x0200          /* synchronous port (no proto thrds) */
 145 #define PR_ASYNC_SEND   0x0400          /* async pru_send */
 146 #define PR_ASYNC_RCVD   0x0800          /* async pru_rcvd */
 147 #define PR_ASEND_HOLDTD 0x1000          /* async pru_send hold orig thread */
 148 #define PR_ACONN_HOLDTD 0x2000          /* async pru_connect hold orig thread */
 149
 150 /*
 151  * The arguments to usrreq are:
 152  *      (*protosw[].pr_usrreq)(up, req, m, nam, opt);
 153  * where up is a (struct socket *), req is one of these requests,
 154  * m is a optional mbuf chain containing a message,
 155  * nam is an optional mbuf chain containing an address,
 156  * and opt is a pointer to a socketopt structure or nil.
 157  * The protocol is responsible for disposal of the mbuf chain m,
 158  * the caller is responsible for any space held by nam and opt.
 159  * A non-zero return from usrreq gives an
 160  * UNIX error number which should be passed to higher level software.
 161  */
 162 #define PRU_ATTACH              0       /* attach protocol to up */
 163 #define PRU_DETACH              1       /* detach protocol from up */
 164 #define PRU_BIND                2       /* bind socket to address */
 165 #define PRU_LISTEN              3       /* listen for connection */
 166 #define PRU_CONNECT             4       /* establish connection to peer */
 167 #define PRU_ACCEPT              5       /* accept connection from peer */
 168 #define PRU_DISCONNECT          6       /* disconnect from peer */
 169 #define PRU_SHUTDOWN            7       /* won't send any more data */
 170 #define PRU_RCVD                8       /* have taken data; more room now */
 171 #define PRU_SEND                9       /* send this data */
 172 #define PRU_ABORT               10      /* abort (fast DISCONNECT, DETATCH) */
 173 #define PRU_CONTROL             11      /* control operations on protocol */
 174 #define PRU_SENSE               12      /* return status into m */
 175 #define PRU_RCVOOB              13      /* retrieve out of band data */
 176 #define PRU_SENDOOB             14      /* send out of band data */
 177 #define PRU_SOCKADDR            15      /* fetch socket's address */
 178 #define PRU_PEERADDR            16      /* fetch peer's address */
 179 #define PRU_CONNECT2            17      /* connect two sockets */
 180 #define PRU_RESERVED1           18      /* formerly PRU_SOPOLL */
 181 /* begin for protocols internal use */
 182 #define PRU_FASTTIMO            19      /* 200ms timeout */
 183 #define PRU_SLOWTIMO            20      /* 500ms timeout */
 184 #define PRU_PROTORCV            21      /* receive from below */
 185 #define PRU_PROTOSEND           22      /* send to below */
 186 /* end for protocol's internal use */
 187 #define PRU_SEND_EOF            23      /* send and close */
 188 #define PRU_PRED                24
 189 #define PRU_CTLOUTPUT           25      /* get/set opts */
 190 #define PRU_NREQ                26
 191
 192 #ifdef PRUREQUESTS
 193 const char *prurequests[] = {
 194         "ATTACH",       "DETACH",       "BIND",         "LISTEN",
 195         "CONNECT",      "ACCEPT",       "DISCONNECT",   "SHUTDOWN",
 196         "RCVD",         "SEND",         "ABORT",        "CONTROL",
 197         "SENSE",        "RCVOOB",       "SENDOOB",      "SOCKADDR",
 198         "PEERADDR",     "CONNECT2",     "",
 199         "FASTTIMO",     "SLOWTIMO",     "PROTORCV",     "PROTOSEND",
 200         "SEND_EOF",     "PREDICATE"
 201 };
 202 #endif
 203
 204 #if defined(_KERNEL) || defined(_KERNEL_STRUCTURES)
 205
 206 struct ifnet;
 207 struct stat;
 208 struct ucred;
 209 struct uio;
 210 struct sockbuf;
 211
 212 struct pru_attach_info {
 213         struct rlimit *sb_rlimit;
 214         struct ucred *p_ucred;
 215         struct vnode *fd_rdir;
 216 };
 217
 218 /*
 219  * These are netmsg'd requests almost universally in the context of the
 220  * appropriate protocol thread.  Exceptions:
 221  *
 222  *      pru_sosend() - called synchronously from user context, typically
 223  *                     runs generic kernel code and then messages via
 224  *                     pru_send().
 225  *
 226  *      pru_soreceive() - called synchronously from user context.  Typically
 227  *                        runs generic kernel code and remains synchronous.
 228  *
 229  *      pru_preconnect() - called synchronously from user context.  Typically
 230  *                         prepares for later asynchronous pru_connect, e.g.
 231  *                         sets ISCONNECTING.  Non-NULL means asynchronous
 232  *                         pru_connect is supported.
 233  */
 234 struct pr_usrreqs {
 235         void    (*pru_abort) (netmsg_t msg);
 236         void    (*pru_accept) (netmsg_t msg);
 237         void    (*pru_attach) (netmsg_t msg);
 238         void    (*pru_bind) (netmsg_t msg);
 239         void    (*pru_connect) (netmsg_t msg);
 240         void    (*pru_connect2) (netmsg_t msg);
 241         void    (*pru_control) (netmsg_t msg);
 242         /*
 243          * If pru_detach() returns EJUSTRETURN, then protocol will
 244          * call sodiscard() and sofree() for soclose().
 245          */
 246         void    (*pru_detach) (netmsg_t msg);
 247         void    (*pru_disconnect) (netmsg_t msg);
 248         void    (*pru_listen) (netmsg_t msg);
 249         void    (*pru_peeraddr) (netmsg_t msg);
 250         void    (*pru_rcvd) (netmsg_t msg);
 251         void    (*pru_rcvoob) (netmsg_t msg);
 252         void    (*pru_send) (netmsg_t msg);
 253         void    (*pru_sense) (netmsg_t msg);
 254         void    (*pru_shutdown) (netmsg_t msg);
 255         void    (*pru_sockaddr) (netmsg_t msg);
 256
 257         /*
 258          * These are direct calls.  Note that sosend() will sometimes
 259          * be converted into an implied connect (pru_connect) with the
 260          * mbufs and flags forwarded in pru_connect's netmsg.  It is
 261          * otherwise typically converted to a send (pru_send).
 262          *
 263          * soreceive() typically remains synchronous in the user's context.
 264          *
 265          * Any converted calls are netmsg's to the socket's protocol thread.
 266          */
 267         int     (*pru_sosend) (struct socket *so, struct sockaddr *addr,
 268                                    struct uio *uio, struct mbuf *top,
 269                                    struct mbuf *control, int flags,
 270                                    struct thread *td);
 271         int     (*pru_soreceive) (struct socket *so,
 272                                       struct sockaddr **paddr,
 273                                       struct uio *uio,
 274                                       struct sockbuf *sio,
 275                                       struct mbuf **controlp, int *flagsp);
 276
 277         /*
 278          * Synchronously called by protocol thread.  Typically save the
 279          * foreign address into socket.so_faddr.
 280          */
 281         void    (*pru_savefaddr) (struct socket *so,
 282                                       const struct sockaddr *addr);
 283
 284         /* synchronously called by user thread. */
 285         int     (*pru_preconnect) (struct socket *so,
 286                                       const struct sockaddr *addr,
 287                                       struct thread *td);
 288         int     (*pru_preattach) (struct socket *so,
 289                                       int, struct pru_attach_info *);
 290 };
 291
 292 typedef int (*pru_sosend_fn_t) (struct socket *so, struct sockaddr *addr,
 293                                         struct uio *uio, struct mbuf *top,
 294                                         struct mbuf *control, int flags,
 295                                         struct thread *td);
 296 typedef int (*pru_soreceive_fn_t) (struct socket *so, struct sockaddr **paddr,
 297                                         struct uio *uio,
 298                                         struct sockbuf *sio,
 299                                         struct mbuf **controlp,
 300                                         int *flagsp);
 301
 302 void    pr_generic_notsupp(netmsg_t msg);
 303 void    pru_sense_null(netmsg_t msg);
 304
 305 int     pru_sosend_notsupp(struct socket *so, struct sockaddr *addr,
 306                                 struct uio *uio, struct mbuf *top,
 307                                 struct mbuf *control, int flags,
 308                                 struct thread *td);
 309 int     pru_soreceive_notsupp(struct socket *so,
 310                                 struct sockaddr **paddr,
 311                                 struct uio *uio,
 312                                 struct sockbuf *sio,
 313                                 struct mbuf **controlp, int *flagsp);
 314
 315 struct lwkt_port *cpu0_soport(struct socket *, struct sockaddr *,
 316                               struct mbuf **);
 317 struct lwkt_port *cpu0_ctlport(int, struct sockaddr *, void *, int *);
 318
 319 #endif /* _KERNEL || _KERNEL_STRUCTURES */
 320
 321 /*
 322  * The arguments to the ctlinput routine are
 323  *      (*protosw[].pr_ctlinput)(cmd, sa, arg);
 324  * where cmd is one of the commands below, sa is a pointer to a sockaddr,
 325  * and arg is a `void *' argument used within a protocol family.
 326  */
 327 #define PRC_IFDOWN              0       /* interface transition */
 328 #define PRC_ROUTEDEAD           1       /* select new route if possible ??? */
 329 #define PRC_IFUP                2       /* interface has come back up */
 330 #define PRC_QUENCH2             3       /* DEC congestion bit says slow down */
 331 #define PRC_QUENCH              4       /* some one said to slow down */
 332 #define PRC_MSGSIZE             5       /* message size forced drop */
 333 #define PRC_HOSTDEAD            6       /* host appears to be down */
 334 #define PRC_HOSTUNREACH         7       /* deprecated (use PRC_UNREACH_HOST) */
 335 #define PRC_UNREACH_NET         8       /* no route to network */
 336 #define PRC_UNREACH_HOST        9       /* no route to host */
 337 #define PRC_UNREACH_PROTOCOL    10      /* dst says bad protocol */
 338 #define PRC_UNREACH_PORT        11      /* bad port # */
 339 /* was  PRC_UNREACH_NEEDFRAG    12         (use PRC_MSGSIZE) */
 340 #define PRC_UNREACH_SRCFAIL     13      /* source route failed */
 341 #define PRC_REDIRECT_NET        14      /* net routing redirect */
 342 #define PRC_REDIRECT_HOST       15      /* host routing redirect */
 343 #define PRC_REDIRECT_TOSNET     16      /* redirect for type of service & net */
 344 #define PRC_REDIRECT_TOSHOST    17      /* redirect for tos & host */
 345 #define PRC_TIMXCEED_INTRANS    18      /* packet lifetime expired in transit */
 346 #define PRC_TIMXCEED_REASS      19      /* lifetime expired on reass q */
 347 #define PRC_PARAMPROB           20      /* header incorrect */
 348 #define PRC_UNREACH_ADMIN_PROHIB        21      /* packet administrativly prohibited */
 349
 350 #define PRC_NCMDS               22
 351
 352 #define PRC_IS_REDIRECT(cmd)    \
 353         ((cmd) >= PRC_REDIRECT_NET && (cmd) <= PRC_REDIRECT_TOSHOST)
 354
 355 #ifdef PRCREQUESTS
 356 const char *prcrequests[] = {
 357         "IFDOWN", "ROUTEDEAD", "IFUP", "DEC-BIT-QUENCH2",
 358         "QUENCH", "MSGSIZE", "HOSTDEAD", "#7",
 359         "NET-UNREACH", "HOST-UNREACH", "PROTO-UNREACH", "PORT-UNREACH",
 360         "#12", "SRCFAIL-UNREACH", "NET-REDIRECT", "HOST-REDIRECT",
 361         "TOSNET-REDIRECT", "TOSHOST-REDIRECT", "TX-INTRANS", "TX-REASS",
 362         "PARAMPROB", "ADMIN-UNREACH"
 363 };
 364 #endif
 365
 366 /*
 367  * The arguments to ctloutput are:
 368  *      (*protosw[].pr_ctloutput)(req, so, level, optname, optval, p);
 369  * req is one of the actions listed below, so is a (struct socket *),
 370  * level is an indication of which protocol layer the option is intended.
 371  * optname is a protocol dependent socket option request,
 372  * optval is a pointer to a mbuf-chain pointer, for value-return results.
 373  * The protocol is responsible for disposal of the mbuf chain *optval
 374  * if supplied,
 375  * the caller is responsible for any space held by *optval, when returned.
 376  * A non-zero return from usrreq gives an
 377  * UNIX error number which should be passed to higher level software.
 378  */
 379 #define PRCO_GETOPT     0
 380 #define PRCO_SETOPT     1
 381
 382 #define PRCO_NCMDS      2
 383
 384 #ifdef PRCOREQUESTS
 385 const char *prcorequests[] = {
 386         "GETOPT", "SETOPT",
 387 };
 388 #endif
 389
 390 /*
 391  * Kernel prototypes
 392  */
 393 #ifdef _KERNEL
 394
 395 void    kpfctlinput (int, struct sockaddr *);
 396 void    kpfctlinput_direct (int, struct sockaddr *);
 397 void    kpfctlinput2 (int, struct sockaddr *, void *);
 398 struct protosw *pffindproto (int family, int protocol, int type);
 399 struct protosw *pffindtype (int family, int type);
 400
 401 #define PR_GET_MPLOCK(_pr) \
 402 do { \
 403         if (((_pr)->pr_flags & PR_MPSAFE) == 0) \
 404                 get_mplock(); \
 405 } while (0)
 406
 407 #define PR_REL_MPLOCK(_pr) \
 408 do { \
 409         if (((_pr)->pr_flags & PR_MPSAFE) == 0) \
 410                 rel_mplock(); \
 411 } while (0)
 412
 413 #endif  /* _KERNEL */
 414
 415 #endif  /* _SYS_PROTOSW_H_ */