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 tarball for details.
   8  */
   9
  10 #include "busybox.h"
  11
  12 static void timeout(int signum)
  13 {
  14         bb_error_msg_and_die("Timed out");
  15 }
  16
  17 int nc_main(int argc, char **argv)
  18 {
  19         int do_listen = 0, lport = 0, delay = 0, wsecs = 0, execflag = 0, opt,
  20                 sfd = 0, cfd;
  21         struct sockaddr_in address;
  22         struct hostent *hostinfo;
  23         fd_set readfds, testfds;
  24         char *infile = NULL;
  25
  26         memset(&address, 0, sizeof(address));
  27
  28         if (ENABLE_NC_SERVER || ENABLE_NC_EXTRA) {
  29                 while ((opt = getopt(argc, argv, "lp:" USE_NC_EXTRA("i:ew:f:"))) > 0) {
  30                         if (ENABLE_NC_SERVER && opt=='l') do_listen++;
  31                         else if (ENABLE_NC_SERVER && opt=='p')
  32                                 lport = bb_lookup_port(optarg, "tcp", 0);
  33                         else if (ENABLE_NC_EXTRA && opt=='w') wsecs = atoi(optarg);
  34                         else if (ENABLE_NC_EXTRA && opt=='i') delay = atoi(optarg);
  35                         else if (ENABLE_NC_EXTRA && opt=='f') infile = optarg;
  36                         else if (ENABLE_NC_EXTRA && opt=='e' && optind!=argc) {
  37                                 execflag++;
  38                                 break;
  39                         } else bb_show_usage();
  40                 }
  41         }
  42
  43
  44         // For listen or file we need zero arguments, dialout is 2.
  45         // For exec we need at least one more argument at the end, more ok
  46
  47         opt = (do_listen  || infile) ? 0 : 2 + execflag;
  48         if (execflag ? argc-optind < opt : argc-optind!=opt ||
  49                 (infile && do_listen))
  50                         bb_show_usage();
  51
  52         if (wsecs) {
  53                 signal(SIGALRM, timeout);
  54                 alarm(wsecs);
  55         }
  56
  57         if (infile) cfd = xopen(infile, O_RDWR);
  58         else {
  59                 opt = 1;
  60                 sfd = xsocket(AF_INET, SOCK_STREAM, 0);
  61                 fcntl(sfd, F_SETFD, FD_CLOEXEC);
  62                 setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt));
  63                 address.sin_family = AF_INET;
  64
  65                 // Set local port.
  66
  67                 if (lport != 0) {
  68                         address.sin_port = lport;
  69
  70                         xbind(sfd, (struct sockaddr *) &address, sizeof(address));
  71                 }
  72
  73                 if (do_listen) {
  74                         socklen_t addrlen = sizeof(address);
  75
  76                         xlisten(sfd, do_listen);
  77
  78                         // If we didn't specify a port number, query and print it to stderr.
  79
  80                         if (!lport) {
  81                                 socklen_t len = sizeof(address);
  82                                 getsockname(sfd, &address, &len);
  83                                 fdprintf(2, "%d\n", SWAP_BE16(address.sin_port));
  84                         }
  85 repeatyness:
  86                         if ((cfd = accept(sfd, (struct sockaddr *) &address, &addrlen)) < 0)
  87                                 bb_perror_msg_and_die("accept");
  88
  89                         if (!execflag) close(sfd);
  90                 } else {
  91                         hostinfo = xgethostbyname(argv[optind]);
  92
  93                         address.sin_addr = *(struct in_addr *) *hostinfo->h_addr_list;
  94                         address.sin_port = bb_lookup_port(argv[optind+1], "tcp", 0);
  95
  96                         if (connect(sfd, (struct sockaddr *) &address, sizeof(address)) < 0)
  97                                 bb_perror_msg_and_die("connect");
  98                         cfd = sfd;
  99                 }
 100         }
 101
 102         if (wsecs) {
 103                 alarm(0);
 104                 signal(SIGALRM, SIG_DFL);
 105         }
 106
 107         /* -e given? */
 108         if (execflag) {
 109                 if(cfd) {
 110                         signal(SIGCHLD, SIG_IGN);
 111                         dup2(cfd, 0);
 112                         close(cfd);
 113                 }
 114                 dup2(0, 1);
 115                 dup2(0, 2);
 116
 117                 // With more than one -l, repeatedly act as server.
 118
 119                 if (do_listen>1 && vfork()) {
 120                         // This is a bit weird as cleanup goes, since we wind up with no
 121                         // stdin/stdout/stderr.  But it's small and shouldn't hurt anything.
 122                         // We check for cfd == 0 above.
 123                         close(0);
 124                         close(1);
 125                         close(2);
 126
 127                         goto repeatyness;
 128                 }
 129                 execvp(argv[optind], argv+optind);
 130                 /* Don't print stuff or it will go over the wire.... */
 131                 _exit(127);
 132         }
 133
 134         // Select loop copying stdin to cfd, and cfd to stdout.
 135
 136         FD_ZERO(&readfds);
 137         FD_SET(cfd, &readfds);
 138         FD_SET(STDIN_FILENO, &readfds);
 139
 140         for (;;) {
 141                 int fd;
 142                 int ofd;
 143                 int nread;
 144
 145                 testfds = readfds;
 146
 147                 if (select(FD_SETSIZE, &testfds, NULL, NULL, NULL) < 0)
 148                         bb_perror_msg_and_die("select");
 149
 150                 for (fd = 0; fd < FD_SETSIZE; fd++) {
 151                         if (FD_ISSET(fd, &testfds)) {
 152                                 nread = safe_read(fd, bb_common_bufsiz1,
 153                                                         sizeof(bb_common_bufsiz1));
 154
 155                                 if (fd == cfd) {
 156                                         if (nread<1) exit(0);
 157                                         ofd = STDOUT_FILENO;
 158                                 } else {
 159                                         if (nread<1) {
 160                                                 // Close outgoing half-connection so they get EOF, but
 161                                                 // leave incoming alone so we can see response.
 162                                                 shutdown(cfd, 1);
 163                                                 FD_CLR(STDIN_FILENO, &readfds);
 164                                         }
 165                                         ofd = cfd;
 166                                 }
 167
 168                                 xwrite(ofd, bb_common_bufsiz1, nread);
 169                                 if (delay > 0) sleep(delay);
 170                         }
 171                 }
 172         }
 173 }