Clean up routing code before I parallelize it.
authorJeffrey Hsu <hsu@dragonflybsd.org>
Tue, 14 Dec 2004 18:46:58 +0000 (18:46 +0000)
committerJeffrey Hsu <hsu@dragonflybsd.org>
Tue, 14 Dec 2004 18:46:58 +0000 (18:46 +0000)
16 files changed:
sys/kern/vfs_subr.c
sys/net/if_ethersubr.c
sys/net/if_fddisubr.c
sys/net/pf/pf_table.c
sys/net/radix.c
sys/net/radix.h
sys/net/route.c
sys/net/route.h
sys/net/rtsock.c
sys/netinet/if_ether.c
sys/netinet/in_rmx.c
sys/netinet6/in6_rmx.c
sys/netinet6/nd6.c
sys/netinet6/nd6_rtr.c
sys/netproto/atalk/at_rmx.c
sys/sys/domain.h

index 25c1a16..573df3b 100644 (file)
@@ -37,7 +37,7 @@
  *
  *     @(#)vfs_subr.c  8.31 (Berkeley) 5/26/95
  * $FreeBSD: src/sys/kern/vfs_subr.c,v 1.249.2.30 2003/04/04 20:35:57 tegge Exp $
- * $DragonFly: src/sys/kern/vfs_subr.c,v 1.48 2004/11/18 20:04:24 dillon Exp $
+ * $DragonFly: src/sys/kern/vfs_subr.c,v 1.49 2004/12/14 18:46:08 hsu Exp $
  */
 
 /*
@@ -1397,7 +1397,7 @@ vfs_hang_addrlist(struct mount *mp, struct netexport *nep,
                        goto out;
                }
        }
-       rn = (*rnh->rnh_addaddr) ((caddr_t) saddr, (caddr_t) smask, rnh,
+       rn = (*rnh->rnh_addaddr) ((char *) saddr, (char *) smask, rnh,
            np->netc_rnodes);
        if (rn == 0 || np != (struct netcred *) rn) {   /* already exists */
                error = EPERM;
@@ -1564,7 +1564,7 @@ vfs_export_lookup(struct mount *mp, struct netexport *nep,
                        rnh = nep->ne_rtable[saddr->sa_family];
                        if (rnh != NULL) {
                                np = (struct netcred *)
-                                       (*rnh->rnh_matchaddr)((caddr_t)saddr,
+                                       (*rnh->rnh_matchaddr)((char *)saddr,
                                                              rnh);
                                if (np && np->netc_rnodes->rn_flags & RNF_ROOT)
                                        np = NULL;
index 24ed837..9e20768 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)if_ethersubr.c      8.1 (Berkeley) 6/10/93
  * $FreeBSD: src/sys/net/if_ethersubr.c,v 1.70.2.33 2003/04/28 15:45:53 archie Exp $
- * $DragonFly: src/sys/net/if_ethersubr.c,v 1.19 2004/11/08 10:28:48 joerg Exp $
+ * $DragonFly: src/sys/net/if_ethersubr.c,v 1.20 2004/12/14 18:46:08 hsu Exp $
  */
 
 #include "opt_atalk.h"
@@ -784,14 +784,14 @@ post_stats:
                if (l->llc_dsap == LLC_SNAP_LSAP &&
                    l->llc_ssap == LLC_SNAP_LSAP &&
                    l->llc_control == LLC_UI) {
-                        if (Bcmp(&(l->llc_snap_org_code)[0], at_org_code,
+                        if (bcmp(&(l->llc_snap_org_code)[0], at_org_code,
                            sizeof(at_org_code)) == 0 &&
                            ntohs(l->llc_snap_ether_type) == ETHERTYPE_AT) {
                                m_adj(m, sizeof(struct llc));
                                isr = NETISR_ATALK2;
                                break;
                        }
-                       if (Bcmp(&(l->llc_snap_org_code)[0], aarp_org_code,
+                       if (bcmp(&(l->llc_snap_org_code)[0], aarp_org_code,
                            sizeof(aarp_org_code)) == 0 &&
                            ntohs(l->llc_snap_ether_type) == ETHERTYPE_AARP) {
                                m_adj(m, sizeof(struct llc));
index 8682db9..0959446 100644 (file)
@@ -34,7 +34,7 @@
  *
  *     from: if_ethersubr.c,v 1.5 1994/12/13 22:31:45 wollman Exp
  * $FreeBSD: src/sys/net/if_fddisubr.c,v 1.41.2.8 2002/02/20 23:34:09 fjoe Exp $
- * $DragonFly: src/sys/net/Attic/if_fddisubr.c,v 1.11 2004/07/23 07:16:30 joerg Exp $
+ * $DragonFly: src/sys/net/Attic/if_fddisubr.c,v 1.12 2004/12/14 18:46:08 hsu Exp $
  */
 
 #include "opt_atalk.h"
@@ -437,7 +437,7 @@ fddi_input(struct ifnet *ifp, struct mbuf *m)
                if (l->llc_control != LLC_UI || l->llc_ssap != LLC_SNAP_LSAP)
                        goto dropanyway;
 #ifdef NETATALK
-               if (Bcmp(&(l->llc_snap_org_code)[0], at_org_code,
+               if (bcmp(&(l->llc_snap_org_code)[0], at_org_code,
                         sizeof(at_org_code)) == 0 &&
                    sizeof(at_org_code) == 0 &&
                    ntohs(l->llc_snap_ether_type) == ETHERTYPE_AT) {
@@ -446,15 +446,17 @@ fddi_input(struct ifnet *ifp, struct mbuf *m)
                        break;
                }
 
-               if (Bcmp(&(l->llc_snap_org_code)[0], aarp_org_code,
+               if (bcmp(&(l->llc_snap_org_code)[0], aarp_org_code,
                         sizeof(aarp_org_code)) == 0 &&
                        ntohs(l->llc_snap_ether_type) == ETHERTYPE_AARP) {
                    m_adj( m, sizeof( struct llc ));
                    isr = NETISR_AARP;
                    break;
                }
-#endif /* NETATALK */
-               if (l->llc_snap.org_code[0] != 0 || l->llc_snap.org_code[1] != 0|| l->llc_snap.org_code[2] != 0)
+#endif
+               if (l->llc_snap.org_code[0] != 0 ||
+                   l->llc_snap.org_code[1] != 0 ||
+                   l->llc_snap.org_code[2] != 0)
                        goto dropanyway;
                type = ntohs(l->llc_snap.ether_type);
                m_adj(m, 8);
index 468e6e5..7503ff8 100644 (file)
@@ -1,6 +1,6 @@
 /*     $FreeBSD: src/sys/contrib/pf/net/pf_table.c,v 1.5 2004/07/28 06:14:44 kan Exp $ */
 /*     $OpenBSD: pf_table.c,v 1.47 2004/03/09 21:44:41 mcbride Exp $   */
-/*     $DragonFly: src/sys/net/pf/pf_table.c,v 1.1 2004/09/19 22:32:47 joerg Exp $ */
+/*     $DragonFly: src/sys/net/pf/pf_table.c,v 1.2 2004/12/14 18:46:08 hsu Exp $ */
 
 /*
  * Copyright (c) 2004 The DragonFly Project.  All rights reserved.
@@ -746,12 +746,13 @@ pfr_lookup_addr(struct pfr_ktable *kt, struct pfr_addr *ad, int exact)
        if (ADDR_NETWORK(ad)) {
                pfr_prepare_network(&mask, ad->pfra_af, ad->pfra_net);
                s = splsoftnet(); /* rn_lookup makes use of globals */
-               ke = (struct pfr_kentry *)rn_lookup(&sa, &mask, head);
+               ke = (struct pfr_kentry *)rn_lookup((char *)&sa, (char *)&mask,
+                   head);
                splx(s);
                if (ke && KENTRY_RNF_ROOT(ke))
                        ke = NULL;
        } else {
-               ke = (struct pfr_kentry *)rn_match(&sa, head);
+               ke = (struct pfr_kentry *)rn_match((char *)&sa, head);
                if (ke && KENTRY_RNF_ROOT(ke))
                        ke = NULL;
                if (exact && ke && KENTRY_NETWORK(ke))
@@ -916,9 +917,11 @@ pfr_route_kentry(struct pfr_ktable *kt, struct pfr_kentry *ke)
        s = splsoftnet();
        if (KENTRY_NETWORK(ke)) {
                pfr_prepare_network(&mask, ke->pfrke_af, ke->pfrke_net);
-               rn = rn_addroute(&ke->pfrke_sa, &mask, head, ke->pfrke_node);
+               rn = rn_addroute((char *)&ke->pfrke_sa, (char *)&mask, head,
+                   ke->pfrke_node);
        } else
-               rn = rn_addroute(&ke->pfrke_sa, NULL, head, ke->pfrke_node);
+               rn = rn_addroute((char *)&ke->pfrke_sa, NULL, head,
+                   ke->pfrke_node);
        splx(s);
 
        return (rn == NULL ? -1 : 0);
@@ -940,9 +943,9 @@ pfr_unroute_kentry(struct pfr_ktable *kt, struct pfr_kentry *ke)
        s = splsoftnet();
        if (KENTRY_NETWORK(ke)) {
                pfr_prepare_network(&mask, ke->pfrke_af, ke->pfrke_net);
-               rn = rn_delete(&ke->pfrke_sa, &mask, head);
+               rn = rn_delete((char *)&ke->pfrke_sa, (char *)&mask, head);
        } else
-               rn = rn_delete(&ke->pfrke_sa, NULL, head);
+               rn = rn_delete((char *)&ke->pfrke_sa, NULL, head);
        splx(s);
 
        if (rn == NULL) {
@@ -1889,13 +1892,15 @@ pfr_match_addr(struct pfr_ktable *kt, struct pf_addr *a, sa_family_t af)
        switch (af) {
        case AF_INET:
                pfr_sin.sin_addr.s_addr = a->addr32[0];
-               ke = (struct pfr_kentry *)rn_match(&pfr_sin, kt->pfrkt_ip4);
+               ke = (struct pfr_kentry *)rn_match((char *)&pfr_sin,
+                   kt->pfrkt_ip4);
                if (ke && KENTRY_RNF_ROOT(ke))
                        ke = NULL;
                break;
        case AF_INET6:
                bcopy(a, &pfr_sin6.sin6_addr, sizeof(pfr_sin6.sin6_addr));
-               ke = (struct pfr_kentry *)rn_match(&pfr_sin6, kt->pfrkt_ip6);
+               ke = (struct pfr_kentry *)rn_match((char *)&pfr_sin6,
+                   kt->pfrkt_ip6);
                if (ke && KENTRY_RNF_ROOT(ke))
                        ke = NULL;
                break;
@@ -1922,13 +1927,15 @@ pfr_update_stats(struct pfr_ktable *kt, struct pf_addr *a, sa_family_t af,
        switch (af) {
        case AF_INET:
                pfr_sin.sin_addr.s_addr = a->addr32[0];
-               ke = (struct pfr_kentry *)rn_match(&pfr_sin, kt->pfrkt_ip4);
+               ke = (struct pfr_kentry *)rn_match((char *)&pfr_sin,
+                   kt->pfrkt_ip4);
                if (ke && KENTRY_RNF_ROOT(ke))
                        ke = NULL;
                break;
        case AF_INET6:
                bcopy(a, &pfr_sin6.sin6_addr, sizeof(pfr_sin6.sin6_addr));
-               ke = (struct pfr_kentry *)rn_match(&pfr_sin6, kt->pfrkt_ip6);
+               ke = (struct pfr_kentry *)rn_match((char *)&pfr_sin6,
+                   kt->pfrkt_ip6);
                if (ke && KENTRY_RNF_ROOT(ke))
                        ke = NULL;
                break;
@@ -2049,8 +2056,8 @@ _next_block:
        for (;;) {
                /* we don't want to use a nested block */
                ke2 = (struct pfr_kentry *)(af == AF_INET ?
-                   rn_match(&pfr_sin, kt->pfrkt_ip4) :
-                   rn_match(&pfr_sin6, kt->pfrkt_ip6));
+                   rn_match((char *)&pfr_sin, kt->pfrkt_ip4) :
+                   rn_match((char *)&pfr_sin6, kt->pfrkt_ip6));
                /* no need to check KENTRY_RNF_ROOT() here */
                if (ke2 == ke) {
                        /* lookup return the same block - perfect */
index 10580aa..7f58883 100644 (file)
  *
  *     @(#)radix.c     8.4 (Berkeley) 11/2/94
  * $FreeBSD: src/sys/net/radix.c,v 1.20.2.3 2002/04/28 05:40:25 suz Exp $
- * $DragonFly: src/sys/net/radix.c,v 1.5 2003/08/26 20:49:47 rob Exp $
+ * $DragonFly: src/sys/net/radix.c,v 1.6 2004/12/14 18:46:08 hsu Exp $
  */
 
 /*
  * Routines to build and maintain radix trees for routing lookups.
  */
-#ifndef _RADIX_H_
 #include <sys/param.h>
 #ifdef _KERNEL
 #include <sys/systm.h>
 #endif
 #include <sys/syslog.h>
 #include <net/radix.h>
-#endif
 
-static int     rn_walktree_from (struct radix_node_head *h, void *a,
-                                     void *m, walktree_f_t *f, void *w);
-static int rn_walktree (struct radix_node_head *, walktree_f_t *, void *);
+/*
+ * The arguments to the radix functions are really counted byte arrays with
+ * the length in the first byte.  struct sockaddr's fit this type structurally.
+ */
+#define clen(c)        (*(u_char *)(c))
+
+static int rn_walktree_from(struct radix_node_head *h, u_char *a, u_char *m,
+                           walktree_f_t *f, void *w);
+static int rn_walktree(struct radix_node_head *, walktree_f_t *, void *);
+
 static struct radix_node
-        *rn_insert (void *, struct radix_node_head *, int *,
-                       struct radix_node [2]),
-        *rn_newpair (void *, int, struct radix_node[2]),
-        *rn_search (void *, struct radix_node *),
-        *rn_search_m (void *, struct radix_node *, void *);
+    *rn_insert(char *, struct radix_node_head *, boolean_t *,
+              struct radix_node [2]),
+    *rn_newpair(char *, int, struct radix_node[2]),
+    *rn_search(const char *, struct radix_node *),
+    *rn_search_m(const char *, struct radix_node *, const char *);
 
-static int     max_keylen;
+static int max_keylen;
 static struct radix_mask *rn_mkfreelist;
 static struct radix_node_head *mask_rnhead;
 static char *addmask_key;
@@ -69,16 +74,33 @@ static char normal_chars[] = {0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, -1};
 static char *rn_zeros, *rn_ones;
 
 #define rn_masktop (mask_rnhead->rnh_treetop)
-#undef Bcmp
-#define Bcmp(a, b, l) \
-       (l == 0 ? 0 : bcmp((caddr_t)(a), (caddr_t)(b), (u_long)l))
 
-static int     rn_lexobetter (void *m_arg, void *n_arg);
+static int rn_lexobetter(char *m, char *n);
 static struct radix_mask *
-               rn_new_radix_mask (struct radix_node *tt,
-                                      struct radix_mask *next);
-static int     rn_satsifies_leaf (char *trial, struct radix_node *leaf,
-                                      int skip);
+    rn_new_radix_mask(struct radix_node *tt, struct radix_mask *nextmask);
+static int
+    rn_satisfies_leaf(char *trial, struct radix_node *leaf, int skip);
+
+static __inline struct radix_mask *
+MKGet(struct radix_mask **l)
+{
+       struct radix_mask *m;
+
+       if (*l != NULL) {
+               m = *l;
+               *l = m->rm_next;
+       } else {
+               R_Malloc(m, struct radix_mask *, sizeof (*(m)));
+       }
+       return m;
+}
+
+static __inline void
+MKFree(struct radix_mask **l, struct radix_mask *m)
+{
+       m->rm_next = *l;
+       *l = m;
+}
 
 /*
  * The data structure for the keys is a radix tree with one way
@@ -115,14 +137,12 @@ static int        rn_satsifies_leaf (char *trial, struct radix_node *leaf,
  */
 
 static struct radix_node *
-rn_search(v_arg, head)
-       void *v_arg;
-       struct radix_node *head;
+rn_search(const char *v, struct radix_node *head)
 {
        struct radix_node *x;
-       caddr_t v;
 
-       for (x = head, v = v_arg; x->rn_bit >= 0;) {
+       x = head;
+       while (x->rn_bit >= 0) {
                if (x->rn_bmask & v[x->rn_offset])
                        x = x->rn_right;
                else
@@ -132,12 +152,9 @@ rn_search(v_arg, head)
 }
 
 static struct radix_node *
-rn_search_m(v_arg, head, m_arg)
-       struct radix_node *head;
-       void *v_arg, *m_arg;
+rn_search_m(const char *v, struct radix_node *head, const char *m)
 {
        struct radix_node *x;
-       caddr_t v = v_arg, m = m_arg;
 
        for (x = head; x->rn_bit >= 0;) {
                if ((x->rn_bmask & m[x->rn_offset]) &&
@@ -149,22 +166,21 @@ rn_search_m(v_arg, head, m_arg)
        return x;
 }
 
-int
-rn_refines(m_arg, n_arg)
-       void *m_arg, *n_arg;
+boolean_t
+rn_refines(char *m, char *n)
 {
-       caddr_t m = m_arg, n = n_arg;
-       caddr_t lim, lim2 = lim = n + *(u_char *)n;
-       int longer = (*(u_char *)n++) - (int)(*(u_char *)m++);
-       int masks_are_equal = 1;
+       char *lim, *lim2;
+       int longer = clen(n++) - clen(m++);
+       boolean_t masks_are_equal = TRUE;
 
+       lim2 = lim = n + clen(n);
        if (longer > 0)
                lim -= longer;
        while (n < lim) {
                if (*n & ~(*m))
                        return 0;
                if (*n++ != *m++)
-                       masks_are_equal = 0;
+                       masks_are_equal = FALSE;
        }
        while (n < lim2)
                if (*n++)
@@ -177,42 +193,39 @@ rn_refines(m_arg, n_arg)
 }
 
 struct radix_node *
-rn_lookup(v_arg, m_arg, head)
-       void *v_arg, *m_arg;
-       struct radix_node_head *head;
+rn_lookup(char *key, char *mask, struct radix_node_head *head)
 {
        struct radix_node *x;
-       caddr_t netmask = 0;
+       char *netmask = NULL;
 
-       if (m_arg) {
-               x = rn_addmask(m_arg, 1, head->rnh_treetop->rn_offset);
-               if (x == 0)
-                       return (0);
+       if (mask != NULL) {
+               x = rn_addmask(mask, TRUE, head->rnh_treetop->rn_offset);
+               if (x == NULL)
+                       return (NULL);
                netmask = x->rn_key;
        }
-       x = rn_match(v_arg, head);
-       if (x && netmask) {
-               while (x && x->rn_mask != netmask)
+       x = rn_match(key, head);
+       if (x != NULL && netmask != NULL) {
+               while (x != NULL && x->rn_mask != netmask)
                        x = x->rn_dupedkey;
        }
        return x;
 }
 
 static int
-rn_satsifies_leaf(trial, leaf, skip)
-       char *trial;
-       struct radix_node *leaf;
-       int skip;
+rn_satisfies_leaf(char *trial, struct radix_node *leaf, int skip)
 {
        char *cp = trial, *cp2 = leaf->rn_key, *cp3 = leaf->rn_mask;
        char *cplim;
-       int length = min(*(u_char *)cp, *(u_char *)cp2);
+       int length = min(clen(cp), clen(cp2));
 
-       if (cp3 == 0)
+       if (cp3 == NULL)
                cp3 = rn_ones;
        else
-               length = min(length, *(u_char *)cp3);
-       cplim = cp + length; cp3 += skip; cp2 += skip;
+               length = min(length, clen(cp3));
+       cplim = cp + length;
+       cp3 += skip;
+       cp2 += skip;
        for (cp += skip; cp < cplim; cp++, cp2++, cp3++)
                if ((*cp ^ *cp2) & *cp3)
                        return 0;
@@ -220,28 +233,16 @@ rn_satsifies_leaf(trial, leaf, skip)
 }
 
 struct radix_node *
-rn_match(v_arg, head)
-       void *v_arg;
-       struct radix_node_head *head;
+rn_match(char *key, struct radix_node_head *head)
 {
-       caddr_t v = v_arg;
-       struct radix_node *t = head->rnh_treetop, *x;
-       caddr_t cp = v, cp2;
-       caddr_t cplim;
-       struct radix_node *saved_t, *top = t;
-       int off = t->rn_offset, vlen = *(u_char *)cp, matched_off;
+       struct radix_node *t, *x;
+       char *cp = key, *cp2;
+       char *cplim;
+       struct radix_node *saved_t, *top = head->rnh_treetop;
+       int off = top->rn_offset, klen, matched_off;
        int test, b, rn_bit;
 
-       /*
-        * Open code rn_search(v, top) to avoid overhead of extra
-        * subroutine call.
-        */
-       for (; t->rn_bit >= 0; ) {
-               if (t->rn_bmask & cp[t->rn_offset])
-                       t = t->rn_right;
-               else
-                       t = t->rn_left;
-       }
+       t = rn_search(key, top);
        /*
         * See if we match exactly as a host destination
         * or at least learn how many bits match, for normal mask finesse.
@@ -253,9 +254,11 @@ rn_match(v_arg, head)
         * with a long one.  This wins big for class B&C netmasks which
         * are probably the most common case...
         */
-       if (t->rn_mask)
-               vlen = *(u_char *)t->rn_mask;
-       cp += off; cp2 = t->rn_key + off; cplim = v + vlen;
+       if (t->rn_mask != NULL)
+               klen = clen(t->rn_mask);
+       else
+               klen = clen(key);
+       cp += off; cp2 = t->rn_key + off; cplim = key + klen;
        for (; cp < cplim; cp++, cp2++)
                if (*cp != *cp2)
                        goto on1;
@@ -273,15 +276,15 @@ on1:
        test = (*cp ^ *cp2) & 0xff; /* find first bit that differs */
        for (b = 7; (test >>= 1) > 0;)
                b--;
-       matched_off = cp - v;
+       matched_off = cp - key;
        b += matched_off << 3;
        rn_bit = -1 - b;
        /*
         * If there is a host route in a duped-key chain, it will be first.
         */
-       if ((saved_t = t)->rn_mask == 0)
+       if ((saved_t = t)->rn_mask == NULL)
                t = t->rn_dupedkey;
-       for (; t; t = t->rn_dupedkey)
+       for (; t; t = t->rn_dupedkey) {
                /*
                 * Even if we don't match exactly as a host,
                 * we may match if the leaf we wound up at is
@@ -290,36 +293,38 @@ on1:
                if (t->rn_flags & RNF_NORMAL) {
                        if (rn_bit <= t->rn_bit)
                                return t;
-               } else if (rn_satsifies_leaf(v, t, matched_off))
+               } else if (rn_satisfies_leaf(key, t, matched_off))
                                return t;
+       }
        t = saved_t;
        /* start searching up the tree */
        do {
                struct radix_mask *m;
+
                t = t->rn_parent;
-               m = t->rn_mklist;
                /*
                 * If non-contiguous masks ever become important
                 * we can restore the masking and open coding of
                 * the search and satisfaction test and put the
                 * calculation of "off" back before the "do".
                 */
-               while (m) {
+               m = t->rn_mklist;
+               while (m != NULL) {
                        if (m->rm_flags & RNF_NORMAL) {
                                if (rn_bit <= m->rm_bit)
                                        return (m->rm_leaf);
                        } else {
                                off = min(t->rn_offset, matched_off);
-                               x = rn_search_m(v, t, m->rm_mask);
-                               while (x && x->rn_mask != m->rm_mask)
+                               x = rn_search_m(key, t, m->rm_mask);
+                               while (x != NULL && x->rn_mask != m->rm_mask)
                                        x = x->rn_dupedkey;
-                               if (x && rn_satsifies_leaf(v, x, off))
+                               if (x && rn_satisfies_leaf(key, x, off))
                                        return x;
                        }
-                       m = m->rm_mklist;
+                       m = m->rm_next;
                }
        } while (t != top);
-       return 0;
+       return NULL;
 }
 
 #ifdef RN_DEBUG
@@ -330,66 +335,68 @@ int       rn_debug =  1;
 #endif
 
 static struct radix_node *
-rn_newpair(v, b, nodes)
-       void *v;
-       int b;
-       struct radix_node nodes[2];
+rn_newpair(char *key, int indexbit, struct radix_node nodes[2])
 {
-       struct radix_node *tt = nodes, *t = tt + 1;
-       t->rn_bit = b;
-       t->rn_bmask = 0x80 >> (b & 7);
-       t->rn_left = tt;
-       t->rn_offset = b >> 3;
-       tt->rn_bit = -1;
-       tt->rn_key = (caddr_t)v;
-       tt->rn_parent = t;
-       tt->rn_flags = t->rn_flags = RNF_ACTIVE;
-       tt->rn_mklist = t->rn_mklist = 0;
+       struct radix_node *leaf = nodes, *interior = leaf + 1;
+
+       interior->rn_bit = indexbit;
+       interior->rn_bmask = 0x80 >> (indexbit & 0x7);
+       interior->rn_offset = indexbit >> 3;
+       interior->rn_left = leaf;
+       interior->rn_mklist = NULL;
+
+       leaf->rn_bit = -1;
+       leaf->rn_key = key;
+       leaf->rn_parent = interior;
+       leaf->rn_flags = interior->rn_flags = RNF_ACTIVE;
+       leaf->rn_mklist = NULL;
+
 #ifdef RN_DEBUG
-       tt->rn_info = rn_nodenum++; t->rn_info = rn_nodenum++;
-       tt->rn_twin = t;
-       tt->rn_ybro = rn_clist;
-       rn_clist = tt;
+       leaf->rn_info = rn_nodenum++;
+       interior->rn_info = rn_nodenum++;
+       leaf->rn_twin = interior;
+       leaf->rn_ybro = rn_clist;
+       rn_clist = leaf;
 #endif
-       return t;
+       return interior;
 }
 
 static struct radix_node *
-rn_insert(v_arg, head, dupentry, nodes)
-       void *v_arg;
-       struct radix_node_head *head;
-       int *dupentry;
-       struct radix_node nodes[2];
+rn_insert(
+       char *key,
+       struct radix_node_head *head,
+       boolean_t *dupentry,
+       struct radix_node nodes[2])
 {
-       caddr_t v = v_arg;
        struct radix_node *top = head->rnh_treetop;
-       int head_off = top->rn_offset, vlen = (int)*((u_char *)v);
-       struct radix_node *t = rn_search(v_arg, top);
-       caddr_t cp = v + head_off;
+       int head_off = top->rn_offset, klen = clen(key);
+       struct radix_node *t = rn_search(key, top);
+       char *cp = key + head_off;
        int b;
        struct radix_node *tt;
        /*
-        * Find first bit at which v and t->rn_key differ
+        * Find first bit at which the key and t->rn_key differ
         */
     {
-       caddr_t cp2 = t->rn_key + head_off;
+       char *cp2 = t->rn_key + head_off;
        int cmp_res;
-       caddr_t cplim = v + vlen;
+       char *cplim = key + klen;
 
        while (cp < cplim)
                if (*cp2++ != *cp++)
                        goto on1;
-       *dupentry = 1;
+       *dupentry = TRUE;
        return t;
 on1:
-       *dupentry = 0;
+       *dupentry = FALSE;
        cmp_res = (cp[-1] ^ cp2[-1]) & 0xff;
-       for (b = (cp - v) << 3; cmp_res; b--)
+       for (b = (cp - key) << 3; cmp_res; b--)
                cmp_res >>= 1;
     }
     {
        struct radix_node *p, *x = top;
-       cp = v;
+
+       cp = key;
        do {
                p = x;
                if (cp[x->rn_offset] & x->rn_bmask)
@@ -402,7 +409,7 @@ on1:
        if (rn_debug)
                log(LOG_DEBUG, "rn_insert: Going In:\n"), traverse(p);
 #endif
-       t = rn_newpair(v_arg, b, nodes); 
+       t = rn_newpair(key, b, nodes);
        tt = t->rn_left;
        if ((cp[p->rn_offset] & p->rn_bmask) == 0)
                p->rn_left = t;
@@ -425,28 +432,25 @@ on1:
 }
 
 struct radix_node *
-rn_addmask(n_arg, search, skip)
-       int search, skip;
-       void *n_arg;
+rn_addmask(char *netmask, boolean_t search, int skip)
 {
-       caddr_t netmask = (caddr_t)n_arg;
-       struct radix_node *x;
-       caddr_t cp, cplim;
+       struct radix_node *x, *saved_x;
+       char *cp, *cplim;
        int b = 0, mlen, j;
-       int maskduplicated, m0, isnormal;
-       struct radix_node *saved_x;
+       boolean_t maskduplicated;
+       int m0, isnormal;
        static int last_zeroed = 0;
 
-       if ((mlen = *(u_char *)netmask) > max_keylen)
+       if ((mlen = clen(netmask)) > max_keylen)
                mlen = max_keylen;
        if (skip == 0)
                skip = 1;
        if (mlen <= skip)
                return (mask_rnhead->rnh_nodes);
        if (skip > 1)
-               Bcopy(rn_ones + 1, addmask_key + 1, skip - 1);
+               bcopy(rn_ones + 1, addmask_key + 1, skip - 1);
        if ((m0 = mlen) > skip)
-               Bcopy(netmask + skip, addmask_key + skip, mlen - skip);
+               bcopy(netmask + skip, addmask_key + skip, mlen - skip);
        /*
         * Trim trailing zeroes.
         */
@@ -459,19 +463,19 @@ rn_addmask(n_arg, search, skip)
                return (mask_rnhead->rnh_nodes);
        }
        if (m0 < last_zeroed)
-               Bzero(addmask_key + m0, last_zeroed - m0);
+               bzero(addmask_key + m0, last_zeroed - m0);
        *addmask_key = last_zeroed = mlen;
        x = rn_search(addmask_key, rn_masktop);
-       if (Bcmp(addmask_key, x->rn_key, mlen) != 0)
-               x = 0;
-       if (x || search)
+       if (bcmp(addmask_key, x->rn_key, mlen) != 0)
+               x = NULL;
+       if (x != NULL || search)
                return (x);
        R_Malloc(x, struct radix_node *, max_keylen + 2 * sizeof (*x));
-       if ((saved_x = x) == 0)
-               return (0);
-       Bzero(x, max_keylen + 2 * sizeof (*x));
-       netmask = cp = (caddr_t)(x + 2);
-       Bcopy(addmask_key, cp, mlen);
+       if ((saved_x = x) == NULL)
+               return (NULL);
+       bzero(x, max_keylen + 2 * sizeof (*x));
+       netmask = cp = (char *)(x + 2);
+       bcopy(addmask_key, cp, mlen);
        x = rn_insert(cp, mask_rnhead, &maskduplicated, x);
        if (maskduplicated) {
                log(LOG_ERR, "rn_addmask: mask impossibly already in tree");
@@ -482,7 +486,7 @@ rn_addmask(n_arg, search, skip)
         * Calculate index of mask, and check for normalcy.
         */
        cplim = netmask + mlen; isnormal = 1;
-       for (cp = netmask + skip; (cp < cplim) && *(u_char *)cp == 0xff;)
+       for (cp = netmask + skip; cp < cplim && clen(cp) == 0xff;)
                cp++;
        if (cp != cplim) {
                for (j = 0x80; (j & *cp) != 0; j >>= 1)
@@ -497,57 +501,51 @@ rn_addmask(n_arg, search, skip)
        return (x);
 }
 
-static int     /* XXX: arbitrary ordering for non-contiguous masks */
-rn_lexobetter(m_arg, n_arg)
-       void *m_arg, *n_arg;
+static boolean_t       /* XXX: arbitrary ordering for non-contiguous masks */
+rn_lexobetter(char *mp, char *np)
 {
-       u_char *mp = m_arg, *np = n_arg, *lim;
+       char *lim;
 
-       if (*mp > *np)
-               return 1;  /* not really, but need to check longer one first */
+       if ((unsigned) *mp > (unsigned) *np)
+               return TRUE;/* not really, but need to check longer one first */
        if (*mp == *np)
-               for (lim = mp + *mp; mp < lim;)
+               for (lim = mp + clen(mp); mp < lim;)
                        if (*mp++ > *np++)
-                               return 1;
-       return 0;
+                               return TRUE;
+       return FALSE;
 }
 
 static struct radix_mask *
-rn_new_radix_mask(tt, next)
-       struct radix_node *tt;
-       struct radix_mask *next;
+rn_new_radix_mask(struct radix_node *tt, struct radix_mask *nextmask)
 {
        struct radix_mask *m;
 
-       MKGet(m);
-       if (m == 0) {
+       m = MKGet(&rn_mkfreelist);
+       if (m == NULL) {
                log(LOG_ERR, "Mask for route not entered\n");
-               return (0);
+               return (NULL);
        }
-       Bzero(m, sizeof *m);
+       bzero(m, sizeof *m);
        m->rm_bit = tt->rn_bit;
        m->rm_flags = tt->rn_flags;
        if (tt->rn_flags & RNF_NORMAL)
                m->rm_leaf = tt;
        else
                m->rm_mask = tt->rn_mask;
-       m->rm_mklist = next;
+       m->rm_next = nextmask;
        tt->rn_mklist = m;
        return m;
 }
 
 struct radix_node *
-rn_addroute(v_arg, n_arg, head, treenodes)
-       void *v_arg, *n_arg;
-       struct radix_node_head *head;
-       struct radix_node treenodes[2];
+rn_addroute(char *key, char *netmask, struct radix_node_head *head,
+           struct radix_node treenodes[2])
 {
-       caddr_t v = (caddr_t)v_arg, netmask = (caddr_t)n_arg;
-       struct radix_node *t, *x = 0, *tt;
+       struct radix_node *t, *x = NULL, *tt;
        struct radix_node *saved_tt, *top = head->rnh_treetop;
        short b = 0, b_leaf = 0;
-       int keyduplicated;
-       caddr_t mmask;
+       boolean_t keyduplicated;
+       char *mmask;
        struct radix_mask *m, **mp;
 
        /*
@@ -557,9 +555,9 @@ rn_addroute(v_arg, n_arg, head, treenodes)
         * the mask to speed avoiding duplicate references at
         * nodes and possibly save time in calculating indices.
         */
-       if (netmask)  {
-               if ((x = rn_addmask(netmask, 0, top->rn_offset)) == 0)
-                       return (0);
+       if (netmask != NULL)  {
+               if ((x = rn_addmask(netmask, FALSE, top->rn_offset)) == NULL)
+                       return (NULL);
                b_leaf = x->rn_bit;
                b = -1 - x->rn_bit;
                netmask = x->rn_key;
@@ -567,12 +565,12 @@ rn_addroute(v_arg, n_arg, head, treenodes)
        /*
         * Deal with duplicated keys: attach node to previous instance
         */
-       saved_tt = tt = rn_insert(v, head, &keyduplicated, treenodes);
+       saved_tt = tt = rn_insert(key, head, &keyduplicated, treenodes);
        if (keyduplicated) {
                for (t = tt; tt; t = tt, tt = tt->rn_dupedkey) {
                        if (tt->rn_mask == netmask)
-                               return (0);
-                       if (netmask == 0 ||
+                               return (NULL);
+                       if (netmask == NULL ||
                            (tt->rn_mask &&
                             ((b_leaf < tt->rn_bit) /* index(netmask) > node */
                              || rn_refines(netmask, tt->rn_mask)
@@ -605,21 +603,21 @@ rn_addroute(v_arg, n_arg, head, treenodes)
                        (tt = treenodes)->rn_dupedkey = t->rn_dupedkey;
                        t->rn_dupedkey = tt;
                        tt->rn_parent = t;                      /* parent */
-                       if (tt->rn_dupedkey)                    /* parent */
+                       if (tt->rn_dupedkey != NULL)            /* parent */
                                tt->rn_dupedkey->rn_parent = tt; /* parent */
                }
 #ifdef RN_DEBUG
                t=tt+1; tt->rn_info = rn_nodenum++; t->rn_info = rn_nodenum++;
                tt->rn_twin = t; tt->rn_ybro = rn_clist; rn_clist = tt;
 #endif
-               tt->rn_key = (caddr_t) v;
+               tt->rn_key = key;
                tt->rn_bit = -1;
                tt->rn_flags = RNF_ACTIVE;
        }
        /*
         * Put mask in tree.
         */
-       if (netmask) {
+       if (netmask != NULL) {
                tt->rn_mask = netmask;
                tt->rn_bit = x->rn_bit;
                tt->rn_flags |= x->rn_flags & RNF_NORMAL;
@@ -634,24 +632,30 @@ rn_addroute(v_arg, n_arg, head, treenodes)
                x = t->rn_right;
        /* Promote general routes from below */
        if (x->rn_bit < 0) {
-           for (mp = &t->rn_mklist; x; x = x->rn_dupedkey)
-               if (x->rn_mask && (x->rn_bit >= b_leaf) && x->rn_mklist == 0) {
-                       *mp = m = rn_new_radix_mask(x, 0);
-                       if (m)
-                               mp = &m->rm_mklist;
+               mp = &t->rn_mklist;
+               while (x != NULL) {
+                       if (x->rn_mask != NULL &&
+                           x->rn_bit >= b_leaf &&
+                           x->rn_mklist == NULL) {
+                               *mp = m = rn_new_radix_mask(x, NULL);
+                               if (m != NULL)
+                                       mp = &m->rm_next;
+                       }
+                       x = x->rn_dupedkey;
                }
-       } else if (x->rn_mklist) {
+       } else if (x->rn_mklist != NULL) {
                /*
                 * Skip over masks whose index is > that of new node
                 */
-               for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist)
+               for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_next)
                        if (m->rm_bit >= b_leaf)
                                break;
-               t->rn_mklist = m; *mp = 0;
+               t->rn_mklist = m;
+               *mp = NULL;
        }
 on2:
        /* Add new route to highest possible ancestor's list */
-       if ((netmask == 0) || (b > t->rn_bit ))
+       if ((netmask == NULL) || (b > t->rn_bit ))
                return tt; /* can't lift at all */
        b_leaf = tt->rn_bit;
        do {
@@ -664,7 +668,7 @@ on2:
         * Need same criteria as when sorting dupedkeys to avoid
         * double loop on deletion.
         */
-       for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist) {
+       for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_next) {
                if (m->rm_bit < b_leaf)
                        continue;
                if (m->rm_bit > b_leaf)
@@ -683,8 +687,7 @@ on2:
                        tt->rn_mklist = m;
                        return tt;
                }
-               if (rn_refines(netmask, mmask)
-                   || rn_lexobetter(netmask, mmask))
+               if (rn_refines(netmask, mmask) || rn_lexobetter(netmask, mmask))
                        break;
        }
        *mp = rn_new_radix_mask(tt, *mp);
@@ -692,44 +695,39 @@ on2:
 }
 
 struct radix_node *
-rn_delete(v_arg, netmask_arg, head)
-       void *v_arg, *netmask_arg;
-       struct radix_node_head *head;
+rn_delete(char *key, char *netmask, struct radix_node_head *head)
 {
        struct radix_node *t, *p, *x, *tt;
        struct radix_mask *m, *saved_m, **mp;
        struct radix_node *dupedkey, *saved_tt, *top;
-       caddr_t v, netmask;
-       int b, head_off, vlen;
+       int b, head_off, klen;
 
-       v = v_arg;
-       netmask = netmask_arg;
        x = head->rnh_treetop;
-       tt = rn_search(v, x);
+       tt = rn_search(key, x);
        head_off = x->rn_offset;
-       vlen =  *(u_char *)v;
+       klen =  clen(key);
        saved_tt = tt;
        top = x;
-       if (tt == 0 ||
-           Bcmp(v + head_off, tt->rn_key + head_off, vlen - head_off))
-               return (0);
+       if (tt == NULL ||
+           bcmp(key + head_off, tt->rn_key + head_off, klen - head_off))
+               return (NULL);
        /*
         * Delete our route from mask lists.
         */
-       if (netmask) {
-               if ((x = rn_addmask(netmask, 1, head_off)) == 0)
-                       return (0);
+       if (netmask != NULL) {
+               if ((x = rn_addmask(netmask, TRUE, head_off)) == NULL)
+                       return (NULL);
                netmask = x->rn_key;
                while (tt->rn_mask != netmask)
-                       if ((tt = tt->rn_dupedkey) == 0)
-                               return (0);
+                       if ((tt = tt->rn_dupedkey) == NULL)
+                               return (NULL);
        }
-       if (tt->rn_mask == 0 || (saved_m = m = tt->rn_mklist) == 0)
+       if (tt->rn_mask == NULL || (saved_m = m = tt->rn_mklist) == NULL)
                goto on1;
        if (tt->rn_flags & RNF_NORMAL) {
                if (m->rm_leaf != tt || m->rm_refs > 0) {
                        log(LOG_ERR, "rn_delete: inconsistent annotation\n");
-                       return 0;  /* dangling ref could cause disaster */
+                       return (NULL);  /* dangling ref could cause disaster */
                }
        } else {
                if (m->rm_mask != tt->rn_mask) {
@@ -747,23 +745,23 @@ rn_delete(v_arg, netmask_arg, head)
                x = t;
                t = t->rn_parent;
        } while (b <= t->rn_bit && x != top);
-       for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist)
+       for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_next)
                if (m == saved_m) {
-                       *mp = m->rm_mklist;
-                       MKFree(m);
+                       *mp = m->rm_next;
+                       MKFree(&rn_mkfreelist, m);
                        break;
                }
-       if (m == 0) {
+       if (m == NULL) {
                log(LOG_ERR, "rn_delete: couldn't find our annotation\n");
                if (tt->rn_flags & RNF_NORMAL)
-                       return (0); /* Dangling ref to us */
+                       return (NULL); /* Dangling ref to us */
        }
 on1:
        /*
         * Eliminate us from tree
         */
        if (tt->rn_flags & RNF_ROOT)
-               return (0);
+               return (NULL);
 #ifdef RN_DEBUG
        /* Get us out of the creation list */
        for (t = rn_clist; t && t->rn_ybro != tt; t = t->rn_ybro) {}
@@ -771,7 +769,7 @@ on1:
 #endif
        t = tt->rn_parent;
        dupedkey = saved_tt->rn_dupedkey;
-       if (dupedkey) {
+       if (dupedkey != NULL) {
                /*
                 * at this point, tt is the deletion target and saved_tt
                 * is the head of the dupekey chain
@@ -827,10 +825,10 @@ on1:
        /*
         * Demote routes attached to us.
         */
-       if (t->rn_mklist) {
+       if (t->rn_mklist != NULL) {
                if (x->rn_bit >= 0) {
                        for (mp = &x->rn_mklist; (m = *mp);)
-                               mp = &m->rm_mklist;
+                               mp = &m->rm_next;
                        *mp = t->rn_mklist;
                } else {
                        /* If there are any key,mask pairs in a sibling
@@ -838,10 +836,11 @@ on1:
                           in the same order attached to our mklist */
                        for (m = t->rn_mklist; m && x; x = x->rn_dupedkey)
                                if (m == x->rn_mklist) {
-                                       struct radix_mask *mm = m->rm_mklist;
-                                       x->rn_mklist = 0;
+                                       struct radix_mask *mm = m->rm_next;
+
+                                       x->rn_mklist = NULL;
                                        if (--(m->rm_refs) < 0)
-                                               MKFree(m);
+                                               MKFree(&rn_mkfreelist, m);
                                        m = mm;
                                }
                        if (m)
@@ -881,19 +880,13 @@ out:
  * exit.
  */
 static int
-rn_walktree_from(h, a, m, f, w)
-       struct radix_node_head *h;
-       void *a, *m;
-       walktree_f_t *f;
-       void *w;
+rn_walktree_from(struct radix_node_head *h, u_char *xa, u_char *xm,
+                walktree_f_t *f, void *w)
 {
-       int error;
        struct radix_node *base, *next;
-       u_char *xa = (u_char *)a;
-       u_char *xm = (u_char *)m;
-       struct radix_node *rn, *last = 0 /* shut up gcc */;
+       struct radix_node *rn, *last = NULL /* shut up gcc */;
        int stopping = 0;
-       int lastb;
+       int lastb, error;
 
        /*
         * rn_search_m is sort-of-open-coded here.
@@ -937,8 +930,8 @@ rn_walktree_from(h, a, m, f, w)
                /* printf("node %p (%d)\n", rn, rn->rn_bit); */
                base = rn;
                /* If at right child go back up, otherwise, go right */
-               while (rn->rn_parent->rn_right == rn
-                      && !(rn->rn_flags & RNF_ROOT)) {
+               while (rn->rn_parent->rn_right == rn &&
+                   !(rn->rn_flags & RNF_ROOT)) {
                        rn = rn->rn_parent;
 
                        /* if went up beyond last, stop */
@@ -953,11 +946,10 @@ rn_walktree_from(h, a, m, f, w)
                        rn = rn->rn_left;
                next = rn;
                /* Process leaves */
-               while ((rn = base) != 0) {
+               while ((rn = base) != NULL) {
                        base = rn->rn_dupedkey;
                        /* printf("leaf %p\n", rn); */
-                       if (!(rn->rn_flags & RNF_ROOT)
-                           && (error = (*f)(rn, w)))
+                       if (!(rn->rn_flags & RNF_ROOT) && (error = (*f)(rn, w)))
                                return (error);
                }
                rn = next;
@@ -972,14 +964,12 @@ rn_walktree_from(h, a, m, f, w)
 }
 
 static int
-rn_walktree(h, f, w)
-       struct radix_node_head *h;
-       walktree_f_t *f;
-       void *w;
+rn_walktree(struct radix_node_head *h, walktree_f_t *f, void *w)
 {
-       int error;
        struct radix_node *base, *next;
        struct radix_node *rn = h->rnh_treetop;
+       int error;
+
        /*
         * This gets complicated because we may delete the node
         * while applying the function f to it, so we need to calculate
@@ -991,8 +981,8 @@ rn_walktree(h, f, w)
        for (;;) {
                base = rn;
                /* If at right child go back up, otherwise, go right */
-               while (rn->rn_parent->rn_right == rn
-                      && (rn->rn_flags & RNF_ROOT) == 0)
+               while (rn->rn_parent->rn_right == rn &&
+                   !(rn->rn_flags & RNF_ROOT))
                        rn = rn->rn_parent;
                /* Find the next *leaf* since next node might vanish, too */
                for (rn = rn->rn_parent->rn_right; rn->rn_bit >= 0;)
@@ -1001,8 +991,7 @@ rn_walktree(h, f, w)
                /* Process leaves */
                while ((rn = base)) {
                        base = rn->rn_dupedkey;
-                       if (!(rn->rn_flags & RNF_ROOT)
-                           && (error = (*f)(rn, w)))
+                       if (!(rn->rn_flags & RNF_ROOT) && (error = (*f)(rn, w)))
                                return (error);
                }
                rn = next;
@@ -1013,28 +1002,31 @@ rn_walktree(h, f, w)
 }
 
 int
-rn_inithead(head, off)
-       void **head;
-       int off;
+rn_inithead(void **head, int off)
 {
        struct radix_node_head *rnh;
-       struct radix_node *t, *tt, *ttt;
+       struct radix_node *t, *left, *right;
+
        if (*head)
                return (1);
        R_Malloc(rnh, struct radix_node_head *, sizeof (*rnh));
-       if (rnh == 0)
+       if (rnh == NULL)
                return (0);
-       Bzero(rnh, sizeof (*rnh));
+       bzero(rnh, sizeof (*rnh));
        *head = rnh;
+
        t = rn_newpair(rn_zeros, off, rnh->rnh_nodes);
-       ttt = rnh->rnh_nodes + 2;
-       t->rn_right = ttt;
+       right = rnh->rnh_nodes + 2;
+       t->rn_right = right;
        t->rn_parent = t;
-       tt = t->rn_left;
-       tt->rn_flags = t->rn_flags = RNF_ROOT | RNF_ACTIVE;
-       tt->rn_bit = -1 - off;
-       *ttt = *tt;
-       ttt->rn_key = rn_ones;
+
+       left = t->rn_left;
+       left->rn_flags = t->rn_flags = RNF_ROOT | RNF_ACTIVE;
+       left->rn_bit = -1 - off;
+
+       *right = *left;
+       right->rn_key = rn_ones;
+
        rnh->rnh_addaddr = rn_addroute;
        rnh->rnh_deladdr = rn_delete;
        rnh->rnh_matchaddr = rn_match;
@@ -1042,6 +1034,7 @@ rn_inithead(head, off)
        rnh->rnh_walktree = rn_walktree;
        rnh->rnh_walktree_from = rn_walktree_from;
        rnh->rnh_treetop = t;
+
        return (1);
 }
 
@@ -1064,7 +1057,7 @@ rn_init()
        R_Malloc(rn_zeros, char *, 3 * max_keylen);
        if (rn_zeros == NULL)
                panic("rn_init");
-       Bzero(rn_zeros, 3 * max_keylen);
+       bzero(rn_zeros, 3 * max_keylen);
        rn_ones = cp = rn_zeros + max_keylen;
        addmask_key = cplim = rn_ones + max_keylen;
        while (cp < cplim)
index dfe5613..e7d6cfa 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)radix.h     8.2 (Berkeley) 10/31/94
  * $FreeBSD: src/sys/net/radix.h,v 1.16.2.1 2000/05/03 19:17:11 wollman Exp $
- * $DragonFly: src/sys/net/radix.h,v 1.5 2004/04/22 04:21:29 dillon Exp $
+ * $DragonFly: src/sys/net/radix.h,v 1.6 2004/12/14 18:46:08 hsu Exp $
  */
 
 #ifndef _RADIX_H_
@@ -47,7 +47,7 @@ MALLOC_DECLARE(M_RTABLE);
  */
 
 struct radix_node {
-       struct  radix_mask *rn_mklist;  /* list of masks contained in subtree */
+       struct  radix_mask *rn_mklist;  /* masks contained in subtree */
        struct  radix_node *rn_parent;  /* parent */
        short   rn_bit;                 /* bit offset; -1-index(netmask) */
        char    rn_bmask;               /* node: mask for bit test*/
@@ -57,8 +57,8 @@ struct radix_node {
 #define RNF_ACTIVE     4               /* This node is alive (for rtfree) */
        union {
                struct {                        /* leaf only data: */
-                       caddr_t rn_Key;         /* object of search */
-                       caddr_t rn_Mask;        /* netmask, if present */
+                       char   *rn_Key;         /* object of search */
+                       char   *rn_Mask;        /* netmask, if present */
                        struct  radix_node *rn_Dupedkey;
                } rn_leaf;
                struct {                        /* node only data: */
@@ -89,7 +89,7 @@ struct radix_mask {
        short   rm_bit;                 /* bit offset; -1-index(netmask) */
        char    rm_unused;              /* cf. rn_bmask */
        u_char  rm_flags;               /* cf. rn_flags */
-       struct  radix_mask *rm_mklist;  /* more masks to try */
+       struct  radix_mask *rm_next;    /* list of more masks to try */
        union   {
                caddr_t rmu_mask;               /* the mask */
                struct  radix_node *rmu_leaf;   /* for normal routes */
@@ -100,72 +100,72 @@ struct radix_mask {
 #define        rm_mask rm_rmu.rmu_mask
 #define        rm_leaf rm_rmu.rmu_leaf         /* extra field would make 32 bytes */
 
-#define MKGet(m) {\
-       if (rn_mkfreelist) {\
-               m = rn_mkfreelist; \
-               rn_mkfreelist = (m)->rm_mklist; \
-       } else \
-               R_Malloc(m, struct radix_mask *, sizeof (*(m))); }\
-
-#define MKFree(m) { (m)->rm_mklist = rn_mkfreelist; rn_mkfreelist = (m);}
-
 typedef int walktree_f_t (struct radix_node *, void *);
 
 struct radix_node_head {
        struct  radix_node *rnh_treetop;
+
+       /* add based on sockaddr */
+       struct  radix_node *(*rnh_addaddr)
+                   (char *key, char *mask,
+                    struct radix_node_head *head, struct radix_node nodes[]);
+
+       /* remove based on sockaddr */
+       struct  radix_node *(*rnh_deladdr)
+                   (char *key, char *mask, struct radix_node_head *head);
+
+       /* locate based on sockaddr */
+       struct  radix_node *(*rnh_matchaddr)
+                   (char *key, struct radix_node_head *head);
+
+       /* locate based on sockaddr */
+       struct  radix_node *(*rnh_lookup)
+                   (char *key, char *mask, struct radix_node_head *head);
+
+       /* traverse tree */
+       int     (*rnh_walktree)
+                   (struct radix_node_head *head, walktree_f_t *f, void *w);
+
+       /* traverse tree below a */
+       int     (*rnh_walktree_from)
+                   (struct radix_node_head *head, u_char *a, u_char *m,
+                    walktree_f_t *f, void *w);
+
+       /* do something when the last ref drops */
+       void    (*rnh_close)
+                   (struct radix_node *rn, struct radix_node_head *head);
+
+       struct  radix_node rnh_nodes[3];        /* empty tree for common case */
+
+       /* unused entries */
        int     rnh_addrsize;           /* permit, but not require fixed keys */
        int     rnh_pktsize;            /* permit, but not require fixed keys */
-       struct  radix_node *(*rnh_addaddr)      /* add based on sockaddr */
-               (void *v, void *mask,
-                    struct radix_node_head *head, struct radix_node nodes[]);
        struct  radix_node *(*rnh_addpkt)       /* add based on packet hdr */
-               (void *v, void *mask,
+                   (void *v, char *mask,
                     struct radix_node_head *head, struct radix_node nodes[]);
-       struct  radix_node *(*rnh_deladdr)      /* remove based on sockaddr */
-               (void *v, void *mask, struct radix_node_head *head);
        struct  radix_node *(*rnh_delpkt)       /* remove based on packet hdr */
-               (void *v, void *mask, struct radix_node_head *head);
-       struct  radix_node *(*rnh_matchaddr)    /* locate based on sockaddr */
-               (void *v, struct radix_node_head *head);
-       struct  radix_node *(*rnh_lookup)       /* locate based on sockaddr */
-               (void *v, void *mask, struct radix_node_head *head);
+                   (void *v, char *mask, struct radix_node_head *head);
        struct  radix_node *(*rnh_matchpkt)     /* locate based on packet hdr */
-               (void *v, struct radix_node_head *head);
-       int     (*rnh_walktree)                 /* traverse tree */
-               (struct radix_node_head *head, walktree_f_t *f, void *w);
-       int     (*rnh_walktree_from)            /* traverse tree below a */
-               (struct radix_node_head *head, void *a, void *m,
-                    walktree_f_t *f, void *w);
-       void    (*rnh_close)    /* do something when the last ref drops */
-               (struct radix_node *rn, struct radix_node_head *head);
-       struct  radix_node rnh_nodes[3];        /* empty tree for common case */
+                   (void *v, struct radix_node_head *head);
 };
 
 #ifndef _KERNEL
-#define Bcmp(a, b, n) bcmp(((char *)(a)), ((char *)(b)), (n))
-#define Bcopy(a, b, n) bcopy(((char *)(a)), ((char *)(b)), (unsigned)(n))
-#define Bzero(p, n) bzero((char *)(p), (int)(n));
-#define R_Malloc(p, t, n) (p = (t) malloc((unsigned int)(n)))
-#define Free(p) free((char *)p);
+#define R_Malloc(p, t, n) (p = (t) malloc((n)))
+#define Free(p) free(p);
 #else
-#define Bcmp(a, b, n) bcmp(((caddr_t)(a)), ((caddr_t)(b)), (unsigned)(n))
-#define Bcopy(a, b, n) bcopy(((caddr_t)(a)), ((caddr_t)(b)), (unsigned)(n))
-#define Bzero(p, n) bzero((caddr_t)(p), (unsigned)(n));
-#define R_Malloc(p, t, n) (p = (t) malloc((unsigned long)(n), M_RTABLE, M_INTWAIT | M_NULLOK))
-#define Free(p) free((caddr_t)p, M_RTABLE);
-#endif /* _KERNEL */
-
-void    rn_init (void);
-int     rn_inithead (void **, int);
-int     rn_refines (void *, void *);
-struct radix_node
-        *rn_addmask (void *, int, int),
-        *rn_addroute (void *, void *, struct radix_node_head *,
-                       struct radix_node [2]),
-        *rn_delete (void *, void *, struct radix_node_head *),
-        *rn_lookup (void *v_arg, void *m_arg,
-                       struct radix_node_head *head),
-        *rn_match (void *, struct radix_node_head *);
+#define R_Malloc(p, t, n) (p = (t) malloc((n), M_RTABLE, M_INTWAIT | M_NULLOK))
+#define Free(p) free(p, M_RTABLE);
+#endif
 
+void                    rn_init (void);
+int                     rn_inithead (void **, int);
+boolean_t               rn_refines (char *, char *);
+struct radix_node      *rn_addmask (char *, boolean_t, int),
+                       *rn_addroute (char *, char *, struct radix_node_head *,
+                                     struct radix_node [2]),
+                       *rn_delete (char *, char *, struct radix_node_head *),
+                       *rn_lookup (char *key, char *mask,
+                                   struct radix_node_head *head),
+                       *rn_match (char *, struct radix_node_head *);
 
 #endif /* _RADIX_H_ */
index 0c5532b..6dd195f 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)route.c     8.3 (Berkeley) 1/9/95
  * $FreeBSD: src/sys/net/route.c,v 1.59.2.10 2003/01/17 08:04:00 ru Exp $
- * $DragonFly: src/sys/net/route.c,v 1.7 2004/06/02 14:42:57 eirikn Exp $
+ * $DragonFly: src/sys/net/route.c,v 1.8 2004/12/14 18:46:08 hsu Exp $
  */
 
 #include "opt_inet.h"
@@ -57,17 +57,17 @@ struct route_cb route_cb;
 static struct rtstat rtstat;
 struct radix_node_head *rt_tables[AF_MAX+1];
 
-static int     rttrash;                /* routes not in table but not freed */
+static int rttrash;            /* routes not in table but not freed */
 
-static void rt_maskedcopy (struct sockaddr *,
-           struct sockaddr *, struct sockaddr *);
+static void rt_maskedcopy (struct sockaddr *, struct sockaddr *,
+    struct sockaddr *);
 static void rtable_init (void **);
 
 static void
-rtable_init(table)
-       void **table;
+rtable_init(void **table)
 {
        struct domain *dom;
+
        for (dom = domains; dom; dom = dom->dom_next)
                if (dom->dom_rtattach)
                        dom->dom_rtattach(&table[dom->dom_family],
@@ -85,16 +85,13 @@ route_init()
  * Packet routing routines.
  */
 void
-rtalloc(ro)
-       struct route *ro;
+rtalloc(struct route *ro)
 {
        rtalloc_ign(ro, 0UL);
 }
 
 void
-rtalloc_ign(ro, ignore)
-       struct route *ro;
-       u_long ignore;
+rtalloc_ign(struct route *ro, u_long ignore)
 {
        struct rtentry *rt;
        int s;
@@ -116,15 +113,12 @@ rtalloc_ign(ro, ignore)
  * Or, at least try.. Create a cloned route if needed.
  */
 struct rtentry *
-rtalloc1(dst, report, ignflags)
-       struct sockaddr *dst;
-       int report;
-       u_long ignflags;
+rtalloc1(struct sockaddr *dst, int report, u_long ignflags)
 {
        struct radix_node_head *rnh = rt_tables[dst->sa_family];
        struct rtentry *rt;
        struct radix_node *rn;
-       struct rtentry *newrt = 0;
+       struct rtentry *newrt = NULL;
        struct rt_addrinfo info;
        u_long nflags;
        int  s = splnet(), err = 0, msgtype = RTM_MISS;
@@ -132,8 +126,8 @@ rtalloc1(dst, report, ignflags)
        /*
         * Look up the address in the table for that Address Family
         */
-       if (rnh && (rn = rnh->rnh_matchaddr((caddr_t)dst, rnh)) &&
-           ((rn->rn_flags & RNF_ROOT) == 0)) {
+       if (rnh != NULL && (rn = rnh->rnh_matchaddr((char *)dst, rnh)) &&
+           !(rn->rn_flags & RNF_ROOT)) {
                /*
                 * If we find it and it's not the root node, then
                 * get a refernce on the rtentry associated.
@@ -172,7 +166,8 @@ rtalloc1(dst, report, ignflags)
                        info.rti_info[RTAX_GATEWAY] = rt->rt_gateway;
                        if (rt->rt_ifp != NULL) {
                                info.rti_info[RTAX_IFP] =
-                                   TAILQ_FIRST(&rt->rt_ifp->if_addrhead)->ifa_addr;
+                                   TAILQ_FIRST(&rt->rt_ifp->if_addrhead)->
+                                                                   ifa_addr;
                                info.rti_info[RTAX_IFA] = rt->rt_ifa->ifa_addr;
                        }
                        rt_missmsg(RTM_ADD, &info, rt->rt_flags, 0);
@@ -185,13 +180,14 @@ rtalloc1(dst, report, ignflags)
                 * "caint get there frm here"
                 */
                rtstat.rts_unreach++;
-       miss:   if (report) {
+miss:
+               if (report) {
                        /*
                         * If required, report the failure to the supervising
                         * Authorities.
                         * For a delete, this is not an error. (report == 0)
                         */
-                       bzero((caddr_t)&info, sizeof(info));
+                       bzero(&info, sizeof(info));
                        info.rti_info[RTAX_DST] = dst;
                        rt_missmsg(msgtype, &info, 0, err);
                }
@@ -205,17 +201,15 @@ rtalloc1(dst, report, ignflags)
  * If the count gets low enough, take it out of the routing table
  */
 void
-rtfree(rt)
-       struct rtentry *rt;
+rtfree(struct rtentry *rt)
 {
        /*
         * find the tree for that address family
         */
-       struct radix_node_head *rnh =
-               rt_tables[rt_key(rt)->sa_family];
+       struct radix_node_head *rnh = rt_tables[rt_key(rt)->sa_family];
        struct ifaddr *ifa;
 
-       if (rt == 0 || rnh == 0)
+       if (rt == NULL || rnh == NULL)
                panic("rtfree");
 
        /*
@@ -232,7 +226,7 @@ rtfree(rt)
         * then we can free the resources associated
         * with the route.
         */
-       if (rt->rt_refcnt <= 0 && (rt->rt_flags & RTF_UP) == 0) {
+       if (rt->rt_refcnt <= 0 && !(rt->rt_flags & RTF_UP)) {
                if (rt->rt_nodes->rn_flags & (RNF_ACTIVE | RNF_ROOT))
                        panic ("rtfree 2");
                /*
@@ -273,8 +267,7 @@ rtfree(rt)
 }
 
 void
-ifafree(ifa)
-       struct ifaddr *ifa;
+ifafree(struct ifaddr *ifa)
 {
        if (ifa == NULL)
                panic("ifafree");
@@ -284,6 +277,8 @@ ifafree(ifa)
                ifa->ifa_refcnt--;
 }
 
+#define        sa_equal(a1, a2) (bcmp((a1), (a2), (a1)->sa_len) == 0)
+
 /*
  * Force a routing table entry to the specified
  * destination to go through the given gateway.
@@ -294,19 +289,22 @@ ifafree(ifa)
  *
  */
 void
-rtredirect(dst, gateway, netmask, flags, src, rtp)
-       struct sockaddr *dst, *gateway, *netmask, *src;
-       int flags;
-       struct rtentry **rtp;
+rtredirect(
+       struct sockaddr *dst,
+       struct sockaddr *gateway,
+       struct sockaddr *netmask,
+       int flags,
+       struct sockaddr *src,
+       struct rtentry **rtp)
 {
        struct rtentry *rt;
        int error = 0;
-       short *stat = 0;
+       short *stat = NULL;
        struct rt_addrinfo info;
        struct ifaddr *ifa;
 
        /* verify the gateway is directly reachable */
-       if ((ifa = ifa_ifwithnet(gateway)) == 0) {
+       if ((ifa = ifa_ifwithnet(gateway)) == NULL) {
                error = ENETUNREACH;
                goto out;
        }
@@ -317,9 +315,8 @@ rtredirect(dst, gateway, netmask, flags, src, rtp)
         * we have a routing loop, perhaps as a result of an interface
         * going down recently.
         */
-#define        equal(a1, a2) (bcmp((caddr_t)(a1), (caddr_t)(a2), (a1)->sa_len) == 0)
        if (!(flags & RTF_DONE) && rt &&
-            (!equal(src, rt->rt_gateway) || rt->rt_ifa != ifa))
+            (!sa_equal(src, rt->rt_gateway) || rt->rt_ifa != ifa))
                error = EINVAL;
        else if (ifa_ifwithaddr(gateway))
                error = EHOSTUNREACH;
@@ -331,14 +328,14 @@ rtredirect(dst, gateway, netmask, flags, src, rtp)
         * which use routing redirects generated by smart gateways
         * to dynamically build the routing tables.
         */
-       if ((rt == 0) || (rt_mask(rt) && rt_mask(rt)->sa_len < 2))
+       if ((rt == NULL) || (rt_mask(rt) != NULL && rt_mask(rt)->sa_len < 2))
                goto create;
        /*
         * Don't listen to the redirect if it's
         * for a route to an interface.
         */
        if (rt->rt_flags & RTF_GATEWAY) {
-               if (((rt->rt_flags & RTF_HOST) == 0) && (flags & RTF_HOST)) {
+               if ((!(rt->rt_flags & RTF_HOST)) && (flags & RTF_HOST)) {
                        /*
                         * Changing from route to net => route to host.
                         * Create new route, rather than smashing route to net.
@@ -347,7 +344,7 @@ rtredirect(dst, gateway, netmask, flags, src, rtp)
                        if (rt)
                                rtfree(rt);
                        flags |=  RTF_GATEWAY | RTF_DYNAMIC;
-                       bzero((caddr_t)&info, sizeof(info));
+                       bzero(&info, sizeof(info));
                        info.rti_info[RTAX_DST] = dst;
                        info.rti_info[RTAX_GATEWAY] = gateway;
                        info.rti_info[RTAX_NETMASK] = netmask;
@@ -375,7 +372,7 @@ rtredirect(dst, gateway, netmask, flags, src, rtp)
                error = EHOSTUNREACH;
 done:
        if (rt) {
-               if (rtp && !error)
+               if (rtp != NULL && !error)
                        *rtp = rt;
                else
                        rtfree(rt);
@@ -385,7 +382,7 @@ out:
                rtstat.rts_badredirect++;
        else if (stat != NULL)
                (*stat)++;
-       bzero((caddr_t)&info, sizeof(info));
+       bzero(&info, sizeof(info));
        info.rti_info[RTAX_DST] = dst;
        info.rti_info[RTAX_GATEWAY] = gateway;
        info.rti_info[RTAX_NETMASK] = netmask;
@@ -402,18 +399,17 @@ rtioctl(u_long req, caddr_t data, struct thread *td)
 #ifdef INET
        /* Multicast goop, grrr... */
        return mrt_ioctl ? mrt_ioctl(req, data) : EOPNOTSUPP;
-#else /* INET */
+#else
        return ENXIO;
-#endif /* INET */
+#endif
 }
 
 struct ifaddr *
-ifa_ifwithroute(flags, dst, gateway)
-       int flags;
-       struct sockaddr *dst, *gateway;
+ifa_ifwithroute(int flags, struct sockaddr *dst, struct sockaddr *gateway)
 {
        struct ifaddr *ifa;
-       if ((flags & RTF_GATEWAY) == 0) {
+
+       if (!(flags & RTF_GATEWAY)) {
                /*
                 * If we are adding a route to an interface,
                 * and the interface is a pt to pt link
@@ -421,11 +417,11 @@ ifa_ifwithroute(flags, dst, gateway)
                 * as our clue to the interface.  Otherwise
                 * we can use the local address.
                 */
-               ifa = 0;
+               ifa = NULL;
                if (flags & RTF_HOST) {
                        ifa = ifa_ifwithdstaddr(dst);
                }
-               if (ifa == 0)
+               if (ifa == NULL)
                        ifa = ifa_ifwithaddr(gateway);
        } else {
                /*
@@ -435,20 +431,20 @@ ifa_ifwithroute(flags, dst, gateway)
                 */
                ifa = ifa_ifwithdstaddr(gateway);
        }
-       if (ifa == 0)
+       if (ifa == NULL)
                ifa = ifa_ifwithnet(gateway);
-       if (ifa == 0) {
+       if (ifa == NULL) {
                struct rtentry *rt = rtalloc1(gateway, 0, 0UL);
-               if (rt == 0)
-                       return (0);
+               if (rt == NULL)
+                       return (NULL);
                rt->rt_refcnt--;
-               if ((ifa = rt->rt_ifa) == 0)
-                       return (0);
+               if ((ifa = rt->rt_ifa) == NULL)
+                       return (NULL);
        }
        if (ifa->ifa_addr->sa_family != dst->sa_family) {
                struct ifaddr *oifa = ifa;
                ifa = ifaof_ifpforaddr(dst, ifa->ifa_ifp);
-               if (ifa == 0)
+               if (ifa == NULL)
                        ifa = oifa;
        }
        return (ifa);
@@ -467,14 +463,17 @@ struct rtfc_arg {
  * all the bits of info needed
  */
 int
-rtrequest(req, dst, gateway, netmask, flags, ret_nrt)
-       int req, flags;
-       struct sockaddr *dst, *gateway, *netmask;
-       struct rtentry **ret_nrt;
+rtrequest(
+       int req,
+       struct sockaddr *dst,
+       struct sockaddr *gateway,
+       struct sockaddr *netmask,
+       int flags,
+       struct rtentry **ret_nrt)
 {
        struct rt_addrinfo info;
 
-       bzero((caddr_t)&info, sizeof(info));
+       bzero(&info, sizeof(info));
        info.rti_flags = flags;
        info.rti_info[RTAX_DST] = dst;
        info.rti_info[RTAX_GATEWAY] = gateway;
@@ -482,21 +481,14 @@ rtrequest(req, dst, gateway, netmask, flags, ret_nrt)
        return rtrequest1(req, &info, ret_nrt);
 }
 
-/*
- * These (questionable) definitions of apparent local variables apply
- * to the next two functions.  XXXXXX!!!
- */
-#define        dst     info->rti_info[RTAX_DST]
-#define        gateway info->rti_info[RTAX_GATEWAY]
-#define        netmask info->rti_info[RTAX_NETMASK]
-#define        ifaaddr info->rti_info[RTAX_IFA]
-#define        ifpaddr info->rti_info[RTAX_IFP]
-#define        flags   info->rti_flags
-
 int
-rt_getifa(info)
-       struct rt_addrinfo *info;
+rt_getifa(struct rt_addrinfo *info)
 {
+       struct sockaddr *gateway = info->rti_info[RTAX_GATEWAY];
+       struct sockaddr *dst = info->rti_info[RTAX_DST];
+       struct sockaddr *ifaaddr = info->rti_info[RTAX_IFA];
+       struct sockaddr *ifpaddr = info->rti_info[RTAX_IFP];
+       int flags = info->rti_flags;
        struct ifaddr *ifa;
        int error = 0;
 
@@ -531,31 +523,31 @@ rt_getifa(info)
 }
 
 int
-rtrequest1(req, info, ret_nrt)
-       int req;
-       struct rt_addrinfo *info;
-       struct rtentry **ret_nrt;
+rtrequest1(int req, struct rt_addrinfo *info, struct rtentry **ret_nrt)
 {
-       int s = splnet(); int error = 0;
+       struct sockaddr *dst = info->rti_info[RTAX_DST];
        struct rtentry *rt;
        struct radix_node *rn;
        struct radix_node_head *rnh;
        struct ifaddr *ifa;
        struct sockaddr *ndst;
-#define senderr(x) { error = x ; goto bad; }
+       int s = splnet();
+       int error = 0;
+
+#define gotoerr(x) { error = x ; goto bad; }
 
        /*
         * Find the correct routing tree to use for this Address Family
         */
-       if ((rnh = rt_tables[dst->sa_family]) == 0)
-               senderr(EAFNOSUPPORT);
+       if ((rnh = rt_tables[dst->sa_family]) == NULL)
+               gotoerr(EAFNOSUPPORT);
        /*
         * If we are adding a host route then we don't want to put
         * a netmask in the tree, nor do we want to clone it.
         */
-       if (flags & RTF_HOST) {
-               netmask = 0;
-               flags &= ~(RTF_CLONING | RTF_PRCLONING);
+       if (info->rti_flags & RTF_HOST) {
+               info->rti_info[RTAX_NETMASK] = 0;
+               info->rti_flags &= ~(RTF_CLONING | RTF_PRCLONING);
        }
        switch (req) {
        case RTM_DELETE:
@@ -563,8 +555,9 @@ rtrequest1(req, info, ret_nrt)
                 * Remove the item from the tree and return it.
                 * Complain if it is not there and do no more processing.
                 */
-               if ((rn = rnh->rnh_deladdr(dst, netmask, rnh)) == 0)
-                       senderr(ESRCH);
+               if ((rn = rnh->rnh_deladdr((char *)dst,
+                   (char *)info->rti_info[RTAX_NETMASK], rnh)) == NULL)
+                       gotoerr(ESRCH);
                if (rn->rn_flags & (RNF_ACTIVE | RNF_ROOT))
                        panic ("rtrequest delete");
                rt = (struct rtentry *)rn;
@@ -574,8 +567,9 @@ rtrequest1(req, info, ret_nrt)
                 * routes which might have been formed from this node.
                 */
                if ((rt->rt_flags & (RTF_CLONING | RTF_PRCLONING)) &&
-                   rt_mask(rt)) {
-                       rnh->rnh_walktree_from(rnh, dst, rt_mask(rt),
+                   rt_mask(rt) != NULL) {
+                       rnh->rnh_walktree_from(rnh, (char *)dst,
+                                              (char *)rt_mask(rt),
                                               rt_fixdelete, rt);
                }
 
@@ -587,7 +581,7 @@ rtrequest1(req, info, ret_nrt)
                if (rt->rt_gwroute) {
                        rt = rt->rt_gwroute;
                        RTFREE(rt);
-                       (rt = (struct rtentry *)rn)->rt_gwroute = 0;
+                       (rt = (struct rtentry *)rn)->rt_gwroute = NULL;
                }
 
                /*
@@ -625,38 +619,40 @@ rtrequest1(req, info, ret_nrt)
                break;
 
        case RTM_RESOLVE:
-               if (ret_nrt == 0 || (rt = *ret_nrt) == 0)
-                       senderr(EINVAL);
+               if (ret_nrt == NULL || (rt = *ret_nrt) == NULL)
+                       gotoerr(EINVAL);
                ifa = rt->rt_ifa;
-               flags = rt->rt_flags &
+               info->rti_flags = rt->rt_flags &
                    ~(RTF_CLONING | RTF_PRCLONING | RTF_STATIC);
-               flags |= RTF_WASCLONED;
-               gateway = rt->rt_gateway;
-               if ((netmask = rt->rt_genmask) == 0)
-                       flags |= RTF_HOST;
+               info->rti_flags |= RTF_WASCLONED;
+               info->rti_info[RTAX_GATEWAY] = rt->rt_gateway;
+               if ((info->rti_info[RTAX_NETMASK] = rt->rt_genmask) == NULL)
+                       info->rti_flags |= RTF_HOST;
                goto makeroute;
 
        case RTM_ADD:
-               if ((flags & RTF_GATEWAY) && !gateway)
+               if ((info->rti_flags & RTF_GATEWAY) &&
+                   !info->rti_info[RTAX_GATEWAY])
                        panic("rtrequest: GATEWAY but no gateway");
 
                if (info->rti_ifa == NULL && (error = rt_getifa(info)))
-                       senderr(error);
+                       gotoerr(error);
                ifa = info->rti_ifa;
 
-       makeroute:
+makeroute:
                R_Malloc(rt, struct rtentry *, sizeof(*rt));
-               if (rt == 0)
-                       senderr(ENOBUFS);
-               Bzero(rt, sizeof(*rt));
-               rt->rt_flags = RTF_UP | flags;
+               if (rt == NULL)
+                       gotoerr(ENOBUFS);
+               bzero(rt, sizeof(*rt));
+               rt->rt_flags = RTF_UP | info->rti_flags;
                /*
                 * Add the gateway. Possibly re-malloc-ing the storage for it
                 * also add the rt_gwroute if possible.
                 */
-               if ((error = rt_setgate(rt, dst, gateway)) != 0) {
+               if ((error = rt_setgate(rt, dst, info->rti_info[RTAX_GATEWAY]))
+                   != 0) {
                        Free(rt);
-                       senderr(error);
+                       gotoerr(error);
                }
 
                /*
@@ -667,10 +663,10 @@ rtrequest1(req, info, ret_nrt)
                /*
                 * make sure it contains the value we want (masked if needed).
                 */
-               if (netmask) {
-                       rt_maskedcopy(dst, ndst, netmask);
+               if (info->rti_info[RTAX_NETMASK]) {
+                       rt_maskedcopy(dst, ndst, info->rti_info[RTAX_NETMASK]);
                } else
-                       Bcopy(dst, ndst, dst->sa_len);
+                       bcopy(dst, ndst, dst->sa_len);
 
                /*
                 * Note that we now have a reference to the ifa.
@@ -682,9 +678,10 @@ rtrequest1(req, info, ret_nrt)
                rt->rt_ifp = ifa->ifa_ifp;
                /* XXX mtu manipulation will be done in rnh_addaddr -- itojun */
 
-               rn = rnh->rnh_addaddr((caddr_t)ndst, (caddr_t)netmask,
-                                       rnh, rt->rt_nodes);
-               if (rn == 0) {
+               rn = rnh->rnh_addaddr((char *)ndst,
+                                     (char *)info->rti_info[RTAX_NETMASK],
+                                     rnh, rt->rt_nodes);
+               if (rn == NULL) {
                        struct rtentry *rt2;
                        /*
                         * Uh-oh, we already have one of these in the tree.
@@ -694,16 +691,16 @@ rtrequest1(req, info, ret_nrt)
                         * the insertion of the new one.
                         */
                        rt2 = rtalloc1(dst, 0, RTF_PRCLONING);
-                       if (rt2 && rt2->rt_parent) {
+                       if (rt2 != NULL && rt2->rt_parent) {
                                rtrequest(RTM_DELETE,
                                          (struct sockaddr *)rt_key(rt2),
                                          rt2->rt_gateway,
                                          rt_mask(rt2), rt2->rt_flags, 0);
                                RTFREE(rt2);
-                               rn = rnh->rnh_addaddr((caddr_t)ndst,
-                                                     (caddr_t)netmask,
-                                                     rnh, rt->rt_nodes);
-                       } else if (rt2) {
+                               rn = rnh->rnh_addaddr((char *)ndst,
+                                   (char *)info->rti_info[RTAX_NETMASK],
+                                   rnh, rt->rt_nodes);
+                       } else if (rt2 != NULL) {
                                /* undo the extra ref we got */
                                RTFREE(rt2);
                        }
@@ -713,7 +710,7 @@ rtrequest1(req, info, ret_nrt)
                 * If it still failed to go into the tree,
                 * then un-make it (this should be a function)
                 */
-               if (rn == 0) {
+               if (rn == NULL) {
                        if (rt->rt_gwroute)
                                rtfree(rt->rt_gwroute);
                        if (rt->rt_ifa) {
@@ -721,7 +718,7 @@ rtrequest1(req, info, ret_nrt)
                        }
                        Free(rt_key(rt));
                        Free(rt);
-                       senderr(EEXIST);
+                       gotoerr(EEXIST);
                }
 
                rt->rt_parent = 0;
@@ -734,7 +731,8 @@ rtrequest1(req, info, ret_nrt)
                if (req == RTM_RESOLVE) {
                        rt->rt_rmx = (*ret_nrt)->rt_rmx; /* copy metrics */
                        rt->rt_rmx.rmx_pksent = 0; /* reset packet counter */
-                       if ((*ret_nrt)->rt_flags & (RTF_CLONING | RTF_PRCLONING)) {
+                       if ((*ret_nrt)->rt_flags &
+                           (RTF_CLONING | RTF_PRCLONING)) {
                                rt->rt_parent = (*ret_nrt);
                                (*ret_nrt)->rt_refcnt++;
                        }
@@ -752,12 +750,13 @@ rtrequest1(req, info, ret_nrt)
                 * it doesn't fire when we call it there because the node
                 * hasn't been added to the tree yet.
                 */
-               if (req == RTM_ADD &&
-                   !(rt->rt_flags & RTF_HOST) && rt_mask(rt) != 0) {
+               if (req == RTM_ADD && !(rt->rt_flags & RTF_HOST) &&
+                   rt_mask(rt) != NULL) {
                        struct rtfc_arg arg;
                        arg.rnh = rnh;
                        arg.rt0 = rt;
-                       rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt),
+                       rnh->rnh_walktree_from(rnh, (char *)rt_key(rt),
+                                              (char *)rt_mask(rt),
                                               rt_fixchange, &arg);
                }
 
@@ -776,12 +775,6 @@ rtrequest1(req, info, ret_nrt)
 bad:
        splx(s);
        return (error);
-#undef dst
-#undef gateway
-#undef netmask
-#undef ifaaddr
-#undef ifpaddr
-#undef flags
 }
 
 /*
@@ -792,9 +785,7 @@ bad:
  * the late parent (passed in as VP here) are themselves deleted.
  */
 static int
-rt_fixdelete(rn, vp)
-       struct radix_node *rn;
-       void *vp;
+rt_fixdelete(struct radix_node *rn, void *vp)
 {
        struct rtentry *rt = (struct rtentry *)rn;
        struct rtentry *rt0 = vp;
@@ -826,9 +817,7 @@ static int rtfcdebug = 0;
 #endif
 
 static int
-rt_fixchange(rn, vp)
-       struct radix_node *rn;
-       void *vp;
+rt_fixchange(struct radix_node *rn, void *vp)
 {
        struct rtentry *rt = (struct rtentry *)rn;
        struct rtfc_arg *ap = vp;
@@ -915,11 +904,9 @@ rt_fixchange(rn, vp)
 #define ROUNDUP(a) (a>0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
 
 int
-rt_setgate(rt0, dst, gate)
-       struct rtentry *rt0;
-       struct sockaddr *dst, *gate;
+rt_setgate(struct rtentry *rt0, struct sockaddr *dst, struct sockaddr *gate)
 {
-       caddr_t new, old;
+       caddr_t newkey, oldkey;
        int dlen = ROUNDUP(dst->sa_len), glen = ROUNDUP(gate->sa_len);
        struct rtentry *rt = rt0;
        struct radix_node_head *rnh = rt_tables[dst->sa_family];
@@ -937,9 +924,9 @@ rt_setgate(rt0, dst, gate)
                 * The route might already exist if this is an RTM_CHANGE
                 * or a routing redirect, so try to delete it.
                 */
-               if (rt_key(rt0))
-                       rtrequest(RTM_DELETE, (struct sockaddr *)rt_key(rt0),
-                           rt0->rt_gateway, rt_mask(rt0), rt0->rt_flags, 0);
+               if (rt_key(rt0) != NULL)
+                       rtrequest(RTM_DELETE, rt_key(rt0), rt0->rt_gateway,
+                           rt_mask(rt0), rt0->rt_flags, 0);
                return EADDRNOTAVAIL;
        }
 
@@ -949,32 +936,33 @@ rt_setgate(rt0, dst, gate)
         * if we need to malloc a new chunk, then keep the old one around
         * till we don't need it any more.
         */
-       if (rt->rt_gateway == 0 || glen > ROUNDUP(rt->rt_gateway->sa_len)) {
-               old = (caddr_t)rt_key(rt);
-               R_Malloc(new, caddr_t, dlen + glen);
-               if (new == 0)
+       if (rt->rt_gateway == NULL || glen > ROUNDUP(rt->rt_gateway->sa_len)) {
+               oldkey = (caddr_t)rt_key(rt);
+               R_Malloc(newkey, caddr_t, dlen + glen);
+               if (newkey == NULL)
                        return ENOBUFS;
-               rt->rt_nodes->rn_key = new;
+               rt->rt_nodes->rn_key = newkey;
        } else {
                /*
                 * otherwise just overwrite the old one
                 */
-               new = rt->rt_nodes->rn_key;
-               old = 0;
+               newkey = rt->rt_nodes->rn_key;
+               oldkey = NULL;
        }
 
        /*
         * copy the new gateway value into the memory chunk
         */
-       Bcopy(gate, (rt->rt_gateway = (struct sockaddr *)(new + dlen)), glen);
+       rt->rt_gateway = (struct sockaddr *)(newkey + dlen);
+       bcopy(gate, rt->rt_gateway, glen);
 
        /*
         * if we are replacing the chunk (or it's new) we need to
         * replace the dst as well
         */
-       if (old) {
-               Bcopy(dst, new, dlen);
-               Free(old);
+       if (oldkey != NULL) {
+               bcopy(dst, newkey, dlen);
+               Free(oldkey);
        }
 
        /*
@@ -1009,11 +997,12 @@ rt_setgate(rt0, dst, gate)
         * don't bother.  Also make sure we have a reasonable mask
         * (we don't yet have one during adds).
         */
-       if (!(rt->rt_flags & RTF_HOST) && rt_mask(rt) != 0) {
+       if (!(rt->rt_flags & RTF_HOST) && rt_mask(rt) != NULL) {
                struct rtfc_arg arg;
                arg.rnh = rnh;
                arg.rt0 = rt;
-               rnh->rnh_walktree_from(rnh, rt_key(rt), rt_mask(rt),
+               rnh->rnh_walktree_from(rnh, (char*)rt_key(rt),
+                                      (char *)rt_mask(rt),
                                       rt_fixchange, &arg);
        }
 
@@ -1021,8 +1010,8 @@ rt_setgate(rt0, dst, gate)
 }
 
 static void
-rt_maskedcopy(src, dst, netmask)
-       struct sockaddr *src, *dst, *netmask;
+rt_maskedcopy(struct sockaddr *src, struct sockaddr *dst,
+    struct sockaddr *netmask)
 {
        u_char *cp1 = (u_char *)src;
        u_char *cp2 = (u_char *)dst;
@@ -1037,7 +1026,7 @@ rt_maskedcopy(src, dst, netmask)
        while (cp2 < cplim)
                *cp2++ = *cp1++ & *cp3++;
        if (cp2 < cplim2)
-               bzero((caddr_t)cp2, (unsigned)(cplim2 - cp2));
+               bzero(cp2, (unsigned)(cplim2 - cp2));
 }
 
 /*
@@ -1045,9 +1034,7 @@ rt_maskedcopy(src, dst, netmask)
  * for an interface.
  */
 int
-rtinit(ifa, cmd, flags)
-       struct ifaddr *ifa;
-       int cmd, flags;
+rtinit(struct ifaddr *ifa, int cmd, int flags)
 {
        struct rtentry *rt;
        struct sockaddr *dst;
@@ -1091,10 +1078,11 @@ rtinit(ifa, cmd, flags)
                 * contains the correct info.
                 */
                if ((rnh = rt_tables[dst->sa_family]) == NULL ||
-                   (rn = rnh->rnh_lookup(dst, netmask, rnh)) == NULL ||
+                   (rn = rnh->rnh_lookup((char *)dst, (char *)netmask,
+                    rnh)) == NULL ||
                    (rn->rn_flags & RNF_ROOT) ||
                    ((struct rtentry *)rn)->rt_ifa != ifa ||
-                   !equal(SA(rn->rn_key), dst)) {
+                   !sa_equal(SA(rn->rn_key), dst)) {
                        if (m)
                                (void) m_free(m);
                        return (flags & RTF_HOST ? EHOSTUNREACH : ENETUNREACH);
@@ -1114,7 +1102,7 @@ rtinit(ifa, cmd, flags)
        /*
         * Do the actual request
         */
-       bzero((caddr_t)&info, sizeof(info));
+       bzero(&info, sizeof(info));
        info.rti_ifa = ifa;
        info.rti_flags = flags | ifa->ifa_flags;
        info.rti_info[RTAX_DST] = dst;
index 32e1be3..fc6ff94 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)route.h     8.4 (Berkeley) 1/9/95
  * $FreeBSD: src/sys/net/route.h,v 1.36.2.5 2002/02/01 11:48:01 ru Exp $
- * $DragonFly: src/sys/net/route.h,v 1.4 2003/08/26 20:49:47 rob Exp $
+ * $DragonFly: src/sys/net/route.h,v 1.5 2004/12/14 18:46:08 hsu Exp $
  */
 
 #ifndef _NET_ROUTE_H_
@@ -59,17 +59,19 @@ struct route {
  * These numbers are used by reliable protocols for determining
  * retransmission behavior and are included in the routing structure.
  */
-struct rt_metrics {
+struct rt_metrics {    /* grouped for locality of reference */
        u_long  rmx_locks;      /* Kernel must leave these values alone */
        u_long  rmx_mtu;        /* MTU for this path */
-       u_long  rmx_hopcount;   /* max hops expected */
-       u_long  rmx_expire;     /* lifetime for route, e.g. redirect */
-       u_long  rmx_recvpipe;   /* inbound delay-bandwidth product */
+       u_long  rmx_pksent;     /* packets sent using this route */
+       u_long  rmx_expire;     /* lifetime for route */
+
        u_long  rmx_sendpipe;   /* outbound delay-bandwidth product */
        u_long  rmx_ssthresh;   /* outbound gateway buffer limit */
        u_long  rmx_rtt;        /* estimated round trip time */
        u_long  rmx_rttvar;     /* estimated rtt variance */
-       u_long  rmx_pksent;     /* packets sent using this route */
+
+       u_long  rmx_recvpipe;   /* inbound delay-bandwidth product */
+       u_long  rmx_hopcount;   /* max hops expected */
        u_long  rmx_filler[4];  /* will be used for T/TCP later */
 };
 
index 3c7b07f..d2741d1 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)rtsock.c    8.7 (Berkeley) 10/12/95
  * $FreeBSD: src/sys/net/rtsock.c,v 1.44.2.11 2002/12/04 14:05:41 ru Exp $
- * $DragonFly: src/sys/net/rtsock.c,v 1.14 2004/06/03 15:04:51 joerg Exp $
+ * $DragonFly: src/sys/net/rtsock.c,v 1.15 2004/12/14 18:46:08 hsu Exp $
  */
 
 
@@ -275,14 +275,14 @@ static struct pr_usrreqs route_usrreqs = {
 static int
 route_output(struct mbuf *m, struct socket *so, ...)
 {
-       struct rt_msghdr *rtm = 0;
-       struct rtentry *rt = 0;
-       struct rtentry *saved_nrt = 0;
+       struct rt_msghdr *rtm = NULL;
+       struct rtentry *rt = NULL;
+       struct rtentry *saved_nrt = NULL;
        struct radix_node_head *rnh;
        struct rt_addrinfo info;
        int len, error = 0;
-       struct ifnet *ifp = 0;
-       struct ifaddr *ifa = 0;
+       struct ifnet *ifp = NULL;
+       struct ifaddr *ifa = NULL;
        struct pr_output_info *oi;
        __va_list ap;
 
@@ -291,8 +291,8 @@ route_output(struct mbuf *m, struct socket *so, ...)
        __va_end(ap);
 
 #define senderr(e) { error = e; goto flush;}
-       if (m == 0 || ((m->m_len < sizeof(long)) &&
-                      (m = m_pullup(m, sizeof(long))) == 0))
+       if (m == NULL || ((m->m_len < sizeof(long)) &&
+                      (m = m_pullup(m, sizeof(long))) == NULL))
                return (ENOBUFS);
        if ((m->m_flags & M_PKTHDR) == 0)
                panic("route_output");
@@ -326,7 +326,7 @@ route_output(struct mbuf *m, struct socket *so, ...)
        if (genmask) {
                struct radix_node *t;
                t = rn_addmask((caddr_t)genmask, 0, 1);
-               if (t && Bcmp((caddr_t *)genmask + 1, (caddr_t *)t->rn_key + 1,
+               if (t && bcmp((caddr_t *)genmask + 1, (caddr_t *)t->rn_key + 1,
                              *(u_char *)t->rn_key - 1) == 0)
                        genmask = (struct sockaddr *)(t->rn_key);
                else
@@ -369,10 +369,10 @@ route_output(struct mbuf *m, struct socket *so, ...)
        case RTM_GET:
        case RTM_CHANGE:
        case RTM_LOCK:
-               if ((rnh = rt_tables[dst->sa_family]) == 0) {
+               if ((rnh = rt_tables[dst->sa_family]) == NULL) {
                        senderr(EAFNOSUPPORT);
-               } else if ((rt = (struct rtentry *)
-                               rnh->rnh_lookup(dst, netmask, rnh)) != NULL)
+               } else if ((rt = (struct rtentry *) rnh->rnh_lookup(
+                   (char *)dst, (char *)netmask, rnh)) != NULL)
                        rt->rt_refcnt++;
                else
                        senderr(ESRCH);
@@ -404,7 +404,7 @@ route_output(struct mbuf *m, struct socket *so, ...)
                                R_Malloc(new_rtm, struct rt_msghdr *, len);
                                if (new_rtm == 0)
                                        senderr(ENOBUFS);
-                               Bcopy(rtm, new_rtm, rtm->rtm_msglen);
+                               bcopy(rtm, new_rtm, rtm->rtm_msglen);
                                Free(rtm); rtm = new_rtm;
                        }
                        (void)rt_msg2(rtm->rtm_type, &info, (caddr_t)rtm,
@@ -512,23 +512,22 @@ rt_setmetrics(which, in, out)
        u_long which;
        struct rt_metrics *in, *out;
 {
-#define metric(f, e) if (which & (f)) out->e = in->e;
-       metric(RTV_RPIPE, rmx_recvpipe);
-       metric(RTV_SPIPE, rmx_sendpipe);
-       metric(RTV_SSTHRESH, rmx_ssthresh);
-       metric(RTV_RTT, rmx_rtt);
-       metric(RTV_RTTVAR, rmx_rttvar);
-       metric(RTV_HOPCOUNT, rmx_hopcount);
-       metric(RTV_MTU, rmx_mtu);
-       metric(RTV_EXPIRE, rmx_expire);
-#undef metric
+#define setmetric(flag, elt) if (which & (flag)) out->elt = in->elt;
+       setmetric(RTV_RPIPE, rmx_recvpipe);
+       setmetric(RTV_SPIPE, rmx_sendpipe);
+       setmetric(RTV_SSTHRESH, rmx_ssthresh);
+       setmetric(RTV_RTT, rmx_rtt);
+       setmetric(RTV_RTTVAR, rmx_rttvar);
+       setmetric(RTV_HOPCOUNT, rmx_hopcount);
+       setmetric(RTV_MTU, rmx_mtu);
+       setmetric(RTV_EXPIRE, rmx_expire);
+#undef setmetric
 }
 
 #define ROUNDUP(a) \
        ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
 #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
 
-
 /*
  * Extract the addresses of the passed sockaddrs.
  * Do a little sanity checking so as to avoid bad memory references.
@@ -1029,7 +1028,7 @@ sysctl_rtsock(SYSCTL_HANDLER_ARGS)
        if (namelen != 3)
                return (EINVAL);
        af = name[0];
-       Bzero(&w, sizeof(w));
+       bzero(&w, sizeof(w));
        w.w_op = name[1];
        w.w_arg = name[2];
        w.w_req = req;
index 2735eff..de45f9b 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)if_ether.c  8.1 (Berkeley) 6/10/93
  * $FreeBSD: src/sys/netinet/if_ether.c,v 1.64.2.23 2003/04/11 07:23:15 fjoe Exp $
- * $DragonFly: src/sys/netinet/if_ether.c,v 1.19 2004/12/11 01:04:00 hsu Exp $
+ * $DragonFly: src/sys/netinet/if_ether.c,v 1.20 2004/12/14 18:46:08 hsu Exp $
  */
 
 /*
@@ -101,7 +101,6 @@ struct llinfo_arp {
        struct  mbuf *la_hold;  /* last packet until resolved/timeout */
        u_short la_preempt;     /* countdown for pre-expiry arps */
        u_short la_asked;       /* #times we QUERIED following expiration */
-#define la_timer la_rt->rt_rmx.rmx_expire /* deletion time in seconds */
 };
 
 static LIST_HEAD(, llinfo_arp) llinfo_arp;
@@ -142,14 +141,11 @@ arptimer(ignored_arg)
        void *ignored_arg;
 {
        int s = splnet();
-       struct llinfo_arp *la = LIST_FIRST(&llinfo_arp);
-       struct llinfo_arp *ola;
-
-       while ((ola = la) != 0) {
-               struct rtentry *rt = la->la_rt;
-               la = LIST_NEXT(la, la_le);
-               if (rt->rt_expire && rt->rt_expire <= time_second)
-                       arptfree(ola); /* timer has expired, clear */
+       struct llinfo_arp *la, *nla;
+
+       LIST_FOREACH_MUTABLE(la, &llinfo_arp, la_le, nla) {
+               if (la->la_rt->rt_expire && la->la_rt->rt_expire <= time_second)
+                       arptfree(la);   /* might remove la from llinfo_arp! */
        }
        callout_reset(&arptimer_ch, arpt_prune * hz, arptimer, NULL);
        splx(s);
@@ -226,7 +222,7 @@ arp_rtrequest(req, rt, info)
                        break;
                }
                arp_inuse++, arp_allocated++;
-               Bzero(la, sizeof(*la));
+               bzero(la, sizeof(*la));
                la->la_rt = rt;
                rt->rt_flags |= RTF_LLINFO;
                LIST_INSERT_HEAD(&llinfo_arp, la, la_le);
@@ -265,7 +261,7 @@ arp_rtrequest(req, rt, info)
                     * the route to force traffic out to the hardware.
                     */
                        rt->rt_expire = 0;
-                       Bcopy(IF_LLADDR(rt->rt_ifp), LLADDR(SDL(gate)),
+                       bcopy(IF_LLADDR(rt->rt_ifp), LLADDR(SDL(gate)),
                              SDL(gate)->sdl_alen = rt->rt_ifp->if_addrlen);
                        if (useloopback)
                                rt->rt_ifp = loif;
index 5292c1c..63f76d8 100644 (file)
@@ -27,7 +27,7 @@
  * SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/netinet/in_rmx.c,v 1.37.2.3 2002/08/09 14:49:23 ru Exp $
- * $DragonFly: src/sys/netinet/in_rmx.c,v 1.5 2004/09/16 23:14:29 joerg Exp $
+ * $DragonFly: src/sys/netinet/in_rmx.c,v 1.6 2004/12/14 18:46:08 hsu Exp $
  */
 
 /*
 #include <netinet/in_var.h>
 #include <netinet/ip_var.h>
 
-static struct callout  in_rtqtimo_ch;
+#define RTPRF_OURS     RTF_PROTO3      /* set on routes we manage */
 
-extern int     in_inithead (void **head, int off);
-
-#define RTPRF_OURS             RTF_PROTO3      /* set on routes we manage */
+static struct callout in_rtqtimo_ch;
 
 /*
  * Do what we need to do when inserting a route.
  */
 static struct radix_node *
-in_addroute(void *v_arg, void *n_arg, struct radix_node_head *head,
+in_addroute(char *key, char *mask, struct radix_node_head *head,
            struct radix_node *treenodes)
 {
        struct rtentry *rt = (struct rtentry *)treenodes;
@@ -77,10 +75,10 @@ in_addroute(void *v_arg, void *n_arg, struct radix_node_head *head,
        /*
         * For IP, all unicast non-host routes are automatically cloning.
         */
-       if(IN_MULTICAST(ntohl(sin->sin_addr.s_addr)))
+       if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr)))
                rt->rt_flags |= RTF_MULTICAST;
 
-       if(!(rt->rt_flags & (RTF_HOST | RTF_CLONING | RTF_MULTICAST))) {
+       if (!(rt->rt_flags & (RTF_HOST | RTF_CLONING | RTF_MULTICAST))) {
                rt->rt_flags |= RTF_PRCLONING;
        }
 
@@ -110,11 +108,11 @@ in_addroute(void *v_arg, void *n_arg, struct radix_node_head *head,
                }
        }
 
-       if (!rt->rt_rmx.rmx_mtu && !(rt->rt_rmx.rmx_locks & RTV_MTU) 
-           && rt->rt_ifp)
+       if (rt->rt_rmx.rmx_mtu != 0 && !(rt->rt_rmx.rmx_locks & RTV_MTU) &&
+           rt->rt_ifp != NULL)
                rt->rt_rmx.rmx_mtu = rt->rt_ifp->if_mtu;
 
-       ret = rn_addroute(v_arg, n_arg, head, treenodes);
+       ret = rn_addroute(key, mask, head, treenodes);
        if (ret == NULL && rt->rt_flags & RTF_HOST) {
                struct rtentry *rt2;
                /*
@@ -133,7 +131,7 @@ in_addroute(void *v_arg, void *n_arg, struct radix_node_head *head,
                                          (struct sockaddr *)rt_key(rt2),
                                          rt2->rt_gateway,
                                          rt_mask(rt2), rt2->rt_flags, 0);
-                               ret = rn_addroute(v_arg, n_arg, head,
+                               ret = rn_addroute(key, mask, head,
                                        treenodes);
                        }
                        RTFREE(rt2);
@@ -145,9 +143,9 @@ in_addroute(void *v_arg, void *n_arg, struct radix_node_head *head,
         * and there is a cached route, free it.  Otherwise, we may end
         * up using the wrong route.
         */
-       if (ret != NULL && ipforwarding && ipforward_rt.ro_rt) {
+       if (ret != NULL && ipforwarding && ipforward_rt.ro_rt != NULL) {
                RTFREE(ipforward_rt.ro_rt);
-               ipforward_rt.ro_rt = 0;
+               ipforward_rt.ro_rt = NULL;
        }
 
        return ret;
@@ -159,13 +157,13 @@ in_addroute(void *v_arg, void *n_arg, struct radix_node_head *head,
  * back off again.
  */
 static struct radix_node *
-in_matroute(void *v_arg, struct radix_node_head *head)
+in_matchroute(char *key, struct radix_node_head *head)
 {
-       struct radix_node *rn = rn_match(v_arg, head);
+       struct radix_node *rn = rn_match(key, head);
        struct rtentry *rt = (struct rtentry *)rn;
 
-       if(rt && rt->rt_refcnt == 0) { /* this is first reference */
-               if(rt->rt_flags & RTPRF_OURS) {
+       if (rt != NULL && rt->rt_refcnt == 0) { /* this is first reference */
+               if (rt->rt_flags & RTPRF_OURS) {
                        rt->rt_flags &= ~RTPRF_OURS;
                        rt->rt_rmx.rmx_expire = 0;
                }
@@ -173,21 +171,18 @@ in_matroute(void *v_arg, struct radix_node_head *head)
        return rn;
 }
 
-static int rtq_reallyold = 60*60;
-       /* one hour is ``really old'' */
-SYSCTL_INT(_net_inet_ip, IPCTL_RTEXPIRE, rtexpire, CTLFLAG_RW, 
-    &rtq_reallyold , 0, 
+static int rtq_reallyold = 60*60;  /* one hour is ``really old'' */
+SYSCTL_INT(_net_inet_ip, IPCTL_RTEXPIRE, rtexpire, CTLFLAG_RW,
+    &rtq_reallyold , 0,
     "Default expiration time on dynamically learned routes");
-                                  
-static int rtq_minreallyold = 10;
-       /* never automatically crank down to less */
-SYSCTL_INT(_net_inet_ip, IPCTL_RTMINEXPIRE, rtminexpire, CTLFLAG_RW, 
-    &rtq_minreallyold , 0, 
+
+static int rtq_minreallyold = 10;  /* never automatically crank down to less */
+SYSCTL_INT(_net_inet_ip, IPCTL_RTMINEXPIRE, rtminexpire, CTLFLAG_RW,
+    &rtq_minreallyold , 0,
     "Minimum time to attempt to hold onto dynamically learned routes");
-                                  
-static int rtq_toomany = 128;
-       /* 128 cached routes is ``too many'' */
-SYSCTL_INT(_net_inet_ip, IPCTL_RTMAXCACHE, rtmaxcache, CTLFLAG_RW, 
+
+static int rtq_toomany = 128;     /* 128 cached routes is ``too many'' */
+SYSCTL_INT(_net_inet_ip, IPCTL_RTMAXCACHE, rtmaxcache, CTLFLAG_RW,
     &rtq_toomany , 0, "Upper limit on dynamically learned routes");
 
 /*
@@ -199,14 +194,13 @@ in_clsroute(struct radix_node *rn, struct radix_node_head *head)
 {
        struct rtentry *rt = (struct rtentry *)rn;
 
-       if(!(rt->rt_flags & RTF_UP))
+       if (!(rt->rt_flags & RTF_UP))
                return;         /* prophylactic measures */
 
-       if((rt->rt_flags & (RTF_LLINFO | RTF_HOST)) != RTF_HOST)
+       if ((rt->rt_flags & (RTF_LLINFO | RTF_HOST)) != RTF_HOST)
                return;
 
-       if((rt->rt_flags & (RTF_WASCLONED | RTPRF_OURS))
-          != RTF_WASCLONED)
+       if ((rt->rt_flags & (RTF_WASCLONED | RTPRF_OURS)) != RTF_WASCLONED)
                return;
 
        /*
@@ -214,7 +208,7 @@ in_clsroute(struct radix_node *rn, struct radix_node_head *head)
         * If rtq_reallyold is 0, just delete the route without
         * waiting for a timeout cycle to kill it.
         */
-       if(rtq_reallyold != 0) {
+       if (rtq_reallyold != 0) {
                rt->rt_flags |= RTPRF_OURS;
                rt->rt_rmx.rmx_expire = time_second + rtq_reallyold;
        } else {
@@ -246,28 +240,28 @@ in_rtqkill(struct radix_node *rn, void *rock)
        struct rtentry *rt = (struct rtentry *)rn;
        int err;
 
-       if(rt->rt_flags & RTPRF_OURS) {
+       if (rt->rt_flags & RTPRF_OURS) {
                ap->found++;
 
-               if(ap->draining || rt->rt_rmx.rmx_expire <= time_second) {
-                       if(rt->rt_refcnt > 0)
+               if (ap->draining || rt->rt_rmx.rmx_expire <= time_second) {
+                       if (rt->rt_refcnt > 0)
                                panic("rtqkill route really not free");
 
                        err = rtrequest(RTM_DELETE,
                                        (struct sockaddr *)rt_key(rt),
                                        rt->rt_gateway, rt_mask(rt),
                                        rt->rt_flags, 0);
-                       if(err) {
+                       if (err) {
                                log(LOG_WARNING, "in_rtqkill: error %d\n", err);
                        } else {
                                ap->killed++;
                        }
                } else {
-                       if(ap->updating
-                          && (rt->rt_rmx.rmx_expire - time_second
-                              > rtq_reallyold)) {
-                               rt->rt_rmx.rmx_expire = time_second
-                                       + rtq_reallyold;
+                       if (ap->updating &&
+                           (rt->rt_rmx.rmx_expire - time_second >
+                            rtq_reallyold)) {
+                               rt->rt_rmx.rmx_expire = time_second +
+                                   rtq_reallyold;
                        }
                        ap->nextstop = lmin(ap->nextstop,
                                            rt->rt_rmx.rmx_expire);
@@ -305,11 +299,11 @@ in_rtqtimo(void *rock)
         * than once in rtq_timeout seconds, to keep from cranking down too
         * hard.
         */
-       if((arg.found - arg.killed > rtq_toomany)
-          && (time_second - last_adjusted_timeout >= rtq_timeout)
-          && rtq_reallyold > rtq_minreallyold) {
+       if ((arg.found - arg.killed > rtq_toomany) &&
+           (time_second - last_adjusted_timeout >= rtq_timeout) &&
+           rtq_reallyold > rtq_minreallyold) {
                rtq_reallyold = 2*rtq_reallyold / 3;
-               if(rtq_reallyold < rtq_minreallyold) {
+               if (rtq_reallyold < rtq_minreallyold) {
                        rtq_reallyold = rtq_minreallyold;
                }
 
@@ -336,6 +330,7 @@ in_rtqdrain(void)
        struct radix_node_head *rnh = rt_tables[AF_INET];
        struct rtqk_arg arg;
        int s;
+
        arg.found = arg.killed = 0;
        arg.rnh = rnh;
        arg.nextstop = 0;
@@ -354,15 +349,15 @@ in_inithead(void **head, int off)
 {
        struct radix_node_head *rnh;
 
-       if(!rn_inithead(head, off))
+       if (!rn_inithead(head, off))
                return 0;
 
-       if(head != (void **)&rt_tables[AF_INET]) /* BOGUS! */
+       if (head != (void **)&rt_tables[AF_INET]) /* BOGUS! */
                return 1;       /* only do this for the real routing table */
 
        rnh = *head;
        rnh->rnh_addaddr = in_addroute;
-       rnh->rnh_matchaddr = in_matroute;
+       rnh->rnh_matchaddr = in_matchroute;
        rnh->rnh_close = in_clsroute;
        callout_init(&in_rtqtimo_ch);
        in_rtqtimo(rnh);        /* kick off timeout first time */
index de535d7..ad94316 100644 (file)
@@ -1,5 +1,5 @@
 /*     $FreeBSD: src/sys/netinet6/in6_rmx.c,v 1.1.2.3 2002/04/28 05:40:27 suz Exp $    */
-/*     $DragonFly: src/sys/netinet6/in6_rmx.c,v 1.6 2004/09/16 23:06:42 joerg Exp $    */
+/*     $DragonFly: src/sys/netinet6/in6_rmx.c,v 1.7 2004/12/14 18:46:08 hsu Exp $      */
 /*     $KAME: in6_rmx.c,v 1.11 2001/07/26 06:53:16 jinmei Exp $        */
 
 /*
@@ -111,7 +111,7 @@ extern int  in6_inithead (void **head, int off);
  * Do what we need to do when inserting a route.
  */
 static struct radix_node *
-in6_addroute(void *v_arg, void *n_arg, struct radix_node_head *head,
+in6_addroute(char *key, char *mask, struct radix_node_head *head,
             struct radix_node *treenodes)
 {
        struct rtentry *rt = (struct rtentry *)treenodes;
@@ -150,11 +150,11 @@ in6_addroute(void *v_arg, void *n_arg, struct radix_node_head *head,
                }
        }
 
-       if (!rt->rt_rmx.rmx_mtu && !(rt->rt_rmx.rmx_locks & RTV_MTU)
-           && rt->rt_ifp)
+       if (!rt->rt_rmx.rmx_mtu && !(rt->rt_rmx.rmx_locks & RTV_MTU) &&
+           rt->rt_ifp != NULL)
                rt->rt_rmx.rmx_mtu = rt->rt_ifp->if_mtu;
 
-       ret = rn_addroute(v_arg, n_arg, head, treenodes);
+       ret = rn_addroute(key, mask, head, treenodes);
        if (ret == NULL && rt->rt_flags & RTF_HOST) {
                struct rtentry *rt2;
                /*
@@ -164,7 +164,7 @@ in6_addroute(void *v_arg, void *n_arg, struct radix_node_head *head,
                 */
                rt2 = rtalloc1((struct sockaddr *)sin6, 0,
                                RTF_CLONING | RTF_PRCLONING);
-               if (rt2) {
+               if (rt2 != NULL) {
                        if (rt2->rt_flags & RTF_LLINFO &&
                                rt2->rt_flags & RTF_HOST &&
                                rt2->rt_gateway &&
@@ -173,13 +173,14 @@ in6_addroute(void *v_arg, void *n_arg, struct radix_node_head *head,
                                          (struct sockaddr *)rt_key(rt2),
                                          rt2->rt_gateway,
                                          rt_mask(rt2), rt2->rt_flags, 0);
-                               ret = rn_addroute(v_arg, n_arg, head,
+                               ret = rn_addroute(key, mask, head,
                                        treenodes);
                        }
                        RTFREE(rt2);
                }
        } else if (ret == NULL && rt->rt_flags & RTF_CLONING) {
                struct rtentry *rt2;
+
                /*
                 * We are trying to add a net route, but can't.
                 * The following case should be allowed, so we'll make a
@@ -193,13 +194,13 @@ in6_addroute(void *v_arg, void *n_arg, struct radix_node_head *head,
                 *      This case should not raise an error.
                 */
                rt2 = rtalloc1((struct sockaddr *)sin6, 0,
-                               RTF_CLONING | RTF_PRCLONING);
-               if (rt2) {
+                              RTF_CLONING | RTF_PRCLONING);
+               if (rt2 != NULL) {
                        if ((rt2->rt_flags & (RTF_CLONING|RTF_HOST|RTF_GATEWAY))
-                                       == RTF_CLONING
-                        && rt2->rt_gateway
-                        && rt2->rt_gateway->sa_family == AF_LINK
-                        && rt2->rt_ifp == rt->rt_ifp) {
+                                       == RTF_CLONING &&
+                           rt2->rt_gateway &&
+                           rt2->rt_gateway->sa_family == AF_LINK &&
+                           rt2->rt_ifp == rt->rt_ifp) {
                                ret = rt2->rt_nodes;
                        }
                        RTFREE(rt2);
@@ -214,12 +215,12 @@ in6_addroute(void *v_arg, void *n_arg, struct radix_node_head *head,
  * back off again.
  */
 static struct radix_node *
-in6_matroute(void *v_arg, struct radix_node_head *head)
+in6_matchroute(char *key, struct radix_node_head *head)
 {
-       struct radix_node *rn = rn_match(v_arg, head);
+       struct radix_node *rn = rn_match(key, head);
        struct rtentry *rt = (struct rtentry *)rn;
 
-       if (rt && rt->rt_refcnt == 0) { /* this is first reference */
+       if (rt != NULL && rt->rt_refcnt == 0) { /* this is first reference */
                if (rt->rt_flags & RTPRF_OURS) {
                        rt->rt_flags &= ~RTPRF_OURS;
                        rt->rt_rmx.rmx_expire = 0;
@@ -476,7 +477,7 @@ in6_inithead(void **head, int off)
 
        rnh = *head;
        rnh->rnh_addaddr = in6_addroute;
-       rnh->rnh_matchaddr = in6_matroute;
+       rnh->rnh_matchaddr = in6_matchroute;
        rnh->rnh_close = in6_clsroute;
        callout_init(&in6_mtutimo_ch);
        callout_init(&in6_rtqtimo_ch);
index a6febee..0fc6b5c 100644 (file)
@@ -1,5 +1,5 @@
 /*     $FreeBSD: src/sys/netinet6/nd6.c,v 1.2.2.15 2003/05/06 06:46:58 suz Exp $       */
-/*     $DragonFly: src/sys/netinet6/nd6.c,v 1.10 2004/09/17 00:07:27 dillon Exp $      */
+/*     $DragonFly: src/sys/netinet6/nd6.c,v 1.11 2004/12/14 18:46:08 hsu Exp $ */
 /*     $KAME: nd6.c,v 1.144 2001/05/24 07:44:00 itojun Exp $   */
 
 /*
@@ -1200,7 +1200,7 @@ nd6_rtrequest(int req, struct rtentry *rt,
                }
                nd6_inuse++;
                nd6_allocated++;
-               Bzero(ln, sizeof(*ln));
+               bzero(ln, sizeof(*ln));
                ln->ln_rt = rt;
                /* this is required for "ndp" command. - shin */
                if (req == RTM_ADD) {
@@ -1237,7 +1237,7 @@ nd6_rtrequest(int req, struct rtentry *rt,
                        ln->ln_state = ND6_LLINFO_REACHABLE;
                        ln->ln_byhint = 0;
                        if (macp) {
-                               Bcopy(macp, LLADDR(SDL(gate)), ifp->if_addrlen);
+                               bcopy(macp, LLADDR(SDL(gate)), ifp->if_addrlen);
                                SDL(gate)->sdl_alen = ifp->if_addrlen;
                        }
                        if (nd6_useloopback) {
index 4b1b8cd..da539ea 100644 (file)
@@ -1,5 +1,5 @@
 /*     $FreeBSD: src/sys/netinet6/nd6_rtr.c,v 1.2.2.5 2003/04/05 10:28:53 ume Exp $    */
-/*     $DragonFly: src/sys/netinet6/nd6_rtr.c,v 1.4 2004/07/23 14:14:30 joerg Exp $    */
+/*     $DragonFly: src/sys/netinet6/nd6_rtr.c,v 1.5 2004/12/14 18:46:08 hsu Exp $      */
 /*     $KAME: nd6_rtr.c,v 1.111 2001/04/27 01:37:15 jinmei Exp $       */
 
 /*
@@ -468,9 +468,9 @@ defrouter_addreq(new)
        struct rtentry *newrt = NULL;
        int s;
 
-       Bzero(&def, sizeof(def));
-       Bzero(&mask, sizeof(mask));
-       Bzero(&gate, sizeof(gate));
+       bzero(&def, sizeof(def));
+       bzero(&mask, sizeof(mask));
+       bzero(&gate, sizeof(gate));
 
        def.sin6_len = mask.sin6_len = gate.sin6_len
                = sizeof(struct sockaddr_in6);
@@ -560,9 +560,9 @@ defrouter_delreq(dr, dofree)
        struct sockaddr_in6 def, mask, gate;
        struct rtentry *oldrt = NULL;
 
-       Bzero(&def, sizeof(def));
-       Bzero(&mask, sizeof(mask));
-       Bzero(&gate, sizeof(gate));
+       bzero(&def, sizeof(def));
+       bzero(&mask, sizeof(mask));
+       bzero(&gate, sizeof(gate));
 
        def.sin6_len = mask.sin6_len = gate.sin6_len
                = sizeof(struct sockaddr_in6);
index ca8db3a..952778a 100644 (file)
@@ -27,6 +27,7 @@
  * SUCH DAMAGE.
  *
  * at_rmx.c,v 1.13 1995/05/30 08:09:31 rgrimes Exp
+ * $DragonFly: src/sys/netproto/atalk/at_rmx.c,v 1.2 2004/12/14 18:46:58 hsu Exp $
  */
 
 /* This code generates debugging traces to the radix code */
@@ -67,17 +68,17 @@ prsockaddr(void *v)
 }
 
 static struct radix_node *
-at_addroute(void *v_arg, void *n_arg, struct radix_node_head *head,
+at_addroute(char *key, char *mask, struct radix_node_head *head,
            struct radix_node *treenodes)
 {
        struct radix_node *rn;
 
-       printf("at_addroute: v=%s\n", prsockaddr(v_arg));
-       printf("at_addroute: n=%s\n", prsockaddr(n_arg));
+       printf("at_addroute: v=%s\n", prsockaddr(key));
+       printf("at_addroute: n=%s\n", prsockaddr(mask));
        printf("at_addroute: head=%p treenodes=%p\n",
            (void *)head, (void *)treenodes);
 
-       rn = rn_addroute(v_arg, n_arg, head, treenodes);
+       rn = rn_addroute(key, mask, head, treenodes);
 
        printf("at_addroute: returns rn=%p\n", (void *)rn);
 
@@ -85,14 +86,14 @@ at_addroute(void *v_arg, void *n_arg, struct radix_node_head *head,
 }
 
 static struct radix_node *
-at_matroute(void *v_arg, struct radix_node_head *head)
+at_matroute(char *key, struct radix_node_head *head)
 {
        struct radix_node *rn;
 
-       printf("at_matroute: v=%s\n", prsockaddr(v_arg));
+       printf("at_matroute: v=%s\n", prsockaddr(key));
        printf("at_matroute: head=%p\n", (void *)head);
 
-       rn = rn_match(v_arg, head);
+       rn = rn_match(key, head);
 
        printf("at_matroute: returnr rn=%p\n", (void *)rn);
 
@@ -100,15 +101,15 @@ at_matroute(void *v_arg, struct radix_node_head *head)
 }
 
 static struct radix_node *
-at_lookup(void *v_arg, void *m_arg, struct radix_node_head *head)
+at_lookup(char *key, char *mask, struct radix_node_head *head)
 {
        struct radix_node *rn;
 
-       printf("at_lookup: v=%s\n", prsockaddr(v_arg));
-       printf("at_lookup: n=%s\n", prsockaddr(m_arg));
+       printf("at_lookup: v=%s\n", prsockaddr(key));
+       printf("at_lookup: n=%s\n", prsockaddr(mask));
        printf("at_lookup: head=%p\n", (void *)head);
 
-       rn = rn_lookup(v_arg, m_arg, head);
+       rn = rn_lookup(key, mask, head);
 
        printf("at_lookup: returns rn=%p\n", (void *)rn);
 
@@ -116,15 +117,15 @@ at_lookup(void *v_arg, void *m_arg, struct radix_node_head *head)
 }
 
 static struct radix_node *  
-at_delroute(void *v_arg, void *netmask_arg, struct radix_node_head *head)
+at_delroute(char *key, char *netmask, struct radix_node_head *head)
 {
        struct radix_node *rn;
 
-       printf("at_delroute: v=%s\n", prsockaddr(v_arg));
-       printf("at_delroute: n=%s\n", prsockaddr(netmask_arg));
+       printf("at_delroute: v=%s\n", prsockaddr(key));
+       printf("at_delroute: n=%s\n", prsockaddr(netmask));
        printf("at_delroute: head=%p\n", (void *)head);
 
-       rn = rn_delete(v_arg, netmask_arg, head);
+       rn = rn_delete(key, netmask, head);
 
        printf("at_delroute: returns rn=%p\n", (void *)rn);
 
index 10c642b..10ec8c6 100644 (file)
@@ -32,7 +32,7 @@
  *
  *     @(#)domain.h    8.1 (Berkeley) 6/2/93
  * $FreeBSD: src/sys/sys/domain.h,v 1.14 1999/12/29 04:24:40 peter Exp $
- * $DragonFly: src/sys/sys/domain.h,v 1.3 2003/08/20 07:31:21 rob Exp $
+ * $DragonFly: src/sys/sys/domain.h,v 1.4 2004/12/14 18:46:08 hsu Exp $
  */
 
 #ifndef _SYS_DOMAIN_H_
@@ -50,16 +50,15 @@ struct      mbuf;
 struct domain {
        int     dom_family;             /* AF_xxx */
        char    *dom_name;
-       void    (*dom_init)             /* initialize domain data structures */
-               (void);
-       int     (*dom_externalize)      /* externalize access rights */
-               (struct mbuf *);
-       void    (*dom_dispose)          /* dispose of internalized rights */
-               (struct mbuf *);
-       struct  protosw *dom_protosw, *dom_protoswNPROTOSW;
+       void    (*dom_init)(void);      /* initialize domain data structures */
+       int     (*dom_externalize)(struct mbuf *);      /* externalize access
+                                                        * rights */
+       void    (*dom_dispose)(struct mbuf *);  /* dispose of internalized
+                                                * rights */
+       struct  protosw *dom_protosw;
+       struct  protosw *dom_protoswNPROTOSW;
        struct  domain *dom_next;
-       int     (*dom_rtattach)         /* initialize routing table */
-               (void **, int);
+       int     (*dom_rtattach)(void **, int);  /* initialize routing table */
        int     dom_rtoffset;           /* an arg to rtattach, in bits */
        int     dom_maxrtkey;           /* for routing layer */
 };