4.4BSD snapshot (revision 8.1); add 1993 to copyright

[unix-history] / usr / src / sys / kern / uipc_domain.c

/*
* Copyright (c) 1982, 1986, 1993
*      The Regents of the University of California.  All rights reserved.
*
* %sccs.include.redist.c%
*
*      @(#)uipc_domain.c       8.1 (Berkeley) %G%
*/

#include <sys/param.h>
#include <sys/socket.h>
#include <sys/protosw.h>
#include <sys/domain.h>
#include <sys/mbuf.h>
#include <sys/time.h>
#include <sys/kernel.h>
#include <sys/proc.h>
#include <vm/vm.h>
#include <sys/sysctl.h>

#define ADDDOMAIN(x)    { \
       extern struct domain __CONCAT(x,domain); \
       __CONCAT(x,domain.dom_next) = domains; \
       domains = &__CONCAT(x,domain); \
}

domaininit()
{
       register struct domain *dp;
       register struct protosw *pr;

#undef unix
#ifndef lint
       ADDDOMAIN(unix);
       ADDDOMAIN(route);
#ifdef INET
       ADDDOMAIN(inet);
#endif
#ifdef NS
       ADDDOMAIN(ns);
#endif
#ifdef ISO
       ADDDOMAIN(iso);
#endif
#ifdef CCITT
       ADDDOMAIN(ccitt);
#endif
#include "imp.h"
#if NIMP > 0
       ADDDOMAIN(imp);
#endif
#endif

       for (dp = domains; dp; dp = dp->dom_next) {
               if (dp->dom_init)
                       (*dp->dom_init)();
               for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
                       if (pr->pr_init)
                               (*pr->pr_init)();
       }

if (max_linkhdr < 16)           /* XXX */
max_linkhdr = 16;
       max_hdr = max_linkhdr + max_protohdr;
       max_datalen = MHLEN - max_hdr;
       pffasttimo();
       pfslowtimo();
}

struct protosw *
pffindtype(family, type)
       int family, type;
{
       register struct domain *dp;
       register struct protosw *pr;

       for (dp = domains; dp; dp = dp->dom_next)
               if (dp->dom_family == family)
                       goto found;
       return (0);
found:
       for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
               if (pr->pr_type && pr->pr_type == type)
                       return (pr);
       return (0);
}

struct protosw *
pffindproto(family, protocol, type)
       int family, protocol, type;
{
       register struct domain *dp;
       register struct protosw *pr;
       struct protosw *maybe = 0;

       if (family == 0)
               return (0);
       for (dp = domains; dp; dp = dp->dom_next)
               if (dp->dom_family == family)
                       goto found;
       return (0);
found:
       for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++) {
               if ((pr->pr_protocol == protocol) && (pr->pr_type == type))
                       return (pr);

               if (type == SOCK_RAW && pr->pr_type == SOCK_RAW &&
                   pr->pr_protocol == 0 && maybe == (struct protosw *)0)
                       maybe = pr;
       }
       return (maybe);
}

net_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
       int *name;
       u_int namelen;
       void *oldp;
       size_t *oldlenp;
       void *newp;
       size_t newlen;
       struct proc *p;
{
       register struct domain *dp;
       register struct protosw *pr;
       int family, protocol;

       /*
        * All sysctl names at this level are nonterminal;
        * next two components are protocol family and protocol number,
        * then at least one addition component.
        */
       if (namelen < 3)
               return (EISDIR);                /* overloaded */
       family = name[0];
       protocol = name[1];

       if (family == 0)
               return (0);
       for (dp = domains; dp; dp = dp->dom_next)
               if (dp->dom_family == family)
                       goto found;
       return (ENOPROTOOPT);
found:
       for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
               if (pr->pr_protocol == protocol && pr->pr_sysctl)
                       return ((*pr->pr_sysctl)(name + 2, namelen - 2,
                           oldp, oldlenp, newp, newlen));
       return (ENOPROTOOPT);
}

pfctlinput(cmd, sa)
       int cmd;
       struct sockaddr *sa;
{
       register struct domain *dp;
       register struct protosw *pr;

       for (dp = domains; dp; dp = dp->dom_next)
               for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
                       if (pr->pr_ctlinput)
                               (*pr->pr_ctlinput)(cmd, sa, (caddr_t) 0);
}

pfslowtimo()
{
       register struct domain *dp;
       register struct protosw *pr;

       for (dp = domains; dp; dp = dp->dom_next)
               for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
                       if (pr->pr_slowtimo)
                               (*pr->pr_slowtimo)();
       timeout(pfslowtimo, (caddr_t)0, hz/2);
}

pffasttimo()
{
       register struct domain *dp;
       register struct protosw *pr;

       for (dp = domains; dp; dp = dp->dom_next)
               for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
                       if (pr->pr_fasttimo)
                               (*pr->pr_fasttimo)();
       timeout(pffasttimo, (caddr_t)0, hz/5);
}