networking/telnet.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * telnet implementation for busybox
   4  *
   5  * Author: Tomi Ollila <too@iki.fi>
   6  * Copyright (C) 1994-2000 by Tomi Ollila
   7  *
   8  * Created: Thu Apr  7 13:29:41 1994 too
   9  * Last modified: Fri Jun  9 14:34:24 2000 too
  10  *
  11  * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
  12  *
  13  * HISTORY
  14  * Revision 3.1  1994/04/17  11:31:54  too
  15  * initial revision
  16  * Modified 2000/06/13 for inclusion into BusyBox by Erik Andersen <andersen@codepoet.org>
  17  * Modified 2001/05/07 to add ability to pass TTYPE to remote host by Jim McQuillan
  18  * <jam@ltsp.org>
  19  * Modified 2004/02/11 to add ability to pass the USER variable to remote host
  20  * by Fernando Silveira <swrh@gmx.net>
  21  *
  22  */
  23
  24 #include <termios.h>
  25 #include <arpa/telnet.h>
  26 #include <netinet/in.h>
  27 #include "busybox.h"
  28
  29 #ifdef DOTRACE
  30 #define TRACE(x, y) do { if (x) printf y; } while (0)
  31 #else
  32 #define TRACE(x, y)
  33 #endif
  34
  35 #define DATABUFSIZE  128
  36 #define IACBUFSIZE   128
  37
  38 enum {
  39         CHM_TRY = 0,
  40         CHM_ON = 1,
  41         CHM_OFF = 2,
  42
  43         UF_ECHO = 0x01,
  44         UF_SGA = 0x02,
  45
  46         TS_0 = 1,
  47         TS_IAC = 2,
  48         TS_OPT = 3,
  49         TS_SUB1 = 4,
  50         TS_SUB2 = 5,
  51 };
  52
  53 #define WriteCS(fd, str) write(fd, str, sizeof str -1)
  54
  55 typedef unsigned char byte;
  56
  57 /* use globals to reduce size ??? */ /* test this hypothesis later */
  58 static struct Globalvars {
  59         int             netfd; /* console fd:s are 0 and 1 (and 2) */
  60     /* same buffer used both for network and console read/write */
  61         char    buf[DATABUFSIZE]; /* allocating so static size is smaller */
  62         byte    telstate; /* telnet negotiation state from network input */
  63         byte    telwish;  /* DO, DONT, WILL, WONT */
  64         byte    charmode;
  65         byte    telflags;
  66         byte    gotsig;
  67         byte    do_termios;
  68         /* buffer to handle telnet negotiations */
  69         char    iacbuf[IACBUFSIZE];
  70         short   iaclen; /* could even use byte */
  71         struct termios termios_def;
  72         struct termios termios_raw;
  73 } G;
  74
  75 #define xUSE_GLOBALVAR_PTR /* xUSE... -> don't use :D (makes smaller code) */
  76
  77 #ifdef USE_GLOBALVAR_PTR
  78 struct Globalvars * Gptr;
  79 #define G (*Gptr)
  80 #endif
  81
  82 static void iacflush(void)
  83 {
  84         write(G.netfd, G.iacbuf, G.iaclen);
  85         G.iaclen = 0;
  86 }
  87
  88 /* Function prototypes */
  89 static void rawmode(void);
  90 static void cookmode(void);
  91 static void do_linemode(void);
  92 static void will_charmode(void);
  93 static void telopt(byte c);
  94 static int subneg(byte c);
  95
  96 /* Some globals */
  97 #ifdef CONFIG_FEATURE_TELNET_TTYPE
  98 static char *ttype;
  99 #endif
 100
 101 #ifdef CONFIG_FEATURE_TELNET_AUTOLOGIN
 102 static const char *autologin;
 103 #endif
 104
 105 #ifdef CONFIG_FEATURE_AUTOWIDTH
 106 static int win_width, win_height;
 107 #endif
 108
 109 static void doexit(int ev)
 110 {
 111         cookmode();
 112         exit(ev);
 113 }
 114
 115 static void conescape(void)
 116 {
 117         char b;
 118
 119         if (G.gotsig)   /* came from line  mode... go raw */
 120                 rawmode();
 121
 122         WriteCS(1, "\r\nConsole escape. Commands are:\r\n\n"
 123                         " l     go to line mode\r\n"
 124                         " c     go to character mode\r\n"
 125                         " z     suspend telnet\r\n"
 126                         " e     exit telnet\r\n");
 127
 128         if (read(0, &b, 1) <= 0)
 129                 doexit(1);
 130
 131         switch (b)
 132         {
 133         case 'l':
 134                 if (!G.gotsig)
 135                 {
 136                         do_linemode();
 137                         goto rrturn;
 138                 }
 139                 break;
 140         case 'c':
 141                 if (G.gotsig)
 142                 {
 143                         will_charmode();
 144                         goto rrturn;
 145                 }
 146                 break;
 147         case 'z':
 148                 cookmode();
 149                 kill(0, SIGTSTP);
 150                 rawmode();
 151                 break;
 152         case 'e':
 153                 doexit(0);
 154         }
 155
 156         WriteCS(1, "continuing...\r\n");
 157
 158         if (G.gotsig)
 159                 cookmode();
 160
 161  rrturn:
 162         G.gotsig = 0;
 163
 164 }
 165 static void handlenetoutput(int len)
 166 {
 167         /*      here we could do smart tricks how to handle 0xFF:s in output
 168          *      stream  like writing twice every sequence of FF:s (thus doing
 169          *      many write()s. But I think interactive telnet application does
 170          *      not need to be 100% 8-bit clean, so changing every 0xff:s to
 171          *      0x7f:s
 172          *
 173          *      2002-mar-21, Przemyslaw Czerpak (druzus@polbox.com)
 174          *      I don't agree.
 175          *      first - I cannot use programs like sz/rz
 176          *      second - the 0x0D is sent as one character and if the next
 177          *               char is 0x0A then it's eaten by a server side.
 178          *      third - whay doy you have to make 'many write()s'?
 179          *              I don't understand.
 180          *      So I implemented it. It's realy useful for me. I hope that
 181          *      others people will find it interesting to.
 182          */
 183
 184         int i, j;
 185         byte * p = (byte*)G.buf;
 186         byte outbuf[4*DATABUFSIZE];
 187
 188         for (i = len, j = 0; i > 0; i--, p++)
 189         {
 190                 if (*p == 0x1d)
 191                 {
 192                         conescape();
 193                         return;
 194                 }
 195                 outbuf[j++] = *p;
 196                 if (*p == 0xff)
 197                         outbuf[j++] = 0xff;
 198                 else if (*p == 0x0d)
 199                         outbuf[j++] = 0x00;
 200         }
 201         if (j > 0 )
 202                 write(G.netfd, outbuf, j);
 203 }
 204
 205
 206 static void handlenetinput(int len)
 207 {
 208         int i;
 209         int cstart = 0;
 210
 211         for (i = 0; i < len; i++)
 212         {
 213                 byte c = G.buf[i];
 214
 215                 if (G.telstate == 0) /* most of the time state == 0 */
 216                 {
 217                         if (c == IAC)
 218                         {
 219                                 cstart = i;
 220                                 G.telstate = TS_IAC;
 221                         }
 222                 }
 223                 else
 224                         switch (G.telstate)
 225                          {
 226                          case TS_0:
 227                                  if (c == IAC)
 228                                          G.telstate = TS_IAC;
 229                                  else
 230                                          G.buf[cstart++] = c;
 231                                  break;
 232
 233                          case TS_IAC:
 234                                  if (c == IAC) /* IAC IAC -> 0xFF */
 235                                  {
 236                                          G.buf[cstart++] = c;
 237                                          G.telstate = TS_0;
 238                                          break;
 239                                  }
 240                                  /* else */
 241                                  switch (c)
 242                                  {
 243                                  case SB:
 244                                          G.telstate = TS_SUB1;
 245                                          break;
 246                                  case DO:
 247                                  case DONT:
 248                                  case WILL:
 249                                  case WONT:
 250                                          G.telwish =  c;
 251                                          G.telstate = TS_OPT;
 252                                          break;
 253                                  default:
 254                                          G.telstate = TS_0;     /* DATA MARK must be added later */
 255                                  }
 256                                  break;
 257                          case TS_OPT: /* WILL, WONT, DO, DONT */
 258                                  telopt(c);
 259                                  G.telstate = TS_0;
 260                                  break;
 261                          case TS_SUB1: /* Subnegotiation */
 262                          case TS_SUB2: /* Subnegotiation */
 263                                  if (subneg(c))
 264                                          G.telstate = TS_0;
 265                                  break;
 266                          }
 267         }
 268         if (G.telstate)
 269         {
 270                 if (G.iaclen)                   iacflush();
 271                 if (G.telstate == TS_0) G.telstate = 0;
 272
 273                 len = cstart;
 274         }
 275
 276         if (len)
 277                 write(1, G.buf, len);
 278 }
 279
 280
 281 /* ******************************* */
 282
 283 static void putiac(int c)
 284 {
 285         G.iacbuf[G.iaclen++] = c;
 286 }
 287
 288
 289 static void putiac2(byte wwdd, byte c)
 290 {
 291         if (G.iaclen + 3 > IACBUFSIZE)
 292                 iacflush();
 293
 294         putiac(IAC);
 295         putiac(wwdd);
 296         putiac(c);
 297 }
 298
 299 #ifdef CONFIG_FEATURE_TELNET_TTYPE
 300 static void putiac_subopt(byte c, char *str)
 301 {
 302         int     len = strlen(str) + 6;   // ( 2 + 1 + 1 + strlen + 2 )
 303
 304         if (G.iaclen + len > IACBUFSIZE)
 305                 iacflush();
 306
 307         putiac(IAC);
 308         putiac(SB);
 309         putiac(c);
 310         putiac(0);
 311
 312         while (*str)
 313                 putiac(*str++);
 314
 315         putiac(IAC);
 316         putiac(SE);
 317 }
 318 #endif
 319
 320 #ifdef CONFIG_FEATURE_TELNET_AUTOLOGIN
 321 static void putiac_subopt_autologin(void)
 322 {
 323         int len = strlen(autologin) + 6;        // (2 + 1 + 1 + strlen + 2)
 324         const char *user = "USER";
 325
 326         if (G.iaclen + len > IACBUFSIZE)
 327                 iacflush();
 328
 329         putiac(IAC);
 330         putiac(SB);
 331         putiac(TELOPT_NEW_ENVIRON);
 332         putiac(TELQUAL_IS);
 333         putiac(NEW_ENV_VAR);
 334
 335         while (*user)
 336                 putiac(*user++);
 337
 338         putiac(NEW_ENV_VALUE);
 339
 340         while (*autologin)
 341                 putiac(*autologin++);
 342
 343         putiac(IAC);
 344         putiac(SE);
 345 }
 346 #endif
 347
 348 #ifdef CONFIG_FEATURE_AUTOWIDTH
 349 static void putiac_naws(byte c, int x, int y)
 350 {
 351         if (G.iaclen + 9 > IACBUFSIZE)
 352                 iacflush();
 353
 354         putiac(IAC);
 355         putiac(SB);
 356         putiac(c);
 357
 358         putiac((x >> 8) & 0xff);
 359         putiac(x & 0xff);
 360         putiac((y >> 8) & 0xff);
 361         putiac(y & 0xff);
 362
 363         putiac(IAC);
 364         putiac(SE);
 365 }
 366 #endif
 367
 368 /* void putiacstring (subneg strings) */
 369
 370 /* ******************************* */
 371
 372 static char const escapecharis[] = "\r\nEscape character is ";
 373
 374 static void setConMode(void)
 375 {
 376         if (G.telflags & UF_ECHO)
 377         {
 378                 if (G.charmode == CHM_TRY) {
 379                         G.charmode = CHM_ON;
 380                         printf("\r\nEntering character mode%s'^]'.\r\n", escapecharis);
 381                         rawmode();
 382                 }
 383         }
 384         else
 385         {
 386                 if (G.charmode != CHM_OFF) {
 387                         G.charmode = CHM_OFF;
 388                         printf("\r\nEntering line mode%s'^C'.\r\n", escapecharis);
 389                         cookmode();
 390                 }
 391         }
 392 }
 393
 394 /* ******************************* */
 395
 396 static void will_charmode(void)
 397 {
 398         G.charmode = CHM_TRY;
 399         G.telflags |= (UF_ECHO | UF_SGA);
 400         setConMode();
 401
 402         putiac2(DO, TELOPT_ECHO);
 403         putiac2(DO, TELOPT_SGA);
 404         iacflush();
 405 }
 406
 407 static void do_linemode(void)
 408 {
 409         G.charmode = CHM_TRY;
 410         G.telflags &= ~(UF_ECHO | UF_SGA);
 411         setConMode();
 412
 413         putiac2(DONT, TELOPT_ECHO);
 414         putiac2(DONT, TELOPT_SGA);
 415         iacflush();
 416 }
 417
 418 /* ******************************* */
 419
 420 static void to_notsup(char c)
 421 {
 422         if      (G.telwish == WILL)     putiac2(DONT, c);
 423         else if (G.telwish == DO)       putiac2(WONT, c);
 424 }
 425
 426 static void to_echo(void)
 427 {
 428         /* if server requests ECHO, don't agree */
 429         if      (G.telwish == DO) {     putiac2(WONT, TELOPT_ECHO);     return; }
 430         else if (G.telwish == DONT)     return;
 431
 432         if (G.telflags & UF_ECHO)
 433         {
 434                 if (G.telwish == WILL)
 435                         return;
 436         }
 437         else
 438                 if (G.telwish == WONT)
 439                         return;
 440
 441         if (G.charmode != CHM_OFF)
 442                 G.telflags ^= UF_ECHO;
 443
 444         if (G.telflags & UF_ECHO)
 445                 putiac2(DO, TELOPT_ECHO);
 446         else
 447                 putiac2(DONT, TELOPT_ECHO);
 448
 449         setConMode();
 450         WriteCS(1, "\r\n");  /* sudden modec */
 451 }
 452
 453 static void to_sga(void)
 454 {
 455         /* daemon always sends will/wont, client do/dont */
 456
 457         if (G.telflags & UF_SGA)
 458         {
 459                 if (G.telwish == WILL)
 460                         return;
 461         }
 462         else
 463                 if (G.telwish == WONT)
 464                         return;
 465
 466         if ((G.telflags ^= UF_SGA) & UF_SGA) /* toggle */
 467                 putiac2(DO, TELOPT_SGA);
 468         else
 469                 putiac2(DONT, TELOPT_SGA);
 470
 471         return;
 472 }
 473
 474 #ifdef CONFIG_FEATURE_TELNET_TTYPE
 475 static void to_ttype(void)
 476 {
 477         /* Tell server we will (or won't) do TTYPE */
 478
 479         if(ttype)
 480                 putiac2(WILL, TELOPT_TTYPE);
 481         else
 482                 putiac2(WONT, TELOPT_TTYPE);
 483
 484         return;
 485 }
 486 #endif
 487
 488 #ifdef CONFIG_FEATURE_TELNET_AUTOLOGIN
 489 static void to_new_environ(void)
 490 {
 491         /* Tell server we will (or will not) do AUTOLOGIN */
 492
 493         if (autologin)
 494                 putiac2(WILL, TELOPT_NEW_ENVIRON);
 495         else
 496                 putiac2(WONT, TELOPT_NEW_ENVIRON);
 497
 498         return;
 499 }
 500 #endif
 501
 502 #ifdef CONFIG_FEATURE_AUTOWIDTH
 503 static void to_naws(void)
 504 {
 505         /* Tell server we will do NAWS */
 506         putiac2(WILL, TELOPT_NAWS);
 507         return;
 508 }
 509 #endif
 510
 511 static void telopt(byte c)
 512 {
 513         switch (c)
 514         {
 515                 case TELOPT_ECHO:               to_echo();      break;
 516                 case TELOPT_SGA:                to_sga();       break;
 517 #ifdef CONFIG_FEATURE_TELNET_TTYPE
 518                 case TELOPT_TTYPE:              to_ttype();break;
 519 #endif
 520 #ifdef CONFIG_FEATURE_TELNET_AUTOLOGIN
 521                 case TELOPT_NEW_ENVIRON:        to_new_environ();       break;
 522 #endif
 523 #ifdef CONFIG_FEATURE_AUTOWIDTH
 524                 case TELOPT_NAWS:               to_naws();
 525                                                                 putiac_naws(c, win_width, win_height);
 526                                                                 break;
 527 #endif
 528                 default:                                to_notsup(c);
 529                                                                 break;
 530         }
 531 }
 532
 533
 534 /* ******************************* */
 535
 536 /* subnegotiation -- ignore all (except TTYPE,NAWS) */
 537
 538 static int subneg(byte c)
 539 {
 540         switch (G.telstate)
 541         {
 542         case TS_SUB1:
 543                 if (c == IAC)
 544                         G.telstate = TS_SUB2;
 545 #ifdef CONFIG_FEATURE_TELNET_TTYPE
 546                 else
 547                 if (c == TELOPT_TTYPE)
 548                         putiac_subopt(TELOPT_TTYPE,ttype);
 549 #endif
 550 #ifdef CONFIG_FEATURE_TELNET_AUTOLOGIN
 551                 else
 552                 if (c == TELOPT_NEW_ENVIRON)
 553                         putiac_subopt_autologin();
 554 #endif
 555                 break;
 556         case TS_SUB2:
 557                 if (c == SE)
 558                         return TRUE;
 559                 G.telstate = TS_SUB1;
 560                 /* break; */
 561         }
 562         return FALSE;
 563 }
 564
 565 /* ******************************* */
 566
 567 static void fgotsig(int sig)
 568 {
 569         G.gotsig = sig;
 570 }
 571
 572
 573 static void rawmode(void)
 574 {
 575         if (G.do_termios) tcsetattr(0, TCSADRAIN, &G.termios_raw);
 576 }
 577
 578 static void cookmode(void)
 579 {
 580         if (G.do_termios) tcsetattr(0, TCSADRAIN, &G.termios_def);
 581 }
 582
 583 int telnet_main(int argc, char** argv);
 584 int telnet_main(int argc, char** argv)
 585 {
 586         char *host;
 587         int port;
 588         int len;
 589 #ifdef USE_POLL
 590         struct pollfd ufds[2];
 591 #else
 592         fd_set readfds;
 593         int maxfd;
 594 #endif
 595
 596 #ifdef CONFIG_FEATURE_AUTOWIDTH
 597         get_terminal_width_height(0, &win_width, &win_height);
 598 #endif
 599
 600 #ifdef CONFIG_FEATURE_TELNET_TTYPE
 601         ttype = getenv("TERM");
 602 #endif
 603
 604         /* memset(&G, 0, sizeof G); - already is */
 605
 606         if (tcgetattr(0, &G.termios_def) >= 0) {
 607                 G.do_termios = 1;
 608                 G.termios_raw = G.termios_def;
 609                 cfmakeraw(&G.termios_raw);
 610         }
 611
 612         if (argc < 2)
 613                 bb_show_usage();
 614
 615 #ifdef CONFIG_FEATURE_TELNET_AUTOLOGIN
 616         if (1 & getopt32(argc, argv, "al:", &autologin))
 617                 autologin = getenv("USER");
 618         argv += optind;
 619 #else
 620         argv++;
 621 #endif
 622         if (!*argv)
 623                 bb_show_usage();
 624         host = *argv++;
 625         port = bb_lookup_port(*argv ? *argv++ : "telnet", "tcp", 23);
 626         if (*argv) /* extra params?? */
 627                 bb_show_usage();
 628
 629         G.netfd = create_and_connect_stream_or_die(host, port);
 630
 631         setsockopt(G.netfd, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1));
 632
 633         signal(SIGINT, fgotsig);
 634
 635 #ifdef USE_POLL
 636         ufds[0].fd = 0; ufds[1].fd = G.netfd;
 637         ufds[0].events = ufds[1].events = POLLIN;
 638 #else
 639         FD_ZERO(&readfds);
 640         FD_SET(0, &readfds);
 641         FD_SET(G.netfd, &readfds);
 642         maxfd = G.netfd + 1;
 643 #endif
 644
 645         while (1) {
 646 #ifndef USE_POLL
 647                 fd_set rfds = readfds;
 648
 649                 switch (select(maxfd, &rfds, NULL, NULL, NULL))
 650 #else
 651                 switch (poll(ufds, 2, -1))
 652 #endif
 653                 {
 654                 case 0:
 655                         /* timeout */
 656                 case -1:
 657                         /* error, ignore and/or log something, bay go to loop */
 658                         if (G.gotsig)
 659                                 conescape();
 660                         else
 661                                 sleep(1);
 662                         break;
 663                 default:
 664
 665 #ifdef USE_POLL
 666                         if (ufds[0].revents) /* well, should check POLLIN, but ... */
 667 #else
 668                         if (FD_ISSET(0, &rfds))
 669 #endif
 670                         {
 671                                 len = read(0, G.buf, DATABUFSIZE);
 672
 673                                 if (len <= 0)
 674                                         doexit(0);
 675
 676                                 TRACE(0, ("Read con: %d\n", len));
 677
 678                                 handlenetoutput(len);
 679                         }
 680
 681 #ifdef USE_POLL
 682                         if (ufds[1].revents) /* well, should check POLLIN, but ... */
 683 #else
 684                         if (FD_ISSET(G.netfd, &rfds))
 685 #endif
 686                         {
 687                                 len = read(G.netfd, G.buf, DATABUFSIZE);
 688
 689                                 if (len <= 0) {
 690                                         WriteCS(1, "Connection closed by foreign host.\r\n");
 691                                         doexit(1);
 692                                 }
 693                                 TRACE(0, ("Read netfd (%d): %d\n", G.netfd, len));
 694
 695                                 handlenetinput(len);
 696                         }
 697                 }
 698         }
 699 }