test/src/client.c

   1 /* $Cambridge: exim/test/src/client.c,v 1.2 2006/10/16 13:42:19 ph10 Exp $ */
   2
   3 /* A little hacked up program that makes a TCP/IP call and reads a script to
   4 drive it, for testing Exim server code running as a daemon. It's got a bit
   5 messy with the addition of support for either OpenSSL or GnuTLS. The code for
   6 those was hacked out of Exim itself. */
   7
   8 /* ANSI C standard includes */
   9
  10 #include <ctype.h>
  11 #include <signal.h>
  12 #include <stdarg.h>
  13 #include <stddef.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <time.h>
  18
  19 /* Unix includes */
  20
  21 #include <errno.h>
  22 #include <dirent.h>
  23 #include <sys/types.h>
  24
  25 #include <netinet/in_systm.h>
  26 #include <netinet/in.h>
  27 #include <netinet/ip.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 #ifdef AF_INET6
  40 #define HAVE_IPV6 1
  41 #endif
  42
  43 #ifndef S_ADDR_TYPE
  44 #define S_ADDR_TYPE u_long
  45 #endif
  46
  47 typedef unsigned char uschar;
  48
  49 #define CS   (char *)
  50 #define US   (unsigned char *)
  51
  52 #define FALSE         0
  53 #define TRUE          1
  54
  55
  56
  57 static int sigalrm_seen = 0;
  58
  59
  60 /* TLS support can be optionally included, either for OpenSSL or GnuTLS. The
  61 latter needs a whole pile of tables. */
  62
  63 #ifdef HAVE_OPENSSL
  64 #define HAVE_TLS
  65 #include <openssl/crypto.h>
  66 #include <openssl/x509.h>
  67 #include <openssl/pem.h>
  68 #include <openssl/ssl.h>
  69 #include <openssl/err.h>
  70 #include <openssl/rand.h>
  71 #endif
  72
  73
  74 #ifdef HAVE_GNUTLS
  75 #define HAVE_TLS
  76 #include <gnutls/gnutls.h>
  77 #include <gnutls/x509.h>
  78
  79 #define DH_BITS      768
  80
  81 /* Local static variables for GNUTLS */
  82
  83 static gnutls_dh_params dh_params = NULL;
  84
  85 static gnutls_certificate_credentials_t x509_cred = NULL;
  86 static gnutls_session tls_session = NULL;
  87
  88 static int  ssl_session_timeout = 200;
  89
  90 /* Priorities for TLS algorithms to use. */
  91
  92 static const int protocol_priority[16] = { GNUTLS_TLS1, GNUTLS_SSL3, 0 };
  93
  94 static const int kx_priority[16] = {
  95   GNUTLS_KX_RSA,
  96   GNUTLS_KX_DHE_DSS,
  97   GNUTLS_KX_DHE_RSA,
  98   0 };
  99
 100 static int default_cipher_priority[16] = {
 101   GNUTLS_CIPHER_AES_256_CBC,
 102   GNUTLS_CIPHER_AES_128_CBC,
 103   GNUTLS_CIPHER_3DES_CBC,
 104   GNUTLS_CIPHER_ARCFOUR_128,
 105   0 };
 106
 107 static const int mac_priority[16] = {
 108   GNUTLS_MAC_SHA,
 109   GNUTLS_MAC_MD5,
 110   0 };
 111
 112 static const int comp_priority[16] = { GNUTLS_COMP_NULL, 0 };
 113 static const int cert_type_priority[16] = { GNUTLS_CRT_X509, 0 };
 114
 115 #endif
 116
 117
 118
 119
 120 /*************************************************
 121 *            SIGALRM handler - crash out         *
 122 *************************************************/
 123
 124 static void
 125 sigalrm_handler_crash(int sig)
 126 {
 127 sig = sig;    /* Keep picky compilers happy */
 128 printf("\nClient timed out\n");
 129 exit(99);
 130 }
 131
 132
 133 /*************************************************
 134 *            SIGALRM handler - set flag          *
 135 *************************************************/
 136
 137 static void
 138 sigalrm_handler_flag(int sig)
 139 {
 140 sig = sig;    /* Keep picky compilers happy */
 141 sigalrm_seen = 1;
 142 }
 143
 144
 145
 146 /****************************************************************************/
 147 /****************************************************************************/
 148
 149 #ifdef HAVE_OPENSSL
 150 /*************************************************
 151 *         Start an OpenSSL TLS session           *
 152 *************************************************/
 153
 154 int tls_start(int sock, SSL **ssl, SSL_CTX *ctx)
 155 {
 156 int rc;
 157 static const char *sid_ctx = "exim";
 158
 159 RAND_load_file("client.c", -1);   /* Not *very* random! */
 160
 161 *ssl = SSL_new (ctx);
 162 SSL_set_session_id_context(*ssl, sid_ctx, strlen(sid_ctx));
 163 SSL_set_fd (*ssl, sock);
 164 SSL_set_connect_state(*ssl);
 165
 166 signal(SIGALRM, sigalrm_handler_flag);
 167 sigalrm_seen = 0;
 168 alarm(5);
 169 rc = SSL_connect (*ssl);
 170 alarm(0);
 171
 172 if (sigalrm_seen)
 173   {
 174   printf("SSL_connect timed out\n");
 175   return 0;
 176   }
 177
 178 if (rc <= 0)
 179   {
 180   ERR_print_errors_fp(stdout);
 181   return 0;
 182   }
 183
 184 printf("SSL connection using %s\n", SSL_get_cipher (*ssl));
 185 return 1;
 186 }
 187
 188
 189 /*************************************************
 190 *           SSL Information callback             *
 191 *************************************************/
 192
 193 static void
 194 info_callback(SSL *s, int where, int ret)
 195 {
 196 where = where;
 197 ret = ret;
 198 printf("SSL info: %s\n", SSL_state_string_long(s));
 199 }
 200 #endif
 201
 202
 203 /****************************************************************************/
 204 /****************************************************************************/
 205
 206
 207 #ifdef HAVE_GNUTLS
 208 /*************************************************
 209 *            Handle GnuTLS error                 *
 210 *************************************************/
 211
 212 /* Called from lots of places when errors occur before actually starting to do
 213 the TLS handshake, that is, while the session is still in clear.
 214
 215 Argument:
 216   prefix    prefix text
 217   err       a GnuTLS error number, or 0 if local error
 218
 219 Returns:    doesn't - it dies
 220 */
 221
 222 static void
 223 gnutls_error(uschar *prefix, int err)
 224 {
 225 fprintf(stderr, "GnuTLS connection error: %s:", prefix);
 226 if (err != 0) fprintf(stderr, " %s", gnutls_strerror(err));
 227 fprintf(stderr, "\n");
 228 exit(1);
 229 }
 230
 231
 232
 233 /*************************************************
 234 *             Setup up DH parameters             *
 235 *************************************************/
 236
 237 /* For the test suite, the parameters should always be available in the spool
 238 directory. */
 239
 240 static void
 241 init_dh(void)
 242 {
 243 int fd;
 244 int ret;
 245 gnutls_datum m;
 246 uschar filename[200];
 247 struct stat statbuf;
 248
 249 /* Initialize the data structures for holding the parameters */
 250
 251 ret = gnutls_dh_params_init(&dh_params);
 252 if (ret < 0) gnutls_error(US"init dh_params", ret);
 253
 254 /* Open the cache file for reading and if successful, read it and set up the
 255 parameters. */
 256
 257 fd = open("aux-fixed/gnutls-params", O_RDONLY, 0);
 258 if (fd < 0)
 259   {
 260   fprintf(stderr, "Failed to open spool/gnutls-params: %s\n", strerror(errno));
 261   exit(1);
 262   }
 263
 264 if (fstat(fd, &statbuf) < 0)
 265   {
 266   (void)close(fd);
 267   return gnutls_error(US"TLS cache stat failed", 0);
 268   }
 269
 270 m.size = statbuf.st_size;
 271 m.data = malloc(m.size);
 272 if (m.data == NULL)
 273   return gnutls_error(US"memory allocation failed", 0);
 274 if (read(fd, m.data, m.size) != m.size)
 275   return gnutls_error(US"TLS cache read failed", 0);
 276 (void)close(fd);
 277
 278 ret = gnutls_dh_params_import_pkcs3(dh_params, &m, GNUTLS_X509_FMT_PEM);
 279 if (ret < 0) return gnutls_error(US"DH params import", ret);
 280 free(m.data);
 281 }
 282
 283
 284
 285
 286 /*************************************************
 287 *            Initialize for GnuTLS               *
 288 *************************************************/
 289
 290 /*
 291 Arguments:
 292   certificate     certificate file
 293   privatekey      private key file
 294 */
 295
 296 static void
 297 tls_init(uschar *certificate, uschar *privatekey)
 298 {
 299 int rc;
 300
 301 rc = gnutls_global_init();
 302 if (rc < 0) gnutls_error(US"gnutls_global_init", rc);
 303
 304 /* Read D-H parameters from the cache file. */
 305
 306 init_dh();
 307
 308 /* Create the credentials structure */
 309
 310 rc = gnutls_certificate_allocate_credentials(&x509_cred);
 311 if (rc < 0) gnutls_error(US"certificate_allocate_credentials", rc);
 312
 313 /* Set the certificate and private keys */
 314
 315 if (certificate != NULL)
 316   {
 317   rc = gnutls_certificate_set_x509_key_file(x509_cred, CS certificate,
 318     CS privatekey, GNUTLS_X509_FMT_PEM);
 319   if (rc < 0) gnutls_error("gnutls_certificate", rc);
 320   }
 321
 322 /* Associate the parameters with the x509 credentials structure. */
 323
 324 gnutls_certificate_set_dh_params(x509_cred, dh_params);
 325 }
 326
 327
 328
 329 /*************************************************
 330 *        Initialize a single GNUTLS session      *
 331 *************************************************/
 332
 333 static gnutls_session
 334 tls_session_init(void)
 335 {
 336 gnutls_session session;
 337
 338 gnutls_init(&session, GNUTLS_CLIENT);
 339
 340 gnutls_cipher_set_priority(session, default_cipher_priority);
 341 gnutls_compression_set_priority(session, comp_priority);
 342 gnutls_kx_set_priority(session, kx_priority);
 343 gnutls_protocol_set_priority(session, protocol_priority);
 344 gnutls_mac_set_priority(session, mac_priority);
 345
 346 gnutls_cred_set(session, GNUTLS_CRD_CERTIFICATE, x509_cred);
 347
 348 gnutls_dh_set_prime_bits(session, DH_BITS);
 349 gnutls_db_set_cache_expiration(session, ssl_session_timeout);
 350
 351 return session;
 352 }
 353 #endif
 354
 355
 356 /****************************************************************************/
 357 /****************************************************************************/
 358
 359
 360
 361
 362 /*************************************************
 363 *                 Main Program                   *
 364 *************************************************/
 365
 366 /* Usage: client
 367           <IP address>
 368           <port>
 369           [<outgoing interface>]
 370           [<cert file>]
 371           [<key file>]
 372 */
 373
 374 int main(int argc, char **argv)
 375 {
 376 struct sockaddr *s_ptr;
 377 struct sockaddr_in s_in4;
 378 char *interface = NULL;
 379 char *address = NULL;
 380 char *certfile = NULL;
 381 char *keyfile = NULL;
 382 int argi = 1;
 383 int host_af, port, s_len, rc, sock, save_errno;
 384 int timeout = 1;
 385 int tls_active = 0;
 386 int sent_starttls = 0;
 387 int tls_on_connect = 0;
 388
 389 #if HAVE_IPV6
 390 struct sockaddr_in6 s_in6;
 391 #endif
 392
 393 #ifdef HAVE_OPENSSL
 394 SSL_CTX* ctx;
 395 SSL*     ssl;
 396 #endif
 397
 398 unsigned char outbuffer[10240];
 399 unsigned char inbuffer[10240];
 400 unsigned char *inptr = inbuffer;
 401
 402 *inptr = 0;   /* Buffer empty */
 403
 404 /* Options */
 405
 406 while (argc >= argi + 1 && argv[argi][0] == '-')
 407   {
 408   if (strcmp(argv[argi], "-tls-on-connect") == 0)
 409     {
 410     tls_on_connect = 1;
 411     argi++;
 412     }
 413   else if (argv[argi][1] == 't' && isdigit(argv[argi][2]))
 414     {
 415     timeout = atoi(argv[argi]+1);
 416     argi++;
 417     }
 418   else
 419     {
 420     printf("Unrecognized option %s\n", argv[argi]);
 421     exit(1);
 422     }
 423   }
 424
 425 /* Mandatory 1st arg is IP address */
 426
 427 if (argc < argi+1)
 428   {
 429   printf("No IP address given\n");
 430   exit(1);
 431   }
 432
 433 address = argv[argi++];
 434 host_af = (strchr(address, ':') != NULL)? AF_INET6 : AF_INET;
 435
 436 /* Mandatory 2nd arg is port */
 437
 438 if (argc < argi+1)
 439   {
 440   printf("No port number given\n");
 441   exit(1);
 442   }
 443
 444 port = atoi(argv[argi++]);
 445
 446 /* Optional next arg is interface */
 447
 448 if (argc > argi &&
 449   (isdigit((unsigned char)argv[argi][0]) || argv[argi][0] == ':'))
 450     interface = argv[argi++];
 451
 452 /* Any more arguments are the name of a certificate file and key file */
 453
 454 if (argc > argi) certfile = argv[argi++];
 455 if (argc > argi) keyfile = argv[argi++];
 456
 457
 458 #if HAVE_IPV6
 459 /* For an IPv6 address, use an IPv6 sockaddr structure. */
 460
 461 if (host_af == AF_INET6)
 462   {
 463   s_ptr = (struct sockaddr *)&s_in6;
 464   s_len = sizeof(s_in6);
 465   }
 466 else
 467 #endif
 468
 469 /* For an IPv4 address, use an IPv4 sockaddr structure,
 470 even on an IPv6 system. */
 471
 472   {
 473   s_ptr = (struct sockaddr *)&s_in4;
 474   s_len = sizeof(s_in4);
 475   }
 476
 477 printf("Connecting to %s port %d ... ", address, port);
 478
 479 sock = socket(host_af, SOCK_STREAM, 0);
 480 if (sock < 0)
 481   {
 482   printf("socket creation failed: %s\n", strerror(errno));
 483   exit(1);
 484   }
 485
 486 /* Bind to a specific interface if requested. On an IPv6 system, this has
 487 to be of the same family as the address we are calling. On an IPv4 system the
 488 test is redundant, but it keeps the code tidier. */
 489
 490 if (interface != NULL)
 491   {
 492   int interface_af = (strchr(interface, ':') != NULL)? AF_INET6 : AF_INET;
 493
 494   if (interface_af == host_af)
 495     {
 496     #if HAVE_IPV6
 497
 498     /* Set up for IPv6 binding */
 499
 500     if (host_af == AF_INET6)
 501       {
 502       memset(&s_in6, 0, sizeof(s_in6));
 503       s_in6.sin6_family = AF_INET6;
 504       s_in6.sin6_port = 0;
 505       if (inet_pton(AF_INET6, interface, &s_in6.sin6_addr) != 1)
 506         {
 507         printf("Unable to parse \"%s\"", interface);
 508         exit(1);
 509         }
 510       }
 511     else
 512     #endif
 513
 514     /* Set up for IPv4 binding */
 515
 516       {
 517       memset(&s_in4, 0, sizeof(s_in4));
 518       s_in4.sin_family = AF_INET;
 519       s_in4.sin_port = 0;
 520       s_in4.sin_addr.s_addr = (S_ADDR_TYPE)inet_addr(interface);
 521       }
 522
 523     /* Bind */
 524
 525     if (bind(sock, s_ptr, s_len) < 0)
 526       {
 527       printf("Unable to bind outgoing SMTP call to %s: %s",
 528         interface, strerror(errno));
 529       exit(1);
 530       }
 531     }
 532   }
 533
 534 /* Set up a remote IPv6 address */
 535
 536 #if HAVE_IPV6
 537 if (host_af == AF_INET6)
 538   {
 539   memset(&s_in6, 0, sizeof(s_in6));
 540   s_in6.sin6_family = AF_INET6;
 541   s_in6.sin6_port = htons(port);
 542   if (inet_pton(host_af, address, &s_in6.sin6_addr) != 1)
 543     {
 544     printf("Unable to parse \"%s\"", address);
 545     exit(1);
 546     }
 547   }
 548 else
 549 #endif
 550
 551 /* Set up a remote IPv4 address */
 552
 553   {
 554   memset(&s_in4, 0, sizeof(s_in4));
 555   s_in4.sin_family = AF_INET;
 556   s_in4.sin_port = htons(port);
 557   s_in4.sin_addr.s_addr = (S_ADDR_TYPE)inet_addr(address);
 558   }
 559
 560 /* SIGALRM handler crashes out */
 561
 562 signal(SIGALRM, sigalrm_handler_crash);
 563 alarm(timeout);
 564 rc = connect(sock, s_ptr, s_len);
 565 save_errno = errno;
 566 alarm(0);
 567
 568 /* A failure whose error code is "Interrupted system call" is in fact
 569 an externally applied timeout if the signal handler has been run. */
 570
 571 if (rc < 0)
 572   {
 573   close(sock);
 574   printf("failed: %s\n", strerror(save_errno));
 575   exit(1);
 576   }
 577
 578 printf("connected\n");
 579
 580
 581 /* --------------- Set up for OpenSSL --------------- */
 582
 583 #ifdef HAVE_OPENSSL
 584 SSL_library_init();
 585 SSL_load_error_strings();
 586
 587 ctx = SSL_CTX_new(SSLv23_method());
 588 if (ctx == NULL)
 589   {
 590   printf ("SSL_CTX_new failed\n");
 591   exit(1);
 592   }
 593
 594 if (certfile != NULL)
 595   {
 596   if (!SSL_CTX_use_certificate_file(ctx, certfile, SSL_FILETYPE_PEM))
 597     {
 598     printf("SSL_CTX_use_certificate_file failed\n");
 599     exit(1);
 600     }
 601   printf("Certificate file = %s\n", certfile);
 602   }
 603
 604 if (keyfile != NULL)
 605   {
 606   if (!SSL_CTX_use_PrivateKey_file(ctx, keyfile, SSL_FILETYPE_PEM))
 607     {
 608     printf("SSL_CTX_use_PrivateKey_file failed\n");
 609     exit(1);
 610     }
 611   printf("Key file = %s\n", keyfile);
 612   }
 613
 614 SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_BOTH);
 615 SSL_CTX_set_timeout(ctx, 200);
 616 SSL_CTX_set_info_callback(ctx, (void (*)())info_callback);
 617 #endif
 618
 619
 620 /* --------------- Set up for GnuTLS --------------- */
 621
 622 #ifdef HAVE_GNUTLS
 623 if (certfile != NULL) printf("Certificate file = %s\n", certfile);
 624 if (keyfile != NULL) printf("Key file = %s\n", keyfile);
 625 tls_init(certfile, keyfile);
 626 tls_session = tls_session_init();
 627 gnutls_transport_set_ptr(tls_session, (gnutls_transport_ptr)sock);
 628
 629 /* When the server asks for a certificate and the client does not have one,
 630 there is a SIGPIPE error in the gnutls_handshake() function for some reason
 631 that is not understood. As luck would have it, this has never hit Exim itself
 632 because it ignores SIGPIPE errors. Doing the same here allows it all to work as
 633 one wants. */
 634
 635 signal(SIGPIPE, SIG_IGN);
 636 #endif
 637
 638 /* ---------------------------------------------- */
 639
 640
 641 /* Start TLS session if configured to do so without STARTTLS */
 642
 643 #ifdef HAVE_TLS
 644 if (tls_on_connect)
 645   {
 646   printf("Attempting to start TLS\n");
 647
 648   #ifdef HAVE_OPENSSL
 649   tls_active = tls_start(sock, &ssl, ctx);
 650   #endif
 651
 652   #ifdef HAVE_GNUTLS
 653   sigalrm_seen = FALSE;
 654   alarm(timeout);
 655   tls_active = gnutls_handshake(tls_session) >= 0;
 656   alarm(0);
 657   #endif
 658
 659   if (!tls_active)
 660     printf("Failed to start TLS\n");
 661   else
 662     printf("Succeeded in starting TLS\n");
 663   }
 664 #endif
 665
 666 while (fgets(outbuffer, sizeof(outbuffer), stdin) != NULL)
 667   {
 668   int n = (int)strlen(outbuffer);
 669   while (n > 0 && isspace(outbuffer[n-1])) n--;
 670   outbuffer[n] = 0;
 671
 672   /* Expect incoming */
 673
 674   if (strncmp(outbuffer, "??? ", 4) == 0)
 675     {
 676     unsigned char *lineptr;
 677     printf("%s\n", outbuffer);
 678
 679     if (*inptr == 0)   /* Refill input buffer */
 680       {
 681       if (tls_active)
 682         {
 683         #ifdef HAVE_OPENSSL
 684         rc = SSL_read (ssl, inbuffer, sizeof(inbuffer) - 1);
 685         #endif
 686         #ifdef HAVE_GNUTLS
 687         rc = gnutls_record_recv(tls_session, CS inbuffer, sizeof(inbuffer) - 1);
 688         #endif
 689         }
 690       else
 691         {
 692         alarm(timeout);
 693         rc = read(sock, inbuffer, sizeof(inbuffer));
 694         alarm(0);
 695         }
 696
 697       if (rc < 0)
 698         {
 699         printf("Read error %s\n", strerror(errno));
 700         exit(1)  ;
 701         }
 702       else if (rc == 0)
 703         {
 704         printf("Unexpected EOF read\n");
 705         close(sock);
 706         exit(1);
 707         }
 708       else
 709         {
 710         inbuffer[rc] = 0;
 711         inptr = inbuffer;
 712         }
 713       }
 714
 715     lineptr = inptr;
 716     while (*inptr != 0 && *inptr != '\r' && *inptr != '\n') inptr++;
 717     if (*inptr != 0)
 718       {
 719       *inptr++ = 0;
 720       if (*inptr == '\n') inptr++;
 721       }
 722
 723     printf("<<< %s\n", lineptr);
 724     if (strncmp(lineptr, outbuffer + 4, (int)strlen(outbuffer) - 4) != 0)
 725       {
 726       printf("\n******** Input mismatch ********\n");
 727       exit(1);
 728       }
 729
 730     #ifdef HAVE_TLS
 731     if (sent_starttls)
 732       {
 733       if (lineptr[0] == '2')
 734         {
 735         printf("Attempting to start TLS\n");
 736         fflush(stdout);
 737
 738         #ifdef HAVE_OPENSSL
 739         tls_active = tls_start(sock, &ssl, ctx);
 740         #endif
 741
 742         #ifdef HAVE_GNUTLS
 743         sigalrm_seen = FALSE;
 744         alarm(timeout);
 745         tls_active = gnutls_handshake(tls_session) >= 0;
 746         alarm(0);
 747         #endif
 748
 749         if (!tls_active)
 750           {
 751           printf("Failed to start TLS\n");
 752           fflush(stdout);
 753           }
 754         else
 755           printf("Succeeded in starting TLS\n");
 756         }
 757       else printf("Abandoning TLS start attempt\n");
 758       }
 759     sent_starttls = 0;
 760     #endif
 761     }
 762
 763   /* Wait for a bit before proceeding */
 764
 765   else if (strncmp(outbuffer, "+++ ", 4) == 0)
 766     {
 767     printf("%s\n", outbuffer);
 768     sleep(atoi(outbuffer + 4));
 769     }
 770
 771   /* Send outgoing, but barf if unconsumed incoming */
 772
 773   else
 774     {
 775     unsigned char *escape;
 776
 777     if (*inptr != 0)
 778       {
 779       printf("Unconsumed input: %s", inptr);
 780       printf("   About to send: %s\n", outbuffer);
 781       exit(1);
 782       }
 783
 784     #ifdef HAVE_TLS
 785
 786     /* Shutdown TLS */
 787
 788     if (strcmp(outbuffer, "stoptls") == 0 ||
 789         strcmp(outbuffer, "STOPTLS") == 0)
 790       {
 791       if (!tls_active)
 792         {
 793         printf("STOPTLS read when TLS not active\n");
 794         exit(1);
 795         }
 796       printf("Shutting down TLS encryption\n");
 797
 798       #ifdef HAVE_OPENSSL
 799       SSL_shutdown(ssl);
 800       SSL_free(ssl);
 801       #endif
 802
 803       #ifdef HAVE_GNUTLS
 804       gnutls_bye(tls_session, GNUTLS_SHUT_WR);
 805       gnutls_deinit(tls_session);
 806       tls_session = NULL;
 807       gnutls_global_deinit();
 808       #endif
 809
 810       tls_active = 0;
 811       continue;
 812       }
 813
 814     /* Remember that we sent STARTTLS */
 815
 816     sent_starttls = (strcmp(outbuffer, "starttls") == 0 ||
 817                      strcmp(outbuffer, "STARTTLS") == 0);
 818
 819     /* Fudge: if the command is "starttls_wait", we send the starttls bit,
 820     but we haven't set the flag, so that there is no negotiation. This is for
 821     testing the server's timeout. */
 822
 823     if (strcmp(outbuffer, "starttls_wait") == 0)
 824       {
 825       outbuffer[8] = 0;
 826       n = 8;
 827       }
 828     #endif
 829
 830     printf(">>> %s\n", outbuffer);
 831     strcpy(outbuffer + n, "\r\n");
 832
 833     /* Turn "\n" and "\r" into the relevant characters. This is a hack. */
 834
 835     while ((escape = strstr(outbuffer, "\\r")) != NULL)
 836       {
 837       *escape = '\r';
 838       memmove(escape + 1, escape + 2,  (n + 2) - (escape - outbuffer) - 2);
 839       n--;
 840       }
 841
 842     while ((escape = strstr(outbuffer, "\\n")) != NULL)
 843       {
 844       *escape = '\n';
 845       memmove(escape + 1, escape + 2,  (n + 2) - (escape - outbuffer) - 2);
 846       n--;
 847       }
 848
 849     /* OK, do it */
 850
 851     alarm(timeout);
 852     if (tls_active)
 853       {
 854       #ifdef HAVE_OPENSSL
 855         rc = SSL_write (ssl, outbuffer, n + 2);
 856       #endif
 857       #ifdef HAVE_GNUTLS
 858         rc = gnutls_record_send(tls_session, CS outbuffer, n + 2);
 859         if (rc < 0)
 860           {
 861           printf("GnuTLS write error: %s\n", gnutls_strerror(rc));
 862           exit(1);
 863           }
 864       #endif
 865       }
 866     else
 867       {
 868       rc = write(sock, outbuffer, n + 2);
 869       }
 870     alarm(0);
 871
 872     if (rc < 0)
 873       {
 874       printf("Write error: %s\n", strerror(errno));
 875       exit(1);
 876       }
 877     }
 878   }
 879
 880 printf("End of script\n");
 881 close(sock);
 882
 883 exit(0);
 884 }
 885
 886 /* End of client.c */