Make test-suite client cmd -t<timeout> actually work
[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 */