/*
  Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
  2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012,
  2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021 Free Software
  Foundation, Inc.

  This file is part of GNU Inetutils.

  GNU Inetutils is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or (at
  your option) any later version.

  GNU Inetutils is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see `http://www.gnu.org/licenses/'. */

/*
 * 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. 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.
 */

#include <config.h>

#include "telnetd.h"

#include <fcntl.h>	/* Solaris */

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

#if defined CRAY2 && defined UNICOS5
int newmap = 1;			/* nonzero if \n maps to ^M^J */
#endif

/*
 * 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)
{
  void netflush (void);
  int need_will_echo = 0;

#if defined CRAY2 && defined UNICOS5
  /*
   * Keep track of that ol' CR/NL mapping while we're in the
   * neighborhood.
   */
  newmap = tty_isnewmap ();
#endif /* defined(CRAY2) && defined(UNICOS5) */

  /*
   * Check for state of BINARY options.
   */
  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);
    }

  /*
   * 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);
    }

#ifdef	ENCRYPTION
  /*
   * If the terminal is not echoing, but editing is enabled,
   * something like password input is going to happen, so
   * if we the other side is not currently sending encrypted
   * data, ask the other side to start encrypting.
   */
  if (his_state_is_will (TELOPT_ENCRYPT))
    {
      static int enc_passwd = 0;
      if (uselinemode && !tty_isecho () && tty_isediting ()
	  && (enc_passwd == 0) && !decrypt_input)
	{
	  encrypt_send_request_start ();
	  enc_passwd = 1;
	}
      else if (enc_passwd)
	{
	  encrypt_send_request_end ();
	  enc_passwd = 0;
	}
    }
#endif /* ENCRYPTION */

  /*
   * 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;
      if (lmodetype == KLUDGE_OK)
	lmodetype = KLUDGE_LINEMODE;
    }

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

  /*
   * 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)
    {
      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;
    }
  else if (lmodetype == KLUDGE_LINEMODE)
    {
      if (tty_isediting () && uselinemode)
	send_wont (TELOPT_SGA, 1);
      else
	send_will (TELOPT_SGA, 1);
    }

  /*
   * 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)
    {
      if (lmodetype == KLUDGE_LINEMODE)
	{
	  send_wont (TELOPT_SGA, 1);
	}
      else if (lmodetype == REAL_LINEMODE)
	{
	  char data[8];

	  send_do (TELOPT_LINEMODE, 1);
	  /* send along edit modes */
	  sprintf (data, "%c%c%c%c%c%c%c",
		   IAC, SB, TELOPT_LINEMODE,
		   LM_MODE, useeditmode,
		   IAC, SE);
	  net_output_datalen (data, sizeof (data));
	  DEBUG (debug_options, 1,
		 printsub ('>', data + 2, sizeof (data) - 2));

	  editmode = useeditmode;
	}
      linemode = uselinemode;
      goto done;
    }

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

  if (linemode && his_state_is_will (TELOPT_LINEMODE))
    {
      /*
       * If edit mode changed, send edit mode.
       */
      if (useeditmode != editmode)
	{
	  /*
	   * Send along appropriate edit mode mask.
	   */
	  char data[8];

	  sprintf (data, "%c%c%c%c%c%c%c",
		   IAC, SB, TELOPT_LINEMODE,
		   LM_MODE, useeditmode,
		   IAC, SE);
	  net_output_datalen (data, sizeof (data));
	  DEBUG (debug_options, 1,
		 printsub ('>', data + 2, sizeof (data) - 2));

	  editmode = useeditmode;
	}


      /*
       * Check for changes to special characters in use.
       */
      start_slc (0);
      check_slc ();
      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 */

/*
 * flowstat
 *
 * Check for changes to flow control
 */
void
flowstat (void)
{
  if (his_state_is_will (TELOPT_LFLOW))
    {
      char data[7];

      if (tty_flowmode () != flowmode)
	{
	  flowmode = tty_flowmode ();
	  sprintf (data, "%c%c%c%c%c%c",
		   IAC, SB, TELOPT_LFLOW,
		   flowmode ? LFLOW_ON : LFLOW_OFF,
		   IAC, SE);
	  net_output_datalen (data, sizeof (data));
	  DEBUG (debug_options, 1,
		 printsub ('>', data + 2, sizeof (data) - 2));
	}
      if (tty_restartany () != restartany)
	{
	  restartany = tty_restartany ();
	  sprintf (data, "%c%c%c%c%c%c",
		   IAC, SB, TELOPT_LFLOW,
		   restartany ? LFLOW_RESTART_ANY : LFLOW_RESTART_XON,
		   IAC, SE);
	  net_output_datalen (data, sizeof (data));
	  DEBUG (debug_options, 1,
		 printsub ('>', data + 2, sizeof (data) - 2));
	}
    }
}

/*
 * 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 (register int code, register int parm1, register int parm2)
{
  void netflush (void);

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

  /*
   * Process request from client. code tells what it is.
   */
  switch (code)
    {
    case TELOPT_LINEMODE:
      /*
       * Don't do anything unless client is asking us to change
       * modes.
       */
      uselinemode = (parm1 == WILL);
      if (uselinemode != linemode)
	{
	  /*
	   * If using kludge linemode, make sure that
	   * we can do what the client asks.
	   * We cannot 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)
	    if (uselinemode)
	      {
		char data[8];

		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;

		sprintf (data, "%c%c%c%c%c%c%c",
			 IAC, SB, TELOPT_LINEMODE,
			 LM_MODE, useeditmode,
			 IAC, SE);
		net_output_datalen (data, sizeof (data));
		DEBUG (debug_options, 1,
		       printsub ('>', data + 2, sizeof (data) - 2));

		editmode = useeditmode;
	      }


	  tty_setlinemode (uselinemode);

	  linemode = uselinemode;

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

    case LM_MODE:
      {
	register 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)
	      {
		char data[8];

		sprintf (data, "%c%c%c%c%c%c%c",
			 IAC, SB, TELOPT_LINEMODE,
			 LM_MODE, useeditmode | MODE_ACK,
			 IAC, SE);
		net_output_datalen (data, sizeof (data));
		DEBUG (debug_options, 1,
		       printsub ('>', data + 2, sizeof (data) - 2));
	      }

	    editmode = useeditmode;
	  }

	break;

      }				/* end of case LM_MODE */

    case TELOPT_NAWS:
#ifdef	TIOCSWINSZ
      {
	struct winsize ws;

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

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

	ws.ws_col = parm1;
	ws.ws_row = parm2;

# if !defined SOLARIS && !defined SOLARIS10
	ioctl (pty, TIOCSWINSZ, (char *) &ws);
# else /* SOLARIS || SOLARIS10 */
	{
	  int tty = pty;
	  char *name = ptsname (pty);

	  if (name)
	    tty = open (name, O_RDWR | O_NONBLOCK | O_NOCTTY);

	  ioctl (tty, TIOCSWINSZ, (char *) &ws);

	  if (name)
	    close (tty);
	}
# endif /* SOLARIS || SOLARIS10 */
      }
#endif /* TIOCSWINSZ */

      break;

    case TELOPT_TSPEED:
      {
	def_tspeed = parm1;
	def_rspeed = parm2;
	/*
	 * Defer changing the terminal speed.
	 */
	if (terminit () == 0)
	  return;
	/*
	 * Change terminal speed as requested by client.
	 * We set the receive speed first, so that if we can't
	 * store seperate 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 */

#if defined CRAY2 && defined UNICOS5
  /*
   * Just in case of the likely event that we changed the pty state.
   */
  rcv_ioctl ();
#endif /* defined(CRAY2) && defined(UNICOS5) */

  netflush ();

}				/* end of clientstat */

#if defined CRAY2 && defined UNICOS5
void
termstat ()
{
  needtermstat = 1;
}

void
_termstat ()
{
  needtermstat = 0;
  init_termbuf ();
  localstat ();
  rcv_ioctl ();
}
#endif /* defined(CRAY2) && defined(UNICOS5) */

/*
 * 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;

# if !defined SOLARIS && !defined SOLARIS10
      ioctl (pty, TIOCSWINSZ, (char *) &ws);
# else /* SOLARIS || SOLARIS10 */
      {
	int tty = pty;
	char *name = ptsname (pty);

	if (name)
	  tty = open (name, O_RDWR | O_NONBLOCK | O_NOCTTY);

	ioctl (tty, TIOCSWINSZ, (char *) &ws);

	if (name)
	  close (tty);
      }
# endif /* SOLARIS || SOLARIS10 */
    }
#endif /* TIOCSWINSZ */

  /*
   * 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 */
