DKIM: ensure that dkim_domain elements are lowercased before use. Bug 2371
[exim.git] / test / src / client.c
index 4a0a1bac465238440e905d667e7d72d613e7ad87..c0c017dd3ab863aadcb4acb7dda98c87f35e84fc 100644 (file)
@@ -36,6 +36,9 @@ ripped from the openssl ocsp and s_client utilities. */
 #include <unistd.h>
 #include <utime.h>
 
 #include <unistd.h>
 #include <utime.h>
 
+/* Set to TRUE to enable debug output */
+#define DEBUG if (FALSE)
+
 #ifdef AF_INET6
 #define HAVE_IPV6 1
 #endif
 #ifdef AF_INET6
 #define HAVE_IPV6 1
 #endif
@@ -103,7 +106,7 @@ static int  ssl_session_timeout = 200;
 
 /* Priorities for TLS algorithms to use. */
 
 
 /* Priorities for TLS algorithms to use. */
 
-#if GNUTLS_VERSION_NUMBER < 0x030400
+# if GNUTLS_VERSION_NUMBER < 0x030400
 static const int protocol_priority[16] = { GNUTLS_TLS1, GNUTLS_SSL3, 0 };
 
 static const int kx_priority[16] = {
 static const int protocol_priority[16] = { GNUTLS_TLS1, GNUTLS_SSL3, 0 };
 
 static const int kx_priority[16] = {
@@ -125,7 +128,7 @@ static const int mac_priority[16] = {
   0 };
 
 static const int comp_priority[16] = { GNUTLS_COMP_NULL, 0 };
   0 };
 
 static const int comp_priority[16] = { GNUTLS_COMP_NULL, 0 };
-#endif
+# endif
 
 #endif /*HAVE_GNUTLS*/
 
 
 #endif /*HAVE_GNUTLS*/
 
@@ -133,6 +136,7 @@ static const int comp_priority[16] = { GNUTLS_COMP_NULL, 0 };
 
 #ifdef HAVE_TLS
 char * ocsp_stapling = NULL;
 
 #ifdef HAVE_TLS
 char * ocsp_stapling = NULL;
+char * pri_string = NULL;
 #endif
 
 
 #endif
 
 
@@ -223,7 +227,7 @@ if(!(bs = OCSP_response_get1_basic(rsp)))
   }
 
 
   }
 
 
-if (!(sk = chain_from_pem_file(ocsp_stapling)))
+if (!(sk = chain_from_pem_file((const uschar *)ocsp_stapling)))
   {
   BIO_printf(arg, "error in cert setup\n");
   return 0;
   {
   BIO_printf(arg, "error in cert setup\n");
   return 0;
@@ -428,7 +432,7 @@ if (certificate != NULL)
   {
   rc = gnutls_certificate_set_x509_key_file(x509_cred, CS certificate,
     CS privatekey, GNUTLS_X509_FMT_PEM);
   {
   rc = gnutls_certificate_set_x509_key_file(x509_cred, CS certificate,
     CS privatekey, GNUTLS_X509_FMT_PEM);
-  if (rc < 0) gnutls_error("gnutls_certificate", rc);
+  if (rc < 0) gnutls_error(US"gnutls_certificate", rc);
   }
 
 /* Associate the parameters with the x509 credentials structure. */
   }
 
 /* Associate the parameters with the x509 credentials structure. */
@@ -454,7 +458,7 @@ gnutls_session_t session;
 
 gnutls_init(&session, GNUTLS_CLIENT | GNUTLS_NO_EXTENSIONS);
 
 
 gnutls_init(&session, GNUTLS_CLIENT | GNUTLS_NO_EXTENSIONS);
 
-#if GNUTLS_VERSION_NUMBER < 0x030400
+# if GNUTLS_VERSION_NUMBER < 0x030400
 gnutls_cipher_set_priority(session, default_cipher_priority);
 gnutls_compression_set_priority(session, comp_priority);
 gnutls_kx_set_priority(session, kx_priority);
 gnutls_cipher_set_priority(session, default_cipher_priority);
 gnutls_compression_set_priority(session, comp_priority);
 gnutls_kx_set_priority(session, kx_priority);
@@ -462,10 +466,19 @@ gnutls_protocol_set_priority(session, protocol_priority);
 gnutls_mac_set_priority(session, mac_priority);
 
 gnutls_cred_set(session, GNUTLS_CRD_CERTIFICATE, x509_cred);
 gnutls_mac_set_priority(session, mac_priority);
 
 gnutls_cred_set(session, GNUTLS_CRD_CERTIFICATE, x509_cred);
-#else
-gnutls_set_default_priority(session);
+# else
+if (pri_string)
+  {
+  gnutls_priority_t priority_cache;
+  const char * errpos;
+
+  gnutls_priority_init(&priority_cache, pri_string, &errpos);
+  gnutls_priority_set(session, priority_cache);
+  }
+else
+  gnutls_set_default_priority(session);
 gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, x509_cred);
 gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, x509_cred);
-#endif
+# endif
 
 gnutls_dh_set_prime_bits(session, DH_BITS);
 gnutls_db_set_cache_expiration(session, ssl_session_timeout);
 
 gnutls_dh_set_prime_bits(session, DH_BITS);
 gnutls_db_set_cache_expiration(session, ssl_session_timeout);
@@ -476,7 +489,408 @@ return session;
 
 
 /****************************************************************************/
 
 
 /****************************************************************************/
+/* Turn "\n" and "\r" into the relevant characters. This is a hack. */
+
+static int
+unescape_buf(unsigned char * buf, int len)
+{
+unsigned char * s;
+unsigned char c, t;
+unsigned shift;
+
+for (s = buf; s < buf+len; s++) if (*s == '\\')
+  {
+  switch (s[1])
+    {
+    default:   c = s[1]; shift = 1; break;
+    case 'n':  c = '\n'; shift = 1; break;
+    case 'r':  c = '\r'; shift = 1; break;
+    case 'x':
+               t = s[2];
+               if (t >= 'A' && t <= 'F') t -= 'A'-'9'-1;
+               else if (t >= 'a' && t <= 'f') t -= 'a'-'9'-1;
+               t -= '0';
+               c = (t<<4) & 0xf0;
+               t = s[3];
+               if (t >= 'A' && t <= 'F') t -= 'A'-'9'-1;
+               else if (t >= 'a' && t <= 'f') t -= 'a'-'9'-1;
+               t -= '0';
+               c |= t & 0xf;
+               shift = 3;
+               break;
+    }
+  *s = c;
+  memmove(s+1, s+shift+1, len-shift);
+  len -= shift;
+  }
+return len;
+}
+
+
 /****************************************************************************/
 /****************************************************************************/
+typedef struct {
+  int  sock;
+  int  tls_active;
+#ifdef HAVE_OPENSSL
+  SSL_CTX * ctx;
+  SSL * ssl;
+#endif
+  int  sent_starttls;
+} srv_ctx;
+
+static void
+do_file(srv_ctx * srv, FILE * f, int timeout,
+  unsigned char * inbuffer, unsigned bsiz, unsigned char * inptr)
+{
+unsigned char outbuffer[1024 * 20];
+
+while (fgets(CS outbuffer, sizeof(outbuffer), f) != NULL)
+  {
+  int n = (int)strlen(CS outbuffer);
+  int crlf = 1;
+  int rc;
+
+  /* Strip trailing newline */
+  if (outbuffer[n-1] == '\n') outbuffer[--n] = 0;
+
+  /* Expect incoming */
+
+  if (  strncmp(CS outbuffer, "???", 3) == 0
+     && (outbuffer[3] == ' ' || outbuffer[3] == '*' || outbuffer[3] == '?')
+     )
+    {
+    unsigned char *lineptr;
+    unsigned exp_eof = outbuffer[3] == '*';
+    unsigned resp_optional = outbuffer[3] == '?';
+
+    printf("%s\n", outbuffer);
+    n = unescape_buf(outbuffer, n);
+
+nextinput:
+    if (*inptr == 0)   /* Refill input buffer */
+      {
+      alarm(timeout);
+      if (srv->tls_active)
+        {
+#ifdef HAVE_OPENSSL
+       int error;
+       DEBUG { printf("call SSL_read\n"); fflush(stdout); }
+        rc = SSL_read(srv->ssl, inbuffer, bsiz - 1);
+       DEBUG { printf("SSL_read: %d\n", rc); fflush(stdout); }
+       if (rc <= 0)
+          switch (error = SSL_get_error(srv->ssl, rc))
+           {
+           case SSL_ERROR_ZERO_RETURN:
+             break;
+           case SSL_ERROR_SYSCALL:
+             printf("%s\n", ERR_error_string(ERR_get_error(), NULL));
+             rc = -1;
+             break;
+           case SSL_ERROR_SSL:
+             printf("%s\nTLS terminated\n", ERR_error_string(ERR_get_error(), NULL));
+             SSL_shutdown(srv->ssl);
+             SSL_free(srv->ssl);
+             srv->tls_active = FALSE;
+             { /* OpenSSL leaves it in restartsys mode */
+             struct sigaction act = {.sa_handler = sigalrm_handler_flag, .sa_flags = 0};
+             sigalrm_seen = 1;
+             sigaction(SIGALRM, &act, NULL);
+             }
+             *inptr = 0;
+             DEBUG { printf("go round\n"); fflush(stdout); }
+             goto nextinput;
+           default:
+             printf("SSL error code %d\n", error);
+           }
+#endif
+#ifdef HAVE_GNUTLS
+        rc = gnutls_record_recv(tls_session, CS inbuffer, bsiz - 1);
+#endif
+        }
+      else
+       {
+       DEBUG { printf("call read\n"); fflush(stdout); }
+       rc = read(srv->sock, inbuffer, bsiz);
+       DEBUG { printf("read: %d\n", rc); fflush(stdout); }
+       }
+      alarm(0);
+
+      if (rc < 0)
+       {
+       if (errno == EINTR && sigalrm_seen && resp_optional)
+         continue;     /* next scriptline */
+        printf("Read error %s\n", strerror(errno));
+        exit(81);
+       }
+      else if (rc == 0)
+       if (exp_eof)
+         {
+          printf("Expected EOF read\n");
+         continue;
+         }
+       else if (resp_optional)
+         continue;     /* next scriptline */
+       else
+         {
+         printf("Unexpected EOF read\n");
+         close(srv->sock);
+         exit(80);
+         }
+      else if (exp_eof)
+        {
+        printf("Expected EOF not read\n");
+        close(srv->sock);
+        exit(74);
+        }
+      else
+        {
+        inbuffer[rc] = 0;
+        inptr = inbuffer;
+        }
+      }
+    DEBUG { printf("read: '%s'\n", inptr); fflush(stdout); }
+
+    lineptr = inptr;
+    while (*inptr != 0 && *inptr != '\r' && *inptr != '\n') inptr++;
+    if (*inptr != 0)
+      {
+      *inptr++ = 0;
+      if (*inptr == '\n') inptr++;
+      }
+
+    if (strncmp(CS lineptr, CS outbuffer + 4, n - 4) != 0)
+      if (resp_optional)
+       {
+       inptr = lineptr;        /* consume scriptline, not inputline */
+       continue;
+       }
+      else
+       {
+       printf("<<< %s\n", lineptr);
+       printf("\n******** Input mismatch ********\n");
+       exit(79);
+       }
+
+    /* Input matched script.  Output the inputline, unless optional  */
+    DEBUG { printf("read matched\n"); fflush(stdout); }
+
+    if (!resp_optional)
+       printf("<<< %s\n", lineptr);
+    else
+
+    /* If there is further input after this line, consume inputline but not
+    scriptline in case there are several matching.  Nonmatches are dealt with
+    above. */
+
+       if (*inptr != 0)
+         goto nextinput;
+
+    #ifdef HAVE_TLS
+    if (srv->sent_starttls)
+      {
+      if (lineptr[0] == '2')
+        {
+       unsigned int verify;
+
+        printf("Attempting to start TLS\n");
+        fflush(stdout);
+
+        #ifdef HAVE_OPENSSL
+        srv->tls_active = tls_start(srv->sock, &srv->ssl, srv->ctx);
+        #endif
+
+        #ifdef HAVE_GNUTLS
+         {
+         int rc;
+         sigalrm_seen = FALSE;
+         alarm(timeout);
+         do {
+           rc = gnutls_handshake(tls_session);
+         } while (rc < 0 && gnutls_error_is_fatal(rc) == 0);
+         srv->tls_active = rc >= 0;
+         alarm(0);
+
+         if (!srv->tls_active) printf("%s\n", gnutls_strerror(rc));
+         }
+        #endif
+
+        if (!srv->tls_active)
+          {
+          printf("Failed to start TLS\n");
+          fflush(stdout);
+          }
+       #ifdef HAVE_GNUTLS
+       else if (ocsp_stapling)
+         {
+         if ((rc= gnutls_certificate_verify_peers2(tls_session, &verify)) < 0)
+           {
+           printf("Failed to verify certificate: %s\n", gnutls_strerror(rc));
+           fflush(stdout);
+           }
+         else if (verify & (GNUTLS_CERT_INVALID|GNUTLS_CERT_REVOKED))
+           {
+           printf("Bad certificate\n");
+           fflush(stdout);
+           }
+         #ifdef HAVE_OCSP
+         else if (gnutls_ocsp_status_request_is_checked(tls_session, 0) == 0)
+           {
+           printf("Failed to verify certificate status\n");
+             {
+             gnutls_datum_t stapling;
+             gnutls_ocsp_resp_t resp;
+             gnutls_datum_t printed;
+             if (  (rc= gnutls_ocsp_status_request_get(tls_session, &stapling)) == 0
+                && (rc= gnutls_ocsp_resp_init(&resp)) == 0
+                && (rc= gnutls_ocsp_resp_import(resp, &stapling)) == 0
+                && (rc= gnutls_ocsp_resp_print(resp, GNUTLS_OCSP_PRINT_FULL, &printed)) == 0
+                )
+               {
+               fprintf(stderr, "%.4096s", printed.data);
+               gnutls_free(printed.data);
+               }
+             else
+               (void) fprintf(stderr,"ocsp decode: %s", gnutls_strerror(rc));
+             }
+           fflush(stdout);
+           }
+         #endif
+         }
+       #endif
+        else
+          printf("Succeeded in starting TLS\n");
+        }
+      else printf("Abandoning TLS start attempt\n");
+      }
+    srv->sent_starttls = 0;
+    #endif
+    }
+
+  /* Wait for a bit before proceeding */
+
+  else if (strncmp(CS outbuffer, "+++ ", 4) == 0)
+    {
+    printf("%s\n", outbuffer);
+    sleep(atoi(CS outbuffer + 4));
+    }
+
+  /* Stack new input file */
+
+  else if (strncmp(CS outbuffer, "<<< ", 4) == 0)
+    {
+    FILE * new_f;
+    if (!(new_f = fopen((const char *)outbuffer+4 , "r")))
+      {
+      printf("Unable to open '%s': %s", inptr, strerror(errno));
+      exit(74);
+      }
+    do_file(srv, new_f, timeout, inbuffer, bsiz, inptr);
+    }
+
+
+  /* Send line outgoing, but barf if unconsumed incoming */
+
+  else
+    {
+    unsigned char * out = outbuffer;
+
+    if (strncmp(CS outbuffer, ">>> ", 4) == 0)
+      {
+      crlf = 0;
+      out += 4;
+      n -= 4;
+      }
+
+    if (*inptr != 0)
+      {
+      printf("Unconsumed input: %s", inptr);
+      printf("   About to send: %s\n", out);
+      exit(78);
+      }
+
+    #ifdef HAVE_TLS
+
+    /* Shutdown TLS */
+
+    if (strcmp(CS out, "stoptls") == 0 ||
+        strcmp(CS out, "STOPTLS") == 0)
+      {
+      if (!srv->tls_active)
+        {
+        printf("STOPTLS read when TLS not active\n");
+        exit(77);
+        }
+      printf("Shutting down TLS encryption\n");
+
+      #ifdef HAVE_OPENSSL
+      SSL_shutdown(srv->ssl);
+      SSL_free(srv->ssl);
+      #endif
+
+      #ifdef HAVE_GNUTLS
+      gnutls_bye(tls_session, GNUTLS_SHUT_WR);
+      gnutls_deinit(tls_session);
+      tls_session = NULL;
+      gnutls_global_deinit();
+      #endif
+
+      srv->tls_active = 0;
+      continue;
+      }
+
+    /* Remember that we sent STARTTLS */
+
+    srv->sent_starttls = (strcmp(CS out, "starttls") == 0 ||
+                     strcmp(CS out, "STARTTLS") == 0);
+
+    /* Fudge: if the command is "starttls_wait", we send the starttls bit,
+    but we haven't set the flag, so that there is no negotiation. This is for
+    testing the server's timeout. */
+
+    if (strcmp(CS out, "starttls_wait") == 0)
+      {
+      out[8] = 0;
+      n = 8;
+      }
+    #endif
+
+    printf(">>> %s\n", out);
+    if (crlf)
+      {
+      strcpy(CS out + n, "\r\n");
+      n += 2;
+      }
+
+    n = unescape_buf(out, n);
+
+    /* OK, do it */
+
+    alarm(timeout);
+    if (srv->tls_active)
+      {
+      #ifdef HAVE_OPENSSL
+        rc = SSL_write (srv->ssl, out, n);
+      #endif
+      #ifdef HAVE_GNUTLS
+        if ((rc = gnutls_record_send(tls_session, CS out, n)) < 0)
+          {
+          printf("GnuTLS write error: %s\n", gnutls_strerror(rc));
+          exit(76);
+          }
+      #endif
+      }
+    else
+      rc = write(srv->sock, out, n);
+    alarm(0);
+
+    if (rc < 0)
+      {
+      printf("Write error: %s\n", strerror(errno));
+      exit(75);
+      }
+    }
+  }
+}
 
 
 
 
 
 
@@ -491,6 +905,10 @@ Usage: client\n"
 "\
           [-tls-on-connect]\n\
           [-ocsp]\n"
 "\
           [-tls-on-connect]\n\
           [-ocsp]\n"
+# ifdef HAVE_GNUTLS
+"\
+          [-p priority-string]\n"
+# endif
 #endif
 "\
           [-tn] n seconds timeout\n\
 #endif
 "\
           [-tn] n seconds timeout\n\
@@ -501,7 +919,8 @@ Usage: client\n"
           [<key file>]\n\
 \n";
 
           [<key file>]\n\
 \n";
 
-int main(int argc, char **argv)
+int
+main(int argc, char **argv)
 {
 struct sockaddr *s_ptr;
 struct sockaddr_in s_in4;
 {
 struct sockaddr *s_ptr;
 struct sockaddr_in s_in4;
@@ -511,10 +930,8 @@ char *certfile = NULL;
 char *keyfile = NULL;
 char *end = NULL;
 int argi = 1;
 char *keyfile = NULL;
 char *end = NULL;
 int argi = 1;
-int host_af, port, s_len, rc, sock, save_errno;
+int host_af, port, s_len, rc, save_errno;
 int timeout = 5;
 int timeout = 5;
-int tls_active = 0;
-int sent_starttls = 0;
 int tls_on_connect = 0;
 long tmplong;
 
 int tls_on_connect = 0;
 long tmplong;
 
@@ -522,16 +939,14 @@ long tmplong;
 struct sockaddr_in6 s_in6;
 #endif
 
 struct sockaddr_in6 s_in6;
 #endif
 
-#ifdef HAVE_OPENSSL
-SSL_CTX* ctx;
-SSL*     ssl;
-#endif
+srv_ctx srv;
 
 
-unsigned char outbuffer[10240];
 unsigned char inbuffer[10240];
 unsigned char *inptr = inbuffer;
 
 *inptr = 0;   /* Buffer empty */
 unsigned char inbuffer[10240];
 unsigned char *inptr = inbuffer;
 
 *inptr = 0;   /* Buffer empty */
+srv.tls_active = 0;
+srv.sent_starttls = 0;
 
 /* Options */
 
 
 /* Options */
 
@@ -559,6 +974,17 @@ while (argc >= argi + 1 && argv[argi][0] == '-')
       }
     ocsp_stapling = argv[argi++];
     }
       }
     ocsp_stapling = argv[argi++];
     }
+# ifdef HAVE_GNUTLS
+  else if (strcmp(argv[argi], "-p") == 0)
+    {
+    if (argc < ++argi + 1)
+      {
+      fprintf(stderr, "Missing priority string\n");
+      exit(96);
+      }
+    pri_string = argv[argi++];
+    }
+#endif
 
 #endif
   else if (argv[argi][1] == 't' && isdigit(argv[argi][2]))
 
 #endif
   else if (argv[argi][1] == 't' && isdigit(argv[argi][2]))
@@ -645,8 +1071,8 @@ even on an IPv6 system. */
 
 printf("Connecting to %s port %d ... ", address, port);
 
 
 printf("Connecting to %s port %d ... ", address, port);
 
-sock = socket(host_af, SOCK_STREAM, 0);
-if (sock < 0)
+srv.sock = socket(host_af, SOCK_STREAM, 0);
+if (srv.sock < 0)
   {
   printf("socket creation failed: %s\n", strerror(errno));
   exit(89);
   {
   printf("socket creation failed: %s\n", strerror(errno));
   exit(89);
@@ -691,7 +1117,7 @@ if (interface != NULL)
 
     /* Bind */
 
 
     /* Bind */
 
-    if (bind(sock, s_ptr, s_len) < 0)
+    if (bind(srv.sock, s_ptr, s_len) < 0)
       {
       printf("Unable to bind outgoing SMTP call to %s: %s",
         interface, strerror(errno));
       {
       printf("Unable to bind outgoing SMTP call to %s: %s",
         interface, strerror(errno));
@@ -730,7 +1156,7 @@ else
 
 signal(SIGALRM, sigalrm_handler_crash);
 alarm(timeout);
 
 signal(SIGALRM, sigalrm_handler_crash);
 alarm(timeout);
-rc = connect(sock, s_ptr, s_len);
+rc = connect(srv.sock, s_ptr, s_len);
 save_errno = errno;
 alarm(0);
 
 save_errno = errno;
 alarm(0);
 
@@ -739,7 +1165,7 @@ an externally applied timeout if the signal handler has been run. */
 
 if (rc < 0)
   {
 
 if (rc < 0)
   {
-  close(sock);
+  close(srv.sock);
   printf("connect failed: %s\n", strerror(save_errno));
   exit(85);
   }
   printf("connect failed: %s\n", strerror(save_errno));
   exit(85);
   }
@@ -753,16 +1179,15 @@ printf("connected\n");
 SSL_library_init();
 SSL_load_error_strings();
 
 SSL_library_init();
 SSL_load_error_strings();
 
-ctx = SSL_CTX_new(SSLv23_method());
-if (ctx == NULL)
+if (!(srv.ctx = SSL_CTX_new(SSLv23_method())))
   {
   printf ("SSL_CTX_new failed\n");
   exit(84);
   }
 
   {
   printf ("SSL_CTX_new failed\n");
   exit(84);
   }
 
-if (certfile != NULL)
+if (certfile)
   {
   {
-  if (!SSL_CTX_use_certificate_file(ctx, certfile, SSL_FILETYPE_PEM))
+  if (!SSL_CTX_use_certificate_file(srv.ctx, certfile, SSL_FILETYPE_PEM))
     {
     printf("SSL_CTX_use_certificate_file failed\n");
     exit(83);
     {
     printf("SSL_CTX_use_certificate_file failed\n");
     exit(83);
@@ -770,9 +1195,9 @@ if (certfile != NULL)
   printf("Certificate file = %s\n", certfile);
   }
 
   printf("Certificate file = %s\n", certfile);
   }
 
-if (keyfile != NULL)
+if (keyfile)
   {
   {
-  if (!SSL_CTX_use_PrivateKey_file(ctx, keyfile, SSL_FILETYPE_PEM))
+  if (!SSL_CTX_use_PrivateKey_file(srv.ctx, keyfile, SSL_FILETYPE_PEM))
     {
     printf("SSL_CTX_use_PrivateKey_file failed\n");
     exit(82);
     {
     printf("SSL_CTX_use_PrivateKey_file failed\n");
     exit(82);
@@ -780,9 +1205,9 @@ if (keyfile != NULL)
   printf("Key file = %s\n", keyfile);
   }
 
   printf("Key file = %s\n", keyfile);
   }
 
-SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_BOTH);
-SSL_CTX_set_timeout(ctx, 200);
-SSL_CTX_set_info_callback(ctx, (void (*)())info_callback);
+SSL_CTX_set_session_cache_mode(srv.ctx, SSL_SESS_CACHE_BOTH);
+SSL_CTX_set_timeout(srv.ctx, 200);
+SSL_CTX_set_info_callback(srv.ctx, (void (*)())info_callback);
 #endif
 
 
 #endif
 
 
@@ -791,13 +1216,13 @@ SSL_CTX_set_info_callback(ctx, (void (*)())info_callback);
 #ifdef HAVE_GNUTLS
 if (certfile != NULL) printf("Certificate file = %s\n", certfile);
 if (keyfile != NULL) printf("Key file = %s\n", keyfile);
 #ifdef HAVE_GNUTLS
 if (certfile != NULL) printf("Certificate file = %s\n", certfile);
 if (keyfile != NULL) printf("Key file = %s\n", keyfile);
-tls_init(certfile, keyfile);
+tls_init(US certfile, US keyfile);
 tls_session = tls_session_init();
 #ifdef HAVE_OCSP
 if (ocsp_stapling)
   gnutls_ocsp_status_request_enable_client(tls_session, NULL, 0, NULL);
 #endif
 tls_session = tls_session_init();
 #ifdef HAVE_OCSP
 if (ocsp_stapling)
   gnutls_ocsp_status_request_enable_client(tls_session, NULL, 0, NULL);
 #endif
-gnutls_transport_set_ptr(tls_session, (gnutls_transport_ptr_t)(intptr_t)sock);
+gnutls_transport_set_ptr(tls_session, (gnutls_transport_ptr_t)(intptr_t)srv.sock);
 
 /* When the server asks for a certificate and the client does not have one,
 there is a SIGPIPE error in the gnutls_handshake() function for some reason
 
 /* When the server asks for a certificate and the client does not have one,
 there is a SIGPIPE error in the gnutls_handshake() function for some reason
@@ -819,7 +1244,7 @@ if (tls_on_connect)
   printf("Attempting to start TLS\n");
 
 #ifdef HAVE_OPENSSL
   printf("Attempting to start TLS\n");
 
 #ifdef HAVE_OPENSSL
-  tls_active = tls_start(sock, &ssl, ctx);
+  srv.tls_active = tls_start(srv.sock, &srv.ssl, srv.ctx);
 #endif
 
 #ifdef HAVE_GNUTLS
 #endif
 
 #ifdef HAVE_GNUTLS
@@ -830,14 +1255,14 @@ if (tls_on_connect)
   do {
     rc = gnutls_handshake(tls_session);
   } while (rc < 0 && gnutls_error_is_fatal(rc) == 0);
   do {
     rc = gnutls_handshake(tls_session);
   } while (rc < 0 && gnutls_error_is_fatal(rc) == 0);
-  tls_active = rc >= 0;
+  srv.tls_active = rc >= 0;
   alarm(0);
 
   alarm(0);
 
-  if (!tls_active) printf("%s\n", gnutls_strerror(rc));
+  if (!srv.tls_active) printf("%s\n", gnutls_strerror(rc));
   }
 #endif
 
   }
 #endif
 
-  if (!tls_active)
+  if (!srv.tls_active)
     printf("Failed to start TLS\n");
 #if defined(HAVE_GNUTLS) && defined(HAVE_OCSP)
   else if (  ocsp_stapling
     printf("Failed to start TLS\n");
 #if defined(HAVE_GNUTLS) && defined(HAVE_OCSP)
   else if (  ocsp_stapling
@@ -849,290 +1274,13 @@ if (tls_on_connect)
   }
 #endif
 
   }
 #endif
 
-while (fgets(CS outbuffer, sizeof(outbuffer), stdin) != NULL)
-  {
-  int n = (int)strlen(CS outbuffer);
-
-  /* Strip trailing newline */
-  if (outbuffer[n-1] == '\n') outbuffer[--n] = 0;
-
-  /* Expect incoming */
-
-  if (  strncmp(CS outbuffer, "???", 3) == 0
-     && (outbuffer[3] == ' ' || outbuffer[3] == '*')
-     )
-    {
-    unsigned char *lineptr;
-    unsigned exp_eof = outbuffer[3] == '*';
-
-    printf("%s\n", outbuffer);
-
-    if (*inptr == 0)   /* Refill input buffer */
-      {
-      if (tls_active)
-        {
-        #ifdef HAVE_OPENSSL
-        rc = SSL_read (ssl, inbuffer, sizeof(inbuffer) - 1);
-        #endif
-        #ifdef HAVE_GNUTLS
-        rc = gnutls_record_recv(tls_session, CS inbuffer, sizeof(inbuffer) - 1);
-        #endif
-        }
-      else
-        {
-        alarm(timeout);
-        rc = read(sock, inbuffer, sizeof(inbuffer));
-        alarm(0);
-        }
-
-      if (rc < 0)
-       {
-        printf("Read error %s\n", strerror(errno));
-        exit(81);
-       }
-      else if (rc == 0)
-       if (exp_eof)
-         {
-          printf("Expected EOF read\n");
-         continue;
-         }
-       else
-         {
-         printf("Enexpected EOF read\n");
-         close(sock);
-         exit(80);
-         }
-      else if (exp_eof)
-        {
-        printf("Expected EOF not read\n");
-        close(sock);
-        exit(74);
-        }
-      else
-        {
-        inbuffer[rc] = 0;
-        inptr = inbuffer;
-        }
-      }
-
-    lineptr = inptr;
-    while (*inptr != 0 && *inptr != '\r' && *inptr != '\n') inptr++;
-    if (*inptr != 0)
-      {
-      *inptr++ = 0;
-      if (*inptr == '\n') inptr++;
-      }
-
-    printf("<<< %s\n", lineptr);
-    if (strncmp(CS lineptr, CS outbuffer + 4, (int)strlen(CS outbuffer) - 4) != 0)
-      {
-      printf("\n******** Input mismatch ********\n");
-      exit(79);
-      }
-
-    #ifdef HAVE_TLS
-    if (sent_starttls)
-      {
-      if (lineptr[0] == '2')
-        {
-int rc;
-       unsigned int verify;
-
-        printf("Attempting to start TLS\n");
-        fflush(stdout);
-
-        #ifdef HAVE_OPENSSL
-        tls_active = tls_start(sock, &ssl, ctx);
-        #endif
-
-        #ifdef HAVE_GNUTLS
-         {
-         int rc;
-         sigalrm_seen = FALSE;
-         alarm(timeout);
-         do {
-           rc = gnutls_handshake(tls_session);
-         } while (rc < 0 && gnutls_error_is_fatal(rc) == 0);
-         tls_active = rc >= 0;
-         alarm(0);
-
-         if (!tls_active) printf("%s\n", gnutls_strerror(rc));
-         }
-        #endif
-
-        if (!tls_active)
-          {
-          printf("Failed to start TLS\n");
-          fflush(stdout);
-          }
-       #ifdef HAVE_GNUTLS
-       else if (ocsp_stapling)
-         {
-         if ((rc= gnutls_certificate_verify_peers2(tls_session, &verify)) < 0)
-           {
-           printf("Failed to verify certificate: %s\n", gnutls_strerror(rc));
-           fflush(stdout);
-           }
-         else if (verify & (GNUTLS_CERT_INVALID|GNUTLS_CERT_REVOKED))
-           {
-           printf("Bad certificate\n");
-           fflush(stdout);
-           }
-         #ifdef HAVE_OCSP
-         else if (gnutls_ocsp_status_request_is_checked(tls_session, 0) == 0)
-           {
-           printf("Failed to verify certificate status\n");
-             {
-             gnutls_datum_t stapling;
-             gnutls_ocsp_resp_t resp;
-             gnutls_datum_t printed;
-             if (  (rc= gnutls_ocsp_status_request_get(tls_session, &stapling)) == 0
-                && (rc= gnutls_ocsp_resp_init(&resp)) == 0
-                && (rc= gnutls_ocsp_resp_import(resp, &stapling)) == 0
-                && (rc= gnutls_ocsp_resp_print(resp, GNUTLS_OCSP_PRINT_FULL, &printed)) == 0
-                )
-               {
-               fprintf(stderr, "%.4096s", printed.data);
-               gnutls_free(printed.data);
-               }
-             else
-               (void) fprintf(stderr,"ocsp decode: %s", gnutls_strerror(rc));
-             }
-           fflush(stdout);
-           }
-         #endif
-         }
-       #endif
-        else
-          printf("Succeeded in starting TLS\n");
-        }
-      else printf("Abandoning TLS start attempt\n");
-      }
-    sent_starttls = 0;
-    #endif
-    }
-
-  /* Wait for a bit before proceeding */
-
-  else if (strncmp(CS outbuffer, "+++ ", 4) == 0)
-    {
-    printf("%s\n", outbuffer);
-    sleep(atoi(CS outbuffer + 4));
-    }
-
-  /* Send outgoing, but barf if unconsumed incoming */
-
-  else
-    {
-    unsigned char *escape;
-
-    if (*inptr != 0)
-      {
-      printf("Unconsumed input: %s", inptr);
-      printf("   About to send: %s\n", outbuffer);
-      exit(78);
-      }
-
-    #ifdef HAVE_TLS
-
-    /* Shutdown TLS */
-
-    if (strcmp(CS outbuffer, "stoptls") == 0 ||
-        strcmp(CS outbuffer, "STOPTLS") == 0)
-      {
-      if (!tls_active)
-        {
-        printf("STOPTLS read when TLS not active\n");
-        exit(77);
-        }
-      printf("Shutting down TLS encryption\n");
-
-      #ifdef HAVE_OPENSSL
-      SSL_shutdown(ssl);
-      SSL_free(ssl);
-      #endif
-
-      #ifdef HAVE_GNUTLS
-      gnutls_bye(tls_session, GNUTLS_SHUT_WR);
-      gnutls_deinit(tls_session);
-      tls_session = NULL;
-      gnutls_global_deinit();
-      #endif
-
-      tls_active = 0;
-      continue;
-      }
-
-    /* Remember that we sent STARTTLS */
-
-    sent_starttls = (strcmp(CS outbuffer, "starttls") == 0 ||
-                     strcmp(CS outbuffer, "STARTTLS") == 0);
-
-    /* Fudge: if the command is "starttls_wait", we send the starttls bit,
-    but we haven't set the flag, so that there is no negotiation. This is for
-    testing the server's timeout. */
-
-    if (strcmp(CS outbuffer, "starttls_wait") == 0)
-      {
-      outbuffer[8] = 0;
-      n = 8;
-      }
-    #endif
-
-    printf(">>> %s\n", outbuffer);
-    strcpy(CS outbuffer + n, "\r\n");
-
-    /* Turn "\n" and "\r" into the relevant characters. This is a hack. */
-
-    while ((escape = US strstr(CS outbuffer, "\\r")) != NULL)
-      {
-      *escape = '\r';
-      memmove(escape + 1, escape + 2,  (n + 2) - (escape - outbuffer) - 2);
-      n--;
-      }
-
-    while ((escape = US strstr(CS outbuffer, "\\n")) != NULL)
-      {
-      *escape = '\n';
-      memmove(escape + 1, escape + 2,  (n + 2) - (escape - outbuffer) - 2);
-      n--;
-      }
-
-    /* OK, do it */
-
-    alarm(timeout);
-    if (tls_active)
-      {
-      #ifdef HAVE_OPENSSL
-        rc = SSL_write (ssl, outbuffer, n + 2);
-      #endif
-      #ifdef HAVE_GNUTLS
-        rc = gnutls_record_send(tls_session, CS outbuffer, n + 2);
-        if (rc < 0)
-          {
-          printf("GnuTLS write error: %s\n", gnutls_strerror(rc));
-          exit(76);
-          }
-      #endif
-      }
-    else
-      {
-      rc = write(sock, outbuffer, n + 2);
-      }
-    alarm(0);
-
-    if (rc < 0)
-      {
-      printf("Write error: %s\n", strerror(errno));
-      exit(75);
-      }
-    }
-  }
+do_file(&srv, stdin, timeout, inbuffer, sizeof(inbuffer), inptr);
 
 printf("End of script\n");
 
 printf("End of script\n");
-shutdown(sock, SHUT_WR);
-while ((rc = read(sock, inbuffer, sizeof(inbuffer))) > 0) ;
-close(sock);
+shutdown(srv.sock, SHUT_WR);
+if (fcntl(srv.sock, F_SETFL, O_NONBLOCK) == 0)
+  while (read(srv.sock, inbuffer, sizeof(inbuffer)) > 0) ;
+close(srv.sock);
 
 exit(0);
 }
 
 exit(0);
 }