networking/nc.c

   1 /* vi: set sw=4 ts=4: */
   2 /* nc: mini-netcat - built from the ground up for LRP
   3  *
   4  * Copyright (C) 1998, 1999  Charles P. Wright
   5  * Copyright (C) 1998  Dave Cinege
   6  *
   7  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
   8  */
   9
  10 #include "libbb.h"
  11
  12 //config:config NC
  13 //config:       bool "nc"
  14 //config:       default y
  15 //config:       help
  16 //config:         A simple Unix utility which reads and writes data across network
  17 //config:         connections.
  18 //config:
  19 //config:config NC_SERVER
  20 //config:       bool "Netcat server options (-l)"
  21 //config:       default y
  22 //config:       depends on NC
  23 //config:       help
  24 //config:         Allow netcat to act as a server.
  25 //config:
  26 //config:config NC_EXTRA
  27 //config:       bool "Netcat extensions (-eiw and -f FILE)"
  28 //config:       default y
  29 //config:       depends on NC
  30 //config:       help
  31 //config:         Add -e (support for executing the rest of the command line after
  32 //config:         making or receiving a successful connection), -i (delay interval for
  33 //config:         lines sent), -w (timeout for initial connection).
  34 //config:
  35 //config:config NC_110_COMPAT
  36 //config:       bool "Netcat 1.10 compatibility (+2.5k)"
  37 //config:       default n  # off specially for Rob
  38 //config:       depends on NC
  39 //config:       help
  40 //config:         This option makes nc closely follow original nc-1.10.
  41 //config:         The code is about 2.5k bigger. It enables
  42 //config:         -s ADDR, -n, -u, -v, -o FILE, -z options, but loses
  43 //config:         busybox-specific extensions: -f FILE.
  44
  45 #if ENABLE_NC_110_COMPAT
  46 # include "nc_bloaty.c"
  47 #else
  48
  49 //usage:#if !ENABLE_NC_110_COMPAT
  50 //usage:
  51 //usage:#if ENABLE_NC_SERVER || ENABLE_NC_EXTRA
  52 //usage:#define NC_OPTIONS_STR "\n"
  53 //usage:#else
  54 //usage:#define NC_OPTIONS_STR
  55 //usage:#endif
  56 //usage:
  57 //usage:#define nc_trivial_usage
  58 //usage:        IF_NC_EXTRA("[-iN] [-wN] ")IF_NC_SERVER("[-l] [-p PORT] ")
  59 //usage:       "["IF_NC_EXTRA("-f FILE|")"IPADDR PORT]"IF_NC_EXTRA(" [-e PROG]")
  60 //usage:#define nc_full_usage "\n\n"
  61 //usage:       "Open a pipe to IP:PORT" IF_NC_EXTRA(" or FILE")
  62 //usage:        NC_OPTIONS_STR
  63 //usage:        IF_NC_SERVER(
  64 //usage:     "\n        -l      Listen mode, for inbound connects"
  65 //usage:        IF_NC_EXTRA(
  66 //usage:     "\n                (use -ll with -e for persistent server)"
  67 //usage:        )
  68 //usage:     "\n        -p PORT Local port"
  69 //usage:        )
  70 //usage:        IF_NC_EXTRA(
  71 //usage:     "\n        -w SEC  Connect timeout"
  72 //usage:     "\n        -i SEC  Delay interval for lines sent"
  73 //usage:     "\n        -f FILE Use file (ala /dev/ttyS0) instead of network"
  74 //usage:     "\n        -e PROG Run PROG after connect"
  75 //usage:        )
  76 //usage:
  77 //usage:#define nc_notes_usage ""
  78 //usage:        IF_NC_EXTRA(
  79 //usage:       "To use netcat as a terminal emulator on a serial port:\n\n"
  80 //usage:       "$ stty 115200 -F /dev/ttyS0\n"
  81 //usage:       "$ stty raw -echo -ctlecho && nc -f /dev/ttyS0\n"
  82 //usage:        )
  83 //usage:
  84 //usage:#define nc_example_usage
  85 //usage:       "$ nc foobar.somedomain.com 25\n"
  86 //usage:       "220 foobar ESMTP Exim 3.12 #1 Sat, 15 Apr 2000 00:03:02 -0600\n"
  87 //usage:       "help\n"
  88 //usage:       "214-Commands supported:\n"
  89 //usage:       "214-    HELO EHLO MAIL RCPT DATA AUTH\n"
  90 //usage:       "214     NOOP QUIT RSET HELP\n"
  91 //usage:       "quit\n"
  92 //usage:       "221 foobar closing connection\n"
  93 //usage:
  94 //usage:#endif
  95
  96 /* Lots of small differences in features
  97  * when compared to "standard" nc
  98  */
  99
 100 static void timeout(int signum UNUSED_PARAM)
 101 {
 102         bb_error_msg_and_die("timed out");
 103 }
 104
 105 int nc_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 106 int nc_main(int argc, char **argv)
 107 {
 108         /* sfd sits _here_ only because of "repeat" option (-l -l). */
 109         int sfd = sfd; /* for gcc */
 110         int cfd = 0;
 111         unsigned lport = 0;
 112         IF_NOT_NC_SERVER(const) unsigned do_listen = 0;
 113         IF_NOT_NC_EXTRA (const) unsigned wsecs = 0;
 114         IF_NOT_NC_EXTRA (const) unsigned delay = 0;
 115         IF_NOT_NC_EXTRA (const int execparam = 0;)
 116         IF_NC_EXTRA     (char **execparam = NULL;)
 117         fd_set readfds, testfds;
 118         int opt; /* must be signed (getopt returns -1) */
 119
 120         if (ENABLE_NC_SERVER || ENABLE_NC_EXTRA) {
 121                 /* getopt32 is _almost_ usable:
 122                 ** it cannot handle "... -e PROG -prog-opt" */
 123                 while ((opt = getopt(argc, argv,
 124                         "" IF_NC_SERVER("lp:") IF_NC_EXTRA("w:i:f:e:") )) > 0
 125                 ) {
 126                         if (ENABLE_NC_SERVER && opt == 'l')
 127                                 IF_NC_SERVER(do_listen++);
 128                         else if (ENABLE_NC_SERVER && opt == 'p')
 129                                 IF_NC_SERVER(lport = bb_lookup_port(optarg, "tcp", 0));
 130                         else if (ENABLE_NC_EXTRA && opt == 'w')
 131                                 IF_NC_EXTRA( wsecs = xatou(optarg));
 132                         else if (ENABLE_NC_EXTRA && opt == 'i')
 133                                 IF_NC_EXTRA( delay = xatou(optarg));
 134                         else if (ENABLE_NC_EXTRA && opt == 'f')
 135                                 IF_NC_EXTRA( cfd = xopen(optarg, O_RDWR));
 136                         else if (ENABLE_NC_EXTRA && opt == 'e' && optind <= argc) {
 137                                 /* We cannot just 'break'. We should let getopt finish.
 138                                 ** Or else we won't be able to find where
 139                                 ** 'host' and 'port' params are
 140                                 ** (think "nc -w 60 host port -e PROG"). */
 141                                 IF_NC_EXTRA(
 142                                         char **p;
 143                                         // +2: one for progname (optarg) and one for NULL
 144                                         execparam = xzalloc(sizeof(char*) * (argc - optind + 2));
 145                                         p = execparam;
 146                                         *p++ = optarg;
 147                                         while (optind < argc) {
 148                                                 *p++ = argv[optind++];
 149                                         }
 150                                 )
 151                                 /* optind points to argv[argc] (NULL) now.
 152                                 ** FIXME: we assume that getopt will not count options
 153                                 ** possibly present on "-e PROG ARGS" and will not
 154                                 ** include them into final value of optind
 155                                 ** which is to be used ...  */
 156                         } else bb_show_usage();
 157                 }
 158                 argv += optind; /* ... here! */
 159                 argc -= optind;
 160                 // -l and -f don't mix
 161                 if (do_listen && cfd) bb_show_usage();
 162                 // File mode needs need zero arguments, listen mode needs zero or one,
 163                 // client mode needs one or two
 164                 if (cfd) {
 165                         if (argc) bb_show_usage();
 166                 } else if (do_listen) {
 167                         if (argc > 1) bb_show_usage();
 168                 } else {
 169                         if (!argc || argc > 2) bb_show_usage();
 170                 }
 171         } else {
 172                 if (argc != 3) bb_show_usage();
 173                 argc--;
 174                 argv++;
 175         }
 176
 177         if (wsecs) {
 178                 signal(SIGALRM, timeout);
 179                 alarm(wsecs);
 180         }
 181
 182         if (!cfd) {
 183                 if (do_listen) {
 184                         sfd = create_and_bind_stream_or_die(argv[0], lport);
 185                         xlisten(sfd, do_listen); /* can be > 1 */
 186 #if 0  /* nc-1.10 does not do this (without -v) */
 187                         /* If we didn't specify a port number,
 188                          * query and print it after listen() */
 189                         if (!lport) {
 190                                 len_and_sockaddr lsa;
 191                                 lsa.len = LSA_SIZEOF_SA;
 192                                 getsockname(sfd, &lsa.u.sa, &lsa.len);
 193                                 lport = get_nport(&lsa.u.sa);
 194                                 fdprintf(2, "%d\n", ntohs(lport));
 195                         }
 196 #endif
 197                         close_on_exec_on(sfd);
 198  accept_again:
 199                         cfd = accept(sfd, NULL, 0);
 200                         if (cfd < 0)
 201                                 bb_perror_msg_and_die("accept");
 202                         if (!execparam)
 203                                 close(sfd);
 204                 } else {
 205                         cfd = create_and_connect_stream_or_die(argv[0],
 206                                 argv[1] ? bb_lookup_port(argv[1], "tcp", 0) : 0);
 207                 }
 208         }
 209
 210         if (wsecs) {
 211                 alarm(0);
 212                 /* Non-ignored signals revert to SIG_DFL on exec anyway */
 213                 /*signal(SIGALRM, SIG_DFL);*/
 214         }
 215
 216         /* -e given? */
 217         if (execparam) {
 218                 pid_t pid;
 219                 /* With more than one -l, repeatedly act as server */
 220                 if (do_listen > 1 && (pid = xvfork()) != 0) {
 221                         /* parent */
 222                         /* prevent zombies */
 223                         signal(SIGCHLD, SIG_IGN);
 224                         close(cfd);
 225                         goto accept_again;
 226                 }
 227                 /* child, or main thread if only one -l */
 228                 xmove_fd(cfd, 0);
 229                 xdup2(0, 1);
 230                 /*xdup2(0, 2); - original nc 1.10 does this, we don't */
 231                 IF_NC_EXTRA(BB_EXECVP(execparam[0], execparam);)
 232                 IF_NC_EXTRA(bb_perror_msg_and_die("can't execute '%s'", execparam[0]);)
 233         }
 234
 235         /* Select loop copying stdin to cfd, and cfd to stdout */
 236
 237         FD_ZERO(&readfds);
 238         FD_SET(cfd, &readfds);
 239         FD_SET(STDIN_FILENO, &readfds);
 240
 241         for (;;) {
 242                 int fd;
 243                 int ofd;
 244                 int nread;
 245
 246                 testfds = readfds;
 247
 248                 if (select(cfd + 1, &testfds, NULL, NULL, NULL) < 0)
 249                         bb_perror_msg_and_die("select");
 250
 251 #define iobuf bb_common_bufsiz1
 252                 fd = STDIN_FILENO;
 253                 while (1) {
 254                         if (FD_ISSET(fd, &testfds)) {
 255                                 nread = safe_read(fd, iobuf, sizeof(iobuf));
 256                                 if (fd == cfd) {
 257                                         if (nread < 1)
 258                                                 exit(EXIT_SUCCESS);
 259                                         ofd = STDOUT_FILENO;
 260                                 } else {
 261                                         if (nread < 1) {
 262                                                 /* Close outgoing half-connection so they get EOF,
 263                                                  * but leave incoming alone so we can see response */
 264                                                 shutdown(cfd, SHUT_WR);
 265                                                 FD_CLR(STDIN_FILENO, &readfds);
 266                                         }
 267                                         ofd = cfd;
 268                                 }
 269                                 xwrite(ofd, iobuf, nread);
 270                                 if (delay > 0)
 271                                         sleep(delay);
 272                         }
 273                         if (fd == cfd)
 274                                 break;
 275                         fd = cfd;
 276                 }
 277         }
 278 }
 279 #endif