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 tarball for details.
   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
  24 /*#define DEBUG 1 */
  25 #define DEBUG 0
  26
  27 #include "busybox.h"
  28
  29 #if DEBUG
  30 #define TELCMDS
  31 #define TELOPTS
  32 #endif
  33 #include <arpa/telnet.h>
  34 #include <sys/syslog.h>
  35
  36
  37 #define BUFSIZE 4000
  38
  39 #if ENABLE_LOGIN
  40 static const char *loginpath = "/bin/login";
  41 #else
  42 static const char *loginpath = DEFAULT_SHELL;
  43 #endif
  44
  45 static const char *issuefile = "/etc/issue.net";
  46
  47 /* shell name and arguments */
  48
  49 static const char *argv_init[2];
  50
  51 /* structure that describes a session */
  52
  53 struct tsession {
  54         struct tsession *next;
  55         int sockfd_read, sockfd_write, ptyfd;
  56         int shell_pid;
  57         /* two circular buffers */
  58         char *buf1, *buf2;
  59         int rdidx1, wridx1, size1;
  60         int rdidx2, wridx2, size2;
  61 };
  62
  63 /*
  64    This is how the buffers are used. The arrows indicate the movement
  65    of data.
  66
  67    +-------+     wridx1++     +------+     rdidx1++     +----------+
  68    |       | <--------------  | buf1 | <--------------  |          |
  69    |       |     size1--      +------+     size1++      |          |
  70    |  pty  |                                            |  socket  |
  71    |       |     rdidx2++     +------+     wridx2++     |          |
  72    |       |  --------------> | buf2 |  --------------> |          |
  73    +-------+     size2++      +------+     size2--      +----------+
  74
  75    Each session has got two buffers.
  76 */
  77
  78 static int maxfd;
  79
  80 static struct tsession *sessions;
  81
  82
  83 /*
  84    Remove all IAC's from the buffer pointed to by bf (received IACs are ignored
  85    and must be removed so as to not be interpreted by the terminal).  Make an
  86    uninterrupted string of characters fit for the terminal.  Do this by packing
  87    all characters meant for the terminal sequentially towards the end of bf.
  88
  89    Return a pointer to the beginning of the characters meant for the terminal.
  90    and make *num_totty the number of characters that should be sent to
  91    the terminal.
  92
  93    Note - If an IAC (3 byte quantity) starts before (bf + len) but extends
  94    past (bf + len) then that IAC will be left unprocessed and *processed will be
  95    less than len.
  96
  97    FIXME - if we mean to send 0xFF to the terminal then it will be escaped,
  98    what is the escape character?  We aren't handling that situation here.
  99
 100    CR-LF ->'s CR mapping is also done here, for convenience
 101  */
 102 static char *
 103 remove_iacs(struct tsession *ts, int *pnum_totty)
 104 {
 105         unsigned char *ptr0 = (unsigned char *)ts->buf1 + ts->wridx1;
 106         unsigned char *ptr = ptr0;
 107         unsigned char *totty = ptr;
 108         unsigned char *end = ptr + MIN(BUFSIZE - ts->wridx1, ts->size1);
 109         int processed;
 110         int num_totty;
 111
 112         while (ptr < end) {
 113                 if (*ptr != IAC) {
 114                         int c = *ptr;
 115                         *totty++ = *ptr++;
 116                         /* We now map \r\n ==> \r for pragmatic reasons.
 117                          * Many client implementations send \r\n when
 118                          * the user hits the CarriageReturn key.
 119                          */
 120                         if (c == '\r' && (*ptr == '\n' || *ptr == 0) && ptr < end)
 121                                 ptr++;
 122                 } else {
 123                         /*
 124                          * TELOPT_NAWS support!
 125                          */
 126                         if ((ptr+2) >= end) {
 127                                 /* only the beginning of the IAC is in the
 128                                 buffer we were asked to process, we can't
 129                                 process this char. */
 130                                 break;
 131                         }
 132
 133                         /*
 134                          * IAC -> SB -> TELOPT_NAWS -> 4-byte -> IAC -> SE
 135                          */
 136                         else if (ptr[1] == SB && ptr[2] == TELOPT_NAWS) {
 137                                 struct winsize ws;
 138                                 if ((ptr+8) >= end)
 139                                         break;  /* incomplete, can't process */
 140                                 ws.ws_col = (ptr[3] << 8) | ptr[4];
 141                                 ws.ws_row = (ptr[5] << 8) | ptr[6];
 142                                 ioctl(ts->ptyfd, TIOCSWINSZ, (char *)&ws);
 143                                 ptr += 9;
 144                         } else {
 145                                 /* skip 3-byte IAC non-SB cmd */
 146 #if DEBUG
 147                                 fprintf(stderr, "Ignoring IAC %s,%s\n",
 148                                         TELCMD(ptr[1]), TELOPT(ptr[2]));
 149 #endif
 150                                 ptr += 3;
 151                         }
 152                 }
 153         }
 154
 155         processed = ptr - ptr0;
 156         num_totty = totty - ptr0;
 157         /* the difference between processed and num_to tty
 158            is all the iacs we removed from the stream.
 159            Adjust buf1 accordingly. */
 160         ts->wridx1 += processed - num_totty;
 161         ts->size1 -= processed - num_totty;
 162         *pnum_totty = num_totty;
 163         /* move the chars meant for the terminal towards the end of the
 164         buffer. */
 165         return memmove(ptr - num_totty, ptr0, num_totty);
 166 }
 167
 168
 169 static int
 170 getpty(char *line, int size)
 171 {
 172         int p;
 173 #if ENABLE_FEATURE_DEVPTS
 174         p = open("/dev/ptmx", O_RDWR);
 175         if (p > 0) {
 176                 const char *name;
 177                 grantpt(p);
 178                 unlockpt(p);
 179                 name = ptsname(p);
 180                 if (!name) {
 181                         bb_perror_msg("ptsname error (is /dev/pts mounted?)");
 182                         return -1;
 183                 }
 184                 safe_strncpy(line, name, size);
 185                 return p;
 186         }
 187 #else
 188         struct stat stb;
 189         int i;
 190         int j;
 191
 192         strcpy(line, "/dev/ptyXX");
 193
 194         for (i = 0; i < 16; i++) {
 195                 line[8] = "pqrstuvwxyzabcde"[i];
 196                 line[9] = '0';
 197                 if (stat(line, &stb) < 0) {
 198                         continue;
 199                 }
 200                 for (j = 0; j < 16; j++) {
 201                         line[9] = j < 10 ? j + '0' : j - 10 + 'a';
 202                         if (DEBUG)
 203                                 fprintf(stderr, "Trying to open device: %s\n", line);
 204                         p = open(line, O_RDWR | O_NOCTTY);
 205                         if (p >= 0) {
 206                                 line[5] = 't';
 207                                 return p;
 208                         }
 209                 }
 210         }
 211 #endif /* FEATURE_DEVPTS */
 212         return -1;
 213 }
 214
 215
 216 static void
 217 send_iac(struct tsession *ts, unsigned char command, int option)
 218 {
 219         /* We rely on that there is space in the buffer for now. */
 220         char *b = ts->buf2 + ts->rdidx2;
 221         *b++ = IAC;
 222         *b++ = command;
 223         *b++ = option;
 224         ts->rdidx2 += 3;
 225         ts->size2 += 3;
 226 }
 227
 228
 229 static struct tsession *
 230 make_new_session(
 231                 USE_FEATURE_TELNETD_STANDALONE(int sock_r, int sock_w)
 232                 SKIP_FEATURE_TELNETD_STANDALONE(void)
 233 ) {
 234         struct termios termbuf;
 235         int fd, pid;
 236         char tty_name[32];
 237         struct tsession *ts = xzalloc(sizeof(struct tsession) + BUFSIZE * 2);
 238
 239         ts->buf1 = (char *)(&ts[1]);
 240         ts->buf2 = ts->buf1 + BUFSIZE;
 241
 242         /* Got a new connection, set up a tty. */
 243         fd = getpty(tty_name, 32);
 244         if (fd < 0) {
 245                 bb_error_msg("all terminals in use");
 246                 return NULL;
 247         }
 248         if (fd > maxfd) maxfd = fd;
 249         ndelay_on(ts->ptyfd = fd);
 250 #if ENABLE_FEATURE_TELNETD_STANDALONE
 251         if (sock_w > maxfd) maxfd = sock_w;
 252         if (sock_r > maxfd) maxfd = sock_r;
 253         ndelay_on(ts->sockfd_write = sock_w);
 254         ndelay_on(ts->sockfd_read = sock_r);
 255 #else
 256         ts->sockfd_write = 1;
 257         /* xzalloc: ts->sockfd_read = 0; */
 258         ndelay_on(0);
 259         ndelay_on(1);
 260 #endif
 261         /* Make the telnet client understand we will echo characters so it
 262          * should not do it locally. We don't tell the client to run linemode,
 263          * because we want to handle line editing and tab completion and other
 264          * stuff that requires char-by-char support. */
 265         send_iac(ts, DO, TELOPT_ECHO);
 266         send_iac(ts, DO, TELOPT_NAWS);
 267         send_iac(ts, DO, TELOPT_LFLOW);
 268         send_iac(ts, WILL, TELOPT_ECHO);
 269         send_iac(ts, WILL, TELOPT_SGA);
 270
 271         pid = fork();
 272         if (pid < 0) {
 273                 free(ts);
 274                 close(fd);
 275                 bb_perror_msg("fork");
 276                 return NULL;
 277         }
 278         if (pid > 0) {
 279                 /* parent */
 280                 ts->shell_pid = pid;
 281                 return ts;
 282         }
 283
 284         /* child */
 285
 286         /* open the child's side of the tty. */
 287         fd = xopen(tty_name, O_RDWR /*| O_NOCTTY*/);
 288         dup2(fd, 0);
 289         dup2(fd, 1);
 290         dup2(fd, 2);
 291         while (fd > 2) close(fd--);
 292         /* make new process group */
 293         setsid();
 294         tcsetpgrp(0, getpid());
 295
 296         /* The pseudo-terminal allocated to the client is configured to operate in
 297          * cooked mode, and with XTABS CRMOD enabled (see tty(4)). */
 298         tcgetattr(0, &termbuf);
 299         termbuf.c_lflag |= ECHO; /* if we use readline we dont want this */
 300         termbuf.c_oflag |= ONLCR|XTABS;
 301         termbuf.c_iflag |= ICRNL;
 302         termbuf.c_iflag &= ~IXOFF;
 303         /*termbuf.c_lflag &= ~ICANON;*/
 304         tcsetattr(0, TCSANOW, &termbuf);
 305
 306         print_login_issue(issuefile, NULL);
 307
 308         /* exec shell, with correct argv and env */
 309         execv(loginpath, (char *const *)argv_init);
 310         bb_perror_msg_and_die("execv");
 311 }
 312
 313 #if ENABLE_FEATURE_TELNETD_STANDALONE
 314
 315 static void
 316 free_session(struct tsession *ts)
 317 {
 318         struct tsession *t = sessions;
 319
 320         /* unlink this telnet session from the session list */
 321         if (t == ts)
 322                 sessions = ts->next;
 323         else {
 324                 while (t->next != ts)
 325                         t = t->next;
 326                 t->next = ts->next;
 327         }
 328
 329         kill(ts->shell_pid, SIGKILL);
 330         wait4(ts->shell_pid, NULL, 0, NULL);
 331         close(ts->ptyfd);
 332         close(ts->sockfd_read);
 333         /* error if ts->sockfd_read == ts->sockfd_write. So what? ;) */
 334         close(ts->sockfd_write);
 335         free(ts);
 336
 337         /* scan all sessions and find new maxfd */
 338         ts = sessions;
 339         maxfd = 0;
 340         while (ts) {
 341                 if (maxfd < ts->ptyfd)
 342                         maxfd = ts->ptyfd;
 343                 if (maxfd < ts->sockfd_read)
 344                         maxfd = ts->sockfd_read;
 345                 if (maxfd < ts->sockfd_write)
 346                         maxfd = ts->sockfd_write;
 347                 ts = ts->next;
 348         }
 349 }
 350
 351 #else /* !FEATURE_TELNETD_STANDALONE */
 352
 353 /* Never actually called */
 354 void free_session(struct tsession *ts);
 355
 356 #endif
 357
 358
 359 int
 360 telnetd_main(int argc, char **argv)
 361 {
 362         fd_set rdfdset, wrfdset;
 363         unsigned opt;
 364         int selret, maxlen, w, r;
 365         struct tsession *ts;
 366 #if ENABLE_FEATURE_TELNETD_STANDALONE
 367 #define IS_INETD (opt & OPT_INETD)
 368         int master_fd = -1; /* be happy, gcc */
 369         unsigned portnbr = 23;
 370         char *opt_bindaddr = NULL;
 371         char *opt_portnbr;
 372 #else
 373         enum {
 374                 IS_INETD = 1,
 375                 master_fd = -1,
 376                 portnbr = 23,
 377         };
 378 #endif
 379         enum {
 380                 OPT_PORT = 4 * ENABLE_FEATURE_TELNETD_STANDALONE,
 381                 OPT_FOREGROUND = 0x10 * ENABLE_FEATURE_TELNETD_STANDALONE,
 382                 OPT_INETD = 0x20 * ENABLE_FEATURE_TELNETD_STANDALONE,
 383         };
 384
 385         opt = getopt32(argc, argv, "f:l:" USE_FEATURE_TELNETD_STANDALONE("p:b:Fi"),
 386                         &issuefile, &loginpath
 387                         USE_FEATURE_TELNETD_STANDALONE(, &opt_portnbr, &opt_bindaddr));
 388         /* Redirect log to syslog early, if needed */
 389         if (IS_INETD || !(opt & OPT_FOREGROUND)) {
 390                 openlog(applet_name, 0, LOG_USER);
 391                 logmode = LOGMODE_SYSLOG;
 392         }
 393         //if (opt & 1) // -f
 394         //if (opt & 2) // -l
 395         USE_FEATURE_TELNETD_STANDALONE(
 396                 if (opt & OPT_PORT) // -p
 397                         portnbr = xatou16(opt_portnbr);
 398                 //if (opt & 8) // -b
 399                 //if (opt & 0x10) // -F
 400                 //if (opt & 0x20) // -i
 401         );
 402
 403         /* Used to check access(loginpath, X_OK) here. Pointless.
 404          * exec will do this for us for free later. */
 405         argv_init[0] = loginpath;
 406
 407 #if ENABLE_FEATURE_TELNETD_STANDALONE
 408         if (IS_INETD) {
 409                 sessions = make_new_session(0, 1);
 410         } else {
 411                 master_fd = create_and_bind_stream_or_die(opt_bindaddr, portnbr);
 412                 xlisten(master_fd, 1);
 413                 if (!(opt & OPT_FOREGROUND))
 414                         xdaemon(0, 0);
 415         }
 416 #else
 417         sessions = make_new_session();
 418 #endif
 419
 420         /* We don't want to die if just one session is broken */
 421         signal(SIGPIPE, SIG_IGN);
 422
 423  again:
 424         FD_ZERO(&rdfdset);
 425         FD_ZERO(&wrfdset);
 426         if (!IS_INETD) {
 427                 FD_SET(master_fd, &rdfdset);
 428                 /* This is needed because free_session() does not
 429                  * take into account master_fd when it finds new
 430                  * maxfd among remaining fd's: */
 431                 if (master_fd > maxfd)
 432                         maxfd = master_fd;
 433         }
 434
 435         /* select on the master socket, all telnet sockets and their
 436          * ptys if there is room in their session buffers. */
 437         ts = sessions;
 438         while (ts) {
 439                 /* buf1 is used from socket to pty
 440                  * buf2 is used from pty to socket */
 441                 if (ts->size1 > 0)       /* can write to pty */
 442                         FD_SET(ts->ptyfd, &wrfdset);
 443                 if (ts->size1 < BUFSIZE) /* can read from socket */
 444                         FD_SET(ts->sockfd_read, &rdfdset);
 445                 if (ts->size2 > 0)       /* can write to socket */
 446                         FD_SET(ts->sockfd_write, &wrfdset);
 447                 if (ts->size2 < BUFSIZE) /* can read from pty */
 448                         FD_SET(ts->ptyfd, &rdfdset);
 449                 ts = ts->next;
 450         }
 451
 452         selret = select(maxfd + 1, &rdfdset, &wrfdset, 0, 0);
 453         if (!selret)
 454                 return 0;
 455
 456 #if ENABLE_FEATURE_TELNETD_STANDALONE
 457         /* First check for and accept new sessions. */
 458         if (!IS_INETD && FD_ISSET(master_fd, &rdfdset)) {
 459                 int fd;
 460                 struct tsession *new_ts;
 461
 462                 fd = accept(master_fd, NULL, 0);
 463                 if (fd < 0)
 464                         goto again;
 465                 /* Create a new session and link it into our active list */
 466                 new_ts = make_new_session(fd, fd);
 467                 if (new_ts) {
 468                         new_ts->next = sessions;
 469                         sessions = new_ts;
 470                 } else {
 471                         close(fd);
 472                 }
 473         }
 474 #endif
 475
 476         /* Then check for data tunneling. */
 477         ts = sessions;
 478         while (ts) { /* For all sessions... */
 479                 struct tsession *next = ts->next; /* in case we free ts. */
 480
 481                 if (ts->size1 && FD_ISSET(ts->ptyfd, &wrfdset)) {
 482                         int num_totty;
 483                         char *ptr;
 484                         /* Write to pty from buffer 1. */
 485                         ptr = remove_iacs(ts, &num_totty);
 486                         w = safe_write(ts->ptyfd, ptr, num_totty);
 487                         /* needed? if (w < 0 && errno == EAGAIN) continue; */
 488                         if (w < 0) {
 489                                 if (IS_INETD)
 490                                         return 0;
 491                                 free_session(ts);
 492                                 ts = next;
 493                                 continue;
 494                         }
 495                         ts->wridx1 += w;
 496                         ts->size1 -= w;
 497                         if (ts->wridx1 == BUFSIZE)
 498                                 ts->wridx1 = 0;
 499                 }
 500
 501                 if (ts->size2 && FD_ISSET(ts->sockfd_write, &wrfdset)) {
 502                         /* Write to socket from buffer 2. */
 503                         maxlen = MIN(BUFSIZE - ts->wridx2, ts->size2);
 504                         w = safe_write(ts->sockfd_write, ts->buf2 + ts->wridx2, maxlen);
 505                         /* needed? if (w < 0 && errno == EAGAIN) continue; */
 506                         if (w < 0) {
 507                                 if (IS_INETD)
 508                                         return 0;
 509                                 free_session(ts);
 510                                 ts = next;
 511                                 continue;
 512                         }
 513                         ts->wridx2 += w;
 514                         ts->size2 -= w;
 515                         if (ts->wridx2 == BUFSIZE)
 516                                 ts->wridx2 = 0;
 517                 }
 518
 519                 if (ts->size1 < BUFSIZE && FD_ISSET(ts->sockfd_read, &rdfdset)) {
 520                         /* Read from socket to buffer 1. */
 521                         maxlen = MIN(BUFSIZE - ts->rdidx1, BUFSIZE - ts->size1);
 522                         r = safe_read(ts->sockfd_read, ts->buf1 + ts->rdidx1, maxlen);
 523                         if (r < 0 && errno == EAGAIN) continue;
 524                         if (r <= 0) {
 525                                 if (IS_INETD)
 526                                         return 0;
 527                                 free_session(ts);
 528                                 ts = next;
 529                                 continue;
 530                         }
 531                         if (!ts->buf1[ts->rdidx1 + r - 1])
 532                                 if (!--r)
 533                                         continue;
 534                         ts->rdidx1 += r;
 535                         ts->size1 += r;
 536                         if (ts->rdidx1 == BUFSIZE)
 537                                 ts->rdidx1 = 0;
 538                 }
 539
 540                 if (ts->size2 < BUFSIZE && FD_ISSET(ts->ptyfd, &rdfdset)) {
 541                         /* Read from pty to buffer 2. */
 542                         maxlen = MIN(BUFSIZE - ts->rdidx2, BUFSIZE - ts->size2);
 543                         r = safe_read(ts->ptyfd, ts->buf2 + ts->rdidx2, maxlen);
 544                         if (r < 0 && errno == EAGAIN) continue;
 545                         if (r <= 0) {
 546                                 if (IS_INETD)
 547                                         return 0;
 548                                 free_session(ts);
 549                                 ts = next;
 550                                 continue;
 551                         }
 552                         ts->rdidx2 += r;
 553                         ts->size2 += r;
 554                         if (ts->rdidx2 == BUFSIZE)
 555                                 ts->rdidx2 = 0;
 556                 }
 557
 558                 if (ts->size1 == 0) {
 559                         ts->rdidx1 = 0;
 560                         ts->wridx1 = 0;
 561                 }
 562                 if (ts->size2 == 0) {
 563                         ts->rdidx2 = 0;
 564                         ts->wridx2 = 0;
 565                 }
 566                 ts = next;
 567         }
 568         goto again;
 569 }