/* Copyright (C) 1998,2001 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 2, 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 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 GNU Inetutils; see the file COPYING. If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#define TELOPTS
#define TELCMDS
#define SLC_NAMES
#include "telnetd.h"
#include <stdarg.h>
#ifdef HAVE_TERMIO_H
# include <termio.h>
#endif
#if defined(AUTHENTICATION) || defined(ENCRYPTION)
# include <libtelnet/misc.h>
# define NET_ENCRYPT net_encrypt
#else
# define NET_ENCRYPT()
#endif
static char netobuf[BUFSIZ+NETSLOP], *nfrontp, *nbackp;
static char *neturg; /* one past last byte of urgent data */
#ifdef ENCRYPTION
static char *nclearto;
#endif
static char ptyobuf[BUFSIZ+NETSLOP], *pfrontp, *pbackp;
static char netibuf[BUFSIZ], *netip;
static int ncc;
static char ptyibuf[BUFSIZ], *ptyip;
static int pcc;
int not42;
static int
readstream (int p, char *ibuf, int bufsize)
{
#ifndef HAVE_STREAMSPTY
return read (p, ibuf, bufsize);
#else
int flags = 0;
int ret = 0;
struct termios *tsp;
struct termio *tp;
struct iocblk *ip;
char vstop, vstart;
int ixon;
int newflow;
struct strbuf strbufc, strbufd;
unsigned char ctlbuf[BUFSIZ];
static int flowstate = -1;
strbufc.maxlen = BUFSIZ;
strbufc.buf = (char *)ctlbuf;
strbufd.maxlen = bufsize-1;
strbufd.len = 0;
strbufd.buf = ibuf+1;
ibuf[0] = 0;
ret = getmsg(p, &strbufc, &strbufd, &flags);
if (ret < 0) /* error of some sort -- probably EAGAIN */
return -1;
if (strbufc.len <= 0 || ctlbuf[0] == M_DATA)
{
/* data message */
if (strbufd.len > 0) /* real data */
return strbufd.len + 1; /* count header char */
else
{
/* nothing there */
errno = EAGAIN;
return -1;
}
}
/*
* It's a control message. Return 1, to look at the flag we set
*/
switch (ctlbuf[0])
{
case M_FLUSH:
if (ibuf[1] & FLUSHW)
ibuf[0] = TIOCPKT_FLUSHWRITE;
return 1;
case M_IOCTL:
ip = (struct iocblk *) (ibuf+1);
switch (ip->ioc_cmd)
{
case TCSETS:
case TCSETSW:
case TCSETSF:
tsp = (struct termios *) (ibuf + 1 + sizeof(struct iocblk));
vstop = tsp->c_cc[VSTOP];
vstart = tsp->c_cc[VSTART];
ixon = tsp->c_iflag & IXON;
break;
case TCSETA:
case TCSETAW:
case TCSETAF:
tp = (struct termio *) (ibuf + 1 + sizeof(struct iocblk));
vstop = tp->c_cc[VSTOP];
vstart = tp->c_cc[VSTART];
ixon = tp->c_iflag & IXON;
break;
default:
errno = EAGAIN;
return -1;
}
newflow = (ixon && (vstart == 021) && (vstop == 023)) ? 1 : 0;
if (newflow != flowstate) /* it's a change */
{
flowstate = newflow;
ibuf[0] = newflow ? TIOCPKT_DOSTOP : TIOCPKT_NOSTOP;
return 1;
}
}
/* nothing worth doing anything about */
errno = EAGAIN;
return -1;
#endif /* HAVE_STREAMSPTY */
}
/* ************************************************************************* */
/* Net and PTY I/O functions */
void
io_setup ()
{
pfrontp = pbackp = ptyobuf;
nfrontp = nbackp = netobuf;
#ifdef ENCRYPTION
nclearto = 0;
#endif
netip = netibuf;
ptyip = ptyibuf;
}
void
set_neturg ()
{
neturg = nfrontp - 1;
}
/* net-buffers */
void
net_output_byte (int c)
{
*nfrontp++ = c;
}
int
net_output_data (const char *format,...)
{
va_list args;
size_t remaining, ret;
va_start (args, format);
remaining = BUFSIZ - (nfrontp - netobuf);
/* try a netflush() if the room is too low */
if (strlen (format) > remaining || BUFSIZ / 4 > remaining)
{
netflush ();
remaining = BUFSIZ - (nfrontp - netobuf);
}
ret = vsnprintf (nfrontp, remaining, format, args);
nfrontp += ((ret < remaining - 1) ? ret : remaining - 1);
va_end (args);
return ret;
}
int
net_output_datalen (const void *buf, size_t l)
{
size_t remaining;
remaining = BUFSIZ - (nfrontp - netobuf);
if (remaining < l)
{
netflush ();
remaining = BUFSIZ - (nfrontp - netobuf);
}
if (remaining < l)
return -1;
memmove (nfrontp, buf, l);
nfrontp += l;
return (int) l;
}
int
net_input_level ()
{
return ncc;
}
int
net_output_level ()
{
return nfrontp - nbackp;
}
int
net_buffer_is_full ()
{
return (&netobuf[BUFSIZ] - nfrontp) < 2;
}
int
net_get_char (int peek)
{
if (peek)
return *netip;
else if (ncc > 0)
{
ncc--;
return *netip++ & 0377;
}
}
int
net_read ()
{
ncc = read (net, netibuf, sizeof (netibuf));
if (ncc < 0 && errno == EWOULDBLOCK)
ncc = 0;
else if (ncc == 0)
{
syslog (LOG_INFO, "telnetd: peer died");
cleanup(0);
}
else if (ncc > 0)
{
netip = netibuf;
DEBUG(debug_report,1,
debug_output_data ("td: netread %d chars\r\n", ncc));
DEBUG(debug_net_data,1,
printdata("nd", netip, ncc));
}
return ncc;
}
/* PTY buffer functions */
int
pty_buffer_is_full ()
{
return (&ptyobuf[BUFSIZ] - pfrontp) < 2;
}
void
pty_output_byte (int c)
{
*pfrontp++ = c;
}
void
pty_output_datalen (const void *data, size_t len)
{
if ((&ptyobuf[BUFSIZ] - pfrontp) > len)
ptyflush ();
memcpy (pfrontp, data, len);
pfrontp += len;
}
int
pty_input_level ()
{
return pcc;
}
int
pty_output_level ()
{
return pfrontp - pbackp;
}
void
ptyflush()
{
int n;
if ((n = pfrontp - pbackp) > 0)
{
DEBUG(debug_report, 1,
debug_output_data ("td: ptyflush %d chars\r\n", n));
DEBUG(debug_pty_data, 1,
printdata("pd", pbackp, n));
n = write(pty, pbackp, n);
}
if (n < 0)
{
if (errno == EWOULDBLOCK || errno == EINTR)
return;
cleanup(0);
}
pbackp += n;
if (pbackp == pfrontp)
pbackp = pfrontp = ptyobuf;
}
int
pty_get_char (int peek)
{
if (peek)
return *ptyip;
else if (pcc > 0)
{
pcc--;
return *ptyip++ & 0377;
}
}
int
pty_input_putback (const char *str, size_t len)
{
if (len > &ptyibuf[BUFSIZ] - ptyip)
len = &ptyibuf[BUFSIZ] - ptyip;
strncpy (ptyip, str, len);
pcc += len;
}
int
pty_read ()
{
pcc = readstream (pty, ptyibuf, BUFSIZ);
if (pcc < 0
&& (errno == EWOULDBLOCK
#ifdef EAGAIN
|| errno == EAGAIN
#endif
|| errno == EIO))
pcc = 0;
ptyip = ptyibuf;
DEBUG(debug_report,1,
debug_output_data ("ptyread %d chars\r\n", pcc));
DEBUG(debug_pty_data,1,
printdata("pty", ptyip, pcc));
return pcc;
}
/* ************************************************************************* */
/* io_drain ()
*
*
* A small subroutine to flush the network output buffer, get some data
* from the network, and pass it through the telnet state machine. We
* also flush the pty input buffer (by dropping its data) if it becomes
* too full.
*/
void
io_drain ()
{
DEBUG(debug_report, 1, debug_output_data("td: ttloop\r\n"));
if (nfrontp - nbackp > 0)
netflush ();
again:
ncc = read (net, netibuf, sizeof netibuf);
if (ncc < 0)
{
if (errno == EAGAIN)
{
syslog (LOG_INFO, "ttloop: retrying");
goto again;
}
syslog (LOG_INFO, "ttloop: read: %m\n");
exit (1);
}
else if (ncc == 0)
{
syslog (LOG_INFO, "ttloop: peer died: %m\n");
exit (1);
}
DEBUG(debug_report, 1,
debug_output_data ("td: ttloop read %d chars\r\n", ncc));
netip = netibuf;
telrcv (); /* state machine */
if (ncc > 0)
{
pfrontp = pbackp = ptyobuf;
telrcv ();
}
} /* end of ttloop */
/*
* Check a descriptor to see if out of band data exists on it.
*/
/* int s; socket number */
int
stilloob (int s)
{
static struct timeval timeout = { 0 };
fd_set excepts;
int value;
do
{
FD_ZERO (&excepts);
FD_SET (s, &excepts);
value = select (s+1, (fd_set *)0, (fd_set *)0, &excepts, &timeout);
}
while (value == -1 && errno == EINTR);
if (value < 0)
fatalperror (pty, "select");
return FD_ISSET (s, &excepts);
}
/*
* nextitem()
*
* Return the address of the next "item" in the TELNET data
* stream. This will be the address of the next character if
* the current address is a user data character, or it will
* be the address of the character following the TELNET command
* if the current address is a TELNET IAC ("I Am a Command")
* character.
*/
char *
nextitem (char *current)
{
if ((*current&0xff) != IAC)
return current+1;
switch (*(current+1)&0xff)
{
case DO:
case DONT:
case WILL:
case WONT:
return current+3;
case SB: /* loop forever looking for the SE */
{
register char *look = current+2;
for (;;)
if ((*look++&0xff) == IAC
&& (*look++&0xff) == SE)
return look;
default:
return current+2;
}
}
} /* end of nextitem */
/*
* netclear()
*
* We are about to do a TELNET SYNCH operation. Clear
* the path to the network.
*
* Things are a bit tricky since we may have sent the first
* byte or so of a previous TELNET command into the network.
* So, we have to scan the network buffer from the beginning
* until we are up to where we want to be.
*
* A side effect of what we do, just to keep things
* simple, is to clear the urgent data pointer. The principal
* caller should be setting the urgent data pointer AFTER calling
* us in any case.
*/
#define wewant(p) \
((nfrontp > p) && ((*p&0xff) == IAC) && \
((*(p+1)&0xff) != EC) && ((*(p+1)&0xff) != EL))
void
netclear ()
{
register char *thisitem, *next;
char *good;
#ifdef ENCRYPTION
thisitem = nclearto > netobuf ? nclearto : netobuf;
#else /* ENCRYPTION */
thisitem = netobuf;
#endif /* ENCRYPTION */
while ((next = nextitem (thisitem)) <= nbackp)
thisitem = next;
/* Now, thisitem is first before/at boundary. */
#ifdef ENCRYPTION
good = nclearto > netobuf ? nclearto : netobuf;
#else /* ENCRYPTION */
good = netobuf; /* where the good bytes go */
#endif /* ENCRYPTION */
while (nfrontp > thisitem)
{
if (wewant (thisitem))
{
int length;
for (next = thisitem; wewant (next) && nfrontp > next;
next = nextitem(next))
;
length = next - thisitem;
memmove (good, thisitem, length);
good += length;
thisitem = next;
}
else
{
thisitem = nextitem (thisitem);
}
}
nbackp = netobuf;
nfrontp = good; /* next byte to be sent */
neturg = 0;
} /* end of netclear */
/*
* netflush
* Send as much data as possible to the network,
* handling requests for urgent data.
*/
void
netflush ()
{
int n;
if ((n = nfrontp - nbackp) > 0)
{
NET_ENCRYPT ();
/*
* if no urgent data, or if the other side appears to be an
* old 4.2 client (and thus unable to survive TCP urgent data),
* write the entire buffer in non-OOB mode.
*/
if (!neturg || !not42)
n = write (net, nbackp, n); /* normal write */
else
{
n = neturg - nbackp;
/*
* In 4.2 (and 4.3) systems, there is some question about
* what byte in a sendOOB operation is the "OOB" data.
* To make ourselves compatible, we only send ONE byte
* out of band, the one WE THINK should be OOB (though
* we really have more the TCP philosophy of urgent data
* rather than the Unix philosophy of OOB data).
*/
if (n > 1)
n = send (net, nbackp, n-1, 0); /* send URGENT all by itself */
else
n = send (net, nbackp, n, MSG_OOB); /* URGENT data */
}
}
if (n < 0)
{
if (errno == EWOULDBLOCK || errno == EINTR)
return;
cleanup (0);
}
nbackp += n;
#ifdef ENCRYPTION
if (nbackp > nclearto)
nclearto = 0;
#endif /* ENCRYPTION */
if (nbackp >= neturg)
neturg = 0;
if (nbackp == nfrontp)
{
nbackp = nfrontp = netobuf;
#ifdef ENCRYPTION
nclearto = 0;
#endif /* ENCRYPTION */
}
DEBUG(debug_report, 1,
debug_output_data ("td: netflush %d chars\r\n", n));
} /* end of netflush */
/*
* miscellaneous functions doing a variety of little jobs follow ...
*/
void
fatal (int f, char *msg)
{
char buf[BUFSIZ];
snprintf (buf, sizeof buf, "telnetd: %s.\r\n", msg);
#ifdef ENCRYPTION
if (encrypt_output)
{
/*
* Better turn off encryption first....
* Hope it flushes...
*/
encrypt_send_end ();
netflush ();
}
#endif /* ENCRYPTION */
write (f, buf, (int)strlen (buf));
sleep (1); /*FIXME*/
exit (1);
}
void
fatalperror (int f, char *msg)
{
char buf[BUFSIZ];
snprintf (buf, sizeof buf, "%s: %s", msg, strerror (errno));
fatal (f, buf);
}
/* ************************************************************************* */
/* Terminal determination */
static unsigned char ttytype_sbbuf[] =
{
IAC, SB, TELOPT_TTYPE, TELQUAL_SEND, IAC, SE
};
static void
_gettermname ()
{
if (his_state_is_wont (TELOPT_TTYPE))
return;
settimer (baseline);
net_output_datalen (ttytype_sbbuf, sizeof ttytype_sbbuf);
ttloop (sequenceIs (ttypesubopt, baseline));
}
/* FIXME: should be getterminaltype (char *user_name, size_t size)
Changes terminaltype.
*/
int
getterminaltype (char *user_name)
{
int retval = -1;
settimer (baseline);
#if defined(AUTHENTICATION)
/*
* Handle the Authentication option before we do anything else.
*/
send_do (TELOPT_AUTHENTICATION, 1);
ttloop (his_will_wont_is_changing (TELOPT_AUTHENTICATION));
if (his_state_is_will (TELOPT_AUTHENTICATION))
retval = auth_wait (user_name);
#endif
#ifdef ENCRYPTION
send_will (TELOPT_ENCRYPT, 1);
#endif /* ENCRYPTION */
send_do (TELOPT_TTYPE, 1);
send_do (TELOPT_TSPEED, 1);
send_do (TELOPT_XDISPLOC, 1);
send_do (TELOPT_NEW_ENVIRON, 1);
send_do (TELOPT_OLD_ENVIRON, 1);
#ifdef ENCRYPTION
ttloop (his_do_dont_is_changing (TELOPT_ENCRYPT)
|| his_will_wont_is_changing (TELOPT_TTYPE)
|| his_will_wont_is_changing (TELOPT_TSPEED)
|| his_will_wont_is_changing (TELOPT_XDISPLOC)
|| his_will_wont_is_changing (TELOPT_NEW_ENVIRON)
|| his_will_wont_is_changing (TELOPT_OLD_ENVIRON));
#else
ttloop (his_will_wont_is_changing (TELOPT_TTYPE)
|| his_will_wont_is_changing (TELOPT_TSPEED)
|| his_will_wont_is_changing (TELOPT_XDISPLOC)
|| his_will_wont_is_changing (TELOPT_NEW_ENVIRON)
|| his_will_wont_is_changing (TELOPT_OLD_ENVIRON));
#endif
#ifdef ENCRYPTION
if (his_state_is_will (TELOPT_ENCRYPT))
encrypt_wait ();
#endif
if (his_state_is_will (TELOPT_TSPEED))
{
static unsigned char sb[] =
{IAC, SB, TELOPT_TSPEED, TELQUAL_SEND, IAC, SE};
net_output_datalen (sb, sizeof sb);
}
if (his_state_is_will (TELOPT_XDISPLOC))
{
static unsigned char sb[] =
{IAC, SB, TELOPT_XDISPLOC, TELQUAL_SEND, IAC, SE};
net_output_datalen (sb, sizeof sb);
}
if (his_state_is_will (TELOPT_NEW_ENVIRON))
{
static unsigned char sb[] =
{IAC, SB, TELOPT_NEW_ENVIRON, TELQUAL_SEND, IAC, SE};
net_output_datalen (sb, sizeof sb);
}
else if (his_state_is_will (TELOPT_OLD_ENVIRON))
{
static unsigned char sb[] =
{IAC, SB, TELOPT_OLD_ENVIRON, TELQUAL_SEND, IAC, SE};
net_output_datalen (sb, sizeof sb);
}
if (his_state_is_will (TELOPT_TTYPE))
net_output_datalen (ttytype_sbbuf, sizeof ttytype_sbbuf);
if (his_state_is_will (TELOPT_TSPEED))
ttloop (sequenceIs (tspeedsubopt, baseline));
if (his_state_is_will (TELOPT_XDISPLOC))
ttloop (sequenceIs (xdisplocsubopt, baseline));
if (his_state_is_will (TELOPT_NEW_ENVIRON))
ttloop (sequenceIs (environsubopt, baseline));
if (his_state_is_will (TELOPT_OLD_ENVIRON))
ttloop (sequenceIs (oenvironsubopt, baseline));
if (his_state_is_will (TELOPT_TTYPE))
{
char *first = NULL, *last = NULL;
ttloop (sequenceIs (ttypesubopt, baseline));
/*
* If the other side has already disabled the option, then
* we have to just go with what we (might) have already gotten.
*/
if (his_state_is_will (TELOPT_TTYPE) && !terminaltypeok (terminaltype))
{
if (first)
free (first);
first = xstrdup (terminaltype);
for (;;)
{
/* Save the unknown name, and request the next name. */
if (last)
free (last);
last = xstrdup (terminaltype);
_gettermname ();
if (terminaltypeok (terminaltype))
break;
if ((strcmp (last, terminaltype) == 0)
|| his_state_is_wont (TELOPT_TTYPE))
{
/*
* We've hit the end. If this is the same as
* the first name, just go with it.
*/
if (strcmp (first, terminaltype) == 0)
break;
/*
* Get the terminal name one more time, so that
* RFC1091 compliant telnets will cycle back to
* the start of the list.
*/
_gettermname ();
if (strcmp (first, terminaltype) != 0)
{
free (terminaltype);
terminaltype = xstrdup (first);
}
break;
}
}
}
if (first)
free (first);
if (last)
free (last);
}
return retval;
}
int
terminaltypeok (char *s)
{
char buf[1024];
if (terminaltype == NULL)
return 1;
if (tgetent (buf, s) == 0)
return 0;
return 1;
}
/* ************************************************************************* */
/* Debugging support */
static FILE *debug_fp = NULL;
static int
debug_open ()
{
int um = umask(077);
if (!debug_fp)
debug_fp = fopen ("/tmp/telnet.debug", "a");
umask(um);
return debug_fp == NULL;
}
static int
debug_close ()
{
if (debug_fp)
fclose (debug_fp);
debug_fp = NULL;
}
void
debug_output_datalen (const char *data, size_t len)
{
if (debug_open ())
return;
fwrite (data, 1, len, debug_fp);
debug_close ();
}
void
debug_output_data (const char *fmt, ...)
{
va_list ap;
if (debug_open ())
return;
va_start (ap, fmt);
vfprintf (debug_fp, fmt, ap);
va_end (ap);
debug_close ();
}
/*
* Print telnet options and commands in plain text, if possible.
*/
void
printoption(register char *fmt, register int option)
{
if (TELOPT_OK(option))
debug_output_data ("%s %s\r\n", fmt, TELOPT(option));
else if (TELCMD_OK(option))
debug_output_data ("%s %s\r\n", fmt, TELCMD(option));
else
debug_output_data ("%s %d\r\n", fmt, option);
}
/* char direction; '<' or '>' */
/* unsigned char *pointer; where suboption data sits */
/* int length; length of suboption data */
void
printsub(int direction, unsigned char *pointer, int length)
{
register int i;
char buf[512];
if (direction)
{
debug_output_data ("td: %s suboption ",
direction == '<' ? "recv" : "send");
if (length >= 3)
{
register int j;
i = pointer[length-2];
j = pointer[length-1];
if (i != IAC || j != SE)
{
debug_output_data ("(terminated by ");
if (TELOPT_OK(i))
debug_output_data ("%s ", TELOPT(i));
else if (TELCMD_OK(i))
debug_output_data ("%s ", TELCMD(i));
else
debug_output_data ("%d ", i);
if (TELOPT_OK(j))
debug_output_data ("%s", TELOPT(j));
else if (TELCMD_OK(j))
debug_output_data ("%s", TELCMD(j));
else
debug_output_data ("%d", j);
debug_output_data (", not IAC SE!) ");
}
}
length -= 2;
}
if (length < 1)
{
debug_output_data ("(Empty suboption??\?)");
return;
}
switch (pointer[0])
{
case TELOPT_TTYPE:
debug_output_data ("TERMINAL-TYPE ");
switch (pointer[1])
{
case TELQUAL_IS:
debug_output_data ("IS \"%.*s\"", length-2, (char *)pointer+2);
break;
case TELQUAL_SEND:
debug_output_data ("SEND");
break;
default:
debug_output_data ("- unknown qualifier %d (0x%x).",
pointer[1], pointer[1]);
}
break;
case TELOPT_TSPEED:
debug_output_data ("TERMINAL-SPEED");
if (length < 2)
{
debug_output_data (" (empty suboption??\?)");
break;
}
switch (pointer[1])
{
case TELQUAL_IS:
debug_output_data (" IS %.*s", length-2, (char *)pointer+2);
break;
default:
if (pointer[1] == 1)
debug_output_data (" SEND");
else
debug_output_data (" %d (unknown)", pointer[1]);
for (i = 2; i < length; i++) {
debug_output_data (" ?%d?", pointer[i]);
}
break;
}
break;
case TELOPT_LFLOW:
debug_output_data ("TOGGLE-FLOW-CONTROL");
if (length < 2)
{
debug_output_data (" (empty suboption??\?)");
break;
}
switch (pointer[1])
{
case LFLOW_OFF:
debug_output_data (" OFF");
break;
case LFLOW_ON:
debug_output_data (" ON");
break;
case LFLOW_RESTART_ANY:
debug_output_data (" RESTART-ANY");
break;
case LFLOW_RESTART_XON:
debug_output_data (" RESTART-XON");
break;
default:
debug_output_data (" %d (unknown)", pointer[1]);
}
for (i = 2; i < length; i++)
debug_output_data (" ?%d?", pointer[i]);
break;
case TELOPT_NAWS:
debug_output_data ("NAWS");
if (length < 2)
{
debug_output_data (" (empty suboption??\?)");
break;
}
if (length == 2)
{
debug_output_data (" ?%d?", pointer[1]);
break;
}
debug_output_data (" %d %d (%d)",
pointer[1], pointer[2],
(int)((((unsigned int)pointer[1])<<8)|((unsigned int)pointer[2])));
if (length == 4)
{
debug_output_data (" ?%d?", pointer[3]);
break;
}
debug_output_data (" %d %d (%d)",
pointer[3], pointer[4],
(int)((((unsigned int)pointer[3])<<8)|((unsigned int)pointer[4])));
for (i = 5; i < length; i++)
debug_output_data (" ?%d?", pointer[i]);
break;
case TELOPT_LINEMODE:
debug_output_data ("LINEMODE ");
if (length < 2)
{
debug_output_data (" (empty suboption??\?)");
break;
}
switch (pointer[1])
{
case WILL:
debug_output_data ("WILL ");
goto common;
case WONT:
debug_output_data ("WONT ");
goto common;
case DO:
debug_output_data ("DO ");
goto common;
case DONT:
debug_output_data ("DONT ");
common:
if (length < 3)
{
debug_output_data ("(no option??\?)");
break;
}
switch (pointer[2])
{
case LM_FORWARDMASK:
debug_output_data ("Forward Mask");
for (i = 3; i < length; i++)
debug_output_data (" %x", pointer[i]);
break;
default:
debug_output_data ("%d (unknown)", pointer[2]);
for (i = 3; i < length; i++)
debug_output_data (" %d", pointer[i]);
break;
}
break;
case LM_SLC:
debug_output_data ("SLC");
for (i = 2; i < length - 2; i += 3)
{
if (SLC_NAME_OK(pointer[i+SLC_FUNC]))
debug_output_data (" %s", SLC_NAME(pointer[i+SLC_FUNC]));
else
debug_output_data (" %d", pointer[i+SLC_FUNC]);
switch (pointer[i+SLC_FLAGS]&SLC_LEVELBITS)
{
case SLC_NOSUPPORT:
debug_output_data (" NOSUPPORT");
break;
case SLC_CANTCHANGE:
debug_output_data (" CANTCHANGE");
break;
case SLC_VARIABLE:
debug_output_data (" VARIABLE");
break;
case SLC_DEFAULT:
debug_output_data (" DEFAULT");
break;
}
debug_output_data ("%s%s%s",
pointer[i+SLC_FLAGS]&SLC_ACK ? "|ACK" : "",
pointer[i+SLC_FLAGS]&SLC_FLUSHIN ? "|FLUSHIN" : "",
pointer[i+SLC_FLAGS]&SLC_FLUSHOUT ? "|FLUSHOUT" : "");
if (pointer[i+SLC_FLAGS]& ~(SLC_ACK|SLC_FLUSHIN|
SLC_FLUSHOUT| SLC_LEVELBITS))
debug_output_data ("(0x%x)", pointer[i+SLC_FLAGS]);
debug_output_data (" %d;", pointer[i+SLC_VALUE]);
if ((pointer[i+SLC_VALUE] == IAC) &&
(pointer[i+SLC_VALUE+1] == IAC))
i++;
}
for (; i < length; i++)
debug_output_data (" ?%d?", pointer[i]);
break;
case LM_MODE:
debug_output_data ("MODE ");
if (length < 3)
{
debug_output_data ("(no mode??\?)");
break;
}
{
char tbuf[32];
snprintf(tbuf, sizeof(tbuf), "%s%s%s%s%s",
pointer[2]&MODE_EDIT ? "|EDIT" : "",
pointer[2]&MODE_TRAPSIG ? "|TRAPSIG" : "",
pointer[2]&MODE_SOFT_TAB ? "|SOFT_TAB" : "",
pointer[2]&MODE_LIT_ECHO ? "|LIT_ECHO" : "",
pointer[2]&MODE_ACK ? "|ACK" : "");
debug_output_data ("%s", tbuf[1] ? &tbuf[1] : "0");
}
if (pointer[2]&~(MODE_EDIT|MODE_TRAPSIG|MODE_ACK))
debug_output_data (" (0x%x)", pointer[2]);
for (i = 3; i < length; i++)
debug_output_data (" ?0x%x?", pointer[i]);
break;
default:
debug_output_data ("%d (unknown)", pointer[1]);
for (i = 2; i < length; i++)
debug_output_data (" %d", pointer[i]);
}
break;
case TELOPT_STATUS:
{
register char *cp;
register int j, k;
debug_output_data ("STATUS");
switch (pointer[1]) {
default:
if (pointer[1] == TELQUAL_SEND)
debug_output_data (" SEND");
else
debug_output_data (" %d (unknown)", pointer[1]);
for (i = 2; i < length; i++)
debug_output_data (" ?%d?", pointer[i]);
break;
case TELQUAL_IS:
debug_output_data (" IS\r\n");
for (i = 2; i < length; i++)
{
switch(pointer[i])
{
case DO:
cp = "DO";
goto common2;
case DONT:
cp = "DONT";
goto common2;
case WILL:
cp = "WILL";
goto common2;
case WONT:
cp = "WONT";
goto common2;
common2:
i++;
if (TELOPT_OK(pointer[i]))
debug_output_data (" %s %s\r\n", cp, TELOPT(pointer[i]));
else
debug_output_data (" %s %d\r\n", cp, pointer[i]);
break;
case SB:
debug_output_data (" SB ");
i++;
j = k = i;
while (j < length)
{
if (pointer[j] == SE)
{
if (j+1 == length)
break;
if (pointer[j+1] == SE)
j++;
else
break;
}
pointer[k++] = pointer[j++];
}
printsub(0, &pointer[i], k - i);
if (i < length)
{
debug_output_data (" SE");
i = j;
} else
i = j - 1;
debug_output_data ("\r\n");
break;
default:
debug_output_data (" %d", pointer[i]);
break;
}
}
break;
}
break;
}
case TELOPT_XDISPLOC:
debug_output_data ("X-DISPLAY-LOCATION ");
switch (pointer[1])
{
case TELQUAL_IS:
debug_output_data ("IS \"%.*s\"", length-2, (char *)pointer+2);
break;
case TELQUAL_SEND:
debug_output_data ("SEND");
break;
default:
debug_output_data ("- unknown qualifier %d (0x%x).",
pointer[1], pointer[1]);
}
break;
case TELOPT_NEW_ENVIRON:
debug_output_data ("NEW-ENVIRON ");
goto env_common1;
case TELOPT_OLD_ENVIRON:
debug_output_data ("OLD-ENVIRON");
env_common1:
switch (pointer[1])
{
case TELQUAL_IS:
debug_output_data ("IS ");
goto env_common;
case TELQUAL_SEND:
debug_output_data ("SEND ");
goto env_common;
case TELQUAL_INFO:
debug_output_data ("INFO ");
env_common:
{
register int noquote = 2;
for (i = 2; i < length; i++ )
{
switch (pointer[i])
{
case NEW_ENV_VAR:
debug_output_data ("\" VAR " + noquote);
noquote = 2;
break;
case NEW_ENV_VALUE:
debug_output_data ("\" VALUE " + noquote);
noquote = 2;
break;
case ENV_ESC:
debug_output_data ("\" ESC " + noquote);
noquote = 2;
break;
case ENV_USERVAR:
debug_output_data ("\" USERVAR " + noquote);
noquote = 2;
break;
default:
def_case:
if (isprint(pointer[i]) && pointer[i] != '"')
{
if (noquote)
{
debug_output_data ("\"");
noquote = 0;
}
debug_output_datalen (&pointer[i], 1);
}
else
{
debug_output_data ("\" %03o " + noquote,
pointer[i]);
noquote = 2;
}
break;
}
}
if (!noquote)
debug_output_data ("\"");
break;
}
}
break;
#if defined(AUTHENTICATION)
case TELOPT_AUTHENTICATION:
debug_output_data ("AUTHENTICATION");
if (length < 2)
{
debug_output_data (" (empty suboption??\?)");
break;
}
switch (pointer[1])
{
case TELQUAL_REPLY:
case TELQUAL_IS:
debug_output_data (" %s ", (pointer[1] == TELQUAL_IS) ?
"IS" : "REPLY");
if (AUTHTYPE_NAME_OK(pointer[2]))
debug_output_data ("%s ", AUTHTYPE_NAME(pointer[2]));
else
debug_output_data ("%d ", pointer[2]);
if (length < 3)
{
debug_output_data ("(partial suboption??\?)");
break;
}
debug_output_data ("%s|%s",
((pointer[3] & AUTH_WHO_MASK) == AUTH_WHO_CLIENT) ?
"CLIENT" : "SERVER",
((pointer[3] & AUTH_HOW_MASK) == AUTH_HOW_MUTUAL) ?
"MUTUAL" : "ONE-WAY");
auth_printsub(&pointer[1], length - 1, buf, sizeof(buf));
debug_output_data ("%s", buf);
break;
case TELQUAL_SEND:
i = 2;
debug_output_data (" SEND ");
while (i < length)
{
if (AUTHTYPE_NAME_OK(pointer[i]))
debug_output_data ("%s ", AUTHTYPE_NAME(pointer[i]));
else
debug_output_data ("%d ", pointer[i]);
if (++i >= length)
{
debug_output_data ("(partial suboption??\?)");
break;
}
debug_output_data ("%s|%s ",
((pointer[i] & AUTH_WHO_MASK) == AUTH_WHO_CLIENT) ?
"CLIENT" : "SERVER",
((pointer[i] & AUTH_HOW_MASK) == AUTH_HOW_MUTUAL) ?
"MUTUAL" : "ONE-WAY");
++i;
}
break;
case TELQUAL_NAME:
i = 2;
debug_output_data (" NAME \"");
debug_output_datalen (&pointer[i], length);
i += length;
debug_output_data ("\"");
break;
default:
for (i = 2; i < length; i++)
debug_output_data (" ?%d?", pointer[i]);
break;
}
break;
#endif
#ifdef ENCRYPTION
case TELOPT_ENCRYPT:
debug_output_data ("ENCRYPT");
if (length < 2)
{
debug_output_data (" (empty suboption??\?)");
break;
}
switch (pointer[1])
{
case ENCRYPT_START:
debug_output_data (" START");
break;
case ENCRYPT_END:
debug_output_data (" END");
break;
case ENCRYPT_REQSTART:
debug_output_data (" REQUEST-START");
break;
case ENCRYPT_REQEND:
debug_output_data (" REQUEST-END");
break;
case ENCRYPT_IS:
case ENCRYPT_REPLY:
debug_output_data (" %s ", (pointer[1] == ENCRYPT_IS) ?
"IS" : "REPLY");
if (length < 3)
{
debug_output_data (" (partial suboption??\?)");
break;
}
if (ENCTYPE_NAME_OK(pointer[2]))
debug_output_data ("%s ", ENCTYPE_NAME(pointer[2]));
else
debug_output_data (" %d (unknown)", pointer[2]);
encrypt_printsub(&pointer[1], length - 1, buf, sizeof(buf));
debug_output_data ("%s", buf);
break;
case ENCRYPT_SUPPORT:
i = 2;
debug_output_data (" SUPPORT ");
while (i < length)
{
if (ENCTYPE_NAME_OK(pointer[i]))
debug_output_data ("%s ", ENCTYPE_NAME(pointer[i]));
else
debug_output_data ("%d ", pointer[i]);
i++;
}
break;
case ENCRYPT_ENC_KEYID:
debug_output_data (" ENC_KEYID", pointer[1]);
goto encommon;
case ENCRYPT_DEC_KEYID:
debug_output_data (" DEC_KEYID", pointer[1]);
goto encommon;
default:
debug_output_data (" %d (unknown)", pointer[1]);
encommon:
for (i = 2; i < length; i++)
debug_output_data (" %d", pointer[i]);
break;
}
break;
#endif /* ENCRYPTION */
default:
if (TELOPT_OK(pointer[0]))
debug_output_data ("%s (unknown)", TELOPT(pointer[0]));
else
debug_output_data ("%d (unknown)", pointer[i]);
for (i = 1; i < length; i++)
debug_output_data (" %d", pointer[i]);
break;
}
debug_output_data ("\r\n");
}
/*
* Dump a data buffer in hex and ascii to the output data stream.
*/
void
printdata(register char *tag, register char *ptr, register int cnt)
{
register int i;
char xbuf[30];
while (cnt)
{
/* add a line of output */
debug_output_data ("%s: ", tag);
for (i = 0; i < 20 && cnt; i++)
{
debug_output_data ("%02x", *ptr);
xbuf[i] = isprint(*ptr) ? *ptr : '.';
if (i % 2)
debug_output_data (" ");
cnt--;
ptr++;
}
xbuf[i] = '\0';
debug_output_data (" %s\r\n", xbuf );
}
}
#if defined(AUTHENTICATION) || defined(ENCRYPTION)
int
net_write (unsigned char *str, int len)
{
return net_output_datalen (str, len);
}
void
net_encrypt ()
{
#ifdef ENCRYPTION
char *s = (nclearto > nbackp) ? nclearto : nbackp;
if (s < nfrontp && encrypt_output)
(*encrypt_output)((unsigned char *)s, nfrontp - s);
nclearto = nfrontp;
#endif /* ENCRYPTION */
}
int
telnet_spin()
{
io_drain ();
return 0;
}
#endif
/* ************************************************************************* */
/* String expansion functions */
#define EXP_STATE_CONTINUE 0
#define EXP_STATE_SUCCESS 1
#define EXP_STATE_ERROR 2
struct line_expander
{
int state; /* Current state */
int level; /* The nesting level */
char *source; /* The source string */
char *cp; /* Current position in the source */
struct obstack stk; /* Obstack for expanded version */
};
static char *_var_short_name P((struct line_expander *exp));
static char *_var_long_name P((struct line_expander *exp,
char *start, int length));
static char *_expand_var P((struct line_expander *exp));
static void _expand_cond P((struct line_expander *exp));
static void _skip_block P((struct line_expander *exp));
static void _expand_block P((struct line_expander *exp));
/* Expand a variable referenced by its short one-symbol name.
Input: exp->cp points to the variable name.
FIXME: not implemented */
char *
_var_short_name (struct line_expander *exp)
{
char *q;
char timebuf[64];
time_t t;
switch (*exp->cp++)
{
case 'a':
#ifdef AUTHENTICATION
if (auth_level >= 0 && autologin == AUTH_VALID)
return xstrdup ("ok");
#endif
return NULL;
case 'd':
time (&t);
strftime(timebuf, sizeof (timebuf),
"%l:%M%P on %A, %d %B %Y", localtime(&t));
return xstrdup (timebuf);
case 'h':
return xstrdup (remote_hostname);
case 'l':
return xstrdup (local_hostname);
case 't':
q = strchr (line + 1, '/');
if (q)
q++;
else
q = line;
return xstrdup (q);
case 'T':
return terminaltype ? xstrdup (terminaltype) : NULL;
case 'u':
return user_name ? xstrdup (user_name) : NULL;
default:
exp->state = EXP_STATE_ERROR;
return NULL;
}
}
/* Expand a variable referenced by its long name.
Input: exp->cp points to initial '('
FIXME: not implemented */
char *
_var_long_name (struct line_expander *exp, char *start, int length)
{
exp->state = EXP_STATE_ERROR;
return NULL;
}
/* Expand a variable to its value.
Input: exp->cp points one character _past_ % (or ?) */
char *
_expand_var (struct line_expander *exp)
{
char *p;
switch (*exp->cp)
{
case '{':
/* Collect variable name */
for (p = ++exp->cp; *exp->cp && *exp->cp != '}'; exp->cp++)
;
if (*exp->cp == 0)
{
exp->cp = p;
exp->state = EXP_STATE_ERROR;
break;
}
p = _var_long_name (exp, p, exp->cp - p);
exp->cp++;
break;
default:
p = _var_short_name (exp);
break;
}
return p;
}
/* Expand a conditional block. A conditional block is:
%?<var>{true-stmt}[{false-stmt}]
<var> may be either a one-symbol variable name or (string). The latter
is not handled yet.
On input exp->cp points to % character */
void
_expand_cond (struct line_expander *exp)
{
char *p;
if (*++exp->cp == '?')
{
/* condition */
exp->cp++;
p = _expand_var (exp);
if (p)
{
_expand_block (exp);
_skip_block (exp);
}
else
{
_skip_block (exp);
_expand_block (exp);
}
free (p);
}
else
{
p = _expand_var (exp);
if (p)
obstack_grow (&exp->stk, p, strlen (p));
free (p);
}
}
/* Skip the block. If the exp->cp does not point to the beginning of a
block ({ character), the function does nothing */
void
_skip_block (struct line_expander *exp)
{
int level = exp->level;
if (*exp->cp != '{')
return;
for (; *exp->cp; exp->cp++)
{
switch (*exp->cp)
{
case '{':
exp->level++;
break;
case '}':
exp->level--;
if (exp->level == level)
{
exp->cp++;
return;
}
}
}
}
/* Expand a block within the formatted line. Stops either when end of source
line was reached or the nesting reaches the initial value */
void
_expand_block (struct line_expander *exp)
{
int level = exp->level;
if (*exp->cp == '{')
{
exp->level++;
exp->cp++;/*FIXME?*/
}
while (exp->state == EXP_STATE_CONTINUE)
{
for (; *exp->cp && *exp->cp != '%'; exp->cp++)
{
switch (*exp->cp)
{
case '{':
exp->level++;
break;
case '}':
exp->level--;
if (exp->level == level)
{
exp->cp++;
return;
}
break;
case '\\':
exp->cp++;
break;
}
obstack_1grow (&exp->stk, *exp->cp);
}
if (*exp->cp == 0)
{
obstack_1grow (&exp->stk, 0);
exp->state = EXP_STATE_SUCCESS;
break;
}
else if (*exp->cp == '%' && exp->cp[1] == '%')
{
obstack_1grow (&exp->stk, *exp->cp);
exp->cp += 2;
continue;
}
_expand_cond (exp);
}
}
/* Expand a format line */
char *
expand_line (const char *line)
{
char *p = NULL;
struct line_expander exp;
exp.state = EXP_STATE_CONTINUE;
exp.level = 0;
exp.source = line;
exp.cp = line;
obstack_init (&exp.stk);
_expand_block (&exp);
if (exp.state == EXP_STATE_SUCCESS)
p = xstrdup (obstack_finish (&exp.stk));
else
{
syslog (LOG_ERR, "can't expand line: %s", line);
syslog (LOG_ERR, "stopped near %s", exp.cp ? exp.cp : "(END)");
}
obstack_free (&exp.stk, NULL);
return p;
}