[dragonfly.git] / libexec / telnetd / termstat.c

/*
 * Copyright (c) 1989, 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.
 *
 * @(#)termstat.c	8.2 (Berkeley) 5/30/95
 * $FreeBSD: src/libexec/telnetd/termstat.c,v 1.9.2.4 2002/04/13 11:07:12 markm Exp $
 * $DragonFly: src/libexec/telnetd/termstat.c,v 1.2 2003/06/17 04:27:08 dillon Exp $
 */

#include "telnetd.h"


/*
 * local variables
 */
int def_tspeed = -1, def_rspeed = -1;
#ifdef	TIOCSWINSZ
int def_row = 0, def_col = 0;
#endif
#ifdef	LINEMODE
static int _terminit = 0;
#endif	/* LINEMODE */

#ifdef	LINEMODE
/*
 * localstat
 *
 * This function handles all management of linemode.
 *
 * Linemode allows the client to do the local editing of data
 * and send only complete lines to the server.  Linemode state is
 * based on the state of the pty driver.  If the pty is set for
 * external processing, then we can use linemode.  Further, if we
 * can use real linemode, then we can look at the edit control bits
 * in the pty to determine what editing the client should do.
 *
 * Linemode support uses the following state flags to keep track of
 * current and desired linemode state.
 *	alwayslinemode : true if -l was specified on the telnetd
 * 	command line.  It means to have linemode on as much as
 *	possible.
 *
 * 	lmodetype: signifies whether the client can
 *	handle real linemode, or if use of kludgeomatic linemode
 *	is preferred.  It will be set to one of the following:
 *		REAL_LINEMODE : use linemode option
 *		NO_KLUDGE : don't initiate kludge linemode.
 *		KLUDGE_LINEMODE : use kludge linemode
 *		NO_LINEMODE : client is ignorant of linemode
 *
 *	linemode, uselinemode : linemode is true if linemode
 *	is currently on, uselinemode is the state that we wish
 *	to be in.  If another function wishes to turn linemode
 *	on or off, it sets or clears uselinemode.
 *
 *	editmode, useeditmode : like linemode/uselinemode, but
 *	these contain the edit mode states (edit and trapsig).
 *
 * The state variables correspond to some of the state information
 * in the pty.
 *	linemode:
 *		In real linemode, this corresponds to whether the pty
 *		expects external processing of incoming data.
 *		In kludge linemode, this more closely corresponds to the
 *		whether normal processing is on or not.  (ICANON in
 *		system V, or COOKED mode in BSD.)
 *		If the -l option was specified (alwayslinemode), then
 *		an attempt is made to force external processing on at
 *		all times.
 *
 * The following heuristics are applied to determine linemode
 * handling within the server.
 *	1) Early on in starting up the server, an attempt is made
 *	   to negotiate the linemode option.  If this succeeds
 *	   then lmodetype is set to REAL_LINEMODE and all linemode
 *	   processing occurs in the context of the linemode option.
 *	2) If the attempt to negotiate the linemode option failed,
 *	   and the "-k" (don't initiate kludge linemode) isn't set,
 *	   then we try to use kludge linemode.  We test for this
 *	   capability by sending "do Timing Mark".  If a positive
 *	   response comes back, then we assume that the client
 *	   understands kludge linemode (ech!) and the
 *	   lmodetype flag is set to KLUDGE_LINEMODE.
 *	3) Otherwise, linemode is not supported at all and
 *	   lmodetype remains set to NO_LINEMODE (which happens
 *	   to be 0 for convenience).
 *	4) At any time a command arrives that implies a higher
 *	   state of linemode support in the client, we move to that
 *	   linemode support.
 *
 * A short explanation of kludge linemode is in order here.
 *	1) The heuristic to determine support for kludge linemode
 *	   is to send a do timing mark.  We assume that a client
 *	   that supports timing marks also supports kludge linemode.
 *	   A risky proposition at best.
 *	2) Further negotiation of linemode is done by changing the
 *	   the server's state regarding SGA.  If server will SGA,
 *	   then linemode is off, if server won't SGA, then linemode
 *	   is on.
 */
void
localstat(void)
{
	int need_will_echo = 0;

	/*
	 * Check for changes to flow control if client supports it.
	 */
	flowstat();

	/*
	 * Check linemode on/off state
	 */
	uselinemode = tty_linemode();

	/*
	 * If alwayslinemode is on, and pty is changing to turn it off, then
	 * force linemode back on.
	 */
	if (alwayslinemode && linemode && !uselinemode) {
		uselinemode = 1;
		tty_setlinemode(uselinemode);
	}

	if (uselinemode) {
		/*
		 * Check for state of BINARY options.
		 *
		 * We only need to do the binary dance if we are actually going
		 * to use linemode.  As this confuses some telnet clients
		 * that don't support linemode, and doesn't gain us
		 * anything, we don't do it unless we're doing linemode.
		 * -Crh (henrich@msu.edu)
		 */

		if (tty_isbinaryin()) {
			if (his_want_state_is_wont(TELOPT_BINARY))
				send_do(TELOPT_BINARY, 1);
		} else {
			if (his_want_state_is_will(TELOPT_BINARY))
				send_dont(TELOPT_BINARY, 1);
		}

		if (tty_isbinaryout()) {
			if (my_want_state_is_wont(TELOPT_BINARY))
				send_will(TELOPT_BINARY, 1);
		} else {
			if (my_want_state_is_will(TELOPT_BINARY))
				send_wont(TELOPT_BINARY, 1);
		}
	}


	/*
	 * Do echo mode handling as soon as we know what the
	 * linemode is going to be.
	 * If the pty has echo turned off, then tell the client that
	 * the server will echo.  If echo is on, then the server
	 * will echo if in character mode, but in linemode the
	 * client should do local echoing.  The state machine will
	 * not send anything if it is unnecessary, so don't worry
	 * about that here.
	 *
	 * If we need to send the WILL ECHO (because echo is off),
	 * then delay that until after we have changed the MODE.
	 * This way, when the user is turning off both editing
	 * and echo, the client will get editing turned off first.
	 * This keeps the client from going into encryption mode
	 * and then right back out if it is doing auto-encryption
	 * when passwords are being typed.
	 */
	if (uselinemode) {
		if (tty_isecho())
			send_wont(TELOPT_ECHO, 1);
		else
			need_will_echo = 1;
#ifdef	KLUDGELINEMODE
		if (lmodetype == KLUDGE_OK)
			lmodetype = KLUDGE_LINEMODE;
#endif
	}

	/*
	 * If linemode is being turned off, send appropriate
	 * command and then we're all done.
	 */
	 if (!uselinemode && linemode) {
# ifdef	KLUDGELINEMODE
		if (lmodetype == REAL_LINEMODE) {
# endif	/* KLUDGELINEMODE */
			send_dont(TELOPT_LINEMODE, 1);
# ifdef	KLUDGELINEMODE
		} else if (lmodetype == KLUDGE_LINEMODE)
			send_will(TELOPT_SGA, 1);
# endif	/* KLUDGELINEMODE */
		send_will(TELOPT_ECHO, 1);
		linemode = uselinemode;
		goto done;
	}

# ifdef	KLUDGELINEMODE
	/*
	 * If using real linemode check edit modes for possible later use.
	 * If we are in kludge linemode, do the SGA negotiation.
	 */
	if (lmodetype == REAL_LINEMODE) {
# endif	/* KLUDGELINEMODE */
		useeditmode = 0;
		if (tty_isediting())
			useeditmode |= MODE_EDIT;
		if (tty_istrapsig())
			useeditmode |= MODE_TRAPSIG;
		if (tty_issofttab())
			useeditmode |= MODE_SOFT_TAB;
		if (tty_islitecho())
			useeditmode |= MODE_LIT_ECHO;
# ifdef	KLUDGELINEMODE
	} else if (lmodetype == KLUDGE_LINEMODE) {
		if (tty_isediting() && uselinemode)
			send_wont(TELOPT_SGA, 1);
		else
			send_will(TELOPT_SGA, 1);
	}
# endif	/* KLUDGELINEMODE */

	/*
	 * Negotiate linemode on if pty state has changed to turn it on.
	 * Send appropriate command and send along edit mode, then all done.
	 */
	if (uselinemode && !linemode) {
# ifdef	KLUDGELINEMODE
		if (lmodetype == KLUDGE_LINEMODE) {
			send_wont(TELOPT_SGA, 1);
		} else if (lmodetype == REAL_LINEMODE) {
# endif	/* KLUDGELINEMODE */
			send_do(TELOPT_LINEMODE, 1);
			/* send along edit modes */
			output_data("%c%c%c%c%c%c%c", IAC, SB,
				TELOPT_LINEMODE, LM_MODE, useeditmode,
				IAC, SE);
			editmode = useeditmode;
# ifdef	KLUDGELINEMODE
		}
# endif	/* KLUDGELINEMODE */
		linemode = uselinemode;
		goto done;
	}

# ifdef	KLUDGELINEMODE
	/*
	 * None of what follows is of any value if not using
	 * real linemode.
	 */
	if (lmodetype < REAL_LINEMODE)
		goto done;
# endif	/* KLUDGELINEMODE */

	if (linemode && his_state_is_will(TELOPT_LINEMODE)) {
		/*
		 * If edit mode changed, send edit mode.
		 */
		 if (useeditmode != editmode) {
			/*
			 * Send along appropriate edit mode mask.
			 */
			output_data("%c%c%c%c%c%c%c", IAC, SB,
				TELOPT_LINEMODE, LM_MODE, useeditmode,
				IAC, SE);
			editmode = useeditmode;
		}


		/*
		 * Check for changes to special characters in use.
		 */
		start_slc(0);
		check_slc();
		(void) end_slc(0);
	}

done:
	if (need_will_echo)
		send_will(TELOPT_ECHO, 1);
	/*
	 * Some things should be deferred until after the pty state has
	 * been set by the local process.  Do those things that have been
	 * deferred now.  This only happens once.
	 */
	if (_terminit == 0) {
		_terminit = 1;
		defer_terminit();
	}

	netflush();
	set_termbuf();
	return;

}  /* end of localstat */
#endif	/* LINEMODE */

/*
 * flowstat
 *
 * Check for changes to flow control
 */
void
flowstat(void)
{
	if (his_state_is_will(TELOPT_LFLOW)) {
		if (tty_flowmode() != flowmode) {
			flowmode = tty_flowmode();
			output_data("%c%c%c%c%c%c",
					IAC, SB, TELOPT_LFLOW,
					flowmode ? LFLOW_ON : LFLOW_OFF,
					IAC, SE);
		}
		if (tty_restartany() != restartany) {
			restartany = tty_restartany();
			output_data("%c%c%c%c%c%c",
					IAC, SB, TELOPT_LFLOW,
					restartany ? LFLOW_RESTART_ANY
						   : LFLOW_RESTART_XON,
					IAC, SE);
		}
	}
}

/*
 * clientstat
 *
 * Process linemode related requests from the client.
 * Client can request a change to only one of linemode, editmode or slc's
 * at a time, and if using kludge linemode, then only linemode may be
 * affected.
 */
void
clientstat(int code, int parm1, int parm2)
{

	/*
	 * Get a copy of terminal characteristics.
	 */
	init_termbuf();

	/*
	 * Process request from client. code tells what it is.
	 */
	switch (code) {
#ifdef	LINEMODE
	case TELOPT_LINEMODE:
		/*
		 * Don't do anything unless client is asking us to change
		 * modes.
		 */
		uselinemode = (parm1 == WILL);
		if (uselinemode != linemode) {
# ifdef	KLUDGELINEMODE
			/*
			 * If using kludge linemode, make sure that
			 * we can do what the client asks.
			 * We can not turn off linemode if alwayslinemode
			 * and the ICANON bit is set.
			 */
			if (lmodetype == KLUDGE_LINEMODE) {
				if (alwayslinemode && tty_isediting()) {
					uselinemode = 1;
				}
			}

			/*
			 * Quit now if we can't do it.
			 */
			if (uselinemode == linemode)
				return;

			/*
			 * If using real linemode and linemode is being
			 * turned on, send along the edit mode mask.
			 */
			if (lmodetype == REAL_LINEMODE && uselinemode)
# else	/* KLUDGELINEMODE */
			if (uselinemode)
# endif	/* KLUDGELINEMODE */
			{
				useeditmode = 0;
				if (tty_isediting())
					useeditmode |= MODE_EDIT;
				if (tty_istrapsig())
					useeditmode |= MODE_TRAPSIG;
				if (tty_issofttab())
					useeditmode |= MODE_SOFT_TAB;
				if (tty_islitecho())
					useeditmode |= MODE_LIT_ECHO;
				output_data("%c%c%c%c%c%c%c", IAC,
					SB, TELOPT_LINEMODE, LM_MODE,
							useeditmode, IAC, SE);
				editmode = useeditmode;
			}


			tty_setlinemode(uselinemode);

			linemode = uselinemode;

			if (!linemode)
				send_will(TELOPT_ECHO, 1);
		}
		break;

	case LM_MODE:
	    {
		int ack, changed;

		/*
		 * Client has sent along a mode mask.  If it agrees with
		 * what we are currently doing, ignore it; if not, it could
		 * be viewed as a request to change.  Note that the server
		 * will change to the modes in an ack if it is different from
		 * what we currently have, but we will not ack the ack.
		 */
		 useeditmode &= MODE_MASK;
		 ack = (useeditmode & MODE_ACK);
		 useeditmode &= ~MODE_ACK;

		 if ((changed = (useeditmode ^ editmode))) {
			/*
			 * This check is for a timing problem.  If the
			 * state of the tty has changed (due to the user
			 * application) we need to process that info
			 * before we write in the state contained in the
			 * ack!!!  This gets out the new MODE request,
			 * and when the ack to that command comes back
			 * we'll set it and be in the right mode.
			 */
			if (ack)
				localstat();
			if (changed & MODE_EDIT)
				tty_setedit(useeditmode & MODE_EDIT);

			if (changed & MODE_TRAPSIG)
				tty_setsig(useeditmode & MODE_TRAPSIG);

			if (changed & MODE_SOFT_TAB)
				tty_setsofttab(useeditmode & MODE_SOFT_TAB);

			if (changed & MODE_LIT_ECHO)
				tty_setlitecho(useeditmode & MODE_LIT_ECHO);

			set_termbuf();

 			if (!ack) {
				output_data("%c%c%c%c%c%c%c", IAC,
					SB, TELOPT_LINEMODE, LM_MODE,
 					useeditmode|MODE_ACK,
 					IAC, SE);
 			}

			editmode = useeditmode;
		}

		break;

	    }  /* end of case LM_MODE */
#endif	/* LINEMODE */

	case TELOPT_NAWS:
#ifdef	TIOCSWINSZ
	    {
		struct winsize ws;

		def_col = parm1;
		def_row = parm2;
#ifdef	LINEMODE
		/*
		 * Defer changing window size until after terminal is
		 * initialized.
		 */
		if (terminit() == 0)
			return;
#endif	/* LINEMODE */

		/*
		 * Change window size as requested by client.
		 */

		ws.ws_col = parm1;
		ws.ws_row = parm2;
		(void) ioctl(pty, TIOCSWINSZ, (char *)&ws);
	    }
#endif	/* TIOCSWINSZ */

		break;

	case TELOPT_TSPEED:
	    {
		def_tspeed = parm1;
		def_rspeed = parm2;
#ifdef	LINEMODE
		/*
		 * Defer changing the terminal speed.
		 */
		if (terminit() == 0)
			return;
#endif	/* LINEMODE */
		/*
		 * Change terminal speed as requested by client.
		 * We set the receive speed first, so that if we can't
		 * store separate receive and transmit speeds, the transmit
		 * speed will take precedence.
		 */
		tty_rspeed(parm2);
		tty_tspeed(parm1);
		set_termbuf();

		break;

	    }  /* end of case TELOPT_TSPEED */

	default:
		/* What? */
		break;
	}  /* end of switch */

	netflush();

}  /* end of clientstat */

#ifdef	LINEMODE
/*
 * defer_terminit
 *
 * Some things should not be done until after the login process has started
 * and all the pty modes are set to what they are supposed to be.  This
 * function is called when the pty state has been processed for the first time.
 * It calls other functions that do things that were deferred in each module.
 */
void
defer_terminit(void)
{

	/*
	 * local stuff that got deferred.
	 */
	if (def_tspeed != -1) {
		clientstat(TELOPT_TSPEED, def_tspeed, def_rspeed);
		def_tspeed = def_rspeed = 0;
	}

#ifdef	TIOCSWINSZ
	if (def_col || def_row) {
		struct winsize ws;

		memset((char *)&ws, 0, sizeof(ws));
		ws.ws_col = def_col;
		ws.ws_row = def_row;
		(void) ioctl(pty, TIOCSWINSZ, (char *)&ws);
	}
#endif

	/*
	 * The only other module that currently defers anything.
	 */
	deferslc();

}  /* end of defer_terminit */

/*
 * terminit
 *
 * Returns true if the pty state has been processed yet.
 */
int
terminit(void)
{
	return(_terminit);

}  /* end of terminit */
#endif	/* LINEMODE */
Commit	Line	Data
984263bc MD	1	/*
	2	* Copyright (c) 1989, 1993
	3	* The Regents of the University of California. All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	* 3. All advertising materials mentioning features or use of this software
	14	* must display the following acknowledgement:
	15	* This product includes software developed by the University of
	16	* California, Berkeley and its contributors.
	17	* 4. Neither the name of the University nor the names of its contributors
	18	* may be used to endorse or promote products derived from this software
	19	* without specific prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	22	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	24	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	25	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	26	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	27	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	28	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	29	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	30	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	31	* SUCH DAMAGE.
1de703da MD	32	*
	33	* @(#)termstat.c 8.2 (Berkeley) 5/30/95
	34	* $FreeBSD: src/libexec/telnetd/termstat.c,v 1.9.2.4 2002/04/13 11:07:12 markm Exp $
	35	* $DragonFly: src/libexec/telnetd/termstat.c,v 1.2 2003/06/17 04:27:08 dillon Exp $
984263bc MD	36	*/
984263bc MD	37
984263bc MD	38	#include "telnetd.h"
	39
	40
	41	/*
	42	* local variables
	43	*/
	44	int def_tspeed = -1, def_rspeed = -1;
	45	#ifdef TIOCSWINSZ
	46	int def_row = 0, def_col = 0;
	47	#endif
	48	#ifdef LINEMODE
	49	static int _terminit = 0;
	50	#endif /* LINEMODE */
	51
	52	#ifdef LINEMODE
	53	/*
	54	* localstat
	55	*
	56	* This function handles all management of linemode.
	57	*
	58	* Linemode allows the client to do the local editing of data
	59	* and send only complete lines to the server. Linemode state is
	60	* based on the state of the pty driver. If the pty is set for
	61	* external processing, then we can use linemode. Further, if we
	62	* can use real linemode, then we can look at the edit control bits
	63	* in the pty to determine what editing the client should do.
	64	*
	65	* Linemode support uses the following state flags to keep track of
	66	* current and desired linemode state.
	67	* alwayslinemode : true if -l was specified on the telnetd
	68	* command line. It means to have linemode on as much as
	69	* possible.
	70	*
	71	* lmodetype: signifies whether the client can
	72	* handle real linemode, or if use of kludgeomatic linemode
	73	* is preferred. It will be set to one of the following:
	74	* REAL_LINEMODE : use linemode option
	75	* NO_KLUDGE : don't initiate kludge linemode.
	76	* KLUDGE_LINEMODE : use kludge linemode
	77	* NO_LINEMODE : client is ignorant of linemode
	78	*
	79	* linemode, uselinemode : linemode is true if linemode
	80	* is currently on, uselinemode is the state that we wish
	81	* to be in. If another function wishes to turn linemode
	82	* on or off, it sets or clears uselinemode.
	83	*
	84	* editmode, useeditmode : like linemode/uselinemode, but
	85	* these contain the edit mode states (edit and trapsig).
	86	*
	87	* The state variables correspond to some of the state information
	88	* in the pty.
	89	* linemode:
	90	* In real linemode, this corresponds to whether the pty
	91	* expects external processing of incoming data.
	92	* In kludge linemode, this more closely corresponds to the
	93	* whether normal processing is on or not. (ICANON in
	94	* system V, or COOKED mode in BSD.)
	95	* If the -l option was specified (alwayslinemode), then
	96	* an attempt is made to force external processing on at
	97	* all times.
	98	*
	99	* The following heuristics are applied to determine linemode
	100	* handling within the server.
	101	* 1) Early on in starting up the server, an attempt is made
102	* to negotiate the linemode option. If this succeeds
103	* then lmodetype is set to REAL_LINEMODE and all linemode
104	* processing occurs in the context of the linemode option.
105	* 2) If the attempt to negotiate the linemode option failed,
106	* and the "-k" (don't initiate kludge linemode) isn't set,
107	* then we try to use kludge linemode. We test for this
108	* capability by sending "do Timing Mark". If a positive
109	* response comes back, then we assume that the client
110	* understands kludge linemode (ech!) and the
111	* lmodetype flag is set to KLUDGE_LINEMODE.
112	* 3) Otherwise, linemode is not supported at all and
113	* lmodetype remains set to NO_LINEMODE (which happens
114	* to be 0 for convenience).
115	* 4) At any time a command arrives that implies a higher
116	* state of linemode support in the client, we move to that
117	* linemode support.
118	*
119	* A short explanation of kludge linemode is in order here.
120	* 1) The heuristic to determine support for kludge linemode
121	* is to send a do timing mark. We assume that a client
122	* that supports timing marks also supports kludge linemode.
123	* A risky proposition at best.
124	* 2) Further negotiation of linemode is done by changing the
125	* the server's state regarding SGA. If server will SGA,
126	* then linemode is off, if server won't SGA, then linemode
127	* is on.
128	*/
129	void
130	localstat(void)
131	{
132	int need_will_echo = 0;
133
134	/*
135	* Check for changes to flow control if client supports it.
136	*/
137	flowstat();
138
139	/*
140	* Check linemode on/off state
141	*/
142	uselinemode = tty_linemode();
143
144	/*
145	* If alwayslinemode is on, and pty is changing to turn it off, then
146	* force linemode back on.
147	*/
148	if (alwayslinemode && linemode && !uselinemode) {
149	uselinemode = 1;
150	tty_setlinemode(uselinemode);
151	}
152
153	if (uselinemode) {
154	/*
155	* Check for state of BINARY options.
156	*
157	* We only need to do the binary dance if we are actually going
158	* to use linemode. As this confuses some telnet clients
159	* that don't support linemode, and doesn't gain us
160	* anything, we don't do it unless we're doing linemode.
161	* -Crh (henrich@msu.edu)
162	*/
163
164	if (tty_isbinaryin()) {
165	if (his_want_state_is_wont(TELOPT_BINARY))
166	send_do(TELOPT_BINARY, 1);
167	} else {
168	if (his_want_state_is_will(TELOPT_BINARY))
169	send_dont(TELOPT_BINARY, 1);
170	}
171
172	if (tty_isbinaryout()) {
173	if (my_want_state_is_wont(TELOPT_BINARY))
174	send_will(TELOPT_BINARY, 1);
175	} else {
176	if (my_want_state_is_will(TELOPT_BINARY))
177	send_wont(TELOPT_BINARY, 1);
178	}
179	}
180
181
182	/*
183	* Do echo mode handling as soon as we know what the
184	* linemode is going to be.
185	* If the pty has echo turned off, then tell the client that
186	* the server will echo. If echo is on, then the server
187	* will echo if in character mode, but in linemode the
188	* client should do local echoing. The state machine will
189	* not send anything if it is unnecessary, so don't worry
190	* about that here.
191	*
192	* If we need to send the WILL ECHO (because echo is off),
193	* then delay that until after we have changed the MODE.
194	* This way, when the user is turning off both editing
195	* and echo, the client will get editing turned off first.
196	* This keeps the client from going into encryption mode
197	* and then right back out if it is doing auto-encryption
198	* when passwords are being typed.
199	*/
200	if (uselinemode) {
201	if (tty_isecho())
202	send_wont(TELOPT_ECHO, 1);
203	else
204	need_will_echo = 1;
205	#ifdef KLUDGELINEMODE
206	if (lmodetype == KLUDGE_OK)
207	lmodetype = KLUDGE_LINEMODE;
208	#endif
209	}
210
211	/*
212	* If linemode is being turned off, send appropriate
213	* command and then we're all done.
214	*/
215	if (!uselinemode && linemode) {
216	# ifdef KLUDGELINEMODE
217	if (lmodetype == REAL_LINEMODE) {
218	# endif /* KLUDGELINEMODE */
219	send_dont(TELOPT_LINEMODE, 1);
220	# ifdef KLUDGELINEMODE
221	} else if (lmodetype == KLUDGE_LINEMODE)
222	send_will(TELOPT_SGA, 1);
223	# endif /* KLUDGELINEMODE */
224	send_will(TELOPT_ECHO, 1);
225	linemode = uselinemode;
226	goto done;
227	}
228
229	# ifdef KLUDGELINEMODE
230	/*
231	* If using real linemode check edit modes for possible later use.
232	* If we are in kludge linemode, do the SGA negotiation.
233	*/
234	if (lmodetype == REAL_LINEMODE) {
235	# endif /* KLUDGELINEMODE */
236	useeditmode = 0;
237	if (tty_isediting())
238	useeditmode \|= MODE_EDIT;
239	if (tty_istrapsig())
240	useeditmode \|= MODE_TRAPSIG;
241	if (tty_issofttab())
242	useeditmode \|= MODE_SOFT_TAB;
243	if (tty_islitecho())
244	useeditmode \|= MODE_LIT_ECHO;
245	# ifdef KLUDGELINEMODE
246	} else if (lmodetype == KLUDGE_LINEMODE) {
247	if (tty_isediting() && uselinemode)
248	send_wont(TELOPT_SGA, 1);
249	else
250	send_will(TELOPT_SGA, 1);
251	}
252	# endif /* KLUDGELINEMODE */
253
254	/*
255	* Negotiate linemode on if pty state has changed to turn it on.
256	* Send appropriate command and send along edit mode, then all done.
257	*/
258	if (uselinemode && !linemode) {
259	# ifdef KLUDGELINEMODE
260	if (lmodetype == KLUDGE_LINEMODE) {
261	send_wont(TELOPT_SGA, 1);
262	} else if (lmodetype == REAL_LINEMODE) {
263	# endif /* KLUDGELINEMODE */
264	send_do(TELOPT_LINEMODE, 1);
265	/* send along edit modes */
266	output_data("%c%c%c%c%c%c%c", IAC, SB,
267	TELOPT_LINEMODE, LM_MODE, useeditmode,
268	IAC, SE);
269	editmode = useeditmode;
270	# ifdef KLUDGELINEMODE
271	}
272	# endif /* KLUDGELINEMODE */
273	linemode = uselinemode;
274	goto done;
275	}
276
277	# ifdef KLUDGELINEMODE
278	/*
279	* None of what follows is of any value if not using
280	* real linemode.
281	*/
282	if (lmodetype < REAL_LINEMODE)
283	goto done;
284	# endif /* KLUDGELINEMODE */
285
286	if (linemode && his_state_is_will(TELOPT_LINEMODE)) {
287	/*
288	* If edit mode changed, send edit mode.
289	*/
290	if (useeditmode != editmode) {
291	/*
292	* Send along appropriate edit mode mask.
293	*/
294	output_data("%c%c%c%c%c%c%c", IAC, SB,
295	TELOPT_LINEMODE, LM_MODE, useeditmode,
296	IAC, SE);
297	editmode = useeditmode;
298	}
299
300
301	/*
302	* Check for changes to special characters in use.
303	*/
304	start_slc(0);
305	check_slc();
306	(void) end_slc(0);
307	}
308
309	done:
310	if (need_will_echo)
311	send_will(TELOPT_ECHO, 1);
312	/*
313	* Some things should be deferred until after the pty state has
314	* been set by the local process. Do those things that have been
315	* deferred now. This only happens once.
316	*/
317	if (_terminit == 0) {
318	_terminit = 1;
319	defer_terminit();
320	}
321
322	netflush();
323	set_termbuf();
324	return;
325
326	} /* end of localstat */
327	#endif /* LINEMODE */
328
329	/*
330	* flowstat
331	*
332	* Check for changes to flow control
333	*/
334	void
335	flowstat(void)
336	{
337	if (his_state_is_will(TELOPT_LFLOW)) {
338	if (tty_flowmode() != flowmode) {
339	flowmode = tty_flowmode();
340	output_data("%c%c%c%c%c%c",
341	IAC, SB, TELOPT_LFLOW,
342	flowmode ? LFLOW_ON : LFLOW_OFF,
343	IAC, SE);
344	}
345	if (tty_restartany() != restartany) {
346	restartany = tty_restartany();
347	output_data("%c%c%c%c%c%c",
348	IAC, SB, TELOPT_LFLOW,
349	restartany ? LFLOW_RESTART_ANY
350	: LFLOW_RESTART_XON,
351	IAC, SE);
352	}
353	}
354	}
355
356	/*
357	* clientstat
358	*
359	* Process linemode related requests from the client.
360	* Client can request a change to only one of linemode, editmode or slc's
361	* at a time, and if using kludge linemode, then only linemode may be
362	* affected.
363	*/
364	void
365	clientstat(int code, int parm1, int parm2)
366	{
367
368	/*
369	* Get a copy of terminal characteristics.
370	*/
371	init_termbuf();
372
373	/*
374	* Process request from client. code tells what it is.
375	*/
376	switch (code) {
377	#ifdef LINEMODE
378	case TELOPT_LINEMODE:
379	/*
380	* Don't do anything unless client is asking us to change
381	* modes.
382	*/
383	uselinemode = (parm1 == WILL);
384	if (uselinemode != linemode) {
385	# ifdef KLUDGELINEMODE
386	/*
387	* If using kludge linemode, make sure that
388	* we can do what the client asks.
389	* We can not turn off linemode if alwayslinemode
390	* and the ICANON bit is set.
391	*/
392	if (lmodetype == KLUDGE_LINEMODE) {
393	if (alwayslinemode && tty_isediting()) {
394	uselinemode = 1;
395	}
396	}
397
398	/*
399	* Quit now if we can't do it.
400	*/
401	if (uselinemode == linemode)
402	return;
403
404	/*
405	* If using real linemode and linemode is being
406	* turned on, send along the edit mode mask.
407	*/
408	if (lmodetype == REAL_LINEMODE && uselinemode)
409	# else /* KLUDGELINEMODE */
410	if (uselinemode)
411	# endif /* KLUDGELINEMODE */
412	{
413	useeditmode = 0;
414	if (tty_isediting())
415	useeditmode \|= MODE_EDIT;
e310e7bc	416	if (tty_istrapsig())
984263bc MD	417	useeditmode \|= MODE_TRAPSIG;
	418	if (tty_issofttab())
	419	useeditmode \|= MODE_SOFT_TAB;
	420	if (tty_islitecho())
	421	useeditmode \|= MODE_LIT_ECHO;
	422	output_data("%c%c%c%c%c%c%c", IAC,
	423	SB, TELOPT_LINEMODE, LM_MODE,
	424	useeditmode, IAC, SE);
	425	editmode = useeditmode;
	426	}
	427
	428
	429	tty_setlinemode(uselinemode);
	430
	431	linemode = uselinemode;
	432
	433	if (!linemode)
	434	send_will(TELOPT_ECHO, 1);
	435	}
	436	break;
	437
	438	case LM_MODE:
	439	{
	440	int ack, changed;
	441
	442	/*
	443	* Client has sent along a mode mask. If it agrees with
	444	* what we are currently doing, ignore it; if not, it could
	445	* be viewed as a request to change. Note that the server
	446	* will change to the modes in an ack if it is different from
	447	* what we currently have, but we will not ack the ack.
	448	*/
	449	useeditmode &= MODE_MASK;
	450	ack = (useeditmode & MODE_ACK);
	451	useeditmode &= ~MODE_ACK;
	452
	453	if ((changed = (useeditmode ^ editmode))) {
	454	/*
	455	* This check is for a timing problem. If the
	456	* state of the tty has changed (due to the user
	457	* application) we need to process that info
	458	* before we write in the state contained in the
	459	* ack!!! This gets out the new MODE request,
	460	* and when the ack to that command comes back
	461	* we'll set it and be in the right mode.
	462	*/
	463	if (ack)
	464	localstat();
	465	if (changed & MODE_EDIT)
	466	tty_setedit(useeditmode & MODE_EDIT);
	467
	468	if (changed & MODE_TRAPSIG)
	469	tty_setsig(useeditmode & MODE_TRAPSIG);
	470
	471	if (changed & MODE_SOFT_TAB)
	472	tty_setsofttab(useeditmode & MODE_SOFT_TAB);
	473
	474	if (changed & MODE_LIT_ECHO)
	475	tty_setlitecho(useeditmode & MODE_LIT_ECHO);
	476
	477	set_termbuf();
	478
	479	if (!ack) {
	480	output_data("%c%c%c%c%c%c%c", IAC,
481	SB, TELOPT_LINEMODE, LM_MODE,
482	useeditmode\|MODE_ACK,
483	IAC, SE);
484	}
485
486	editmode = useeditmode;
487	}
488
489	break;
490
491	} /* end of case LM_MODE */
492	#endif /* LINEMODE */
493
494	case TELOPT_NAWS:
495	#ifdef TIOCSWINSZ
496	{
497	struct winsize ws;
498
499	def_col = parm1;
500	def_row = parm2;
501	#ifdef LINEMODE
502	/*
503	* Defer changing window size until after terminal is
504	* initialized.
505	*/
506	if (terminit() == 0)
507	return;
508	#endif /* LINEMODE */
509
510	/*
511	* Change window size as requested by client.
512	*/
513
514	ws.ws_col = parm1;
515	ws.ws_row = parm2;
516	(void) ioctl(pty, TIOCSWINSZ, (char *)&ws);
517	}
518	#endif /* TIOCSWINSZ */
519
520	break;
521
522	case TELOPT_TSPEED:
523	{
524	def_tspeed = parm1;
525	def_rspeed = parm2;
526	#ifdef LINEMODE
527	/*
528	* Defer changing the terminal speed.
529	*/
530	if (terminit() == 0)
531	return;
532	#endif /* LINEMODE */
533	/*
534	* Change terminal speed as requested by client.
535	* We set the receive speed first, so that if we can't
536	* store separate receive and transmit speeds, the transmit
537	* speed will take precedence.
538	*/
539	tty_rspeed(parm2);
540	tty_tspeed(parm1);
541	set_termbuf();
542
543	break;
544
545	} /* end of case TELOPT_TSPEED */
546
547	default:
548	/* What? */
549	break;
550	} /* end of switch */
551
552	netflush();
553
554	} /* end of clientstat */
555
556	#ifdef LINEMODE
557	/*
558	* defer_terminit
559	*
560	* Some things should not be done until after the login process has started
561	* and all the pty modes are set to what they are supposed to be. This
562	* function is called when the pty state has been processed for the first time.
563	* It calls other functions that do things that were deferred in each module.
564	*/
565	void
566	defer_terminit(void)
567	{
568
569	/*
570	* local stuff that got deferred.
571	*/
572	if (def_tspeed != -1) {
573	clientstat(TELOPT_TSPEED, def_tspeed, def_rspeed);
574	def_tspeed = def_rspeed = 0;
575	}
576
577	#ifdef TIOCSWINSZ
578	if (def_col \|\| def_row) {
579	struct winsize ws;
580
581	memset((char *)&ws, 0, sizeof(ws));
582	ws.ws_col = def_col;
583	ws.ws_row = def_row;
584	(void) ioctl(pty, TIOCSWINSZ, (char *)&ws);
585	}
586	#endif
587
588	/*
589	* The only other module that currently defers anything.
590	*/
591	deferslc();
592
593	} /* end of defer_terminit */
594
595	/*
596	* terminit
597	*
598	* Returns true if the pty state has been processed yet.
599	*/
600	int
601	terminit(void)
602	{
603	return(_terminit);
604
605	} /* end of terminit */
606	#endif /* LINEMODE */