update to i4b version 0.95.04

53 files changed, 8104 insertions, 1318 deletions

diff --git a/sys/i386/include/i4b_cause.h b/sys/i386/include/i4b_cause.h
index 96589e5..36c6142 100644
--- a/sys/i386/include/i4b_cause.h
+++ b/sys/i386/include/i4b_cause.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_cause.h - causes and cause handling for i4b
  *	-----------------------------------------------
  *
- *	$Id: i4b_cause.h,v 1.11 1999/12/13 21:25:28 hm Exp $
+ *	$Id: i4b_cause.h,v 1.13 2000/02/06 19:01:14 hm Exp $
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:06:51 1999]
+ *      last edit-date: [Sun Feb  6 19:46:41 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -70,7 +70,8 @@
 #define CAUSE_I4B_L1ERROR	7	/* L1 error / persistent deact	*/
 #define CAUSE_I4B_LLDIAL	8	/* no dialout on leased line	*/
 #define CAUSE_I4B_MAX		9
-		/* NOTE: update isdnd/pcause.c when adding causes !!!!! */
+	/* NOTE: update isdnd/pcause.c when adding causes !!!!!		*/
+	/* NOTE: update layer3/i4b_q931.c when adding causes !!!!!	*/
 	
 /* CAUSET_Q850 - causes defined in Q.850 */
 
diff --git a/sys/i386/include/i4b_debug.h b/sys/i386/include/i4b_debug.h
index aabc498..0e7eab2 100644
--- a/sys/i386/include/i4b_debug.h
+++ b/sys/i386/include/i4b_debug.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,58 +27,52 @@
  *	i4b_debug.h - i4b debug header file
  *	-----------------------------------
  *
- *	$Id: i4b_debug.h,v 1.20 1999/12/13 21:25:28 hm Exp $ 
+ *	$Id: i4b_debug.h,v 1.32 2000/07/24 12:22:08 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:06:59 1999]
+ *      last edit-date: [Wed May 31 09:51:34 2000]
  *
  *---------------------------------------------------------------------------*/
 
-#define DO_I4B_DEBUG	/* enable debugging code inclusion */
+#if !defined DO_I4B_DEBUG
+# define DO_I4B_DEBUG 1		/* default = include debugging code */
+#elif DO_I4B_DEBUG != 0
+# undef DO_I4B_DEBUG
+# define DO_I4B_DEBUG 1
+#endif
 
-#undef DO_I4B_MAXDEBUG	/* enable ALL debug messages by default	*/
+#undef DO_I4B_MAXDEBUG		/* default = disable ALL debug messages */
 
-#ifdef DO_I4B_DEBUG
+#if DO_I4B_DEBUG
 
 extern unsigned int i4b_l1_debug;
 extern unsigned int i4b_l2_debug;
 extern unsigned int i4b_l3_debug;
 extern unsigned int i4b_l4_debug;
 
-#define DBGL1(bits, routine, what)			\
-	if(bits & i4b_l1_debug)				\
-	{						\
-		printf("i4b-L1-%s: ", routine);	\
-		printf what ;				\
-	}
-
-#define DBGL2(bits, routine, what)			\
-	if(bits & i4b_l2_debug)				\
-	{						\
-		printf("i4b-L2-%s: ", routine);	\
-		printf what ;				\
-	}
-
-#define DBGL3(bits, routine, what)			\
-	if(bits & i4b_l3_debug)				\
-	{						\
-		printf("i4b-L3-%s: ", routine);	\
-		printf what ;				\
-	}
-
-#define DBGL4(bits, routine, what)			\
-	if(bits & i4b_l4_debug)				\
-	{						\
-		printf("i4b-L4-%s: ", routine);	\
-		printf what ;				\
-	}
+#define NDBGL1(bits, fmt, args...)				 	\
+	if(bits & i4b_l1_debug)						\
+	{ printf("i4b-L1 %s: " fmt "\n", __FUNCTION__ , ##args ); }
+
+#define NDBGL2(bits, fmt, args...)				 	\
+	if(bits & i4b_l2_debug)						\
+	{ printf("i4b-L2 %s: " fmt "\n", __FUNCTION__ , ##args ); }
+	
+#define NDBGL3(bits, fmt, args...)				 	\
+	if(bits & i4b_l3_debug)						\
+	{ printf("i4b-L3 %s: " fmt "\n", __FUNCTION__ , ##args ); }
+	
+#define NDBGL4(bits, fmt, args...)				 	\
+	if(bits & i4b_l4_debug)						\
+	{ printf("i4b-L4 %s: " fmt "\n", __FUNCTION__ , ##args ); }
+	
 #else /* !DO_I4B_DEBUG */
 
-#define DBGL1(bits, routine, what);
-#define DBGL2(bits, routine, what);
-#define DBGL3(bits, routine, what);
-#define DBGL4(bits, routine, what);
+#define NDBGL1(bits, fmt, args...);
+#define NDBGL2(bits, fmt, args...);
+#define NDBGL3(bits, fmt, args...);
+#define NDBGL4(bits, fmt, args...);
 
 #endif /* DO_I4B_DEBUG */
 
@@ -98,9 +92,11 @@ extern unsigned int i4b_l4_debug;
 #define L1_T_ERR	0x0800		/* Timer error messages	*/
 #define L1_H_XFRERR	0x1000		/* HSCX data xfer error */
 #define L1_I_CICO	0x2000		/* ISAC command in/out	*/
+#define L1_S_MSG	0x4000		/* silent messages (soft-HDLC)	*/
+#define L1_S_ERR	0x8000		/* error messages (soft-HDLC)	*/
 
-#define L1_DEBUG_MAX	0x3fef		/* all messages on except IRQ!	*/
-#define L1_DEBUG_ERR (L1_H_ERR | L1_I_ERR | L1_F_ERR | L1_T_ERR | L1_ERROR)
+#define L1_DEBUG_MAX	0xffef		/* all messages on except IRQ!	*/
+#define L1_DEBUG_ERR (L1_S_ERR | L1_H_ERR | L1_I_ERR | L1_F_ERR | L1_T_ERR | L1_ERROR)
 
 #ifndef L1_DEBUG_DEFAULT
 #ifdef DO_I4B_MAXDEBUG
@@ -176,8 +172,9 @@ extern unsigned int i4b_l4_debug;
 #define L4_TINADBG	0x0100		/* tina driver debug messages	*/
 #define L4_TINAMSG	0x0200		/* tina driver messages		*/
 #define L4_TINAERR	0x0400		/* tina driver error messages	*/
+#define L4_INGDBG	0x0800		/* ing driver debug messages	*/
 
-#define L4_DEBUG_MAX	0x07ff		/* all messages on	*/
+#define L4_DEBUG_MAX	0x0fff		/* all messages on	*/
 #define L4_DEBUG_ERR	(L4_ERR | L4_TINADBG |  L4_TINAMSG | L4_TINAERR)
 
 #ifndef L4_DEBUG_DEFAULT
@@ -205,9 +202,23 @@ typedef struct {
 #define	I4B_CTL_SET_DEBUG	_IOW('C', 1, ctl_debug_t)
 
 /*---------------------------------------------------------------------------*
- *	get hscx statistics
+ *	generic get chipset statistics
  *---------------------------------------------------------------------------*/
 
+/* for the ihfc-driver: structure for HFC-1/S/SP statistics */
+
+typedef struct {
+	int txframes;
+	int rxframes;
+	int xdu;
+	int rdo;
+	int crc;
+	int rab;
+} hfcstat_t;
+
+
+/* for the isic-driver: structure for HSCX statistics */
+
 typedef struct {
 	int unit;	/* controller number */
 	int chan;	/* channel number */
@@ -218,44 +229,61 @@ typedef struct {
 	int xdu;
 	int rfo;
 } hscxstat_t;
-	
-#define	I4B_CTL_GET_HSCXSTAT	_IOWR('C', 2, hscxstat_t)
 
-#define	I4B_CTL_CLR_HSCXSTAT	_IOW('C', 3, hscxstat_t)
+/* generic statistics structure */
+
+struct chipstat {
+	int driver_type;		/* type, L1DRVR_XXXX		*/
+	int driver_unit;		/* the unit number		*/
+	int driver_bchannel;		/* the B-channel		*/
+	union stats {			/* union for all drivers	*/
+		hfcstat_t  hfcstat;	/* for ihfc driver, L1DRVR_IHFC	*/
+		hscxstat_t hscxstat;	/* for isic driver, L1DRVR_ISIC	*/
+	} stats;
+};
+
+/* get statistics */
+
+#define	I4B_CTL_GET_CHIPSTAT	_IOWR('C', 2, struct chipstat)
+
+/* clear statistics */
+
+#define	I4B_CTL_CLR_CHIPSTAT	_IOW('C', 3, struct chipstat)
 
 /*---------------------------------------------------------------------------*
  *	get LAPD/Q.921 statistics
  *---------------------------------------------------------------------------*/
 typedef struct {
-				/* transmit */
 
-	u_long	tx_i;	/* I 	*/
-	u_long	tx_rr;	/* RR	*/
-	u_long	tx_rnr;	/* RNR 	*/
-	u_long	tx_rej;	/* REJ	*/
+	/* transmit */
+
+	u_long	tx_i;		/* I 	*/
+	u_long	tx_rr;		/* RR	*/
+	u_long	tx_rnr;		/* RNR 	*/
+	u_long	tx_rej;		/* REJ	*/
 	u_long	tx_sabme;	/* SABME*/
-	u_long	tx_dm;	/* DM	*/
+	u_long	tx_dm;		/* DM	*/
 	u_long	tx_disc;	/* DISC */
-	u_long	tx_ua;	/* UA	*/
+	u_long	tx_ua;		/* UA	*/
 	u_long	tx_frmr;	/* FRMR	*/	
-	u_long	tx_tei;	/* TEI	*/
+	u_long	tx_tei;		/* TEI	*/
 
-				/* receive */
+	/* receive */
 
-	u_long	rx_i;	/* I    */
-	u_long	rx_rr;	/* RR   */
-	u_long	rx_rnr;	/* RNR  */
-	u_long	rx_rej;	/* REJ  */
+	u_long	rx_i;		/* I    */
+	u_long	rx_rr;		/* RR   */
+	u_long	rx_rnr;		/* RNR  */
+	u_long	rx_rej;		/* REJ  */
 	u_long	rx_sabme;	/* SABME*/
-	u_long	rx_tei;	/* TEI	*/
-	u_long	rx_ui;	/* UI	*/
+	u_long	rx_tei;		/* TEI	*/
+	u_long	rx_ui;		/* UI	*/
 	u_long	rx_disc;	/* DISC */
-	u_long	rx_xid;	/* XID	*/
-	u_long	rx_dm;	/* DM	*/
-	u_long	rx_ua;	/* UA	*/
+	u_long	rx_xid;		/* XID	*/
+	u_long	rx_dm;		/* DM	*/
+	u_long	rx_ua;		/* UA	*/
 	u_long	rx_frmr;	/* FRMR	*/	
 	
-					/* errors */
+	/* errors */
 
 	u_long	err_rx_len;	/* incorrect length */
 	u_long	err_rx_badf;	/* bad frame type */
diff --git a/sys/i386/include/i4b_ioctl.h b/sys/i386/include/i4b_ioctl.h
index c2a2460..0a498b9 100644
--- a/sys/i386/include/i4b_ioctl.h
+++ b/sys/i386/include/i4b_ioctl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_ioctl.h - messages kernel <--> userland
  *	-------------------------------------------
  *
- *	$Id: i4b_ioctl.h,v 1.150 1999/12/13 21:25:28 hm Exp $ 
+ *	$Id: i4b_ioctl.h,v 1.196 2000/10/09 11:17:07 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:12:16 1999]
+ *      last edit-date: [Mon Oct  9 13:17:34 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -48,8 +48,8 @@
  *	version and release number for isdn4bsd package
  *---------------------------------------------------------------------------*/
 #define	VERSION		0		/* version number	*/
-#define	REL		90		/* release number	*/
-#define STEP		1 		/* release step		*/
+#define	REL		95		/* release number	*/
+#define STEP		04		/* release step		*/
 
 /*---------------------------------------------------------------------------*
  * date/time format in i4b log messages
@@ -87,6 +87,20 @@
 #define	CTRL_NUMTYPES	5		/* number of controller types	*/
 
 /*---------------------------------------------------------------------------*
+ *	CTRL_PASSIVE: driver types
+ *---------------------------------------------------------------------------*/
+#define MAXL1UNITS      8		/* max number of units	*/
+
+#define L1DRVR_ISIC     0		/* isic - driver	*/
+#define L1DRVR_IWIC     1		/* iwic - driver	*/
+#define L1DRVR_IFPI     2		/* ifpi - driver	*/
+#define L1DRVR_IHFC     3		/* ihfc - driver	*/
+#define L1DRVR_IFPNP    4		/* ifpnp - driver	*/
+
+/* MAXL1DRVR MUST be updated when more passive drivers are added !!! */
+#define MAXL1DRVR       (L1DRVR_IFPNP + 1)
+
+/*---------------------------------------------------------------------------*
  *	card types for CTRL_PASSIVE 
  *---------------------------------------------------------------------------*/
 #define CARD_TYPEP_INVAL	(-1)	/* invalid, error		*/
@@ -114,16 +128,21 @@
 #define CARD_TYPEP_AVM_PNP	21	/* AVM FRITZ!CARD PnP		*/
 #define CARD_TYPEP_SIE_ISURF2 	22	/* Siemens I-Surf 2 PnP		*/
 #define CARD_TYPEP_ASUSCOMIPAC	23	/* Asuscom ISDNlink 128 K PnP	*/
+#define CARD_TYPEP_WINB6692	24	/* Winbond W6692 based		*/
+#define CARD_TYPEP_16_3C	25	/* Teles S0/16.3c PnP (HFC-S/SP	*/
+#define CARD_TYPEP_ACERP10	26	/* Acer ISDN P10 (HFC-S)	*/
+#define CARD_TYPEP_TELEINT_NO_1	27	/* TELEINT ISDN SPEED No. 1 (HFC-1) */
+
 /*
  * in case you add support for more cards, please update:
  *
- *	isdnd:		support.c, name_of_controller()
+ *	isdnd:		controller.c, name_of_controller()
  *	diehl/diehlctl:	main.c, listall()
  *
  * and adjust CARD_TYPEP_MAX below.
  */
 
-#define CARD_TYPEP_MAX		23	/* max type */
+#define CARD_TYPEP_MAX		27	/* max type */
 
 /*---------------------------------------------------------------------------*
  *	card types for CTRL_DAIC
@@ -162,6 +181,7 @@
 #define BDRV_IPR	2       /* IP over raw HDLC interface driver    */
 #define BDRV_ISPPP	3       /* sync Kernel PPP interface driver     */
 #define BDRV_IBC	4       /* BSD/OS point to point driver		*/
+#define BDRV_ING	5       /* NetGraph ing driver			*/
 
 /*---------------------------------------------------------------------------*
  * B channel protocol
@@ -311,6 +331,12 @@ typedef struct {
 #define  SCR_USR_PASS 2		/* screening user provided, verified & passed */
 #define  SCR_USR_FAIL 3		/* screening user provided, verified & failed */
 #define  SCR_NET      4		/* screening network provided		*/
+	int		prs_ind;/* presentation indicator		*/
+#define  PRS_NONE     0		/* no presentation indicator transmitted*/
+#define  PRS_ALLOWED  1		/* presentation allowed			*/
+#define  PRS_RESTRICT 2		/* presentation restricted		*/
+#define  PRS_NNINTERW 3		/* number not available due to interworking */
+#define  PRS_RESERVED 4		/* reserved				*/
 	char		display[DISPLAY_MAX];	/* content of display IE*/
 } msg_connect_ind_t;
 
diff --git a/sys/i386/include/i4b_isppp.h b/sys/i386/include/i4b_isppp.h
new file mode 100644
index 0000000..9d1b59e
--- /dev/null
+++ b/sys/i386/include/i4b_isppp.h
@@ -0,0 +1,253 @@
+/*
+ * Defines for synchronous PPP/Cisco link level subroutines.
+ *
+ * Copyright (C) 1994 Cronyx Ltd.
+ * Author: Serge Vakulenko, <vak@cronyx.ru>
+ *
+ * Heavily revamped to conform to RFC 1661.
+ * Copyright (C) 1997, Joerg Wunsch.
+ *
+ * This software is distributed with NO WARRANTIES, not even the implied
+ * warranties for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Authors grant any other persons or organizations permission to use
+ * or modify this software as long as this message is kept with the software,
+ * all derivative works or modified versions.
+ *
+ * From: Version 2.0, Fri Oct  6 20:39:21 MSK 1995
+ *
+ * From: if_sppp.h,v 1.14 1999/03/30 13:28:26 phk Exp
+ *
+ * $Id: i4b_isppp.h,v 1.5 2000/07/18 15:05:37 hm Exp $
+ *
+ * $FreeBSD$
+ */
+
+#ifndef _I4B_ISPPP_H_
+#define _I4B_ISPPP_H_
+
+#define SPPP_VJ			/* use VJ compression */
+
+
+#ifdef SPPP_VJ
+#if !(defined (KERNEL) || defined (_KERNEL))
+#ifdef __FreeBSD__
+#if 0
+/*
+ * this is needed on FreeBSD to make /usr/src/usr.bin/kdump and
+ * /usr/src/usr.bin/truss compile.
+ */
+#include <sys/mbuf.h>
+#endif
+#include <netinet/in_systm.h>
+#include <netinet/ip.h>
+#include <net/slcompress.h>
+#endif
+#endif
+#endif
+
+#define IDX_LCP 0		/* idx into state table */
+
+struct slcp {
+	u_long	opts;		/* LCP options to send (bitfield) */
+	u_long  magic;          /* local magic number */
+	u_long	mru;		/* our max receive unit */
+	u_long	their_mru;	/* their max receive unit */
+	u_long	protos;		/* bitmask of protos that are started */
+	u_char  echoid;         /* id of last keepalive echo request */
+	/* restart max values, see RFC 1661 */
+	int	timeout;
+	int	max_terminate;
+	int	max_configure;
+	int	max_failure;
+};
+
+#define IDX_IPCP 1		/* idx into state table */
+
+struct sipcp {
+	u_long	opts;		/* IPCP options to send (bitfield) */
+	u_int	flags;
+#define IPCP_HISADDR_SEEN 1	/* have seen his address already */
+#define IPCP_MYADDR_DYN   2	/* my address is dynamically assigned */
+#define IPCP_MYADDR_SEEN  4	/* have seen his address already */
+#define IPCP_VJ		  8	/* We can use VJ compression */
+	int	max_state;	/* Max-Slot-Id */
+	int	compress_cid;	/* Comp-Slot-Id */
+};
+
+#define AUTHNAMELEN	32
+#define AUTHKEYLEN	16
+
+struct sauth {
+	u_short	proto;			/* authentication protocol to use */
+	u_short	flags;
+#define AUTHFLAG_NOCALLOUT	1	/* do not require authentication on */
+					/* callouts */
+#define AUTHFLAG_NORECHALLENGE	2	/* do not re-challenge CHAP */
+	u_char	name[AUTHNAMELEN];	/* system identification name */
+	u_char	secret[AUTHKEYLEN];	/* secret password */
+	u_char	challenge[AUTHKEYLEN];	/* random challenge */
+};
+
+#define IDX_PAP		2
+#define IDX_CHAP	3
+
+#define IDX_COUNT (IDX_CHAP + 1) /* bump this when adding cp's! */
+
+/*
+ * Don't change the order of this.  Ordering the phases this way allows
+ * for a comparision of ``pp_phase >= PHASE_AUTHENTICATE'' in order to
+ * know whether LCP is up.
+ */
+enum ppp_phase {
+	PHASE_DEAD, PHASE_ESTABLISH, PHASE_TERMINATE,
+	PHASE_AUTHENTICATE, PHASE_NETWORK
+};
+
+struct sppp {
+	/* NB: pp_if _must_ be first */
+	struct  ifnet pp_if;    /* network interface data */
+	struct  ifqueue pp_fastq; /* fast output queue */
+	struct	ifqueue pp_cpq;	/* PPP control protocol queue */
+	struct  sppp *pp_next;  /* next interface in keepalive list */
+	u_int   pp_mode;        /* major protocol modes (cisco/ppp/...) */
+	u_int   pp_flags;       /* sub modes */
+	u_short pp_alivecnt;    /* keepalive packets counter */
+	u_short pp_loopcnt;     /* loopback detection counter */
+	u_long  pp_seq;         /* local sequence number */
+	u_long  pp_rseq;        /* remote sequence number */
+	time_t  pp_last_sent;
+	time_t  pp_last_recv;
+	enum ppp_phase pp_phase;	/* phase we're currently in */
+	int	state[IDX_COUNT];	/* state machine */
+	u_char  confid[IDX_COUNT];	/* id of last configuration request */
+	int	rst_counter[IDX_COUNT];	/* restart counter */
+	int	fail_counter[IDX_COUNT]; /* negotiation failure counter */
+#if defined(__FreeBSD__) && __FreeBSD__ >= 3
+	struct callout_handle ch[IDX_COUNT]; /* per-proto and if callouts */
+	struct callout_handle pap_my_to_ch; /* PAP needs one more... */
+#endif
+	struct slcp lcp;		/* LCP params */
+	struct sipcp ipcp;		/* IPCP params */
+	struct sauth myauth;		/* auth params, i'm peer */
+	struct sauth hisauth;		/* auth params, i'm authenticator */
+#ifdef SPPP_VJ
+	int enable_vj;			/* enable VJ negotiation */
+	struct slcompress pp_comp;	/* for VJ compression */
+#endif
+	/*
+	 * These functions are filled in by sppp_attach(), and are
+	 * expected to be used by the lower layer (hardware) drivers
+	 * in order to communicate the (un)availability of the
+	 * communication link.  Lower layer drivers that are always
+	 * ready to communicate (like hardware HDLC) can shortcut
+	 * pp_up from pp_tls, and pp_down from pp_tlf.
+	 */
+	void	(*pp_up)(struct sppp *sp);
+	void	(*pp_down)(struct sppp *sp);
+	/*
+	 * These functions need to be filled in by the lower layer
+	 * (hardware) drivers if they request notification from the
+	 * PPP layer whether the link is actually required.  They
+	 * correspond to the tls and tlf actions.
+	 */
+	void	(*pp_tls)(struct sppp *sp);
+	void	(*pp_tlf)(struct sppp *sp);
+	/*
+	 * These (optional) functions may be filled by the hardware
+	 * driver if any notification of established connections
+	 * (currently: IPCP up) is desired (pp_con) or any internal
+	 * state change of the interface state machine should be
+	 * signaled for monitoring purposes (pp_chg).
+	 */
+	void	(*pp_con)(struct sppp *sp);
+	void	(*pp_chg)(struct sppp *sp, int new_state);
+	/* These two fields are for use by the lower layer */
+	void    *pp_lowerp;
+	int     pp_loweri;
+};
+
+#define PP_KEEPALIVE    0x01    /* use keepalive protocol */
+#define PP_CALLIN	0x08	/* we are being called */
+#define PP_NEEDAUTH	0x10	/* remote requested authentication */
+
+
+#define PP_MTU          1500    /* default/minimal MRU */
+#define PP_MAX_MRU	2048	/* maximal MRU we want to negotiate */
+
+/*
+ * Definitions to pass struct sppp data down into the kernel using the
+ * SIOC[SG]IFGENERIC ioctl interface.
+ *
+ * In order to use this, create a struct spppreq, fill in the cmd
+ * field with SPPPIOGDEFS, and put the address of this structure into
+ * the ifr_data portion of a struct ifreq.  Pass this struct to a
+ * SIOCGIFGENERIC ioctl.  Then replace the cmd field by SPPPIOCDEFS,
+ * modify the defs field as desired, and pass the struct ifreq now
+ * to a SIOCSIFGENERIC ioctl.
+ */
+
+#define SPPPIOGDEFS  ((caddr_t)(('S' << 24) + (1 << 16) + sizeof(struct sppp)))
+#define SPPPIOSDEFS  ((caddr_t)(('S' << 24) + (2 << 16) + sizeof(struct sppp)))
+
+struct spppreq {
+	u_long	cmd;
+	struct sppp defs;
+};
+
+#ifndef SIOCSIFGENERIC
+#define	SIOCSIFGENERIC	 _IOW('i', 57, struct ifreq)	/* generic IF set op */
+#endif
+
+#ifndef SIOCGIFGENERIC
+#define	SIOCGIFGENERIC	_IOWR('i', 58, struct ifreq)	/* generic IF get op */
+#endif
+
+#if defined(KERNEL) || defined(_KERNEL)
+
+#ifndef USE_ISPPP
+
+void sppp_attach (struct ifnet *ifp);
+void sppp_detach (struct ifnet *ifp);
+void sppp_input (struct ifnet *ifp, struct mbuf *m);
+
+#if defined(__FreeBSD_version) && __FreeBSD_version >= 300003
+int sppp_ioctl (struct ifnet *ifp, u_long cmd, void *data);
+#else
+#ifdef __FreeBSD__
+int sppp_ioctl (struct ifnet *ifp, int cmd, void *data);
+#else
+int sppp_ioctl (struct ifnet *ifp, u_long cmd, void *data);
+#endif
+#endif
+
+struct mbuf *sppp_dequeue (struct ifnet *ifp);
+struct mbuf *sppp_pick(struct ifnet *ifp);
+int sppp_isempty (struct ifnet *ifp);
+void sppp_flush (struct ifnet *ifp);
+
+#else /* USE_ISPPP */
+
+void isppp_attach (struct ifnet *ifp);
+void isppp_detach (struct ifnet *ifp);
+void isppp_input (struct ifnet *ifp, struct mbuf *m);
+
+#if defined(__FreeBSD_version) && __FreeBSD_version >= 300003
+int isppp_ioctl (struct ifnet *ifp, u_long cmd, void *data);
+#else
+#ifdef __FreeBSD__
+int isppp_ioctl (struct ifnet *ifp, int cmd, void *data);
+#else
+int isppp_ioctl (struct ifnet *ifp, u_long cmd, void *data);
+#endif
+#endif
+
+struct mbuf *isppp_dequeue (struct ifnet *ifp);
+struct mbuf *isppp_pick(struct ifnet *ifp);
+int isppp_isempty (struct ifnet *ifp);
+void isppp_flush (struct ifnet *ifp);
+#endif /* USE_ISPPP */
+
+#endif /* KERNEL */
+
+#endif /* _I4B_ISPPP_H_ */
diff --git a/sys/i386/include/i4b_tel_ioctl.h b/sys/i386/include/i4b_tel_ioctl.h
index 2cc9e15..0f955af 100644
--- a/sys/i386/include/i4b_tel_ioctl.h
+++ b/sys/i386/include/i4b_tel_ioctl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000  Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_tel_ioctl.h telephony interface ioctls
  *	------------------------------------------
  *
- *	$Id: i4b_tel_ioctl.h,v 1.11 1999/12/13 21:25:28 hm Exp $ 
+ *	$Id: i4b_tel_ioctl.h,v 1.13 2000/01/12 14:49:36 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:07:18 1999]
+ *      last edit-date: [Wed Jan 12 15:47:11 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -62,6 +62,19 @@
 
 #define I4B_TEL_VR_REQ		_IOR('A', 3, msg_vr_req_t)
 
+/*---------------------------------------------------------------------------*
+ *	send tones out of the tel interface
+ *---------------------------------------------------------------------------*/
+
+#define I4B_TEL_MAXTONES 32
+
+struct i4b_tel_tones {
+	int frequency[I4B_TEL_MAXTONES];
+	int duration[I4B_TEL_MAXTONES];
+};
+
+#define I4B_TEL_TONES		_IOR('A', 4, struct i4b_tel_tones)
+
 /*===========================================================================*
  *	/dev/i4bteld<n> devices (dialer interface)
  *===========================================================================*/
diff --git a/sys/i386/include/i4b_trace.h b/sys/i386/include/i4b_trace.h
index fa1a9a6..24229ec 100644
--- a/sys/i386/include/i4b_trace.h
+++ b/sys/i386/include/i4b_trace.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_trace.h - header file for trace data read device
  *	----------------------------------------------------
  *
- *	$Id: i4b_trace.h,v 1.7 1999/12/13 21:25:28 hm Exp $ 
+ *	$Id: i4b_trace.h,v 1.8 2000/03/08 16:08:18 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:07:25 1999]
+ *      last edit-date: [Wed Mar  8 16:41:43 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -70,8 +70,7 @@ typedef struct {
  *	get/set current trace flag settings
  *---------------------------------------------------------------------------*/
 	
-#define	I4B_TRC_GET	_IOR('T', 0, int)	/* get trace settings	*/
-#define	I4B_TRC_SET	_IOW('T', 1, int)	/* set trace settings	*/
+#define	I4B_TRC_SET	_IOW('T', 0, int)	/* set trace settings	*/
 
 #define TRACE_OFF       0x00		/* tracing off 		*/
 #define TRACE_I		0x01		/* trace L1 INFO's on	*/
@@ -87,7 +86,7 @@ typedef struct {
 	int txflags;		/* d and/or b channel	*/
 } i4b_trace_setupa_t;
 
-#define	I4B_TRC_SETA	_IOW('T', 2, i4b_trace_setupa_t) /* set analyze mode */
-#define	I4B_TRC_RESETA	_IOW('T', 3, int)	/* reset analyze mode	*/
+#define	I4B_TRC_SETA	_IOW('T', 1, i4b_trace_setupa_t) /* set analyze mode */
+#define	I4B_TRC_RESETA	_IOW('T', 2, int)	/* reset analyze mode	*/
 
 #endif /* _I4B_TRACE_H_ */
diff --git a/sys/i4b/driver/i4b_bsdi_ibc.c b/sys/i4b/driver/i4b_bsdi_ibc.c
index 2134997..369d4aa 100644
--- a/sys/i4b/driver/i4b_bsdi_ibc.c
+++ b/sys/i4b/driver/i4b_bsdi_ibc.c
@@ -30,11 +30,11 @@
  *	i4b_bsdi_ibc.c - isdn4bsd kernel BSD/OS point to point driver
  *	-------------------------------------------------------------
  *
- *	$Id: i4b_bsdi_ibc.c,v 1.1 1999/04/23 08:35:07 hm Exp $
+ *	$Id: i4b_bsdi_ibc.c,v 1.3 2000/08/21 07:21:07 hm Exp $
  *
  * $FreeBSD$
  *
- *	last edit-date: [Tue Dec 14 21:55:37 1999]
+ *	last edit-date: [Tue Dec 14 21:55:24 1999]
  *
  *---------------------------------------------------------------------------*/
 
@@ -184,7 +184,11 @@ ibcattach(void *dummy)
 		sc->sc_loutb = 0;
 		sc->sc_fn = 1;
 #endif
+#if defined(__FreeBSD_version) && ((__FreeBSD_version >= 500009) || (410000 <= __FreeBSD_version && __FreeBSD_version < 500000))
+		ether_ifattach(ifp, 0);
+#else
 		if_attach(ifp);
+#endif
 		p2p_attach(&sc->sc_p2pcom);
 	}
 }
diff --git a/sys/i4b/driver/i4b_ctl.c b/sys/i4b/driver/i4b_ctl.c
index c026fef..a5c7597 100644
--- a/sys/i4b/driver/i4b_ctl.c
+++ b/sys/i4b/driver/i4b_ctl.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_ctl.c - i4b system control port driver
  *	------------------------------------------
  *
- *	$Id: i4b_ctl.c,v 1.30 1999/12/13 21:25:23 hm Exp $
+ *	$Id: i4b_ctl.c,v 1.37 2000/05/31 08:04:43 hm Exp $
  *
  * $FreeBSD$
  *
- *	last edit-date: [Mon Dec 13 21:38:15 1999]
+ *	last edit-date: [Wed May 31 09:59:01 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -62,6 +62,18 @@
 #include <net/if.h>
 
 #ifdef __FreeBSD__
+
+#if defined(__FreeBSD__) && __FreeBSD__ == 3
+#include "opt_devfs.h"
+#endif
+
+#ifdef DEVFS
+#include <sys/devfsext.h>
+#endif
+
+#endif /* __FreeBSD__ */
+
+#ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
 #elif defined(__bsdi__)
@@ -76,7 +88,8 @@
 
 #include <i4b/include/i4b_global.h>
 #include <i4b/include/i4b_mbuf.h>
-#include <i4b/layer1/i4b_l1.h>
+#include <i4b/include/i4b_l3l4.h>
+
 #include <i4b/layer2/i4b_l2.h>
 
 static int openflag = 0;
@@ -126,6 +139,9 @@ PSEUDO_SET(i4bctlattach, i4b_i4bctldrv);
 #endif /* __FreeBSD__ */
 
 #if defined(__FreeBSD__) && __FreeBSD__ == 3
+#ifdef DEVFS
+static void *devfs_token;
+#endif
 #endif
 
 #ifndef __FreeBSD__
@@ -204,6 +220,11 @@ i4bctlattach()
 #if defined(__FreeBSD__)
 #if __FreeBSD__ == 3
 
+#ifdef DEVFS
+	devfs_token = devfs_add_devswf(&i4bctl_cdevsw, 0, DV_CHR,
+				       UID_ROOT, GID_WHEEL, 0600,
+				       "i4bctl");
+#endif
 
 #else
 	make_dev(&i4bctl_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600, "i4bctl");
@@ -250,10 +271,12 @@ i4bctlioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
 i4bctlioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 #endif
 {
+#if DO_I4B_DEBUG
 	ctl_debug_t *cdbg;	
 	int error = 0;
+#endif
 	
-#ifndef DO_I4B_DEBUG
+#if !DO_I4B_DEBUG
        return(ENODEV);
 #else
 	if(minor(dev))
@@ -277,63 +300,19 @@ i4bctlioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 			i4b_l4_debug = cdbg->l4;
 			break;
 
-                case I4B_CTL_GET_HSCXSTAT:
+                case I4B_CTL_GET_CHIPSTAT:
                 {
-                        hscxstat_t *hst;
-                        struct l1_softc *sc;
-                        hst = (hscxstat_t *)data;
-
-                        if( hst->unit < 0		||
-			    hst->unit > ISIC_MAXUNIT	||
-			    hst->chan < 0		||
-			    hst->chan > 1 )
-                        {
-                        	error = EINVAL;
-				break;
-			}
-			  
-#ifndef __FreeBSD__
-			sc = isic_find_sc(hst->unit);
-#else
-			sc = &l1_sc[hst->unit];
-#endif
-			hst->vfr = sc->sc_chan[hst->chan].stat_VFR;
-			hst->rdo = sc->sc_chan[hst->chan].stat_RDO;
-			hst->crc = sc->sc_chan[hst->chan].stat_CRC;
-			hst->rab = sc->sc_chan[hst->chan].stat_RAB;
-			hst->xdu = sc->sc_chan[hst->chan].stat_XDU;
-			hst->rfo = sc->sc_chan[hst->chan].stat_RFO;
+                        struct chipstat *cst;
+			cst = (struct chipstat *)data;
+			(*ctrl_desc[cst->driver_unit].N_MGMT_COMMAND)(cst->driver_unit, CMR_GCST, cst);
                         break;
                 }
 
-                case I4B_CTL_CLR_HSCXSTAT:
+                case I4B_CTL_CLR_CHIPSTAT:
                 {
-                        hscxstat_t *hst;
-                        struct l1_softc *sc;
-                        hst = (hscxstat_t *)data;
-
-                        if( hst->unit < 0		||
-			    hst->unit > ISIC_MAXUNIT	||
-			    hst->chan < 0		||
-			    hst->chan > 1 )
-                        {
-                        	error = EINVAL;
-				break;
-			}
-			  
-#ifndef __FreeBSD__
-			sc = isic_find_sc(hst->unit);
-#else
-			sc = &l1_sc[hst->unit];
-#endif
-
-			sc->sc_chan[hst->chan].stat_VFR = 0;
-			sc->sc_chan[hst->chan].stat_RDO = 0;
-			sc->sc_chan[hst->chan].stat_CRC = 0;
-			sc->sc_chan[hst->chan].stat_RAB = 0;
-			sc->sc_chan[hst->chan].stat_XDU = 0;
-			sc->sc_chan[hst->chan].stat_RFO = 0;
-			
+                        struct chipstat *cst;
+			cst = (struct chipstat *)data;
+			(*ctrl_desc[cst->driver_unit].N_MGMT_COMMAND)(cst->driver_unit, CMR_CCST, cst);
                         break;
                 }
 
@@ -343,7 +322,7 @@ i4bctlioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
                         l2_softc_t *sc;
                         l2s = (l2stat_t *)data;
 
-                        if( l2s->unit < 0 || l2s->unit > ISIC_MAXUNIT)
+                        if( l2s->unit < 0 || l2s->unit > MAXL1UNITS)
                         {
                         	error = EINVAL;
 				break;
@@ -361,7 +340,7 @@ i4bctlioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
                         l2_softc_t *sc;
                         up = (int *)data;
 
-                        if( *up < 0 || *up > ISIC_MAXUNIT)
+                        if( *up < 0 || *up > MAXL1UNITS)
                         {
                         	error = EINVAL;
 				break;
diff --git a/sys/i4b/driver/i4b_ing.c b/sys/i4b/driver/i4b_ing.c
new file mode 100644
index 0000000..dc6d348
--- /dev/null
+++ b/sys/i4b/driver/i4b_ing.c
@@ -0,0 +1,860 @@
+/*
+ * Copyright (c) 1999, 2000 Hellmuth Michaelis. 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 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.
+ *
+ *---------------------------------------------------------------------------
+ *
+ *	i4b_ing.c - isdn4bsd B-channel to netgraph driver
+ *	-------------------------------------------------
+ *
+ *	$Id: i4b_ing.c,v 1.10 2000/04/27 11:35:00 hm Exp $
+ *
+ * $FreeBSD$
+ *
+ *	last edit-date: [Thu Apr 27 13:33:18 2000]
+ *
+ *---------------------------------------------------------------------------*/ 
+
+#include "i4bing.h"
+
+#if NI4BING > 0
+
+#include "opt_i4b.h"
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/mbuf.h>
+#include <sys/socket.h>
+#include <sys/errno.h>
+#include <sys/ctype.h>
+#include <sys/ioccom.h>
+#include <sys/syslog.h>
+#include <sys/malloc.h>
+
+#include <net/if.h>
+
+#include <netgraph/ng_message.h>
+#include <netgraph/ng_parse.h>
+#include <netgraph/netgraph.h>
+
+#include <machine/i4b_ioctl.h>
+#include <machine/i4b_debug.h>
+
+#include <i4b/include/i4b_global.h>
+#include <i4b/include/i4b_mbuf.h>
+#include <i4b/include/i4b_l3l4.h>
+
+#include <i4b/layer4/i4b_l4.h>
+
+#define I4BINGACCT	1		/* enable accounting messages */
+#define	I4BINGACCTINTVL	2		/* accounting msg interval in secs */
+
+#define I4BINGMAXQLEN	50		/* max queue length */
+
+/* initialized by L4 */
+
+static drvr_link_t ing_drvr_linktab[NI4BING];
+static isdn_link_t *isdn_linktab[NI4BING];
+
+struct ing_softc {
+	int		sc_unit;	/* unit number			*/
+	int		sc_state;	/* state of the interface	*/
+	call_desc_t	*sc_cdp;	/* ptr to call descriptor	*/
+	int		sc_updown;	/* soft state of interface	*/
+	struct ifqueue  sc_fastq;	/* interactive traffic		*/
+	int		sc_dialresp;	/* dialresponse			*/
+	int		sc_lastdialresp;/* last dialresponse		*/
+	
+#if I4BINGACCT
+	struct callout_handle sc_callout;
+	int		sc_iinb;	/* isdn driver # of inbytes	*/
+	int		sc_ioutb;	/* isdn driver # of outbytes	*/
+	int		sc_inb;		/* # of bytes rx'd		*/
+	int		sc_outb;	/* # of bytes tx'd	 	*/
+	int		sc_linb;	/* last # of bytes rx'd		*/
+	int		sc_loutb;	/* last # of bytes tx'd 	*/
+	int		sc_fn;		/* flag, first null acct	*/
+#endif	
+
+	int		sc_inpkt;	/* incoming packets		*/
+	int		sc_outpkt;	/* outgoing packets		*/	
+
+	struct ifqueue  xmitq_hipri;    /* hi-priority transmit queue */
+	struct ifqueue  xmitq;	  /* transmit queue */
+		
+	node_p		node;		/* back pointer to node */
+	char		nodename[NG_NODELEN + 1]; /* store our node name */
+	hook_p  	debughook;
+	hook_p  	hook;	
+
+	u_int   	packets_in;	/* packets in from downstream */
+	u_int   	packets_out;	/* packets out towards downstream */
+	u_int32_t	flags;
+
+} ing_softc[NI4BING];
+
+enum ing_states {
+	ST_IDLE,			/* initialized, ready, idle	*/
+	ST_DIALING,			/* dialling out to remote	*/
+	ST_CONNECTED			/* connected to remote		*/
+};
+
+static void i4bingattach(void *);
+
+PSEUDO_SET(i4bingattach, i4b_ing);
+
+static void ing_init_linktab(int unit);
+static void ing_tx_queue_empty(int unit);
+
+/* ========= NETGRAPH ============= */
+
+#define NG_ING_NODE_TYPE	"i4bing"	/* node type name */
+#define NGM_ING_COOKIE		947513046	/* node type cookie */
+
+/* Hook names */
+#define NG_ING_HOOK_DEBUG	"debug"
+#define NG_ING_HOOK_RAW		"rawdata"
+
+/* Netgraph commands understood by this node type */
+enum {
+	NGM_ING_SET_FLAG = 1,
+	NGM_ING_GET_STATUS,
+};
+
+/* This structure is returned by the NGM_ING_GET_STATUS command */
+struct ngingstat {
+	u_int   packets_in;	/* packets in from downstream */
+	u_int   packets_out;	/* packets out towards downstream */
+};
+
+/*
+ * This is used to define the 'parse type' for a struct ngingstat, which
+ * is bascially a description of how to convert a binary struct ngingstat
+ * to an ASCII string and back.  See ng_parse.h for more info.
+ *
+ * This needs to be kept in sync with the above structure definition
+ */
+#define NG_ING_STATS_TYPE_INFO	{				\
+	{							\
+	  { "packets_in",	&ng_parse_int32_type	},	\
+	  { "packets_out",	&ng_parse_int32_type	},	\
+	  { NULL },						\
+	}							\
+}
+
+/*
+ * This section contains the netgraph method declarations for the
+ * sample node. These methods define the netgraph 'type'.
+ */
+
+static ng_constructor_t	ng_ing_constructor;
+static ng_rcvmsg_t	ng_ing_rcvmsg;
+static ng_shutdown_t	ng_ing_rmnode;
+static ng_newhook_t	ng_ing_newhook;
+static ng_connect_t	ng_ing_connect;
+static ng_rcvdata_t	ng_ing_rcvdata;
+static ng_disconnect_t	ng_ing_disconnect;
+
+/* Parse type for struct ngingstat */
+static const struct
+	ng_parse_struct_info ng_ing_stat_type_info = NG_ING_STATS_TYPE_INFO;
+
+static const struct ng_parse_type ng_ing_stat_type = {
+	&ng_parse_struct_type,
+	&ng_ing_stat_type_info
+};
+
+/* List of commands and how to convert arguments to/from ASCII */
+
+static const struct ng_cmdlist ng_ing_cmdlist[] = {
+	{
+		NGM_ING_COOKIE,
+		NGM_ING_GET_STATUS,
+		"getstatus",
+		NULL,
+		&ng_ing_stat_type,
+	},
+	{
+		NGM_ING_COOKIE,
+		NGM_ING_SET_FLAG,
+		"setflag",
+		&ng_parse_int32_type,
+		NULL
+	},
+	{ 0 }
+};
+
+/* Netgraph node type descriptor */
+static struct ng_type typestruct = {
+	NG_VERSION,
+	NG_ING_NODE_TYPE,
+	NULL,
+	ng_ing_constructor,
+	ng_ing_rcvmsg,
+	ng_ing_rmnode,
+	ng_ing_newhook,
+	NULL,
+	ng_ing_connect,
+	ng_ing_rcvdata,
+	ng_ing_rcvdata,
+	ng_ing_disconnect,
+	ng_ing_cmdlist
+};
+
+NETGRAPH_INIT(ing, &typestruct);
+
+/*===========================================================================*
+ *			DEVICE DRIVER ROUTINES
+ *===========================================================================*/
+
+/*---------------------------------------------------------------------------*
+ *	interface attach routine at kernel boot time
+ *---------------------------------------------------------------------------*/
+static void
+i4bingattach(void *dummy)
+{
+	struct ing_softc *sc = ing_softc;
+	int i;
+	int ret;
+
+	printf("i4bing: %d i4b NetGraph ISDN B-channel device(s) attached\n", NI4BING);
+	
+	for(i=0; i < NI4BING; sc++, i++)
+	{
+		sc->sc_unit = i;
+		
+		ing_init_linktab(i);
+
+		NDBGL4(L4_DIALST, "setting dial state to ST_IDLE");
+
+		sc->sc_state = ST_IDLE;
+		
+		sc->sc_fastq.ifq_maxlen = I4BINGMAXQLEN;
+		
+#if I4BINGACCT
+		callout_handle_init(&sc->sc_callout);
+		sc->sc_iinb = 0;
+		sc->sc_ioutb = 0;
+		sc->sc_inb = 0;
+		sc->sc_outb = 0;
+		sc->sc_linb = 0;
+		sc->sc_loutb = 0;
+		sc->sc_fn = 1;
+#endif
+
+		sc->sc_inpkt = 0;
+		sc->sc_outpkt = 0;		
+
+		sc->sc_updown = SOFT_ENA;	/* soft enabled */
+
+		sc->sc_dialresp = DSTAT_NONE;	/* no response */
+		sc->sc_lastdialresp = DSTAT_NONE;
+		
+		/* setup a netgraph node */
+
+		if ((ret = ng_make_node_common(&typestruct, &sc->node)))
+		{
+			printf("ing: ng_make_node_common, ret = %d\n!", ret);
+		}
+
+		sc->node->private = sc;
+
+		sc->xmitq.ifq_maxlen = IFQ_MAXLEN;
+		sc->xmitq_hipri.ifq_maxlen = IFQ_MAXLEN;
+				
+		/* name the netgraph node */
+
+		sprintf(sc->nodename, "%s%d", NG_ING_NODE_TYPE, sc->sc_unit);
+
+		if(ng_name_node(sc->node, sc->nodename))
+		{
+			ng_rmnode(sc->node);
+			ng_unref(sc->node);
+		}
+	}
+}
+
+#ifdef I4BINGACCT
+/*---------------------------------------------------------------------------*
+ *	accounting timeout routine
+ *---------------------------------------------------------------------------*/
+static void
+ing_timeout(struct ing_softc *sc)
+{
+	bchan_statistics_t bs;
+	int unit = sc->sc_unit;
+
+	/* get # of bytes in and out from the HSCX driver */ 
+	
+	(*isdn_linktab[unit]->bch_stat)
+		(isdn_linktab[unit]->unit, isdn_linktab[unit]->channel, &bs);
+
+	sc->sc_ioutb += bs.outbytes;
+	sc->sc_iinb += bs.inbytes;
+	
+	if((sc->sc_iinb != sc->sc_linb) || (sc->sc_ioutb != sc->sc_loutb) || sc->sc_fn) 
+	{
+		int ri = (sc->sc_iinb - sc->sc_linb)/I4BINGACCTINTVL;
+		int ro = (sc->sc_ioutb - sc->sc_loutb)/I4BINGACCTINTVL;
+
+		if((sc->sc_iinb == sc->sc_linb) && (sc->sc_ioutb == sc->sc_loutb))
+			sc->sc_fn = 0;
+		else
+			sc->sc_fn = 1;
+			
+		sc->sc_linb = sc->sc_iinb;
+		sc->sc_loutb = sc->sc_ioutb;
+
+		i4b_l4_accounting(BDRV_ING, unit, ACCT_DURING,
+			 sc->sc_ioutb, sc->sc_iinb, ro, ri, sc->sc_ioutb, sc->sc_iinb);
+ 	}
+
+	sc->sc_callout = timeout((TIMEOUT_FUNC_T)ing_timeout,
+					(void *)sc, I4BINGACCTINTVL*hz);
+}
+#endif /* I4BINGACCT */
+
+#if 0
+/*---------------------------------------------------------------------------*
+ *	clear the interface's send queues
+ *---------------------------------------------------------------------------*/
+static void
+ingclearqueue(struct ifqueue *iq)
+{
+	int x;
+	struct mbuf *m;
+	
+	for(;;)
+	{
+		x = splimp();
+		IF_DEQUEUE(iq, m);
+		splx(x);
+
+		if(m)
+			m_freem(m);
+		else
+			break;
+	}
+}	
+#endif
+
+/*===========================================================================*
+ *			ISDN INTERFACE ROUTINES
+ *===========================================================================*/
+
+/*---------------------------------------------------------------------------*
+ *	this routine is called from L4 handler at connect time
+ *---------------------------------------------------------------------------*/
+static void
+ing_connect(int unit, void *cdp)
+{
+	struct ing_softc *sc = &ing_softc[unit];
+	int s;
+
+	sc->sc_cdp = (call_desc_t *)cdp;
+
+	s = SPLI4B();
+
+	NDBGL4(L4_DIALST, "ing%d: setting dial state to ST_CONNECTED", unit);
+
+	sc->sc_dialresp = DSTAT_NONE;
+	sc->sc_lastdialresp = DSTAT_NONE;	
+	
+#if I4BINGACCT
+	sc->sc_iinb = 0;
+	sc->sc_ioutb = 0;
+	sc->sc_inb = 0;
+	sc->sc_outb = 0;
+	sc->sc_linb = 0;
+	sc->sc_loutb = 0;
+	sc->sc_callout = timeout((TIMEOUT_FUNC_T)ing_timeout,
+				(void *)sc, I4BINGACCTINTVL*hz);
+#endif
+
+	sc->sc_state = ST_CONNECTED;
+	
+	splx(s);
+}
+	
+/*---------------------------------------------------------------------------*
+ *	this routine is called from L4 handler at disconnect time
+ *---------------------------------------------------------------------------*/
+static void
+ing_disconnect(int unit, void *cdp)
+{
+	call_desc_t *cd = (call_desc_t *)cdp;
+	struct ing_softc *sc = &ing_softc[unit];
+
+	/* new stuff to check that the active channel is being closed */
+
+	if (cd != sc->sc_cdp)
+	{
+		NDBGL4(L4_INGDBG, "ing%d: channel %d not active",
+				cd->driver_unit, cd->channelid);
+		return;
+	}
+
+#if I4BINGACCT
+	untimeout((TIMEOUT_FUNC_T)ing_timeout,
+		(void *)sc, sc->sc_callout);
+#endif
+
+	i4b_l4_accounting(BDRV_ING, cd->driver_unit, ACCT_FINAL,
+		 sc->sc_ioutb, sc->sc_iinb, 0, 0, sc->sc_outb, sc->sc_inb);
+	
+	sc->sc_cdp = (call_desc_t *)0;	
+
+	NDBGL4(L4_DIALST, "setting dial state to ST_IDLE");
+
+	sc->sc_dialresp = DSTAT_NONE;
+	sc->sc_lastdialresp = DSTAT_NONE;	
+
+	sc->sc_state = ST_IDLE;
+}
+
+/*---------------------------------------------------------------------------*
+ *	this routine is used to give a feedback from userland daemon
+ *	in case of dial problems
+ *---------------------------------------------------------------------------*/
+static void
+ing_dialresponse(int unit, int status, cause_t cause)
+{
+	struct ing_softc *sc = &ing_softc[unit];
+	sc->sc_dialresp = status;
+
+	NDBGL4(L4_INGDBG, "ing%d: last=%d, this=%d",
+		unit, sc->sc_lastdialresp, sc->sc_dialresp);
+
+	if(status != DSTAT_NONE)
+	{
+		NDBGL4(L4_INGDBG, "ing%d: clearing queues", unit);
+/*		ingclearqueues(sc); */
+	}
+}
+	
+/*---------------------------------------------------------------------------*
+ *	interface soft up/down
+ *---------------------------------------------------------------------------*/
+static void
+ing_updown(int unit, int updown)
+{
+	struct ing_softc *sc = &ing_softc[unit];
+	sc->sc_updown = updown;
+}
+	
+/*---------------------------------------------------------------------------*
+ *	this routine is called from the HSCX interrupt handler
+ *	when a new frame (mbuf) has been received and was put on
+ *	the rx queue. It is assumed that this routines runs at
+ *	pri level splimp() ! Keep it short !
+ *---------------------------------------------------------------------------*/
+static void
+ing_rx_data_rdy(int unit)
+{
+	register struct ing_softc *sc = &ing_softc[unit];
+	register struct mbuf *m;
+	
+	if((m = *isdn_linktab[unit]->rx_mbuf) == NULL)
+		return;
+
+#if I4BINGACCT
+	sc->sc_inb += m->m_pkthdr.len;
+#endif
+
+	m->m_pkthdr.rcvif = NULL;
+
+	sc->sc_inpkt++;
+	
+	ng_queue_data(sc->hook, m, NULL);
+}
+
+/*---------------------------------------------------------------------------*
+ *	this routine is called from the HSCX interrupt handler
+ *	when the last frame has been sent out and there is no
+ *	further frame (mbuf) in the tx queue.
+ *---------------------------------------------------------------------------*/
+static void
+ing_tx_queue_empty(int unit)
+{
+	register struct ing_softc *sc = &ing_softc[unit];
+	register struct mbuf *m;
+	int x = 0;
+
+	if(sc->sc_state != ST_CONNECTED)
+		return;
+		
+	for(;;)
+	{
+		IF_DEQUEUE(&sc->xmitq_hipri, m);
+
+		if(m == NULL)
+		{
+			IF_DEQUEUE(&sc->xmitq, m);
+			if(m == NULL)
+				break;
+		}
+	
+#if I4BINGACCT
+		sc->sc_outb += m->m_pkthdr.len;
+#endif
+
+		x = 1;
+
+		if(IF_QFULL(isdn_linktab[unit]->tx_queue))
+		{
+			NDBGL4(L4_INGDBG, "ing%d: tx queue full!", unit);
+			m_freem(m);
+		}
+		else
+		{
+			IF_ENQUEUE(isdn_linktab[unit]->tx_queue, m);
+		}
+	}
+
+	if(x)
+		(*isdn_linktab[unit]->bch_tx_start)(isdn_linktab[unit]->unit, isdn_linktab[unit]->channel);
+}
+
+/*---------------------------------------------------------------------------*
+ *	this routine is called from the HSCX interrupt handler
+ *	each time a packet is received or transmitted. It should
+ *	be used to implement an activity timeout mechanism.
+ *---------------------------------------------------------------------------*/
+static void
+ing_activity(int unit, int rxtx)
+{
+	ing_softc[unit].sc_cdp->last_active_time = SECOND;
+}
+
+/*---------------------------------------------------------------------------*
+ *	return this drivers linktab address
+ *---------------------------------------------------------------------------*/
+drvr_link_t *
+ing_ret_linktab(int unit)
+{
+	return(&ing_drvr_linktab[unit]);
+}
+
+/*---------------------------------------------------------------------------*
+ *	setup the isdn_linktab for this driver
+ *---------------------------------------------------------------------------*/
+void
+ing_set_linktab(int unit, isdn_link_t *ilt)
+{
+	isdn_linktab[unit] = ilt;
+}
+
+/*---------------------------------------------------------------------------*
+ *	initialize this drivers linktab
+ *---------------------------------------------------------------------------*/
+static void
+ing_init_linktab(int unit)
+{
+	ing_drvr_linktab[unit].unit = unit;
+	ing_drvr_linktab[unit].bch_rx_data_ready = ing_rx_data_rdy;
+	ing_drvr_linktab[unit].bch_tx_queue_empty = ing_tx_queue_empty;
+	ing_drvr_linktab[unit].bch_activity = ing_activity;
+	ing_drvr_linktab[unit].line_connected = ing_connect;
+	ing_drvr_linktab[unit].line_disconnected = ing_disconnect;
+	ing_drvr_linktab[unit].dial_response = ing_dialresponse;
+	ing_drvr_linktab[unit].updown_ind = ing_updown;	
+}
+
+/*===========================================================================*
+ *			NETGRAPH INTERFACE ROUTINES
+ *===========================================================================*/
+
+/*---------------------------------------------------------------------------*
+ * It is not possible or allowable to create a node of this type.
+ * If the hardware exists, it will already have created it.
+ *---------------------------------------------------------------------------*/
+static int
+ng_ing_constructor(node_p *nodep)
+{
+	return(EINVAL);
+}
+
+/*---------------------------------------------------------------------------*
+ * Give our ok for a hook to be added...
+ * Add the hook's private info to the hook structure.
+ *---------------------------------------------------------------------------*/
+static int
+ng_ing_newhook(node_p node, hook_p hook, const char *name)
+{
+	struct ing_softc *sc = node->private;
+
+	/*
+	 * check if it's our friend the debug hook
+	 */
+	if(strcmp(name, NG_ING_HOOK_DEBUG) == 0)
+	{
+		hook->private = NULL; /* paranoid */
+		sc->debughook = hook;
+		return (0);
+	}
+	/*
+	 * Check for raw mode hook.
+	 */
+	if(strcmp(name, NG_ING_HOOK_RAW) == 0)
+	{
+		hook->private = sc;
+		sc->hook = hook;
+		return (0);
+	}
+
+	return (EINVAL);
+}
+
+/*---------------------------------------------------------------------------*
+ * Get a netgraph control message.
+ * Check it is one we understand. If needed, send a response.
+ * We could save the address for an async action later, but don't here.
+ * Always free the message.
+ * The response should be in a malloc'd region that the caller can 'free'.
+ * A response is not required.
+ *---------------------------------------------------------------------------*/
+static int
+ng_ing_rcvmsg(node_p node, struct ng_mesg *msg, const char *retaddr,
+							struct ng_mesg **rptr)
+{
+	struct ing_softc *sc = node->private;
+
+	struct ng_mesg *resp = NULL;
+	int error = 0;
+
+	if(msg->header.typecookie == NGM_GENERIC_COOKIE)
+	{
+		switch(msg->header.cmd)
+		{
+			case NGM_TEXT_STATUS:
+			{
+				char *arg;
+				char *p;
+				int pos = 0;
+
+				NG_MKRESPONSE(resp, msg, sizeof(struct ng_mesg) + NG_TEXTRESPONSE, M_NOWAIT);
+
+				if (resp == NULL)
+				{
+					error = ENOMEM;
+					break;
+				}
+				arg = (char *) resp->data;
+
+				switch(sc->sc_state)
+				{
+			    		case ST_IDLE:
+						p = "idle";
+						break;
+				    	case ST_DIALING:
+						p = "dialing";
+						break;
+				    	case ST_CONNECTED:
+						p = "connected";
+						break;
+				    	default:
+						p = "???";
+						break;
+			    	}
+
+				pos = sprintf(arg, "state = %s (%d)\n", p, sc->sc_state);
+#if I4BINGACCT
+				pos += sprintf(arg + pos, "%d bytes in, %d bytes out\n", sc->sc_inb, sc->sc_outb);
+#endif			    
+				pos += sprintf(arg + pos, "%d pkts in, %d pkts out\n", sc->sc_inpkt, sc->sc_outpkt);
+
+				resp->header.arglen = pos + 1;
+				break;
+			}
+
+			default:
+				error = EINVAL;
+				break;
+		}
+	}
+	else if(msg->header.typecookie == NGM_ING_COOKIE)
+	{
+		switch (msg->header.cmd)
+		{
+			case NGM_ING_GET_STATUS:
+			{
+				struct ngingstat *stats;
+
+				NG_MKRESPONSE(resp, msg, sizeof(*stats), M_NOWAIT);
+
+				if (!resp)
+				{
+					error = ENOMEM;
+					break;
+				}
+
+				stats = (struct ngingstat *) resp->data;
+				stats->packets_in = sc->packets_in;
+				stats->packets_out = sc->packets_out;
+				break;
+			}
+
+			case NGM_ING_SET_FLAG:
+				if (msg->header.arglen != sizeof(u_int32_t))
+				{
+					error = EINVAL;
+					break;
+				}
+				sc->flags = *((u_int32_t *) msg->data);
+				break;
+
+			default:
+				error = EINVAL;		/* unknown command */
+				break;
+		}
+	}
+	else
+	{
+		error = EINVAL;			/* unknown cookie type */
+	}
+
+	/* Take care of synchronous response, if any */
+
+	if (rptr)
+		*rptr = resp;
+	else if (resp)
+		FREE(resp, M_NETGRAPH);
+
+	/* Free the message and return */
+
+	FREE(msg, M_NETGRAPH);
+	return(error);
+}
+
+/*---------------------------------------------------------------------------*
+ * get data from another node and transmit it out on a B-channel
+ *---------------------------------------------------------------------------*/
+static int
+ng_ing_rcvdata(hook_p hook, struct mbuf *m, meta_p meta)
+{
+	struct ing_softc *sc = hook->node->private;
+	struct ifqueue  *xmitq_p;
+	int s;
+	
+	if(hook->private == NULL)
+	{
+		NG_FREE_DATA(m, meta);
+		return(ENETDOWN);
+	}
+	
+	if(sc->sc_state == ST_IDLE || sc->sc_state == ST_DIALING)
+	{
+		i4b_l4_dialout(BDRV_ING, sc->sc_unit);
+		sc->sc_state = ST_DIALING;
+	}
+
+	sc->sc_outpkt++;
+	
+       /*
+	* Now queue the data for when it can be sent
+	*/
+
+	if (meta && meta->priority > 0)
+	{
+		xmitq_p = (&sc->xmitq_hipri);
+	}
+	else
+	{
+		xmitq_p = (&sc->xmitq);
+	}
+
+	s = splimp();
+
+	if (IF_QFULL(xmitq_p))
+	{
+		IF_DROP(xmitq_p);
+		splx(s);
+		NG_FREE_DATA(m, meta);
+		return(ENOBUFS);
+	}
+
+	IF_ENQUEUE(xmitq_p, m);
+
+	ing_tx_queue_empty(sc->sc_unit);
+
+	splx(s);
+	return (0);
+}
+
+/*---------------------------------------------------------------------------*
+ * Do local shutdown processing..
+ * If we are a persistant device, we might refuse to go away, and
+ * we'd only remove our links and reset ourself.
+ *---------------------------------------------------------------------------*/
+static int
+ng_ing_rmnode(node_p node)
+{
+	struct ing_softc *sc = node->private;
+
+	node->flags |= NG_INVALID;
+	ng_cutlinks(node);
+
+	sc->packets_in = 0;		/* reset stats */
+	sc->packets_out = 0;
+
+	node->flags &= ~NG_INVALID;	/* reset invalid flag */
+
+	return (0);
+}
+
+/*---------------------------------------------------------------------------*
+ * This is called once we've already connected a new hook to the other node.
+ *---------------------------------------------------------------------------*/
+static int
+ng_ing_connect(hook_p hook)
+{
+	return (0);
+}
+
+/*
+ * Dook disconnection
+ *
+ * For this type, removal of the last link destroys the node
+ */
+static int
+ng_ing_disconnect(hook_p hook)
+{
+	struct ing_softc *sc = hook->node->private;
+	int s;
+	
+	if(hook->private)
+	{
+		s = splimp();
+		splx(s);
+	}
+	else
+	{
+		sc->debughook = NULL;
+	}
+	return (0);
+}
+
+/*===========================================================================*/
+
+#endif /* NI4BING > 0 */
diff --git a/sys/i4b/driver/i4b_ipr.c b/sys/i4b/driver/i4b_ipr.c
index e807412..4e7533f 100644
--- a/sys/i4b/driver/i4b_ipr.c
+++ b/sys/i4b/driver/i4b_ipr.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_ipr.c - isdn4bsd IP over raw HDLC ISDN network driver
  *	---------------------------------------------------------
  *
- *	$Id: i4b_ipr.c,v 1.55 1999/12/13 21:25:24 hm Exp $
+ *	$Id: i4b_ipr.c,v 1.59 2000/08/28 07:24:58 hm Exp $
  *
  * $FreeBSD$
  *
- *	last edit-date: [Mon Dec 13 21:38:51 1999]
+ *	last edit-date: [Fri Aug 25 20:25:21 2000]
  *
  *---------------------------------------------------------------------------*
  *
@@ -80,6 +80,11 @@
 #else
 #include <sys/ioctl.h>
 #endif
+
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
 #include <sys/kernel.h>
 #include <sys/protosw.h>
 
@@ -193,6 +198,13 @@ struct ipr_softc {
 	int		sc_fn;		/* flag, first null acct	*/
 #endif	
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+	struct callout	sc_callout;
+#endif
+#if defined(__FreeBSD__)
+	struct callout_handle	sc_callout;
+#endif
+
 #ifdef I4BIPRADJFRXP
 	int		sc_first_pkt;	/* flag, first rxd packet	*/
 #endif
@@ -279,7 +291,7 @@ i4biprattach()
 	{
 		ipr_init_linktab(i);
 
-		DBGL4(L4_DIALST, "i4biprattach", ("setting dial state to ST_IDLE\n"));
+		NDBGL4(L4_DIALST, "setting dial state to ST_IDLE");
 
 		sc->sc_state = ST_IDLE;
 		
@@ -304,6 +316,10 @@ i4biprattach()
 		sc->sc_if.if_flags = IFF_POINTOPOINT | IFF_SIMPLEX;
 #endif
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+		callout_init(&sc->sc_callout);
+#endif
+
 		sc->sc_if.if_mtu = I4BIPRMTU;
 		sc->sc_if.if_type = IFT_ISDNBASIC;
 		sc->sc_if.if_ioctl = i4biprioctl;
@@ -360,7 +376,12 @@ i4biprattach()
 		sc->sc_dialresp = DSTAT_NONE;	/* no response */
 		sc->sc_lastdialresp = DSTAT_NONE;
 		
+#if defined(__FreeBSD_version) && ((__FreeBSD_version >= 500009) || (410000 <= __FreeBSD_version && __FreeBSD_version < 500000))
+		/* do not call bpfattach in ether_ifattach */
+		ether_ifattach(&sc->sc_if, 0);
+#else
 		if_attach(&sc->sc_if);
+#endif
 
 #if NBPFILTER > 0 || NBPF > 0
 #ifdef __FreeBSD__
@@ -411,7 +432,7 @@ i4biproutput(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
 	
 	if(!(ifp->if_flags & IFF_UP))
 	{
-		DBGL4(L4_IPRDBG, "i4biproutput", ("ipr%d: interface is DOWN!\n", unit));
+		NDBGL4(L4_IPRDBG, "ipr%d: interface is DOWN!", unit);
 		m_freem(m);
 		splx(s);
 		sc->sc_if.if_oerrors++;
@@ -427,7 +448,7 @@ i4biproutput(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
 		switch(sc->sc_dialresp)
 		{
 			case DSTAT_TFAIL:	/* transient failure */
-				DBGL4(L4_IPRDBG, "i4biproutput", ("ipr%d: transient dial failure!\n", unit));
+				NDBGL4(L4_IPRDBG, "ipr%d: transient dial failure!", unit);
 				m_freem(m);
 				iprclearqueues(sc);
 				sc->sc_dialresp = DSTAT_NONE;
@@ -437,7 +458,7 @@ i4biproutput(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
 				break;
 
 			case DSTAT_PFAIL:	/* permanent failure */
-				DBGL4(L4_IPRDBG, "i4biproutput", ("ipr%d: permanent dial failure!\n", unit));
+				NDBGL4(L4_IPRDBG, "ipr%d: permanent dial failure!", unit);
 				m_freem(m);
 				iprclearqueues(sc);
 				sc->sc_dialresp = DSTAT_NONE;
@@ -447,7 +468,7 @@ i4biproutput(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
 				break;
 
 			case DSTAT_INONLY:	/* no dialout allowed*/
-				DBGL4(L4_IPRDBG, "i4biproutput", ("ipr%d: dialout not allowed failure!\n", unit));
+				NDBGL4(L4_IPRDBG, "ipr%d: dialout not allowed failure!", unit);
 				m_freem(m);
 				iprclearqueues(sc);
 				sc->sc_dialresp = DSTAT_NONE;
@@ -458,8 +479,8 @@ i4biproutput(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
 		}
 #endif
 
-		DBGL4(L4_IPRDBG, "i4biproutput", ("ipr%d: send dial request message!\n", unit));
-		DBGL4(L4_DIALST, "i4biproutput", ("ipr%d: setting dial state to ST_DIALING\n", unit));
+		NDBGL4(L4_IPRDBG, "ipr%d: send dial request message!", unit);
+		NDBGL4(L4_DIALST, "ipr%d: setting dial state to ST_DIALING", unit);
 		i4b_l4_dialout(BDRV_IPR, unit);
 		sc->sc_state = ST_DIALING;
 	}
@@ -493,7 +514,7 @@ i4biproutput(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
 	
 	if(IF_QFULL(ifq))
 	{
-		DBGL4(L4_IPRDBG, "i4biproutput", ("ipr%d: send queue full!\n", unit));
+		NDBGL4(L4_IPRDBG, "ipr%d: send queue full!", unit);
 		IF_DROP(ifq);
 		m_freem(m);
 		splx(s);
@@ -501,7 +522,7 @@ i4biproutput(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
 		return(ENOBUFS);
 	}
 	
-	DBGL4(L4_IPRDBG, "i4biproutput", ("ipr%d: add packet to send queue!\n", unit));
+	NDBGL4(L4_IPRDBG, "ipr%d: add packet to send queue!", unit);
 	
 	IF_ENQUEUE(ifq, m);
 
@@ -747,7 +768,7 @@ ipr_connect(int unit, void *cdp)
 
 	s = SPLI4B();
 
-	DBGL4(L4_DIALST, "ipr_connect", ("ipr%d: setting dial state to ST_CONNECTED\n", unit));
+	NDBGL4(L4_DIALST, "ipr%d: setting dial state to ST_CONNECTED", unit);
 
 	sc->sc_if.if_flags |= IFF_RUNNING;
 	sc->sc_state = ST_CONNECTED_W;
@@ -782,7 +803,16 @@ ipr_connect(int unit, void *cdp)
 
 	if(sc->sc_cdp->isdntxdelay > 0)
 	{
-		timeout((TIMEOUT_FUNC_T)i4bipr_connect_startio, (void *)sc, sc->sc_cdp->isdntxdelay /* hz*1 */);
+		int delay;
+
+		if (hz == 100) {
+			delay = sc->sc_cdp->isdntxdelay;	/* avoid any rounding */
+		} else {
+			delay = sc->sc_cdp->isdntxdelay*hz;
+			delay /= 100;
+		}
+
+		START_TIMER(sc->sc_callout, (TIMEOUT_FUNC_T)i4bipr_connect_startio, (void *)sc,  delay);
 	}
 	else
 	{
@@ -809,8 +839,8 @@ ipr_disconnect(int unit, void *cdp)
 
 	if (cd != sc->sc_cdp)
 	{
-		DBGL4(L4_IPRDBG, "ipr_disconnect", ("ipr%d: channel %d not active\n",
-				cd->driver_unit, cd->channelid));
+		NDBGL4(L4_IPRDBG, "ipr%d: channel %d not active",
+				cd->driver_unit, cd->channelid);
 		return;
 	}
 
@@ -827,7 +857,7 @@ ipr_disconnect(int unit, void *cdp)
 	
 	sc->sc_cdp = (call_desc_t *)0;	
 
-	DBGL4(L4_DIALST, "ipr_disconnect", ("setting dial state to ST_IDLE\n"));
+	NDBGL4(L4_DIALST, "setting dial state to ST_IDLE");
 
 	sc->sc_dialresp = DSTAT_NONE;
 	sc->sc_lastdialresp = DSTAT_NONE;	
@@ -846,12 +876,12 @@ ipr_dialresponse(int unit, int status, cause_t cause)
 	struct ipr_softc *sc = &ipr_softc[unit];
 	sc->sc_dialresp = status;
 
-	DBGL4(L4_IPRDBG, "ipr_dialresponse", ("ipr%d: last=%d, this=%d\n",
-		unit, sc->sc_lastdialresp, sc->sc_dialresp));
+	NDBGL4(L4_IPRDBG, "ipr%d: last=%d, this=%d",
+		unit, sc->sc_lastdialresp, sc->sc_dialresp);
 
 	if(status != DSTAT_NONE)
 	{
-		DBGL4(L4_IPRDBG, "ipr_dialresponse", ("ipr%d: clearing queues\n", unit));
+		NDBGL4(L4_IPRDBG, "ipr%d: clearing queues", unit);
 		iprclearqueues(sc);
 	}
 }
@@ -1045,7 +1075,7 @@ error:
 
 	if(IF_QFULL(&ipintrq))
 	{
-		DBGL4(L4_IPRDBG, "ipr_rx_data_rdy", ("ipr%d: ipintrq full!\n", unit));
+		NDBGL4(L4_IPRDBG, "ipr%d: ipintrq full!", unit);
 
 		IF_DROP(&ipintrq);
 		sc->sc_if.if_ierrors++;
@@ -1130,7 +1160,7 @@ ipr_tx_queue_empty(int unit)
 
 		if(IF_QFULL(isdn_linktab[unit]->tx_queue))
 		{
-			DBGL4(L4_IPRDBG, "ipr_rx_data_rdy", ("ipr%d: tx queue full!\n", unit));
+			NDBGL4(L4_IPRDBG, "ipr%d: tx queue full!", unit);
 			m_freem(m);
 		}
 		else
diff --git a/sys/i4b/driver/i4b_isppp.c b/sys/i4b/driver/i4b_isppp.c
index a33348c..45ed303 100644
--- a/sys/i4b/driver/i4b_isppp.c
+++ b/sys/i4b/driver/i4b_isppp.c
@@ -1,7 +1,7 @@
 /*
  *   Copyright (c) 1997 Joerg Wunsch. All rights reserved.
  *
- *   Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ *   Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  *   Redistribution and use in source and binary forms, with or without
  *   modification, are permitted provided that the following conditions
@@ -34,19 +34,33 @@
  *	the "cx" driver for Cronyx's HDLC-in-hardware device).  This driver
  *	is only the glue between sppp and i4b.
  *
- *	$Id: i4b_isppp.c,v 1.35 1999/12/13 21:25:24 hm Exp $
+ *	$Id: i4b_isppp.c,v 1.44 2000/08/31 07:07:26 hm Exp $
  *
  * $FreeBSD$
  *
- *	last edit-date: [Mon Dec 13 21:39:06 1999]
+ *	last edit-date: [Thu Aug 31 09:02:27 2000]
  *
  *---------------------------------------------------------------------------*/
 
+
+#ifndef __NetBSD__
+#define USE_ISPPP
+#endif
 #include "i4bisppp.h"
 
+#ifndef USE_ISPPP
+
+#ifdef __FreeBSD__
+#include "sppp.h"
+#endif
+
+#ifndef __NetBSD__
 #if NI4BISPPP == 0
 # error "You need to define `pseudo-device sppp <N>' with options ISPPP"
 #endif
+#endif
+
+#endif
 
 #include <sys/param.h>
 #include <sys/systm.h>
@@ -71,9 +85,13 @@
 #include <net/slcompress.h>
 
 #if defined(__FreeBSD__) || defined(__OpenBSD__)
+#ifndef USE_ISPPP
 #include <net/if_sppp.h>
 #else
-#include <i4b/sppp/if_sppp.h>
+#include <machine/i4b_isppp.h>
+#endif /* USE_ISPPP */
+#else
+#include <net/if_sppp.h>
 #endif
 
 
@@ -135,7 +153,7 @@
 PDEVSTATIC void i4bispppattach(void *);
 PSEUDO_SET(i4bispppattach, i4b_isppp);
 #else
-PDEVSTATIC void i4bispppattach __P((void));
+PDEVSTATIC void i4bispppattach(void);
 #endif
 
 #define I4BISPPPACCT		1	/* enable accounting messages */
@@ -199,6 +217,7 @@ static void	i4bisppp_tlf(struct sppp *sp);
 static void	i4bisppp_state_changed(struct sppp *sp, int new_state);
 static void	i4bisppp_negotiation_complete(struct sppp *sp);
 static void	i4bisppp_watchdog(struct ifnet *ifp);
+time_t   	i4bisppp_idletime(int unit);
 
 /* initialized by L4 */
 
@@ -222,7 +241,7 @@ PDEVSTATIC void
 #ifdef __FreeBSD__
 i4bispppattach(void *dummy)
 #else
-i4bispppattach(void)
+i4bispppattach()
 #endif
 {
 	struct i4bisppp_softc *sc = i4bisppp_softc;
@@ -253,7 +272,14 @@ i4bispppattach(void)
 #endif
 
 		sc->sc_if.if_mtu = PP_MTU;
+
+#ifdef __NetBSD__
+		sc->sc_if.if_flags = IFF_SIMPLEX | IFF_POINTOPOINT |
+					IFF_MULTICAST;
+#else
 		sc->sc_if.if_flags = IFF_SIMPLEX | IFF_POINTOPOINT;
+#endif
+
 		sc->sc_if.if_type = IFT_ISDNBASIC;
 		sc->sc_state = ST_IDLE;
 
@@ -297,8 +323,17 @@ i4bispppattach(void)
 		sc->sc_if_un.scu_sp.pp_con = i4bisppp_negotiation_complete;
 		sc->sc_if_un.scu_sp.pp_chg = i4bisppp_state_changed;
 
+#ifndef USE_ISPPP
 		sppp_attach(&sc->sc_if);
+#else
+		isppp_attach(&sc->sc_if);
+#endif
+#if defined(__FreeBSD_version) && ((__FreeBSD_version >= 500009) || (410000 <= __FreeBSD_version && __FreeBSD_version < 500000))
+		/* do not call bpfattach in ether_ifattach */
+		ether_ifattach(&sc->sc_if, 0);
+#else
 		if_attach(&sc->sc_if);
+#endif
 
 #if NBPFILTER > 0 || NBPF > 0
 #ifdef __FreeBSD__
@@ -327,7 +362,11 @@ i4bisppp_ioctl(struct ifnet *ifp, IOCTL_CMD_T cmd, caddr_t data)
 
 	int error;
 
+#ifndef USE_ISPPP		
 	error = sppp_ioctl(&sc->sc_if, cmd, data);
+#else
+	error = isppp_ioctl(&sc->sc_if, cmd, data);
+#endif
 	if (error)
 		return error;
 
@@ -356,7 +395,11 @@ i4bisppp_start(struct ifnet *ifp)
 	/* int s; */
 	int unit = IFP2UNIT(ifp);
 
+#ifndef USE_ISPPP
 	if (sppp_isempty(ifp))
+#else
+	if (isppp_isempty(ifp))
+#endif
 		return;
 
 	if(sc->sc_state != ST_CONNECTED)
@@ -368,7 +411,11 @@ i4bisppp_start(struct ifnet *ifp)
 	 * splx(s);
 	 */
 
+#ifndef USE_ISPPP
 	while ((m = sppp_dequeue(&sc->sc_if)) != NULL)
+#else
+	while ((m = isppp_dequeue(&sc->sc_if)) != NULL)
+#endif
 	{
 
 #if NBPFILTER > 0 || NBPF > 0
@@ -387,14 +434,15 @@ i4bisppp_start(struct ifnet *ifp)
 
 		if(IF_QFULL(isdn_linktab[unit]->tx_queue))
 		{
-			DBGL4(L4_ISPDBG, "i4bisppp_start", ("isp%d, tx queue full!\n", unit));
+			NDBGL4(L4_ISPDBG, "isp%d, tx queue full!", unit);
 			m_freem(m);
 		}
 		else
 		{
 			IF_ENQUEUE(isdn_linktab[unit]->tx_queue, m);
-
+#if 0
 			sc->sc_if.if_obytes += m->m_pkthdr.len;
+#endif
 			sc->sc_outb += m->m_pkthdr.len;
 			sc->sc_if.if_opackets++;
 		}
@@ -554,7 +602,9 @@ i4bisppp_connect(int unit, void *cdp)
 #endif
 
 	sp->pp_up(sp);		/* tell PPP we are ready */
-
+#ifndef __NetBSD__
+	sp->pp_last_sent = sp->pp_last_recv = SECOND;
+#endif
 	splx(s);
 }
 
@@ -573,7 +623,7 @@ i4bisppp_disconnect(int unit, void *cdp)
 	/* new stuff to check that the active channel is being closed */
 	if (cd != sc->sc_cdp)
 	{
-		DBGL4(L4_ISPDBG, "i4bisppp_disconnect", ("isp%d, channel%d not active!\n", unit, cd->channelid));
+		NDBGL4(L4_ISPDBG, "isp%d, channel%d not active!", unit, cd->channelid);
 		splx(s);
 		return;
 	}
@@ -608,17 +658,25 @@ i4bisppp_dialresponse(int unit, int status, cause_t cause)
 {
 	struct i4bisppp_softc *sc = &i4bisppp_softc[unit];
 
-	DBGL4(L4_ISPDBG, "i4bisppp_dialresponse", ("isp%d: status=%d, cause=%d\n", unit, status, cause));
+	NDBGL4(L4_ISPDBG, "isp%d: status=%d, cause=%d", unit, status, cause);
 
 	if(status != DSTAT_NONE)
 	{
 		struct mbuf *m;
 		
-		DBGL4(L4_ISPDBG, "i4bisppp_dialresponse", ("isp%d: clearing queues\n", unit));
+		NDBGL4(L4_ISPDBG, "isp%d: clearing queues", unit);
 
+#ifndef USE_ISPPP
 		if(!(sppp_isempty(&sc->sc_if)))
+#else
+		if(!(isppp_isempty(&sc->sc_if)))
+#endif		
 		{
+#ifndef USE_ISPPP
 			while((m = sppp_dequeue(&sc->sc_if)) != NULL)
+#else
+			while((m = isppp_dequeue(&sc->sc_if)) != NULL)
+#endif
 				m_freem(m);
 		}
 	}
@@ -654,7 +712,9 @@ i4bisppp_rx_data_rdy(int unit)
 	microtime(&sc->sc_if.if_lastchange);
 
 	sc->sc_if.if_ipackets++;
+#if 0
 	sc->sc_if.if_ibytes += m->m_pkthdr.len;
+#endif
 
 #if I4BISPPPACCT
 	sc->sc_inb += m->m_pkthdr.len;
@@ -680,7 +740,11 @@ i4bisppp_rx_data_rdy(int unit)
 
 	s = splimp();
 
+#ifndef USE_ISPPP
 	sppp_input(&sc->sc_if, m);
+#else
+	isppp_input(&sc->sc_if, m);
+#endif
 
 	splx(s);
 }
@@ -697,6 +761,28 @@ i4bisppp_tx_queue_empty(int unit)
 }
 
 /*---------------------------------------------------------------------------*
+ *	THIS should be used instead of last_active_time to implement
+ *	an activity timeout mechanism.
+ *
+ *	Sending back the time difference unneccessarily complicates the
+ *	idletime checks in i4b_l4.c. Return the largest time instead.
+ *	That way the code in i4b_l4.c needs only minimal changes.
+ *---------------------------------------------------------------------------*/
+time_t
+i4bisppp_idletime(int unit)
+{
+#ifdef __NetBSD__
+       return(i4bisppp_softc[unit].sc_cdp->last_active_time);
+#else
+	struct sppp *sp;
+	sp = (struct sppp *) &i4bisppp_softc[unit];
+
+	return((sp->pp_last_recv < sp->pp_last_sent) ?
+			sp->pp_last_sent : sp->pp_last_recv);
+#endif
+}
+
+/*---------------------------------------------------------------------------*
  *	this routine is called from the HSCX interrupt handler
  *	each time a packet is received or transmitted. It should
  *	be used to implement an activity timeout mechanism.
diff --git a/sys/i4b/driver/i4b_ispppsubr.c b/sys/i4b/driver/i4b_ispppsubr.c
new file mode 100644
index 0000000..a7785e3
--- /dev/null
+++ b/sys/i4b/driver/i4b_ispppsubr.c
@@ -0,0 +1,4612 @@
+/*
+ * 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.
+ *
+ * This software is distributed with NO WARRANTIES, not even the implied
+ * warranties for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Authors grant any other persons or organisations permission to use
+ * or modify this software as long as this message is kept with the software,
+ * all derivative works or modified versions.
+ *
+ * From: Version 2.4, Thu Apr 30 17:17:21 MSD 1997
+ *
+ * From: if_spppsubr.c,v 1.55 1999/03/30 13:28:26 phk Exp
+ *
+ * $Id: i4b_ispppsubr.c,v 1.8 2000/09/01 14:11:51 hm Exp $
+ *
+ * $FreeBSD$
+ */
+
+#define USE_ISPPP
+
+#if defined(__NetBSD__) || (defined(__FreeBSD__) && __FreeBSD__ >= 3)
+#include "opt_inet.h"
+#include "opt_ipx.h"
+#endif
+
+#if defined(__NetBSD__)
+#include "opt_iso.h"
+#include "opt_ns.h"
+#endif
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/sockio.h>
+#include <sys/socket.h>
+#include <sys/syslog.h>
+
+#if defined(__FreeBSD__)
+#if defined (__FreeBSD_version) && __FreeBSD_version <= 400000
+#include <machine/random.h>
+#else
+#include <sys/random.h>
+#endif
+#endif
+
+#include <sys/malloc.h>
+#include <sys/mbuf.h>
+
+#if defined (__OpenBSD__)
+#include <sys/md5k.h>
+#else
+#include <sys/md5.h>
+#endif
+
+#include <net/if.h>
+#include <net/netisr.h>
+#include <net/if_types.h>
+#include <net/route.h>
+
+#include <machine/stdarg.h>
+
+#ifdef INET
+#include <netinet/in.h>
+#include <netinet/in_systm.h>
+#include <netinet/in_var.h>
+#include <netinet/ip.h>
+#include <netinet/tcp.h>
+
+#include <netinet/in.h>
+
+#if !defined (__OpenBSD__)
+#include <netinet/in_systm.h>
+#include <netinet/ip.h>
+#endif
+
+#include <net/slcompress.h>
+
+#if defined (__FreeBSD__) || defined (__OpenBSD__)
+#include <netinet/if_ether.h>
+#else
+#include <net/ethertypes.h>
+#endif
+#else
+#error Huh? sppp without INET?
+#endif
+
+#ifdef IPX
+#include <netipx/ipx.h>
+#include <netipx/ipx_if.h>
+#endif
+
+#ifdef NS
+#include <netns/ns.h>
+#include <netns/ns_if.h>
+#endif
+
+#ifdef ISO
+#include <netiso/argo_debug.h>
+#include <netiso/iso.h>
+#include <netiso/iso_var.h>
+#include <netiso/iso_snpac.h>
+#endif
+
+#if defined(__FreeBSD__)
+
+#ifndef USE_ISPPP
+#include <net/if_sppp.h>
+#else
+#include <machine/i4b_isppp.h>
+#endif
+
+#else
+#include <i4b/sppp/if_sppp.h>
+#endif
+#if defined(__NetBSD__) || defined (__OpenBSD__)
+#include <machine/cpu.h> /* XXX for softnet */
+#endif
+
+#if defined(__FreeBSD__) && __FreeBSD__ >= 3
+# define UNTIMEOUT(fun, arg, handle) untimeout(fun, arg, handle)
+# define TIMEOUT(fun, arg1, arg2, handle) handle = timeout(fun, arg1, arg2)
+# define IOCTL_CMD_T    u_long
+#else
+# define UNTIMEOUT(fun, arg, handle) untimeout(fun, arg)
+# define TIMEOUT(fun, arg1, arg2, handle) timeout(fun, arg1, arg2)
+#ifdef __FreeBSD__
+# define IOCTL_CMD_T    int
+#else
+# define IOCTL_CMD_T    u_long
+#endif
+#endif
+
+#if defined(__FreeBSD_version) && (__FreeBSD_version > 300005)
+#define HAS_SNPRINTF
+#endif
+
+#define MAXALIVECNT     3               /* max. alive packets */
+
+/*
+ * 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 IFF_CISCO	IFF_LINK2	/* auto-dial on output */
+
+#define PPP_ALLSTATIONS 0xff		/* All-Stations broadcast address */
+#define PPP_UI		0x03		/* Unnumbered Information */
+#define PPP_IP		0x0021		/* Internet Protocol */
+#define PPP_ISO		0x0023		/* ISO OSI Protocol */
+#define PPP_XNS		0x0025		/* Xerox NS Protocol */
+#define PPP_IPX		0x002b		/* Novell IPX Protocol */
+#define PPP_VJ_COMP	0x002d		/* VJ compressed TCP/IP */
+#define PPP_VJ_UCOMP	0x002f		/* VJ uncompressed TCP/IP */
+#define PPP_LCP		0xc021		/* Link Control Protocol */
+#define PPP_PAP		0xc023		/* Password Authentication Protocol */
+#define PPP_CHAP	0xc223		/* Challenge-Handshake Auth Protocol */
+#define PPP_IPCP	0x8021		/* Internet Protocol Control Protocol */
+
+#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 (VJ) */
+#define IPCP_OPT_ADDRESS	3	/* local IP address */
+
+#define IPCP_COMP_VJ		0x2d	/* Code for VJ compression */
+
+#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 {
+	u_char address;
+	u_char control;
+	u_short protocol;
+};
+#define PPP_HEADER_LEN          sizeof (struct ppp_header)
+
+struct lcp_header {
+	u_char type;
+	u_char ident;
+	u_short len;
+};
+#define LCP_HEADER_LEN          sizeof (struct lcp_header)
+
+struct cisco_packet {
+	u_long type;
+	u_long par1;
+	u_long par2;
+	u_short rel;
+	u_short time0;
+	u_short time1;
+};
+#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;
+#if defined(__FreeBSD__) && __FreeBSD__ >= 3
+static struct callout_handle keepalive_ch;
+#endif
+
+#if defined(__FreeBSD__)
+#define SPP_FMT         "%s%d: "
+#define SPP_ARGS(ifp)   (ifp)->if_name, (ifp)->if_unit
+#else
+#define SPP_FMT         "%s: "
+#define SPP_ARGS(ifp)   (ifp)->if_xname
+#endif
+
+/*
+ * 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] = {
+	0,	513,	0,	0,
+	0,	21,	0,	23,
+};
+#define INTERACTIVE(p) (interactive_ports[(p) & 7] == (p))
+
+/* 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,
+		       struct sockaddr *dst, struct rtentry *rt);
+
+static void sppp_cisco_send(struct sppp *sp, int type, long par1, long 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_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(u_long addr);
+static const char *sppp_ipcp_opt_name(u_char opt);
+static const char *sppp_lcp_opt_name(u_char opt);
+static const char *sppp_phase_name(enum ppp_phase 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, IOCTL_CMD_T cmd, void *data);
+static int sppp_strnlen(u_char *p, int max);
+static void sppp_get_ip_addrs(struct sppp *sp, u_long *src, u_long *dst,
+			      u_long *srcmask);
+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);
+static void sppp_qflush(struct ifqueue *ifq);
+static void sppp_set_ip_addr(struct sppp *sp, u_long src);
+
+/* 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, CP_NCP, "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 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 */
+	&pap,			/* IDX_PAP */
+	&chap,			/* IDX_CHAP */
+};
+
+
+/*
+ * Exported functions, comprising our interface to the lower layer.
+ */
+
+/*
+ * Process the received packet.
+ */
+void
+#ifndef USE_ISPPP
+sppp_input(struct ifnet *ifp, struct mbuf *m)
+#else
+isppp_input(struct ifnet *ifp, struct mbuf *m)
+#endif
+{
+	struct ppp_header *h;
+	struct ifqueue *inq = 0;
+	int s;
+	struct sppp *sp = (struct sppp *)ifp;
+	int debug = ifp->if_flags & IFF_DEBUG;
+
+	if (ifp->if_flags & IFF_UP)
+		/* Count received bytes, add FCS and one flag */
+		ifp->if_ibytes += m->m_pkthdr.len + 3;
+
+	if (m->m_pkthdr.len <= PPP_HEADER_LEN) {
+		/* Too small packet, drop it. */
+		if (debug)
+			log(LOG_DEBUG,
+			    SPP_FMT "input packet is too small, %d bytes\n",
+			    SPP_ARGS(ifp), m->m_pkthdr.len);
+	  drop:
+		++ifp->if_ierrors;
+		++ifp->if_iqdrops;
+		m_freem (m);
+		return;
+	}
+
+	/* 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_mode == IFF_CISCO) {
+			if (debug)
+				log(LOG_DEBUG,
+				    SPP_FMT "PPP packet in Cisco mode "
+				    "<addr=0x%x ctrl=0x%x proto=0x%x>\n",
+				    SPP_ARGS(ifp),
+				    h->address, h->control, ntohs(h->protocol));
+			goto drop;
+		}
+		switch (ntohs (h->protocol)) {
+		default:
+			if (debug)
+				log(LOG_DEBUG,
+				    SPP_FMT "rejecting protocol "
+				    "<addr=0x%x ctrl=0x%x proto=0x%x>\n",
+				    SPP_ARGS(ifp),
+				    h->address, h->control, ntohs(h->protocol));
+
+			if (sp->state[IDX_LCP] == STATE_OPENED)
+				sppp_cp_send (sp, PPP_LCP, PROTO_REJ,
+					++sp->pp_seq, m->m_pkthdr.len + 2,
+					&h->protocol);
+
+			++ifp->if_noproto;
+			goto drop;
+		case PPP_LCP:
+			sppp_cp_input(&lcp, sp, m);
+			m_freem (m);
+			return;
+		case PPP_PAP:
+			if (sp->pp_phase >= PHASE_AUTHENTICATE)
+				sppp_pap_input(sp, m);
+			m_freem (m);
+			return;
+		case PPP_CHAP:
+			if (sp->pp_phase >= PHASE_AUTHENTICATE)
+				sppp_chap_input(sp, m);
+			m_freem (m);
+			return;
+#ifdef INET
+		case PPP_IPCP:
+			if (sp->pp_phase == PHASE_NETWORK)
+				sppp_cp_input(&ipcp, sp, m);
+			m_freem (m);
+			return;
+		case PPP_IP:
+			if (sp->state[IDX_IPCP] == STATE_OPENED) {
+				schednetisr (NETISR_IP);
+				inq = &ipintrq;
+			}
+			break;
+#ifdef SPPP_VJ
+		case PPP_VJ_COMP:
+			if (sp->state[IDX_IPCP] == STATE_OPENED) {
+				int len;
+
+				if ((len = sl_uncompress_tcp(
+				   (u_char **)&m->m_data, m->m_len,
+				   TYPE_COMPRESSED_TCP, &sp->pp_comp)) <= 0)
+					goto drop;
+				m->m_len = m->m_pkthdr.len = len;
+				schednetisr (NETISR_IP);
+				inq = &ipintrq;
+			}
+			break;
+		case PPP_VJ_UCOMP:
+			if (sp->state[IDX_IPCP] == STATE_OPENED) {
+				int len;
+
+				if ((len = sl_uncompress_tcp(
+				   (u_char **)&m->m_data, m->m_len,
+				   TYPE_UNCOMPRESSED_TCP, &sp->pp_comp)) <= 0)
+					goto drop;
+				m->m_len = m->m_pkthdr.len = len;
+				schednetisr (NETISR_IP);
+				inq = &ipintrq;
+			}
+			break;
+#endif
+#endif
+#ifdef IPX
+		case PPP_IPX:
+			/* IPX IPXCP not implemented yet */
+			if (sp->pp_phase == PHASE_NETWORK) {
+				schednetisr (NETISR_IPX);
+				inq = &ipxintrq;
+			}
+			break;
+#endif
+#ifdef NS
+		case PPP_XNS:
+			/* XNS IDPCP not implemented yet */
+			if (sp->pp_phase == PHASE_NETWORK) {
+				schednetisr (NETISR_NS);
+				inq = &nsintrq;
+			}
+			break;
+#endif
+#ifdef ISO
+		case PPP_ISO:
+			/* OSI NLCP not implemented yet */
+			if (sp->pp_phase == PHASE_NETWORK) {
+				schednetisr (NETISR_ISO);
+				inq = &clnlintrq;
+			}
+			break;
+#endif
+		}
+		break;
+	case CISCO_MULTICAST:
+	case CISCO_UNICAST:
+		/* Don't check the control field here (RFC 1547). */
+		if (sp->pp_mode != IFF_CISCO) {
+			if (debug)
+				log(LOG_DEBUG,
+				    SPP_FMT "Cisco packet in PPP mode "
+				    "<addr=0x%x ctrl=0x%x proto=0x%x>\n",
+				    SPP_ARGS(ifp),
+				    h->address, h->control, ntohs(h->protocol));
+			goto drop;
+		}
+		switch (ntohs (h->protocol)) {
+		default:
+			++ifp->if_noproto;
+			goto invalid;
+		case CISCO_KEEPALIVE:
+			sppp_cisco_input ((struct sppp*) ifp, m);
+			m_freem (m);
+			return;
+#ifdef INET
+		case ETHERTYPE_IP:
+			schednetisr (NETISR_IP);
+			inq = &ipintrq;
+			break;
+#endif
+#ifdef IPX
+		case ETHERTYPE_IPX:
+			schednetisr (NETISR_IPX);
+			inq = &ipxintrq;
+			break;
+#endif
+#ifdef NS
+		case ETHERTYPE_NS:
+			schednetisr (NETISR_NS);
+			inq = &nsintrq;
+			break;
+#endif
+		}
+		break;
+	default:        /* Invalid PPP packet. */
+	  invalid:
+		if (debug)
+			log(LOG_DEBUG,
+			    SPP_FMT "invalid input packet "
+			    "<addr=0x%x ctrl=0x%x proto=0x%x>\n",
+			    SPP_ARGS(ifp),
+			    h->address, h->control, ntohs(h->protocol));
+		goto drop;
+	}
+
+	if (! (ifp->if_flags & IFF_UP) || ! inq)
+		goto drop;
+
+	/* Check queue. */
+	s = splimp();
+	if (IF_QFULL (inq)) {
+		/* Queue overflow. */
+		IF_DROP(inq);
+		splx(s);
+		if (debug)
+			log(LOG_DEBUG, SPP_FMT "protocol queue overflow\n",
+				SPP_ARGS(ifp));
+		goto drop;
+	}
+	IF_ENQUEUE(inq, m);
+	sp->pp_last_recv = time_second;
+	splx(s);
+}
+
+/*
+ * Enqueue transmit packet.
+ */
+static int
+sppp_output(struct ifnet *ifp, struct mbuf *m,
+	    struct sockaddr *dst, struct rtentry *rt)
+{
+	struct sppp *sp = (struct sppp*) ifp;
+	struct ppp_header *h;
+	struct ifqueue *ifq;
+	int s, rv = 0;
+	int debug = ifp->if_flags & IFF_DEBUG;
+#ifdef SPPP_VJ
+	int ipproto = PPP_IP;
+#endif
+
+	s = splimp();
+
+	if ((ifp->if_flags & IFF_UP) == 0 ||
+	    (ifp->if_flags & (IFF_RUNNING | IFF_AUTO)) == 0) {
+		m_freem (m);
+		splx (s);
+		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;
+		splx(s);
+		lcp.Open(sp);
+		s = splimp();
+	}
+
+	ifq = &ifp->if_snd;
+
+#ifdef INET
+	if (dst->sa_family == AF_INET) {
+		/* XXX Check mbuf length here? */
+		struct ip *ip = mtod (m, struct ip*);
+		struct tcphdr *tcp = (struct tcphdr*) ((long*)ip + ip->ip_hl);
+
+		/*
+		 * 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_src.s_addr == INADDR_ANY)	/* -hm */
+		{
+			m_freem(m);
+			splx(s);
+			if(ip->ip_p == IPPROTO_TCP)
+				return(EADDRNOTAVAIL);
+			else
+				return(0);
+		}
+		
+		/*
+		 * Put low delay, telnet, rlogin and ftp control packets
+		 * in front of the queue.
+		 */
+		if (IF_QFULL (&sp->pp_fastq))
+			;
+		else if (ip->ip_tos & IPTOS_LOWDELAY)
+			ifq = &sp->pp_fastq;
+		else if (m->m_len < sizeof *ip + sizeof *tcp)
+			;
+		else if (ip->ip_p != IPPROTO_TCP)
+			;
+		else if (INTERACTIVE (ntohs (tcp->th_sport)))
+			ifq = &sp->pp_fastq;
+		else if (INTERACTIVE (ntohs (tcp->th_dport)))
+			ifq = &sp->pp_fastq;
+
+#ifdef SPPP_VJ
+		/*
+		* Do IP Header compression
+		*/
+		if (sp->pp_mode != IFF_CISCO &&
+		    (sp->ipcp.flags & IPCP_VJ) &&
+		    ip->ip_p == IPPROTO_TCP)
+		{		    
+			switch (sl_compress_tcp(m, ip, &sp->pp_comp,
+						sp->ipcp.compress_cid)) {
+			case TYPE_COMPRESSED_TCP:
+				ipproto = PPP_VJ_COMP;
+				break;
+			case TYPE_UNCOMPRESSED_TCP:
+				ipproto = PPP_VJ_UCOMP;
+				break;
+			case TYPE_IP:
+				ipproto = PPP_IP;
+				break;
+			default:
+				m_freem(m);
+				splx(s);
+				return (EINVAL);
+			}
+		}
+#endif			
+	}
+#endif
+
+	/*
+	 * Prepend general data packet PPP header. For now, IP only.
+	 */
+	M_PREPEND (m, PPP_HEADER_LEN, M_DONTWAIT);
+	if (! m) {
+		if (debug)
+			log(LOG_DEBUG, SPP_FMT "no memory for transmit header\n",
+				SPP_ARGS(ifp));
+		++ifp->if_oerrors;
+		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_mode == IFF_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_mode == IFF_CISCO)
+			h->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.
+			 */
+#ifdef SPPP_VJ
+			h->protocol = htons(ipproto);
+#else
+			h->protocol = htons(PPP_IP);
+#endif
+			if (sp->state[IDX_IPCP] != STATE_OPENED)
+				rv = ENETDOWN;
+		}
+		break;
+#endif
+#ifdef NS
+	case AF_NS:     /* Xerox NS Protocol */
+		h->protocol = htons (sp->pp_mode == IFF_CISCO ?
+			ETHERTYPE_NS : PPP_XNS);
+		break;
+#endif
+#ifdef IPX
+	case AF_IPX:     /* Novell IPX Protocol */
+		h->protocol = htons (sp->pp_mode == IFF_CISCO ?
+			ETHERTYPE_IPX : PPP_IPX);
+		break;
+#endif
+#ifdef ISO
+	case AF_ISO:    /* ISO OSI Protocol */
+		if (sp->pp_mode == IFF_CISCO)
+			goto nosupport;
+		h->protocol = htons (PPP_ISO);
+		break;
+nosupport:
+#endif
+	default:
+		m_freem (m);
+		++ifp->if_oerrors;
+		splx (s);
+		return (EAFNOSUPPORT);
+	}
+
+	/*
+	 * Queue message on interface, and start output if interface
+	 * not yet active.
+	 */
+	if (IF_QFULL (ifq)) {
+		IF_DROP (&ifp->if_snd);
+		m_freem (m);
+		++ifp->if_oerrors;
+		splx (s);
+		return (rv? rv: ENOBUFS);
+	}
+	IF_ENQUEUE (ifq, m);
+	if (! (ifp->if_flags & IFF_OACTIVE))
+		(*ifp->if_start) (ifp);
+
+	/*
+	 * Count output packets and bytes.
+	 * The packet length includes header, FCS and 1 flag,
+	 * according to RFC 1333.
+	 */
+	ifp->if_obytes += m->m_pkthdr.len + 3;
+	sp->pp_last_sent = time_second;
+	splx (s);
+	return (0);
+}
+
+void
+#ifndef USE_ISPPP
+sppp_attach(struct ifnet *ifp)
+#else
+isppp_attach(struct ifnet *ifp)
+#endif
+{
+	struct sppp *sp = (struct sppp*) ifp;
+
+	/* Initialize keepalive handler. */
+	if (! spppq)
+		TIMEOUT(sppp_keepalive, 0, hz * 10, keepalive_ch);
+
+	/* Insert new entry into the keepalive list. */
+	sp->pp_next = spppq;
+	spppq = sp;
+
+	sp->pp_if.if_mtu = PP_MTU;
+	sp->pp_if.if_flags = IFF_POINTOPOINT | IFF_MULTICAST;
+	sp->pp_if.if_type = IFT_PPP;
+	sp->pp_if.if_output = sppp_output;
+
+#if 0
+	sp->pp_flags = PP_KEEPALIVE;
+#endif
+
+	sp->pp_fastq.ifq_maxlen = 32;
+	sp->pp_cpq.ifq_maxlen = 20;
+	sp->pp_loopcnt = 0;
+	sp->pp_alivecnt = 0;
+	sp->pp_seq = 0;
+	sp->pp_rseq = 0;
+	sp->pp_phase = PHASE_DEAD;
+	sp->pp_up = lcp.Up;
+	sp->pp_down = lcp.Down;
+
+#ifdef SPPP_VJ
+	sp->enable_vj = 1;
+#ifdef __FreeBSD__
+	sl_compress_init(&sp->pp_comp, -1);
+#else
+	sl_compress_init(&sp->pp_comp);
+#endif
+#endif
+
+	sp->pp_last_recv = sp->pp_last_sent = time_second;
+	sppp_lcp_init(sp);
+	sppp_ipcp_init(sp);
+	sppp_pap_init(sp);
+	sppp_chap_init(sp);
+}
+
+void
+#ifndef USE_ISPPP
+sppp_detach(struct ifnet *ifp)
+#else
+isppp_detach(struct ifnet *ifp)
+#endif
+{
+	struct sppp **q, *p, *sp = (struct sppp*) ifp;
+	int i;
+
+	/* Remove the entry from the keepalive list. */
+	for (q = &spppq; (p = *q); q = &p->pp_next)
+		if (p == sp) {
+			*q = p->pp_next;
+			break;
+		}
+
+	/* Stop keepalive handler. */
+	if (! spppq)
+		UNTIMEOUT(sppp_keepalive, 0, keepalive_ch);
+
+	for (i = 0; i < IDX_COUNT; i++)
+		UNTIMEOUT((cps[i])->TO, (void *)sp, sp->ch[i]);
+
+	UNTIMEOUT(sppp_pap_my_TO, (void *)sp, sp->pap_my_to_ch);
+}
+
+/*
+ * Flush the interface output queue.
+ */
+void
+#ifndef USE_ISPPP
+sppp_flush(struct ifnet *ifp)
+#else
+isppp_flush(struct ifnet *ifp)
+#endif
+{
+	struct sppp *sp = (struct sppp*) ifp;
+
+	sppp_qflush (&sp->pp_if.if_snd);
+	sppp_qflush (&sp->pp_fastq);
+	sppp_qflush (&sp->pp_cpq);
+}
+
+/*
+ * Check if the output queue is empty.
+ */
+int
+#ifndef USE_ISPPP
+sppp_isempty(struct ifnet *ifp)
+#else
+isppp_isempty(struct ifnet *ifp)
+#endif
+{
+	struct sppp *sp = (struct sppp*) ifp;
+	int empty, s;
+
+	s = splimp();
+	empty = !sp->pp_fastq.ifq_head && !sp->pp_cpq.ifq_head &&
+		!sp->pp_if.if_snd.ifq_head;
+	splx(s);
+	return (empty);
+}
+
+/*
+ * Get next packet to send.
+ */
+struct mbuf *
+#ifndef USE_ISPPP
+sppp_dequeue(struct ifnet *ifp)
+#else
+isppp_dequeue(struct ifnet *ifp)
+#endif
+{
+	struct sppp *sp = (struct sppp*) ifp;
+	struct mbuf *m;
+	int s;
+
+	s = splimp();
+	/*
+	 * 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_mode == IFF_CISCO)) {
+		IF_DEQUEUE(&sp->pp_fastq, m);
+		if (m == NULL)
+			IF_DEQUEUE (&sp->pp_if.if_snd, m);
+	}
+	splx(s);
+	return m;
+}
+
+/*
+ * Pick the next packet, do not remove it from the queue.
+ */
+struct mbuf *
+#ifndef USE_ISPPP
+sppp_pick(struct ifnet *ifp)
+#else
+isppp_pick(struct ifnet *ifp)
+#endif
+{
+	struct sppp *sp = (struct sppp*)ifp;
+	struct mbuf *m;
+	int s;
+
+	s= splimp ();
+
+	m = sp->pp_cpq.ifq_head;
+	if (m == NULL &&
+	    (sp->pp_phase == PHASE_NETWORK || sp->pp_mode == IFF_CISCO))
+		if ((m = sp->pp_fastq.ifq_head) == NULL)
+			m = sp->pp_if.if_snd.ifq_head;
+	splx (s);
+	return (m);
+}
+
+/*
+ * Process an ioctl request.  Called on low priority level.
+ */
+int
+#ifndef USE_ISPPP
+sppp_ioctl(struct ifnet *ifp, IOCTL_CMD_T cmd, void *data)
+#else
+isppp_ioctl(struct ifnet *ifp, IOCTL_CMD_T cmd, void *data)
+#endif
+{
+	struct ifreq *ifr = (struct ifreq*) data;
+	struct sppp *sp = (struct sppp*) ifp;
+	int s, rv, going_up, going_down, newmode;
+
+	s = splimp();
+	rv = 0;
+	switch (cmd) {
+	case SIOCAIFADDR:
+	case SIOCSIFDSTADDR:
+		break;
+
+	case SIOCSIFADDR:
+		if_up(ifp);
+		/* fall through... */
+
+	case SIOCSIFFLAGS:
+		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_PASSIVE;
+		if (!newmode)
+			newmode = ifp->if_flags & IFF_AUTO;
+		if (!newmode)
+			newmode = ifp->if_flags & IFF_CISCO;
+		ifp->if_flags &= ~(IFF_PASSIVE | IFF_AUTO | IFF_CISCO);
+		ifp->if_flags |= newmode;
+
+		if (newmode != sp->pp_mode) {
+			going_down = 1;
+			if (!going_up)
+				going_up = ifp->if_flags & IFF_RUNNING;
+		}
+
+		if (going_down) {
+			if (sp->pp_mode != IFF_CISCO) 
+				lcp.Close(sp);
+			else if (sp->pp_tlf)
+				(sp->pp_tlf)(sp);
+
+#ifndef USE_ISPPP
+			sppp_flush(ifp);
+#else
+			isppp_flush(ifp);
+#endif
+			ifp->if_flags &= ~IFF_RUNNING;
+			sp->pp_mode = newmode;
+		}
+
+		if (going_up) {
+			if (sp->pp_mode != IFF_CISCO) 
+				lcp.Close(sp);
+			sp->pp_mode = newmode;
+			if (sp->pp_mode == 0) {
+				ifp->if_flags |= IFF_RUNNING;
+				lcp.Open(sp);
+			}
+			if (sp->pp_mode == IFF_CISCO) {
+				if (sp->pp_tls)
+					(sp->pp_tls)(sp);
+				ifp->if_flags |= IFF_RUNNING;
+			}
+		}
+
+		break;
+
+#ifdef SIOCSIFMTU
+#ifndef ifr_mtu
+#define ifr_mtu ifr_metric
+#endif
+	case SIOCSIFMTU:
+		if (ifr->ifr_mtu < 128 || ifr->ifr_mtu > sp->lcp.their_mru)
+			return (EINVAL);
+		ifp->if_mtu = ifr->ifr_mtu;
+		break;
+#endif
+#ifdef SLIOCSETMTU
+	case SLIOCSETMTU:
+		if (*(short*)data < 128 || *(short*)data > sp->lcp.their_mru)
+			return (EINVAL);
+		ifp->if_mtu = *(short*)data;
+		break;
+#endif
+#ifdef SIOCGIFMTU
+	case SIOCGIFMTU:
+		ifr->ifr_mtu = ifp->if_mtu;
+		break;
+#endif
+#ifdef SLIOCGETMTU
+	case SLIOCGETMTU:
+		*(short*)data = ifp->if_mtu;
+		break;
+#endif
+	case SIOCADDMULTI:
+	case SIOCDELMULTI:
+		break;
+
+	case SIOCGIFGENERIC:
+	case SIOCSIFGENERIC:
+		rv = sppp_params(sp, cmd, data);
+		break;
+
+	default:
+		rv = ENOTTY;
+	}
+	splx(s);
+	return rv;
+}
+
+
+/*
+ * 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;
+	u_long me, mymask;
+
+	if (m->m_pkthdr.len < CISCO_PACKET_LEN) {
+		if (debug)
+			log(LOG_DEBUG,
+			    SPP_FMT "cisco invalid packet length: %d bytes\n",
+			    SPP_ARGS(ifp), m->m_pkthdr.len);
+		return;
+	}
+	h = mtod (m, struct cisco_packet*);
+	if (debug)
+		log(LOG_DEBUG,
+		    SPP_FMT "cisco input: %d bytes "
+		    "<0x%lx 0x%lx 0x%lx 0x%x 0x%x-0x%x>\n",
+		    SPP_ARGS(ifp), m->m_pkthdr.len,
+		    (u_long)ntohl (h->type), (u_long)h->par1, (u_long)h->par2, (u_int)h->rel,
+		    (u_int)h->time0, (u_int)h->time1);
+	switch (ntohl (h->type)) {
+	default:
+		if (debug)
+			addlog(SPP_FMT "cisco unknown packet type: 0x%lx\n",
+			       SPP_ARGS(ifp), (u_long)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 = ntohl (h->par1);
+		if (sp->pp_seq == sp->pp_rseq) {
+			/* Local and remote sequence numbers are equal.
+			 * Probably, the line is in loopback mode. */
+			if (sp->pp_loopcnt >= MAXALIVECNT) {
+				printf (SPP_FMT "loopback\n",
+					SPP_ARGS(ifp));
+				sp->pp_loopcnt = 0;
+				if (ifp->if_flags & IFF_UP) {
+					if_down (ifp);
+					sppp_qflush (&sp->pp_cpq);
+				}
+			}
+			++sp->pp_loopcnt;
+
+			/* Generate new local sequence number */
+#if defined(__NetBSD__) || (defined(__FreeBSD__) && __FreeBSD__ >= 3)
+			sp->pp_seq = random();
+#else
+			sp->pp_seq ^= time.tv_sec ^ time.tv_usec;
+#endif
+			break;
+		}
+		sp->pp_loopcnt = 0;
+		if (! (ifp->if_flags & IFF_UP) &&
+		    (ifp->if_flags & IFF_RUNNING)) {
+			if_up(ifp);
+			printf (SPP_FMT "up\n", SPP_ARGS(ifp));
+		}
+		break;
+	case CISCO_ADDR_REQ:
+		sppp_get_ip_addrs(sp, &me, 0, &mymask);
+		if (me != 0L)
+			sppp_cisco_send(sp, CISCO_ADDR_REPLY, me, mymask);
+		break;
+	}
+}
+
+/*
+ * Send Cisco keepalive packet.
+ */
+static void
+sppp_cisco_send(struct sppp *sp, int type, long par1, long par2)
+{
+	STDDCL;
+	struct ppp_header *h;
+	struct cisco_packet *ch;
+	struct mbuf *m;
+#if defined(__FreeBSD__) && __FreeBSD__ >= 3
+	struct timeval tv;
+#else
+	u_long t = (time.tv_sec - boottime.tv_sec) * 1000;
+#endif
+
+#if defined(__FreeBSD__) && __FreeBSD__ >= 3
+	getmicrouptime(&tv);
+#endif
+	
+	MGETHDR (m, M_DONTWAIT, MT_DATA);
+	if (! m)
+		return;
+	m->m_pkthdr.len = m->m_len = PPP_HEADER_LEN + CISCO_PACKET_LEN;
+	m->m_pkthdr.rcvif = 0;
+
+	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;
+
+#if defined(__FreeBSD__) && __FreeBSD__ >= 3
+	ch->time0 = htons ((u_short) (tv.tv_sec >> 16));
+	ch->time1 = htons ((u_short) tv.tv_sec);
+#else
+	ch->time0 = htons ((u_short) (t >> 16));
+	ch->time1 = htons ((u_short) t);
+#endif
+
+	if (debug)
+		log(LOG_DEBUG,
+		    SPP_FMT "cisco output: <0x%lx 0x%lx 0x%lx 0x%x 0x%x-0x%x>\n",
+			SPP_ARGS(ifp), (u_long)ntohl (ch->type), (u_long)ch->par1,
+			(u_long)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);
+	} else
+		IF_ENQUEUE (&sp->pp_cpq, m);
+	if (! (ifp->if_flags & IFF_OACTIVE))
+		(*ifp->if_start) (ifp);
+	ifp->if_obytes += m->m_pkthdr.len + 3;
+}
+
+/*
+ * 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 ppp_header *h;
+	struct lcp_header *lh;
+	struct mbuf *m;
+
+	if (len > MHLEN - PPP_HEADER_LEN - LCP_HEADER_LEN)
+		len = MHLEN - PPP_HEADER_LEN - LCP_HEADER_LEN;
+	MGETHDR (m, M_DONTWAIT, MT_DATA);
+	if (! m)
+		return;
+	m->m_pkthdr.len = m->m_len = PPP_HEADER_LEN + LCP_HEADER_LEN + len;
+	m->m_pkthdr.rcvif = 0;
+
+	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)
+		bcopy (data, lh+1, len);
+
+	if (debug) {
+		log(LOG_DEBUG, SPP_FMT "%s output <%s id=0x%x len=%d",
+		    SPP_ARGS(ifp),
+		    sppp_proto_name(proto),
+		    sppp_cp_type_name (lh->type), lh->ident,
+		    ntohs (lh->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;
+	} else
+		IF_ENQUEUE (&sp->pp_cpq, m);
+	if (! (ifp->if_flags & IFF_OACTIVE))
+		(*ifp->if_start) (ifp);
+	ifp->if_obytes += m->m_pkthdr.len + 3;
+}
+
+/*
+ * 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 len = m->m_pkthdr.len;
+	int rv;
+	u_char *p;
+
+	if (len < 4) {
+		if (debug)
+			log(LOG_DEBUG,
+			    SPP_FMT "%s invalid packet length: %d bytes\n",
+			    SPP_ARGS(ifp), cp->name, len);
+		return;
+	}
+	h = mtod (m, struct lcp_header*);
+	if (debug) {
+		log(LOG_DEBUG,
+		    SPP_FMT "%s input(%s): <%s id=0x%x len=%d",
+		    SPP_ARGS(ifp), cp->name,
+		    sppp_state_name(sp->state[cp->protoidx]),
+		    sppp_cp_type_name (h->type), h->ident, ntohs (h->len));
+		sppp_print_bytes ((u_char*) (h+1), len-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(SPP_FMT "%s invalid conf-req length %d\n",
+				       SPP_ARGS(ifp), 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:
+			return;
+		case STATE_CLOSED:
+			sppp_cp_send(sp, cp->proto, TERM_ACK, h->ident,
+				     0, 0);
+			return;
+		}
+		rv = (cp->RCR)(sp, h, len);
+		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, SPP_FMT "%s tlu\n",
+					    SPP_ARGS(ifp),
+					    cp->name);
+				(cp->tlu)(sp);
+			} else
+				sppp_cp_change_state(cp, sp, STATE_ACK_RCVD);
+			break;
+		default:
+			printf(SPP_FMT "%s illegal %s in state %s\n",
+			       SPP_ARGS(ifp), 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(SPP_FMT "%s id mismatch 0x%x != 0x%x\n",
+				       SPP_ARGS(ifp), 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, SPP_FMT "%s tlu\n",
+				       SPP_ARGS(ifp), cp->name);
+			(cp->tlu)(sp);
+			break;
+		default:
+			printf(SPP_FMT "%s illegal %s in state %s\n",
+			       SPP_ARGS(ifp), 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(SPP_FMT "%s id mismatch 0x%x != 0x%x\n",
+				       SPP_ARGS(ifp), 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(SPP_FMT "%s illegal %s in state %s\n",
+			       SPP_ARGS(ifp), 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, SPP_FMT "%s send terminate-ack\n",
+				    SPP_ARGS(ifp), 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;
+			break;
+		default:
+			printf(SPP_FMT "%s illegal %s in state %s\n",
+			       SPP_ARGS(ifp), 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:
+			sppp_cp_change_state(cp, sp, STATE_CLOSED);
+			(cp->tlf)(sp);
+			break;
+		case STATE_STOPPING:
+			sppp_cp_change_state(cp, sp, STATE_STOPPED);
+			(cp->tlf)(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(SPP_FMT "%s illegal %s in state %s\n",
+			       SPP_ARGS(ifp), cp->name,
+			       sppp_cp_type_name(h->type),
+			       sppp_state_name(sp->state[cp->protoidx]));
+			++ifp->if_ierrors;
+		}
+		break;
+	case CODE_REJ:
+	case PROTO_REJ:
+		/* XXX catastrophic rejects (RXJ-) aren't handled yet. */
+		log(LOG_INFO,
+		    SPP_FMT "%s: ignoring RXJ (%s) for proto 0x%x, "
+		    "danger will robinson\n",
+		    SPP_ARGS(ifp), cp->name,
+		    sppp_cp_type_name(h->type), ntohs(*((u_short *)p)));
+		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(SPP_FMT "%s illegal %s in state %s\n",
+			       SPP_ARGS(ifp), 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(SPP_FMT "lcp echo req but lcp closed\n",
+				       SPP_ARGS(ifp));
+			++ifp->if_ierrors;
+			break;
+		}
+		if (len < 8) {
+			if (debug)
+				addlog(SPP_FMT "invalid lcp echo request "
+				       "packet length: %d bytes\n",
+				       SPP_ARGS(ifp), len);
+			break;
+		}
+
+		if ((sp->lcp.opts & (1 << LCP_OPT_MAGIC)) &&
+		    ntohl (*(long*)(h+1)) == sp->lcp.magic) {
+
+			/* Line loopback mode detected. */
+			printf(SPP_FMT "loopback\n", SPP_ARGS(ifp));
+			if_down (ifp);
+			sppp_qflush (&sp->pp_cpq);
+
+			/* Shut down the PPP link. */
+			/* XXX */
+			lcp.Down(sp);
+			lcp.Up(sp);
+			break;
+		}
+		*(long*)(h+1) = htonl (sp->lcp.magic);
+		if (debug)
+			addlog(SPP_FMT "got lcp echo req, sending echo rep\n",
+			       SPP_ARGS(ifp));
+		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(SPP_FMT "lcp invalid echo reply "
+				       "packet length: %d bytes\n",
+				       SPP_ARGS(ifp), len);
+			break;
+		}
+		if (debug)
+			addlog(SPP_FMT "lcp got echo rep\n",
+			       SPP_ARGS(ifp));
+
+		if (!(sp->lcp.opts & (1 << LCP_OPT_MAGIC)) ||
+		    ntohl (*(long*)(h+1)) != sp->lcp.magic)
+			sp->pp_alivecnt = 0;
+		break;
+	default:
+		/* Unknown packet type -- send Code-Reject packet. */
+	  illegal:
+		if (debug)
+			addlog(SPP_FMT "%s send code-rej for 0x%x\n",
+			       SPP_ARGS(ifp), cp->name, h->type);
+		sppp_cp_send(sp, cp->proto, CODE_REJ, ++sp->pp_seq,
+			     m->m_pkthdr.len, h);
+		++ifp->if_ierrors;
+	}
+}
+
+
+/*
+ * 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;
+
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "%s up(%s)\n",
+		    SPP_ARGS(ifp), 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(SPP_FMT "%s illegal up in state %s\n",
+		       SPP_ARGS(ifp), cp->name,
+		       sppp_state_name(sp->state[cp->protoidx]));
+	}
+}
+
+static void
+sppp_down_event(const struct cp *cp, struct sppp *sp)
+{
+	STDDCL;
+
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "%s down(%s)\n",
+		    SPP_ARGS(ifp), 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:
+		sppp_cp_change_state(cp, sp, STATE_STARTING);
+		(cp->tls)(sp);
+		break;
+	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(SPP_FMT "%s illegal down in state %s\n",
+		       SPP_ARGS(ifp), cp->name,
+		       sppp_state_name(sp->state[cp->protoidx]));
+	}
+}
+
+
+static void
+sppp_open_event(const struct cp *cp, struct sppp *sp)
+{
+	STDDCL;
+
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "%s open(%s)\n",
+		    SPP_ARGS(ifp), 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;
+
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "%s close(%s)\n",
+		    SPP_ARGS(ifp), 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;
+		sppp_cp_send(sp, cp->proto, TERM_REQ, ++sp->pp_seq, 0, 0);
+		sppp_cp_change_state(cp, sp, STATE_CLOSING);
+		break;
+	}
+}
+
+static void
+sppp_to_event(const struct cp *cp, struct sppp *sp)
+{
+	STDDCL;
+	int s;
+
+	s = splimp();
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "%s TO(%s) rst_counter = %d\n",
+		    SPP_ARGS(ifp), cp->name,
+		    sppp_state_name(sp->state[cp->protoidx]),
+		    sp->rst_counter[cp->protoidx]);
+
+	if (--sp->rst_counter[cp->protoidx] < 0)
+		/* TO- event */
+		switch (sp->state[cp->protoidx]) {
+		case STATE_CLOSING:
+			sppp_cp_change_state(cp, sp, STATE_CLOSED);
+			(cp->tlf)(sp);
+			break;
+		case STATE_STOPPING:
+			sppp_cp_change_state(cp, sp, STATE_STOPPED);
+			(cp->tlf)(sp);
+			break;
+		case STATE_REQ_SENT:
+		case STATE_ACK_RCVD:
+		case STATE_ACK_SENT:
+			sppp_cp_change_state(cp, sp, STATE_STOPPED);
+			(cp->tlf)(sp);
+			break;
+		}
+	else
+		/* TO+ event */
+		switch (sp->state[cp->protoidx]) {
+		case STATE_CLOSING:
+		case STATE_STOPPING:
+			sppp_cp_send(sp, cp->proto, TERM_REQ, ++sp->pp_seq,
+				     0, 0);
+			TIMEOUT(cp->TO, (void *)sp, sp->lcp.timeout, 
+			    sp->ch[cp->protoidx]);
+			break;
+		case STATE_REQ_SENT:
+		case STATE_ACK_RCVD:
+			(cp->scr)(sp);
+			/* sppp_cp_change_state() will restart the timer */
+			sppp_cp_change_state(cp, sp, STATE_REQ_SENT);
+			break;
+		case STATE_ACK_SENT:
+			(cp->scr)(sp);
+			TIMEOUT(cp->TO, (void *)sp, sp->lcp.timeout,
+			    sp->ch[cp->protoidx]);
+			break;
+		}
+
+	splx(s);
+}
+
+/*
+ * Change the state of a control protocol in the state automaton.
+ * Takes care of starting/stopping the restart timer.
+ */
+void
+sppp_cp_change_state(const struct cp *cp, struct sppp *sp, int newstate)
+{
+	sp->state[cp->protoidx] = newstate;
+	UNTIMEOUT(cp->TO, (void *)sp, sp->ch[cp->protoidx]);
+
+	switch (newstate) {
+	case STATE_INITIAL:
+	case STATE_STARTING:
+	case STATE_CLOSED:
+	case STATE_STOPPED:
+	case STATE_OPENED:
+		break;
+	case STATE_CLOSING:
+	case STATE_STOPPING:
+	case STATE_REQ_SENT:
+	case STATE_ACK_RCVD:
+	case STATE_ACK_SENT:
+		TIMEOUT(cp->TO, (void *)sp, sp->lcp.timeout, 
+		    sp->ch[cp->protoidx]);
+		break;
+	}
+}
+/*
+ *--------------------------------------------------------------------------*
+ *                                                                          *
+ *                         The LCP implementation.                          *
+ *                                                                          *
+ *--------------------------------------------------------------------------*
+ */
+static void
+sppp_lcp_init(struct sppp *sp)
+{
+	sp->lcp.opts = (1 << LCP_OPT_MAGIC);
+	sp->lcp.magic = 0;
+	sp->state[IDX_LCP] = STATE_INITIAL;
+	sp->fail_counter[IDX_LCP] = 0;
+	sp->lcp.protos = 0;
+	sp->lcp.mru = sp->lcp.their_mru = PP_MTU;
+
+	/* Note that these values are  relevant for all control protocols */
+	sp->lcp.timeout = 3 * hz;
+
+	sp->lcp.max_terminate = 2;
+	sp->lcp.max_configure = 10;
+	sp->lcp.max_failure = 10;
+#if defined(__FreeBSD__) && __FreeBSD__ >= 3
+	callout_handle_init(&sp->ch[IDX_LCP]);
+#endif
+}
+
+static void
+sppp_lcp_up(struct sppp *sp)
+{
+	STDDCL;
+
+	/*
+	 * If this interface is passive or dial-on-demand, and we are
+	 * still in Initial state, it means we've got an incoming
+	 * call.  Activate the interface.
+	 */
+	if ((ifp->if_flags & (IFF_AUTO | IFF_PASSIVE)) != 0) {
+		if (debug)
+			log(LOG_DEBUG,
+			    SPP_FMT "Up event", SPP_ARGS(ifp));
+		ifp->if_flags |= IFF_RUNNING;
+		if (sp->state[IDX_LCP] == STATE_INITIAL) {
+			if (debug)
+				addlog("(incoming call)\n");
+			sp->pp_flags |= PP_CALLIN;
+			lcp.Open(sp);
+		} else if (debug)
+			addlog("\n");
+	}
+
+	sppp_up_event(&lcp, sp);
+}
+
+static void
+sppp_lcp_down(struct sppp *sp)
+{
+	STDDCL;
+
+	sppp_down_event(&lcp, sp);
+
+	/*
+	 * If this is neither a dial-on-demand nor a passive
+	 * interface, simulate an ``ifconfig down'' action, so the
+	 * administrator can force a redial by another ``ifconfig
+	 * up''.  XXX For leased line operation, should we immediately
+	 * try to reopen the connection here?
+	 */
+	if ((ifp->if_flags & (IFF_AUTO | IFF_PASSIVE)) == 0) {
+		log(LOG_INFO,
+		    SPP_FMT "Down event, taking interface down.\n",
+		    SPP_ARGS(ifp));
+		if_down(ifp);
+	} else {
+		if (debug)
+			log(LOG_DEBUG,
+			    SPP_FMT "Down event (carrier loss)\n",
+			    SPP_ARGS(ifp));
+	}
+	sp->pp_flags &= ~PP_CALLIN;
+	if (sp->state[IDX_LCP] != STATE_INITIAL)
+		lcp.Close(sp);
+	ifp->if_flags &= ~IFF_RUNNING;
+}
+
+static void
+sppp_lcp_open(struct sppp *sp)
+{
+	/*
+	 * If we are authenticator, negotiate LCP_AUTH
+	 */
+	if (sp->hisauth.proto != 0)
+		sp->lcp.opts |= (1 << LCP_OPT_AUTH_PROTO);
+	else
+		sp->lcp.opts &= ~(1 << LCP_OPT_AUTH_PROTO);
+	sp->pp_flags &= ~PP_NEEDAUTH;
+	sppp_open_event(&lcp, sp);
+}
+
+static void
+sppp_lcp_close(struct sppp *sp)
+{
+	sppp_close_event(&lcp, sp);
+}
+
+static void
+sppp_lcp_TO(void *cookie)
+{
+	sppp_to_event(&lcp, (struct sppp *)cookie);
+}
+
+/*
+ * Analyze a configure request.  Return true if it was agreeable, and
+ * caused action sca, false if it has been rejected or nak'ed, and
+ * caused action scn.  (The return value is used to make the state
+ * transition decision in the state automaton.)
+ */
+static int
+sppp_lcp_RCR(struct sppp *sp, struct lcp_header *h, int len)
+{
+	STDDCL;
+	u_char *buf, *r, *p;
+	int origlen, rlen;
+	u_long nmagic;
+	u_short authproto;
+
+	len -= 4;
+	origlen = len;
+	buf = r = malloc (len, M_TEMP, M_NOWAIT);
+	if (! buf)
+		return (0);
+
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "lcp parse opts: ",
+		    SPP_ARGS(ifp));
+
+	/* pass 1: check for things that need to be rejected */
+	p = (void*) (h+1);
+	for (rlen=0; len>1 && p[1]; len-=p[1], p+=p[1]) {
+		if (debug)
+			addlog(" %s ", sppp_lcp_opt_name(*p));
+		switch (*p) {
+		case LCP_OPT_MAGIC:
+			/* Magic number. */
+			/* fall through, both are same length */
+		case LCP_OPT_ASYNC_MAP:
+			/* Async control character map. */
+			if (len >= 6 || p[1] == 6)
+				continue;
+			if (debug)
+				addlog("[invalid] ");
+			break;
+		case LCP_OPT_MRU:
+			/* Maximum receive unit. */
+			if (len >= 4 && p[1] == 4)
+				continue;
+			if (debug)
+				addlog("[invalid] ");
+			break;
+		case LCP_OPT_AUTH_PROTO:
+			if (len < 4) {
+				if (debug)
+					addlog("[invalid] ");
+				break;
+			}
+			authproto = (p[2] << 8) + p[3];
+			if (authproto == PPP_CHAP && p[1] != 5) {
+				if (debug)
+					addlog("[invalid chap len] ");
+				break;
+			}
+			if (sp->myauth.proto == 0) {
+				/* we are not configured to do auth */
+				if (debug)
+					addlog("[not configured] ");
+				break;
+			}
+			/*
+			 * Remote want us to authenticate, remember this,
+			 * so we stay in PHASE_AUTHENTICATE after LCP got
+			 * up.
+			 */
+			sp->pp_flags |= PP_NEEDAUTH;
+			continue;
+		default:
+			/* Others not supported. */
+			if (debug)
+				addlog("[rej] ");
+			break;
+		}
+		/* Add the option to rejected list. */
+		bcopy (p, r, p[1]);
+		r += p[1];
+		rlen += p[1];
+	}
+	if (rlen) {
+		if (debug)
+			addlog(" send conf-rej\n");
+		sppp_cp_send (sp, PPP_LCP, CONF_REJ, h->ident, rlen, buf);
+		return 0;
+	} else if (debug)
+		addlog("\n");
+
+	/*
+	 * pass 2: check for option values that are unacceptable and
+	 * thus require to be nak'ed.
+	 */
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "lcp parse opt values: ",
+		    SPP_ARGS(ifp));
+
+	p = (void*) (h+1);
+	len = origlen;
+	for (rlen=0; len>1 && p[1]; len-=p[1], p+=p[1]) {
+		if (debug)
+			addlog(" %s ", sppp_lcp_opt_name(*p));
+		switch (*p) {
+		case LCP_OPT_MAGIC:
+			/* Magic number -- extract. */
+			nmagic = (u_long)p[2] << 24 |
+				(u_long)p[3] << 16 | p[4] << 8 | p[5];
+			if (nmagic != sp->lcp.magic) {
+				if (debug)
+					addlog("0x%lx ", nmagic);
+				continue;
+			}
+			/*
+			 * Local and remote magics equal -- loopback?
+			 */
+			if (sp->pp_loopcnt >= MAXALIVECNT*5) {
+				printf (SPP_FMT "loopback\n",
+					SPP_ARGS(ifp));
+				sp->pp_loopcnt = 0;
+				if (ifp->if_flags & IFF_UP) {
+					if_down(ifp);
+					sppp_qflush(&sp->pp_cpq);
+					/* XXX ? */
+					lcp.Down(sp);
+					lcp.Up(sp);
+				}
+			} else if (debug)
+				addlog("[glitch] ");
+			++sp->pp_loopcnt;
+			/*
+			 * We negate our magic here, and NAK it.  If
+			 * we see it later in an NAK packet, we
+			 * suggest a new one.
+			 */
+			nmagic = ~sp->lcp.magic;
+			/* Gonna NAK it. */
+			p[2] = nmagic >> 24;
+			p[3] = nmagic >> 16;
+			p[4] = nmagic >> 8;
+			p[5] = nmagic;
+			break;
+
+		case LCP_OPT_ASYNC_MAP:
+#ifdef NOTDEF
+			/* Async control character map -- check to be zero. */
+			if (! p[2] && ! p[3] && ! p[4] && ! p[5]) {
+				if (debug)
+					addlog("[empty] ");
+				continue;
+			}
+			if (debug)
+				addlog("[non-empty] ");
+	from Armin Gruner:
+
+	Anyway, if I remove the "p[2] = p[3] = p[4] = p[5] = 0;",
+	the driver sends back the original async map request with a
+	NAK, and the errors in the Win95 ppp log go away.
+		
+			/* suggest a zero one */
+			p[2] = p[3] = p[4] = p[5] = 0;
+			break;
+#endif
+			continue;	/* Stefan Bethke :-) told me	*/
+					/* to continue ....		*/
+
+		case LCP_OPT_MRU:
+			/*
+			 * Maximum receive unit.  Always agreeable,
+			 * but ignored by now.
+			 */
+			sp->lcp.their_mru = p[2] * 256 + p[3];
+			if (debug)
+				addlog("%lu ", sp->lcp.their_mru);
+			continue;
+
+		case LCP_OPT_AUTH_PROTO:
+			authproto = (p[2] << 8) + p[3];
+			if (sp->myauth.proto != authproto) {
+				/* not agreed, nak */
+				if (debug)
+					addlog("[mine %s != his %s] ",
+					       sppp_proto_name(sp->hisauth.proto),
+					       sppp_proto_name(authproto));
+				p[2] = sp->myauth.proto >> 8;
+				p[3] = sp->myauth.proto;
+				break;
+			}
+			if (authproto == PPP_CHAP && p[4] != CHAP_MD5) {
+				if (debug)
+					addlog("[chap not MD5] ");
+				p[4] = CHAP_MD5;
+				break;
+			}
+			continue;
+		}
+		/* Add the option to nak'ed list. */
+		bcopy (p, r, p[1]);
+		r += p[1];
+		rlen += p[1];
+	}
+	if (rlen) {
+		if (++sp->fail_counter[IDX_LCP] >= sp->lcp.max_failure) {
+			if (debug)
+				addlog(" max_failure (%d) exceeded, "
+				       "send conf-rej\n",
+				       sp->lcp.max_failure);
+			sppp_cp_send(sp, PPP_LCP, CONF_REJ, h->ident, rlen, buf);
+		} else {
+			if (debug)
+				addlog(" send conf-nak\n");
+			sppp_cp_send (sp, PPP_LCP, CONF_NAK, h->ident, rlen, buf);
+		}
+		return 0;
+	} else {
+		if (debug)
+			addlog(" send conf-ack\n");
+		sp->fail_counter[IDX_LCP] = 0;
+		sp->pp_loopcnt = 0;
+		sppp_cp_send (sp, PPP_LCP, CONF_ACK,
+			      h->ident, origlen, h+1);
+	}
+
+	free (buf, M_TEMP);
+	return (rlen == 0);
+}
+
+/*
+ * Analyze the LCP Configure-Reject option list, and adjust our
+ * negotiation.
+ */
+static void
+sppp_lcp_RCN_rej(struct sppp *sp, struct lcp_header *h, int len)
+{
+	STDDCL;
+	u_char *buf, *p;
+
+	len -= 4;
+	buf = malloc (len, M_TEMP, M_NOWAIT);
+	if (!buf)
+		return;
+
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "lcp rej opts: ",
+		    SPP_ARGS(ifp));
+
+	p = (void*) (h+1);
+	for (; len > 1 && p[1]; len -= p[1], p += p[1]) {
+		if (debug)
+			addlog(" %s ", sppp_lcp_opt_name(*p));
+		switch (*p) {
+		case LCP_OPT_MAGIC:
+			/* Magic number -- can't use it, use 0 */
+			sp->lcp.opts &= ~(1 << LCP_OPT_MAGIC);
+			sp->lcp.magic = 0;
+			break;
+		case LCP_OPT_MRU:
+			/*
+			 * Should not be rejected anyway, since we only
+			 * negotiate a MRU if explicitly requested by
+			 * peer.
+			 */
+			sp->lcp.opts &= ~(1 << LCP_OPT_MRU);
+			break;
+		case LCP_OPT_AUTH_PROTO:
+			/*
+			 * Peer doesn't want to authenticate himself,
+			 * deny unless this is a dialout call, and
+			 * AUTHFLAG_NOCALLOUT is set.
+			 */
+			if ((sp->pp_flags & PP_CALLIN) == 0 &&
+			    (sp->hisauth.flags & AUTHFLAG_NOCALLOUT) != 0) {
+				if (debug)
+					addlog("[don't insist on auth "
+					       "for callout]");
+				sp->lcp.opts &= ~(1 << LCP_OPT_AUTH_PROTO);
+				break;
+			}
+			if (debug)
+				addlog("[access denied]\n");
+			lcp.Close(sp);
+			break;
+		}
+	}
+	if (debug)
+		addlog("\n");
+	free (buf, M_TEMP);
+	return;
+}
+
+/*
+ * Analyze the LCP Configure-NAK option list, and adjust our
+ * negotiation.
+ */
+static void
+sppp_lcp_RCN_nak(struct sppp *sp, struct lcp_header *h, int len)
+{
+	STDDCL;
+	u_char *buf, *p;
+	u_long magic;
+
+	len -= 4;
+	buf = malloc (len, M_TEMP, M_NOWAIT);
+	if (!buf)
+		return;
+
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "lcp nak opts: ",
+		    SPP_ARGS(ifp));
+
+	p = (void*) (h+1);
+	for (; len > 1 && p[1]; len -= p[1], p += p[1]) {
+		if (debug)
+			addlog(" %s ", sppp_lcp_opt_name(*p));
+		switch (*p) {
+		case LCP_OPT_MAGIC:
+			/* Magic number -- renegotiate */
+			if ((sp->lcp.opts & (1 << LCP_OPT_MAGIC)) &&
+			    len >= 6 && p[1] == 6) {
+				magic = (u_long)p[2] << 24 |
+					(u_long)p[3] << 16 | p[4] << 8 | p[5];
+				/*
+				 * If the remote magic is our negated one,
+				 * this looks like a loopback problem.
+				 * Suggest a new magic to make sure.
+				 */
+				if (magic == ~sp->lcp.magic) {
+					if (debug)
+						addlog("magic glitch ");
+#if defined(__NetBSD__) || (defined(__FreeBSD__) && __FreeBSD__ >= 3)
+					sp->lcp.magic = random();
+#else
+					sp->lcp.magic = time.tv_sec + time.tv_usec;
+#endif
+				} else {
+					sp->lcp.magic = magic;
+					if (debug)
+						addlog("%lu ", magic);
+				}
+			}
+			break;
+		case LCP_OPT_MRU:
+			/*
+			 * Peer wants to advise us to negotiate an MRU.
+			 * Agree on it if it's reasonable, or use
+			 * default otherwise.
+			 */
+			if (len >= 4 && p[1] == 4) {
+				u_int mru = p[2] * 256 + p[3];
+				if (debug)
+					addlog("%d ", mru);
+				if (mru < PP_MTU || mru > PP_MAX_MRU)
+					mru = PP_MTU;
+				sp->lcp.mru = mru;
+				sp->lcp.opts |= (1 << LCP_OPT_MRU);
+			}
+			break;
+		case LCP_OPT_AUTH_PROTO:
+			/*
+			 * Peer doesn't like our authentication method,
+			 * deny.
+			 */
+			if (debug)
+				addlog("[access denied]\n");
+			lcp.Close(sp);
+			break;
+		}
+	}
+	if (debug)
+		addlog("\n");
+	free (buf, M_TEMP);
+	return;
+}
+
+static void
+sppp_lcp_tlu(struct sppp *sp)
+{
+	STDDCL;
+	int i;
+	u_long mask;
+
+	/* XXX ? */
+	if (! (ifp->if_flags & IFF_UP) &&
+	    (ifp->if_flags & IFF_RUNNING)) {
+		/* Coming out of loopback mode. */
+		if_up(ifp);
+		printf (SPP_FMT "up\n", SPP_ARGS(ifp));
+	}
+
+	for (i = 0; i < IDX_COUNT; i++)
+		if ((cps[i])->flags & CP_QUAL)
+			(cps[i])->Open(sp);
+
+	if ((sp->lcp.opts & (1 << LCP_OPT_AUTH_PROTO)) != 0 ||
+	    (sp->pp_flags & PP_NEEDAUTH) != 0)
+		sp->pp_phase = PHASE_AUTHENTICATE;
+	else
+		sp->pp_phase = PHASE_NETWORK;
+
+	if(debug)
+		log(LOG_DEBUG, SPP_FMT "phase %s\n", SPP_ARGS(ifp),
+		    sppp_phase_name(sp->pp_phase));
+
+	/*
+	 * Open all authentication protocols.  This is even required
+	 * if we already proceeded to network phase, since it might be
+	 * that remote wants us to authenticate, so we might have to
+	 * send a PAP request.  Undesired authentication protocols
+	 * don't do anything when they get an Open event.
+	 */
+	for (i = 0; i < IDX_COUNT; i++)
+		if ((cps[i])->flags & CP_AUTH)
+			(cps[i])->Open(sp);
+
+	if (sp->pp_phase == PHASE_NETWORK) {
+		/* Notify all NCPs. */
+		for (i = 0; i < IDX_COUNT; i++)
+			if ((cps[i])->flags & CP_NCP)
+				(cps[i])->Open(sp);
+	}
+
+	/* Send Up events to all started protos. */
+	for (i = 0, mask = 1; i < IDX_COUNT; i++, mask <<= 1)
+		if (sp->lcp.protos & mask && ((cps[i])->flags & CP_LCP) == 0)
+			(cps[i])->Up(sp);
+
+	/* notify low-level driver of state change */
+	if (sp->pp_chg)
+		sp->pp_chg(sp, (int)sp->pp_phase);
+	
+	if (sp->pp_phase == PHASE_NETWORK)
+		/* if no NCP is starting, close down */
+		sppp_lcp_check_and_close(sp);
+}
+
+static void
+sppp_lcp_tld(struct sppp *sp)
+{
+	STDDCL;
+	int i;
+	u_long mask;
+
+	sp->pp_phase = PHASE_TERMINATE;
+
+	if(debug)
+		log(LOG_DEBUG, SPP_FMT "phase %s\n", SPP_ARGS(ifp),
+			sppp_phase_name(sp->pp_phase));
+
+	/*
+	 * Take upper layers down.  We send the Down event first and
+	 * the Close second to prevent the upper layers from sending
+	 * ``a flurry of terminate-request packets'', as the RFC
+	 * describes it.
+	 */
+	for (i = 0, mask = 1; i < IDX_COUNT; i++, mask <<= 1)
+		if (sp->lcp.protos & mask && ((cps[i])->flags & CP_LCP) == 0) {
+			(cps[i])->Down(sp);
+			(cps[i])->Close(sp);
+		}
+}
+
+static void
+sppp_lcp_tls(struct sppp *sp)
+{
+	STDDCL;
+
+	sp->pp_phase = PHASE_ESTABLISH;
+
+	if(debug)
+		log(LOG_DEBUG, SPP_FMT "phase %s\n", SPP_ARGS(ifp),
+			sppp_phase_name(sp->pp_phase));
+
+	/* Notify lower layer if desired. */
+	if (sp->pp_tls)
+		(sp->pp_tls)(sp);
+	else
+		(sp->pp_up)(sp);
+}
+
+static void
+sppp_lcp_tlf(struct sppp *sp)
+{
+	STDDCL;
+
+	sp->pp_phase = PHASE_DEAD;
+
+	if(debug)
+		log(LOG_DEBUG, SPP_FMT "phase %s\n", SPP_ARGS(ifp),
+			sppp_phase_name(sp->pp_phase));
+
+	/* Notify lower layer if desired. */
+	if (sp->pp_tlf)
+		(sp->pp_tlf)(sp);
+	else
+		(sp->pp_down)(sp);
+}
+
+static void
+sppp_lcp_scr(struct sppp *sp)
+{
+	char opt[6 /* magicnum */ + 4 /* mru */ + 5 /* chap */];
+	int i = 0;
+	u_short authproto;
+
+	if (sp->lcp.opts & (1 << LCP_OPT_MAGIC)) {
+		if (! sp->lcp.magic)
+#if defined(__NetBSD__) || (defined(__FreeBSD__) && __FreeBSD__ >= 3)
+			sp->lcp.magic = random();
+#else
+			sp->lcp.magic = time.tv_sec + time.tv_usec;
+#endif
+		opt[i++] = LCP_OPT_MAGIC;
+		opt[i++] = 6;
+		opt[i++] = sp->lcp.magic >> 24;
+		opt[i++] = sp->lcp.magic >> 16;
+		opt[i++] = sp->lcp.magic >> 8;
+		opt[i++] = sp->lcp.magic;
+	}
+
+	if (sp->lcp.opts & (1 << LCP_OPT_MRU)) {
+		opt[i++] = LCP_OPT_MRU;
+		opt[i++] = 4;
+		opt[i++] = sp->lcp.mru >> 8;
+		opt[i++] = sp->lcp.mru;
+	}
+
+	if (sp->lcp.opts & (1 << LCP_OPT_AUTH_PROTO)) {
+		authproto = sp->hisauth.proto;
+		opt[i++] = LCP_OPT_AUTH_PROTO;
+		opt[i++] = authproto == PPP_CHAP? 5: 4;
+		opt[i++] = authproto >> 8;
+		opt[i++] = authproto;
+		if (authproto == PPP_CHAP)
+			opt[i++] = CHAP_MD5;
+	}
+
+	sp->confid[IDX_LCP] = ++sp->pp_seq;
+	sppp_cp_send (sp, PPP_LCP, CONF_REQ, sp->confid[IDX_LCP], i, &opt);
+}
+
+/*
+ * Check the open NCPs, return true if at least one NCP is open.
+ */
+static int
+sppp_ncp_check(struct sppp *sp)
+{
+	int i, mask;
+
+	for (i = 0, mask = 1; i < IDX_COUNT; i++, mask <<= 1)
+		if (sp->lcp.protos & mask && (cps[i])->flags & CP_NCP)
+			return 1;
+	return 0;
+}
+
+/*
+ * Re-check the open NCPs and see if we should terminate the link.
+ * Called by the NCPs during their tlf action handling.
+ */
+static void
+sppp_lcp_check_and_close(struct sppp *sp)
+{
+
+	if (sp->pp_phase < PHASE_NETWORK)
+		/* don't bother, we are already going down */
+		return;
+
+	if (sppp_ncp_check(sp))
+		return;
+
+	lcp.Close(sp);
+}
+/*
+ *--------------------------------------------------------------------------*
+ *                                                                          *
+ *                        The IPCP implementation.                          *
+ *                                                                          *
+ *--------------------------------------------------------------------------*
+ */
+
+static void
+sppp_ipcp_init(struct sppp *sp)
+{
+	sp->ipcp.opts = 0;
+	sp->ipcp.flags = 0;
+	sp->state[IDX_IPCP] = STATE_INITIAL;
+	sp->fail_counter[IDX_IPCP] = 0;
+#if defined(__FreeBSD__) && __FreeBSD__ >= 3
+	callout_handle_init(&sp->ch[IDX_IPCP]);
+#endif
+}
+
+static void
+sppp_ipcp_up(struct sppp *sp)
+{
+	sppp_up_event(&ipcp, sp);
+}
+
+static void
+sppp_ipcp_down(struct sppp *sp)
+{
+	sppp_down_event(&ipcp, sp);
+}
+
+static void
+sppp_ipcp_open(struct sppp *sp)
+{
+	STDDCL;
+	u_long myaddr, hisaddr;
+
+#ifdef SPPP_VJ
+	if(sp->enable_vj)
+	{
+		sp->ipcp.flags &= ~(IPCP_HISADDR_SEEN | IPCP_MYADDR_SEEN |
+				IPCP_MYADDR_DYN | IPCP_VJ);
+	}
+	else
+	{
+		sp->ipcp.flags &= ~(IPCP_HISADDR_SEEN | IPCP_MYADDR_SEEN |
+				IPCP_MYADDR_DYN);
+	}
+#else	
+	sp->ipcp.flags &= ~(IPCP_HISADDR_SEEN|IPCP_MYADDR_SEEN|IPCP_MYADDR_DYN);
+#endif
+
+	sppp_get_ip_addrs(sp, &myaddr, &hisaddr, 0);
+	/*
+	 * If we don't have his address, this probably means our
+	 * interface doesn't want to talk IP at all.  (This could
+	 * be the case if somebody wants to speak only IPX, for
+	 * example.)  Don't open IPCP in this case.
+	 */
+	if (hisaddr == 0L) {
+		/* XXX this message should go away */
+		if (debug)
+			log(LOG_DEBUG, SPP_FMT "ipcp_open(): no IP interface\n",
+			    SPP_ARGS(ifp));
+		return;
+	}
+
+#ifdef SPPP_VJ
+	if(sp->enable_vj)	
+		sp->ipcp.opts |= (1 << IPCP_OPT_COMPRESSION);
+	
+	sp->ipcp.max_state = MAX_STATES - 1;
+	sp->ipcp.compress_cid = 1;
+#endif
+	
+	if (myaddr == 0L) {
+		/*
+		 * I don't have an assigned address, so i need to
+		 * negotiate my address.
+		 */
+		sp->ipcp.flags |= IPCP_MYADDR_DYN;
+		sp->ipcp.opts |= (1 << IPCP_OPT_ADDRESS);
+	} else
+		sp->ipcp.flags |= IPCP_MYADDR_SEEN;
+	sppp_open_event(&ipcp, sp);
+}
+
+static void
+sppp_ipcp_close(struct sppp *sp)
+{
+	sppp_close_event(&ipcp, sp);
+	if (sp->ipcp.flags & IPCP_MYADDR_DYN)
+		/*
+		 * My address was dynamic, clear it again.
+		 */
+		sppp_set_ip_addr(sp, 0L);
+}
+
+static void
+sppp_ipcp_TO(void *cookie)
+{
+	sppp_to_event(&ipcp, (struct sppp *)cookie);
+}
+
+/*
+ * Analyze a configure request.  Return true if it was agreeable, and
+ * caused action sca, false if it has been rejected or nak'ed, and
+ * caused action scn.  (The return value is used to make the state
+ * transition decision in the state automaton.)
+ */
+static int
+sppp_ipcp_RCR(struct sppp *sp, struct lcp_header *h, int len)
+{
+	u_char *buf, *r, *p;
+	struct ifnet *ifp = &sp->pp_if;
+	int rlen, origlen, debug = ifp->if_flags & IFF_DEBUG;
+	u_long hisaddr, desiredaddr;
+	int gotmyaddr = 0;
+#ifdef SPPP_VJ
+	int desiredcomp;
+#endif
+
+	len -= 4;
+	origlen = len;
+	/*
+	 * Make sure to allocate a buf that can at least hold a
+	 * conf-nak with an `address' option.  We might need it below.
+	 */
+	buf = r = malloc ((len < 6? 6: len), M_TEMP, M_NOWAIT);
+	if (! buf)
+		return (0);
+
+	/* pass 1: see if we can recognize them */
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "ipcp parse opts: ",
+		    SPP_ARGS(ifp));
+	p = (void*) (h+1);
+	for (rlen=0; len>1 && p[1]; len-=p[1], p+=p[1]) {
+		if (debug)
+			addlog(" %s ", sppp_ipcp_opt_name(*p));
+		switch (*p) {
+
+#ifdef SPPP_VJ
+		case IPCP_OPT_COMPRESSION:
+			if(sp->enable_vj)
+			{
+				if (len >= 6 && p[1] == 6) {
+					/* correctly formed compress option */
+					continue;
+				}
+				if (debug)
+					addlog("[invalid] ");
+			}
+			break;
+#endif
+
+		case IPCP_OPT_ADDRESS:
+			if (len >= 6 && p[1] == 6) {
+				/* correctly formed address option */
+				continue;
+			}
+			if (debug)
+				addlog("[invalid] ");
+			break;
+		default:
+			/* Others not supported. */
+			if (debug)
+				addlog("[rej] ");
+			break;
+		}
+		/* Add the option to rejected list. */
+		bcopy (p, r, p[1]);
+		r += p[1];
+		rlen += p[1];
+	}
+	if (rlen) {
+		if (debug)
+			addlog(" send conf-rej\n");
+		sppp_cp_send (sp, PPP_IPCP, CONF_REJ, h->ident, rlen, buf);
+		return 0;
+	} else if (debug)
+		addlog("\n");
+
+	/* pass 2: parse option values */
+	sppp_get_ip_addrs(sp, 0, &hisaddr, 0);
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "ipcp parse opt values: ",
+		       SPP_ARGS(ifp));
+	p = (void*) (h+1);
+	len = origlen;
+	for (rlen=0; len>1 && p[1]; len-=p[1], p+=p[1]) {
+		if (debug)
+			addlog(" %s ", sppp_ipcp_opt_name(*p));
+		switch (*p) {
+
+#ifdef SPPP_VJ
+               case IPCP_OPT_COMPRESSION:
+			desiredcomp = p[2] << 8 | p[3];
+
+			/* We only support VJ */
+			if (desiredcomp == IPCP_COMP_VJ)
+			{
+				if(sp->enable_vj)
+				{
+	                               if (debug)
+	                                       addlog("VJ [ack] ");
+	                               sp->ipcp.flags |= IPCP_VJ;
+#ifdef __FreeBSD__
+					sl_compress_init(&sp->pp_comp, p[4]);
+#else
+					sl_compress_setup(&sp->pp_comp, p[4]);
+#endif
+	                               sp->ipcp.max_state = p[4];
+	                               sp->ipcp.compress_cid = p[5];
+	                               continue;
+	                        }
+	                        else
+	                        {
+					if (debug)
+						addlog("%#04x [VJ disabled] ", desiredcomp);
+					p[2] = IPCP_COMP_VJ >> 8;
+					p[3] = IPCP_COMP_VJ;
+					break;
+                		}
+                       }
+                       if (debug)
+                               addlog("%#04x [not supported] ", desiredcomp);
+                       p[2] = IPCP_COMP_VJ >> 8;
+                       p[3] = IPCP_COMP_VJ;
+                       break;
+#endif
+	
+		case IPCP_OPT_ADDRESS:
+			/* This is the address he wants in his end */
+			desiredaddr = p[2] << 24 | p[3] << 16 |
+				p[4] << 8 | p[5];
+
+			if (desiredaddr == hisaddr ||
+			    	(hisaddr == 1 && desiredaddr != 0)) {
+				/*
+				 * Peer's address is same as our value,
+				 * or we have set it to 0.0.0.1 to 
+				 * indicate that we do not really care,
+			 	 * this is agreeable.  Gonna conf-ack
+				 * it.
+				 */
+				if (debug)
+					addlog("%s [ack] ",
+				       		sppp_dotted_quad(hisaddr));
+				/* record that we've seen it already */
+				sp->ipcp.flags |= IPCP_HISADDR_SEEN;
+				continue;
+			}
+			/*
+			 * The address wasn't agreeable.  This is either
+			 * he sent us 0.0.0.0, asking to assign him an
+			 * address, or he send us another address not
+			 * matching our value.  Either case, we gonna
+			 * conf-nak it with our value.
+			 * XXX: we should "rej" if hisaddr == 0
+			 */
+			if (debug) {
+				if (desiredaddr == 0)
+					addlog("[addr requested] ");
+				else
+					addlog("%s [not agreed] ",
+				       		sppp_dotted_quad(desiredaddr));
+			}
+			p[2] = hisaddr >> 24;
+			p[3] = hisaddr >> 16;
+			p[4] = hisaddr >> 8;
+			p[5] = hisaddr;
+			break;
+		}
+
+		/* Add the option to nak'ed list. */
+		bcopy (p, r, p[1]);
+		r += p[1];
+		rlen += p[1];
+	}
+
+	/*
+	 * If we are about to conf-ack the request, but haven't seen
+	 * his address so far, gonna conf-nak it instead, with the
+	 * `address' option present and our idea of his address being
+	 * filled in there, to request negotiation of both addresses.
+	 *
+	 * XXX This can result in an endless req - nak loop if peer
+	 * doesn't want to send us his address.  Q: What should we do
+	 * about it?  XXX  A: implement the max-failure counter.
+	 */
+	if (rlen == 0 && !(sp->ipcp.flags & IPCP_HISADDR_SEEN) && !gotmyaddr) {
+		buf[0] = IPCP_OPT_ADDRESS;
+		buf[1] = 6;
+		buf[2] = hisaddr >> 24;
+		buf[3] = hisaddr >> 16;
+		buf[4] = hisaddr >> 8;
+		buf[5] = hisaddr;
+		rlen = 6;
+		if (debug)
+			addlog("still need hisaddr ");
+	}
+
+	if (rlen) {
+		if (debug)
+			addlog(" send conf-nak\n");
+		sppp_cp_send (sp, PPP_IPCP, CONF_NAK, h->ident, rlen, buf);
+	} else {
+		if (debug)
+			addlog(" send conf-ack\n");
+		sppp_cp_send (sp, PPP_IPCP, CONF_ACK,
+			      h->ident, origlen, h+1);
+	}
+
+	free (buf, M_TEMP);
+	return (rlen == 0);
+}
+
+/*
+ * Analyze the IPCP Configure-Reject option list, and adjust our
+ * negotiation.
+ */
+static void
+sppp_ipcp_RCN_rej(struct sppp *sp, struct lcp_header *h, int len)
+{
+	u_char *buf, *p;
+	struct ifnet *ifp = &sp->pp_if;
+	int debug = ifp->if_flags & IFF_DEBUG;
+
+	len -= 4;
+	buf = malloc (len, M_TEMP, M_NOWAIT);
+	if (!buf)
+		return;
+
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "ipcp rej opts: ",
+		    SPP_ARGS(ifp));
+
+	p = (void*) (h+1);
+	for (; len > 1 && p[1]; len -= p[1], p += p[1]) {
+		if (debug)
+			addlog(" %s ", sppp_ipcp_opt_name(*p));
+		switch (*p) {
+#ifdef SPPP_VJ
+		case IPCP_OPT_COMPRESSION:
+			sp->ipcp.opts &= ~(1 << IPCP_OPT_COMPRESSION);
+			break;
+#endif
+		case IPCP_OPT_ADDRESS:
+			/*
+			 * Peer doesn't grok address option.  This is
+			 * bad.  XXX  Should we better give up here?
+			 * XXX We could try old "addresses" option...
+			 */
+			sp->ipcp.opts &= ~(1 << IPCP_OPT_ADDRESS);
+			break;
+
+#ifdef NOTYET
+		case IPCP_OPT_COMPRESS:
+			sp->ipcp.opts &= ~(1 << IPCP_OPT_COMPRESS);
+			break;
+#endif
+		}
+	}
+	if (debug)
+		addlog("\n");
+	free (buf, M_TEMP);
+	return;
+}
+
+/*
+ * Analyze the IPCP Configure-NAK option list, and adjust our
+ * negotiation.
+ */
+static void
+sppp_ipcp_RCN_nak(struct sppp *sp, struct lcp_header *h, int len)
+{
+	u_char *buf, *p;
+	struct ifnet *ifp = &sp->pp_if;
+	int debug = ifp->if_flags & IFF_DEBUG;
+	u_long wantaddr;
+#ifdef SPPP_VJ
+	int desiredcomp;
+#endif
+
+	len -= 4;
+	buf = malloc (len, M_TEMP, M_NOWAIT);
+	if (!buf)
+		return;
+
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "ipcp nak opts: ",
+		    SPP_ARGS(ifp));
+
+	p = (void*) (h+1);
+	for (; len > 1 && p[1]; len -= p[1], p += p[1]) {
+		if (debug)
+			addlog(" %s ", sppp_ipcp_opt_name(*p));
+		switch (*p) {
+#ifdef SPPP_VJ
+               case IPCP_OPT_COMPRESSION:
+                       if (len >= 6 && p[1] == 6) {
+                               desiredcomp = p[2] << 8 | p[3];
+                               if (debug)
+                                       addlog("[wantcomp %#04x] ",
+                                               desiredcomp);
+                               if (desiredcomp == IPCP_COMP_VJ && sp->enable_vj) {
+#ifdef __FreeBSD__
+                                       sl_compress_init(&sp->pp_comp, p[4]);
+#else
+                                       sl_compress_setup(&sp->pp_comp, p[4]);
+#endif
+                                       sp->ipcp.max_state = p[4];
+                                       sp->ipcp.compress_cid = p[5];
+                                       addlog("[agree] ");
+                               } else
+                                       sp->ipcp.opts &=
+                                               ~(1 << IPCP_OPT_COMPRESSION);
+                       }
+                       break;
+#endif
+		case IPCP_OPT_ADDRESS:
+			/*
+			 * Peer doesn't like our local IP address.  See
+			 * if we can do something for him.  We'll drop
+			 * him our address then.
+			 */
+			if (len >= 6 && p[1] == 6) {
+				wantaddr = p[2] << 24 | p[3] << 16 |
+					p[4] << 8 | p[5];
+				sp->ipcp.opts |= (1 << IPCP_OPT_ADDRESS);
+				if (debug)
+					addlog("[wantaddr %s] ",
+					       sppp_dotted_quad(wantaddr));
+				/*
+				 * When doing dynamic address assignment,
+				 * we accept his offer.  Otherwise, we
+				 * ignore it and thus continue to negotiate
+				 * our already existing value.
+			 	 * XXX: Bogus, if he said no once, he'll
+				 * just say no again, might as well die.
+				 */
+				if (sp->ipcp.flags & IPCP_MYADDR_DYN) {
+					sppp_set_ip_addr(sp, wantaddr);
+					if (debug)
+						addlog("[agree] ");
+					sp->ipcp.flags |= IPCP_MYADDR_SEEN;
+				}
+			}
+			break;
+#ifdef NOTYET
+		case IPCP_OPT_COMPRESS:
+			/*
+			 * Peer wants different compression parameters.
+			 */
+			break;
+#endif
+		}
+	}
+	if (debug)
+		addlog("\n");
+	free (buf, M_TEMP);
+	return;
+}
+
+static void
+sppp_ipcp_tlu(struct sppp *sp)
+{
+	/* we are up - notify isdn daemon */
+	if (sp->pp_con)
+		sp->pp_con(sp);
+}
+
+static void
+sppp_ipcp_tld(struct sppp *sp)
+{
+}
+
+static void
+sppp_ipcp_tls(struct sppp *sp)
+{
+	/* indicate to LCP that it must stay alive */
+	sp->lcp.protos |= (1 << IDX_IPCP);
+}
+
+static void
+sppp_ipcp_tlf(struct sppp *sp)
+{
+	/* we no longer need LCP */
+	sp->lcp.protos &= ~(1 << IDX_IPCP);
+	sppp_lcp_check_and_close(sp);
+}
+
+static void
+sppp_ipcp_scr(struct sppp *sp)
+{
+	char opt[6 /* compression */ + 6 /* address */];
+	u_long ouraddr;
+	int i = 0;
+
+#ifdef SPPP_VJ
+	if (sp->ipcp.opts & (1 << IPCP_OPT_COMPRESSION)) {
+		opt[i++] = IPCP_OPT_COMPRESSION;
+		opt[i++] = 6;
+		opt[i++] = IPCP_COMP_VJ >> 8;
+		opt[i++] = IPCP_COMP_VJ;
+		opt[i++] = sp->ipcp.max_state;
+		opt[i++] = sp->ipcp.compress_cid;
+	}
+#endif
+
+	if (sp->ipcp.opts & (1 << IPCP_OPT_ADDRESS)) {
+		sppp_get_ip_addrs(sp, &ouraddr, 0, 0);
+		opt[i++] = IPCP_OPT_ADDRESS;
+		opt[i++] = 6;
+		opt[i++] = ouraddr >> 24;
+		opt[i++] = ouraddr >> 16;
+		opt[i++] = ouraddr >> 8;
+		opt[i++] = ouraddr;
+	}
+
+	sp->confid[IDX_IPCP] = ++sp->pp_seq;
+	sppp_cp_send(sp, PPP_IPCP, CONF_REQ, sp->confid[IDX_IPCP], i, &opt);
+}
+
+
+/*
+ *--------------------------------------------------------------------------*
+ *                                                                          *
+ *                        The CHAP implementation.                          *
+ *                                                                          *
+ *--------------------------------------------------------------------------*
+ */
+
+/*
+ * The authentication protocols don't employ a full-fledged state machine as
+ * the control protocols do, since they do have Open and Close events, but
+ * not Up and Down, nor are they explicitly terminated.  Also, use of the
+ * authentication protocols may be different in both directions (this makes
+ * sense, think of a machine that never accepts incoming calls but only
+ * calls out, it doesn't require the called party to authenticate itself).
+ *
+ * Our state machine for the local authentication protocol (we are requesting
+ * the peer to authenticate) looks like:
+ *
+ *						    RCA-
+ *	      +--------------------------------------------+
+ *	      V					    scn,tld|
+ *	  +--------+			       Close   +---------+ RCA+
+ *	  |	   |<----------------------------------|	 |------+
+ *   +--->| Closed |				TO*    | Opened	 | sca	|
+ *   |	  |	   |-----+		       +-------|	 |<-----+
+ *   |	  +--------+ irc |		       |       +---------+
+ *   |	    ^		 |		       |	   ^
+ *   |	    |		 |		       |	   |
+ *   |	    |		 |		       |	   |
+ *   |	 TO-|		 |		       |	   |
+ *   |	    |tld  TO+	 V		       |	   |
+ *   |	    |	+------->+		       |	   |
+ *   |	    |	|	 |		       |	   |
+ *   |	  +--------+	 V		       |	   |
+ *   |	  |	   |<----+<--------------------+	   |
+ *   |	  | Req-   | scr				   |
+ *   |	  | Sent   |					   |
+ *   |	  |	   |					   |
+ *   |	  +--------+					   |
+ *   | RCA- |	| RCA+					   |
+ *   +------+	+------------------------------------------+
+ *   scn,tld	  sca,irc,ict,tlu
+ *
+ *
+ *   with:
+ *
+ *	Open:	LCP reached authentication phase
+ *	Close:	LCP reached terminate phase
+ *
+ *	RCA+:	received reply (pap-req, chap-response), acceptable
+ *	RCN:	received reply (pap-req, chap-response), not acceptable
+ *	TO+:	timeout with restart counter >= 0
+ *	TO-:	timeout with restart counter < 0
+ *	TO*:	reschedule timeout for CHAP
+ *
+ *	scr:	send request packet (none for PAP, chap-challenge)
+ *	sca:	send ack packet (pap-ack, chap-success)
+ *	scn:	send nak packet (pap-nak, chap-failure)
+ *	ict:	initialize re-challenge timer (CHAP only)
+ *
+ *	tlu:	this-layer-up, LCP reaches network phase
+ *	tld:	this-layer-down, LCP enters terminate phase
+ *
+ * Note that in CHAP mode, after sending a new challenge, while the state
+ * automaton falls back into Req-Sent state, it doesn't signal a tld
+ * event to LCP, so LCP remains in network phase.  Only after not getting
+ * any response (or after getting an unacceptable response), CHAP closes,
+ * causing LCP to enter terminate phase.
+ *
+ * With PAP, there is no initial request that can be sent.  The peer is
+ * expected to send one based on the successful negotiation of PAP as
+ * the authentication protocol during the LCP option negotiation.
+ *
+ * Incoming authentication protocol requests (remote requests
+ * authentication, we are peer) don't employ a state machine at all,
+ * they are simply answered.  Some peers [Ascend P50 firmware rev
+ * 4.50] react allergically when sending IPCP requests while they are
+ * still in authentication phase (thereby violating the standard that
+ * demands that these NCP packets are to be discarded), so we keep
+ * track of the peer demanding us to authenticate, and only proceed to
+ * phase network once we've seen a positive acknowledge for the
+ * authentication.
+ */
+
+/*
+ * Handle incoming CHAP packets.
+ */
+void
+sppp_chap_input(struct sppp *sp, struct mbuf *m)
+{
+	STDDCL;
+	struct lcp_header *h;
+	int len, x;
+	u_char *value, *name, digest[AUTHKEYLEN], dsize;
+	int value_len, name_len;
+	MD5_CTX ctx;
+
+	len = m->m_pkthdr.len;
+	if (len < 4) {
+		if (debug)
+			log(LOG_DEBUG,
+			    SPP_FMT "chap invalid packet length: %d bytes\n",
+			    SPP_ARGS(ifp), len);
+		return;
+	}
+	h = mtod (m, struct lcp_header*);
+	if (len > ntohs (h->len))
+		len = ntohs (h->len);
+
+	switch (h->type) {
+	/* challenge, failure and success are his authproto */
+	case CHAP_CHALLENGE:
+		value = 1 + (u_char*)(h+1);
+		value_len = value[-1];
+		name = value + value_len;
+		name_len = len - value_len - 5;
+		if (name_len < 0) {
+			if (debug) {
+				log(LOG_DEBUG,
+				    SPP_FMT "chap corrupted challenge "
+				    "<%s id=0x%x len=%d",
+				    SPP_ARGS(ifp),
+				    sppp_auth_type_name(PPP_CHAP, h->type),
+				    h->ident, ntohs(h->len));
+				sppp_print_bytes((u_char*) (h+1), len-4);
+				addlog(">\n");
+			}
+			break;
+		}
+		
+		if (debug) {
+			log(LOG_DEBUG,
+			    SPP_FMT "chap input <%s id=0x%x len=%d name=",
+			    SPP_ARGS(ifp),
+			    sppp_auth_type_name(PPP_CHAP, h->type), h->ident,
+			    ntohs(h->len));
+			sppp_print_string((char*) name, name_len);
+			addlog(" value-size=%d value=", value_len);
+			sppp_print_bytes(value, value_len);
+			addlog(">\n");
+		}
+
+		/* Compute reply value. */
+		MD5Init(&ctx);
+		MD5Update(&ctx, &h->ident, 1);
+		MD5Update(&ctx, sp->myauth.secret,
+			  sppp_strnlen(sp->myauth.secret, AUTHKEYLEN));
+		MD5Update(&ctx, value, value_len);
+		MD5Final(digest, &ctx);
+		dsize = sizeof digest;
+
+		sppp_auth_send(&chap, sp, CHAP_RESPONSE, h->ident,
+			       sizeof dsize, (const char *)&dsize,
+			       sizeof digest, digest,
+			       (size_t)sppp_strnlen(sp->myauth.name, AUTHNAMELEN),
+			       sp->myauth.name,
+			       0);
+		break;
+
+	case CHAP_SUCCESS:
+		if (debug) {
+			log(LOG_DEBUG, SPP_FMT "chap success",
+			    SPP_ARGS(ifp));
+			if (len > 4) {
+				addlog(": ");
+				sppp_print_string((char*)(h + 1), len - 4);
+			}
+			addlog("\n");
+		}
+		x = splimp();
+		sp->pp_flags &= ~PP_NEEDAUTH;
+		if (sp->myauth.proto == PPP_CHAP &&
+		    (sp->lcp.opts & (1 << LCP_OPT_AUTH_PROTO)) &&
+		    (sp->lcp.protos & (1 << IDX_CHAP)) == 0) {
+			/*
+			 * We are authenticator for CHAP but didn't
+			 * complete yet.  Leave it to tlu to proceed
+			 * to network phase.
+			 */
+			splx(x);
+			break;
+		}
+		splx(x);
+		sppp_phase_network(sp);
+		break;
+
+	case CHAP_FAILURE:
+		if (debug) {
+			log(LOG_INFO, SPP_FMT "chap failure",
+			    SPP_ARGS(ifp));
+			if (len > 4) {
+				addlog(": ");
+				sppp_print_string((char*)(h + 1), len - 4);
+			}
+			addlog("\n");
+		} else
+			log(LOG_INFO, SPP_FMT "chap failure\n",
+			    SPP_ARGS(ifp));
+		/* await LCP shutdown by authenticator */
+		break;
+
+	/* response is my authproto */
+	case CHAP_RESPONSE:
+		value = 1 + (u_char*)(h+1);
+		value_len = value[-1];
+		name = value + value_len;
+		name_len = len - value_len - 5;
+		if (name_len < 0) {
+			if (debug) {
+				log(LOG_DEBUG,
+				    SPP_FMT "chap corrupted response "
+				    "<%s id=0x%x len=%d",
+				    SPP_ARGS(ifp),
+				    sppp_auth_type_name(PPP_CHAP, h->type),
+				    h->ident, ntohs(h->len));
+				sppp_print_bytes((u_char*)(h+1), len-4);
+				addlog(">\n");
+			}
+			break;
+		}
+		if (h->ident != sp->confid[IDX_CHAP]) {
+			if (debug)
+				log(LOG_DEBUG,
+				    SPP_FMT "chap dropping response for old ID "
+				    "(got %d, expected %d)\n",
+				    SPP_ARGS(ifp),
+				    h->ident, sp->confid[IDX_CHAP]);
+			break;
+		}
+		if (name_len != sppp_strnlen(sp->hisauth.name, AUTHNAMELEN)
+		    || bcmp(name, sp->hisauth.name, name_len) != 0) {
+			log(LOG_INFO, SPP_FMT "chap response, his name ",
+			    SPP_ARGS(ifp));
+			sppp_print_string(name, name_len);
+			addlog(" != expected ");
+			sppp_print_string(sp->hisauth.name,
+					  sppp_strnlen(sp->hisauth.name, AUTHNAMELEN));
+			addlog("\n");
+		}    
+		if (debug) {
+			log(LOG_DEBUG, SPP_FMT "chap input(%s) "
+			    "<%s id=0x%x len=%d name=",
+			    SPP_ARGS(ifp),
+			    sppp_state_name(sp->state[IDX_CHAP]),
+			    sppp_auth_type_name(PPP_CHAP, h->type),
+			    h->ident, ntohs (h->len));
+			sppp_print_string((char*)name, name_len);
+			addlog(" value-size=%d value=", value_len);
+			sppp_print_bytes(value, value_len);
+			addlog(">\n");
+		}
+		if (value_len != AUTHKEYLEN) {
+			if (debug)
+				log(LOG_DEBUG,
+				    SPP_FMT "chap bad hash value length: "
+				    "%d bytes, should be %d\n",
+				    SPP_ARGS(ifp), value_len,
+				    AUTHKEYLEN);
+			break;
+		}
+
+		MD5Init(&ctx);
+		MD5Update(&ctx, &h->ident, 1);
+		MD5Update(&ctx, sp->hisauth.secret,
+			  sppp_strnlen(sp->hisauth.secret, AUTHKEYLEN));
+		MD5Update(&ctx, sp->myauth.challenge, AUTHKEYLEN);
+		MD5Final(digest, &ctx);
+
+#define FAILMSG "Failed..."
+#define SUCCMSG "Welcome!"
+
+		if (value_len != sizeof digest ||
+		    bcmp(digest, value, value_len) != 0) {
+			/* action scn, tld */
+			sppp_auth_send(&chap, sp, CHAP_FAILURE, h->ident,
+				       sizeof(FAILMSG) - 1, (u_char *)FAILMSG,
+				       0);
+			chap.tld(sp);
+			break;
+		}
+		/* action sca, perhaps tlu */
+		if (sp->state[IDX_CHAP] == STATE_REQ_SENT ||
+		    sp->state[IDX_CHAP] == STATE_OPENED)
+			sppp_auth_send(&chap, sp, CHAP_SUCCESS, h->ident,
+				       sizeof(SUCCMSG) - 1, (u_char *)SUCCMSG,
+				       0);
+		if (sp->state[IDX_CHAP] == STATE_REQ_SENT) {
+			sppp_cp_change_state(&chap, sp, STATE_OPENED);
+			chap.tlu(sp);
+		}
+		break;
+
+	default:
+		/* Unknown CHAP packet type -- ignore. */
+		if (debug) {
+			log(LOG_DEBUG, SPP_FMT "chap unknown input(%s) "
+			    "<0x%x id=0x%xh len=%d",
+			    SPP_ARGS(ifp),
+			    sppp_state_name(sp->state[IDX_CHAP]),
+			    h->type, h->ident, ntohs(h->len));
+			sppp_print_bytes((u_char*)(h+1), len-4);
+			addlog(">\n");
+		}
+		break;
+
+	}
+}
+
+static void
+sppp_chap_init(struct sppp *sp)
+{
+	/* Chap doesn't have STATE_INITIAL at all. */
+	sp->state[IDX_CHAP] = STATE_CLOSED;
+	sp->fail_counter[IDX_CHAP] = 0;
+#if defined(__FreeBSD__) && __FreeBSD__ >= 3
+	callout_handle_init(&sp->ch[IDX_CHAP]);
+#endif
+}
+
+static void
+sppp_chap_open(struct sppp *sp)
+{
+	if (sp->myauth.proto == PPP_CHAP &&
+	    (sp->lcp.opts & (1 << LCP_OPT_AUTH_PROTO)) != 0) {
+		/* we are authenticator for CHAP, start it */
+		chap.scr(sp);
+		sp->rst_counter[IDX_CHAP] = sp->lcp.max_configure;
+		sppp_cp_change_state(&chap, sp, STATE_REQ_SENT);
+	}
+	/* nothing to be done if we are peer, await a challenge */
+}
+
+static void
+sppp_chap_close(struct sppp *sp)
+{
+	if (sp->state[IDX_CHAP] != STATE_CLOSED)
+		sppp_cp_change_state(&chap, sp, STATE_CLOSED);
+}
+
+static void
+sppp_chap_TO(void *cookie)
+{
+	struct sppp *sp = (struct sppp *)cookie;
+	STDDCL;
+	int s;
+
+	s = splimp();
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "chap TO(%s) rst_counter = %d\n",
+		    SPP_ARGS(ifp),
+		    sppp_state_name(sp->state[IDX_CHAP]),
+		    sp->rst_counter[IDX_CHAP]);
+
+	if (--sp->rst_counter[IDX_CHAP] < 0)
+		/* TO- event */
+		switch (sp->state[IDX_CHAP]) {
+		case STATE_REQ_SENT:
+			chap.tld(sp);
+			sppp_cp_change_state(&chap, sp, STATE_CLOSED);
+			break;
+		}
+	else
+		/* TO+ (or TO*) event */
+		switch (sp->state[IDX_CHAP]) {
+		case STATE_OPENED:
+			/* TO* event */
+			sp->rst_counter[IDX_CHAP] = sp->lcp.max_configure;
+			/* fall through */
+		case STATE_REQ_SENT:
+			chap.scr(sp);
+			/* sppp_cp_change_state() will restart the timer */
+			sppp_cp_change_state(&chap, sp, STATE_REQ_SENT);
+			break;
+		}
+
+	splx(s);
+}
+
+static void
+sppp_chap_tlu(struct sppp *sp)
+{
+	STDDCL;
+	int i, x;
+
+	i = 0;
+	sp->rst_counter[IDX_CHAP] = sp->lcp.max_configure;
+
+	/*
+	 * Some broken CHAP implementations (Conware CoNet, firmware
+	 * 4.0.?) don't want to re-authenticate their CHAP once the
+	 * initial challenge-response exchange has taken place.
+	 * Provide for an option to avoid rechallenges.
+	 */
+	if ((sp->hisauth.flags & AUTHFLAG_NORECHALLENGE) == 0) {
+		/*
+		 * Compute the re-challenge timeout.  This will yield
+		 * a number between 300 and 810 seconds.
+		 */
+		i = 300 + ((unsigned)(random() & 0xff00) >> 7);
+		TIMEOUT(chap.TO, (void *)sp, i * hz, sp->ch[IDX_CHAP]);
+	}
+
+	if (debug) {
+		log(LOG_DEBUG,
+		    SPP_FMT "chap %s, ",
+		    SPP_ARGS(ifp),
+		    sp->pp_phase == PHASE_NETWORK? "reconfirmed": "tlu");
+		if ((sp->hisauth.flags & AUTHFLAG_NORECHALLENGE) == 0)
+			addlog("next re-challenge in %d seconds\n", i);
+		else
+			addlog("re-challenging supressed\n");
+	}
+
+	x = splimp();
+	/* indicate to LCP that we need to be closed down */
+	sp->lcp.protos |= (1 << IDX_CHAP);
+
+	if (sp->pp_flags & PP_NEEDAUTH) {
+		/*
+		 * Remote is authenticator, but his auth proto didn't
+		 * complete yet.  Defer the transition to network
+		 * phase.
+		 */
+		splx(x);
+		return;
+	}
+	splx(x);
+
+	/*
+	 * If we are already in phase network, we are done here.  This
+	 * is the case if this is a dummy tlu event after a re-challenge.
+	 */
+	if (sp->pp_phase != PHASE_NETWORK)
+		sppp_phase_network(sp);
+}
+
+static void
+sppp_chap_tld(struct sppp *sp)
+{
+	STDDCL;
+
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "chap tld\n", SPP_ARGS(ifp));
+	UNTIMEOUT(chap.TO, (void *)sp, sp->ch[IDX_CHAP]);
+	sp->lcp.protos &= ~(1 << IDX_CHAP);
+
+	lcp.Close(sp);
+}
+
+static void
+sppp_chap_scr(struct sppp *sp)
+{
+#if !(defined(__FreeBSD__) && __FreeBSD__ >= 3)
+	struct timeval tv;
+#endif
+	u_long *ch, seed;
+	u_char clen;
+
+	/* Compute random challenge. */
+	ch = (u_long *)sp->myauth.challenge;
+#if defined(__FreeBSD__) && __FreeBSD__ >= 3
+
+#ifdef RANDOMDEV
+	read_random(&seed, sizeof seed);
+#else
+	seed = (u_long)random();
+#endif /* RANDOMDEV */
+
+#else
+	microtime(&tv);
+	seed = tv.tv_sec ^ tv.tv_usec;
+#endif
+	ch[0] = seed ^ random();
+	ch[1] = seed ^ random();
+	ch[2] = seed ^ random();
+	ch[3] = seed ^ random();
+	clen = AUTHKEYLEN;
+
+	sp->confid[IDX_CHAP] = ++sp->pp_seq;
+
+	sppp_auth_send(&chap, sp, CHAP_CHALLENGE, sp->confid[IDX_CHAP],
+		       sizeof clen, (const char *)&clen,
+		       (size_t)AUTHKEYLEN, sp->myauth.challenge,
+		       (size_t)sppp_strnlen(sp->myauth.name, AUTHNAMELEN),
+		       sp->myauth.name,
+		       0);
+}
+/*
+ *--------------------------------------------------------------------------*
+ *                                                                          *
+ *                        The PAP implementation.                           *
+ *                                                                          *
+ *--------------------------------------------------------------------------*
+ */
+/*
+ * For PAP, we need to keep a little state also if we are the peer, not the
+ * authenticator.  This is since we don't get a request to authenticate, but
+ * have to repeatedly authenticate ourself until we got a response (or the
+ * retry counter is expired).
+ */
+
+/*
+ * Handle incoming PAP packets.  */
+static void
+sppp_pap_input(struct sppp *sp, struct mbuf *m)
+{
+	STDDCL;
+	struct lcp_header *h;
+	int len, x;
+	u_char *name, *passwd, mlen;
+	int name_len, passwd_len;
+
+	len = m->m_pkthdr.len;
+	if (len < 5) {
+		if (debug)
+			log(LOG_DEBUG,
+			    SPP_FMT "pap invalid packet length: %d bytes\n",
+			    SPP_ARGS(ifp), len);
+		return;
+	}
+	h = mtod (m, struct lcp_header*);
+	if (len > ntohs (h->len))
+		len = ntohs (h->len);
+	switch (h->type) {
+	/* PAP request is my authproto */
+	case PAP_REQ:
+		name = 1 + (u_char*)(h+1);
+		name_len = name[-1];
+		passwd = name + name_len + 1;
+		if (name_len > len - 6 ||
+		    (passwd_len = passwd[-1]) > len - 6 - name_len) {
+			if (debug) {
+				log(LOG_DEBUG, SPP_FMT "pap corrupted input "
+				    "<%s id=0x%x len=%d",
+				    SPP_ARGS(ifp),
+				    sppp_auth_type_name(PPP_PAP, h->type),
+				    h->ident, ntohs(h->len));
+				sppp_print_bytes((u_char*)(h+1), len-4);
+				addlog(">\n");
+			}
+			break;
+		}
+		if (debug) {
+			log(LOG_DEBUG, SPP_FMT "pap input(%s) "
+			    "<%s id=0x%x len=%d name=",
+			    SPP_ARGS(ifp),
+			    sppp_state_name(sp->state[IDX_PAP]),
+			    sppp_auth_type_name(PPP_PAP, h->type),
+			    h->ident, ntohs(h->len));
+			sppp_print_string((char*)name, name_len);
+			addlog(" passwd=");
+			sppp_print_string((char*)passwd, passwd_len);
+			addlog(">\n");
+		}
+		if (name_len > AUTHNAMELEN ||
+		    passwd_len > AUTHKEYLEN ||
+		    bcmp(name, sp->hisauth.name, name_len) != 0 ||
+		    bcmp(passwd, sp->hisauth.secret, passwd_len) != 0) {
+			/* action scn, tld */
+			mlen = sizeof(FAILMSG) - 1;
+			sppp_auth_send(&pap, sp, PAP_NAK, h->ident,
+				       sizeof mlen, (const char *)&mlen,
+				       sizeof(FAILMSG) - 1, (u_char *)FAILMSG,
+				       0);
+			pap.tld(sp);
+			break;
+		}
+		/* action sca, perhaps tlu */
+		if (sp->state[IDX_PAP] == STATE_REQ_SENT ||
+		    sp->state[IDX_PAP] == STATE_OPENED) {
+			mlen = sizeof(SUCCMSG) - 1;
+			sppp_auth_send(&pap, sp, PAP_ACK, h->ident,
+				       sizeof mlen, (const char *)&mlen,
+				       sizeof(SUCCMSG) - 1, (u_char *)SUCCMSG,
+				       0);
+		}
+		if (sp->state[IDX_PAP] == STATE_REQ_SENT) {
+			sppp_cp_change_state(&pap, sp, STATE_OPENED);
+			pap.tlu(sp);
+		}
+		break;
+
+	/* ack and nak are his authproto */
+	case PAP_ACK:
+		UNTIMEOUT(sppp_pap_my_TO, (void *)sp, sp->pap_my_to_ch);
+		if (debug) {
+			log(LOG_DEBUG, SPP_FMT "pap success",
+			    SPP_ARGS(ifp));
+			name_len = *((char *)h);
+			if (len > 5 && name_len) {
+				addlog(": ");
+				sppp_print_string((char*)(h+1), name_len);
+			}
+			addlog("\n");
+		}
+		x = splimp();
+		sp->pp_flags &= ~PP_NEEDAUTH;
+		if (sp->myauth.proto == PPP_PAP &&
+		    (sp->lcp.opts & (1 << LCP_OPT_AUTH_PROTO)) &&
+		    (sp->lcp.protos & (1 << IDX_PAP)) == 0) {
+			/*
+			 * We are authenticator for PAP but didn't
+			 * complete yet.  Leave it to tlu to proceed
+			 * to network phase.
+			 */
+			splx(x);
+			break;
+		}
+		splx(x);
+		sppp_phase_network(sp);
+		break;
+
+	case PAP_NAK:
+		UNTIMEOUT(sppp_pap_my_TO, (void *)sp, sp->pap_my_to_ch);
+		if (debug) {
+			log(LOG_INFO, SPP_FMT "pap failure",
+			    SPP_ARGS(ifp));
+			name_len = *((char *)h);
+			if (len > 5 && name_len) {
+				addlog(": ");
+				sppp_print_string((char*)(h+1), name_len);
+			}
+			addlog("\n");
+		} else
+			log(LOG_INFO, SPP_FMT "pap failure\n",
+			    SPP_ARGS(ifp));
+		/* await LCP shutdown by authenticator */
+		break;
+
+	default:
+		/* Unknown PAP packet type -- ignore. */
+		if (debug) {
+			log(LOG_DEBUG, SPP_FMT "pap corrupted input "
+			    "<0x%x id=0x%x len=%d",
+			    SPP_ARGS(ifp),
+			    h->type, h->ident, ntohs(h->len));
+			sppp_print_bytes((u_char*)(h+1), len-4);
+			addlog(">\n");
+		}
+		break;
+
+	}
+}
+
+static void
+sppp_pap_init(struct sppp *sp)
+{
+	/* PAP doesn't have STATE_INITIAL at all. */
+	sp->state[IDX_PAP] = STATE_CLOSED;
+	sp->fail_counter[IDX_PAP] = 0;
+#if defined(__FreeBSD__) && __FreeBSD__ >= 3
+	callout_handle_init(&sp->ch[IDX_PAP]);
+	callout_handle_init(&sp->pap_my_to_ch);
+#endif
+}
+
+static void
+sppp_pap_open(struct sppp *sp)
+{
+	if (sp->hisauth.proto == PPP_PAP &&
+	    (sp->lcp.opts & (1 << LCP_OPT_AUTH_PROTO)) != 0) {
+		/* we are authenticator for PAP, start our timer */
+		sp->rst_counter[IDX_PAP] = sp->lcp.max_configure;
+		sppp_cp_change_state(&pap, sp, STATE_REQ_SENT);
+	}
+	if (sp->myauth.proto == PPP_PAP) {
+		/* we are peer, send a request, and start a timer */
+		pap.scr(sp);
+		TIMEOUT(sppp_pap_my_TO, (void *)sp, sp->lcp.timeout,
+		    sp->pap_my_to_ch);
+	}
+}
+
+static void
+sppp_pap_close(struct sppp *sp)
+{
+	if (sp->state[IDX_PAP] != STATE_CLOSED)
+		sppp_cp_change_state(&pap, sp, STATE_CLOSED);
+}
+
+/*
+ * That's the timeout routine if we are authenticator.  Since the
+ * authenticator is basically passive in PAP, we can't do much here.
+ */
+static void
+sppp_pap_TO(void *cookie)
+{
+	struct sppp *sp = (struct sppp *)cookie;
+	STDDCL;
+	int s;
+
+	s = splimp();
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "pap TO(%s) rst_counter = %d\n",
+		    SPP_ARGS(ifp),
+		    sppp_state_name(sp->state[IDX_PAP]),
+		    sp->rst_counter[IDX_PAP]);
+
+	if (--sp->rst_counter[IDX_PAP] < 0)
+		/* TO- event */
+		switch (sp->state[IDX_PAP]) {
+		case STATE_REQ_SENT:
+			pap.tld(sp);
+			sppp_cp_change_state(&pap, sp, STATE_CLOSED);
+			break;
+		}
+	else
+		/* TO+ event, not very much we could do */
+		switch (sp->state[IDX_PAP]) {
+		case STATE_REQ_SENT:
+			/* sppp_cp_change_state() will restart the timer */
+			sppp_cp_change_state(&pap, sp, STATE_REQ_SENT);
+			break;
+		}
+
+	splx(s);
+}
+
+/*
+ * That's the timeout handler if we are peer.  Since the peer is active,
+ * we need to retransmit our PAP request since it is apparently lost.
+ * XXX We should impose a max counter.
+ */
+static void
+sppp_pap_my_TO(void *cookie)
+{
+	struct sppp *sp = (struct sppp *)cookie;
+	STDDCL;
+
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "pap peer TO\n",
+		    SPP_ARGS(ifp));
+
+	pap.scr(sp);
+}
+
+static void
+sppp_pap_tlu(struct sppp *sp)
+{
+	STDDCL;
+	int x;
+
+	sp->rst_counter[IDX_PAP] = sp->lcp.max_configure;
+
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "%s tlu\n",
+		    SPP_ARGS(ifp), pap.name);
+
+	x = splimp();
+	/* indicate to LCP that we need to be closed down */
+	sp->lcp.protos |= (1 << IDX_PAP);
+
+	if (sp->pp_flags & PP_NEEDAUTH) {
+		/*
+		 * Remote is authenticator, but his auth proto didn't
+		 * complete yet.  Defer the transition to network
+		 * phase.
+		 */
+		splx(x);
+		return;
+	}
+	splx(x);
+	sppp_phase_network(sp);
+}
+
+static void
+sppp_pap_tld(struct sppp *sp)
+{
+	STDDCL;
+
+	if (debug)
+		log(LOG_DEBUG, SPP_FMT "pap tld\n", SPP_ARGS(ifp));
+	UNTIMEOUT(pap.TO, (void *)sp, sp->ch[IDX_PAP]);
+	UNTIMEOUT(sppp_pap_my_TO, (void *)sp, sp->pap_my_to_ch);
+	sp->lcp.protos &= ~(1 << IDX_PAP);
+
+	lcp.Close(sp);
+}
+
+static void
+sppp_pap_scr(struct sppp *sp)
+{
+	u_char idlen, pwdlen;
+
+	sp->confid[IDX_PAP] = ++sp->pp_seq;
+	pwdlen = sppp_strnlen(sp->myauth.secret, AUTHKEYLEN);
+	idlen = sppp_strnlen(sp->myauth.name, AUTHNAMELEN);
+
+	sppp_auth_send(&pap, sp, PAP_REQ, sp->confid[IDX_PAP],
+		       sizeof idlen, (const char *)&idlen,
+		       (size_t)idlen, sp->myauth.name,
+		       sizeof pwdlen, (const char *)&pwdlen,
+		       (size_t)pwdlen, sp->myauth.secret,
+		       0);
+}
+/*
+ * Random miscellaneous functions.
+ */
+
+/*
+ * Send a PAP or CHAP proto packet.
+ *
+ * Varadic function, each of the elements for the ellipsis is of type
+ * ``size_t mlen, const u_char *msg''.  Processing will stop iff
+ * mlen == 0.
+ * NOTE: never declare variadic functions with types subject to type
+ * promotion (i.e. u_char). This is asking for big trouble depending
+ * on the architecture you are on...
+ */
+
+static void
+sppp_auth_send(const struct cp *cp, struct sppp *sp,
+               unsigned int type, unsigned int id,
+	       ...)
+{
+	STDDCL;
+	struct ppp_header *h;
+	struct lcp_header *lh;
+	struct mbuf *m;
+	u_char *p;
+	int len;
+	unsigned int mlen;
+	const char *msg;
+	va_list ap;
+
+	MGETHDR (m, M_DONTWAIT, MT_DATA);
+	if (! m)
+		return;
+	m->m_pkthdr.rcvif = 0;
+
+	h = mtod (m, struct ppp_header*);
+	h->address = PPP_ALLSTATIONS;		/* broadcast address */
+	h->control = PPP_UI;			/* Unnumbered Info */
+	h->protocol = htons(cp->proto);
+
+	lh = (struct lcp_header*)(h + 1);
+	lh->type = type;
+	lh->ident = id;
+	p = (u_char*) (lh+1);
+
+	va_start(ap, id);
+	len = 0;
+
+	while ((mlen = (unsigned int)va_arg(ap, size_t)) != 0) {
+		msg = va_arg(ap, const char *);
+		len += mlen;
+		if (len > MHLEN - PPP_HEADER_LEN - LCP_HEADER_LEN) {
+			va_end(ap);
+			m_freem(m);
+			return;
+		}
+
+		bcopy(msg, p, mlen);
+		p += mlen;
+	}
+	va_end(ap);
+
+	m->m_pkthdr.len = m->m_len = PPP_HEADER_LEN + LCP_HEADER_LEN + len;
+	lh->len = htons (LCP_HEADER_LEN + len);
+
+	if (debug) {
+		log(LOG_DEBUG, SPP_FMT "%s output <%s id=0x%x len=%d",
+		    SPP_ARGS(ifp), cp->name,
+		    sppp_auth_type_name(cp->proto, lh->type),
+		    lh->ident, ntohs(lh->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;
+	} else
+		IF_ENQUEUE (&sp->pp_cpq, m);
+	if (! (ifp->if_flags & IFF_OACTIVE))
+		(*ifp->if_start) (ifp);
+	ifp->if_obytes += m->m_pkthdr.len + 3;
+}
+
+/*
+ * Flush interface queue.
+ */
+static void
+sppp_qflush(struct ifqueue *ifq)
+{
+	struct mbuf *m, *n;
+
+	n = ifq->ifq_head;
+	while ((m = n)) {
+		n = m->m_act;
+		m_freem (m);
+	}
+	ifq->ifq_head = 0;
+	ifq->ifq_tail = 0;
+	ifq->ifq_len = 0;
+}
+
+/*
+ * Send keepalive packets, every 10 seconds.
+ */
+static void
+sppp_keepalive(void *dummy)
+{
+	struct sppp *sp;
+	int s;
+
+	s = splimp();
+	for (sp=spppq; sp; sp=sp->pp_next) {
+		struct ifnet *ifp = &sp->pp_if;
+
+		/* Keepalive mode disabled or channel down? */
+		if (! (sp->pp_flags & PP_KEEPALIVE) ||
+		    ! (ifp->if_flags & IFF_RUNNING))
+			continue;
+
+		/* No keepalive in PPP mode if LCP not opened yet. */
+		if (sp->pp_mode != IFF_CISCO &&
+		    sp->pp_phase < PHASE_AUTHENTICATE)
+			continue;
+
+		if (sp->pp_alivecnt == MAXALIVECNT) {
+			/* No keepalive packets got.  Stop the interface. */
+			printf (SPP_FMT "down\n", SPP_ARGS(ifp));
+			if_down (ifp);
+			sppp_qflush (&sp->pp_cpq);
+			if (sp->pp_mode != IFF_CISCO) {
+				/* XXX */
+				/* Shut down the PPP link. */
+				lcp.Down(sp);
+				/* Initiate negotiation. XXX */
+				lcp.Up(sp);
+			}
+		}
+		if (sp->pp_alivecnt <= MAXALIVECNT)
+			++sp->pp_alivecnt;
+		if (sp->pp_mode == IFF_CISCO)
+			sppp_cisco_send (sp, CISCO_KEEPALIVE_REQ, ++sp->pp_seq,
+				sp->pp_rseq);
+		else if (sp->pp_phase >= PHASE_AUTHENTICATE) {
+			long nmagic = htonl (sp->lcp.magic);
+			sp->lcp.echoid = ++sp->pp_seq;
+			sppp_cp_send (sp, PPP_LCP, ECHO_REQ,
+				sp->lcp.echoid, 4, &nmagic);
+		}
+	}
+	splx(s);
+	TIMEOUT(sppp_keepalive, 0, hz * 10, keepalive_ch);
+}
+
+/*
+ * Get both IP addresses.
+ */
+static void
+sppp_get_ip_addrs(struct sppp *sp, u_long *src, u_long *dst, u_long *srcmask)
+{
+	struct ifnet *ifp = &sp->pp_if;
+	struct ifaddr *ifa;
+	struct sockaddr_in *si, *sm;
+	u_long ssrc, ddst;
+
+	sm = NULL;
+	ssrc = ddst = 0L;
+	/*
+	 * Pick the first AF_INET address from the list,
+	 * aliases don't make any sense on a p2p link anyway.
+	 */
+	si = 0;
+
+#if defined(__FreeBSD__) && __FreeBSD__ >= 3
+	TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
+#elif defined(__NetBSD__) || defined (__OpenBSD__)
+	for (ifa = ifp->if_addrlist.tqh_first;
+	     ifa;
+	     ifa = ifa->ifa_list.tqe_next)
+#else
+	for (ifa = ifp->if_addrlist;
+	     ifa;
+	     ifa = ifa->ifa_next)
+#endif
+		if (ifa->ifa_addr->sa_family == AF_INET) {
+			si = (struct sockaddr_in *)ifa->ifa_addr;
+			sm = (struct sockaddr_in *)ifa->ifa_netmask;
+			if (si)
+				break;
+		}
+	if (ifa) {
+		if (si && si->sin_addr.s_addr) {
+			ssrc = si->sin_addr.s_addr;
+			if (srcmask)
+				*srcmask = ntohl(sm->sin_addr.s_addr);
+		}
+
+		si = (struct sockaddr_in *)ifa->ifa_dstaddr;
+		if (si && si->sin_addr.s_addr)
+			ddst = si->sin_addr.s_addr;
+	}
+
+	if (dst) *dst = ntohl(ddst);
+	if (src) *src = ntohl(ssrc);
+}
+
+/*
+ * Set my IP address.  Must be called at splimp.
+ */
+static void
+sppp_set_ip_addr(struct sppp *sp, u_long src)
+{
+	STDDCL;
+	struct ifaddr *ifa;
+	struct sockaddr_in *si;
+
+	/*
+	 * Pick the first AF_INET address from the list,
+	 * aliases don't make any sense on a p2p link anyway.
+	 */
+	si = 0;
+
+#if defined(__FreeBSD__) && __FreeBSD__ >= 3
+	TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
+#elif defined(__NetBSD__) || defined (__OpenBSD__)
+	for (ifa = ifp->if_addrlist.tqh_first;
+	     ifa;
+	     ifa = ifa->ifa_list.tqe_next)
+#else
+	for (ifa = ifp->if_addrlist;
+	     ifa;
+	     ifa = ifa->ifa_next)
+#endif
+	{
+		if (ifa->ifa_addr->sa_family == AF_INET)
+		{
+			si = (struct sockaddr_in *)ifa->ifa_addr;
+			if (si)
+				break;
+		}
+	}
+
+	if (ifa && si)
+	{
+		int error;
+#if __NetBSD_Version__ >= 103080000
+		struct sockaddr_in new_sin = *si;
+
+		new_sin.sin_addr.s_addr = htonl(src);
+		error = in_ifinit(ifp, ifatoia(ifa), &new_sin, 1);
+		if(debug && error)
+		{
+			log(LOG_DEBUG, SPP_FMT "sppp_set_ip_addr: in_ifinit "
+			" failed, error=%d\n", SPP_ARGS(ifp), error);
+		}
+#else
+		/* delete old route */
+		error = rtinit(ifa, (int)RTM_DELETE, RTF_HOST);
+		if(debug && error)
+		{
+			log(LOG_DEBUG, SPP_FMT "sppp_set_ip_addr: rtinit DEL failed, error=%d\n",
+		    		SPP_ARGS(ifp), error);
+		}
+
+		/* set new address */
+		si->sin_addr.s_addr = htonl(src);
+
+		/* add new route */
+		error = rtinit(ifa, (int)RTM_ADD, RTF_HOST);		
+		if (debug && error)
+		{
+			log(LOG_DEBUG, SPP_FMT "sppp_set_ip_addr: rtinit ADD failed, error=%d",
+		    		SPP_ARGS(ifp), error);
+		}
+#endif
+	}
+}			
+
+static int
+sppp_params(struct sppp *sp, IOCTL_CMD_T cmd, void *data)
+{
+	struct ifreq *ifr = (struct ifreq *)data;
+	int ret;
+	struct spppreq *sppprp;
+
+	if((sppprp = (struct spppreq *)malloc(sizeof(struct spppreq),
+			M_TEMP, M_WAITOK)) == NULL)
+	{
+		printf("i4bsppp, sppp_params: malloc failed!\n");
+		return EFAULT;
+	}
+	
+	/*
+	 * ifr->ifr_data is supposed to point to a struct spppreq.
+	 */
+	if (copyin((caddr_t)ifr->ifr_data, sppprp, sizeof(struct spppreq)) != 0)
+	{
+		free(sppprp, M_TEMP);
+		return EFAULT;
+	}
+
+	switch (sppprp->cmd) {
+	case SPPPIOGDEFS:
+		if (cmd != SIOCGIFGENERIC)
+		{
+			free(sppprp, M_TEMP);			
+			return EINVAL;
+		}
+		/*
+		 * We copy over the entire current state, but clean
+		 * out some of the stuff we don't wanna pass up.
+		 * Remember, SIOCGIFGENERIC is unprotected, and can be
+		 * called by any user.  No need to ever get PAP or
+		 * CHAP secrets back to userland anyway.
+		 */
+		bcopy(sp, &sppprp->defs, sizeof(struct sppp));
+		bzero(sppprp->defs.myauth.secret, AUTHKEYLEN);
+		bzero(sppprp->defs.myauth.challenge, AUTHKEYLEN);
+		bzero(sppprp->defs.hisauth.secret, AUTHKEYLEN);
+		bzero(sppprp->defs.hisauth.challenge, AUTHKEYLEN);
+		ret = copyout(sppprp, (caddr_t)ifr->ifr_data, sizeof(struct spppreq));
+		free(sppprp, M_TEMP);
+		return(ret);
+
+	case SPPPIOSDEFS:
+		if (cmd != SIOCSIFGENERIC)
+		{
+			free(sppprp, M_TEMP);
+			return EINVAL;
+		}
+		/*
+		 * We have a very specific idea of which fields we allow
+		 * being passed back from userland, so to not clobber our
+		 * current state.  For one, we only allow setting
+		 * anything if LCP is in dead phase.  Once the LCP
+		 * negotiations started, the authentication settings must
+		 * not be changed again.  (The administrator can force an
+		 * ifconfig down in order to get LCP back into dead
+		 * phase.)
+		 *
+		 * Also, we only allow for authentication parameters to be
+		 * specified.
+		 *
+		 * XXX Should allow to set or clear pp_flags.
+		 *
+		 * Finally, if the respective authentication protocol to
+		 * be used is set differently than 0, but the secret is
+		 * passed as all zeros, we don't trash the existing secret.
+		 * This allows an administrator to change the system name
+		 * only without clobbering the secret (which he didn't get
+		 * back in a previous SPPPIOGDEFS call).  However, the
+		 * secrets are cleared if the authentication protocol is
+		 * reset to 0.
+		 */
+		if (!((sp->pp_phase == PHASE_DEAD) || 
+		      (sp->pp_phase == PHASE_ESTABLISH)))
+		{
+			free(sppprp, M_TEMP);
+			return EBUSY;
+		}
+
+		if ((sppprp->defs.myauth.proto != 0 && sppprp->defs.myauth.proto != PPP_PAP &&
+		     sppprp->defs.myauth.proto != PPP_CHAP) ||
+		    (sppprp->defs.hisauth.proto != 0 && sppprp->defs.hisauth.proto != PPP_PAP &&
+		     sppprp->defs.hisauth.proto != PPP_CHAP))
+		{
+			free(sppprp, M_TEMP);
+			return EINVAL;
+		}
+
+		if (sppprp->defs.myauth.proto == 0)
+			/* resetting myauth */
+			bzero(&sp->myauth, sizeof sp->myauth);
+		else {
+			/* setting/changing myauth */
+			sp->myauth.proto = sppprp->defs.myauth.proto;
+			bcopy(sppprp->defs.myauth.name, sp->myauth.name, AUTHNAMELEN);
+			if (sppprp->defs.myauth.secret[0] != '\0')
+				bcopy(sppprp->defs.myauth.secret, sp->myauth.secret,
+				      AUTHKEYLEN);
+		}
+		if (sppprp->defs.hisauth.proto == 0)
+			/* resetting hisauth */
+			bzero(&sp->hisauth, sizeof sp->hisauth);
+		else {
+			/* setting/changing hisauth */
+			sp->hisauth.proto = sppprp->defs.hisauth.proto;
+			sp->hisauth.flags = sppprp->defs.hisauth.flags;
+			bcopy(sppprp->defs.hisauth.name, sp->hisauth.name, AUTHNAMELEN);
+			if (sppprp->defs.hisauth.secret[0] != '\0')
+				bcopy(sppprp->defs.hisauth.secret, sp->hisauth.secret,
+				      AUTHKEYLEN);
+		}
+		if (sppprp->defs.lcp.timeout != 0) {
+			/* Set the LCP timeout */
+			sp->lcp.timeout = sppprp->defs.lcp.timeout;
+		}
+
+		/* Set enable VJ compression */
+		sp->enable_vj = sppprp->defs.enable_vj;
+		
+		break;
+
+	default:
+		free(sppprp, M_TEMP);
+		return EINVAL;
+	}
+	free(sppprp, M_TEMP);
+	return 0;
+}
+
+static void
+sppp_phase_network(struct sppp *sp)
+{
+	STDDCL;
+	int i;
+	u_long mask;
+
+	sp->pp_phase = PHASE_NETWORK;
+
+	if(debug)
+		log(LOG_DEBUG, SPP_FMT "phase %s\n", SPP_ARGS(ifp),
+			sppp_phase_name(sp->pp_phase));
+
+	/* Notify NCPs now. */
+	for (i = 0; i < IDX_COUNT; i++)
+		if ((cps[i])->flags & CP_NCP)
+			(cps[i])->Open(sp);
+
+	/* Send Up events to all NCPs. */
+	for (i = 0, mask = 1; i < IDX_COUNT; i++, mask <<= 1)
+		if (sp->lcp.protos & mask && ((cps[i])->flags & CP_NCP))
+			(cps[i])->Up(sp);
+
+	/* if no NCP is starting, all this was in vain, close down */
+	sppp_lcp_check_and_close(sp);
+}
+	
+
+static const char *
+sppp_cp_type_name(u_char type)
+{
+	static char buf[12];
+	switch (type) {
+	case CONF_REQ:   return "conf-req";
+	case CONF_ACK:   return "conf-ack";
+	case CONF_NAK:   return "conf-nak";
+	case CONF_REJ:   return "conf-rej";
+	case TERM_REQ:   return "term-req";
+	case TERM_ACK:   return "term-ack";
+	case CODE_REJ:   return "code-rej";
+	case PROTO_REJ:  return "proto-rej";
+	case ECHO_REQ:   return "echo-req";
+	case ECHO_REPLY: return "echo-reply";
+	case DISC_REQ:   return "discard-req";
+	}
+#ifdef HAS_SNPRINTF
+	snprintf (buf, sizeof(buf), "cp/0x%x", type);
+#else
+	sprintf (buf, "cp/0x%x", type);
+#endif
+	return buf;
+}
+
+static const char *
+sppp_auth_type_name(u_short proto, u_char type)
+{
+	static char buf[12];
+	switch (proto) {
+	case PPP_CHAP:
+		switch (type) {
+		case CHAP_CHALLENGE:	return "challenge";
+		case CHAP_RESPONSE:	return "response";
+		case CHAP_SUCCESS:	return "success";
+		case CHAP_FAILURE:	return "failure";
+		}
+	case PPP_PAP:
+		switch (type) {
+		case PAP_REQ:		return "req";
+		case PAP_ACK:		return "ack";
+		case PAP_NAK:		return "nak";
+		}
+	}
+#ifdef HAS_SNPRINTF
+	snprintf (buf, sizeof(buf), "auth/0x%x", type);
+#else
+	sprintf (buf, "auth/0x%x", type);
+#endif
+	return buf;
+}
+
+static const char *
+sppp_lcp_opt_name(u_char opt)
+{
+	static char buf[12];
+	switch (opt) {
+	case LCP_OPT_MRU:		return "mru";
+	case LCP_OPT_ASYNC_MAP:		return "async-map";
+	case LCP_OPT_AUTH_PROTO:	return "auth-proto";
+	case LCP_OPT_QUAL_PROTO:	return "qual-proto";
+	case LCP_OPT_MAGIC:		return "magic";
+	case LCP_OPT_PROTO_COMP:	return "proto-comp";
+	case LCP_OPT_ADDR_COMP:		return "addr-comp";
+	}
+#ifdef HAS_SNPRINTF
+	snprintf (buf, sizeof(buf), "lcp/0x%x", opt);
+#else
+	sprintf (buf, "lcp/0x%x", opt);
+#endif
+	return buf;
+}
+
+static const char *
+sppp_ipcp_opt_name(u_char opt)
+{
+	static char buf[12];
+	switch (opt) {
+	case IPCP_OPT_ADDRESSES:	return "addresses";
+	case IPCP_OPT_COMPRESSION:	return "compression";
+	case IPCP_OPT_ADDRESS:		return "address";
+	}
+#ifdef HAS_SNPRINTF
+	snprintf (buf, sizeof(buf), "ipcp/0x%x", opt);
+#else
+	sprintf (buf, "ipcp/0x%x", opt);
+#endif
+	return buf;
+}
+
+static const char *
+sppp_state_name(int state)
+{
+	switch (state) {
+	case STATE_INITIAL:	return "initial";
+	case STATE_STARTING:	return "starting";
+	case STATE_CLOSED:	return "closed";
+	case STATE_STOPPED:	return "stopped";
+	case STATE_CLOSING:	return "closing";
+	case STATE_STOPPING:	return "stopping";
+	case STATE_REQ_SENT:	return "req-sent";
+	case STATE_ACK_RCVD:	return "ack-rcvd";
+	case STATE_ACK_SENT:	return "ack-sent";
+	case STATE_OPENED:	return "opened";
+	}
+	return "illegal";
+}
+
+static const char *
+sppp_phase_name(enum ppp_phase phase)
+{
+	switch (phase) {
+	case PHASE_DEAD:	return "dead";
+	case PHASE_ESTABLISH:	return "establish";
+	case PHASE_TERMINATE:	return "terminate";
+	case PHASE_AUTHENTICATE: return "authenticate";
+	case PHASE_NETWORK:	return "network";
+	}
+	return "illegal";
+}
+
+static const char *
+sppp_proto_name(u_short proto)
+{
+	static char buf[12];
+	switch (proto) {
+	case PPP_LCP:	return "lcp";
+	case PPP_IPCP:	return "ipcp";
+	case PPP_PAP:	return "pap";
+	case PPP_CHAP:	return "chap";
+	}
+#ifdef HAS_SNPRINTF
+	snprintf(buf, sizeof(buf), "proto/0x%x", (unsigned)proto);
+#else
+	sprintf(buf, "proto/0x%x", (unsigned)proto);
+#endif
+	return buf;
+}
+
+static void
+sppp_print_bytes(const u_char *p, u_short len)
+{
+#if defined(__FreeBSD_version) && (__FreeBSD_version > 300005)
+	if (len)
+		addlog(" %*D", len, p, "-");
+#else
+	if (!len)
+		return;
+
+	addlog("%x", *p++);
+	while (--len)
+		addlog("-%x", *p++);
+#endif
+}
+
+static void
+sppp_print_string(const char *p, u_short len)
+{
+	u_char c;
+
+	while (len-- > 0) {
+		c = *p++;
+		/*
+		 * Print only ASCII chars directly.  RFC 1994 recommends
+		 * using only them, but we don't rely on it.  */
+		if (c < ' ' || c > '~')
+			addlog("\\x%x", c);
+		else
+			addlog("%c", c);
+	}
+}
+
+static const char *
+sppp_dotted_quad(u_long addr)
+{
+	static char s[16];
+	sprintf(s, "%d.%d.%d.%d",
+		(int)((addr >> 24) & 0xff),
+		(int)((addr >> 16) & 0xff),
+		(int)((addr >> 8) & 0xff),
+		(int)(addr & 0xff));
+	return s;
+}
+
+static int
+sppp_strnlen(u_char *p, int max)
+{
+	int len;
+
+	for (len = 0; len < max && *p; ++p)
+		++len;
+	return len;
+}
+
+/* a dummy, used to drop uninteresting events */
+static void
+sppp_null(struct sppp *unused)
+{
+	/* do just nothing */
+}
diff --git a/sys/i4b/driver/i4b_rbch.c b/sys/i4b/driver/i4b_rbch.c
index d4c9225..53af7bc 100644
--- a/sys/i4b/driver/i4b_rbch.c
+++ b/sys/i4b/driver/i4b_rbch.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_rbch.c - device driver for raw B channel data
  *	---------------------------------------------------
  *
- *	$Id: i4b_rbch.c,v 1.48 1999/12/13 21:25:24 hm Exp $
+ *	$Id: i4b_rbch.c,v 1.52 2000/10/06 08:37:43 hm Exp $
  *
  * $FreeBSD$
  *
- *	last edit-date: [Mon Dec 13 21:39:15 1999]
+ *	last edit-date: [Mon Oct  2 10:13:09 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -51,14 +51,29 @@
 #include <sys/proc.h>
 #include <sys/tty.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
 #if defined (__NetBSD__) || defined (__OpenBSD__)
 extern cc_t ttydefchars;
 #define termioschars(t) memcpy((t)->c_cc, &ttydefchars, sizeof((t)->c_cc))
 #endif
 
+#ifdef __FreeBSD__
+
+#if defined(__FreeBSD__) && __FreeBSD__ == 3
+#include "opt_devfs.h"
+#endif
+
+#ifdef DEVFS
+#include <sys/devfsext.h>
+#endif
+
+#endif /* __FreeBSD__ */
+
 #ifdef __NetBSD__
 #include <sys/filio.h>
-#define bootverbose 0
 #endif
 
 #ifdef __FreeBSD__
@@ -79,8 +94,6 @@ extern cc_t ttydefchars;
 
 #ifdef __bsdi__
 #include <sys/device.h>
-/* XXX FIXME */
-int bootverbose = 0;
 #endif
 
 #ifdef OS_USES_POLL
@@ -125,12 +138,19 @@ static struct rbch_softc {
 	struct selinfo selp;		/* select / poll	*/
 
 #if defined(__FreeBSD__) && __FreeBSD__ == 3
+#ifdef DEVFS
+	void *devfs_token;		/* device filesystem	*/
+#endif	
 #endif
 
 #if I4BRBCHACCT
 #if defined(__FreeBSD__)
 	struct callout_handle sc_callout;
 #endif	
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+	struct callout	sc_callout;
+#endif
+
 	int		sc_iinb;	/* isdn driver # of inbytes	*/
 	int		sc_ioutb;	/* isdn driver # of outbytes	*/
 	int		sc_linb;	/* last # of bytes rx'd		*/
@@ -283,6 +303,12 @@ i4brbchattach()
 #if defined(__FreeBSD__)
 #if __FreeBSD__ == 3
 
+#ifdef DEVFS
+		rbch_softc[i].devfs_token =
+			devfs_add_devswf(&i4brbch_cdevsw, i, DV_CHR,
+				     UID_ROOT, GID_WHEEL, 0600,
+				     "i4brbch%d", i);
+#endif
 
 #else
 		make_dev(&i4brbch_cdevsw, i,
@@ -294,6 +320,9 @@ i4brbchattach()
 #if defined(__FreeBSD__)
 		callout_handle_init(&rbch_softc[i].sc_callout);
 #endif
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+		callout_init(&rbch_softc[i].sc_callout);
+#endif
 		rbch_softc[i].sc_fn = 1;
 #endif
 		rbch_softc[i].sc_unit = i;
@@ -313,7 +342,7 @@ i4brbchopen(dev_t dev, int flag, int fmt, struct proc *p)
 {
 	int unit = minor(dev);
 	
-	if(unit > NI4BRBCH)
+	if(unit >= NI4BRBCH)
 		return(ENXIO);
 
 	if(rbch_softc[unit].sc_devstate & ST_ISOPEN)
@@ -325,7 +354,7 @@ i4brbchopen(dev_t dev, int flag, int fmt, struct proc *p)
 	
 	rbch_softc[unit].sc_devstate |= ST_ISOPEN;		
 
-	DBGL4(L4_RBCHDBG, "i4brbchopen", ("unit %d, open\n", unit));	
+	NDBGL4(L4_RBCHDBG, "unit %d, open", unit);	
 
 	return(0);
 }
@@ -346,7 +375,7 @@ i4brbchclose(dev_t dev, int flag, int fmt, struct proc *p)
 
 	rbch_clrq(unit);
 	
-	DBGL4(L4_RBCHDBG, "i4brbclose", ("unit %d, closed\n", unit));
+	NDBGL4(L4_RBCHDBG, "unit %d, closed", unit);
 	
 	return(0);
 }
@@ -365,38 +394,45 @@ i4brbchread(dev_t dev, struct uio *uio, int ioflag)
 
 	CRIT_VAR;
 	
-	DBGL4(L4_RBCHDBG, "i4brbchread", ("unit %d, enter read\n", unit));
+	NDBGL4(L4_RBCHDBG, "unit %d, enter read", unit);
 	
+	CRIT_BEG;
 	if(!(sc->sc_devstate & ST_ISOPEN))
 	{
-		DBGL4(L4_RBCHDBG, "i4brbchread", ("unit %d, read while not open\n", unit));
+		CRIT_END;
+		NDBGL4(L4_RBCHDBG, "unit %d, read while not open", unit);
 		return(EIO);
 	}
 
 	if((sc->sc_devstate & ST_NOBLOCK))
 	{
-		if(!(sc->sc_devstate & ST_CONNECTED))
+		if(!(sc->sc_devstate & ST_CONNECTED)) {
+			CRIT_END;
 			return(EWOULDBLOCK);
+		}
 
 		if(sc->sc_bprot == BPROT_RHDLC)
 			iqp = &sc->sc_hdlcq;
 		else
 			iqp = isdn_linktab[unit]->rx_queue;	
 
-		if(IF_QEMPTY(iqp) && (sc->sc_devstate & ST_ISOPEN))
+		if(IF_QEMPTY(iqp) && (sc->sc_devstate & ST_ISOPEN)) {
+			CRIT_END;
 			return(EWOULDBLOCK);
 	}
+	}
 	else
 	{
 		while(!(sc->sc_devstate & ST_CONNECTED))
 		{
-			DBGL4(L4_RBCHDBG, "i4brbchread", ("unit %d, wait read init\n", unit));
+			NDBGL4(L4_RBCHDBG, "unit %d, wait read init", unit);
 		
 			if((error = tsleep((caddr_t) &rbch_softc[unit],
 					   TTIPRI | PCATCH,
 					   "rrrbch", 0 )) != 0)
 			{
-				DBGL4(L4_RBCHDBG, "i4brbchread", ("unit %d, error %d tsleep\n", unit, error));
+				CRIT_END;
+				NDBGL4(L4_RBCHDBG, "unit %d, error %d tsleep", unit, error);
 				return(error);
 			}
 		}
@@ -408,28 +444,25 @@ i4brbchread(dev_t dev, struct uio *uio, int ioflag)
 
 		while(IF_QEMPTY(iqp) && (sc->sc_devstate & ST_ISOPEN))
 		{
-			CRIT_BEG;
 			sc->sc_devstate |= ST_RDWAITDATA;
-			CRIT_END;
 		
-			DBGL4(L4_RBCHDBG, "i4brbchread", ("unit %d, wait read data\n", unit));
+			NDBGL4(L4_RBCHDBG, "unit %d, wait read data", unit);
 		
 			if((error = tsleep((caddr_t) &isdn_linktab[unit]->rx_queue,
 					   TTIPRI | PCATCH,
 					   "rrbch", 0 )) != 0)
 			{
-				DBGL4(L4_RBCHDBG, "i4brbchread", ("unit %d, error %d tsleep read\n", unit, error));
+				CRIT_END;
+				NDBGL4(L4_RBCHDBG, "unit %d, error %d tsleep read", unit, error);
 				sc->sc_devstate &= ~ST_RDWAITDATA;
 				return(error);
 			}
 		}
 	}
 
-	CRIT_BEG;
-
 	IF_DEQUEUE(iqp, m);
 
-	DBGL4(L4_RBCHDBG, "i4brbchread", ("unit %d, read %d bytes\n", unit, m->m_len));
+	NDBGL4(L4_RBCHDBG, "unit %d, read %d bytes", unit, m->m_len);
 	
 	if(m && m->m_len)
 	{
@@ -437,7 +470,7 @@ i4brbchread(dev_t dev, struct uio *uio, int ioflag)
 	}
 	else
 	{
-		DBGL4(L4_RBCHDBG, "i4brbchread", ("unit %d, error %d uiomove\n", unit, error));
+		NDBGL4(L4_RBCHDBG, "unit %d, error %d uiomove", unit, error);
 		error = EIO;
 	}
 		
@@ -462,40 +495,50 @@ i4brbchwrite(dev_t dev, struct uio * uio, int ioflag)
 
 	CRIT_VAR;
 	
-	DBGL4(L4_RBCHDBG, "i4brbchwrite", ("unit %d, write\n", unit));	
+	NDBGL4(L4_RBCHDBG, "unit %d, write", unit);	
 
+	CRIT_BEG;
 	if(!(sc->sc_devstate & ST_ISOPEN))
 	{
-		DBGL4(L4_RBCHDBG, "i4brbchwrite", ("unit %d, write while not open\n", unit));
+		NDBGL4(L4_RBCHDBG, "unit %d, write while not open", unit);
+		CRIT_END;
 		return(EIO);
 	}
 
 	if((sc->sc_devstate & ST_NOBLOCK))
 	{
-		if(!(sc->sc_devstate & ST_CONNECTED))
+		if(!(sc->sc_devstate & ST_CONNECTED)) {
+			CRIT_END;
 			return(EWOULDBLOCK);
-		if(IF_QFULL(isdn_linktab[unit]->tx_queue) && (sc->sc_devstate & ST_ISOPEN))
+		}
+		if(IF_QFULL(isdn_linktab[unit]->tx_queue) && (sc->sc_devstate & ST_ISOPEN)) {
+			CRIT_END;
 			return(EWOULDBLOCK);
 	}
+	}
 	else
 	{
 		while(!(sc->sc_devstate & ST_CONNECTED))
 		{
-			DBGL4(L4_RBCHDBG, "i4brbchwrite", ("unit %d, write wait init\n", unit));
+			NDBGL4(L4_RBCHDBG, "unit %d, write wait init", unit);
 		
 			error = tsleep((caddr_t) &rbch_softc[unit],
 						   TTIPRI | PCATCH,
 						   "wrrbch", 0 );
-			if(error == ERESTART)
+			if(error == ERESTART) {
+				CRIT_END;
 				return (ERESTART);
+			}
 			else if(error == EINTR)
 			{
-				DBGL4(L4_RBCHDBG, "i4brbchwrite", ("unit %d, EINTR during wait init\n", unit));
+				CRIT_END;
+				NDBGL4(L4_RBCHDBG, "unit %d, EINTR during wait init", unit);
 				return(EINTR);
 			}
 			else if(error)
 			{
-				DBGL4(L4_RBCHDBG, "i4brbchwrite", ("unit %d, error %d tsleep init\n", unit, error));
+				CRIT_END;
+				NDBGL4(L4_RBCHDBG, "unit %d, error %d tsleep init", unit, error);
 				return(error);
 			}
 			tsleep((caddr_t) &rbch_softc[unit], TTIPRI | PCATCH, "xrbch", (hz*1));
@@ -503,11 +546,9 @@ i4brbchwrite(dev_t dev, struct uio * uio, int ioflag)
 
 		while(IF_QFULL(isdn_linktab[unit]->tx_queue) && (sc->sc_devstate & ST_ISOPEN))
 		{
-			CRIT_BEG;
 			sc->sc_devstate |= ST_WRWAITEMPTY;
-			CRIT_END;
 
-			DBGL4(L4_RBCHDBG, "i4brbchwrite", ("unit %d, write queue full\n", unit));
+			NDBGL4(L4_RBCHDBG, "unit %d, write queue full", unit);
 		
 			if ((error = tsleep((caddr_t) &isdn_linktab[unit]->tx_queue,
 					    TTIPRI | PCATCH,
@@ -515,27 +556,28 @@ i4brbchwrite(dev_t dev, struct uio * uio, int ioflag)
 				sc->sc_devstate &= ~ST_WRWAITEMPTY;
 				if(error == ERESTART)
 				{
+					CRIT_END;
 					return(ERESTART);
 				}
 				else if(error == EINTR)
 				{
-					DBGL4(L4_RBCHDBG, "i4brbchwrite", ("unit %d, EINTR during wait write\n", unit));
+					CRIT_END;
+					NDBGL4(L4_RBCHDBG, "unit %d, EINTR during wait write", unit);
 					return(error);
 				}
 				else if(error)
 				{
-					DBGL4(L4_RBCHDBG, "i4brbchwrite", ("unit %d, error %d tsleep write\n", unit, error));
+					CRIT_END;
+					NDBGL4(L4_RBCHDBG, "unit %d, error %d tsleep write", unit, error);
 					return(error);
 				}
 			}
 		}
 	}
 
-	CRIT_BEG;
-
 	if(!(sc->sc_devstate & ST_ISOPEN))
 	{
-		DBGL4(L4_RBCHDBG, "i4brbchwrite", ("unit %d, not open anymore\n", unit));
+		NDBGL4(L4_RBCHDBG, "unit %d, not open anymore", unit);
 		CRIT_END;
 		return(EIO);
 	}
@@ -544,7 +586,7 @@ i4brbchwrite(dev_t dev, struct uio * uio, int ioflag)
 	{
 		m->m_len = min(BCH_MAX_DATALEN, uio->uio_resid);
 
-		DBGL4(L4_RBCHDBG, "i4brbchwrite", ("unit %d, write %d bytes\n", unit, m->m_len));
+		NDBGL4(L4_RBCHDBG, "unit %d, write %d bytes", unit, m->m_len);
 		
 		error = uiomove(m->m_data, m->m_len, uio);
 
@@ -580,23 +622,23 @@ i4brbchioctl(dev_t dev, IOCTL_CMD_T cmd, caddr_t data, int flag, struct proc *p)
 		case FIOASYNC:	/* Set async mode */
 			if (*(int *)data)
 			{
-				DBGL4(L4_RBCHDBG, "i4brbchioctl", ("unit %d, setting async mode\n", unit));
+				NDBGL4(L4_RBCHDBG, "unit %d, setting async mode", unit);
 			}
 			else
 			{
-				DBGL4(L4_RBCHDBG, "i4brbchioctl", ("unit %d, clearing async mode\n", unit));
+				NDBGL4(L4_RBCHDBG, "unit %d, clearing async mode", unit);
 			}
 			break;
 
 		case FIONBIO:
 			if (*(int *)data)
 			{
-				DBGL4(L4_RBCHDBG, "i4brbchioctl", ("unit %d, setting non-blocking mode\n", unit));
+				NDBGL4(L4_RBCHDBG, "unit %d, setting non-blocking mode", unit);
 				sc->sc_devstate |= ST_NOBLOCK;
 			}
 			else
 			{
-				DBGL4(L4_RBCHDBG, "i4brbchioctl", ("unit %d, clearing non-blocking mode\n", unit));
+				NDBGL4(L4_RBCHDBG, "unit %d, clearing non-blocking mode", unit);
 				sc->sc_devstate &= ~ST_NOBLOCK;
 			}
 			break;
@@ -604,7 +646,7 @@ i4brbchioctl(dev_t dev, IOCTL_CMD_T cmd, caddr_t data, int flag, struct proc *p)
 		case TIOCCDTR:	/* Clear DTR */
 			if(sc->sc_devstate & ST_CONNECTED)
 			{
-				DBGL4(L4_RBCHDBG, "i4brbchioctl", ("unit %d, disconnecting for DTR down\n", unit));
+				NDBGL4(L4_RBCHDBG, "unit %d, disconnecting for DTR down", unit);
 				i4b_l4_drvrdisc(BDRV_RBCH, unit);
 			}
 			break;
@@ -617,7 +659,7 @@ i4brbchioctl(dev_t dev, IOCTL_CMD_T cmd, caddr_t data, int flag, struct proc *p)
 				;
 			if (l)
 			{
-				DBGL4(L4_RBCHDBG, "i4brbchioctl", ("unit %d, attempting dialout to %s\n", unit, (char *)data));
+				NDBGL4(L4_RBCHDBG, "unit %d, attempting dialout to %s", unit, (char *)data);
 				i4b_l4_dialoutnumber(BDRV_RBCH, unit, l, (char *)data);
 				break;
 			}
@@ -625,7 +667,7 @@ i4brbchioctl(dev_t dev, IOCTL_CMD_T cmd, caddr_t data, int flag, struct proc *p)
 		}
 
 		case TIOCSDTR:	/* Set DTR */
-			DBGL4(L4_RBCHDBG, "i4brbchioctl", ("unit %d, attempting dialout (DTR)\n", unit));
+			NDBGL4(L4_RBCHDBG, "unit %d, attempting dialout (DTR)", unit);
 			i4b_l4_dialout(BDRV_RBCH, unit);
 			break;
 
@@ -655,7 +697,7 @@ i4brbchioctl(dev_t dev, IOCTL_CMD_T cmd, caddr_t data, int flag, struct proc *p)
 		}
 
 		default:	/* Unknown stuff */
-			DBGL4(L4_RBCHDBG, "i4brbchioctl", ("unit %d, ioctl, unknown cmd %lx\n", unit, (u_long)cmd));
+			NDBGL4(L4_RBCHDBG, "unit %d, ioctl, unknown cmd %lx", unit, (u_long)cmd);
 			error = EINVAL;
 			break;
 	}
@@ -737,7 +779,7 @@ i4brbchselect(dev_t dev, int rw, struct proc *p)
 	if(!(sc->sc_devstate & ST_ISOPEN))
 	{
 		splx(s);
-		DBGL4(L4_RBCHDBG, "i4brbchselect", ("unit %d, not open anymore\n", unit));
+		NDBGL4(L4_RBCHDBG, "unit %d, not open anymore", unit);
 		return(1);
 	}
 	
@@ -814,11 +856,7 @@ rbch_timeout(struct rbch_softc *sc)
 		i4b_l4_accounting(BDRV_RBCH, unit, ACCT_DURING,
 			 sc->sc_ioutb, sc->sc_iinb, ro, ri, sc->sc_ioutb, sc->sc_iinb);
  	}
-#if defined(__FreeBSD__)
-	sc->sc_callout =
-#endif	
-		timeout((TIMEOUT_FUNC_T)rbch_timeout,
-			(void *)sc, I4BRBCHACCTINTVL*hz);
+	START_TIMER(sc->sc_callout, rbch_timeout, sc, I4BRBCHACCTINTVL*hz);
 }
 #endif /* I4BRBCHACCT */
 
@@ -845,16 +883,12 @@ rbch_connect(int unit, void *cdp)
 		sc->sc_linb = 0;
 		sc->sc_loutb = 0;
 
-#if defined(__FreeBSD__)
-		sc->sc_callout =
-#endif
-			timeout((TIMEOUT_FUNC_T)rbch_timeout,
-				(void *)sc, I4BRBCHACCTINTVL*hz);
+		START_TIMER(sc->sc_callout, rbch_timeout, sc, I4BRBCHACCTINTVL*hz);
 	}
 #endif		
 	if(!(sc->sc_devstate & ST_CONNECTED))
 	{
-		DBGL4(L4_RBCHDBG, "rbch_connect", ("unit %d, wakeup\n", unit));
+		NDBGL4(L4_RBCHDBG, "unit %d, wakeup", unit);
 		sc->sc_devstate |= ST_CONNECTED;
 		sc->sc_cd = cdp;
 		wakeup((caddr_t)sc);
@@ -874,14 +908,14 @@ rbch_disconnect(int unit, void *cdp)
 	
         if(cd != sc->sc_cd)
 	{
-		DBGL4(L4_RBCHDBG, "rbch_disconnect", ("rbch%d: channel %d not active\n",
-			cd->driver_unit, cd->channelid));
+		NDBGL4(L4_RBCHDBG, "rbch%d: channel %d not active",
+			cd->driver_unit, cd->channelid);
 		return;
 	}
 
 	CRIT_BEG;
 	
-	DBGL4(L4_RBCHDBG, "rbch_disconnect", ("unit %d, disconnect\n", unit));
+	NDBGL4(L4_RBCHDBG, "unit %d, disconnect", unit);
 
 	sc->sc_devstate &= ~ST_CONNECTED;
 
@@ -891,13 +925,7 @@ rbch_disconnect(int unit, void *cdp)
 	i4b_l4_accounting(BDRV_RBCH, unit, ACCT_FINAL,
 		 sc->sc_ioutb, sc->sc_iinb, 0, 0, sc->sc_ioutb, sc->sc_iinb);
 
-#if defined(__FreeBSD__)
-	untimeout((TIMEOUT_FUNC_T)rbch_timeout,
-		(void *)sc, sc->sc_callout);
-#else
-	untimeout((TIMEOUT_FUNC_T)rbch_timeout,	(void *)sc);
-#endif
-
+	STOP_TIMER(sc->sc_callout, rbch_timeout, sc);
 #endif		
 	CRIT_END;
 }
@@ -937,7 +965,7 @@ rbch_rx_data_rdy(int unit)
 
 		if(IF_QFULL(&(rbch_softc[unit].sc_hdlcq)))
 		{
-			DBGL4(L4_RBCHDBG, "rbch_rx_data_rdy", ("unit %d: hdlc rx queue full!\n", unit));
+			NDBGL4(L4_RBCHDBG, "unit %d: hdlc rx queue full!", unit);
 			m_freem(m);
 		}
 		else
@@ -948,13 +976,13 @@ rbch_rx_data_rdy(int unit)
 
 	if(rbch_softc[unit].sc_devstate & ST_RDWAITDATA)
 	{
-		DBGL4(L4_RBCHDBG, "rbch_rx_data_rdy", ("unit %d, wakeup\n", unit));
+		NDBGL4(L4_RBCHDBG, "unit %d, wakeup", unit);
 		rbch_softc[unit].sc_devstate &= ~ST_RDWAITDATA;
 		wakeup((caddr_t) &isdn_linktab[unit]->rx_queue);
 	}
 	else
 	{
-		DBGL4(L4_RBCHDBG, "rbch_rx_data_rdy", ("unit %d, NO wakeup\n", unit));
+		NDBGL4(L4_RBCHDBG, "unit %d, NO wakeup", unit);
 	}
 	selwakeup(&rbch_softc[unit].selp);
 }
@@ -969,13 +997,13 @@ rbch_tx_queue_empty(int unit)
 {
 	if(rbch_softc[unit].sc_devstate & ST_WRWAITEMPTY)
 	{
-		DBGL4(L4_RBCHDBG, "rbch_tx_queue_empty", ("unit %d, wakeup\n", unit));
+		NDBGL4(L4_RBCHDBG, "unit %d, wakeup", unit);
 		rbch_softc[unit].sc_devstate &= ~ST_WRWAITEMPTY;
 		wakeup((caddr_t) &isdn_linktab[unit]->tx_queue);
 	}
 	else
 	{
-		DBGL4(L4_RBCHDBG, "rbch_tx_queue_empty", ("unit %d, NO wakeup\n", unit));
+		NDBGL4(L4_RBCHDBG, "unit %d, NO wakeup", unit);
 	}
 	selwakeup(&rbch_softc[unit].selp);
 }
diff --git a/sys/i4b/driver/i4b_tel.c b/sys/i4b/driver/i4b_tel.c
index a236d37..0a1c423 100644
--- a/sys/i4b/driver/i4b_tel.c
+++ b/sys/i4b/driver/i4b_tel.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_tel.c - device driver for ISDN telephony
  *	--------------------------------------------
  *
- *	$Id: i4b_tel.c,v 1.47 1999/12/13 21:25:24 hm Exp $
+ *	$Id: i4b_tel.c,v 1.51 2000/10/06 08:37:43 hm Exp $
  *
  * $FreeBSD$
  *
- *	last edit-date: [Mon Dec 13 21:39:26 1999]
+ *	last edit-date: [Mon Oct  2 10:06:32 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -61,6 +61,18 @@
 #include <sys/proc.h>
 #include <sys/tty.h>
 
+#ifdef __FreeBSD__
+
+#if defined(__FreeBSD__) && __FreeBSD__ == 3
+#include "opt_devfs.h"
+#endif
+
+#ifdef DEVFS
+#include <sys/devfsext.h>
+#endif
+
+#endif /* __FreeBSD__ */
+
 #ifdef __bsdi__
 #include <sys/device.h>
 #endif
@@ -122,11 +134,19 @@ typedef struct {
 #define ST_ISOPEN	0x02		/* userland opened */
 #define ST_RDWAITDATA	0x04		/* userland read waiting */
 #define ST_WRWAITEMPTY	0x08		/* userland write waiting */
+#define ST_TONE		0x10		/* tone generator */
 
 	struct selinfo		selp;		/* select / poll */
 
 #if defined(__FreeBSD__) && __FreeBSD__ == 3
+#ifdef DEVFS
+        void                    *devfs_token;   /* token for DEVFS */
 #endif
+#endif
+	struct i4b_tel_tones	tones;
+	int			toneidx;
+	int			toneomega;
+	int			tonefreq;
 
 } tel_sc_t;
 
@@ -139,11 +159,13 @@ static void tel_tx_queue_empty(int unit);
 static void tel_init_linktab(int unit);
 static void tel_connect(int unit, void *cdp);
 static void tel_disconnect(int unit, void *cdp);
+static void tel_tone(tel_sc_t *sc);
 
 /* audio format conversion tables */
 static unsigned char a2u_tab[];
 static unsigned char u2a_tab[];
 static unsigned char bitreverse[];
+static u_char sinetab[];
 
 #ifndef __FreeBSD__
 #define	PDEVSTATIC	/* - not static - */
@@ -262,14 +284,14 @@ struct devsw i4btelsw =
 int
 i4btelmatch(struct device *parent, struct cfdata *cf, void *aux)
 {
-	DBGL4(L4_TELDBG, "i4btelmatch", ("aux=0x%x\n", aux));	
+	NDBGL4(L4_TELDBG, "aux=0x%x", aux);	
 	return 1;
 }
 
 void
 dummy_i4btelattach(struct device *parent, struct device *self, void *aux)
 {
-	DBGL4(L4_TELDBG, "dummy_i4btelattach", ("aux=0x%x\n", aux));
+	NDBGL4(L4_TELDBG, "aux=0x%x", aux);
 }
 
 #endif /* __bsdi__ */
@@ -303,6 +325,13 @@ i4btelattach()
 #if defined(__FreeBSD__)
 #if __FreeBSD__ == 3
 
+#ifdef DEVFS
+
+/* XXX */  		tel_sc[i][j].devfs_token
+		  		= devfs_add_devswf(&i4btel_cdevsw, i, DV_CHR,
+				     UID_ROOT, GID_WHEEL, 0600,
+				     "i4btel%d", i);
+#endif
 
 #else
 			switch(j)
@@ -337,7 +366,7 @@ i4btelopen(dev_t dev, int flag, int fmt, struct proc *p)
 	
 	tel_sc_t *sc;
 	
-	if(unit > NI4BTEL)
+	if(unit >= NI4BTEL)
 		return(ENXIO);
 
 	sc = &tel_sc[unit][func];		
@@ -365,12 +394,15 @@ i4btelclose(dev_t dev, int flag, int fmt, struct proc *p)
 	int func = FUNC(dev);
 	tel_sc_t *sc;
 	int error = 0;
+	int x;
 	
 	if(unit > NI4BTEL)
 		return(ENXIO);
 
 	sc = &tel_sc[unit][func];		
 
+	x = splimp();
+	sc->devstate &= ~ST_TONE;		
 	if((func == FUNCTEL) &&
 	   (sc->isdn_linktab != NULL && sc->isdn_linktab->tx_queue != NULL))
 	{
@@ -388,6 +420,8 @@ i4btelclose(dev_t dev, int flag, int fmt, struct proc *p)
 	}
 
 	sc->devstate &= ~ST_ISOPEN;		
+	splx(x);
+	wakeup((caddr_t) &sc->tones);
 
 	return(error);
 }
@@ -471,6 +505,37 @@ i4btelioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 				mvr->step = STEP;			
 				break;
 			}
+			case I4B_TEL_TONES:
+			{
+				struct i4b_tel_tones *tt;
+
+				tt = (struct i4b_tel_tones *)data;
+				s = splimp();
+				while ((sc->devstate & ST_TONE) && 
+				    sc->tones.duration[sc->toneidx] != 0) {
+					if((error = tsleep((caddr_t) &sc->tones,
+					    TTIPRI | PCATCH, "rtone", 0 )) != 0) {
+					    	splx(s);
+						return(error);
+					}
+				} 
+				if(!(sc->devstate & ST_ISOPEN)) {
+					splx(s);
+					return (EIO);
+				}
+				if(!(sc->devstate & ST_CONNECTED)) {
+					splx(s);
+					return (EIO);
+				}
+
+				sc->tones = *tt;
+				sc->toneidx = 0;
+				sc->tonefreq = tt->frequency[0];
+				sc->devstate |= ST_TONE;
+				splx(s);
+				tel_tone(sc);
+				break;
+			}
 	
 			default:
 				error = ENOTTY;
@@ -509,34 +574,37 @@ i4btelread(dev_t dev, struct uio *uio, int ioflag)
 
 	if(func == FUNCTEL)
 	{
+		s = splimp();
 		while(IF_QEMPTY(sc->isdn_linktab->rx_queue) &&
 			(sc->devstate & ST_ISOPEN)          &&
 			(sc->devstate & ST_CONNECTED))		
 		{
 			sc->devstate |= ST_RDWAITDATA;
 
-			DBGL4(L4_TELDBG, "i4btelread", ("i4btel%d, queue empty!\n", unit));
+			NDBGL4(L4_TELDBG, "i4btel%d, queue empty!", unit);
 			
 			if((error = tsleep((caddr_t) &sc->isdn_linktab->rx_queue,
 						TTIPRI | PCATCH,
 						"rtel", 0 )) != 0)
 			{
 				sc->devstate &= ~ST_RDWAITDATA;
+				splx(s);
 				return(error);
 			}
 		}
 	
 		if(!(sc->devstate & ST_ISOPEN))
 		{
+			splx(s);
 			return(EIO);
 		}
 	
 		if(!(sc->devstate & ST_CONNECTED))
 		{
+			splx(s);
 			return(EIO);
 		}
 		
-		s = splimp();
 	
 		IF_DEQUEUE(sc->isdn_linktab->rx_queue, m);
 		
@@ -555,11 +623,11 @@ i4btelread(dev_t dev, struct uio *uio, int ioflag)
 	                }
 			error = uiomove(m->m_data, m->m_len, uio);
 
-			DBGL4(L4_TELDBG, "i4btelread", ("i4btel%d, mbuf (%d bytes), uiomove %d!\n", unit, m->m_len, error));
+			NDBGL4(L4_TELDBG, "i4btel%d, mbuf (%d bytes), uiomove %d!", unit, m->m_len, error);
 		}
 		else
 		{
-			DBGL4(L4_TELDBG, "i4btelread", ("i4btel%d, empty mbuf from queue!\n", unit));
+			NDBGL4(L4_TELDBG, "i4btel%d, empty mbuf from queue!", unit);
 			error = EIO;
 		}
 			
@@ -570,6 +638,7 @@ i4btelread(dev_t dev, struct uio *uio, int ioflag)
 	}
 	else if(func == FUNCDIAL)
 	{
+		s = splimp();
 		while((sc->result == 0) && (sc->devstate & ST_ISOPEN))
 		{
 			sc->devstate |= ST_RDWAITDATA;
@@ -579,17 +648,17 @@ i4btelread(dev_t dev, struct uio *uio, int ioflag)
 						"rtel1", 0 )) != 0)
 			{
 				sc->devstate &= ~ST_RDWAITDATA;
+				splx(s);
 				return(error);
 			}
 		}
 	
 		if(!(sc->devstate & ST_ISOPEN))
 		{
+			splx(s);
 			return(EIO);
 		}
 	
-		s = splimp();
-
 		if(sc->result != 0)
 		{
 			error = uiomove(&sc->result, 1, uio);
@@ -625,9 +694,14 @@ i4btelwrite(dev_t dev, struct uio * uio, int ioflag)
 
 	if(func == FUNCTEL)
 	{
-		if(!(sc->devstate & ST_CONNECTED))
+		s = splimp();
+		
+		if(!(sc->devstate & ST_CONNECTED)) {
+			splx(s);
 			return(EIO);
+		}
 			
+		sc->devstate &= ~ST_TONE;		
 		while((IF_QFULL(sc->isdn_linktab->tx_queue)) &&
 		      (sc->devstate & ST_ISOPEN))
 		{
@@ -637,22 +711,23 @@ i4btelwrite(dev_t dev, struct uio * uio, int ioflag)
 					TTIPRI | PCATCH, "wtel", 0)) != 0)
 			{
 				sc->devstate &= ~ST_WRWAITEMPTY;			
+				splx(s);
 				return(error);
 			}
 		}
 	
 		if(!(sc->devstate & ST_ISOPEN))
 		{
+			splx(s);
 			return(EIO);
 		}
 	
 		if(!(sc->devstate & ST_CONNECTED))
 		{
+			splx(s);
 			return(EIO);
 		}
 
-		s = splimp();
-	
 		if((m = i4b_Bgetmbuf(BCH_MAX_DATALEN)) != NULL)
 		{
 			register int i;
@@ -687,7 +762,7 @@ i4btelwrite(dev_t dev, struct uio * uio, int ioflag)
 	}
 	else if(func == FUNCDIAL)
 	{
-#define CMDBUFSIZ 80
+#define CMDBUFSIZ 80 
 		char cmdbuf[CMDBUFSIZ];
 		int len = min(CMDBUFSIZ-1, uio->uio_resid);
 	
@@ -710,6 +785,57 @@ i4btelwrite(dev_t dev, struct uio * uio, int ioflag)
 	return(error);
 }
 
+/*---------------------------------------------------------------------------*
+ *	
+ *---------------------------------------------------------------------------*/
+#define NTONESAMP 32
+static void
+tel_tone(tel_sc_t *sc)
+{
+	struct mbuf *m;
+	u_char *p;
+	int i;
+
+	if((m = i4b_Bgetmbuf(NTONESAMP)) == NULL) {
+		printf("no mbuf in tel_tone\n");
+		return;
+	}
+	p = m->m_data;
+	m->m_len = 0;
+	for (i = 0; i < NTONESAMP && (sc->devstate & ST_TONE); i++) {
+
+		if (sc->tones.duration[sc->toneidx] > 0) {
+			if (--sc->tones.duration[sc->toneidx] == 0) {
+				sc->toneidx++;
+				if (sc->toneidx == I4B_TEL_MAXTONES) {
+					sc->devstate &= ~ST_TONE;
+					sc->toneomega = 0;
+					sc->tonefreq = 0;
+				} else if (sc->tones.frequency[sc->toneidx] == 0 &&
+					   sc->tones.duration[sc->toneidx] == 0) {
+					sc->devstate &= ~ST_TONE;
+					sc->toneomega = 0;
+					sc->tonefreq = 0;
+				} else {
+					sc->tonefreq = sc->tones.frequency[sc->toneidx];
+				}
+				if (sc->tones.duration[sc->toneidx] == 0) {
+					wakeup((caddr_t) &sc->tones);
+				}
+			}
+		}
+
+		sc->toneomega += sc->tonefreq;
+		if (sc->toneomega >= 8000)
+			sc->toneomega -= 8000;
+		*p++ = bitreverse[sinetab[sc->toneomega]];
+		m->m_len++;
+	}
+	IF_ENQUEUE(sc->isdn_linktab->tx_queue, m);
+	(*sc->isdn_linktab->bch_tx_start)(sc->isdn_linktab->unit, sc->isdn_linktab->channel);
+}
+
+
 #ifdef OS_USES_POLL
 /*---------------------------------------------------------------------------*
  *	device driver poll
@@ -728,7 +854,7 @@ i4btelpoll(dev_t dev, int events, struct proc *p)
 
 	if(!(sc->devstate & ST_ISOPEN))
 	{
-		DBGL4(L4_TELDBG, "i4btelpoll", ("i4btel%d, !ST_ISOPEN\n", unit));
+		NDBGL4(L4_TELDBG, "i4btel%d, !ST_ISOPEN", unit);
 		splx(s);
 		return(0);
 	}
@@ -745,7 +871,7 @@ i4btelpoll(dev_t dev, int events, struct proc *p)
 			(sc->isdn_linktab != NULL)	&&
 			(!IF_QFULL(sc->isdn_linktab->tx_queue)))
 		{
-			DBGL4(L4_TELDBG, "i4btelpoll", ("i4btel%d, POLLOUT\n", unit));
+			NDBGL4(L4_TELDBG, "i4btel%d, POLLOUT", unit);
 			revents |= (events & (POLLOUT|POLLWRNORM));
 		}
 		
@@ -756,13 +882,13 @@ i4btelpoll(dev_t dev, int events, struct proc *p)
 			(sc->isdn_linktab != NULL)	&&
 			(!IF_QEMPTY(sc->isdn_linktab->rx_queue)))
 		{
-			DBGL4(L4_TELDBG, "i4btelpoll", ("i4btel%d, POLLIN\n", unit));
+			NDBGL4(L4_TELDBG, "i4btel%d, POLLIN", unit);
 			revents |= (events & (POLLIN|POLLRDNORM));
 		}
 			
 		if(revents == 0)
 		{
-			DBGL4(L4_TELDBG, "i4btelpoll", ("i4btel%d, selrecord\n", unit));
+			NDBGL4(L4_TELDBG, "i4btel%d, selrecord", unit);
 			selrecord(p, &sc->selp);
 		}
 	}
@@ -770,20 +896,20 @@ i4btelpoll(dev_t dev, int events, struct proc *p)
 	{
 		if(events & (POLLOUT|POLLWRNORM))
 		{
-			DBGL4(L4_TELDBG, "i4btelpoll", ("i4bteld%d,  POLLOUT\n", unit));
+			NDBGL4(L4_TELDBG, "i4bteld%d,  POLLOUT", unit);
 			revents |= (events & (POLLOUT|POLLWRNORM));
 		}
 
 		if(events & (POLLIN|POLLRDNORM))
 		{
-			DBGL4(L4_TELDBG, "i4btelpoll", ("i4bteld%d,  POLLIN, result = %d\n", unit, sc->result));
+			NDBGL4(L4_TELDBG, "i4bteld%d,  POLLIN, result = %d", unit, sc->result);
 			if(sc->result != 0)
 				revents |= (events & (POLLIN|POLLRDNORM));
 		}
 			
 		if(revents == 0)
 		{
-			DBGL4(L4_TELDBG, "i4btelpoll", ("i4bteld%d,  selrecord\n", unit));
+			NDBGL4(L4_TELDBG, "i4bteld%d,  selrecord", unit);
 			selrecord(p, &sc->selp);
 		}
 	}
@@ -809,7 +935,7 @@ i4btelsel(dev_t dev, int rw, struct proc *p)
 
 	if (!(sc->devstate & ST_ISOPEN))
 	{
-		DBGL4(L4_TELDBG, "i4btelsel", ("i4btel%d, !ST_ISOPEN\n", unit));
+		NDBGL4(L4_TELDBG, "i4btel%d, !ST_ISOPEN", unit);
 		splx(s);
 		return(0);
 	}
@@ -827,7 +953,7 @@ i4btelsel(dev_t dev, int rw, struct proc *p)
 		{
 			if (!IF_QEMPTY(sc->isdn_linktab->rx_queue))
 			{
-				DBGL4(L4_TELDBG, "i4btelsel", ("i4btel%d, FREAD\n", unit));
+				NDBGL4(L4_TELDBG, "i4btel%d, FREAD", unit);
 				splx(s);
 				return 1;
 			}
@@ -836,7 +962,7 @@ i4btelsel(dev_t dev, int rw, struct proc *p)
 		{
 			if (!IF_QFULL(sc->isdn_linktab->tx_queue))
 			{
-				DBGL4(L4_TELDBG, "i4btelsel", ("i4btel%d, FWRITE\n", unit));
+				NDBGL4(L4_TELDBG, "i4btel%d, FWRITE", unit);
 				splx(s);
 				return 1;
 			}
@@ -846,14 +972,14 @@ i4btelsel(dev_t dev, int rw, struct proc *p)
 	{
 		if (rw == FWRITE)
 		{
-			DBGL4(L4_TELDBG, "i4btelsel", ("i4bteld%d,  FWRITE\n", unit));
+			NDBGL4(L4_TELDBG, "i4bteld%d,  FWRITE", unit);
 			splx(s);
 			return 1;
 		}
 
 		if (rw == FREAD)
 		{
-			DBGL4(L4_TELDBG, "i4btelsel", ("i4bteld%d,  FREAD, result = %d\n", unit, sc->result));
+			NDBGL4(L4_TELDBG, "i4bteld%d,  FREAD, result = %d", unit, sc->result);
 			if (sc->result != 0)
 			{
 				splx(s);
@@ -862,7 +988,7 @@ i4btelsel(dev_t dev, int rw, struct proc *p)
 		}
 	}
 
-	DBGL4(L4_TELDBG, "i4btelsel", ("i4bteld%d,  selrecord\n", unit));
+	NDBGL4(L4_TELDBG, "i4bteld%d,  selrecord", unit);
 	selrecord(p, &sc->selp);
 	splx(s);
 	return 0;
@@ -935,7 +1061,7 @@ tel_disconnect(int unit, void *cdp)
 	
 	sc = &tel_sc[unit][FUNCDIAL];
 
-	if(sc->devstate == ST_ISOPEN)
+	if(sc->devstate & ST_ISOPEN)
 	{
 		sc->result = RSP_HUP;
 
@@ -945,6 +1071,11 @@ tel_disconnect(int unit, void *cdp)
 			wakeup((caddr_t) &sc->result);
 		}
 		selwakeup(&sc->selp);
+
+		if (sc->devstate & ST_TONE) {
+			sc->devstate &= ~ST_TONE;
+			wakeup((caddr_t) &sc->tones);
+		}
 	}
 }
 
@@ -956,7 +1087,7 @@ tel_dialresponse(int unit, int status, cause_t cause)
 {	
 	tel_sc_t *sc = &tel_sc[unit][FUNCDIAL];
 
-	DBGL4(L4_TELDBG, "tel_dialresponse", ("i4btel%d,  status=%d, cause=0x%4x\n", unit, status, cause));
+	NDBGL4(L4_TELDBG, "i4btel%d,  status=%d, cause=0x%4x", unit, status, cause);
 
 	if((sc->devstate == ST_ISOPEN) && status)
 	{	
@@ -1012,7 +1143,11 @@ tel_tx_queue_empty(int unit)
 		sc->devstate &= ~ST_WRWAITEMPTY;
 		wakeup((caddr_t) &sc->isdn_linktab->tx_queue);
 	}
-	selwakeup(&sc->selp);
+	if(sc->devstate & ST_TONE) {
+		tel_tone(sc);
+	} else {
+		selwakeup(&sc->selp);
+	}
 }
 
 /*---------------------------------------------------------------------------*
@@ -1184,6 +1319,581 @@ static unsigned char bitreverse[256] = {
 /* f8 */	0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
 };
 
+static u_char sinetab[8000] = { 213, 213, 213, 213, 213, 213, 213, 212,
+212, 212, 212, 212, 212, 215, 215, 215, 215, 215, 215, 214, 214,
+214, 214, 214, 214, 209, 209, 209, 209, 209, 209, 209, 208, 208,
+208, 208, 208, 208, 211, 211, 211, 211, 211, 211, 210, 210, 210,
+210, 210, 210, 221, 221, 221, 221, 221, 221, 220, 220, 220, 220,
+220, 220, 220, 223, 223, 223, 223, 223, 223, 222, 222, 222, 222,
+222, 222, 217, 217, 217, 217, 217, 217, 216, 216, 216, 216, 216,
+216, 216, 219, 219, 219, 219, 219, 219, 218, 218, 218, 218, 218,
+218, 197, 197, 197, 197, 197, 197, 196, 196, 196, 196, 196, 196,
+196, 199, 199, 199, 199, 199, 199, 198, 198, 198, 198, 198, 198,
+193, 193, 193, 193, 193, 193, 192, 192, 192, 192, 192, 192, 192,
+195, 195, 195, 195, 195, 195, 194, 194, 194, 194, 194, 194, 205,
+205, 205, 205, 205, 205, 204, 204, 204, 204, 204, 204, 204, 207,
+207, 207, 207, 207, 207, 206, 206, 206, 206, 206, 206, 201, 201,
+201, 201, 201, 201, 200, 200, 200, 200, 200, 200, 200, 203, 203,
+203, 203, 203, 203, 202, 202, 202, 202, 202, 202, 245, 245, 245,
+245, 245, 245, 245, 245, 245, 245, 245, 245, 245, 244, 244, 244,
+244, 244, 244, 244, 244, 244, 244, 244, 244, 247, 247, 247, 247,
+247, 247, 247, 247, 247, 247, 247, 247, 247, 246, 246, 246, 246,
+246, 246, 246, 246, 246, 246, 246, 246, 246, 241, 241, 241, 241,
+241, 241, 241, 241, 241, 241, 241, 241, 240, 240, 240, 240, 240,
+240, 240, 240, 240, 240, 240, 240, 240, 243, 243, 243, 243, 243,
+243, 243, 243, 243, 243, 243, 243, 243, 242, 242, 242, 242, 242,
+242, 242, 242, 242, 242, 242, 242, 242, 253, 253, 253, 253, 253,
+253, 253, 253, 253, 253, 253, 253, 253, 252, 252, 252, 252, 252,
+252, 252, 252, 252, 252, 252, 252, 255, 255, 255, 255, 255, 255,
+255, 255, 255, 255, 255, 255, 255, 254, 254, 254, 254, 254, 254,
+254, 254, 254, 254, 254, 254, 254, 249, 249, 249, 249, 249, 249,
+249, 249, 249, 249, 249, 249, 249, 248, 248, 248, 248, 248, 248,
+248, 248, 248, 248, 248, 248, 248, 251, 251, 251, 251, 251, 251,
+251, 251, 251, 251, 251, 251, 251, 250, 250, 250, 250, 250, 250,
+250, 250, 250, 250, 250, 250, 250, 229, 229, 229, 229, 229, 229,
+229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229,
+229, 229, 229, 229, 229, 229, 229, 228, 228, 228, 228, 228, 228,
+228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
+228, 228, 228, 228, 228, 228, 228, 228, 231, 231, 231, 231, 231,
+231, 231, 231, 231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
+231, 231, 231, 231, 231, 231, 231, 231, 231, 230, 230, 230, 230,
+230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+230, 230, 230, 230, 230, 230, 230, 230, 230, 225, 225, 225, 225,
+225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225,
+225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 224, 224,
+224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 227,
+227, 227, 227, 227, 227, 227, 227, 227, 227, 227, 227, 227, 227,
+227, 227, 227, 227, 227, 227, 227, 227, 227, 227, 227, 227, 227,
+227, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226,
+226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226,
+226, 226, 226, 237, 237, 237, 237, 237, 237, 237, 237, 237, 237,
+237, 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, 237,
+237, 237, 237, 237, 237, 236, 236, 236, 236, 236, 236, 236, 236,
+236, 236, 236, 236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
+236, 236, 236, 236, 236, 236, 236, 236, 239, 239, 239, 239, 239,
+239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
+239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 238, 238,
+238, 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, 238,
+238, 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, 238,
+238, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233,
+233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233,
+233, 233, 233, 233, 233, 232, 232, 232, 232, 232, 232, 232, 232,
+232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232,
+232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 235, 235, 235,
+235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235,
+235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235,
+235, 235, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234,
+234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234,
+234, 234, 234, 234, 234, 234, 234, 149, 149, 149, 149, 149, 149,
+149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
+149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
+149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
+149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
+149, 149, 149, 149, 149, 149, 149, 148, 148, 148, 148, 148, 148,
+148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
+148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
+148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
+148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
+148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 151, 151, 151,
+151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
+151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
+151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
+151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
+151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
+151, 151, 151, 151, 150, 150, 150, 150, 150, 150, 150, 150, 150,
+150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
+150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
+150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
+150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
+150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
+150, 150, 150, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+145, 145, 145, 145, 145, 145, 145, 145, 144, 144, 144, 144, 144,
+144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
+144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
+144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
+144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
+144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
+144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
+144, 144, 144, 144, 144, 144, 144, 144, 144, 147, 147, 147, 147,
+147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
+147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
+147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
+147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
+147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
+147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
+147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
+147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
+156, 156, 156, 156, 156, 156, 156, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
+157, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
+146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 147, 147, 147,
+147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
+147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
+147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
+147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
+147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
+147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
+147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
+147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, 144, 144,
+144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
+144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
+144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
+144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
+144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
+144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
+144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 145,
+145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+145, 145, 145, 145, 150, 150, 150, 150, 150, 150, 150, 150, 150,
+150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
+150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
+150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
+150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
+150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
+150, 150, 150, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
+151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
+151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
+151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
+151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
+151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 148, 148, 148,
+148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
+148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
+148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
+148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
+148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
+149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
+149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
+149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
+149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
+149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
+234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234,
+234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234,
+234, 234, 234, 234, 234, 235, 235, 235, 235, 235, 235, 235, 235,
+235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235,
+235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 232, 232, 232,
+232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232,
+232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232,
+232, 232, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233,
+233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233,
+233, 233, 233, 233, 233, 233, 238, 238, 238, 238, 238, 238, 238,
+238, 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, 238,
+238, 238, 238, 238, 238, 238, 238, 238, 238, 239, 239, 239, 239,
+239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
+239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 236,
+236, 236, 236, 236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
+236, 236, 236, 236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
+236, 236, 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, 237,
+237, 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, 237,
+237, 237, 237, 237, 226, 226, 226, 226, 226, 226, 226, 226, 226,
+226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226,
+226, 226, 226, 226, 226, 226, 227, 227, 227, 227, 227, 227, 227,
+227, 227, 227, 227, 227, 227, 227, 227, 227, 227, 227, 227, 227,
+227, 227, 227, 227, 227, 227, 227, 227, 224, 224, 224, 224, 224,
+224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+224, 224, 224, 224, 224, 224, 224, 224, 224, 225, 225, 225, 225,
+225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225,
+225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 230, 230,
+230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
+230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 231, 231,
+231, 231, 231, 231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
+231, 231, 231, 231, 231, 231, 231, 231, 231, 231, 231, 231, 228,
+228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
+228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
+229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229,
+229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229,
+250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
+251, 251, 251, 251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
+248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248,
+249, 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
+254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254,
+255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+252, 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, 253,
+253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 242,
+242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 243,
+243, 243, 243, 243, 243, 243, 243, 243, 243, 243, 243, 243, 240,
+240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 241,
+241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 246, 246,
+246, 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, 247, 247,
+247, 247, 247, 247, 247, 247, 247, 247, 247, 247, 247, 244, 244,
+244, 244, 244, 244, 244, 244, 244, 244, 244, 244, 245, 245, 245,
+245, 245, 245, 245, 245, 245, 245, 245, 245, 245, 202, 202, 202,
+202, 202, 202, 203, 203, 203, 203, 203, 203, 200, 200, 200, 200,
+200, 200, 200, 201, 201, 201, 201, 201, 201, 206, 206, 206, 206,
+206, 206, 207, 207, 207, 207, 207, 207, 204, 204, 204, 204, 204,
+204, 204, 205, 205, 205, 205, 205, 205, 194, 194, 194, 194, 194,
+194, 195, 195, 195, 195, 195, 195, 192, 192, 192, 192, 192, 192,
+192, 193, 193, 193, 193, 193, 193, 198, 198, 198, 198, 198, 198,
+199, 199, 199, 199, 199, 199, 196, 196, 196, 196, 196, 196, 196,
+197, 197, 197, 197, 197, 197, 218, 218, 218, 218, 218, 218, 219,
+219, 219, 219, 219, 219, 216, 216, 216, 216, 216, 216, 216, 217,
+217, 217, 217, 217, 217, 222, 222, 222, 222, 222, 222, 223, 223,
+223, 223, 223, 223, 220, 220, 220, 220, 220, 220, 220, 221, 221,
+221, 221, 221, 221, 210, 210, 210, 210, 210, 210, 211, 211, 211,
+211, 211, 211, 208, 208, 208, 208, 208, 208, 209, 209, 209, 209,
+209, 209, 209, 214, 214, 214, 214, 214, 214, 215, 215, 215, 215,
+215, 215, 212, 212, 212, 212, 212, 212, 213, 213, 213, 213, 213,
+213, 213, 90, 90, 90, 85, 85, 85, 85, 85, 85, 84, 84, 84, 84, 84,
+84, 87, 87, 87, 87, 87, 87, 86, 86, 86, 86, 86, 86, 81, 81, 81,
+81, 81, 81, 81, 80, 80, 80, 80, 80, 80, 83, 83, 83, 83, 83, 83,
+82, 82, 82, 82, 82, 82, 93, 93, 93, 93, 93, 93, 93, 92, 92, 92,
+92, 92, 92, 95, 95, 95, 95, 95, 95, 94, 94, 94, 94, 94, 94, 89,
+89, 89, 89, 89, 89, 88, 88, 88, 88, 88, 88, 88, 91, 91, 91, 91,
+91, 91, 90, 90, 90, 90, 90, 90, 69, 69, 69, 69, 69, 69, 68, 68,
+68, 68, 68, 68, 68, 71, 71, 71, 71, 71, 71, 70, 70, 70, 70, 70,
+70, 65, 65, 65, 65, 65, 65, 64, 64, 64, 64, 64, 64, 64, 67, 67,
+67, 67, 67, 67, 66, 66, 66, 66, 66, 66, 77, 77, 77, 77, 77, 77,
+76, 76, 76, 76, 76, 76, 76, 79, 79, 79, 79, 79, 79, 78, 78, 78,
+78, 78, 78, 73, 73, 73, 73, 73, 73, 73, 72, 72, 72, 72, 72, 72,
+75, 75, 75, 75, 75, 75, 74, 74, 74, 74, 74, 74, 117, 117, 117, 117,
+117, 117, 117, 117, 117, 117, 117, 117, 117, 116, 116, 116, 116,
+116, 116, 116, 116, 116, 116, 116, 116, 116, 119, 119, 119, 119,
+119, 119, 119, 119, 119, 119, 119, 119, 118, 118, 118, 118, 118,
+118, 118, 118, 118, 118, 118, 118, 118, 113, 113, 113, 113, 113,
+113, 113, 113, 113, 113, 113, 113, 113, 112, 112, 112, 112, 112,
+112, 112, 112, 112, 112, 112, 112, 115, 115, 115, 115, 115, 115,
+115, 115, 115, 115, 115, 115, 115, 114, 114, 114, 114, 114, 114,
+114, 114, 114, 114, 114, 114, 114, 125, 125, 125, 125, 125, 125,
+125, 125, 125, 125, 125, 125, 125, 124, 124, 124, 124, 124, 124,
+124, 124, 124, 124, 124, 124, 124, 127, 127, 127, 127, 127, 127,
+127, 127, 127, 127, 127, 127, 126, 126, 126, 126, 126, 126, 126,
+126, 126, 126, 126, 126, 126, 121, 121, 121, 121, 121, 121, 121,
+121, 121, 121, 121, 121, 121, 120, 120, 120, 120, 120, 120, 120,
+120, 120, 120, 120, 120, 120, 123, 123, 123, 123, 123, 123, 123,
+123, 123, 123, 123, 123, 123, 122, 122, 122, 122, 122, 122, 122,
+122, 122, 122, 122, 122, 122, 101, 101, 101, 101, 101, 101, 101,
+101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101,
+101, 101, 101, 101, 101, 101, 101, 100, 100, 100, 100, 100, 100,
+100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
+100, 100, 100, 100, 100, 100, 100, 103, 103, 103, 103, 103, 103,
+103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
+103, 103, 103, 103, 103, 103, 103, 103, 102, 102, 102, 102, 102,
+102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102,
+102, 102, 102, 102, 102, 102, 102, 102, 102, 97, 97, 97, 97, 97,
+97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
+97, 97, 97, 97, 97, 97, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
+96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
+96, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 98, 98, 98,
+98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98,
+98, 98, 98, 98, 98, 98, 98, 98, 98, 109, 109, 109, 109, 109, 109,
+109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
+109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 108, 108, 108,
+108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
+108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 111,
+111, 111, 111, 111, 111, 111, 111, 111, 111, 111, 111, 111, 111,
+111, 111, 111, 111, 111, 111, 111, 111, 111, 111, 111, 111, 111,
+111, 111, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
+110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
+110, 110, 110, 110, 110, 110, 105, 105, 105, 105, 105, 105, 105,
+105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105,
+105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 104, 104, 104,
+104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
+104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
+104, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
+107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
+107, 107, 107, 107, 107, 107, 106, 106, 106, 106, 106, 106, 106,
+106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
+106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 21,
+21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+20, 20, 20, 20, 20, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 17, 17, 17, 17, 17, 17,
+17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 16, 16,
+16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 19, 19, 19, 19, 19, 19,
+19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+19, 19, 19, 19, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+18, 18, 18, 18, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 18, 18, 18, 18, 18,
+18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19,
+19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+19, 19, 19, 19, 19, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+16, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+17, 17, 17, 17, 17, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 20, 20, 20, 20, 20, 20,
+20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21,
+21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
+106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
+106, 106, 106, 106, 106, 106, 107, 107, 107, 107, 107, 107, 107,
+107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
+107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 104, 104,
+104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
+104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
+104, 104, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105,
+105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105,
+105, 105, 105, 105, 105, 105, 110, 110, 110, 110, 110, 110, 110,
+110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
+110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 111, 111, 111,
+111, 111, 111, 111, 111, 111, 111, 111, 111, 111, 111, 111, 111,
+111, 111, 111, 111, 111, 111, 111, 111, 111, 111, 111, 111, 111,
+108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
+108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
+108, 108, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
+109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
+109, 109, 109, 109, 109, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98,
+98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98,
+98, 98, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 96, 96,
+96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
+96, 96, 96, 96, 96, 96, 96, 96, 96, 97, 97, 97, 97, 97, 97, 97,
+97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
+97, 97, 97, 97, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102,
+102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102,
+102, 102, 102, 102, 103, 103, 103, 103, 103, 103, 103, 103, 103,
+103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
+103, 103, 103, 103, 103, 100, 100, 100, 100, 100, 100, 100, 100,
+100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
+100, 100, 100, 100, 100, 101, 101, 101, 101, 101, 101, 101, 101,
+101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101,
+101, 101, 101, 101, 101, 101, 122, 122, 122, 122, 122, 122, 122,
+122, 122, 122, 122, 122, 122, 123, 123, 123, 123, 123, 123, 123,
+123, 123, 123, 123, 123, 123, 120, 120, 120, 120, 120, 120, 120,
+120, 120, 120, 120, 120, 120, 121, 121, 121, 121, 121, 121, 121,
+121, 121, 121, 121, 121, 121, 126, 126, 126, 126, 126, 126, 126,
+126, 126, 126, 126, 126, 126, 127, 127, 127, 127, 127, 127, 127,
+127, 127, 127, 127, 127, 124, 124, 124, 124, 124, 124, 124, 124,
+124, 124, 124, 124, 124, 125, 125, 125, 125, 125, 125, 125, 125,
+125, 125, 125, 125, 125, 114, 114, 114, 114, 114, 114, 114, 114,
+114, 114, 114, 114, 114, 115, 115, 115, 115, 115, 115, 115, 115,
+115, 115, 115, 115, 115, 112, 112, 112, 112, 112, 112, 112, 112,
+112, 112, 112, 112, 113, 113, 113, 113, 113, 113, 113, 113, 113,
+113, 113, 113, 113, 118, 118, 118, 118, 118, 118, 118, 118, 118,
+118, 118, 118, 118, 119, 119, 119, 119, 119, 119, 119, 119, 119,
+119, 119, 119, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
+116, 116, 116, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117,
+117, 117, 117, 74, 74, 74, 74, 74, 74, 75, 75, 75, 75, 75, 75, 72,
+72, 72, 72, 72, 72, 73, 73, 73, 73, 73, 73, 73, 78, 78, 78, 78,
+78, 78, 79, 79, 79, 79, 79, 79, 76, 76, 76, 76, 76, 76, 76, 77,
+77, 77, 77, 77, 77, 66, 66, 66, 66, 66, 66, 67, 67, 67, 67, 67,
+67, 64, 64, 64, 64, 64, 64, 64, 65, 65, 65, 65, 65, 65, 70, 70,
+70, 70, 70, 70, 71, 71, 71, 71, 71, 71, 68, 68, 68, 68, 68, 68,
+68, 69, 69, 69, 69, 69, 69, 90, 90, 90, 90, 90, 90, 91, 91, 91,
+91, 91, 91, 88, 88, 88, 88, 88, 88, 88, 89, 89, 89, 89, 89, 89,
+94, 94, 94, 94, 94, 94, 95, 95, 95, 95, 95, 95, 92, 92, 92, 92,
+92, 92, 93, 93, 93, 93, 93, 93, 93, 82, 82, 82, 82, 82, 82, 83,
+83, 83, 83, 83, 83, 80, 80, 80, 80, 80, 80, 81, 81, 81, 81, 81,
+81, 81, 86, 86, 86, 86, 86, 86, 87, 87, 87, 87, 87, 87, 84, 84,
+84, 84, 84, 84, 85, 85, 85, 85, 85, 85, 90, 90, 90 };
+
 /*===========================================================================*/
 
 #endif /* NI4BTEL > 0 */
diff --git a/sys/i4b/driver/i4b_trace.c b/sys/i4b/driver/i4b_trace.c
index c3c1688..3847508 100644
--- a/sys/i4b/driver/i4b_trace.c
+++ b/sys/i4b/driver/i4b_trace.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,9 +27,9 @@
  *	i4btrc - device driver for trace data read device
  *	---------------------------------------------------
  *
- *	$Id: i4b_trace.c,v 1.24 1999/12/13 21:25:24 hm Exp $
+ *	$Id: i4b_trace.c,v 1.27 2000/06/02 16:14:35 hm Exp $
  *
- *	last edit-date: [Mon Dec 13 21:39:35 1999]
+ *	last edit-date: [Fri Jun  2 17:48:19 2000]
  *
  * $FreeBSD$
  *
@@ -41,17 +41,6 @@
 
 #if NI4BTRC > 0
 
-#ifdef __FreeBSD__
-#include "isic.h"	/* 'isic' is no pseudo-device on non FreeBSD -
-			 * so we just can't count it at compile time,
-			 * we're doing an attach-time check instead. */
-
-#if NI4BTRC < NISIC
-#error "number of trace devices != number of passive ISDN controllers !"
-#error "change number of i4btrc to be equal to number of isic devices !"
-#endif
-#endif	/* __FreeBSD__ */
-
 #include <sys/param.h>
 #include <sys/systm.h>
 
@@ -72,6 +61,9 @@
 
 #ifdef __FreeBSD__
 
+#ifdef DEVFS
+#include <sys/devfsext.h>
+#endif
 
 #include <machine/i4b_trace.h>
 #include <machine/i4b_ioctl.h>
@@ -98,6 +90,9 @@ static int device_state[NI4BTRC];
 #define ST_WAITDATA	0x02
 
 #if defined(__FreeBSD__) && __FreeBSD__ == 3
+#ifdef DEVFS
+static void *devfs_token[NI4BTRC];
+#endif
 #endif
 
 static int analyzemode = 0;
@@ -238,6 +233,12 @@ i4btrcattach()
 #if defined(__FreeBSD__)
 #if __FreeBSD__ < 4
 
+#ifdef DEVFS
+	  	devfs_token[i]
+		  = devfs_add_devswf(&i4btrc_cdevsw, i, DV_CHR,
+				     UID_ROOT, GID_WHEEL, 0600,
+				     "i4btrc%d", i);
+#endif
 
 #else
 		make_dev(&i4btrc_cdevsw, i,
@@ -361,7 +362,7 @@ i4btrcopen(dev_t dev, int flag, int fmt, struct proc *p)
 	int x;
 	int unit = minor(dev);
 
-	if(unit > NI4BTRC)
+	if(unit >= NI4BTRC)
 		return(ENXIO);
 
 	if(device_state[unit] & ST_ISOPEN)
@@ -386,11 +387,13 @@ PDEVSTATIC int
 i4btrcclose(dev_t dev, int flag, int fmt, struct proc *p)
 {
 	int unit = minor(dev);
-	int i, x, cno = -1;
+	int i, x;
+	int cno = -1;
 
-	for(i = 0; i < nctrl; i++)
+	for(i=0; i < nctrl; i++)
 	{
-		if(ctrl_desc[i].N_SET_TRACE)
+		if((ctrl_desc[i].ctrl_type == CTRL_PASSIVE) &&
+			(ctrl_desc[i].unit == unit))
 		{
 			cno = i;
 			break;
@@ -404,8 +407,8 @@ i4btrcclose(dev_t dev, int flag, int fmt, struct proc *p)
 		
 		if(cno >= 0)
 		{
-			ctrl_desc[cno].N_SET_TRACE(rxunit, TRACE_OFF);
-			ctrl_desc[cno].N_SET_TRACE(txunit, TRACE_OFF);
+			(*ctrl_desc[cno].N_MGMT_COMMAND)(rxunit, CMR_SETTRACE, TRACE_OFF);
+			(*ctrl_desc[cno].N_MGMT_COMMAND)(txunit, CMR_SETTRACE, TRACE_OFF);
 		}
 		rxunit = -1;
 		txunit = -1;
@@ -413,7 +416,7 @@ i4btrcclose(dev_t dev, int flag, int fmt, struct proc *p)
 	
 	if(cno >= 0)
 	{
-		ctrl_desc[cno].N_SET_TRACE(unit, TRACE_OFF);
+			(*ctrl_desc[cno].N_MGMT_COMMAND)(ctrl_desc[cno].unit, CMR_SETTRACE, TRACE_OFF);
 	}
 
 	x = SPLI4B();
@@ -494,33 +497,27 @@ i4btrcioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 	int error = 0;
 	int unit = minor(dev);
 	i4b_trace_setupa_t *tsa;
-	int i, cno = -1;
+	int i;
+	int cno = -1;
 
-	/* find the first passive controller to get at the set/get function
-	   pointers. Would be better if we had the controller class virtual
-	   function table separate from the port registry... */
+	/* find the first passive controller matching our unit no */
 
 	for(i=0; i < nctrl; i++)
 	{
-		if(ctrl_desc[i].N_SET_TRACE)
+		if((ctrl_desc[i].ctrl_type == CTRL_PASSIVE) &&
+			(ctrl_desc[i].unit == unit))
 		{
-			cno = i;	/* one suitable controller, might not */
-			break;		/* be related to the trace unit at all, but */
-		}			/* has the right function pointers */
+			cno = i;
+			break;
+		}
 	}
 	
 	switch(cmd)
 	{
-		case I4B_TRC_GET:
-			if(cno < 0)
-				return ENOTTY;
-			*(int *)data = ctrl_desc[cno].N_GET_TRACE(unit);
-			break;
-		
 		case I4B_TRC_SET:
 			if(cno < 0)
 				return ENOTTY;
-			ctrl_desc[cno].N_SET_TRACE(unit, *(int *)data);
+			(*ctrl_desc[cno].N_MGMT_COMMAND)(ctrl_desc[cno].unit, CMR_SETTRACE, (void *)*(unsigned int *)data);
 			break;
 
 		case I4B_TRC_SETA:
@@ -549,8 +546,8 @@ i4btrcioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 					
 				outunit = unit;
 				analyzemode = 1;
-				ctrl_desc[cno].N_SET_TRACE(rxunit, tsa->rxflags & (TRACE_I | TRACE_D_RX | TRACE_B_RX));
-				ctrl_desc[cno].N_SET_TRACE(txunit, tsa->txflags & (TRACE_I | TRACE_D_RX | TRACE_B_RX));
+				(*ctrl_desc[cno].N_MGMT_COMMAND)(rxunit, CMR_SETTRACE, (int *)(tsa->rxflags & (TRACE_I | TRACE_D_RX | TRACE_B_RX)));
+				(*ctrl_desc[cno].N_MGMT_COMMAND)(txunit, CMR_SETTRACE, (int *)(tsa->txflags & (TRACE_I | TRACE_D_RX | TRACE_B_RX)));
 			}
 			break;
 
diff --git a/sys/i4b/include/i4b_cause.h b/sys/i4b/include/i4b_cause.h
index 96589e5..36c6142 100644
--- a/sys/i4b/include/i4b_cause.h
+++ b/sys/i4b/include/i4b_cause.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_cause.h - causes and cause handling for i4b
  *	-----------------------------------------------
  *
- *	$Id: i4b_cause.h,v 1.11 1999/12/13 21:25:28 hm Exp $
+ *	$Id: i4b_cause.h,v 1.13 2000/02/06 19:01:14 hm Exp $
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:06:51 1999]
+ *      last edit-date: [Sun Feb  6 19:46:41 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -70,7 +70,8 @@
 #define CAUSE_I4B_L1ERROR	7	/* L1 error / persistent deact	*/
 #define CAUSE_I4B_LLDIAL	8	/* no dialout on leased line	*/
 #define CAUSE_I4B_MAX		9
-		/* NOTE: update isdnd/pcause.c when adding causes !!!!! */
+	/* NOTE: update isdnd/pcause.c when adding causes !!!!!		*/
+	/* NOTE: update layer3/i4b_q931.c when adding causes !!!!!	*/
 	
 /* CAUSET_Q850 - causes defined in Q.850 */
 
diff --git a/sys/i4b/include/i4b_debug.h b/sys/i4b/include/i4b_debug.h
index aabc498..0e7eab2 100644
--- a/sys/i4b/include/i4b_debug.h
+++ b/sys/i4b/include/i4b_debug.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,58 +27,52 @@
  *	i4b_debug.h - i4b debug header file
  *	-----------------------------------
  *
- *	$Id: i4b_debug.h,v 1.20 1999/12/13 21:25:28 hm Exp $ 
+ *	$Id: i4b_debug.h,v 1.32 2000/07/24 12:22:08 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:06:59 1999]
+ *      last edit-date: [Wed May 31 09:51:34 2000]
  *
  *---------------------------------------------------------------------------*/
 
-#define DO_I4B_DEBUG	/* enable debugging code inclusion */
+#if !defined DO_I4B_DEBUG
+# define DO_I4B_DEBUG 1		/* default = include debugging code */
+#elif DO_I4B_DEBUG != 0
+# undef DO_I4B_DEBUG
+# define DO_I4B_DEBUG 1
+#endif
 
-#undef DO_I4B_MAXDEBUG	/* enable ALL debug messages by default	*/
+#undef DO_I4B_MAXDEBUG		/* default = disable ALL debug messages */
 
-#ifdef DO_I4B_DEBUG
+#if DO_I4B_DEBUG
 
 extern unsigned int i4b_l1_debug;
 extern unsigned int i4b_l2_debug;
 extern unsigned int i4b_l3_debug;
 extern unsigned int i4b_l4_debug;
 
-#define DBGL1(bits, routine, what)			\
-	if(bits & i4b_l1_debug)				\
-	{						\
-		printf("i4b-L1-%s: ", routine);	\
-		printf what ;				\
-	}
-
-#define DBGL2(bits, routine, what)			\
-	if(bits & i4b_l2_debug)				\
-	{						\
-		printf("i4b-L2-%s: ", routine);	\
-		printf what ;				\
-	}
-
-#define DBGL3(bits, routine, what)			\
-	if(bits & i4b_l3_debug)				\
-	{						\
-		printf("i4b-L3-%s: ", routine);	\
-		printf what ;				\
-	}
-
-#define DBGL4(bits, routine, what)			\
-	if(bits & i4b_l4_debug)				\
-	{						\
-		printf("i4b-L4-%s: ", routine);	\
-		printf what ;				\
-	}
+#define NDBGL1(bits, fmt, args...)				 	\
+	if(bits & i4b_l1_debug)						\
+	{ printf("i4b-L1 %s: " fmt "\n", __FUNCTION__ , ##args ); }
+
+#define NDBGL2(bits, fmt, args...)				 	\
+	if(bits & i4b_l2_debug)						\
+	{ printf("i4b-L2 %s: " fmt "\n", __FUNCTION__ , ##args ); }
+	
+#define NDBGL3(bits, fmt, args...)				 	\
+	if(bits & i4b_l3_debug)						\
+	{ printf("i4b-L3 %s: " fmt "\n", __FUNCTION__ , ##args ); }
+	
+#define NDBGL4(bits, fmt, args...)				 	\
+	if(bits & i4b_l4_debug)						\
+	{ printf("i4b-L4 %s: " fmt "\n", __FUNCTION__ , ##args ); }
+	
 #else /* !DO_I4B_DEBUG */
 
-#define DBGL1(bits, routine, what);
-#define DBGL2(bits, routine, what);
-#define DBGL3(bits, routine, what);
-#define DBGL4(bits, routine, what);
+#define NDBGL1(bits, fmt, args...);
+#define NDBGL2(bits, fmt, args...);
+#define NDBGL3(bits, fmt, args...);
+#define NDBGL4(bits, fmt, args...);
 
 #endif /* DO_I4B_DEBUG */
 
@@ -98,9 +92,11 @@ extern unsigned int i4b_l4_debug;
 #define L1_T_ERR	0x0800		/* Timer error messages	*/
 #define L1_H_XFRERR	0x1000		/* HSCX data xfer error */
 #define L1_I_CICO	0x2000		/* ISAC command in/out	*/
+#define L1_S_MSG	0x4000		/* silent messages (soft-HDLC)	*/
+#define L1_S_ERR	0x8000		/* error messages (soft-HDLC)	*/
 
-#define L1_DEBUG_MAX	0x3fef		/* all messages on except IRQ!	*/
-#define L1_DEBUG_ERR (L1_H_ERR | L1_I_ERR | L1_F_ERR | L1_T_ERR | L1_ERROR)
+#define L1_DEBUG_MAX	0xffef		/* all messages on except IRQ!	*/
+#define L1_DEBUG_ERR (L1_S_ERR | L1_H_ERR | L1_I_ERR | L1_F_ERR | L1_T_ERR | L1_ERROR)
 
 #ifndef L1_DEBUG_DEFAULT
 #ifdef DO_I4B_MAXDEBUG
@@ -176,8 +172,9 @@ extern unsigned int i4b_l4_debug;
 #define L4_TINADBG	0x0100		/* tina driver debug messages	*/
 #define L4_TINAMSG	0x0200		/* tina driver messages		*/
 #define L4_TINAERR	0x0400		/* tina driver error messages	*/
+#define L4_INGDBG	0x0800		/* ing driver debug messages	*/
 
-#define L4_DEBUG_MAX	0x07ff		/* all messages on	*/
+#define L4_DEBUG_MAX	0x0fff		/* all messages on	*/
 #define L4_DEBUG_ERR	(L4_ERR | L4_TINADBG |  L4_TINAMSG | L4_TINAERR)
 
 #ifndef L4_DEBUG_DEFAULT
@@ -205,9 +202,23 @@ typedef struct {
 #define	I4B_CTL_SET_DEBUG	_IOW('C', 1, ctl_debug_t)
 
 /*---------------------------------------------------------------------------*
- *	get hscx statistics
+ *	generic get chipset statistics
  *---------------------------------------------------------------------------*/
 
+/* for the ihfc-driver: structure for HFC-1/S/SP statistics */
+
+typedef struct {
+	int txframes;
+	int rxframes;
+	int xdu;
+	int rdo;
+	int crc;
+	int rab;
+} hfcstat_t;
+
+
+/* for the isic-driver: structure for HSCX statistics */
+
 typedef struct {
 	int unit;	/* controller number */
 	int chan;	/* channel number */
@@ -218,44 +229,61 @@ typedef struct {
 	int xdu;
 	int rfo;
 } hscxstat_t;
-	
-#define	I4B_CTL_GET_HSCXSTAT	_IOWR('C', 2, hscxstat_t)
 
-#define	I4B_CTL_CLR_HSCXSTAT	_IOW('C', 3, hscxstat_t)
+/* generic statistics structure */
+
+struct chipstat {
+	int driver_type;		/* type, L1DRVR_XXXX		*/
+	int driver_unit;		/* the unit number		*/
+	int driver_bchannel;		/* the B-channel		*/
+	union stats {			/* union for all drivers	*/
+		hfcstat_t  hfcstat;	/* for ihfc driver, L1DRVR_IHFC	*/
+		hscxstat_t hscxstat;	/* for isic driver, L1DRVR_ISIC	*/
+	} stats;
+};
+
+/* get statistics */
+
+#define	I4B_CTL_GET_CHIPSTAT	_IOWR('C', 2, struct chipstat)
+
+/* clear statistics */
+
+#define	I4B_CTL_CLR_CHIPSTAT	_IOW('C', 3, struct chipstat)
 
 /*---------------------------------------------------------------------------*
  *	get LAPD/Q.921 statistics
  *---------------------------------------------------------------------------*/
 typedef struct {
-				/* transmit */
 
-	u_long	tx_i;	/* I 	*/
-	u_long	tx_rr;	/* RR	*/
-	u_long	tx_rnr;	/* RNR 	*/
-	u_long	tx_rej;	/* REJ	*/
+	/* transmit */
+
+	u_long	tx_i;		/* I 	*/
+	u_long	tx_rr;		/* RR	*/
+	u_long	tx_rnr;		/* RNR 	*/
+	u_long	tx_rej;		/* REJ	*/
 	u_long	tx_sabme;	/* SABME*/
-	u_long	tx_dm;	/* DM	*/
+	u_long	tx_dm;		/* DM	*/
 	u_long	tx_disc;	/* DISC */
-	u_long	tx_ua;	/* UA	*/
+	u_long	tx_ua;		/* UA	*/
 	u_long	tx_frmr;	/* FRMR	*/	
-	u_long	tx_tei;	/* TEI	*/
+	u_long	tx_tei;		/* TEI	*/
 
-				/* receive */
+	/* receive */
 
-	u_long	rx_i;	/* I    */
-	u_long	rx_rr;	/* RR   */
-	u_long	rx_rnr;	/* RNR  */
-	u_long	rx_rej;	/* REJ  */
+	u_long	rx_i;		/* I    */
+	u_long	rx_rr;		/* RR   */
+	u_long	rx_rnr;		/* RNR  */
+	u_long	rx_rej;		/* REJ  */
 	u_long	rx_sabme;	/* SABME*/
-	u_long	rx_tei;	/* TEI	*/
-	u_long	rx_ui;	/* UI	*/
+	u_long	rx_tei;		/* TEI	*/
+	u_long	rx_ui;		/* UI	*/
 	u_long	rx_disc;	/* DISC */
-	u_long	rx_xid;	/* XID	*/
-	u_long	rx_dm;	/* DM	*/
-	u_long	rx_ua;	/* UA	*/
+	u_long	rx_xid;		/* XID	*/
+	u_long	rx_dm;		/* DM	*/
+	u_long	rx_ua;		/* UA	*/
 	u_long	rx_frmr;	/* FRMR	*/	
 	
-					/* errors */
+	/* errors */
 
 	u_long	err_rx_len;	/* incorrect length */
 	u_long	err_rx_badf;	/* bad frame type */
diff --git a/sys/i4b/include/i4b_global.h b/sys/i4b/include/i4b_global.h
index 4b8bfb6..9bf3025 100644
--- a/sys/i4b/include/i4b_global.h
+++ b/sys/i4b/include/i4b_global.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_global.h - i4b global include file
  *	--------------------------------------
  *
- *	$Id: i4b_global.h,v 1.23 1999/12/13 21:25:24 hm Exp $
+ *	$Id: i4b_global.h,v 1.27 2000/08/28 07:24:58 hm Exp $
  *
  * $FreeBSD$
  *
- *	last edit-date: [Mon Dec 13 21:44:17 1999]
+ *	last edit-date: [Thu Aug 24 12:38:50 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -77,6 +77,29 @@
 
 #endif /* __NetBSD__ */
 
+/*----------------*/
+/* timer handling */
+/*----------------*/
+
+#if defined(__NetBSD__)
+
+#if __NetBSD_Version__ >= 104230000
+#define START_TIMER(XHANDLE, XF, XSC, XTIME) callout_reset(&XHANDLE, XTIME, (TIMEOUT_FUNC_T)XF, (void*)XSC)
+#define STOP_TIMER(XHANDLE, XF, XSC) callout_stop(&XHANDLE)
+#else
+#define START_TIMER(XHANDLE, XF, XSC, XTIME) timeout((TIMEOUT_FUNC_T)XF, (void*)XSC, XTIME)
+#define STOP_TIMER(XHANDLE, XF, XSC)    untimeout((TIMEOUT_FUNC_T)XF, (void*)XSC)
+#endif
+
+#else
+#define START_TIMER(XHANDLE, XF, XSC, XTIME) XHANDLE = timeout((TIMEOUT_FUNC_T)XF, (void*)XSC, XTIME)
+#ifdef __FreeBSD__
+#define	STOP_TIMER(XHANDLE, XF, XSC)	untimeout((TIMEOUT_FUNC_T)XF, (void*)XSC, XHANDLE)
+#else
+#define STOP_TIMER(XHANDLE, XF, XSC)	untimeout((TIMEOUT_FUNC_T)XF, (void*)XSC)
+#endif
+#endif
+
 /*----------------------*/
 /* poll/select handling */
 /*----------------------*/
@@ -110,28 +133,19 @@
 
 /* definitions for the STATUS indications L1 -> L2 -> L3 */
 
-#define	STI_ATTACH	0	/* attach at boot time	*/
-#define	STI_L1STAT	1	/* layer 1 status	*/
-#define	STI_L2STAT	2	/* layer 2 status	*/
-#define	STI_TEIASG	3	/* TEI assignments	*/
+#define	STI_ATTACH	0	/* attach at boot time			*/
+#define	STI_L1STAT	1	/* layer 1 status			*/
+#define	STI_L2STAT	2	/* layer 2 status			*/
+#define	STI_TEIASG	3	/* TEI assignments			*/
 #define	STI_PDEACT	4	/* Layer 1 T4 expired = persistent deactivation */
-#define STI_NOL1ACC	5	/* no outgoing L1 access possible */
+#define STI_NOL1ACC	5	/* no outgoing L1 access possible	*/
 
 /* definitions for the COMMAND requests L3 -> L2 -> L1 */
 
-#define CMR_DOPEN	0	/* daemon opened /dev/i4b */
-#define CMR_DCLOSE	1	/* daemon closed /dev/i4b */
-
-/*---------------------------------------------------------------------------
- *
- *	Number of max supported passive card units
- *
- *	Teles/Creatix/Neuhaus cards have a hardware limitation
- *	as one is able to set 3 (sometimes 4) different configurations by
- *      jumpers so a maximum of 3 (4) cards per ISA bus is possible.
- *      (Note: there are multiple ISA buses on some architectures)
- *
- *---------------------------------------------------------------------------*/
-#define ISIC_MAXUNIT	3		/* max no of supported units 0..3 */
+#define CMR_DOPEN	0	/* daemon opened /dev/i4b		*/
+#define CMR_DCLOSE	1	/* daemon closed /dev/i4b		*/
+#define CMR_SETTRACE	2	/* set D-channel and B-channel trace	*/
+#define CMR_GCST	3	/* get chipset statistics		*/
+#define CMR_CCST	4	/* clear chipset statistics		*/
 
 #endif /* _I4B_GLOBAL_H_ */
diff --git a/sys/i4b/include/i4b_ioctl.h b/sys/i4b/include/i4b_ioctl.h
index c2a2460..0a498b9 100644
--- a/sys/i4b/include/i4b_ioctl.h
+++ b/sys/i4b/include/i4b_ioctl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_ioctl.h - messages kernel <--> userland
  *	-------------------------------------------
  *
- *	$Id: i4b_ioctl.h,v 1.150 1999/12/13 21:25:28 hm Exp $ 
+ *	$Id: i4b_ioctl.h,v 1.196 2000/10/09 11:17:07 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:12:16 1999]
+ *      last edit-date: [Mon Oct  9 13:17:34 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -48,8 +48,8 @@
  *	version and release number for isdn4bsd package
  *---------------------------------------------------------------------------*/
 #define	VERSION		0		/* version number	*/
-#define	REL		90		/* release number	*/
-#define STEP		1 		/* release step		*/
+#define	REL		95		/* release number	*/
+#define STEP		04		/* release step		*/
 
 /*---------------------------------------------------------------------------*
  * date/time format in i4b log messages
@@ -87,6 +87,20 @@
 #define	CTRL_NUMTYPES	5		/* number of controller types	*/
 
 /*---------------------------------------------------------------------------*
+ *	CTRL_PASSIVE: driver types
+ *---------------------------------------------------------------------------*/
+#define MAXL1UNITS      8		/* max number of units	*/
+
+#define L1DRVR_ISIC     0		/* isic - driver	*/
+#define L1DRVR_IWIC     1		/* iwic - driver	*/
+#define L1DRVR_IFPI     2		/* ifpi - driver	*/
+#define L1DRVR_IHFC     3		/* ihfc - driver	*/
+#define L1DRVR_IFPNP    4		/* ifpnp - driver	*/
+
+/* MAXL1DRVR MUST be updated when more passive drivers are added !!! */
+#define MAXL1DRVR       (L1DRVR_IFPNP + 1)
+
+/*---------------------------------------------------------------------------*
  *	card types for CTRL_PASSIVE 
  *---------------------------------------------------------------------------*/
 #define CARD_TYPEP_INVAL	(-1)	/* invalid, error		*/
@@ -114,16 +128,21 @@
 #define CARD_TYPEP_AVM_PNP	21	/* AVM FRITZ!CARD PnP		*/
 #define CARD_TYPEP_SIE_ISURF2 	22	/* Siemens I-Surf 2 PnP		*/
 #define CARD_TYPEP_ASUSCOMIPAC	23	/* Asuscom ISDNlink 128 K PnP	*/
+#define CARD_TYPEP_WINB6692	24	/* Winbond W6692 based		*/
+#define CARD_TYPEP_16_3C	25	/* Teles S0/16.3c PnP (HFC-S/SP	*/
+#define CARD_TYPEP_ACERP10	26	/* Acer ISDN P10 (HFC-S)	*/
+#define CARD_TYPEP_TELEINT_NO_1	27	/* TELEINT ISDN SPEED No. 1 (HFC-1) */
+
 /*
  * in case you add support for more cards, please update:
  *
- *	isdnd:		support.c, name_of_controller()
+ *	isdnd:		controller.c, name_of_controller()
  *	diehl/diehlctl:	main.c, listall()
  *
  * and adjust CARD_TYPEP_MAX below.
  */
 
-#define CARD_TYPEP_MAX		23	/* max type */
+#define CARD_TYPEP_MAX		27	/* max type */
 
 /*---------------------------------------------------------------------------*
  *	card types for CTRL_DAIC
@@ -162,6 +181,7 @@
 #define BDRV_IPR	2       /* IP over raw HDLC interface driver    */
 #define BDRV_ISPPP	3       /* sync Kernel PPP interface driver     */
 #define BDRV_IBC	4       /* BSD/OS point to point driver		*/
+#define BDRV_ING	5       /* NetGraph ing driver			*/
 
 /*---------------------------------------------------------------------------*
  * B channel protocol
@@ -311,6 +331,12 @@ typedef struct {
 #define  SCR_USR_PASS 2		/* screening user provided, verified & passed */
 #define  SCR_USR_FAIL 3		/* screening user provided, verified & failed */
 #define  SCR_NET      4		/* screening network provided		*/
+	int		prs_ind;/* presentation indicator		*/
+#define  PRS_NONE     0		/* no presentation indicator transmitted*/
+#define  PRS_ALLOWED  1		/* presentation allowed			*/
+#define  PRS_RESTRICT 2		/* presentation restricted		*/
+#define  PRS_NNINTERW 3		/* number not available due to interworking */
+#define  PRS_RESERVED 4		/* reserved				*/
 	char		display[DISPLAY_MAX];	/* content of display IE*/
 } msg_connect_ind_t;
 
diff --git a/sys/i4b/include/i4b_isdnq931.h b/sys/i4b/include/i4b_isdnq931.h
index 76c84f1..19ef428 100644
--- a/sys/i4b/include/i4b_isdnq931.h
+++ b/sys/i4b/include/i4b_isdnq931.h
@@ -27,11 +27,11 @@
  *	i4b_isdnq931.h - DSS1 layer 3 message types
  *	-------------------------------------------
  *
- *	$Id: i4b_isdnq931.h,v 1.6 1999/12/13 21:25:24 hm Exp $
+ *	$Id: i4b_isdnq931.h,v 1.7 2000/04/27 07:42:43 hm Exp $
  *
  * $FreeBSD$
  *
- *	last edit-date: [Mon Dec 13 21:44:28 1999]
+ *	last edit-date: [Thu Apr 27 09:46:13 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -76,7 +76,7 @@
 #define IEI_LLCOMPAT	0x7c	/* low layer compatibility		*/
 #define IEI_HLCOMPAT	0x7d	/* high layer compatibility		*/
 #define IEI_USERUSER	0x7e	/* user-user				*/
-#define IEI_ESACPE	0x7f	/* escape for extension			*/
+#define IEI_ESCAPE	0x7f	/* escape for extension			*/
 
 /* Q.932 variable length information element identifiers */
 
diff --git a/sys/i4b/include/i4b_l1l2.h b/sys/i4b/include/i4b_l1l2.h
index 704fc5d..4a8ccba 100644
--- a/sys/i4b/include/i4b_l1l2.h
+++ b/sys/i4b/include/i4b_l1l2.h
@@ -27,11 +27,11 @@
  *	i4b_l1l2.h - i4b layer 1 / layer 2 interactions
  *	---------------------------------------------------
  *
- *	$Id: i4b_l1l2.h,v 1.9 1999/12/13 21:25:24 hm Exp $
+ *	$Id: i4b_l1l2.h,v 1.11 2000/06/02 16:14:35 hm Exp $
  *
  * $FreeBSD$
  *
- *	last edit-date: [Mon Dec 13 21:44:39 1999]
+ *	last edit-date: [Fri Jun  2 14:35:03 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -67,11 +67,6 @@ struct i4b_l1l2_func
 	/* =================== */
 	
 	int	(*PH_DATA_REQ) (int, struct mbuf *, int);
-
-	/* 3rd ph_data_req parameter */
-#define MBUF_DONTFREE	0
-#define MBUF_FREE	1	
-
 	int	(*PH_ACTIVATE_REQ) (int);
 
 #define PH_Data_Req(unit, data, freeflag)	\
@@ -89,7 +84,7 @@ struct i4b_l1l2_func
 	/* L1/L2 management command and status information */
 	/* =============================================== */
 	int	(*MPH_STATUS_IND) (int, int, int);
-	int	(*MPH_COMMAND_REQ) (int, int, int);
+	int	(*MPH_COMMAND_REQ) (int, int, void *);
 
 #define MPH_Status_Ind(unit, status, parm)	\
 	((*i4b_l1l2_func.MPH_STATUS_IND)(unit, status, parm))
diff --git a/sys/i4b/include/i4b_l2l3.h b/sys/i4b/include/i4b_l2l3.h
index d25bc7b..6e0e197 100644
--- a/sys/i4b/include/i4b_l2l3.h
+++ b/sys/i4b/include/i4b_l2l3.h
@@ -27,11 +27,11 @@
  *	i4b_l2l3.h - i4b layer 2 / layer 3 interactions
  *	-----------------------------------------------
  *
- *	$Id: i4b_l2l3.h,v 1.7 1999/12/13 21:25:24 hm Exp $
+ *	$Id: i4b_l2l3.h,v 1.8 2000/06/02 16:14:35 hm Exp $
  *
  * $FreeBSD$
  *
- *	last edit-date: [Mon Dec 13 21:44:47 1999]
+ *	last edit-date: [Fri Jun  2 14:33:34 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -108,7 +108,7 @@ struct i4b_l2l3_func
 	/* Layer 3 --> Layer 2 management */
 	/* ============================== */
 
-	int	(*MDL_COMMAND_REQ) (int, int, int);	/* L3 --> L2 command */
+	int	(*MDL_COMMAND_REQ) (int, int, void *);	/* L3 --> L2 command */
 
 #define MDL_Command_Req(unit, command, parm)		\
 	((*i4b_l2l3_func.MDL_COMMAND_REQ)(unit, command, parm))
diff --git a/sys/i4b/include/i4b_l3l4.h b/sys/i4b/include/i4b_l3l4.h
index 622baf2..518aa60 100644
--- a/sys/i4b/include/i4b_l3l4.h
+++ b/sys/i4b/include/i4b_l3l4.h
@@ -27,11 +27,11 @@
  *	i4b_l3l4.h - layer 3 / layer 4 interface
  *	------------------------------------------
  *
- *	$Id: i4b_l3l4.h,v 1.27 1999/12/13 21:25:24 hm Exp $
+ *	$Id: i4b_l3l4.h,v 1.32 2000/08/24 11:48:57 hm Exp $
  *
  * $FreeBSD$
  *
- *	last edit-date: [Mon Dec 13 21:44:56 1999]
+ *	last edit-date: [Fri Jun  2 14:29:35 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -121,6 +121,12 @@ drvr_link_t *ibc_ret_linktab(int unit);
 void ibc_set_linktab(int unit, isdn_link_t *ilt);
 #endif
 
+/* global linktab functions for ING network driver */
+
+drvr_link_t *ing_ret_linktab(int unit);
+void ing_set_linktab(int unit, isdn_link_t *ilt);
+
+
 /*---------------------------------------------------------------------------*
  *	this structure describes one call/connection on one B-channel
  *	and all its parameters
@@ -150,7 +156,9 @@ typedef struct
 	
 	u_char	dst_telno[TELNO_MAX];	/* destination number	*/
 	u_char	src_telno[TELNO_MAX];	/* source number	*/
+
 	int	scr_ind;		/* screening ind for incoming call */
+	int	prs_ind;		/* presentation ind for incoming call */
 	
 	int	Q931state;		/* Q.931 state for call	*/
 	int	event;			/* event to be processed */
@@ -194,6 +202,17 @@ typedef struct
 	struct	callout_handle	T400_callout;
 	int	callouts_inited;		/* must init before use */
 #endif
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+	struct	callout	idle_timeout_handle;
+	struct	callout	T303_callout;
+	struct	callout	T305_callout;
+	struct	callout	T308_callout;
+	struct	callout	T309_callout;
+	struct	callout	T310_callout;
+	struct	callout	T313_callout;
+	struct	callout	T400_callout;
+	int	callouts_inited;		/* must init before use */
+#endif
 
 	int	idletime_state;		/* wait for idle_time begin	*/
 #define IST_IDLE	0	/* shorthold mode disabled 	*/
@@ -257,11 +276,9 @@ typedef struct
 	void	(*N_CONNECT_RESPONSE)	(unsigned int, int, int);
 	void	(*N_DISCONNECT_REQUEST)	(unsigned int, int);
 	void	(*N_ALERT_REQUEST)	(unsigned int);	
-	void    (*N_SET_TRACE) 		(int unit, int val);
-	int     (*N_GET_TRACE) 		(int unit);
 	int     (*N_DOWNLOAD)		(int unit, int numprotos, struct isdn_dr_prot *protocols);
 	int     (*N_DIAGNOSTICS)	(int unit, struct isdn_diagnostic_request*);
-	void	(*N_MGMT_COMMAND)	(int unit, int cmd, int parm);
+	void	(*N_MGMT_COMMAND)	(int unit, int cmd, void *);
 } ctrl_desc_t;
 
 extern ctrl_desc_t ctrl_desc[MAX_CONTROLLERS];
diff --git a/sys/i4b/include/i4b_mbuf.h b/sys/i4b/include/i4b_mbuf.h
index b7d8984..b1b46c0 100644
--- a/sys/i4b/include/i4b_mbuf.h
+++ b/sys/i4b/include/i4b_mbuf.h
@@ -27,17 +27,21 @@
  *	i4b - mbuf handling support routines
  *	--------------------------------------
  *
- *	$Id: i4b_mbuf.h,v 1.8 1999/12/13 21:25:24 hm Exp $
+ *	$Id: i4b_mbuf.h,v 1.9 2000/03/07 14:21:18 hm Exp $
  *
  * $FreeBSD$
  *
- *	last edit-date: [Mon Dec 13 21:45:05 1999]
+ *	last edit-date: [Fri Mar  3 14:30:09 2000]
  *
  *---------------------------------------------------------------------------*/
 
 #ifndef _I4B_MBUF_H_
 #define _I4B_MBUF_H_
 
+/* layer 1 / layer 2 comunication: 3rd ph_data_req parameter */
+#define MBUF_DONTFREE	0
+#define MBUF_FREE	1	
+
 #define IF_QEMPTY(ifq)	((ifq)->ifq_len == 0)
 
 struct mbuf *i4b_Dgetmbuf( int );
diff --git a/sys/i4b/include/i4b_tel_ioctl.h b/sys/i4b/include/i4b_tel_ioctl.h
index 2cc9e15..0f955af 100644
--- a/sys/i4b/include/i4b_tel_ioctl.h
+++ b/sys/i4b/include/i4b_tel_ioctl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000  Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_tel_ioctl.h telephony interface ioctls
  *	------------------------------------------
  *
- *	$Id: i4b_tel_ioctl.h,v 1.11 1999/12/13 21:25:28 hm Exp $ 
+ *	$Id: i4b_tel_ioctl.h,v 1.13 2000/01/12 14:49:36 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:07:18 1999]
+ *      last edit-date: [Wed Jan 12 15:47:11 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -62,6 +62,19 @@
 
 #define I4B_TEL_VR_REQ		_IOR('A', 3, msg_vr_req_t)
 
+/*---------------------------------------------------------------------------*
+ *	send tones out of the tel interface
+ *---------------------------------------------------------------------------*/
+
+#define I4B_TEL_MAXTONES 32
+
+struct i4b_tel_tones {
+	int frequency[I4B_TEL_MAXTONES];
+	int duration[I4B_TEL_MAXTONES];
+};
+
+#define I4B_TEL_TONES		_IOR('A', 4, struct i4b_tel_tones)
+
 /*===========================================================================*
  *	/dev/i4bteld<n> devices (dialer interface)
  *===========================================================================*/
diff --git a/sys/i4b/include/i4b_trace.h b/sys/i4b/include/i4b_trace.h
index fa1a9a6..24229ec 100644
--- a/sys/i4b/include/i4b_trace.h
+++ b/sys/i4b/include/i4b_trace.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_trace.h - header file for trace data read device
  *	----------------------------------------------------
  *
- *	$Id: i4b_trace.h,v 1.7 1999/12/13 21:25:28 hm Exp $ 
+ *	$Id: i4b_trace.h,v 1.8 2000/03/08 16:08:18 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:07:25 1999]
+ *      last edit-date: [Wed Mar  8 16:41:43 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -70,8 +70,7 @@ typedef struct {
  *	get/set current trace flag settings
  *---------------------------------------------------------------------------*/
 	
-#define	I4B_TRC_GET	_IOR('T', 0, int)	/* get trace settings	*/
-#define	I4B_TRC_SET	_IOW('T', 1, int)	/* set trace settings	*/
+#define	I4B_TRC_SET	_IOW('T', 0, int)	/* set trace settings	*/
 
 #define TRACE_OFF       0x00		/* tracing off 		*/
 #define TRACE_I		0x01		/* trace L1 INFO's on	*/
@@ -87,7 +86,7 @@ typedef struct {
 	int txflags;		/* d and/or b channel	*/
 } i4b_trace_setupa_t;
 
-#define	I4B_TRC_SETA	_IOW('T', 2, i4b_trace_setupa_t) /* set analyze mode */
-#define	I4B_TRC_RESETA	_IOW('T', 3, int)	/* reset analyze mode	*/
+#define	I4B_TRC_SETA	_IOW('T', 1, i4b_trace_setupa_t) /* set analyze mode */
+#define	I4B_TRC_RESETA	_IOW('T', 2, int)	/* reset analyze mode	*/
 
 #endif /* _I4B_TRACE_H_ */
diff --git a/sys/i4b/layer2/i4b_iframe.c b/sys/i4b/layer2/i4b_iframe.c
index 5c4851d..aedd2a0 100644
--- a/sys/i4b/layer2/i4b_iframe.c
+++ b/sys/i4b/layer2/i4b_iframe.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_iframe.c - i frame handling routines
  *	------------------------------------------
  *
- *	$Id: i4b_iframe.c,v 1.22 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_iframe.c,v 1.25 2000/08/24 11:48:57 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:03:16 1999]
+ *      last edit-date: [Thu Aug 24 12:49:18 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -43,18 +43,16 @@
 #if NI4BQ921 > 0
 
 #include <sys/param.h>
-
-#if defined(__FreeBSD__)
-#else
-#include <sys/ioctl.h>
-#endif
-
 #include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -98,7 +96,7 @@ i4b_rxd_i_frame(int unit, struct mbuf *m)
 	if((l2sc->Q921_state != ST_MULTIFR) && (l2sc->Q921_state != ST_TIMREC))
 	{
 		i4b_Dfreembuf(m);
-		DBGL2(L2_I_ERR, "i4b_rxd_i_frame", ("ERROR, state != (MF || TR)!\n"));
+		NDBGL2(L2_I_ERR, "ERROR, state != (MF || TR)!");
 		return;
 	}
 
@@ -223,12 +221,12 @@ i4b_i_frame_queued_up(l2_softc_t *l2sc)
 	{
 		if(l2sc->peer_busy)
 		{
-			DBGL2(L2_I_MSG, "i4b_i_frame_queued_up", ("regen IFQUP, cause: peer busy!\n"));
+			NDBGL2(L2_I_MSG, "regen IFQUP, cause: peer busy!");
 		}
 
 		if(l2sc->vs == ((l2sc->va + MAX_K_VALUE) & 127))
 		{
-			DBGL2(L2_I_MSG, "i4b_i_frame_queued_up", ("regen IFQUP, cause: vs=va+k!\n"));
+			NDBGL2(L2_I_MSG, "regen IFQUP, cause: vs=va+k!");
 		}	
 
 		/*
@@ -238,13 +236,8 @@ i4b_i_frame_queued_up(l2_softc_t *l2sc)
 
 		if(!(IF_QEMPTY(&l2sc->i_queue)))
 		{
-			DBGL2(L2_I_MSG, "i4b_i_frame_queued_up", ("re-scheduling IFQU call!\n"));
-
-#if defined(__FreeBSD__)
-			l2sc->IFQU_callout = timeout((TIMEOUT_FUNC_T)i4b_i_frame_queued_up, (void *)l2sc, IFQU_DLY);
-#else
-			timeout((TIMEOUT_FUNC_T)i4b_i_frame_queued_up, (void *)l2sc, IFQU_DLY);
-#endif			
+			NDBGL2(L2_I_MSG, "re-scheduling IFQU call!");
+			START_TIMER(l2sc->IFQU_callout, i4b_i_frame_queued_up, l2sc, IFQU_DLY);
 		}
 		CRIT_END;
 		return;
@@ -254,7 +247,7 @@ i4b_i_frame_queued_up(l2_softc_t *l2sc)
 
 	if(!m)
 	{
-		DBGL2(L2_I_ERR, "i4b_i_frame_queued_up", ("ERROR, mbuf NULL after IF_DEQUEUE\n"));
+		NDBGL2(L2_I_ERR, "ERROR, mbuf NULL after IF_DEQUEUE");
 		CRIT_END;
 		return;
 	}
@@ -275,7 +268,7 @@ i4b_i_frame_queued_up(l2_softc_t *l2sc)
 	
 	if(l2sc->ua_num != UA_EMPTY)	/* failsafe */
 	{
-		DBGL2(L2_I_ERR, "i4b_i_frame_queued_up", ("ERROR, l2sc->ua_num: %d != UA_EMPTY\n", l2sc->ua_num));
+		NDBGL2(L2_I_ERR, "ERROR, l2sc->ua_num: %d != UA_EMPTY", l2sc->ua_num);
 		i4b_print_l2var(l2sc);
 		i4b_Dfreembuf(l2sc->ua_frame);
 	}
diff --git a/sys/i4b/layer2/i4b_l2.c b/sys/i4b/layer2/i4b_l2.c
index 9ecbe41..6f76196 100644
--- a/sys/i4b/layer2/i4b_l2.c
+++ b/sys/i4b/layer2/i4b_l2.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *      i4b_l2.c - ISDN layer 2 (Q.921)
  *	-------------------------------
  *
- *	$Id: i4b_l2.c,v 1.30 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_l2.c,v 1.35 2000/08/24 11:48:57 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:03:23 1999]
+ *      last edit-date: [Thu Aug 24 13:40:35 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -43,17 +43,16 @@
 #if NI4BQ921 > 0
 
 #include <sys/param.h>
-
-#if defined(__FreeBSD__)
-#else
-#include <sys/ioctl.h>
-#endif
-
+#include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -78,11 +77,10 @@ int i4b_dl_release_cnf(int);
 int i4b_dl_data_ind(int, struct mbuf *);
 int i4b_dl_unit_data_ind(int, struct mbuf *);
 
-static int i4b_mdl_command_req(int, int, int);
+static int i4b_mdl_command_req(int, int, void *);
 
 /* from layer 2 */
 
-extern int i4b_mdl_attach_ind(int, int);
 extern int i4b_mdl_status_ind(int, int, int);
 
 /* this layers debug level */
@@ -113,7 +111,7 @@ struct i4b_l2l3_func i4b_l2l3_func = {
 
 	/* Layer 3  --> Layer 2 management */
 	
-	(int (*)(int, int, int))		i4b_mdl_command_req	
+	(int (*)(int, int, void *))		i4b_mdl_command_req	
 };
 
 /*---------------------------------------------------------------------------*
@@ -123,7 +121,7 @@ int i4b_dl_establish_req(int unit)
 {
 	l2_softc_t *l2sc = &l2_softc[unit];
 	
-	DBGL2(L2_PRIM, "DL-ESTABLISH-REQ", ("unit %d\n",unit));
+	NDBGL2(L2_PRIM, "unit %d",unit);
 	i4b_l1_activate(l2sc);
 	i4b_next_l2state(l2sc, EV_DLESTRQ);
 	return(0);
@@ -136,7 +134,7 @@ int i4b_dl_release_req(int unit)
 {
 	l2_softc_t *l2sc = &l2_softc[unit];
 
-	DBGL2(L2_PRIM, "DL-RELEASE-REQ", ("unit %d\n",unit));	
+	NDBGL2(L2_PRIM, "unit %d",unit);	
 	i4b_next_l2state(l2sc, EV_DLRELRQ);
 	return(0);	
 }
@@ -147,7 +145,7 @@ int i4b_dl_release_req(int unit)
 int i4b_dl_unit_data_req(int unit, struct mbuf *m)
 {
 #ifdef NOTDEF
-	DBGL2(L2_PRIM, "DL-UNIT-DATA-REQ", ("unit %d\n",unit));
+	NDBGL2(L2_PRIM, "unit %d",unit);
 #endif
 	return(0);
 }
@@ -160,7 +158,7 @@ int i4b_dl_data_req(int unit, struct mbuf *m)
 	l2_softc_t *l2sc = &l2_softc[unit];
 
 #ifdef NOTDEF
-	DBGL2(L2_PRIM, "DL-DATA-REQ", ("unit %d\n",unit));
+	NDBGL2(L2_PRIM, "unit %d",unit);
 #endif
 	switch(l2sc->Q921_state)
 	{
@@ -170,7 +168,7 @@ int i4b_dl_data_req(int unit, struct mbuf *m)
 		
 		        if(IF_QFULL(&l2sc->i_queue))
 		        {
-		        	DBGL2(L2_ERROR, "i4b_dl_data_req", ("i_queue full!!\n"));
+		        	NDBGL2(L2_ERROR, "i_queue full!!");
 		        	i4b_Dfreembuf(m);
 		        }
 		        else
@@ -186,7 +184,7 @@ int i4b_dl_data_req(int unit, struct mbuf *m)
 			break;
 			
 		default:
-			DBGL2(L2_ERROR, "i4b_dl_data_req", ("unit %d ERROR in state [%s], freeing mbuf\n", unit, i4b_print_l2state(l2sc)));
+			NDBGL2(L2_ERROR, "unit %d ERROR in state [%s], freeing mbuf", unit, i4b_print_l2state(l2sc));
 			i4b_Dfreembuf(m);
 			break;
 	}		
@@ -201,7 +199,7 @@ i4b_ph_activate_ind(int unit)
 {
 	l2_softc_t *l2sc = &l2_softc[unit];
 
-	DBGL1(L1_PRIM, "PH-ACTIVATE-IND", ("unit %d\n",unit));
+	NDBGL1(L1_PRIM, "unit %d",unit);
 	l2sc->ph_active = PH_ACTIVE;
 	return(0);
 }
@@ -214,7 +212,7 @@ i4b_ph_deactivate_ind(int unit)
 {
 	l2_softc_t *l2sc = &l2_softc[unit];
 
-	DBGL1(L1_PRIM, "PH-DEACTIVATE-IND", ("unit %d\n",unit));
+	NDBGL1(L1_PRIM, "unit %d",unit);
 	l2sc->ph_active = PH_INACTIVE;
 	return(0);
 }
@@ -275,7 +273,7 @@ i4b_mph_status_ind(int unit, int status, int parm)
 	
 	CRIT_BEG;
 
-	DBGL1(L1_PRIM, "MPH-STATUS-IND", ("unit %d, status=%d, parm=%d\n", unit, status, parm));
+	NDBGL1(L1_PRIM, "unit %d, status=%d, parm=%d", unit, status, parm);
 
 	switch(status)
 	{
@@ -293,6 +291,14 @@ i4b_mph_status_ind(int unit, int status, int parm)
 			callout_handle_init(&l2sc->T203_callout);
 			callout_handle_init(&l2sc->IFQU_callout);
 #endif
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+			/* initialize the callout handles for timeout routines */
+			callout_init(&l2sc->T200_callout);
+			callout_init(&l2sc->T202_callout);
+			callout_init(&l2sc->T203_callout);
+			callout_init(&l2sc->IFQU_callout);
+#endif
+
 			break;
 
 		case STI_L1STAT:	/* state of layer 1 */
@@ -302,7 +308,7 @@ i4b_mph_status_ind(int unit, int status, int parm)
 /*XXX*/			if((l2sc->Q921_state >= ST_AW_EST) &&
 			   (l2sc->Q921_state <= ST_TIMREC))
 			{
-				DBGL2(L2_ERROR, "i4b_mph_status_ind", ("unit %d, persistent deactivation!\n", unit));
+				NDBGL2(L2_ERROR, "unit %d, persistent deactivation!", unit);
 				i4b_l2_unit_init(unit);
 			}
 			else
@@ -313,11 +319,11 @@ i4b_mph_status_ind(int unit, int status, int parm)
 
 		case STI_NOL1ACC:
 			i4b_l2_unit_init(unit);
-			DBGL2(L2_ERROR, "i4b_mph_status_ind", ("unit %d, cannot access S0 bus!\n", unit));
+			NDBGL2(L2_ERROR, "unit %d, cannot access S0 bus!", unit);
 			break;
 			
 		default:
-			DBGL2(L2_ERROR, "i4b_mph_status_ind", ("ERROR, unit %d, unknown status message!\n", unit));
+			NDBGL2(L2_ERROR, "ERROR, unit %d, unknown status message!", unit);
 			break;
 	}
 	
@@ -332,9 +338,9 @@ i4b_mph_status_ind(int unit, int status, int parm)
 /*---------------------------------------------------------------------------*
  *	MDL_COMMAND_REQ from layer 3
  *---------------------------------------------------------------------------*/
-int i4b_mdl_command_req(int unit, int command, int parm)
+int i4b_mdl_command_req(int unit, int command, void * parm)
 {
-	DBGL2(L2_PRIM, "MDL-COMMAND-REQ", ("unit %d, command=%d, parm=%d\n", unit, command, parm));
+	NDBGL2(L2_PRIM, "unit %d, command=%d, parm=%d", unit, command, (unsigned int)parm);
 
 	switch(command)
 	{
@@ -356,7 +362,7 @@ i4b_ph_data_ind(int unit, struct mbuf *m)
 {
 	l2_softc_t *l2sc = &l2_softc[unit];
 #ifdef NOTDEF
-	DBGL1(L1_PRIM, "PH-DATA-IND", ("unit %d\n", unit));
+	NDBGL1(L1_PRIM, "unit %d", unit);
 #endif
 	u_char *ptr = m->m_data;
 
@@ -365,7 +371,7 @@ i4b_ph_data_ind(int unit, struct mbuf *m)
 		if(m->m_len < 4)	/* 6 oct - 2 chksum oct */
 		{
 			l2sc->stat.err_rx_len++;
-			DBGL2(L2_ERROR, "i4b_ph_data_ind", ("ERROR, I-frame < 6 octetts!\n"));
+			NDBGL2(L2_ERROR, "ERROR, I-frame < 6 octetts!");
 			i4b_Dfreembuf(m);
 			return(0);
 		}
@@ -376,7 +382,7 @@ i4b_ph_data_ind(int unit, struct mbuf *m)
 		if(m->m_len < 4)	/* 6 oct - 2 chksum oct */
 		{
 			l2sc->stat.err_rx_len++;
-			DBGL2(L2_ERROR, "i4b_ph_data_ind", ("ERROR, S-frame < 6 octetts!\n"));
+			NDBGL2(L2_ERROR, "ERROR, S-frame < 6 octetts!");
 			i4b_Dfreembuf(m);
 			return(0);
 		}
@@ -387,7 +393,7 @@ i4b_ph_data_ind(int unit, struct mbuf *m)
 		if(m->m_len < 3)	/* 5 oct - 2 chksum oct */
 		{
 			l2sc->stat.err_rx_len++;
-			DBGL2(L2_ERROR, "i4b_ph_data_ind", ("ERROR, U-frame < 5 octetts!\n"));
+			NDBGL2(L2_ERROR, "ERROR, U-frame < 5 octetts!");
 			i4b_Dfreembuf(m);
 			return(0);
 		}
@@ -396,7 +402,7 @@ i4b_ph_data_ind(int unit, struct mbuf *m)
 	else
 	{
 		l2sc->stat.err_rx_badf++;
-		DBGL2(L2_ERROR, "i4b_ph_data_ind", ("ERROR, bad frame rx'd - "));
+		NDBGL2(L2_ERROR, "ERROR, bad frame rx'd - ");
 		i4b_print_frame(m->m_len, m->m_data);
 		i4b_Dfreembuf(m);
 	}
diff --git a/sys/i4b/layer2/i4b_l2.h b/sys/i4b/layer2/i4b_l2.h
index b00c386..5277a06 100644
--- a/sys/i4b/layer2/i4b_l2.h
+++ b/sys/i4b/layer2/i4b_l2.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_l2.h - ISDN layer 2 (Q.921) definitions
  *	---------------------------------------------
  *
- *	$Id: i4b_l2.h,v 1.20 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_l2.h,v 1.23 2000/08/24 11:48:58 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:03:29 1999]
+ *      last edit-date: [Sat Mar 18 10:28:22 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -69,6 +69,12 @@ typedef struct {
 	struct	callout_handle T203_callout;
 	struct	callout_handle IFQU_callout;	
 #endif
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+	struct	callout T200_callout;
+	struct	callout T202_callout;
+	struct	callout T203_callout;
+	struct	callout IFQU_callout;	
+#endif
 
 /*
  * i4b_iframe.c, i4b_i_frame_queued_up(): value of IFQU_DLY
@@ -314,7 +320,6 @@ extern int i4b_l2_nr_ok ( int nr, int va, int vs );
 extern void i4b_make_rand_ri ( l2_softc_t *l2sc );
 extern void i4b_mdl_assign_ind ( l2_softc_t *l2sc );
 extern void i4b_mdl_error_ind ( l2_softc_t *l2sc, char *where, int errorcode );
-extern int i4b_mph_attach_ind ( int unit, int type );
 extern int i4b_mph_status_ind ( int unit, int status, int parm );
 extern void i4b_next_l2state ( l2_softc_t *l2sc, int event );
 extern void i4b_nr_error_recovery ( l2_softc_t *l2sc );
diff --git a/sys/i4b/layer2/i4b_l2fsm.c b/sys/i4b/layer2/i4b_l2fsm.c
index 9c6d513..51912ab 100644
--- a/sys/i4b/layer2/i4b_l2fsm.c
+++ b/sys/i4b/layer2/i4b_l2fsm.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_l2fsm.c - layer 2 FSM
  *	-------------------------
  *
- *	$Id: i4b_l2fsm.c,v 1.17 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_l2fsm.c,v 1.22 2000/08/24 11:48:58 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:03:36 1999]
+ *      last edit-date: [Tue May 30 15:48:20 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -43,17 +43,16 @@
 #if NI4BQ921 > 0
 
 #include <sys/param.h>
-
-#if defined(__FreeBSD__)
-#else
-#include <sys/ioctl.h>
-#endif
-
+#include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -71,8 +70,9 @@
 #include <i4b/layer2/i4b_l2.h>
 #include <i4b/layer2/i4b_l2fsm.h>
 
-l2_softc_t l2_softc[ISIC_MAXUNIT];
+l2_softc_t l2_softc[MAXL1UNITS];
 
+#if DO_I4B_DEBUG
 static char *l2state_text[N_STATES] = {
 	"ST_TEI_UNAS",
 	"ST_ASG_AW_TEI",
@@ -111,6 +111,7 @@ static char *l2event_text[N_EVENTS] = {
 	"EV_RXFRMR",
 	"Illegal Event"
 };
+#endif
 
 static void F_TU01 __P((l2_softc_t *));
 static void F_TU03 __P((l2_softc_t *));
@@ -193,7 +194,7 @@ static void F_NCNA __P((l2_softc_t *));
 static void
 F_ILL(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_ERR, "F_ILL", ("FSM function F_ILL executing\n"));
+	NDBGL2(L2_F_ERR, "FSM function F_ILL executing");
 }
 
 /*---------------------------------------------------------------------------*
@@ -202,7 +203,7 @@ F_ILL(l2_softc_t *l2sc)
 static void
 F_NCNA(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_NCNA", ("FSM function F_NCNA executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_NCNA executing");
 }
 
 /*---------------------------------------------------------------------------*
@@ -261,10 +262,10 @@ void i4b_next_l2state(l2_softc_t *l2sc, int event)
 	
 	if(newstate != ST_SUBSET)
 	{	/* state function does NOT set new state */
-		DBGL2(L2_F_MSG, "i4b_next_l2state", ("FSM event [%s]: [%s/%d => %s/%d]\n",
+		NDBGL2(L2_F_MSG, "FSM event [%s]: [%s/%d => %s/%d]",
 				l2event_text[event],
                                 l2state_text[currstate], currstate,
-                                l2state_text[newstate], newstate));
+                                l2state_text[newstate], newstate);
         }
 
 	/* execute state transition function */
@@ -272,9 +273,9 @@ void i4b_next_l2state(l2_softc_t *l2sc, int event)
 
 	if(newstate == ST_SUBSET)
 	{	/* state function DOES set new state */
-		DBGL2(L2_F_MSG, "i4b_next_l2state", ("FSM S-event [%s]: [%s => %s]\n", l2event_text[event],
+		NDBGL2(L2_F_MSG, "FSM S-event [%s]: [%s => %s]", l2event_text[event],
                                            l2state_text[currstate],
-                                           l2state_text[l2sc->Q921_state]));
+                                           l2state_text[l2sc->Q921_state]);
         }
         
 	/* check for illegal new state */
@@ -282,9 +283,9 @@ void i4b_next_l2state(l2_softc_t *l2sc, int event)
 	if(newstate == ST_ILL)
 	{
 		newstate = currstate;
-		DBGL2(L2_F_ERR, "i4b_next_l2state", ("FSM illegal state, state = %s, event = %s!\n",
+		NDBGL2(L2_F_ERR, "FSM illegal state, state = %s, event = %s!",
                                 l2state_text[currstate],
-				l2event_text[event]));
+				l2event_text[event]);
 	}
 
 	/* check if state machine function has to set new state */
@@ -294,7 +295,7 @@ void i4b_next_l2state(l2_softc_t *l2sc, int event)
 
 	if(l2sc->postfsmfunc != NULL)
 	{
-		DBGL2(L2_F_MSG, "i4b_next_l2state", ("FSM executing postfsmfunc!\n"));
+		NDBGL2(L2_F_MSG, "FSM executing postfsmfunc!");
 		/* try to avoid an endless loop */
 		savpostfsmfunc = l2sc->postfsmfunc;
 		l2sc->postfsmfunc = NULL;
@@ -302,6 +303,7 @@ void i4b_next_l2state(l2_softc_t *l2sc, int event)
         }
 }
 
+#if DO_I4B_DEBUG
 /*---------------------------------------------------------------------------*
  *	return pointer to current state description
  *---------------------------------------------------------------------------*/	
@@ -309,6 +311,7 @@ char *i4b_print_l2state(l2_softc_t *l2sc)
 {
 	return((char *) l2state_text[l2sc->Q921_state]);
 }
+#endif
 
 /*---------------------------------------------------------------------------*
  *	FSM state ST_TEI_UNAS event dl establish request
@@ -316,7 +319,7 @@ char *i4b_print_l2state(l2_softc_t *l2sc)
 static void
 F_TU01(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TU01", ("FSM function F_TU01 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TU01 executing");
 	i4b_mdl_assign_ind(l2sc);
 }
 
@@ -326,7 +329,7 @@ F_TU01(l2_softc_t *l2sc)
 static void
 F_TU03(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TU03", ("FSM function F_TU03 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TU03 executing");
 }
 
 /*---------------------------------------------------------------------------*
@@ -335,7 +338,7 @@ F_TU03(l2_softc_t *l2sc)
 static void
 F_TA03(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TA03", ("FSM function F_TA03 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TA03 executing");
 }
 
 /*---------------------------------------------------------------------------*
@@ -344,7 +347,7 @@ F_TA03(l2_softc_t *l2sc)
 static void
 F_TA04(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TA04", ("FSM function F_TA04 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TA04 executing");
 }
 
 /*---------------------------------------------------------------------------*
@@ -353,7 +356,7 @@ F_TA04(l2_softc_t *l2sc)
 static void
 F_TA05(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TA05", ("FSM function F_TA05 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TA05 executing");
 }
 
 /*---------------------------------------------------------------------------*
@@ -362,7 +365,7 @@ F_TA05(l2_softc_t *l2sc)
 static void
 F_TE03(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TE03", ("FSM function F_TE03 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TE03 executing");
 	i4b_establish_data_link(l2sc);
 	l2sc->l3initiated = 1;
 }
@@ -373,7 +376,7 @@ F_TE03(l2_softc_t *l2sc)
 static void
 F_TE04(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TE04", ("FSM function F_TE04 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TE04 executing");
 	l2sc->postfsmarg = l2sc->unit;
 	l2sc->postfsmfunc = DL_Rel_Ind_A;
 }
@@ -384,7 +387,7 @@ F_TE04(l2_softc_t *l2sc)
 static void
 F_TE05(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TE05", ("FSM function F_TE05 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TE05 executing");
 	l2sc->postfsmarg = l2sc->unit;
 	l2sc->postfsmfunc = DL_Rel_Ind_A;
 }
@@ -395,7 +398,7 @@ F_TE05(l2_softc_t *l2sc)
 static void
 F_T01(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_T01", ("FSM function F_T01 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_T01 executing");
 	i4b_establish_data_link(l2sc);
 	l2sc->l3initiated = 1;
 }
@@ -406,7 +409,7 @@ F_T01(l2_softc_t *l2sc)
 static void
 F_T05(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_T05", ("FSM function F_T05 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_T05 executing");
 }
 
 /*---------------------------------------------------------------------------*
@@ -415,7 +418,7 @@ F_T05(l2_softc_t *l2sc)
 static void
 F_T06(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_T06", ("FSM function F_T06 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_T06 executing");
 /*XXX*/	i4b_mdl_assign_ind(l2sc);
 }
 
@@ -425,7 +428,7 @@ F_T06(l2_softc_t *l2sc)
 static void
 F_T07(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_T07", ("FSM function F_T07 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_T07 executing");
 
 /* XXX */
 #ifdef NOTDEF
@@ -461,7 +464,7 @@ F_T07(l2_softc_t *l2sc)
 static void
 F_T08(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_T08", ("FSM function F_T08 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_T08 executing");
 	MDL_Status_Ind(l2sc->unit, STI_L2STAT, LAYER_IDLE);
 	i4b_tx_ua(l2sc, l2sc->rxd_PF);
 }
@@ -472,7 +475,7 @@ F_T08(l2_softc_t *l2sc)
 static void
 F_T09(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_T09", ("FSM function F_T09 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_T09 executing");
 	i4b_mdl_error_ind(l2sc, "F_T09", MDL_ERR_C);
 	i4b_mdl_error_ind(l2sc, "F_T09", MDL_ERR_D);	
 }
@@ -483,7 +486,7 @@ F_T09(l2_softc_t *l2sc)
 static void
 F_T10(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_T10", ("FSM function F_T10 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_T10 executing");
 
 	if(l2sc->rxd_PF)
 	{
@@ -512,7 +515,7 @@ F_T10(l2_softc_t *l2sc)
 static void
 F_T13(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_T13", ("FSM function F_T13 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_T13 executing");
 	l2sc->postfsmarg = l2sc->unit;
 	l2sc->postfsmfunc = DL_Rel_Cnf_A;
 }
@@ -523,7 +526,7 @@ F_T13(l2_softc_t *l2sc)
 static void
 F_AE01(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_AE01", ("FSM function F_AE01 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_AE01 executing");
 
 	i4b_Dcleanifq(&l2sc->i_queue);
 	
@@ -536,7 +539,7 @@ F_AE01(l2_softc_t *l2sc)
 static void
 F_AE05(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_AE05", ("FSM function F_AE05 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_AE05 executing");
 
 	i4b_Dcleanifq(&l2sc->i_queue);	
 
@@ -552,7 +555,7 @@ F_AE05(l2_softc_t *l2sc)
 static void
 F_AE06(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_AE06", ("FSM function F_AE06 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_AE06 executing");
 
 	i4b_Dcleanifq(&l2sc->i_queue);	
 
@@ -570,7 +573,7 @@ F_AE06(l2_softc_t *l2sc)
 static void
 F_AE07(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_AE07", ("FSM function F_AE07 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_AE07 executing");
 	MDL_Status_Ind(l2sc->unit, STI_L2STAT, LAYER_ACTIVE);
 	i4b_tx_ua(l2sc, l2sc->rxd_PF);
 }
@@ -581,7 +584,7 @@ F_AE07(l2_softc_t *l2sc)
 static void
 F_AE08(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_AE08", ("FSM function F_AE08 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_AE08 executing");
 	i4b_tx_dm(l2sc, l2sc->rxd_PF);
 }
 
@@ -591,7 +594,7 @@ F_AE08(l2_softc_t *l2sc)
 static void
 F_AE09(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_AE09", ("FSM function F_AE09 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_AE09 executing");
 
 	if(l2sc->rxd_PF == 0)
 	{
@@ -635,7 +638,7 @@ F_AE09(l2_softc_t *l2sc)
 static void
 F_AE10(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_AE10", ("FSM function F_AE10 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_AE10 executing");
 
 	if(l2sc->rxd_PF == 0)
 	{
@@ -660,7 +663,7 @@ F_AE10(l2_softc_t *l2sc)
 static void
 F_AE11(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_AE11", ("FSM function F_AE11 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_AE11 executing");
 
 	if(l2sc->RC >= N200)
 	{
@@ -691,7 +694,7 @@ F_AE11(l2_softc_t *l2sc)
 static void
 F_AE12(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_AE12", ("FSM function F_AE12 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_AE12 executing");
 
 	if(l2sc->l3initiated == 0)
 	{
@@ -705,7 +708,7 @@ F_AE12(l2_softc_t *l2sc)
 static void
 F_AR05(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_AR05", ("FSM function F_AR05 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_AR05 executing");
 
 	l2sc->postfsmarg = l2sc->unit;
 	l2sc->postfsmfunc = DL_Rel_Cnf_A;
@@ -719,7 +722,7 @@ F_AR05(l2_softc_t *l2sc)
 static void
 F_AR06(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_AR06", ("FSM function F_AR06 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_AR06 executing");
 
 	l2sc->postfsmarg = l2sc->unit;
 	l2sc->postfsmfunc = DL_Rel_Cnf_A;
@@ -735,7 +738,7 @@ F_AR06(l2_softc_t *l2sc)
 static void
 F_AR07(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_AR07", ("FSM function F_AR07 executing\n"));	
+	NDBGL2(L2_F_MSG, "FSM function F_AR07 executing");	
 	i4b_tx_dm(l2sc, l2sc->rxd_PF);
 }
 
@@ -745,7 +748,7 @@ F_AR07(l2_softc_t *l2sc)
 static void
 F_AR08(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_AR08", ("FSM function F_AR08 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_AR08 executing");
 	MDL_Status_Ind(l2sc->unit, STI_L2STAT, LAYER_IDLE);
 	i4b_tx_ua(l2sc, l2sc->rxd_PF);	
 }
@@ -756,7 +759,7 @@ F_AR08(l2_softc_t *l2sc)
 static void
 F_AR09(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_AR09", ("FSM function F_AR09 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_AR09 executing");
 
 	if(l2sc->rxd_PF)
 	{
@@ -781,7 +784,7 @@ F_AR09(l2_softc_t *l2sc)
 static void
 F_AR10(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_AR10", ("FSM function F_AR10 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_AR10 executing");
 
 	if(l2sc->rxd_PF)
 	{
@@ -804,7 +807,7 @@ F_AR10(l2_softc_t *l2sc)
 static void
 F_AR11(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_AR11", ("FSM function F_AR11 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_AR11 executing");
 
 	if(l2sc->RC >= N200)
 	{
@@ -833,7 +836,7 @@ F_AR11(l2_softc_t *l2sc)
 static void
 F_MF01(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_MF01", ("FSM function F_MF01 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_MF01 executing");
 
 	i4b_Dcleanifq(&l2sc->i_queue);
 
@@ -848,7 +851,7 @@ F_MF01(l2_softc_t *l2sc)
 static void
 F_MF05(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_MF05", ("FSM function F_MF05 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_MF05 executing");
 
 	i4b_Dcleanifq(&l2sc->i_queue);
 	
@@ -865,7 +868,7 @@ F_MF05(l2_softc_t *l2sc)
 static void
 F_MF06(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_MF06", ("FSM function F_MF06 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_MF06 executing");
 
 	i4b_Dcleanifq(&l2sc->i_queue);
 	
@@ -884,7 +887,7 @@ F_MF06(l2_softc_t *l2sc)
 static void
 F_MF07(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_MF07", ("FSM function F_MF07 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_MF07 executing");
 
 	i4b_clear_exception_conditions(l2sc);
 
@@ -916,7 +919,7 @@ F_MF07(l2_softc_t *l2sc)
 static void
 F_MF08(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_MF08", ("FSM function F_MF08 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_MF08 executing");
 
 	i4b_Dcleanifq(&l2sc->i_queue);
 	MDL_Status_Ind(l2sc->unit, STI_L2STAT, LAYER_IDLE);
@@ -935,7 +938,7 @@ F_MF08(l2_softc_t *l2sc)
 static void
 F_MF09(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_MF09", ("FSM function F_MF09 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_MF09 executing");
 	if(l2sc->rxd_PF)
 		i4b_mdl_error_ind(l2sc, "F_MF09", MDL_ERR_C);
 	else
@@ -948,7 +951,7 @@ F_MF09(l2_softc_t *l2sc)
 static void
 F_MF10(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_MF10", ("FSM function F_MF10 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_MF10 executing");
 
 	if(l2sc->rxd_PF)
 	{
@@ -974,7 +977,7 @@ F_MF10(l2_softc_t *l2sc)
 static void
 F_MF11(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_MF11", ("FSM function F_MF11 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_MF11 executing");
 
 	l2sc->RC = 0;
 
@@ -989,7 +992,7 @@ F_MF11(l2_softc_t *l2sc)
 static void
 F_MF12(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_MF12", ("FSM function F_MF12 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_MF12 executing");
 
 	i4b_i_frame_queued_up(l2sc);
 }
@@ -1000,7 +1003,7 @@ F_MF12(l2_softc_t *l2sc)
 static void
 F_MF13(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_MF13", ("FSM function F_MF13 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_MF13 executing");
 
 	i4b_Dcleanifq(&l2sc->i_queue);
 
@@ -1018,7 +1021,7 @@ F_MF13(l2_softc_t *l2sc)
 static void
 F_MF14(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_MF14", ("FSM function F_MF14 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_MF14 executing");
 
 	i4b_transmit_enquire(l2sc);
 
@@ -1031,7 +1034,7 @@ F_MF14(l2_softc_t *l2sc)
 static void
 F_MF15(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_MF15", ("FSM function F_MF15 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_MF15 executing");
 
 	if(l2sc->own_busy == 0)
 	{
@@ -1049,7 +1052,7 @@ F_MF15(l2_softc_t *l2sc)
 static void
 F_MF16(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_MF16", ("FSM function F_MF16 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_MF16 executing");
 
 	if(l2sc->own_busy != 0)
 	{
@@ -1067,7 +1070,7 @@ F_MF16(l2_softc_t *l2sc)
 static void
 F_MF17(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_MF17", ("FSM function F_MF17 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_MF17 executing");
 
 	l2sc->peer_busy = 0;
 
@@ -1114,7 +1117,7 @@ F_MF17(l2_softc_t *l2sc)
 static void
 F_MF18(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_MF18", ("FSM function F_MF18 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_MF18 executing");
 
 	l2sc->peer_busy = 0;
 
@@ -1154,7 +1157,7 @@ F_MF18(l2_softc_t *l2sc)
 static void
 F_MF19(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_MF19", ("FSM function F_MF19 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_MF19 executing");
 
 	l2sc->peer_busy = 1;
 
@@ -1193,7 +1196,7 @@ F_MF19(l2_softc_t *l2sc)
 static void
 F_MF20(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_MF20", ("FSM function F_MF20 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_MF20 executing");
 
 	i4b_mdl_error_ind(l2sc, "F_MF20", MDL_ERR_K);
 
@@ -1208,7 +1211,7 @@ F_MF20(l2_softc_t *l2sc)
 static void
 F_TR01(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TR01", ("FSM function F_TR01 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TR01 executing");
 
 	i4b_Dcleanifq(&l2sc->i_queue);
 
@@ -1223,7 +1226,7 @@ F_TR01(l2_softc_t *l2sc)
 static void
 F_TR05(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TR05", ("FSM function F_TR05 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TR05 executing");
 
 	i4b_Dcleanifq(&l2sc->i_queue);	
 
@@ -1239,7 +1242,7 @@ F_TR05(l2_softc_t *l2sc)
 static void
 F_TR06(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TR06", ("FSM function F_TR06 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TR06 executing");
 
 	i4b_Dcleanifq(&l2sc->i_queue);
 
@@ -1257,7 +1260,7 @@ F_TR06(l2_softc_t *l2sc)
 static void
 F_TR07(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TR07", ("FSM function F_TR07 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TR07 executing");
 
 	i4b_clear_exception_conditions(l2sc);
 
@@ -1289,7 +1292,7 @@ F_TR07(l2_softc_t *l2sc)
 static void
 F_TR08(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TR08", ("FSM function F_TR08 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TR08 executing");
 
 	i4b_Dcleanifq(&l2sc->i_queue);		
 	MDL_Status_Ind(l2sc->unit, STI_L2STAT, LAYER_IDLE);
@@ -1307,7 +1310,7 @@ F_TR08(l2_softc_t *l2sc)
 static void
 F_TR09(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TR09", ("FSM function F_TR09 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TR09 executing");
 	if(l2sc->rxd_PF)
 		i4b_mdl_error_ind(l2sc, "F_TR09", MDL_ERR_C);
 	else
@@ -1320,7 +1323,7 @@ F_TR09(l2_softc_t *l2sc)
 static void
 F_TR10(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TR10", ("FSM function F_TR10 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TR10 executing");
 
 	if(l2sc->rxd_PF)
 	{
@@ -1342,7 +1345,7 @@ F_TR10(l2_softc_t *l2sc)
 static void
 F_TR11(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TR11", ("FSM function F_TR11 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TR11 executing");
 
 	if(l2sc->RC >= N200)
 	{
@@ -1370,7 +1373,7 @@ F_TR11(l2_softc_t *l2sc)
 static void
 F_TR12(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TR12", ("FSM function F_TR12 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TR12 executing");
 
 	i4b_i_frame_queued_up(l2sc);
 }
@@ -1381,7 +1384,7 @@ F_TR12(l2_softc_t *l2sc)
 static void
 F_TR13(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TR13", ("FSM function F_TR13 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TR13 executing");
 
 	i4b_Dcleanifq(&l2sc->i_queue);			
 
@@ -1398,7 +1401,7 @@ F_TR13(l2_softc_t *l2sc)
 static void
 F_TR15(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TR15", ("FSM function F_TR15 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TR15 executing");
 
 	if(l2sc->own_busy == 0)
 	{
@@ -1416,7 +1419,7 @@ F_TR15(l2_softc_t *l2sc)
 static void
 F_TR16(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TR16", ("FSM function F_TR16 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TR16 executing");
 
 	if(l2sc->own_busy != 0)
 	{
@@ -1434,7 +1437,7 @@ F_TR16(l2_softc_t *l2sc)
 static void
 F_TR17(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TR17", ("FSM function F_TR17 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TR17 executing");
 
 	l2sc->peer_busy = 0;
 
@@ -1485,7 +1488,7 @@ F_TR17(l2_softc_t *l2sc)
 static void
 F_TR18(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TR18", ("FSM function F_TR18 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TR18 executing");
 
 	l2sc->peer_busy = 0;
 
@@ -1536,7 +1539,7 @@ F_TR18(l2_softc_t *l2sc)
 static void
 F_TR19(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TR19", ("FSM function F_TR19 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TR19 executing");
 
 	l2sc->peer_busy = 0;
 
@@ -1586,7 +1589,7 @@ F_TR19(l2_softc_t *l2sc)
 static void
 F_TR20(l2_softc_t *l2sc)
 {
-	DBGL2(L2_F_MSG, "F_TR20", ("FSM function F_TR20 executing\n"));
+	NDBGL2(L2_F_MSG, "FSM function F_TR20 executing");
 
 	i4b_mdl_error_ind(l2sc, "F_TR20", MDL_ERR_K);
 
diff --git a/sys/i4b/layer2/i4b_l2fsm.h b/sys/i4b/layer2/i4b_l2fsm.h
index 56a11ff..c7ddaee 100644
--- a/sys/i4b/layer2/i4b_l2fsm.h
+++ b/sys/i4b/layer2/i4b_l2fsm.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *      i4b_l2fsm.h - layer 2 FSM
  *      -------------------------
  *
- *	$Id: i4b_l2fsm.h,v 1.5 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_l2fsm.h,v 1.6 2000/03/18 09:33:48 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:03:48 1999]
+ *      last edit-date: [Sat Mar 18 10:28:37 2000]
  *
  *---------------------------------------------------------------------------*/
 
diff --git a/sys/i4b/layer2/i4b_l2timer.c b/sys/i4b/layer2/i4b_l2timer.c
index 6372b43..d06d205 100644
--- a/sys/i4b/layer2/i4b_l2timer.c
+++ b/sys/i4b/layer2/i4b_l2timer.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_l2timer.c - layer 2 timer handling
  *	--------------------------------------
  *
- *	$Id: i4b_l2timer.c,v 1.17 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_l2timer.c,v 1.20 2000/08/24 11:48:58 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:03:56 1999]
+ *      last edit-date: [Thu Aug 24 12:48:52 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -43,17 +43,16 @@
 #if NI4BQ921 > 0
 
 #include <sys/param.h>
-
-#if defined(__FreeBSD__)
-#else
-#include <sys/ioctl.h>
-#endif
 #include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -77,7 +76,7 @@
 static void
 i4b_T200_timeout(l2_softc_t *l2sc)
 {
-	DBGL2(L2_T_ERR, "i4b_T200_timeout", ("unit %d, RC = %d\n", l2sc->unit, l2sc->RC));
+	NDBGL2(L2_T_ERR, "unit %d, RC = %d", l2sc->unit, l2sc->RC);
 	i4b_next_l2state(l2sc, EV_T200EXP);
 }
 
@@ -90,14 +89,10 @@ i4b_T200_start(l2_softc_t *l2sc)
 	if(l2sc->T200 == TIMER_ACTIVE)
 		return;
 		
-	DBGL2(L2_T_MSG, "i4b_T200_start", ("unit %d\n", l2sc->unit));
+	NDBGL2(L2_T_MSG, "unit %d", l2sc->unit);
 	l2sc->T200 = TIMER_ACTIVE;
 
-#if defined(__FreeBSD__)
-	l2sc->T200_callout = timeout((TIMEOUT_FUNC_T)i4b_T200_timeout, (void *)l2sc, T200DEF);
-#else
-	timeout((TIMEOUT_FUNC_T)i4b_T200_timeout, (void *)l2sc, T200DEF);
-#endif
+	START_TIMER(l2sc->T200_callout, i4b_T200_timeout, l2sc, T200DEF);
 }
 
 /*---------------------------------------------------------------------------*
@@ -110,15 +105,11 @@ i4b_T200_stop(l2_softc_t *l2sc)
 	CRIT_BEG;
 	if(l2sc->T200 != TIMER_IDLE)
 	{
-#if defined(__FreeBSD__)
-		untimeout((TIMEOUT_FUNC_T)i4b_T200_timeout, (void *)l2sc, l2sc->T200_callout);
-#else
-		untimeout((TIMEOUT_FUNC_T)i4b_T200_timeout, (void *)l2sc);
-#endif
+		STOP_TIMER(l2sc->T200_callout, i4b_T200_timeout, l2sc);
 		l2sc->T200 = TIMER_IDLE;
 	}
 	CRIT_END;
-	DBGL2(L2_T_MSG, "i4b_T200_stop", ("unit %d\n", l2sc->unit));
+	NDBGL2(L2_T_MSG, "unit %d", l2sc->unit);
 }
 
 /*---------------------------------------------------------------------------*
@@ -131,24 +122,16 @@ i4b_T200_restart(l2_softc_t *l2sc)
 	CRIT_BEG;
 	if(l2sc->T200 != TIMER_IDLE)
 	{
-#if defined(__FreeBSD__)
-		untimeout((TIMEOUT_FUNC_T)i4b_T200_timeout, (void *)l2sc, l2sc->T200_callout);
-#else
-		untimeout((TIMEOUT_FUNC_T)i4b_T200_timeout, (void *)l2sc);
-#endif
+		STOP_TIMER(l2sc->T200_callout, i4b_T200_timeout, l2sc);
 	}
 	else
 	{
 		l2sc->T200 = TIMER_ACTIVE;
 	}
 
-#if defined(__FreeBSD__)
-	l2sc->T200_callout = timeout((TIMEOUT_FUNC_T)i4b_T200_timeout, (void *)l2sc, T200DEF);
-#else
-	timeout((TIMEOUT_FUNC_T)i4b_T200_timeout, (void *)l2sc, T200DEF);
-#endif
+	START_TIMER(l2sc->T200_callout, i4b_T200_timeout, l2sc, T200DEF);
 	CRIT_END;
-	DBGL2(L2_T_MSG, "i4b_T200_restart", ("unit %d\n", l2sc->unit));
+	NDBGL2(L2_T_MSG, "unit %d", l2sc->unit);
 }
 
 /*---------------------------------------------------------------------------*
@@ -157,7 +140,7 @@ i4b_T200_restart(l2_softc_t *l2sc)
 static void
 i4b_T202_timeout(l2_softc_t *l2sc)
 {
-	DBGL2(L2_T_ERR, "i4b_T202_timeout", ("unit %d, N202 = %d\n", l2sc->unit, l2sc->N202));
+	NDBGL2(L2_T_ERR, "unit %d, N202 = %d", l2sc->unit, l2sc->N202);
 	
 	if(--(l2sc->N202))
 	{
@@ -174,15 +157,11 @@ i4b_T202_start(l2_softc_t *l2sc)
 	if (l2sc->N202 == TIMER_ACTIVE)
 		return;
 
-	DBGL2(L2_T_MSG, "i4b_T202_start", ("unit %d\n", l2sc->unit));
+	NDBGL2(L2_T_MSG, "unit %d", l2sc->unit);
 	l2sc->N202 = N202DEF;	
 	l2sc->T202 = TIMER_ACTIVE;
 
-#if defined(__FreeBSD__)
-	l2sc->T202_callout = timeout((TIMEOUT_FUNC_T)i4b_T202_timeout, (void *)l2sc, T202DEF);
-#else
-	timeout((TIMEOUT_FUNC_T)i4b_T202_timeout, (void *)l2sc, T202DEF);
-#endif
+	START_TIMER(l2sc->T202_callout, i4b_T202_timeout, l2sc, T202DEF);
 }
 
 /*---------------------------------------------------------------------------*
@@ -195,15 +174,11 @@ i4b_T202_stop(l2_softc_t *l2sc)
 	CRIT_BEG;
 	if(l2sc->T202 != TIMER_IDLE)
 	{
-#if defined(__FreeBSD__)
-		untimeout((TIMEOUT_FUNC_T)i4b_T202_timeout, (void *)l2sc, l2sc->T202_callout);
-#else
-		untimeout((TIMEOUT_FUNC_T)i4b_T202_timeout, (void *)l2sc);
-#endif
+		STOP_TIMER(l2sc->T202_callout, i4b_T202_timeout, l2sc);
 		l2sc->T202 = TIMER_IDLE;
 	}
 	CRIT_END;
-	DBGL2(L2_T_MSG, "i4b_T202_stop", ("unit %d\n", l2sc->unit));
+	NDBGL2(L2_T_MSG, "unit %d", l2sc->unit);
 }
 
 /*---------------------------------------------------------------------------*
@@ -213,7 +188,7 @@ i4b_T202_stop(l2_softc_t *l2sc)
 static void
 i4b_T203_timeout(l2_softc_t *l2sc)
 {
-	DBGL2(L2_T_ERR, "i4b_T203_timeout", ("unit %d\n", l2sc->unit));
+	NDBGL2(L2_T_ERR, "unit %d", l2sc->unit);
 	i4b_next_l2state(l2sc, EV_T203EXP);
 }
 #endif
@@ -228,14 +203,10 @@ i4b_T203_start(l2_softc_t *l2sc)
 	if (l2sc->T203 == TIMER_ACTIVE)
 		return;
 		
-	DBGL2(L2_T_MSG, "i4b_T203_start", ("unit %d\n", l2sc->unit));
+	NDBGL2(L2_T_MSG, "unit %d", l2sc->unit);
 	l2sc->T203 = TIMER_ACTIVE;
 
-#if defined(__FreeBSD__)
-	l2sc->T203_callout = timeout((TIMEOUT_FUNC_T)i4b_T203_timeout, (void *)l2sc, T203DEF);
-#else
-	timeout((TIMEOUT_FUNC_T)i4b_T203_timeout, (void *)l2sc, T203DEF);
-#endif
+	START_TIMER(l2sc->T203_callout, i4b_T203_timeout, l2sc, T203DEF);
 #endif
 }
 
@@ -250,15 +221,11 @@ i4b_T203_stop(l2_softc_t *l2sc)
 	CRIT_BEG;
 	if(l2sc->T203 != TIMER_IDLE)
 	{
-#if defined(__FreeBSD__)
-		untimeout((TIMEOUT_FUNC_T)i4b_T203_timeout, (void *)l2sc, l2sc->T203_callout);
-#else
-		untimeout((TIMEOUT_FUNC_T)i4b_T203_timeout, (void *)l2sc);
-#endif
+		STOP_TIMER(l2sc->T203_callout, i4b_T203_timeout, l2sc);
 		l2sc->T203 = TIMER_IDLE;
 	}
 	CRIT_END;
-	DBGL2(L2_T_MSG, "i4b_T203_stop", ("unit %d\n", l2sc->unit));
+	NDBGL2(L2_T_MSG, "unit %d", l2sc->unit);
 #endif
 }
 
@@ -274,24 +241,16 @@ i4b_T203_restart(l2_softc_t *l2sc)
 
 	if(l2sc->T203 != TIMER_IDLE)
 	{
-#if defined(__FreeBSD__)
-		untimeout((TIMEOUT_FUNC_T)i4b_T203_timeout, (void *)l2sc, l2sc->T203_callout);
-#else
-		untimeout((TIMEOUT_FUNC_T)i4b_T203_timeout, (void *)l2sc);
-#endif
+		STOP_TIMER(l2sc->T203_callout, i4b_T203_timerout, l2sc);
 	}
 	else
 	{
 		l2sc->T203 = TIMER_ACTIVE;
 	}
-	
-#if defined(__FreeBSD__)
-	l2sc->T203_callout = timeout((TIMEOUT_FUNC_T)i4b_T203_timeout, (void *)l2sc, T203DEF);
-#else
-	timeout((TIMEOUT_FUNC_T)i4b_T203_timeout, (void *)l2sc, T203DEF);
-#endif
+
+	START_TIMER(l2sc->T203_callout, i4b_T203_timerout, l2sc, T203DEF);	
 	CRIT_END;
-	DBGL2(L2_T_MSG, "i4b_T203_restart", ("unit %d\n", l2sc->unit));
+	NDBGL2(L2_T_MSG, "unit %d", l2sc->unit);
 #endif
 }
 
diff --git a/sys/i4b/layer2/i4b_lme.c b/sys/i4b/layer2/i4b_lme.c
index f4ae9f5..429ddc2 100644
--- a/sys/i4b/layer2/i4b_lme.c
+++ b/sys/i4b/layer2/i4b_lme.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_lme.c - layer management entity
  *	-------------------------------------
  *
- *	$Id: i4b_lme.c,v 1.11 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_lme.c,v 1.15 2000/08/24 11:48:58 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:04:03 1999]
+ *      last edit-date: [Mon May 29 16:55:12 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -43,17 +43,16 @@
 #if NI4BQ921 > 0
 
 #include <sys/param.h>
-
-#if defined(__FreeBSD__)
-#else
-#include <sys/ioctl.h>
-#endif
-
+#include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -76,7 +75,7 @@
 void
 i4b_mdl_assign_ind(l2_softc_t *l2sc)
 {
-	DBGL2(L2_PRIM, "MDL-ASSIGN-IND", ("unit %d\n", l2sc->unit));
+	NDBGL2(L2_PRIM, "unit %d", l2sc->unit);
 	
 	i4b_l1_activate(l2sc);
 	
@@ -100,6 +99,7 @@ i4b_mdl_assign_ind(l2_softc_t *l2sc)
 void
 i4b_mdl_error_ind(l2_softc_t *l2sc, char *where, int errorcode)
 {
+#if DO_I4B_DEBUG
 	static char *error_text[] = {
 		"MDL_ERR_A: rx'd unsolicited response - supervisory (F=1)",
 		"MDL_ERR_B: rx'd unsolicited response - DM (F=1)",
@@ -118,12 +118,13 @@ i4b_mdl_error_ind(l2_softc_t *l2sc, char *where, int errorcode)
 		"MDL_ERR_O: other error - N201 error",
 		"MDL_ERR_MAX: i4b_mdl_error_ind called with wrong parameter!!!"
 	};
+#endif
 
 	if(errorcode > MDL_ERR_MAX)
 		errorcode = MDL_ERR_MAX;
 		
-	DBGL2(L2_ERROR, "i4b_mdl_error_ind", ("unit = %d, location = %s\n", l2sc->unit, where));
-	DBGL2(L2_ERROR, "i4b_mdl_error_ind", ("error = %s\n", error_text[errorcode]));
+	NDBGL2(L2_ERROR, "unit = %d, location = %s", l2sc->unit, where);
+	NDBGL2(L2_ERROR, "error = %s", error_text[errorcode]);
 
 	switch(errorcode)
 	{	
diff --git a/sys/i4b/layer2/i4b_mbuf.c b/sys/i4b/layer2/i4b_mbuf.c
index cdd3969..ea6f479 100644
--- a/sys/i4b/layer2/i4b_mbuf.c
+++ b/sys/i4b/layer2/i4b_mbuf.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,26 +27,21 @@
  *	i4b - mbuf handling support routines
  *	------------------------------------
  *
- *	$Id: i4b_mbuf.c,v 1.13 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_mbuf.c,v 1.15 2000/05/29 15:41:42 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:04:10 1999]
+ *      last edit-date: [Mon May 29 16:55:18 2000]
  *
  *---------------------------------------------------------------------------*/
 
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
-
-#if defined(__FreeBSD__)
-#else
-#include <sys/ioctl.h>
-#endif
-
 #include <sys/tty.h>
 #include <sys/proc.h>
 #include <sys/uio.h>
+#include <sys/kernel.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
diff --git a/sys/i4b/layer2/i4b_sframe.c b/sys/i4b/layer2/i4b_sframe.c
index 6644082..5e3ef26 100644
--- a/sys/i4b/layer2/i4b_sframe.c
+++ b/sys/i4b/layer2/i4b_sframe.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_sframe.c - s frame handling routines
  *	----------------------------------------
  *
- *	$Id: i4b_sframe.c,v 1.12 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_sframe.c,v 1.15 2000/08/24 11:48:58 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:04:17 1999]
+ *      last edit-date: [Mon May 29 16:55:23 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -43,17 +43,16 @@
 #if NI4BQ921 > 0
 
 #include <sys/param.h>
-
-#if defined(__FreeBSD__)
-#else
-#include <sys/ioctl.h>
-#endif
-
+#include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -96,25 +95,25 @@ i4b_rxd_s_frame(int unit, struct mbuf *m)
 	{
 		case RR:
 			l2sc->stat.rx_rr++; /* update statistics */
-			DBGL2(L2_S_MSG, "i4b_rxd_s_frame", ("rx'd RR, N(R) = %d\n", l2sc->rxd_NR));
+			NDBGL2(L2_S_MSG, "rx'd RR, N(R) = %d", l2sc->rxd_NR);
 			i4b_next_l2state(l2sc, EV_RXRR);
 			break;
 
 		case RNR:
 			l2sc->stat.rx_rnr++; /* update statistics */
-			DBGL2(L2_S_MSG, "i4b_rxd_s_frame", ("rx'd RNR, N(R) = %d\n", l2sc->rxd_NR));
+			NDBGL2(L2_S_MSG, "rx'd RNR, N(R) = %d", l2sc->rxd_NR);
 			i4b_next_l2state(l2sc, EV_RXRNR);
 			break;
 
 		case REJ:
 			l2sc->stat.rx_rej++; /* update statistics */
-			DBGL2(L2_S_MSG, "i4b_rxd_s_frame", ("rx'd REJ, N(R) = %d\n", l2sc->rxd_NR));
+			NDBGL2(L2_S_MSG, "rx'd REJ, N(R) = %d", l2sc->rxd_NR);
 			i4b_next_l2state(l2sc, EV_RXREJ);
 			break;
 
 		default:
 			l2sc->stat.err_rx_bads++; /* update statistics */
-			DBGL2(L2_S_ERR, "i4b_rxd_s_frame", ("ERROR, unknown code, frame = \n"));
+			NDBGL2(L2_S_ERR, "ERROR, unknown code, frame = ");
 			i4b_print_frame(m->m_len, m->m_data);
 			break;
 	}
@@ -129,7 +128,7 @@ i4b_tx_rr_command(l2_softc_t *l2sc, pbit_t pbit)
 {
 	struct mbuf *m;
 
-	DBGL2(L2_S_MSG, "i4b_tx_rr_command", ("tx RR, unit = %d\n", l2sc->unit));
+	NDBGL2(L2_S_MSG, "tx RR, unit = %d", l2sc->unit);
 
 	m = i4b_build_s_frame(l2sc, CR_CMD_TO_NT, pbit, RR);
 
@@ -146,7 +145,7 @@ i4b_tx_rr_response(l2_softc_t *l2sc, fbit_t fbit)
 {
 	struct mbuf *m;
 
-	DBGL2(L2_S_MSG, "i4b_tx_rr_response", ("tx RR, unit = %d\n", l2sc->unit));
+	NDBGL2(L2_S_MSG, "tx RR, unit = %d", l2sc->unit);
 
 	m = i4b_build_s_frame(l2sc, CR_RSP_TO_NT, fbit, RR);	
 
@@ -163,7 +162,7 @@ i4b_tx_rnr_command(l2_softc_t *l2sc, pbit_t pbit)
 {
 	struct mbuf *m;
 
-	DBGL2(L2_S_MSG, "i4b_tx_rnr_command", ("tx RNR, unit = %d\n", l2sc->unit));
+	NDBGL2(L2_S_MSG, "tx RNR, unit = %d", l2sc->unit);
 
 	m = i4b_build_s_frame(l2sc, CR_CMD_TO_NT, pbit, RNR);	
 
@@ -180,7 +179,7 @@ i4b_tx_rnr_response(l2_softc_t *l2sc, fbit_t fbit)
 {
 	struct mbuf *m;
 
-	DBGL2(L2_S_MSG, "i4b_tx_rnr_response", ("tx RNR, unit = %d\n", l2sc->unit));
+	NDBGL2(L2_S_MSG, "tx RNR, unit = %d", l2sc->unit);
 
 	m = i4b_build_s_frame(l2sc, CR_RSP_TO_NT, fbit, RNR);
 
@@ -197,7 +196,7 @@ i4b_tx_rej_response(l2_softc_t *l2sc, fbit_t fbit)
 {
 	struct mbuf *m;
 
-	DBGL2(L2_S_MSG, "i4b_tx_rej_response", ("tx REJ, unit = %d\n", l2sc->unit));
+	NDBGL2(L2_S_MSG, "tx REJ, unit = %d", l2sc->unit);
 
 	m = i4b_build_s_frame(l2sc, CR_RSP_TO_NT, fbit, REJ);
 
diff --git a/sys/i4b/layer2/i4b_tei.c b/sys/i4b/layer2/i4b_tei.c
index a57ff9a..b07074b 100644
--- a/sys/i4b/layer2/i4b_tei.c
+++ b/sys/i4b/layer2/i4b_tei.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_tei.c - tei handling procedures
  *	-----------------------------------
  *
- *	$Id: i4b_tei.c,v 1.17 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_tei.c,v 1.25 2000/09/01 14:11:51 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:04:24 1999]
+ *      last edit-date: [Fri Sep  1 16:04:58 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -43,19 +43,25 @@
 #if NI4BQ921 > 0
 
 #include <sys/param.h>
-
-#if defined(__FreeBSD__)
-#include <sys/random.h>
-#else
-#include <sys/ioctl.h>
-#endif
-
+#include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/syslog.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
+#if defined(__FreeBSD__)
+#if defined (__FreeBSD_version) && __FreeBSD_version <= 400000
+#include <machine/random.h>
+#else
+#include <sys/random.h>
+#endif
+#endif
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -98,7 +104,7 @@ i4b_tei_rxframe(int unit, struct mbuf *m)
 
 				log(LOG_INFO, "i4b: unit %d, assigned TEI = %d = 0x%02x\n", l2sc->unit, l2sc->tei, l2sc->tei);
 
-				DBGL2(L2_TEI_MSG, "i4b_tei_rx_frame", ("TEI ID Assign - TEI = %d\n", l2sc->tei));
+				NDBGL2(L2_TEI_MSG, "TEI ID Assign - TEI = %d", l2sc->tei);
 
 				i4b_next_l2state(l2sc, EV_MDASGRQ);
 			}
@@ -114,12 +120,12 @@ i4b_tei_rxframe(int unit, struct mbuf *m)
 				if(l2sc->tei == GROUP_TEI)
 				{
 					log(LOG_WARNING, "i4b: unit %d, denied TEI, no TEI values available from exchange!\n", l2sc->unit);
-					DBGL2(L2_TEI_ERR, "i4b_tei_rx_frame", ("TEI ID Denied, No TEI values available from exchange!\n"));
+					NDBGL2(L2_TEI_ERR, "TEI ID Denied, No TEI values available from exchange!");
 				}
 				else
 				{
 					log(LOG_WARNING, "i4b: unit %d, denied TEI = %d = 0x%02x\n", l2sc->unit, l2sc->tei, l2sc->tei);
-					DBGL2(L2_TEI_ERR, "i4b_tei_rx_frame", ("TEI ID Denied - TEI = %d\n", l2sc->tei));
+					NDBGL2(L2_TEI_ERR, "TEI ID Denied - TEI = %d", l2sc->tei);
 				}					
 				MDL_Status_Ind(l2sc->unit, STI_TEIASG, -1);
 				i4b_next_l2state(l2sc, EV_MDERRRS);
@@ -135,7 +141,7 @@ i4b_tei_rxframe(int unit, struct mbuf *m)
 
 				if(l2sc->tei != lasttei)
 				{
-					DBGL2(L2_TEI_MSG, "i4b_tei_rx_frame", ("TEI ID Check Req - TEI = %d\n", l2sc->tei));
+					NDBGL2(L2_TEI_MSG, "TEI ID Check Req - TEI = %d", l2sc->tei);
 					lasttei = l2sc->tei;
 				}
 				
@@ -154,14 +160,14 @@ i4b_tei_rxframe(int unit, struct mbuf *m)
 				l2sc->tei = GET_TEIFROMAI(*(ptr+OFF_AI));
 
 				log(LOG_INFO, "i4b: unit %d, removed TEI = %d = 0x%02x\n", l2sc->unit, l2sc->tei, l2sc->tei);
-				DBGL2(L2_TEI_MSG, "i4b_tei_rx_frame", ("TEI ID Remove - TEI = %d\n", l2sc->tei));
+				NDBGL2(L2_TEI_MSG, "TEI ID Remove - TEI = %d", l2sc->tei);
 				MDL_Status_Ind(l2sc->unit, STI_TEIASG, -1);
 				i4b_next_l2state(l2sc, EV_MDREMRQ);
 			}
 			break;
 			
 		default:
-			DBGL2(L2_TEI_ERR, "i4b_tei_rx_frame", ("UNKNOWN TEI MGMT Frame, type = 0x%x\n", *(ptr + OFF_MT)));
+			NDBGL2(L2_TEI_ERR, "UNKNOWN TEI MGMT Frame, type = 0x%x", *(ptr + OFF_MT));
 			i4b_print_frame(m->m_len, m->m_data);
 			break;
 	}
@@ -225,7 +231,7 @@ i4b_tei_assign(l2_softc_t *l2sc)
 {
 	struct mbuf *m;
 
-	DBGL2(L2_TEI_MSG, "i4b_tei_assign", ("tx TEI ID_Request\n"));
+	NDBGL2(L2_TEI_MSG, "tx TEI ID_Request");
 	
 	m = build_tei_mgmt_frame(l2sc, MT_ID_REQEST);
 
@@ -246,7 +252,7 @@ i4b_tei_verify(l2_softc_t *l2sc)
 {
 	struct mbuf *m;
 
-	DBGL2(L2_TEI_MSG, "i4b_tei_verify", ("tx TEI ID_Verify\n"));
+	NDBGL2(L2_TEI_MSG, "tx TEI ID_Verify");
 
 	m = build_tei_mgmt_frame(l2sc, MT_ID_VERIFY);
 
@@ -270,7 +276,7 @@ i4b_tei_chkresp(l2_softc_t *l2sc)
 	if(l2sc->tei != lasttei)
 	{
 		lasttei = l2sc->tei;
-		DBGL2(L2_TEI_MSG, "i4b_tei_chkresp", ("tx TEI ID_Check_Response\n"));
+		NDBGL2(L2_TEI_MSG, "tx TEI ID_Check_Response");
 	}
 
 	m = build_tei_mgmt_frame(l2sc, MT_ID_CHK_RSP);
@@ -291,7 +297,12 @@ i4b_make_rand_ri(l2_softc_t *l2sc)
 #if defined(__FreeBSD__)
 
 	u_short val;
-	read_random((char *)&val, sizeof(val));
+
+#ifdef RANDOMDEV
+        read_random((char *)&val, sizeof(val));
+#else
+	val = (u_short)random();
+#endif /* RANDOMDEV */ 
 
 #else
 
diff --git a/sys/i4b/layer2/i4b_uframe.c b/sys/i4b/layer2/i4b_uframe.c
index cc6234b..7376eb5 100644
--- a/sys/i4b/layer2/i4b_uframe.c
+++ b/sys/i4b/layer2/i4b_uframe.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_uframe.c - routines for handling U-frames
  *	-----------------------------------------------
  *
- *	$Id: i4b_uframe.c,v 1.10 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_uframe.c,v 1.13 2000/08/24 11:48:58 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:04:30 1999]
+ *      last edit-date: [Mon May 29 16:55:30 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -43,17 +43,16 @@
 #if NI4BQ921 > 0
 
 #include <sys/param.h>
-
-#if defined(__FreeBSD__)
-#else
-#include <sys/ioctl.h>
-#endif
-
+#include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -92,7 +91,7 @@ i4b_rxd_u_frame(int unit, struct mbuf *m)
 			   (l2sc->tei == GETTEI(*(ptr+OFF_TEI))))
 			{
 				l2sc->stat.rx_sabme++;
-				DBGL2(L2_U_MSG, "i4b_rxd_u_frame", ("SABME, sapi = %d, tei = %d\n", sapi, tei));
+				NDBGL2(L2_U_MSG, "SABME, sapi = %d, tei = %d", sapi, tei);
 				l2sc->rxd_PF = pfbit;
 				i4b_next_l2state(l2sc, EV_RXSABME);
 			}
@@ -120,7 +119,7 @@ i4b_rxd_u_frame(int unit, struct mbuf *m)
 			else
 			{
 				l2sc->stat.err_rx_badui++;
-				DBGL2(L2_U_ERR, "i4b_rxd_u_frame", ("unknown UI frame!\n"));
+				NDBGL2(L2_U_ERR, "unknown UI frame!");
 				i4b_Dfreembuf(m);				
 			}
 			break;
@@ -130,7 +129,7 @@ i4b_rxd_u_frame(int unit, struct mbuf *m)
 			   (l2sc->tei == GETTEI(*(ptr+OFF_TEI))))
 			{		
 				l2sc->stat.rx_disc++;
-				DBGL2(L2_U_MSG, "i4b_rxd_u_frame", ("DISC, sapi = %d, tei = %d\n", sapi, tei));
+				NDBGL2(L2_U_MSG, "DISC, sapi = %d, tei = %d", sapi, tei);
 				l2sc->rxd_PF = pfbit;
 				i4b_next_l2state(l2sc, EV_RXDISC);
 			}
@@ -142,7 +141,7 @@ i4b_rxd_u_frame(int unit, struct mbuf *m)
 			   (l2sc->tei == GETTEI(*(ptr+OFF_TEI))))
 			{		
 				l2sc->stat.rx_xid++;
-				DBGL2(L2_U_MSG, "i4b_rxd_u_frame", ("XID, sapi = %d, tei = %d\n", sapi, tei));
+				NDBGL2(L2_U_MSG, "XID, sapi = %d, tei = %d", sapi, tei);
 			}
 			i4b_Dfreembuf(m);			
 			break;
@@ -154,7 +153,7 @@ i4b_rxd_u_frame(int unit, struct mbuf *m)
 			   (l2sc->tei == GETTEI(*(ptr+OFF_TEI))))
 			{		
 				l2sc->stat.rx_dm++;
-				DBGL2(L2_U_MSG, "i4b_rxd_u_frame", ("DM, sapi = %d, tei = %d\n", sapi, tei));
+				NDBGL2(L2_U_MSG, "DM, sapi = %d, tei = %d", sapi, tei);
 				i4b_print_frame(m->m_len, m->m_data);
 				l2sc->rxd_PF = pfbit;
 				i4b_next_l2state(l2sc, EV_RXDM);
@@ -167,7 +166,7 @@ i4b_rxd_u_frame(int unit, struct mbuf *m)
 			   (l2sc->tei == GETTEI(*(ptr+OFF_TEI))))
 			{		
 				l2sc->stat.rx_ua++;
-				DBGL2(L2_U_MSG, "i4b_rxd_u_frame", ("UA, sapi = %d, tei = %d\n", sapi, tei));
+				NDBGL2(L2_U_MSG, "UA, sapi = %d, tei = %d", sapi, tei);
 				l2sc->rxd_PF = pfbit;
 				i4b_next_l2state(l2sc, EV_RXUA);
 			}
@@ -179,7 +178,7 @@ i4b_rxd_u_frame(int unit, struct mbuf *m)
 			   (l2sc->tei == GETTEI(*(ptr+OFF_TEI))))
 			{
 				l2sc->stat.rx_frmr++;
-				DBGL2(L2_U_MSG, "i4b_rxd_u_frame", ("FRMR, sapi = %d, tei = %d\n", sapi, tei));
+				NDBGL2(L2_U_MSG, "FRMR, sapi = %d, tei = %d", sapi, tei);
 				l2sc->rxd_PF = pfbit;
 				i4b_next_l2state(l2sc, EV_RXFRMR);
 			}
@@ -190,12 +189,12 @@ i4b_rxd_u_frame(int unit, struct mbuf *m)
 			if((l2sc->tei_valid == TEI_VALID) &&
 			   (l2sc->tei == GETTEI(*(ptr+OFF_TEI))))
 			{		
-				DBGL2(L2_U_ERR, "i4b_rxd_u_frame", ("UNKNOWN TYPE ERROR, sapi = %d, tei = %d, frame = ", sapi, tei));
+				NDBGL2(L2_U_ERR, "UNKNOWN TYPE ERROR, sapi = %d, tei = %d, frame = ", sapi, tei);
 				i4b_print_frame(m->m_len, m->m_data);
 			}
 			else
 			{		
-				DBGL2(L2_U_ERR, "i4b_rxd_u_frame", ("not mine -  UNKNOWN TYPE ERROR, sapi = %d, tei = %d, frame = ", sapi, tei));
+				NDBGL2(L2_U_ERR, "not mine -  UNKNOWN TYPE ERROR, sapi = %d, tei = %d, frame = ", sapi, tei);
 				i4b_print_frame(m->m_len, m->m_data);
 			}
 			l2sc->stat.err_rx_badui++;			
@@ -236,7 +235,7 @@ i4b_tx_sabme(l2_softc_t *l2sc, pbit_t pbit)
 	struct mbuf *m;
 
 	l2sc->stat.tx_sabme++;
-	DBGL2(L2_U_MSG, "i4b_tx_sabme", ("tx SABME, tei = %d\n", l2sc->tei));
+	NDBGL2(L2_U_MSG, "tx SABME, tei = %d", l2sc->tei);
 	m = i4b_build_u_frame(l2sc, CR_CMD_TO_NT, pbit, SABME);
 	PH_Data_Req(l2sc->unit, m, MBUF_FREE);
 }
@@ -250,7 +249,7 @@ i4b_tx_dm(l2_softc_t *l2sc, fbit_t fbit)
 	struct mbuf *m;
 
 	l2sc->stat.tx_dm++;	
-	DBGL2(L2_U_MSG, "i4b_tx_dm", ("tx DM, tei = %d\n", l2sc->tei));
+	NDBGL2(L2_U_MSG, "tx DM, tei = %d", l2sc->tei);
 	m = i4b_build_u_frame(l2sc, CR_RSP_TO_NT, fbit, DM);
 	PH_Data_Req(l2sc->unit, m, MBUF_FREE);
 }
@@ -264,7 +263,7 @@ i4b_tx_disc(l2_softc_t *l2sc, pbit_t pbit)
 	struct mbuf *m;
 	
 	l2sc->stat.tx_disc++;
-	DBGL2(L2_U_MSG, "i4b_tx_disc", ("tx DISC, tei = %d\n", l2sc->tei));
+	NDBGL2(L2_U_MSG, "tx DISC, tei = %d", l2sc->tei);
 	m = i4b_build_u_frame(l2sc, CR_CMD_TO_NT, pbit, DISC);
 	PH_Data_Req(l2sc->unit, m, MBUF_FREE);
 }
@@ -278,7 +277,7 @@ i4b_tx_ua(l2_softc_t *l2sc, fbit_t fbit)
 	struct mbuf *m;
 	
 	l2sc->stat.tx_ua++;
-	DBGL2(L2_U_MSG, "i4b_tx_ua", ("tx UA, tei = %d\n", l2sc->tei));
+	NDBGL2(L2_U_MSG, "tx UA, tei = %d", l2sc->tei);
 	m = i4b_build_u_frame(l2sc, CR_RSP_TO_NT, fbit, UA);
 	PH_Data_Req(l2sc->unit, m, MBUF_FREE);
 }
@@ -292,7 +291,7 @@ i4b_tx_frmr(l2_softc_t *l2sc, fbit_t fbit)
 	struct mbuf *m;
 	
 	l2sc->stat.tx_frmr++;
-	DBGL2(L2_U_MSG, "i4b_tx_frmr", ("tx FRMR, tei = %d\n", l2sc->tei));
+	NDBGL2(L2_U_MSG, "tx FRMR, tei = %d", l2sc->tei);
 	m = i4b_build_u_frame(l2sc, CR_RSP_TO_NT, fbit, FRMR);
 	PH_Data_Req(l2sc->unit, m, MBUF_FREE);
 }
diff --git a/sys/i4b/layer2/i4b_util.c b/sys/i4b/layer2/i4b_util.c
index 23eb29f..676c877 100644
--- a/sys/i4b/layer2/i4b_util.c
+++ b/sys/i4b/layer2/i4b_util.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_util.c - layer 2 utility routines
  *	-------------------------------------
  *
- *	$Id: i4b_util.c,v 1.22 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_util.c,v 1.26 2000/08/24 11:48:58 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:04:37 1999]
+ *      last edit-date: [Mon May 29 16:55:35 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -43,17 +43,16 @@
 #if NI4BQ921 > 0
 
 #include <sys/param.h>
-
-#if defined(__FreeBSD__)
-#else
-#include <sys/ioctl.h>
-#endif
-
+#include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -176,11 +175,11 @@ i4b_invoke_retransmission(l2_softc_t *l2sc, int nr)
 
 	CRIT_BEG;
 
-	DBGL2(L2_ERROR, "i4b_invoke_retransmission", ("nr = %d\n", nr ));
+	NDBGL2(L2_ERROR, "nr = %d", nr );
 	
 	while(l2sc->vs != nr)
 	{
-		DBGL2(L2_ERROR, "i4b_invoke_retransmission", ("nr(%d) != vs(%d)\n", nr, l2sc->vs));
+		NDBGL2(L2_ERROR, "nr(%d) != vs(%d)", nr, l2sc->vs);
 
 		M128DEC(l2sc->vs);
 
@@ -190,7 +189,7 @@ i4b_invoke_retransmission(l2_softc_t *l2sc, int nr)
 		{
 			if(IF_QFULL(&l2sc->i_queue))
 			{
-				DBGL2(L2_ERROR, "i4b_invoke_retransmission", ("ERROR, I-queue full!\n"));
+				NDBGL2(L2_ERROR, "ERROR, I-queue full!");
 			}
 			else
 			{
@@ -200,7 +199,7 @@ i4b_invoke_retransmission(l2_softc_t *l2sc, int nr)
 		}
 		else
 		{
-			DBGL2(L2_ERROR, "i4b_invoke_retransmission", ("ERROR, l2sc->vs = %d, l2sc->ua_num = %d \n",l2sc->vs, l2sc->ua_num));
+			NDBGL2(L2_ERROR, "ERROR, l2sc->vs = %d, l2sc->ua_num = %d ",l2sc->vs, l2sc->ua_num);
 		}
 
 /* XXXXXXXXXXXXXXXXX */
@@ -230,7 +229,7 @@ i4b_acknowledge_pending(l2_softc_t *l2sc)
 void
 i4b_print_frame(int len, u_char *buf)
 {
-#ifdef DO_I4B_DEBUG
+#if DO_I4B_DEBUG
 	int i;
 
 	if (!(i4b_l2_debug & L2_ERROR))		/* XXXXXXXXXXXXXXXXXXXXX */
@@ -248,14 +247,14 @@ i4b_print_frame(int len, u_char *buf)
 void
 i4b_print_l2var(l2_softc_t *l2sc)
 {
-	DBGL2(L2_ERROR, "i4b_print_l2var", ("unit%d V(R)=%d, V(S)=%d, V(A)=%d,ACKP=%d,PBSY=%d,OBSY=%d\n",
+	NDBGL2(L2_ERROR, "unit%d V(R)=%d, V(S)=%d, V(A)=%d,ACKP=%d,PBSY=%d,OBSY=%d",
 		l2sc->unit,
 		l2sc->vr,
 		l2sc->vs,
 		l2sc->va,
 		l2sc->ack_pend,
 		l2sc->peer_busy,
-		l2sc->own_busy));
+		l2sc->own_busy);
 }
 
 /*---------------------------------------------------------------------------*
@@ -266,12 +265,12 @@ i4b_rxd_ack(l2_softc_t *l2sc, int nr)
 {
 
 #ifdef NOTDEF
-	DBGL2(L2_ERROR, "i4b_rxd_ack", ("N(R)=%d, UA=%d, V(R)=%d, V(S)=%d, V(A)=%d\n",
+	NDBGL2(L2_ERROR, "N(R)=%d, UA=%d, V(R)=%d, V(S)=%d, V(A)=%d",
 		nr,
 		l2sc->ua_num,
 		l2sc->vr,
 		l2sc->vs,
-		l2sc->va));
+		l2sc->va);
 #endif
 
 	if(l2sc->ua_num != UA_EMPTY)
@@ -283,7 +282,7 @@ i4b_rxd_ack(l2_softc_t *l2sc, int nr)
 		M128DEC(nr);
 
 		if(l2sc->ua_num != nr)
-			DBGL2(L2_ERROR, "i4b_rxd_ack", ("((N(R)-1)=%d) != (UA=%d) !!!\n", nr, l2sc->ua_num));
+			NDBGL2(L2_ERROR, "((N(R)-1)=%d) != (UA=%d) !!!", nr, l2sc->ua_num);
 			
 		i4b_Dfreembuf(l2sc->ua_frame);
 		l2sc->ua_num = UA_EMPTY;
@@ -315,13 +314,13 @@ i4b_l2_nr_ok(int nr, int va, int vs)
 {
 	if((va > nr) && ((nr != 0) || (va != 127)))
 	{
-		DBGL2(L2_ERROR, "i4b_l2_nr_ok", ("ERROR, va = %d, nr = %d, vs = %d [1]\n", va, nr, vs));
+		NDBGL2(L2_ERROR, "ERROR, va = %d, nr = %d, vs = %d [1]", va, nr, vs);
 		return 0;	/* fail */
 	}
 
 	if((nr > vs) && ((vs != 0) || (nr != 127)))
 	{
-		DBGL2(L2_ERROR, "i4b_l2_nr_ok", ("ERROR, va = %d, nr = %d, vs = %d [2]\n", va, nr, vs));
+		NDBGL2(L2_ERROR, "ERROR, va = %d, nr = %d, vs = %d [2]", va, nr, vs);
 		return 0;	/* fail */
 	}
 	return 1;		/* good */
diff --git a/sys/i4b/layer3/i4b_l2if.c b/sys/i4b/layer3/i4b_l2if.c
index c68b622..fda8622 100644
--- a/sys/i4b/layer3/i4b_l2if.c
+++ b/sys/i4b/layer3/i4b_l2if.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_l2if.c - Layer 3 interface to Layer 2
  *	-------------------------------------------
  *
- *	$Id: i4b_l2if.c,v 1.18 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_l2if.c,v 1.23 2000/08/24 11:48:58 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:04:48 1999]
+ *      last edit-date: [Mon May 29 16:56:22 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -43,17 +43,16 @@
 #if NI4BQ931 > 0
 
 #include <sys/param.h>
-
-#if defined(__FreeBSD__)
-#else
-#include <sys/ioctl.h>
-#endif
-
+#include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -142,7 +141,7 @@ i4b_dl_establish_ind(int unit)
 	int i;
 	int found = 0;
 	
-	DBGL2(L2_PRIM, "DL-ESTABLISH-IND", ("unit %d\n",unit));
+	NDBGL2(L2_PRIM, "DL-ESTABLISH-IND unit %d",unit);
 
 	/* first set DL up in controller descriptor */
 	
@@ -151,7 +150,7 @@ i4b_dl_establish_ind(int unit)
 		if((ctrl_desc[i].ctrl_type == CTRL_PASSIVE) &&
 		   (ctrl_desc[i].unit == unit))
                 {
-                 	DBGL3(L3_MSG, "i4b_dl_establish_ind", ("unit=%d DL established!\n",unit));
+                 	NDBGL3(L3_MSG, "unit=%d DL established!",unit);
 			ctrl_desc[i].dl_est = DL_UP;
 			found = 1;
 		}
@@ -159,7 +158,7 @@ i4b_dl_establish_ind(int unit)
 
 	if(found == 0)
 	{
-	       	DBGL3(L3_ERR, "i4b_dl_establish_ind", ("ERROR, controller not found for unit=%d!\n",unit));
+	       	NDBGL3(L3_ERR, "ERROR, controller not found for unit=%d!",unit);
 		return(-1);	       	
 	}
 
@@ -173,8 +172,8 @@ i4b_dl_establish_ind(int unit)
 		    (ctrl_desc[call_desc[i].controller].ctrl_type == CTRL_PASSIVE) &&
 		    (ctrl_desc[call_desc[i].controller].unit == unit))
                 {
-                 	DBGL3(L3_MSG, "i4b_dl_establish_ind", ("unit=%d, index=%d cdid=%u cr=%d\n",
-					unit, i, call_desc[i].cdid, call_desc[i].cr));
+                 	NDBGL3(L3_MSG, "unit=%d, index=%d cdid=%u cr=%d",
+					unit, i, call_desc[i].cdid, call_desc[i].cr);
 			next_l3state(&call_desc[i], EV_DLESTIN);
 			found++;
 		}
@@ -182,7 +181,7 @@ i4b_dl_establish_ind(int unit)
 	
 	if(found == 0)
 	{
-		DBGL3(L3_ERR, "i4b_dl_establish_ind", ("ERROR, no cdid for unit %d found!\n", unit));
+		NDBGL3(L3_ERR, "ERROR, no cdid for unit %d found!", unit);
 		return(-1);
 	}
 	else
@@ -200,7 +199,7 @@ i4b_dl_establish_cnf(int unit)
 	int i;
 	int found = 0;
 
-	DBGL2(L2_PRIM, "DL-ESTABLISH-CONF", ("unit %d\n",unit));
+	NDBGL2(L2_PRIM, "DL-ESTABLISH-CONF unit %d",unit);
 	
 	for(i=0; i < N_CALL_DESC; i++)
 	{
@@ -210,8 +209,8 @@ i4b_dl_establish_cnf(int unit)
                 {
 			ctrl_desc[call_desc[i].controller].dl_est = DL_UP;
 
-                 	DBGL3(L3_MSG, "i4b_dl_establish_cnf", ("unit=%d, index=%d cdid=%u cr=%d\n",
-					unit, i, call_desc[i].cdid, call_desc[i].cr));
+                 	NDBGL3(L3_MSG, "unit=%d, index=%d cdid=%u cr=%d",
+					unit, i, call_desc[i].cdid, call_desc[i].cr);
 
 			next_l3state(&call_desc[i], EV_DLESTCF);
 			found++;
@@ -220,7 +219,7 @@ i4b_dl_establish_cnf(int unit)
 	
 	if(found == 0)
 	{
-		DBGL3(L3_ERR, "i4b_dl_establish_cnf", ("ERROR, no cdid for unit %d found!\n", unit));
+		NDBGL3(L3_ERR, "ERROR, no cdid for unit %d found!", unit);
 		return(-1);
 	}
 	else
@@ -238,7 +237,7 @@ i4b_dl_release_ind(int unit)
 	int i;
 	int found = 0;
 
-	DBGL2(L2_PRIM, "DL-RELEASE-IND", ("unit %d\n",unit));
+	NDBGL2(L2_PRIM, "DL-RELEASE-IND unit %d",unit);
 	
 	/* first set controller to down */
 	
@@ -247,7 +246,7 @@ i4b_dl_release_ind(int unit)
 		if((ctrl_desc[i].ctrl_type == CTRL_PASSIVE) &&
 		   (ctrl_desc[i].unit == unit))
                 {
-                 	DBGL3(L3_MSG, "i4b_dl_release_ind", ("unit=%d DL released!\n",unit));
+                 	NDBGL3(L3_MSG, "unit=%d DL released!",unit);
 			ctrl_desc[i].dl_est = DL_DOWN;
 			found = 1;
 		}
@@ -255,7 +254,7 @@ i4b_dl_release_ind(int unit)
 
 	if(found == 0)
 	{
-	       	DBGL3(L3_ERR, "i4b_dl_release_ind", ("ERROR, controller not found for unit=%d!\n",unit));
+	       	NDBGL3(L3_ERR, "ERROR, controller not found for unit=%d!",unit);
 		return(-1);
 	}
 	
@@ -269,8 +268,8 @@ i4b_dl_release_ind(int unit)
 		    (ctrl_desc[call_desc[i].controller].ctrl_type == CTRL_PASSIVE) &&
 		    (ctrl_desc[call_desc[i].controller].unit == unit))
                 {
-                 	DBGL3(L3_MSG, "i4b_dl_release_ind", ("unit=%d, index=%d cdid=%u cr=%d\n",
-					unit, i, call_desc[i].cdid, call_desc[i].cr));
+                 	NDBGL3(L3_MSG, "unit=%d, index=%d cdid=%u cr=%d",
+					unit, i, call_desc[i].cdid, call_desc[i].cr);
 			next_l3state(&call_desc[i], EV_DLRELIN);
 			found++;
 		}
@@ -279,7 +278,7 @@ i4b_dl_release_ind(int unit)
 	if(found == 0)
 	{
 		/* this is not an error since it might be a normal call end */
-		DBGL3(L3_MSG, "i4b_dl_release_ind", ("no cdid for unit %d found\n", unit));
+		NDBGL3(L3_MSG, "no cdid for unit %d found", unit);
 	}
 	return(0);
 }
@@ -292,19 +291,19 @@ i4b_dl_release_cnf(int unit)
 {
 	int i;
 	
-	DBGL2(L2_PRIM, "DL-RELEASE-CONF", ("unit %d\n",unit));
+	NDBGL2(L2_PRIM, "DL-RELEASE-CONF unit %d",unit);
 	
 	for(i=0; i < nctrl; i++)
 	{
 		if((ctrl_desc[i].ctrl_type == CTRL_PASSIVE) &&
 		   (ctrl_desc[i].unit == unit))
                 {
-                 	DBGL3(L3_MSG, "i4b_dl_release_cnf", ("unit=%d DL released!\n",unit));
+                 	NDBGL3(L3_MSG, "unit=%d DL released!",unit);
 			ctrl_desc[i].dl_est = DL_DOWN;
 			return(0);
 		}
 	}
-       	DBGL3(L3_ERR, "i4b_dl_release_cnf", ("ERROR, controller not found for unit=%d!\n",unit));
+       	NDBGL3(L3_ERR, "ERROR, controller not found for unit=%d!",unit);
 	return(-1);
 }
 
@@ -315,7 +314,7 @@ int
 i4b_dl_data_ind(int unit, struct mbuf *m)
 {
 #ifdef NOTDEF
-	DBGL2(L2_PRIM, "DL-DATA-IND", ("unit %d\n",unit));
+	NDBGL2(L2_PRIM, "DL-DATA-IND unit %d",unit);
 #endif
 	i4b_decode_q931(unit, m->m_len, m->m_data);
 	i4b_Dfreembuf(m);
@@ -329,7 +328,7 @@ int
 i4b_dl_unit_data_ind(int unit, struct mbuf *m)
 {
 #ifdef NOTDEF
-	DBGL2(L2_PRIM, "DL-UNIT-DATA-IND", ("unit %d\n",unit));
+	NDBGL2(L2_PRIM, "DL-UNIT-DATA-IND unit %d",unit);
 #endif
 	i4b_decode_q931(unit, m->m_len, m->m_data);
 	i4b_Dfreembuf(m);
@@ -345,7 +344,7 @@ i4b_l3_tx_connect(call_desc_t *cd)
 	struct mbuf *m;
 	u_char *ptr;
 
-	DBGL3(L3_PRIM, "tx CONNECT", ("unit %d, cr = 0x%02x\n", ctrl_desc[cd->controller].unit, cd->cr));
+	NDBGL3(L3_PRIM, "unit %d, cr = 0x%02x", ctrl_desc[cd->controller].unit, cd->cr);
 	
 	if((m = i4b_Dgetmbuf(I_FRAME_HDRLEN + MSG_CONNECT_LEN)) == NULL)
 		panic("i4b_l3_tx_connect: can't allocate mbuf\n");
@@ -369,12 +368,19 @@ i4b_l3_tx_release_complete(call_desc_t *cd, int send_cause_flag)
 	struct mbuf *m;
 	u_char *ptr;
 	int len = I_FRAME_HDRLEN + MSG_RELEASE_COMPLETE_LEN;
-
-	DBGL3(L3_PRIM, "tx RELEASE-COMPLETE", ("unit %d, cr = 0x%02x\n", ctrl_desc[cd->controller].unit, cd->cr));
 	
 	if(send_cause_flag == 0)
+	{
 		len -= 4;
-
+		NDBGL3(L3_PRIM, "unit %d, cr = 0x%02x",
+			ctrl_desc[cd->controller].unit, cd->cr);
+	}
+	else
+	{
+		NDBGL3(L3_PRIM, "unit=%d, cr=0x%02x, cause=0x%x",
+			ctrl_desc[cd->controller].unit, cd->cr, cd->cause_out);
+	}
+		
 	if((m = i4b_Dgetmbuf(len)) == NULL)
 		panic("i4b_l3_tx_release_complete: can't allocate mbuf\n");
 
@@ -405,7 +411,7 @@ i4b_l3_tx_disconnect(call_desc_t *cd)
 	struct mbuf *m;
 	u_char *ptr;
 
-	DBGL3(L3_PRIM, "tx DISCONNECT", ("unit %d, cr = 0x%02x\n", ctrl_desc[cd->controller].unit, cd->cr));
+	NDBGL3(L3_PRIM, "unit %d, cr = 0x%02x", ctrl_desc[cd->controller].unit, cd->cr);
 	
 	if((m = i4b_Dgetmbuf(I_FRAME_HDRLEN + MSG_DISCONNECT_LEN)) == NULL)
 		panic("i4b_l3_tx_disconnect: can't allocate mbuf\n");
@@ -443,7 +449,7 @@ i4b_l3_tx_setup(call_desc_t *cd)
 	 *       mechanism should be used in future. (-hm)
 	 */
 
-	DBGL3(L3_PRIM, "tx SETUP", ("unit %d, cr = 0x%02x\n", ctrl_desc[cd->controller].unit, cd->cr));
+	NDBGL3(L3_PRIM, "unit %d, cr = 0x%02x", ctrl_desc[cd->controller].unit, cd->cr);
 	
 	if((m = i4b_Dgetmbuf(I_FRAME_HDRLEN + MSG_SETUP_LEN + slen + dlen +
 			    (cd->bprot == BPROT_NONE ? 1 : 0))) == NULL)
@@ -533,7 +539,7 @@ i4b_l3_tx_connect_ack(call_desc_t *cd)
 	struct mbuf *m;
 	u_char *ptr;
 
-	DBGL3(L3_PRIM, "tx CONNECT-ACK", ("unit %d, cr = 0x%02x\n", ctrl_desc[cd->controller].unit, cd->cr));
+	NDBGL3(L3_PRIM, "unit %d, cr = 0x%02x", ctrl_desc[cd->controller].unit, cd->cr);
 	
 	if((m = i4b_Dgetmbuf(I_FRAME_HDRLEN + MSG_CONNECT_ACK_LEN)) == NULL)
 		panic("i4b_l3_tx_connect_ack: can't allocate mbuf\n");
@@ -557,7 +563,7 @@ i4b_l3_tx_status(call_desc_t *cd, u_char q850cause)
 	struct mbuf *m;
 	u_char *ptr;
 
-	DBGL3(L3_PRIM, "tx STATUS", ("unit %d, cr = 0x%02x\n", ctrl_desc[cd->controller].unit, cd->cr));
+	NDBGL3(L3_PRIM, "unit %d, cr = 0x%02x", ctrl_desc[cd->controller].unit, cd->cr);
 	
 	if((m = i4b_Dgetmbuf(I_FRAME_HDRLEN + MSG_STATUS_LEN)) == NULL)
 		panic("i4b_l3_tx_status: can't allocate mbuf\n");
@@ -591,7 +597,7 @@ i4b_l3_tx_release(call_desc_t *cd, int send_cause_flag)
 	u_char *ptr;
 	int len = I_FRAME_HDRLEN + MSG_RELEASE_LEN;
 
-	DBGL3(L3_PRIM, "tx RELEASE", ("unit %d, cr = 0x%02x\n", ctrl_desc[cd->controller].unit, cd->cr));
+	NDBGL3(L3_PRIM, "unit %d, cr = 0x%02x", ctrl_desc[cd->controller].unit, cd->cr);
 	
 	if(send_cause_flag == 0)
 		len -= 4;
@@ -629,7 +635,7 @@ i4b_l3_tx_alert(call_desc_t *cd)
 	if((m = i4b_Dgetmbuf(I_FRAME_HDRLEN + MSG_ALERT_LEN)) == NULL)
 		panic("i4b_l3_tx_alert: can't allocate mbuf\n");
 
-	DBGL3(L3_PRIM, "tx ALERT", ("unit %d, cr = 0x%02x\n", ctrl_desc[cd->controller].unit, cd->cr));
+	NDBGL3(L3_PRIM, "unit %d, cr = 0x%02x", ctrl_desc[cd->controller].unit, cd->cr);
 	
 	ptr = m->m_data + I_FRAME_HDRLEN;
 	
diff --git a/sys/i4b/layer3/i4b_l3.h b/sys/i4b/layer3/i4b_l3.h
index 3badbd8..56caf0e 100644
--- a/sys/i4b/layer3/i4b_l3.h
+++ b/sys/i4b/layer3/i4b_l3.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_l3.h - layer 3 header file
  *	------------------------------
  *
- *	$Id: i4b_l3.h,v 1.10 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_l3.h,v 1.11 2000/04/27 09:25:21 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:04:55 1999]
+ *      last edit-date: [Thu Apr 27 11:07:01 2000]
  *
  *---------------------------------------------------------------------------*/
 
diff --git a/sys/i4b/layer3/i4b_l3fsm.c b/sys/i4b/layer3/i4b_l3fsm.c
index a74c49c..c8462c7 100644
--- a/sys/i4b/layer3/i4b_l3fsm.c
+++ b/sys/i4b/layer3/i4b_l3fsm.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_l3fsm.c - layer 3 FSM
  *	-------------------------
  *
- *	$Id: i4b_l3fsm.c,v 1.18 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_l3fsm.c,v 1.22 2000/08/24 11:48:58 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:05:02 1999]
+ *      last edit-date: [Mon May 29 16:56:30 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -43,17 +43,16 @@
 #if NI4BQ931 > 0
 
 #include <sys/param.h>
-
-#if defined(__FreeBSD__)
-#else
-#include <sys/ioctl.h>
-#endif
-
+#include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -114,6 +113,7 @@ static void F_309TO(call_desc_t *cd), F_DECF(call_desc_t *cd), F_FCTY(call_desc_
 static void F_DECF1(call_desc_t *cd), F_DECF2(call_desc_t *cd), F_DECF3(call_desc_t *cd);
 static void F_DLRI(call_desc_t *cd), F_DLRIA(call_desc_t *cd), F_DECF4(call_desc_t *cd);
 
+#if DO_I4B_DEBUG
 static char *l3state_text[N_STATES] = {
 	 "ST_U0 - Null",
 	 "ST_U1 - Out Init",
@@ -176,6 +176,7 @@ static char *l3event_text[N_EVENTS] = {
 
 	"EV_ILL - Illegal event!!" 	/* Illegal */
 };
+#endif
 
 /*---------------------------------------------------------------------------*
  *	layer 3 state transition table
@@ -247,10 +248,10 @@ void next_l3state(call_desc_t *cd, int event)
 	if(newstate > N_STATES)
 		panic("i4b_l3fsm.c: newstate > N_STATES\n");	
 	
-	DBGL3(L3_F_MSG, "next_l3state", ("L3 FSM event [%s]: [%s => %s]\n",
+	NDBGL3(L3_F_MSG, "L3 FSM event [%s]: [%s => %s]",
 				l3event_text[event],
                                 l3state_text[currstate],
-                                l3state_text[newstate]));
+                                l3state_text[newstate]);
 
 	/* execute function */
 	
@@ -259,29 +260,31 @@ void next_l3state(call_desc_t *cd, int event)
 	if(newstate == ST_ILL)
 	{
 		newstate = currstate;
-		DBGL3(L3_F_ERR, "next_l3state", ("FSM illegal state, state = %s, event = %s!\n",
+		NDBGL3(L3_F_ERR, "FSM illegal state, state = %s, event = %s!",
 				l3state_text[newstate],
-				l3event_text[event]));
+				l3event_text[event]);
 	}
 
 	if(newstate != ST_SUSE)	
 		cd->Q931state = newstate;        
 }
 
+#if DO_I4B_DEBUG
 /*---------------------------------------------------------------------------*
- *	resturn pointer to current state description
+ *	return pointer to current state description
  *---------------------------------------------------------------------------*/	
 char *print_l3state(call_desc_t *cd)
 {
 	return((char *) l3state_text[cd->Q931state]);
 }
+#endif
 
 /*---------------------------------------------------------------------------*
  *	L3 FSM state U0 event L4 setup req
  *---------------------------------------------------------------------------*/	
 static void F_00A(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_00A", ("FSM function F_00A executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_00A executing");
 
 	if(i4b_get_dl_stat(cd) == DL_DOWN)
 	{
@@ -303,7 +306,7 @@ static void F_00A(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_00H(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_00H", ("FSM function F_00H executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_00H executing");
 	i4b_l4_connect_ind(cd);	/* tell l4 we have an incoming setup */	
 }
 
@@ -312,7 +315,7 @@ static void F_00H(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_00I(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_00I", ("FSM function F_00I executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_00I executing");
 
 	if(cd->call_state != 0)
 	{
@@ -327,7 +330,7 @@ static void F_00I(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_00J(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_00J", ("FSM function F_00J executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_00J executing");
 	i4b_l3_tx_release_complete(cd, 0);	/* 0 = don't send cause */	
 }
 
@@ -336,7 +339,7 @@ static void F_00J(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_01B(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_01B", ("FSM function F_01B executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_01B executing");
 	/* cause from L4 */
 	i4b_l3_tx_disconnect(cd);
 	T303_stop(cd);
@@ -348,7 +351,7 @@ static void F_01B(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_01K(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_01K", ("FSM function F_01K executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_01K executing");
 	T303_stop(cd);
 	i4b_l4_disconnect_ind(cd);	/* tell l4 we were rejected */
 	freecd_by_cd(cd);	
@@ -359,7 +362,7 @@ static void F_01K(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_01L(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_01L", ("FSM function F_01L executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_01L executing");
 	T303_stop(cd);
 
 	/*
@@ -379,7 +382,7 @@ static void F_01L(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_01M(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_01M", ("FSM function F_01M executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_01M executing");
 	T303_stop(cd);
 	T310_start(cd);
 	i4b_l4_proceeding_ind(cd);
@@ -390,7 +393,7 @@ static void F_01M(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_01N(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_01N", ("FSM function F_01N executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_01N executing");
 	T303_stop(cd);
 	i4b_l4_alert_ind(cd);
 }
@@ -400,7 +403,7 @@ static void F_01N(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_01O(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_01O", ("FSM function F_01O executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_01O executing");
 	T303_stop(cd);
 	i4b_l3_tx_connect_ack(cd);
 	i4b_l4_connect_active_ind(cd);
@@ -411,7 +414,7 @@ static void F_01O(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_01U(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_01U", ("FSM function F_01U executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_01U executing");
 	if(cd->T303_first_to == 1)
 	{
 		cd->T303_first_to = 0;
@@ -432,7 +435,7 @@ static void F_01U(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_03C(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_03C", ("FSM function F_03C executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_03C executing");
 	T310_stop(cd);
 	cd->cause_out = 6;
 	i4b_l3_tx_release(cd, 1);	/* 0 = don't send cause */	
@@ -445,7 +448,7 @@ static void F_03C(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_03N(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_03N", ("FSM function F_03N executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_03N executing");
 	T310_stop(cd);
 	i4b_l4_alert_ind(cd);
 }
@@ -455,7 +458,7 @@ static void F_03N(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_03O(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_03O", ("FSM function F_03O executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_03O executing");
 	T310_stop(cd);
 	i4b_l3_tx_connect_ack(cd);	/* CONNECT ACK to network */
 	i4b_l4_connect_active_ind(cd);
@@ -466,7 +469,7 @@ static void F_03O(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_03P(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_03P", ("FSM function F_03P executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_03P executing");
 	T310_stop(cd);
 #ifdef NOTDEF
 	i4b_l4_progress_ind(cd);
@@ -478,7 +481,7 @@ static void F_03P(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_03Y(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_03Y", ("FSM function F_03Y executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_03Y executing");
 	cd->cause_out = 102;	/* recovery on timer expiry */
 	i4b_l3_tx_disconnect(cd);
 	T305_start(cd);
@@ -490,7 +493,7 @@ static void F_03Y(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_04O(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_04O", ("FSM function F_04O executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_04O executing");
 	i4b_l3_tx_connect_ack(cd);	/* CONNECT ACK to network */		
 	i4b_l4_connect_active_ind(cd);
 }
@@ -500,7 +503,7 @@ static void F_04O(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_06D(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_06D", ("FSM function F_06D executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_06D executing");
 
 	if(i4b_get_dl_stat(cd) == DL_DOWN)
 	{	
@@ -519,7 +522,7 @@ static void F_06D(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_06E(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_06E", ("FSM function F_06E executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_06E executing");
 
 	if(i4b_get_dl_stat(cd) == DL_DOWN)
 	{	
@@ -539,7 +542,7 @@ static void F_06E(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_06F(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_06F", ("FSM function F_06F executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_06F executing");
 
 	if(i4b_get_dl_stat(cd) == DL_DOWN)
 	{	
@@ -561,7 +564,7 @@ static void F_06F(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_06G(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_06G", ("FSM function F_06G executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_06G executing");
 	freecd_by_cd(cd);
 }
 
@@ -570,7 +573,7 @@ static void F_06G(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_06J(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_06J", ("FSM function F_06J executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_06J executing");
 	i4b_l3_tx_release_complete(cd, 0);
 	i4b_l4_disconnect_ind(cd);	
 	freecd_by_cd(cd);	
@@ -581,7 +584,7 @@ static void F_06J(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_06Q(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_06Q", ("FSM function F_06Q executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_06Q executing");
 	i4b_l4_disconnect_ind(cd);
 }
 
@@ -590,7 +593,7 @@ static void F_06Q(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_07E(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_07E", ("FSM function F_07E executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_07E executing");
 	i4b_l3_tx_connect(cd);
 	T313_start(cd);
 }
@@ -600,7 +603,7 @@ static void F_07E(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_07F(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_07F", ("FSM function F_07F executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_07F executing");
 	i4b_l3_tx_release_complete(cd, 1);
 	freecd_by_cd(cd);
 }
@@ -610,7 +613,7 @@ static void F_07F(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_07G(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_07G", ("FSM function F_07G executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_07G executing");
 	freecd_by_cd(cd);
 }
 
@@ -619,7 +622,7 @@ static void F_07G(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_08R(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_08R", ("FSM function F_08R executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_08R executing");
 	T313_stop(cd);
 	i4b_l4_connect_active_ind(cd);
 }
@@ -629,7 +632,7 @@ static void F_08R(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_08Z(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_08Z", ("FSM function F_08Z executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_08Z executing");
 	cd->cause_out = 102;	/* recovery on timer expiry */
 	i4b_l3_tx_disconnect(cd);
 	T305_start(cd);
@@ -641,7 +644,7 @@ static void F_08Z(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_09D(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_09D", ("FSM function F_09D executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_09D executing");
 	i4b_l3_tx_alert(cd);
 }
 
@@ -650,7 +653,7 @@ static void F_09D(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_09E(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_09E", ("FSM function F_09E executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_09E executing");
 	i4b_l3_tx_connect(cd);
 	T313_start(cd);
 }
@@ -660,7 +663,7 @@ static void F_09E(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_09F(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_09F", ("FSM function F_09F executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_09F executing");
 	i4b_l3_tx_release_complete(cd, 1);
 	freecd_by_cd(cd);
 }
@@ -669,7 +672,7 @@ static void F_09F(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_09G(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_09G", ("FSM function F_09G executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_09G executing");
 	freecd_by_cd(cd);	
 }
 
@@ -678,7 +681,7 @@ static void F_09G(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_11J(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_11J", ("FSM function F_11J executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_11J executing");
 	T305_stop(cd);
 	i4b_l3_tx_release_complete(cd, 0);
 	i4b_l4_disconnect_ind(cd);
@@ -690,7 +693,7 @@ static void F_11J(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_11Q(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_11Q", ("FSM function F_11Q executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_11Q executing");
 	T305_stop(cd);
 	i4b_l3_tx_release(cd, 0);
 	cd->T308_first_to = 1;
@@ -702,7 +705,7 @@ static void F_11Q(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_11V(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_11V", ("FSM function F_11V executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_11V executing");
 	cd->cause_out = 102;
 	i4b_l3_tx_release(cd, 1);
 	cd->T308_first_to = 1;
@@ -714,7 +717,7 @@ static void F_11V(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_12C(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_12C", ("FSM function F_12C executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_12C executing");
 	i4b_l3_tx_release(cd, 1);
 	cd->T308_first_to = 1;
 	T308_start(cd);
@@ -725,7 +728,7 @@ static void F_12C(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_12J(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_12J", ("FSM function F_12J executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_12J executing");
 	i4b_l3_tx_release_complete(cd, 0);
 	i4b_l4_disconnect_ind(cd);	
 	freecd_by_cd(cd);
@@ -736,7 +739,7 @@ static void F_12J(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_19I(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_19I", ("FSM function F_19I executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_19I executing");
 
 	if(cd->call_state == 0)
 	{
@@ -755,7 +758,7 @@ static void F_19I(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_19J(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_19J", ("FSM function F_19J executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_19J executing");
 	T308_stop(cd);
 	i4b_l4_disconnect_ind(cd);
 	freecd_by_cd(cd);
@@ -766,7 +769,7 @@ static void F_19J(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_19K(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_19K", ("FSM function F_19K executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_19K executing");
 	T308_stop(cd);
 	i4b_l4_disconnect_ind(cd);
 	freecd_by_cd(cd);
@@ -777,7 +780,7 @@ static void F_19K(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_19W(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_19W", ("FSM function F_19W executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_19W executing");
 	if(cd->T308_first_to == 0)
 	{
 		cd->T308_first_to = 1;
@@ -806,7 +809,7 @@ static void F_NCNA(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_STENQ(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_STENQ", ("FSM function F_STENQ executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_STENQ executing");
 	i4b_l3_tx_status(cd, CAUSE_Q850_STENQRSP); /* 30, resonse to stat enq */
 }
 
@@ -815,7 +818,7 @@ static void F_STENQ(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_STAT(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_STAT", ("FSM function F_STAT executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_STAT executing");
 	if(cd->call_state == 0)
 	{
 		i4b_l4_status_ind(cd);
@@ -839,7 +842,7 @@ static void F_STAT(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_INFO(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_INFO", ("FSM function F_INFO executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_INFO executing");
 	i4b_l4_info_ind(cd);
 	/* remain in current state */
 }
@@ -849,7 +852,7 @@ static void F_INFO(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_RELCP(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_RELCP", ("FSM function F_RELCP executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_RELCP executing");
 	i4b_l3_stop_all_timers(cd);
 	i4b_l4_disconnect_ind(cd);
 	freecd_by_cd(cd);
@@ -860,7 +863,7 @@ static void F_RELCP(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_REL(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_REL", ("FSM function F_REL executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_REL executing");
 	i4b_l3_stop_all_timers(cd);
 	i4b_l3_tx_release_complete(cd, 0);
 	i4b_l4_disconnect_ind(cd);	
@@ -872,7 +875,7 @@ static void F_REL(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_DISC(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_DISC", ("FSM function F_DISC executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_DISC executing");
 	i4b_l3_stop_all_timers(cd);
 
 	/*
@@ -891,7 +894,7 @@ static void F_DISC(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_DCRQ(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_DCRQ", ("FSM function F_DCRQ executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_DCRQ executing");
 
 	/* stop T310 in case this is the result of an incoming call for a */
 	/* calledback connection */
@@ -910,7 +913,7 @@ static void F_DCRQ(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_UEM(call_desc_t *cd)
 {
-	DBGL3(L3_F_ERR, "F_UEM", ("FSM function F_UEM executing, state = %s\n", print_l3state(cd)));
+	NDBGL3(L3_F_ERR, "FSM function F_UEM executing, state = %s", print_l3state(cd));
 	i4b_l3_tx_status(cd, CAUSE_Q850_MSGNCWCS); /* 101, message not compatible with call state */
 }
 
@@ -919,7 +922,7 @@ static void F_UEM(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_SIGN(call_desc_t *cd)
 {
-	DBGL3(L3_F_ERR, "F_SIGN", ("FSM function F_SIGN executing\n"));
+	NDBGL3(L3_F_ERR, "FSM function F_SIGN executing");
 
 /* XXX */ /* freecd_by_cd(cd); ?????????? XXX */
 }
@@ -929,7 +932,7 @@ static void F_SIGN(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_DLEI(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_DLEI", ("FSM function F_DLEI executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_DLEI executing");
 
 /* XXX */
 
@@ -941,7 +944,7 @@ static void F_DLEI(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_ILL(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_ILL", ("FSM function F_ILL executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_ILL executing");
 }
 
 /*---------------------------------------------------------------------------*
@@ -949,7 +952,7 @@ static void F_ILL(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_309TO(call_desc_t *cd)
 {
-	DBGL3(L3_F_ERR, "F_309TO", ("FSM function F_309TO executing\n"));
+	NDBGL3(L3_F_ERR, "FSM function F_309TO executing");
 
 /* XXX */
 
@@ -965,7 +968,7 @@ static void F_309TO(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_FCTY(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_FCTY", ("FSM function F_FCTY executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_FCTY executing");
 	/* ST_SUSE, no change in state ! */
 }
 
@@ -974,7 +977,7 @@ static void F_FCTY(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_DECF1(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_DECF1", ("FSM function F_DECF1 executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_DECF1 executing");
 	i4b_l3_tx_setup(cd);
 }
 
@@ -983,7 +986,7 @@ static void F_DECF1(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_DECF2(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_DECF2", ("FSM function F_DECF2 executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_DECF2 executing");
 	i4b_l3_tx_connect(cd);
 }
 
@@ -992,7 +995,7 @@ static void F_DECF2(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_DECF3(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_DECF3", ("FSM function F_DECF3 executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_DECF3 executing");
 	i4b_l3_tx_release_complete(cd, 1);
 	freecd_by_cd(cd);
 }
@@ -1002,7 +1005,7 @@ static void F_DECF3(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_DECF4(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_DECF4", ("FSM function F_DECF4 executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_DECF4 executing");
 	i4b_l3_tx_alert(cd);
 }
 
@@ -1012,7 +1015,7 @@ static void F_DECF4(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_DECF(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_DECF", ("FSM function F_DECF executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_DECF executing");
 	T309_stop(cd);
 	i4b_l3_tx_status(cd, CAUSE_Q850_NORMUNSP); /* 31, normal unspecified */
 }
@@ -1022,7 +1025,7 @@ static void F_DECF(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_DLRI(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_DLRI", ("FSM function F_DLRI executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_DLRI executing");
 	i4b_l3_stop_all_timers(cd);
 	i4b_l4_disconnect_ind(cd);
 	freecd_by_cd(cd);
@@ -1033,7 +1036,7 @@ static void F_DLRI(call_desc_t *cd)
  *---------------------------------------------------------------------------*/	
 static void F_DLRIA(call_desc_t *cd)
 {
-	DBGL3(L3_F_MSG, "F_DLRIA", ("FSM function F_DLRIA executing\n"));
+	NDBGL3(L3_F_MSG, "FSM function F_DLRIA executing");
 
 	if(cd->T309 == TIMER_IDLE)
 		T309_start(cd);
diff --git a/sys/i4b/layer3/i4b_l3fsm.h b/sys/i4b/layer3/i4b_l3fsm.h
index 1980ae0..0b1c76d 100644
--- a/sys/i4b/layer3/i4b_l3fsm.h
+++ b/sys/i4b/layer3/i4b_l3fsm.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *      i4b_l3fsm.c - layer 3 FSM
  *      -------------------------
  * 
- *	$Id: i4b_l3fsm.h,v 1.7 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_l3fsm.h,v 1.8 2000/04/27 09:25:22 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:05:09 1999]
+ *      last edit-date: [Thu Apr 27 11:07:16 2000]
  *
  *---------------------------------------------------------------------------*/
 
diff --git a/sys/i4b/layer3/i4b_l3timer.c b/sys/i4b/layer3/i4b_l3timer.c
index 261f8de..66dffe4 100644
--- a/sys/i4b/layer3/i4b_l3timer.c
+++ b/sys/i4b/layer3/i4b_l3timer.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_l3timer.c - timer and timeout handling for layer 3
  *	------------------------------------------------------
  *
- *	$Id: i4b_l3timer.c,v 1.14 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_l3timer.c,v 1.17 2000/08/24 11:48:58 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:05:18 1999]
+ *      last edit-date: [Thu Aug 24 12:49:50 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -43,18 +43,16 @@
 #if NI4BQ931 > 0
 
 #include <sys/param.h>
-
-#if defined(__FreeBSD__)
-#else
-#include <sys/ioctl.h>
-#endif
-
 #include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -94,7 +92,7 @@ void i4b_l3_stop_all_timers(call_desc_t *cd)
 static void
 T303_timeout(call_desc_t *cd)
 {
-	DBGL3(L3_T_ERR, "T303_timeout", ("SETUP not answered, cr = %d\n", cd->cr));
+	NDBGL3(L3_T_ERR, "SETUP not answered, cr = %d", cd->cr);
 	next_l3state(cd, EV_T303EXP);
 }
 
@@ -107,14 +105,10 @@ T303_start(call_desc_t *cd)
 	if (cd->T303 == TIMER_ACTIVE)
 		return;
 		
-	DBGL3(L3_T_MSG, "T303_start", ("cr = %d\n", cd->cr));
+	NDBGL3(L3_T_MSG, "cr = %d", cd->cr);
 	cd->T303 = TIMER_ACTIVE;
 
-#if defined(__FreeBSD__)
-	cd->T303_callout = timeout((TIMEOUT_FUNC_T)T303_timeout, (void *)cd, T303VAL);
-#else
-	timeout((TIMEOUT_FUNC_T)T303_timeout, (void *)cd, T303VAL);
-#endif
+	START_TIMER(cd->T303_callout, T303_timeout, cd, T303VAL);
 }
 
 /*---------------------------------------------------------------------------*
@@ -128,15 +122,11 @@ T303_stop(call_desc_t *cd)
 	
 	if(cd->T303 != TIMER_IDLE)
 	{
-#if defined(__FreeBSD__)
-		untimeout((TIMEOUT_FUNC_T)T303_timeout, (void *)cd, cd->T303_callout);
-#else
-		untimeout((TIMEOUT_FUNC_T)T303_timeout, (void *)cd);
-#endif
+		STOP_TIMER(cd->T303_callout, T303_timeout, cd);
 		cd->T303 = TIMER_IDLE;
 	}
 	CRIT_END;
-	DBGL3(L3_T_MSG, "T303_stop", ("cr = %d\n", cd->cr));
+	NDBGL3(L3_T_MSG, "cr = %d", cd->cr);
 }
 
 /*---------------------------------------------------------------------------*
@@ -145,7 +135,7 @@ T303_stop(call_desc_t *cd)
 static void
 T305_timeout(call_desc_t *cd)
 {
-	DBGL3(L3_T_ERR, "T305_timeout", ("DISC not answered, cr = %d\n", cd->cr));
+	NDBGL3(L3_T_ERR, "DISC not answered, cr = %d", cd->cr);
 	next_l3state(cd, EV_T305EXP);
 }
 
@@ -158,14 +148,10 @@ T305_start(call_desc_t *cd)
 	if (cd->T305 == TIMER_ACTIVE)
 		return;
 		
-	DBGL3(L3_T_MSG, "T305_start", ("cr = %d\n", cd->cr));
+	NDBGL3(L3_T_MSG, "cr = %d", cd->cr);
 	cd->T305 = TIMER_ACTIVE;
 
-#if defined(__FreeBSD__)
-	cd->T305_callout = timeout((TIMEOUT_FUNC_T)T305_timeout, (void *)cd, T305VAL);
-#else
-	timeout((TIMEOUT_FUNC_T)T305_timeout, (void *)cd, T305VAL);
-#endif
+	START_TIMER(cd->T305_callout, T305_timeout, cd, T305VAL);
 }
 
 /*---------------------------------------------------------------------------*
@@ -179,16 +165,12 @@ T305_stop(call_desc_t *cd)
 	
 	if(cd->T305 != TIMER_IDLE)
 	{
-#if defined(__FreeBSD__)
-		untimeout((TIMEOUT_FUNC_T)T305_timeout, (void *)cd, cd->T305_callout);
-#else
-		untimeout((TIMEOUT_FUNC_T)T305_timeout, (void *)cd);
-#endif
+		STOP_TIMER(cd->T305_callout, T305_timeout, cd);
 		cd->T305 = TIMER_IDLE;
 	}
 	CRIT_END;
 	
-	DBGL3(L3_T_MSG, "T305_stop", ("cr = %d\n", cd->cr));
+	NDBGL3(L3_T_MSG, "cr = %d", cd->cr);
 }
 
 /*---------------------------------------------------------------------------*
@@ -197,7 +179,7 @@ T305_stop(call_desc_t *cd)
 static void
 T308_timeout(call_desc_t *cd)
 {
-	DBGL3(L3_T_ERR, "T308_timeout", ("REL not answered, cr = %d\n", cd->cr));
+	NDBGL3(L3_T_ERR, "REL not answered, cr = %d", cd->cr);
 	next_l3state(cd, EV_T308EXP);
 }
 
@@ -210,14 +192,10 @@ T308_start(call_desc_t *cd)
 	if(cd->T308 == TIMER_ACTIVE)
 		return;
 		
-	DBGL3(L3_T_MSG, "T308_start", ("cr = %d\n", cd->cr));
+	NDBGL3(L3_T_MSG, "cr = %d", cd->cr);
 	cd->T308 = TIMER_ACTIVE;
 
-#if defined(__FreeBSD__)
-	cd->T308_callout = timeout((TIMEOUT_FUNC_T)T308_timeout, (void *)cd, T308VAL);
-#else
-	timeout((TIMEOUT_FUNC_T)T308_timeout, (void *)cd, T308VAL);
-#endif
+	START_TIMER(cd->T308_callout, T308_timeout, cd, T308VAL);
 }
 
 /*---------------------------------------------------------------------------*
@@ -231,16 +209,12 @@ T308_stop(call_desc_t *cd)
 	
 	if(cd->T308 != TIMER_IDLE)
 	{
-#if defined(__FreeBSD__)
-		untimeout((TIMEOUT_FUNC_T)T308_timeout, (void *)cd, cd->T308_callout);
-#else
-		untimeout((TIMEOUT_FUNC_T)T308_timeout, (void *)cd);
-#endif
+		STOP_TIMER(cd->T308_callout, T308_timeout, cd);
 		cd->T308 = TIMER_IDLE;
 	}
 	CRIT_END;
 	
-	DBGL3(L3_T_MSG, "T308_stop", ("cr = %d\n", cd->cr));
+	NDBGL3(L3_T_MSG, "cr = %d", cd->cr);
 }
 
 /*---------------------------------------------------------------------------*
@@ -249,7 +223,7 @@ T308_stop(call_desc_t *cd)
 static void
 T309_timeout(call_desc_t *cd)
 {
-	DBGL3(L3_T_ERR, "T309_timeout", ("datalink not reconnected, cr = %d\n", cd->cr));
+	NDBGL3(L3_T_ERR, "datalink not reconnected, cr = %d", cd->cr);
 	next_l3state(cd, EV_T309EXP);
 }
 
@@ -262,14 +236,10 @@ T309_start(call_desc_t *cd)
 	if (cd->T309 == TIMER_ACTIVE)
 		return;
 
-	DBGL3(L3_T_MSG, "T309_start", ("cr = %d\n", cd->cr));
+	NDBGL3(L3_T_MSG, "cr = %d", cd->cr);
 	cd->T309 = TIMER_ACTIVE;
 
-#if defined(__FreeBSD__)
-	cd->T309_callout = timeout((TIMEOUT_FUNC_T)T309_timeout, (void *)cd, T309VAL);
-#else
-	timeout((TIMEOUT_FUNC_T)T309_timeout, (void *)cd, T309VAL);
-#endif
+	START_TIMER(cd->T309_callout, T309_timeout, cd, T309VAL);
 }
 
 /*---------------------------------------------------------------------------*
@@ -283,16 +253,12 @@ T309_stop(call_desc_t *cd)
 	
 	if(cd->T309 != TIMER_IDLE)
 	{
-#if defined(__FreeBSD__)
-		untimeout((TIMEOUT_FUNC_T)T309_timeout, (void *)cd, cd->T309_callout);
-#else
-		untimeout((TIMEOUT_FUNC_T)T309_timeout, (void *)cd);
-#endif
+		STOP_TIMER(cd->T309_callout, T309_timeout, cd);
 		cd->T309 = TIMER_IDLE;
 	}
 	CRIT_END;
 	
-	DBGL3(L3_T_MSG, "T309_stop", ("cr = %d\n", cd->cr));
+	NDBGL3(L3_T_MSG, "cr = %d", cd->cr);
 }
 
 /*---------------------------------------------------------------------------*
@@ -301,7 +267,7 @@ T309_stop(call_desc_t *cd)
 static void
 T310_timeout(call_desc_t *cd)
 {
-	DBGL3(L3_T_ERR, "T310_timeout", ("CALL PROC timeout, cr = %d\n", cd->cr));
+	NDBGL3(L3_T_ERR, "CALL PROC timeout, cr = %d", cd->cr);
 	next_l3state(cd, EV_T310EXP);
 }
 
@@ -314,14 +280,10 @@ T310_start(call_desc_t *cd)
 	if (cd->T310 == TIMER_ACTIVE)
 		return;
 		
-	DBGL3(L3_T_MSG, "T310_start", ("cr = %d\n", cd->cr));
+	NDBGL3(L3_T_MSG, "cr = %d", cd->cr);
 	cd->T310 = TIMER_ACTIVE;
 
-#if defined(__FreeBSD__)
-	cd->T310_callout = timeout((TIMEOUT_FUNC_T)T310_timeout, (void *)cd, T310VAL);
-#else
-	timeout((TIMEOUT_FUNC_T)T310_timeout, (void *)cd, T310VAL);
-#endif
+	START_TIMER(cd->T310_callout, T310_timeout, cd, T310VAL);
 }
 
 /*---------------------------------------------------------------------------*
@@ -335,16 +297,12 @@ T310_stop(call_desc_t *cd)
 	
 	if(cd->T310 != TIMER_IDLE)
 	{
-#if defined(__FreeBSD__)
-		untimeout((TIMEOUT_FUNC_T)T310_timeout, (void *)cd, cd->T310_callout);
-#else
-		untimeout((TIMEOUT_FUNC_T)T310_timeout, (void *)cd);
-#endif
+		STOP_TIMER(cd->T310_callout, T310_timeout, cd);
 		cd->T310 = TIMER_IDLE;
 	}
 	CRIT_END;
 
-	DBGL3(L3_T_MSG, "T310_stop", ("cr = %d\n", cd->cr));
+	NDBGL3(L3_T_MSG, "cr = %d", cd->cr);
 }
 
 /*---------------------------------------------------------------------------*
@@ -353,7 +311,7 @@ T310_stop(call_desc_t *cd)
 static void
 T313_timeout(call_desc_t *cd)
 {
-	DBGL3(L3_T_ERR, "T313_timeout", ("CONN ACK not received, cr = %d\n", cd->cr));
+	NDBGL3(L3_T_ERR, "CONN ACK not received, cr = %d", cd->cr);
 	next_l3state(cd, EV_T313EXP);
 }
 
@@ -366,14 +324,10 @@ T313_start(call_desc_t *cd)
 	if (cd->T313 == TIMER_ACTIVE)
 		return;
 		
-	DBGL3(L3_T_MSG, "T313_start", ("cr = %d\n", cd->cr));
+	NDBGL3(L3_T_MSG, "cr = %d", cd->cr);
 	cd->T313 = TIMER_ACTIVE;
 
-#if defined(__FreeBSD__)
-	cd->T313_callout = timeout((TIMEOUT_FUNC_T)T313_timeout, (void *)cd, T313VAL);
-#else
-	timeout((TIMEOUT_FUNC_T)T313_timeout, (void *)cd, T313VAL);
-#endif
+	START_TIMER(cd->T313_callout, T313_timeout, cd, T313VAL);
 }
 
 /*---------------------------------------------------------------------------*
@@ -388,15 +342,11 @@ T313_stop(call_desc_t *cd)
 	if(cd->T313 != TIMER_IDLE)
 	{
 		cd->T313 = TIMER_IDLE;
-#if defined(__FreeBSD__)
-		untimeout((TIMEOUT_FUNC_T)T313_timeout, (void *)cd, cd->T313_callout);
-#else
-		untimeout((TIMEOUT_FUNC_T)T313_timeout, (void *)cd);
-#endif
+		STOP_TIMER(cd->T313_callout, T313_timeout, cd);
 	}
 	CRIT_END;
 	
-	DBGL3(L3_T_MSG, "T313_stop", ("cr = %d\n", cd->cr));
+	NDBGL3(L3_T_MSG, "cr = %d", cd->cr);
 }
 
 #endif /* NI4BQ931 > 0 */
diff --git a/sys/i4b/layer3/i4b_l4if.c b/sys/i4b/layer3/i4b_l4if.c
index 0062d97..a963288 100644
--- a/sys/i4b/layer3/i4b_l4if.c
+++ b/sys/i4b/layer3/i4b_l4if.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_l4if.c - Layer 3 interface to Layer 4
  *	-------------------------------------------
  *
- *	$Id: i4b_l4if.c,v 1.22 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_l4if.c,v 1.27 2000/08/24 11:48:58 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:05:25 1999]
+ *      last edit-date: [Fri Jun  2 14:32:19 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -43,17 +43,16 @@
 #if NI4BQ931 > 0
 
 #include <sys/param.h>
-
-#if defined(__FreeBSD__)
-#else
-#include <sys/ioctl.h>
-#endif
-
+#include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -83,7 +82,7 @@ static void n_connect_request(u_int cdid);
 static void n_connect_response(u_int cdid, int response, int cause);
 static void n_disconnect_request(u_int cdid, int cause);
 static void n_alert_request(u_int cdid);
-static void n_mgmt_command(int unit, int cmd, int parm);
+static void n_mgmt_command(int unit, int cmd, void *parm);
 
 /*---------------------------------------------------------------------------*
  *	i4b_mdl_status_ind - status indication from lower layers
@@ -94,12 +93,12 @@ i4b_mdl_status_ind(int unit, int status, int parm)
 	int sendup;
 	int i;
 	
-	DBGL3(L3_MSG, "i4b_mdl_status_ind", ("unit = %d, status = %d, parm = %d\n", unit, status, parm));
+	NDBGL3(L3_MSG, "unit = %d, status = %d, parm = %d", unit, status, parm);
 
 	switch(status)
 	{
 		case STI_ATTACH:
-			DBGL3(L3_MSG, "i4b_mdl_status_ind", ("STI_ATTACH: attaching unit %d to controller %d\n", unit, nctrl));
+			NDBGL3(L3_MSG, "STI_ATTACH: attaching unit %d to controller %d", unit, nctrl);
 		
 			/* init function pointers */
 			
@@ -107,8 +106,6 @@ i4b_mdl_status_ind(int unit, int status, int parm)
 			ctrl_desc[nctrl].N_CONNECT_RESPONSE = n_connect_response;
 			ctrl_desc[nctrl].N_DISCONNECT_REQUEST = n_disconnect_request;
 			ctrl_desc[nctrl].N_ALERT_REQUEST = n_alert_request;	
-			ctrl_desc[nctrl].N_SET_TRACE = isic_settrace;
-			ctrl_desc[nctrl].N_GET_TRACE = isic_gettrace;
 			ctrl_desc[nctrl].N_DOWNLOAD = NULL;	/* only used by active cards */
 			ctrl_desc[nctrl].N_DIAGNOSTICS = NULL;	/* only used by active cards */
 			ctrl_desc[nctrl].N_MGMT_COMMAND = n_mgmt_command;
@@ -138,22 +135,22 @@ i4b_mdl_status_ind(int unit, int status, int parm)
 			
 		case STI_L1STAT:
 			i4b_l4_l12stat(unit, 1, parm);
-			DBGL3(L3_MSG, "i4b_mdl_status_ind", ("STI_L1STAT: unit %d layer 1 = %s\n", unit, status ? "up" : "down"));
+			NDBGL3(L3_MSG, "STI_L1STAT: unit %d layer 1 = %s", unit, status ? "up" : "down");
 			break;
 			
 		case STI_L2STAT:
 			i4b_l4_l12stat(unit, 2, parm);
-			DBGL3(L3_MSG, "i4b_mdl_status_ind", ("STI_L2STAT: unit %d layer 2 = %s\n", unit, status ? "up" : "down"));
+			NDBGL3(L3_MSG, "STI_L2STAT: unit %d layer 2 = %s", unit, status ? "up" : "down");
 			break;
 
 		case STI_TEIASG:
 			ctrl_desc[unit].tei = parm;
 			i4b_l4_teiasg(unit, parm);
-			DBGL3(L3_MSG, "i4b_mdl_status_ind", ("STI_TEIASG: unit %d TEI = %d = 0x%02x\n", unit, parm, parm));
+			NDBGL3(L3_MSG, "STI_TEIASG: unit %d TEI = %d = 0x%02x", unit, parm, parm);
 			break;
 
 		case STI_PDEACT:	/* L1 T4 timeout */
-			DBGL3(L3_ERR, "i4b_mdl_status_ind", ("STI_PDEACT: unit %d TEI = %d = 0x%02x\n", unit, parm, parm));
+			NDBGL3(L3_ERR, "STI_PDEACT: unit %d TEI = %d = 0x%02x", unit, parm, parm);
 
 			sendup = 0;
 
@@ -181,7 +178,7 @@ i4b_mdl_status_ind(int unit, int status, int parm)
 			break;
 
 		case STI_NOL1ACC:	/* no outgoing access to S0 */
-			DBGL3(L3_ERR, "i4b_mdl_status_ind", ("STI_NOL1ACC: unit %d no outgoing access to S0\n", unit));
+			NDBGL3(L3_ERR, "STI_NOL1ACC: unit %d no outgoing access to S0", unit);
 
 			for(i=0; i < N_CALL_DESC; i++)
 			{
@@ -204,7 +201,7 @@ i4b_mdl_status_ind(int unit, int status, int parm)
 			break;
 
 		default:
-			DBGL3(L3_ERR, "i4b_mdl_status_ind", ("ERROR, unit %d, unknown status value %d!\n", unit, status));
+			NDBGL3(L3_ERR, "ERROR, unit %d, unknown status value %d!", unit, status);
 			break;
 	}		
 	return(0);
@@ -214,14 +211,14 @@ i4b_mdl_status_ind(int unit, int status, int parm)
  *	send command to the lower layers
  *---------------------------------------------------------------------------*/
 static void
-n_mgmt_command(int unit, int cmd, int parm)
+n_mgmt_command(int unit, int cmd, void *parm)
 {
 	int i;
 
 	switch(cmd)
 	{
 		case CMR_DOPEN:
-			DBGL3(L3_MSG, "n_mgmt_command", ("CMR_DOPEN for unit %d\n", unit));
+			NDBGL3(L3_MSG, "CMR_DOPEN for unit %d", unit);
 			
 			for(i=0; i < N_CALL_DESC; i++)
 			{
@@ -239,12 +236,16 @@ n_mgmt_command(int unit, int cmd, int parm)
 			break;
 
 		case CMR_DCLOSE:
-			DBGL3(L3_MSG, "n_mgmt_command", ("CMR_DCLOSE for unit %d\n", unit));
+			NDBGL3(L3_MSG, "CMR_DCLOSE for unit %d", unit);
 			break;
 			
-		default:
+		case CMR_SETTRACE:
+			NDBGL3(L3_MSG, "CMR_SETTRACE for unit %d", unit);
 			break;
 			
+		default:
+			NDBGL3(L3_MSG, "unknown cmd %d for unit %d", cmd, unit);
+			break;
 	}
 
 	MDL_Command_Req(unit, cmd, parm);
@@ -300,7 +301,7 @@ n_connect_response(u_int cdid, int response, int cause)
 		default:	/* failsafe */
 			next_l3state(cd, EV_SETDCRS);
 			chstate = BCH_ST_FREE;
-			DBGL3(L3_ERR, "n_connect_response", ("unknown response, doing SETUP_RESP_DNTCRE"));
+			NDBGL3(L3_ERR, "unknown response, doing SETUP_RESP_DNTCRE");
 			break;
 	}
 
@@ -310,7 +311,7 @@ n_connect_response(u_int cdid, int response, int cause)
 	}
 	else
 	{
-		DBGL3(L3_MSG, "n_connect_response", ("Warning, invalid channelid %d, response = %d\n", cd->channelid, response));
+		NDBGL3(L3_MSG, "Warning, invalid channelid %d, response = %d\n", cd->channelid, response);
 	}
 }
 
diff --git a/sys/i4b/layer3/i4b_q931.c b/sys/i4b/layer3/i4b_q931.c
index 06ccbdc..3e8f7ff 100644
--- a/sys/i4b/layer3/i4b_q931.c
+++ b/sys/i4b/layer3/i4b_q931.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_q931.c - Q931 received messages handling
  *	--------------------------------------------
  *
- *	$Id: i4b_q931.c,v 1.23 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_q931.c,v 1.32 2000/08/24 11:48:58 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:05:33 1999]
+ *      last edit-date: [Mon May 29 16:56:52 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -44,17 +44,16 @@
 #if NI4BQ931 > 0
 
 #include <sys/param.h>
-
-#if defined(__FreeBSD__)
-#else
-#include <sys/ioctl.h>
-#endif
-
+#include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -97,6 +96,8 @@ unsigned char cause_tab_q931[CAUSE_I4B_MAX] = {
 	CAUSE_Q850_CALLREJ,	/* CAUSE_I4B_REJECT -> call rejected */
 	CAUSE_Q850_DSTOOORDR,	/* CAUSE_I4B_OOO -> destination out of order */
 	CAUSE_Q850_TMPFAIL,	/* CAUSE_I4B_TMPFAIL -> temporary failure */
+	CAUSE_Q850_USRBSY,	/* CAUSE_I4B_L1ERROR -> L1 error / persistent deact XXX */
+	CAUSE_Q850_USRBSY,	/* CAUSE_I4B_LLDIAL -> no dialout on leased line XXX */
 };	
 
 /*---------------------------------------------------------------------------*
@@ -134,9 +135,16 @@ i4b_decode_q931(int unit, int msg_len, u_char *msg_ptr)
 	
 	if(*msg_ptr != PD_Q931)
 	{
-		DBGL3(L3_P_ERR, "i4b_decode_q931", ("protocol discriminator 0x%x != Q.931\n", *msg_ptr));
+		static int protoflag = -1;	/* print only once .. */
+
+		if(*msg_ptr != protoflag)
+		{
+			NDBGL3(L3_P_ERR, "unknown protocol discriminator 0x%x!", *msg_ptr);
+			protoflag = *msg_ptr;
+		}			
 		return;
 	}
+
 	msg_ptr++;
 	msg_len--;
 
@@ -168,7 +176,7 @@ i4b_decode_q931(int unit, int msg_len, u_char *msg_ptr)
 		crflag = 0;
 	}
 			
-	DBGL3(L3_P_MSG, "i4b_decode_q931", ("Call Ref, len %d, val %d, flag %d\n", crlen, crval, crflag));
+	NDBGL3(L3_P_MSG, "Call Ref, len %d, val %d, flag %d", crlen, crval, crflag);
 
 	/* find or allocate calldescriptor */
 
@@ -190,7 +198,7 @@ i4b_decode_q931(int unit, int msg_len, u_char *msg_ptr)
 		{
 /*XXX*/			if(crval != 0)	/* ignore global call references */
 			{
-				DBGL3(L3_P_ERR, "i4b_decode_q931", ("cannot find calldescriptor for cr = 0x%x, crflag = 0x%x, msg = 0x%x, frame = ", crval, crflag, *msg_ptr));
+				NDBGL3(L3_P_ERR, "cannot find calldescriptor for cr = 0x%x, crflag = 0x%x, msg = 0x%x, frame = ", crval, crflag, *msg_ptr);
 				i4b_print_frame(msg_len, msg_ptr);
 			}
 			splx(s);
@@ -223,7 +231,7 @@ i4b_decode_q931(int unit, int msg_len, u_char *msg_ptr)
 			if((shift_flag != SHIFTED) &&
 			   (codeset <= old_codeset))
 			{
-				DBGL3(L3_P_ERR, "i4b_decode_q931", ("Q.931 lockingshift proc violation, shift %d -> %d\n", old_codeset, codeset));
+				NDBGL3(L3_P_ERR, "Q.931 lockingshift proc violation, shift %d -> %d", old_codeset, codeset);
 				codeset = old_codeset;
 			}
 			msg_len--;
@@ -241,7 +249,7 @@ i4b_decode_q931(int unit, int msg_len, u_char *msg_ptr)
 				break;
 				
 			default:
-				DBGL3(L3_P_ERR, "i4b_decode_q931", ("unknown codeset %d, ", codeset));
+				NDBGL3(L3_P_ERR, "unknown codeset %d, ", codeset);
 				i4b_print_frame(msg_len, msg_ptr);
 				msg_len = 0;
 				break;
@@ -269,15 +277,23 @@ i4b_decode_q931_cs0_ie(int unit, call_desc_t *cd, int msg_len, u_char *msg_ptr)
 	
 	switch(*msg_ptr)
 	{
+
+/*********/
+/* Q.931 */
+/*********/
 		/* single byte IE's */
 		
 		case IEI_SENDCOMPL:
-			DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_SENDCOMPL\n"));
+			NDBGL3(L3_P_MSG, "IEI_SENDCOMPL");
 			return(1);
 			break;
 
 		/* multi byte IE's */
 		
+		case IEI_SEGMMSG:	/* segmented message */
+			NDBGL3(L3_P_MSG, "IEI_SEGMENTED_MESSAGE");
+			break;
+			
 		case IEI_BEARERCAP:	/* bearer capability */
 			switch(msg_ptr[2])
 			{
@@ -285,17 +301,17 @@ i4b_decode_q931_cs0_ie(int unit, call_desc_t *cd, int msg_len, u_char *msg_ptr)
 				case 0x89:	/* restricted digital info */
 				case 0x90:	/* 3.1KHz audio */
 /* XXX */				cd->bprot = BPROT_NONE;
-					DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_BEARERCAP - Telephony\n"));
+					NDBGL3(L3_P_MSG, "IEI_BEARERCAP - Telephony");
 					break;
 
 				case 0x88:	/* unrestricted digital info */
 /* XXX */				cd->bprot = BPROT_RHDLC;
-					DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_BEARERCAP - Raw HDLC\n"));
+					NDBGL3(L3_P_MSG, "IEI_BEARERCAP - Raw HDLC");
 					break;
 
 				default:
 /* XXX */				cd->bprot = BPROT_NONE;
-					DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_BEARERCAP - No Protocol\n"));
+					NDBGL3(L3_P_ERR, "IEI_BEARERCAP - Unsupported B-Protocol 0x%x", msg_ptr[2]);
 					break;
 			}
 			break;
@@ -304,20 +320,29 @@ i4b_decode_q931_cs0_ie(int unit, call_desc_t *cd, int msg_len, u_char *msg_ptr)
 			if(msg_ptr[2] & 0x80)
 			{
 				cd->cause_in = msg_ptr[3] & 0x7f;
-				DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_CAUSE = %d\n", msg_ptr[3] & 0x7f));
+				NDBGL3(L3_P_MSG, "IEI_CAUSE = %d", msg_ptr[3] & 0x7f);
 			}
 			else
 			{
 				cd->cause_in = msg_ptr[4] & 0x7f;
-				DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_CAUSE = %d\n", msg_ptr[4] & 0x7f));
+				NDBGL3(L3_P_MSG, "IEI_CAUSE = %d", msg_ptr[4] & 0x7f);
 			}
 			break;
 	
+		case IEI_CALLID:	/* call identity */
+			NDBGL3(L3_P_MSG, "IEI_CALL_IDENTITY");
+			break;
+
+		case IEI_CALLSTATE:	/* call state		*/
+			cd->call_state = msg_ptr[2] & 0x3f;		
+			NDBGL3(L3_P_MSG, "IEI_CALLSTATE = %d", cd->call_state);
+			break;
+			
 		case IEI_CHANNELID:	/* channel id */
 			if((msg_ptr[2] & 0xf4) != 0x80)
 			{
 				cd->channelid = CHAN_NO;
-				DBGL3(L3_P_ERR, "i4b_decode_q931_cs0_ie", ("IEI_CHANNELID, unsupported value 0x%x\n", msg_ptr[2]));
+				NDBGL3(L3_P_ERR, "IEI_CHANNELID, unsupported value 0x%x", msg_ptr[2]);
 			}
 			else
 			{
@@ -338,7 +363,7 @@ i4b_decode_q931_cs0_ie(int unit, call_desc_t *cd, int msg_len, u_char *msg_ptr)
 				}
 				cd->channelexcl = (msg_ptr[2] & 0x08) >> 3;
 
-				DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_CHANNELID - channel %d, exclusive = %d\n", cd->channelid, cd->channelexcl));
+				NDBGL3(L3_P_MSG, "IEI_CHANNELID - channel %d, exclusive = %d", cd->channelid, cd->channelexcl);
 
 				/* if this is a setup message, reserve channel */
 				
@@ -349,102 +374,149 @@ i4b_decode_q931_cs0_ie(int unit, call_desc_t *cd, int msg_len, u_char *msg_ptr)
 						if(ctrl_desc[cd->controller].bch_state[cd->channelid] == BCH_ST_FREE)
 							ctrl_desc[cd->controller].bch_state[cd->channelid] = BCH_ST_RSVD;
 						else
-							DBGL3(L3_P_ERR, "i4b_decode_q931_cs0_ie", ("IE ChannelID, Channel NOT free!!\n"));
+							NDBGL3(L3_P_ERR, "IE ChannelID, Channel NOT free!!");
 					}
 					else if(cd->channelid == CHAN_NO)
 					{
-						DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IE ChannelID, SETUP with channel = No channel (CW)\n"));
+						NDBGL3(L3_P_MSG, "IE ChannelID, SETUP with channel = No channel (CW)");
 					}
 					else /* cd->channelid == CHAN_ANY */
 					{
-						DBGL3(L3_P_ERR, "i4b_decode_q931_cs0_ie", ("ERROR: IE ChannelID, SETUP with channel = Any channel!\n"));
+						NDBGL3(L3_P_ERR, "ERROR: IE ChannelID, SETUP with channel = Any channel!");
 					}
 				}
 			}
 			break;				
 	
+		case IEI_PROGRESSI:	/* progress indicator	*/
+			NDBGL3(L3_P_MSG, "IEI_PROGRESSINDICATOR");
+			break;
+			
+		case IEI_NETSPCFAC:	/* network specific fac */
+			NDBGL3(L3_P_MSG, "IEI_NETSPCFAC");
+			break;
+			
+		case IEI_NOTIFIND:	/* notification indicator */
+			NDBGL3(L3_P_MSG, "IEI_NOTIFICATION_INDICATOR");
+			break;
+			
+		case IEI_DISPLAY:	/* display		*/
+			memcpy(cd->display, &msg_ptr[2], min(DISPLAY_MAX, msg_ptr[1]));
+			cd->display[min(DISPLAY_MAX, msg_ptr[1])] = '\0';
+			NDBGL3(L3_P_MSG, "IEI_DISPLAY = %s", cd->display);
+  			break;
+			
+		case IEI_DATETIME:	/* date/time		*/
+			i = 2;
+			j = msg_ptr[1];
+			p = &(cd->datetime[0]);
+			*p = '\0';
+			
+			for(j = msg_ptr[1]; j > 0; j--, i++)
+				sprintf(p+strlen(p), "%02d", msg_ptr[i]);
+			
+			NDBGL3(L3_P_MSG, "IEI_DATETIME = %s", cd->datetime);
+			break;
+			
+		case IEI_KEYPAD:	/* keypad facility */
+			NDBGL3(L3_P_MSG, "IEI_KEYPAD_FACILITY");
+			break;
+			
+		case IEI_SIGNAL:	/* signal type */
+			NDBGL3(L3_P_MSG, "IEI_SIGNAL = %d", msg_ptr[2]);
+			break;
+
+		case IEI_INFRATE:	/* information rate */
+			NDBGL3(L3_P_MSG, "IEI_INFORMATION_RATE");
+			break;
+
+		case IEI_ETETDEL:	/* end to end transit delay */
+			NDBGL3(L3_P_MSG, "IEI_END_TO_END_TRANSIT_DELAY");
+			break;
+
+		case IEI_CUG:		/* closed user group */
+			NDBGL3(L3_P_MSG, "IEI_CLOSED_USER_GROUP");
+			break;
+
 		case IEI_CALLINGPN:	/* calling party no */
 			if(msg_ptr[2] & 0x80) /* no presentation/screening indicator ? */
 			{
 				memcpy(cd->src_telno, &msg_ptr[3], min(TELNO_MAX, msg_ptr[1]-1));
 				cd->src_telno[min(TELNO_MAX, msg_ptr[1] - 1)] = '\0';
 				cd->scr_ind = SCR_NONE;
+				cd->prs_ind = PRS_NONE;				
 			}
 			else
 			{
 				memcpy(cd->src_telno, &msg_ptr[4], min(TELNO_MAX, msg_ptr[1]-2));
 				cd->src_telno[min(TELNO_MAX, msg_ptr[1] - 2)] = '\0';
 				cd->scr_ind = (msg_ptr[3] & 0x03) + SCR_USR_NOSC;
+				cd->prs_ind = ((msg_ptr[3] >> 5) & 0x03) + PRS_ALLOWED;
 			}
-			DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_CALLINGPN = %s\n", cd->src_telno));
+			NDBGL3(L3_P_MSG, "IEI_CALLINGPN = %s", cd->src_telno);
 			break;
 	
+		case IEI_CALLINGPS:	/* calling party subaddress */
+			NDBGL3(L3_P_MSG, "IEI_CALLINGPS");
+			break;
+			
 		case IEI_CALLEDPN:	/* called party number */
 			memcpy(cd->dst_telno, &msg_ptr[3], min(TELNO_MAX, msg_ptr[1]-1));
 			cd->dst_telno[min(TELNO_MAX, msg_ptr [1] - 1)] = '\0';
-			DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_CALLED = %s\n", cd->dst_telno)); 
+			NDBGL3(L3_P_MSG, "IEI_CALLED = %s", cd->dst_telno); 
 			break;
 	
-		case IEI_CALLSTATE:	/* call state		*/
-			cd->call_state = msg_ptr[2] & 0x3f;		
-			DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_CALLSTATE = %d\n", cd->call_state));
+		case IEI_CALLEDPS:	/* called party subaddress */
+			NDBGL3(L3_P_MSG, "IEI_CALLEDPS");
 			break;
-			
-		case IEI_PROGRESSI:	/* progress indicator	*/
-			DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_PROGRESSINDICATOR\n"));
+
+		case IEI_REDIRNO:	/* redirecting number */
+			NDBGL3(L3_P_MSG, "IEI_REDIRECTING_NUMBER");
 			break;
-			
-		case IEI_DISPLAY:	/* display		*/
-			/* CHANGED BY <chris@medis.de> */
-			memcpy(cd->display, &msg_ptr[2], min(DISPLAY_MAX, msg_ptr[1]));
-			cd->display[min(DISPLAY_MAX, msg_ptr[1])] = '\0';
-			DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_DISPLAY = %s\n", cd->display));
-  			break;
-			
-		case IEI_DATETIME:	/* date/time		*/
-			i = 2;
-			j = msg_ptr[1];
-			p = &(cd->datetime[0]);
-			*p = '\0';
-			
-			for(j = msg_ptr[1]; j > 0; j--, i++)
-				sprintf(p+strlen(p), "%02d", msg_ptr[i]);
-			
-			DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_DATETIME = %s\n", cd->datetime));
+
+		case IEI_TRNSEL:	/* transit network selection */
+			NDBGL3(L3_P_MSG, "IEI_TRANSIT_NETWORK_SELECTION");
 			break;
-			
-		case IEI_FACILITY:	/* facility		*/
-			DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_FACILITY\n"));
-			if(i4b_aoc(msg_ptr, cd) > -1)
-				i4b_l4_charging_ind(cd);
+
+		case IEI_RESTARTI:	/* restart indicator */
+			NDBGL3(L3_P_MSG, "IEI_RESTART_INDICATOR");
 			break;
-			
-		case IEI_CONCTDNO:	/* connected number	*/
-			DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_CONCTDNO\n"));
+
+		case IEI_LLCOMPAT:	/* low layer compat */
+			NDBGL3(L3_P_MSG, "IEI_LLCOMPAT");
 			break;
 			
-		case IEI_NETSPCFAC:	/* network specific fac */
-			DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_NETSPCFAC\n"));
+		case IEI_HLCOMPAT:	/* high layer compat	*/
+			NDBGL3(L3_P_MSG, "IEI_HLCOMPAT");
 			break;
 			
-		case IEI_LLCOMPAT:	/* low layer compat	*/
-			DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_LLCOMPAT\n"));
+		case IEI_USERUSER:	/* user-user */
+			NDBGL3(L3_P_MSG, "IEI_USER_USER");
 			break;
 			
-		case IEI_HLCOMPAT:	/* high layer compat	*/
-			DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_HLCOMPAT\n"));
+		case IEI_ESCAPE:	/* escape for extension */
+			NDBGL3(L3_P_MSG, "IEI_ESCAPE");
 			break;
 			
-		case IEI_CALLINGPS:	/* calling party subaddress */
-			DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_CALLINGPS\n"));
+/*********/
+/* Q.932 */
+/*********/
+		case IEI_FACILITY:	/* facility		*/
+			NDBGL3(L3_P_MSG, "IEI_FACILITY");
+			if(i4b_aoc(msg_ptr, cd) > -1)
+				i4b_l4_charging_ind(cd);
 			break;
 			
-		case IEI_CALLEDPS:	/* called party subaddress */
-			DBGL3(L3_P_MSG, "i4b_decode_q931_cs0_ie", ("IEI_CALLEDPS\n"));
+/*********/
+/* Q.95x */
+/*********/
+		case IEI_CONCTDNO:	/* connected number	*/
+			NDBGL3(L3_P_MSG, "IEI_CONCTDNO");
 			break;
 			
+			
 		default:
-			DBGL3(L3_P_ERR, "i4b_decode_q931_cs0_ie", ("Unknown IE %d - ", *msg_ptr));
+			NDBGL3(L3_P_ERR, "Unknown IE %d - ", *msg_ptr);
 			i4b_print_frame(msg_ptr[1]+2, msg_ptr);
 			break;
 	}
@@ -457,29 +529,31 @@ i4b_decode_q931_cs0_ie(int unit, call_desc_t *cd, int msg_len, u_char *msg_ptr)
 void
 i4b_decode_q931_message(int unit, call_desc_t *cd, u_char message_type)
 {
-	cd->event = EV_ILL;
+	char *m = NULL;
 	
+	cd->event = EV_ILL;
+
 	switch(message_type)
 	{
 		/* call establishment */
 
 		case ALERT:
 			cd->event = EV_ALERT;			
-			DBGL3(L3_PRIM, "rx ALERT", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "ALERT";
 			break;
 			
 		case CALL_PROCEEDING:
 			cd->event = EV_CALLPRC;
-			DBGL3(L3_PRIM, "rx CALL-PROC", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "CALL_PROCEEDING";
 			break;
 			
 		case PROGRESS:
 			cd->event = EV_PROGIND;
-			DBGL3(L3_PRIM, "rx PROGRESS", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "PROGRESS";
 			break;
 			
 		case SETUP:
-			DBGL3(L3_PRIM, "rx SETUP", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "SETUP";
 			cd->bprot = BPROT_NONE;
 			cd->cause_in = 0;
 			cd->cause_out = 0;			
@@ -493,142 +567,146 @@ i4b_decode_q931_message(int unit, call_desc_t *cd, u_char message_type)
 			break;
 			
 		case CONNECT:
-			DBGL3(L3_PRIM, "rx CONNECT", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "CONNECT";
 			cd->datetime[0] = '\0';		
 			cd->event = EV_CONNECT;			
 			break;
 			
 		case SETUP_ACKNOWLEDGE:
-			DBGL3(L3_PRIM, "rx SETUP-ACK", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "SETUP_ACKNOWLEDGE";
 			cd->event = EV_SETUPAK;
 			break;
 			
 		case CONNECT_ACKNOWLEDGE:
-			DBGL3(L3_PRIM, "rx CONNECT-ACK", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "CONNECT_ACKNOWLEDGE";
 			cd->event = EV_CONACK;
 			break;
 			
 		/* call information */
 
 		case USER_INFORMATION:
-			DBGL3(L3_PRIM, "rx USER-INFO", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "USER_INFORMATION";
 			break;
 	
 		case SUSPEND_REJECT:
-			DBGL3(L3_PRIM, "rx SUSPEND-REJ", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "SUSPEND_REJECT";
 			break;
 			
 		case RESUME_REJECT:
-			DBGL3(L3_PRIM, "rx RESUME-REJ", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "RESUME_REJECT";
 			break;
 			
 		case HOLD:
-			DBGL3(L3_PRIM, "rx HOLD", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "HOLD";
 			break;
 			
 		case SUSPEND:
-			DBGL3(L3_PRIM, "rx SUSPEND", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "SUSPEND";
 			break;
 			
 		case RESUME:
-			DBGL3(L3_PRIM, "rx RESUME", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "RESUME";
 			break;
 			
 		case HOLD_ACKNOWLEDGE:
-			DBGL3(L3_PRIM, "rx HOLD-ACK", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "HOLD_ACKNOWLEDGE";
 			break;
 			
 		case SUSPEND_ACKNOWLEDGE:
-			DBGL3(L3_PRIM, "rx SUSPEND-ACK", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "SUSPEND_ACKNOWLEDGE";
 			break;
 			
 		case RESUME_ACKNOWLEDGE:
-			DBGL3(L3_PRIM, "rx RESUME-ACK", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "RESUME_ACKNOWLEDGE";
 			break;
 			
 		case HOLD_REJECT:
-			DBGL3(L3_PRIM, "rx HOLD-REJ", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "HOLD_REJECT";
 			break;
 			
 		case RETRIEVE:
-			DBGL3(L3_PRIM, "rx RETRIEVE", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "RETRIEVE";
 			break;
 			
 		case RETRIEVE_ACKNOWLEDGE:
-			DBGL3(L3_PRIM, "rx RETRIEVE-ACK", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "RETRIEVE_ACKNOWLEDGE";
 			break;
 			
 		case RETRIEVE_REJECT:
-			DBGL3(L3_PRIM, "rx RETRIEVE-REJ", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "RETRIEVE_REJECT";
 			break;
 			
 		/* call clearing */
 
 		case DISCONNECT:
-			DBGL3(L3_PRIM, "rx DISCONNECT", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "DISCONNECT";
 			cd->event = EV_DISCONN;
 			break;
 	
 		case RESTART:
-			DBGL3(L3_PRIM, "rx RESTART", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "RESTART";
 			break;
 			
 		case RELEASE:
-			DBGL3(L3_PRIM, "rx RELEASE", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "RELEASE";
 			cd->event = EV_RELEASE;
 			break;
 			
 		case RESTART_ACKNOWLEDGE:
-			DBGL3(L3_PRIM, "rx RESTART-ACK", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "RESTART_ACKNOWLEDGE";
 			break;
 			
 		case RELEASE_COMPLETE:
-			DBGL3(L3_PRIM, "rx RELEASE-COMPLETE", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "RELEASE_COMPLETE";
 			cd->event = EV_RELCOMP;		
 			break;
 			
 		/* misc messages */
 
 		case SEGMENT:
-			DBGL3(L3_PRIM, "rx SEGMENT", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "SEGMENT";
 			break;
 	
 		case FACILITY:
-			DBGL3(L3_PRIM, "rx FACILITY", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "FACILITY";
 			cd->event = EV_FACILITY;		
 			break;
 			
 		case REGISTER:
-			DBGL3(L3_PRIM, "rx REGISTER", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "REGISTER";
 			break;
 			
 		case NOTIFY:
-			DBGL3(L3_PRIM, "rx NOTIFY", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "NOTIFY";
 			break;
 			
 		case STATUS_ENQUIRY:
-			DBGL3(L3_PRIM, "rx STATUS-ENQ", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "STATUS_ENQUIRY";
 			cd->event = EV_STATENQ;		
 			break;
 			
 		case CONGESTION_CONTROL:
-			DBGL3(L3_PRIM, "rx CONGESTION-CONTROL", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "CONGESTION_CONTROL";
 			break;
 			
 		case INFORMATION:
-			DBGL3(L3_PRIM, "rx INFORMATION", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "INFORMATION";
 			cd->event = EV_INFO;		
 			break;
 			
 		case STATUS:
-			DBGL3(L3_PRIM, "rx STATUS", ("unit %d, cr = 0x%02x\n", unit, cd->cr));
+			m = "STATUS";
 			cd->event = EV_STATUS;		
 			break;
 			
 		default:
-			DBGL3(L3_P_ERR, "rx UNKNOWN msg", ("unit %d, cr = 0x%02x, msg = 0x%02x\n", unit, cd->cr, message_type));
+			NDBGL3(L3_P_ERR, "unit %d, cr = 0x%02x, msg = 0x%02x", unit, cd->cr, message_type);
 			break;
 	}
+	if(m)
+	{
+		NDBGL3(L3_PRIM, "%s: unit %d, cr = 0x%02x\n", m, unit, cd->cr);
+	}
 }
 
 #endif /* NI4BQ931 > 0 */
diff --git a/sys/i4b/layer3/i4b_q931.h b/sys/i4b/layer3/i4b_q931.h
index bbfc9b6..5568607 100644
--- a/sys/i4b/layer3/i4b_q931.h
+++ b/sys/i4b/layer3/i4b_q931.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_q931.h - Q931 handling header file
  *	--------------------------------------
  *
- *	$Id: i4b_q931.h,v 1.8 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_q931.h,v 1.9 2000/04/27 09:25:22 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:05:44 1999]
+ *      last edit-date: [Thu Apr 27 11:07:37 2000]
  *
  *---------------------------------------------------------------------------*/
 
diff --git a/sys/i4b/layer3/i4b_q932fac.c b/sys/i4b/layer3/i4b_q932fac.c
index a791b08..4ef2644 100644
--- a/sys/i4b/layer3/i4b_q932fac.c
+++ b/sys/i4b/layer3/i4b_q932fac.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_q932fac.c - Q932 facility handling
  *	--------------------------------------
  *
- *	$Id: i4b_q932fac.c,v 1.8 1999/12/13 21:25:27 hm Exp $ 
+ *	$Id: i4b_q932fac.c,v 1.11 2000/08/24 11:48:58 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:05:51 1999]
+ *      last edit-date: [Mon May 29 16:57:04 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -43,17 +43,16 @@
 #if NI4BQ931 > 0
 
 #include <sys/param.h>
-
-#if defined(__FreeBSD__)
-#else
-#include <sys/ioctl.h>
-#endif
-
+#include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -105,24 +104,24 @@ i4b_aoc(unsigned char *buf, call_desc_t *cd)
 	{
 		case FAC_PROTO_ROP:
 			break;
-			
+
 		case FAC_PROTO_CMIP:
-			DBGL3(L3_A_MSG, "i4b_facility", ("CMIP Protocol (Q.941), UNSUPPORTED\n"));
+			NDBGL3(L3_A_MSG, "CMIP Protocol (Q.941), UNSUPPORTED");
 			return(-1);
 			break;
 
 		case FAC_PROTO_ACSE:
-			DBGL3(L3_A_MSG, "i4b_facility", ("ACSE Protocol (X.217/X.227), UNSUPPORTED!\n"));
+			NDBGL3(L3_A_MSG, "ACSE Protocol (X.217/X.227), UNSUPPORTED!");
 			return(-1);
 			break;
 
 		default:
-			DBGL3(L3_A_ERR, "i4b_facility", ("Unknown Protocol, UNSUPPORTED!\n"));
+			NDBGL3(L3_A_ERR, "Unknown Protocol, UNSUPPORTED!");
 			return(-1);
 			break;
 	}
 
-	DBGL3(L3_A_MSG, "i4b_facility", ("Remote Operations Protocol\n"));
+	NDBGL3(L3_A_MSG, "Remote Operations Protocol");
 
 	/* next byte */
 	
@@ -382,7 +381,7 @@ F_2(int val)
 {
 	if(val != -1)
 	{
-		DBGL3(L3_A_MSG, "i4b_facility", ("Invoke ID = %d\n", val));
+		NDBGL3(L3_A_MSG, "Invoke ID = %d", val);
 		state = ST_EXP_OP_VAL;
 	}
 }
@@ -395,7 +394,7 @@ F_3(int val)
 {
 	if(val != -1)
 	{
-		DBGL3(L3_A_MSG, "i4b_facility", ("Operation Value = %d\n", val));
+		NDBGL3(L3_A_MSG, "Operation Value = %d", val);
 	
 		operation_value = val;
 		
@@ -429,7 +428,7 @@ F_4_1(int val)
 {
 	if(val == -1)
 	{
-		DBGL3(L3_A_MSG, "i4b_facility", ("Free of Charge\n"));
+		NDBGL3(L3_A_MSG, "Free of Charge");
 		/* units = 0; XXXX */
 		state = ST_EXP_NIX;
 	}
@@ -443,7 +442,7 @@ F_4_2(int val)
 {
 	if(val == -1)
 	{
-		DBGL3(L3_A_MSG, "i4b_facility", ("Charge not available\n"));
+		NDBGL3(L3_A_MSG, "Charge not available");
 		/* units = -1; 	XXXXXX ??? */
 		state = ST_EXP_NIX;
 	}
@@ -477,7 +476,7 @@ F_7(int val)
 {
 	if(val != -1)
 	{
-		DBGL3(L3_A_MSG, "i4b_facility", ("Number of Units = %d\n", val));
+		NDBGL3(L3_A_MSG, "Number of Units = %d", val);
 		units = val;
 		state = ST_EXP_TOCI;
 	}
@@ -491,7 +490,7 @@ F_8(int val)
 {
 	if(val != -1)
 	{
-		DBGL3(L3_A_MSG, "i4b_facility", ("Subtotal/Total = %d\n", val));
+		NDBGL3(L3_A_MSG, "Subtotal/Total = %d", val);
 		/* type_of_charge = val; */
 		state = ST_EXP_DBID;
 	}
@@ -505,7 +504,7 @@ F_9(int val)
 {
 	if(val != -1)
 	{
-		DBGL3(L3_A_MSG, "i4b_facility", ("Billing ID = %d\n", val));
+		NDBGL3(L3_A_MSG, "Billing ID = %d", val);
 		/* billing_id = val; */
 		state = ST_EXP_NIX;
 	}
diff --git a/sys/i4b/layer3/i4b_q932fac.h b/sys/i4b/layer3/i4b_q932fac.h
index d878c2e..0c92177 100644
--- a/sys/i4b/layer3/i4b_q932fac.h
+++ b/sys/i4b/layer3/i4b_q932fac.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_q932fac.h - Q932 facility handling header file
  *	--------------------------------------------------
  *
- *	$Id: i4b_q932fac.h,v 1.7 1999/12/13 21:25:28 hm Exp $ 
+ *	$Id: i4b_q932fac.h,v 1.8 2000/04/27 09:25:22 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:06:00 1999]
+ *      last edit-date: [Thu Apr 27 11:07:52 2000]
  *
  *---------------------------------------------------------------------------
  *
diff --git a/sys/i4b/layer4/i4b_i4bdrv.c b/sys/i4b/layer4/i4b_i4bdrv.c
index 0821c2d..ed61e64 100644
--- a/sys/i4b/layer4/i4b_i4bdrv.c
+++ b/sys/i4b/layer4/i4b_i4bdrv.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_i4bdrv.c - i4b userland interface driver
  *	--------------------------------------------
  *
- *	$Id: i4b_i4bdrv.c,v 1.52 1999/12/13 21:25:28 hm Exp $ 
+ *	$Id: i4b_i4bdrv.c,v 1.59 2000/10/06 08:37:43 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:06:11 1999]
+ *      last edit-date: [Mon Oct  2 09:55:28 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -39,11 +39,6 @@
 #include "i4bipr.h"
 #include "i4btel.h"
 
-#ifdef __bsdi__
-#include "ibc.h"
-#else
-#include "i4bisppp.h"
-#endif
 
 #if NI4B > 1
 #error "only 1 (one) i4b device possible!"
@@ -71,6 +66,36 @@
 #include <sys/select.h>
 #include <net/if.h>
 
+#ifdef __NetBSD__
+#include <sys/types.h>
+#endif
+
+#if defined(__FreeBSD__)
+#include "i4bing.h"
+#endif
+
+#ifdef __bsdi__
+#include "ibc.h"
+#else
+#ifdef __FreeBSD__
+#include "i4bisppp.h"
+#else
+#include <net/if_sppp.h>
+#endif
+#endif
+
+#ifdef __FreeBSD__
+
+#if defined(__FreeBSD__) && __FreeBSD__ == 3
+#include "opt_devfs.h"
+#endif
+
+#ifdef DEVFS
+#include <sys/devfsext.h>
+#endif
+
+#endif /* __FreeBSD__*/
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -99,6 +124,9 @@ static int selflag = 0;
 static int readflag = 0;
 
 #if defined(__FreeBSD__) && __FreeBSD__ == 3
+#ifdef DEVFS
+static void *devfs_token;
+#endif
 #endif
 
 #ifndef __FreeBSD__
@@ -240,6 +268,11 @@ i4battach()
 #if defined(__FreeBSD__)
 #if __FreeBSD__ == 3
 
+#ifdef DEVFS
+	devfs_token = devfs_add_devswf(&i4b_cdevsw, 0, DV_CHR,
+				       UID_ROOT, GID_WHEEL, 0600,
+				       "i4b");
+#endif
 
 #else
 	make_dev(&i4b_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600, "i4b");
@@ -296,16 +329,17 @@ i4bread(dev_t dev, struct uio *uio, int ioflag)
 	if(minor(dev))
 		return(ENODEV);
 
+	x = splimp();
 	while(IF_QEMPTY(&i4b_rdqueue))
 	{
-		x = splimp();
 		readflag = 1;
+		error = tsleep((caddr_t) &i4b_rdqueue, (PZERO + 1) | PCATCH, "bird", 0);
+		if (error != 0) {
 		splx(x);
-		tsleep((caddr_t) &i4b_rdqueue, (PZERO + 1) | PCATCH, "bird", 0);
+			return error;
+		}
 	}
 
-	x = splimp();
-
 	IF_DEQUEUE(&i4b_rdqueue, m);
 
 	splx(x);
@@ -361,7 +395,7 @@ i4bioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 
 			if((cd = cd_by_cdid(mcr->cdid)) == NULL)/* get cd */
 			{
-				DBGL4(L4_ERR, "i4bioctl", ("I4B_CONNECT_REQ ioctl, cdid not found!\n")); 
+				NDBGL4(L4_ERR, "I4B_CONNECT_REQ ioctl, cdid not found!"); 
 				error = EINVAL;
 				break;
 			}
@@ -399,9 +433,9 @@ i4bioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 
 			cd->dir = DIR_OUTGOING;
 			
-			DBGL4(L4_TIMO, "i4bioctl", ("I4B_CONNECT_REQ times, algorithm=%ld unitlen=%ld idle=%ld earlyhup=%ld\n",
+			NDBGL4(L4_TIMO, "I4B_CONNECT_REQ times, algorithm=%ld unitlen=%ld idle=%ld earlyhup=%ld",
 					(long)cd->shorthold_data.shorthold_algorithm, (long)cd->shorthold_data.unitlen_time,
-					(long)cd->shorthold_data.idle_time, (long)cd->shorthold_data.earlyhup_time));
+					(long)cd->shorthold_data.idle_time, (long)cd->shorthold_data.earlyhup_time);
 
 			strcpy(cd->dst_telno, mcr->dst_telno);
 			strcpy(cd->src_telno, mcr->src_telno);
@@ -460,7 +494,7 @@ i4bioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 
 			if((cd = cd_by_cdid(mcrsp->cdid)) == NULL)/* get cd */
 			{
-				DBGL4(L4_ERR, "i4bioctl", ("I4B_CONNECT_RESP ioctl, cdid not found!\n")); 
+				NDBGL4(L4_ERR, "I4B_CONNECT_RESP ioctl, cdid not found!"); 
 				error = EINVAL;
 				break;
 			}
@@ -478,7 +512,7 @@ i4bioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 
 			cd->isdntxdelay = mcrsp->txdelay;			
 			
-			DBGL4(L4_TIMO, "i4bioctl", ("I4B_CONNECT_RESP max_idle_time set to %ld seconds\n", (long)cd->max_idle_time));
+			NDBGL4(L4_TIMO, "I4B_CONNECT_RESP max_idle_time set to %ld seconds", (long)cd->max_idle_time);
 
 			(*ctrl_desc[cd->controller].N_CONNECT_RESPONSE)(mcrsp->cdid, mcrsp->response, mcrsp->cause);
 			break;
@@ -494,7 +528,7 @@ i4bioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 
 			if((cd = cd_by_cdid(mdr->cdid)) == NULL)/* get cd */
 			{
-				DBGL4(L4_ERR, "i4bioctl", ("I4B_DISCONNECT_REQ ioctl, cdid not found!\n")); 
+				NDBGL4(L4_ERR, "I4B_DISCONNECT_REQ ioctl, cdid not found!"); 
 				error = EINVAL;
 				break;
 			}
@@ -569,6 +603,12 @@ i4bioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 					dlt = ibc_ret_linktab(mdrsp->driver_unit);
 					break;
 #endif
+
+#if NI4BING > 0
+				case BDRV_ING:
+					dlt = ing_ret_linktab(mdrsp->driver_unit);
+					break;
+#endif					
 			}
 
 			if(dlt != NULL)		
@@ -585,13 +625,13 @@ i4bioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 			
 			mtu = (msg_timeout_upd_t *)data;
 
-			DBGL4(L4_TIMO, "i4bioctl", ("I4B_TIMEOUT_UPD ioctl, alg %d, unit %d, idle %d, early %d!\n",
+			NDBGL4(L4_TIMO, "I4B_TIMEOUT_UPD ioctl, alg %d, unit %d, idle %d, early %d!",
 					mtu->shorthold_data.shorthold_algorithm, mtu->shorthold_data.unitlen_time,
-					mtu->shorthold_data.idle_time, mtu->shorthold_data.earlyhup_time )); 
+					mtu->shorthold_data.idle_time, mtu->shorthold_data.earlyhup_time); 
 
 			if((cd = cd_by_cdid(mtu->cdid)) == NULL)/* get cd */
 			{
-				DBGL4(L4_ERR, "i4bioctl", ("I4B_TIMEOUT_UPD ioctl, cdid not found!\n")); 
+				NDBGL4(L4_ERR, "I4B_TIMEOUT_UPD ioctl, cdid not found!"); 
 				error = EINVAL;
 				break;
 			}
@@ -608,7 +648,7 @@ i4bioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 					     mtu->shorthold_data.idle_time >= 0    &&
 					     mtu->shorthold_data.earlyhup_time >= 0))
 					{
-						DBGL4(L4_ERR, "i4bioctl", ("I4B_TIMEOUT_UPD ioctl, invalid args for fix unit algorithm!\n")); 
+						NDBGL4(L4_ERR, "I4B_TIMEOUT_UPD ioctl, invalid args for fix unit algorithm!"); 
 						error = EINVAL;
 					}
 					break;
@@ -625,13 +665,13 @@ i4bioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 					     mtu->shorthold_data.idle_time >= 0   &&
 					     mtu->shorthold_data.earlyhup_time == 0))
 					{
-						DBGL4(L4_ERR, "i4bioctl", ("I4B_TIMEOUT_UPD ioctl, invalid args for var unit algorithm!\n")); 
+						NDBGL4(L4_ERR, "I4B_TIMEOUT_UPD ioctl, invalid args for var unit algorithm!"); 
 						error = EINVAL;
 					}
 					break;
 	
 				default:
-					DBGL4(L4_ERR, "i4bioctl", ("I4B_TIMEOUT_UPD ioctl, invalid algorithm!\n")); 
+					NDBGL4(L4_ERR, "I4B_TIMEOUT_UPD ioctl, invalid algorithm!"); 
 					error = EINVAL;
 					break;
 			}
@@ -681,7 +721,7 @@ i4bioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
 
 			if((cd = cd_by_cdid(mar->cdid)) == NULL)
 			{
-				DBGL4(L4_ERR, "i4bioctl", ("I4B_ALERT_REQ ioctl, cdid not found!\n")); 
+				NDBGL4(L4_ERR, "I4B_ALERT_REQ ioctl, cdid not found!"); 
 				error = EINVAL;
 				break;
 			}
@@ -945,7 +985,7 @@ i4bputqueue(struct mbuf *m)
 		struct mbuf *m1;
 		IF_DEQUEUE(&i4b_rdqueue, m1);
 		i4b_Dfreembuf(m1);
-		DBGL4(L4_ERR, "i4bputqueue", ("ERROR, queue full, removing entry!\n"));
+		NDBGL4(L4_ERR, "ERROR, queue full, removing entry!");
 	}
 
 	IF_ENQUEUE(&i4b_rdqueue, m);
@@ -986,7 +1026,7 @@ i4bputqueue_hipri(struct mbuf *m)
 		struct mbuf *m1;
 		IF_DEQUEUE(&i4b_rdqueue, m1);
 		i4b_Dfreembuf(m1);
-		DBGL4(L4_ERR, "i4bputqueue", ("ERROR, queue full, removing entry!\n"));
+		NDBGL4(L4_ERR, "ERROR, queue full, removing entry!");
 	}
 
 	IF_PREPEND(&i4b_rdqueue, m);
diff --git a/sys/i4b/layer4/i4b_l4.c b/sys/i4b/layer4/i4b_l4.c
index d54872a..fbb14f1 100644
--- a/sys/i4b/layer4/i4b_l4.c
+++ b/sys/i4b/layer4/i4b_l4.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,32 +27,20 @@
  *	i4b_l4.c - kernel interface to userland
  *	-----------------------------------------
  *
- *	$Id: i4b_l4.c,v 1.45 1999/12/13 21:25:28 hm Exp $ 
+ *	$Id: i4b_l4.c,v 1.54 2000/08/28 07:24:59 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:06:17 1999]
+ *      last edit-date: [Sun Aug 27 14:53:42 2000]
  *
  *---------------------------------------------------------------------------*/
 
 #include "i4b.h"
 #include "i4bipr.h"
-#ifdef __bsdi__
-#define NI4BISPPP 0
-#include "ibc.h"
-#else
-#include "i4bisppp.h"
-#endif
-#include "i4brbch.h"
-#include "i4btel.h"
 
 #if NI4B > 0
 
 #include <sys/param.h>
-#if defined(__FreeBSD__)
-#else
-#include <sys/ioctl.h>
-#endif
 #include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/conf.h>
@@ -62,6 +50,28 @@
 #include <sys/socket.h>
 #include <net/if.h>
 
+#ifdef __NetBSD__
+#include <sys/types.h>
+#endif
+
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
+#if defined(__FreeBSD__)
+#include "i4bing.h"
+#endif
+
+#ifdef __bsdi__
+#define NI4BISPPP 0
+#include "ibc.h"
+#else
+#include "i4bisppp.h"
+#endif
+
+#include "i4brbch.h"
+#include "i4btel.h"
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -93,6 +103,10 @@ static void i4b_idle_check_fix_unit(call_desc_t *cd);
 static void i4b_idle_check_var_unit(call_desc_t *cd);
 static void i4b_l4_setup_timeout_fix_unit(call_desc_t *cd);
 static void i4b_l4_setup_timeout_var_unit(call_desc_t *cd);
+static time_t i4b_get_idletime(call_desc_t *cd);
+#if NI4BISPPP > 0
+extern time_t i4bisppp_idletime(int);
+#endif
 
 /*---------------------------------------------------------------------------*
  *	send MSG_PDEACT_IND message to userland
@@ -114,11 +128,7 @@ i4b_l4_pdeact(int controller, int numactive)
 			
 			if(cd->timeout_active)
 			{
-#if defined(__FreeBSD__)
-				untimeout((TIMEOUT_FUNC_T)i4b_idle_check,(void *)cd, cd->idle_timeout_handle);	
-#else
-				untimeout((TIMEOUT_FUNC_T)i4b_idle_check,(void *)cd);	
-#endif
+				STOP_TIMER(cd->idle_timeout_handle, i4b_idle_check, cd);
 			}
 			
 			if(cd->dlt != NULL)
@@ -370,6 +380,7 @@ i4b_l4_connect_ind(call_desc_t *cd)
 		strcpy(mp->display, cd->display);
 
 		mp->scr_ind = cd->scr_ind;
+		mp->prs_ind = cd->prs_ind;		
 		
 		T400_start(cd);
 		
@@ -390,7 +401,7 @@ i4b_l4_connect_active_ind(call_desc_t *cd)
 
 	cd->last_active_time = cd->connect_time = SECOND;
 
-	DBGL4(L4_TIMO, "i4b_l4_connect_active_ind", ("last_active/connect_time=%ld\n", (long)cd->connect_time));
+	NDBGL4(L4_TIMO, "last_active/connect_time=%ld", (long)cd->connect_time);
 	
 	i4b_link_bchandrvr(cd);
 
@@ -425,11 +436,7 @@ i4b_l4_disconnect_ind(call_desc_t *cd)
 	struct mbuf *m;
 
 	if(cd->timeout_active)
-#if defined(__FreeBSD_version) && __FreeBSD_version >= 300001
-		untimeout((TIMEOUT_FUNC_T)i4b_idle_check,(void *)cd, cd->idle_timeout_handle);	
-#else
-		untimeout((TIMEOUT_FUNC_T)i4b_idle_check,(void *)cd);	
-#endif
+		STOP_TIMER(cd->idle_timeout_handle, i4b_idle_check, cd);
 
 	if(cd->dlt != NULL)
 	{
@@ -444,7 +451,7 @@ i4b_l4_disconnect_ind(call_desc_t *cd)
 	else
 	{
 		/* no error, might be hunting call for callback */
-		DBGL4(L4_MSG, "i4b_l4_disconnect_ind", ("channel free not B1/B2 but %d!\n", cd->channelid));
+		NDBGL4(L4_MSG, "channel free not B1/B2 but %d!", cd->channelid);
 	}
 	
 	if((m = i4b_Dgetmbuf(sizeof(msg_disconnect_ind_t))) != NULL)
@@ -634,6 +641,12 @@ i4b_link_bchandrvr(call_desc_t *cd)
 			break;
 #endif
 
+#if NI4BING > 0
+		case BDRV_ING:
+			cd->dlt = ing_ret_linktab(cd->driver_unit);
+			break;
+#endif
+
 		default:
 			cd->dlt = NULL;
 			break;
@@ -681,6 +694,13 @@ i4b_link_bchandrvr(call_desc_t *cd)
 			ibc_set_linktab(cd->driver_unit, cd->ilt);
 			break;
 #endif
+
+#if NI4BING > 0
+		case BDRV_ING:
+			ing_set_linktab(cd->driver_unit, cd->ilt);
+			break;
+#endif
+
 		default:
 			return(0);
 			break;
@@ -688,8 +708,7 @@ i4b_link_bchandrvr(call_desc_t *cd)
 
 	/* activate B channel */
 		
-	(*cd->ilt->bch_config)(ctrl_desc[cd->controller].unit,
-				cd->channelid, cd->bprot, 1);
+	(*cd->ilt->bch_config)(cd->ilt->unit, cd->ilt->channel, cd->bprot, 1);
 
 	return(0);
 }
@@ -716,8 +735,7 @@ i4b_unlink_bchandrvr(call_desc_t *cd)
 	
 	/* deactivate B channel */
 		
-	(*cd->ilt->bch_config)(ctrl_desc[cd->controller].unit,
-				cd->channelid, cd->bprot, 0);
+	(*cd->ilt->bch_config)(cd->ilt->unit, cd->ilt->channel, cd->bprot, 0);
 } 
 
 /*---------------------------------------------------------------------------
@@ -762,14 +780,28 @@ idletime_state:      IST_NONCHK             IST_CHECK       IST_SAFE
 	
 ---------------------------------------------------------------------------*/	
 
+static time_t
+i4b_get_idletime(call_desc_t *cd)
+{
+	switch (cd->driver) {
+#if NI4BISPPP > 0
+		case BDRV_ISPPP:
+			return i4bisppp_idletime(cd->driver_unit);
+		break;
+#endif
+		default:
+			return cd->last_active_time;
+		break;
+	}
+}
 /*---------------------------------------------------------------------------*
  *	B channel idle check timeout setup
  *---------------------------------------------------------------------------*/ 
 static void
 i4b_l4_setup_timeout(call_desc_t *cd)
 {
-	DBGL4(L4_TIMO, "i4b_l4_setup_timeout", ("%ld: direction %d, shorthold algorithm %d\n",
-		(long)SECOND, cd->dir, cd->shorthold_data.shorthold_algorithm ));
+	NDBGL4(L4_TIMO, "%ld: direction %d, shorthold algorithm %d",
+		(long)SECOND, cd->dir, cd->shorthold_data.shorthold_algorithm);
 	
 	cd->timeout_active = 0;
 	cd->idletime_state = IST_IDLE;
@@ -778,12 +810,9 @@ i4b_l4_setup_timeout(call_desc_t *cd)
 	{
 		/* incoming call: simple max idletime check */
 	
-#if defined(__FreeBSD_version) && __FreeBSD_version >= 300001
-		cd->idle_timeout_handle =
-#endif
-		timeout((TIMEOUT_FUNC_T)i4b_idle_check,(void *)cd, hz/2);
+		START_TIMER(cd->idle_timeout_handle, i4b_idle_check, cd, hz/2);
 		cd->timeout_active = 1;
-		DBGL4(L4_TIMO, "i4b_l4_setup_timeout", ("%ld: incoming-call, setup max_idle_time to %ld\n", (long)SECOND, (long)cd->max_idle_time));
+		NDBGL4(L4_TIMO, "%ld: incoming-call, setup max_idle_time to %ld", (long)SECOND, (long)cd->max_idle_time);
 	}
 	else if((cd->dir == DIR_OUTGOING) && (cd->shorthold_data.idle_time > 0))
 	{
@@ -801,7 +830,7 @@ i4b_l4_setup_timeout(call_desc_t *cd)
 	}
 	else
 	{
-		DBGL4(L4_TIMO, "i4b_l4_setup_timeout", ("no idle_timeout configured\n"));
+		NDBGL4(L4_TIMO, "no idle_timeout configured");
 	}
 }
 
@@ -817,26 +846,20 @@ i4b_l4_setup_timeout_fix_unit(call_desc_t *cd)
 	{
 		/* outgoing call: simple max idletime check */
 		
-#if defined(__FreeBSD_version) && __FreeBSD_version >= 300001
-		cd->idle_timeout_handle =
-#endif
-		timeout((TIMEOUT_FUNC_T)i4b_idle_check,(void *)cd, hz/2);
+		START_TIMER(cd->idle_timeout_handle, i4b_idle_check, cd, hz/2);
 		cd->timeout_active = 1;
-		DBGL4(L4_TIMO, "i4b_l4_setup_timeout", ("%ld: outgoing-call, setup idle_time to %ld\n",
-			(long)SECOND, (long)cd->shorthold_data.idle_time));
+		NDBGL4(L4_TIMO, "%ld: outgoing-call, setup idle_time to %ld",
+			(long)SECOND, (long)cd->shorthold_data.idle_time);
 	}
 	else if((cd->shorthold_data.unitlen_time > 0) && (cd->shorthold_data.unitlen_time > (cd->shorthold_data.idle_time + cd->shorthold_data.earlyhup_time)))
 	{
 		/* outgoing call: full shorthold mode check */
 		
-#if defined(__FreeBSD_version) && __FreeBSD_version >= 300001
-		cd->idle_timeout_handle =
-#endif
-		timeout((TIMEOUT_FUNC_T)i4b_idle_check,(void *)cd, hz*(cd->shorthold_data.unitlen_time - (cd->shorthold_data.idle_time + cd->shorthold_data.earlyhup_time)));
+		START_TIMER(cd->idle_timeout_handle, i4b_idle_check, cd, hz*(cd->shorthold_data.unitlen_time - (cd->shorthold_data.idle_time + cd->shorthold_data.earlyhup_time)));
 		cd->timeout_active = 1;
 		cd->idletime_state = IST_NONCHK;
-		DBGL4(L4_TIMO, "i4b_l4_setup_timeout", ("%ld: outgoing-call, start %ld sec nocheck window\n", 
-			(long)SECOND, (long)(cd->shorthold_data.unitlen_time - (cd->shorthold_data.idle_time + cd->shorthold_data.earlyhup_time))));
+		NDBGL4(L4_TIMO, "%ld: outgoing-call, start %ld sec nocheck window", 
+			(long)SECOND, (long)(cd->shorthold_data.unitlen_time - (cd->shorthold_data.idle_time + cd->shorthold_data.earlyhup_time)));
 
 		if(cd->aocd_flag == 0)
 		{
@@ -849,8 +872,8 @@ i4b_l4_setup_timeout_fix_unit(call_desc_t *cd)
 	{
 		/* parms somehow got wrong .. */
 		
-		DBGL4(L4_ERR, "i4b_l4_setup_timeout", ("%ld: ERROR: idletime[%ld]+earlyhup[%ld] > unitlength[%ld]!\n",
-			(long)SECOND, (long)cd->shorthold_data.idle_time, (long)cd->shorthold_data.earlyhup_time, (long)cd->shorthold_data.unitlen_time));
+		NDBGL4(L4_ERR, "%ld: ERROR: idletime[%ld]+earlyhup[%ld] > unitlength[%ld]!",
+			(long)SECOND, (long)cd->shorthold_data.idle_time, (long)cd->shorthold_data.earlyhup_time, (long)cd->shorthold_data.unitlen_time);
 	}
 }
 
@@ -869,13 +892,10 @@ i4b_l4_setup_timeout_var_unit(call_desc_t *cd)
 	 */
 	cd->idletime_state = IST_CHECK;	/* move directly to the checking state */
 
-#if defined(__FreeBSD_version) && __FreeBSD_version >= 300001
-	cd->idle_timeout_handle =
-#endif
-		timeout((TIMEOUT_FUNC_T)i4b_idle_check,(void *)cd, hz * (cd->shorthold_data.unitlen_time - 1) );
+	START_TIMER(cd->idle_timeout_handle, i4b_idle_check, cd, hz * (cd->shorthold_data.unitlen_time - 1) );
 	cd->timeout_active = 1;
-	DBGL4(L4_TIMO, "i4b_l4_setup_timeout", ("%ld: outgoing-call, var idle time - setup to %ld\n",
-		(long)SECOND, (long)cd->shorthold_data.unitlen_time));
+	NDBGL4(L4_TIMO, "%ld: outgoing-call, var idle time - setup to %ld",
+		(long)SECOND, (long)cd->shorthold_data.unitlen_time);
 }
 
 
@@ -896,7 +916,7 @@ i4b_idle_check(call_desc_t *cd)
 
 	if(cd->timeout_active == 0)
 	{
-		DBGL4(L4_ERR, "i4b_idle_check", ("ERROR: timeout_active == 0 !!!\n"));
+		NDBGL4(L4_ERR, "ERROR: timeout_active == 0 !!!");
 	}
 	else
 	{	
@@ -907,21 +927,18 @@ i4b_idle_check(call_desc_t *cd)
 
 	if(cd->dir == DIR_INCOMING)
 	{
-		if((cd->last_active_time + cd->max_idle_time) <= SECOND)
+		if((i4b_get_idletime(cd) + cd->max_idle_time) <= SECOND)
 		{
-			DBGL4(L4_TIMO, "i4b_idle_check", ("%ld: incoming-call, line idle timeout, disconnecting!\n", (long)SECOND));
+			NDBGL4(L4_TIMO, "%ld: incoming-call, line idle timeout, disconnecting!", (long)SECOND);
 			(*ctrl_desc[cd->controller].N_DISCONNECT_REQUEST)(cd->cdid,
 					(CAUSET_I4B << 8) | CAUSE_I4B_NORMAL);
 			i4b_l4_idle_timeout_ind(cd);
 		}
 		else
 		{
-			DBGL4(L4_TIMO, "i4b_idle_check", ("%ld: incoming-call, activity, last_active=%ld, max_idle=%ld\n", (long)SECOND, (long)cd->last_active_time, (long)cd->max_idle_time));
+			NDBGL4(L4_TIMO, "%ld: incoming-call, activity, last_active=%ld, max_idle=%ld", (long)SECOND, (long)i4b_get_idletime(cd), (long)cd->max_idle_time);
 
-#if defined(__FreeBSD_version) && __FreeBSD_version >= 300001
-			cd->idle_timeout_handle =
-#endif
-			timeout((TIMEOUT_FUNC_T)i4b_idle_check,(void *)cd, hz/2);
+			START_TIMER(cd->idle_timeout_handle, i4b_idle_check, cd, hz/2);
 			cd->timeout_active = 1;
 		}
 	}
@@ -939,8 +956,8 @@ i4b_idle_check(call_desc_t *cd)
 				i4b_idle_check_var_unit( cd );
 				break;
 			default:
-				DBGL4(L4_TIMO, "i4b_idle_check", ("%ld: bad value for shorthold_algorithm of %d\n",
-					(long)SECOND, cd->shorthold_data.shorthold_algorithm ));
+				NDBGL4(L4_TIMO, "%ld: bad value for shorthold_algorithm of %d",
+					(long)SECOND, cd->shorthold_data.shorthold_algorithm);
 				i4b_idle_check_fix_unit( cd );
 				break;
 		}
@@ -959,20 +976,17 @@ i4b_idle_check_fix_unit(call_desc_t *cd)
 
 	if((cd->shorthold_data.idle_time > 0) && (cd->shorthold_data.unitlen_time == 0))
 	{
-		if((cd->last_active_time + cd->shorthold_data.idle_time) <= SECOND)
+		if((i4b_get_idletime(cd) + cd->shorthold_data.idle_time) <= SECOND)
 		{
-			DBGL4(L4_TIMO, "i4b_idle_check", ("%ld: outgoing-call-st, idle timeout, disconnecting!\n", (long)SECOND));
+			NDBGL4(L4_TIMO, "%ld: outgoing-call-st, idle timeout, disconnecting!", (long)SECOND);
 			(*ctrl_desc[cd->controller].N_DISCONNECT_REQUEST)(cd->cdid, (CAUSET_I4B << 8) | CAUSE_I4B_NORMAL);
 			i4b_l4_idle_timeout_ind(cd);
 		}
 		else
 		{
-			DBGL4(L4_TIMO, "i4b_idle_check", ("%ld: outgoing-call-st, activity, last_active=%ld, max_idle=%ld\n",
-					(long)SECOND, (long)cd->last_active_time, (long)cd->shorthold_data.idle_time));
-#if defined(__FreeBSD_version) && __FreeBSD_version >= 300001
-		cd->idle_timeout_handle =
-#endif
-			timeout((TIMEOUT_FUNC_T)i4b_idle_check,(void *)cd, hz/2);
+			NDBGL4(L4_TIMO, "%ld: outgoing-call-st, activity, last_active=%ld, max_idle=%ld",
+					(long)SECOND, (long)i4b_get_idletime(cd), (long)cd->shorthold_data.idle_time);
+			START_TIMER(cd->idle_timeout_handle, i4b_idle_check, cd, hz/2);
 			cd->timeout_active = 1;
 		}
 	}
@@ -987,31 +1001,25 @@ i4b_idle_check_fix_unit(call_desc_t *cd)
 
 		case IST_NONCHK:	/* end of non-check time */
 
-#if defined(__FreeBSD_version) && __FreeBSD_version >= 300001
-			cd->idle_timeout_handle =
-#endif
-			timeout((TIMEOUT_FUNC_T)i4b_idle_check,(void *)cd, hz*(cd->shorthold_data.idle_time));
+			START_TIMER(cd->idle_timeout_handle, i4b_idle_check, cd, hz*(cd->shorthold_data.idle_time));
 			cd->idletimechk_start = SECOND;
 			cd->idletime_state = IST_CHECK;
 			cd->timeout_active = 1;
-			DBGL4(L4_TIMO, "i4b_idle_check", ("%ld: outgoing-call, idletime check window reached!\n", (long)SECOND));
+			NDBGL4(L4_TIMO, "%ld: outgoing-call, idletime check window reached!", (long)SECOND);
 			break;
 
 		case IST_CHECK:		/* end of idletime chk */
-			if((cd->last_active_time > cd->idletimechk_start) &&
-			   (cd->last_active_time <= SECOND))
+			if((i4b_get_idletime(cd) > cd->idletimechk_start) &&
+			   (i4b_get_idletime(cd) <= SECOND))
 			{	/* activity detected */
-#if defined(__FreeBSD_version) && __FreeBSD_version >= 300001
-				cd->idle_timeout_handle =
-#endif
-				timeout((TIMEOUT_FUNC_T)i4b_idle_check,(void *)cd, hz*(cd->shorthold_data.earlyhup_time));
+				START_TIMER(cd->idle_timeout_handle, i4b_idle_check, cd, hz*(cd->shorthold_data.earlyhup_time));
 				cd->timeout_active = 1;
 				cd->idletime_state = IST_SAFE;
-				DBGL4(L4_TIMO, "i4b_idle_check", ("%ld: outgoing-call, activity at %ld, wait earlyhup-end\n", (long)SECOND, (long)cd->last_active_time));
+				NDBGL4(L4_TIMO, "%ld: outgoing-call, activity at %ld, wait earlyhup-end", (long)SECOND, (long)i4b_get_idletime(cd));
 			}
 			else
 			{	/* no activity, hangup */
-				DBGL4(L4_TIMO, "i4b_idle_check", ("%ld: outgoing-call, idle timeout, last activity at %ld\n", (long)SECOND, (long)cd->last_active_time));
+				NDBGL4(L4_TIMO, "%ld: outgoing-call, idle timeout, last activity at %ld", (long)SECOND, (long)i4b_get_idletime(cd));
 				(*ctrl_desc[cd->controller].N_DISCONNECT_REQUEST)(cd->cdid, (CAUSET_I4B << 8) | CAUSE_I4B_NORMAL);
 				i4b_l4_idle_timeout_ind(cd);
 				cd->idletime_state = IST_IDLE;
@@ -1020,10 +1028,7 @@ i4b_idle_check_fix_unit(call_desc_t *cd)
 
 		case IST_SAFE:	/* end of earlyhup time */
 
-#if defined(__FreeBSD_version) && __FreeBSD_version >= 300001
-			cd->idle_timeout_handle =
-#endif
-			timeout((TIMEOUT_FUNC_T)i4b_idle_check,(void *)cd, hz*(cd->shorthold_data.unitlen_time - (cd->shorthold_data.idle_time+cd->shorthold_data.earlyhup_time)));
+			START_TIMER(cd->idle_timeout_handle, i4b_idle_check, cd, hz*(cd->shorthold_data.unitlen_time - (cd->shorthold_data.idle_time+cd->shorthold_data.earlyhup_time)));
 			cd->timeout_active = 1;
 			cd->idletime_state = IST_NONCHK;
 
@@ -1034,11 +1039,11 @@ i4b_idle_check_fix_unit(call_desc_t *cd)
 				i4b_l4_charging_ind(cd);
 			}
 			
-			DBGL4(L4_TIMO, "i4b_idle_check", ("%ld: outgoing-call, earlyhup end, wait for idletime start\n", (long)SECOND));
+			NDBGL4(L4_TIMO, "%ld: outgoing-call, earlyhup end, wait for idletime start", (long)SECOND);
 			break;
 
 		default:
-			DBGL4(L4_ERR, "i4b_idle_check", ("outgoing-call: invalid idletime_state value!\n"));
+			NDBGL4(L4_ERR, "outgoing-call: invalid idletime_state value!");
 			cd->idletime_state = IST_IDLE;
 			break;
 		}
@@ -1056,20 +1061,20 @@ i4b_idle_check_var_unit(call_desc_t *cd)
 
 	/* see if there has been any activity within the last idle_time seconds */
 	case IST_CHECK:
-		if( cd->last_active_time > (SECOND - cd->shorthold_data.idle_time))
+		if( i4b_get_idletime(cd) > (SECOND - cd->shorthold_data.idle_time))
 		{	/* activity detected */
 #if defined(__FreeBSD_version) && __FreeBSD_version >= 300001
 			cd->idle_timeout_handle =
 #endif
 			/* check again in one second */
-			timeout((TIMEOUT_FUNC_T)i4b_idle_check,(void *)cd, hz );
+			START_TIMER(cd->idle_timeout_handle, i4b_idle_check, cd, hz);
 			cd->timeout_active = 1;
 			cd->idletime_state = IST_CHECK;
-			DBGL4(L4_TIMO, "i4b_idle_check", ("%ld: outgoing-call, var idle timeout - activity at %ld, continuing\n", (long)SECOND, (long)cd->last_active_time));
+			NDBGL4(L4_TIMO, "%ld: outgoing-call, var idle timeout - activity at %ld, continuing", (long)SECOND, (long)i4b_get_idletime(cd));
 		}
 		else
 		{	/* no activity, hangup */
-			DBGL4(L4_TIMO, "i4b_idle_check", ("%ld: outgoing-call, var idle timeout - last activity at %ld\n", (long)SECOND, (long)cd->last_active_time));
+			NDBGL4(L4_TIMO, "%ld: outgoing-call, var idle timeout - last activity at %ld", (long)SECOND, (long)i4b_get_idletime(cd));
 			(*ctrl_desc[cd->controller].N_DISCONNECT_REQUEST)(cd->cdid, (CAUSET_I4B << 8) | CAUSE_I4B_NORMAL);
 			i4b_l4_idle_timeout_ind(cd);
 			cd->idletime_state = IST_IDLE;
@@ -1077,7 +1082,7 @@ i4b_idle_check_var_unit(call_desc_t *cd)
 		break;
 
 	default:
-		DBGL4(L4_ERR, "i4b_idle_check", ("outgoing-call: var idle timeout invalid idletime_state value!\n"));
+		NDBGL4(L4_ERR, "outgoing-call: var idle timeout invalid idletime_state value!");
 		cd->idletime_state = IST_IDLE;
 		break;
 	}
diff --git a/sys/i4b/layer4/i4b_l4.h b/sys/i4b/layer4/i4b_l4.h
index 35be567..f1ec1e2 100644
--- a/sys/i4b/layer4/i4b_l4.h
+++ b/sys/i4b/layer4/i4b_l4.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_l4.h - kernel interface to userland header file
  *	---------------------------------------------------
  *
- *	$Id: i4b_l4.h,v 1.17 1999/12/13 21:25:28 hm Exp $ 
+ *	$Id: i4b_l4.h,v 1.18 2000/04/27 11:35:01 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:06:24 1999]
+ *      last edit-date: [Thu Apr 27 13:28:01 2000]
  *
  *---------------------------------------------------------------------------*/
 
diff --git a/sys/i4b/layer4/i4b_l4mgmt.c b/sys/i4b/layer4/i4b_l4mgmt.c
index 1eca5a1..01ef0ff 100644
--- a/sys/i4b/layer4/i4b_l4mgmt.c
+++ b/sys/i4b/layer4/i4b_l4mgmt.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_l4mgmt.c - layer 4 calldescriptor management utilites
  *	-----------------------------------------------------------
  *
- *	$Id: i4b_l4mgmt.c,v 1.26 1999/12/13 21:25:28 hm Exp $ 
+ *	$Id: i4b_l4mgmt.c,v 1.34 2000/09/01 14:11:51 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:06:32 1999]
+ *      last edit-date: [Fri Sep  1 16:06:44 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -40,18 +40,24 @@
 #if NI4B > 0
 
 #include <sys/param.h>
-
-#if defined(__FreeBSD__)
-#include <sys/random.h>
-#else
-#include <sys/ioctl.h>
-#endif
-
+#include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
+#if defined(__FreeBSD__)
+#if defined (__FreeBSD_version) && __FreeBSD_version <= 400000
+#include <machine/random.h>
+#else
+#include <sys/random.h>
+#endif
+#endif
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -74,8 +80,8 @@ static unsigned int get_cdid(void);
 
 int nctrl;				/* number of attached controllers */
 
-#if defined(__FreeBSD__)
-void init_callout(call_desc_t *);
+#if (defined(__NetBSD__) && __NetBSD_Version__ >= 104230000) || defined(__FreeBSD__)
+void i4b_init_callout(call_desc_t *);
 #endif
 
 /*---------------------------------------------------------------------------*
@@ -146,8 +152,8 @@ reserve_cd(void)
 			bzero(&call_desc[i], sizeof(call_desc_t)); /* clear it */
 			call_desc[i].cdid = get_cdid();	/* fill in new cdid */
 			cd = &(call_desc[i]);	/* get pointer to descriptor */
-			DBGL4(L4_MSG, "reserve_cd", ("found free cd - index=%d cdid=%u\n",
-				 i, call_desc[i].cdid));
+			NDBGL4(L4_MSG, "found free cd - index=%d cdid=%u",
+				 i, call_desc[i].cdid);
 			break;
 		}
 	}
@@ -157,8 +163,8 @@ reserve_cd(void)
 	if(cd == NULL)
 		panic("reserve_cd: no free call descriptor available!");
 
-#if defined(__FreeBSD__)
-	init_callout(cd);
+#if (defined(__NetBSD__) && __NetBSD_Version__ >= 104230000) || defined(__FreeBSD__)
+	i4b_init_callout(cd);
 #endif
 
 	return(cd);
@@ -181,8 +187,8 @@ freecd_by_cd(call_desc_t *cd)
 		if( (call_desc[i].cdid != CDID_UNUSED) &&
 		    (&(call_desc[i]) == cd) )
 		{
-			DBGL4(L4_MSG, "freecd_by_cd", ("releasing cd - index=%d cdid=%u cr=%d\n",
-				i, call_desc[i].cdid, cd->cr));
+			NDBGL4(L4_MSG, "releasing cd - index=%d cdid=%u cr=%d",
+				i, call_desc[i].cdid, cd->cr);
 			call_desc[i].cdid = CDID_UNUSED;
 			break;
 		}
@@ -210,10 +216,10 @@ cd_by_cdid(unsigned int cdid)
 	{
 		if(call_desc[i].cdid == cdid)
 		{
-			DBGL4(L4_MSG, "cd_by_cdid", ("found cdid - index=%d cdid=%u cr=%d\n",
-					i, call_desc[i].cdid, call_desc[i].cr));
-#if defined(__FreeBSD__)
-			init_callout(&call_desc[i]);
+			NDBGL4(L4_MSG, "found cdid - index=%d cdid=%u cr=%d",
+					i, call_desc[i].cdid, call_desc[i].cr);
+#if (defined(__NetBSD__) && __NetBSD_Version__ >= 104230000) || defined(__FreeBSD__)
+			i4b_init_callout(&call_desc[i]);
 #endif
 			return(&(call_desc[i]));
 		}
@@ -241,10 +247,10 @@ cd_by_unitcr(int unit, int cr, int crf)
 	     (call_desc[i].cr == cr)                                        &&
 	     (call_desc[i].crflag == crf) )
 	  {
-	    DBGL4(L4_MSG, "cd_by_unitcr", ("found cd, index=%d cdid=%u cr=%d\n",
-				i, call_desc[i].cdid, call_desc[i].cr));
-#if defined(__FreeBSD__)
-	    init_callout(&call_desc[i]);
+	    NDBGL4(L4_MSG, "found cd, index=%d cdid=%u cr=%d",
+			i, call_desc[i].cdid, call_desc[i].cr);
+#if (defined(__NetBSD__) && __NetBSD_Version__ >= 104230000) || defined(__FreeBSD__)
+	    i4b_init_callout(&call_desc[i]);
 #endif
 	    return(&(call_desc[i]));
 	  }
@@ -269,8 +275,14 @@ get_rand_cr(int unit)
 		int found = 1;
 		
 #if defined(__FreeBSD__)
+
+#ifdef RANDOMDEV
 		read_random((char *)&val, sizeof(val));
 #else
+		val = (u_char)random();
+#endif /* RANDOMDEV */
+
+#else
 		val |= unit+i;
 		val <<= i;
 		val ^= (time.tv_sec >> 8) ^ time.tv_usec;
@@ -302,12 +314,13 @@ get_rand_cr(int unit)
 /*---------------------------------------------------------------------------*
  *	initialize the callout handles for FreeBSD
  *---------------------------------------------------------------------------*/
-#if defined(__FreeBSD__)
+#if (defined(__NetBSD__) && __NetBSD_Version__ >= 104230000) || defined(__FreeBSD__)
 void
-init_callout(call_desc_t *cd)
+i4b_init_callout(call_desc_t *cd)
 {
 	if(cd->callouts_inited == 0)
 	{
+#ifdef __FreeBSD__
 		callout_handle_init(&cd->idle_timeout_handle);
 		callout_handle_init(&cd->T303_callout);
 		callout_handle_init(&cd->T305_callout);
@@ -316,6 +329,16 @@ init_callout(call_desc_t *cd)
 		callout_handle_init(&cd->T310_callout);
 		callout_handle_init(&cd->T313_callout);
 		callout_handle_init(&cd->T400_callout);
+#else
+		callout_init(&cd->idle_timeout_handle);
+		callout_init(&cd->T303_callout);
+		callout_init(&cd->T305_callout);
+		callout_init(&cd->T308_callout);
+		callout_init(&cd->T309_callout);
+		callout_init(&cd->T310_callout);
+		callout_init(&cd->T313_callout);
+		callout_init(&cd->T400_callout);
+#endif
 		cd->callouts_inited = 1;
 	}
 }
@@ -335,8 +358,7 @@ i4b_l4_daemon_attached(void)
 	{
 /*XXX*/		if(ctrl_desc[i].ctrl_type == CTRL_PASSIVE)
 		{
-			DBGL4(L4_MSG, "i4b_l4_daemon_attached", ("CMR_DOPEN sent to unit %d\n",	ctrl_desc[i].unit));
-
+			NDBGL4(L4_MSG, "CMR_DOPEN sent to unit %d", ctrl_desc[i].unit);
 			(*ctrl_desc[i].N_MGMT_COMMAND)(ctrl_desc[i].unit, CMR_DOPEN, 0);
 		}
 	}
@@ -357,8 +379,7 @@ i4b_l4_daemon_detached(void)
 	{
 /*XXX*/		if(ctrl_desc[i].ctrl_type == CTRL_PASSIVE)
 		{
-			DBGL4(L4_MSG, "i4b_l4_daemon_detached", ("CMR_DCLOSE sent to unit %d\n", ctrl_desc[i].unit));
-
+			NDBGL4(L4_MSG, "CMR_DCLOSE sent to unit %d", ctrl_desc[i].unit);
 			(*ctrl_desc[i].N_MGMT_COMMAND)(ctrl_desc[i].unit, CMR_DCLOSE, 0);
 		}
 	}
diff --git a/sys/i4b/layer4/i4b_l4timer.c b/sys/i4b/layer4/i4b_l4timer.c
index 288fc56..c9707d7 100644
--- a/sys/i4b/layer4/i4b_l4timer.c
+++ b/sys/i4b/layer4/i4b_l4timer.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 1999 Hellmuth Michaelis. All rights reserved.
+ * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -27,11 +27,11 @@
  *	i4b_l4timer.c - timer and timeout handling for layer 4
  *	--------------------------------------------------------
  *
- *	$Id: i4b_l4timer.c,v 1.15 1999/12/13 21:25:28 hm Exp $ 
+ *	$Id: i4b_l4timer.c,v 1.18 2000/08/24 11:48:58 hm Exp $ 
  *
  * $FreeBSD$
  *
- *      last edit-date: [Mon Dec 13 22:06:39 1999]
+ *      last edit-date: [Thu Aug 24 12:50:17 2000]
  *
  *---------------------------------------------------------------------------*/
 
@@ -40,18 +40,16 @@
 #if NI4B > 0
 
 #include <sys/param.h>
-
-#if defined(__FreeBSD__)
-#else
-#include <sys/ioctl.h>
-#endif
-
 #include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
 #include <net/if.h>
 
+#if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
+#include <sys/callout.h>
+#endif
+
 #ifdef __FreeBSD__
 #include <machine/i4b_debug.h>
 #include <machine/i4b_ioctl.h>
@@ -72,7 +70,7 @@
 static void
 T400_timeout(call_desc_t *cd)
 {
-	DBGL4(L4_ERR, "T400_timeout", ("cr = %d\n", cd->cr));
+	NDBGL4(L4_ERR, "cr = %d", cd->cr);
 }
 
 /*---------------------------------------------------------------------------*
@@ -84,14 +82,10 @@ T400_start(call_desc_t *cd)
 	if (cd->T400 == TIMER_ACTIVE)
 		return;
 		
-	DBGL4(L4_MSG, "T400_start", ("cr = %d\n", cd->cr));
+	NDBGL4(L4_MSG, "cr = %d", cd->cr);
 	cd->T400 = TIMER_ACTIVE;
 
-#if defined(__FreeBSD__)
-	cd->T400_callout = timeout((TIMEOUT_FUNC_T)T400_timeout, (void *)cd, T400DEF);
-#else
-	timeout((TIMEOUT_FUNC_T)T400_timeout, (void *)cd, T400DEF);
-#endif
+	START_TIMER(cd->T400_callout, T400_timeout, cd, T400DEF);
 }
 
 /*---------------------------------------------------------------------------*
@@ -105,15 +99,11 @@ T400_stop(call_desc_t *cd)
 
 	if(cd->T400 == TIMER_ACTIVE)
 	{
-#if defined(__FreeBSD__)
-		untimeout((TIMEOUT_FUNC_T)T400_timeout, (void *)cd, cd->T400_callout);
-#else
-		untimeout((TIMEOUT_FUNC_T)T400_timeout, (void *)cd);
-#endif
+		STOP_TIMER(cd->T400_callout, T400_timeout, cd);
 		cd->T400 = TIMER_IDLE;
 	}
 	CRIT_END;
-	DBGL4(L4_MSG, "T400_stop", ("cr = %d\n", cd->cr));
+	NDBGL4(L4_MSG, "cr = %d", cd->cr);
 }
 
 #endif /* NI4B > 0 */