Make TELNET client do both read and write in parallel.

Author: larsbrinkhoff

src/telnet.c

@@ -4,6 +4,9 @@
 #include <unistd.h>
 #include <string.h>
 #include <getopt.h>
+#include <fcntl.h>
+#include <termios.h>
+#include <sys/wait.h>
 #include "ncp.h"
 
 #define OLD_TELNET    1
@@ -39,15 +42,31 @@
 #define OPT_SUPDUP              025
 #define OPT_SUPDUP_OUTPUT       026
 
+#define OMARK         0200
+#define OBREAK        0201
+#define ONOP          0202
+#define ONOECHO       0203
+#define OECHO         0204
+#define OHIDE         0205
+#define OASCII        0240
+#define OTRANSPARENT  0241
+#define OEBCDIC       0242
+
+static pid_t reader_pid = 0;
+static pid_t writer_pid = 0;
+static struct termios saved;
+
 static char options[] = {
   IAC, DO, OPT_ECHO,
   IAC, DO, OPT_SUPPRESS_GO_AHEAD,
   IAC, WILL, OPT_SUPPRESS_GO_AHEAD,
   0
 };
 
-static void option (unsigned char c)
+static void option (int fd)
 {
+  unsigned char c;
+  read (fd, &c, 1);
   switch (c) {
   case OPT_BINARY:
     break;
@@ -76,23 +95,23 @@ static void option (unsigned char c)
   }
 }
 
-static int special (unsigned char c, const unsigned char *data)
+static int special (unsigned char c, int fd)
 {
   switch (c) {
   case IAC:
     write (1, &c, 1);
     return 0;
   case DONT:
-    option (*data);
+    option (fd);
     return 1;
   case DO:
-    option (*data);
+    option (fd);
     return 1;
   case WONT:
-    option (*data);
+    option (fd);
     return 1;
   case WILL:
-    option (*data);
+    option (fd);
     return 1;
   case SB:
     return 0;
@@ -122,32 +141,187 @@ static int special (unsigned char c, const unsigned char *data)
   }
 }
 
-static void process (const unsigned char *data, int size)
+static void process_new (unsigned char data, int fd)
 {
-  int i;
+  switch (data) {
+  case NUL:
+    break;
+  case IAC:
+    read (fd, &data, 1);
+    special (data, fd);
+    break;
+  default:
+    write (1, &data, 1);
+    break;
+  }
+}
 
-  for (i = 0; i < size; i++) {
-    switch (data[i]) {
-    case NUL:
-      break;
-    case IAC:
-      i++;
-      i += special (data[i], &data[i + 1]);
-      break;
-    default:
-      write (1, &data[i], 1);
-      break;
+static void process_old (unsigned char data, int fd)
+{
+  unsigned char crlf[] = { 015, 012 };
+  switch (data) {
+  case NUL:
+    break;
+  case 001: case 002: case 003: case 004: case 005: case 006:
+    break;
+  case 016: case 017: case 020: case 021: case 022: case 023:
+  case 024: case 025: case 026: case 027: case 030: case 031:
+  case 032: case 033: case 034: case 035: case 036: case 037:
+    break;
+  case 0177:
+    break;
+  case 015:
+    read (fd, &data, 1);
+    if (data == NUL)
+      write (1, crlf, 1);
+    else if (data == 012)
+      write (1, crlf, 2);
+    else
+      fprintf (stderr, "[CR without LF or NUL]");
+  case OMARK:
+    fprintf (stderr, "[MARK]"); fflush (stderr);
+    break;
+  case OBREAK:
+    fprintf (stderr, "[BREAK]"); fflush (stderr);
+    break;
+  case ONOP:
+    fprintf (stderr, "[NOP]"); fflush (stderr);
+    break;
+  case ONOECHO:
+    fprintf (stderr, "[NOECHO]"); fflush (stderr);
+    break;
+  case OECHO:
+    fprintf (stderr, "[ECHO]"); fflush (stderr);
+    break;
+  case OHIDE:
+    fprintf (stderr, "[HIDE]"); fflush (stderr);
+    break;
+  case OASCII:
+    fprintf (stderr, "[ASCII]"); fflush (stderr);
+    break;
+  case OTRANSPARENT:
+    fprintf (stderr, "[TRANSPARENT]"); fflush (stderr);
+    break;
+  case OEBCDIC:
+    fprintf (stderr, "[EBCDIC]"); fflush (stderr);
+    break;
+  default:
+    write (1, &data, 1);
+  }
+}
+
+static int reader (int connection)
+{
+  unsigned char data[200];
+  int size, flags;
+  int fds[2];
+
+  if (pipe (fds) == -1)
+    exit (1);
+
+  flags = fcntl (fds[0], F_GETFL);
+  fcntl (fds[0], F_SETFL, flags | O_NONBLOCK);
+
+  reader_pid = fork();
+  if (reader_pid) {
+    close (fds[1]);
+    return fds[0];
+  }
+  close (fds[0]);
+
+  if (ncp_init (NULL) == -1)
+    exit (1);
+
+  for (;;) {
+    size = sizeof data;
+    if (ncp_read (connection, data, &size) == -1) {
+      fprintf (stderr, "NCP read error.\n");
+      exit (1);
     }
+    if (size == 0)
+      exit (0);
+    if (write (fds[1], data, size) == -1)
+      exit (1);
   }
 }
 
-static void telnet_client (int host, int sock, int new)
+static int writer (int connection)
 {
-  unsigned char reply[1000];
-  int connection, size;
+  unsigned char data[200], *ptr;
+  ssize_t n, m;
+  int fds[2];
+  int size;
+
+  if (pipe (fds) == -1)
+    exit (1);
+
+  writer_pid = fork();
+  if (writer_pid) {
+    close (fds[0]);
+    return fds[1];
+  }
+  close (fds[1]);
+
+  if (ncp_init (NULL) == -1)
+    exit (1);
+
+  size = strlen (options);
+  if (ncp_write (connection, options, &size) == -1) {
+    fprintf (stderr, "NCP write error.\n");
+    exit (1);
+  }
+
+  for (;;) {
+    fd_set rfds;
+    FD_ZERO (&rfds);
+    FD_SET (fds[0], &rfds);
+    n = select (33, &rfds, NULL, NULL, NULL);
+    n = read (fds[0], data, 1);
+    if (n == 0)
+      exit (0);
+    if (n < 0)
+      continue;
+    ptr = data;
+    for (ptr = data, m = n; m > 0; ptr += size, m -= size) {
+      size = m;
+      if (ncp_write (connection, ptr, &size) == -1) {
+        fprintf (stderr, "NCP write error.\n");
+        exit (1);
+      }
+      if (size == 0)
+        exit (0);
+    }
+  }
+}
+
+static void restore_termios (void)
+{
+  tcsetattr (0, TCSAFLUSH, &saved);
+}
+
+static void raw (void)
+{
+  struct termios new;
+  new = saved;
+  new.c_iflag = 0;
+  new.c_oflag = 0;
+  new.c_lflag = 0;
+  new.c_cc[VMIN] = 1;
+  new.c_cc[VTIME] = 0;
+  tcsetattr (0, TCSAFLUSH, &new);
+}
+
+static void telnet_client (int host, int sock,
+                           void (*process) (unsigned char, int))
+{
+  int connection;
+  int reader_fd, writer_fd;
 
   printf ("TELNET to host %03o.\n", host);
 
+  tcgetattr (0, &saved);
+  raw ();
+
   switch (ncp_open (host, sock, &connection)) {
   case 0:
     break;
@@ -160,19 +334,37 @@ static void telnet_client (int host, int sock, int new)
     exit (1);
   }
 
-  size = strlen (options);
-  if (ncp_write (connection, options, &size) == -1) {
-    fprintf (stderr, "NCP write error.\n");
-    exit (1);
-  }
+  reader_fd = reader (connection);
+  writer_fd = writer (connection);
 
-  size = sizeof reply;
-  if (ncp_read (connection, reply, &size) == -1) {
-    fprintf (stderr, "NCP read error.\n");
-    exit (1);
+  for (;;) {
+    fd_set rfds;
+    int n;
+    FD_ZERO (&rfds);
+    FD_SET (0, &rfds);
+    FD_SET (reader_fd, &rfds);
+    n = select (33, &rfds, NULL, NULL, NULL);
+    if (n > 0) {
+      if (FD_ISSET (0, &rfds)) {
+        unsigned char data;
+        read (0, &data, 1);
+        if (data == 035)
+          goto end;
+        write (writer_fd, &data, 1);
+      }
+      if (FD_ISSET (reader_fd, &rfds)) {
+        unsigned char data;
+        n = read (reader_fd, &data, 1);
+        if (n == 1)
+          process (data, reader_fd);
+      }
+    }
   }
 
-  process (reply, size);
+ end:
+  kill (reader_pid, SIGTERM);
+  kill (writer_pid, SIGTERM);
+  restore_termios ();
 
   if (ncp_close (connection) == -1) {
     fprintf (stderr, "NCP close error.\n");
@@ -271,7 +463,7 @@ int main (int argc, char **argv)
   }
 
   if (client)
-    telnet_client (host, sock, new);
+    telnet_client (host, sock, new ? process_new : process_old);
   else if (server)
     telnet_server (sock, new);