counter = pipe_write[0];

      if(counter < pipe_write[1])

	counter = pipe_write[1];

      if(counter < pipe_read[0])

	counter = pipe_read[0];

      if(counter < pipe_read[1])

	counter = pipe_read[1];

      counter2 = 0;

      maxfds = counter;

      while(counter > 2)

	{

	  if(!close(counter))

	    counter2 ++; /* record how many descriptors we still had open :-) */

	  counter --;

	}

      /* stderr is the only stream we haven't confiscated atm - just for fun - I will confiscate it later, though, to support parsing error messages */

      fprintf(stderr, "closed %d/%d fds before execing \"%s\"\n", counter2, maxfds, progname);

      /*

	now exec: execvp uses interpreter to find the file to exec

       */

      execvp(progname, argv);

      fprintf(stderr, "uh-oh, ``%s'' didn't start for execio\n", progname);

      exit(1);

    }

}

/*

  returns 1 if child has exited, 

  returns 0 if child is still alive

 */

int _execio_checkpid(struct execio *eio)

{

  int childstatus;

#ifdef _WIN32

  waitpid(eio->child, &childstatus, 0);

#else

  waitpid(eio->child, &childstatus, WNOHANG);

#endif

  /* perror()? */

  return WIFEXITED(childstatus);

}

{

  ssize_t ret;

  /*

    TODO: detect NULL eio? 

    TODO: errno?

    update status of eio for execio_status/to be able to cleanup subproc??

    whenever read() returns 0, it means EOF

   */

  ret = read(eio->pipe_read, buf, len);

  if(ret == -1)

    {

      (*bytesread) = 0;

      perror("read");

      switch(errno)

	{

	case EAGAIN:

	case EINTR:

	  return 0;

	  break;

	default:

	  return 1;

	}

    }

  (*bytesread) = (size_t)ret;

  if(!ret)

    {

      /* should also be able to figure out if is bad fd and should set EXECIO_STATE_ERROR instead of _EOF */

      eio->state = EXECIO_STATE_EOF;

      return 1;

    }

  return 0;

}

{

  errno = 0;

  (*bytesread) = write(eio->pipe_write, buf, len);

  if(!*bytesread)

    {

      switch(errno)

	{

	case EPIPE:

	  /* 

	     the program closed the pipe (died)

	  */

	fprintf(stderr, "execio_write: the child program closed its stdin pipe\n");

	eio->state = EXECIO_STATE_EOF;

	break;

	default:

	  fprintf(stderr, "execio_write: unhandled error writing to an fd: \n");

	  perror("write");

	  eio->state = EXECIO_STATE_ERROR;

	  break;

	}

      return 1;

    }

  return 0;

}

enum execio_state execio_state(struct execio *eio)

{

  return eio->state;

}

int execio_close(struct execio *eio)

{

  int childstatus;

  close(eio->pipe_read);

  close(eio->pipe_write);

  /* maybe we should just kill rather than term the child */

  kill(eio->child, SIGTERM);

  /* 

     the waitpid(2) seems to indicate that only when the child is terminated will this wait return. 

     This are of code will probably need improving - the ability to seng SIGKILL after a timeout? So we'll output a debug line before running waitpid

  (at your option) any later version.

  DistRen 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 Affero General Public License for more details.

  You should have received a copy of the GNU Affero General Public License

  along with DistRen.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef _DISTREN_EXECIO_H

#define _DISTREN_EXECIO_H

/*

  This file tries to abstract away getting a socket/fd that talks to a spawned program

 */

#include <unistd.h>

enum execio_state

  {

    EXECIO_STATE_ERROR,

    EXECIO_STATE_EOF

  };

struct execio

{

  int pipe_write;

  int pipe_read;

  enum execio_state state;

  pid_t child;

};

/**

  runs progname with the arguments in argv. argv must be null terminated!!!!!!!!!

  returns nonzero return on error

*/

int execio_open(struct execio **eio, const char *progname, char *const argv[]);

/**

   doesn't block,

   returns 0 on success, 1 on failure

*/

/**

  use this function to determine if the using program should keep trying to read/write

  @todo is this function good enough/necessary?

 */

enum execio_state execio_state(struct execio *eio);

/**

   Closes an execio session.

   @return nonzero on error 

*/

int execio_close(struct execio *eio);

#endif

 * and remoteio_read() (?).

 */

struct remoteio_packet

{

  size_t len;

  char *data;

};

struct remoteio

{

  enum remoteio_method method;

  struct remoteio_opts *opts;

  struct execio *execio;

#ifndef WINDOWS

  int sock;

#endif

  remoteio_read_handle_func_t read_handler;

  /* for the read_handler */

  void *read_handler_data;

  /* so that read_handler_data can be cleaned up */

  remoteio_close_handle_func_t close_handler;

  /**

   * Store a buffer of data waiting to be processed.

   */

  struct remoteio_packet inbuf;

  /**

   * Provide the asynchronosity abstraction by queuing outgoing messages.

   */

  queue_t outmsgs;

  /**

   * This is disappointingly hacky. If this variable is 0, then

   * remoteio_close() will act normal. If set to 1, then

   * remoteio_close() will not actually free this struct but instead

   * increment this variable to 2. This is so that read_handler can

   * call remoteio_close() without segfaulting us.

   */

  short careful_free;

};

/* lookup table */

typedef int remoteio_open_func_t(struct remoteio *rem, struct remoteio_server *server);

typedef int remoteio_read_func_t(struct remoteio *rem, void *buf, size_t len, size_t *bytesread);

typedef int remoteio_close_func_t(struct remoteio *rem);

struct remoteio_method_funcmap

{

  enum remoteio_method method;

  remoteio_open_func_t *open_func;

  remoteio_read_func_t *read_func;

  remoteio_write_func_t *write_func;

  remoteio_close_func_t *close_func;

  char *name; /*< used for error messages */

};

int remoteio_config(cfg_t *cfg, struct remoteio_opts *opts);

#endif

#include "common/config.h"

#include "common/libremoteio.h"

#include "common/execio.h"

#include "common/asprintf.h"

#include <list.h>

#include <errno.h>

#ifndef _WIN32

#include <netdb.h>

#endif

#include <poll.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <sys/types.h>

#ifdef _WIN32

#include <winsock2.h>

#include <ws2tcpip.h>

#else

#include <sys/socket.h>

#endif

#include <unistd.h>

#include <queue.h>

#ifndef _WIN32

#include <sys/un.h>

#endif

/* local */

#define REMOTEIO_DEFAULT_PORT "4050"

int _remoteio_handle_write(multiio_context_t multiio,

			   int fd,

			   short revent,

			   struct remoteio_opts *opts,

			   struct remoteio *rem);

int _remoteio_handle_read(multiio_context_t multiio,

			  int fd,

			  short revent,

			  struct remoteio_opts *opts,

			  struct remoteio *rem);

int _remoteio_ssh_open(struct remoteio *rem, struct remoteio_server *server);

int _remoteio_ssh_read(struct remoteio *rem, void *buf, size_t len, size_t *bytesread);

int _remoteio_ssh_close(struct remoteio *rem);

/**

   ``named pipes''

 */

#ifndef _WIN32

int _remoteio_sock_open(struct remoteio *rem, struct remoteio_server *server);

int _remoteio_sock_close(struct remoteio *rem);

#endif

int _remoteio_sock_read(struct remoteio *rem, void *buf, size_t len, size_t *bytesread);

/**

   These borrow from _remoteio_sock_read() and _remoteio_sock_write().

 */

int _remoteio_tcp_open(struct remoteio *rem, struct remoteio_server *server);

int _remoteio_tcp_close(struct remoteio *rem);

/**

  lookup table for different methods of remoteio:

  the enum remoteio_method is the index of the entry to use for that method. 

  Regardless, a NULL terminator is required because the configuration function

  searches through this table for the method specified in the config file.

*/

struct remoteio_method_funcmap funcmap[] = 

  {

    /* [REMOTEIO_METHOD_SSH] */

    {REMOTEIO_METHOD_SSH, &_remoteio_ssh_open, &_remoteio_ssh_read, &_remoteio_ssh_write, &_remoteio_ssh_close, "ssh"},

#ifndef _WIN32

    {REMOTEIO_METHOD_UNIX, &_remoteio_sock_open, &_remoteio_sock_read, &_remoteio_sock_write, &_remoteio_sock_close, "unix"},

#endif

    {REMOTEIO_METHOD_TCP, &_remoteio_tcp_open, &_remoteio_sock_read, &_remoteio_sock_write, &_remoteio_tcp_close, "tcp"},

    {REMOTEIO_METHOD_SOCKET, NULL, &_remoteio_sock_read, &_remoteio_sock_write, &_remoteio_sock_close},

    {REMOTEIO_METHOD_MAX, NULL, NULL, NULL, NULL, NULL}

  };

struct remoteio_server *remoteio_getserver(const struct remoteio_opts *opts, const char *servername);

void remoteio_packet_free(struct remoteio_packet *packet);

int remoteio_config(cfg_t *cfg, struct remoteio_opts *opts)

{

  size_t numservers;

  size_t counter, counter2;

  static int haslisted_methods = 0;

  struct remoteio_server aserver;

  multiio_socket_type_register(opts->multiio, &opts->socket_type);

  multiio_event_handler_register(opts->multiio,

				 opts->socket_type,

				 POLLOUT,

				 (multiio_event_handler_func_t)&_remoteio_handle_write,

				 opts);

  multiio_event_handler_register(opts->multiio,

				 opts->socket_type,

				 POLLIN,

				 (multiio_event_handler_func_t)&_remoteio_handle_read,

      return 1;

    }

  /* expand the input buffer */

  packet.len = rem->inbuf.len + readlen;

  packet.data = malloc(rem->inbuf.len + readlen);

  if(!packet.data)

    {

      fprintf(stderr, "OOM!\n");

      return 1;

    }

  if(rem->inbuf.data)

    memcpy(packet.data, rem->inbuf.data, rem->inbuf.len);

  memcpy(packet.data + rem->inbuf.len, buf, readlen);

  free(rem->inbuf.data);

  memcpy(&rem->inbuf, &packet, sizeof(struct remoteio_packet));

  /*

   * readlen wil now keeps track of how many bytes the handler

   * function has read.

   *

   * Call the read_handler. Set careful_free, see remoteio_close(), so

   * that rem->read_handler() may call remoteio_close() without

   * segfaulting us ;-).

   */

  rem->careful_free = 1;

  readlen = (*rem->read_handler)(rem, rem->opts->generic_handler_data, rem->inbuf.data, rem->inbuf.len, rem->read_handler_data);

  if(rem->careful_free == 2)

    {

      rem->careful_free = 0;

      remoteio_close(rem);

      return 0;

    }

  rem->careful_free = 0;

  memmove(rem->inbuf.data, rem->inbuf.data + readlen, rem->inbuf.len - readlen);

  rem->inbuf.len -= readlen;

  return 0;

}

int remoteio_write(struct remoteio *rem, const void *buf, size_t len)

{

  struct remoteio_packet *packet;

  struct pollfd pollfd;

  /**

   * This is probably about the only optimization that exists in

   * distren.... :-D

   *

   * Write to the client immediately if there are no other messages

   * waiting and if the client will accept it.

   */

  if(q_empty(rem->outmsgs))

    {

      pollfd.fd = rem->sock;

      pollfd.revents = POLLOUT;

      pollfd.events = 0;

      poll(&pollfd, 1, 0);

      if(pollfd.events & POLLOUT)

	{

	  if(bytes_written > 0)

	    {

	      len -= bytes_written;

	      buf += bytes_written;

	    }

	}

    }

  /**

   * zero length is easy... and might be possible if the above

   * optimization works ;-)

   */

  if(!len)

    return 0;

  packet = malloc(sizeof(struct remoteio_packet));

  if(!packet)

    {

      fprintf(stderr, "OOM\n");

      return 1;

    }

  packet->len = len;

  packet->data = malloc(len);

  if(!packet->data)

    {

      free(packet);

      fprintf(stderr, "OOM\n");

      return 1;

    }

  memcpy(packet->data, buf, len);

  q_enqueue(rem->outmsgs, packet, 0);

  multiio_socket_event_enable(rem->opts->multiio, rem->sock, POLLOUT);

  return 0;

}

int _remoteio_handle_write(multiio_context_t multiio,

			   int fd,

			   short revent,

			   struct remoteio_opts *opts,

			   struct remoteio *rem)

{

  struct remoteio_packet *packet;

  size_t written_amount;

  /* backend-specific cleanup */

  rtn = funcmap[rem->method].close_func(rem);

  /* this part is normal ;-) */

  free(rem->inbuf.data);

  q_free(rem->outmsgs, (list_dealloc_func_t)remoteio_packet_free);

  free(rem);

  return rtn;

}

/**

 * Frees an entire packet, including the passed pointer. If you just

 * want the contents of the packet free()ed, just do

 * free(packet.data);

 */

void remoteio_packet_free(struct remoteio_packet *packet)

{

  free(packet->data);

  free(packet); 

}

int _remoteio_getserver_traverse(char *servername, struct remoteio_server *aserver)

{

  if(!strcmp(aserver->name, servername))

    return FALSE; /* stop traversal */

  return TRUE;

}

struct remoteio_server *remoteio_getserver(const struct remoteio_opts *opts, const char *servername)

{

  int traversal_result;

  char *dispensible_servername;

  dispensible_servername = strdup(servername); /* for the sake of constness... */

  traversal_result = list_traverse(opts->servers, dispensible_servername, (list_traverse_func_t)&_remoteio_getserver_traverse, LIST_FRNT | LIST_ALTR);

  free(dispensible_servername);

  if(traversal_result == LIST_OK)

    return (struct remoteio_server *)list_curr(opts->servers);

  return (struct remoteio_server *)NULL;

}

/**

   different remoteio methods' implementations:

 */

/*

  SSH, via execio

*/

int _remoteio_ssh_open(struct remoteio *rem, struct remoteio_server *server)

{

  char *userhost;

  char *sshargs[] = {rem->opts->ssh_command, NULL /* userhost */, "distrend", "-d", (char *)NULL};

  int rtn;

  if(server->username)

    _distren_asprintf(&userhost, "%s@%s", server->username, server->hostname);

  else

    userhost = strdup(server->hostname);

  sshargs[1] = userhost;

  rtn = execio_open( &rem->execio, "ssh", sshargs);

  if(rtn)

    {

      fprintf(stderr, "error opening remoteio channel to ssh userhost ``%s''\n" , userhost);

      free(userhost);

      return 1;

    }

  free(userhost);

  return 0;

}

int _remoteio_ssh_read(struct remoteio *rem, void *buf, size_t len, size_t *bytesread)

{

  return execio_read(rem->execio, buf, len, bytesread);

}

{

  return execio_write(rem->execio, buf, len, byteswritten);

}

int _remoteio_ssh_close(struct remoteio *rem)

{

  int rtn;

  rtn = execio_close(rem->execio);

  if(rtn)

    fprintf(stderr, "%s:%d: error closing execio\n", __FILE__, __LINE__);

  return rtn;

}

#ifndef _WIN32

/*

  local sockets implementation (``named pipes''), unix-only

 */

int _remoteio_sock_open(struct remoteio *rem, struct remoteio_server *server)

{

  int sock;

  struct sockaddr_un sockaddr;

  /*

    The POSIX docs pretty much say that I can't depend on sockpath being able to be longer than 

    some proprietary length. So, if the compiler specifies a long path for RUNSTATEDIR, it could

    cause a buffer overflow.

   */

  char *sockpath = RUNSTATEDIR "/distrend.sock";

  unsigned int sockaddr_len;

  sock = socket(AF_UNIX, SOCK_STREAM, 0);

  if(sock == -1)

    {

      perror("socket");

      return 1;

    }

  sockaddr.sun_family = AF_UNIX;

  /*

    The terminating NULL should not be included in what's copied to sun_path,

    although it won't hurt as long as strlen(sockpath) < max socket length

   */

  for(sockaddr_len = 0; sockpath[sockaddr_len]; sockaddr_len ++)

    sockaddr.sun_path[sockaddr_len] = sockpath[sockaddr_len];

  if(connect(sock, (struct sockaddr *)&sockaddr, sockaddr_len) == -1)

int _remoteio_sock_close(struct remoteio *rem)

{

  close(rem->sock);

  return 0;

}

int _remoteio_sock_read(struct remoteio *rem, void *buf, size_t len, size_t *bytesread)

{

  ssize_t readrtn;

  *bytesread = 0;

  readrtn = read(rem->sock, buf, len);

  /*

    The following is valid for blocking sockets:

   */

  if(readrtn == -1)

    {

      /*

	in this case, we may have been interrupted by a signal and errno == EINTR

	or the connection was reset and errno = ECONNRESET

	Some of these are not error conditions:

       */

      perror("read");

      if(errno != EINTR)

	{

	  fprintf(stderr, "error reading socket in remoteio_sock_read\n");

	  return 1;

	}

      return 0;

    }

  *bytesread = readrtn;

  if(!readrtn)

    {

      /*

	means EOF except when FD is in ``message-nondiscard'' or ``message-discard''

	modes.

       */

      return 1;

    }

  return 0;

}

{

  ssize_t writertn;

  writertn = write(rem->sock, buf, len);

  if(writertn == -1)

    {

      perror("write");

      if(errno != EINTR)

	{

	  fprintf(stderr, "error writing to socket in remoteio_sock_write()\n");

	  return 1;

	}

    }

  *byteswritten = writertn;

  if(!writertn)

    {

      /*

	should we consider this an error? I'm pretty

	sure we should :-/

       */

      fprintf(stderr, "write() returned 0 in remoteio_sock_write()\n");

      return 1;

    }

  return 0;

}

/**

   TCP, taking advantage of the two generic socks read/write functions:

 */

int _remoteio_tcp_open(struct remoteio *rem, struct remoteio_server *server)

{

  int tmp;

  int tmp2;

  int sock;

  char *hostname;

  char *port;

  struct addrinfo addrinfo_hints;

  struct addrinfo *addrinfo_res;

  static char *default_port = REMOTEIO_DEFAULT_PORT;

  /**

   @param read_handler_data the data to pass to the read_handler function.

   @param servername the name of the configuration file entry for the server.

   From this, information about how to make the outgoing connection is derived.

 */

int remoteio_open_server(struct remoteio **rem,

			 struct remoteio_opts *opts,

			 remoteio_read_handle_func_t read_handler,

			 void *read_handler_data,

			 remoteio_close_handle_func_t close_handler,

			 const char *servername);

/**

 * Initializes a remoteio instance for a socket that's already been floating

 * around for a while. I.e., this socket probably came from accept().

 *

 * @param rem a pointer to where the poiner to the newly allocated struct remoteio should be stored.

 * @param opts remoteio's options

 * @param read_handler the function to call when data has been read from the server.

 * @param read_handler_data the data to pass to the read_handler function.

 * @param opts self explanatory.

 */

int remoteio_open_socket(struct remoteio **rem,

			 struct remoteio_opts *opts,

			 remoteio_read_handle_func_t read_handler,

			 void *read_handler_data,

			 remoteio_close_handle_func_t close_handler,

			 int fd);

/**

 * Queue bytes to be written to the remote host.

 *

 * @param rem the remoteio handle

 * @param buf a buffer to be queued for writing. We will copy this, so the caller has to handle its memory (and free() it if necessary).

 * @param len number of bytes to grab from buf

 * @return 0 on success, 1 on failure

 */

int remoteio_write(struct remoteio *rem, const void *buf, size_t len);

/**

 * Closes a remoteio session.

 *

 * It is safe to call this function from within

 * remoteio_read_handle_func_t.

 *

 * @return nonzero on error

*/

int remoteio_close(struct remoteio *rem);

#endif