moparisthebest/curl
1
0
Fork 0
mirror of https://github.com/moparisthebest/curl synced 2024-11-10 11:35:07 -05:00
Code Issues Releases Wiki Activity
215c75135b
curl/lib/telnet.c
Daniel Stenberg 1ef3600a07 haxx.nu => haxx.se
2000-06-20 15:31:26 +00:00

944 lines
18 KiB
C
Raw Blame History

/*****************************************************************************
* _ _ ____ _
* Project ___| | | | _ \| |
* / __| | | | |_) | |
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
* License for the specific language governing rights and limitations
* under the License.
*
* The Original Code is Curl.
*
* The Initial Developer of the Original Code is Daniel Stenberg.
*
* Portions created by the Initial Developer are Copyright (C) 1998.
* All Rights Reserved.
*
* ------------------------------------------------------------
* Main author:
* - Daniel Stenberg <daniel@haxx.se>
*
* http://curl.haxx.se
*
* $Source$
* $Revision$
* $Date$
* $Author$
* $State$
* $Locker$
*
* ------------------------------------------------------------
*
* This implementation of the TELNET protocol is written by
* Linus Nielsen <Linus.Nielsen@haxx.se>,
* with some code snippets stolen from the BSD Telnet client.
*
* The negotiation is performed according to RFC 1143 (D. Bernstein,
* "The Q Method of Implementing TELNET Option Negotiation")
*
****************************************************************************/
/* -- WIN32 approved -- */
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include "setup.h"
#if defined(WIN32) && !defined(__GNUC__) || defined(__MINGW32__)
#include <winsock.h>
#include <time.h>
#include <io.h>
#else
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#include <netinet/in.h>
#include <sys/time.h>
#include <sys/resource.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <netdb.h>
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
#ifdef HAVE_NET_IF_H
#include <net/if.h>
#endif
#include <sys/ioctl.h>
#include <signal.h>
#ifdef HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif
#endif
#include "urldata.h"
#include <curl/curl.h>
#include "download.h"
#include "sendf.h"
#include "formdata.h"
#include "progress.h"
#define _MPRINTF_REPLACE /* use our functions only */
#include <curl/mprintf.h>
#define TELOPTS
#define TELCMDS
#define SLC_NAMES
#include "arpa_telnet.h"
#define SUBBUFSIZE 512
#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_PEEK() ((*subpointer)&0xff)
#define SB_EOF() (subpointer >= subend)
#define SB_LEN() (subend - subpointer)
void telwrite(struct UrlData *data,
unsigned char *buffer, /* Data to write */
int count); /* Number of bytes to write */
void telrcv(struct UrlData *data,
unsigned char *inbuf, /* Data received from socket */
int count); /* Number of bytes received */
static void printoption(struct UrlData *data,
const char *direction,
int cmd, int option);
static void negotiate(struct UrlData *data);
static void send_negotiation(struct UrlData *data, int cmd, int option);
static void set_local_option(struct UrlData *data, int cmd, int option);
static void set_remote_option(struct UrlData *data, int cmd, int option);
static void printsub(struct UrlData *data,
int direction, unsigned char *pointer, int length);
static void suboption(struct UrlData *data);
/* suboptions */
static char subbuffer[SUBBUFSIZE];
static char *subpointer, *subend; /* buffer for sub-options */
/*
* Telnet receiver states for fsm
*/
static enum
{
TS_DATA = 0,
TS_IAC,
TS_WILL,
TS_WONT,
TS_DO,
TS_DONT,
TS_CR,
TS_SB, /* sub-option collection */
TS_SE /* looking for sub-option end */
} telrcv_state;
/* For negotiation compliant to RFC 1143 */
#define NO 0
#define YES 1
#define WANTYES 2
#define WANTNO 3
#define EMPTY 0
#define OPPOSITE 1
static int us[256];
static int usq[256];
static int us_preferred[256];
static int him[256];
static int himq[256];
static int him_preferred[256];
void init_telnet(struct UrlData *data)
{
telrcv_state = TS_DATA;
/* Init suboptions */
SB_CLEAR();
/* Set all options to NO */
memset(us, NO, 256);
memset(usq, NO, 256);
memset(us_preferred, NO, 256);
memset(him, NO, 256);
memset(himq, NO, 256);
memset(him_preferred, NO, 256);
/* Set the options we want */
us_preferred[TELOPT_BINARY] = YES;
us_preferred[TELOPT_SGA] = YES;
him_preferred[TELOPT_BINARY] = YES;
him_preferred[TELOPT_SGA] = YES;
/* Start negotiating */
negotiate(data);
}
static void negotiate(struct UrlData *data)
{
int i;
for(i = 0;i < NTELOPTS;i++)
{
if(us_preferred[i] == YES)
set_local_option(data, i, YES);
if(him_preferred[i] == YES)
set_remote_option(data, i, YES);
}
}
static void printoption(struct UrlData *data,
const char *direction, int cmd, int option)
{
char *fmt;
char *opt;
if (data->bits.verbose)
{
if (cmd == IAC)
{
if (TELCMD_OK(option))
printf("%s IAC %s\n", direction, TELCMD(option));
else
printf("%s IAC %d\n", direction, option);
}
else
{
fmt = (cmd == WILL) ? "WILL" : (cmd == WONT) ? "WONT" :
(cmd == DO) ? "DO" : (cmd == DONT) ? "DONT" : 0;
if (fmt)
{
if (TELOPT_OK(option))
opt = TELOPT(option);
else if (option == TELOPT_EXOPL)
opt = "EXOPL";
else
opt = NULL;
if(opt)
printf("%s %s %s\n", direction, fmt, opt);
else
printf("%s %s %d\n", direction, fmt, option);
}
else
printf("%s %d %d\n", direction, cmd, option);
}
}
}
static void send_negotiation(struct UrlData *data, int cmd, int option)
{
unsigned char buf[3];
buf[0] = IAC;
buf[1] = cmd;
buf[2] = option;
swrite(data->firstsocket, buf, 3);
printoption(data, "SENT", cmd, option);
}
void set_remote_option(struct UrlData *data, int option, int newstate)
{
if(newstate == YES)
{
switch(him[option])
{
case NO:
him[option] = WANTYES;
send_negotiation(data, DO, option);
break;
case YES:
/* Already enabled */
break;
case WANTNO:
switch(himq[option])
{
case EMPTY:
/* Already negotiating for YES, queue the request */
himq[option] = OPPOSITE;
break;
case OPPOSITE:
/* Error: already queued an enable request */
break;
}
break;
case WANTYES:
switch(himq[option])
{
case EMPTY:
/* Error: already negotiating for enable */
break;
case OPPOSITE:
himq[option] = EMPTY;
break;
}
break;
}
}
else /* NO */
{
switch(him[option])
{
case NO:
/* Already disabled */
break;
case YES:
him[option] = WANTNO;
send_negotiation(data, DONT, option);
break;
case WANTNO:
switch(himq[option])
{
case EMPTY:
/* Already negotiating for NO */
break;
case OPPOSITE:
himq[option] = EMPTY;
break;
}
break;
case WANTYES:
switch(himq[option])
{
case EMPTY:
himq[option] = OPPOSITE;
break;
case OPPOSITE:
break;
}
break;
}
}
}
void rec_will(struct UrlData *data, int option)
{
switch(him[option])
{
case NO:
if(him_preferred[option] == YES)
{
him[option] = YES;
send_negotiation(data, DO, option);
}
else
{
send_negotiation(data, DONT, option);
}
break;
case YES:
/* Already enabled */
break;
case WANTNO:
switch(himq[option])
{
case EMPTY:
/* Error: DONT answered by WILL */
him[option] = NO;
break;
case OPPOSITE:
/* Error: DONT answered by WILL */
him[option] = YES;
himq[option] = EMPTY;
break;
}
break;
case WANTYES:
switch(himq[option])
{
case EMPTY:
him[option] = YES;
break;
case OPPOSITE:
him[option] = WANTNO;
himq[option] = EMPTY;
send_negotiation(data, DONT, option);
break;
}
break;
}
}
void rec_wont(struct UrlData *data, int option)
{
switch(him[option])
{
case NO:
/* Already disabled */
break;
case YES:
him[option] = NO;
send_negotiation(data, DONT, option);
break;
case WANTNO:
switch(himq[option])
{
case EMPTY:
him[option] = NO;
break;
case OPPOSITE:
him[option] = WANTYES;
himq[option] = EMPTY;
send_negotiation(data, DO, option);
break;
}
break;
case WANTYES:
switch(himq[option])
{
case EMPTY:
him[option] = NO;
break;
case OPPOSITE:
him[option] = NO;
himq[option] = EMPTY;
break;
}
break;
}
}
void set_local_option(struct UrlData *data, int option, int newstate)
{
if(newstate == YES)
{
switch(us[option])
{
case NO:
us[option] = WANTYES;
send_negotiation(data, WILL, option);
break;
case YES:
/* Already enabled */
break;
case WANTNO:
switch(usq[option])
{
case EMPTY:
/* Already negotiating for YES, queue the request */
usq[option] = OPPOSITE;
break;
case OPPOSITE:
/* Error: already queued an enable request */
break;
}
break;
case WANTYES:
switch(usq[option])
{
case EMPTY:
/* Error: already negotiating for enable */
break;
case OPPOSITE:
usq[option] = EMPTY;
break;
}
break;
}
}
else /* NO */
{
switch(us[option])
{
case NO:
/* Already disabled */
break;
case YES:
us[option] = WANTNO;
send_negotiation(data, WONT, option);
break;
case WANTNO:
switch(usq[option])
{
case EMPTY:
/* Already negotiating for NO */
break;
case OPPOSITE:
usq[option] = EMPTY;
break;
}
break;
case WANTYES:
switch(usq[option])
{
case EMPTY:
usq[option] = OPPOSITE;
break;
case OPPOSITE:
break;
}
break;
}
}
}
void rec_do(struct UrlData *data, int option)
{
switch(us[option])
{
case NO:
if(us_preferred[option] == YES)
{
us[option] = YES;
send_negotiation(data, WILL, option);
}
else
{
send_negotiation(data, WONT, option);
}
break;
case YES:
/* Already enabled */
break;
case WANTNO:
switch(usq[option])
{
case EMPTY:
/* Error: DONT answered by WILL */
us[option] = NO;
break;
case OPPOSITE:
/* Error: DONT answered by WILL */
us[option] = YES;
usq[option] = EMPTY;
break;
}
break;
case WANTYES:
switch(usq[option])
{
case EMPTY:
us[option] = YES;
break;
case OPPOSITE:
us[option] = WANTNO;
himq[option] = EMPTY;
send_negotiation(data, WONT, option);
break;
}
break;
}
}
void rec_dont(struct UrlData *data, int option)
{
switch(us[option])
{
case NO:
/* Already disabled */
break;
case YES:
us[option] = NO;
send_negotiation(data, WONT, option);
break;
case WANTNO:
switch(usq[option])
{
case EMPTY:
us[option] = NO;
break;
case OPPOSITE:
us[option] = WANTYES;
usq[option] = EMPTY;
send_negotiation(data, WILL, option);
break;
}
break;
case WANTYES:
switch(usq[option])
{
case EMPTY:
us[option] = NO;
break;
case OPPOSITE:
us[option] = NO;
usq[option] = EMPTY;
break;
}
break;
}
}
static void printsub(struct UrlData *data,
int direction, /* '<' or '>' */
unsigned char *pointer, /* where suboption data is */
int length) /* length of suboption data */
{
int i = 0;
if (data->bits.verbose)
{
if (direction)
{
printf("%s IAC SB ", (direction == '<')? "RCVD":"SENT");
if (length >= 3)
{
int j;
i = pointer[length-2];
j = pointer[length-1];
if (i != IAC || j != SE)
{
printf("(terminated by ");
if (TELOPT_OK(i))
printf("%s ", TELOPT(i));
else if (TELCMD_OK(i))
printf("%s ", TELCMD(i));
else
printf("%d ", i);
if (TELOPT_OK(j))
printf("%s", TELOPT(j));
else if (TELCMD_OK(j))
printf("%s", TELCMD(j));
else
printf("%d", j);
printf(", not IAC SE!) ");
}
}
length -= 2;
}
if (length < 1)
{
printf("(Empty suboption?)");
return;
}
if (TELOPT_OK(pointer[0]))
printf("%s (unknown)", TELOPT(pointer[0]));
else
printf("%d (unknown)", pointer[i]);
for (i = 1; i < length; i++)
printf(" %d", pointer[i]);
if (direction)
{
printf("\n");
}
}
}
/*
* suboption()
*
* Look at the sub-option buffer, and try to be helpful to the other
* side.
* No suboptions are supported yet.
*/
static void suboption(struct UrlData *data)
{
printsub(data, '<', (unsigned char *)subbuffer, SB_LEN()+2);
return;
}
void telrcv(struct UrlData *data,
unsigned char *inbuf, /* Data received from socket */
int count) /* Number of bytes received */
{
unsigned char c;
int index = 0;
while(count--)
{
c = inbuf[index++];
switch (telrcv_state)
{
case TS_CR:
telrcv_state = TS_DATA;
if (c == '\0')
{
break; /* Ignore \0 after CR */
}
data->fwrite((char *)&c, 1, 1, data->out);
continue;
case TS_DATA:
if (c == IAC)
{
telrcv_state = TS_IAC;
break;
}
else if(c == '\r')
{
telrcv_state = TS_CR;
}
data->fwrite((char *)&c, 1, 1, data->out);
continue;
case TS_IAC:
process_iac:
switch (c)
{
case WILL:
telrcv_state = TS_WILL;
continue;
case WONT:
telrcv_state = TS_WONT;
continue;
case DO:
telrcv_state = TS_DO;
continue;
case DONT:
telrcv_state = TS_DONT;
continue;
case SB:
SB_CLEAR();
telrcv_state = TS_SB;
continue;
case IAC:
data->fwrite((char *)&c, 1, 1, data->out);
break;
case DM:
case NOP:
case GA:
default:
printoption(data, "RCVD", IAC, c);
break;
}
telrcv_state = TS_DATA;
continue;
case TS_WILL:
printoption(data, "RCVD", WILL, c);
rec_will(data, c);
telrcv_state = TS_DATA;
continue;
case TS_WONT:
printoption(data, "RCVD", WONT, c);
rec_wont(data, c);
telrcv_state = TS_DATA;
continue;
case TS_DO:
printoption(data, "RCVD", DO, c);
rec_do(data, c);
telrcv_state = TS_DATA;
continue;
case TS_DONT:
printoption(data, "RCVD", DONT, c);
rec_dont(data, c);
telrcv_state = TS_DATA;
continue;
case TS_SB:
if (c == IAC)
{
telrcv_state = TS_SE;
}
else
{
SB_ACCUM(c);
}
continue;
case TS_SE:
if (c != SE)
{
if (c != IAC)
{
/*
* This is an error. We only expect to get
* "IAC IAC" or "IAC SE". Several things may
* have happend. An IAC was not doubled, the
* IAC SE was left off, or another option got
* inserted into the suboption are all possibilities.
* If we assume that the IAC was not doubled,
* and really the IAC SE was left off, we could
* get into an infinate loop here. So, instead,
* we terminate the suboption, and process the
* partial suboption if we can.
*/
SB_ACCUM((unsigned char)IAC);
SB_ACCUM(c);
subpointer -= 2;
SB_TERM();
printoption(data, "In SUBOPTION processing, RCVD", IAC, c);
suboption(data); /* handle sub-option */
telrcv_state = TS_IAC;
goto process_iac;
}
SB_ACCUM(c);
telrcv_state = TS_SB;
}
else
{
SB_ACCUM((unsigned char)IAC);
SB_ACCUM((unsigned char)SE);
subpointer -= 2;
SB_TERM();
suboption(data); /* handle sub-option */
telrcv_state = TS_DATA;
}
break;
}
}
}
void telwrite(struct UrlData *data,
unsigned char *buffer, /* Data to write */
int count) /* Number of bytes to write */
{
unsigned char outbuf[2];
int out_count = 0;
int bytes_written;
while(count--)
{
outbuf[0] = *buffer++;
out_count = 1;
if(outbuf[0] == IAC)
outbuf[out_count++] = IAC;
#ifndef USE_SSLEAY
bytes_written = swrite(data->firstsocket, outbuf, out_count);
#else
if (data->use_ssl) {
bytes_written = SSL_write(data->ssl, (char *)outbuf, out_count);
}
else {
bytes_written = swrite(data->firstsocket, outbuf, out_count);
}
#endif /* USE_SSLEAY */
}
}
CURLcode telnet_done(struct connectdata *conn)
{
return CURLE_OK;
}
CURLcode telnet(struct connectdata *conn)
{
struct UrlData *data = conn->data;
int sockfd = data->firstsocket;
fd_set readfd;
fd_set keepfd;
bool keepon = TRUE;
char *buf = data->buffer;
int nread;
init_telnet(data);
FD_ZERO (&readfd); /* clear it */
FD_SET (sockfd, &readfd);
FD_SET (1, &readfd);
keepfd = readfd;
while (keepon)
{
readfd = keepfd; /* set this every lap in the loop */
switch (select (sockfd + 1, &readfd, NULL, NULL, NULL))
{
case -1: /* error, stop reading */
keepon = FALSE;
continue;
case 0: /* timeout */
break;
default: /* read! */
if(FD_ISSET(1, &readfd))
{
nread = read(1, buf, 255);
telwrite(data, (unsigned char *)buf, nread);
}
if(FD_ISSET(sockfd, &readfd))
{
#ifndef USE_SSLEAY
nread = sread (sockfd, buf, BUFSIZE - 1);
#else
if (data->use_ssl) {
nread = SSL_read (data->ssl, buf, BUFSIZE - 1);
}
else {
nread = sread (sockfd, buf, BUFSIZE - 1);
}
#endif /* USE_SSLEAY */
}
/* if we receive 0 or less here, the server closed the connection and
we bail out from this! */
if (nread <= 0) {
keepon = FALSE;
break;
}
telrcv(data, (unsigned char *)buf, nread);
}
}
return CURLE_OK;
}
Reference in New Issue View Git Blame Copy Permalink