 @@ -1,2360 +1,2361 @@
-/*	$NetBSD: if_bridge.c,v 1.146 2017/12/19 03:32:35 ozaki-r Exp $	*/
+/*	$NetBSD: if_bridge.c,v 1.147 2017/12/28 07:06:36 ozaki-r Exp $	*/
 /*
  * Copyright 2001 Wasabi Systems, Inc.
  * All rights reserved.
+ *
  * Written by Jason R. Thorpe for Wasabi Systems, Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    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 for the NetBSD Project by
  *	Wasabi Systems, Inc.
  * 4. The name of Wasabi Systems, Inc. may not be used to endorse
  *    or promote products derived from this software without specific prior
  *    written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASABI SYSTEMS, INC
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Copyright (c) 1999, 2000 Jason L. Wright (jason@thought.net)
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    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 Jason L. Wright
  * 4. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
+ *
  * OpenBSD: if_bridge.c,v 1.60 2001/06/15 03:38:33 itojun Exp
  */
 /*
  * Network interface bridge support.
+ *
  * TODO:
+ *
  *	- Currently only supports Ethernet-like interfaces (Ethernet,
  *	  802.11, VLANs on Ethernet, etc.)  Figure out a nice way
  *	  to bridge other types of interfaces (FDDI-FDDI, and maybe
  *	  consider heterogenous bridges).
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_bridge.c,v 1.146 2017/12/19 03:32:35 ozaki-r Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_bridge.c,v 1.147 2017/12/28 07:06:36 ozaki-r Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_bridge_ipf.h"
 #include "opt_inet.h"
 #include "opt_net_mpsafe.h"
 #endif /* _KERNEL_OPT */
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/mbuf.h>
 #include <sys/queue.h>
 #include <sys/socket.h>
 #include <sys/socketvar.h> /* for softnet_lock */
 #include <sys/sockio.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/pool.h>
 #include <sys/kauth.h>
 #include <sys/cpu.h>
 #include <sys/cprng.h>
 #include <sys/mutex.h>
 #include <sys/kmem.h>
 #include <net/bpf.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <net/if_types.h>
 #include <net/if_llc.h>
 #include <net/if_ether.h>
 #include <net/if_bridgevar.h>
 #if defined(BRIDGE_IPF)
 /* Used for bridge_ip[6]_checkbasic */
 #include <netinet/in.h>
 #include <netinet/in_systm.h>
 #include <netinet/ip.h>
 #include <netinet/ip_var.h>
 #include <netinet/ip_private.h>		/* XXX */
 #include <netinet/ip6.h>
 #include <netinet6/in6_var.h>
 #include <netinet6/ip6_var.h>
 #include <netinet6/ip6_private.h>	/* XXX */
 #endif /* BRIDGE_IPF */
 /*
  * Size of the route hash table.  Must be a power of two.
  */
 #ifndef BRIDGE_RTHASH_SIZE
 #define	BRIDGE_RTHASH_SIZE		1024
 #endif
 #define	BRIDGE_RTHASH_MASK		(BRIDGE_RTHASH_SIZE - 1)
 #include "carp.h"
 #if NCARP > 0
 #include <netinet/in.h>
 #include <netinet/in_var.h>
 #include <netinet/ip_carp.h>
 #endif
 #include "ioconf.h"
 __CTASSERT(sizeof(struct ifbifconf) == sizeof(struct ifbaconf));
 __CTASSERT(offsetof(struct ifbifconf, ifbic_len) == offsetof(struct ifbaconf, ifbac_len));
 __CTASSERT(offsetof(struct ifbifconf, ifbic_buf) == offsetof(struct ifbaconf, ifbac_buf));
 /*
  * Maximum number of addresses to cache.
  */
 #ifndef BRIDGE_RTABLE_MAX
 #define	BRIDGE_RTABLE_MAX		100
 #endif
 /*
  * Spanning tree defaults.
  */
 #define	BSTP_DEFAULT_MAX_AGE		(20 * 256)
 #define	BSTP_DEFAULT_HELLO_TIME		(2 * 256)
 #define	BSTP_DEFAULT_FORWARD_DELAY	(15 * 256)
 #define	BSTP_DEFAULT_HOLD_TIME		(1 * 256)
 #define	BSTP_DEFAULT_BRIDGE_PRIORITY	0x8000
 #define	BSTP_DEFAULT_PORT_PRIORITY	0x80
 #define	BSTP_DEFAULT_PATH_COST		55
 /*
  * Timeout (in seconds) for entries learned dynamically.
  */
 #ifndef BRIDGE_RTABLE_TIMEOUT
 #define	BRIDGE_RTABLE_TIMEOUT		(20 * 60)	/* same as ARP */
 #endif
 /*
  * Number of seconds between walks of the route list.
  */
 #ifndef BRIDGE_RTABLE_PRUNE_PERIOD
 #define	BRIDGE_RTABLE_PRUNE_PERIOD	(5 * 60)
 #endif
 #define BRIDGE_RT_LOCK(_sc)	if ((_sc)->sc_rtlist_lock) \
 					mutex_enter((_sc)->sc_rtlist_lock)
 #define BRIDGE_RT_UNLOCK(_sc)	if ((_sc)->sc_rtlist_lock) \
 					mutex_exit((_sc)->sc_rtlist_lock)
 #define BRIDGE_RT_LOCKED(_sc)	(!(_sc)->sc_rtlist_lock || \
 				 mutex_owned((_sc)->sc_rtlist_lock))
 #define BRIDGE_RT_PSZ_PERFORM(_sc) \
 				if ((_sc)->sc_rtlist_psz != NULL) \
 					pserialize_perform((_sc)->sc_rtlist_psz);
 #define BRIDGE_RT_RENTER(__s)	do { __s = pserialize_read_enter(); } while (0)
 #define BRIDGE_RT_REXIT(__s)	do { pserialize_read_exit(__s); } while (0)
 #ifdef NET_MPSAFE
 #define DECLARE_LOCK_VARIABLE
 #define ACQUIRE_GLOBAL_LOCKS()	do { } while (0)
 #define RELEASE_GLOBAL_LOCKS()	do { } while (0)
 #else
 #define DECLARE_LOCK_VARIABLE	int __s
 #define ACQUIRE_GLOBAL_LOCKS()	do {					\
 					KERNEL_LOCK(1, NULL);		\
 					mutex_enter(softnet_lock);	\
 					__s = splsoftnet();		\
 				} while (0)
 #define RELEASE_GLOBAL_LOCKS()	do {					\
 					splx(__s);			\
 					mutex_exit(softnet_lock);	\
 					KERNEL_UNLOCK_ONE(NULL);	\
 				} while (0)
 #endif
 struct psref_class *bridge_psref_class __read_mostly;
 int	bridge_rtable_prune_period = BRIDGE_RTABLE_PRUNE_PERIOD;
 static struct pool bridge_rtnode_pool;
 static int	bridge_clone_create(struct if_clone *, int);
 static int	bridge_clone_destroy(struct ifnet *);
 static int	bridge_ioctl(struct ifnet *, u_long, void *);
 static int	bridge_init(struct ifnet *);
 static void	bridge_stop(struct ifnet *, int);
 static void	bridge_start(struct ifnet *);
 static void	bridge_input(struct ifnet *, struct mbuf *);
 static void	bridge_forward(struct bridge_softc *, struct mbuf *);
 static void	bridge_timer(void *);
 static void	bridge_broadcast(struct bridge_softc *, struct ifnet *,
 				 struct mbuf *);
 static int	bridge_rtupdate(struct bridge_softc *, const uint8_t *,
 				struct ifnet *, int, uint8_t);
 static struct ifnet *bridge_rtlookup(struct bridge_softc *, const uint8_t *);
 static void	bridge_rttrim(struct bridge_softc *);
 static void	bridge_rtage(struct bridge_softc *);
 static void	bridge_rtage_work(struct work *, void *);
 static void	bridge_rtflush(struct bridge_softc *, int);
 static int	bridge_rtdaddr(struct bridge_softc *, const uint8_t *);
 static void	bridge_rtdelete(struct bridge_softc *, struct ifnet *ifp);
 static void	bridge_rtable_init(struct bridge_softc *);
 static void	bridge_rtable_fini(struct bridge_softc *);
 static struct bridge_rtnode *bridge_rtnode_lookup(struct bridge_softc *,
 						  const uint8_t *);
 static int	bridge_rtnode_insert(struct bridge_softc *,
 				     struct bridge_rtnode *);
 static void	bridge_rtnode_remove(struct bridge_softc *,
 				     struct bridge_rtnode *);
 static void	bridge_rtnode_destroy(struct bridge_rtnode *);
 static struct bridge_iflist *bridge_lookup_member(struct bridge_softc *,
 						  const char *name,
 						  struct psref *);
 static struct bridge_iflist *bridge_lookup_member_if(struct bridge_softc *,
 						     struct ifnet *ifp,
 						     struct psref *);
 static void	bridge_release_member(struct bridge_softc *, struct bridge_iflist *,
                                       struct psref *);
 static void	bridge_delete_member(struct bridge_softc *,
 				     struct bridge_iflist *);
 static void	bridge_acquire_member(struct bridge_softc *sc,
                                       struct bridge_iflist *,
                                       struct psref *);
 static int	bridge_ioctl_add(struct bridge_softc *, void *);
 static int	bridge_ioctl_del(struct bridge_softc *, void *);
 static int	bridge_ioctl_gifflags(struct bridge_softc *, void *);
 static int	bridge_ioctl_sifflags(struct bridge_softc *, void *);
 static int	bridge_ioctl_scache(struct bridge_softc *, void *);
 static int	bridge_ioctl_gcache(struct bridge_softc *, void *);
 static int	bridge_ioctl_gifs(struct bridge_softc *, void *);
 static int	bridge_ioctl_rts(struct bridge_softc *, void *);
 static int	bridge_ioctl_saddr(struct bridge_softc *, void *);
 static int	bridge_ioctl_sto(struct bridge_softc *, void *);
 static int	bridge_ioctl_gto(struct bridge_softc *, void *);
 static int	bridge_ioctl_daddr(struct bridge_softc *, void *);
 static int	bridge_ioctl_flush(struct bridge_softc *, void *);
 static int	bridge_ioctl_gpri(struct bridge_softc *, void *);
 static int	bridge_ioctl_spri(struct bridge_softc *, void *);
 static int	bridge_ioctl_ght(struct bridge_softc *, void *);
 static int	bridge_ioctl_sht(struct bridge_softc *, void *);
 static int	bridge_ioctl_gfd(struct bridge_softc *, void *);
 static int	bridge_ioctl_sfd(struct bridge_softc *, void *);
 static int	bridge_ioctl_gma(struct bridge_softc *, void *);
 static int	bridge_ioctl_sma(struct bridge_softc *, void *);
 static int	bridge_ioctl_sifprio(struct bridge_softc *, void *);
 static int	bridge_ioctl_sifcost(struct bridge_softc *, void *);
 #if defined(BRIDGE_IPF)
 static int	bridge_ioctl_gfilt(struct bridge_softc *, void *);
 static int	bridge_ioctl_sfilt(struct bridge_softc *, void *);
 static int	bridge_ipf(void *, struct mbuf **, struct ifnet *, int);
 static int	bridge_ip_checkbasic(struct mbuf **mp);
 # ifdef INET6
 static int	bridge_ip6_checkbasic(struct mbuf **mp);
 # endif /* INET6 */
 #endif /* BRIDGE_IPF */
 struct bridge_control {
 	int	(*bc_func)(struct bridge_softc *, void *);
 	int	bc_argsize;
 	int	bc_flags;
 };
 #define	BC_F_COPYIN		0x01	/* copy arguments in */
 #define	BC_F_COPYOUT		0x02	/* copy arguments out */
 #define	BC_F_SUSER		0x04	/* do super-user check */
 #define BC_F_XLATEIN		0x08	/* xlate arguments in */
 #define BC_F_XLATEOUT		0x10	/* xlate arguments out */
 static const struct bridge_control bridge_control_table[] = {
 [BRDGADD] = {bridge_ioctl_add, sizeof(struct ifbreq), BC_F_COPYIN|BC_F_SUSER},
 [BRDGDEL] = {bridge_ioctl_del, sizeof(struct ifbreq), BC_F_COPYIN|BC_F_SUSER},
 [BRDGGIFFLGS] = {bridge_ioctl_gifflags, sizeof(struct ifbreq), BC_F_COPYIN|BC_F_COPYOUT},
 [BRDGSIFFLGS] = {bridge_ioctl_sifflags, sizeof(struct ifbreq), BC_F_COPYIN|BC_F_SUSER},
 [BRDGSCACHE] = {bridge_ioctl_scache, sizeof(struct ifbrparam), BC_F_COPYIN|BC_F_SUSER},
 [BRDGGCACHE] = {bridge_ioctl_gcache, sizeof(struct ifbrparam), BC_F_COPYOUT},
 [OBRDGGIFS] = {bridge_ioctl_gifs, sizeof(struct ifbifconf), BC_F_COPYIN|BC_F_COPYOUT},
 [OBRDGRTS] = {bridge_ioctl_rts, sizeof(struct ifbaconf), BC_F_COPYIN|BC_F_COPYOUT},
 [BRDGSADDR] = {bridge_ioctl_saddr, sizeof(struct ifbareq), BC_F_COPYIN|BC_F_SUSER},
 [BRDGSTO] = {bridge_ioctl_sto, sizeof(struct ifbrparam), BC_F_COPYIN|BC_F_SUSER},
 [BRDGGTO] = {bridge_ioctl_gto, sizeof(struct ifbrparam), BC_F_COPYOUT},
 [BRDGDADDR] = {bridge_ioctl_daddr, sizeof(struct ifbareq), BC_F_COPYIN|BC_F_SUSER},
 [BRDGFLUSH] = {bridge_ioctl_flush, sizeof(struct ifbreq), BC_F_COPYIN|BC_F_SUSER},
 [BRDGGPRI] = {bridge_ioctl_gpri, sizeof(struct ifbrparam), BC_F_COPYOUT},
 [BRDGSPRI] = {bridge_ioctl_spri, sizeof(struct ifbrparam), BC_F_COPYIN|BC_F_SUSER},
 [BRDGGHT] = {bridge_ioctl_ght, sizeof(struct ifbrparam), BC_F_COPYOUT},
 [BRDGSHT] = {bridge_ioctl_sht, sizeof(struct ifbrparam), BC_F_COPYIN|BC_F_SUSER},
 [BRDGGFD] = {bridge_ioctl_gfd, sizeof(struct ifbrparam), BC_F_COPYOUT},
 [BRDGSFD] = {bridge_ioctl_sfd, sizeof(struct ifbrparam), BC_F_COPYIN|BC_F_SUSER},
 [BRDGGMA] = {bridge_ioctl_gma, sizeof(struct ifbrparam), BC_F_COPYOUT},
 [BRDGSMA] = {bridge_ioctl_sma, sizeof(struct ifbrparam), BC_F_COPYIN|BC_F_SUSER},
 [BRDGSIFPRIO] = {bridge_ioctl_sifprio, sizeof(struct ifbreq), BC_F_COPYIN|BC_F_SUSER},
 [BRDGSIFCOST] = {bridge_ioctl_sifcost, sizeof(struct ifbreq), BC_F_COPYIN|BC_F_SUSER},
 #if defined(BRIDGE_IPF)
 [BRDGGFILT] = {bridge_ioctl_gfilt, sizeof(struct ifbrparam), BC_F_COPYOUT},
 [BRDGSFILT] = {bridge_ioctl_sfilt, sizeof(struct ifbrparam), BC_F_COPYIN|BC_F_SUSER},
 #endif /* BRIDGE_IPF */
 [BRDGGIFS] = {bridge_ioctl_gifs, sizeof(struct ifbifconf), BC_F_XLATEIN|BC_F_XLATEOUT},
 [BRDGRTS] = {bridge_ioctl_rts, sizeof(struct ifbaconf), BC_F_XLATEIN|BC_F_XLATEOUT},
 };
 static const int bridge_control_table_size = __arraycount(bridge_control_table);
 static struct if_clone bridge_cloner =
     IF_CLONE_INITIALIZER("bridge", bridge_clone_create, bridge_clone_destroy);
 /*
  * bridgeattach:
+ *
  *	Pseudo-device attach routine.
  */
 void
 bridgeattach(int n)
+{
 	pool_init(&bridge_rtnode_pool, sizeof(struct bridge_rtnode),
 , 0, 0, "brtpl", NULL, IPL_NET);
 	bridge_psref_class = psref_class_create("bridge", IPL_SOFTNET);
 	if_clone_attach(&bridge_cloner);
+}
 /*
  * bridge_clone_create:
+ *
  *	Create a new bridge instance.
  */
 static int
 bridge_clone_create(struct if_clone *ifc, int unit)
+{
 	struct bridge_softc *sc;
 	struct ifnet *ifp;
 	int error;
 	sc = kmem_zalloc(sizeof(*sc),  KM_SLEEP);
 	ifp = &sc->sc_if;
 	sc->sc_brtmax = BRIDGE_RTABLE_MAX;
 	sc->sc_brttimeout = BRIDGE_RTABLE_TIMEOUT;
 	sc->sc_bridge_max_age = BSTP_DEFAULT_MAX_AGE;
 	sc->sc_bridge_hello_time = BSTP_DEFAULT_HELLO_TIME;
 	sc->sc_bridge_forward_delay = BSTP_DEFAULT_FORWARD_DELAY;
 	sc->sc_bridge_priority = BSTP_DEFAULT_BRIDGE_PRIORITY;
 	sc->sc_hold_time = BSTP_DEFAULT_HOLD_TIME;
 	sc->sc_filter_flags = 0;
 	/* Initialize our routing table. */
 	bridge_rtable_init(sc);
 	error = workqueue_create(&sc->sc_rtage_wq, "bridge_rtage",
 	    bridge_rtage_work, sc, PRI_SOFTNET, IPL_SOFTNET, WQ_MPSAFE);
 	if (error)
 		panic("%s: workqueue_create %d\n", __func__, error);
 	callout_init(&sc->sc_brcallout, CALLOUT_MPSAFE);
 	callout_init(&sc->sc_bstpcallout, CALLOUT_MPSAFE);
 	mutex_init(&sc->sc_iflist_psref.bip_lock, MUTEX_DEFAULT, IPL_NONE);
 	PSLIST_INIT(&sc->sc_iflist_psref.bip_iflist);
 	sc->sc_iflist_psref.bip_psz = pserialize_create();
 	if_initname(ifp, ifc->ifc_name, unit);
 	ifp->if_softc = sc;
 	ifp->if_extflags = IFEF_NO_LINK_STATE_CHANGE;
 #ifdef NET_MPSAFE
 	ifp->if_extflags |= IFEF_MPSAFE;
 #endif
 	ifp->if_mtu = ETHERMTU;
 	ifp->if_ioctl = bridge_ioctl;
 	ifp->if_output = bridge_output;
 	ifp->if_start = bridge_start;
 	ifp->if_stop = bridge_stop;
 	ifp->if_init = bridge_init;
 	ifp->if_type = IFT_BRIDGE;
 	ifp->if_addrlen = 0;
 	ifp->if_dlt = DLT_EN10MB;
 	ifp->if_hdrlen = ETHER_HDR_LEN;
 	error = if_initialize(ifp);
 	if (error != 0) {
 		pserialize_destroy(sc->sc_iflist_psref.bip_psz);
 		mutex_destroy(&sc->sc_iflist_psref.bip_lock);
 		callout_destroy(&sc->sc_brcallout);
 		callout_destroy(&sc->sc_bstpcallout);
 		workqueue_destroy(sc->sc_rtage_wq);
 		bridge_rtable_fini(sc);
 		kmem_free(sc, sizeof(*sc));
 		return error;
+	}
 	if_register(ifp);
 	if_alloc_sadl(ifp);
 	return 0;
+}
 /*
  * bridge_clone_destroy:
+ *
  *	Destroy a bridge instance.
  */
 static int
 bridge_clone_destroy(struct ifnet *ifp)
+{
 	struct bridge_softc *sc = ifp->if_softc;
 	struct bridge_iflist *bif;
 	bridge_stop(ifp, 1);
 	BRIDGE_LOCK(sc);
 	for (;;) {
 		bif = PSLIST_WRITER_FIRST(&sc->sc_iflist_psref.bip_iflist, struct bridge_iflist,
 		    bif_next);
 		if (bif == NULL)
 			break;
 		bridge_delete_member(sc, bif);
+	}
 	PSLIST_DESTROY(&sc->sc_iflist_psref.bip_iflist);
 	BRIDGE_UNLOCK(sc);
 	if_detach(ifp);
 	/* Tear down the routing table. */
 	bridge_rtable_fini(sc);
 	pserialize_destroy(sc->sc_iflist_psref.bip_psz);
 	mutex_destroy(&sc->sc_iflist_psref.bip_lock);
 	callout_destroy(&sc->sc_brcallout);
 	callout_destroy(&sc->sc_bstpcallout);
 	workqueue_destroy(sc->sc_rtage_wq);
 	kmem_free(sc, sizeof(*sc));
 	return 0;
+}
 /*
  * bridge_ioctl:
+ *
  *	Handle a control request from the operator.
  */
 static int
 bridge_ioctl(struct ifnet *ifp, u_long cmd, void *data)
+{
 	struct bridge_softc *sc = ifp->if_softc;
 	struct lwp *l = curlwp;	/* XXX */
 	union {
 		struct ifbreq ifbreq;
 		struct ifbifconf ifbifconf;
 		struct ifbareq ifbareq;
 		struct ifbaconf ifbaconf;
 		struct ifbrparam ifbrparam;
 	} args;
 	struct ifdrv *ifd = (struct ifdrv *) data;
 	const struct bridge_control *bc = NULL; /* XXXGCC */
 	int s, error = 0;
 	/* Authorize command before calling splsoftnet(). */
 	switch (cmd) {
 	case SIOCGDRVSPEC:
 	case SIOCSDRVSPEC:
 		if (ifd->ifd_cmd >= bridge_control_table_size
 		    || (bc = &bridge_control_table[ifd->ifd_cmd]) == NULL) {
 			error = EINVAL;
 			return error;
+		}
 		/* We only care about BC_F_SUSER at this point. */
 		if ((bc->bc_flags & BC_F_SUSER) == 0)
 			break;
 		error = kauth_authorize_network(l->l_cred,
 		    KAUTH_NETWORK_INTERFACE_BRIDGE,
 		    cmd == SIOCGDRVSPEC ?
 		     KAUTH_REQ_NETWORK_INTERFACE_BRIDGE_GETPRIV :
 		     KAUTH_REQ_NETWORK_INTERFACE_BRIDGE_SETPRIV,
 		     ifd, NULL, NULL);
 		if (error)
 			return error;
 		break;
+	}
 	s = splsoftnet();
 	switch (cmd) {
 	case SIOCGDRVSPEC:
 	case SIOCSDRVSPEC:
 		KASSERT(bc != NULL);
 		if (cmd == SIOCGDRVSPEC &&
 		    (bc->bc_flags & (BC_F_COPYOUT|BC_F_XLATEOUT)) == 0) {
 			error = EINVAL;
 			break;
+		}
 		else if (cmd == SIOCSDRVSPEC &&
 		    (bc->bc_flags & (BC_F_COPYOUT|BC_F_XLATEOUT)) != 0) {
 			error = EINVAL;
 			break;
+		}
 		/* BC_F_SUSER is checked above, before splsoftnet(). */
 		if ((bc->bc_flags & (BC_F_XLATEIN|BC_F_XLATEOUT)) == 0
 		    && (ifd->ifd_len != bc->bc_argsize
 			|| ifd->ifd_len > sizeof(args))) {
 			error = EINVAL;
 			break;
+		}
 		memset(&args, 0, sizeof(args));
 		if (bc->bc_flags & BC_F_COPYIN) {
 			error = copyin(ifd->ifd_data, &args, ifd->ifd_len);
 			if (error)
 				break;
 		} else if (bc->bc_flags & BC_F_XLATEIN) {
 			args.ifbifconf.ifbic_len = ifd->ifd_len;
 			args.ifbifconf.ifbic_buf = ifd->ifd_data;
+		}
 		error = (*bc->bc_func)(sc, &args);
 		if (error)
 			break;
 		if (bc->bc_flags & BC_F_COPYOUT) {
 			error = copyout(&args, ifd->ifd_data, ifd->ifd_len);
 		} else if (bc->bc_flags & BC_F_XLATEOUT) {
 			ifd->ifd_len = args.ifbifconf.ifbic_len;
 			ifd->ifd_data = args.ifbifconf.ifbic_buf;
+		}
 		break;
 	case SIOCSIFFLAGS:
 		if ((error = ifioctl_common(ifp, cmd, data)) != 0)
 			break;
 		switch (ifp->if_flags & (IFF_UP|IFF_RUNNING)) {
 		case IFF_RUNNING:
 			/*
 			 * If interface is marked down and it is running,
 			 * then stop and disable it.
 			 */
 			(*ifp->if_stop)(ifp, 1);
 			break;
 		case IFF_UP:
 			/*
 			 * If interface is marked up and it is stopped, then
 			 * start it.
 			 */
 			error = (*ifp->if_init)(ifp);
 			break;
 		default:
 			break;
+		}
 		break;
 	case SIOCSIFMTU:
 		if ((error = ifioctl_common(ifp, cmd, data)) == ENETRESET)
 			error = 0;
 		break;
 	default:
 		error = ifioctl_common(ifp, cmd, data);
 		break;
+	}
 	splx(s);
 	return error;
+}
 /*
  * bridge_lookup_member:
+ *
  *	Lookup a bridge member interface.
  */
 static struct bridge_iflist *
 bridge_lookup_member(struct bridge_softc *sc, const char *name, struct psref *psref)
+{
 	struct bridge_iflist *bif;
 	struct ifnet *ifp;
 	int s;
 	BRIDGE_PSZ_RENTER(s);
 	BRIDGE_IFLIST_READER_FOREACH(bif, sc) {
 		ifp = bif->bif_ifp;
 		if (strcmp(ifp->if_xname, name) == 0)
 			break;
+	}
 	if (bif != NULL)
 		bridge_acquire_member(sc, bif, psref);
 	BRIDGE_PSZ_REXIT(s);
 	return bif;
+}
 /*
  * bridge_lookup_member_if:
+ *
  *	Lookup a bridge member interface by ifnet*.
  */
 static struct bridge_iflist *
 bridge_lookup_member_if(struct bridge_softc *sc, struct ifnet *member_ifp,
     struct psref *psref)
+{
 	struct bridge_iflist *bif;
 	int s;
 	BRIDGE_PSZ_RENTER(s);
 	bif = member_ifp->if_bridgeif;
 	if (bif != NULL) {
 		psref_acquire(psref, &bif->bif_psref,
 		    bridge_psref_class);
+	}
 	BRIDGE_PSZ_REXIT(s);
 	return bif;
+}
 static void
 bridge_acquire_member(struct bridge_softc *sc, struct bridge_iflist *bif,
     struct psref *psref)
+{
 	psref_acquire(psref, &bif->bif_psref, bridge_psref_class);
+}
 /*
  * bridge_release_member:
+ *
  *	Release the specified member interface.
  */
 static void
 bridge_release_member(struct bridge_softc *sc, struct bridge_iflist *bif,
     struct psref *psref)
+{
 	psref_release(psref, &bif->bif_psref, bridge_psref_class);
+}
 /*
  * bridge_delete_member:
+ *
  *	Delete the specified member interface.
  */
 static void
 bridge_delete_member(struct bridge_softc *sc, struct bridge_iflist *bif)
+{
 	struct ifnet *ifs = bif->bif_ifp;
 	KASSERT(BRIDGE_LOCKED(sc));
 	ifs->_if_input = ether_input;
 	ifs->if_bridge = NULL;
 	ifs->if_bridgeif = NULL;
 	PSLIST_WRITER_REMOVE(bif, bif_next);
 	BRIDGE_PSZ_PERFORM(sc);
 	BRIDGE_UNLOCK(sc);
 	psref_target_destroy(&bif->bif_psref, bridge_psref_class);
 	PSLIST_ENTRY_DESTROY(bif, bif_next);
 	kmem_free(bif, sizeof(*bif));
 	BRIDGE_LOCK(sc);
+}
 static int
 bridge_ioctl_add(struct bridge_softc *sc, void *arg)
+{
 	struct ifbreq *req = arg;
 	struct bridge_iflist *bif = NULL;
 	struct ifnet *ifs;
 	int error = 0;
 	struct psref psref;
 	ifs = if_get(req->ifbr_ifsname, &psref);
 	if (ifs == NULL)
 		return ENOENT;
 	if (ifs->if_bridge == sc) {
 		error = EEXIST;
 		goto out;
+	}
 	if (ifs->if_bridge != NULL) {
 		error = EBUSY;
 		goto out;
+	}
 	if (ifs->_if_input != ether_input) {
 		error = EINVAL;
 		goto out;
+	}
 	/* FIXME: doesn't work with non-IFF_SIMPLEX interfaces */
 	if ((ifs->if_flags & IFF_SIMPLEX) == 0) {
 		error = EINVAL;
 		goto out;
+	}
 	bif = kmem_alloc(sizeof(*bif), KM_SLEEP);
 	switch (ifs->if_type) {
 	case IFT_ETHER:
 		if (sc->sc_if.if_mtu != ifs->if_mtu) {
 			error = EINVAL;
 			goto out;
+		}
 		/* FALLTHROUGH */
 	case IFT_L2TP:
 		IFNET_LOCK(ifs);
 		error = ether_enable_vlan_mtu(ifs);
 		IFNET_UNLOCK(ifs);
 		if (error > 0)
 			goto out;
 		/*
 		 * Place the interface into promiscuous mode.
 		 */
 		error = ifpromisc(ifs, 1);
 		if (error)
 			goto out;
 		break;
 	default:
 		error = EINVAL;
 		goto out;
+	}
 	bif->bif_ifp = ifs;
 	bif->bif_flags = IFBIF_LEARNING | IFBIF_DISCOVER;
 	bif->bif_priority = BSTP_DEFAULT_PORT_PRIORITY;
 	bif->bif_path_cost = BSTP_DEFAULT_PATH_COST;
 	PSLIST_ENTRY_INIT(bif, bif_next);
 	psref_target_init(&bif->bif_psref, bridge_psref_class);
 	BRIDGE_LOCK(sc);
 	ifs->if_bridge = sc;
 	ifs->if_bridgeif = bif;
 	PSLIST_WRITER_INSERT_HEAD(&sc->sc_iflist_psref.bip_iflist, bif, bif_next);
 	ifs->_if_input = bridge_input;
 	BRIDGE_UNLOCK(sc);
 	if (sc->sc_if.if_flags & IFF_RUNNING)
 		bstp_initialization(sc);
 	else
 		bstp_stop(sc);
  out:
 	if_put(ifs, &psref);
 	if (error) {
 		if (bif != NULL)
 			kmem_free(bif, sizeof(*bif));
+	}
 	return error;
+}
 static int
 bridge_ioctl_del(struct bridge_softc *sc, void *arg)
+{
 	struct ifbreq *req = arg;
 	const char *name = req->ifbr_ifsname;
 	struct bridge_iflist *bif;
 	struct ifnet *ifs;
 	BRIDGE_LOCK(sc);
 	/*
 	 * Don't use bridge_lookup_member. We want to get a member
 	 * with bif_refs == 0.
 	 */
 	BRIDGE_IFLIST_WRITER_FOREACH(bif, sc) {
 		ifs = bif->bif_ifp;
 		if (strcmp(ifs->if_xname, name) == 0)
 			break;
+	}
 	if (bif == NULL) {
 		BRIDGE_UNLOCK(sc);
 		return ENOENT;
+	}
 	bridge_delete_member(sc, bif);
 	BRIDGE_UNLOCK(sc);
 	switch (ifs->if_type) {
 	case IFT_ETHER:
 	case IFT_L2TP:
 		/*
 		 * Take the interface out of promiscuous mode.
 		 * Don't call it with holding a spin lock.
 		 */
 		(void) ifpromisc(ifs, 0);
 		IFNET_LOCK(ifs);
 		(void) ether_disable_vlan_mtu(ifs);
 		IFNET_UNLOCK(ifs);
 		break;
 	default:
 #ifdef DIAGNOSTIC
 		panic("bridge_delete_member: impossible");
 #endif
 		break;
+	}
 	bridge_rtdelete(sc, ifs);
 	if (sc->sc_if.if_flags & IFF_RUNNING)
 		bstp_initialization(sc);
 	return 0;
+}
 static int
 bridge_ioctl_gifflags(struct bridge_softc *sc, void *arg)
+{
 	struct ifbreq *req = arg;
 	struct bridge_iflist *bif;
 	struct psref psref;
 	bif = bridge_lookup_member(sc, req->ifbr_ifsname, &psref);
 	if (bif == NULL)
 		return ENOENT;
 	req->ifbr_ifsflags = bif->bif_flags;
 	req->ifbr_state = bif->bif_state;
 	req->ifbr_priority = bif->bif_priority;
 	req->ifbr_path_cost = bif->bif_path_cost;
 	req->ifbr_portno = bif->bif_ifp->if_index & 0xff;
 	bridge_release_member(sc, bif, &psref);
 	return 0;
+}
 static int
 bridge_ioctl_sifflags(struct bridge_softc *sc, void *arg)
+{
 	struct ifbreq *req = arg;
 	struct bridge_iflist *bif;
 	struct psref psref;
 	bif = bridge_lookup_member(sc, req->ifbr_ifsname, &psref);
 	if (bif == NULL)
 		return ENOENT;
 	if (req->ifbr_ifsflags & IFBIF_STP) {
 		switch (bif->bif_ifp->if_type) {
 		case IFT_ETHER:
 		case IFT_L2TP:
 			/* These can do spanning tree. */
 			break;
 		default:
 			/* Nothing else can. */
 			bridge_release_member(sc, bif, &psref);
 			return EINVAL;
+		}
+	}
 	bif->bif_flags = req->ifbr_ifsflags;
 	bridge_release_member(sc, bif, &psref);
 	if (sc->sc_if.if_flags & IFF_RUNNING)
 		bstp_initialization(sc);
 	return 0;
+}
 static int
 bridge_ioctl_scache(struct bridge_softc *sc, void *arg)
+{
 	struct ifbrparam *param = arg;
 	sc->sc_brtmax = param->ifbrp_csize;
 	bridge_rttrim(sc);
 	return 0;
+}
 static int
 bridge_ioctl_gcache(struct bridge_softc *sc, void *arg)
+{
 	struct ifbrparam *param = arg;
 	param->ifbrp_csize = sc->sc_brtmax;
 	return 0;
+}
 static int
 bridge_ioctl_gifs(struct bridge_softc *sc, void *arg)
+{
 	struct ifbifconf *bifc = arg;
 	struct bridge_iflist *bif;
 	struct ifbreq *breqs;
 	int i, count, error = 0;
 retry:
 	BRIDGE_LOCK(sc);
 	count = 0;
 	BRIDGE_IFLIST_WRITER_FOREACH(bif, sc)
 		count++;
 	BRIDGE_UNLOCK(sc);
 	if (count == 0) {
 		bifc->ifbic_len = 0;
 		return 0;
+	}
 	if (bifc->ifbic_len == 0 || bifc->ifbic_len < (sizeof(*breqs) * count)) {
 		/* Tell that a larger buffer is needed */
 		bifc->ifbic_len = sizeof(*breqs) * count;
 		return 0;
+	}
 	breqs = kmem_alloc(sizeof(*breqs) * count, KM_SLEEP);
 	BRIDGE_LOCK(sc);
 	i = 0;
 	BRIDGE_IFLIST_WRITER_FOREACH(bif, sc)
 		i++;
 	if (i > count) {
 		/*
 		 * The number of members has been increased.
 		 * We need more memory!
 		 */
 		BRIDGE_UNLOCK(sc);
 		kmem_free(breqs, sizeof(*breqs) * count);
 		goto retry;
+	}
 	i = 0;
 	BRIDGE_IFLIST_WRITER_FOREACH(bif, sc) {
 		struct ifbreq *breq = &breqs[i++];
 		memset(breq, 0, sizeof(*breq));
 		strlcpy(breq->ifbr_ifsname, bif->bif_ifp->if_xname,
 		    sizeof(breq->ifbr_ifsname));
 		breq->ifbr_ifsflags = bif->bif_flags;
 		breq->ifbr_state = bif->bif_state;
 		breq->ifbr_priority = bif->bif_priority;
 		breq->ifbr_path_cost = bif->bif_path_cost;
 		breq->ifbr_portno = bif->bif_ifp->if_index & 0xff;
+	}
 	/* Don't call copyout with holding the mutex */
 	BRIDGE_UNLOCK(sc);
 	for (i = 0; i < count; i++) {
 		error = copyout(&breqs[i], bifc->ifbic_req + i, sizeof(*breqs));
 		if (error)
 			break;
+	}
 	bifc->ifbic_len = sizeof(*breqs) * i;
 	kmem_free(breqs, sizeof(*breqs) * count);
 	return error;
+}
 static int
 bridge_ioctl_rts(struct bridge_softc *sc, void *arg)
+{
 	struct ifbaconf *bac = arg;
 	struct bridge_rtnode *brt;
 	struct ifbareq bareq;
 	int count = 0, error = 0, len;
 	if (bac->ifbac_len == 0)
 		return 0;
 	BRIDGE_RT_LOCK(sc);
 	len = bac->ifbac_len;
 	LIST_FOREACH(brt, &sc->sc_rtlist, brt_list) {
 		if (len < sizeof(bareq))
 			goto out;
 		memset(&bareq, 0, sizeof(bareq));
 		strlcpy(bareq.ifba_ifsname, brt->brt_ifp->if_xname,
 		    sizeof(bareq.ifba_ifsname));
 		memcpy(bareq.ifba_dst, brt->brt_addr, sizeof(brt->brt_addr));
 		if ((brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC) {
 			bareq.ifba_expire = brt->brt_expire - time_uptime;
 		} else
 			bareq.ifba_expire = 0;
 		bareq.ifba_flags = brt->brt_flags;
 		error = copyout(&bareq, bac->ifbac_req + count, sizeof(bareq));
 		if (error)
 			goto out;
 		count++;
 		len -= sizeof(bareq);
+	}
  out:
 	BRIDGE_RT_UNLOCK(sc);
 	bac->ifbac_len = sizeof(bareq) * count;
 	return error;
+}
 static int
 bridge_ioctl_saddr(struct bridge_softc *sc, void *arg)
+{
 	struct ifbareq *req = arg;
 	struct bridge_iflist *bif;
 	int error;
 	struct psref psref;
 	bif = bridge_lookup_member(sc, req->ifba_ifsname, &psref);
 	if (bif == NULL)
 		return ENOENT;
 	error = bridge_rtupdate(sc, req->ifba_dst, bif->bif_ifp, 1,
 	    req->ifba_flags);
 	bridge_release_member(sc, bif, &psref);
 	return error;
+}
 static int
 bridge_ioctl_sto(struct bridge_softc *sc, void *arg)
+{
 	struct ifbrparam *param = arg;
 	sc->sc_brttimeout = param->ifbrp_ctime;
 	return 0;
+}
 static int
 bridge_ioctl_gto(struct bridge_softc *sc, void *arg)
+{
 	struct ifbrparam *param = arg;
 	param->ifbrp_ctime = sc->sc_brttimeout;
 	return 0;
+}
 static int
 bridge_ioctl_daddr(struct bridge_softc *sc, void *arg)
+{
 	struct ifbareq *req = arg;
 	return (bridge_rtdaddr(sc, req->ifba_dst));
+}
 static int
 bridge_ioctl_flush(struct bridge_softc *sc, void *arg)
+{
 	struct ifbreq *req = arg;
 	bridge_rtflush(sc, req->ifbr_ifsflags);
 	return 0;
+}
 static int
 bridge_ioctl_gpri(struct bridge_softc *sc, void *arg)
+{
 	struct ifbrparam *param = arg;
 	param->ifbrp_prio = sc->sc_bridge_priority;
 	return 0;
+}
 static int
 bridge_ioctl_spri(struct bridge_softc *sc, void *arg)
+{
 	struct ifbrparam *param = arg;
 	sc->sc_bridge_priority = param->ifbrp_prio;
 	if (sc->sc_if.if_flags & IFF_RUNNING)
 		bstp_initialization(sc);
 	return 0;
+}
 static int
 bridge_ioctl_ght(struct bridge_softc *sc, void *arg)
+{
 	struct ifbrparam *param = arg;
 	param->ifbrp_hellotime = sc->sc_bridge_hello_time >> 8;
 	return 0;
+}
 static int
 bridge_ioctl_sht(struct bridge_softc *sc, void *arg)
+{
 	struct ifbrparam *param = arg;
 	if (param->ifbrp_hellotime == 0)
 		return EINVAL;
 	sc->sc_bridge_hello_time = param->ifbrp_hellotime << 8;
 	if (sc->sc_if.if_flags & IFF_RUNNING)
 		bstp_initialization(sc);
 	return 0;
+}
 static int
 bridge_ioctl_gfd(struct bridge_softc *sc, void *arg)
+{
 	struct ifbrparam *param = arg;
 	param->ifbrp_fwddelay = sc->sc_bridge_forward_delay >> 8;
 	return 0;
+}
 static int
 bridge_ioctl_sfd(struct bridge_softc *sc, void *arg)
+{
 	struct ifbrparam *param = arg;
 	if (param->ifbrp_fwddelay == 0)
 		return EINVAL;
 	sc->sc_bridge_forward_delay = param->ifbrp_fwddelay << 8;
 	if (sc->sc_if.if_flags & IFF_RUNNING)
 		bstp_initialization(sc);
 	return 0;
+}
 static int
 bridge_ioctl_gma(struct bridge_softc *sc, void *arg)
+{
 	struct ifbrparam *param = arg;
 	param->ifbrp_maxage = sc->sc_bridge_max_age >> 8;
 	return 0;
+}
 static int
 bridge_ioctl_sma(struct bridge_softc *sc, void *arg)
+{
 	struct ifbrparam *param = arg;
 	if (param->ifbrp_maxage == 0)
 		return EINVAL;
 	sc->sc_bridge_max_age = param->ifbrp_maxage << 8;
 	if (sc->sc_if.if_flags & IFF_RUNNING)
 		bstp_initialization(sc);
 	return 0;
+}
 static int
 bridge_ioctl_sifprio(struct bridge_softc *sc, void *arg)
+{
 	struct ifbreq *req = arg;
 	struct bridge_iflist *bif;
 	struct psref psref;
 	bif = bridge_lookup_member(sc, req->ifbr_ifsname, &psref);
 	if (bif == NULL)
 		return ENOENT;
 	bif->bif_priority = req->ifbr_priority;
 	if (sc->sc_if.if_flags & IFF_RUNNING)
 		bstp_initialization(sc);
 	bridge_release_member(sc, bif, &psref);
 	return 0;
+}
 #if defined(BRIDGE_IPF)
 static int
 bridge_ioctl_gfilt(struct bridge_softc *sc, void *arg)
+{
 	struct ifbrparam *param = arg;
 	param->ifbrp_filter = sc->sc_filter_flags;
 	return 0;
+}
 static int
 bridge_ioctl_sfilt(struct bridge_softc *sc, void *arg)
+{
 	struct ifbrparam *param = arg;
 	uint32_t nflags, oflags;
 	if (param->ifbrp_filter & ~IFBF_FILT_MASK)
 		return EINVAL;
 	nflags = param->ifbrp_filter;
 	oflags = sc->sc_filter_flags;
 	if ((nflags & IFBF_FILT_USEIPF) && !(oflags & IFBF_FILT_USEIPF)) {
 		pfil_add_hook((void *)bridge_ipf, NULL, PFIL_IN|PFIL_OUT,
 			sc->sc_if.if_pfil);
+	}
 	if (!(nflags & IFBF_FILT_USEIPF) && (oflags & IFBF_FILT_USEIPF)) {
 		pfil_remove_hook((void *)bridge_ipf, NULL, PFIL_IN|PFIL_OUT,
 			sc->sc_if.if_pfil);
+	}
 	sc->sc_filter_flags = nflags;
 	return 0;
+}
 #endif /* BRIDGE_IPF */
 static int
 bridge_ioctl_sifcost(struct bridge_softc *sc, void *arg)
+{
 	struct ifbreq *req = arg;
 	struct bridge_iflist *bif;
 	struct psref psref;
 	bif = bridge_lookup_member(sc, req->ifbr_ifsname, &psref);
 	if (bif == NULL)
 		return ENOENT;
 	bif->bif_path_cost = req->ifbr_path_cost;
 	if (sc->sc_if.if_flags & IFF_RUNNING)
 		bstp_initialization(sc);
 	bridge_release_member(sc, bif, &psref);
 	return 0;
+}
 /*
  * bridge_ifdetach:
+ *
  *	Detach an interface from a bridge.  Called when a member
  *	interface is detaching.
  */
 void
 bridge_ifdetach(struct ifnet *ifp)
+{
 	struct bridge_softc *sc = ifp->if_bridge;
 	struct ifbreq breq;
 	/* ioctl_lock should prevent this from happening */
 	KASSERT(sc != NULL);
 	memset(&breq, 0, sizeof(breq));
 	strlcpy(breq.ifbr_ifsname, ifp->if_xname, sizeof(breq.ifbr_ifsname));
 	(void) bridge_ioctl_del(sc, &breq);
+}
 /*
  * bridge_init:
+ *
  *	Initialize a bridge interface.
  */
 static int
 bridge_init(struct ifnet *ifp)
+{
 	struct bridge_softc *sc = ifp->if_softc;
 	KASSERT((ifp->if_flags & IFF_RUNNING) == 0);
 	callout_reset(&sc->sc_brcallout, bridge_rtable_prune_period * hz,
 	    bridge_timer, sc);
 	bstp_initialization(sc);
 	ifp->if_flags |= IFF_RUNNING;
 	return 0;
+}
 /*
  * bridge_stop:
+ *
  *	Stop the bridge interface.
  */
 static void
 bridge_stop(struct ifnet *ifp, int disable)
+{
 	struct bridge_softc *sc = ifp->if_softc;
 	KASSERT((ifp->if_flags & IFF_RUNNING) != 0);
 	ifp->if_flags &= ~IFF_RUNNING;
-	callout_stop(&sc->sc_brcallout);
+	callout_halt(&sc->sc_brcallout, NULL);
 	workqueue_wait(sc->sc_rtage_wq, &sc->sc_rtage_wk);
 	bstp_stop(sc);
 	bridge_rtflush(sc, IFBF_FLUSHDYN);
+}
 /*
  * bridge_enqueue:
+ *
  *	Enqueue a packet on a bridge member interface.
  */
 void
 bridge_enqueue(struct bridge_softc *sc, struct ifnet *dst_ifp, struct mbuf *m,
     int runfilt)
+{
 	int len, error;
 	short mflags;
 	/*
 	 * Clear any in-bound checksum flags for this packet.
 	 */
 	m->m_pkthdr.csum_flags = 0;
 	if (runfilt) {
 		if (pfil_run_hooks(sc->sc_if.if_pfil, &m,
 		    dst_ifp, PFIL_OUT) != 0) {
 			if (m != NULL)
 				m_freem(m);
 			return;
+		}
 		if (m == NULL)
 			return;
+	}
 #ifdef ALTQ
 	KERNEL_LOCK(1, NULL);
 	/*
 	 * If ALTQ is enabled on the member interface, do
 	 * classification; the queueing discipline might
 	 * not require classification, but might require
 	 * the address family/header pointer in the pktattr.
 	 */
 	if (ALTQ_IS_ENABLED(&dst_ifp->if_snd)) {
 		/* XXX IFT_ETHER */
 		altq_etherclassify(&dst_ifp->if_snd, m);
+	}
 	KERNEL_UNLOCK_ONE(NULL);
 #endif /* ALTQ */
 	len = m->m_pkthdr.len;
 	mflags = m->m_flags;
 	error = if_transmit_lock(dst_ifp, m);
 	if (error) {
 		/* mbuf is already freed */
 		sc->sc_if.if_oerrors++;
 		return;
+	}
 	sc->sc_if.if_opackets++;
 	sc->sc_if.if_obytes += len;
 	if (mflags & M_MCAST)
 		sc->sc_if.if_omcasts++;
+}
 /*
  * bridge_output:
+ *
  *	Send output from a bridge member interface.  This
  *	performs the bridging function for locally originated
  *	packets.
+ *
  *	The mbuf has the Ethernet header already attached.  We must
  *	enqueue or free the mbuf before returning.
  */
 int
 bridge_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *sa,
     const struct rtentry *rt)
+{
 	struct ether_header *eh;
 	struct ifnet *dst_if;
 	struct bridge_softc *sc;
 	int s;
 	/*
 	 * bridge_output() is called from ether_output(), furthermore
 	 * ifp argument doesn't point to bridge(4). So, don't assert
 	 * IFEF_MPSAFE here.
 	 */
 	if (m->m_len < ETHER_HDR_LEN) {
 		m = m_pullup(m, ETHER_HDR_LEN);
 		if (m == NULL)
 			return 0;
+	}
 	eh = mtod(m, struct ether_header *);
 	sc = ifp->if_bridge;
 	if (ETHER_IS_MULTICAST(eh->ether_dhost)) {
 		if (memcmp(etherbroadcastaddr,
 		    eh->ether_dhost, ETHER_ADDR_LEN) == 0)
 			m->m_flags |= M_BCAST;
 		else
 			m->m_flags |= M_MCAST;
+	}
 	/*
 	 * If bridge is down, but the original output interface is up,
 	 * go ahead and send out that interface.  Otherwise, the packet
 	 * is dropped below.
 	 */
 	if (__predict_false(sc == NULL) ||
 	    (sc->sc_if.if_flags & IFF_RUNNING) == 0) {
 		dst_if = ifp;
 		goto sendunicast;
+	}
 	/*
 	 * If the packet is a multicast, or we don't know a better way to
 	 * get there, send to all interfaces.
 	 */
 	if ((m->m_flags & (M_MCAST | M_BCAST)) != 0)
 		dst_if = NULL;
 	else
 		dst_if = bridge_rtlookup(sc, eh->ether_dhost);
 	if (dst_if == NULL) {
 		/* XXX Should call bridge_broadcast, but there are locking
 		 * issues which need resolving first. */
 		struct bridge_iflist *bif;
 		struct mbuf *mc;
 		bool used = false;
 		BRIDGE_PSZ_RENTER(s);
 		BRIDGE_IFLIST_READER_FOREACH(bif, sc) {
 			struct psref psref;
 			bridge_acquire_member(sc, bif, &psref);
 			BRIDGE_PSZ_REXIT(s);
 			dst_if = bif->bif_ifp;
 			if ((dst_if->if_flags & IFF_RUNNING) == 0)
 				goto next;
 			/*
 			 * If this is not the original output interface,
 			 * and the interface is participating in spanning
 			 * tree, make sure the port is in a state that
 			 * allows forwarding.
 			 */
 			if (dst_if != ifp &&
 			    (bif->bif_flags & IFBIF_STP) != 0) {
 				switch (bif->bif_state) {
 				case BSTP_IFSTATE_BLOCKING:
 				case BSTP_IFSTATE_LISTENING:
 				case BSTP_IFSTATE_DISABLED:
 					goto next;
+				}
+			}
 			if (PSLIST_READER_NEXT(bif, struct bridge_iflist,
 			    bif_next) == NULL &&
 			    ((m->m_flags & (M_MCAST | M_BCAST)) == 0 ||
 			    dst_if == ifp))
+			{
 				used = true;
 				mc = m;
 			} else {
 				mc = m_copym(m, 0, M_COPYALL, M_NOWAIT);
 				if (mc == NULL) {
 					sc->sc_if.if_oerrors++;
 					goto next;
+				}
+			}
 			bridge_enqueue(sc, dst_if, mc, 0);
 			if ((m->m_flags & (M_MCAST | M_BCAST)) != 0 &&
 			    dst_if != ifp)
+			{
 				if (PSLIST_READER_NEXT(bif,
 				    struct bridge_iflist, bif_next) == NULL)
+				{
 					used = true;
 					mc = m;
 				} else {
 					mc = m_copym(m, 0, M_COPYALL,
 					    M_DONTWAIT);
 					if (mc == NULL) {
 						sc->sc_if.if_oerrors++;
 						goto next;
+					}
+				}
 				m_set_rcvif(mc, dst_if);
 				mc->m_flags &= ~M_PROMISC;
 #ifndef NET_MPSAFE
 				s = splsoftnet();
 #endif
 				ether_input(dst_if, mc);
 #ifndef NET_MPSAFE
 				splx(s);
 #endif
+			}
 next:
 			BRIDGE_PSZ_RENTER(s);
 			bridge_release_member(sc, bif, &psref);
 			/* Guarantee we don't re-enter the loop as we already
 			 * decided we're at the end. */
 			if (used)
 				break;
+		}
 		BRIDGE_PSZ_REXIT(s);
 		if (!used)
 			m_freem(m);
 		return 0;
+	}
  sendunicast:
 	/*
 	 * XXX Spanning tree consideration here?
 	 */
 	if ((dst_if->if_flags & IFF_RUNNING) == 0) {
 		m_freem(m);
 		return 0;
+	}
 	bridge_enqueue(sc, dst_if, m, 0);
 	return 0;
+}
 /*
  * bridge_start:
+ *
  *	Start output on a bridge.
+ *
  *	NOTE: This routine should never be called in this implementation.
  */
 static void
 bridge_start(struct ifnet *ifp)
+{
 	printf("%s: bridge_start() called\n", ifp->if_xname);
+}
 /*
  * bridge_forward:
+ *
  *	The forwarding function of the bridge.
  */
 static void
 bridge_forward(struct bridge_softc *sc, struct mbuf *m)
+{
 	struct bridge_iflist *bif;
 	struct ifnet *src_if, *dst_if;
 	struct ether_header *eh;
 	struct psref psref;
 	struct psref psref_src;
 	DECLARE_LOCK_VARIABLE;
 	if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
 		return;
 	src_if = m_get_rcvif_psref(m, &psref_src);
 	if (src_if == NULL) {
 		/* Interface is being destroyed? */
 		m_freem(m);
 		goto out;
+	}
 	sc->sc_if.if_ipackets++;
 	sc->sc_if.if_ibytes += m->m_pkthdr.len;
 	/*
 	 * Look up the bridge_iflist.
 	 */
 	bif = bridge_lookup_member_if(sc, src_if, &psref);
 	if (bif == NULL) {
 		/* Interface is not a bridge member (anymore?) */
 		m_freem(m);
 		goto out;
+	}
 	if (bif->bif_flags & IFBIF_STP) {
 		switch (bif->bif_state) {
 		case BSTP_IFSTATE_BLOCKING:
 		case BSTP_IFSTATE_LISTENING:
 		case BSTP_IFSTATE_DISABLED:
 			m_freem(m);
 			bridge_release_member(sc, bif, &psref);
 			goto out;
+		}
+	}
 	eh = mtod(m, struct ether_header *);
 	/*
 	 * If the interface is learning, and the source
 	 * address is valid and not multicast, record
 	 * the address.
 	 */
 	if ((bif->bif_flags & IFBIF_LEARNING) != 0 &&
 	    ETHER_IS_MULTICAST(eh->ether_shost) == 0 &&
 	    (eh->ether_shost[0] == 0 &&
 	     eh->ether_shost[1] == 0 &&
 	     eh->ether_shost[2] == 0 &&
 	     eh->ether_shost[3] == 0 &&
 	     eh->ether_shost[4] == 0 &&
 	     eh->ether_shost[5] == 0) == 0) {
 		(void) bridge_rtupdate(sc, eh->ether_shost,
 		    src_if, 0, IFBAF_DYNAMIC);
+	}
 	if ((bif->bif_flags & IFBIF_STP) != 0 &&
 	    bif->bif_state == BSTP_IFSTATE_LEARNING) {
 		m_freem(m);
 		bridge_release_member(sc, bif, &psref);
 		goto out;
+	}
 	bridge_release_member(sc, bif, &psref);
 	/*
 	 * At this point, the port either doesn't participate
 	 * in spanning tree or it is in the forwarding state.
 	 */
 	/*
 	 * If the packet is unicast, destined for someone on
 	 * "this" side of the bridge, drop it.
 	 */
 	if ((m->m_flags & (M_BCAST|M_MCAST)) == 0) {
 		dst_if = bridge_rtlookup(sc, eh->ether_dhost);
 		if (src_if == dst_if) {
 			m_freem(m);
 			goto out;
+		}
 	} else {
 		/* ...forward it to all interfaces. */
 		sc->sc_if.if_imcasts++;
 		dst_if = NULL;
+	}
 	if (pfil_run_hooks(sc->sc_if.if_pfil, &m, src_if, PFIL_IN) != 0) {
 		if (m != NULL)
 			m_freem(m);
 		goto out;
+	}
 	if (m == NULL)
 		goto out;
 	if (dst_if == NULL) {
 		bridge_broadcast(sc, src_if, m);
 		goto out;
+	}
 	m_put_rcvif_psref(src_if, &psref_src);
 	src_if = NULL;
 	/*
 	 * At this point, we're dealing with a unicast frame
 	 * going to a different interface.
 	 */
 	if ((dst_if->if_flags & IFF_RUNNING) == 0) {
 		m_freem(m);
 		goto out;
+	}
 	bif = bridge_lookup_member_if(sc, dst_if, &psref);
 	if (bif == NULL) {
 		/* Not a member of the bridge (anymore?) */
 		m_freem(m);
 		goto out;
+	}
 	if (bif->bif_flags & IFBIF_STP) {
 		switch (bif->bif_state) {
 		case BSTP_IFSTATE_DISABLED:
 		case BSTP_IFSTATE_BLOCKING:
 			m_freem(m);
 			bridge_release_member(sc, bif, &psref);
 			goto out;
+		}
+	}
 	bridge_release_member(sc, bif, &psref);
 	ACQUIRE_GLOBAL_LOCKS();
 	bridge_enqueue(sc, dst_if, m, 1);
 	RELEASE_GLOBAL_LOCKS();
 out:
 	if (src_if != NULL)
 		m_put_rcvif_psref(src_if, &psref_src);
 	return;
+}
 static bool
 bstp_state_before_learning(struct bridge_iflist *bif)
+{
 	if (bif->bif_flags & IFBIF_STP) {
 		switch (bif->bif_state) {
 		case BSTP_IFSTATE_BLOCKING:
 		case BSTP_IFSTATE_LISTENING:
 		case BSTP_IFSTATE_DISABLED:
 			return true;
+		}
+	}
 	return false;
+}
 static bool
 bridge_ourether(struct bridge_iflist *bif, struct ether_header *eh, int src)
+{
 	uint8_t *ether = src ? eh->ether_shost : eh->ether_dhost;
 	if (memcmp(CLLADDR(bif->bif_ifp->if_sadl), ether, ETHER_ADDR_LEN) == 0
 #if NCARP > 0
 	    || (bif->bif_ifp->if_carp &&
 	        carp_ourether(bif->bif_ifp->if_carp, eh, IFT_ETHER, src) != NULL)
 #endif /* NCARP > 0 */
+	    )
 		return true;
 	return false;
+}
 /*
  * bridge_input:
+ *
  *	Receive input from a member interface.  Queue the packet for
  *	bridging if it is not for us.
  */
 static void
 bridge_input(struct ifnet *ifp, struct mbuf *m)
+{
 	struct bridge_softc *sc = ifp->if_bridge;
 	struct bridge_iflist *bif;
 	struct ether_header *eh;
 	struct psref psref;
 	int bound;
 	DECLARE_LOCK_VARIABLE;
 	KASSERT(!cpu_intr_p());
 	if (__predict_false(sc == NULL) ||
 	    (sc->sc_if.if_flags & IFF_RUNNING) == 0) {
 		ACQUIRE_GLOBAL_LOCKS();
 		ether_input(ifp, m);
 		RELEASE_GLOBAL_LOCKS();
 		return;
+	}
 	bound = curlwp_bind();
 	bif = bridge_lookup_member_if(sc, ifp, &psref);
 	if (bif == NULL) {
 		curlwp_bindx(bound);
 		ACQUIRE_GLOBAL_LOCKS();
 		ether_input(ifp, m);
 		RELEASE_GLOBAL_LOCKS();
 		return;
+	}
 	eh = mtod(m, struct ether_header *);
 	if (ETHER_IS_MULTICAST(eh->ether_dhost)) {
 		if (memcmp(etherbroadcastaddr,
 		    eh->ether_dhost, ETHER_ADDR_LEN) == 0)
 			m->m_flags |= M_BCAST;
 		else
 			m->m_flags |= M_MCAST;
+	}
 	/*
 	 * A 'fast' path for packets addressed to interfaces that are
 	 * part of this bridge.
 	 */
 	if (!(m->m_flags & (M_BCAST|M_MCAST)) &&
 	    !bstp_state_before_learning(bif)) {
 		struct bridge_iflist *_bif;
 		struct ifnet *_ifp = NULL;
 		int s;
 		struct psref _psref;
 		BRIDGE_PSZ_RENTER(s);
 		BRIDGE_IFLIST_READER_FOREACH(_bif, sc) {
 			/* It is destined for us. */
 			if (bridge_ourether(_bif, eh, 0)) {
 				bridge_acquire_member(sc, _bif, &_psref);
 				BRIDGE_PSZ_REXIT(s);
 				if (_bif->bif_flags & IFBIF_LEARNING)
 					(void) bridge_rtupdate(sc,
 					    eh->ether_shost, ifp, 0, IFBAF_DYNAMIC);
 				m_set_rcvif(m, _bif->bif_ifp);
 				_ifp = _bif->bif_ifp;
 				bridge_release_member(sc, _bif, &_psref);
 				goto out;
+			}
 			/* We just received a packet that we sent out. */
 			if (bridge_ourether(_bif, eh, 1))
 				break;
+		}
 		BRIDGE_PSZ_REXIT(s);
 out:
 		if (_bif != NULL) {
 			bridge_release_member(sc, bif, &psref);
 			curlwp_bindx(bound);
 			if (_ifp != NULL) {
 				m->m_flags &= ~M_PROMISC;
 				ACQUIRE_GLOBAL_LOCKS();
 				ether_input(_ifp, m);
 				RELEASE_GLOBAL_LOCKS();
 			} else
 				m_freem(m);
 			return;
+		}
+	}
 	/* Tap off 802.1D packets; they do not get forwarded. */
 	if (bif->bif_flags & IFBIF_STP &&
 	    memcmp(eh->ether_dhost, bstp_etheraddr, ETHER_ADDR_LEN) == 0) {
 		bstp_input(sc, bif, m);
 		bridge_release_member(sc, bif, &psref);
 		curlwp_bindx(bound);
 		return;
+	}
 	/*
 	 * A normal switch would discard the packet here, but that's not what
 	 * we've done historically. This also prevents some obnoxious behaviour.
 	 */
 	if (bstp_state_before_learning(bif)) {
 		bridge_release_member(sc, bif, &psref);
 		curlwp_bindx(bound);
 		ACQUIRE_GLOBAL_LOCKS();
 		ether_input(ifp, m);
 		RELEASE_GLOBAL_LOCKS();
 		return;
+	}
 	bridge_release_member(sc, bif, &psref);
 	bridge_forward(sc, m);
 	curlwp_bindx(bound);
+}
 /*
  * bridge_broadcast:
+ *
  *	Send a frame to all interfaces that are members of
  *	the bridge, except for the one on which the packet
  *	arrived.
  */
 static void
 bridge_broadcast(struct bridge_softc *sc, struct ifnet *src_if,
     struct mbuf *m)
+{
 	struct bridge_iflist *bif;
 	struct mbuf *mc;
 	struct ifnet *dst_if;
 	bool bmcast;
 	int s;
 	DECLARE_LOCK_VARIABLE;
 	bmcast = m->m_flags & (M_BCAST|M_MCAST);
 	BRIDGE_PSZ_RENTER(s);
 	BRIDGE_IFLIST_READER_FOREACH(bif, sc) {
 		struct psref psref;
 		bridge_acquire_member(sc, bif, &psref);
 		BRIDGE_PSZ_REXIT(s);
 		dst_if = bif->bif_ifp;
 		if (bif->bif_flags & IFBIF_STP) {
 			switch (bif->bif_state) {
 			case BSTP_IFSTATE_BLOCKING:
 			case BSTP_IFSTATE_DISABLED:
 				goto next;
+			}
+		}
 		if ((bif->bif_flags & IFBIF_DISCOVER) == 0 && !bmcast)
 			goto next;
 		if ((dst_if->if_flags & IFF_RUNNING) == 0)
 			goto next;
 		if (dst_if != src_if) {
 			mc = m_copym(m, 0, M_COPYALL, M_DONTWAIT);
 			if (mc == NULL) {
 				sc->sc_if.if_oerrors++;
 				goto next;
+			}
 			ACQUIRE_GLOBAL_LOCKS();
 			bridge_enqueue(sc, dst_if, mc, 1);
 			RELEASE_GLOBAL_LOCKS();
+		}
 		if (bmcast) {
 			mc = m_copym(m, 0, M_COPYALL, M_DONTWAIT);
 			if (mc == NULL) {
 				sc->sc_if.if_oerrors++;
 				goto next;
+			}
 			m_set_rcvif(mc, dst_if);
 			mc->m_flags &= ~M_PROMISC;
 			ACQUIRE_GLOBAL_LOCKS();
 			ether_input(dst_if, mc);
 			RELEASE_GLOBAL_LOCKS();
+		}
 next:
 		BRIDGE_PSZ_RENTER(s);
 		bridge_release_member(sc, bif, &psref);
+	}
 	BRIDGE_PSZ_REXIT(s);
 	m_freem(m);
+}
 static int
 bridge_rtalloc(struct bridge_softc *sc, const uint8_t *dst,
     struct bridge_rtnode **brtp)
+{
 	struct bridge_rtnode *brt;
 	int error;
 	if (sc->sc_brtcnt >= sc->sc_brtmax)
 		return ENOSPC;
 	/*
 	 * Allocate a new bridge forwarding node, and
 	 * initialize the expiration time and Ethernet
 	 * address.
 	 */
 	brt = pool_get(&bridge_rtnode_pool, PR_NOWAIT);
 	if (brt == NULL)
 		return ENOMEM;
 	memset(brt, 0, sizeof(*brt));
 	brt->brt_expire = time_uptime + sc->sc_brttimeout;
 	brt->brt_flags = IFBAF_DYNAMIC;
 	memcpy(brt->brt_addr, dst, ETHER_ADDR_LEN);
 	BRIDGE_RT_LOCK(sc);
 	error = bridge_rtnode_insert(sc, brt);
 	BRIDGE_RT_UNLOCK(sc);
 	if (error != 0) {
 		pool_put(&bridge_rtnode_pool, brt);
 		return error;
+	}
 	*brtp = brt;
 	return 0;
+}
 /*
  * bridge_rtupdate:
+ *
  *	Add a bridge routing entry.
  */
 static int
 bridge_rtupdate(struct bridge_softc *sc, const uint8_t *dst,
     struct ifnet *dst_if, int setflags, uint8_t flags)
+{
 	struct bridge_rtnode *brt;
 	int s;
 again:
 	/*
 	 * A route for this destination might already exist.  If so,
 	 * update it, otherwise create a new one.
 	 */
 	BRIDGE_RT_RENTER(s);
 	brt = bridge_rtnode_lookup(sc, dst);
 	if (brt != NULL) {
 		brt->brt_ifp = dst_if;
 		if (setflags) {
 			brt->brt_flags = flags;
 			if (flags & IFBAF_STATIC)
 				brt->brt_expire = 0;
 			else
 				brt->brt_expire = time_uptime + sc->sc_brttimeout;
 		} else {
 			if ((brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC)
 				brt->brt_expire = time_uptime + sc->sc_brttimeout;
+		}
+	}
 	BRIDGE_RT_REXIT(s);
 	if (brt == NULL) {
 		int r;
 		r = bridge_rtalloc(sc, dst, &brt);
 		if (r != 0)
 			return r;
 		goto again;
+	}
 	return 0;
+}
 /*
  * bridge_rtlookup:
+ *
  *	Lookup the destination interface for an address.
  */
 static struct ifnet *
 bridge_rtlookup(struct bridge_softc *sc, const uint8_t *addr)
+{
 	struct bridge_rtnode *brt;
 	struct ifnet *ifs = NULL;
 	int s;
 	BRIDGE_RT_RENTER(s);
 	brt = bridge_rtnode_lookup(sc, addr);
 	if (brt != NULL)
 		ifs = brt->brt_ifp;
 	BRIDGE_RT_REXIT(s);
 	return ifs;
+}
 typedef bool (*bridge_iterate_cb_t)
     (struct bridge_softc *, struct bridge_rtnode *, bool *, void *);
 /*
  * bridge_rtlist_iterate_remove:
+ *
  *	It iterates on sc->sc_rtlist and removes rtnodes of it which func
  *	callback judges to remove. Removals of rtnodes are done in a manner
  *	of pserialize. To this end, all kmem_* operations are placed out of
  *	mutexes.
  */
 static void
 bridge_rtlist_iterate_remove(struct bridge_softc *sc, bridge_iterate_cb_t func, void *arg)
+{
 	struct bridge_rtnode *brt, *nbrt;
 	struct bridge_rtnode **brt_list;
 	int i, count;
 retry:
 	count = sc->sc_brtcnt;
 	if (count == 0)
 		return;
 	brt_list = kmem_alloc(sizeof(*brt_list) * count, KM_SLEEP);
 	BRIDGE_RT_LOCK(sc);
 	if (__predict_false(sc->sc_brtcnt > count)) {
 		/* The rtnodes increased, we need more memory */
 		BRIDGE_RT_UNLOCK(sc);
 		kmem_free(brt_list, sizeof(*brt_list) * count);
 		goto retry;
+	}
 	i = 0;
 	LIST_FOREACH_SAFE(brt, &sc->sc_rtlist, brt_list, nbrt) {
 		bool need_break = false;
 		if (func(sc, brt, &need_break, arg)) {
 			bridge_rtnode_remove(sc, brt);
 			brt_list[i++] = brt;
+		}
 		if (need_break)
 			break;
+	}
 	if (i > 0)
 		BRIDGE_RT_PSZ_PERFORM(sc);
 	BRIDGE_RT_UNLOCK(sc);
 	while (--i >= 0)
 		bridge_rtnode_destroy(brt_list[i]);
 	kmem_free(brt_list, sizeof(*brt_list) * count);
+}
 static bool
 bridge_rttrim0_cb(struct bridge_softc *sc, struct bridge_rtnode *brt,
     bool *need_break, void *arg)
+{
 	if ((brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC) {
 		/* Take into account of the subsequent removal */
 		if ((sc->sc_brtcnt - 1) <= sc->sc_brtmax)
 			*need_break = true;
 		return true;
 	} else
 		return false;
+}
 static void
 bridge_rttrim0(struct bridge_softc *sc)
+{
 	bridge_rtlist_iterate_remove(sc, bridge_rttrim0_cb, NULL);
+}
 /*
  * bridge_rttrim:
+ *
  *	Trim the routine table so that we have a number
  *	of routing entries less than or equal to the
  *	maximum number.
  */
 static void
 bridge_rttrim(struct bridge_softc *sc)
+{
 	/* Make sure we actually need to do this. */
 	if (sc->sc_brtcnt <= sc->sc_brtmax)
 		return;
 	/* Force an aging cycle; this might trim enough addresses. */
 	bridge_rtage(sc);
 	if (sc->sc_brtcnt <= sc->sc_brtmax)
 		return;
 	bridge_rttrim0(sc);
 	return;
+}
 /*
  * bridge_timer:
+ *
  *	Aging timer for the bridge.
  */
 static void
 bridge_timer(void *arg)
+{
 	struct bridge_softc *sc = arg;
 	workqueue_enqueue(sc->sc_rtage_wq, &sc->sc_rtage_wk, NULL);
+}
 static void
 bridge_rtage_work(struct work *wk, void *arg)
+{
 	struct bridge_softc *sc = arg;
 	KASSERT(wk == &sc->sc_rtage_wk);
 	bridge_rtage(sc);
 	if (sc->sc_if.if_flags & IFF_RUNNING)
 		callout_reset(&sc->sc_brcallout,
 		    bridge_rtable_prune_period * hz, bridge_timer, sc);
+}
 static bool
 bridge_rtage_cb(struct bridge_softc *sc, struct bridge_rtnode *brt,
     bool *need_break, void *arg)
+{
 	if ((brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC &&
 	    time_uptime >= brt->brt_expire)
 		return true;
 	else
 		return false;
+}
 /*
  * bridge_rtage:
+ *
  *	Perform an aging cycle.
  */
 static void
 bridge_rtage(struct bridge_softc *sc)
+{
 	bridge_rtlist_iterate_remove(sc, bridge_rtage_cb, NULL);
+}
 static bool
 bridge_rtflush_cb(struct bridge_softc *sc, struct bridge_rtnode *brt,
     bool *need_break, void *arg)
+{
 	int full = *(int*)arg;
 	if (full || (brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC)
 		return true;
 	else
 		return false;
+}
 /*
  * bridge_rtflush:
+ *
  *	Remove all dynamic addresses from the bridge.
  */
 static void
 bridge_rtflush(struct bridge_softc *sc, int full)
+{
 	bridge_rtlist_iterate_remove(sc, bridge_rtflush_cb, &full);
+}
 /*
  * bridge_rtdaddr:
+ *
  *	Remove an address from the table.
  */
 static int
 bridge_rtdaddr(struct bridge_softc *sc, const uint8_t *addr)
+{
 	struct bridge_rtnode *brt;
 	BRIDGE_RT_LOCK(sc);
 	if ((brt = bridge_rtnode_lookup(sc, addr)) == NULL) {
 		BRIDGE_RT_UNLOCK(sc);
 		return ENOENT;
+	}
 	bridge_rtnode_remove(sc, brt);
 	BRIDGE_RT_PSZ_PERFORM(sc);
 	BRIDGE_RT_UNLOCK(sc);
 	bridge_rtnode_destroy(brt);
 	return 0;
+}
 /*
  * bridge_rtdelete:
+ *
  *	Delete routes to a speicifc member interface.
  */
 static void
 bridge_rtdelete(struct bridge_softc *sc, struct ifnet *ifp)
+{
 	struct bridge_rtnode *brt;
 	BRIDGE_RT_LOCK(sc);
 	LIST_FOREACH(brt, &sc->sc_rtlist, brt_list) {
 		if (brt->brt_ifp == ifp)
 			break;
+	}
 	if (brt == NULL) {
 		BRIDGE_RT_UNLOCK(sc);
 		return;
+	}
 	bridge_rtnode_remove(sc, brt);
 	BRIDGE_RT_PSZ_PERFORM(sc);
 	BRIDGE_RT_UNLOCK(sc);
 	bridge_rtnode_destroy(brt);
+}
 /*
  * bridge_rtable_init:
+ *
  *	Initialize the route table for this bridge.
  */
 static void
 bridge_rtable_init(struct bridge_softc *sc)
+{
 	int i;
 	sc->sc_rthash = kmem_alloc(sizeof(*sc->sc_rthash) * BRIDGE_RTHASH_SIZE,
 	    KM_SLEEP);
 	for (i = 0; i < BRIDGE_RTHASH_SIZE; i++)
 		LIST_INIT(&sc->sc_rthash[i]);
 	sc->sc_rthash_key = cprng_fast32();
 	LIST_INIT(&sc->sc_rtlist);
 	sc->sc_rtlist_psz = pserialize_create();
 	sc->sc_rtlist_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_SOFTNET);
+}
 /*
  * bridge_rtable_fini:
+ *
  *	Deconstruct the route table for this bridge.
  */
 static void
 bridge_rtable_fini(struct bridge_softc *sc)
+{
 	kmem_free(sc->sc_rthash, sizeof(*sc->sc_rthash) * BRIDGE_RTHASH_SIZE);
 	if (sc->sc_rtlist_lock)
 		mutex_obj_free(sc->sc_rtlist_lock);
 	if (sc->sc_rtlist_psz)
 		pserialize_destroy(sc->sc_rtlist_psz);
+}
 /*
  * The following hash function is adapted from "Hash Functions" by Bob Jenkins
  * ("Algorithm Alley", Dr. Dobbs Journal, September 1997).
  */
 #define	mix(a, b, c)							\

 @@ -1,2074 +1,2075 @@
-/*	$NetBSD: if_spppsubr.c,v 1.177 2017/12/11 03:29:20 ozaki-r Exp $	 */
+/*	$NetBSD: if_spppsubr.c,v 1.178 2017/12/28 07:06:36 ozaki-r Exp $	 */
 /*
  * Synchronous PPP/Cisco link level subroutines.
  * Keepalive protocol implemented in both Cisco and PPP modes.
+ *
  * Copyright (C) 1994-1996 Cronyx Engineering Ltd.
  * Author: Serge Vakulenko, <vak@cronyx.ru>
+ *
  * Heavily revamped to conform to RFC 1661.
  * Copyright (C) 1997, Joerg Wunsch.
+ *
  * RFC2472 IPv6CP support.
  * Copyright (C) 2000, Jun-ichiro itojun Hagino <itojun@iijlab.net>.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  * 1. Redistributions of source code must retain the above copyright notice,
  *    this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright notice,
  *    this list of conditions and the following disclaimer in the documentation
  *    and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE FREEBSD PROJECT ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE FREEBSD PROJECT OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
+ *
  * From: Version 2.4, Thu Apr 30 17:17:21 MSD 1997
+ *
  * From: if_spppsubr.c,v 1.39 1998/04/04 13:26:03 phk Exp
+ *
  * From: Id: if_spppsubr.c,v 1.23 1999/02/23 14:47:50 hm Exp
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_spppsubr.c,v 1.177 2017/12/11 03:29:20 ozaki-r Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_spppsubr.c,v 1.178 2017/12/28 07:06:36 ozaki-r Exp $");
 #if defined(_KERNEL_OPT)
 #include "opt_inet.h"
 #include "opt_modular.h"
 #include "opt_compat_netbsd.h"
 #include "opt_net_mpsafe.h"
 #endif
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/sockio.h>
 #include <sys/socket.h>
 #include <sys/syslog.h>
 #include <sys/malloc.h>
 #include <sys/mbuf.h>
 #include <sys/callout.h>
 #include <sys/md5.h>
 #include <sys/inttypes.h>
 #include <sys/kauth.h>
 #include <sys/cprng.h>
 #include <sys/module.h>
 #include <sys/workqueue.h>
 #include <sys/atomic.h>
 #include <net/if.h>
 #include <net/netisr.h>
 #include <net/if_types.h>
 #include <net/route.h>
 #include <net/ppp_defs.h>
 #include <netinet/in.h>
 #include <netinet/in_systm.h>
 #include <netinet/in_var.h>
 #ifdef INET
 #include <netinet/ip.h>
 #include <netinet/tcp.h>
 #endif
 #include <net/ethertypes.h>
 #ifdef INET6
 #include <netinet6/scope6_var.h>
 #endif
 #include <net/if_sppp.h>
 #include <net/if_spppvar.h>
 #ifdef NET_MPSAFE
 #define SPPPSUBR_MPSAFE	1
 #endif
 #define	LCP_KEEPALIVE_INTERVAL		10	/* seconds between checks */
 #define LOOPALIVECNT     		3	/* loopback detection tries */
 #define DEFAULT_MAXALIVECNT    		3	/* max. missed alive packets */
 #define	DEFAULT_NORECV_TIME		15	/* before we get worried */
 #define DEFAULT_MAX_AUTH_FAILURES	5	/* max. auth. failures */
 /*
  * Interface flags that can be set in an ifconfig command.
+ *
  * Setting link0 will make the link passive, i.e. it will be marked
  * as being administrative openable, but won't be opened to begin
  * with.  Incoming calls will be answered, or subsequent calls with
  * -link1 will cause the administrative open of the LCP layer.
+ *
  * Setting link1 will cause the link to auto-dial only as packets
  * arrive to be sent.
+ *
  * Setting IFF_DEBUG will syslog the option negotiation and state
  * transitions at level kern.debug.  Note: all logs consistently look
  * like
+ *
  *   <if-name><unit>: <proto-name> <additional info...>
+ *
  * with <if-name><unit> being something like "bppp0", and <proto-name>
  * being one of "lcp", "ipcp", "cisco", "chap", "pap", etc.
  */
 #define IFF_PASSIVE	IFF_LINK0	/* wait passively for connection */
 #define IFF_AUTO	IFF_LINK1	/* auto-dial on output */
 #define CONF_REQ	1		/* PPP configure request */
 #define CONF_ACK	2		/* PPP configure acknowledge */
 #define CONF_NAK	3		/* PPP configure negative ack */
 #define CONF_REJ	4		/* PPP configure reject */
 #define TERM_REQ	5		/* PPP terminate request */
 #define TERM_ACK	6		/* PPP terminate acknowledge */
 #define CODE_REJ	7		/* PPP code reject */
 #define PROTO_REJ	8		/* PPP protocol reject */
 #define ECHO_REQ	9		/* PPP echo request */
 #define ECHO_REPLY	10		/* PPP echo reply */
 #define DISC_REQ	11		/* PPP discard request */
 #define LCP_OPT_MRU		1	/* maximum receive unit */
 #define LCP_OPT_ASYNC_MAP	2	/* async control character map */
 #define LCP_OPT_AUTH_PROTO	3	/* authentication protocol */
 #define LCP_OPT_QUAL_PROTO	4	/* quality protocol */
 #define LCP_OPT_MAGIC		5	/* magic number */
 #define LCP_OPT_RESERVED	6	/* reserved */
 #define LCP_OPT_PROTO_COMP	7	/* protocol field compression */
 #define LCP_OPT_ADDR_COMP	8	/* address/control field compression */
 #define IPCP_OPT_ADDRESSES	1	/* both IP addresses; deprecated */
 #define IPCP_OPT_COMPRESSION	2	/* IP compression protocol */
 #define IPCP_OPT_ADDRESS	3	/* local IP address */
 #define	IPCP_OPT_PRIMDNS	129	/* primary remote dns address */
 #define	IPCP_OPT_SECDNS		131	/* secondary remote dns address */
 #define IPCP_UPDATE_LIMIT	8	/* limit of pending IP updating job */
 #define IPCP_SET_ADDRS		1	/* marker for IP address setting job */
 #define IPCP_CLEAR_ADDRS	2	/* marker for IP address clearing job */
 #define IPV6CP_OPT_IFID		1	/* interface identifier */
 #define IPV6CP_OPT_COMPRESSION	2	/* IPv6 compression protocol */
 #define PAP_REQ			1	/* PAP name/password request */
 #define PAP_ACK			2	/* PAP acknowledge */
 #define PAP_NAK			3	/* PAP fail */
 #define CHAP_CHALLENGE		1	/* CHAP challenge request */
 #define CHAP_RESPONSE		2	/* CHAP challenge response */
 #define CHAP_SUCCESS		3	/* CHAP response ok */
 #define CHAP_FAILURE		4	/* CHAP response failed */
 #define CHAP_MD5		5	/* hash algorithm - MD5 */
 #define CISCO_MULTICAST		0x8f	/* Cisco multicast address */
 #define CISCO_UNICAST		0x0f	/* Cisco unicast address */
 #define CISCO_KEEPALIVE		0x8035	/* Cisco keepalive protocol */
 #define CISCO_ADDR_REQ		0	/* Cisco address request */
 #define CISCO_ADDR_REPLY	1	/* Cisco address reply */
 #define CISCO_KEEPALIVE_REQ	2	/* Cisco keepalive request */
 /* states are named and numbered according to RFC 1661 */
 #define STATE_INITIAL	0
 #define STATE_STARTING	1
 #define STATE_CLOSED	2
 #define STATE_STOPPED	3
 #define STATE_CLOSING	4
 #define STATE_STOPPING	5
 #define STATE_REQ_SENT	6
 #define STATE_ACK_RCVD	7
 #define STATE_ACK_SENT	8
 #define STATE_OPENED	9
 struct ppp_header {
 	uint8_t address;
 	uint8_t control;
 	uint16_t protocol;
 } __packed;
 #define PPP_HEADER_LEN          sizeof (struct ppp_header)
 struct lcp_header {
 	uint8_t type;
 	uint8_t ident;
 	uint16_t len;
 } __packed;
 #define LCP_HEADER_LEN          sizeof (struct lcp_header)
 struct cisco_packet {
 	uint32_t type;
 	uint32_t par1;
 	uint32_t par2;
 	uint16_t rel;
 	uint16_t time0;
 	uint16_t time1;
 } __packed;
 #define CISCO_PACKET_LEN 18
 /*
  * We follow the spelling and capitalization of RFC 1661 here, to make
  * it easier comparing with the standard.  Please refer to this RFC in
  * case you can't make sense out of these abbreviation; it will also
  * explain the semantics related to the various events and actions.
  */
 struct cp {
 	u_short	proto;		/* PPP control protocol number */
 	u_char protoidx;	/* index into state table in struct sppp */
 	u_char flags;
 #define CP_LCP		0x01	/* this is the LCP */
 #define CP_AUTH		0x02	/* this is an authentication protocol */
 #define CP_NCP		0x04	/* this is a NCP */
 #define CP_QUAL		0x08	/* this is a quality reporting protocol */
 	const char *name;	/* name of this control protocol */
 	/* event handlers */
 	void	(*Up)(struct sppp *sp);
 	void	(*Down)(struct sppp *sp);
 	void	(*Open)(struct sppp *sp);
 	void	(*Close)(struct sppp *sp);
 	void	(*TO)(void *sp);
 	int	(*RCR)(struct sppp *sp, struct lcp_header *h, int len);
 	void	(*RCN_rej)(struct sppp *sp, struct lcp_header *h, int len);
 	void	(*RCN_nak)(struct sppp *sp, struct lcp_header *h, int len);
 	/* actions */
 	void	(*tlu)(struct sppp *sp);
 	void	(*tld)(struct sppp *sp);
 	void	(*tls)(struct sppp *sp);
 	void	(*tlf)(struct sppp *sp);
 	void	(*scr)(struct sppp *sp);
 };
 static struct sppp *spppq;
 static kmutex_t *spppq_lock = NULL;
 static callout_t keepalive_ch;
 #define SPPPQ_LOCK()	if (spppq_lock) \
 				mutex_enter(spppq_lock);
 #define SPPPQ_UNLOCK()	if (spppq_lock) \
 				mutex_exit(spppq_lock);
 #define SPPP_LOCK(_sp, _op)	rw_enter(&(_sp)->pp_lock, (_op))
 #define SPPP_UNLOCK(_sp)	rw_exit(&(_sp)->pp_lock)
 #define SPPP_WLOCKED(_sp)	rw_write_held(&(_sp)->pp_lock)
 #define SPPP_UPGRADE(_sp)	do{	\
 	SPPP_UNLOCK(_sp);		\
 	SPPP_LOCK(_sp, RW_WRITER);	\
 }while (0)
 #define SPPP_DOWNGRADE(_sp)	rw_downgrade(&(_sp)->pp_lock)
 #ifdef INET
 #ifndef SPPPSUBR_MPSAFE
 /*
  * The following disgusting hack gets around the problem that IP TOS
  * can't be set yet.  We want to put "interactive" traffic on a high
  * priority queue.  To decide if traffic is interactive, we check that
  * a) it is TCP and b) one of its ports is telnet, rlogin or ftp control.
+ *
  * XXX is this really still necessary?  - joerg -
  */
 static u_short interactive_ports[8] = {
 ,	513,	0,	0,
 ,	21,	0,	23,
 };
 #define INTERACTIVE(p)	(interactive_ports[(p) & 7] == (p))
 #endif /* SPPPSUBR_MPSAFE */
 #endif
 /* almost every function needs these */
 #define STDDCL							\
 	struct ifnet *ifp = &sp->pp_if;				\
 	int debug = ifp->if_flags & IFF_DEBUG
 static int sppp_output(struct ifnet *ifp, struct mbuf *m,
 		       const struct sockaddr *dst, const struct rtentry *rt);
 static void sppp_cisco_send(struct sppp *sp, int type, int32_t par1, int32_t par2);
 static void sppp_cisco_input(struct sppp *sp, struct mbuf *m);
 static void sppp_cp_input(const struct cp *cp, struct sppp *sp,
 			  struct mbuf *m);
 static void sppp_cp_send(struct sppp *sp, u_short proto, u_char type,
 			 u_char ident, u_short len, void *data);
 /* static void sppp_cp_timeout(void *arg); */
 static void sppp_cp_change_state(const struct cp *cp, struct sppp *sp,
 				 int newstate);
 static void sppp_auth_send(const struct cp *cp,
 			   struct sppp *sp, unsigned int type, unsigned int id,
 			   ...);
 static void sppp_up_event(const struct cp *cp, struct sppp *sp);
 static void sppp_down_event(const struct cp *cp, struct sppp *sp);
 static void sppp_open_event(const struct cp *cp, struct sppp *sp);
 static void sppp_close_event(const struct cp *cp, struct sppp *sp);
 static void sppp_to_event(const struct cp *cp, struct sppp *sp);
 static void sppp_null(struct sppp *sp);
 static void sppp_lcp_init(struct sppp *sp);
 static void sppp_lcp_up(struct sppp *sp);
 static void sppp_lcp_down(struct sppp *sp);
 static void sppp_lcp_open(struct sppp *sp);
 static void sppp_lcp_close(struct sppp *sp);
 static void sppp_lcp_TO(void *sp);
 static int sppp_lcp_RCR(struct sppp *sp, struct lcp_header *h, int len);
 static void sppp_lcp_RCN_rej(struct sppp *sp, struct lcp_header *h, int len);
 static void sppp_lcp_RCN_nak(struct sppp *sp, struct lcp_header *h, int len);
 static void sppp_lcp_tlu(struct sppp *sp);
 static void sppp_lcp_tld(struct sppp *sp);
 static void sppp_lcp_tls(struct sppp *sp);
 static void sppp_lcp_tlf(struct sppp *sp);
 static void sppp_lcp_scr(struct sppp *sp);
 static void sppp_lcp_check_and_close(struct sppp *sp);
 static int sppp_ncp_check(struct sppp *sp);
 static void sppp_ipcp_init(struct sppp *sp);
 static void sppp_ipcp_up(struct sppp *sp);
 static void sppp_ipcp_down(struct sppp *sp);
 static void sppp_ipcp_open(struct sppp *sp);
 static void sppp_ipcp_close(struct sppp *sp);
 static void sppp_ipcp_TO(void *sp);
 static int sppp_ipcp_RCR(struct sppp *sp, struct lcp_header *h, int len);
 static void sppp_ipcp_RCN_rej(struct sppp *sp, struct lcp_header *h, int len);
 static void sppp_ipcp_RCN_nak(struct sppp *sp, struct lcp_header *h, int len);
 static void sppp_ipcp_tlu(struct sppp *sp);
 static void sppp_ipcp_tld(struct sppp *sp);
 static void sppp_ipcp_tls(struct sppp *sp);
 static void sppp_ipcp_tlf(struct sppp *sp);
 static void sppp_ipcp_scr(struct sppp *sp);
 static void sppp_ipv6cp_init(struct sppp *sp);
 static void sppp_ipv6cp_up(struct sppp *sp);
 static void sppp_ipv6cp_down(struct sppp *sp);
 static void sppp_ipv6cp_open(struct sppp *sp);
 static void sppp_ipv6cp_close(struct sppp *sp);
 static void sppp_ipv6cp_TO(void *sp);
 static int sppp_ipv6cp_RCR(struct sppp *sp, struct lcp_header *h, int len);
 static void sppp_ipv6cp_RCN_rej(struct sppp *sp, struct lcp_header *h, int len);
 static void sppp_ipv6cp_RCN_nak(struct sppp *sp, struct lcp_header *h, int len);
 static void sppp_ipv6cp_tlu(struct sppp *sp);
 static void sppp_ipv6cp_tld(struct sppp *sp);
 static void sppp_ipv6cp_tls(struct sppp *sp);
 static void sppp_ipv6cp_tlf(struct sppp *sp);
 static void sppp_ipv6cp_scr(struct sppp *sp);
 static void sppp_pap_input(struct sppp *sp, struct mbuf *m);
 static void sppp_pap_init(struct sppp *sp);
 static void sppp_pap_open(struct sppp *sp);
 static void sppp_pap_close(struct sppp *sp);
 static void sppp_pap_TO(void *sp);
 static void sppp_pap_my_TO(void *sp);
 static void sppp_pap_tlu(struct sppp *sp);
 static void sppp_pap_tld(struct sppp *sp);
 static void sppp_pap_scr(struct sppp *sp);
 static void sppp_chap_input(struct sppp *sp, struct mbuf *m);
 static void sppp_chap_init(struct sppp *sp);
 static void sppp_chap_open(struct sppp *sp);
 static void sppp_chap_close(struct sppp *sp);
 static void sppp_chap_TO(void *sp);
 static void sppp_chap_tlu(struct sppp *sp);
 static void sppp_chap_tld(struct sppp *sp);
 static void sppp_chap_scr(struct sppp *sp);
 static const char *sppp_auth_type_name(u_short proto, u_char type);
 static const char *sppp_cp_type_name(u_char type);
 static const char *sppp_dotted_quad(uint32_t addr);
 static const char *sppp_ipcp_opt_name(u_char opt);
 #ifdef INET6
 static const char *sppp_ipv6cp_opt_name(u_char opt);
 #endif
 static const char *sppp_lcp_opt_name(u_char opt);
 static const char *sppp_phase_name(int phase);
 static const char *sppp_proto_name(u_short proto);
 static const char *sppp_state_name(int state);
 static int sppp_params(struct sppp *sp, u_long cmd, void *data);
 #ifdef INET
 static void sppp_get_ip_addrs(struct sppp *sp, uint32_t *src, uint32_t *dst,
 			      uint32_t *srcmask);
 static void sppp_set_ip_addrs_work(struct work *wk, struct sppp *sp);
 static void sppp_set_ip_addrs(struct sppp *sp);
 static void sppp_clear_ip_addrs_work(struct work *wk, struct sppp *sp);
 static void sppp_clear_ip_addrs(struct sppp *sp);
 static void sppp_update_ip_addrs_work(struct work *wk, void *arg);
 #endif
 static void sppp_keepalive(void *dummy);
 static void sppp_phase_network(struct sppp *sp);
 static void sppp_print_bytes(const u_char *p, u_short len);
 static void sppp_print_string(const char *p, u_short len);
 #ifdef INET6
 static void sppp_get_ip6_addrs(struct sppp *sp, struct in6_addr *src,
 				struct in6_addr *dst, struct in6_addr *srcmask);
 #ifdef IPV6CP_MYIFID_DYN
 static void sppp_set_ip6_addr(struct sppp *sp, const struct in6_addr *src);
 static void sppp_gen_ip6_addr(struct sppp *sp, const struct in6_addr *src);
 #endif
 static void sppp_suggest_ip6_addr(struct sppp *sp, struct in6_addr *src);
 #endif
 static void sppp_notify_up(struct sppp *);
 static void sppp_notify_down(struct sppp *);
 static void sppp_notify_tls_wlocked(struct sppp *);
 static void sppp_notify_tlf_wlocked(struct sppp *);
 #ifdef INET6
 static void sppp_notify_con_wlocked(struct sppp *);
 #endif
 static void sppp_notify_con(struct sppp *);
 static void sppp_notify_chg_wlocked(struct sppp *);
 /* our control protocol descriptors */
 static const struct cp lcp = {
 	PPP_LCP, IDX_LCP, CP_LCP, "lcp",
 	sppp_lcp_up, sppp_lcp_down, sppp_lcp_open, sppp_lcp_close,
 	sppp_lcp_TO, sppp_lcp_RCR, sppp_lcp_RCN_rej, sppp_lcp_RCN_nak,
 	sppp_lcp_tlu, sppp_lcp_tld, sppp_lcp_tls, sppp_lcp_tlf,
 	sppp_lcp_scr
 };
 static const struct cp ipcp = {
 	PPP_IPCP, IDX_IPCP,
 #ifdef INET
 	CP_NCP,	/*don't run IPCP if there's no IPv4 support*/
 #else
 ,
 #endif
 	"ipcp",
 	sppp_ipcp_up, sppp_ipcp_down, sppp_ipcp_open, sppp_ipcp_close,
 	sppp_ipcp_TO, sppp_ipcp_RCR, sppp_ipcp_RCN_rej, sppp_ipcp_RCN_nak,
 	sppp_ipcp_tlu, sppp_ipcp_tld, sppp_ipcp_tls, sppp_ipcp_tlf,
 	sppp_ipcp_scr
 };
 static const struct cp ipv6cp = {
 	PPP_IPV6CP, IDX_IPV6CP,
 #ifdef INET6	/*don't run IPv6CP if there's no IPv6 support*/
 	CP_NCP,
 #else
 ,
 #endif
 	"ipv6cp",
 	sppp_ipv6cp_up, sppp_ipv6cp_down, sppp_ipv6cp_open, sppp_ipv6cp_close,
 	sppp_ipv6cp_TO, sppp_ipv6cp_RCR, sppp_ipv6cp_RCN_rej, sppp_ipv6cp_RCN_nak,
 	sppp_ipv6cp_tlu, sppp_ipv6cp_tld, sppp_ipv6cp_tls, sppp_ipv6cp_tlf,
 	sppp_ipv6cp_scr
 };
 static const struct cp pap = {
 	PPP_PAP, IDX_PAP, CP_AUTH, "pap",
 	sppp_null, sppp_null, sppp_pap_open, sppp_pap_close,
 	sppp_pap_TO, 0, 0, 0,
 	sppp_pap_tlu, sppp_pap_tld, sppp_null, sppp_null,
 	sppp_pap_scr
 };
 static const struct cp chap = {
 	PPP_CHAP, IDX_CHAP, CP_AUTH, "chap",
 	sppp_null, sppp_null, sppp_chap_open, sppp_chap_close,
 	sppp_chap_TO, 0, 0, 0,
 	sppp_chap_tlu, sppp_chap_tld, sppp_null, sppp_null,
 	sppp_chap_scr
 };
 static const struct cp *cps[IDX_COUNT] = {
 	&lcp,			/* IDX_LCP */
 	&ipcp,			/* IDX_IPCP */
 	&ipv6cp,		/* IDX_IPV6CP */
 	&pap,			/* IDX_PAP */
 	&chap,			/* IDX_CHAP */
 };
 static void
 sppp_change_phase(struct sppp *sp, int phase)
+{
 	STDDCL;
 	KASSERT(SPPP_WLOCKED(sp));
 	if (sp->pp_phase == phase)
 		return;
 	sp->pp_phase = phase;
 	if (phase == SPPP_PHASE_NETWORK)
 		if_link_state_change(ifp, LINK_STATE_UP);
 	else
 		if_link_state_change(ifp, LINK_STATE_DOWN);
 	if (debug)
+	{
 		log(LOG_INFO, "%s: phase %s\n", ifp->if_xname,
 			sppp_phase_name(sp->pp_phase));
+	}
+}
 /*
  * Exported functions, comprising our interface to the lower layer.
  */
 /*
  * Process the received packet.
  */
 void
 sppp_input(struct ifnet *ifp, struct mbuf *m)
+{
 	struct ppp_header *h = NULL;
 	pktqueue_t *pktq = NULL;
 	struct ifqueue *inq = NULL;
 	uint16_t protocol;
 	struct sppp *sp = (struct sppp *)ifp;
 	int debug = ifp->if_flags & IFF_DEBUG;
 	int isr = 0;
 	SPPP_LOCK(sp, RW_READER);
 	if (ifp->if_flags & IFF_UP) {
 		/* Count received bytes, add hardware framing */
 		ifp->if_ibytes += m->m_pkthdr.len + sp->pp_framebytes;
 		/* Note time of last receive */
 		sp->pp_last_receive = time_uptime;
+	}
 	if (m->m_pkthdr.len <= PPP_HEADER_LEN) {
 		/* Too small packet, drop it. */
 		if (debug)
 			log(LOG_DEBUG,
 			    "%s: input packet is too small, %d bytes\n",
 			    ifp->if_xname, m->m_pkthdr.len);
 	  drop:
 		++ifp->if_ierrors;
 		++ifp->if_iqdrops;
 		m_freem(m);
 		SPPP_UNLOCK(sp);
 		return;
+	}
 	if (sp->pp_flags & PP_NOFRAMING) {
 		memcpy(&protocol, mtod(m, void *), 2);
 		protocol = ntohs(protocol);
 		m_adj(m, 2);
 	} else {
 		/* Get PPP header. */
 		h = mtod(m, struct ppp_header *);
 		m_adj(m, PPP_HEADER_LEN);
 		switch (h->address) {
 		case PPP_ALLSTATIONS:
 			if (h->control != PPP_UI)
 				goto invalid;
 			if (sp->pp_flags & PP_CISCO) {
 				if (debug)
 					log(LOG_DEBUG,
 					    "%s: PPP packet in Cisco mode "
 					    "<addr=0x%x ctrl=0x%x proto=0x%x>\n",
 					    ifp->if_xname,
 					    h->address, h->control, ntohs(h->protocol));
 				goto drop;
+			}
 			break;
 		case CISCO_MULTICAST:
 		case CISCO_UNICAST:
 			/* Don't check the control field here (RFC 1547). */
 			if (! (sp->pp_flags & PP_CISCO)) {
 				if (debug)
 					log(LOG_DEBUG,
 					    "%s: Cisco packet in PPP mode "
 					    "<addr=0x%x ctrl=0x%x proto=0x%x>\n",
 					    ifp->if_xname,
 					    h->address, h->control, ntohs(h->protocol));
 				goto drop;
+			}
 			switch (ntohs(h->protocol)) {
 			default:
 				++ifp->if_noproto;
 				goto invalid;
 			case CISCO_KEEPALIVE:
 				SPPP_UNLOCK(sp);
 				sppp_cisco_input((struct sppp *) ifp, m);
 				m_freem(m);
 				return;
 #ifdef INET
 			case ETHERTYPE_IP:
 				pktq = ip_pktq;
 				break;
 #endif
 #ifdef INET6
 			case ETHERTYPE_IPV6:
 				pktq = ip6_pktq;
 				break;
 #endif
+			}
 			goto queue_pkt;
 		default:        /* Invalid PPP packet. */
 		  invalid:
 			if (debug)
 				log(LOG_DEBUG,
 				    "%s: invalid input packet "
 				    "<addr=0x%x ctrl=0x%x proto=0x%x>\n",
 				    ifp->if_xname,
 				    h->address, h->control, ntohs(h->protocol));
 			goto drop;
+		}
 		protocol = ntohs(h->protocol);
+	}
 	switch (protocol) {
 	default:
 		if (sp->state[IDX_LCP] == STATE_OPENED) {
 			uint16_t prot = htons(protocol);
 			SPPP_UPGRADE(sp);
 			sppp_cp_send(sp, PPP_LCP, PROTO_REJ,
 			    ++sp->pp_seq[IDX_LCP], m->m_pkthdr.len + 2,
 			    &prot);
 			SPPP_DOWNGRADE(sp);
+		}
 		if (debug)
 			log(LOG_DEBUG,
 			    "%s: invalid input protocol "
 			    "<proto=0x%x>\n", ifp->if_xname, ntohs(protocol));
 		++ifp->if_noproto;
 		goto drop;
 	case PPP_LCP:
 		SPPP_UNLOCK(sp);
 		sppp_cp_input(&lcp, sp, m);
 		m_freem(m);
 		return;
 	case PPP_PAP:
 		SPPP_UNLOCK(sp);
 		if (sp->pp_phase >= SPPP_PHASE_AUTHENTICATE) {
 			sppp_pap_input(sp, m);
+		}
 		m_freem(m);
 		return;
 	case PPP_CHAP:
 		SPPP_UNLOCK(sp);
 		if (sp->pp_phase >= SPPP_PHASE_AUTHENTICATE) {
 			sppp_chap_input(sp, m);
+		}
 		m_freem(m);
 		return;
 #ifdef INET
 	case PPP_IPCP:
 		SPPP_UNLOCK(sp);
 		if (sp->pp_phase == SPPP_PHASE_NETWORK) {
 			sppp_cp_input(&ipcp, sp, m);
+		}
 		m_freem(m);
 		return;
 	case PPP_IP:
 		if (sp->state[IDX_IPCP] == STATE_OPENED) {
 			sp->pp_last_activity = time_uptime;
 			pktq = ip_pktq;
+		}
 		break;
 #endif
 #ifdef INET6
 	case PPP_IPV6CP:
 		SPPP_UNLOCK(sp);
 		if (sp->pp_phase == SPPP_PHASE_NETWORK) {
 			sppp_cp_input(&ipv6cp, sp, m);
+		}
 		m_freem(m);
 		return;
 	case PPP_IPV6:
 		if (sp->state[IDX_IPV6CP] == STATE_OPENED) {
 			sp->pp_last_activity = time_uptime;
 			pktq = ip6_pktq;
+		}
 		break;
 #endif
+	}
 queue_pkt:
 	if ((ifp->if_flags & IFF_UP) == 0 || (!inq && !pktq)) {
 		goto drop;
+	}
 	/* Check queue. */
 	if (__predict_true(pktq)) {
 		if (__predict_false(!pktq_enqueue(pktq, m, 0))) {
 			goto drop;
+		}
 		SPPP_UNLOCK(sp);
 		return;
+	}
 	SPPP_UNLOCK(sp);
 	IFQ_LOCK(inq);
 	if (IF_QFULL(inq)) {
 		/* Queue overflow. */
 		IF_DROP(inq);
 		IFQ_UNLOCK(inq);
 		if (debug)
 			log(LOG_DEBUG, "%s: protocol queue overflow\n",
 				ifp->if_xname);
 		SPPP_LOCK(sp, RW_READER);
 		goto drop;
+	}
 	IF_ENQUEUE(inq, m);
 	IFQ_UNLOCK(inq);
 	schednetisr(isr);
+}
 /*
  * Enqueue transmit packet.
  */
 static int
 sppp_output(struct ifnet *ifp, struct mbuf *m,
     const struct sockaddr *dst, const struct rtentry *rt)
+{
 	struct sppp *sp = (struct sppp *) ifp;
 	struct ppp_header *h = NULL;
 #ifndef SPPPSUBR_MPSAFE
 	struct ifqueue *ifq = NULL;		/* XXX */
 #endif
 	int s, error = 0;
 	uint16_t protocol;
 	size_t pktlen;
 	s = splnet();
 	SPPP_LOCK(sp, RW_READER);
 	sp->pp_last_activity = time_uptime;
 	if ((ifp->if_flags & IFF_UP) == 0 ||
 	    (ifp->if_flags & (IFF_RUNNING | IFF_AUTO)) == 0) {
 		SPPP_UNLOCK(sp);
 		splx(s);
 		m_freem(m);
 		return (ENETDOWN);
+	}
 	if ((ifp->if_flags & (IFF_RUNNING | IFF_AUTO)) == IFF_AUTO) {
 		/*
 		 * Interface is not yet running, but auto-dial.  Need
 		 * to start LCP for it.
 		 */
 		ifp->if_flags |= IFF_RUNNING;
 		SPPP_UNLOCK(sp);
 		splx(s);
 		SPPP_LOCK(sp, RW_WRITER);
 		lcp.Open(sp);
 		SPPP_UNLOCK(sp);
 		s = splnet();
 		SPPP_LOCK(sp, RW_READER);
+	}
 	/*
 	 * If the queueing discipline needs packet classification,
 	 * do it before prepending link headers.
 	 */
 	IFQ_CLASSIFY(&ifp->if_snd, m, dst->sa_family);
 #ifdef INET
 	if (dst->sa_family == AF_INET) {
 		struct ip *ip = NULL;
 #ifndef SPPPSUBR_MPSAFE
 		struct tcphdr *th = NULL;
 #endif
 		if (m->m_len >= sizeof(struct ip)) {
 			ip = mtod(m, struct ip *);
 #ifndef SPPPSUBR_MPSAFE
 			if (ip->ip_p == IPPROTO_TCP &&
 			    m->m_len >= sizeof(struct ip) + (ip->ip_hl << 2) +
 			    sizeof(struct tcphdr)) {
 				th = (struct tcphdr *)
 				    ((char *)ip + (ip->ip_hl << 2));
+			}
 #endif
 		} else
 			ip = NULL;
 		/*
 		 * When using dynamic local IP address assignment by using
 		 * 0.0.0.0 as a local address, the first TCP session will
 		 * not connect because the local TCP checksum is computed
 		 * using 0.0.0.0 which will later become our real IP address
 		 * so the TCP checksum computed at the remote end will
 		 * become invalid. So we
 		 * - don't let packets with src ip addr 0 thru
 		 * - we flag TCP packets with src ip 0 as an error
 		 */
 		if (ip && ip->ip_src.s_addr == INADDR_ANY) {
 			uint8_t proto = ip->ip_p;
 			SPPP_UNLOCK(sp);
 			splx(s);
 			m_freem(m);
 			if (proto == IPPROTO_TCP)
 				return (EADDRNOTAVAIL);
 			else
 				return (0);
+		}
 #ifndef SPPPSUBR_MPSAFE
 		/*
 		 * Put low delay, telnet, rlogin and ftp control packets
 		 * in front of the queue.
 		 */
 		if (!IF_QFULL(&sp->pp_fastq) &&
 		    ((ip && (ip->ip_tos & IPTOS_LOWDELAY)) ||
 		     (th && (INTERACTIVE(ntohs(th->th_sport)) ||
 		      INTERACTIVE(ntohs(th->th_dport))))))
 			ifq = &sp->pp_fastq;
 #endif /* !SPPPSUBR_MPSAFE */
+	}
 #endif
 #ifdef INET6
 	if (dst->sa_family == AF_INET6) {
 		/* XXX do something tricky here? */
+	}
 #endif
 	if ((sp->pp_flags & PP_NOFRAMING) == 0) {
 		/*
 		 * Prepend general data packet PPP header. For now, IP only.
 		 */
 		M_PREPEND(m, PPP_HEADER_LEN, M_DONTWAIT);
 		if (! m) {
 			if (ifp->if_flags & IFF_DEBUG)
 				log(LOG_DEBUG, "%s: no memory for transmit header\n",
 					ifp->if_xname);
 			++ifp->if_oerrors;
 			SPPP_UNLOCK(sp);
 			splx(s);
 			return (ENOBUFS);
+		}
 		/*
 		 * May want to check size of packet
 		 * (albeit due to the implementation it's always enough)
 		 */
 		h = mtod(m, struct ppp_header *);
 		if (sp->pp_flags & PP_CISCO) {
 			h->address = CISCO_UNICAST;        /* unicast address */
 			h->control = 0;
 		} else {
 			h->address = PPP_ALLSTATIONS;        /* broadcast address */
 			h->control = PPP_UI;                 /* Unnumbered Info */
+		}
+	}
 	switch (dst->sa_family) {
 #ifdef INET
 	case AF_INET:   /* Internet Protocol */
 		if (sp->pp_flags & PP_CISCO)
 			protocol = htons(ETHERTYPE_IP);
 		else {
 			/*
 			 * Don't choke with an ENETDOWN early.  It's
 			 * possible that we just started dialing out,
 			 * so don't drop the packet immediately.  If
 			 * we notice that we run out of buffer space
 			 * below, we will however remember that we are
 			 * not ready to carry IP packets, and return
 			 * ENETDOWN, as opposed to ENOBUFS.
 			 */
 			protocol = htons(PPP_IP);
 			if (sp->state[IDX_IPCP] != STATE_OPENED)
 				error = ENETDOWN;
+		}
 		break;
 #endif
 #ifdef INET6
 	case AF_INET6:   /* Internet Protocol version 6 */
 		if (sp->pp_flags & PP_CISCO)
 			protocol = htons(ETHERTYPE_IPV6);
 		else {
 			/*
 			 * Don't choke with an ENETDOWN early.  It's
 			 * possible that we just started dialing out,
 			 * so don't drop the packet immediately.  If
 			 * we notice that we run out of buffer space
 			 * below, we will however remember that we are
 			 * not ready to carry IP packets, and return
 			 * ENETDOWN, as opposed to ENOBUFS.
 			 */
 			protocol = htons(PPP_IPV6);
 			if (sp->state[IDX_IPV6CP] != STATE_OPENED)
 				error = ENETDOWN;
+		}
 		break;
 #endif
 	default:
 		m_freem(m);
 		++ifp->if_oerrors;
 		SPPP_UNLOCK(sp);
 		splx(s);
 		return (EAFNOSUPPORT);
+	}
 	if (sp->pp_flags & PP_NOFRAMING) {
 		M_PREPEND(m, 2, M_DONTWAIT);
 		if (m == NULL) {
 			if (ifp->if_flags & IFF_DEBUG)
 				log(LOG_DEBUG, "%s: no memory for transmit header\n",
 					ifp->if_xname);
 			++ifp->if_oerrors;
 			SPPP_UNLOCK(sp);
 			splx(s);
 			return (ENOBUFS);
+		}
 		*mtod(m, uint16_t *) = protocol;
 	} else {
 		h->protocol = protocol;
+	}
 	pktlen = m->m_pkthdr.len;
 #ifdef SPPPSUBR_MPSAFE
 	SPPP_UNLOCK(sp);
 	error = if_transmit_lock(ifp, m);
 	SPPP_LOCK(sp, RW_READER);
 	if (error == 0)
 		ifp->if_obytes += pktlen + sp->pp_framebytes;
 #else /* !SPPPSUBR_MPSAFE */
 	error = ifq_enqueue2(ifp, ifq, m);
 	if (error == 0) {
 		/*
 		 * Count output packets and bytes.
 		 * The packet length includes header + additional hardware
 		 * framing according to RFC 1333.
 		 */
 		if (!(ifp->if_flags & IFF_OACTIVE)) {
 			SPPP_UNLOCK(sp);
 			if_start_lock(ifp);
 			SPPP_LOCK(sp, RW_READER);
+		}
 		ifp->if_obytes += pktlen + sp->pp_framebytes;
+	}
 #endif /* !SPPPSUBR_MPSAFE */
 	SPPP_UNLOCK(sp);
 	splx(s);
 	return error;
+}
 static int
 sppp_mediachange(struct ifnet *ifp)
+{
 	return (0);
+}
 static void
 sppp_mediastatus(struct ifnet *ifp, struct ifmediareq *imr)
+{
 	struct sppp *sp = (struct sppp *)ifp;
 	SPPP_LOCK(sp, RW_WRITER);
 	switch (ifp->if_link_state) {
 	case LINK_STATE_UP:
 		imr->ifm_status = IFM_AVALID | IFM_ACTIVE;
 		break;
 	case LINK_STATE_DOWN:
 		imr->ifm_status = IFM_AVALID;
 		break;
 	default:
 		/* Should be impossible as we set link state down in attach. */
 		imr->ifm_status = 0;
 		break;
+	}
 	SPPP_UNLOCK(sp);
+}
 void
 sppp_attach(struct ifnet *ifp)
+{
 	struct sppp *sp = (struct sppp *) ifp;
 	/* Initialize keepalive handler. */
 	if (! spppq) {
 		callout_init(&keepalive_ch, CALLOUT_MPSAFE);
 		callout_reset(&keepalive_ch, hz * LCP_KEEPALIVE_INTERVAL, sppp_keepalive, NULL);
+	}
 	if (! spppq_lock)
 		spppq_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_SOFTNET);
 	/* Insert new entry into the keepalive list. */
 	sp->pp_next = spppq;
 	spppq = sp;
 	sp->pp_if.if_type = IFT_PPP;
 	sp->pp_if.if_output = sppp_output;
 	sp->pp_fastq.ifq_maxlen = 32;
 	sp->pp_cpq.ifq_maxlen = 20;
 	sp->pp_loopcnt = 0;
 	sp->pp_alivecnt = 0;
 	sp->pp_last_activity = 0;
 	sp->pp_last_receive = 0;
 	sp->pp_maxalive = DEFAULT_MAXALIVECNT;
 	sp->pp_max_noreceive = DEFAULT_NORECV_TIME;
 	sp->pp_idle_timeout = 0;
 	memset(&sp->pp_seq[0], 0, sizeof(sp->pp_seq));
 	memset(&sp->pp_rseq[0], 0, sizeof(sp->pp_rseq));
 	sp->pp_auth_failures = 0;
 	sp->pp_max_auth_fail = DEFAULT_MAX_AUTH_FAILURES;
 	sp->pp_phase = SPPP_PHASE_DEAD;
 	sp->pp_up = sppp_notify_up;
 	sp->pp_down = sppp_notify_down;
 	rw_init(&sp->pp_lock);
 	if_alloc_sadl(ifp);
 	/* Lets not beat about the bush, we know we're down. */
 	ifp->if_link_state = LINK_STATE_DOWN;
 	/* There is no media for PPP, but it's needed to report link status. */
 	ifmedia_init(&sp->pp_im, 0, sppp_mediachange, sppp_mediastatus);
 	memset(&sp->myauth, 0, sizeof sp->myauth);
 	memset(&sp->hisauth, 0, sizeof sp->hisauth);
 	SPPP_LOCK(sp, RW_WRITER);
 	sppp_lcp_init(sp);
 	sppp_ipcp_init(sp);
 	sppp_ipv6cp_init(sp);
 	sppp_pap_init(sp);
 	sppp_chap_init(sp);
 	SPPP_UNLOCK(sp);
+}
 void
 sppp_detach(struct ifnet *ifp)
+{
 	struct sppp **q, *p, *sp = (struct sppp *) ifp;
 	/* Remove the entry from the keepalive list. */
 	SPPPQ_LOCK();
 	for (q = &spppq; (p = *q); q = &p->pp_next)
 		if (p == sp) {
 			*q = p->pp_next;
 			break;
+		}
 	SPPPQ_UNLOCK();
 	if (! spppq) {
 		/* Stop keepalive handler. */
 		callout_stop(&keepalive_ch);
 		mutex_obj_free(spppq_lock);
 		spppq_lock = NULL;
+	}
 	SPPP_LOCK(sp, RW_WRITER);
 	/* to avoid workqueue enqueued */
 	atomic_swap_uint(&sp->ipcp.update_addrs_enqueued, 1);
 	workqueue_wait(sp->ipcp.update_addrs_wq, &sp->ipcp.update_addrs_wk);
 	workqueue_destroy(sp->ipcp.update_addrs_wq);
 	pcq_destroy(sp->ipcp.update_addrs_q);
 	callout_stop(&sp->ch[IDX_LCP]);
 	callout_stop(&sp->ch[IDX_IPCP]);
 	callout_stop(&sp->ch[IDX_PAP]);
 	callout_stop(&sp->ch[IDX_CHAP]);
 #ifdef INET6
 	callout_stop(&sp->ch[IDX_IPV6CP]);
 #endif
 	callout_stop(&sp->pap_my_to_ch);
 	/* free authentication info */
 	if (sp->myauth.name) free(sp->myauth.name, M_DEVBUF);
 	if (sp->myauth.secret) free(sp->myauth.secret, M_DEVBUF);
 	if (sp->hisauth.name) free(sp->hisauth.name, M_DEVBUF);
 	if (sp->hisauth.secret) free(sp->hisauth.secret, M_DEVBUF);
 	SPPP_UNLOCK(sp);
 	rw_destroy(&sp->pp_lock);
 	/* Safety - shouldn't be needed as there is no media to set. */
 	ifmedia_delete_instance(&sp->pp_im, IFM_INST_ANY);
+}
 /*
  * Flush the interface output queue.
  */
 void
 sppp_flush(struct ifnet *ifp)
+{
 	struct sppp *sp = (struct sppp *) ifp;
 	SPPP_LOCK(sp, RW_WRITER);
 	IFQ_PURGE(&sp->pp_if.if_snd);
 	IF_PURGE(&sp->pp_fastq);
 	IF_PURGE(&sp->pp_cpq);
 	SPPP_UNLOCK(sp);
+}
 /*
  * Check if the output queue is empty.
  */
 int
 sppp_isempty(struct ifnet *ifp)
+{
 	struct sppp *sp = (struct sppp *) ifp;
 	int empty, s;
 	s = splnet();
 	SPPP_LOCK(sp, RW_READER);
 	empty = IF_IS_EMPTY(&sp->pp_fastq) && IF_IS_EMPTY(&sp->pp_cpq) &&
 		IFQ_IS_EMPTY(&sp->pp_if.if_snd);
 	SPPP_UNLOCK(sp);
 	splx(s);
 	return (empty);
+}
 /*
  * Get next packet to send.
  */
 struct mbuf *
 sppp_dequeue(struct ifnet *ifp)
+{
 	struct sppp *sp = (struct sppp *) ifp;
 	struct mbuf *m;
 	int s;
 	s = splnet();
 	SPPP_LOCK(sp, RW_WRITER);
 	/*
 	 * Process only the control protocol queue until we have at
 	 * least one NCP open.
+	 *
 	 * Do always serve all three queues in Cisco mode.
 	 */
 	IF_DEQUEUE(&sp->pp_cpq, m);
 	if (m == NULL &&
 	    (sppp_ncp_check(sp) || (sp->pp_flags & PP_CISCO) != 0)) {
 		IF_DEQUEUE(&sp->pp_fastq, m);
 		if (m == NULL)
 			IFQ_DEQUEUE(&sp->pp_if.if_snd, m);
+	}
 	SPPP_UNLOCK(sp);
 	splx(s);
 	return m;
+}
 /*
  * Process an ioctl request.  Called on low priority level.
  */
 int
 sppp_ioctl(struct ifnet *ifp, u_long cmd, void *data)
+{
 	struct lwp *l = curlwp;	/* XXX */
 	struct ifreq *ifr = (struct ifreq *) data;
 	struct ifaddr *ifa = (struct ifaddr *) data;
 	struct sppp *sp = (struct sppp *) ifp;
 	int s, error=0, going_up, going_down, newmode;
 	s = splnet();
 	switch (cmd) {
 	case SIOCINITIFADDR:
 		ifa->ifa_rtrequest = p2p_rtrequest;
 		break;
 	case SIOCSIFFLAGS:
 		if ((error = ifioctl_common(ifp, cmd, data)) != 0)
 			break;
 		SPPP_LOCK(sp, RW_WRITER);
 		going_up = ifp->if_flags & IFF_UP &&
 			(ifp->if_flags & IFF_RUNNING) == 0;
 		going_down = (ifp->if_flags & IFF_UP) == 0 &&
 			ifp->if_flags & IFF_RUNNING;
 		newmode = ifp->if_flags & (IFF_AUTO | IFF_PASSIVE);
 		if (newmode == (IFF_AUTO | IFF_PASSIVE)) {
 			/* sanity */
 			newmode = IFF_PASSIVE;
 			ifp->if_flags &= ~IFF_AUTO;
+		}
 		if (going_up || going_down) {
 			lcp.Close(sp);
+		}
 		if (going_up && newmode == 0) {
 			/* neither auto-dial nor passive */
 			ifp->if_flags |= IFF_RUNNING;
 			if (!(sp->pp_flags & PP_CISCO))
 				lcp.Open(sp);
 		} else if (going_down) {
 			SPPP_UNLOCK(sp);
 			sppp_flush(ifp);
 			SPPP_LOCK(sp, RW_WRITER);
 			ifp->if_flags &= ~IFF_RUNNING;
+		}
 		SPPP_UNLOCK(sp);
 		break;
 	case SIOCSIFMTU:
 		if (ifr->ifr_mtu < PPP_MINMRU ||
 		    ifr->ifr_mtu > sp->lcp.their_mru) {
 			error = EINVAL;
 			break;
+		}
 		/*FALLTHROUGH*/
 	case SIOCGIFMTU:
 		if ((error = ifioctl_common(ifp, cmd, data)) == ENETRESET)
 			error = 0;
 		break;
 	case SIOCADDMULTI:
 	case SIOCDELMULTI:
 		break;
 	case SPPPSETAUTHCFG:
 	case SPPPSETLCPCFG:
 	case SPPPSETIDLETO:
 	case SPPPSETAUTHFAILURE:
 	case SPPPSETDNSOPTS:
 	case SPPPSETKEEPALIVE:
 #if defined(COMPAT_50) || defined(MODULAR)
 	case __SPPPSETIDLETO50:
 	case __SPPPSETKEEPALIVE50:
 #endif /* COMPAT_50 || MODULAR */
 		error = kauth_authorize_network(l->l_cred,
 		    KAUTH_NETWORK_INTERFACE,
 		    KAUTH_REQ_NETWORK_INTERFACE_SETPRIV, ifp, (void *)cmd,
 		    NULL);
 		if (error)
 			break;
 		error = sppp_params(sp, cmd, data);
 		break;
 	case SPPPGETAUTHCFG:
 	case SPPPGETLCPCFG:
 	case SPPPGETAUTHFAILURES:
 		error = kauth_authorize_network(l->l_cred,
 		    KAUTH_NETWORK_INTERFACE,
 		    KAUTH_REQ_NETWORK_INTERFACE_GETPRIV, ifp, (void *)cmd,
 		    NULL);
 		if (error)
 			break;
 		error = sppp_params(sp, cmd, data);
 		break;
 	case SPPPGETSTATUS:
 	case SPPPGETSTATUSNCP:
 	case SPPPGETIDLETO:
 	case SPPPGETDNSOPTS:
 	case SPPPGETDNSADDRS:
 	case SPPPGETKEEPALIVE:
 #if defined(COMPAT_50) || defined(MODULAR)
 	case __SPPPGETIDLETO50:
 	case __SPPPGETKEEPALIVE50:
 #endif /* COMPAT_50 || MODULAR */
 		error = sppp_params(sp, cmd, data);
 		break;
 	case SIOCGIFMEDIA:
 		error = ifmedia_ioctl(ifp, ifr, &sp->pp_im, cmd);
 		break;
 	default:
 		error = ifioctl_common(ifp, cmd, data);
 		break;
+	}
 	splx(s);
 	return (error);
+}
 /*
  * Cisco framing implementation.
  */
 /*
  * Handle incoming Cisco keepalive protocol packets.
  */
 static void
 sppp_cisco_input(struct sppp *sp, struct mbuf *m)
+{
 	STDDCL;
 	struct cisco_packet *h;
 #ifdef INET
 	uint32_t me, mymask = 0;	/* XXX: GCC */
 #endif
 	SPPP_LOCK(sp, RW_WRITER);
 	if (m->m_pkthdr.len < CISCO_PACKET_LEN) {
 		if (debug)
 			log(LOG_DEBUG,
 			    "%s: cisco invalid packet length: %d bytes\n",
 			    ifp->if_xname, m->m_pkthdr.len);
 		SPPP_UNLOCK(sp);
 		return;
+	}
 	h = mtod(m, struct cisco_packet *);
 	if (debug)
 		log(LOG_DEBUG,
 		    "%s: cisco input: %d bytes "
 		    "<0x%x 0x%x 0x%x 0x%x 0x%x-0x%x>\n",
 		    ifp->if_xname, m->m_pkthdr.len,
 		    ntohl(h->type), h->par1, h->par2, (u_int)h->rel,
 		    (u_int)h->time0, (u_int)h->time1);
 	switch (ntohl(h->type)) {
 	default:
 		if (debug)
 			addlog("%s: cisco unknown packet type: 0x%x\n",
 			       ifp->if_xname, ntohl(h->type));
 		break;
 	case CISCO_ADDR_REPLY:
 		/* Reply on address request, ignore */
 		break;
 	case CISCO_KEEPALIVE_REQ:
 		sp->pp_alivecnt = 0;
 		sp->pp_rseq[IDX_LCP] = ntohl(h->par1);
 		if (sp->pp_seq[IDX_LCP] == sp->pp_rseq[IDX_LCP]) {
 			/* Local and remote sequence numbers are equal.
 			 * Probably, the line is in loopback mode. */
 			if (sp->pp_loopcnt >= LOOPALIVECNT) {
 				printf ("%s: loopback\n",
 					ifp->if_xname);
 				sp->pp_loopcnt = 0;
 				if (ifp->if_flags & IFF_UP) {
 					SPPP_UNLOCK(sp);
 					if_down(ifp);
 					SPPP_LOCK(sp, RW_WRITER);
 					IF_PURGE(&sp->pp_cpq);
+				}
+			}
 			++sp->pp_loopcnt;
 			/* Generate new local sequence number */
 			sp->pp_seq[IDX_LCP] = cprng_fast32();
 			break;
+		}
 		sp->pp_loopcnt = 0;
 		if (! (ifp->if_flags & IFF_UP) &&
 		    (ifp->if_flags & IFF_RUNNING)) {
 			SPPP_UNLOCK(sp);
 			if_up(ifp);
 			SPPP_LOCK(sp, RW_WRITER);
+		}
 		break;
 	case CISCO_ADDR_REQ:
 #ifdef INET
 		sppp_get_ip_addrs(sp, &me, 0, &mymask);
 		if (me != 0L)
 			sppp_cisco_send(sp, CISCO_ADDR_REPLY, me, mymask);
 #endif
 		break;
+	}
 	SPPP_UNLOCK(sp);
+}
 /*
  * Send Cisco keepalive packet.
  */
 static void
 sppp_cisco_send(struct sppp *sp, int type, int32_t par1, int32_t par2)
+{
 	STDDCL;
 	struct ppp_header *h;
 	struct cisco_packet *ch;
 	struct mbuf *m;
 	uint32_t t;
 	KASSERT(SPPP_WLOCKED(sp));
 	t = time_uptime * 1000;
 	MGETHDR(m, M_DONTWAIT, MT_DATA);
 	if (! m)
 		return;
 	m->m_pkthdr.len = m->m_len = PPP_HEADER_LEN + CISCO_PACKET_LEN;
 	m_reset_rcvif(m);
 	h = mtod(m, struct ppp_header *);
 	h->address = CISCO_MULTICAST;
 	h->control = 0;
 	h->protocol = htons(CISCO_KEEPALIVE);
 	ch = (struct cisco_packet *)(h + 1);
 	ch->type = htonl(type);
 	ch->par1 = htonl(par1);
 	ch->par2 = htonl(par2);
 	ch->rel = -1;
 	ch->time0 = htons((u_short)(t >> 16));
 	ch->time1 = htons((u_short) t);
 	if (debug)
 		log(LOG_DEBUG,
 		    "%s: cisco output: <0x%x 0x%x 0x%x 0x%x 0x%x-0x%x>\n",
 			ifp->if_xname, ntohl(ch->type), ch->par1,
 			ch->par2, (u_int)ch->rel, (u_int)ch->time0,
 			(u_int)ch->time1);
 	if (IF_QFULL(&sp->pp_cpq)) {
 		IF_DROP(&sp->pp_fastq);
 		IF_DROP(&ifp->if_snd);
 		m_freem(m);
 		++ifp->if_oerrors;
 		return;
+	}
 	ifp->if_obytes += m->m_pkthdr.len + sp->pp_framebytes;
 	IF_ENQUEUE(&sp->pp_cpq, m);
 	if (! (ifp->if_flags & IFF_OACTIVE)) {
 		SPPP_UNLOCK(sp);
 		if_start_lock(ifp);
 		SPPP_LOCK(sp, RW_WRITER);
+	}
+}
 /*
  * PPP protocol implementation.
  */
 /*
  * Send PPP control protocol packet.
  */
 static void
 sppp_cp_send(struct sppp *sp, u_short proto, u_char type,
 	     u_char ident, u_short len, void *data)
+{
 	STDDCL;
 	struct lcp_header *lh;
 	struct mbuf *m;
 	size_t pkthdrlen;
 	KASSERT(SPPP_WLOCKED(sp));
 	pkthdrlen = (sp->pp_flags & PP_NOFRAMING) ? 2 : PPP_HEADER_LEN;
 	if (len > MHLEN - pkthdrlen - LCP_HEADER_LEN)
 		len = MHLEN - pkthdrlen - LCP_HEADER_LEN;
 	MGETHDR(m, M_DONTWAIT, MT_DATA);
 	if (! m) {
 		return;
+	}
 	m->m_pkthdr.len = m->m_len = pkthdrlen + LCP_HEADER_LEN + len;
 	m_reset_rcvif(m);
 	if (sp->pp_flags & PP_NOFRAMING) {
 		*mtod(m, uint16_t *) = htons(proto);
 		lh = (struct lcp_header *)(mtod(m, uint8_t *) + 2);
 	} else {
 		struct ppp_header *h;
 		h = mtod(m, struct ppp_header *);
 		h->address = PPP_ALLSTATIONS;        /* broadcast address */
 		h->control = PPP_UI;                 /* Unnumbered Info */
 		h->protocol = htons(proto);         /* Link Control Protocol */
 		lh = (struct lcp_header *)(h + 1);
+	}
 	lh->type = type;
 	lh->ident = ident;
 	lh->len = htons(LCP_HEADER_LEN + len);
 	if (len)
 		memcpy(lh + 1, data, len);
 	if (debug) {
 		log(LOG_DEBUG, "%s: %s output <%s id=0x%x len=%d",
 		    ifp->if_xname,
 		    sppp_proto_name(proto),
 		    sppp_cp_type_name(lh->type), lh->ident, ntohs(lh->len));
 		if (len)
 			sppp_print_bytes((u_char *)(lh + 1), len);
 		addlog(">\n");
+	}
 	if (IF_QFULL(&sp->pp_cpq)) {
 		IF_DROP(&sp->pp_fastq);
 		IF_DROP(&ifp->if_snd);
 		m_freem(m);
 		++ifp->if_oerrors;
 		return;
+	}
 	ifp->if_obytes += m->m_pkthdr.len + sp->pp_framebytes;
 	IF_ENQUEUE(&sp->pp_cpq, m);
 	if (! (ifp->if_flags & IFF_OACTIVE)) {
 		SPPP_UNLOCK(sp);
 		if_start_lock(ifp);
 		SPPP_LOCK(sp, RW_WRITER);
+	}
+}
 /*
  * Handle incoming PPP control protocol packets.
  */
 static void
 sppp_cp_input(const struct cp *cp, struct sppp *sp, struct mbuf *m)
+{
 	STDDCL;
 	struct lcp_header *h;
 	int printlen, len = m->m_pkthdr.len;
 	int rv;
 	u_char *p;
 	uint32_t u32;
 	SPPP_LOCK(sp, RW_WRITER);
 	if (len < 4) {
 		if (debug)
 			log(LOG_DEBUG,
 			    "%s: %s invalid packet length: %d bytes\n",
 			    ifp->if_xname, cp->name, len);
 		SPPP_UNLOCK(sp);
 		return;
+	}
 	h = mtod(m, struct lcp_header *);
 	if (debug) {
 		printlen = ntohs(h->len);
 		log(LOG_DEBUG,
 		    "%s: %s input(%s): <%s id=0x%x len=%d",
 		    ifp->if_xname, cp->name,
 		    sppp_state_name(sp->state[cp->protoidx]),
 		    sppp_cp_type_name(h->type), h->ident, printlen);
 		if (len < printlen)
 			printlen = len;
 		if (printlen > 4)
 			sppp_print_bytes((u_char *)(h + 1), printlen - 4);
 		addlog(">\n");
+	}
 	if (len > ntohs(h->len))
 		len = ntohs(h->len);
 	p = (u_char *)(h + 1);
 	switch (h->type) {
 	case CONF_REQ:
 		if (len < 4) {
 			if (debug)
 				addlog("%s: %s invalid conf-req length %d\n",
 				       ifp->if_xname, cp->name,
 				       len);
 			++ifp->if_ierrors;
 			break;
+		}
 		/* handle states where RCR doesn't get a SCA/SCN */
 		switch (sp->state[cp->protoidx]) {
 		case STATE_CLOSING:
 		case STATE_STOPPING:
 			SPPP_UNLOCK(sp);
 			return;
 		case STATE_CLOSED:
 			sppp_cp_send(sp, cp->proto, TERM_ACK, h->ident,
 , 0);
 			SPPP_UNLOCK(sp);
 			return;
+		}
 		rv = (cp->RCR)(sp, h, len);
 		if (rv < 0) {
 			/* fatal error, shut down */
 			(cp->tld)(sp);
 			sppp_lcp_tlf(sp);
 			SPPP_UNLOCK(sp);
 			return;
+		}
 		switch (sp->state[cp->protoidx]) {
 		case STATE_OPENED:
 			(cp->tld)(sp);
 			(cp->scr)(sp);
 			/* fall through... */
 		case STATE_ACK_SENT:
 		case STATE_REQ_SENT:
 			sppp_cp_change_state(cp, sp, rv?
 					     STATE_ACK_SENT: STATE_REQ_SENT);
 			break;
 		case STATE_STOPPED:
 			sp->rst_counter[cp->protoidx] = sp->lcp.max_configure;
 			(cp->scr)(sp);
 			sppp_cp_change_state(cp, sp, rv?
 					     STATE_ACK_SENT: STATE_REQ_SENT);
 			break;
 		case STATE_ACK_RCVD:
 			if (rv) {
 				sppp_cp_change_state(cp, sp, STATE_OPENED);
 				if (debug)
 					log(LOG_DEBUG, "%s: %s tlu\n",
 					    ifp->if_xname,
 					    cp->name);
 				(cp->tlu)(sp);
 			} else
 				sppp_cp_change_state(cp, sp, STATE_ACK_RCVD);
 			break;
 		default:
 			printf("%s: %s illegal %s in state %s\n",
 			       ifp->if_xname, cp->name,
 			       sppp_cp_type_name(h->type),
 			       sppp_state_name(sp->state[cp->protoidx]));
 			++ifp->if_ierrors;
+		}
 		break;
 	case CONF_ACK:
 		if (h->ident != sp->confid[cp->protoidx]) {
 			if (debug)
 				addlog("%s: %s id mismatch 0x%x != 0x%x\n",
 				       ifp->if_xname, cp->name,
 				       h->ident, sp->confid[cp->protoidx]);
 			++ifp->if_ierrors;
 			break;
+		}
 		switch (sp->state[cp->protoidx]) {
 		case STATE_CLOSED:
 		case STATE_STOPPED:
 			sppp_cp_send(sp, cp->proto, TERM_ACK, h->ident, 0, 0);
 			break;
 		case STATE_CLOSING:
 		case STATE_STOPPING:
 			break;
 		case STATE_REQ_SENT:
 			sp->rst_counter[cp->protoidx] = sp->lcp.max_configure;
 			sppp_cp_change_state(cp, sp, STATE_ACK_RCVD);
 			break;
 		case STATE_OPENED:
 			(cp->tld)(sp);
 			/* fall through */
 		case STATE_ACK_RCVD:
 			(cp->scr)(sp);
 			sppp_cp_change_state(cp, sp, STATE_REQ_SENT);
 			break;
 		case STATE_ACK_SENT:
 			sp->rst_counter[cp->protoidx] = sp->lcp.max_configure;
 			sppp_cp_change_state(cp, sp, STATE_OPENED);
 			if (debug)
 				log(LOG_DEBUG, "%s: %s tlu\n",
 				       ifp->if_xname, cp->name);
 			(cp->tlu)(sp);
 			break;
 		default:
 			printf("%s: %s illegal %s in state %s\n",
 			       ifp->if_xname, cp->name,
 			       sppp_cp_type_name(h->type),
 			       sppp_state_name(sp->state[cp->protoidx]));
 			++ifp->if_ierrors;
+		}
 		break;
 	case CONF_NAK:
 	case CONF_REJ:
 		if (h->ident != sp->confid[cp->protoidx]) {
 			if (debug)
 				addlog("%s: %s id mismatch 0x%x != 0x%x\n",
 				       ifp->if_xname, cp->name,
 				       h->ident, sp->confid[cp->protoidx]);
 			++ifp->if_ierrors;
 			break;
+		}
 		if (h->type == CONF_NAK)
 			(cp->RCN_nak)(sp, h, len);
 		else /* CONF_REJ */
 			(cp->RCN_rej)(sp, h, len);
 		switch (sp->state[cp->protoidx]) {
 		case STATE_CLOSED:
 		case STATE_STOPPED:
 			sppp_cp_send(sp, cp->proto, TERM_ACK, h->ident, 0, 0);
 			break;
 		case STATE_REQ_SENT:
 		case STATE_ACK_SENT:
 			sp->rst_counter[cp->protoidx] = sp->lcp.max_configure;
 			(cp->scr)(sp);
 			break;
 		case STATE_OPENED:
 			(cp->tld)(sp);
 			/* fall through */
 		case STATE_ACK_RCVD:
 			sppp_cp_change_state(cp, sp, STATE_ACK_SENT);
 			(cp->scr)(sp);
 			break;
 		case STATE_CLOSING:
 		case STATE_STOPPING:
 			break;
 		default:
 			printf("%s: %s illegal %s in state %s\n",
 			       ifp->if_xname, cp->name,
 			       sppp_cp_type_name(h->type),
 			       sppp_state_name(sp->state[cp->protoidx]));
 			++ifp->if_ierrors;
+		}
 		break;
 	case TERM_REQ:
 		switch (sp->state[cp->protoidx]) {
 		case STATE_ACK_RCVD:
 		case STATE_ACK_SENT:
 			sppp_cp_change_state(cp, sp, STATE_REQ_SENT);
 			/* fall through */
 		case STATE_CLOSED:
 		case STATE_STOPPED:
 		case STATE_CLOSING:
 		case STATE_STOPPING:
 		case STATE_REQ_SENT:
 		  sta:
 			/* Send Terminate-Ack packet. */
 			if (debug)
 				log(LOG_DEBUG, "%s: %s send terminate-ack\n",
 				    ifp->if_xname, cp->name);
 			sppp_cp_send(sp, cp->proto, TERM_ACK, h->ident, 0, 0);
 			break;
 		case STATE_OPENED:
 			(cp->tld)(sp);
 			sp->rst_counter[cp->protoidx] = 0;
 			sppp_cp_change_state(cp, sp, STATE_STOPPING);
 			goto sta;
 		default:
 			printf("%s: %s illegal %s in state %s\n",
 			       ifp->if_xname, cp->name,
 			       sppp_cp_type_name(h->type),
 			       sppp_state_name(sp->state[cp->protoidx]));
 			++ifp->if_ierrors;
+		}
 		break;
 	case TERM_ACK:
 		switch (sp->state[cp->protoidx]) {
 		case STATE_CLOSED:
 		case STATE_STOPPED:
 		case STATE_REQ_SENT:
 		case STATE_ACK_SENT:
 			break;
 		case STATE_CLOSING:
 			(cp->tlf)(sp);
 			sppp_cp_change_state(cp, sp, STATE_CLOSED);
 			sppp_lcp_check_and_close(sp);
 			break;
 		case STATE_STOPPING:
 			(cp->tlf)(sp);
 			sppp_cp_change_state(cp, sp, STATE_STOPPED);
 			sppp_lcp_check_and_close(sp);
 			break;
 		case STATE_ACK_RCVD:
 			sppp_cp_change_state(cp, sp, STATE_REQ_SENT);
 			break;
 		case STATE_OPENED:
 			(cp->tld)(sp);
 			(cp->scr)(sp);
 			sppp_cp_change_state(cp, sp, STATE_ACK_RCVD);
 			break;
 		default:
 			printf("%s: %s illegal %s in state %s\n",
 			       ifp->if_xname, cp->name,
 			       sppp_cp_type_name(h->type),
 			       sppp_state_name(sp->state[cp->protoidx]));
 			++ifp->if_ierrors;
+		}
 		break;
 	case CODE_REJ:
 		/* XXX catastrophic rejects (RXJ-) aren't handled yet. */
 		log(LOG_INFO,
 		    "%s: %s: ignoring RXJ (%s) for code ?, "
 		    "danger will robinson\n",
 		    ifp->if_xname, cp->name,
 		    sppp_cp_type_name(h->type));
 		switch (sp->state[cp->protoidx]) {
 		case STATE_CLOSED:
 		case STATE_STOPPED:
 		case STATE_REQ_SENT:
 		case STATE_ACK_SENT:
 		case STATE_CLOSING:
 		case STATE_STOPPING:
 		case STATE_OPENED:
 			break;
 		case STATE_ACK_RCVD:
 			sppp_cp_change_state(cp, sp, STATE_REQ_SENT);
 			break;
 		default:
 			printf("%s: %s illegal %s in state %s\n",
 			       ifp->if_xname, cp->name,
 			       sppp_cp_type_name(h->type),
 			       sppp_state_name(sp->state[cp->protoidx]));
 			++ifp->if_ierrors;
+		}
 		break;
 	case PROTO_REJ:
+	    {
 		int catastrophic;
 		const struct cp *upper;
 		int i;
 		uint16_t proto;
 		catastrophic = 0;
 		upper = NULL;
 		proto = p[0] << 8 | p[1];
 		for (i = 0; i < IDX_COUNT; i++) {
 			if (cps[i]->proto == proto) {
 				upper = cps[i];
 				break;
+			}
+		}
 		if (upper == NULL)
 			catastrophic++;
 		if (debug)
 			log(LOG_INFO,
 			    "%s: %s: RXJ%c (%s) for proto 0x%x (%s/%s)\n",
 			    ifp->if_xname, cp->name, catastrophic ? '-' : '+',
 			    sppp_cp_type_name(h->type), proto,
 			    upper ? upper->name : "unknown",
 			    upper ? sppp_state_name(sp->state[upper->protoidx]) : "?");
 		/*
 		 * if we got RXJ+ against conf-req, the peer does not implement
 		 * this particular protocol type.  terminate the protocol.
 		 */
 		if (upper && !catastrophic) {
 			if (sp->state[upper->protoidx] == STATE_REQ_SENT) {
 				upper->Close(sp);
 				break;
+			}
+		}
 		/* XXX catastrophic rejects (RXJ-) aren't handled yet. */
 		switch (sp->state[cp->protoidx]) {
 		case STATE_CLOSED:
 		case STATE_STOPPED:
 		case STATE_REQ_SENT:
 		case STATE_ACK_SENT:
 		case STATE_CLOSING:
 		case STATE_STOPPING:
 		case STATE_OPENED:
 			break;
 		case STATE_ACK_RCVD:
 			sppp_cp_change_state(cp, sp, STATE_REQ_SENT);
 			break;
 		default:
 			printf("%s: %s illegal %s in state %s\n",
 			       ifp->if_xname, cp->name,
 			       sppp_cp_type_name(h->type),
 			       sppp_state_name(sp->state[cp->protoidx]));
 			++ifp->if_ierrors;
+		}
 		break;
+	    }
 	case DISC_REQ:
 		if (cp->proto != PPP_LCP)
 			goto illegal;
 		/* Discard the packet. */
 		break;
 	case ECHO_REQ:
 		if (cp->proto != PPP_LCP)
 			goto illegal;
 		if (sp->state[cp->protoidx] != STATE_OPENED) {
 			if (debug)
 				addlog("%s: lcp echo req but lcp closed\n",
 				       ifp->if_xname);
 			++ifp->if_ierrors;
 			break;
+		}
 		if (len < 8) {
 			if (debug)
 				addlog("%s: invalid lcp echo request "
 				       "packet length: %d bytes\n",
 				       ifp->if_xname, len);
 			break;
+		}
 		memcpy(&u32, h + 1, sizeof u32);
 		if (ntohl(u32) == sp->lcp.magic) {
 			/* Line loopback mode detected. */
 			printf("%s: loopback\n", ifp->if_xname);
 			SPPP_UNLOCK(sp);
 			if_down(ifp);
 			SPPP_LOCK(sp, RW_WRITER);
 			IF_PURGE(&sp->pp_cpq);
 			/* Shut down the PPP link. */
 			/* XXX */
 			lcp.Down(sp);
 			lcp.Up(sp);
 			break;
+		}
 		u32 = htonl(sp->lcp.magic);
 		memcpy(h + 1, &u32, sizeof u32);
 		if (debug)
 			addlog("%s: got lcp echo req, sending echo rep\n",
 			       ifp->if_xname);
 		sppp_cp_send(sp, PPP_LCP, ECHO_REPLY, h->ident, len - 4,
 		    h + 1);
 		break;
 	case ECHO_REPLY:
 		if (cp->proto != PPP_LCP)
 			goto illegal;
 		if (h->ident != sp->lcp.echoid) {
 			++ifp->if_ierrors;
 			break;
+		}
 		if (len < 8) {
 			if (debug)
 				addlog("%s: lcp invalid echo reply "
 				       "packet length: %d bytes\n",
 				       ifp->if_xname, len);
 			break;
+		}
 		if (debug)
 			addlog("%s: lcp got echo rep\n",
 			       ifp->if_xname);
 		memcpy(&u32, h + 1, sizeof u32);
 		if (ntohl(u32) != sp->lcp.magic)
 			sp->pp_alivecnt = 0;
 		break;
 	default:
 		/* Unknown packet type -- send Code-Reject packet. */
 	  illegal:
 		if (debug)
 			addlog("%s: %s send code-rej for 0x%x\n",
 			       ifp->if_xname, cp->name, h->type);
 		sppp_cp_send(sp, cp->proto, CODE_REJ,
 		    ++sp->pp_seq[cp->protoidx], m->m_pkthdr.len, h);
 		++ifp->if_ierrors;
+	}
 	SPPP_UNLOCK(sp);
+}
 /*
  * The generic part of all Up/Down/Open/Close/TO event handlers.
  * Basically, the state transition handling in the automaton.
  */
 static void
 sppp_up_event(const struct cp *cp, struct sppp *sp)
+{
 	STDDCL;
 	KASSERT(SPPP_WLOCKED(sp));
 	if (debug)
 		log(LOG_DEBUG, "%s: %s up(%s)\n",
 		    ifp->if_xname, cp->name,
 		    sppp_state_name(sp->state[cp->protoidx]));
 	switch (sp->state[cp->protoidx]) {
 	case STATE_INITIAL:
 		sppp_cp_change_state(cp, sp, STATE_CLOSED);
 		break;
 	case STATE_STARTING:
 		sp->rst_counter[cp->protoidx] = sp->lcp.max_configure;
 		(cp->scr)(sp);
 		sppp_cp_change_state(cp, sp, STATE_REQ_SENT);
 		break;
 	default:
 		printf("%s: %s illegal up in state %s\n",
 		       ifp->if_xname, cp->name,
 		       sppp_state_name(sp->state[cp->protoidx]));
+	}
+}
 static void
 sppp_down_event(const struct cp *cp, struct sppp *sp)
+{
 	STDDCL;
 	KASSERT(SPPP_WLOCKED(sp));
 	if (debug)
 		log(LOG_DEBUG, "%s: %s down(%s)\n",
 		    ifp->if_xname, cp->name,
 		    sppp_state_name(sp->state[cp->protoidx]));
 	switch (sp->state[cp->protoidx]) {
 	case STATE_CLOSED:
 	case STATE_CLOSING:
 		sppp_cp_change_state(cp, sp, STATE_INITIAL);
 		break;
 	case STATE_STOPPED:
 		(cp->tls)(sp);
 		/* fall through */
 	case STATE_STOPPING:
 	case STATE_REQ_SENT:
 	case STATE_ACK_RCVD:
 	case STATE_ACK_SENT:
 		sppp_cp_change_state(cp, sp, STATE_STARTING);
 		break;
 	case STATE_OPENED:
 		(cp->tld)(sp);
 		sppp_cp_change_state(cp, sp, STATE_STARTING);
 		break;
 	default:
 		printf("%s: %s illegal down in state %s\n",
 		       ifp->if_xname, cp->name,
 		       sppp_state_name(sp->state[cp->protoidx]));
+	}
+}
 static void
 sppp_open_event(const struct cp *cp, struct sppp *sp)
+{
 	STDDCL;
 	KASSERT(SPPP_WLOCKED(sp));
 	if (debug)
 		log(LOG_DEBUG, "%s: %s open(%s)\n",
 		    ifp->if_xname, cp->name,
 		    sppp_state_name(sp->state[cp->protoidx]));
 	switch (sp->state[cp->protoidx]) {
 	case STATE_INITIAL:
 		sppp_cp_change_state(cp, sp, STATE_STARTING);
 		(cp->tls)(sp);
 		break;
 	case STATE_STARTING:
 		break;
 	case STATE_CLOSED:
 		sp->rst_counter[cp->protoidx] = sp->lcp.max_configure;
 		(cp->scr)(sp);
 		sppp_cp_change_state(cp, sp, STATE_REQ_SENT);
 		break;
 	case STATE_STOPPED:
 	case STATE_STOPPING:
 	case STATE_REQ_SENT:
 	case STATE_ACK_RCVD:
 	case STATE_ACK_SENT:
 	case STATE_OPENED:
 		break;
 	case STATE_CLOSING:
 		sppp_cp_change_state(cp, sp, STATE_STOPPING);
 		break;
+	}
+}
 static void
 sppp_close_event(const struct cp *cp, struct sppp *sp)
+{
 	STDDCL;
 	KASSERT(SPPP_WLOCKED(sp));
 	if (debug)
 		log(LOG_DEBUG, "%s: %s close(%s)\n",
 		    ifp->if_xname, cp->name,
 		    sppp_state_name(sp->state[cp->protoidx]));
 	switch (sp->state[cp->protoidx]) {
 	case STATE_INITIAL:
 	case STATE_CLOSED:
 	case STATE_CLOSING:
 		break;
 	case STATE_STARTING:
 		sppp_cp_change_state(cp, sp, STATE_INITIAL);
 		(cp->tlf)(sp);
 		break;
 	case STATE_STOPPED:
 		sppp_cp_change_state(cp, sp, STATE_CLOSED);
 		break;
 	case STATE_STOPPING:
 		sppp_cp_change_state(cp, sp, STATE_CLOSING);
 		break;
 	case STATE_OPENED:
 		(cp->tld)(sp);
 		/* fall through */
 	case STATE_REQ_SENT:
 	case STATE_ACK_RCVD:
 	case STATE_ACK_SENT:
 		sp->rst_counter[cp->protoidx] = sp->lcp.max_terminate;