static int
getterminaltype (void)
{
int retval = -1;
settimer(baseline);
send_do(TELOPT_TTYPE, 1);
send_do(TELOPT_TSPEED, 1);
send_do(TELOPT_XDISPLOC, 1);
send_do(TELOPT_ENVIRON, 1);
while (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_ENVIRON)) {
ttloop();
}
if (his_state_is_will(TELOPT_TSPEED)) {
static unsigned char sb[] =
{ IAC, SB, TELOPT_TSPEED, TELQUAL_SEND, IAC, SE };
memmove((void *)nfrontp, (void *)sb, sizeof sb);
nfrontp += sizeof sb;
DIAG(TD_OPTIONS, printsub('>', sb + 2, sizeof sb - 2););
}
int
getterminaltype(char *name, size_t name_sz)
{
int retval = -1;
settimer(baseline);
#ifdef AUTHENTICATION
/*
* Handle the Authentication option before we do anything else.
*/
send_do(TELOPT_AUTHENTICATION, 1);
while (his_will_wont_is_changing(TELOPT_AUTHENTICATION))
ttloop();
if (his_state_is_will(TELOPT_AUTHENTICATION)) {
retval = auth_wait(name, name_sz);
}
#endif
#ifdef ENCRYPTION
send_will(TELOPT_ENCRYPT, 1);
send_do(TELOPT_ENCRYPT, 1); /* [email protected] */
#endif
/* DayDream wants binary transmission mode */
send_will(TELOPT_BINARY, 1);
send_do(TELOPT_BINARY, 1);
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);
while (
#ifdef ENCRYPTION
his_do_dont_is_changing(TELOPT_ENCRYPT) ||
#endif
his_do_dont_is_changing(TELOPT_BINARY) ||
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)) {
ttloop();
}
#ifdef ENCRYPTION
/*
* Wait for the negotiation of what type of encryption we can
* send with. If autoencrypt is not set, this will just return.
*/
if (his_state_is_will(TELOPT_ENCRYPT)) {
encrypt_wait();
}
#endif
if (his_state_is_will(TELOPT_BINARY)) {
static unsigned char sb[] =
{ IAC, SB, TELOPT_BINARY, TELQUAL_SEND, IAC, SE };
telnet_net_write (sb, sizeof sb);
DIAG(TD_OPTIONS, printsub('>', sb + 2, sizeof sb - 2););
}
static
int
getterminaltype(char *name)
{
int retval = -1;
(void)name;
settimer(baseline);
#if defined(AUTHENTICATE)
/*
* Handle the Authentication option before we do anything else.
*/
send_do(TELOPT_AUTHENTICATION, 1);
while (his_will_wont_is_changing(TELOPT_AUTHENTICATION))
ttloop();
if (his_state_is_will(TELOPT_AUTHENTICATION)) {
retval = auth_wait(name);
}
#endif
#if defined(ENCRYPT)
send_will(TELOPT_ENCRYPT, 1);
#endif
send_do(TELOPT_TTYPE, 1);
send_do(TELOPT_TSPEED, 1);
send_do(TELOPT_XDISPLOC, 1);
send_do(TELOPT_ENVIRON, 1);
while (
#if defined(ENCRYPT)
his_do_dont_is_changing(TELOPT_ENCRYPT) ||
#endif
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_ENVIRON)) {
ttloop();
}
#if defined(ENCRYPT)
/*
* Wait for the negotiation of what type of encryption we can
* send with. If autoencrypt is not set, this will just return.
*/
if (his_state_is_will(TELOPT_ENCRYPT)) {
encrypt_wait();
}
#endif
if (his_state_is_will(TELOPT_TSPEED)) {
static char sbbuf[] = { IAC, SB, TELOPT_TSPEED, TELQUAL_SEND, IAC, SE };
bcopy(sbbuf, nfrontp, sizeof sbbuf);
nfrontp += sizeof sbbuf;
}
if (his_state_is_will(TELOPT_XDISPLOC)) {
static char sbbuf[] = { IAC, SB, TELOPT_XDISPLOC, TELQUAL_SEND, IAC, SE };
bcopy(sbbuf, nfrontp, sizeof sbbuf);
nfrontp += sizeof sbbuf;
}
if (his_state_is_will(TELOPT_ENVIRON)) {
static char sbbuf[] = { IAC, SB, TELOPT_ENVIRON, TELQUAL_SEND, IAC, SE };
bcopy(sbbuf, nfrontp, sizeof sbbuf);
nfrontp += sizeof sbbuf;
}
if (his_state_is_will(TELOPT_TTYPE)) {
bcopy(ttytype_sbbuf, nfrontp, sizeof ttytype_sbbuf);
nfrontp += sizeof ttytype_sbbuf;
}
if (his_state_is_will(TELOPT_TSPEED)) {
while (sequenceIs(tspeedsubopt, baseline))
ttloop();
}
if (his_state_is_will(TELOPT_XDISPLOC)) {
while (sequenceIs(xdisplocsubopt, baseline))
ttloop();
}
if (his_state_is_will(TELOPT_ENVIRON)) {
while (sequenceIs(environsubopt, baseline))
ttloop();
}
if (his_state_is_will(TELOPT_TTYPE)) {
char first[256], last[256];
while (sequenceIs(ttypesubopt, baseline))
ttloop();
/*
* 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)) {
(void) strncpy(first, terminaltype, sizeof(first));
for(;;) {
/*
* Save the unknown name, and request the next name.
*/
(void) strncpy(last, terminaltype, sizeof(last));
_gettermname();
if (terminaltypeok(terminaltype))
break;
if ((strncmp(last, terminaltype, sizeof(last)) == 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 (strncmp(first, terminaltype, sizeof(first)) == 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 (strncmp(first, terminaltype, sizeof(first)) != 0)
(void) strncpy(terminaltype, first, sizeof(first));
break;
}
}
}
}
return(retval);
} /* end of getterminaltype */
/*
* Main loop. Select from pty and network, and
* hand data to telnet receiver finite state machine.
*/
void telnet(int f, int p)
{
int on = 1;
char *HE;
const char *IM;
/*
* Initialize the slc mapping table.
*/
get_slc_defaults();
/*
* Do some tests where it is desireable to wait for a response.
* Rather than doing them slowly, one at a time, do them all
* at once.
*/
if (my_state_is_wont(TELOPT_SGA))
send_will(TELOPT_SGA, 1);
/*
* Is the client side a 4.2 (NOT 4.3) system? We need to know this
* because 4.2 clients are unable to deal with TCP urgent data.
*
* To find out, we send out a "DO ECHO". If the remote system
* answers "WILL ECHO" it is probably a 4.2 client, and we note
* that fact ("WILL ECHO" ==> that the client will echo what
* WE, the server, sends it; it does NOT mean that the client will
* echo the terminal input).
*/
send_do(TELOPT_ECHO, 1);
#ifdef LINEMODE
if (his_state_is_wont(TELOPT_LINEMODE)) {
/*
* Query the peer for linemode support by trying to negotiate
* the linemode option.
*/
linemode = 0;
editmode = 0;
send_do(TELOPT_LINEMODE, 1); /* send do linemode */
}
#endif /* LINEMODE */
/*
* Send along a couple of other options that we wish to negotiate.
*/
send_do(TELOPT_NAWS, 1);
send_will(TELOPT_STATUS, 1);
flowmode = 1; /* default flow control state */
send_do(TELOPT_LFLOW, 1);
/*
* Spin, waiting for a response from the DO ECHO. However,
* some REALLY DUMB telnets out there might not respond
* to the DO ECHO. So, we spin looking for NAWS, (most dumb
* telnets so far seem to respond with WONT for a DO that
* they don't understand...) because by the time we get the
* response, it will already have processed the DO ECHO.
* Kludge upon kludge.
*/
while (his_will_wont_is_changing(TELOPT_NAWS)) {
ttloop();
}
/*
* But...
* The client might have sent a WILL NAWS as part of its
* startup code; if so, we'll be here before we get the
* response to the DO ECHO. We'll make the assumption
* that any implementation that understands about NAWS
* is a modern enough implementation that it will respond
* to our DO ECHO request; hence we'll do another spin
* waiting for the ECHO option to settle down, which is
* what we wanted to do in the first place...
*/
if (his_want_state_is_will(TELOPT_ECHO) &&
his_state_is_will(TELOPT_NAWS)) {
while (his_will_wont_is_changing(TELOPT_ECHO))
ttloop();
}
/*
* On the off chance that the telnet client is broken and does not
* respond to the DO ECHO we sent, (after all, we did send the
* DO NAWS negotiation after the DO ECHO, and we won't get here
* until a response to the DO NAWS comes back) simulate the
* receipt of a will echo. This will also send a WONT ECHO
* to the client, since we assume that the client failed to
* respond because it believes that it is already in DO ECHO
* mode, which we do not want.
*/
if (his_want_state_is_will(TELOPT_ECHO)) {
DIAG(TD_OPTIONS, netoprintf("td: simulating recv\r\n"););
willoption(TELOPT_ECHO);
}
static
int
getterminaltype(char *name)
{
int retval = -1;
(void)name;
settimer(baseline);
#if defined(AUTHENTICATE)
/*
* Handle the Authentication option before we do anything else.
*/
send_do(TELOPT_AUTHENTICATION, 1);
while (his_will_wont_is_changing(TELOPT_AUTHENTICATION))
ttloop();
if (his_state_is_will(TELOPT_AUTHENTICATION)) {
retval = auth_wait(name);
}
#endif
#if defined(ENCRYPT)
send_will(TELOPT_ENCRYPT, 1);
#endif
send_do(TELOPT_TTYPE, 1);
send_do(TELOPT_TSPEED, 1);
send_do(TELOPT_XDISPLOC, 1);
send_do(TELOPT_ENVIRON, 1);
while (
#if defined(ENCRYPT)
his_do_dont_is_changing(TELOPT_ENCRYPT) ||
#endif
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_ENVIRON)) {
ttloop();
}
#if defined(ENCRYPT)
/*
* Wait for the negotiation of what type of encryption we can
* send with. If autoencrypt is not set, this will just return.
*/
if (his_state_is_will(TELOPT_ENCRYPT)) {
encrypt_wait();
}
#endif
if (his_state_is_will(TELOPT_TSPEED)) {
netoprintf("%c%c%c%c%c%c",
IAC, SB, TELOPT_TSPEED, TELQUAL_SEND, IAC, SE);
}
if (his_state_is_will(TELOPT_XDISPLOC)) {
netoprintf("%c%c%c%c%c%c",
IAC, SB, TELOPT_XDISPLOC, TELQUAL_SEND, IAC, SE);
}
if (his_state_is_will(TELOPT_ENVIRON)) {
netoprintf("%c%c%c%c%c%c",
IAC, SB, TELOPT_ENVIRON, TELQUAL_SEND, IAC, SE);
}
if (his_state_is_will(TELOPT_TTYPE)) {
netoprintf("%c%c%c%c%c%c",
IAC, SB, TELOPT_TTYPE, TELQUAL_SEND, IAC, SE);
}
if (his_state_is_will(TELOPT_TSPEED)) {
while (sequenceIs(tspeedsubopt, baseline))
ttloop();
}
if (his_state_is_will(TELOPT_XDISPLOC)) {
while (sequenceIs(xdisplocsubopt, baseline))
ttloop();
}
if (his_state_is_will(TELOPT_ENVIRON)) {
while (sequenceIs(environsubopt, baseline))
ttloop();
}
if (his_state_is_will(TELOPT_TTYPE)) {
char first[256], last[256];
while (sequenceIs(ttypesubopt, baseline))
ttloop();
/*
* 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)) {
/*
* Due to state.c, terminaltype points to a static char[41].
* Therefore, this assert cannot fail, and therefore, strings
* arising from "terminaltype" can be safely strcpy'd into
* first[] or last[].
*/
assert(strlen(terminaltype) < sizeof(first));
strcpy(first, terminaltype);
for(;;) {
/*
* Save the unknown name, and request the next name.
*/
strcpy(last, terminaltype);
_gettermname();
assert(strlen(terminaltype) < sizeof(first));
if (terminaltypeok(terminaltype))
break;
if (!strcmp(last, terminaltype) ||
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))
break;
/*
* Get the terminal name one more time, so that
* RFC1091 compliant telnets will cycle back to
* the start of the list.
*/
_gettermname();
assert(strlen(terminaltype) < sizeof(first));
if (strcmp(first, terminaltype)) {
/*
* first[] came from terminaltype, so it must fit
* back in.
*/
strcpy(terminaltype, first);
}
break;
}
}
}
}
return(retval);
} /* end of getterminaltype */