networking/telnetd.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Simple telnet server
   4  * Bjorn Wesen, Axis Communications AB (bjornw@axis.com)
   5  *
   6  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
   7  *
   8  * ---------------------------------------------------------------------------
   9  * (C) Copyright 2000, Axis Communications AB, LUND, SWEDEN
  10  ****************************************************************************
  11  *
  12  * The telnetd manpage says it all:
  13  *
  14  * Telnetd operates by allocating a pseudo-terminal device (see pty(4)) for
  15  * a client, then creating a login process which has the slave side of the
  16  * pseudo-terminal as stdin, stdout, and stderr. Telnetd manipulates the
  17  * master side of the pseudo-terminal, implementing the telnet protocol and
  18  * passing characters between the remote client and the login process.
  19  *
  20  * Vladimir Oleynik <dzo@simtreas.ru> 2001
  21  * Set process group corrections, initial busybox port
  22  */
  23 #define DEBUG 0
  24
  25 #include "libbb.h"
  26 #include <syslog.h>
  27
  28 #if DEBUG
  29 # define TELCMDS
  30 # define TELOPTS
  31 #endif
  32 #include <arpa/telnet.h>
  33
  34 #if ENABLE_FEATURE_UTMP
  35 # include <utmp.h> /* LOGIN_PROCESS */
  36 #endif
  37
  38
  39 struct tsession {
  40         struct tsession *next;
  41         pid_t shell_pid;
  42         int sockfd_read;
  43         int sockfd_write;
  44         int ptyfd;
  45
  46         /* two circular buffers */
  47         /*char *buf1, *buf2;*/
  48 /*#define TS_BUF1(ts) ts->buf1*/
  49 /*#define TS_BUF2(ts) TS_BUF2(ts)*/
  50 #define TS_BUF1(ts) ((unsigned char*)(ts + 1))
  51 #define TS_BUF2(ts) (((unsigned char*)(ts + 1)) + BUFSIZE)
  52         int rdidx1, wridx1, size1;
  53         int rdidx2, wridx2, size2;
  54 };
  55
  56 /* Two buffers are directly after tsession in malloced memory.
  57  * Make whole thing fit in 4k */
  58 enum { BUFSIZE = (4 * 1024 - sizeof(struct tsession)) / 2 };
  59
  60
  61 /* Globals */
  62 struct globals {
  63         struct tsession *sessions;
  64         const char *loginpath;
  65         const char *issuefile;
  66         int maxfd;
  67 } FIX_ALIASING;
  68 #define G (*(struct globals*)&bb_common_bufsiz1)
  69 #define INIT_G() do { \
  70         G.loginpath = "/bin/login"; \
  71         G.issuefile = "/etc/issue.net"; \
  72 } while (0)
  73
  74
  75 /*
  76    Remove all IAC's from buf1 (received IACs are ignored and must be removed
  77    so as to not be interpreted by the terminal).  Make an uninterrupted
  78    string of characters fit for the terminal.  Do this by packing
  79    all characters meant for the terminal sequentially towards the end of buf.
  80
  81    Return a pointer to the beginning of the characters meant for the terminal
  82    and make *num_totty the number of characters that should be sent to
  83    the terminal.
  84
  85    Note - if an IAC (3 byte quantity) starts before (bf + len) but extends
  86    past (bf + len) then that IAC will be left unprocessed and *processed
  87    will be less than len.
  88
  89    CR-LF ->'s CR mapping is also done here, for convenience.
  90
  91    NB: may fail to remove iacs which wrap around buffer!
  92  */
  93 static unsigned char *
  94 remove_iacs(struct tsession *ts, int *pnum_totty)
  95 {
  96         unsigned char *ptr0 = TS_BUF1(ts) + ts->wridx1;
  97         unsigned char *ptr = ptr0;
  98         unsigned char *totty = ptr;
  99         unsigned char *end = ptr + MIN(BUFSIZE - ts->wridx1, ts->size1);
 100         int num_totty;
 101
 102         while (ptr < end) {
 103                 if (*ptr != IAC) {
 104                         char c = *ptr;
 105
 106                         *totty++ = c;
 107                         ptr++;
 108                         /* We map \r\n ==> \r for pragmatic reasons.
 109                          * Many client implementations send \r\n when
 110                          * the user hits the CarriageReturn key.
 111                          */
 112                         if (c == '\r' && ptr < end && (*ptr == '\n' || *ptr == '\0'))
 113                                 ptr++;
 114                         continue;
 115                 }
 116
 117                 if ((ptr+1) >= end)
 118                         break;
 119                 if (ptr[1] == NOP) { /* Ignore? (putty keepalive, etc.) */
 120                         ptr += 2;
 121                         continue;
 122                 }
 123                 if (ptr[1] == IAC) { /* Literal IAC? (emacs M-DEL) */
 124                         *totty++ = ptr[1];
 125                         ptr += 2;
 126                         continue;
 127                 }
 128
 129                 /*
 130                  * TELOPT_NAWS support!
 131                  */
 132                 if ((ptr+2) >= end) {
 133                         /* Only the beginning of the IAC is in the
 134                         buffer we were asked to process, we can't
 135                         process this char */
 136                         break;
 137                 }
 138                 /*
 139                  * IAC -> SB -> TELOPT_NAWS -> 4-byte -> IAC -> SE
 140                  */
 141                 if (ptr[1] == SB && ptr[2] == TELOPT_NAWS) {
 142                         struct winsize ws;
 143                         if ((ptr+8) >= end)
 144                                 break;  /* incomplete, can't process */
 145                         ws.ws_col = (ptr[3] << 8) | ptr[4];
 146                         ws.ws_row = (ptr[5] << 8) | ptr[6];
 147                         ioctl(ts->ptyfd, TIOCSWINSZ, (char *)&ws);
 148                         ptr += 9;
 149                         continue;
 150                 }
 151                 /* skip 3-byte IAC non-SB cmd */
 152 #if DEBUG
 153                 fprintf(stderr, "Ignoring IAC %s,%s\n",
 154                                 TELCMD(ptr[1]), TELOPT(ptr[2]));
 155 #endif
 156                 ptr += 3;
 157         }
 158
 159         num_totty = totty - ptr0;
 160         *pnum_totty = num_totty;
 161         /* The difference between ptr and totty is number of iacs
 162            we removed from the stream. Adjust buf1 accordingly */
 163         if ((ptr - totty) == 0) /* 99.999% of cases */
 164                 return ptr0;
 165         ts->wridx1 += ptr - totty;
 166         ts->size1 -= ptr - totty;
 167         /* Move chars meant for the terminal towards the end of the buffer */
 168         return memmove(ptr - num_totty, ptr0, num_totty);
 169 }
 170
 171 /*
 172  * Converting single IAC into double on output
 173  */
 174 static size_t iac_safe_write(int fd, const char *buf, size_t count)
 175 {
 176         const char *IACptr;
 177         size_t wr, rc, total;
 178
 179         total = 0;
 180         while (1) {
 181                 if (count == 0)
 182                         return total;
 183                 if (*buf == (char)IAC) {
 184                         static const char IACIAC[] ALIGN1 = { IAC, IAC };
 185                         rc = safe_write(fd, IACIAC, 2);
 186                         if (rc != 2)
 187                                 break;
 188                         buf++;
 189                         total++;
 190                         count--;
 191                         continue;
 192                 }
 193                 /* count != 0, *buf != IAC */
 194                 IACptr = memchr(buf, IAC, count);
 195                 wr = count;
 196                 if (IACptr)
 197                         wr = IACptr - buf;
 198                 rc = safe_write(fd, buf, wr);
 199                 if (rc != wr)
 200                         break;
 201                 buf += rc;
 202                 total += rc;
 203                 count -= rc;
 204         }
 205         /* here: rc - result of last short write */
 206         if ((ssize_t)rc < 0) { /* error? */
 207                 if (total == 0)
 208                         return rc;
 209                 rc = 0;
 210         }
 211         return total + rc;
 212 }
 213
 214 /* Must match getopt32 string */
 215 enum {
 216         OPT_WATCHCHILD = (1 << 2), /* -K */
 217         OPT_INETD      = (1 << 3) * ENABLE_FEATURE_TELNETD_STANDALONE, /* -i */
 218         OPT_PORT       = (1 << 4) * ENABLE_FEATURE_TELNETD_STANDALONE, /* -p PORT */
 219         OPT_FOREGROUND = (1 << 6) * ENABLE_FEATURE_TELNETD_STANDALONE, /* -F */
 220         OPT_SYSLOG     = (1 << 7) * ENABLE_FEATURE_TELNETD_INETD_WAIT, /* -S */
 221         OPT_WAIT       = (1 << 8) * ENABLE_FEATURE_TELNETD_INETD_WAIT, /* -w SEC */
 222 };
 223
 224 static struct tsession *
 225 make_new_session(
 226                 IF_FEATURE_TELNETD_STANDALONE(int sock)
 227                 IF_NOT_FEATURE_TELNETD_STANDALONE(void)
 228 ) {
 229 #if !ENABLE_FEATURE_TELNETD_STANDALONE
 230         enum { sock = 0 };
 231 #endif
 232         const char *login_argv[2];
 233         struct termios termbuf;
 234         int fd, pid;
 235         char tty_name[GETPTY_BUFSIZE];
 236         struct tsession *ts = xzalloc(sizeof(struct tsession) + BUFSIZE * 2);
 237
 238         /*ts->buf1 = (char *)(ts + 1);*/
 239         /*ts->buf2 = ts->buf1 + BUFSIZE;*/
 240
 241         /* Got a new connection, set up a tty */
 242         fd = xgetpty(tty_name);
 243         if (fd > G.maxfd)
 244                 G.maxfd = fd;
 245         ts->ptyfd = fd;
 246         ndelay_on(fd);
 247         close_on_exec_on(fd);
 248
 249         /* SO_KEEPALIVE by popular demand */
 250         setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1));
 251 #if ENABLE_FEATURE_TELNETD_STANDALONE
 252         ts->sockfd_read = sock;
 253         ndelay_on(sock);
 254         if (sock == 0) { /* We are called with fd 0 - we are in inetd mode */
 255                 sock++; /* so use fd 1 for output */
 256                 ndelay_on(sock);
 257         }
 258         ts->sockfd_write = sock;
 259         if (sock > G.maxfd)
 260                 G.maxfd = sock;
 261 #else
 262         /* ts->sockfd_read = 0; - done by xzalloc */
 263         ts->sockfd_write = 1;
 264         ndelay_on(0);
 265         ndelay_on(1);
 266 #endif
 267
 268         /* Make the telnet client understand we will echo characters so it
 269          * should not do it locally. We don't tell the client to run linemode,
 270          * because we want to handle line editing and tab completion and other
 271          * stuff that requires char-by-char support. */
 272         {
 273                 static const char iacs_to_send[] ALIGN1 = {
 274                         IAC, DO, TELOPT_ECHO,
 275                         IAC, DO, TELOPT_NAWS,
 276                         /* This requires telnetd.ctrlSQ.patch (incomplete) */
 277                         /*IAC, DO, TELOPT_LFLOW,*/
 278                         IAC, WILL, TELOPT_ECHO,
 279                         IAC, WILL, TELOPT_SGA
 280                 };
 281                 /* This confuses iac_safe_write(), it will try to duplicate
 282                  * each IAC... */
 283                 //memcpy(TS_BUF2(ts), iacs_to_send, sizeof(iacs_to_send));
 284                 //ts->rdidx2 = sizeof(iacs_to_send);
 285                 //ts->size2 = sizeof(iacs_to_send);
 286                 /* So just stuff it into TCP stream! (no error check...) */
 287 #if ENABLE_FEATURE_TELNETD_STANDALONE
 288                 safe_write(sock, iacs_to_send, sizeof(iacs_to_send));
 289 #else
 290                 safe_write(1, iacs_to_send, sizeof(iacs_to_send));
 291 #endif
 292                 /*ts->rdidx2 = 0; - xzalloc did it */
 293                 /*ts->size2 = 0;*/
 294         }
 295
 296         fflush_all();
 297         pid = vfork(); /* NOMMU-friendly */
 298         if (pid < 0) {
 299                 free(ts);
 300                 close(fd);
 301                 /* sock will be closed by caller */
 302                 bb_perror_msg("vfork");
 303                 return NULL;
 304         }
 305         if (pid > 0) {
 306                 /* Parent */
 307                 ts->shell_pid = pid;
 308                 return ts;
 309         }
 310
 311         /* Child */
 312         /* Careful - we are after vfork! */
 313
 314         /* Restore default signal handling ASAP */
 315         bb_signals((1 << SIGCHLD) + (1 << SIGPIPE), SIG_DFL);
 316
 317         pid = getpid();
 318
 319         if (ENABLE_FEATURE_UTMP) {
 320                 len_and_sockaddr *lsa = get_peer_lsa(sock);
 321                 char *hostname = NULL;
 322                 if (lsa) {
 323                         hostname = xmalloc_sockaddr2dotted(&lsa->u.sa);
 324                         free(lsa);
 325                 }
 326                 write_new_utmp(pid, LOGIN_PROCESS, tty_name, /*username:*/ "LOGIN", hostname);
 327                 free(hostname);
 328         }
 329
 330         /* Make new session and process group */
 331         setsid();
 332
 333         /* Open the child's side of the tty */
 334         /* NB: setsid() disconnects from any previous ctty's. Therefore
 335          * we must open child's side of the tty AFTER setsid! */
 336         close(0);
 337         xopen(tty_name, O_RDWR); /* becomes our ctty */
 338         xdup2(0, 1);
 339         xdup2(0, 2);
 340         tcsetpgrp(0, pid); /* switch this tty's process group to us */
 341
 342         /* The pseudo-terminal allocated to the client is configured to operate
 343          * in cooked mode, and with XTABS CRMOD enabled (see tty(4)) */
 344         tcgetattr(0, &termbuf);
 345         termbuf.c_lflag |= ECHO; /* if we use readline we dont want this */
 346         termbuf.c_oflag |= ONLCR | XTABS;
 347         termbuf.c_iflag |= ICRNL;
 348         termbuf.c_iflag &= ~IXOFF;
 349         /*termbuf.c_lflag &= ~ICANON;*/
 350         tcsetattr_stdin_TCSANOW(&termbuf);
 351
 352         /* Uses FILE-based I/O to stdout, but does fflush_all(),
 353          * so should be safe with vfork.
 354          * I fear, though, that some users will have ridiculously big
 355          * issue files, and they may block writing to fd 1,
 356          * (parent is supposed to read it, but parent waits
 357          * for vforked child to exec!) */
 358         print_login_issue(G.issuefile, tty_name);
 359
 360         /* Exec shell / login / whatever */
 361         login_argv[0] = G.loginpath;
 362         login_argv[1] = NULL;
 363         /* exec busybox applet (if PREFER_APPLETS=y), if that fails,
 364          * exec external program.
 365          * NB: sock is either 0 or has CLOEXEC set on it.
 366          * fd has CLOEXEC set on it too. These two fds will be closed here.
 367          */
 368         BB_EXECVP(G.loginpath, (char **)login_argv);
 369         /* _exit is safer with vfork, and we shouldn't send message
 370          * to remote clients anyway */
 371         _exit(EXIT_FAILURE); /*bb_perror_msg_and_die("execv %s", G.loginpath);*/
 372 }
 373
 374 #if ENABLE_FEATURE_TELNETD_STANDALONE
 375
 376 static void
 377 free_session(struct tsession *ts)
 378 {
 379         struct tsession *t;
 380
 381         if (option_mask32 & OPT_INETD)
 382                 exit(EXIT_SUCCESS);
 383
 384         /* Unlink this telnet session from the session list */
 385         t = G.sessions;
 386         if (t == ts)
 387                 G.sessions = ts->next;
 388         else {
 389                 while (t->next != ts)
 390                         t = t->next;
 391                 t->next = ts->next;
 392         }
 393
 394 #if 0
 395         /* It was said that "normal" telnetd just closes ptyfd,
 396          * doesn't send SIGKILL. When we close ptyfd,
 397          * kernel sends SIGHUP to processes having slave side opened. */
 398         kill(ts->shell_pid, SIGKILL);
 399         waitpid(ts->shell_pid, NULL, 0);
 400 #endif
 401         close(ts->ptyfd);
 402         close(ts->sockfd_read);
 403         /* We do not need to close(ts->sockfd_write), it's the same
 404          * as sockfd_read unless we are in inetd mode. But in inetd mode
 405          * we do not reach this */
 406         free(ts);
 407
 408         /* Scan all sessions and find new maxfd */
 409         G.maxfd = 0;
 410         ts = G.sessions;
 411         while (ts) {
 412                 if (G.maxfd < ts->ptyfd)
 413                         G.maxfd = ts->ptyfd;
 414                 if (G.maxfd < ts->sockfd_read)
 415                         G.maxfd = ts->sockfd_read;
 416 #if 0
 417                 /* Again, sockfd_write == sockfd_read here */
 418                 if (G.maxfd < ts->sockfd_write)
 419                         G.maxfd = ts->sockfd_write;
 420 #endif
 421                 ts = ts->next;
 422         }
 423 }
 424
 425 #else /* !FEATURE_TELNETD_STANDALONE */
 426
 427 /* Used in main() only, thus "return 0" actually is exit(EXIT_SUCCESS). */
 428 #define free_session(ts) return 0
 429
 430 #endif
 431
 432 static void handle_sigchld(int sig UNUSED_PARAM)
 433 {
 434         pid_t pid;
 435         struct tsession *ts;
 436         int save_errno = errno;
 437
 438         /* Looping: more than one child may have exited */
 439         while (1) {
 440                 pid = wait_any_nohang(NULL);
 441                 if (pid <= 0)
 442                         break;
 443                 ts = G.sessions;
 444                 while (ts) {
 445                         if (ts->shell_pid == pid) {
 446                                 ts->shell_pid = -1;
 447 // man utmp:
 448 // When init(8) finds that a process has exited, it locates its utmp entry
 449 // by ut_pid, sets ut_type to DEAD_PROCESS, and clears ut_user, ut_host
 450 // and ut_time with null bytes.
 451 // [same applies to other processes which maintain utmp entries, like telnetd]
 452 //
 453 // We do not bother actually clearing fields:
 454 // it might be interesting to know who was logged in and from where
 455                                 update_utmp(pid, DEAD_PROCESS, /*tty_name:*/ NULL, /*username:*/ NULL, /*hostname:*/ NULL);
 456                                 break;
 457                         }
 458                         ts = ts->next;
 459                 }
 460         }
 461
 462         errno = save_errno;
 463 }
 464
 465 int telnetd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 466 int telnetd_main(int argc UNUSED_PARAM, char **argv)
 467 {
 468         fd_set rdfdset, wrfdset;
 469         unsigned opt;
 470         int count;
 471         struct tsession *ts;
 472 #if ENABLE_FEATURE_TELNETD_STANDALONE
 473 #define IS_INETD (opt & OPT_INETD)
 474         int master_fd = master_fd; /* for compiler */
 475         int sec_linger = sec_linger;
 476         char *opt_bindaddr = NULL;
 477         char *opt_portnbr;
 478 #else
 479         enum {
 480                 IS_INETD = 1,
 481                 master_fd = -1,
 482         };
 483 #endif
 484         INIT_G();
 485
 486         /* -w NUM, and implies -F. -w and -i don't mix */
 487         IF_FEATURE_TELNETD_INETD_WAIT(opt_complementary = "wF:w+:i--w:w--i";)
 488         /* Even if !STANDALONE, we accept (and ignore) -i, thus people
 489          * don't need to guess whether it's ok to pass -i to us */
 490         opt = getopt32(argv, "f:l:Ki"
 491                         IF_FEATURE_TELNETD_STANDALONE("p:b:F")
 492                         IF_FEATURE_TELNETD_INETD_WAIT("Sw:"),
 493                         &G.issuefile, &G.loginpath
 494                         IF_FEATURE_TELNETD_STANDALONE(, &opt_portnbr, &opt_bindaddr)
 495                         IF_FEATURE_TELNETD_INETD_WAIT(, &sec_linger)
 496         );
 497         if (!IS_INETD /*&& !re_execed*/) {
 498                 /* inform that we start in standalone mode?
 499                  * May be useful when people forget to give -i */
 500                 /*bb_error_msg("listening for connections");*/
 501                 if (!(opt & OPT_FOREGROUND)) {
 502                         /* DAEMON_CHDIR_ROOT was giving inconsistent
 503                          * behavior with/without -F, -i */
 504                         bb_daemonize_or_rexec(0 /*was DAEMON_CHDIR_ROOT*/, argv);
 505                 }
 506         }
 507         /* Redirect log to syslog early, if needed */
 508         if (IS_INETD || (opt & OPT_SYSLOG) || !(opt & OPT_FOREGROUND)) {
 509                 openlog(applet_name, LOG_PID, LOG_DAEMON);
 510                 logmode = LOGMODE_SYSLOG;
 511         }
 512 #if ENABLE_FEATURE_TELNETD_STANDALONE
 513         if (IS_INETD) {
 514                 G.sessions = make_new_session(0);
 515                 if (!G.sessions) /* pty opening or vfork problem, exit */
 516                         return 1; /* make_new_session printed error message */
 517         } else {
 518                 master_fd = 0;
 519                 if (!(opt & OPT_WAIT)) {
 520                         unsigned portnbr = 23;
 521                         if (opt & OPT_PORT)
 522                                 portnbr = xatou16(opt_portnbr);
 523                         master_fd = create_and_bind_stream_or_die(opt_bindaddr, portnbr);
 524                         xlisten(master_fd, 1);
 525                 }
 526                 close_on_exec_on(master_fd);
 527         }
 528 #else
 529         G.sessions = make_new_session();
 530         if (!G.sessions) /* pty opening or vfork problem, exit */
 531                 return 1; /* make_new_session printed error message */
 532 #endif
 533
 534         /* We don't want to die if just one session is broken */
 535         signal(SIGPIPE, SIG_IGN);
 536
 537         if (opt & OPT_WATCHCHILD)
 538                 signal(SIGCHLD, handle_sigchld);
 539         else /* prevent dead children from becoming zombies */
 540                 signal(SIGCHLD, SIG_IGN);
 541
 542 /*
 543    This is how the buffers are used. The arrows indicate data flow.
 544
 545    +-------+     wridx1++     +------+     rdidx1++     +----------+
 546    |       | <--------------  | buf1 | <--------------  |          |
 547    |       |     size1--      +------+     size1++      |          |
 548    |  pty  |                                            |  socket  |
 549    |       |     rdidx2++     +------+     wridx2++     |          |
 550    |       |  --------------> | buf2 |  --------------> |          |
 551    +-------+     size2++      +------+     size2--      +----------+
 552
 553    size1: "how many bytes are buffered for pty between rdidx1 and wridx1?"
 554    size2: "how many bytes are buffered for socket between rdidx2 and wridx2?"
 555
 556    Each session has got two buffers. Buffers are circular. If sizeN == 0,
 557    buffer is empty. If sizeN == BUFSIZE, buffer is full. In both these cases
 558    rdidxN == wridxN.
 559 */
 560  again:
 561         FD_ZERO(&rdfdset);
 562         FD_ZERO(&wrfdset);
 563
 564         /* Select on the master socket, all telnet sockets and their
 565          * ptys if there is room in their session buffers.
 566          * NB: scalability problem: we recalculate entire bitmap
 567          * before each select. Can be a problem with 500+ connections. */
 568         ts = G.sessions;
 569         while (ts) {
 570                 struct tsession *next = ts->next; /* in case we free ts */
 571                 if (ts->shell_pid == -1) {
 572                         /* Child died and we detected that */
 573                         free_session(ts);
 574                 } else {
 575                         if (ts->size1 > 0)       /* can write to pty */
 576                                 FD_SET(ts->ptyfd, &wrfdset);
 577                         if (ts->size1 < BUFSIZE) /* can read from socket */
 578                                 FD_SET(ts->sockfd_read, &rdfdset);
 579                         if (ts->size2 > 0)       /* can write to socket */
 580                                 FD_SET(ts->sockfd_write, &wrfdset);
 581                         if (ts->size2 < BUFSIZE) /* can read from pty */
 582                                 FD_SET(ts->ptyfd, &rdfdset);
 583                 }
 584                 ts = next;
 585         }
 586         if (!IS_INETD) {
 587                 FD_SET(master_fd, &rdfdset);
 588                 /* This is needed because free_session() does not
 589                  * take master_fd into account when it finds new
 590                  * maxfd among remaining fd's */
 591                 if (master_fd > G.maxfd)
 592                         G.maxfd = master_fd;
 593         }
 594
 595         {
 596                 struct timeval *tv_ptr = NULL;
 597 #if ENABLE_FEATURE_TELNETD_INETD_WAIT
 598                 struct timeval tv;
 599                 if ((opt & OPT_WAIT) && !G.sessions) {
 600                         tv.tv_sec = sec_linger;
 601                         tv.tv_usec = 0;
 602                         tv_ptr = &tv;
 603                 }
 604 #endif
 605                 count = select(G.maxfd + 1, &rdfdset, &wrfdset, NULL, tv_ptr);
 606         }
 607         if (count == 0) /* "telnetd -w SEC" timed out */
 608                 return 0;
 609         if (count < 0)
 610                 goto again; /* EINTR or ENOMEM */
 611
 612 #if ENABLE_FEATURE_TELNETD_STANDALONE
 613         /* Check for and accept new sessions */
 614         if (!IS_INETD && FD_ISSET(master_fd, &rdfdset)) {
 615                 int fd;
 616                 struct tsession *new_ts;
 617
 618                 fd = accept(master_fd, NULL, NULL);
 619                 if (fd < 0)
 620                         goto again;
 621                 close_on_exec_on(fd);
 622
 623                 /* Create a new session and link it into active list */
 624                 new_ts = make_new_session(fd);
 625                 if (new_ts) {
 626                         new_ts->next = G.sessions;
 627                         G.sessions = new_ts;
 628                 } else {
 629                         close(fd);
 630                 }
 631         }
 632 #endif
 633
 634         /* Then check for data tunneling */
 635         ts = G.sessions;
 636         while (ts) { /* For all sessions... */
 637                 struct tsession *next = ts->next; /* in case we free ts */
 638
 639                 if (/*ts->size1 &&*/ FD_ISSET(ts->ptyfd, &wrfdset)) {
 640                         int num_totty;
 641                         unsigned char *ptr;
 642                         /* Write to pty from buffer 1 */
 643                         ptr = remove_iacs(ts, &num_totty);
 644                         count = safe_write(ts->ptyfd, ptr, num_totty);
 645                         if (count < 0) {
 646                                 if (errno == EAGAIN)
 647                                         goto skip1;
 648                                 goto kill_session;
 649                         }
 650                         ts->size1 -= count;
 651                         ts->wridx1 += count;
 652                         if (ts->wridx1 >= BUFSIZE) /* actually == BUFSIZE */
 653                                 ts->wridx1 = 0;
 654                 }
 655  skip1:
 656                 if (/*ts->size2 &&*/ FD_ISSET(ts->sockfd_write, &wrfdset)) {
 657                         /* Write to socket from buffer 2 */
 658                         count = MIN(BUFSIZE - ts->wridx2, ts->size2);
 659                         count = iac_safe_write(ts->sockfd_write, (void*)(TS_BUF2(ts) + ts->wridx2), count);
 660                         if (count < 0) {
 661                                 if (errno == EAGAIN)
 662                                         goto skip2;
 663                                 goto kill_session;
 664                         }
 665                         ts->size2 -= count;
 666                         ts->wridx2 += count;
 667                         if (ts->wridx2 >= BUFSIZE) /* actually == BUFSIZE */
 668                                 ts->wridx2 = 0;
 669                 }
 670  skip2:
 671                 /* Should not be needed, but... remove_iacs is actually buggy
 672                  * (it cannot process iacs which wrap around buffer's end)!
 673                  * Since properly fixing it requires writing bigger code,
 674                  * we rely instead on this code making it virtually impossible
 675                  * to have wrapped iac (people don't type at 2k/second).
 676                  * It also allows for bigger reads in common case. */
 677                 if (ts->size1 == 0) {
 678                         ts->rdidx1 = 0;
 679                         ts->wridx1 = 0;
 680                 }
 681                 if (ts->size2 == 0) {
 682                         ts->rdidx2 = 0;
 683                         ts->wridx2 = 0;
 684                 }
 685
 686                 if (/*ts->size1 < BUFSIZE &&*/ FD_ISSET(ts->sockfd_read, &rdfdset)) {
 687                         /* Read from socket to buffer 1 */
 688                         count = MIN(BUFSIZE - ts->rdidx1, BUFSIZE - ts->size1);
 689                         count = safe_read(ts->sockfd_read, TS_BUF1(ts) + ts->rdidx1, count);
 690                         if (count <= 0) {
 691                                 if (count < 0 && errno == EAGAIN)
 692                                         goto skip3;
 693                                 goto kill_session;
 694                         }
 695                         /* Ignore trailing NUL if it is there */
 696                         if (!TS_BUF1(ts)[ts->rdidx1 + count - 1]) {
 697                                 --count;
 698                         }
 699                         ts->size1 += count;
 700                         ts->rdidx1 += count;
 701                         if (ts->rdidx1 >= BUFSIZE) /* actually == BUFSIZE */
 702                                 ts->rdidx1 = 0;
 703                 }
 704  skip3:
 705                 if (/*ts->size2 < BUFSIZE &&*/ FD_ISSET(ts->ptyfd, &rdfdset)) {
 706                         /* Read from pty to buffer 2 */
 707                         count = MIN(BUFSIZE - ts->rdidx2, BUFSIZE - ts->size2);
 708                         count = safe_read(ts->ptyfd, TS_BUF2(ts) + ts->rdidx2, count);
 709                         if (count <= 0) {
 710                                 if (count < 0 && errno == EAGAIN)
 711                                         goto skip4;
 712                                 goto kill_session;
 713                         }
 714                         ts->size2 += count;
 715                         ts->rdidx2 += count;
 716                         if (ts->rdidx2 >= BUFSIZE) /* actually == BUFSIZE */
 717                                 ts->rdidx2 = 0;
 718                 }
 719  skip4:
 720                 ts = next;
 721                 continue;
 722  kill_session:
 723                 if (ts->shell_pid > 0)
 724                         update_utmp(ts->shell_pid, DEAD_PROCESS, /*tty_name:*/ NULL, /*username:*/ NULL, /*hostname:*/ NULL);
 725                 free_session(ts);
 726                 ts = next;
 727         }
 728
 729         goto again;
 730 }