Tom Gray's new tip changes to support a modem capabilities database and

fixes to many assorted bugs and misfeatures.
Submitted by:	Tom Gray - DCA <dcasba@rain.org>

17 files changed, 3969 insertions, 0 deletions

diff --git a/usr.bin/tip/libacu/Makefile b/usr.bin/tip/libacu/Makefile
new file mode 100644
index 0000000..1fb8ba0
--- /dev/null
+++ b/usr.bin/tip/libacu/Makefile
@@ -0,0 +1,6 @@
+CFLAGS+= -g -I../tip
+SRCS=acucommon.c biz22.c courier.c df.c dn11.c hayes.c multitech.c t3000.c tod.c unidialer.c v3451.c v831.c ventel.c
+LIB=acu
+$(OBJS): ../tip/tipconf.h
+install:
+.include <bsd.lib.mk>
diff --git a/usr.bin/tip/libacu/acucommon.c b/usr.bin/tip/libacu/acucommon.c
new file mode 100644
index 0000000..479e9a3
--- /dev/null
+++ b/usr.bin/tip/libacu/acucommon.c
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 1986, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)acucommon.c	8.1 (Berkeley) 6/6/93";
+#endif /* not lint */
+
+/*
+ * Routines for calling up on a Courier modem.
+ * Derived from Hayes driver.
+ */
+#include "tipconf.h"
+#include "tip.h"
+
+#if HAVE_SELECT
+#include <sys/types.h>
+#include <sys/times.h>
+#include <unistd.h>
+
+void acu_nap (unsigned int how_long)
+{
+	struct timeval t;
+	t.tv_usec = (how_long % 1000) * 1000;
+	t.tv_sec = how_long / 1000;
+	(void) select (0, NULL, NULL, NULL, &t);
+}
+
+#elif HAVE_USLEEP
+void acu_nap (unsigned int how_long)
+{
+	(void) usleep (how_long * 1000);
+}
+
+#else
+
+/*
+ * Code stolen from /usr/src/lib/libc/gen/sleep.c
+ */
+#define mask(s) (1<<((s)-1))
+#define setvec(vec, a) \
+        vec.sv_handler = a; vec.sv_mask = vec.sv_onstack = 0
+
+static int ringring;
+
+static void acunap_napx()
+{
+	ringring = 1;
+}
+
+void acu_nap (unsigned int how_long)
+{
+				int omask;
+        struct itimerval itv, oitv;
+        register struct itimerval *itp = &itv;
+        struct sigvec vec, ovec;
+
+        timerclear(&itp->it_interval);
+        timerclear(&itp->it_value);
+        if (setitimer(ITIMER_REAL, itp, &oitv) < 0)
+					return;
+        setvec(ovec, SIG_DFL);
+        omask = sigblock(mask(SIGALRM));
+        itp->it_value.tv_sec = how_long / 1000;
+				itp->it_value.tv_usec = ((how_long % 1000) * 1000);
+        setvec(vec, acunap_napx);
+        ringring = 0;
+        (void) sigvec(SIGALRM, &vec, &ovec);
+        (void) setitimer(ITIMER_REAL, itp, (struct itimerval *)0);
+        while (!ringring)
+					sigpause(omask &~ mask(SIGALRM));
+        (void) sigvec(SIGALRM, &ovec, (struct sigvec *)0);
+        (void) setitimer(ITIMER_REAL, &oitv, (struct itimerval *)0);
+				(void) sigsetmask(omask);
+}
+
+#endif /* HAVE_USLEEP */
+
+void acu_hw_flow_control (hw_flow_control)
+{
+#if HAVE_TERMIOS
+	struct termios t;
+	if (tcgetattr (FD, &t) == 0) {
+		if (hw_flow_control)
+			t.c_cflag |= CRTSCTS;
+		else
+			t.c_cflag &= ~CRTSCTS;
+		tcsetattr (FD, TCSANOW, &t);
+	}
+#endif /* HAVE_TERMIOS */
+}
+
+int acu_flush ()
+{
+#ifdef TIOCFLUSH
+	int flags = 0;
+	return (ioctl (FD, TIOCFLUSH, &flags) == 0);	/* flush any clutter */
+#elif !HAVE_TERMIOS
+	struct sgttyb buf;
+	return (ioctl (FD, TIOCGETP, &buf) == 0 && ioctl (FD, TIOCSETP, &buf) == 0);
+#endif
+}
+
+int acu_getspeed ()
+{
+#if HAVE_TERMIOS
+	struct termios term;
+	tcgetattr (FD, &term);
+	return (term.c_ospeed);
+#else /* HAVE_TERMIOS */
+	struct sgttyb buf;
+	ioctl (FD, TIOCGETP, &buf);
+	return (buf.sg_ospeed);
+#endif
+}
+
+int acu_setspeed (int speed)
+{
+	int rc = 0;
+#if HAVE_TERMIOS
+	struct termios term;
+	if (tcgetattr (FD, &term) == 0) {
+#ifndef _POSIX_SOURCE
+		cfsetspeed (&term, speed);
+#else
+		cfsetispeed (&term, speed);
+		cfsetospeed (&term, speed);
+#endif
+		if (tcsetattr (FD, TCSANOW, &term) == 0)
+			++rc;
+	}
+#else /* HAVE TERMIOS */
+	struct sgttyb sb;
+	if (ioctl(FD, TIOCGETP, &sb) < 0) {
+		perror("TIOCGETP");
+	}
+	else {
+		sb.sg_ispeed = sb.sg_ospeed = speed;
+		if (ioctl(FD, TIOCSETP, &sb) < 0) {
+			perror("TIOCSETP");
+		}
+		else
+			++rc;
+	}
+#endif /* HAVE TERMIOS */
+	return (rc);
+}
+
+void acu_hupcl ()
+{
+#if HAVE_TERMIOS
+	struct termios term;
+	tcgetattr (FD, &term);
+	term.c_cflag |= HUPCL;
+	tcsetattr (FD, TCSANOW, &term);
+#elif defined(TIOCHPCL)
+	ioctl(FD, TIOCHPCL, 0);
+#endif
+}
+
+/* end of acucommon.c */
diff --git a/usr.bin/tip/libacu/acucommon.h b/usr.bin/tip/libacu/acucommon.h
new file mode 100644
index 0000000..50d28cd
--- /dev/null
+++ b/usr.bin/tip/libacu/acucommon.h
@@ -0,0 +1,6 @@
+void acu_nap (unsigned int how_long);
+void acu_hw_flow_control (int hw_flow_control);
+int acu_flush ();
+void acu_hupcl ();
+int acu_setspeed (int speed);
+/* end of acucommon.h */
diff --git a/usr.bin/tip/libacu/biz22.c b/usr.bin/tip/libacu/biz22.c
new file mode 100644
index 0000000..63fb11c
--- /dev/null
+++ b/usr.bin/tip/libacu/biz22.c
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 1983, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)biz22.c	8.1 (Berkeley) 6/6/93";
+#endif /* not lint */
+
+#include "tipconf.h"
+#include "tip.h"
+
+#define DISCONNECT_CMD	"\20\04"	/* disconnection string */
+
+static	void sigALRM();
+static	int timeout = 0;
+static	jmp_buf timeoutbuf;
+
+/*
+ * Dial up on a BIZCOMP Model 1022 with either
+ * 	tone dialing (mod = "V")
+ *	pulse dialing (mod = "W")
+ */
+static int
+biz_dialer(num, mod)
+	char *num, *mod;
+{
+	register int connected = 0;
+	char cbuf[40];
+	static int cmd(), detect();
+
+	if (boolean(value(VERBOSE)))
+		printf("\nstarting call...");
+	/*
+	 * Disable auto-answer and configure for tone/pulse
+	 *  dialing
+	 */
+	if (cmd("\02K\r")) {
+		printf("can't initialize bizcomp...");
+		return (0);
+	}
+	strcpy(cbuf, "\02.\r");
+	cbuf[1] = *mod;
+	if (cmd(cbuf)) {
+		printf("can't set dialing mode...");
+		return (0);
+	}
+	strcpy(cbuf, "\02D");
+	strcat(cbuf, num);
+	strcat(cbuf, "\r");
+	write(FD, cbuf, strlen(cbuf));
+	if (!detect("7\r")) {
+		printf("can't get dial tone...");
+		return (0);
+	}
+	if (boolean(value(VERBOSE)))
+		printf("ringing...");
+	/*
+	 * The reply from the BIZCOMP should be:
+	 *	2 \r or 7 \r	failure
+	 *	1 \r		success
+	 */
+	connected = detect("1\r");
+#if ACULOG
+	if (timeout) {
+		char line[80];
+
+		sprintf(line, "%d second dial timeout",
+			number(value(DIALTIMEOUT)));
+		logent(value(HOST), num, "biz1022", line);
+	}
+#endif
+	if (timeout)
+		biz22_disconnect();	/* insurance */
+	return (connected);
+}
+
+biz22w_dialer(num, acu)
+	char *num, *acu;
+{
+
+	return (biz_dialer(num, "W"));
+}
+
+biz22f_dialer(num, acu)
+	char *num, *acu;
+{
+
+	return (biz_dialer(num, "V"));
+}
+
+biz22_disconnect()
+{
+	int rw = 2;
+
+	write(FD, DISCONNECT_CMD, 4);
+	sleep(2);
+	ioctl(FD, TIOCFLUSH, &rw);
+}
+
+biz22_abort()
+{
+
+	write(FD, "\02", 1);
+}
+
+static void
+sigALRM()
+{
+
+	timeout = 1;
+	longjmp(timeoutbuf, 1);
+}
+
+static int
+cmd(s)
+	register char *s;
+{
+	sig_t f;
+	char c;
+
+	write(FD, s, strlen(s));
+	f = signal(SIGALRM, sigALRM);
+	if (setjmp(timeoutbuf)) {
+		biz22_abort();
+		signal(SIGALRM, f);
+		return (1);
+	}
+	alarm(number(value(DIALTIMEOUT)));
+	read(FD, &c, 1);
+	alarm(0);
+	signal(SIGALRM, f);
+	c &= 0177;
+	return (c != '\r');
+}
+
+static int
+detect(s)
+	register char *s;
+{
+	sig_t f;
+	char c;
+
+	f = signal(SIGALRM, sigALRM);
+	timeout = 0;
+	while (*s) {
+		if (setjmp(timeoutbuf)) {
+			biz22_abort();
+			break;
+		}
+		alarm(number(value(DIALTIMEOUT)));
+		read(FD, &c, 1);
+		alarm(0);
+		c &= 0177;
+		if (c != *s++)
+			return (0);
+	}
+	signal(SIGALRM, f);
+	return (timeout == 0);
+}
diff --git a/usr.bin/tip/libacu/biz31.c b/usr.bin/tip/libacu/biz31.c
new file mode 100644
index 0000000..9553a6d
--- /dev/null
+++ b/usr.bin/tip/libacu/biz31.c
@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) 1983, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)biz31.c	8.1 (Berkeley) 6/6/93";
+#endif /* not lint */
+
+#include "tipconf.h"
+#include "tip.h"
+
+#define MAXRETRY	3		/* sync up retry count */
+#define DISCONNECT_CMD	"\21\25\11\24"	/* disconnection string */
+
+static	void sigALRM();
+static	int timeout = 0;
+static	jmp_buf timeoutbuf;
+
+/*
+ * Dial up on a BIZCOMP Model 1031 with either
+ * 	tone dialing (mod = "f")
+ *	pulse dialing (mod = "w")
+ */
+static int
+biz_dialer(num, mod)
+	char *num, *mod;
+{
+	register int connected = 0;
+
+	if (!bizsync(FD)) {
+		logent(value(HOST), "", "biz", "out of sync");
+		printf("bizcomp out of sync\n");
+		delock(uucplock);
+		exit(0);
+	}
+	if (boolean(value(VERBOSE)))
+		printf("\nstarting call...");
+	echo("#\rk$\r$\n");			/* disable auto-answer */
+	echo("$>$.$ #\r");			/* tone/pulse dialing */
+	echo(mod);
+	echo("$\r$\n");
+	echo("$>$.$ #\re$ ");			/* disconnection sequence */
+	echo(DISCONNECT_CMD);
+	echo("\r$\n$\r$\n");
+	echo("$>$.$ #\rr$ ");			/* repeat dial */
+	echo(num);
+	echo("\r$\n");
+	if (boolean(value(VERBOSE)))
+		printf("ringing...");
+	/*
+	 * The reply from the BIZCOMP should be:
+	 *	`^G NO CONNECTION\r\n^G\r\n'	failure
+	 *	` CONNECTION\r\n^G'		success
+	 */
+	connected = detect(" ");
+#if ACULOG
+	if (timeout) {
+		char line[80];
+
+		sprintf(line, "%d second dial timeout",
+			number(value(DIALTIMEOUT)));
+		logent(value(HOST), num, "biz", line);
+	}
+#endif
+	if (!connected)
+		flush(" NO CONNECTION\r\n\07\r\n");
+	else
+		flush("CONNECTION\r\n\07");
+	if (timeout)
+		biz31_disconnect();	/* insurance */
+	return (connected);
+}
+
+biz31w_dialer(num, acu)
+	char *num, *acu;
+{
+
+	return (biz_dialer(num, "w"));
+}
+
+biz31f_dialer(num, acu)
+	char *num, *acu;
+{
+
+	return (biz_dialer(num, "f"));
+}
+
+biz31_disconnect()
+{
+
+	write(FD, DISCONNECT_CMD, 4);
+	sleep(2);
+	ioctl(FD, TIOCFLUSH);
+}
+
+biz31_abort()
+{
+
+	write(FD, "\33", 1);
+}
+
+static int
+echo(s)
+	register char *s;
+{
+	char c;
+
+	while (c = *s++) switch (c) {
+
+	case '$':
+		read(FD, &c, 1);
+		s++;
+		break;
+
+	case '#':
+		c = *s++;
+		write(FD, &c, 1);
+		break;
+
+	default:
+		write(FD, &c, 1);
+		read(FD, &c, 1);
+	}
+}
+
+static void
+sigALRM()
+{
+
+	timeout = 1;
+	longjmp(timeoutbuf, 1);
+}
+
+static int
+detect(s)
+	register char *s;
+{
+	sig_t f;
+	char c;
+
+	f = signal(SIGALRM, sigALRM);
+	timeout = 0;
+	while (*s) {
+		if (setjmp(timeoutbuf)) {
+			printf("\07timeout waiting for reply\n");
+			biz31_abort();
+			break;
+		}
+		alarm(number(value(DIALTIMEOUT)));
+		read(FD, &c, 1);
+		alarm(0);
+		if (c != *s++)
+			break;
+	}
+	signal(SIGALRM, f);
+	return (timeout == 0);
+}
+
+static int
+flush(s)
+	register char *s;
+{
+	sig_t f;
+	char c;
+
+	f = signal(SIGALRM, sigALRM);
+	while (*s++) {
+		if (setjmp(timeoutbuf))
+			break;
+		alarm(10);
+		read(FD, &c, 1);
+		alarm(0);
+	}
+	signal(SIGALRM, f);
+	timeout = 0;			/* guard against disconnection */
+}
+
+/*
+ * This convoluted piece of code attempts to get
+ *  the bizcomp in sync.  If you don't have the capacity or nread
+ *  call there are gory ways to simulate this.
+ */
+static int
+bizsync(fd)
+{
+#ifdef FIOCAPACITY
+	struct capacity b;
+#	define chars(b)	((b).cp_nbytes)
+#	define IOCTL	FIOCAPACITY
+#endif
+#ifdef FIONREAD
+	long b;
+#	define chars(b)	(b)
+#	define IOCTL	FIONREAD
+#endif
+	register int already = 0;
+	char buf[10];
+
+retry:
+	if (ioctl(fd, IOCTL, (caddr_t)&b) >= 0 && chars(b) > 0)
+		ioctl(fd, TIOCFLUSH);
+	write(fd, "\rp>\r", 4);
+	sleep(1);
+	if (ioctl(fd, IOCTL, (caddr_t)&b) >= 0) {
+		if (chars(b) != 10) {
+	nono:
+			if (already > MAXRETRY)
+				return (0);
+			write(fd, DISCONNECT_CMD, 4);
+			sleep(2);
+			already++;
+			goto retry;
+		} else {
+			read(fd, buf, 10);
+			if (strncmp(buf, "p >\r\n\r\n>", 8))
+				goto nono;
+		}
+	}
+	return (1);
+}
diff --git a/usr.bin/tip/libacu/courier.c b/usr.bin/tip/libacu/courier.c
new file mode 100644
index 0000000..f4aeab3
--- /dev/null
+++ b/usr.bin/tip/libacu/courier.c
@@ -0,0 +1,334 @@
+/*
+ * Copyright (c) 1986, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)courier.c	8.1 (Berkeley) 6/6/93";
+#endif /* not lint */
+
+/*
+ * Routines for calling up on a Courier modem.
+ * Derived from Hayes driver.
+ */
+#include "tipconf.h"
+#include "tip.h"
+#include "acucommon.h"
+#include <stdio.h>
+
+#define	MAXRETRY	5
+
+static	void sigALRM();
+static	int timeout = 0;
+static	int connected = 0;
+static	jmp_buf timeoutbuf, intbuf;
+static	int coursync();
+
+cour_dialer(num, acu)
+	register char *num;
+	char *acu;
+{
+	register char *cp;
+#if ACULOG
+	char line[80];
+#endif
+	static int cour_connect(), cour_swallow();
+
+	if (boolean(value(VERBOSE)))
+		printf("Using \"%s\"\n", acu);
+
+	acu_hupcl ();
+
+	/*
+	 * Get in synch.
+	 */
+	if (!coursync()) {
+badsynch:
+		printf("can't synchronize with courier\n");
+#if ACULOG
+		logent(value(HOST), num, "courier", "can't synch up");
+#endif
+		return (0);
+	}
+	cour_write(FD, "AT E0\r", 6);	/* turn off echoing */
+	sleep(1);
+#ifdef DEBUG
+	if (boolean(value(VERBOSE)))
+		cour_verbose_read();
+#endif
+	ioctl(FD, TIOCFLUSH, 0);	/* flush any clutter */
+	cour_write(FD, "AT C1 E0 H0 Q0 X6 V1\r", 21);
+	if (!cour_swallow("\r\nOK\r\n"))
+		goto badsynch;
+	fflush(stdout);
+	cour_write(FD, "AT D", 4);
+	for (cp = num; *cp; cp++)
+		if (*cp == '=')
+			*cp = ',';
+	cour_write(FD, num, strlen(num));
+	cour_write(FD, "\r", 1);
+	connected = cour_connect();
+#if ACULOG
+	if (timeout) {
+		sprintf(line, "%d second dial timeout",
+			number(value(DIALTIMEOUT)));
+		logent(value(HOST), num, "cour", line);
+	}
+#endif
+	if (timeout)
+		cour_disconnect();
+	return (connected);
+}
+
+cour_disconnect()
+{
+	 /* first hang up the modem*/
+	ioctl(FD, TIOCCDTR, 0);
+	sleep(1);
+	ioctl(FD, TIOCSDTR, 0);
+	coursync();				/* reset */
+	close(FD);
+}
+
+cour_abort()
+{
+	cour_write(FD, "\r", 1);	/* send anything to abort the call */
+	cour_disconnect();
+}
+
+static void
+sigALRM()
+{
+	printf("\07timeout waiting for reply\n");
+	timeout = 1;
+	longjmp(timeoutbuf, 1);
+}
+
+static int
+cour_swallow(match)
+  register char *match;
+  {
+	sig_t f;
+	char c;
+
+	f = signal(SIGALRM, sigALRM);
+	timeout = 0;
+	do {
+		if (*match =='\0') {
+			signal(SIGALRM, f);
+			return (1);
+		}
+		if (setjmp(timeoutbuf)) {
+			signal(SIGALRM, f);
+			return (0);
+		}
+		alarm(number(value(DIALTIMEOUT)));
+		read(FD, &c, 1);
+		alarm(0);
+		c &= 0177;
+#ifdef DEBUG
+		if (boolean(value(VERBOSE)))
+			putchar(c);
+#endif
+	} while (c == *match++);
+#ifdef DEBUG
+	if (boolean(value(VERBOSE)))
+		fflush(stdout);
+#endif
+	signal(SIGALRM, SIG_DFL);
+	return (0);
+}
+
+struct baud_msg {
+	char *msg;
+	int baud;
+} baud_msg[] = {
+	"",		B300,
+	" 1200",	B1200,
+	" 2400",	B2400,
+	" 9600",	B9600,
+	" 9600/ARQ",	B9600,
+	0,		0,
+};
+
+static int
+cour_connect()
+{
+	char c;
+	int nc, nl, n;
+	char dialer_buf[64];
+	struct baud_msg *bm;
+	sig_t f;
+
+	if (cour_swallow("\r\n") == 0)
+		return (0);
+	f = signal(SIGALRM, sigALRM);
+again:
+	nc = 0; nl = sizeof(dialer_buf)-1;
+	bzero(dialer_buf, sizeof(dialer_buf));
+	timeout = 0;
+	for (nc = 0, nl = sizeof(dialer_buf)-1 ; nl > 0 ; nc++, nl--) {
+		if (setjmp(timeoutbuf))
+			break;
+		alarm(number(value(DIALTIMEOUT)));
+		n = read(FD, &c, 1);
+		alarm(0);
+		if (n <= 0)
+			break;
+		c &= 0x7f;
+		if (c == '\r') {
+			if (cour_swallow("\n") == 0)
+				break;
+			if (!dialer_buf[0])
+				goto again;
+			if (strcmp(dialer_buf, "RINGING") == 0 &&
+			    boolean(value(VERBOSE))) {
+#ifdef DEBUG
+				printf("%s\r\n", dialer_buf);
+#endif
+				goto again;
+			}
+			if (strncmp(dialer_buf, "CONNECT",
+				    sizeof("CONNECT")-1) != 0)
+				break;
+			for (bm = baud_msg ; bm->msg ; bm++)
+				if (strcmp(bm->msg,
+				    dialer_buf+sizeof("CONNECT")-1) == 0) {
+					if (!acu_setspeed(bm->baud))
+						goto error;
+					signal(SIGALRM, f);
+#ifdef DEBUG
+					if (boolean(value(VERBOSE)))
+						printf("%s\r\n", dialer_buf);
+#endif
+					return (1);
+				}
+			break;
+		}
+		dialer_buf[nc] = c;
+#ifdef notdef
+		if (boolean(value(VERBOSE)))
+			putchar(c);
+#endif
+	}
+error1:
+	printf("%s\r\n", dialer_buf);
+error:
+	signal(SIGALRM, f);
+	return (0);
+}
+
+/*
+ * This convoluted piece of code attempts to get
+ * the courier in sync.
+ */
+static int
+coursync()
+{
+	int already = 0;
+	int len;
+	char buf[40];
+
+	while (already++ < MAXRETRY) {
+		ioctl(FD, TIOCFLUSH, 0);	/* flush any clutter */
+		cour_write(FD, "\rAT Z\r", 6);	/* reset modem */
+		bzero(buf, sizeof(buf));
+		sleep(1);
+		ioctl(FD, FIONREAD, &len);
+		if (len) {
+			len = read(FD, buf, sizeof(buf));
+#ifdef DEBUG
+			buf[len] = '\0';
+			printf("coursync: (\"%s\")\n\r", buf);
+#endif
+			if (index(buf, '0') || 
+		   	   (index(buf, 'O') && index(buf, 'K')))
+				return(1);
+		}
+		/*
+		 * If not strapped for DTR control,
+		 * try to get command mode.
+		 */
+		sleep(1);
+		cour_write(FD, "+++", 3);
+		sleep(1);
+		/*
+		 * Toggle DTR to force anyone off that might have left
+		 * the modem connected.
+		 */
+		ioctl(FD, TIOCCDTR, 0);
+		sleep(1);
+		ioctl(FD, TIOCSDTR, 0);
+	}
+	cour_write(FD, "\rAT Z\r", 6);
+	return (0);
+}
+
+cour_write(fd, cp, n)
+int fd;
+char *cp;
+int n;
+{
+#ifdef notdef
+	if (boolean(value(VERBOSE)))
+		write(1, cp, n);
+#endif
+	acu_flush ();
+	cour_nap();
+	for ( ; n-- ; cp++) {
+		write(fd, cp, 1);
+		acu_flush ();
+		cour_nap();
+	}
+}
+
+#ifdef DEBUG
+cour_verbose_read()
+{
+	int n = 0;
+	char buf[BUFSIZ];
+
+	if (ioctl(FD, FIONREAD, &n) < 0)
+		return;
+	if (n <= 0)
+		return;
+	if (read(FD, buf, n) != n)
+		return;
+	write(1, buf, n);
+}
+#endif
+
+cour_nap()
+{
+	acu_nap (50);
+}
+
+/* end of courier.c */
diff --git a/usr.bin/tip/libacu/df.c b/usr.bin/tip/libacu/df.c
new file mode 100644
index 0000000..fc60ad3
--- /dev/null
+++ b/usr.bin/tip/libacu/df.c
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 1983, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)df.c	8.1 (Berkeley) 6/6/93";
+#endif /* not lint */
+
+/*
+ * Dial the DF02-AC or DF03-AC
+ */
+
+#include "tipconf.h"
+#include "tip.h"
+
+static jmp_buf Sjbuf;
+static void timeout();
+
+df02_dialer(num, acu)
+	char *num, *acu;
+{
+
+	return (df_dialer(num, acu, 0));
+}
+
+df03_dialer(num, acu)
+	char *num, *acu;
+{
+
+	return (df_dialer(num, acu, 1));
+}
+
+df_dialer(num, acu, df03)
+	char *num, *acu;
+	int df03;
+{
+	register int f = FD;
+	int speed = 0, rw = 2;
+	char c = '\0';
+
+	acu_hupcl ();
+
+	if (setjmp(Sjbuf)) {
+		printf("connection timed out\r\n");
+		df_disconnect();
+		return (0);
+	}
+	if (boolean(value(VERBOSE)))
+		printf("\ndialing...");
+	fflush(stdout);
+#ifdef TIOCMSET
+	if (df03) {
+		int st = TIOCM_ST;	/* secondary Transmit flag */
+
+		if ((speed = acu_getspeed ()) != B1200) {	/* must dial at 1200 baud */
+			acu_setspeed (B1200);
+			ioctl(f, TIOCMBIC, &st); /* clear ST for 300 baud */
+		} else
+			ioctl(f, TIOCMBIS, &st); /* set ST for 1200 baud */
+	}
+#endif
+	signal(SIGALRM, timeout);
+	alarm(5 * strlen(num) + 10);
+	ioctl(f, TIOCFLUSH, &rw);
+	write(f, "\001", 1);
+	sleep(1);
+	write(f, "\002", 1);
+	write(f, num, strlen(num));
+	read(f, &c, 1);
+#ifdef TIOCMSET
+	if (df03 && speed) {
+		acu_setspeed (speed);
+	}
+#endif
+	return (c == 'A');
+}
+
+df_disconnect()
+{
+	int rw = 2;
+
+	write(FD, "\001", 1);
+	sleep(1);
+	ioctl(FD, TIOCFLUSH, &rw);
+}
+
+
+df_abort()
+{
+
+	df_disconnect();
+}
+
+
+static void
+timeout()
+{
+
+	longjmp(Sjbuf, 1);
+}
diff --git a/usr.bin/tip/libacu/dn11.c b/usr.bin/tip/libacu/dn11.c
new file mode 100644
index 0000000..52749da
--- /dev/null
+++ b/usr.bin/tip/libacu/dn11.c
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 1983, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)dn11.c	8.1 (Berkeley) 6/6/93";
+#endif /* not lint */
+
+/*
+ * Routines for dialing up on DN-11
+ */
+#include "tipconf.h"
+#include "tip.h"
+
+int dn_abort();
+void alarmtr();
+static jmp_buf jmpbuf;
+static int child = -1, dn;
+
+dn_dialer(num, acu)
+	char *num, *acu;
+{
+	extern errno;
+	char *p, *q, phone[40];
+	int lt, nw, connected = 1;
+	register int timelim;
+
+	if (boolean(value(VERBOSE)))
+		printf("\nstarting call...");
+	if ((dn = open(acu, 1)) < 0) {
+		if (errno == EBUSY)
+			printf("line busy...");
+		else
+			printf("acu open error...");
+		return (0);
+	}
+	if (setjmp(jmpbuf)) {
+		kill(child, SIGKILL);
+		close(dn);
+		return (0);
+	}
+	signal(SIGALRM, alarmtr);
+	timelim = 5 * strlen(num);
+	alarm(timelim < 30 ? 30 : timelim);
+	if ((child = fork()) == 0) {
+		/*
+		 * ignore this stuff for aborts
+		 */
+		signal(SIGALRM, SIG_IGN);
+		signal(SIGINT, SIG_IGN);
+		signal(SIGQUIT, SIG_IGN);
+		sleep(2);
+		nw = write(dn, num, lt = strlen(num));
+		exit(nw != lt);
+	}
+	/*
+	 * open line - will return on carrier
+	 */
+	if ((FD = open(DV, 2)) < 0) {
+		if (errno == EIO)
+			printf("lost carrier...");
+		else
+			printf("dialup line open failed...");
+		alarm(0);
+		kill(child, SIGKILL);
+		close(dn);
+		return (0);
+	}
+	alarm(0);
+
+#if HAVE_TERMIOS
+	{
+		struct termios term;
+		tcgetattr (dn, &term);
+		term.c_cflag |= HUPCL;
+		tcsetattr (dn, TCSANOW, &term);
+	}
+#elif defined(TIOCHPCL)
+	ioctl(dn, TIOCHPCL, 0);
+#endif
+
+	signal(SIGALRM, SIG_DFL);
+	while ((nw = wait(&lt)) != child && nw != -1)
+		;
+	fflush(stdout);
+	close(dn);
+	if (lt != 0) {
+		close(FD);
+		return (0);
+	}
+	return (1);
+}
+
+void
+alarmtr()
+{
+	alarm(0);
+	longjmp(jmpbuf, 1);
+}
+
+/*
+ * Insurance, for some reason we don't seem to be
+ *  hanging up...
+ */
+dn_disconnect()
+{
+
+	sleep(2);
+	if (FD > 0)
+		ioctl(FD, TIOCCDTR, 0);
+	close(FD);
+}
+
+dn_abort()
+{
+
+	sleep(2);
+	if (child > 0)
+		kill(child, SIGKILL);
+	if (dn > 0)
+		close(dn);
+	if (FD > 0)
+		ioctl(FD, TIOCCDTR, 0);
+	close(FD);
+}
diff --git a/usr.bin/tip/libacu/hayes.c b/usr.bin/tip/libacu/hayes.c
new file mode 100644
index 0000000..6cc6c06
--- /dev/null
+++ b/usr.bin/tip/libacu/hayes.c
@@ -0,0 +1,306 @@
+/*
+ * Copyright (c) 1983, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)hayes.c	8.1 (Berkeley) 6/6/93";
+#endif /* not lint */
+
+/*
+ * Routines for calling up on a Hayes Modem
+ * (based on the old VenTel driver).
+ * The modem is expected to be strapped for "echo".
+ * Also, the switches enabling the DTR and CD lines
+ * must be set correctly.
+ * NOTICE:
+ * The easy way to hang up a modem is always simply to
+ * clear the DTR signal. However, if the +++ sequence
+ * (which switches the modem back to local mode) is sent
+ * before modem is hung up, removal of the DTR signal
+ * has no effect (except that it prevents the modem from
+ * recognizing commands).
+ * (by Helge Skrivervik, Calma Company, Sunnyvale, CA. 1984) 
+ */
+/*
+ * TODO:
+ * It is probably not a good idea to switch the modem
+ * state between 'verbose' and terse (status messages).
+ * This should be kicked out and we should use verbose 
+ * mode only. This would make it consistent with normal
+ * interactive use thru the command 'tip dialer'.
+ */
+#include "tipconf.h"
+#include "tip.h"
+
+#define	min(a,b)	((a < b) ? a : b)
+
+static	void sigALRM();
+static	int timeout = 0;
+static	jmp_buf timeoutbuf;
+static 	char gobble();
+#define DUMBUFLEN	40
+static char dumbuf[DUMBUFLEN];
+
+#define	DIALING		1
+#define IDLE		2
+#define CONNECTED	3
+#define	FAILED		4
+static	int state = IDLE;
+
+hay_dialer(num, acu)
+	register char *num;
+	char *acu;
+{
+	register char *cp;
+	register int connected = 0;
+	char dummy;
+#if ACULOG
+	char line[80];
+#endif
+	if (hay_sync() == 0)		/* make sure we can talk to the modem */
+		return(0);
+	if (boolean(value(VERBOSE)))
+		printf("\ndialing...");
+	fflush(stdout);
+	acu_hupcl ();
+	acu_flush ();
+	write(FD, "ATv0\r", 5);	/* tell modem to use short status codes */
+	gobble("\r");
+	gobble("\r");
+	write(FD, "ATTD", 4);	/* send dial command */
+	write(FD, num, strlen(num));
+	state = DIALING;
+	write(FD, "\r", 1);
+	connected = 0;
+	if (gobble("\r")) {
+		if ((dummy = gobble("01234")) != '1')
+			error_rep(dummy);
+		else
+			connected = 1;
+	}
+	if (connected)
+		state = CONNECTED;
+	else {
+		state = FAILED;
+		return (connected);	/* lets get out of here.. */
+	}
+	ioctl(FD, TIOCFLUSH, 0);
+#if ACULOG
+	if (timeout) {
+		sprintf(line, "%d second dial timeout",
+			number(value(DIALTIMEOUT)));
+		logent(value(HOST), num, "hayes", line);
+	}
+#endif
+	if (timeout)
+		hay_disconnect();	/* insurance */
+	return (connected);
+}
+
+
+hay_disconnect()
+{
+	char c;
+	int len, rlen;
+
+	/* first hang up the modem*/
+#ifdef DEBUG
+	printf("\rdisconnecting modem....\n\r");
+#endif
+	ioctl(FD, TIOCCDTR, 0);
+	sleep(1);
+	ioctl(FD, TIOCSDTR, 0);
+	goodbye();
+}
+
+hay_abort()
+{
+
+	char c;
+
+	write(FD, "\r", 1);	/* send anything to abort the call */
+	hay_disconnect();
+}
+
+static void
+sigALRM()
+{
+
+	printf("\07timeout waiting for reply\n\r");
+	timeout = 1;
+	longjmp(timeoutbuf, 1);
+}
+
+static char
+gobble(match)
+	register char *match;
+{
+	char c;
+	sig_t f;
+	int i, status = 0;
+
+	f = signal(SIGALRM, sigALRM);
+	timeout = 0;
+#ifdef DEBUG
+	printf("\ngobble: waiting for %s\n", match);
+#endif
+	do {
+		if (setjmp(timeoutbuf)) {
+			signal(SIGALRM, f);
+			return (0);
+		}
+		alarm(number(value(DIALTIMEOUT)));
+		read(FD, &c, 1);
+		alarm(0);
+		c &= 0177;
+#ifdef DEBUG
+		printf("%c 0x%x ", c, c);
+#endif
+		for (i = 0; i < strlen(match); i++)
+			if (c == match[i])
+				status = c;
+	} while (status == 0);
+	signal(SIGALRM, SIG_DFL);
+#ifdef DEBUG
+	printf("\n");
+#endif
+	return (status);
+}
+
+error_rep(c)
+	register char c;
+{
+	printf("\n\r");
+	switch (c) {
+
+	case '0':
+		printf("OK");
+		break;
+
+	case '1':
+		printf("CONNECT");
+		break;
+	
+	case '2':
+		printf("RING");
+		break;
+	
+	case '3':
+		printf("NO CARRIER");
+		break;
+	
+	case '4':
+		printf("ERROR in input");
+		break;
+	
+	case '5':
+		printf("CONNECT 1200");
+		break;
+	
+	default:
+		printf("Unknown Modem error: %c (0x%x)", c, c);
+	}
+	printf("\n\r");
+	return;
+}
+
+/*
+ * set modem back to normal verbose status codes.
+ */
+goodbye()
+{
+	int len, rlen;
+	char c;
+
+	ioctl(FD, TIOCFLUSH, &len);	/* get rid of trash */
+	if (hay_sync()) {
+		sleep(1);
+#ifndef DEBUG
+		ioctl(FD, TIOCFLUSH, 0);
+#endif
+		write(FD, "ATH0\r", 5);		/* insurance */
+#ifndef DEBUG
+		c = gobble("03");
+		if (c != '0' && c != '3') {
+			printf("cannot hang up modem\n\r");
+			printf("please use 'tip dialer' to make sure the line is hung up\n\r");
+		}
+#endif
+		sleep(1);
+		ioctl(FD, FIONREAD, &len);
+#ifdef DEBUG
+		printf("goodbye1: len=%d -- ", len);
+		rlen = read(FD, dumbuf, min(len, DUMBUFLEN));
+		dumbuf[rlen] = '\0';
+		printf("read (%d): %s\r\n", rlen, dumbuf);
+#endif
+		write(FD, "ATv1\r", 5);
+		sleep(1);
+#ifdef DEBUG
+		ioctl(FD, FIONREAD, &len);
+		printf("goodbye2: len=%d -- ", len);
+		rlen = read(FD, dumbuf, min(len, DUMBUFLEN));
+		dumbuf[rlen] = '\0';
+		printf("read (%d): %s\r\n", rlen, dumbuf);
+#endif
+	}
+	ioctl(FD, TIOCFLUSH, 0);	/* clear the input buffer */
+	ioctl(FD, TIOCCDTR, 0);		/* clear DTR (insurance) */
+	close(FD);
+}
+
+#define MAXRETRY	5
+
+hay_sync()
+{
+	int len, retry = 0;
+
+	while (retry++ <= MAXRETRY) {
+		write(FD, "AT\r", 3);
+		sleep(1);
+		ioctl(FD, FIONREAD, &len);
+		if (len) {
+			len = read(FD, dumbuf, min(len, DUMBUFLEN));
+			if (index(dumbuf, '0') || 
+		   	(index(dumbuf, 'O') && index(dumbuf, 'K')))
+				return(1);
+#ifdef DEBUG
+			dumbuf[len] = '\0';
+			printf("hay_sync: (\"%s\") %d\n\r", dumbuf, retry);
+#endif
+		}
+		ioctl(FD, TIOCCDTR, 0);
+		ioctl(FD, TIOCSDTR, 0);
+	}
+	printf("Cannot synchronize with hayes...\n\r");
+	return(0);
+}
diff --git a/usr.bin/tip/libacu/multitech.c b/usr.bin/tip/libacu/multitech.c
new file mode 100644
index 0000000..44ee6c2
--- /dev/null
+++ b/usr.bin/tip/libacu/multitech.c
@@ -0,0 +1,402 @@
+/*
+ * Copyright (c) 1986, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)multitech.c	8.1 (Berkeley) 6/6/93";
+#endif /* not lint */
+
+/*
+ * Routines for calling up on a Courier modem.
+ * Derived from Hayes driver.
+ */
+#include "tipconf.h"
+#include "tip.h"
+#include "acucommon.h"
+
+#include <stdio.h>
+
+/* #define DEBUG /**/
+#define	MAXRETRY	5
+/*
+	Configuration
+*/
+static CONST char *dial_command = "ATDT";
+static CONST char *hangup_command = "ATH\r";
+static CONST char *echo_off_command = "ATE0\r";
+static CONST char *reset_command = "\rATZ\r";
+static CONST char *init_string = "AT$BA0$SB38400&E1&E4&E13&E15Q0V1X4E0S0=0\r";
+static CONST char *escape_sequence = "+++"; /* return to command escape sequence */
+static CONST int lock_baud = 1;
+static CONST unsigned int intercharacter_delay = 20; 
+static CONST unsigned int intercommand_delay = 250; 
+static CONST unsigned int escape_guard_time = 250;
+static CONST unsigned int reset_delay = 2000;
+
+/*
+	Forward declarations
+*/
+void multitech_write (int fd, CONST char *cp, int n);
+void multitech_write_str (int fd, CONST char *cp);
+void multitech_disconnect ();
+void acu_nap (unsigned int how_long);
+static void sigALRM ();
+static int multitechsync ();
+static int multitech_swallow (register char *match);
+
+/*
+	Global vars
+*/
+static int timeout = 0;
+static int connected = 0;
+static jmp_buf timeoutbuf, intbuf;
+
+int multitech_dialer (register char *num, char *acu)
+{
+	register char *cp;
+#if ACULOG
+	char line [80];
+#endif
+	static int multitech_connect(), multitech_swallow();
+
+	if (lock_baud)
+	{
+		int i;
+		if ((i = speed(number(value(BAUDRATE)))) == NULL) 
+			return 0;
+		ttysetup (i);
+	}
+
+	if (boolean(value(VERBOSE)))
+		printf("Using \"%s\"\n", acu);
+
+	acu_hupcl ();
+
+	/*
+	 * Get in synch.
+	 */
+	if (!multitechsync()) {
+badsynch:
+		printf("can't synchronize with multitech\n");
+#if ACULOG
+		logent(value(HOST), num, "multitech", "can't synch up");
+#endif
+		return (0);
+	}
+	acu_nap (intercommand_delay); 
+
+	multitech_write_str (FD, echo_off_command);	/* turn off echoing */
+
+	sleep(1);
+
+#ifdef DEBUG
+	if (boolean(value(VERBOSE)))
+		multitech_verbose_read();
+#endif
+
+	acu_flush ();
+
+	acu_nap (intercommand_delay); 
+	multitech_write_str (FD, init_string);
+
+	if (!multitech_swallow ("\r\nOK\r\n"))
+		goto badsynch;
+
+	fflush (stdout);
+
+	acu_nap (intercommand_delay); 
+	multitech_write_str (FD, dial_command);
+
+	for (cp = num; *cp; cp++)
+		if (*cp == '=')
+			*cp = ',';
+
+	multitech_write_str (FD, num);
+
+	multitech_write_str (FD, "\r");
+
+	connected = multitech_connect();
+
+#if ACULOG
+	if (timeout) {
+		sprintf(line, "%d second dial timeout",
+			number(value(DIALTIMEOUT)));
+		logent(value(HOST), num, "multitech", line);
+	}
+#endif
+	if (timeout)
+		multitech_disconnect ();
+	return (connected);
+}
+
+void multitech_disconnect ()
+{
+	int okay, retries;
+	for (retries = okay = 0; retries < 3 && !okay; retries++)
+	{
+		 /* first hang up the modem*/
+		ioctl (FD, TIOCCDTR, 0);
+		acu_nap (escape_guard_time); 
+		ioctl (FD, TIOCSDTR, 0);
+		acu_nap (escape_guard_time); 
+		/*
+		 * If not strapped for DTR control, try to get command mode.
+		 */
+		acu_nap (escape_guard_time);
+		multitech_write_str (FD, escape_sequence);
+		acu_nap (escape_guard_time);
+		multitech_write_str (FD, hangup_command);
+		okay = multitech_swallow ("\r\nOK\r\n");
+	}
+	if (!okay)
+	{
+		#if ACULOG
+		logent(value(HOST), "", "multitech", "can't hang up modem");
+		#endif
+		if (boolean(value(VERBOSE)))
+			printf("hang up failed\n");
+	}
+	close (FD);
+}
+
+void multitech_abort ()
+{
+	multitech_write_str (FD, "\r");	/* send anything to abort the call */
+	multitech_disconnect ();
+}
+
+static void sigALRM ()
+{
+	(void) printf("\07timeout waiting for reply\n");
+	timeout = 1;
+	longjmp(timeoutbuf, 1);
+}
+
+static int multitech_swallow (register char *match)
+  {
+	sig_t f;
+	char c;
+
+	f = signal(SIGALRM, sigALRM);
+	timeout = 0;
+	do {
+		if (*match =='\0') {
+			signal(SIGALRM, f);
+			return (1);
+		}
+		if (setjmp(timeoutbuf)) {
+			signal(SIGALRM, f);
+			return (0);
+		}
+		alarm(number(value(DIALTIMEOUT)));
+		read(FD, &c, 1);
+		alarm(0);
+		c &= 0177;
+#ifdef DEBUG
+		if (boolean(value(VERBOSE)))
+			putchar(c);
+#endif
+	} while (c == *match++);
+#ifdef DEBUG
+	if (boolean(value(VERBOSE)))
+		fflush (stdout);
+#endif
+	signal(SIGALRM, SIG_DFL);
+	return (0);
+}
+
+static struct baud_msg {
+	char *msg;
+	int baud;
+} baud_msg[] = {
+	"",		B300,
+	" 1200",	B1200,
+	" 2400",	B2400,
+	" 9600",	B9600,
+	" 9600/ARQ",	B9600,
+	0,		0,
+};
+
+static int multitech_connect ()
+{
+	char c;
+	int nc, nl, n;
+	char dialer_buf[64];
+	struct baud_msg *bm;
+	sig_t f;
+
+	if (multitech_swallow("\r\n") == 0)
+		return (0);
+	f = signal(SIGALRM, sigALRM);
+again:
+	nc = 0; nl = sizeof(dialer_buf)-1;
+	bzero(dialer_buf, sizeof(dialer_buf));
+	timeout = 0;
+	for (nc = 0, nl = sizeof(dialer_buf)-1 ; nl > 0 ; nc++, nl--) {
+		if (setjmp(timeoutbuf))
+			break;
+		alarm(number(value(DIALTIMEOUT)));
+		n = read(FD, &c, 1);
+		alarm(0);
+		if (n <= 0)
+			break;
+		c &= 0x7f;
+		if (c == '\r') {
+			if (multitech_swallow("\n") == 0)
+				break;
+			if (!dialer_buf[0])
+				goto again;
+			if (strcmp(dialer_buf, "RINGING") == 0 &&
+			    boolean(value(VERBOSE))) {
+#ifdef DEBUG
+				printf("%s\r\n", dialer_buf);
+#endif
+				goto again;
+			}
+			if (strncmp(dialer_buf, "CONNECT",
+				    sizeof("CONNECT")-1) != 0)
+				break;
+			if (lock_baud) {
+				signal(SIGALRM, f);
+#ifdef DEBUG
+				if (boolean(value(VERBOSE)))
+					printf("%s\r\n", dialer_buf);
+#endif
+				return (1);
+			}
+			for (bm = baud_msg ; bm->msg ; bm++)
+				if (strcmp(bm->msg, dialer_buf+sizeof("CONNECT")-1) == 0) {
+					if (!acu_setspeed (bm->baud))
+						goto error;
+					signal(SIGALRM, f);
+#ifdef DEBUG
+					if (boolean(value(VERBOSE)))
+						printf("%s\r\n", dialer_buf);
+#endif
+					return (1);
+				}
+			break;
+		}
+		dialer_buf[nc] = c;
+	}
+error1:
+	printf("%s\r\n", dialer_buf);
+error:
+	signal(SIGALRM, f);
+	return (0);
+}
+
+/*
+ * This convoluted piece of code attempts to get
+ * the multitech in sync.
+ */
+static int multitechsync ()
+{
+	int already = 0;
+	int len;
+	char buf[40];
+
+	while (already++ < MAXRETRY) {
+		acu_nap (intercommand_delay); 
+		ioctl (FD, TIOCFLUSH, 0);	/* flush any clutter */
+		multitech_write_str (FD, reset_command); /* reset modem */
+		bzero(buf, sizeof(buf));
+		acu_nap (reset_delay); 
+		ioctl (FD, FIONREAD, &len);
+		if (len) {
+			len = read(FD, buf, sizeof(buf));
+#ifdef DEBUG 
+			buf [len] = '\0';
+			printf("multitechsync: (\"%s\")\n\r", buf);
+#endif
+			if (index(buf, '0') || 
+		   	   (index(buf, 'O') && index(buf, 'K')))
+				return(1);
+		}
+		/*
+		 * If not strapped for DTR control,
+		 * try to get command mode.
+		 */
+		acu_nap (escape_guard_time);
+		multitech_write_str (FD, escape_sequence);
+		acu_nap (escape_guard_time);
+		multitech_write_str (FD, hangup_command);
+		/*
+		 * Toggle DTR to force anyone off that might have left
+		 * the modem connected.
+		 */
+		acu_nap (escape_guard_time); 
+		ioctl (FD, TIOCCDTR, 0);
+		acu_nap (escape_guard_time); 
+		ioctl (FD, TIOCSDTR, 0);
+	}
+	acu_nap (intercommand_delay); 
+	multitech_write_str (FD, reset_command);
+	return (0);
+}
+
+void multitech_write_str (int fd, const char *cp)
+{
+#ifdef DEBUG
+	printf ("multitech: sending %s\n", cp);
+#endif
+	multitech_write (fd, cp, strlen (cp));
+}
+
+void multitech_write (int fd, const char *cp, int n)
+{
+	acu_flush ();
+	acu_nap (intercharacter_delay);
+	for ( ; n-- ; cp++) {
+		write (fd, cp, 1);
+		acu_flush ();
+		acu_nap (intercharacter_delay);
+	}
+}
+
+#ifdef DEBUG
+multitech_verbose_read()
+{
+	int n = 0;
+	char buf[BUFSIZ];
+
+	if (ioctl(FD, FIONREAD, &n) < 0)
+		return;
+	if (n <= 0)
+		return;
+	if (read(FD, buf, n) != n)
+		return;
+	write(1, buf, n);
+}
+#endif
+
+/* end of multitech.c */
diff --git a/usr.bin/tip/libacu/t3000.c b/usr.bin/tip/libacu/t3000.c
new file mode 100644
index 0000000..1f1a1f0
--- /dev/null
+++ b/usr.bin/tip/libacu/t3000.c
@@ -0,0 +1,350 @@
+/*
+ * Copyright (c) 1992, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)t3000.c	8.1 (Berkeley) 6/6/93";
+#endif /* not lint */
+
+/*
+ * Routines for calling up on a Telebit T3000 modem.
+ * Derived from Courier driver.
+ */
+#include "tipconf.h"
+#include "tip.h"
+#include "acucommon.h"
+#include <stdio.h>
+
+#define	MAXRETRY	5
+
+static	void sigALRM();
+static	int timeout = 0;
+static	int connected = 0;
+static	jmp_buf timeoutbuf, intbuf;
+static	int t3000_sync();
+
+t3000_dialer(num, acu)
+	register char *num;
+	char *acu;
+{
+	register char *cp;
+#if ACULOG
+	char line[80];
+#endif
+	static int t3000_connect(), t3000_swallow();
+
+	if (boolean(value(VERBOSE)))
+		printf("Using \"%s\"\n", acu);
+
+	acu_hupcl ();
+	/*
+	 * Get in synch.
+	 */
+	if (!t3000_sync()) {
+badsynch:
+		printf("can't synchronize with t3000\n");
+#if ACULOG
+		logent(value(HOST), num, "t3000", "can't synch up");
+#endif
+		return (0);
+	}
+	t3000_write(FD, "AT E0\r", 6);	/* turn off echoing */
+	sleep(1);
+#ifdef DEBUG
+	if (boolean(value(VERBOSE)))
+		t3000_verbose_read();
+#endif
+	ioctl(FD, TIOCFLUSH, 0);	/* flush any clutter */
+	t3000_write(FD, "AT E0 H0 Q0 X4 V1\r", 18);
+	if (!t3000_swallow("\r\nOK\r\n"))
+		goto badsynch;
+	fflush(stdout);
+	t3000_write(FD, "AT D", 4);
+	for (cp = num; *cp; cp++)
+		if (*cp == '=')
+			*cp = ',';
+	t3000_write(FD, num, strlen(num));
+	t3000_write(FD, "\r", 1);
+	connected = t3000_connect();
+#if ACULOG
+	if (timeout) {
+		sprintf(line, "%d second dial timeout",
+			number(value(DIALTIMEOUT)));
+		logent(value(HOST), num, "t3000", line);
+	}
+#endif
+	if (timeout)
+		t3000_disconnect();
+	return (connected);
+}
+
+t3000_disconnect()
+{
+	 /* first hang up the modem*/
+	ioctl(FD, TIOCCDTR, 0);
+	sleep(1);
+	ioctl(FD, TIOCSDTR, 0);
+	t3000_sync();				/* reset */
+	close(FD);
+}
+
+t3000_abort()
+{
+	t3000_write(FD, "\r", 1);	/* send anything to abort the call */
+	t3000_disconnect();
+}
+
+static void
+sigALRM()
+{
+	printf("\07timeout waiting for reply\n");
+	timeout = 1;
+	longjmp(timeoutbuf, 1);
+}
+
+static int
+t3000_swallow(match)
+  register char *match;
+  {
+	sig_t f;
+	char c;
+
+	f = signal(SIGALRM, sigALRM);
+	timeout = 0;
+	do {
+		if (*match =='\0') {
+			signal(SIGALRM, f);
+			return (1);
+		}
+		if (setjmp(timeoutbuf)) {
+			signal(SIGALRM, f);
+			return (0);
+		}
+		alarm(number(value(DIALTIMEOUT)));
+		read(FD, &c, 1);
+		alarm(0);
+		c &= 0177;
+#ifdef DEBUG
+		if (boolean(value(VERBOSE)))
+			putchar(c);
+#endif
+	} while (c == *match++);
+#ifdef DEBUG
+	if (boolean(value(VERBOSE)))
+		fflush(stdout);
+#endif
+	signal(SIGALRM, SIG_DFL);
+	return (0);
+}
+
+#ifndef B19200		/* XXX */
+#define	B19200	EXTA
+#define	B38400	EXTB
+#endif
+
+struct tbaud_msg {
+	char *msg;
+	int baud;
+	int baud2;
+} tbaud_msg[] = {
+	"",		B300,	0,
+	" 1200",	B1200,	0,
+	" 2400",	B2400,	0,
+	" 4800",	B4800,	0,
+	" 9600",	B9600,	0,
+	" 14400",	B19200,	B9600,
+	" 19200",	B19200,	B9600,
+	" 38400",	B38400,	B9600,
+	" 57600",	B38400,	B9600,
+	" 7512",	B9600,	0,
+	" 1275",	B2400,	0,
+	" 7200",	B9600,	0,
+	" 12000",	B19200,	B9600,
+	0,		0,	0,
+};
+
+static int
+t3000_connect()
+{
+	char c;
+	int nc, nl, n;
+	char dialer_buf[64];
+	struct tbaud_msg *bm;
+	sig_t f;
+
+	if (t3000_swallow("\r\n") == 0)
+		return (0);
+	f = signal(SIGALRM, sigALRM);
+again:
+	nc = 0; nl = sizeof(dialer_buf)-1;
+	bzero(dialer_buf, sizeof(dialer_buf));
+	timeout = 0;
+	for (nc = 0, nl = sizeof(dialer_buf)-1 ; nl > 0 ; nc++, nl--) {
+		if (setjmp(timeoutbuf))
+			break;
+		alarm(number(value(DIALTIMEOUT)));
+		n = read(FD, &c, 1);
+		alarm(0);
+		if (n <= 0)
+			break;
+		c &= 0x7f;
+		if (c == '\r') {
+			if (t3000_swallow("\n") == 0)
+				break;
+			if (!dialer_buf[0])
+				goto again;
+			if (strcmp(dialer_buf, "RINGING") == 0 &&
+			    boolean(value(VERBOSE))) {
+#ifdef DEBUG
+				printf("%s\r\n", dialer_buf);
+#endif
+				goto again;
+			}
+			if (strncmp(dialer_buf, "CONNECT",
+				    sizeof("CONNECT")-1) != 0)
+				break;
+			for (bm = tbaud_msg ; bm->msg ; bm++)
+				if (strcmp(bm->msg,
+				    dialer_buf+sizeof("CONNECT")-1) == 0) {
+					if (!(acu_setspeed (bm->baud) || (bm->baud2 && acu_setspeed (bm->baud2))))
+						goto error;
+					signal(SIGALRM, f);
+#ifdef DEBUG
+					if (boolean(value(VERBOSE)))
+						printf("%s\r\n", dialer_buf);
+#endif
+					return (1);
+				}
+			break;
+		}
+		dialer_buf[nc] = c;
+#ifdef notdef
+		if (boolean(value(VERBOSE)))
+			putchar(c);
+#endif
+	}
+error1:
+	printf("%s\r\n", dialer_buf);
+error:
+	signal(SIGALRM, f);
+	return (0);
+}
+
+/*
+ * This convoluted piece of code attempts to get
+ * the t3000 in sync.
+ */
+static int
+t3000_sync()
+{
+	int already = 0;
+	int len;
+	char buf[40];
+
+	while (already++ < MAXRETRY) {
+		ioctl(FD, TIOCFLUSH, 0);	/* flush any clutter */
+		t3000_write(FD, "\rAT Z\r", 6);	/* reset modem */
+		bzero(buf, sizeof(buf));
+		sleep(2);
+		ioctl(FD, FIONREAD, &len);
+#if 1
+if (len == 0) len = 1;
+#endif
+		if (len) {
+			len = read(FD, buf, sizeof(buf));
+#ifdef DEBUG
+			buf[len] = '\0';
+			printf("t3000_sync: (\"%s\")\n\r", buf);
+#endif
+			if (index(buf, '0') || 
+		   	   (index(buf, 'O') && index(buf, 'K')))
+				return(1);
+		}
+		/*
+		 * If not strapped for DTR control,
+		 * try to get command mode.
+		 */
+		sleep(1);
+		t3000_write(FD, "+++", 3);
+		sleep(1);
+		/*
+		 * Toggle DTR to force anyone off that might have left
+		 * the modem connected.
+		 */
+		ioctl(FD, TIOCCDTR, 0);
+		sleep(1);
+		ioctl(FD, TIOCSDTR, 0);
+	}
+	t3000_write(FD, "\rAT Z\r", 6);
+	return (0);
+}
+
+t3000_write(fd, cp, n)
+int fd;
+char *cp;
+int n;
+{
+#ifdef notdef
+	if (boolean(value(VERBOSE)))
+		write(1, cp, n);
+#endif
+	acu_flush ();
+	t3000_nap();
+	for ( ; n-- ; cp++) {
+		write(fd, cp, 1);
+		acu_flush ();
+		t3000_nap();
+	}
+}
+
+#ifdef DEBUG
+t3000_verbose_read()
+{
+	int n = 0;
+	char buf[BUFSIZ];
+
+	if (ioctl(FD, FIONREAD, &n) < 0)
+		return;
+	if (n <= 0)
+		return;
+	if (read(FD, buf, n) != n)
+		return;
+	write(1, buf, n);
+}
+#endif
+
+t3000_nap()
+{
+	acu_nap (50);
+}
+
+/* end of t3000.c */
diff --git a/usr.bin/tip/libacu/tod.c b/usr.bin/tip/libacu/tod.c
new file mode 100644
index 0000000..62ccddc
--- /dev/null
+++ b/usr.bin/tip/libacu/tod.c
@@ -0,0 +1,107 @@
+/*
+ * tod.c -- time of day pseudo-class implementation
+ *
+ * Copyright (c) 1995 John H. Poplett
+ * 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 immediately at the beginning of the file, without modification,
+ *    this list of conditions, and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Absolutely no warranty of function or purpose is made by the author
+ *    John H. Poplett.
+ * 4. This work was done expressly for inclusion into FreeBSD.  Other use
+ *    is allowed if this notation is included.
+ * 5. Modifications may be freely made to this file if the above conditions
+ *    are met.
+ *
+ */
+
+#include <sys/types.h>
+#include <sys/time.h>
+
+#include <assert.h>
+#include <stdio.h>
+
+#include "tod.h"
+
+#define USP 1000000
+
+int tod_cmp (const struct timeval *a, const struct timeval *b)
+{
+	int rc;
+	assert (a->tv_usec <= USP);
+	assert (b->tv_usec <= USP);
+	rc = a->tv_sec - b->tv_sec;
+	if (rc == 0)
+		rc = a->tv_usec - b->tv_usec;
+	return rc;
+}
+
+/*
+	TOD < command
+*/
+int tod_lt (const struct timeval *a, const struct timeval *b) 
+{
+	return tod_cmp (a, b) < 0;
+}
+
+int tod_gt (const struct timeval *a, const struct timeval *b) 
+{
+	return tod_cmp (a, b) > 0;
+}
+
+int tod_lte (const struct timeval *a, const struct timeval *b) 
+{
+	return tod_cmp (a, b) <= 0;
+}
+
+int tod_gte (const struct timeval *a, const struct timeval *b) 
+{
+	return tod_cmp (a, b) >= 0;
+}
+
+int tod_eq (const struct timeval *a, const struct timeval *b) 
+{
+	return tod_cmp (a, b) == 0;
+}
+
+/*
+	TOD += command
+*/
+void tod_addto (struct timeval *a, const struct timeval *b)
+{
+	a->tv_usec += b->tv_usec;
+	a->tv_sec += b->tv_sec + a->tv_usec / USP;
+	a->tv_usec %= USP;
+}
+
+/*
+	TOD -= command
+*/
+void tod_subfrom (struct timeval *a, struct timeval b)
+{
+	assert (a->tv_usec <= USP);
+	assert (b.tv_usec <= USP);
+	if (b.tv_usec > a->tv_usec)
+	{
+		a->tv_usec += USP;
+		a->tv_sec -= 1;
+	}
+	a->tv_usec -= b.tv_usec;
+	a->tv_sec -= b.tv_sec;
+}
+
+void tod_gettime (struct timeval *tp)
+{
+	gettimeofday (tp, NULL);
+	tp->tv_sec += tp->tv_usec / USP;
+	tp->tv_usec %= USP;
+}
+
+/* end of tod.c */
diff --git a/usr.bin/tip/libacu/tod.h b/usr.bin/tip/libacu/tod.h
new file mode 100644
index 0000000..d772230
--- /dev/null
+++ b/usr.bin/tip/libacu/tod.h
@@ -0,0 +1,9 @@
+int tod_cmp (const struct timeval *a, const struct timeval *b);
+int tod_lt (const struct timeval *a, const struct timeval *b) ;
+int tod_gt (const struct timeval *a, const struct timeval *b);
+int tod_lte (const struct timeval *a, const struct timeval *b);
+int tod_gte (const struct timeval *a, const struct timeval *b);
+int tod_eq (const struct timeval *a, const struct timeval *b);
+void tod_addto (struct timeval *a, const struct timeval *b);
+void tod_subfrom (struct timeval *a, struct timeval b);
+void tod_gettime (struct timeval *tp);
diff --git a/usr.bin/tip/libacu/unidialer.c b/usr.bin/tip/libacu/unidialer.c
new file mode 100644
index 0000000..889a0f3
--- /dev/null
+++ b/usr.bin/tip/libacu/unidialer.c
@@ -0,0 +1,800 @@
+/*
+ * Copyright (c) 1986, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)unidialer.c	8.1 (Berkeley) 6/6/93";
+#endif /* not lint */
+
+/*
+ * Generalized routines for calling up on a Hayes AT command set based modem.
+ * Control variables are pulled out of a modem caps-style database to
+ * configure the driver for a particular modem.
+ */
+#include "tipconf.h"
+#include "tip.h"
+#include "pathnames.h"
+
+#include <sys/times.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "acucommon.h"
+#include "tod.h"
+
+/* #define DEBUG /**/
+#define	MAXRETRY	5
+
+typedef enum
+{
+	mpt_notype, mpt_string, mpt_number, mpt_boolean
+} modem_parm_type_t;
+
+typedef struct {
+	modem_parm_type_t modem_parm_type;
+	const char *name;
+	union {
+		char **string;
+		unsigned int *number;
+	} value;
+	union {
+		char *string;
+		unsigned int number;
+	} default_value;
+} modem_parm_t;
+
+/*
+	Configuration
+*/
+static char modem_name [80];
+static char *dial_command;
+static char *hangup_command;
+static char *echo_off_command;
+static char *reset_command;
+static char *init_string;
+static char *escape_sequence;
+static int hw_flow_control;
+static int lock_baud;
+static unsigned int intercharacter_delay; 
+static unsigned int intercommand_delay; 
+static unsigned int escape_guard_time;
+static unsigned int reset_delay;
+
+static int unidialer_dialer (register char *num, char *acu);
+static void unidialer_disconnect ();
+static void unidialer_abort ();
+
+static acu_t unidialer =
+{
+	modem_name,
+	unidialer_dialer,
+	unidialer_disconnect,
+	unidialer_abort
+};
+
+/*
+	Table of parameters kept in modem database
+*/
+modem_parm_t modem_parms [] = {
+	{ mpt_string, "dial_command", &dial_command, "ATDT%s\r" },
+	{ mpt_string, "hangup_command", &hangup_command, "ATH\r", },
+	{ mpt_string, "echo_off_command", &echo_off_command, "ATE0\r" },
+	{ mpt_string, "reset_command", &reset_command, "ATZ\r" },
+	{ mpt_string, "init_string", &init_string, "AT&F\r", },
+	{ mpt_string, "escape_sequence", &escape_sequence, "+++" },
+	{ mpt_boolean, "hw_flow_control", (char **)&hw_flow_control, NULL },
+	{ mpt_boolean, "lock_baud", (char **)&lock_baud, NULL },
+	{ mpt_number, "intercharacter_delay", (char **)&intercharacter_delay, (char *)50 },
+	{ mpt_number, "intercommand_delay", (char **)&intercommand_delay, (char *)300 },
+	{ mpt_number, "escape_guard_time", (char **)&escape_guard_time, (char *)300 },
+	{ mpt_number, "reset_delay", (char **)&reset_delay, (char *)3000 },
+	{ mpt_notype, NULL, NULL, NULL }
+};
+
+/*
+	Forward declarations
+*/
+static void unidialer_verbose_read ();
+static void unidialer_modem_cmd (int fd, CONST char *cmd);
+static void unidialer_write (int fd, CONST char *cp, int n);
+static void unidialer_write_str (int fd, CONST char *cp);
+static void unidialer_disconnect ();
+static void sigALRM ();
+static int unidialersync ();
+static int unidialer_swallow (register char *match);
+
+/*
+	Global vars
+*/
+static int timeout = 0;
+static int connected = 0;
+static jmp_buf timeoutbuf, intbuf;
+
+#define cgetflag(f)	(cgetcap(bp, f, ':') != NULL)
+
+#ifdef DEBUG
+
+#define print_str(x) printf (#x " = %s\n", x)
+#define print_num(x) printf (#x " = %d\n", x)
+
+void dumpmodemparms (char *modem)
+{
+		printf ("modem parms for %s\n", modem);
+		print_str (dial_command);
+		print_str (hangup_command);
+		print_str (echo_off_command);
+		print_str (reset_command);
+		print_str (init_string);
+		print_str (escape_sequence);
+		print_num (lock_baud);
+		print_num (intercharacter_delay); 
+		print_num (intercommand_delay); 
+		print_num (escape_guard_time);
+		print_num (reset_delay);
+		printf ("\n");
+}
+#endif
+
+static int getmodemparms (const char *modem)
+{
+	char *bp, *db_array [3], *modempath;
+	int ndx, stat;
+	modem_parm_t *mpp;
+
+	modempath = getenv ("MODEMS");
+
+	ndx = 0;
+
+	if (modempath != NULL) 
+		db_array [ndx++] = modempath;
+
+	db_array [ndx++] = _PATH_MODEMS;
+	db_array [ndx] = NULL;
+
+	if ((stat = cgetent (&bp, db_array, (char *)modem)) < 0) {
+		switch (stat) {
+		case -1:
+			fprintf (stderr, "tip: unknown modem %s\n", modem);
+			break;
+		case -2:
+			fprintf (stderr, "tip: can't open modem description file\n");
+			break;
+		case -3:
+			fprintf (stderr, "tip: possible reference loop in modem description file\n");
+			break;
+		}
+		return 0;
+	}
+	for (mpp = modem_parms; mpp->name; mpp++)
+	{
+		switch (mpp->modem_parm_type)
+		{
+			case mpt_string:
+				if (cgetstr (bp, (char *)mpp->name, mpp->value.string) == -1)
+					*mpp->value.string = mpp->default_value.string;
+				break;
+
+			case mpt_number:
+			{
+				long l;
+				if (cgetnum (bp, (char *)mpp->name, &l) == -1)
+					*mpp->value.number = mpp->default_value.number;
+				else
+					*mpp->value.number = (unsigned int)l;
+			}
+				break;
+
+			case mpt_boolean:
+				*mpp->value.number = cgetflag ((char *)mpp->name);
+				break;
+		}
+	}
+	strncpy (modem_name, modem, sizeof (modem_name) - 1);
+	modem_name [sizeof (modem_name) - 1] = '\0';
+	return 1;
+}
+
+/*
+*/
+acu_t* unidialer_getmodem (const char *modem_name)
+{
+	acu_t* rc = NOACU;
+	if (getmodemparms (modem_name))
+		rc = &unidialer;
+	return rc;
+}
+
+static int unidialer_modem_ready ()
+{
+#ifdef TIOCMGET
+	int state;
+	ioctl (FD, TIOCMGET, &state);
+	return (state & TIOCM_DSR) ? 1 : 0;
+#else
+	return (1);
+#endif
+}
+
+static int unidialer_waitfor_modem_ready (int ms)
+{
+#ifdef TIOCMGET
+	int count;
+	for (count = 0; count < ms; count += 100)
+	{
+		if (unidialer_modem_ready ())
+		{
+#ifdef DEBUG
+			printf ("unidialer_waitfor_modem_ready: modem ready.\n");
+#endif
+			break;
+		}
+		acu_nap (100);
+	}
+	return (count < ms);
+#else
+	acu_nap (250);
+	return (1);
+#endif
+}
+
+int unidialer_tty_clocal (int flag)
+{
+#if HAVE_TERMIOS
+	struct termios t;
+	tcgetattr (FD, &t);
+	if (flag)
+		t.c_cflag |= CLOCAL;
+	else
+		t.c_cflag &= ~CLOCAL;
+	tcsetattr (FD, TCSANOW, &t);
+#elif defined(TIOCMSET)
+	int state;
+	/*
+		Don't have CLOCAL so raise CD in software to
+		get the same effect.
+	*/
+	ioctl (FD, TIOCMGET, &state);
+	if (flag)
+		state |= TIOCM_CD;
+	else
+		state &= ~TIOCM_CD;
+	ioctl (FD, TIOCMSET, &state);
+#endif
+}
+
+int unidialer_get_modem_response (char *buf, int bufsz, int response_timeout)
+{
+	sig_t f;
+	char c, *p = buf, *lid = buf + bufsz - 1;
+	int state;
+
+	assert (bufsz > 0);
+
+	f = signal (SIGALRM, sigALRM);
+
+	timeout = 0;
+
+	if (setjmp (timeoutbuf)) {
+		signal (SIGALRM, f);
+		*p = '\0';
+#ifdef DEBUG
+		printf ("get_response: timeout buf=%s, state=%d\n", buf, state);
+#endif
+		return (0);
+	}
+
+	ualarm (response_timeout * 1000, 0);
+
+	state = 0;
+
+	while (1)
+	{
+		switch (state)
+		{
+			case 0:
+				if (read (FD, &c, 1) == 1)
+				{
+					if (c == '\r')
+					{
+						++state;
+					}
+					else
+					{
+#ifdef DEBUG
+						printf ("get_response: unexpected char %s.\n", ctrl (c));
+#endif
+					}
+				}
+				break;
+	
+			case 1:
+				if (read (FD, &c, 1) == 1) 
+				{
+					if (c == '\n')
+					{
+#ifdef DEBUG
+						printf ("get_response: <CRLF> encountered.\n", buf);
+#endif
+						++state;
+					}
+					else
+					{
+							state = 0;
+#ifdef DEBUG
+							printf ("get_response: unexpected char %s.\n", ctrl (c));
+#endif
+					}
+				}
+				break;
+	
+			case 2:
+				if (read (FD, &c, 1) == 1) 
+				{
+					if (c == '\r')
+						++state;
+					else if (c >= ' ' && p < lid)
+						*p++ = c;
+				}
+				break;
+	
+			case 3:
+				if (read (FD, &c, 1) == 1) 
+				{
+					if (c == '\n')
+					{
+						signal (SIGALRM, f);
+						/* ualarm (0, 0); */
+						alarm (0);
+						*p = '\0';
+#ifdef DEBUG
+						printf ("get_response: %s\n", buf);
+#endif
+						return (1);
+					}
+					else
+					{
+						state = 0;
+						p = buf;
+					}
+				}
+				break;
+		}
+	}
+}
+
+int unidialer_get_okay (int ms)
+{
+	int okay;
+	char buf [BUFSIZ];
+	okay = unidialer_get_modem_response (buf, sizeof (buf), ms) &&
+		strcmp (buf, "OK") == 0;
+	return okay;
+}
+
+static int unidialer_dialer (register char *num, char *acu)
+{
+	register char *cp;
+	char dial_string [80];
+#if ACULOG
+	char line [80];
+#endif
+	static int unidialer_connect(), unidialer_swallow();
+
+	#ifdef DEBUG
+	dumpmodemparms (modem_name);
+	#endif
+
+	if (lock_baud) {
+		int i;
+		if ((i = speed(number(value(BAUDRATE)))) == NULL) 
+			return 0;
+		ttysetup (i);
+	}
+
+	if (boolean(value(VERBOSE)))
+		printf("Using \"%s\"\n", acu);
+
+	acu_hupcl ();
+
+	/*
+	 * Get in synch.
+	 */
+	if (!unidialersync()) {
+badsynch:
+		printf("tip: can't synchronize with %s\n", modem_name);
+#if ACULOG
+		logent(value(HOST), num, modem_name, "can't synch up");
+#endif
+		return (0);
+	}
+
+	unidialer_modem_cmd (FD, echo_off_command);	/* turn off echoing */
+
+	sleep(1);
+
+#ifdef DEBUG
+	if (boolean(value(VERBOSE)))
+		unidialer_verbose_read();
+#endif
+
+	acu_flush (); /* flush any clutter */
+
+	unidialer_modem_cmd (FD, init_string);
+
+	if (!unidialer_get_okay (250))
+		goto badsynch;
+
+	fflush (stdout);
+
+	for (cp = num; *cp; cp++)
+		if (*cp == '=')
+			*cp = ',';
+
+	(void) sprintf (dial_string, dial_command, num);
+
+	unidialer_modem_cmd (FD, dial_string);
+
+	connected = unidialer_connect ();
+
+	if (connected && hw_flow_control) {
+		acu_hw_flow_control (hw_flow_control);
+	}
+
+#if ACULOG
+	if (timeout) {
+		sprintf(line, "%d second dial timeout",
+			number(value(DIALTIMEOUT)));
+		logent(value(HOST), num, modem_name, line);
+	}
+#endif
+
+	if (timeout)
+		unidialer_disconnect ();
+
+	return (connected);
+}
+
+static void unidialer_disconnect ()
+{
+	int okay, retries;
+
+	acu_flush (); /* flush any clutter */
+
+	unidialer_tty_clocal (TRUE);
+
+ 	/* first hang up the modem*/
+	ioctl (FD, TIOCCDTR, 0);
+	acu_nap (250);
+	ioctl (FD, TIOCSDTR, 0);
+
+	/*
+	 * If AT&D2, then dropping DTR *should* just hangup the modem. But
+	 * some modems reset anyway; also, the modem may be programmed to reset
+	 * anyway with AT&D3. Play it safe and wait for the full reset time before
+	 * proceeding.
+	 */
+	acu_nap (reset_delay);
+
+	if (!unidialer_waitfor_modem_ready (reset_delay))
+	{
+#ifdef DEBUG
+			printf ("unidialer_disconnect: warning CTS low.\r\n");
+#endif
+	}
+
+	/*
+	 * If not strapped for DTR control, try to get command mode.
+	 */
+	for (retries = okay = 0; retries < MAXRETRY && !okay; retries++)
+	{
+		int timeout_value;
+		/* flush any clutter */
+		if (!acu_flush ())
+		{
+#ifdef DEBUG
+			printf ("unidialer_disconnect: warning flush failed.\r\n");
+#endif
+		}
+		timeout_value = escape_guard_time;
+		timeout_value += (timeout_value * retries / MAXRETRY);
+		acu_nap (timeout_value);
+		acu_flush (); /* flush any clutter */
+		unidialer_modem_cmd (FD, escape_sequence);
+		acu_nap (timeout_value);
+		unidialer_modem_cmd (FD, hangup_command);
+		okay = unidialer_get_okay (250);
+	}
+	if (!okay)
+	{
+		#if ACULOG
+		logent(value(HOST), "", modem_name, "can't hang up modem");
+		#endif
+		if (boolean(value(VERBOSE)))
+			printf("hang up failed\n");
+	}
+	(void) acu_flush ();
+	close (FD);
+}
+
+static void unidialer_abort ()
+{
+	unidialer_write_str (FD, "\r");	/* send anything to abort the call */
+	unidialer_disconnect ();
+}
+
+static void sigALRM ()
+{
+	(void) printf("\07timeout waiting for reply\n");
+	timeout = 1;
+	longjmp(timeoutbuf, 1);
+}
+
+static int unidialer_swallow (register char *match)
+{
+	sig_t f;
+	char c;
+
+	f = signal(SIGALRM, sigALRM);
+
+	timeout = 0;
+
+	if (setjmp(timeoutbuf)) {
+		signal(SIGALRM, f);
+		return (0);
+	}
+
+	alarm(number(value(DIALTIMEOUT)));
+
+	do {
+		if (*match =='\0') {
+			signal(SIGALRM, f);
+			alarm (0);
+			return (1);
+		}
+		do {
+			read (FD, &c, 1);
+		} while (c == '\0');
+		c &= 0177;
+#ifdef DEBUG
+		if (boolean(value(VERBOSE)))
+		{
+			/* putchar(c); */
+			printf (ctrl (c));
+		}
+#endif
+	} while (c == *match++);
+	signal(SIGALRM, SIG_DFL);
+	alarm(0);
+#ifdef DEBUG
+	if (boolean(value(VERBOSE)))
+		fflush (stdout);
+#endif
+	return (0);
+}
+
+static struct baud_msg {
+	char *msg;
+	int baud;
+} baud_msg[] = {
+	"",		B300,
+	" 1200",	B1200,
+	" 2400",	B2400,
+	" 9600",	B9600,
+	" 9600/ARQ",	B9600,
+	0,		0,
+};
+
+static int unidialer_connect ()
+{
+	char c;
+	int nc, nl, n;
+	char dialer_buf[64];
+	struct baud_msg *bm;
+	sig_t f;
+
+	if (unidialer_swallow("\r\n") == 0)
+		return (0);
+	f = signal(SIGALRM, sigALRM);
+again:
+	nc = 0; nl = sizeof(dialer_buf)-1;
+	bzero(dialer_buf, sizeof(dialer_buf));
+	timeout = 0;
+	for (nc = 0, nl = sizeof(dialer_buf)-1 ; nl > 0 ; nc++, nl--) {
+		if (setjmp(timeoutbuf))
+			break;
+		alarm(number(value(DIALTIMEOUT)));
+		n = read(FD, &c, 1);
+		alarm(0);
+		if (n <= 0)
+			break;
+		c &= 0x7f;
+		if (c == '\r') {
+			if (unidialer_swallow("\n") == 0)
+				break;
+			if (!dialer_buf[0])
+				goto again;
+			if (strcmp(dialer_buf, "RINGING") == 0 &&
+			    boolean(value(VERBOSE))) {
+#ifdef DEBUG
+				printf("%s\r\n", dialer_buf);
+#endif
+				goto again;
+			}
+			if (strncmp(dialer_buf, "CONNECT",
+				    sizeof("CONNECT")-1) != 0)
+				break;
+			if (lock_baud) {
+				signal(SIGALRM, f);
+#ifdef DEBUG
+				if (boolean(value(VERBOSE)))
+					printf("%s\r\n", dialer_buf);
+#endif
+				return (1);
+			}
+			for (bm = baud_msg ; bm->msg ; bm++)
+				if (strcmp(bm->msg, dialer_buf+sizeof("CONNECT")-1) == 0) {
+					if (!acu_setspeed (bm->baud))
+						goto error;
+					signal(SIGALRM, f);
+#ifdef DEBUG
+					if (boolean(value(VERBOSE)))
+						printf("%s\r\n", dialer_buf);
+#endif
+					return (1);
+				}
+			break;
+		}
+		dialer_buf[nc] = c;
+	}
+error1:
+	printf("%s\r\n", dialer_buf);
+error:
+	signal(SIGALRM, f);
+	return (0);
+}
+
+/*
+ * This convoluted piece of code attempts to get
+ * the unidialer in sync.
+ */
+static int unidialersync ()
+{
+	int already = 0;
+	int len;
+	char buf[40];
+
+	while (already++ < MAXRETRY) {
+		acu_nap (intercommand_delay); 
+		acu_flush (); /* flush any clutter */
+		unidialer_write_str (FD, reset_command); /* reset modem */
+		bzero(buf, sizeof(buf));
+		acu_nap (reset_delay); 
+		ioctl (FD, FIONREAD, &len);
+		if (len) {
+			len = read(FD, buf, sizeof(buf));
+#ifdef DEBUG 
+			buf [len] = '\0';
+			printf("unidialersync (%s): (\"%s\")\n\r", modem_name, buf);
+#endif
+			if (index(buf, '0') || 
+		   	   (index(buf, 'O') && index(buf, 'K')))
+				return(1);
+		}
+		/*
+		 * If not strapped for DTR control,
+		 * try to get command mode.
+		 */
+		acu_nap (escape_guard_time);
+		unidialer_write_str (FD, escape_sequence);
+		acu_nap (escape_guard_time);
+		unidialer_write_str (FD, hangup_command);
+		/*
+		 * Toggle DTR to force anyone off that might have left
+		 * the modem connected.
+		 */
+		acu_nap (escape_guard_time); 
+		ioctl (FD, TIOCCDTR, 0);
+		acu_nap (1000); 
+		ioctl (FD, TIOCSDTR, 0);
+	}
+	acu_nap (intercommand_delay); 
+	unidialer_write_str (FD, reset_command);
+	return (0);
+}
+
+/*
+	Send commands to modem; impose delay between commands.
+*/
+static void unidialer_modem_cmd (int fd, const char *cmd)
+{
+	static struct timeval oldt = { 0, 0 };
+	struct timeval newt;
+	tod_gettime (&newt);
+	if (tod_lt (&newt, &oldt))
+	{
+		unsigned int naptime;
+		tod_subfrom (&oldt, newt);
+		naptime = oldt.tv_sec * 1000 + oldt.tv_usec / 1000;
+		if (naptime > intercommand_delay)
+		{
+#ifdef DEBUG 
+		printf ("unidialer_modem_cmd: suspicious naptime (%u ms)\r\n", naptime);
+#endif
+			naptime = intercommand_delay;
+		}
+#ifdef DEBUG 
+		printf ("unidialer_modem_cmd: delaying %u ms\r\n", naptime);
+#endif
+		acu_nap (naptime);
+	}
+	unidialer_write_str (fd, cmd);
+	tod_gettime (&oldt);
+	newt.tv_sec = 0;
+	newt.tv_usec = intercommand_delay; 
+	tod_addto (&oldt, &newt);
+}
+
+static void unidialer_write_str (int fd, const char *cp)
+{
+#ifdef DEBUG
+	printf ("unidialer (%s): sending %s\n", modem_name, cp);
+#endif
+	unidialer_write (fd, cp, strlen (cp));
+}
+
+static void unidialer_write (int fd, const char *cp, int n)
+{
+	acu_nap (intercharacter_delay);
+	for ( ; n-- ; cp++) {
+		write (fd, cp, 1);
+		acu_nap (intercharacter_delay);
+	}
+}
+
+#ifdef DEBUG
+static void unidialer_verbose_read()
+{
+	int n = 0;
+	char buf[BUFSIZ];
+
+	if (ioctl(FD, FIONREAD, &n) < 0)
+		return;
+	if (n <= 0)
+		return;
+	if (read(FD, buf, n) != n)
+		return;
+	write(1, buf, n);
+}
+#endif
+
+/* end of unidialer.c */
diff --git a/usr.bin/tip/libacu/v3451.c b/usr.bin/tip/libacu/v3451.c
new file mode 100644
index 0000000..a98c4d4
--- /dev/null
+++ b/usr.bin/tip/libacu/v3451.c
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) 1983, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)v3451.c	8.1 (Berkeley) 6/6/93";
+#endif /* not lint */
+
+/*
+ * Routines for calling up on a Vadic 3451 Modem
+ */
+#include "tipconf.h"
+#include "tip.h"
+
+static	jmp_buf Sjbuf;
+
+v3451_dialer(num, acu)
+	register char *num;
+	char *acu;
+{
+	sig_t func;
+	int ok;
+	int slow = number(value(BAUDRATE)) < 1200, rw = 2;
+	char phone[50];
+#if ACULOG
+	char line[80];
+#endif
+	static int expect();
+	static void vawrite();
+
+	/*
+	 * Get in synch
+	 */
+	vawrite("I\r", 1 + slow);
+	vawrite("I\r", 1 + slow);
+	vawrite("I\r", 1 + slow);
+	vawrite("\005\r", 2 + slow);
+	if (!expect("READY")) {
+		printf("can't synchronize with vadic 3451\n");
+#if ACULOG
+		logent(value(HOST), num, "vadic", "can't synch up");
+#endif
+		return (0);
+	}
+	acu_hupcl ();
+	sleep(1);
+	vawrite("D\r", 2 + slow);
+	if (!expect("NUMBER?")) {
+		printf("Vadic will not accept dial command\n");
+#if ACULOG
+		logent(value(HOST), num, "vadic", "will not accept dial");
+#endif
+		return (0);
+	}
+	strcpy(phone, num);
+	strcat(phone, "\r");
+	vawrite(phone, 1 + slow);
+	if (!expect(phone)) {
+		printf("Vadic will not accept phone number\n");
+#if ACULOG
+		logent(value(HOST), num, "vadic", "will not accept number");
+#endif
+		return (0);
+	}
+	func = signal(SIGINT,SIG_IGN);
+	/*
+	 * You cannot interrupt the Vadic when its dialing;
+	 * even dropping DTR does not work (definitely a
+	 * brain damaged design).
+	 */
+	vawrite("\r", 1 + slow);
+	vawrite("\r", 1 + slow);
+	if (!expect("DIALING:")) {
+		printf("Vadic failed to dial\n");
+#if ACULOG
+		logent(value(HOST), num, "vadic", "failed to dial");
+#endif
+		return (0);
+	}
+	if (boolean(value(VERBOSE)))
+		printf("\ndialing...");
+	ok = expect("ON LINE");
+	signal(SIGINT, func);
+	if (!ok) {
+		printf("call failed\n");
+#if ACULOG
+		logent(value(HOST), num, "vadic", "call failed");
+#endif
+		return (0);
+	}
+	ioctl(FD, TIOCFLUSH, &rw);
+	return (1);
+}
+
+v3451_disconnect()
+{
+
+	close(FD);
+}
+
+v3451_abort()
+{
+
+	close(FD);
+}
+
+static void
+vawrite(cp, delay)
+	register char *cp;
+	int delay;
+{
+
+	for (; *cp; sleep(delay), cp++)
+		write(FD, cp, 1);
+}
+
+static
+expect(cp)
+	register char *cp;
+{
+	char buf[300];
+	register char *rp = buf;
+	int timeout = 30, online = 0;
+	static int notin();
+	static void alarmtr();
+
+	if (strcmp(cp, "\"\"") == 0)
+		return (1);
+	*rp = 0;
+	/*
+	 * If we are waiting for the Vadic to complete
+	 * dialing and get a connection, allow more time
+	 * Unfortunately, the Vadic times out 24 seconds after
+	 * the last digit is dialed
+	 */
+	online = strcmp(cp, "ON LINE") == 0;
+	if (online)
+		timeout = number(value(DIALTIMEOUT));
+	signal(SIGALRM, alarmtr);
+	if (setjmp(Sjbuf))
+		return (0);
+	alarm(timeout);
+	while (notin(cp, buf) && rp < buf + sizeof (buf) - 1) {
+		if (online && notin("FAILED CALL", buf) == 0)
+			return (0);
+		if (read(FD, rp, 1) < 0) {
+			alarm(0);
+			return (0);
+		}
+		if (*rp &= 0177)
+			rp++;
+		*rp = '\0';
+	}
+	alarm(0);
+	return (1);
+}
+
+static void
+alarmtr()
+{
+	longjmp(Sjbuf, 1);
+}
+
+static int
+notin(sh, lg)
+	char *sh, *lg;
+{
+	static int prefix();
+
+	for (; *lg; lg++)
+		if (prefix(sh, lg))
+			return (0);
+	return (1);
+}
+
+static
+prefix(s1, s2)
+	register char *s1, *s2;
+{
+	register char c;
+
+	while ((c = *s1++) == *s2++)
+		if (c == '\0')
+			return (1);
+	return (c == '\0');
+}
diff --git a/usr.bin/tip/libacu/v831.c b/usr.bin/tip/libacu/v831.c
new file mode 100644
index 0000000..b670c2a
--- /dev/null
+++ b/usr.bin/tip/libacu/v831.c
@@ -0,0 +1,272 @@
+/*
+ * Copyright (c) 1983, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)v831.c	8.1 (Berkeley) 6/6/93";
+#endif /* not lint */
+
+/*
+ * Routines for dialing up on Vadic 831
+ */
+#include "tipconf.h"
+#include "tip.h"
+
+int	v831_abort();
+static	void alarmtr();
+extern	int errno;
+
+static jmp_buf jmpbuf;
+static int child = -1;
+
+v831_dialer(num, acu)
+        char *num, *acu;
+{
+        int status, pid, connected = 1;
+        register int timelim;
+	static int dialit();
+
+        if (boolean(value(VERBOSE)))
+                printf("\nstarting call...");
+#ifdef DEBUG
+        printf ("(acu=%s)\n", acu);
+#endif
+        if ((AC = open(acu, O_RDWR)) < 0) {
+                if (errno == EBUSY)
+                        printf("line busy...");
+                else
+                        printf("acu open error...");
+                return (0);
+        }
+        if (setjmp(jmpbuf)) {
+                kill(child, SIGKILL);
+                close(AC);
+                return (0);
+        }
+        signal(SIGALRM, alarmtr);
+        timelim = 5 * strlen(num);
+        alarm(timelim < 30 ? 30 : timelim);
+        if ((child = fork()) == 0) {
+                /*
+                 * ignore this stuff for aborts
+                 */
+                signal(SIGALRM, SIG_IGN);
+		signal(SIGINT, SIG_IGN);
+                signal(SIGQUIT, SIG_IGN);
+                sleep(2);
+                exit(dialit(num, acu) != 'A');
+        }
+        /*
+         * open line - will return on carrier
+         */
+        if ((FD = open(DV, O_RDWR)) < 0) {
+#ifdef DEBUG
+                printf("(after open, errno=%d)\n", errno);
+#endif
+                if (errno == EIO)
+                        printf("lost carrier...");
+                else
+                        printf("dialup line open failed...");
+                alarm(0);
+                kill(child, SIGKILL);
+                close(AC);
+                return (0);
+        }
+        alarm(0);
+#ifdef notdef
+        ioctl(AC, TIOCHPCL, 0);
+#endif
+        signal(SIGALRM, SIG_DFL);
+        while ((pid = wait(&status)) != child && pid != -1)
+                ;
+        if (status) {
+                close(AC);
+                return (0);
+        }
+        return (1);
+}
+
+static void
+alarmtr()
+{
+        alarm(0);
+        longjmp(jmpbuf, 1);
+}
+
+/*
+ * Insurance, for some reason we don't seem to be
+ *  hanging up...
+ */
+v831_disconnect()
+{
+        sleep(2);
+#ifdef DEBUG
+        printf("[disconnect: FD=%d]\n", FD);
+#endif
+        if (FD > 0) {
+                ioctl(FD, TIOCCDTR, 0);
+								acu_setspeec (0);
+                ioctl(FD, TIOCNXCL, 0);
+        }
+        close(FD);
+}
+
+v831_abort()
+{
+
+#ifdef DEBUG
+        printf("[abort: AC=%d]\n", AC);
+#endif
+        sleep(2);
+        if (child > 0)
+                kill(child, SIGKILL);
+        if (AC > 0)
+                ioctl(FD, TIOCNXCL, 0);
+                close(AC);
+        if (FD > 0)
+                ioctl(FD, TIOCCDTR, 0);
+        close(FD);
+}
+
+/*
+ * Sigh, this probably must be changed at each site.
+ */
+struct vaconfig {
+	char	*vc_name;
+	char	vc_rack;
+	char	vc_modem;
+} vaconfig[] = {
+	{ "/dev/cua0",'4','0' },
+	{ "/dev/cua1",'4','1' },
+	{ 0 }
+};
+
+#define pc(x)	(c = x, write(AC,&c,1))
+#define ABORT	01
+#define SI	017
+#define STX	02
+#define ETX	03
+
+static int
+dialit(phonenum, acu)
+	register char *phonenum;
+	char *acu;
+{
+        register struct vaconfig *vp;
+        char c;
+        int i, two = 2;
+	static char *sanitize();
+
+        phonenum = sanitize(phonenum);
+#ifdef DEBUG
+        printf ("(dial phonenum=%s)\n", phonenum);
+#endif
+        if (*phonenum == '<' && phonenum[1] == 0)
+                return ('Z');
+	for (vp = vaconfig; vp->vc_name; vp++)
+		if (strcmp(vp->vc_name, acu) == 0)
+			break;
+	if (vp->vc_name == 0) {
+		printf("Unable to locate dialer (%s)\n", acu);
+		return ('K');
+	}
+	{
+#if HAVE_TERMIOS
+				struct termios termios;
+				tcgetattr (AC, &termios);
+				termios.c_iflag = 0;
+#ifndef _POSIX_SOURCE
+				termios.c_lflag = (PENDIN|ECHOKE|ECHOE);
+#else
+				termios.c_lflag = (PENDIN|ECHOE);
+#endif
+				termios.c_cflag = (CLOCAL|HUPCL|CREAD|CS8);
+				termios.c_ispeed = termios.c_ospeed = B2400;
+				tcsetattr (AC, TCSANOW, &termios);
+#else /* HAVE_TERMIOS */
+				struct sgttyb cntrl;
+        ioctl(AC, TIOCGETP, &cntrl);
+        cntrl.sg_ispeed = cntrl.sg_ospeed = B2400;
+        cntrl.sg_flags = RAW | EVENP | ODDP;
+        ioctl(AC, TIOCSETP, &cntrl);
+ #endif
+	}
+	ioctl(AC, TIOCFLUSH, &two);
+        pc(STX);
+	pc(vp->vc_rack);
+	pc(vp->vc_modem);
+	while (*phonenum && *phonenum != '<')
+		pc(*phonenum++);
+        pc(SI);
+	pc(ETX);
+        sleep(1);
+        i = read(AC, &c, 1);
+#ifdef DEBUG
+        printf("read %d chars, char=%c, errno %d\n", i, c, errno);
+#endif
+        if (i != 1)
+		c = 'M';
+        if (c == 'B' || c == 'G') {
+                char cc, oc = c;
+
+                pc(ABORT);
+                read(AC, &cc, 1);
+#ifdef DEBUG
+                printf("abort response=%c\n", cc);
+#endif
+                c = oc;
+                v831_disconnect();
+        }
+        close(AC);
+#ifdef DEBUG
+        printf("dialit: returns %c\n", c);
+#endif
+        return (c);
+}
+
+static char *
+sanitize(s)
+	register char *s;
+{
+        static char buf[128];
+        register char *cp;
+
+        for (cp = buf; *s; s++) {
+		if (!isdigit(*s) && *s == '<' && *s != '_')
+			continue;
+		if (*s == '_')
+			*s = '=';
+		*cp++ = *s;
+	}
+        *cp++ = 0;
+        return (buf);
+}
diff --git a/usr.bin/tip/libacu/ventel.c b/usr.bin/tip/libacu/ventel.c
new file mode 100644
index 0000000..73733e5
--- /dev/null
+++ b/usr.bin/tip/libacu/ventel.c
@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) 1983, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)ventel.c	8.1 (Berkeley) 6/6/93";
+#endif /* not lint */
+
+/*
+ * Routines for calling up on a Ventel Modem
+ * The Ventel is expected to be strapped for local echo (just like uucp)
+ */
+#include "tipconf.h"
+#include "tip.h"
+
+#define	MAXRETRY	5
+
+static	void sigALRM();
+static	int timeout = 0;
+static	jmp_buf timeoutbuf;
+
+/*
+ * some sleep calls have been replaced by this macro
+ * because some ventel modems require two <cr>s in less than
+ * a second in order to 'wake up'... yes, it is dirty...
+ */
+#define delay(num,denom) busyloop(CPUSPEED*num/denom)
+#define CPUSPEED 1000000	/* VAX 780 is 1MIPS */
+#define	DELAY(n)	{ register long N = (n); while (--N > 0); }
+busyloop(n) { DELAY(n); }
+
+ven_dialer(num, acu)
+	register char *num;
+	char *acu;
+{
+	register char *cp;
+	register int connected = 0;
+	char *msg, *index(), line[80];
+	static int gobble(), vensync();
+	static void echo();
+
+	/*
+	 * Get in synch with a couple of carriage returns
+	 */
+	if (!vensync(FD)) {
+		printf("can't synchronize with ventel\n");
+#if ACULOG
+		logent(value(HOST), num, "ventel", "can't synch up");
+#endif
+		return (0);
+	}
+	if (boolean(value(VERBOSE)))
+		printf("\ndialing...");
+	fflush(stdout);
+	acu_hupcl ();
+	echo("#k$\r$\n$D$I$A$L$:$ ");
+	for (cp = num; *cp; cp++) {
+		delay(1, 10);
+		write(FD, cp, 1);
+	}
+	delay(1, 10);
+	write(FD, "\r", 1);
+	gobble('\n', line);
+	if (gobble('\n', line))
+		connected = gobble('!', line);
+	acu_flush ();
+#if ACULOG
+	if (timeout) {
+		sprintf(line, "%d second dial timeout",
+			number(value(DIALTIMEOUT)));
+		logent(value(HOST), num, "ventel", line);
+	}
+#endif
+	if (timeout)
+		ven_disconnect();	/* insurance */
+	if (connected || timeout || !boolean(value(VERBOSE)))
+		return (connected);
+	/* call failed, parse response for user */
+	cp = index(line, '\r');
+	if (cp)
+		*cp = '\0';
+	for (cp = line; cp = index(cp, ' '); cp++)
+		if (cp[1] == ' ')
+			break;
+	if (cp) {
+		while (*cp == ' ')
+			cp++;
+		msg = cp;
+		while (*cp) {
+			if (isupper(*cp))
+				*cp = tolower(*cp);
+			cp++;
+		}
+		printf("%s...", msg);
+	}
+	return (connected);
+}
+
+ven_disconnect()
+{
+
+	close(FD);
+}
+
+ven_abort()
+{
+
+	write(FD, "\03", 1);
+	close(FD);
+}
+
+static void
+echo(s)
+	register char *s;
+{
+	char c;
+
+	while (c = *s++) switch (c) {
+
+	case '$':
+		read(FD, &c, 1);
+		s++;
+		break;
+
+	case '#':
+		c = *s++;
+		write(FD, &c, 1);
+		break;
+
+	default:
+		write(FD, &c, 1);
+		read(FD, &c, 1);
+	}
+}
+
+static void
+sigALRM()
+{
+	printf("\07timeout waiting for reply\n");
+	timeout = 1;
+	longjmp(timeoutbuf, 1);
+}
+
+static int
+gobble(match, response)
+	register char match;
+	char response[];
+{
+	register char *cp = response;
+	sig_t f;
+	char c;
+
+	f = signal(SIGALRM, sigALRM);
+	timeout = 0;
+	do {
+		if (setjmp(timeoutbuf)) {
+			signal(SIGALRM, f);
+			*cp = '\0';
+			return (0);
+		}
+		alarm(number(value(DIALTIMEOUT)));
+		read(FD, cp, 1);
+		alarm(0);
+		c = (*cp++ &= 0177);
+#ifdef notdef
+		if (boolean(value(VERBOSE)))
+			putchar(c);
+#endif
+	} while (c != '\n' && c != match);
+	signal(SIGALRM, SIG_DFL);
+	*cp = '\0';
+	return (c == match);
+}
+
+#define min(a,b)	((a)>(b)?(b):(a))
+/*
+ * This convoluted piece of code attempts to get
+ * the ventel in sync.  If you don't have FIONREAD
+ * there are gory ways to simulate this.
+ */
+static int
+vensync(fd)
+{
+	int already = 0, nread;
+	char buf[60];
+
+	/*
+	 * Toggle DTR to force anyone off that might have left
+	 * the modem connected, and insure a consistent state
+	 * to start from.
+	 *
+	 * If you don't have the ioctl calls to diddle directly
+	 * with DTR, you can always try setting the baud rate to 0.
+	 */
+	ioctl(FD, TIOCCDTR, 0);
+	sleep(1);
+	ioctl(FD, TIOCSDTR, 0);
+	while (already < MAXRETRY) {
+		/*
+		 * After reseting the modem, send it two \r's to
+		 * autobaud on. Make sure to delay between them
+		 * so the modem can frame the incoming characters.
+		 */
+		write(fd, "\r", 1);
+		delay(1,10);
+		write(fd, "\r", 1);
+		sleep(2);
+		if (ioctl(fd, FIONREAD, (caddr_t)&nread) < 0) {
+			perror("tip: ioctl");
+			continue;
+		}
+		while (nread > 0) {
+			read(fd, buf, min(nread, 60));
+			if ((buf[nread - 1] & 0177) == '$')
+				return (1);
+			nread -= min(nread, 60);
+		}
+		sleep(1);
+		already++;
+	}
+	return (0);
+}
+