xref: /plan9/sys/src/cmd/postscript/postio/ifdef.c (revision 7dd7cddf99dd7472612f1413b4da293630e6b1bc)

/*
 *
 * Conditionally compiled routines for setting up and reading the line. Things
 * were getting out of hand with all the ifdefs, and even though this defeats
 * part of the purpose of conditional complilation directives, I think it's easier
 * to follow this way. Thanks to Alan Buckwalter for the System V DKHOST code.
 *
 * postio now can be run as separate read and write processes, but requires that
 * you write a procedure called resetline() and perhaps modify readline() some.
 * I've already tested the code on System V and it seems to work. Ninth Edition
 * and BSD code may be missing.
 *
 * By request I've changed the way some of the setupline() procedures (eg. in the
 * System V implementation) handle things when no line has been given. If line is
 * NULL the new setupline() procedures try to continue, assuming whoever called
 * postio connected stdout to the printer. Things will only work if we can read
 * and write stdout!
 *
 */

#include <stdio.h>
#include <ctype.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/types.h>
#include <errno.h>

#include "ifdef.h"			/* conditional header file inclusion */
#include "gen.h"			/* general purpose definitions */

FILE	*fp_ttyi, *fp_ttyo;
char	*ptr = mesg;

extern int	window_size;

/*****************************************************************************/

#ifdef SYSV
setupline()

{

    struct termio	termio;

/*
 *
 * Line initialization for SYSV. For now if no line is given (ie. line == NULL )
 * we continue on as before using stdout as ttyi and ttyo. Doesn't work when we're
 * running in interactive mode or forcing stuff that comes back from the printer
 * to stdout. Both cases are now caught by a test that's been added to routine
 * initialize(). The change is primarily for the version of lp that's available
 * with SVR3.2.
 *
 */

#ifdef DKHOST
    if ( line != NULL && *line != '/' )  {
	if ( strncmp(line, "DK:", 3) == 0 )
	    line += 3;
	dkhost_connect();
#ifdef DKSTREAMS
	if ( ioctl(ttyi, I_PUSH, DKSTREAMS) == -1 )
	    error(FATAL, "ioctl error - %s", DKSTREAMS);
	if ( ioctl(ttyi, I_PUSH, "ldterm") == -1 )
	    error(FATAL, "ioctl error - ldterm");
#endif
    } else
#endif

    if ( line == NULL )
	ttyi = fileno(stdout);
    else if ( (ttyi = open(line, O_RDWR)) == -1 )
	error(FATAL, "can't open %s", line);

    if ( (ttyo = dup(ttyi)) == -1 )
	error(FATAL, "can't dup file descriptor for %s", line);

    if ( stopbits == 1 )
	stopbits = 0;
    else stopbits = CSTOPB;

    if ( fcntl(ttyi, F_SETFL, O_NDELAY) == -1 )
	error(FATAL, "fcntl error - F_SETFL");

    if ( ioctl(ttyi, TCGETA, &termio) == -1 )
	error(FATAL, "ioctl error - TCGETA");

    termio.c_iflag = IXON | IGNCR;
    termio.c_oflag = 0;
    termio.c_cflag = HUPCL | CREAD | CS8 | stopbits | baudrate;
    termio.c_lflag = 0;
    termio.c_cc[VMIN] = termio.c_cc[VTIME] = 0;

    if ( ioctl(ttyi, TCSETA, &termio) == -1 )
	error(FATAL, "ioctl error - TCSETA");

    if ( ioctl(ttyi, TCFLSH, 2) == -1 )
	error(FATAL, "ioctl error - TCFLSH");

    fp_ttyi = fdopen(ttyi, "r");

}   /* End of setupline */

/*****************************************************************************/

resetline()

{

    int			flags;		/* for turning O_NDELAY off */
    struct termio	termio;		/* so we can reset flow control */

/*
 *
 * Only used if we're running the program as separate read and write processes.
 * Called from split() after the initial connection has been made and returns
 * TRUE if two processes should work. Don't know if the O_NDELAY stuff is really
 * needed, but setting c_cc[VMIN] to 1 definitely is. If we leave it be (as a 0)
 * the read in readline() won't block!
 *
 */

    if ( (flags = fcntl(ttyi, F_GETFL, 0)) == -1 )
	error(FATAL, "fcntl error - F_GETFL");

    flags &= ~O_NDELAY;

    if ( fcntl(ttyi, F_SETFL, flags) == -1 )
	error(FATAL, "fcntl error - F_SETFL");

    if ( ioctl(ttyi, TCGETA, &termio) == -1 )
	error(FATAL, "ioctl error - TCGETA");

    termio.c_iflag &= ~IXANY;
    termio.c_iflag |= IXON | IXOFF;
    termio.c_cc[VMIN] = 1;
    termio.c_cc[VTIME] = 0;

    if ( ioctl(ttyi, TCSETA, &termio) == -1 )
	error(FATAL, "ioctl error - TCSETA");

    return(TRUE);

}   /* End of resetline */

/*****************************************************************************/

setupstdin(mode)

    int		mode;			/* what to do with stdin settings */

{

    struct termio		termio;

    static int			saved = FALSE;
    static struct termio	oldtermio;

/*
 *
 * Save (mode = 0), reset (mode = 1), or restore (mode = 2) the tty settings for
 * stdin. Expect something like raw mode with no echo will be set up. Explicit
 * code to ensure blocking reads probably isn't needed because blocksize is set
 * to 1 when we're in interactive mode, but I've included it anyway.
 *
 */

    if ( interactive == TRUE )
	switch ( mode )  {
	    case 0:
		if ( isatty(0) != 1 )
		    error(FATAL, "stdin not a terminal - can't run interactive mode");
		if ( ioctl(0, TCGETA, &oldtermio) == -1 )
		    error(FATAL, "can't save terminal settings");
		saved = TRUE;
		break;

	    case 1:
		termio = oldtermio;
		termio.c_lflag &= ~(ICANON | ECHO | ECHOE | ECHOK | ECHONL);
		termio.c_cc[VMIN] = 1;
		termio.c_cc[VTIME] = 0;
		ioctl(0, TCSETA, &termio);
		break;

	    case 2:
		if ( saved == TRUE )
		    ioctl(0, TCSETA, &oldtermio);
		break;
	}   /* End switch */

}   /* End of setupstdin */

/*****************************************************************************/

readline()

{

    int		n;			/* read() return value */
    int		ch;			/* for interactive mode */

    static int	tries = 0;		/* consecutive times read returned 0 */

/*
 *
 * Reads characters coming back from the printer on ttyi up to a newline (or EOF)
 * or until no more characters are available. Characters are put in mesg[], the
 * string is terminated with '\0' when we're done with a line and TRUE is returned
 * to the caller. If complete line wasn't available FALSE is returned. Interactive
 * mode should loop here forever, except during start(), echoing characters to
 * stdout. If it happens to leave FALSE should be returned. The non-blocking read
 * gets us out until split() is called.
 *
 * Some users (apparently just on 3B2 DKHOST systems) have had problems with the
 * two process implementation that's forced me to kludge things up some. When a
 * printer (on those systems) is turned off while postio is transmitting files
 * the write process hangs in writeblock() (postio.c) - it's typically in the
 * middle of a write() call, while the read() call (below) continually returns 0.
 * In the original code readline() returned FALSE when read() returned 0 and we
 * get into a loop that never ends - because the write process is hung. In the
 * one process implementation having read return 0 is legitimate because the line
 * is opened for no delay, but with two processes the read() blocks and a return
 * value of 0 should never occur. From my point of view the real problem is that
 * the write() call hangs on 3B2 DKHOST systems and apparently doesn't anywhere
 * else. If the write returned anything less than or equal to 0 writeblock() would
 * shut things down. The kludge I've implemented counts the number of consecutive
 * times read() returns a 0 and if it exceeds a limit (100) the read process will
 * shut things down. In fact one return of 0 from read() when we're in the two
 * process mode is undoubtedly sufficient and no counting should be necessary!!!
 * Moving the check to getstatus() should also work and is probably where things
 * belong.
 *
 */

    if ( interactive == FALSE )  {
	while ( (n = read(ttyi, ptr, 1)) != 0 )  {
	    if ( n < 0 )
		if ( errno == EINTR )
		    continue;
		else error(FATAL, "error reading %s", line);
	    tries = 0;
	    if ( *ptr == '\n' || *ptr == '\004' || ptr >= endmesg )  {
		*(ptr+1) = '\0';
		if ( *ptr == '\004' )
		    strcpy(ptr, "%%[ status: endofjob ]%%\n");
		ptr = mesg;
		return(TRUE);
	    }   /* End if */
	    ptr++;
	}   /* End while */
	if ( canread == TRUE && canwrite == FALSE )	/* read process kludge */
	    if ( ++tries > 100 )
		error(FATAL, "printer appears to be offline - shutting down");
	return(FALSE);
    }	/* End if */

    if ( canwrite == TRUE )		/* don't block during start() */
	return(FALSE);

    while ( (ch = getc(fp_ttyi)) != EOF )
	putc(ch, stdout);
    return(FALSE);

}   /* End of readline */
#endif

/*****************************************************************************/

#ifdef V9
#include <ipc.h>

char	tbuf[256];			/* temporary input buffer */
char	*nptr = tbuf;			/* next character comes from here */
char	*eptr = tbuf;			/* one past the last character in tbuf */

setupline()

{

    struct sgttyb	sgtty;
    struct ttydevb	ttydev;		/* for setting up the line */
    static struct tchars	tchar = { '\377',	/* interrupt */
					  '\377',	/* quit */
					  '\021',	/* start output */
					  '\023',	/* stop output */
					  '\377',	/* end-of-file */
					  '\377'	/* input delimiter */
					};

/*
 *
 * Line initialization for V9.
 *
 */

    if ( line == NULL )  {
	ttyi = ttyo = 1;
	return;
    }	/* End if */
    alarm(120);			/* watch for hanging opens */
    if ( line[0] == '/' ) {
	if ( (ttyi = open(line, O_RDWR)) == -1 )
	error(FATAL, "can't open %s", line);
    } else if ((ttyi = ipcopen(ipcpath(line, "dk", 0), "")) < 0) {
		sleep(5);	/* wait for Datakit to hangup */
		if ((ttyi = ipcopen(ipcpath(line, "dk", 0), "")) < 0) {
			fprintf(stderr, "%s", errstr);
			error(FATAL, "can't ipcopen %s", line);
		}
    }
    alarm(0);

    if ( (ttyo = dup(ttyi)) == -1 )
	error(FATAL, "can't dup file descriptor for %s", line);

    if ( ioctl(ttyi, FIOPUSHLD, &tty_ld) == -1 )
	error(FATAL, "ioctl error - FIOPUSHLD");

    if ( ioctl(ttyi, TIOCGDEV, &ttydev) == -1 )
	error(FATAL, "ioctl error - TIOCGDEV");

    if ( ioctl(ttyi, TIOCGETP, &sgtty) == -1 )
	error(FATAL, "ioctl error - TIOCGETP");

    sgtty.sg_flags &= ~ECHO;
    sgtty.sg_flags &= ~CRMOD;
    sgtty.sg_flags |= CBREAK;
    ttydev.ispeed = baudrate;
    ttydev.ospeed = baudrate;

    if ( ioctl(ttyi, TIOCSDEV, &ttydev) == -1 )
	error(FATAL, "ioctl error - TIOCSDEV");

    if ( ioctl(ttyi, TIOCSETP, &sgtty) == -1 )
	error(FATAL, "ioctl error - TIOCSETP");

    if ( ioctl(ttyi, TIOCSETC, &tchar) == -1 )
	error(FATAL, "ioctl error - TIOCSETC");

    fp_ttyi = fdopen(ttyi, "r");

}   /* End of setupline */

/*****************************************************************************/

resetline()

{

    struct sgttyb	sgtty;

/*
 *
 * Only used if we're running the program as separate read and write processes.
 * Called from split() after the initial connection has been made and returns
 * TRUE if two processes should work. Haven't tested or even compiled the stuff
 * for separate read and write processes on Ninth Edition systems - no guarantees
 * even though we return TRUE!
 *
 */

    if ( ioctl(ttyi, TIOCGETP, &sgtty) == -1 )
	error(FATAL, "ioctl error - TIOCGETP");

    sgtty.sg_flags |= TANDEM;

    if ( ioctl(ttyi, TIOCSETP, &sgtty) == -1 )
	error(FATAL, "ioctl error - TIOCSETP");

    return(TRUE);

}   /* End of resetline */

/*****************************************************************************/

setupstdin(mode)

    int		mode;			/* what to do with stdin settings */

{

    struct sgttyb		sgtty;

    static int			saved = FALSE;
    static struct sgttyb	oldsgtty;

/*
 *
 * Save (mode = 0), reset (mode = 1), or restore (mode = 2) the tty settings for
 * stdin. Expect something like raw mode with no echo will be set up. Need to make
 * sure interrupt and quit still work - they're the only good way to exit when
 * we're running interactive mode. I haven't tested or even compiled this code
 * so there are no guarantees.
 *
 */

    if ( interactive == TRUE )
	switch ( mode )  {
	    case 0:
		if ( ioctl(0, TIOCGETP, &oldsgtty) == -1 )
		    error(FATAL, "can't save terminal settings");
		saved = TRUE;
		break;

	    case 1:
		sgtty = oldsgtty;
		sgtty.sg_flags &= ~ECHO;
		sgtty.sg_flags |= CBREAK;
		ioctl(0, TIOCSETP, &sgtty);
		break;

	    case 2:
		if ( saved == TRUE )
		    ioctl(0, TIOCSETP, &oldsgtty);
		break;
	}   /* End switch */

}   /* End of setupstdin */

/*****************************************************************************/

readline()

{

    int		n;			/* read() return value */
    int		ch;			/* for interactive mode */

/*
 *
 * Reads characters coming back from the printer on ttyi up to a newline (or EOF)
 * and transfers each line to the mesg[] array. Everything available on ttyi is
 * initially stored in tbuf[] and a line at a time is transferred from there to
 * mesg[]. The string in mesg[] is terminated with a '\0' and TRUE is returned to
 * the caller when we find a newline, EOF, or reach the end of the mesg[] array.
 * If nothing is available on ttyi we return FALSE if a single process is being
 * used for reads and writes, while in the two process implementation we force a
 * one character read. Interactive mode loops here forever, except during start(),
 * echoing everything that comes back on ttyi to stdout. The performance of a
 * simple getc/putc loop for interactive mode was unacceptable when run under mux
 * and has been replaced by more complicated code. When layers wasn't involved
 * the getc/putc loop worked well.
 *
 */

    if ( interactive == FALSE )  {
	while ( 1 )  {
	    while ( nptr < eptr )  {	/* grab characters from tbuf */
		*ptr = *nptr++;
		if ( *ptr == '\r' ) continue;
		if ( *ptr == '\n' || *ptr == '\004' || ptr >= endmesg )  {
		    *(ptr+1) = '\0';
		    if ( *ptr == '\004' )
			strcpy(ptr, "%%[ status: endofjob ]%%\n");
		    ptr = mesg;
		    return(TRUE);
		}   /* End if */
		++ptr;
	    }	/* End for */

	    nptr = eptr = tbuf;
	    if ( ioctl(ttyi, FIONREAD, &n) < 0 )
		if ( errno == EINTR )
		    continue;
		else error(FATAL, "ioctl error - FIONREAD");
	    if ( n <= 0 )
		if ( canwrite == TRUE )
		    return(FALSE);
	    n = ((n < 1) ? 1 : ((n < sizeof(tbuf)) ? n : sizeof(tbuf)));
	    if ( (n = read(ttyi, tbuf, n)) < 0 )
		if ( errno == EINTR )
		    continue;
		else error(FATAL, "error reading line %s", line);
	    else eptr = nptr + n;
	}   /* End while */
    }	/* End if */

    if ( canwrite == TRUE )		/* don't block during start() */
	return(FALSE);

    while ( 1 )  {			/* only interactive mode gets here */
	if ( ioctl(ttyi, FIONREAD, &n) < 0 )
	    error(FATAL, "ioctl error - FIONREAD");
	n = ((n < 1) ? 1 : ((n < sizeof(tbuf)) ? n : sizeof(tbuf)));
	if ( (n = read(ttyi, tbuf, n)) < 0 )
	    error(FATAL, "error reading line %s", line);
	else if ( n == 0 )		/* should not happen */
	    error(FATAL, "end of file in interactive mode");
	if ( write(1, tbuf, n) != n )
	    error(FATAL, "error writing to stdout");
    }	/* End while */

    return(FALSE);

}   /* End of readline */
#endif

/*****************************************************************************/

#ifdef BSD4_2
setupline()

{

    struct sgttyb	sgtty;
    static struct tchars	tchar = { '\377',	/* interrupt */
					  '\377',	/* quit */
					  '\021',	/* start output */
					  '\023',	/* stop output */
					  '\377',	/* end-of-file */
					  '\377'	/* input delimiter */
					};
    long	lmodes;
    int		disc = NTTYDISC;

/*
 *
 * Line initialization for BSD4_2. As in the System V code, if no line is given
 * (ie. line == NULL) we continue on as before using stdout as ttyi and ttyo.
 *
 */

    if ( line == NULL )
	ttyi = fileno(stdout);
    else if ( (ttyi = open(line, O_RDWR)) == -1 )
	error(FATAL, "can't open %s", line);

    if ( (ttyo = dup(ttyi)) == -1 )
	error(FATAL, "can't dup file descriptor for %s", line);

    if (ioctl(ttyi, TIOCSETD, &disc) == -1 )
	error(FATAL, "ioctl error - TIOCSETD");

    if ( ioctl(ttyi, TIOCGETP, &sgtty) == -1 )
	error(FATAL, "ioctl error - TIOCGETP");

    if ( ioctl(ttyi, TIOCLGET, &lmodes) == -1 )
	error(FATAL, "ioctl error - TIOCLGET");

    sgtty.sg_flags &= ~ECHO;
    sgtty.sg_flags &= ~CRMOD;
    sgtty.sg_flags |= CBREAK;
    sgtty.sg_ispeed = baudrate;
    sgtty.sg_ospeed = baudrate;
    lmodes |= LDECCTQ;

    if ( ioctl(ttyi, TIOCSETP, &sgtty) == -1 )
	error(FATAL, "ioctl error - TIOCSETP");

    if ( ioctl(ttyi, TIOCSETC, &tchar) == -1 )
	error(FATAL, "ioctl error - TIOCSETC");

    if ( ioctl(ttyi, TIOCLSET, &lmodes) == -1 )
	error(FATAL, "ioctl error - TIOCLSET");

    fp_ttyi = fdopen(ttyi, "r");

}   /* End of setupline */

/*****************************************************************************/

resetline()

{

    struct sgttyb	sgtty;

/*
 *
 * Only used if we're running the program as separate read and write processes.
 * Called from split() after the initial connection has been made and returns
 * TRUE if two processes should work. Haven't tested or even compiled the stuff
 * for separate read and write processes on Berkeley systems - no guarantees
 * even though we return TRUE!
 *
 */

    if ( ioctl(ttyi, TIOCGETP, &sgtty) == -1 )
	error(FATAL, "ioctl error - TIOCGETP");

    sgtty.sg_flags |= TANDEM;

    if ( ioctl(ttyi, TIOCSETP, &sgtty) == -1 )
	error(FATAL, "ioctl error - TIOCSETP");

    return(TRUE);

}   /* End of resetline */

/*****************************************************************************/

setupstdin(mode)

    int		mode;			/* what to do with stdin settings */

{

    struct sgttyb		sgtty;

    static int			saved = FALSE;
    static struct sgttyb	oldsgtty;

/*
 *
 * Save (mode = 0), reset (mode = 1), or restore (mode = 2) the tty settings for
 * stdin. Expect something like raw mode with no echo will be set up. Need to make
 * sure interrupt and quit still work - they're the only good way to exit when
 * we're running interactive mode. I haven't tested or even compiled this code
 * so there are no guarantees.
 *
 */

    if ( interactive == TRUE )
	switch ( mode )  {
	    case 0:
		if ( isatty(0) != 1 )
		    error(FATAL, "stdin not a terminal - can't run interactive mode");
		if ( ioctl(0, TIOCGETP, &oldsgtty) == -1 )
		    error(FATAL, "can't save terminal settings");
		saved = TRUE;
		break;

	    case 1:
		sgtty = oldsgtty;
		sgtty.sg_flags &= ~ECHO;
		sgtty.sg_flags |= CBREAK;
		ioctl(0, TIOCSETP, &sgtty);
		break;

	    case 2:
		if ( saved == TRUE )
		    ioctl(0, TIOCSETP, &oldsgtty);
		break;
	}   /* End switch */

}   /* End of setupstdin */

/*****************************************************************************/

readline()

{

    int		n;			/* read() return value */
    int		ch;			/* for interactive mode */

/*
 *
 * Reads characters coming back from the printer on ttyo up to a newline (or EOF)
 * or until no more characters are available. Characters are put in mesg[], the
 * string is terminated with '\0' when we're done with a line and TRUE is returned
 * to the caller. If complete line wasn't available FALSE is returned. Interactive
 * mode should loop here forever, except during start(), echoing characters to
 * stdout. If it happens to leave FALSE should be returned. Probably should read
 * everything available on ttyi into a temporary buffer and work from there rather
 * than reading one character at a time.
 *
 */

    if ( interactive == FALSE )  {
	while ( 1 )  {
	    if ( ioctl(ttyi, FIONREAD, &n) < 0 )
		if ( errno == EINTR )
		    continue;
		else error(FATAL, "ioctl error - FIONREAD");
	    if ( n <= 0 )
		if ( canwrite == TRUE )
		    return(FALSE);
		else n = 1;
	    for ( ; n > 0; n-- )  {
		/*if ( read(ttyi, ptr, 1) < 0 )*/
		if ( (*ptr = getc(fp_ttyi)) == EOF )
		    if ( errno == EINTR )
			continue;
		    else error(FATAL, "error reading %s", line);
		if ( *ptr == '\r' ) continue;
		if ( *ptr == '\n' || *ptr == '\004' || ptr >= endmesg )  {
		    *(ptr+1) = '\0';
		    if ( *ptr == '\004' )
			strcpy(ptr, "%%[ status: endofjob ]%%\n");
		    ptr = mesg;
		    return(TRUE);
		}   /* End if */
		++ptr;
	    }	/* End for */
	}   /* End while */
    }	/* End if */

    if ( canwrite == TRUE )		/* don't block during start() */
	return(FALSE);

    while ( (ch = getc(fp_ttyi)) != EOF )
	putc(ch, stdout);
    return(FALSE);

}   /* End of readline */

/*****************************************************************************/

/*	@(#)strspn.c	1.2	*/
/*LINTLIBRARY*/
/*
 * Return the number of characters in the maximum leading segment
 * of string which consists solely of characters from charset.
 */
int
strspn(string, charset)
char	*string;
register char	*charset;
{
	register char *p, *q;

	for(q=string; *q != '\0'; ++q) {
		for(p=charset; *p != '\0' && *p != *q; ++p)
			;
		if(*p == '\0')
			break;
	}
	return(q-string);
}

/*	@(#)strpbrk.c	1.2	*/
/*LINTLIBRARY*/
/*
 * Return ptr to first occurance of any character from `brkset'
 * in the character string `string'; NULL if none exists.
 */

char *
strpbrk(string, brkset)
register char *string, *brkset;
{
	register char *p;

	do {
		for(p=brkset; *p != '\0' && *p != *string; ++p)
			;
		if(*p != '\0')
			return(string);
	}
	while(*string++);
	return((char*)0);
}

/*	@(#)strtok.c	1.2	*/
/*	3.0 SID #	1.2	*/
/*LINTLIBRARY*/
/*
 * uses strpbrk and strspn to break string into tokens on
 * sequentially subsequent calls.  returns NULL when no
 * non-separator characters remain.
 * `subsequent' calls are calls with first argument NULL.
 */


extern int strspn();
extern char *strpbrk();

char *
strtok(string, sepset)
char	*string, *sepset;
{
	register char	*p, *q, *r;
	static char	*savept;

	/*first or subsequent call*/
	p = (string == (char*)0)? savept: string;

	if(p == 0)		/* return if no tokens remaining */
		return((char*)0);

	q = p + strspn(p, sepset);	/* skip leading separators */

	if(*q == '\0')		/* return if no tokens remaining */
		return((char*)0);

	if((r = strpbrk(q, sepset)) == (char*)0)	/* move past token */
		savept = 0;	/* indicate this is last token */
	else {
		*r = '\0';
		savept = ++r;
	}
	return(q);
}
#endif

/*****************************************************************************/

#ifdef DKHOST

#ifndef DKSTREAMS
short	dkrmode[3] = {DKR_TIME, 0, 0};
#endif

dkhost_connect()

{

    int		ofd;			/* for saving and restoring stderr */
    int		dfd;
    int		retrytime = 5;

/*
 *
 * Tries to connect to a Datakit destination. The extra stuff I've added to save
 * and later restore stderr is primarily for our spooling setup at Murray Hill.
 * postio is usually called with stderr directed to a file that will be returned
 * to the user when the job finishes printing. Problems encountered by dkdial(),
 * like busy messages, go to stderr but don't belong in the user's mail. They'll
 * be temporarily directed to the log file. After we've connected stderr will be
 * restored.
 *
 */

    if ( *line == '\0' )
	error(FATAL, "incomplete Datakit line");

    if ( fp_log != NULL && fp_log != stderr )  {	/* redirect dkdial errors */
	ofd = dup(2);
	close(2);
	dup(fileno(fp_log));
    }	/* End if */

    while ( (dfd = ttyi = dkdial(line)) < 0 )  {
	if ( retrytime < 0 )
	    error(FATAL, "can't connect to %s", line);
	sleep(retrytime++);
	if ( retrytime > 60 )
	    retrytime = 60;
    }	/* End while */

    if ( fp_log != NULL && fp_log != stderr )  {	/* restore stderr */
	close(2);
	dup(ofd);
	close(ofd);
    }	/* End if */

#ifndef DKSTREAMS
    if ( ioctl(ttyi, DIOCRMODE, dkrmode) == -1 )
	error(FATAL, "ioctl error - DIOCRMODE");

#ifdef DIOURPWD
    if ( window_size > 0 ) {
	short	dkparm[3];

	dkparm[0] = dkminor(ttyi);
	dkparm[1] = 1;
	dkparm[2] = window_size;
	if ( ioctl(ttyi, DIOURPWD, dkparm) < 0 || ioctl(ttyi, DIOCFLUSH, 0) < 0 )
	    error(NON_FATAL, "WSA failed");
    }	/* End if */
#endif

    line = dtnamer(dkminor(ttyi));

    if ( (ttyi = open(line, O_RDWR)) == -1 )
	error(FATAL, "can't open %s", line);

    close(dfd);
#endif

}   /* End of dkhost_connect */
#endif

/*****************************************************************************/