Drag into the 21st century.

[sw-tools] / src / sw_rsh.c

/* -*-c-*-
 *
 * $Id$
 *
 * Run remote commands
 *
 * (c) 1999 EBI
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of sw-tools.
 *
 * sw-tools is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * sw-tools is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with sw-tools; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Header files ------------------------------------------------------*/

#include "config.h"

#include <ctype.h>
#include <errno.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>
#include <sys/time.h>
#include <fcntl.h>
#include <unistd.h>

#include <sys/socket.h>
#include <sys/wait.h>

#ifndef DECL_ENVIRON
  extern char **environ;
#endif

#include <mLib/alloc.h>
#include <mLib/bits.h>
#include <mLib/dstr.h>
#include <mLib/exc.h>
#include <mLib/mdwopt.h>
#include <mLib/quis.h>
#include <mLib/report.h>
#include <mLib/sym.h>

#define RCMD_LINK 0
#include "sw_arch.h"
#include "sw_build.h"
#include "sw_env.h"
#include "sw_rsh.h"

/*----- Data structures ---------------------------------------------------*/

#define PKHEADSZ 3

/*----- Static variables --------------------------------------------------*/

static int handler = 0;
static rcmd *rcmds = RCMD_LINK;

/*----- Packet interface --------------------------------------------------*/

/* --- @pksend@ --- *
 *
 * Arguments:	@sw_remote@ = pointer to the remote block
 *		@int type@ = packet type to send
 *		@const void *p@ = pointer to packet data
 *		@size_t sz@ = size of data to send
 *
 * Returns:	Zero if it worked, nonzero otherwise.
 *
 * Use:		Sends a data packet.  If the type is `data', then `sz' may be
 *		arbitrarily large and is divided into small enough chunks.
 *		Otherwise it's an error to send a packet that's too big.
 */

int pksend(sw_remote *r, int type, const void *p, size_t sz)
{
  octet h[PKHEADSZ];
  const char *q = p;
  size_t chunk;

  /* --- Sort out error conditions --- */

  if (sz > PKMAX && type != PKTYPE_DATA) {
    errno = E2BIG;
    return (-1);
  }

  /* --- Main output loop --- */

  h[2] = type;
  do {

    /* --- Set up the packet header --- */

    chunk = (sz > PKMAX ? PKMAX : sz);
    STORE16(h, chunk);

    /* --- Write the packet header --- */

  try_again:
    if (write(r->fdout, &h, PKHEADSZ) < PKHEADSZ) {
      if (errno == EINTR)
	goto try_again;
      return (-1);
    }

    /* --- Write the payload, if there is one --- *
     *
     * Maybe the OS won't want to bite it all off in one go.
     */

    while (chunk) {
      ssize_t n = write(r->fdout, q, chunk);
      if (n < 0 && errno != EINTR)
	return (-1);
      if (n > 0) {
	q += n;
	chunk -= n;
	sz -= n;
      }
    }
  } while (sz);

  /* --- Done --- */

  return (0);
}

/* --- @pkrecv@ --- *
 *
 * Arguments:	@sw_remote *r@ = remote block
 *
 * Returns:	Packet type received, or @-1@ for an error.
 *
 * Use:		Receives a packet from the remote host.  The packet data is
 *		placed in the block's buffer, the block's packet length is
 *		diddled appropriately.
 */

int pkrecv(sw_remote *r)
{
  octet h[PKHEADSZ];
  size_t sz;
  char *p;
  ssize_t n;

  /* --- Read the packet header --- */

  sz = PKHEADSZ;
  p = (char *)&h;
  while (sz) {
    n = read(r->fdin, p, sz);
    if (n < 0 && errno != EINTR)
      return (-1);
    if (n == 0)
      return (PKTYPE_EOF);
    if (n > 0) {
      p += n;
      sz -= n;
    }
  }

  /* --- Hack for error messages --- *
   *
   * If it doesn't look like a valid packet, read a `chunk' and pretend it's
   * data.  This isn't too bad, because all the packet types are control
   * codes, and are unlikely to be in a textual message.
   *
   * Normally what happens here is that something sitting before the `sw'
   * program fails, reports a plain textual error, and exits.  Grabbing the
   * `last gasp' like this, then, traps that error message and allows
   * something to report it.  The rest ought to be completely silent, so I
   * get an `unexpected eof' and then drop everything.
   *
   * This is certainly better than the behaviour otherwise, which is an
   * @E2BIG@ message reported when the packet size is really ASCII
   * characters.
   */

  if (h[2] >= PKTYPE_BOGUS) {
    memcpy(r->buf, &h, PKHEADSZ);
    n = read(r->fdin, r->buf + PKHEADSZ, sizeof(r->buf) - PKHEADSZ);
    if (n < 0)
      return (-1);
    r->sz = n + PKHEADSZ;
    return (PKTYPE_DATA);
  }

  /* --- Sort out what's going on --- */

  sz = LOAD16(h);
  r->sz = sz;
  if (!sz)
    return (h[2]);
  if (sz > PKMAX) {
    errno = E2BIG;
    return (-1);
  }

  /* --- Read the packet payload --- */

  p = r->buf;
  while (sz) {
    n = read(r->fdin, p, sz);
    if (n < 0 && errno != EINTR)
      return (-1);
    if (n == 0)
      return (PKTYPE_EOF);
    if (n > 0) {
      p += n;
      sz -= n;
    }
  }

  return (h[2]);
}

/*----- Error reporting and exit statuses --------------------------------*/

/* --- @swexit@ --- *
 *
 * Arguments:	@sw_remote *r@ = remote context
 *		@int status@ = exit status to return
 *
 * Returns:	Doesn't.
 *
 * Use:		Reports the exit status via packet protocol and quits.
 */

void swexit(sw_remote *r, int status)
{
  unsigned char s = status;
  pksend(r, PKTYPE_STATUS, &s, 1);
  _exit(status);
}

/* --- @swsignal@ --- *
 *
 * Arguments:	@sw_remote *r@ = remote context
 *		@int sig@ = signal ocurrence to return
 *
 * Returns:	Doesn't.
 *
 * Use:		Reports a signalled-to-death status via packet protocol and
 *		quits.
 */

void swsignal(sw_remote *r, int sig)
{
#if defined(HAVE_STRSIGNAL)
  char *s = strsignal(sig);
#elif defined(HAVE__SYS_SIGLIST)
  char *s = _sys_siglist[sig];
#else
  char s[16];
  sprintf(s, "signal %i", sig);
#endif

  pksend(r, PKTYPE_STATUS, s, strlen(s) + 1);
  _exit(127);
}

/* --- @swwait@ --- *
 *
 * Arguments:	@sw_remote *r@ = remote context
 *		@int status@ = status answer from @wait@(2)
 *
 * Returns:	Doesn't.
 *
 * Use:		Reports a child's demise appropriately, and quits.
 */

void swwait(sw_remote *r, int status)
{
  if (WIFEXITED(status))
    swexit(r, WEXITSTATUS(status));
  else if (WIFSIGNALED(status))
    swsignal(r, WTERMSIG(status));
  else
    swexit(r, 126);
}

/* --- @swvprintf@ --- *
 *
 * Arguments:	@sw_remote *r@ = remote context
 *		@const char *format@ = format string
 *		@va_list ap@ = things to format
 *
 * Returns:	---
 *
 * Use:		Writes a string to the remote end.  This is the low-level bit
 *		of @swprintf@.
 */

void swvprintf(sw_remote *r, const char *format, va_list ap)
{
  dstr d = DSTR_INIT;
  dstr_vputf(&d, format, &ap);
  pksend(r, PKTYPE_DATA, d.buf, d.len);
  dstr_destroy(&d);
}

/* --- @swprintf@ --- *
 *
 * Arguments:	@sw_remote *r@ = remote context
 *		@const char *format@ = format string
 *		@...@ = other arguments
 *
 * Returns:	---
 *
 * Use:		Writes a string to the remote end.
 */

void swprintf(sw_remote *r, const char *format, ...)
{
  va_list ap;
  va_start(ap, format);
  swvprintf(r, format, ap);
  va_end(ap);
}

/* --- @swdie@ --- *
 *
 * Arguments:	@sw_remote *r@ = remote context
 *		@int status@ = exit status to report
 *		@const char *format@ = format string to fill in
 *		@...@ = other arguments
 *
 * Returns:	Doesn't.
 *
 * Use:		Reports a message and quits.
 */

void swdie(sw_remote *r, int status, const char *format, ...)
{
  va_list ap;
  dstr d = DSTR_INIT;

  va_start(ap, format);
  dstr_putf(&d, "%s [remote]: ", QUIS);
  dstr_vputf(&d, format, &ap);
  dstr_putc(&d, '\n');
  dstr_putz(&d);
  va_end(ap);
  pksend(r, PKTYPE_DATA, d.buf, d.len);
  dstr_destroy(&d);
  swexit(r, status);
}

/*----- Command handling and dispatch -------------------------------------*/

/* --- @remote@ --- *
 *
 * Arguments:	@sw_remote *r@ = pointer to remote block
 *		@const char *cmd@ = command to run
 *		@char *argv[]@ = argument array
 *		@char *env[]@ = environment variables
 *
 * Returns:	Doesn't.  Reports an exit status through packet protocol and
 *		quits.
 *
 * Use:		Dispatches a remote command.  At this point, the two code
 *		paths for local and remote invokation have joined again.
 */

static void remote(sw_remote *r, const char *cmd, char *argv[], char *env[])
{
  struct rcmd *p, *chosen = 0;
  size_t sz = strlen(cmd);

  /* --- Make sure that I can get the exit status of children --- */

  signal(SIGCHLD, SIG_DFL);

  /* --- Fix up the environment --- */

  {
    sym_table t;
    sym_create(&t);
    env_import(&t, env);
    if (env != environ) {
      free(env);
      env_import(&t, environ);
    }
    env_put(&t, "SW_ARCH", ARCH);
    env_file(&t, DATADIR "/sw-env");
    env = env_export(&t);
  }

  /* --- Dispatch to the command handler --- */

  for (p = rcmds; p; p = p->next) {
    if (strncmp(cmd, p->name, sz) == 0) {
      if (p->name[sz] == 0) {
	chosen = p;
	break;
      } else if (chosen)
	swdie(r, 1, "ambiguous remote command name `%s'", cmd);
      else
	chosen = p;
    }
  }
  if (!chosen)
    swdie(r, 1, "unknown remote command name `%s'", cmd);
  chosen->rcmd(r, argv, env);
}

/*----- Remote invocation -------------------------------------------------*/

/* --- @sendargv@ --- *
 *
 * Arguments:	@sw_remote *r@ = pointer to the remote context
 *		@int type@ = packet type to send with
 *		@char *v[]@ = pointer to the array to send
 *
 * Returns:	Zero if OK, nonzero if it failed.
 *
 * Use:		Sends something @argv@-shaped; i.e., an array of strings
 *		terminated by a null pointer.
 */

static int sendargv(sw_remote *r, int type, char *v[])
{
  dstr d = DSTR_INIT;
  int e;

  while (*v) {
    dstr_puts(&d, *v);
    d.len++;				/* Make the null `real' */
    v++;
  }
  e = pksend(r, type, d.buf, d.len);
  dstr_destroy(&d);
  return (e);
}

/* --- @snarfargv@ --- *
 *
 * Arguments:	@const char *buf@ = pointer to buffer
 *		@size_t sz@ = size of buffer
 *
 * Returns:	Pointer to argument array (allocated with @malloc@).
 *
 * Use:		Snarfs the null-terminated strings in the buffer and returns
 *		an array of them.  The whole lot, strings and array, is
 *		returned in one big chunk allocated from the heap.  Note that
 *		this means it's OK to throw the initial buffer away.
 */

static char **snarfargv(const char *buf, size_t sz)
{
  /* --- Initial setup --- */

  const char *p, *lim;
  char *q;
  size_t c;
  char **v, **w;

  /* --- Pass one: count the number of arguments --- */

  c = 0;
  p = buf;
  lim = p + sz;
  while (p < lim) {
    c++;
    while (*p) {
      p++;
      if (p >= lim)
	goto done_pass1;
    }
    p++;
  }
done_pass1:

  /* --- Allocate memory for everything --- */

  v = xmalloc((c + 1) * sizeof(char *) + sz + 1);
  q = (char *)(v + c + 1);
  memcpy(q, buf, sz);

  /* --- Pass two: set up the arrays --- */

  lim = q + sz;
  w = v;
  while (q < lim) {
    *w++ = q;
    while (*q) {
      q++;
      if (q >= lim)
	goto done_pass2;
    }
    q++;
  }
done_pass2:
  *w++ = 0;
  *q++ = 0;

  /* --- Done --- */

  return (v);
}

/* --- @swrsh_remote@ --- *
 *
 * Arguments:	@const char *cmd@ = the command to perform
 *
 * Returns:	Doesn't.  Reports an exit status through packet protocol and
 *		quits.
 *
 * Use:		Handles the remote end of a remote job invokation.
 */

void swrsh_remote(const char *cmd)
{
  sw_remote r;
  static char *dummy = 0;
  char **argv = 0;
  char **env = 0;
  char *dir = 0;
  r.fdin = 0;
  r.fdout = 1;

 /* --- Read packets from the remote host --- */

  for (;;) {
    int t = pkrecv(&r);
    switch (t) {
      case -1:
	swdie(&r, 1, "error reading packet: %s", strerror(errno));
	break;
      case PKTYPE_EOF:
	goto done;
      case PKTYPE_ARGS:
	if (argv)
	  free(argv);
	argv = snarfargv(r.buf, r.sz);
	break;
      case PKTYPE_ENV:
	if (env)
	  free(env);
	env = snarfargv(r.buf, r.sz);
	break;
      case PKTYPE_DIR:
	if (dir)
	  free(dir);
	r.buf[r.sz] = 0;
	dir = xstrdup(r.buf);
	break;
      case PKTYPE_GO:
	goto done;
      case PKTYPE_DATA:
      case PKTYPE_STATUS:
	swdie(&r, 1, "internal error: unexpected packet");
	break;
    }
  }

  /* --- Sort out any missing arguments --- */

done:
  if (!argv)
    argv = &dummy;
  if (!env)
    env = &dummy;
  if (dir)
    chdir(dir);

  /* --- Run the command --- */

  TRY
    remote(&r, cmd, argv, env);
  CATCH switch (exc_type) {
    case EXC_NOMEM: {
      static char msg[] = "\nsw [remote]: not enough memory\n";
      pksend(&r, PKTYPE_DATA, msg, sizeof(msg) - 1);
      swexit(&r, 1);
    } break;
    default:
      swdie(&r, 1, "uncaught exception, type = %lx", exc_type);
  } END_TRY;
}

/*----- Starting remote jobs ----------------------------------------------*/

/* --- @sigchld@ --- *
 *
 * Arguments:	@int sig@ = the signal number
 *
 * Returns:	---
 *
 * Use:		Catches @SIGCHLD@ and reaps any children that have lost.
 */

static void sigchld(int sig)
{
  int e = errno;
#ifdef DEBUG_SIGCHLD
  int status;
  while (waitpid(-1, &status, WNOHANG) > 0) {
    if (WIFEXITED(status)) {
      fprintf(stderr, "reap child with exit status %i\n",
	      WEXITSTATUS(status));
    } else if (WIFSIGNALED(status)) {
      fprintf(stderr, "reap child killed by signal %s\n",
	      strsignal(WTERMSIG(status)));
    } else
      fprintf(stderr, "reaped bizarre child which is still alive\n");
  }
#else
  while (waitpid(-1, 0, WNOHANG) > 0)
    ;
#endif
  errno = e;
}

/* --- @swrsh@ --- *
 *
 * Arguments:	@sw_remote *r@ = remote process block to look after
 *		@const char *host@ = host to run on (0 for this one)
 *		@const char *cmd@ = remote command to run
 *		@char *argv[]@ = arguments to pass on
 *
 * Returns:	Zero if it worked, nonzero if not.
 *
 * Use:		Runs a command on a remote host.  The argument array is
 *		mangled to come out OK at the far end.  The environment and
 *		current directory are also passed along, and pop out the
 *		other end unmolested.
 */

int swrsh(sw_remote *r, const char *host, const char *cmd, char *argv[])
{
  int sk[2];
  pid_t kid;

  /* --- Get a socket pair for communicating with the other end --- */

  if (socketpair(PF_UNIX, SOCK_STREAM, 0, sk))
    goto tidy_0;

  /* --- Set up a signal handler --- */

  if (!handler) {
    struct sigaction sa;
    sa.sa_handler = sigchld;
    sa.sa_flags = SA_NOCLDSTOP;
#ifdef SA_RESTART
    sa.sa_flags |= SA_RESTART;
#endif
    sigemptyset(&sa.sa_mask);
    sigaction(SIGCHLD, &sa, 0);
    handler = 1;
  }

  /* --- Fork off a child to cope with stuff --- */

  kid = fork();
  if (kid < 0)
    goto tidy_1;

  /* --- Handle the child process --- *
   *
   * If this is a local job, then just loop around inside to handle the
   * `remote' command.  Otherwise crank up `rsh' and pass the command over to
   * a remote copy of myself.
   *
   * (Why do I need a separate process for local jobs?  I don't really, but
   * it makes everything much simpler when running multiple jobs at the same
   * time.)
   */

  if (kid == 0) {
    close(sk[0]);

    /* --- Child end of a local job --- */

    signal(SIGINT, SIG_DFL);
    signal(SIGQUIT, SIG_DFL);

    if (!host) {
      r->fdin = r->fdout = sk[1];
      remote(r, cmd, argv, environ);
    }

    /* --- Local child end of a remote job --- */

    else {
      const char *rsh;
      dup2(sk[1], 0);
      dup2(sk[1], 1);
      dup2(sk[1], 2);
      if (sk[1] > 2)
	close(sk[1]);
      rsh = getenv("SW_RSH");
      if (!rsh)
	rsh = RSH;
      execlp(rsh, rsh, host, PATH_SW, "--remote", cmd, (char *)0);
    }

    /* --- I don't expect either to come back --- */

    _exit(1);
  }

  /* --- Local sort out of what to do --- *
   *
   * Either way, I've now got a socket tied to something which speaks my
   * communication protocol.  However, if this is a local job, then I can get
   * going right away; otherwise, I've got to transmit various bits of
   * information over the protocol.
   */

  r->fdin = r->fdout = sk[0];
  close(sk[1]);

  if (host) {
    char buf[PKMAX];
    if (!getcwd(buf, sizeof(buf)))
      goto tidy_1;
    sendargv(r, PKTYPE_ARGS, argv);
    sendargv(r, PKTYPE_ENV, environ);
    pksend(r, PKTYPE_DIR, buf, strlen(buf) + 1);
    pksend(r, PKTYPE_GO, 0, 0);
  }

  /* --- Ready to rock'n'roll --- */

  r->sz = 0;
  return (0);

  /* --- Tidy up if it failed --- */

tidy_1:
  close(sk[0]);
  close(sk[1]);
tidy_0:
  return (-1);
}

/*----- Subcommands -------------------------------------------------------*/

/* --- @swrsh_rsh@ --- */

void rsw_rsh(sw_remote *r, char *argv[], char *env[])
{
  pid_t kid, k;
  int pfd[2];
  int status;

  /* --- Create a pipe --- */

  if (pipe(pfd))
    swdie(r, 1, "couldn't create pipe: %s", strerror(errno));

  /* --- Start the child process up --- */

  kid = fork();
  if (kid < 0)
    swdie(r, 1, "fork failed: %s", strerror(errno));
  else if (kid == 0) {
    int fd;

    /* --- Use my new environment --- */

    environ = env; /* Yuk. */

    /* --- Fiddle with pipe file descriptors --- */

    close(pfd[0]);
    dup2(pfd[1], 1);
    dup2(pfd[1], 2);
    if (pfd[1] > 2)
      close(pfd[1]);

    /* --- Make sure it doesn't get any input --- */

    close(0);
    fd = open("/dev/null", O_RDONLY);
    if (fd != 0) {
      dup2(fd, 0);
      close(fd);
    }

    /* --- Run the program --- */

    execvp(argv[0], argv);
    die(1, "couldn't exec `%s': %s", argv[0], strerror(errno));
  }

  /* --- Read the data from the pipe until it closes --- */

  close(pfd[1]);
  for (;;) {
    ssize_t n = read(pfd[0], r->buf, sizeof(r->buf));
    if (n < 0)
      swdie(r, 1, "read error: %s", strerror(errno));
    else if (!n)
      break;
    else
      pksend(r, PKTYPE_DATA, r->buf, n);
  }
  close(pfd[0]);

  /* --- Finally, reap the exit status and pass it on --- */

  for (;;) {
    k = wait(&status);
    if (k == kid)
      break;
    if (k < 0)
      swdie(r, 1, "error reaping child: %s", strerror(errno));
  }
  swwait(r, status);
}

/* --- @sw_rsh@ --- */

int sw_rsh(int argc, char *argv[])
{
  sw_remote r;
  char *h;
  int status = 1;

  /* --- Check the arguments --- */

  if (argc < 3)
    die(1, "Usage: rsh HOST|ARCH COMMAND [ARGS...]");

  /* --- Translate architecture names into hostnames --- */

  if (strcmp(argv[1], "-") == 0)
    h = 0;
  else {
    archent *a = arch_lookup(argv[1], 0);
    if (!a)
      h = argv[1];
    else if (a->flags & archFlag_home)
      h = 0;
    else
      h = a->host;
  }

  /* --- Start the remote process --- */

  if (swrsh(&r, h, "rsh", argv + 2))
    die(1, "remote shell failed: %s", strerror(errno));

  /* --- Cope with packets from the remote process --- */

  fflush(stdout);
  for (;;) {
    int t = pkrecv(&r);
    switch (t) {
      case -1:
	die(1, "error reading packet: %s", strerror(errno));
      case PKTYPE_DATA:
	write(STDOUT_FILENO, r.buf, r.sz);
	break;
      case PKTYPE_STATUS:
	r.buf[r.sz] = 0;
	if (r.sz > 1) {
	  status = 127;
	  moan("command exited due to signal: %s", r.buf);
	} else {
	  status = r.buf[0];
	    moan("command exited with status %i", r.buf[0]);
	}
	goto done;
      case PKTYPE_EOF:
	moan("command exited unexpectedly");
	goto done;
      default:
	die(1, "unexpected packet type");
    }
  }

  /* --- Finished --- */

done:
  close(r.fdin);
  return (status);
}

/*----- That's all, folks -------------------------------------------------*/