/* * 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. * 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 lintstatic char sccsid[] = "@(#)state.c	8.5 (Berkeley) 5/30/95";#endif /* not lint */#include "telnetd.h"#include <stdarg.h>/* Format lines for corresponing commands */unsigned char doopt[] = {IAC, DO, '%', 'c', 0};unsigned char dont[] = {IAC, DONT, '%', 'c', 0};unsigned char will[] = {IAC, WILL, '%', 'c', 0};unsigned char wont[] = {IAC, WONT, '%', 'c', 0};int not42 = 1;/* * Buffer for sub-options, and macros * for suboptions buffer manipulations */unsigned char subbuffer[512], *subpointer = subbuffer, *subend = subbuffer;#define	SB_CLEAR()	subpointer = subbuffer#define	SB_TERM()	{ subend = subpointer; SB_CLEAR(); }#define	SB_ACCUM(c)	if (subpointer < (subbuffer+sizeof subbuffer)) { \				*subpointer++ = (c); \			}#define	SB_GET()	((*subpointer++)&0xff)#define	SB_EOF()	(subpointer >= subend)#define	SB_LEN()	(subend - subpointer)#ifdef	ENV_HACKunsigned char *subsave;#define SB_SAVE()	subsave = subpointer;#define	SB_RESTORE()	subpointer = subsave;#endif/* * State for recv fsm */#define	TS_DATA		0	/* base state */#define	TS_IAC		1	/* look for double IAC's */#define	TS_CR		2	/* CR-LF ->'s CR */#define	TS_SB		3	/* throw away begin's... */#define	TS_SE		4	/* ...end's (suboption negotiation) */#define	TS_WILL		5	/* will option negotiation */#define	TS_WONT		6	/* wont " */#define	TS_DO		7	/* do " */#define	TS_DONT		8	/* dont " */static voidsend_eof (){  init_termbuf ();  term_send_eof ();  pty_output_byte (slctab[SLC_EOF].sptr ?		   (unsigned char) *slctab[SLC_EOF].sptr : '\004');}/* * When we get an AYT, if ^T is enabled, use that.  Otherwise, * just send back "[Yes]". */static voidrecv_ayt (){#if	defined(SIGINFO) && defined(TCSIG)  if (slctab[SLC_AYT].sptr && *slctab[SLC_AYT].sptr != _POSIX_VDISABLE)    {      ioctl (pty, TCSIG, (char *) SIGINFO);      return;    }#endif  net_output_data ("\r\n[Yes]\r\n");}static voidsend_susp (){#ifdef	SIGTSTP  ptyflush ();			/* half-hearted */#ifdef	TCSIG  ioctl (pty, TCSIG, (char *) SIGTSTP);#else /* TCSIG */  pty_output_byte (slctab[SLC_SUSP].sptr ?		   (unsigned char) *slctab[SLC_SUSP].sptr : '\032');#endif /* TCSIG */#endif /* SIGTSTP */}/* * Send quit to process on other side of pty. * If it is in raw mode, just write NULL; * otherwise, write quit char. */static voidsend_brk (){  ptyflush ();			/* half-hearted */#ifdef	TCSIG  ioctl (pty, TCSIG, (char *) SIGQUIT);#else /* TCSIG */  init_termbuf ();  pty_output_byte (slctab[SLC_ABORT].sptr ?		   (unsigned char) *slctab[SLC_ABORT].sptr : '\034');#endif /* TCSIG */}/* * Send interrupt to process on other side of pty. * If it is in raw mode, just write NULL; * otherwise, write intr char. */static voidsend_intr (){  ptyflush ();			/* half-hearted */#if defined(HAVE_STREAMSPTY) && defined(TIOCSIGNAL)  /* Streams PTY style ioctl to post a signal */  {    int sig = SIGINT;    ioctl (pty, TIOCSIGNAL, &sig);    ioctl (pty, I_FLUSH, FLUSHR);  }#else#ifdef	TCSIG  ioctl (pty, TCSIG, (char *) SIGINT);#else /* TCSIG */  init_termbuf ();  pty_output_byte (slctab[SLC_IP].sptr ?		   (unsigned char) *slctab[SLC_IP].sptr : '\177');#endif /* TCSIG */#endif}voidtelrcv (){  register int c;  static int state = TS_DATA;  while (net_input_level () > 0 & !pty_buffer_is_full () )    {      c = net_get_char (0);#ifdef	ENCRYPTION      if (decrypt_input)	c = (*decrypt_input) (c);#endif /* ENCRYPTION */      switch (state)	{	case TS_CR:	  state = TS_DATA;	  /* Strip off \n or \0 after a \r */	  if ((c == 0) || (c == '\n'))	    break;	  /* FALL THROUGH */	case TS_DATA:	  if (c == IAC)	    {	      state = TS_IAC;	      break;	    }	  /*	   * We now map \r\n ==> \r for pragmatic reasons.	   * Many client implementations send \r\n when	   * the user hits the CarriageReturn key.	   *	   * We USED to map \r\n ==> \n, since \r\n says	   * that we want to be in column 1 of the next	   * printable line, and \n is the standard	   * unix way of saying that (\r is only good	   * if CRMOD is set, which it normally is).	   */	  if ((c == '\r') && his_state_is_wont (TELOPT_BINARY))	    {	      int nc = net_get_char (1);#ifdef	ENCRYPTION	      if (decrypt_input)		nc = (*decrypt_input) (nc & 0xff);#endif /* ENCRYPTION */	      /*	       * If we are operating in linemode,	       * convert to local end-of-line.	       */	      if (linemode		  && net_input_level () > 0		  && (('\n' == nc) || (!nc && tty_iscrnl ())))		{		  net_get_char (0); /* Remove from the buffer */		  c = '\n';		}	      else		{#ifdef	ENCRYPTION		  if (decrypt_input)		    (*decrypt_input) (-1);#endif /* ENCRYPTION */		  state = TS_CR;		}	    }	  pty_output_byte (c);	  break;	case TS_IAC:	gotiac:	  switch (c)	    {	      /*	       * Send the process on the pty side an	       * interrupt.  Do this with a NULL or	       * interrupt char; depending on the tty mode.	       */	    case IP:	      DEBUG (debug_options, 1,		    printoption ("td: recv IAC", c));	      send_intr ();	      break;	    case BREAK:	      DEBUG (debug_options, 1,		    printoption ("td: recv IAC", c));	      send_brk ();	      break;	      /*	       * Are You There?	       */	    case AYT:	      DEBUG (debug_options, 1,                     printoption ("td: recv IAC", c));	      recv_ayt ();	      break;	      /*	       * Abort Output	       */	    case AO:	      {                DEBUG (debug_options, 1,		      printoption ("td: recv IAC", c));		ptyflush ();	/* half-hearted */		init_termbuf ();		if (slctab[SLC_AO].sptr		    && *slctab[SLC_AO].sptr != (cc_t) (_POSIX_VDISABLE))		  pty_output_byte (*slctab[SLC_AO].sptr);		netclear ();	/* clear buffer back */		net_output_data ("%c%c", IAC, DM);		set_neturg ();		DEBUG(debug_options, 1,		      printoption ("td: send IAC", DM));		break;	      }	      /*	       * Erase Character and	       * Erase Line	       */	    case EC:	    case EL:	      {		cc_t ch;                DEBUG(debug_options, 1,            		      printoption ("td: recv IAC", c));		ptyflush ();	/* half-hearted */		init_termbuf ();		if (c == EC)		  ch = *slctab[SLC_EC].sptr;		else		  ch = *slctab[SLC_EL].sptr;		if (ch != (cc_t) (_POSIX_VDISABLE))		  pty_output_byte ((unsigned char)ch);		break;	      }	      /*	       * Check for urgent data...	       */	    case DM:	      DEBUG(debug_options, 1,		    printoption ("td: recv IAC", c));	      SYNCHing = stilloob (net);	      settimer (gotDM);	      break;	      /*	       * Begin option subnegotiation...	       */	    case SB:	      state = TS_SB;	      SB_CLEAR ();	      continue;	    case WILL:	      state = TS_WILL;	      continue;	    case WONT:	      state = TS_WONT;	      continue;	    case DO:	      state = TS_DO;	      continue;	    case DONT:	      state = TS_DONT;	      continue;	    case EOR:	      if (his_state_is_will (TELOPT_EOR))		send_eof ();	      break;	      /*	       * Handle RFC 10xx Telnet linemode option additions	       * to command stream (EOF, SUSP, ABORT).	       */	    case xEOF:	      send_eof ();	      break;	    case SUSP:	      send_susp ();	      break;	    case ABORT:	      send_brk ();	      break;	    case IAC:	      pty_output_byte (c);	      break;	    }	  state = TS_DATA;	  break;	case TS_SB:	  if (c == IAC)	    state = TS_SE;	  else	    SB_ACCUM (c);	  break;	case TS_SE:	  if (c != SE)	    {	      if (c != IAC)		{		  /*		   * bad form of suboption negotiation.		   * handle it in such a way as to avoid		   * damage to local state.  Parse		   * suboption buffer found so far,		   * then treat remaining stream as		   * another command sequence.		   */		  /* for DIAGNOSTICS */		  SB_ACCUM (IAC);		  SB_ACCUM (c);		  subpointer -= 2;		  SB_TERM ();		  suboption ();		  state = TS_IAC;		  goto gotiac;		}	      SB_ACCUM (c);	      state = TS_SB;	    }	  else	    {	      /* for DIAGNOSTICS */	      SB_ACCUM (IAC);	      SB_ACCUM (SE);	      subpointer -= 2;	      SB_TERM ();	      suboption ();	/* handle sub-option */	      state = TS_DATA;	    }	  break;	case TS_WILL:	  willoption (c);	  state = TS_DATA;	  continue;	case TS_WONT:	  wontoption (c);	  state = TS_DATA;	  continue;	case TS_DO:	  dooption (c);	  state = TS_DATA;	  continue;	case TS_DONT:	  dontoption (c);	  state = TS_DATA;	  continue;	default:	  syslog (LOG_ERR, "telnetd: panic state=%d\n", state);	  printf ("telnetd: panic state=%d\n", state);	  exit (1);	}    }}				/* end of telrcv *//* * The will/wont/do/dont state machines are based on Dave Borman's * Telnet option processing state machine. * * These correspond to the following states: *      my_state = the last negotiated state *      want_state = what I want the state to go to *      want_resp = how many requests I have sent * All state defaults are negative, and resp defaults to 0. * * When initiating a request to change state to new_state: * * if ((want_resp == 0 && new_state == my_state) || want_state == new_state) { *      do nothing; * } else { *      want_state = new_state; *      send new_state; *      want_resp++; * } * * When receiving new_state: * * if (want_resp) { *      want_resp--; *      if (want_resp && (new_state == my_state)) *              want_resp--; * } * if ((want_resp == 0) && (new_state != want_state)) { *      if (ok_to_switch_to new_state) *              want_state = new_state; *      else *              want_resp++; *      send want_state; * } * my_state = new_state; * * Note that new_state is implied in these functions by the function itself. * will and do imply positive new_state, wont and dont imply negative. * * Finally, there is one catch.  If we send a negative response to a * positive request, my_state will be the positive while want_state will * remain negative.  my_state will revert to negative when the negative * acknowlegment arrives from the peer.  Thus, my_state generally tells * us not only the last negotiated state, but also tells us what the peer * wants to be doing as well.  It is important to understand this difference * as we may wish to be processing data streams based on our desired state * (want_state) or based on what the peer thinks the state is (my_state). * * This all works fine because if the peer sends a positive request, the data * that we receive prior to negative acknowlegment will probably be affected * by the positive state, and we can process it as such (if we can; if we * can't then it really doesn't matter).  If it is that important, then the * peer probably should be buffering until this option state negotiation * is complete. * */voidsend_do (int option, int init){  if (init)    {      if ((do_dont_resp[option] == 0 && his_state_is_will (option)) ||	  his_want_state_is_will (option))	return;      /*       * Special case for TELOPT_TM:  We send a DO, but pretend       * that we sent a DONT, so that we can send more DOs if       * we want to.       */      if (option == TELOPT_TM)	set_his_want_state_wont (option);      else	set_his_want_state_will (option);      do_dont_resp[option]++;    }  net_output_data (doopt, option);  DEBUG(debug_options, 1, printoption ("td: send do", option));}#ifdef	AUTHENTICATIONextern void auth_request ();#endifextern void doclientstat ();#ifdef	ENCRYPTIONextern void encrypt_send_support ();#endif /* ENCRYPTION */voidwilloption (int option){  int changeok = 0;  void (*func) () = 0;  /*   * process input from peer.   */  DEBUG(debug_options, 1, printoption ("td: recv will", option));  if (do_dont_resp[option])    {      do_dont_resp[option]--;      if (do_dont_resp[option] && his_state_is_will (option))	do_dont_resp[option]--;    }  if (do_dont_resp[option] == 0)    {      if (his_want_state_is_wont (option))	{	  switch (option)	    {	    case TELOPT_BINARY:	      init_termbuf ();	      tty_binaryin (1);	      set_termbuf ();	      changeok++;	      break;	    case TELOPT_ECHO: