/* rget 2.6 - remote pipe Author: Kees J. Bot

* 20 Mar 1989

*

* here$ ... | rput key there$ rget -h here key | ...

* here$ rput key command ... there$ rget -h here key command ...

*

* (Once my first try at network programming, completely reworked by now.)

*/

#define nil ((void*)0)

#include <sys/types.h>

#include <sys/ioctl.h>

#include <stdio.h>

#include <fcntl.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <errno.h>

#if __minix

#include <net/gen/in.h>

#include <net/gen/inet.h>

#include <netdb.h>

#include <net/gen/socket.h>

#include <net/gen/tcp.h>

#include <net/gen/tcp_hdr.h>

#include <net/gen/tcp_io.h>

#include <net/hton.h>

#include <net/netlib.h>

#else

#include <sys/socket.h>

#include <netinet/in.h>

#include <netdb.h>

#endif

static char *name;

static int iflag, oflag, hflag, lflag, cflag; /* -iolch? */

static char *host; /* Argument to -h. */

static struct hostent *hent; /* gethostbyname(host) */

static char *key; /* key (port) */

static char **cmdv; /* command [arg ...] */

static void fatal(const char *label)

{

int err= errno;

fprintf(stderr, "%s: %s: %s\n", name, label, strerror(err));

exit(1);

}

static unsigned name2port(char *n)

{

char *end;

unsigned port;

port= strtoul(n, &end, 0);

if (end == n || *end != 0) {

port= 1;

while (*n != 0) port *= (*n++ & 0xFF);

port |= 0x8000;

}

return htons(port & 0xFFFF);

}

static void usage(void)

{

fprintf(stderr,

"Usage: %s [-lcio] [-h host] key [command [arg ...]]\n"

"\t-l: Open TCP socket and listen (default for rput)\n"

"\t-c: Connect to a remote TCP socket (default for rget)\n"

"\t-i: Tie standard input to the TCP stream (default for rget)\n"

"\t-o: Tie standard output to the TCP stream (default for rput)\n"

"\t-io: Bidirectional!\n"

"\tkey: A word to hash into a port number, or simply a port number\n",

name);

exit(1);

}

int main(int argc, char **argv)

{

int i, s;

if ((name= strrchr(argv[0], '/')) == nil) name= argv[0]; else name++;

if (strcmp(name, "rget") != 0 && strcmp(name, "rput") != 0) {

fprintf(stderr, "Don't know what to do if you call me '%s'\n", name);

exit(1);

}

i= 1;

while (i < argc && argv[i][0] == '-') {

char *opt= argv[i++]+1;

if (opt[0] == '-' && opt[1] == 0) break; /* -- */

while (*opt != 0) switch (*opt++) {

case 'l': lflag= 1; break;

case 'c': cflag= 1; break;

case 'i': iflag= 1; break;

case 'o': oflag= 1; break;

case 'h':

hflag= 1;

if (*opt == 0) {

if (i == argc) usage();

opt= argv[i++];

}

host= opt;

opt= "";

break;

default: usage(); break;

}

}

if (i == argc) usage();

key= argv[i++];

cmdv= argv + i;

/* Defaults. */

if (!lflag && !cflag) {

if (name[1] == 'p') lflag= 1;

if (name[1] == 'g') cflag= 1;

}

if (!iflag && !oflag) {

if (name[1] == 'g') iflag= 1;

if (name[1] == 'p') oflag= 1;

}

/* Constraints. */

if (lflag && cflag) {

fprintf(stderr, "%s: -c and -l don't mix\n", name);

usage();

}

if (cflag && !hflag) {

fprintf(stderr, "%s: -c requires a host name given with -h\n", name);

usage();

}

if (lflag && hflag) {

fprintf(stderr, "%s: -l does not require a host name given with -h\n",

name);

usage();

}

if (iflag && oflag && cmdv[0] == nil) {

fprintf(stderr, "%s: -io requires that a command is given\n", name);

usage();

}

if (hflag) {

if ((hent= gethostbyname(host)) == nil) {

fprintf(stderr, "%s: %s: Name lookup failed\n", name, host);

exit(1);

}

}

s= -1;

if (lflag) {

/* We need to listen and wait. (We're "rput", most likely.) */

#if __minix

char *tcp_device;

struct nwio_tcpconf tcpconf;

struct nwio_tcpcl tcplistenopt;

if ((tcp_device= getenv("TCP_DEVICE")) == nil) tcp_device= "/dev/tcp";

if ((s= open(tcp_device, O_RDWR)) < 0) fatal(tcp_device);

tcpconf.nwtc_flags=

NWTC_EXCL | NWTC_LP_SET | NWTC_UNSET_RA | NWTC_UNSET_RP;

tcpconf.nwtc_locport= name2port(key);

if (ioctl(s, NWIOSTCPCONF, &tcpconf) < 0) fatal("NWIOSTCPCONF");

tcplistenopt.nwtcl_flags= 0;

if (ioctl(s, NWIOTCPLISTEN, &tcplistenopt) < 0) fatal("NWIOTCPLISTEN");

#else

int sa;

struct sockaddr_in channel;

static int on= 1;

if ((s= socket(AF_INET, SOCK_STREAM, IPPROTO_TCP))<0) fatal("socket()");

(void) setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *) &on,

sizeof(on));

memset(&channel, 0, sizeof(channel));

channel.sin_family= AF_INET;

channel.sin_addr.s_addr= htonl(INADDR_ANY);

channel.sin_port= name2port(key);

if (bind(s, (struct sockaddr *) &channel, sizeof(channel)) < 0)

fatal("bind()");

if (listen(s, 0) < 0) fatal("listen()");

if ((sa= accept(s, nil, nil)) < 0) fatal("accept()");

close(s);

s= sa;

#endif

}

if (cflag) {

/* Connect to the remote end. (We're "rget", most likely.) */

#if __minix

int n;

char *tcp_device;

nwio_tcpconf_t tcpconf;

nwio_tcpcl_t tcpconnopt;

if ((tcp_device= getenv("TCP_DEVICE")) == nil) tcp_device= "/dev/tcp";

n=60;

for (;;) {

if ((s= open(tcp_device, O_RDWR)) < 0) fatal(tcp_device);

tcpconf.nwtc_flags= NWTC_LP_SEL | NWTC_SET_RA | NWTC_SET_RP;

memcpy(&tcpconf.nwtc_remaddr, hent->h_addr,

sizeof(tcpconf.nwtc_remaddr));

tcpconf.nwtc_remport= name2port(key);

if (ioctl(s, NWIOSTCPCONF, &tcpconf) < 0) fatal("NWIOSTCPCONF");

tcpconnopt.nwtcl_flags= 0;

if (ioctl(s, NWIOTCPCONN, &tcpconnopt) == 0) break;

if (--n > 0) sleep(2); else fatal("NWIOTCPCONN");

close(s);

}

#else

int n;

struct sockaddr_in channel;

n=60;

for (;;) {

if ((s= socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)

fatal("socket()");

memset(&channel, 0, sizeof(channel));

channel.sin_family= AF_INET;

memcpy(&channel.sin_addr.s_addr, hent->h_addr,

sizeof(channel.sin_addr.s_addr));

channel.sin_port= name2port(key);

if (connect(s, (struct sockaddr *) &channel,

sizeof(channel)) >= 0) break;

if (--n > 0) sleep(2); else fatal("connect()");

close(s);

}

#endif

}

if (cmdv[0] != nil) {

/* A command is given, so execute it with standard input (rget),

* standard output (rput) or both (-io) tied to the TCP stream.

*/

if (iflag) dup2(s, 0);

if (oflag) dup2(s, 1);

close(s);

execvp(cmdv[0], cmdv);

fatal(cmdv[0]);

} else {

/* Without a command we have to copy bytes ourselves, probably to or

* from a command that is connected to us with a pipe. (The original

* function of rput/rget, a remote pipe.)

*/

int fi, fo;

int n;

char buf[8192];

if (iflag) {

fi= s;

fo= 1;

} else {

fi= 0;

fo= s;

}

while ((n= read(fi, buf, sizeof(buf))) > 0) {

char *bp= buf;

while (n > 0) {

int r;

if ((r= write(fo, bp, n)) <= 0) {

if (r == 0) {

fprintf(stderr, "%s: write(): Unexpected EOF\n", name);

exit(1);

}

fatal("write()");

}

bp+= r;

n-= r;

}

}

if (n < 0) fatal("read()");

}

return 0;

}