int main(int argc, char **argv)
{
struct sockaddr_in sa;
int master_fd;
fd_set rdfdset, wrfdset;
int selret;
int on = 1;
int portnbr = 23;
int c, ii;
int daemonize = 0;
char *interface_name = NULL;
struct ifreq interface;
#ifdef USE_SYSLOG
char *appname;
appname = strrchr (argv [0], '/');
if (!appname) appname = argv [0];
else appname++;
#endif
/* check if user supplied a port number */
for (;;) {
c = getopt( argc, argv, "i:p:l:hd");
if (c == EOF) break;
switch (c) {
case 'p':
portnbr = atoi(optarg);
break;
case 'i':
interface_name = strdup(optarg);
break;
case 'l':
loginpath = strdup(optarg);
break;
case 'd':
daemonize = 1;
break;
case 'h':
default:
show_usage();
exit(1);
}
}
if (!loginpath) {
loginpath = SHELLPATH;
if (access(loginpath, X_OK) < 0) loginpath = "/bin/sh";
}
if (access(loginpath, X_OK) < 0) {
/* workaround: error_msg_and_die has doesn't understand
variable argument lists yet */
fprintf(stderr,"\"%s\"",loginpath);
perror_msg_and_die(" is no valid executable!\n");
}
printf("telnetd: starting\n");
printf(" port: %i; interface: %s; login program: %s\n",
portnbr, (interface_name)?interface_name:"any", loginpath);
argv_init[0] = loginpath;
sessions = 0;
/* Grab a TCP socket. */
master_fd = socket(AF_INET, SOCK_STREAM, 0);
if (master_fd < 0) {
perror("socket");
return 1;
}
(void)setsockopt(master_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
/* Set it to listen to specified port */
memset((void *)&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(portnbr);
/* Set it to listen on the specified interface */
if (interface_name) {
strcpy(interface.ifr_name, interface_name);
/* use ioctl() here as BSD does not have setsockopt() */
if (ioctl(master_fd, SIOCGIFADDR, &interface) < 0) {
printf("Please check the NIC you specified with -i option\n");
perror("ioctl SIOCGFADDR");
return 1;
}
sa.sin_addr = ((struct sockaddr_in *)(&interface.ifr_addr))->sin_addr;
} else
sa.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(master_fd, (struct sockaddr *) &sa, sizeof(sa)) < 0) {
perror("bind");
return 1;
}
if (listen(master_fd, 1) < 0) {
perror("listen");
return 1;
}
if (daemonize)
{
DEBUG_OUT(" daemonizing\n");
if (daemon(0, 1) < 0) perror_msg_and_die("daemon");
}
#ifdef USE_SYSLOG
openlog(appname , LOG_NDELAY | LOG_PID, LOG_DAEMON);
syslog(LOG_INFO, "%s (port: %i, ifname: %s, login: %s) startup succeeded\n"\
, appname, portnbr, (interface_name)?interface_name:"any", loginpath);
closelog();
#endif
maxfd = master_fd;
do {
struct tsession *ts;
FD_ZERO(&rdfdset);
FD_ZERO(&wrfdset);
/* select on the master socket, all telnet sockets and their
* ptys if there is room in their respective session buffers.
*/
FD_SET(master_fd, &rdfdset);
ts = sessions;
while (ts) {
/* buf1 is used from socket to pty
* buf2 is used from pty to socket
*/
if (ts->size1 > 0) {
FD_SET(ts->ptyfd, &wrfdset); /* can write to pty */
}
if (ts->size1 < BUFSIZE) {
FD_SET(ts->sockfd, &rdfdset); /* can read from socket */
}
if (ts->size2 > 0) {
FD_SET(ts->sockfd, &wrfdset); /* can write to socket */
}
if (ts->size2 < BUFSIZE) {
FD_SET(ts->ptyfd, &rdfdset); /* can read from pty */
}
ts = ts->next;
}
selret = select(maxfd + 1, &rdfdset, &wrfdset, 0, 0);
if (!selret)
break;
/* First check for and accept new sessions. */
if (FD_ISSET(master_fd, &rdfdset)) {
int fd, salen;
salen = sizeof(sa);
if ((fd = accept(master_fd, (struct sockaddr *)&sa,
&salen)) < 0) {
continue;
} else {
/* Create a new session and link it into our active list. */
struct tsession *new_ts;
#ifdef USE_SYSLOG
openlog(appname , LOG_NDELAY, LOG_DAEMON);
syslog(LOG_INFO, "connection from: %s\n", inet_ntoa(sa.sin_addr));
closelog();
#endif
new_ts = make_new_session(fd);
if (new_ts) {
new_ts->next = sessions;
sessions = new_ts;
if (fd > maxfd)
maxfd = fd;
} else {
close(fd);
}
}
}
/* Then check for data tunneling. */
ts = sessions;
while (ts) { /* For all sessions... */
int maxlen, w, r;
struct tsession *next = ts->next; /* in case we free ts. */
if (ts->size1 && FD_ISSET(ts->ptyfd, &wrfdset)) {
int processed, num_totty;
char *ptr;
/* Write to pty from buffer 1. */
maxlen = MIN(BUFSIZE - ts->wridx1,
ts->size1);
ptr = remove_iacs(ts->buf1 + ts->wridx1, maxlen,
&processed, &num_totty);
/* the difference between processed and num_totty
is all the iacs we removed from the stream.
Adjust buf1 accordingly. */
ts->wridx1 += processed - num_totty;
ts->size1 -= processed - num_totty;
w = write(ts->ptyfd, ptr, num_totty);
if (w < 0) {
perror("write");
free_session(ts);
ts = next;
continue;
}
ts->wridx1 += w;
ts->size1 -= w;
if (ts->wridx1 == BUFSIZE)
ts->wridx1 = 0;
}
if (ts->size2 && FD_ISSET(ts->sockfd, &wrfdset)) {
/* Write to socket from buffer 2. */
maxlen = MIN(BUFSIZE - ts->wridx2,
ts->size2);
w = write(ts->sockfd, ts->buf2 + ts->wridx2, maxlen);
if (w < 0) {
perror("write");
free_session(ts);
ts = next;
continue;
}
ts->wridx2 += w;
ts->size2 -= w;
if (ts->wridx2 == BUFSIZE)
ts->wridx2 = 0;
}
if (ts->size1 < BUFSIZE && FD_ISSET(ts->sockfd, &rdfdset)) {
/* Read from socket to buffer 1. */
maxlen = MIN(BUFSIZE - ts->rdidx1,
BUFSIZE - ts->size1);
r = read(ts->sockfd, ts->buf1 + ts->rdidx1, maxlen);
if (!r || (r < 0 && errno != EINTR)) {
free_session(ts);
ts = next;
continue;
}
if(!*(ts->buf1 + ts->rdidx1 + r - 1)) {
r--;
if(!r)
continue;
}
ts->rdidx1 += r;
ts->size1 += r;
if (ts->rdidx1 == BUFSIZE)
ts->rdidx1 = 0;
}
if (ts->size2 < BUFSIZE && FD_ISSET(ts->ptyfd, &rdfdset)) {
/* Read from pty to buffer 2. */
maxlen = MIN(BUFSIZE - ts->rdidx2,
BUFSIZE - ts->size2);
r = read(ts->ptyfd, ts->buf2 + ts->rdidx2, maxlen);
if (!r || (r < 0 && errno != EINTR)) {
free_session(ts);
ts = next;
continue;
}
for (ii=0; ii < r; ii++)
if (*(ts->buf2 + ts->rdidx2 + ii) == 3)
fprintf(stderr, "found <CTRL>-<C> in data!\n");
ts->rdidx2 += r;
ts->size2 += r;
if (ts->rdidx2 == BUFSIZE)
ts->rdidx2 = 0;
}
if (ts->size1 == 0) {
ts->rdidx1 = 0;
ts->wridx1 = 0;
}
if (ts->size2 == 0) {
ts->rdidx2 = 0;
ts->wridx2 = 0;
}
ts = next;
}
} while (1);
return 0;
}
int
telnetd_main(int argc, char **argv)
{
#if !defined(CONFIG_FEATURE_TELNETD_INETD) || defined(IFX_INETD_ENHANCEMENT)
int master_fd;
#endif
#ifndef CONFIG_FEATURE_TELNETD_INETD
struct sockaddr_in sa;
#endif /* CONFIG_FEATURE_TELNETD_INETD */
fd_set rdfdset, wrfdset;
int selret;
#ifndef CONFIG_FEATURE_TELNETD_INETD
int on = 1;
int portnbr = 23;
#endif /* CONFIG_FEATURE_TELNETD_INETD */
int c;
static const char options[] =
#ifdef CONFIG_FEATURE_TELNETD_INETD
#ifdef CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT
"f:l:t:";
#else /*CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT*/
"f:l:";
#endif /* CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT */
#else /* CONFIG_EATURE_TELNETD_INETD */
#ifdef CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT
"f:l:p:t:";
#else /* CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT */
"f:l:p:";
#endif /*CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT*/
#endif /* CONFIG_FEATURE_TELNETD_INETD */
int maxlen, w, r;
#ifdef CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT
struct timeval time_val;
int daemon_timeout_val = time(NULL) + 120;
#endif
#ifndef CONFIG_LOGIN
loginpath = DEFAULT_SHELL;
#endif
for (;;) {
c = getopt( argc, argv, options);
if (c == EOF) break;
switch (c) {
case 'f':
issuefile = optarg;
break;
case 'l':
loginpath = optarg;
break;
#ifndef CONFIG_FEATURE_TELNETD_INETD
case 'p':
portnbr = atoi(optarg);
break;
#endif /* CONFIG_FEATURE_TELNETD_INETD */
#ifdef CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT
case 't':
TIMEOUT = atoi(optarg);
break;
#endif /* CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT*/
default:
bb_show_usage();
}
}
if (access(loginpath, X_OK) < 0) {
bb_error_msg_and_die ("'%s' unavailable.", loginpath);
}
argv_init[0] = loginpath;
openlog(bb_applet_name, 0, LOG_USER);
#ifndef IFX_INETD_ENHANCEMENT
#ifdef CONFIG_FEATURE_TELNETD_INETD
maxfd = 1;
sessions = make_new_session();
#else /* CONFIG_EATURE_TELNETD_INETD */
sessions = 0;
/* Grab a TCP socket. */
master_fd = socket(AF_INET, SOCK_STREAM, 0);
if (master_fd < 0) {
bb_perror_msg_and_die("socket");
}
(void)setsockopt(master_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
/* Set it to listen to specified port. */
memset((void *)&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(portnbr);
if (bind(master_fd, (struct sockaddr *) &sa, sizeof(sa)) < 0) {
bb_perror_msg_and_die("bind");
}
if (listen(master_fd, 1) < 0) {
bb_perror_msg_and_die("listen");
}
if (daemon(0, 0) < 0)
bb_perror_msg_and_die("daemon");
maxfd = master_fd;
#endif /* CONFIG_FEATURE_TELNETD_INETD */
#else /* IFX_INETD_ENHANCEMENT */
sessions = 0;
master_fd = 0;
maxfd = master_fd;
#endif /* IFX_INETD_ENHANCEMENT */
do {
struct tsession *ts;
FD_ZERO(&rdfdset);
FD_ZERO(&wrfdset);
/* select on the master socket, all telnet sockets and their
* ptys if there is room in their respective session buffers.
*/
#ifndef CONFIG_FEATURE_TELNETD_INETD
FD_SET(master_fd, &rdfdset);
#endif /* CONFIG_FEATURE_TELNETD_INETD */
ts = sessions;
#ifndef CONFIG_FEATURE_TELNETD_INETD
while (ts) {
#endif /* CONFIG_FEATURE_TELNETD_INETD */
/* buf1 is used from socket to pty
* buf2 is used from pty to socket
*/
if (ts->size1 > 0) {
FD_SET(ts->ptyfd, &wrfdset); /* can write to pty */
}
if (ts->size1 < BUFSIZE) {
#ifdef CONFIG_FEATURE_TELNETD_INETD
FD_SET(ts->sockfd_read, &rdfdset); /* can read from socket */
#else /* CONFIG_FEATURE_TELNETD_INETD */
FD_SET(ts->sockfd, &rdfdset); /* can read from socket */
#endif /* CONFIG_FEATURE_TELNETD_INETD */
}
if (ts->size2 > 0) {
#ifdef CONFIG_FEATURE_TELNETD_INETD
FD_SET(ts->sockfd_write, &wrfdset); /* can write to socket */
#else /* CONFIG_FEATURE_TELNETD_INETD */
FD_SET(ts->sockfd, &wrfdset); /* can write to socket */
#endif /* CONFIG_FEATURE_TELNETD_INETD */
}
if (ts->size2 < BUFSIZE) {
FD_SET(ts->ptyfd, &rdfdset); /* can read from pty */
}
#ifndef CONFIG_FEATURE_TELNETD_INETD
ts = ts->next;
}
#endif /* CONFIG_FEATURE_TELNETD_INETD */
#ifdef CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT
time_val.tv_sec = 10;
time_val.tv_usec = 0;
selret = select(maxfd + 1, &rdfdset, &wrfdset, 0, &time_val);
#else
selret = select(maxfd + 1, &rdfdset, &wrfdset, 0, 0);
#endif
if (selret < 0)
break;
#ifdef CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT
// check if the currtime exceeded timeout time
#ifndef CONFIG_FEATURE_TELNETD_INETD
ts= sessions;
while(ts)
{
struct tsession *next = ts->next; /* in case we free ts. */
#endif /* CONFIG_FEATURE_TELNETD_INETD */
if(ts->timeout_time < time(NULL))
{
printf("Timed out \n");
syslog(LOG_ERR,"Session timed out\n");
#ifdef CONFIG_FEATURE_TELNETD_INETD
exit(0);
#else /* CONFIG_FEATURE_TELNETD_INETD */
daemon_timeout_val = time(NULL) + 120;
free_session(ts);
#endif/* CONFIG_FEATURE_TELNETD_INETD */
}
#ifndef CONFIG_FEATURE_TELNETD_INETD
ts= next;
}
#endif /* CONFIG_FEATURE_TELNETD_INETD */
if(selret == 0) {
if(sessions == NULL && daemon_timeout_val < time(NULL)) {
printf("Telnetd Timed out \n");
syslog(LOG_ERR,"Telnetd timed out\n");
exit(0);
} else
continue;
}
#endif /* CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT */
#ifndef CONFIG_FEATURE_TELNETD_INETD
daemon_timeout_val = time(NULL) + 120;
/* First check for and accept new sessions. */
if (FD_ISSET(master_fd, &rdfdset)) {
int fd, salen;
salen = sizeof(sa);
if ((fd = accept(master_fd, (struct sockaddr *)&sa,
&salen)) < 0) {
continue;
} else {
/* Create a new session and link it into
our active list. */
struct tsession *new_ts = make_new_session(fd);
if (new_ts) {
new_ts->next = sessions;
sessions = new_ts;
if (fd > maxfd)
maxfd = fd;
} else {
close(fd);
}
}
}
/* Then check for data tunneling. */
ts = sessions;
while (ts) { /* For all sessions... */
#endif /* CONFIG_FEATURE_TELNETD_INETD */
#ifndef CONFIG_FEATURE_TELNETD_INETD
struct tsession *next = ts->next; /* in case we free ts. */
#endif /* CONFIG_FEATURE_TELNETD_INETD */
if (ts->size1 && FD_ISSET(ts->ptyfd, &wrfdset)) {
int num_totty;
char *ptr;
/* Write to pty from buffer 1. */
ptr = remove_iacs(ts, &num_totty);
w = write(ts->ptyfd, ptr, num_totty);
if (w < 0) {
#ifdef CONFIG_FEATURE_TELNETD_INETD
exit(0);
#else /* CONFIG_FEATURE_TELNETD_INETD */
free_session(ts);
ts = next;
continue;
#endif /* CONFIG_FEATURE_TELNETD_INETD */
}
ts->wridx1 += w;
ts->size1 -= w;
if (ts->wridx1 == BUFSIZE)
ts->wridx1 = 0;
#ifdef CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT
//some activity in this session reset the timer
ts->timeout_time = time(NULL)+ TIMEOUT;
#endif /* CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT */
}
#ifdef CONFIG_FEATURE_TELNETD_INETD
if (ts->size2 && FD_ISSET(ts->sockfd_write, &wrfdset))
#else /* CONFIG_FEATURE_TELNETD_INETD */
if (ts->size2 && FD_ISSET(ts->sockfd, &wrfdset))
#endif /* CONFIG_FEATURE_TELNETD_INETD */
{
/* Write to socket from buffer 2. */
maxlen = MIN(BUFSIZE - ts->wridx2, ts->size2);
#ifdef CONFIG_FEATURE_TELNETD_INETD
w = write(ts->sockfd_write, ts->buf2 + ts->wridx2, maxlen);
if (w < 0)
exit(0);
#ifdef CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT
else
ts->timeout_time = time(NULL)+TIMEOUT;
#endif /*CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT*/
#else /* CONFIG_FEATURE_TELNETD_INETD */
w = write(ts->sockfd, ts->buf2 + ts->wridx2, maxlen);
if (w < 0) {
free_session(ts);
ts = next;
continue;
}
#endif /* CONFIG_FEATURE_TELNETD_INETD */
ts->wridx2 += w;
ts->size2 -= w;
if (ts->wridx2 == BUFSIZE)
ts->wridx2 = 0;
#ifdef CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT
//some activity in this session reset the timer
ts->timeout_time = time(NULL)+ TIMEOUT;
#endif /* CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT */
}
#ifdef CONFIG_FEATURE_TELNETD_INETD
if (ts->size1 < BUFSIZE && FD_ISSET(ts->sockfd_read, &rdfdset))
#else /* CONFIG_FEATURE_TELNETD_INETD */
if (ts->size1 < BUFSIZE && FD_ISSET(ts->sockfd, &rdfdset))
#endif /* CONFIG_FEATURE_TELNETD_INETD */
{
/* Read from socket to buffer 1. */
maxlen = MIN(BUFSIZE - ts->rdidx1,
BUFSIZE - ts->size1);
#ifdef CONFIG_FEATURE_TELNETD_INETD
r = read(ts->sockfd_read, ts->buf1 + ts->rdidx1, maxlen);
if (!r || (r < 0 && errno != EINTR))
exit(0);
#else /* CONFIG_FEATURE_TELNETD_INETD */
r = read(ts->sockfd, ts->buf1 + ts->rdidx1, maxlen);
if (!r || (r < 0 && errno != EINTR)) {
free_session(ts);
ts = next;
continue;
}
#endif /* CONFIG_FEATURE_TELNETD_INETD */
#ifdef CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT
//some activity in this session reset the timer
ts->timeout_time = time(NULL)+ TIMEOUT;
#endif /* CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT */
if(!*(ts->buf1 + ts->rdidx1 + r - 1)) {
r--;
if(!r)
continue;
}
ts->rdidx1 += r;
ts->size1 += r;
if (ts->rdidx1 == BUFSIZE)
ts->rdidx1 = 0;
}
if (ts->size2 < BUFSIZE && FD_ISSET(ts->ptyfd, &rdfdset)) {
/* Read from pty to buffer 2. */
maxlen = MIN(BUFSIZE - ts->rdidx2,
BUFSIZE - ts->size2);
r = read(ts->ptyfd, ts->buf2 + ts->rdidx2, maxlen);
if (!r || (r < 0 && errno != EINTR)) {
#ifdef CONFIG_FEATURE_TELNETD_INETD
exit(0);
#else /* CONFIG_FEATURE_TELNETD_INETD */
free_session(ts);
ts = next;
continue;
#endif /* CONFIG_FEATURE_TELNETD_INETD */
}
ts->rdidx2 += r;
ts->size2 += r;
if (ts->rdidx2 == BUFSIZE)
ts->rdidx2 = 0;
#ifdef CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT
//some activity in this session reset the timer
ts->timeout_time = time(NULL)+ TIMEOUT;
#endif /* CONFIG_FEATURE_TELNETD_INACTIVE_TIMEOUT */
}
if (ts->size1 == 0) {
ts->rdidx1 = 0;
ts->wridx1 = 0;
}
if (ts->size2 == 0) {
ts->rdidx2 = 0;
ts->wridx2 = 0;
}
#ifndef CONFIG_FEATURE_TELNETD_INETD
ts = next;
}
#endif /* CONFIG_FEATURE_TELNETD_INETD */
} while (1);
return 0;
}
static void *misc_thread_func(void *arg)
{
fd_set r_fds,w_fds,except_fds;
struct timeval tv;
int retval, max_fd, tmp_fd;
save_ori_io();
fd_server=tcp_socket_init(NULL, server_port);
if (fd_server<0)
{
ERR_DBG_PRINT_QUIT("create telnetd server socket failed.");
}
listen(fd_server,0);
while (1)
{
FD_ZERO(&r_fds);
FD_ZERO(&w_fds);
FD_ZERO(&except_fds);
FD_SET(fd_server, &r_fds);
max_fd=fd_server;
if (fd_conn>0)
{
FD_SET(fd_conn, &r_fds);
FD_SET(fd_conn, &except_fds);
max_fd=(fd_conn>max_fd)?fd_conn:max_fd;
FD_SET(fd_pty_master, &r_fds);
max_fd=(fd_pty_master>max_fd)?fd_pty_master:max_fd;
}
tv.tv_sec = 0;
tv.tv_usec = 200000;
retval = select(max_fd + 1, &r_fds, &w_fds, &except_fds, &tv);
if (retval <= 0)
{
continue;
}
if (FD_ISSET(fd_server, &r_fds))
{
tmp_fd=accept(fd_server, NULL, NULL);
if (tmp_fd<0)
{
continue;
}
if (fd_conn>0)
{
printf_to_fd(fd_conn, "A new login happens, so we shutdown your session...\r\n");
}
term_session();
if (make_new_session(tmp_fd))
{
close(tmp_fd);
}
continue;
}
if (shell_quit_occurred || FD_ISSET(fd_conn, &except_fds))
{
term_session();
continue;
}
if (FD_ISSET(fd_conn, &r_fds))
{
trans_data_sock2pty();
}
if (FD_ISSET(fd_pty_master, &r_fds)|| (pty2sock_cache_len>0))
{
if (trans_data_pty2sock())
{
term_session();
continue;
}
}
}
return NULL;
}