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