Re-init from old SVN checkout after data loss in 2019.HEADmaster

No history is preserved as our svn server is long gone.

1 files changed, 666 insertions, 0 deletions

diff --git a/src/test_pty.c b/src/test_pty.c
new file mode 100644
index 0000000..b1efae1
--- /dev/null
+++ b/src/test_pty.c
@@ -0,0 +1,666 @@
+#include "common.h"
+#include <gnunet/gnunet_util_lib.h>
+#include <termios.h>
+#include "mtypes.h"
+
+/****************************************************************************/
+/* Implemented after http://rachid.koucha.free.fr/tech_corner/pty_pdip.html */
+/****************************************************************************/
+
+#define LOG(kind,...)                          \
+  GNUNET_log (kind, __VA_ARGS__)
+
+#define LOG_DEBUG(...) LOG(GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
+
+#define LOG_ERROR(...) LOG(GNUNET_ERROR_TYPE_ERROR, __VA_ARGS__)
+
+#define TIMEOUT(secs) \
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, secs)
+
+#define DEFAULT_TIMEOUT TIMEOUT(30)
+
+#define BUF_SIZE 512
+
+/**
+ * handler for SIGCHLD.l  Register it just before forking
+ */
+static struct GNUNET_SIGNAL_Context *shc_chld;
+
+/**
+ * Task to kill the child
+ */
+static GNUNET_SCHEDULER_TaskIdentifier child_death_task;
+
+/**
+ * Task to read output from child
+ */
+static GNUNET_SCHEDULER_TaskIdentifier read_child_task;
+
+/**
+ * Pipe used to communicate shutdown via signal.
+ */
+static struct GNUNET_DISK_PipeHandle *sigpipe;
+
+static struct GNUNET_DISK_FileHandle *chld_io;
+
+static struct GNUNET_CONNECTION_Handle *conn;
+
+static struct GNUNET_CONNECTION_TransmitHandle *tx;
+
+static char **chld_argv;
+
+static char *cp;
+static struct termios tio;
+static  struct winsize ws;
+
+static int in_receive;
+
+static char buf[BUF_SIZE];
+static size_t buf_off;
+
+/**
+ * The process id of the child
+ */
+static pid_t child_pid;
+
+/**
+ * Function to copy NULL terminated list of arguments
+ *
+ * @param argv the NULL terminated list of arguments. Cannot be NULL.
+ * @return the copied NULL terminated arguments
+ */
+static char **
+copy_argv (char *const *argv)
+{
+  char **argv_dup;
+  unsigned int argp;
+
+  GNUNET_assert (NULL != argv);
+  for (argp = 0; NULL != argv[argp]; argp++) ;
+  argv_dup = GNUNET_malloc (sizeof (char *) * (argp + 1));
+  for (argp = 0; NULL != argv[argp]; argp++)
+    argv_dup[argp] = strdup (argv[argp]);
+  return argv_dup;
+}
+
+
+/**
+ * Frees the given NULL terminated arguments
+ *
+ * @param argv the NULL terminated list of arguments
+ */
+static void
+free_argv (char **argv)
+{
+  unsigned int argp;
+
+  for (argp = 0; NULL != argv[argp]; argp++)
+    GNUNET_free (argv[argp]);
+  GNUNET_free (argv);
+}
+
+
+/**
+ * shutdown task
+ */
+static void
+do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  if (NULL != chld_argv)
+  {
+    free_argv (chld_argv);
+    chld_argv = NULL;
+  }
+  if (NULL != conn)
+  {
+    if (in_receive)
+      GNUNET_CONNECTION_receive_cancel (conn);
+    if (NULL != tx)
+      GNUNET_CONNECTION_notify_transmit_ready_cancel (tx);
+    GNUNET_CONNECTION_destroy (conn);
+    conn = NULL;
+  }
+  if (0 != child_pid)
+  {
+    GNUNET_break (0 == kill (child_pid, SIGTERM));
+    LOG_DEBUG ("Child still running.  Delaying shutdown\n");
+    (void) GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, 
+                                  &do_shutdown, NULL);
+    return;
+  }
+  if (GNUNET_SCHEDULER_NO_TASK != child_death_task)
+  {
+    GNUNET_SCHEDULER_cancel (child_death_task);
+    child_death_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  if (NULL != chld_io)
+    GNUNET_DISK_file_close (chld_io);
+}
+
+
+/**
+ * Read the child processes output and send it to over network connection to waiter
+ */
+static void
+read_child (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+
+
+/**
+ * Function called to notify a client about the connection
+ * begin ready to queue more data.  "buf" will be
+ * NULL and "size" zero if the connection was closed for
+ * writing in the meantime.
+ *
+ * @param cls closure
+ * @param size number of bytes available in buf
+ * @param netbuf where the callee should write the message
+ * @return number of bytes written to buf
+ */
+static size_t
+do_tx (void *cls, size_t size, void *netbuf)
+{
+  tx = NULL;
+  if ((NULL == buf) || (0 == size))
+  {
+    LOG_ERROR ("Failure in connectivity\n");
+    GNUNET_SCHEDULER_shutdown ();
+    return 0;
+  }
+  GNUNET_assert (buf_off <= size);
+  (void) memcpy (netbuf, buf, buf_off);
+  size = buf_off;
+  buf_off = 0;
+  if (GNUNET_SCHEDULER_NO_TASK == read_child_task)
+    read_child_task = 
+        GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, chld_io,
+                                        &read_child, NULL);
+  return size;
+}
+
+
+/**
+ * Read the child processes output and send it to over network connection to waiter
+ */
+static void
+read_child (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  ssize_t rsize;
+
+  read_child_task = GNUNET_SCHEDULER_NO_TASK;
+  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+    return;
+  if (BUF_SIZE == buf_off)
+  {
+    GNUNET_assert (NULL != tx);
+    return;
+  }
+  rsize = GNUNET_DISK_file_read (chld_io, buf + buf_off, BUF_SIZE - buf_off);
+  if (rsize <= 0)
+  {
+    LOG_DEBUG ("Child stdout closed\n");
+    return;
+  }
+  buf_off += rsize;
+  if (NULL != tx)
+    GNUNET_CONNECTION_notify_transmit_ready_cancel (tx);
+  tx = GNUNET_CONNECTION_notify_transmit_ready (conn, buf_off, DEFAULT_TIMEOUT,
+                                                &do_tx, NULL);
+  if (BUF_SIZE == buf_off)
+    return;
+  read_child_task = 
+      GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, chld_io,
+                                      &read_child, NULL);
+}
+
+
+/**
+ * Task triggered whenever we receive a SIGCHLD (child
+ * process died).
+ *
+ * @param cls closure, NULL if we need to self-restart
+ * @param tc context
+ */
+static void
+child_died (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  const struct GNUNET_DISK_FileHandle *pr;
+  char c[16];
+
+  pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ);
+  child_death_task = GNUNET_SCHEDULER_NO_TASK;
+  if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
+  {
+    child_death_task =
+        GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                        pr, &child_died, NULL);
+    return;
+  }
+  /* consume the signal */
+  GNUNET_break (0 < GNUNET_DISK_file_read (pr, &c, sizeof (c)));
+  LOG_DEBUG ("Child died\n");
+  child_pid = 0;
+  GNUNET_SCHEDULER_shutdown ();
+  /* FIXME: read any of the left over output from child? */
+}
+
+
+/**
+ * Signal handler called for SIGCHLD.
+ */
+static void
+sighandler_child_death ()
+{
+  static char c;
+  int old_errno = errno;        /* back-up errno */
+
+  GNUNET_break (1 ==
+                GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle
+                                        (sigpipe, GNUNET_DISK_PIPE_END_WRITE),
+                                        &c, sizeof (c)));
+  errno = old_errno;            /* restore errno */
+}
+
+
+/**
+ * Configure the terminal for the child
+ */
+static int
+parse_term_mode (const struct MSH_MSG_PtyMode *msg)
+{
+  uint16_t *params;
+  unsigned int cnt;
+  unsigned int ns;
+  uint16_t msize;
+  size_t expected;
+  speed_t ospeed;
+  speed_t ispeed;
+
+  msize = ntohs (msg->header.size);
+  ns = ntohs (msg->nsettings);
+  expected = (sizeof (struct MSH_MSG_PtyMode) + (sizeof (uint16_t) * ns * 2));
+  if (msize < expected)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+#define PARSE_WIN_SIZE(field) \
+  ws.field = ntohs (msg->field);
+  PARSE_WIN_SIZE (ws_row);
+  PARSE_WIN_SIZE (ws_col);
+  PARSE_WIN_SIZE (ws_xpixel);
+  PARSE_WIN_SIZE (ws_ypixel);
+#undef PARSE_WIN_SIZE
+  ospeed = baud_to_speed (ntohl (msg->ospeed));
+  ispeed = baud_to_speed (ntohl (msg->ispeed));
+  if (0 != cfsetospeed (&tio, ospeed))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  if (0 != cfsetispeed (&tio, ispeed))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  params = (uint16_t *) &msg[1];
+  for (cnt = 0; cnt < ns; cnt++)
+  {
+    switch (ntohs (params[2 * cnt]))
+    {
+#define TTYCHAR(NAME,OP)                                \
+      case OP:                                          \
+        tio.c_cc[NAME] = ntohs (params[(2 * cnt)+1]);   \
+        break;
+#define TTYMODE(NAME, FIELD, OP)                \
+      case OP:                                  \
+        if (1 == ntohs (params[(2 * cnt)+1]))   \
+          tio.FIELD |= NAME;                    \
+        break;
+#include "ttymodes.h"
+#undef TTYCHAR
+#undef TTYMODE
+      
+    default:
+      GNUNET_assert (0);
+    }
+  }
+  if (0 == (msize - expected))
+    return GNUNET_OK;
+  cp = ((void *) msg) + expected;
+  if ('\0' != cp[(msize - expected) - 1])
+  {
+    GNUNET_break (0);
+    cp = NULL;
+    return GNUNET_OK;
+  }
+  cp = GNUNET_strdup (cp);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Create pty, fork, setup the tty modes and exec the given binary
+ */
+static int
+spawn_child (const struct MSH_MSG_PtyMode *msg)
+{
+  const char *fn;
+  int master;
+  int ret;
+
+  LOG_DEBUG ("Creating PTY\n");
+  master = posix_openpt (O_RDWR);
+  if (-1 == master)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "posix_openpt");
+    goto err_ret;
+  }
+  if (-1 == grantpt (master))
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "grantpt");
+    goto err_ret;
+  }
+  if (-1 == unlockpt (master))
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "unlockpt");
+    goto err_ret;
+  }
+  if (NULL == (fn = ptsname (master)))
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "ptsname");
+    goto err_ret;
+  }
+  shc_chld =
+      GNUNET_SIGNAL_handler_install (GNUNET_SIGCHLD, &sighandler_child_death);
+  ret = fork();
+  if (-1 == ret)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
+    goto err_ret;
+  }
+  if (0 != ret)
+  {
+    LOG_DEBUG ("Forked child successfully\n");
+    child_pid = ret;
+    chld_io = GNUNET_DISK_get_handle_from_int_fd (master);
+    read_child_task =
+        GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, chld_io,
+                                        &read_child, NULL);
+    return GNUNET_OK;
+  }
+  /* child process */
+  {
+    int slave;
+
+    close (master);
+    LOG_DEBUG ("Opening slave PTY %s\n", fn);
+    slave = open (fn, O_RDWR);
+    if (-1 == slave)
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "open");
+      _exit (1);
+    }
+    if (-1 == tcgetattr (slave, &tio))
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "tcsetattr");
+      _exit (1);
+    }
+    parse_term_mode (msg);
+    if (-1 == tcsetattr (slave, TCSANOW, &tio))
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "tcsetattr");
+      //_exit (1);                /* Ignore for now */
+    }
+    if (-1 == ioctl (slave, TIOCSWINSZ, &ws))
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "ioctl");
+      _exit (1);
+    }
+    if (-1 == setsid ())
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "setsid");
+      _exit (1);
+    }
+    close (0);
+    close (1);
+    close (2);
+    if ( (-1 == dup2 (slave, 0)) ||
+         (-1 == dup2 (slave, 1)) ||
+         (-1 == dup2 (slave, 2)) )
+    {
+      //GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "dup"); //we won't get it
+      //at this point
+      _exit (2);
+    }
+    close (slave);
+    LOG_DEBUG ("Execing %s\n", chld_argv[0]);
+    if (-1 == execvp (chld_argv[0], chld_argv))
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "execvp");
+      _exit (1);
+    }
+  }
+
+ err_ret:
+  GNUNET_SCHEDULER_shutdown ();
+  return GNUNET_SYSERR;
+}
+
+
+/**
+ * Callback function for data received from the network.  Note that
+ * both "available" and "err" would be 0 if the read simply timed out.
+ *
+ * @param cls closure
+ * @param buf pointer to received data
+ * @param available number of bytes availabe in "buf",
+ *        possibly 0 (on errors)
+ * @param addr address of the sender
+ * @param addrlen size of addr
+ * @param errCode value of errno (on errors receiving)
+ */
+static void
+net_receive (void *cls, const void *buf, size_t available,
+             const struct sockaddr * addr, socklen_t addrlen, int errCode)
+{
+  static enum {
+    STATE_HEADER = 0,
+    STATE_MSG,
+    STATE_FORWARD
+  } state;
+  static size_t rb;
+  struct GNUNET_TIME_Relative timeout;
+  static struct MSH_MSG_PtyMode *msg;
+  size_t rsize;
+  
+  in_receive = 0;
+  if (0 == available)
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  switch (state)
+  {
+  case STATE_HEADER:
+    {
+      static struct GNUNET_MessageHeader hdr;
+      uint16_t msize;
+
+      GNUNET_assert (available <= sizeof (hdr));
+      memcpy (((void *) &hdr) + rb, buf, available);
+      rb += available;
+      timeout = DEFAULT_TIMEOUT;
+      rsize = sizeof (hdr) - rb;
+      if (0 != rsize)
+        goto read_again;
+      if (MSH_MTYPE_PTY_MODE != ntohs (hdr.type))
+      {
+        GNUNET_break_op (0);
+        GNUNET_SCHEDULER_shutdown ();
+        return;
+      }
+      msize = ntohs (hdr.size);
+      msg = GNUNET_malloc (msize);
+      memcpy (msg, &hdr, sizeof (hdr));
+      rsize = msize - sizeof (hdr);
+      state = STATE_MSG;
+      goto read_again;
+    }
+  case STATE_MSG:
+    {
+      uint16_t msize;
+      
+      msize = ntohs (msg->header.size);
+      GNUNET_assert (available <= (msize - rb));
+      memcpy (((void *) msg) + rb, buf, available);
+      rb += available;
+      timeout = DEFAULT_TIMEOUT;
+      rsize = msize - rb;
+      if (0 != rsize)
+        goto read_again;
+      spawn_child (msg);
+      GNUNET_free (msg);
+      msg = NULL;
+      state = STATE_FORWARD;
+    }
+    break;
+  case STATE_FORWARD:
+    /* receive from net and write to child pty */
+    {
+      size_t wb;
+      ssize_t ret;
+
+      wb = 0;
+      do {
+        ret = GNUNET_DISK_file_write (chld_io, buf + wb, available - wb);
+        if (GNUNET_SYSERR == ret)
+        {
+          GNUNET_break (0);
+          GNUNET_SCHEDULER_shutdown ();
+          return;
+        }
+        wb += ret;
+      } while (wb < available);
+    }
+    break;
+  }
+  rsize = BUF_SIZE;
+  timeout = GNUNET_TIME_UNIT_FOREVER_REL;
+  
+ read_again:
+  GNUNET_CONNECTION_receive (conn, rsize, timeout, &net_receive, NULL);
+  in_receive = 1;
+}
+
+
+/**
+ * Main function that will be run by the scheduler.
+ *
+ * @param cls closure
+ * @param args remaining command-line arguments
+ * @param cfgfile name of the configuration file used (for saving, can be NULL!)
+ * @param c configuration
+ */
+static void
+run (void *cls, 
+     char *const *args, 
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
+{
+  unsigned int argc;
+  const char *hostname;
+  const char *portstr;
+  struct sockaddr *addr;
+  struct addrinfo *res;
+  struct addrinfo hints;
+  int af_family;
+  socklen_t addrlen;
+  int ret;
+  
+  argc = 0;
+  hostname = args[argc++];
+  if (NULL == hostname)
+  {
+    GNUNET_break (0); 
+    return;
+  }
+  portstr = args[argc++];
+  if (NULL == portstr)
+  {
+    GNUNET_break (0); 
+    return;
+  }
+  if (NULL == args[argc])
+  {
+    GNUNET_break (0); 
+    return;
+  }
+  (void) memset (&hints, 0, sizeof (hints));
+  hints.ai_flags = AI_NUMERICSERV;
+  hints.ai_family = AF_INET;
+  hints.ai_socktype = SOCK_STREAM;
+  ret = getaddrinfo (hostname, portstr, &hints, &res);
+  if (0 != ret)
+  {
+    LOG_ERROR ("getaddrinfo() failed: %s\n", gai_strerror (ret));
+    return;
+  }
+  if (NULL == res)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  addrlen = res->ai_addrlen;
+  addr = GNUNET_malloc (addrlen);
+  memcpy (addr, res->ai_addr, addrlen);
+  af_family = res->ai_family;
+  freeaddrinfo (res);
+  conn = GNUNET_CONNECTION_create_from_sockaddr (af_family, addr, addrlen);
+  GNUNET_free (addr);
+  if (NULL == conn)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  GNUNET_CONNECTION_receive (conn, sizeof (struct GNUNET_MessageHeader),
+                             DEFAULT_TIMEOUT, &net_receive, NULL);
+  in_receive = 1;
+  child_death_task =
+    GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                    GNUNET_DISK_pipe_handle (sigpipe,
+                                                             GNUNET_DISK_PIPE_END_READ),
+                                    &child_died, NULL);
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
+                                &do_shutdown, NULL);
+  chld_argv = copy_argv (&args[argc]);
+  return;
+}
+
+
+int main(int argc, char *const argv[])
+{
+  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_OPTION_END
+  };
+  int ret;
+
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
+    return 2;
+  if (NULL == (sigpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, 
+                                           GNUNET_NO, GNUNET_NO)))
+  {
+    GNUNET_break (0);
+    return 1;
+  }
+  ret = 
+      GNUNET_PROGRAM_run (argc, argv, "test-pty",
+                          gettext_noop
+                          ("msh-waiter test program"),
+                          options, &run, NULL);
+  if (NULL != shc_chld)
+    GNUNET_SIGNAL_handler_uninstall (shc_chld);
+  GNUNET_DISK_pipe_close (sigpipe);
+  GNUNET_free ((void *) argv);
+  LOG_DEBUG ("Exiting\n");
+  return ret;
+}