Merge tag 'exim-4_82_1'
[exim.git] / 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
28 #include <netdb.h>
29 #include <arpa/inet.h>
30 #include <sys/time.h>
31 #include <sys/resource.h>
32 #include <sys/socket.h>
33 #include <sys/stat.h>
34 #include <fcntl.h>
35 #include <unistd.h>
36 #include <utime.h>
37
38 #ifdef AF_INET6
39 #define HAVE_IPV6 1
40 #endif
41
42 #ifndef S_ADDR_TYPE
43 #define S_ADDR_TYPE u_long
44 #endif
45
46 typedef unsigned char uschar;
47
48 #define CS   (char *)
49 #define US   (unsigned char *)
50
51 #define FALSE         0
52 #define TRUE          1
53
54
55
56 static int sigalrm_seen = 0;
57
58
59 /* TLS support can be optionally included, either for OpenSSL or GnuTLS. The
60 latter needs a whole pile of tables. */
61
62 #ifdef HAVE_OPENSSL
63 # define HAVE_TLS
64 # include <openssl/crypto.h>
65 # include <openssl/x509.h>
66 # include <openssl/pem.h>
67 # include <openssl/ssl.h>
68 # include <openssl/err.h>
69 # include <openssl/rand.h>
70 # include <openssl/ocsp.h>
71 #endif
72
73
74 #ifdef HAVE_GNUTLS
75 # define HAVE_TLS
76 # include <gnutls/gnutls.h>
77 # include <gnutls/x509.h>
78 # if GNUTLS_VERSION_NUMBER >= 0x030103
79 #  define HAVE_OCSP
80 #  include <gnutls/ocsp.h>
81 # endif
82
83 # define DH_BITS      768
84
85 /* Local static variables for GNUTLS */
86
87 static gnutls_dh_params dh_params = NULL;
88
89 static gnutls_certificate_credentials_t x509_cred = NULL;
90 static gnutls_session tls_session = NULL;
91
92 static int  ssl_session_timeout = 200;
93
94 /* Priorities for TLS algorithms to use. */
95
96 static const int protocol_priority[16] = { GNUTLS_TLS1, GNUTLS_SSL3, 0 };
97
98 static const int kx_priority[16] = {
99   GNUTLS_KX_RSA,
100   GNUTLS_KX_DHE_DSS,
101   GNUTLS_KX_DHE_RSA,
102   0 };
103
104 static int default_cipher_priority[16] = {
105   GNUTLS_CIPHER_AES_256_CBC,
106   GNUTLS_CIPHER_AES_128_CBC,
107   GNUTLS_CIPHER_3DES_CBC,
108   GNUTLS_CIPHER_ARCFOUR_128,
109   0 };
110
111 static const int mac_priority[16] = {
112   GNUTLS_MAC_SHA,
113   GNUTLS_MAC_MD5,
114   0 };
115
116 static const int comp_priority[16] = { GNUTLS_COMP_NULL, 0 };
117 static const int cert_type_priority[16] = { GNUTLS_CRT_X509, 0 };
118
119 #endif  /*HAVE_GNUTLS*/
120
121
122
123 #ifdef HAVE_TLS
124 char * ocsp_stapling = NULL;
125 #endif
126
127
128 /*************************************************
129 *            SIGALRM handler - crash out         *
130 *************************************************/
131
132 static void
133 sigalrm_handler_crash(int sig)
134 {
135 sig = sig;    /* Keep picky compilers happy */
136 printf("\nClient timed out\n");
137 exit(99);
138 }
139
140
141 /*************************************************
142 *            SIGALRM handler - set flag          *
143 *************************************************/
144
145 static void
146 sigalrm_handler_flag(int sig)
147 {
148 sig = sig;    /* Keep picky compilers happy */
149 sigalrm_seen = 1;
150 }
151
152
153
154 /****************************************************************************/
155 /****************************************************************************/
156
157 #ifdef HAVE_OPENSSL
158
159 X509_STORE *
160 setup_verify(BIO *bp, char *CAfile, char *CApath)
161 {
162         X509_STORE *store;
163         X509_LOOKUP *lookup;
164         if(!(store = X509_STORE_new())) goto end;
165         lookup=X509_STORE_add_lookup(store,X509_LOOKUP_file());
166         if (lookup == NULL) goto end;
167         if (CAfile) {
168                 if(!X509_LOOKUP_load_file(lookup,CAfile,X509_FILETYPE_PEM)) {
169                         BIO_printf(bp, "Error loading file %s\n", CAfile);
170                         goto end;
171                 }
172         } else X509_LOOKUP_load_file(lookup,NULL,X509_FILETYPE_DEFAULT);
173
174         lookup=X509_STORE_add_lookup(store,X509_LOOKUP_hash_dir());
175         if (lookup == NULL) goto end;
176         if (CApath) {
177                 if(!X509_LOOKUP_add_dir(lookup,CApath,X509_FILETYPE_PEM)) {
178                         BIO_printf(bp, "Error loading directory %s\n", CApath);
179                         goto end;
180                 }
181         } else X509_LOOKUP_add_dir(lookup,NULL,X509_FILETYPE_DEFAULT);
182
183         ERR_clear_error();
184         return store;
185         end:
186         X509_STORE_free(store);
187         return NULL;
188 }
189
190
191 static int
192 tls_client_stapling_cb(SSL *s, void *arg)
193 {
194 const unsigned char *p;
195 int len;
196 OCSP_RESPONSE *rsp;
197 OCSP_BASICRESP *bs;
198 char *CAfile = NULL;
199 X509_STORE *store = NULL;
200 int ret = 1;
201
202 len = SSL_get_tlsext_status_ocsp_resp(s, &p);
203 /*BIO_printf(arg, "OCSP response: ");*/
204 if (!p)
205         {
206         BIO_printf(arg, "no response received\n");
207         return 1;
208         }
209 if(!(rsp = d2i_OCSP_RESPONSE(NULL, &p, len)))
210         {
211         BIO_printf(arg, "response parse error\n");
212         BIO_dump_indent(arg, (char *)p, len, 4);
213         return 0;
214         }
215 if(!(bs = OCSP_response_get1_basic(rsp)))
216   {
217   BIO_printf(arg, "error parsing response\n");
218   return 0;
219   }
220
221 CAfile = ocsp_stapling;
222 if(!(store = setup_verify(arg, CAfile, NULL)))
223   {
224   BIO_printf(arg, "error in cert setup\n");
225   return 0;
226   }
227
228 /* No file of alternate certs, no options */
229 if(OCSP_basic_verify(bs, NULL, store, 0) <= 0)
230   {
231   BIO_printf(arg, "Response Verify Failure\n");
232   ERR_print_errors(arg);
233   ret = 0;
234   }
235 else
236   BIO_printf(arg, "Response verify OK\n");
237
238 X509_STORE_free(store);
239 return ret;
240 }
241
242
243 /*************************************************
244 *         Start an OpenSSL TLS session           *
245 *************************************************/
246
247 int
248 tls_start(int sock, SSL **ssl, SSL_CTX *ctx)
249 {
250 int rc;
251 static const char *sid_ctx = "exim";
252
253 RAND_load_file("client.c", -1);   /* Not *very* random! */
254
255 *ssl = SSL_new (ctx);
256 SSL_set_session_id_context(*ssl, sid_ctx, strlen(sid_ctx));
257 SSL_set_fd (*ssl, sock);
258 SSL_set_connect_state(*ssl);
259
260 if (ocsp_stapling)
261   {
262   SSL_CTX_set_tlsext_status_cb(ctx, tls_client_stapling_cb);
263   SSL_CTX_set_tlsext_status_arg(ctx, BIO_new_fp(stdout, BIO_NOCLOSE));
264   SSL_set_tlsext_status_type(*ssl, TLSEXT_STATUSTYPE_ocsp);
265   }
266
267 signal(SIGALRM, sigalrm_handler_flag);
268 sigalrm_seen = 0;
269 alarm(5);
270 rc = SSL_connect (*ssl);
271 alarm(0);
272
273 if (sigalrm_seen)
274   {
275   printf("SSL_connect timed out\n");
276   return 0;
277   }
278
279 if (rc <= 0)
280   {
281   ERR_print_errors_fp(stdout);
282   return 0;
283   }
284
285 printf("SSL connection using %s\n", SSL_get_cipher (*ssl));
286 return 1;
287 }
288
289
290 /*************************************************
291 *           SSL Information callback             *
292 *************************************************/
293
294 static void
295 info_callback(SSL *s, int where, int ret)
296 {
297 where = where;
298 ret = ret;
299 printf("SSL info: %s\n", SSL_state_string_long(s));
300 }
301 #endif
302
303
304 /****************************************************************************/
305 /****************************************************************************/
306
307
308 #ifdef HAVE_GNUTLS
309 /*************************************************
310 *            Handle GnuTLS error                 *
311 *************************************************/
312
313 /* Called from lots of places when errors occur before actually starting to do
314 the TLS handshake, that is, while the session is still in clear.
315
316 Argument:
317   prefix    prefix text
318   err       a GnuTLS error number, or 0 if local error
319
320 Returns:    doesn't - it dies
321 */
322
323 static void
324 gnutls_error(uschar *prefix, int err)
325 {
326 fprintf(stderr, "GnuTLS connection error: %s:", prefix);
327 if (err != 0) fprintf(stderr, " %s", gnutls_strerror(err));
328 fprintf(stderr, "\n");
329 exit(1);
330 }
331
332
333
334 /*************************************************
335 *             Setup up DH parameters             *
336 *************************************************/
337
338 /* For the test suite, the parameters should always be available in the spool
339 directory. */
340
341 static void
342 init_dh(void)
343 {
344 int fd;
345 int ret;
346 gnutls_datum m;
347 uschar filename[200];
348 struct stat statbuf;
349
350 /* Initialize the data structures for holding the parameters */
351
352 ret = gnutls_dh_params_init(&dh_params);
353 if (ret < 0) gnutls_error(US"init dh_params", ret);
354
355 /* Open the cache file for reading and if successful, read it and set up the
356 parameters. */
357
358 fd = open("aux-fixed/gnutls-params", O_RDONLY, 0);
359 if (fd < 0)
360   {
361   fprintf(stderr, "Failed to open spool/gnutls-params: %s\n", strerror(errno));
362   exit(1);
363   }
364
365 if (fstat(fd, &statbuf) < 0)
366   {
367   (void)close(fd);
368   return gnutls_error(US"TLS cache stat failed", 0);
369   }
370
371 m.size = statbuf.st_size;
372 m.data = malloc(m.size);
373 if (m.data == NULL)
374   return gnutls_error(US"memory allocation failed", 0);
375 if (read(fd, m.data, m.size) != m.size)
376   return gnutls_error(US"TLS cache read failed", 0);
377 (void)close(fd);
378
379 ret = gnutls_dh_params_import_pkcs3(dh_params, &m, GNUTLS_X509_FMT_PEM);
380 if (ret < 0) return gnutls_error(US"DH params import", ret);
381 free(m.data);
382 }
383
384
385
386
387 /*************************************************
388 *            Initialize for GnuTLS               *
389 *************************************************/
390
391 /*
392 Arguments:
393   certificate     certificate file
394   privatekey      private key file
395 */
396
397 static void
398 tls_init(uschar *certificate, uschar *privatekey)
399 {
400 int rc;
401
402 rc = gnutls_global_init();
403 if (rc < 0) gnutls_error(US"gnutls_global_init", rc);
404
405 /* Read D-H parameters from the cache file. */
406
407 init_dh();
408
409 /* Create the credentials structure */
410
411 rc = gnutls_certificate_allocate_credentials(&x509_cred);
412 if (rc < 0) gnutls_error(US"certificate_allocate_credentials", rc);
413
414 /* Set the certificate and private keys */
415
416 if (certificate != NULL)
417   {
418   rc = gnutls_certificate_set_x509_key_file(x509_cred, CS certificate,
419     CS privatekey, GNUTLS_X509_FMT_PEM);
420   if (rc < 0) gnutls_error("gnutls_certificate", rc);
421   }
422
423 /* Associate the parameters with the x509 credentials structure. */
424
425 gnutls_certificate_set_dh_params(x509_cred, dh_params);
426
427 /* set the CA info for server-cert verify */
428 if (ocsp_stapling)
429   gnutls_certificate_set_x509_trust_file(x509_cred, ocsp_stapling,
430         GNUTLS_X509_FMT_PEM);
431 }
432
433
434
435 /*************************************************
436 *        Initialize a single GNUTLS session      *
437 *************************************************/
438
439 static gnutls_session
440 tls_session_init(void)
441 {
442 gnutls_session session;
443
444 gnutls_init(&session, GNUTLS_CLIENT);
445
446 gnutls_cipher_set_priority(session, default_cipher_priority);
447 gnutls_compression_set_priority(session, comp_priority);
448 gnutls_kx_set_priority(session, kx_priority);
449 gnutls_protocol_set_priority(session, protocol_priority);
450 gnutls_mac_set_priority(session, mac_priority);
451
452 gnutls_cred_set(session, GNUTLS_CRD_CERTIFICATE, x509_cred);
453
454 gnutls_dh_set_prime_bits(session, DH_BITS);
455 gnutls_db_set_cache_expiration(session, ssl_session_timeout);
456
457 return session;
458 }
459 #endif
460
461
462 /****************************************************************************/
463 /****************************************************************************/
464
465
466
467
468 /*************************************************
469 *                 Main Program                   *
470 *************************************************/
471
472 const char * const HELP_MESSAGE = "\n\
473 Usage: client\n\
474           <IP address>\n\
475           <port>\n\
476           [<outgoing interface>]\n\
477           [<cert file>]\n\
478           [<key file>]\n\
479 \n";
480
481 int main(int argc, char **argv)
482 {
483 struct sockaddr *s_ptr;
484 struct sockaddr_in s_in4;
485 char *interface = NULL;
486 char *address = NULL;
487 char *certfile = NULL;
488 char *keyfile = NULL;
489 char *end = NULL;
490 int argi = 1;
491 int host_af, port, s_len, rc, sock, save_errno;
492 int timeout = 1;
493 int tls_active = 0;
494 int sent_starttls = 0;
495 int tls_on_connect = 0;
496 long tmplong;
497
498 #if HAVE_IPV6
499 struct sockaddr_in6 s_in6;
500 #endif
501
502 #ifdef HAVE_OPENSSL
503 SSL_CTX* ctx;
504 SSL*     ssl;
505 #endif
506
507 unsigned char outbuffer[10240];
508 unsigned char inbuffer[10240];
509 unsigned char *inptr = inbuffer;
510
511 *inptr = 0;   /* Buffer empty */
512
513 /* Options */
514
515 while (argc >= argi + 1 && argv[argi][0] == '-')
516   {
517   if (strcmp(argv[argi], "-help") == 0 ||
518       strcmp(argv[argi], "--help") == 0 ||
519       strcmp(argv[argi], "-h") == 0)
520     {
521     printf(HELP_MESSAGE);
522     exit(0);
523     }
524   if (strcmp(argv[argi], "-tls-on-connect") == 0)
525     {
526     tls_on_connect = 1;
527     argi++;
528     }
529 #ifdef HAVE_TLS
530   else if (strcmp(argv[argi], "-ocsp") == 0)
531     {
532     if (argc < ++argi + 1)
533       {
534       fprintf(stderr, "Missing required certificate file for ocsp option\n");
535       exit(1);
536       }
537     ocsp_stapling = argv[argi++];
538     }
539
540 #endif
541   else if (argv[argi][1] == 't' && isdigit(argv[argi][2]))
542     {
543     tmplong = strtol(argv[argi]+2, &end, 10);
544     if (end == argv[argi]+2 || *end)
545       {
546       fprintf(stderr, "Failed to parse seconds from option <%s>\n",
547         argv[argi]);
548       exit(1);
549       }
550     if (tmplong > 10000L)
551       {
552       fprintf(stderr, "Unreasonably long wait of %d seconds requested\n",
553         tmplong);
554       exit(1);
555       }
556     if (tmplong < 0L)
557       {
558       fprintf(stderr, "Timeout must not be negative (%d)\n", tmplong);
559       exit(1);
560       }
561     timeout = (int) tmplong;
562     argi++;
563     }
564   else
565     {
566     fprintf(stderr, "Unrecognized option %s\n", argv[argi]);
567     exit(1);
568     }
569   }
570
571 /* Mandatory 1st arg is IP address */
572
573 if (argc < argi+1)
574   {
575   fprintf(stderr, "No IP address given\n");
576   exit(1);
577   }
578
579 address = argv[argi++];
580 host_af = (strchr(address, ':') != NULL)? AF_INET6 : AF_INET;
581
582 /* Mandatory 2nd arg is port */
583
584 if (argc < argi+1)
585   {
586   fprintf(stderr, "No port number given\n");
587   exit(1);
588   }
589
590 port = atoi(argv[argi++]);
591
592 /* Optional next arg is interface */
593
594 if (argc > argi &&
595   (isdigit((unsigned char)argv[argi][0]) || argv[argi][0] == ':'))
596     interface = argv[argi++];
597
598 /* Any more arguments are the name of a certificate file and key file */
599
600 if (argc > argi) certfile = argv[argi++];
601 if (argc > argi) keyfile = argv[argi++];
602
603
604 #if HAVE_IPV6
605 /* For an IPv6 address, use an IPv6 sockaddr structure. */
606
607 if (host_af == AF_INET6)
608   {
609   s_ptr = (struct sockaddr *)&s_in6;
610   s_len = sizeof(s_in6);
611   }
612 else
613 #endif
614
615 /* For an IPv4 address, use an IPv4 sockaddr structure,
616 even on an IPv6 system. */
617
618   {
619   s_ptr = (struct sockaddr *)&s_in4;
620   s_len = sizeof(s_in4);
621   }
622
623 printf("Connecting to %s port %d ... ", address, port);
624
625 sock = socket(host_af, SOCK_STREAM, 0);
626 if (sock < 0)
627   {
628   printf("socket creation failed: %s\n", strerror(errno));
629   exit(1);
630   }
631
632 /* Bind to a specific interface if requested. On an IPv6 system, this has
633 to be of the same family as the address we are calling. On an IPv4 system the
634 test is redundant, but it keeps the code tidier. */
635
636 if (interface != NULL)
637   {
638   int interface_af = (strchr(interface, ':') != NULL)? AF_INET6 : AF_INET;
639
640   if (interface_af == host_af)
641     {
642     #if HAVE_IPV6
643
644     /* Set up for IPv6 binding */
645
646     if (host_af == AF_INET6)
647       {
648       memset(&s_in6, 0, sizeof(s_in6));
649       s_in6.sin6_family = AF_INET6;
650       s_in6.sin6_port = 0;
651       if (inet_pton(AF_INET6, interface, &s_in6.sin6_addr) != 1)
652         {
653         printf("Unable to parse \"%s\"", interface);
654         exit(1);
655         }
656       }
657     else
658     #endif
659
660     /* Set up for IPv4 binding */
661
662       {
663       memset(&s_in4, 0, sizeof(s_in4));
664       s_in4.sin_family = AF_INET;
665       s_in4.sin_port = 0;
666       s_in4.sin_addr.s_addr = (S_ADDR_TYPE)inet_addr(interface);
667       }
668
669     /* Bind */
670
671     if (bind(sock, s_ptr, s_len) < 0)
672       {
673       printf("Unable to bind outgoing SMTP call to %s: %s",
674         interface, strerror(errno));
675       exit(1);
676       }
677     }
678   }
679
680 /* Set up a remote IPv6 address */
681
682 #if HAVE_IPV6
683 if (host_af == AF_INET6)
684   {
685   memset(&s_in6, 0, sizeof(s_in6));
686   s_in6.sin6_family = AF_INET6;
687   s_in6.sin6_port = htons(port);
688   if (inet_pton(host_af, address, &s_in6.sin6_addr) != 1)
689     {
690     printf("Unable to parse \"%s\"", address);
691     exit(1);
692     }
693   }
694 else
695 #endif
696
697 /* Set up a remote IPv4 address */
698
699   {
700   memset(&s_in4, 0, sizeof(s_in4));
701   s_in4.sin_family = AF_INET;
702   s_in4.sin_port = htons(port);
703   s_in4.sin_addr.s_addr = (S_ADDR_TYPE)inet_addr(address);
704   }
705
706 /* SIGALRM handler crashes out */
707
708 signal(SIGALRM, sigalrm_handler_crash);
709 alarm(timeout);
710 rc = connect(sock, s_ptr, s_len);
711 save_errno = errno;
712 alarm(0);
713
714 /* A failure whose error code is "Interrupted system call" is in fact
715 an externally applied timeout if the signal handler has been run. */
716
717 if (rc < 0)
718   {
719   close(sock);
720   printf("failed: %s\n", strerror(save_errno));
721   exit(1);
722   }
723
724 printf("connected\n");
725
726
727 /* --------------- Set up for OpenSSL --------------- */
728
729 #ifdef HAVE_OPENSSL
730 SSL_library_init();
731 SSL_load_error_strings();
732
733 ctx = SSL_CTX_new(SSLv23_method());
734 if (ctx == NULL)
735   {
736   printf ("SSL_CTX_new failed\n");
737   exit(1);
738   }
739
740 if (certfile != NULL)
741   {
742   if (!SSL_CTX_use_certificate_file(ctx, certfile, SSL_FILETYPE_PEM))
743     {
744     printf("SSL_CTX_use_certificate_file failed\n");
745     exit(1);
746     }
747   printf("Certificate file = %s\n", certfile);
748   }
749
750 if (keyfile != NULL)
751   {
752   if (!SSL_CTX_use_PrivateKey_file(ctx, keyfile, SSL_FILETYPE_PEM))
753     {
754     printf("SSL_CTX_use_PrivateKey_file failed\n");
755     exit(1);
756     }
757   printf("Key file = %s\n", keyfile);
758   }
759
760 SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_BOTH);
761 SSL_CTX_set_timeout(ctx, 200);
762 SSL_CTX_set_info_callback(ctx, (void (*)())info_callback);
763 #endif
764
765
766 /* --------------- Set up for GnuTLS --------------- */
767
768 #ifdef HAVE_GNUTLS
769 if (certfile != NULL) printf("Certificate file = %s\n", certfile);
770 if (keyfile != NULL) printf("Key file = %s\n", keyfile);
771 tls_init(certfile, keyfile);
772 tls_session = tls_session_init();
773 #ifdef HAVE_OCSP
774 if (ocsp_stapling)
775   gnutls_ocsp_status_request_enable_client(tls_session, NULL, 0, NULL);
776 #endif
777 gnutls_transport_set_ptr(tls_session, (gnutls_transport_ptr)sock);
778
779 /* When the server asks for a certificate and the client does not have one,
780 there is a SIGPIPE error in the gnutls_handshake() function for some reason
781 that is not understood. As luck would have it, this has never hit Exim itself
782 because it ignores SIGPIPE errors. Doing the same here allows it all to work as
783 one wants. */
784
785 signal(SIGPIPE, SIG_IGN);
786 #endif
787
788 /* ---------------------------------------------- */
789
790
791 /* Start TLS session if configured to do so without STARTTLS */
792
793 #ifdef HAVE_TLS
794 if (tls_on_connect)
795   {
796   printf("Attempting to start TLS\n");
797
798   #ifdef HAVE_OPENSSL
799   tls_active = tls_start(sock, &ssl, ctx);
800   #endif
801
802   #ifdef HAVE_GNUTLS
803   sigalrm_seen = FALSE;
804   alarm(timeout);
805   tls_active = gnutls_handshake(tls_session) >= 0;
806   alarm(0);
807   #endif
808
809   if (!tls_active)
810     printf("Failed to start TLS\n");
811   #if defined(HAVE_GNUTLS) && defined(HAVE_OCSP)
812   else if (  ocsp_stapling
813           && gnutls_ocsp_status_request_is_checked(tls_session, 0) == 0)
814     printf("Failed to verify certificate status\n");
815   #endif
816   else
817     printf("Succeeded in starting TLS\n");
818   }
819 #endif
820
821 while (fgets(outbuffer, sizeof(outbuffer), stdin) != NULL)
822   {
823   int n = (int)strlen(outbuffer);
824   while (n > 0 && isspace(outbuffer[n-1])) n--;
825   outbuffer[n] = 0;
826
827   /* Expect incoming */
828
829   if (strncmp(outbuffer, "??? ", 4) == 0)
830     {
831     unsigned char *lineptr;
832     printf("%s\n", outbuffer);
833
834     if (*inptr == 0)   /* Refill input buffer */
835       {
836       if (tls_active)
837         {
838         #ifdef HAVE_OPENSSL
839         rc = SSL_read (ssl, inbuffer, sizeof(inbuffer) - 1);
840         #endif
841         #ifdef HAVE_GNUTLS
842         rc = gnutls_record_recv(tls_session, CS inbuffer, sizeof(inbuffer) - 1);
843         #endif
844         }
845       else
846         {
847         alarm(timeout);
848         rc = read(sock, inbuffer, sizeof(inbuffer));
849         alarm(0);
850         }
851
852       if (rc < 0)
853         {
854         printf("Read error %s\n", strerror(errno));
855         exit(1)  ;
856         }
857       else if (rc == 0)
858         {
859         printf("Unexpected EOF read\n");
860         close(sock);
861         exit(1);
862         }
863       else
864         {
865         inbuffer[rc] = 0;
866         inptr = inbuffer;
867         }
868       }
869
870     lineptr = inptr;
871     while (*inptr != 0 && *inptr != '\r' && *inptr != '\n') inptr++;
872     if (*inptr != 0)
873       {
874       *inptr++ = 0;
875       if (*inptr == '\n') inptr++;
876       }
877
878     printf("<<< %s\n", lineptr);
879     if (strncmp(lineptr, outbuffer + 4, (int)strlen(outbuffer) - 4) != 0)
880       {
881       printf("\n******** Input mismatch ********\n");
882       exit(1);
883       }
884
885     #ifdef HAVE_TLS
886     if (sent_starttls)
887       {
888       if (lineptr[0] == '2')
889         {
890 int rc;
891         unsigned int verify;
892
893         printf("Attempting to start TLS\n");
894         fflush(stdout);
895
896         #ifdef HAVE_OPENSSL
897         tls_active = tls_start(sock, &ssl, ctx);
898         #endif
899
900         #ifdef HAVE_GNUTLS
901         sigalrm_seen = FALSE;
902         alarm(timeout);
903         tls_active = gnutls_handshake(tls_session) >= 0;
904         alarm(0);
905         #endif
906
907         if (!tls_active)
908           {
909           printf("Failed to start TLS\n");
910           fflush(stdout);
911           }
912         #ifdef HAVE_GNUTLS
913         else if (ocsp_stapling)
914           {
915           if ((rc= gnutls_certificate_verify_peers2(tls_session, &verify)) < 0)
916             {
917             printf("Failed to verify certificate: %s\n", gnutls_strerror(rc));
918             fflush(stdout);
919             }
920           else if (verify & (GNUTLS_CERT_INVALID|GNUTLS_CERT_REVOKED))
921             {
922             printf("Bad certificate\n");
923             fflush(stdout);
924             }
925           #ifdef HAVE_OCSP
926           else if (gnutls_ocsp_status_request_is_checked(tls_session, 0) == 0)
927             {
928             printf("Failed to verify certificate status\n");
929               {
930               gnutls_datum_t stapling;
931               gnutls_ocsp_resp_t resp;
932               gnutls_datum_t printed;
933               if (  (rc= gnutls_ocsp_status_request_get(tls_session, &stapling)) == 0
934                  && (rc= gnutls_ocsp_resp_init(&resp)) == 0
935                  && (rc= gnutls_ocsp_resp_import(resp, &stapling)) == 0
936                  && (rc= gnutls_ocsp_resp_print(resp, GNUTLS_OCSP_PRINT_FULL, &printed)) == 0
937                  )
938                 {
939                 fprintf(stderr, "%.4096s", printed.data);
940                 gnutls_free(printed.data);
941                 }
942               else
943                 (void) fprintf(stderr,"ocsp decode: %s", gnutls_strerror(rc));
944               }
945             fflush(stdout);
946             }
947           #endif
948           }
949         #endif
950         else
951           printf("Succeeded in starting TLS\n");
952         }
953       else printf("Abandoning TLS start attempt\n");
954       }
955     sent_starttls = 0;
956     #endif
957     }
958
959   /* Wait for a bit before proceeding */
960
961   else if (strncmp(outbuffer, "+++ ", 4) == 0)
962     {
963     printf("%s\n", outbuffer);
964     sleep(atoi(outbuffer + 4));
965     }
966
967   /* Send outgoing, but barf if unconsumed incoming */
968
969   else
970     {
971     unsigned char *escape;
972
973     if (*inptr != 0)
974       {
975       printf("Unconsumed input: %s", inptr);
976       printf("   About to send: %s\n", outbuffer);
977       exit(1);
978       }
979
980     #ifdef HAVE_TLS
981
982     /* Shutdown TLS */
983
984     if (strcmp(outbuffer, "stoptls") == 0 ||
985         strcmp(outbuffer, "STOPTLS") == 0)
986       {
987       if (!tls_active)
988         {
989         printf("STOPTLS read when TLS not active\n");
990         exit(1);
991         }
992       printf("Shutting down TLS encryption\n");
993
994       #ifdef HAVE_OPENSSL
995       SSL_shutdown(ssl);
996       SSL_free(ssl);
997       #endif
998
999       #ifdef HAVE_GNUTLS
1000       gnutls_bye(tls_session, GNUTLS_SHUT_WR);
1001       gnutls_deinit(tls_session);
1002       tls_session = NULL;
1003       gnutls_global_deinit();
1004       #endif
1005
1006       tls_active = 0;
1007       continue;
1008       }
1009
1010     /* Remember that we sent STARTTLS */
1011
1012     sent_starttls = (strcmp(outbuffer, "starttls") == 0 ||
1013                      strcmp(outbuffer, "STARTTLS") == 0);
1014
1015     /* Fudge: if the command is "starttls_wait", we send the starttls bit,
1016     but we haven't set the flag, so that there is no negotiation. This is for
1017     testing the server's timeout. */
1018
1019     if (strcmp(outbuffer, "starttls_wait") == 0)
1020       {
1021       outbuffer[8] = 0;
1022       n = 8;
1023       }
1024     #endif
1025
1026     printf(">>> %s\n", outbuffer);
1027     strcpy(outbuffer + n, "\r\n");
1028
1029     /* Turn "\n" and "\r" into the relevant characters. This is a hack. */
1030
1031     while ((escape = strstr(outbuffer, "\\r")) != NULL)
1032       {
1033       *escape = '\r';
1034       memmove(escape + 1, escape + 2,  (n + 2) - (escape - outbuffer) - 2);
1035       n--;
1036       }
1037
1038     while ((escape = strstr(outbuffer, "\\n")) != NULL)
1039       {
1040       *escape = '\n';
1041       memmove(escape + 1, escape + 2,  (n + 2) - (escape - outbuffer) - 2);
1042       n--;
1043       }
1044
1045     /* OK, do it */
1046
1047     alarm(timeout);
1048     if (tls_active)
1049       {
1050       #ifdef HAVE_OPENSSL
1051         rc = SSL_write (ssl, outbuffer, n + 2);
1052       #endif
1053       #ifdef HAVE_GNUTLS
1054         rc = gnutls_record_send(tls_session, CS outbuffer, n + 2);
1055         if (rc < 0)
1056           {
1057           printf("GnuTLS write error: %s\n", gnutls_strerror(rc));
1058           exit(1);
1059           }
1060       #endif
1061       }
1062     else
1063       {
1064       rc = write(sock, outbuffer, n + 2);
1065       }
1066     alarm(0);
1067
1068     if (rc < 0)
1069       {
1070       printf("Write error: %s\n", strerror(errno));
1071       exit(1);
1072       }
1073     }
1074   }
1075
1076 printf("End of script\n");
1077 close(sock);
1078
1079 exit(0);
1080 }
1081
1082 /* End of client.c */