From: kostas <>
Date: Sun, 28 Dec 1997 01:15:29 +0000 (+0000)
Subject: Aligned to squid coding practice (xfree/xmalloc etc)
X-Git-Tag: SQUID_3_0_PRE1~4348
X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=a3aeddcad981fdb2d87586191d7e17c6483471e5;p=thirdparty%2Fsquid.git

Aligned to squid coding practice (xfree/xmalloc etc)
---

diff --git a/lib/radix.c b/lib/radix.c
index 341ff3164f..5965caa369 100644
--- a/lib/radix.c
+++ b/lib/radix.c
@@ -1,6 +1,37 @@
+
+/*
+ *
+ * DEBUG: section 53     Radix tree data structure implementation
+ * AUTHOR: NetBSD Derived
+ *
+ * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
+ * --------------------------------------------------------
+ *
+ *  Squid is the result of efforts by numerous individuals from the
+ *  Internet community.  Development is led by Duane Wessels of the
+ *  National Laboratory for Applied Network Research and funded by
+ *  the National Science Foundation.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *  
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *  
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *  
+ */
+
+
 /*
  * Copyright (c) 1988, 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
+ *      The Regents of the University of California.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -12,8 +43,8 @@
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
+ *      This product includes software developed by the University of
+ *      California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
@@ -30,35 +61,61 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- *	@(#)radix.c	8.4 (Berkeley) 11/2/94
+ *      @(#)radix.c     8.4 (Berkeley) 11/2/94
  */
 
-/*
- * Routines to build and maintain radix trees for routing lookups.
- */
 #include "config.h"
 
-#ifndef _RADIX_H_
-#include <stdio.h>
-#include <sys/param.h>
-#define	M_DONTWAIT M_NOWAIT
+#if HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#if HAVE_STDLIB_H
 #include <stdlib.h>
-#include <radix.h>
-#ifdef HAVE_STRING_H
-#include <string.h>
 #endif
+#if HAVE_STDIO_H
+#include <stdio.h>
+#endif
+#if HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#if HAVE_CTYPE_H
+#include <ctype.h>
+#endif
+#if HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#if HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#if HAVE_GRP_H
+#include <grp.h>
 #endif
+#if HAVE_GNUMALLOC_H
+#include <gnumalloc.h>
+#elif HAVE_MALLOC_H && !defined(_SQUID_FREEBSD_) && !defined(_SQUID_NEXT_)
+#include <malloc.h>
+#endif
+#if HAVE_MEMORY_H
+#include <memory.h>
+#endif
+#if HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+#include "util.h"
+
+#include "radix.h"
 
-int	max_keylen;
+int max_keylen;
 struct radix_mask *rn_mkfreelist;
 struct radix_node_head *mask_rnhead;
 static char *addmask_key;
-static char normal_chars[] = {0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, -1};
+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))
+#define Bcmp(a, b, l) (l == 0 ? 0 : memcmp((caddr_t)(a), (caddr_t)(b), (u_long)l))
 /*
  * The data structure for the keys is a radix tree with one way
  * branching removed.  The index rn_b at an internal node n represents a bit
@@ -95,804 +152,860 @@ static char *rn_zeros, *rn_ones;
 
 struct radix_node *
 rn_search(v_arg, head)
-	void *v_arg;
-	struct radix_node *head;
+     void *v_arg;
+     struct radix_node *head;
 {
-	register struct radix_node *x;
-	register caddr_t v;
-
-	for (x = head, v = v_arg; x->rn_b >= 0;) {
-		if (x->rn_bmask & v[x->rn_off])
-			x = x->rn_r;
-		else
-			x = x->rn_l;
-	}
-	return (x);
+    register struct radix_node *x;
+    register caddr_t v;
+
+    for (x = head, v = v_arg; x->rn_b >= 0;) {
+	if (x->rn_bmask & v[x->rn_off])
+	    x = x->rn_r;
+	else
+	    x = x->rn_l;
+    }
+    return (x);
 };
 
 struct radix_node *
 rn_search_m(v_arg, head, m_arg)
-	struct radix_node *head;
-	void *v_arg, *m_arg;
+     struct radix_node *head;
+     void *v_arg, *m_arg;
 {
-	register struct radix_node *x;
-	register caddr_t v = v_arg, m = m_arg;
-
-	for (x = head; x->rn_b >= 0;) {
-		if ((x->rn_bmask & m[x->rn_off]) &&
-		    (x->rn_bmask & v[x->rn_off]))
-			x = x->rn_r;
-		else
-			x = x->rn_l;
-	}
-	return x;
+    register struct radix_node *x;
+    register caddr_t v = v_arg, m = m_arg;
+
+    for (x = head; x->rn_b >= 0;) {
+	if ((x->rn_bmask & m[x->rn_off]) &&
+	    (x->rn_bmask & v[x->rn_off]))
+	    x = x->rn_r;
+	else
+	    x = x->rn_l;
+    }
+    return x;
 };
 
 int
 rn_refines(m_arg, n_arg)
-	void *m_arg, *n_arg;
+     void *m_arg, *n_arg;
 {
-	register caddr_t m = m_arg, n = n_arg;
-	register caddr_t lim, lim2 = lim = n + *(u_char *)n;
-	int longer = (*(u_char *)n++) - (int)(*(u_char *)m++);
-	int masks_are_equal = 1;
-
-	if (longer > 0)
-		lim -= longer;
-	while (n < lim) {
-		if (*n & ~(*m))
-			return 0;
-		if (*n++ != *m++)
-			masks_are_equal = 0;
-	}
-	while (n < lim2)
-		if (*n++)
-			return 0;
-	if (masks_are_equal && (longer < 0))
-		for (lim2 = m - longer; m < lim2; )
-			if (*m++)
-				return 1;
-	return (!masks_are_equal);
+    register caddr_t m = m_arg, n = n_arg;
+    register caddr_t lim, lim2 = lim = n + *(u_char *) n;
+    int longer = (*(u_char *) n++) - (int) (*(u_char *) m++);
+    int masks_are_equal = 1;
+
+    if (longer > 0)
+	lim -= longer;
+    while (n < lim) {
+	if (*n & ~(*m))
+	    return 0;
+	if (*n++ != *m++)
+	    masks_are_equal = 0;
+    }
+    while (n < lim2)
+	if (*n++)
+	    return 0;
+    if (masks_are_equal && (longer < 0))
+	for (lim2 = m - longer; m < lim2;)
+	    if (*m++)
+		return 1;
+    return (!masks_are_equal);
 }
 
 struct radix_node *
 rn_lookup(v_arg, m_arg, head)
-	void *v_arg, *m_arg;
-	struct radix_node_head *head;
+     void *v_arg, *m_arg;
+     struct radix_node_head *head;
 {
-	register struct radix_node *x;
-	caddr_t netmask = 0;
+    register struct radix_node *x;
+    caddr_t netmask = 0;
 
-	if (m_arg) {
-		if ((x = rn_addmask(m_arg, 1, head->rnh_treetop->rn_off)) == 0)
-			return (0);
-		netmask = x->rn_key;
-	}
-	x = rn_match(v_arg, head);
-	if (x && netmask) {
-		while (x && x->rn_mask != netmask)
-			x = x->rn_dupedkey;
-	}
-	return x;
+    if (m_arg) {
+	if ((x = rn_addmask(m_arg, 1, head->rnh_treetop->rn_off)) == 0)
+	    return (0);
+	netmask = x->rn_key;
+    }
+    x = rn_match(v_arg, head);
+    if (x && netmask) {
+	while (x && x->rn_mask != netmask)
+	    x = x->rn_dupedkey;
+    }
+    return x;
 }
 
 static
-int rn_satsifies_leaf(trial, leaf, skip)
-	char *trial;
-	register struct radix_node *leaf;
-	int skip;
+int 
+rn_satsifies_leaf(trial, leaf, skip)
+     char *trial;
+     register struct radix_node *leaf;
+     int skip;
 {
-	register char *cp = trial, *cp2 = leaf->rn_key, *cp3 = leaf->rn_mask;
-	char *cplim;
-	int length = min(*(u_char *)cp, *(u_char *)cp2);
-
-	if (cp3 == 0)
-		cp3 = rn_ones;
-	else
-		length = min(length, *(u_char *)cp3);
-	cplim = cp + length; cp3 += skip; cp2 += skip;
-	for (cp += skip; cp < cplim; cp++, cp2++, cp3++)
-		if ((*cp ^ *cp2) & *cp3)
-			return 0;
-	return 1;
+    register char *cp = trial, *cp2 = leaf->rn_key, *cp3 = leaf->rn_mask;
+    char *cplim;
+    int length = min(*(u_char *) cp, *(u_char *) cp2);
+
+    if (cp3 == 0)
+	cp3 = rn_ones;
+    else
+	length = min(length, *(u_char *) cp3);
+    cplim = cp + length;
+    cp3 += skip;
+    cp2 += skip;
+    for (cp += skip; cp < cplim; cp++, cp2++, cp3++)
+	if ((*cp ^ *cp2) & *cp3)
+	    return 0;
+    return 1;
 }
 
 struct radix_node *
 rn_match(v_arg, head)
-	void *v_arg;
-	struct radix_node_head *head;
+     void *v_arg;
+     struct radix_node_head *head;
 {
-	caddr_t v = v_arg;
-	register struct radix_node *t = head->rnh_treetop, *x;
-	register caddr_t cp = v, cp2;
-	caddr_t cplim;
-	struct radix_node *saved_t, *top = t;
-	int off = t->rn_off, vlen = *(u_char *)cp, matched_off;
-	register int test, b, rn_b;
-
-	/*
-	 * Open code rn_search(v, top) to avoid overhead of extra
-	 * subroutine call.
-	 */
-	for (; t->rn_b >= 0; ) {
-		if (t->rn_bmask & cp[t->rn_off])
-			t = t->rn_r;
-		else
-			t = t->rn_l;
-	}
-	/*
-	 * See if we match exactly as a host destination
-	 * or at least learn how many bits match, for normal mask finesse.
-	 *
-	 * It doesn't hurt us to limit how many bytes to check
-	 * to the length of the mask, since if it matches we had a genuine
-	 * match and the leaf we have is the most specific one anyway;
-	 * if it didn't match with a shorter length it would fail
-	 * 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;
-	for (; cp < cplim; cp++, cp2++)
-		if (*cp != *cp2)
-			goto on1;
-	/*
-	 * This extra grot is in case we are explicitly asked
-	 * to look up the default.  Ugh!
-	 */
-	if ((t->rn_flags & RNF_ROOT) && t->rn_dupedkey)
-		t = t->rn_dupedkey;
-	return t;
-on1:
-	test = (*cp ^ *cp2) & 0xff; /* find first bit that differs */
-	for (b = 7; (test >>= 1) > 0;)
-		b--;
-	matched_off = cp - v;
-	b += matched_off << 3;
-	rn_b = -1 - b;
+    caddr_t v = v_arg;
+    register struct radix_node *t = head->rnh_treetop, *x;
+    register caddr_t cp = v, cp2;
+    caddr_t cplim;
+    struct radix_node *saved_t, *top = t;
+    int off = t->rn_off, vlen = *(u_char *) cp, matched_off;
+    register int test, b, rn_b;
+
+    /*
+     * Open code rn_search(v, top) to avoid overhead of extra
+     * subroutine call.
+     */
+    for (; t->rn_b >= 0;) {
+	if (t->rn_bmask & cp[t->rn_off])
+	    t = t->rn_r;
+	else
+	    t = t->rn_l;
+    }
+    /*
+     * See if we match exactly as a host destination
+     * or at least learn how many bits match, for normal mask finesse.
+     *
+     * It doesn't hurt us to limit how many bytes to check
+     * to the length of the mask, since if it matches we had a genuine
+     * match and the leaf we have is the most specific one anyway;
+     * if it didn't match with a shorter length it would fail
+     * 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;
+    for (; cp < cplim; cp++, cp2++)
+	if (*cp != *cp2)
+	    goto on1;
+    /*
+     * This extra grot is in case we are explicitly asked
+     * to look up the default.  Ugh!
+     */
+    if ((t->rn_flags & RNF_ROOT) && t->rn_dupedkey)
+	t = t->rn_dupedkey;
+    return t;
+  on1:
+    test = (*cp ^ *cp2) & 0xff;	/* find first bit that differs */
+    for (b = 7; (test >>= 1) > 0;)
+	b--;
+    matched_off = cp - v;
+    b += matched_off << 3;
+    rn_b = -1 - b;
+    /*
+     * If there is a host route in a duped-key chain, it will be first.
+     */
+    if ((saved_t = t)->rn_mask == 0)
+	t = t->rn_dupedkey;
+    for (; t; t = t->rn_dupedkey)
 	/*
-	 * If there is a host route in a duped-key chain, it will be first.
+	 * Even if we don't match exactly as a host,
+	 * we may match if the leaf we wound up at is
+	 * a route to a net.
 	 */
-	if ((saved_t = t)->rn_mask == 0)
-		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
-		 * a route to a net.
-		 */
-		if (t->rn_flags & RNF_NORMAL) {
-			if (rn_b <= t->rn_b)
-				return t;
-		} else if (rn_satsifies_leaf(v, t, matched_off))
-				return t;
-	t = saved_t;
-	/* start searching up the tree */
-	do {
-		register struct radix_mask *m;
-		t = t->rn_p;
-		if ((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".
-			 */
-			do {
-				if (m->rm_flags & RNF_NORMAL) {
-					if (rn_b <= m->rm_b)
-						return (m->rm_leaf);
-				} else {
-					off = min(t->rn_off, matched_off);
-					x = rn_search_m(v, t, m->rm_mask);
-					while (x && x->rn_mask != m->rm_mask)
-						x = x->rn_dupedkey;
-					if (x && rn_satsifies_leaf(v, x, off))
-						    return x;
-				}
-			} while ((m = m->rm_mklist));
+	if (t->rn_flags & RNF_NORMAL) {
+	    if (rn_b <= t->rn_b)
+		return t;
+	} else if (rn_satsifies_leaf(v, t, matched_off))
+	    return t;
+    t = saved_t;
+    /* start searching up the tree */
+    do {
+	register struct radix_mask *m;
+	t = t->rn_p;
+	if ((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".
+	     */
+	    do {
+		if (m->rm_flags & RNF_NORMAL) {
+		    if (rn_b <= m->rm_b)
+			return (m->rm_leaf);
+		} else {
+		    off = min(t->rn_off, matched_off);
+		    x = rn_search_m(v, t, m->rm_mask);
+		    while (x && x->rn_mask != m->rm_mask)
+			x = x->rn_dupedkey;
+		    if (x && rn_satsifies_leaf(v, x, off))
+			return x;
 		}
-	} while (t != top);
-	return 0;
+	    } while ((m = m->rm_mklist));
+	}
+    } while (t != top);
+    return 0;
 };
-		
+
 #ifdef RN_DEBUG
-int	rn_nodenum;
-struct	radix_node *rn_clist;
-int	rn_saveinfo;
-int	rn_debug =  1;
+int rn_nodenum;
+struct radix_node *rn_clist;
+int rn_saveinfo;
+int rn_debug = 1;
 #endif
 
 struct radix_node *
 rn_newpair(v, b, nodes)
-	void *v;
-	int b;
-	struct radix_node nodes[2];
+     void *v;
+     int b;
+     struct radix_node nodes[2];
 {
-	register struct radix_node *tt = nodes, *t = tt + 1;
-	t->rn_b = b; t->rn_bmask = 0x80 >> (b & 7);
-	t->rn_l = tt; t->rn_off = b >> 3;
-	tt->rn_b = -1; tt->rn_key = (caddr_t)v; tt->rn_p = t;
-	tt->rn_flags = t->rn_flags = RNF_ACTIVE;
+    register struct radix_node *tt = nodes, *t = tt + 1;
+    t->rn_b = b;
+    t->rn_bmask = 0x80 >> (b & 7);
+    t->rn_l = tt;
+    t->rn_off = b >> 3;
+    tt->rn_b = -1;
+    tt->rn_key = (caddr_t) v;
+    tt->rn_p = t;
+    tt->rn_flags = t->rn_flags = RNF_ACTIVE;
 #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;
+    tt->rn_info = rn_nodenum++;
+    t->rn_info = rn_nodenum++;
+    tt->rn_twin = t;
+    tt->rn_ybro = rn_clist;
+    rn_clist = tt;
 #endif
-	return t;
+    return t;
 }
 
 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];
+     void *v_arg;
+     struct radix_node_head *head;
+     int *dupentry;
+     struct radix_node nodes[2];
 {
-	caddr_t v = v_arg;
-	struct radix_node *top = head->rnh_treetop;
-	int head_off = top->rn_off, vlen = (int)*((u_char *)v);
-	register struct radix_node *t = rn_search(v_arg, top);
-	register caddr_t cp = v + head_off;
-	register int b;
-	struct radix_node *tt;
-    	/*
-	 * Find first bit at which v and t->rn_key differ
-	 */
+    caddr_t v = v_arg;
+    struct radix_node *top = head->rnh_treetop;
+    int head_off = top->rn_off, vlen = (int) *((u_char *) v);
+    register struct radix_node *t = rn_search(v_arg, top);
+    register caddr_t cp = v + head_off;
+    register int b;
+    struct radix_node *tt;
+    /*
+     * Find first bit at which v and t->rn_key differ
+     */
     {
 	register caddr_t cp2 = t->rn_key + head_off;
 	register int cmp_res;
 	caddr_t cplim = v + vlen;
 
 	while (cp < cplim)
-		if (*cp2++ != *cp++)
-			goto on1;
+	    if (*cp2++ != *cp++)
+		goto on1;
 	*dupentry = 1;
 	return t;
-on1:
+      on1:
 	*dupentry = 0;
 	cmp_res = (cp[-1] ^ cp2[-1]) & 0xff;
 	for (b = (cp - v) << 3; cmp_res; b--)
-		cmp_res >>= 1;
+	    cmp_res >>= 1;
     }
     {
 	register struct radix_node *p, *x = top;
 	cp = v;
 	do {
-		p = x;
-		if (cp[x->rn_off] & x->rn_bmask) 
-			x = x->rn_r;
-		else x = x->rn_l;
-	} while (b > (unsigned) x->rn_b); /* x->rn_b < b && x->rn_b >= 0 */
+	    p = x;
+	    if (cp[x->rn_off] & x->rn_bmask)
+		x = x->rn_r;
+	    else
+		x = x->rn_l;
+	} while (b > (unsigned) x->rn_b);	/* x->rn_b < b && x->rn_b >= 0 */
 #ifdef RN_DEBUG
 	if (rn_debug)
-		fprintf(stderr, "rn_insert: Going In:\n"); traverse(p);
+	    fprintf(stderr, "rn_insert: Going In:\n");
+	traverse(p);
 #endif
-	t = rn_newpair(v_arg, b, nodes); tt = t->rn_l;
+	t = rn_newpair(v_arg, b, nodes);
+	tt = t->rn_l;
 	if ((cp[p->rn_off] & p->rn_bmask) == 0)
-		p->rn_l = t;
+	    p->rn_l = t;
 	else
-		p->rn_r = t;
-	x->rn_p = t; t->rn_p = p; /* frees x, p as temp vars below */
+	    p->rn_r = t;
+	x->rn_p = t;
+	t->rn_p = p;		/* frees x, p as temp vars below */
 	if ((cp[t->rn_off] & t->rn_bmask) == 0) {
-		t->rn_r = x;
+	    t->rn_r = x;
 	} else {
-		t->rn_r = tt; t->rn_l = x;
+	    t->rn_r = tt;
+	    t->rn_l = x;
 	}
 #ifdef RN_DEBUG
 	if (rn_debug)
-		log(LOG_DEBUG, "rn_insert: Coming Out:\n"), traverse(p);
+	    log(LOG_DEBUG, "rn_insert: Coming Out:\n"), traverse(p);
 #endif
     }
-	return (tt);
+    return (tt);
 }
 
 struct radix_node *
 rn_addmask(n_arg, search, skip)
-	int search, skip;
-	void *n_arg;
+     int search, skip;
+     void *n_arg;
 {
-	caddr_t netmask = (caddr_t)n_arg;
-	register struct radix_node *x;
-	register caddr_t cp, cplim;
-	register int b = 0, mlen, j;
-	int maskduplicated, m0, isnormal;
-	struct radix_node *saved_x;
-	static int last_zeroed = 0;
-
-	if ((mlen = *(u_char *)netmask) > max_keylen)
-		mlen = max_keylen;
-	if (skip == 0)
-		skip = 1;
-	if (mlen <= skip)
-		return (mask_rnhead->rnh_nodes);
-	if (skip > 1)
-		memcpy(addmask_key+1,rn_ones + 1, skip - 1);
-	if ((m0 = mlen) > skip)
-		memcpy(addmask_key + skip, netmask + skip,  mlen - skip);
-	/*
-	 * Trim trailing zeroes.
-	 */
-	for (cp = addmask_key + mlen; (cp > addmask_key) && cp[-1] == 0;)
-		cp--;
-	mlen = cp - addmask_key;
-	if (mlen <= skip) {
-		if (m0 >= last_zeroed)
-			last_zeroed = mlen;
-		return (mask_rnhead->rnh_nodes);
-	}
-	if (m0 < last_zeroed)
-		memset( addmask_key + m0,'\0',  last_zeroed - m0);
-	*addmask_key = last_zeroed = mlen;
-	x = rn_search(addmask_key, rn_masktop);
-	if (memcmp(addmask_key, x->rn_key, mlen) != 0)
-		x = 0;
-	if (x || search)
-		return (x);
-	R_Malloc(x, struct radix_node *, max_keylen + 2 * sizeof (*x));
-	if ((saved_x = x) == 0)
-		return (0);
-	memset(x,'\0', max_keylen + 2 * sizeof (*x));
-	netmask = cp = (caddr_t)(x + 2);
-	memcpy(cp,addmask_key, mlen);
-	x = rn_insert(cp, mask_rnhead, &maskduplicated, x);
-	if (maskduplicated) {
-		fprintf(stderr, "rn_addmask: mask impossibly already in tree");
-		Free(saved_x);
-		return (x);
-	}
-	/*
-	 * Calculate index of mask, and check for normalcy.
-	 */
-	cplim = netmask + mlen; isnormal = 1;
-	for (cp = netmask + skip; (cp < cplim) && *(u_char *)cp == 0xff;)
-		cp++;
-	if (cp != cplim) {
-		for (j = 0x80; (j & *cp) != 0; j >>= 1)  
-			b++;
-		if (*cp != normal_chars[b] || cp != (cplim - 1))
-			isnormal = 0;
-	}
-	b += (cp - netmask) << 3;
-	x->rn_b = -1 - b;
-	if (isnormal)
-		x->rn_flags |= RNF_NORMAL;
+    caddr_t netmask = (caddr_t) n_arg;
+    register struct radix_node *x;
+    register caddr_t cp, cplim;
+    register int b = 0, mlen, j;
+    int maskduplicated, m0, isnormal;
+    struct radix_node *saved_x;
+    static int last_zeroed = 0;
+
+    if ((mlen = *(u_char *) netmask) > max_keylen)
+	mlen = max_keylen;
+    if (skip == 0)
+	skip = 1;
+    if (mlen <= skip)
+	return (mask_rnhead->rnh_nodes);
+    if (skip > 1)
+	memcpy(addmask_key + 1, rn_ones + 1, skip - 1);
+    if ((m0 = mlen) > skip)
+	memcpy(addmask_key + skip, netmask + skip, mlen - skip);
+    /*
+     * Trim trailing zeroes.
+     */
+    for (cp = addmask_key + mlen; (cp > addmask_key) && cp[-1] == 0;)
+	cp--;
+    mlen = cp - addmask_key;
+    if (mlen <= skip) {
+	if (m0 >= last_zeroed)
+	    last_zeroed = mlen;
+	return (mask_rnhead->rnh_nodes);
+    }
+    if (m0 < last_zeroed)
+	memset(addmask_key + m0, '\0', last_zeroed - m0);
+    *addmask_key = last_zeroed = mlen;
+    x = rn_search(addmask_key, rn_masktop);
+    if (memcmp(addmask_key, x->rn_key, mlen) != 0)
+	x = 0;
+    if (x || search)
+	return (x);
+    R_Malloc(x, struct radix_node *, max_keylen + 2 * sizeof(*x));
+    if ((saved_x = x) == 0)
+	return (0);
+    memset(x, '\0', max_keylen + 2 * sizeof(*x));
+    netmask = cp = (caddr_t) (x + 2);
+    memcpy(cp, addmask_key, mlen);
+    x = rn_insert(cp, mask_rnhead, &maskduplicated, x);
+    if (maskduplicated) {
+	fprintf(stderr, "rn_addmask: mask impossibly already in tree");
+	Free(saved_x);
 	return (x);
+    }
+    /*
+     * Calculate index of mask, and check for normalcy.
+     */
+    cplim = netmask + mlen;
+    isnormal = 1;
+    for (cp = netmask + skip; (cp < cplim) && *(u_char *) cp == 0xff;)
+	cp++;
+    if (cp != cplim) {
+	for (j = 0x80; (j & *cp) != 0; j >>= 1)
+	    b++;
+	if (*cp != normal_chars[b] || cp != (cplim - 1))
+	    isnormal = 0;
+    }
+    b += (cp - netmask) << 3;
+    x->rn_b = -1 - b;
+    if (isnormal)
+	x->rn_flags |= RNF_NORMAL;
+    return (x);
 }
 
-static int	/* XXX: arbitrary ordering for non-contiguous masks */
+static int			/* XXX: arbitrary ordering for non-contiguous masks */
 rn_lexobetter(m_arg, n_arg)
-	void *m_arg, *n_arg;
+     void *m_arg, *n_arg;
 {
-	register u_char *mp = m_arg, *np = n_arg, *lim;
-
-	if (*mp > *np)
-		return 1;  /* not really, but need to check longer one first */
-	if (*mp == *np) 
-		for (lim = mp + *mp; mp < lim;)
-			if (*mp++ > *np++)
-				return 1;
-	return 0;
+    register u_char *mp = m_arg, *np = n_arg, *lim;
+
+    if (*mp > *np)
+	return 1;		/* not really, but need to check longer one first */
+    if (*mp == *np)
+	for (lim = mp + *mp; mp < lim;)
+	    if (*mp++ > *np++)
+		return 1;
+    return 0;
 }
 
 static struct radix_mask *
 rn_new_radix_mask(tt, next)
-	register struct radix_node *tt;
-	register struct radix_mask *next;
+     register struct radix_node *tt;
+     register struct radix_mask *next;
 {
-	register struct radix_mask *m;
+    register struct radix_mask *m;
 
-	MKGet(m);
-	if (m == 0) {
-		fprintf(stderr, "Mask for route not entered\n");
-		return (0);
-	}
-	memset(m,'\0', sizeof *m);
-	m->rm_b = tt->rn_b;
-	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;
-	tt->rn_mklist = m;
-	return m;
+    MKGet(m);
+    if (m == 0) {
+	fprintf(stderr, "Mask for route not entered\n");
+	return (0);
+    }
+    memset(m, '\0', sizeof *m);
+    m->rm_b = tt->rn_b;
+    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;
+    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];
+     void *v_arg, *n_arg;
+     struct radix_node_head *head;
+     struct radix_node treenodes[2];
 {
-	caddr_t v = (caddr_t)v_arg, netmask = (caddr_t)n_arg;
-	register 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;
-	struct radix_mask *m, **mp;
-
-	/*
-	 * In dealing with non-contiguous masks, there may be
-	 * many different routes which have the same mask.
-	 * We will find it useful to have a unique pointer to
-	 * 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_off)) == 0)
-			return (0);
-		b_leaf = x->rn_b;
-		b = -1 - x->rn_b;
-		netmask = x->rn_key;
+    caddr_t v = (caddr_t) v_arg, netmask = (caddr_t) n_arg;
+    register 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;
+    struct radix_mask *m, **mp;
+
+    /*
+     * In dealing with non-contiguous masks, there may be
+     * many different routes which have the same mask.
+     * We will find it useful to have a unique pointer to
+     * 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_off)) == 0)
+	    return (0);
+	b_leaf = x->rn_b;
+	b = -1 - x->rn_b;
+	netmask = x->rn_key;
+    }
+    /*
+     * Deal with duplicated keys: attach node to previous instance
+     */
+    saved_tt = tt = rn_insert(v, 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 ||
+		(tt->rn_mask &&
+		    ((b_leaf < tt->rn_b) ||	/* index(netmask) > node */
+			rn_refines(netmask, tt->rn_mask) ||
+			rn_lexobetter(netmask, tt->rn_mask))))
+		break;
 	}
 	/*
-	 * Deal with duplicated keys: attach node to previous instance
+	 * If the mask is not duplicated, we wouldn't
+	 * find it among possible duplicate key entries
+	 * anyway, so the above test doesn't hurt.
+	 *
+	 * We sort the masks for a duplicated key the same way as
+	 * in a masklist -- most specific to least specific.
+	 * This may require the unfortunate nuisance of relocating
+	 * the head of the list.
 	 */
-	saved_tt = tt = rn_insert(v, 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 ||
-			    (tt->rn_mask &&
-			     ((b_leaf < tt->rn_b) || /* index(netmask) > node */
-			       rn_refines(netmask, tt->rn_mask) ||
-			       rn_lexobetter(netmask, tt->rn_mask))))
-				break;
-		}
-		/*
-		 * If the mask is not duplicated, we wouldn't
-		 * find it among possible duplicate key entries
-		 * anyway, so the above test doesn't hurt.
-		 *
-		 * We sort the masks for a duplicated key the same way as
-		 * in a masklist -- most specific to least specific.
-		 * This may require the unfortunate nuisance of relocating
-		 * the head of the list.
-		 */
-		if (tt == saved_tt) {
-			struct	radix_node *xx = x;
-			/* link in at head of list */
-			(tt = treenodes)->rn_dupedkey = t;
-			tt->rn_flags = t->rn_flags;
-			tt->rn_p = x = t->rn_p;
-			if (x->rn_l == t) x->rn_l = tt; else x->rn_r = tt;
-			saved_tt = tt; x = xx;
-		} else {
-			(tt = treenodes)->rn_dupedkey = t->rn_dupedkey;
-			t->rn_dupedkey = tt;
-		}
+	if (tt == saved_tt) {
+	    struct radix_node *xx = x;
+	    /* link in at head of list */
+	    (tt = treenodes)->rn_dupedkey = t;
+	    tt->rn_flags = t->rn_flags;
+	    tt->rn_p = x = t->rn_p;
+	    if (x->rn_l == t)
+		x->rn_l = tt;
+	    else
+		x->rn_r = tt;
+	    saved_tt = tt;
+	    x = xx;
+	} else {
+	    (tt = treenodes)->rn_dupedkey = t->rn_dupedkey;
+	    t->rn_dupedkey = tt;
+	}
 #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;
+	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_b = -1;
-		tt->rn_flags = RNF_ACTIVE;
-	}
-	/*
-	 * Put mask in tree.
-	 */
-	if (netmask) {
-		tt->rn_mask = netmask;
-		tt->rn_b = x->rn_b;
-		tt->rn_flags |= x->rn_flags & RNF_NORMAL;
-	}
-	t = saved_tt->rn_p;
-	if (keyduplicated)
-		goto on2;
-	b_leaf = -1 - t->rn_b;
-	if (t->rn_r == saved_tt) x = t->rn_l; else x = t->rn_r;
-	/* Promote general routes from below */
-	if (x->rn_b < 0) { 
-	    for (mp = &t->rn_mklist; x; x = x->rn_dupedkey)
-		if (x->rn_mask && (x->rn_b >= b_leaf) && x->rn_mklist == 0) {
-			if ((*mp = m = rn_new_radix_mask(x, 0)))
-				mp = &m->rm_mklist;
-		}
-	} else if (x->rn_mklist) {
-		/*
-		 * Skip over masks whose index is > that of new node
-		 */
-		for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist)
-			if (m->rm_b >= b_leaf)
-				break;
-		t->rn_mklist = m; *mp = 0;
-	}
-on2:
-	/* Add new route to highest possible ancestor's list */
-	if ((netmask == 0) || (b > t->rn_b ))
-		return tt; /* can't lift at all */
-	b_leaf = tt->rn_b;
-	do {
-		x = t;
-		t = t->rn_p;
-	} while (b <= t->rn_b && x != top);
+	tt->rn_key = (caddr_t) v;
+	tt->rn_b = -1;
+	tt->rn_flags = RNF_ACTIVE;
+    }
+    /*
+     * Put mask in tree.
+     */
+    if (netmask) {
+	tt->rn_mask = netmask;
+	tt->rn_b = x->rn_b;
+	tt->rn_flags |= x->rn_flags & RNF_NORMAL;
+    }
+    t = saved_tt->rn_p;
+    if (keyduplicated)
+	goto on2;
+    b_leaf = -1 - t->rn_b;
+    if (t->rn_r == saved_tt)
+	x = t->rn_l;
+    else
+	x = t->rn_r;
+    /* Promote general routes from below */
+    if (x->rn_b < 0) {
+	for (mp = &t->rn_mklist; x; x = x->rn_dupedkey)
+	    if (x->rn_mask && (x->rn_b >= b_leaf) && x->rn_mklist == 0) {
+		if ((*mp = m = rn_new_radix_mask(x, 0)))
+		    mp = &m->rm_mklist;
+	    }
+    } else if (x->rn_mklist) {
 	/*
-	 * Search through routes associated with node to
-	 * insert new route according to index.
-	 * Need same criteria as when sorting dupedkeys to avoid
-	 * double loop on deletion.
+	 * Skip over masks whose index is > that of new node
 	 */
-	for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist) {
-		if (m->rm_b < b_leaf)
-			continue;
-		if (m->rm_b > b_leaf)
-			break;
-		if (m->rm_flags & RNF_NORMAL) {
-			mmask = m->rm_leaf->rn_mask;
-			if (tt->rn_flags & RNF_NORMAL) {
-				fprintf(stderr,
-				   "Non-unique normal route, mask not entered");
-				return tt;
-			}
-		} else
-			mmask = m->rm_mask;
-		if (mmask == netmask) {
-			m->rm_refs++;
-			tt->rn_mklist = m;
-			return tt;
-		}
-		if (rn_refines(netmask, mmask) || rn_lexobetter(netmask, mmask))
-			break;
+	for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist)
+	    if (m->rm_b >= b_leaf)
+		break;
+	t->rn_mklist = m;
+	*mp = 0;
+    }
+  on2:
+    /* Add new route to highest possible ancestor's list */
+    if ((netmask == 0) || (b > t->rn_b))
+	return tt;		/* can't lift at all */
+    b_leaf = tt->rn_b;
+    do {
+	x = t;
+	t = t->rn_p;
+    } while (b <= t->rn_b && x != top);
+    /*
+     * Search through routes associated with node to
+     * insert new route according to index.
+     * Need same criteria as when sorting dupedkeys to avoid
+     * double loop on deletion.
+     */
+    for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist) {
+	if (m->rm_b < b_leaf)
+	    continue;
+	if (m->rm_b > b_leaf)
+	    break;
+	if (m->rm_flags & RNF_NORMAL) {
+	    mmask = m->rm_leaf->rn_mask;
+	    if (tt->rn_flags & RNF_NORMAL) {
+		fprintf(stderr,
+		    "Non-unique normal route, mask not entered");
+		return tt;
+	    }
+	} else
+	    mmask = m->rm_mask;
+	if (mmask == netmask) {
+	    m->rm_refs++;
+	    tt->rn_mklist = m;
+	    return tt;
 	}
-	*mp = rn_new_radix_mask(tt, *mp);
-	return tt;
+	if (rn_refines(netmask, mmask) || rn_lexobetter(netmask, mmask))
+	    break;
+    }
+    *mp = rn_new_radix_mask(tt, *mp);
+    return tt;
 }
 
 struct radix_node *
 rn_delete(v_arg, netmask_arg, head)
-	void *v_arg, *netmask_arg;
-	struct radix_node_head *head;
+     void *v_arg, *netmask_arg;
+     struct radix_node_head *head;
 {
-	register 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;
-
-	v = v_arg;
-	netmask = netmask_arg;
-	x = head->rnh_treetop;
-	tt = rn_search(v, x);
-	head_off = x->rn_off;
-	vlen =  *(u_char *)v;
-	saved_tt = tt;
-	top = x;
-	if (tt == 0 ||
-	    memcmp(v + head_off, tt->rn_key + head_off, vlen - head_off))
+    register 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;
+
+    v = v_arg;
+    netmask = netmask_arg;
+    x = head->rnh_treetop;
+    tt = rn_search(v, x);
+    head_off = x->rn_off;
+    vlen = *(u_char *) v;
+    saved_tt = tt;
+    top = x;
+    if (tt == 0 ||
+	memcmp(v + head_off, tt->rn_key + head_off, vlen - head_off))
+	return (0);
+    /*
+     * Delete our route from mask lists.
+     */
+    if (netmask) {
+	if ((x = rn_addmask(netmask, 1, head_off)) == 0)
+	    return (0);
+	netmask = x->rn_key;
+	while (tt->rn_mask != netmask)
+	    if ((tt = tt->rn_dupedkey) == 0)
 		return (0);
-	/*
-	 * Delete our route from mask lists.
-	 */
-	if (netmask) {
-		if ((x = rn_addmask(netmask, 1, head_off)) == 0)
-			return (0);
-		netmask = x->rn_key;
-		while (tt->rn_mask != netmask)
-			if ((tt = tt->rn_dupedkey) == 0)
-				return (0);
+    }
+    if (tt->rn_mask == 0 || (saved_m = m = tt->rn_mklist) == 0)
+	goto on1;
+    if (tt->rn_flags & RNF_NORMAL) {
+	if (m->rm_leaf != tt || m->rm_refs > 0) {
+	    fprintf(stderr, "rn_delete: inconsistent annotation\n");
+	    return 0;		/* dangling ref could cause disaster */
 	}
-	if (tt->rn_mask == 0 || (saved_m = m = tt->rn_mklist) == 0)
-		goto on1;
-	if (tt->rn_flags & RNF_NORMAL) {
-		if (m->rm_leaf != tt || m->rm_refs > 0) {
-			fprintf(stderr, "rn_delete: inconsistent annotation\n");
-			return 0;  /* dangling ref could cause disaster */
-		}
-	} else { 
-		if (m->rm_mask != tt->rn_mask) {
-			fprintf(stderr, "rn_delete: inconsistent annotation\n");
-			goto on1;
-		}
-		if (--m->rm_refs >= 0)
-			goto on1;
+    } else {
+	if (m->rm_mask != tt->rn_mask) {
+	    fprintf(stderr, "rn_delete: inconsistent annotation\n");
+	    goto on1;
 	}
-	b = -1 - tt->rn_b;
-	t = saved_tt->rn_p;
-	if (b > t->rn_b)
-		goto on1; /* Wasn't lifted at all */
-	do {
-		x = t;
-		t = t->rn_p;
-	} while (b <= t->rn_b && x != top);
-	for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist)
-		if (m == saved_m) {
-			*mp = m->rm_mklist;
-			MKFree(m);
-			break;
-		}
-	if (m == 0) {
-		fprintf(stderr, "rn_delete: couldn't find our annotation\n");
-		if (tt->rn_flags & RNF_NORMAL)
-			return (0); /* Dangling ref to us */
+	if (--m->rm_refs >= 0)
+	    goto on1;
+    }
+    b = -1 - tt->rn_b;
+    t = saved_tt->rn_p;
+    if (b > t->rn_b)
+	goto on1;		/* Wasn't lifted at all */
+    do {
+	x = t;
+	t = t->rn_p;
+    } while (b <= t->rn_b && x != top);
+    for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist)
+	if (m == saved_m) {
+	    *mp = m->rm_mklist;
+	    MKFree(m);
+	    break;
 	}
-on1:
-	/*
-	 * Eliminate us from tree
-	 */
-	if (tt->rn_flags & RNF_ROOT)
-		return (0);
+    if (m == 0) {
+	fprintf(stderr, "rn_delete: couldn't find our annotation\n");
+	if (tt->rn_flags & RNF_NORMAL)
+	    return (0);		/* Dangling ref to us */
+    }
+  on1:
+    /*
+     * Eliminate us from tree
+     */
+    if (tt->rn_flags & RNF_ROOT)
+	return (0);
 #ifdef RN_DEBUG
-	/* Get us out of the creation list */
-	for (t = rn_clist; t && t->rn_ybro != tt; t = t->rn_ybro) {}
-	if (t) t->rn_ybro = tt->rn_ybro;
+    /* Get us out of the creation list */
+    for (t = rn_clist; t && t->rn_ybro != tt; t = t->rn_ybro) {
+    }
+    if (t)
+	t->rn_ybro = tt->rn_ybro;
 #endif
-	t = tt->rn_p;
-	if ((dupedkey = saved_tt->rn_dupedkey)) {
-		if (tt == saved_tt) {
-			x = dupedkey; x->rn_p = t;
-			if (t->rn_l == tt) t->rn_l = x; else t->rn_r = x;
-		} else {
-			for (x = p = saved_tt; p && p->rn_dupedkey != tt;)
-				p = p->rn_dupedkey;
-			if (p) p->rn_dupedkey = tt->rn_dupedkey;
-			else fprintf(stderr, "rn_delete: couldn't find us\n");
-		}
-		t = tt + 1;
-		if  (t->rn_flags & RNF_ACTIVE) {
+    t = tt->rn_p;
+    if ((dupedkey = saved_tt->rn_dupedkey)) {
+	if (tt == saved_tt) {
+	    x = dupedkey;
+	    x->rn_p = t;
+	    if (t->rn_l == tt)
+		t->rn_l = x;
+	    else
+		t->rn_r = x;
+	} else {
+	    for (x = p = saved_tt; p && p->rn_dupedkey != tt;)
+		p = p->rn_dupedkey;
+	    if (p)
+		p->rn_dupedkey = tt->rn_dupedkey;
+	    else
+		fprintf(stderr, "rn_delete: couldn't find us\n");
+	}
+	t = tt + 1;
+	if (t->rn_flags & RNF_ACTIVE) {
 #ifndef RN_DEBUG
-			*++x = *t; p = t->rn_p;
+	    *++x = *t;
+	    p = t->rn_p;
 #else
-			b = t->rn_info; *++x = *t; t->rn_info = b; p = t->rn_p;
+	    b = t->rn_info;
+	    *++x = *t;
+	    t->rn_info = b;
+	    p = t->rn_p;
 #endif
-			if (p->rn_l == t) p->rn_l = x; else p->rn_r = x;
-			x->rn_l->rn_p = x; x->rn_r->rn_p = x;
-		}
-		goto out;
+	    if (p->rn_l == t)
+		p->rn_l = x;
+	    else
+		p->rn_r = x;
+	    x->rn_l->rn_p = x;
+	    x->rn_r->rn_p = x;
 	}
-	if (t->rn_l == tt) x = t->rn_r; else x = t->rn_l;
-	p = t->rn_p;
-	if (p->rn_r == t) p->rn_r = x; else p->rn_l = x;
-	x->rn_p = p;
-	/*
-	 * Demote routes attached to us.
-	 */
-	if (t->rn_mklist) {
-		if (x->rn_b >= 0) {
-			for (mp = &x->rn_mklist; (m = *mp);)
-				mp = &m->rm_mklist;
-			*mp = t->rn_mklist;
-		} else {
-			/* If there are any key,mask pairs in a sibling
-			   duped-key chain, some subset will appear sorted
-			   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;
-					if (--(m->rm_refs) < 0)
-						MKFree(m);
-					m = mm;
-				}
-			if (m)
-				fprintf(stderr, "%s %x at %x\n",
-					    "rn_delete: Orphaned Mask", (int)m, (int)x);
+	goto out;
+    }
+    if (t->rn_l == tt)
+	x = t->rn_r;
+    else
+	x = t->rn_l;
+    p = t->rn_p;
+    if (p->rn_r == t)
+	p->rn_r = x;
+    else
+	p->rn_l = x;
+    x->rn_p = p;
+    /*
+     * Demote routes attached to us.
+     */
+    if (t->rn_mklist) {
+	if (x->rn_b >= 0) {
+	    for (mp = &x->rn_mklist; (m = *mp);)
+		mp = &m->rm_mklist;
+	    *mp = t->rn_mklist;
+	} else {
+	    /* If there are any key,mask pairs in a sibling
+	     * duped-key chain, some subset will appear sorted
+	     * 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;
+		    if (--(m->rm_refs) < 0)
+			MKFree(m);
+		    m = mm;
 		}
+	    if (m)
+		fprintf(stderr, "%s %x at %x\n",
+		    "rn_delete: Orphaned Mask", (int) m, (int) x);
 	}
-	/*
-	 * We may be holding an active internal node in the tree.
-	 */
-	x = tt + 1;
-	if (t != x) {
+    }
+    /*
+     * We may be holding an active internal node in the tree.
+     */
+    x = tt + 1;
+    if (t != x) {
 #ifndef RN_DEBUG
-		*t = *x;
+	*t = *x;
 #else
-		b = t->rn_info; *t = *x; t->rn_info = b;
+	b = t->rn_info;
+	*t = *x;
+	t->rn_info = b;
 #endif
-		t->rn_l->rn_p = t; t->rn_r->rn_p = t;
-		p = x->rn_p;
-		if (p->rn_l == x) p->rn_l = t; else p->rn_r = t;
-	}
-out:
-	tt->rn_flags &= ~RNF_ACTIVE;
-	tt[1].rn_flags &= ~RNF_ACTIVE;
-	return (tt);
+	t->rn_l->rn_p = t;
+	t->rn_r->rn_p = t;
+	p = x->rn_p;
+	if (p->rn_l == x)
+	    p->rn_l = t;
+	else
+	    p->rn_r = t;
+    }
+  out:
+    tt->rn_flags &= ~RNF_ACTIVE;
+    tt[1].rn_flags &= ~RNF_ACTIVE;
+    return (tt);
 }
 
 int
 rn_walktree(h, f, w)
-	struct radix_node_head *h;
-	register int (*f)();
-	void *w;
+     struct radix_node_head *h;
+     int (*f) ();
+     void *w;
 {
-	int error;
-	struct radix_node *base, *next;
-	register struct radix_node *rn = h->rnh_treetop;
-	/*
-	 * This gets complicated because we may delete the node
-	 * while applying the function f to it, so we need to calculate
-	 * the successor node in advance.
-	 */
-	/* First time through node, go left */
-	while (rn->rn_b >= 0)
-		rn = rn->rn_l;
-	for (;;) {
-		base = rn;
-		/* If at right child go back up, otherwise, go right */
-		while (rn->rn_p->rn_r == rn && (rn->rn_flags & RNF_ROOT) == 0)
-			rn = rn->rn_p;
-		/* Find the next *leaf* since next node might vanish, too */
-		for (rn = rn->rn_p->rn_r; rn->rn_b >= 0;)
-			rn = rn->rn_l;
-		next = rn;
-		/* Process leaves */
-		while ((rn = base)) {
-			base = rn->rn_dupedkey;
-			if (!(rn->rn_flags & RNF_ROOT) && (error = (*f)(rn, w)))
-				return (error);
-		}
-		rn = next;
-		if (rn->rn_flags & RNF_ROOT)
-			return (0);
+    int error;
+    struct radix_node *base, *next;
+    register struct radix_node *rn = h->rnh_treetop;
+    /*
+     * This gets complicated because we may delete the node
+     * while applying the function f to it, so we need to calculate
+     * the successor node in advance.
+     */
+    /* First time through node, go left */
+    while (rn->rn_b >= 0)
+	rn = rn->rn_l;
+    for (;;) {
+	base = rn;
+	/* If at right child go back up, otherwise, go right */
+	while (rn->rn_p->rn_r == rn && (rn->rn_flags & RNF_ROOT) == 0)
+	    rn = rn->rn_p;
+	/* Find the next *leaf* since next node might vanish, too */
+	for (rn = rn->rn_p->rn_r; rn->rn_b >= 0;)
+	    rn = rn->rn_l;
+	next = rn;
+	/* Process leaves */
+	while ((rn = base)) {
+	    base = rn->rn_dupedkey;
+	    if (!(rn->rn_flags & RNF_ROOT) && (error = (*f) (rn, w)))
+		return (error);
 	}
-	/* NOTREACHED */
+	rn = next;
+	if (rn->rn_flags & RNF_ROOT)
+	    return (0);
+    }
+    /* NOTREACHED */
 }
 
 int
 rn_inithead(head, off)
-	void **head;
-	int off;
+     void **head;
+     int off;
 {
-	register struct radix_node_head *rnh;
-	register struct radix_node *t, *tt, *ttt;
-	if (*head)
-		return (1);
-	R_Malloc(rnh, struct radix_node_head *, sizeof (*rnh));
-	if (rnh == 0)
-		return (0);
-	memset(rnh, '\0', sizeof (*rnh));
-	*head = rnh;
-	t = rn_newpair(rn_zeros, off, rnh->rnh_nodes);
-	ttt = rnh->rnh_nodes + 2;
-	t->rn_r = ttt;
-	t->rn_p = t;
-	tt = t->rn_l;
-	tt->rn_flags = t->rn_flags = RNF_ROOT | RNF_ACTIVE;
-	tt->rn_b = -1 - off;
-	*ttt = *tt;
-	ttt->rn_key = rn_ones;
-	rnh->rnh_addaddr = rn_addroute;
-	rnh->rnh_deladdr = rn_delete;
-	rnh->rnh_matchaddr = rn_match;
-	rnh->rnh_lookup = rn_lookup;
-	rnh->rnh_walktree = rn_walktree;
-	rnh->rnh_treetop = t;
+    register struct radix_node_head *rnh;
+    register struct radix_node *t, *tt, *ttt;
+    if (*head)
 	return (1);
+    R_Malloc(rnh, struct radix_node_head *, sizeof(*rnh));
+    if (rnh == 0)
+	return (0);
+    memset(rnh, '\0', sizeof(*rnh));
+    *head = rnh;
+    t = rn_newpair(rn_zeros, off, rnh->rnh_nodes);
+    ttt = rnh->rnh_nodes + 2;
+    t->rn_r = ttt;
+    t->rn_p = t;
+    tt = t->rn_l;
+    tt->rn_flags = t->rn_flags = RNF_ROOT | RNF_ACTIVE;
+    tt->rn_b = -1 - off;
+    *ttt = *tt;
+    ttt->rn_key = rn_ones;
+    rnh->rnh_addaddr = rn_addroute;
+    rnh->rnh_deladdr = rn_delete;
+    rnh->rnh_matchaddr = rn_match;
+    rnh->rnh_lookup = rn_lookup;
+    rnh->rnh_walktree = rn_walktree;
+    rnh->rnh_treetop = t;
+    return (1);
 }
 
 void
 rn_init()
 {
-	char *cp, *cplim;
+    char *cp, *cplim;
 #ifdef KERNEL
-	struct domain *dom;
+    struct domain *dom;
 
-	for (dom = domains; dom; dom = dom->dom_next)
-		if (dom->dom_maxrtkey > max_keylen)
-			max_keylen = dom->dom_maxrtkey;
+    for (dom = domains; dom; dom = dom->dom_next)
+	if (dom->dom_maxrtkey > max_keylen)
+	    max_keylen = dom->dom_maxrtkey;
 #endif
-	if (max_keylen == 0) {
-		fprintf(stderr,
-		    "rn_init: radix functions require max_keylen be set\n");
-		return;
-	}
-	R_Malloc(rn_zeros, char *, 3 * max_keylen);
-	if (rn_zeros == NULL)
-	{
-		fprintf(stderr,"rn_init failed.\n");
-		exit(-1);
-	}
-	memset(rn_zeros, '\0', 3 * max_keylen);
-	rn_ones = cp = rn_zeros + max_keylen;
-	addmask_key = cplim = rn_ones + max_keylen;
-	while (cp < cplim)
-		*cp++ = -1;
-	if (rn_inithead((void **)&mask_rnhead, 0) == 0)
-	{
-		fprintf(stderr,"rn_init2 failed.\n");
-		exit(-1);
-	}
+    if (max_keylen == 0) {
+	fprintf(stderr,
+	    "rn_init: radix functions require max_keylen be set\n");
+	return;
+    }
+    R_Malloc(rn_zeros, char *, 3 * max_keylen);
+    if (rn_zeros == NULL) {
+	fprintf(stderr, "rn_init failed.\n");
+	exit(-1);
+    }
+    memset(rn_zeros, '\0', 3 * max_keylen);
+    rn_ones = cp = rn_zeros + max_keylen;
+    addmask_key = cplim = rn_ones + max_keylen;
+    while (cp < cplim)
+	*cp++ = -1;
+    if (rn_inithead((void **) &mask_rnhead, 0) == 0) {
+	fprintf(stderr, "rn_init2 failed.\n");
+	exit(-1);
+    }
 }