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