test/src/client.c

   1 /* A little hacked up program that makes a TCP/IP call and reads a script to
   2 drive it, for testing Exim server code running as a daemon. It's got a bit
   3 messy with the addition of support for either OpenSSL or GnuTLS. The code for
   4 those was hacked out of Exim itself, then code for OpenSSL OCSP stapling was
   5 ripped from the openssl ocsp and s_client utilities. */
   6
   7 /* ANSI C standard includes */
   8
   9 #include <ctype.h>
  10 #include <signal.h>
  11 #include <stdarg.h>
  12 #include <stddef.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <time.h>
  17
  18 /* Unix includes */
  19
  20 #include <errno.h>
  21 #include <dirent.h>
  22 #include <sys/types.h>
  23
  24 #include <netinet/in_systm.h>
  25 #include <netinet/in.h>
  26 #include <netinet/ip.h>
  27 #include <netinet/tcp.h>
  28
  29 #include <netdb.h>
  30 #include <arpa/inet.h>
  31 #include <sys/time.h>
  32 #include <sys/resource.h>
  33 #include <sys/socket.h>
  34 #include <sys/stat.h>
  35 #include <fcntl.h>
  36 #include <unistd.h>
  37 #include <utime.h>
  38
  39 /* Set to TRUE to enable debug output */
  40 #define DEBUG if (FALSE)
  41
  42 #ifdef AF_INET6
  43 #define HAVE_IPV6 1
  44 #endif
  45
  46 #ifndef S_ADDR_TYPE
  47 #define S_ADDR_TYPE u_long
  48 #endif
  49
  50 typedef unsigned char uschar;
  51
  52 #define CS   (char *)
  53 #define US   (unsigned char *)
  54
  55 #define FALSE         0
  56 #define TRUE          1
  57
  58
  59
  60 static int sigalrm_seen = 0;
  61
  62
  63 /* TLS support can be optionally included, either for OpenSSL or GnuTLS. The
  64 latter needs a whole pile of tables. */
  65 #ifdef HAVE_OPENSSL
  66 # define HAVE_TLS
  67 # include <openssl/crypto.h>
  68 # include <openssl/x509.h>
  69 # include <openssl/pem.h>
  70 # include <openssl/ssl.h>
  71 # include <openssl/err.h>
  72 # include <openssl/rand.h>
  73
  74 # if OPENSSL_VERSION_NUMBER < 0x0090806fL && !defined(DISABLE_OCSP) && !defined(OPENSSL_NO_TLSEXT)
  75 #  warning "OpenSSL library version too old; define DISABLE_OCSP in Makefile"
  76 #  define DISABLE_OCSP
  77 # endif
  78 # ifndef DISABLE_OCSP
  79 #  include <openssl/ocsp.h>
  80 # endif
  81 #endif
  82
  83
  84 #ifdef HAVE_GNUTLS
  85 # define HAVE_TLS
  86 # include <gnutls/gnutls.h>
  87 # include <gnutls/x509.h>
  88 # if GNUTLS_VERSION_NUMBER >= 0x030103
  89 #  define HAVE_OCSP
  90 #  include <gnutls/ocsp.h>
  91 # endif
  92 # ifndef GNUTLS_NO_EXTENSIONS
  93 #  define GNUTLS_NO_EXTENSIONS 0
  94 # endif
  95
  96 # define DH_BITS      768
  97
  98 /* Local static variables for GNUTLS */
  99
 100 static gnutls_dh_params_t dh_params = NULL;
 101
 102 static gnutls_certificate_credentials_t x509_cred = NULL;
 103 static gnutls_session_t tls_session = NULL;
 104
 105 static int  ssl_session_timeout = 200;
 106
 107 /* Priorities for TLS algorithms to use. */
 108
 109 # if GNUTLS_VERSION_NUMBER < 0x030400
 110 static const int protocol_priority[16] = { GNUTLS_TLS1, GNUTLS_SSL3, 0 };
 111
 112 static const int kx_priority[16] = {
 113   GNUTLS_KX_RSA,
 114   GNUTLS_KX_DHE_DSS,
 115   GNUTLS_KX_DHE_RSA,
 116   0 };
 117
 118 static int default_cipher_priority[16] = {
 119   GNUTLS_CIPHER_AES_256_CBC,
 120   GNUTLS_CIPHER_AES_128_CBC,
 121   GNUTLS_CIPHER_3DES_CBC,
 122   GNUTLS_CIPHER_ARCFOUR_128,
 123   0 };
 124
 125 static const int mac_priority[16] = {
 126   GNUTLS_MAC_SHA,
 127   GNUTLS_MAC_MD5,
 128   0 };
 129
 130 static const int comp_priority[16] = { GNUTLS_COMP_NULL, 0 };
 131 # endif
 132
 133 #endif  /*HAVE_GNUTLS*/
 134
 135
 136
 137 #ifdef HAVE_TLS
 138 char * ocsp_stapling = NULL;
 139 char * pri_string = NULL;
 140 #endif
 141
 142
 143 /*************************************************
 144 *            SIGALRM handler - crash out         *
 145 *************************************************/
 146
 147 static void
 148 sigalrm_handler_crash(int sig)
 149 {
 150 sig = sig;    /* Keep picky compilers happy */
 151 printf("\nClient timed out\n");
 152 exit(99);
 153 }
 154
 155
 156 /*************************************************
 157 *            SIGALRM handler - set flag          *
 158 *************************************************/
 159
 160 static void
 161 sigalrm_handler_flag(int sig)
 162 {
 163 sig = sig;    /* Keep picky compilers happy */
 164 sigalrm_seen = 1;
 165 }
 166
 167
 168
 169 /****************************************************************************/
 170 /****************************************************************************/
 171
 172 #ifdef HAVE_OPENSSL
 173 # ifndef DISABLE_OCSP
 174
 175 static STACK_OF(X509) *
 176 chain_from_pem_file(const uschar * file)
 177 {
 178 BIO * bp;
 179 X509 * x;
 180 STACK_OF(X509) * sk;
 181
 182 if (!(sk = sk_X509_new_null())) return NULL;
 183 if (!(bp = BIO_new_file(CS file, "r"))) return NULL;
 184 while ((x = PEM_read_bio_X509(bp, NULL, 0, NULL)))
 185   sk_X509_push(sk, x);
 186 BIO_free(bp);
 187 return sk;
 188 }
 189
 190
 191
 192 static void
 193 cert_stack_free(STACK_OF(X509) * sk)
 194 {
 195 while (sk_X509_num(sk) > 0) (void) sk_X509_pop(sk);
 196 sk_X509_free(sk);
 197 }
 198
 199
 200 static int
 201 tls_client_stapling_cb(SSL *s, void *arg)
 202 {
 203 const unsigned char *p;
 204 int len;
 205 OCSP_RESPONSE *rsp;
 206 OCSP_BASICRESP *bs;
 207 STACK_OF(X509) * sk;
 208 int ret = 1;
 209
 210 len = SSL_get_tlsext_status_ocsp_resp(s, &p);
 211 /*BIO_printf(arg, "OCSP response: ");*/
 212 if (!p)
 213         {
 214         BIO_printf(arg, "no response received\n");
 215         return 1;
 216         }
 217 if(!(rsp = d2i_OCSP_RESPONSE(NULL, &p, len)))
 218         {
 219         BIO_printf(arg, "response parse error\n");
 220         BIO_dump_indent(arg, (char *)p, len, 4);
 221         return 0;
 222         }
 223 if(!(bs = OCSP_response_get1_basic(rsp)))
 224   {
 225   BIO_printf(arg, "error parsing response\n");
 226   return 0;
 227   }
 228
 229
 230 if (!(sk = chain_from_pem_file((const uschar *)ocsp_stapling)))
 231   {
 232   BIO_printf(arg, "error in cert setup\n");
 233   return 0;
 234   }
 235
 236 /* OCSP_basic_verify takes a "store" arg, but does not
 237 use it for the chain verification, which is all we do
 238 when OCSP_NOVERIFY is set.  The content from the wire
 239 (in "bs") and a cert-stack "sk" are all that is used. */
 240
 241 if(OCSP_basic_verify(bs, sk, NULL, OCSP_NOVERIFY) <= 0)
 242   {
 243   BIO_printf(arg, "Response Verify Failure\n");
 244   ERR_print_errors(arg);
 245   ret = 0;
 246   }
 247 else
 248   BIO_printf(arg, "Response verify OK\n");
 249
 250 cert_stack_free(sk);
 251 return ret;
 252 }
 253 # endif /*DISABLE_OCSP*/
 254
 255
 256 /*************************************************
 257 *         Start an OpenSSL TLS session           *
 258 *************************************************/
 259
 260 int
 261 tls_start(int sock, SSL **ssl, SSL_CTX *ctx)
 262 {
 263 int rc;
 264 static const unsigned char *sid_ctx = US"exim";
 265
 266 RAND_load_file("client.c", -1);   /* Not *very* random! */
 267
 268 *ssl = SSL_new (ctx);
 269 SSL_set_session_id_context(*ssl, sid_ctx, strlen(CS sid_ctx));
 270 SSL_set_fd (*ssl, sock);
 271 SSL_set_connect_state(*ssl);
 272
 273 #ifndef DISABLE_OCSP
 274 if (ocsp_stapling)
 275   {
 276   SSL_CTX_set_tlsext_status_cb(ctx, tls_client_stapling_cb);
 277   SSL_CTX_set_tlsext_status_arg(ctx, BIO_new_fp(stdout, BIO_NOCLOSE));
 278   SSL_set_tlsext_status_type(*ssl, TLSEXT_STATUSTYPE_ocsp);
 279   }
 280 #endif
 281
 282 signal(SIGALRM, sigalrm_handler_flag);
 283 sigalrm_seen = 0;
 284 alarm(5);
 285 rc = SSL_connect (*ssl);
 286 alarm(0);
 287
 288 if (sigalrm_seen)
 289   {
 290   printf("SSL_connect timed out\n");
 291   return 0;
 292   }
 293
 294 if (rc <= 0)
 295   {
 296   ERR_print_errors_fp(stdout);
 297   return 0;
 298   }
 299
 300 printf("SSL connection using %s\n", SSL_get_cipher (*ssl));
 301 return 1;
 302 }
 303
 304
 305 /*************************************************
 306 *           SSL Information callback             *
 307 *************************************************/
 308
 309 static void
 310 info_callback(SSL *s, int where, int ret)
 311 {
 312 where = where;
 313 ret = ret;
 314 printf("SSL info: %s\n", SSL_state_string_long(s));
 315 }
 316 #endif
 317
 318
 319 /****************************************************************************/
 320 /****************************************************************************/
 321
 322
 323 #ifdef HAVE_GNUTLS
 324 /*************************************************
 325 *            Handle GnuTLS error                 *
 326 *************************************************/
 327
 328 /* Called from lots of places when errors occur before actually starting to do
 329 the TLS handshake, that is, while the session is still in clear.
 330
 331 Argument:
 332   prefix    prefix text
 333   err       a GnuTLS error number, or 0 if local error
 334
 335 Returns:    doesn't - it dies
 336 */
 337
 338 static void
 339 gnutls_error(uschar *prefix, int err)
 340 {
 341 fprintf(stderr, "GnuTLS connection error: %s:", prefix);
 342 if (err != 0) fprintf(stderr, " %s", gnutls_strerror(err));
 343 fprintf(stderr, "\n");
 344 exit(98);
 345 }
 346
 347
 348
 349 /*************************************************
 350 *             Setup up DH parameters             *
 351 *************************************************/
 352
 353 /* For the test suite, the parameters should always be available in the spool
 354 directory. */
 355
 356 static void
 357 init_dh(void)
 358 {
 359 int fd;
 360 int ret;
 361 gnutls_datum_t m;
 362 uschar filename[200];
 363 struct stat statbuf;
 364
 365 /* Initialize the data structures for holding the parameters */
 366
 367 ret = gnutls_dh_params_init(&dh_params);
 368 if (ret < 0) gnutls_error(US"init dh_params", ret);
 369
 370 /* Open the cache file for reading and if successful, read it and set up the
 371 parameters. */
 372
 373 fd = open("aux-fixed/gnutls-params", O_RDONLY, 0);
 374 if (fd < 0)
 375   {
 376   fprintf(stderr, "Failed to open spool/gnutls-params: %s\n", strerror(errno));
 377   exit(97);
 378   }
 379
 380 if (fstat(fd, &statbuf) < 0)
 381   {
 382   (void)close(fd);
 383   return gnutls_error(US"TLS cache stat failed", 0);
 384   }
 385
 386 m.size = statbuf.st_size;
 387 m.data = malloc(m.size);
 388 if (m.data == NULL)
 389   return gnutls_error(US"memory allocation failed", 0);
 390 if (read(fd, m.data, m.size) != m.size)
 391   return gnutls_error(US"TLS cache read failed", 0);
 392 (void)close(fd);
 393
 394 ret = gnutls_dh_params_import_pkcs3(dh_params, &m, GNUTLS_X509_FMT_PEM);
 395 if (ret < 0) return gnutls_error(US"DH params import", ret);
 396 free(m.data);
 397 }
 398
 399
 400
 401
 402 /*************************************************
 403 *            Initialize for GnuTLS               *
 404 *************************************************/
 405
 406 /*
 407 Arguments:
 408   certificate     certificate file
 409   privatekey      private key file
 410 */
 411
 412 static void
 413 tls_init(uschar *certificate, uschar *privatekey)
 414 {
 415 int rc;
 416
 417 rc = gnutls_global_init();
 418 if (rc < 0) gnutls_error(US"gnutls_global_init", rc);
 419
 420 /* Read D-H parameters from the cache file. */
 421
 422 init_dh();
 423
 424 /* Create the credentials structure */
 425
 426 rc = gnutls_certificate_allocate_credentials(&x509_cred);
 427 if (rc < 0) gnutls_error(US"certificate_allocate_credentials", rc);
 428
 429 /* Set the certificate and private keys */
 430
 431 if (certificate != NULL)
 432   {
 433   rc = gnutls_certificate_set_x509_key_file(x509_cred, CS certificate,
 434     CS privatekey, GNUTLS_X509_FMT_PEM);
 435   if (rc < 0) gnutls_error(US"gnutls_certificate", rc);
 436   }
 437
 438 /* Associate the parameters with the x509 credentials structure. */
 439
 440 gnutls_certificate_set_dh_params(x509_cred, dh_params);
 441
 442 /* set the CA info for server-cert verify */
 443 if (ocsp_stapling)
 444   gnutls_certificate_set_x509_trust_file(x509_cred, ocsp_stapling,
 445         GNUTLS_X509_FMT_PEM);
 446 }
 447
 448
 449
 450 /*************************************************
 451 *        Initialize a single GNUTLS session      *
 452 *************************************************/
 453
 454 static gnutls_session_t
 455 tls_session_init(void)
 456 {
 457 gnutls_session_t session;
 458
 459 gnutls_init(&session, GNUTLS_CLIENT | GNUTLS_NO_EXTENSIONS);
 460
 461 # if GNUTLS_VERSION_NUMBER < 0x030400
 462 gnutls_cipher_set_priority(session, default_cipher_priority);
 463 gnutls_compression_set_priority(session, comp_priority);
 464 gnutls_kx_set_priority(session, kx_priority);
 465 gnutls_protocol_set_priority(session, protocol_priority);
 466 gnutls_mac_set_priority(session, mac_priority);
 467
 468 gnutls_cred_set(session, GNUTLS_CRD_CERTIFICATE, x509_cred);
 469 # else
 470 if (pri_string)
 471   {
 472   gnutls_priority_t priority_cache;
 473   const char * errpos;
 474
 475   gnutls_priority_init(&priority_cache, pri_string, &errpos);
 476   gnutls_priority_set(session, priority_cache);
 477   }
 478 else
 479   gnutls_set_default_priority(session);
 480 gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, x509_cred);
 481 # endif
 482
 483 gnutls_dh_set_prime_bits(session, DH_BITS);
 484 gnutls_db_set_cache_expiration(session, ssl_session_timeout);
 485
 486 return session;
 487 }
 488 #endif
 489
 490
 491 /****************************************************************************/
 492 /* Turn "\n" and "\r" into the relevant characters. This is a hack. */
 493
 494 static int
 495 unescape_buf(unsigned char * buf, int len)
 496 {
 497 unsigned char * s;
 498 unsigned char c, t;
 499 unsigned shift;
 500
 501 for (s = buf; s < buf+len; s++) if (*s == '\\')
 502   {
 503   switch (s[1])
 504     {
 505     default:    c = s[1]; shift = 1; break;
 506     case 'n':   c = '\n'; shift = 1; break;
 507     case 'r':   c = '\r'; shift = 1; break;
 508     case 'x':
 509                 t = s[2];
 510                 if (t >= 'A' && t <= 'F') t -= 'A'-'9'-1;
 511                 else if (t >= 'a' && t <= 'f') t -= 'a'-'9'-1;
 512                 t -= '0';
 513                 c = (t<<4) & 0xf0;
 514                 t = s[3];
 515                 if (t >= 'A' && t <= 'F') t -= 'A'-'9'-1;
 516                 else if (t >= 'a' && t <= 'f') t -= 'a'-'9'-1;
 517                 t -= '0';
 518                 c |= t & 0xf;
 519                 shift = 3;
 520                 break;
 521     }
 522   *s = c;
 523   memmove(s+1, s+shift+1, len-shift);
 524   len -= shift;
 525   }
 526 return len;
 527 }
 528
 529
 530 /****************************************************************************/
 531 typedef struct {
 532   int   sock;
 533   int   tls_active;
 534 #ifdef HAVE_OPENSSL
 535   SSL_CTX * ctx;
 536   SSL * ssl;
 537 #endif
 538   int   sent_starttls;
 539 } srv_ctx;
 540
 541 static void
 542 do_file(srv_ctx * srv, FILE * f, int timeout,
 543   unsigned char * inbuffer, unsigned bsiz, unsigned char * inptr)
 544 {
 545 unsigned char outbuffer[1024 * 20];
 546
 547 while (fgets(CS outbuffer, sizeof(outbuffer), f) != NULL)
 548   {
 549   int n = (int)strlen(CS outbuffer);
 550   int crlf = 1;
 551   int rc;
 552
 553   /* Strip trailing newline */
 554   if (outbuffer[n-1] == '\n') outbuffer[--n] = 0;
 555
 556   /* Expect incoming */
 557
 558   if (  strncmp(CS outbuffer, "???", 3) == 0
 559      && (outbuffer[3] == ' ' || outbuffer[3] == '*' || outbuffer[3] == '?')
 560      )
 561     {
 562     unsigned char *lineptr;
 563     unsigned exp_eof = outbuffer[3] == '*';
 564     unsigned resp_optional = outbuffer[3] == '?';
 565
 566     printf("%s\n", outbuffer);
 567     n = unescape_buf(outbuffer, n);
 568
 569 nextinput:
 570     if (*inptr == 0)   /* Refill input buffer */
 571       {
 572       alarm(timeout);
 573       unsigned char *inbufferp = inbuffer;
 574       for (;;) {
 575       if (srv->tls_active)
 576         {
 577 #ifdef HAVE_OPENSSL
 578         int error;
 579         DEBUG { printf("call SSL_read\n"); fflush(stdout); }
 580         rc = SSL_read(srv->ssl, inbufferp, bsiz - (inbufferp - inbuffer) - 1);
 581         DEBUG { printf("SSL_read: %d\n", rc); fflush(stdout); }
 582         if (rc <= 0)
 583           switch (error = SSL_get_error(srv->ssl, rc))
 584             {
 585             case SSL_ERROR_ZERO_RETURN:
 586               break;
 587             case SSL_ERROR_SYSCALL:
 588               printf("%s\n", ERR_error_string(ERR_get_error(), NULL));
 589               rc = -1;
 590               break;
 591             case SSL_ERROR_SSL:
 592               printf("%s\nTLS terminated\n", ERR_error_string(ERR_get_error(), NULL));
 593               SSL_shutdown(srv->ssl);
 594               SSL_free(srv->ssl);
 595               srv->tls_active = FALSE;
 596               { /* OpenSSL leaves it in restartsys mode */
 597               struct sigaction act = {.sa_handler = sigalrm_handler_flag, .sa_flags = 0};
 598               sigalrm_seen = 1;
 599               sigaction(SIGALRM, &act, NULL);
 600               }
 601               *inptr = 0;
 602               DEBUG { printf("go round\n"); fflush(stdout); }
 603               goto nextinput;
 604             default:
 605               printf("SSL error code %d\n", error);
 606             }
 607 #endif
 608 #ifdef HAVE_GNUTLS
 609       retry1:
 610         DEBUG { printf("call gnutls_record_recv\n"); fflush(stdout); }
 611         rc = gnutls_record_recv(tls_session, CS inbufferp, bsiz - (inbufferp - inbuffer) - 1);
 612         if (rc < 0)
 613           {
 614           DEBUG { printf("gnutls_record_recv: %s\n", gnutls_strerror(rc)); fflush(stdout); }
 615           if (rc == GNUTLS_E_INTERRUPTED || rc == GNUTLS_E_AGAIN)
 616             goto retry1;
 617           printf("%s\n", gnutls_strerror(rc));
 618           srv->tls_active = FALSE;
 619           *inptr = 0;
 620           DEBUG { printf("go round\n"); fflush(stdout); }
 621           goto nextinput;
 622           }
 623         DEBUG { printf("gnutls_record_recv: %d\n", rc); fflush(stdout); }
 624 #endif
 625         }
 626       else
 627         {
 628         DEBUG { printf("call read\n"); fflush(stdout); }
 629         rc = read(srv->sock, inbufferp, bsiz - (inbufferp - inbuffer) - 1);
 630         DEBUG { printf("read: %d\n", rc); fflush(stdout); }
 631         }
 632
 633         if (rc > 0) inbufferp[rc] = '\0';
 634         if (rc <= 0 || strchr(inbufferp, '\n')) break;
 635         inbufferp += rc;
 636         if (inbufferp >= inbuffer + bsiz) {
 637           printf("Input buffer overrun, need more than %d bytes input buffer\n", bsiz);
 638           exit(73);
 639         }
 640         DEBUG { printf("read more\n"); }
 641       }
 642       alarm(0);
 643
 644       if (rc < 0)
 645         {
 646         if (errno == EINTR && sigalrm_seen && resp_optional)
 647           continue;     /* next scriptline */
 648         printf("Read error: %s\n", strerror(errno));
 649         exit(81);
 650         }
 651       else if (rc == 0)
 652         if (exp_eof)
 653           {
 654           printf("Expected EOF read\n");
 655           continue;
 656           }
 657         else if (resp_optional)
 658           continue;     /* next scriptline */
 659         else
 660           {
 661           printf("Unexpected EOF read\n");
 662           close(srv->sock);
 663           exit(80);
 664           }
 665       else if (exp_eof)
 666         {
 667         printf("Expected EOF not read\n");
 668         close(srv->sock);
 669         exit(74);
 670         }
 671       else
 672         inptr = inbuffer;
 673       }
 674     DEBUG { printf("read: '%s'\n", inptr); fflush(stdout); }
 675
 676     lineptr = inptr;
 677     while (*inptr != 0 && *inptr != '\r' && *inptr != '\n') inptr++;
 678     if (*inptr != 0)
 679       {
 680       *inptr++ = 0;
 681       if (*inptr == '\n') inptr++;
 682       }
 683
 684     if (strncmp(CS lineptr, CS outbuffer + 4, n - 4) != 0)
 685       if (resp_optional)
 686         {
 687         inptr = lineptr;        /* consume scriptline, not inputline */
 688         continue;
 689         }
 690       else
 691         {
 692         printf("<<< %s\n", lineptr);
 693         printf("\n******** Input mismatch ********\n");
 694         exit(79);
 695         }
 696
 697     /* Input matched script.  Output the inputline, unless optional  */
 698     DEBUG { printf("read matched\n"); fflush(stdout); }
 699
 700     if (!resp_optional)
 701         printf("<<< %s\n", lineptr);
 702     else
 703
 704     /* If there is further input after this line, consume inputline but not
 705     scriptline in case there are several matching.  Nonmatches are dealt with
 706     above. */
 707
 708         if (*inptr != 0)
 709           goto nextinput;
 710
 711     #ifdef HAVE_TLS
 712     if (srv->sent_starttls)
 713       {
 714       if (lineptr[0] == '2')
 715         {
 716         unsigned int verify;
 717
 718         printf("Attempting to start TLS\n");
 719         fflush(stdout);
 720
 721         #ifdef HAVE_OPENSSL
 722         srv->tls_active = tls_start(srv->sock, &srv->ssl, srv->ctx);
 723         #endif
 724
 725         #ifdef HAVE_GNUTLS
 726           {
 727           int rc;
 728           fd_set rfd;
 729           struct timeval tv = { 0, 2000 };
 730
 731           sigalrm_seen = FALSE;
 732           alarm(timeout);
 733           do {
 734             rc = gnutls_handshake(tls_session);
 735           } while (rc < 0 && gnutls_error_is_fatal(rc) == 0);
 736           srv->tls_active = rc >= 0;
 737           alarm(0);
 738
 739           if (!srv->tls_active) printf("%s\n", gnutls_strerror(rc));
 740
 741           /* look for an error on the TLS conn */
 742           FD_ZERO(&rfd);
 743           FD_SET(srv->sock, &rfd);
 744           if (select(srv->sock+1, &rfd, NULL, NULL, &tv) > 0)
 745             {
 746           retry2:
 747             DEBUG { printf("call gnutls_record_recv\n"); fflush(stdout); }
 748             rc = gnutls_record_recv(tls_session, CS inbuffer, bsiz - 1);
 749             if (rc < 0)
 750               {
 751               DEBUG { printf("gnutls_record_recv: %s\n", gnutls_strerror(rc)); fflush(stdout); }
 752               if (rc == GNUTLS_E_INTERRUPTED || rc == GNUTLS_E_AGAIN)
 753                 goto retry2;
 754               printf("%s\n", gnutls_strerror(rc));
 755               srv->tls_active = FALSE;
 756               }
 757             DEBUG { printf("gnutls_record_recv: %d\n", rc); fflush(stdout); }
 758             }
 759           }
 760         #endif
 761
 762         if (!srv->tls_active)
 763           {
 764           printf("Failed to start TLS\n");
 765           fflush(stdout);
 766           }
 767         #ifdef HAVE_GNUTLS
 768         else if (ocsp_stapling)
 769           {
 770           if ((rc= gnutls_certificate_verify_peers2(tls_session, &verify)) < 0)
 771             {
 772             printf("Failed to verify certificate: %s\n", gnutls_strerror(rc));
 773             fflush(stdout);
 774             }
 775           else if (verify & (GNUTLS_CERT_INVALID|GNUTLS_CERT_REVOKED))
 776             {
 777             printf("Bad certificate\n");
 778             fflush(stdout);
 779             }
 780           #ifdef HAVE_OCSP
 781           else if (gnutls_ocsp_status_request_is_checked(tls_session, 0) == 0)
 782             {
 783             printf("Failed to verify certificate status\n");
 784               {
 785               gnutls_datum_t stapling;
 786               gnutls_ocsp_resp_t resp;
 787               gnutls_datum_t printed;
 788               if (  (rc= gnutls_ocsp_status_request_get(tls_session, &stapling)) == 0
 789                  && (rc= gnutls_ocsp_resp_init(&resp)) == 0
 790                  && (rc= gnutls_ocsp_resp_import(resp, &stapling)) == 0
 791                  && (rc= gnutls_ocsp_resp_print(resp, GNUTLS_OCSP_PRINT_FULL, &printed)) == 0
 792                  )
 793                 {
 794                 fprintf(stderr, "%.4096s", printed.data);
 795                 gnutls_free(printed.data);
 796                 }
 797               else
 798                 (void) fprintf(stderr,"ocsp decode: %s", gnutls_strerror(rc));
 799               }
 800             fflush(stdout);
 801             }
 802           #endif
 803           }
 804         #endif
 805         else
 806           printf("Succeeded in starting TLS\n");
 807         }
 808       else printf("Abandoning TLS start attempt\n");
 809       }
 810     srv->sent_starttls = 0;
 811     #endif
 812     }
 813
 814   /* Wait for a bit before proceeding */
 815
 816   else if (strncmp(CS outbuffer, "+++ ", 4) == 0)
 817     {
 818     printf("%s\n", outbuffer);
 819     sleep(atoi(CS outbuffer + 4));
 820     }
 821
 822   /* Stack new input file */
 823
 824   else if (strncmp(CS outbuffer, "<<< ", 4) == 0)
 825     {
 826     FILE * new_f;
 827     if (!(new_f = fopen((const char *)outbuffer+4 , "r")))
 828       {
 829       printf("Unable to open '%s': %s", inptr, strerror(errno));
 830       exit(74);
 831       }
 832     do_file(srv, new_f, timeout, inbuffer, bsiz, inptr);
 833     }
 834
 835
 836   /* Send line outgoing, but barf if unconsumed incoming */
 837
 838   else
 839     {
 840     unsigned char * out = outbuffer;
 841
 842     if (strncmp(CS outbuffer, ">>> ", 4) == 0)
 843       {
 844       crlf = 0;
 845       out += 4;
 846       n -= 4;
 847       }
 848
 849     if (*inptr != 0)
 850       {
 851       printf("Unconsumed input: %s", inptr);
 852       printf("   About to send: %s\n", out);
 853       exit(78);
 854       }
 855
 856     #ifdef HAVE_TLS
 857
 858     /* Shutdown TLS */
 859
 860     if (strcmp(CS out, "stoptls") == 0 ||
 861         strcmp(CS out, "STOPTLS") == 0)
 862       {
 863       if (!srv->tls_active)
 864         {
 865         printf("STOPTLS read when TLS not active\n");
 866         exit(77);
 867         }
 868       printf("Shutting down TLS encryption\n");
 869
 870       #ifdef HAVE_OPENSSL
 871       SSL_shutdown(srv->ssl);
 872       SSL_free(srv->ssl);
 873       #endif
 874
 875       #ifdef HAVE_GNUTLS
 876       gnutls_bye(tls_session, GNUTLS_SHUT_WR);
 877       gnutls_deinit(tls_session);
 878       tls_session = NULL;
 879       gnutls_global_deinit();
 880       #endif
 881
 882       srv->tls_active = 0;
 883       continue;
 884       }
 885
 886     /* Remember that we sent STARTTLS */
 887
 888     srv->sent_starttls = (strcmp(CS out, "starttls") == 0 ||
 889                      strcmp(CS out, "STARTTLS") == 0);
 890
 891     /* Fudge: if the command is "starttls_wait", we send the starttls bit,
 892     but we haven't set the flag, so that there is no negotiation. This is for
 893     testing the server's timeout. */
 894
 895     if (strcmp(CS out, "starttls_wait") == 0)
 896       {
 897       out[8] = 0;
 898       n = 8;
 899       }
 900     #endif
 901
 902     printf(">>> %s\n", out);
 903     if (crlf)
 904       {
 905       strcpy(CS out + n, "\r\n");
 906       n += 2;
 907       }
 908
 909     n = unescape_buf(out, n);
 910
 911     /* OK, do it */
 912
 913     alarm(timeout);
 914     if (srv->tls_active)
 915       {
 916       #ifdef HAVE_OPENSSL
 917         rc = SSL_write (srv->ssl, out, n);
 918       #endif
 919       #ifdef HAVE_GNUTLS
 920         if ((rc = gnutls_record_send(tls_session, CS out, n)) < 0)
 921           {
 922           printf("GnuTLS write error: %s\n", gnutls_strerror(rc));
 923           exit(76);
 924           }
 925       #endif
 926       }
 927     else
 928       rc = write(srv->sock, out, n);
 929     alarm(0);
 930
 931     if (rc < 0)
 932       {
 933       printf("Write error: %s\n", strerror(errno));
 934       exit(75);
 935       }
 936     }
 937   }
 938 }
 939
 940
 941
 942
 943 /*************************************************
 944 *                 Main Program                   *
 945 *************************************************/
 946
 947 const char * const HELP_MESSAGE = "\n\
 948 Usage: client\n"
 949 #ifdef HAVE_TLS
 950 "\
 951           [-tls-on-connect]\n\
 952           [-ocsp]\n"
 953 # ifdef HAVE_GNUTLS
 954 "\
 955           [-p priority-string]\n"
 956 # endif
 957 #endif
 958 "\
 959           [-tn] n seconds timeout\n\
 960           <IP address>\n\
 961           <port>\n\
 962           [<outgoing interface>]\n\
 963           [<cert file>]\n\
 964           [<key file>]\n\
 965 \n";
 966
 967 int
 968 main(int argc, char **argv)
 969 {
 970 struct sockaddr *s_ptr;
 971 struct sockaddr_in s_in4;
 972 char *interface = NULL;
 973 char *address = NULL;
 974 char *certfile = NULL;
 975 char *keyfile = NULL;
 976 char *end = NULL;
 977 int argi = 1;
 978 int host_af, port, s_len, rc, save_errno;
 979 int timeout = 5;
 980 int tls_on_connect = 0;
 981 long tmplong;
 982
 983 #if HAVE_IPV6
 984 struct sockaddr_in6 s_in6;
 985 #endif
 986
 987 srv_ctx srv;
 988
 989 unsigned char inbuffer[100 * 1024];
 990 unsigned char *inptr = inbuffer;
 991
 992 *inptr = 0;   /* Buffer empty */
 993 srv.tls_active = 0;
 994 srv.sent_starttls = 0;
 995
 996 /* Options */
 997
 998 while (argc >= argi + 1 && argv[argi][0] == '-')
 999   {
1000   if (strcmp(argv[argi], "-help") == 0 ||
1001       strcmp(argv[argi], "--help") == 0 ||
1002       strcmp(argv[argi], "-h") == 0)
1003     {
1004     puts(HELP_MESSAGE);
1005     exit(0);
1006     }
1007   if (strcmp(argv[argi], "-tls-on-connect") == 0)
1008     {
1009     tls_on_connect = 1;
1010     argi++;
1011     }
1012 #ifdef HAVE_TLS
1013   else if (strcmp(argv[argi], "-ocsp") == 0)
1014     {
1015     if (argc < ++argi + 1)
1016       {
1017       fprintf(stderr, "Missing required certificate file for ocsp option\n");
1018       exit(96);
1019       }
1020     ocsp_stapling = argv[argi++];
1021     }
1022 # ifdef HAVE_GNUTLS
1023   else if (strcmp(argv[argi], "-p") == 0)
1024     {
1025     if (argc < ++argi + 1)
1026       {
1027       fprintf(stderr, "Missing priority string\n");
1028       exit(96);
1029       }
1030     pri_string = argv[argi++];
1031     }
1032 #endif
1033
1034 #endif
1035   else if (argv[argi][1] == 't' && isdigit(argv[argi][2]))
1036     {
1037     tmplong = strtol(argv[argi]+2, &end, 10);
1038     if (end == argv[argi]+2 || *end)
1039       {
1040       fprintf(stderr, "Failed to parse seconds from option <%s>\n",
1041         argv[argi]);
1042       exit(95);
1043       }
1044     if (tmplong > 10000L)
1045       {
1046       fprintf(stderr, "Unreasonably long wait of %ld seconds requested\n",
1047         tmplong);
1048       exit(94);
1049       }
1050     if (tmplong < 0L)
1051       {
1052       fprintf(stderr, "Timeout must not be negative (%ld)\n", tmplong);
1053       exit(93);
1054       }
1055     timeout = (int) tmplong;
1056     argi++;
1057     }
1058   else
1059     {
1060     fprintf(stderr, "Unrecognized option %s\n", argv[argi]);
1061     exit(92);
1062     }
1063   }
1064
1065 /* Mandatory 1st arg is IP address */
1066
1067 if (argc < argi+1)
1068   {
1069   fprintf(stderr, "No IP address given\n");
1070   exit(91);
1071   }
1072
1073 address = argv[argi++];
1074 host_af = (strchr(address, ':') != NULL)? AF_INET6 : AF_INET;
1075
1076 /* Mandatory 2nd arg is port */
1077
1078 if (argc < argi+1)
1079   {
1080   fprintf(stderr, "No port number given\n");
1081   exit(90);
1082   }
1083
1084 port = atoi(argv[argi++]);
1085
1086 /* Optional next arg is interface */
1087
1088 if (argc > argi &&
1089   (isdigit((unsigned char)argv[argi][0]) || argv[argi][0] == ':'))
1090     interface = argv[argi++];
1091
1092 /* Any more arguments are the name of a certificate file and key file */
1093
1094 if (argc > argi) certfile = argv[argi++];
1095 if (argc > argi) keyfile = argv[argi++];
1096
1097
1098 #if HAVE_IPV6
1099 /* For an IPv6 address, use an IPv6 sockaddr structure. */
1100
1101 if (host_af == AF_INET6)
1102   {
1103   s_ptr = (struct sockaddr *)&s_in6;
1104   s_len = sizeof(s_in6);
1105   }
1106 else
1107 #endif
1108
1109 /* For an IPv4 address, use an IPv4 sockaddr structure,
1110 even on an IPv6 system. */
1111
1112   {
1113   s_ptr = (struct sockaddr *)&s_in4;
1114   s_len = sizeof(s_in4);
1115   }
1116
1117 printf("Connecting to %s port %d ... ", address, port);
1118
1119 srv.sock = socket(host_af, SOCK_STREAM, 0);
1120 if (srv.sock < 0)
1121   {
1122   printf("socket creation failed: %s\n", strerror(errno));
1123   exit(89);
1124   }
1125
1126 /* Bind to a specific interface if requested. On an IPv6 system, this has
1127 to be of the same family as the address we are calling. On an IPv4 system the
1128 test is redundant, but it keeps the code tidier. */
1129
1130 if (interface != NULL)
1131   {
1132   int interface_af = (strchr(interface, ':') != NULL)? AF_INET6 : AF_INET;
1133
1134   if (interface_af == host_af)
1135     {
1136     #if HAVE_IPV6
1137
1138     /* Set up for IPv6 binding */
1139
1140     if (host_af == AF_INET6)
1141       {
1142       memset(&s_in6, 0, sizeof(s_in6));
1143       s_in6.sin6_family = AF_INET6;
1144       s_in6.sin6_port = 0;
1145       if (inet_pton(AF_INET6, interface, &s_in6.sin6_addr) != 1)
1146         {
1147         printf("Unable to parse \"%s\"", interface);
1148         exit(88);
1149         }
1150       }
1151     else
1152     #endif
1153
1154     /* Set up for IPv4 binding */
1155
1156       {
1157       memset(&s_in4, 0, sizeof(s_in4));
1158       s_in4.sin_family = AF_INET;
1159       s_in4.sin_port = 0;
1160       s_in4.sin_addr.s_addr = (S_ADDR_TYPE)inet_addr(interface);
1161       }
1162
1163     /* Bind */
1164
1165     if (bind(srv.sock, s_ptr, s_len) < 0)
1166       {
1167       printf("Unable to bind outgoing SMTP call to %s: %s",
1168         interface, strerror(errno));
1169       exit(87);
1170       }
1171     }
1172   }
1173
1174 /* Set up a remote IPv6 address */
1175
1176 #if HAVE_IPV6
1177 if (host_af == AF_INET6)
1178   {
1179   memset(&s_in6, 0, sizeof(s_in6));
1180   s_in6.sin6_family = AF_INET6;
1181   s_in6.sin6_port = htons(port);
1182   if (inet_pton(host_af, address, &s_in6.sin6_addr) != 1)
1183     {
1184     printf("Unable to parse \"%s\"", address);
1185     exit(86);
1186     }
1187   }
1188 else
1189 #endif
1190
1191 /* Set up a remote IPv4 address */
1192
1193   {
1194   memset(&s_in4, 0, sizeof(s_in4));
1195   s_in4.sin_family = AF_INET;
1196   s_in4.sin_port = htons(port);
1197   s_in4.sin_addr.s_addr = (S_ADDR_TYPE)inet_addr(address);
1198   }
1199
1200 /* SIGALRM handler crashes out */
1201
1202 signal(SIGALRM, sigalrm_handler_crash);
1203 alarm(timeout);
1204 rc = connect(srv.sock, s_ptr, s_len);
1205 save_errno = errno;
1206 alarm(0);
1207
1208 /* A failure whose error code is "Interrupted system call" is in fact
1209 an externally applied timeout if the signal handler has been run. */
1210
1211 if (rc < 0)
1212   {
1213   close(srv.sock);
1214   printf("connect failed: %s\n", strerror(save_errno));
1215   exit(85);
1216   }
1217
1218 printf("connected\n");
1219
1220
1221 /* --------------- Set up for OpenSSL --------------- */
1222
1223 #ifdef HAVE_OPENSSL
1224 SSL_library_init();
1225 SSL_load_error_strings();
1226
1227 if (!(srv.ctx = SSL_CTX_new(SSLv23_method())))
1228   {
1229   printf ("SSL_CTX_new failed\n");
1230   exit(84);
1231   }
1232
1233 if (certfile)
1234   {
1235   if (!SSL_CTX_use_certificate_file(srv.ctx, certfile, SSL_FILETYPE_PEM))
1236     {
1237     printf("SSL_CTX_use_certificate_file failed\n");
1238     exit(83);
1239     }
1240   printf("Certificate file = %s\n", certfile);
1241   }
1242
1243 if (keyfile)
1244   {
1245   if (!SSL_CTX_use_PrivateKey_file(srv.ctx, keyfile, SSL_FILETYPE_PEM))
1246     {
1247     printf("SSL_CTX_use_PrivateKey_file failed\n");
1248     exit(82);
1249     }
1250   printf("Key file = %s\n", keyfile);
1251   }
1252
1253 SSL_CTX_set_session_cache_mode(srv.ctx, SSL_SESS_CACHE_BOTH);
1254 SSL_CTX_set_timeout(srv.ctx, 200);
1255 SSL_CTX_set_info_callback(srv.ctx, (void (*)())info_callback);
1256 #endif
1257
1258
1259 /* --------------- Set up for GnuTLS --------------- */
1260
1261 #ifdef HAVE_GNUTLS
1262 if (certfile != NULL) printf("Certificate file = %s\n", certfile);
1263 if (keyfile != NULL) printf("Key file = %s\n", keyfile);
1264 tls_init(US certfile, US keyfile);
1265 tls_session = tls_session_init();
1266 #ifdef HAVE_OCSP
1267 if (ocsp_stapling)
1268   gnutls_ocsp_status_request_enable_client(tls_session, NULL, 0, NULL);
1269 #endif
1270 gnutls_transport_set_ptr(tls_session, (gnutls_transport_ptr_t)(intptr_t)srv.sock);
1271
1272 /* When the server asks for a certificate and the client does not have one,
1273 there is a SIGPIPE error in the gnutls_handshake() function for some reason
1274 that is not understood. As luck would have it, this has never hit Exim itself
1275 because it ignores SIGPIPE errors. Doing the same here allows it all to work as
1276 one wants. */
1277
1278 signal(SIGPIPE, SIG_IGN);
1279 #endif
1280
1281 /* ---------------------------------------------- */
1282
1283
1284 /* Start TLS session if configured to do so without STARTTLS */
1285
1286 #ifdef HAVE_TLS
1287 if (tls_on_connect)
1288   {
1289   printf("Attempting to start TLS\n");
1290
1291 #ifdef HAVE_OPENSSL
1292   srv.tls_active = tls_start(srv.sock, &srv.ssl, srv.ctx);
1293 #endif
1294
1295 #ifdef HAVE_GNUTLS
1296   {
1297   int rc;
1298   sigalrm_seen = FALSE;
1299   alarm(timeout);
1300   do {
1301     rc = gnutls_handshake(tls_session);
1302   } while (rc < 0 && gnutls_error_is_fatal(rc) == 0);
1303   srv.tls_active = rc >= 0;
1304   alarm(0);
1305
1306   if (!srv.tls_active) printf("%s\n", gnutls_strerror(rc));
1307   }
1308 #endif
1309
1310   if (!srv.tls_active)
1311     printf("Failed to start TLS\n");
1312 #if defined(HAVE_GNUTLS) && defined(HAVE_OCSP)
1313   else if (  ocsp_stapling
1314           && gnutls_ocsp_status_request_is_checked(tls_session, 0) == 0)
1315     printf("Failed to verify certificate status\n");
1316 #endif
1317   else
1318     printf("Succeeded in starting TLS\n");
1319   }
1320 #endif
1321
1322 do_file(&srv, stdin, timeout, inbuffer, sizeof(inbuffer), inptr);
1323
1324 printf("End of script\n");
1325 shutdown(srv.sock, SHUT_WR);
1326 if (fcntl(srv.sock, F_SETFL, O_NONBLOCK) == 0)
1327   while (read(srv.sock, inbuffer, sizeof(inbuffer)) > 0) ;
1328 close(srv.sock);
1329
1330 exit(0);
1331 }
1332
1333 /* End of client.c */