domain(9)

NAME

net_add_domain, pfctlinput, pfctlinput2, pffindproto,

pffindtype,
DOMAIN_SET - network domain management

SYNOPSIS

#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/protosw.h>
#include <sys/domain.h>
void
net_add_domain(void *data);
void
pfctlinput(int cmd, struct sockaddr *sa);
void
pfctlinput2(int cmd, struct sockaddr *sa, void *ctlparam);
struct protosw *
pffindproto(int family, int protocol, int type);
struct protosw *
pffindtype(int family, int type);
void
DOMAIN_SET(name);

DESCRIPTION

Network protocols installed in the system are maintained

within what are
called domains (for example the inetdomain and localdomain).

struct domain {

int dom_family; /* AF_xxx */
char *dom_name;
void (*dom_init) /* initialize domain

data structures */

(void);

int (*dom_externalize) /* externalize ac

cess rights */

(struct mbuf *, struct mbuf **);

void (*dom_dispose) /* dispose of inter

nalized rights */

(struct mbuf *);

struct protosw *dom_protosw, *dom_protoswNPROTOSW;
struct domain *dom_next;
int (*dom_rtattach) /* initialize rout

ing table */

(void **, int);

int dom_rtoffset; /* an arg to rtat

tach, in bits */
int dom_maxrtkey; /* for routing layer

*/

};

Each domain contains an array of protocol switch structures

(struct
protosw *), one for each socket type supported.

struct protosw {

short pr_type; /* socket type used

for */
struct domain *pr_domain; /* domain protocol a

member of */
short pr_protocol; /* protocol number

*/
short pr_flags; /* see below */

/* protocol-protocol hooks */

pr_input_t *pr_input; /* input to protocol

(from below) */
pr_output_t *pr_output; /* output to proto

col (from above) */
pr_ctlinput_t *pr_ctlinput; /* control input

(from below) */
pr_ctloutput_t *pr_ctloutput; /* control output

(from above) */

/* user-protocol hook */

pr_usrreq_t *pr_ousrreq;

/* utility hooks */

pr_init_t *pr_init;
pr_fasttimo_t *pr_fasttimo; /* fast timeout

(200ms) */
pr_slowtimo_t *pr_slowtimo; /* slow timeout

(500ms) */
pr_drain_t *pr_drain; /* flush any excess

space possible */

struct pr_usrreqs *pr_usrreqs; /* supersedes pr_us

rreq() */
struct pfil_head pr_pfh;

};

The following functions handle the registration of a new do

main, lookups
of specific protocols and protocol types within those do

mains, and handle
control messages from the system.

pfctlinput() is called by the system whenever an event oc

curs that could
affect every domain. Examples of those types of events are

routing table
changes, interface shutdowns or certain ICMP message types.

When called,
pfctlinput() calls the protocol specific pr_ctlinput() func

tion for each
protocol in that has defined one, in every domain.

pfctlinput2() provides that same functionality of

pfctlinput(), but with
a few additional checks and a new void * argument that is

passed directly
to the protocol's pr_ctlinput() function. Unlike

pfctlinput(),
pfctlinput2() verifies that sa is not NULL, and that only

the protocol
families that are the same as sa have their pr_ctlinput()

function
called.

net_add_domain() adds a new protocol domain to the system.

The argument
data is cast directly to struct domain * within the func

tion, but is
declared void * in order to prevent compiler warnings when

new domains
are registered with SYSINIT(). In most cases

net_add_domain() is not
called directly, instead DOMAIN_SET() is used.

If the new domain has defined an initialization routine, it

is called by
net_add_domain(); as well, each of the protocols within the

domain that
have defined an initialization routine will have theirs

called.

Once a domain is added it cannot be unloaded. This is be

cause there is
no reference counting system in place to determine if there

are any
active references from sockets within that domain.

pffindtype() and pffindproto() look up a protocol by its

number or by its
type. In most cases, if the protocol or type cannot be

found, NULL is
returned, but pffindproto() may return the default if the

requested type
is SOCK_RAW, a protocol switch type of SOCK_RAW is found,

and the domain
has a default raw protocol.

Both functions are called by socreate() in order to resolve

the protocol
for the socket currently being created.

DOMAIN_SET() is a macro that simplifies the registration of

a domain via
SYSINIT(). The code resulting from the macro expects there

to be a
domain structure named ``namedomain'' where name is the ar

gument to
DOMAIN_SET():

struct domain localdomain =
{ AF_LOCAL, "local", unp_init, unp_externalize, unp_dispose,

localsw, &localsw[sizeof(localsw)/sizeof(localsw[0])] };

DOMAIN_SET(local);

RETURN VALUES

Both pffindtype() and pffindproto() return a struct protosw

* for the
protocol requested. If the protocol or socket type is not

found, NULL is
returned. In the case of pffindproto(), the default proto

col may be
returned for SOCK_RAW types if the domain has a default raw

protocol.

SEE ALSO

socket(2)

AUTHORS

This manual page was written by Chad David <davidc@ac

ns.ab.ca>.

BSD December 7, 2001

BSD