/* netcat.c - Forward stdin/stdout to a file or network connection. * * Copyright 2007 Rob Landley * * TODO: udp, ipv6, genericize for telnet/microcom/tail-f USE_NETCAT(OLDTOY(nc, netcat, TOYFLAG_USR|TOYFLAG_BIN)) USE_NETCAT(NEWTOY(netcat, USE_NETCAT_LISTEN("^tlL")"w#W#p#s:q#f:"USE_NETCAT_LISTEN("[!tlL][!Lw]"), TOYFLAG_BIN)) config NETCAT bool "netcat" default y help usage: netcat [-u] [-wpq #] [-s addr] {IPADDR PORTNUM|-f FILENAME} -f use FILENAME (ala /dev/ttyS0) instead of network -p local port number -q quit SECONDS after EOF on stdin, even if stdout hasn't closed yet. -s local source address -w SECONDS timeout to establish connection -W SECONDS timeout for idle connection Use "stty 115200 -F /dev/ttyS0 && stty raw -echo -ctlecho" with netcat -f to connect to a serial port. config NETCAT_LISTEN bool "netcat server options (-let)" default y depends on NETCAT help usage: netcat [-t] [-lL COMMAND...] -l listen for one incoming connection -L listen for multiple incoming connections (server mode) -t allocate tty (must come before -l or -L) The command line after -l or -L is executed (as a child process) to handle each incoming connection. If blank -l waits for a connection and forwards it to stdin/stdout. If no -p specified, -l prints port it bound to and backgrounds itself (returning immediately). For a quick-and-dirty server, try something like: netcat -s 127.0.0.1 -p 1234 -tL /bin/bash -l */ #define FOR_netcat #include "toys.h" GLOBALS( char *filename; // -f read from filename instead of network long quit_delay; // -q Exit after EOF from stdin after # seconds. char *source_address; // -s Bind to a specific source address. long port; // -p Bind to a specific source port. long idle; // -W Wait # seconds for more data long wait; // -w Wait # seconds for a connection. ) static void timeout(int signum) { if (TT.wait) error_exit("Timeout"); // This should be xexit() but would need siglongjmp()... exit(0); } static void set_alarm(int seconds) { xsignal(SIGALRM, seconds ? timeout : SIG_DFL); alarm(seconds); } // Translate x.x.x.x numeric IPv4 address, or else DNS lookup an IPv4 name. static void lookup_name(char *name, uint32_t *result) { struct hostent *hostbyname; hostbyname = gethostbyname(name); // getaddrinfo if (!hostbyname) error_exit("no host '%s'", name); *result = *(uint32_t *)*hostbyname->h_addr_list; } // Worry about a fancy lookup later. static void lookup_port(char *str, uint16_t *port) { *port = SWAP_BE16(atoi(str)); } void netcat_main(void) { struct sockaddr_in *address = (void *)toybuf; int sockfd=-1, in1 = 0, in2 = 0, out1 = 1, out2 = 1; pid_t child; // Addjust idle and quit_delay to miliseconds or -1 for no timeout TT.idle = TT.idle ? TT.idle*1000 : -1; TT.quit_delay = TT.quit_delay ? TT.quit_delay*1000 : -1; set_alarm(TT.wait); // The argument parsing logic can't make "<2" conditional on other // arguments like -f and -l, so we do it by hand here. if ((toys.optflags&FLAG_f) ? toys.optc : (!(toys.optflags&(FLAG_l|FLAG_L)) && toys.optc!=2)) help_exit("bad argument count"); if (TT.filename) in1 = out2 = xopen(TT.filename, O_RDWR); else { // Setup socket sockfd = xsocket(AF_INET, SOCK_STREAM, 0); fcntl(sockfd, F_SETFD, FD_CLOEXEC); setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &out1, sizeof(out1)); address->sin_family = AF_INET; if (TT.source_address || TT.port) { address->sin_port = SWAP_BE16(TT.port); if (TT.source_address) lookup_name(TT.source_address, (uint32_t *)&(address->sin_addr)); if (bind(sockfd, (struct sockaddr *)address, sizeof(*address))) perror_exit("bind"); } // Dial out if (!CFG_NETCAT_LISTEN || !(toys.optflags&(FLAG_L|FLAG_l))) { // Figure out where to dial out to. lookup_name(*toys.optargs, (uint32_t *)&(address->sin_addr)); lookup_port(toys.optargs[1], &(address->sin_port)); // TODO xconnect if (connect(sockfd, (struct sockaddr *)address, sizeof(*address))<0) perror_exit("connect"); in1 = out2 = sockfd; // Listen for incoming connections } else { socklen_t len = sizeof(*address); if (listen(sockfd, 5)) error_exit("listen"); if (!TT.port) { getsockname(sockfd, (struct sockaddr *)address, &len); printf("%d\n", SWAP_BE16(address->sin_port)); fflush(stdout); // Return immediately if no -p and -Ll has arguments, so wrapper // script can use port number. if (CFG_TOYBOX_FORK && toys.optc && xfork()) goto cleanup; } for (;;) { child = 0; len = sizeof(*address); // gcc's insane optimizer can overwrite this in1 = out2 = accept(sockfd, (struct sockaddr *)address, &len); if (in1<0) perror_exit("accept"); // We can't exit this loop or the optimizer's "liveness analysis" // combines badly with vfork() to corrupt or local variables // (the child's call stack gets trimmed and the next function call // stops the variables the parent tries to re-use next loop) // So there's a bit of redundancy here // We have a connection. Disarm timeout. set_alarm(0); if (toys.optc) { // Do we need a tty? // TODO nommu, and -t only affects server mode...? Only do -t with optc // if (CFG_TOYBOX_FORK && (toys.optflags&FLAG_t)) // child = forkpty(&fdout, NULL, NULL, NULL); // else // Do we need to fork and/or redirect for exec? if (toys.optflags&FLAG_L) { toys.stacktop = 0; child = vfork(); } if (child<0) error_msg("vfork failed\n"); else { if (child) { close(in1); continue; } dup2(in1, 0); dup2(in1, 1); if (toys.optflags&FLAG_L) dup2(in1, 2); if (in1>2) close(in1); xexec(toys.optargs); } } pollinate(in1, in2, out1, out2, TT.idle, TT.quit_delay); close(in1); } } } // We have a connection. Disarm timeout. set_alarm(0); pollinate(in1, in2, out1, out2, TT.idle, TT.quit_delay); cleanup: if (CFG_TOYBOX_FREE) { close(in1); close(sockfd); } }