]> diplodocus.org Git - nmh/blob - mts/smtp/smtp.c
projects / nmh / blob
? search:


e6bca9a9f1338f49d9a2ac6574cf285976a5fed9
[nmh] / mts / smtp / smtp.c
1 /*
2 * smtp.c -- nmh SMTP interface
3 *
4 * $Id$
5 *
6 * This code is Copyright (c) 2002, by the authors of nmh. See the
7 * COPYRIGHT file in the root directory of the nmh distribution for
8 * complete copyright information.
9 */
10
11 #include <h/mh.h>
12 #include "smtp.h"
13 #include <h/mts.h>
14 #include <signal.h>
15 #include <h/signals.h>
16
17 #ifdef CYRUS_SASL
18 #include <sasl/sasl.h>
19 #include <sasl/saslutil.h>
20 #include <sys/socket.h>
21 #include <netinet/in.h>
22 #include <arpa/inet.h>
23 #include <netdb.h>
24 #include <errno.h>
25 #endif /* CYRUS_SASL */
26
27 #ifdef TLS_SUPPORT
28 #include <openssl/ssl.h>
29 #include <openssl/err.h>
30 #endif /* TLS_SUPPORT */
31
32 /*
33 * This module implements an interface to SendMail very similar
34 * to the MMDF mm_(3) routines. The sm_() routines herein talk
35 * SMTP to a sendmail process, mapping SMTP reply codes into
36 * RP_-style codes.
37 */
38
39 /*
40 * On older 4.2BSD machines without the POSIX function `sigaction',
41 * the alarm handing stuff for time-outs will NOT work due to the way
42 * syscalls get restarted. This is not really crucial, since SendMail
43 * is generally well-behaved in this area.
44 */
45
46 #ifdef SENDMAILBUG
47 /*
48 * It appears that some versions of Sendmail will return Code 451
49 * when they don't really want to indicate a failure.
50 * "Code 451 almost always means sendmail has deferred; we don't
51 * really want bomb out at this point since sendmail will rectify
52 * things later." So, if you define SENDMAILBUG, Code 451 is
53 * considered the same as Code 250. Yuck!
54 */
55 #endif
56
57 #define TRUE 1
58 #define FALSE 0
59
60 #define NBITS ((sizeof (int)) * 8)
61
62 /*
63 * these codes must all be different!
64 */
65 #define SM_OPEN 300 /* Changed to 5 minutes to comply with a SHOULD in RFC 1123 */
66 #define SM_HELO 20
67 #define SM_RSET 15
68 #define SM_MAIL 301 /* changed to 5 minutes and a second (for uniqueness), see above */
69 #define SM_RCPT 302 /* see above */
70 #define SM_DATA 120 /* see above */
71 #define SM_TEXT 180 /* see above */
72 #define SM_DOT 600 /* see above */
73 #define SM_QUIT 30
74 #define SM_CLOS 10
75 #define SM_AUTH 45
76
77 static int sm_addrs = 0;
78 static int sm_alarmed = 0;
79 static int sm_child = NOTOK;
80 static int sm_debug = 0;
81 static int sm_nl = TRUE;
82 static int sm_verbose = 0;
83
84 static FILE *sm_rfp = NULL;
85 static FILE *sm_wfp = NULL;
86
87 #ifdef CYRUS_SASL
88 /*
89 * Some globals needed by SASL
90 */
91
92 static sasl_conn_t *conn = NULL; /* SASL connection state */
93 static int sasl_complete = 0; /* Has authentication succeded? */
94 static sasl_ssf_t sasl_ssf; /* Our security strength factor */
95 static char *sasl_pw_context[2]; /* Context to pass into sm_get_pass */
96 static int maxoutbuf; /* Maximum crypto output buffer */
97 static char *sasl_outbuffer; /* SASL output buffer for encryption */
98 static int sasl_outbuflen; /* Current length of data in outbuf */
99 static int sm_get_user(void *, int, const char **, unsigned *);
100 static int sm_get_pass(sasl_conn_t *, void *, int, sasl_secret_t **);
101
102 static sasl_callback_t callbacks[] = {
103 { SASL_CB_USER, sm_get_user, NULL },
104 #define SM_SASL_N_CB_USER 0
105 { SASL_CB_PASS, sm_get_pass, NULL },
106 #define SM_SASL_N_CB_PASS 1
107 { SASL_CB_AUTHNAME, sm_get_user, NULL },
108 #define SM_SASL_N_CB_AUTHNAME 2
109 { SASL_CB_LIST_END, NULL, NULL },
110 };
111
112 #else /* CYRUS_SASL */
113 int sasl_ssf = 0;
114 #endif /* CYRUS_SASL */
115
116 #ifdef TLS_SUPPORT
117 static SSL_CTX *sslctx = NULL;
118 static SSL *ssl = NULL;
119 static BIO *sbior = NULL;
120 static BIO *sbiow = NULL;
121 #endif /* TLS_SUPPORT */
122
123 #if defined(CYRUS_SASL) || defined(TLS_SUPPORT)
124 #define SASL_MAXRECVBUF 65536
125 static int sm_fgetc(FILE *);
126 static char *sasl_inbuffer; /* SASL input buffer for encryption */
127 static char *sasl_inptr; /* Pointer to current inbuf position */
128 static int sasl_inbuflen; /* Current length of data in inbuf */
129 #else
130 #define sm_fgetc fgetc
131 #endif
132
133 static int tls_active = 0;
134
135 static char *sm_noreply = "No reply text given";
136 static char *sm_moreply = "; ";
137
138 struct smtp sm_reply; /* global... */
139
140 #define MAXEHLO 20
141
142 static int doingEHLO;
143 char *EHLOkeys[MAXEHLO + 1];
144
145 /*
146 * static prototypes
147 */
148 static int smtp_init (char *, char *, char *, int, int, int, int, int, int,
149 char *, char *, int);
150 static int sendmail_init (char *, char *, int, int, int, int, int, int,
151 char *, char *);
152
153 static int rclient (char *, char *);
154 static int sm_ierror (char *fmt, ...);
155 static int smtalk (int time, char *fmt, ...);
156 static int sm_wrecord (char *, int);
157 static int sm_wstream (char *, int);
158 static int sm_werror (void);
159 static int smhear (void);
160 static int sm_rrecord (char *, int *);
161 static int sm_rerror (int);
162 static RETSIGTYPE alrmser (int);
163 static char *EHLOset (char *);
164 static int sm_fwrite(char *, int);
165 static int sm_fputs(char *);
166 static int sm_fputc(int);
167 static void sm_fflush(void);
168 static int sm_fgets(char *, int, FILE *);
169
170 #ifdef CYRUS_SASL
171 /*
172 * Function prototypes needed for SASL
173 */
174
175 static int sm_auth_sasl(char *, char *, char *);
176 #endif /* CYRUS_SASL */
177
178 int
179 sm_init (char *client, char *server, char *port, int watch, int verbose,
180 int debug, int onex, int queued, int sasl, char *saslmech,
181 char *user, int tls)
182 {
183 if (sm_mts == MTS_SMTP)
184 return smtp_init (client, server, port, watch, verbose,
185 debug, onex, queued, sasl, saslmech, user, tls);
186 else
187 return sendmail_init (client, server, watch, verbose,
188 debug, onex, queued, sasl, saslmech, user);
189 }
190
191 static int
192 smtp_init (char *client, char *server, char *port, int watch, int verbose,
193 int debug, int onex, int queued,
194 int sasl, char *saslmech, char *user, int tls)
195 {
196 #ifdef CYRUS_SASL
197 char *server_mechs;
198 #endif /* CYRUS_SASL */
199 int result, sd1, sd2;
200
201 if (watch)
202 verbose = TRUE;
203
204 sm_verbose = verbose;
205 sm_debug = debug;
206
207 if (sm_rfp != NULL && sm_wfp != NULL)
208 goto send_options;
209
210 if (client == NULL || *client == '\0') {
211 if (clientname) {
212 client = clientname;
213 } else {
214 client = LocalName(); /* no clientname -> LocalName */
215 }
216 }
217
218 /*
219 * Last-ditch check just in case client still isn't set to anything
220 */
221
222 if (client == NULL || *client == '\0')
223 client = "localhost";
224
225 #if defined(CYRUS_SASL) || defined(TLS_SUPPORT)
226 sasl_inbuffer = malloc(SASL_MAXRECVBUF);
227 if (!sasl_inbuffer)
228 return sm_ierror("Unable to allocate %d bytes for read buffer",
229 SASL_MAXRECVBUF);
230 #endif /* CYRUS_SASL || TLS_SUPPORT */
231
232 if ((sd1 = rclient (server, port)) == NOTOK)
233 return RP_BHST;
234
235 if ((sd2 = dup (sd1)) == NOTOK) {
236 close (sd1);
237 return sm_ierror ("unable to dup");
238 }
239
240 SIGNAL (SIGALRM, alrmser);
241 SIGNAL (SIGPIPE, SIG_IGN);
242
243 if ((sm_rfp = fdopen (sd1, "r")) == NULL
244 || (sm_wfp = fdopen (sd2, "w")) == NULL) {
245 close (sd1);
246 close (sd2);
247 sm_rfp = sm_wfp = NULL;
248 return sm_ierror ("unable to fdopen");
249 }
250
251 tls_active = 0;
252
253 sm_alarmed = 0;
254 alarm (SM_OPEN);
255 result = smhear ();
256 alarm (0);
257
258 switch (result) {
259 case 220:
260 break;
261
262 default:
263 sm_end (NOTOK);
264 return RP_RPLY;
265 }
266
267 /*
268 * Give EHLO or HELO command
269 */
270
271 doingEHLO = 1;
272 result = smtalk (SM_HELO, "EHLO %s", client);
273 doingEHLO = 0;
274
275 if (result >= 500 && result <= 599)
276 result = smtalk (SM_HELO, "HELO %s", client);
277
278 if (result != 250) {
279 sm_end (NOTOK);
280 return RP_RPLY;
281 }
282
283 #ifdef TLS_SUPPORT
284 /*
285 * If the user requested TLS support, then try to do the STARTTLS command
286 * as part of the initial dialog. Assuming this works, we then need to
287 * restart the EHLO dialog after TLS negotiation is complete.
288 */
289
290 if (tls) {
291 if (! EHLOset("STARTTLS")) {
292 sm_end(NOTOK);
293 return sm_ierror("SMTP server does not support TLS");
294 }
295
296 result = smtalk(SM_HELO, "STARTTLS");
297
298 if (result != 220) {
299 sm_end(NOTOK);
300 return RP_RPLY;
301 }
302
303 /*
304 * Okay, the other side should be waiting for us to start TLS
305 * negotiation. Oblige them.
306 */
307
308 if (! sslctx) {
309 SSL_METHOD *method;
310
311 SSL_library_init();
312 SSL_load_error_strings();
313
314 method = TLSv1_client_method(); /* Not sure about this */
315
316 sslctx = SSL_CTX_new(method);
317
318 if (! sslctx) {
319 sm_end(NOTOK);
320 return sm_ierror("Unable to initialize OpenSSL context: %s",
321 ERR_error_string(ERR_get_error(), NULL));
322 }
323 }
324
325 ssl = SSL_new(sslctx);
326
327 if (! ssl) {
328 sm_end(NOTOK);
329 return sm_ierror("Unable to create SSL connection: %s",
330 ERR_error_string(ERR_get_error(), NULL));
331 }
332
333 sbior = BIO_new_socket(fileno(sm_rfp), BIO_NOCLOSE);
334 sbiow = BIO_new_socket(fileno(sm_wfp), BIO_NOCLOSE);
335
336 if (sbior == NULL || sbiow == NULL) {
337 sm_end(NOTOK);
338 return sm_ierror("Unable to create BIO endpoints: %s",
339 ERR_error_string(ERR_get_error(), NULL));
340 }
341
342 SSL_set_bio(ssl, sbior, sbiow);
343
344 if (SSL_connect(ssl) < 1) {
345 sm_end(NOTOK);
346 return sm_ierror("Unable to negotiate SSL connection: %s",
347 ERR_error_string(ERR_get_error(), NULL));
348 }
349
350 if (sm_debug) {
351 SSL_CIPHER *cipher = SSL_get_current_cipher(ssl);
352 printf("SSL negotiation successful: %s(%d) %s\n",
353 SSL_CIPHER_get_name(cipher),
354 SSL_CIPHER_get_bits(cipher, NULL),
355 SSL_CIPHER_get_version(cipher));
356
357 }
358
359 tls_active = 1;
360
361 doingEHLO = 1;
362 result = smtalk (SM_HELO, "EHLO %s", client);
363 doingEHLO = 0;
364
365 if (result != 250) {
366 sm_end (NOTOK);
367 return RP_RPLY;
368 }
369 }
370 #endif /* TLS_SUPPORT */
371
372 #ifdef CYRUS_SASL
373 /*
374 * If the user asked for SASL, then check to see if the SMTP server
375 * supports it. Otherwise, error out (because the SMTP server
376 * might have been spoofed; we don't want to just silently not
377 * do authentication
378 */
379
380 if (sasl) {
381 if (! (server_mechs = EHLOset("AUTH"))) {
382 sm_end(NOTOK);
383 return sm_ierror("SMTP server does not support SASL");
384 }
385
386 if (saslmech && stringdex(saslmech, server_mechs) == -1) {
387 sm_end(NOTOK);
388 return sm_ierror("Requested SASL mech \"%s\" is not in the "
389 "list of supported mechanisms:\n%s",
390 saslmech, server_mechs);
391 }
392
393 if (sm_auth_sasl(user, saslmech ? saslmech : server_mechs,
394 server) != RP_OK) {
395 sm_end(NOTOK);
396 return NOTOK;
397 }
398 }
399 #endif /* CYRUS_SASL */
400
401 send_options: ;
402 if (watch && EHLOset ("XVRB"))
403 smtalk (SM_HELO, "VERB on");
404 if (onex && EHLOset ("XONE"))
405 smtalk (SM_HELO, "ONEX");
406 if (queued && EHLOset ("XQUE"))
407 smtalk (SM_HELO, "QUED");
408
409 return RP_OK;
410 }
411
412 int
413 sendmail_init (char *client, char *server, int watch, int verbose,
414 int debug, int onex, int queued,
415 int sasl, char *saslmech, char *user)
416 {
417 #ifdef CYRUS_SASL
418 char *server_mechs;
419 #endif /* CYRUS_SASL */
420 int i, result, vecp;
421 int pdi[2], pdo[2];
422 char *vec[15];
423
424 if (watch)
425 verbose = TRUE;
426
427 sm_verbose = verbose;
428 sm_debug = debug;
429 if (sm_rfp != NULL && sm_wfp != NULL)
430 return RP_OK;
431
432 if (client == NULL || *client == '\0') {
433 if (clientname)
434 client = clientname;
435 else
436 client = LocalName(); /* no clientname -> LocalName */
437 }
438
439 /*
440 * Last-ditch check just in case client still isn't set to anything
441 */
442
443 if (client == NULL || *client == '\0')
444 client = "localhost";
445
446 #ifdef CYRUS_SASL
447 sasl_inbuffer = malloc(SASL_MAXRECVBUF);
448 if (!sasl_inbuffer)
449 return sm_ierror("Unable to allocate %d bytes for read buffer",
450 SASL_MAXRECVBUF);
451 #endif /* CYRUS_SASL */
452
453 if (pipe (pdi) == NOTOK)
454 return sm_ierror ("no pipes");
455 if (pipe (pdo) == NOTOK) {
456 close (pdi[0]);
457 close (pdi[1]);
458 return sm_ierror ("no pipes");
459 }
460
461 for (i = 0; (sm_child = fork ()) == NOTOK && i < 5; i++)
462 sleep (5);
463
464 switch (sm_child) {
465 case NOTOK:
466 close (pdo[0]);
467 close (pdo[1]);
468 close (pdi[0]);
469 close (pdi[1]);
470 return sm_ierror ("unable to fork");
471
472 case OK:
473 if (pdo[0] != fileno (stdin))
474 dup2 (pdo[0], fileno (stdin));
475 if (pdi[1] != fileno (stdout))
476 dup2 (pdi[1], fileno (stdout));
477 if (pdi[1] != fileno (stderr))
478 dup2 (pdi[1], fileno (stderr));
479 for (i = fileno (stderr) + 1; i < NBITS; i++)
480 close (i);
481
482 vecp = 0;
483 vec[vecp++] = r1bindex (sendmail, '/');
484 vec[vecp++] = "-bs";
485 vec[vecp++] = watch ? "-odi" : queued ? "-odq" : "-odb";
486 vec[vecp++] = "-oem";
487 vec[vecp++] = "-om";
488 # ifndef RAND
489 if (verbose)
490 vec[vecp++] = "-ov";
491 # endif /* not RAND */
492 vec[vecp++] = NULL;
493
494 setgid (getegid ());
495 setuid (geteuid ());
496 execvp (sendmail, vec);
497 fprintf (stderr, "unable to exec ");
498 perror (sendmail);
499 _exit (-1); /* NOTREACHED */
500
501 default:
502 SIGNAL (SIGALRM, alrmser);
503 SIGNAL (SIGPIPE, SIG_IGN);
504
505 close (pdi[1]);
506 close (pdo[0]);
507 if ((sm_rfp = fdopen (pdi[0], "r")) == NULL
508 || (sm_wfp = fdopen (pdo[1], "w")) == NULL) {
509 close (pdi[0]);
510 close (pdo[1]);
511 sm_rfp = sm_wfp = NULL;
512 return sm_ierror ("unable to fdopen");
513 }
514 sm_alarmed = 0;
515 alarm (SM_OPEN);
516 result = smhear ();
517 alarm (0);
518 switch (result) {
519 case 220:
520 break;
521
522 default:
523 sm_end (NOTOK);
524 return RP_RPLY;
525 }
526
527 doingEHLO = 1;
528 result = smtalk (SM_HELO, "EHLO %s", client);
529 doingEHLO = 0;
530
531 if (500 <= result && result <= 599)
532 result = smtalk (SM_HELO, "HELO %s", client);
533
534 switch (result) {
535 case 250:
536 break;
537
538 default:
539 sm_end (NOTOK);
540 return RP_RPLY;
541 }
542
543 #ifdef CYRUS_SASL
544 /*
545 * If the user asked for SASL, then check to see if the SMTP server
546 * supports it. Otherwise, error out (because the SMTP server
547 * might have been spoofed; we don't want to just silently not
548 * do authentication
549 */
550
551 if (sasl) {
552 if (! (server_mechs = EHLOset("AUTH"))) {
553 sm_end(NOTOK);
554 return sm_ierror("SMTP server does not support SASL");
555 }
556
557 if (saslmech && stringdex(saslmech, server_mechs) == -1) {
558 sm_end(NOTOK);
559 return sm_ierror("Requested SASL mech \"%s\" is not in the "
560 "list of supported mechanisms:\n%s",
561 saslmech, server_mechs);
562 }
563
564 if (sm_auth_sasl(user, saslmech ? saslmech : server_mechs,
565 server) != RP_OK) {
566 sm_end(NOTOK);
567 return NOTOK;
568 }
569 }
570 #endif /* CYRUS_SASL */
571
572 if (onex)
573 smtalk (SM_HELO, "ONEX");
574 if (watch)
575 smtalk (SM_HELO, "VERB on");
576
577 return RP_OK;
578 }
579 }
580
581 static int
582 rclient (char *server, char *service)
583 {
584 int sd;
585 char response[BUFSIZ];
586
587 if ((sd = client (server, service, response, sizeof(response),
588 sm_debug)) != NOTOK)
589 return sd;
590
591 sm_ierror ("%s", response);
592 return NOTOK;
593 }
594
595 int
596 sm_winit (int mode, char *from)
597 {
598 char *smtpcom = NULL;
599
600 switch (mode) {
601 case S_MAIL:
602 smtpcom = "MAIL";
603 break;
604
605 case S_SEND:
606 smtpcom = "SEND";
607 break;
608
609 case S_SOML:
610 smtpcom = "SOML";
611 break;
612
613 case S_SAML:
614 smtpcom = "SAML";
615 break;
616
617 default:
618 /* Hopefully, we do not get here. */
619 break;
620 }
621
622 switch (smtalk (SM_MAIL, "%s FROM:<%s>", smtpcom, from)) {
623 case 250:
624 sm_addrs = 0;
625 return RP_OK;
626
627 case 500:
628 case 501:
629 case 552:
630 return RP_PARM;
631
632 default:
633 return RP_RPLY;
634 }
635 }
636
637
638 int
639 sm_wadr (char *mbox, char *host, char *path)
640 {
641 switch (smtalk (SM_RCPT, host && *host ? "RCPT TO:<%s%s@%s>"
642 : "RCPT TO:<%s%s>",
643 path ? path : "", mbox, host)) {
644 case 250:
645 case 251:
646 sm_addrs++;
647 return RP_OK;
648
649 case 451:
650 #ifdef SENDMAILBUG
651 sm_addrs++;
652 return RP_OK;
653 #endif /* SENDMAILBUG */
654 case 421:
655 case 450:
656 case 452:
657 return RP_NO;
658
659 case 500:
660 case 501:
661 return RP_PARM;
662
663 case 550:
664 case 551:
665 case 552:
666 case 553:
667 return RP_USER;
668
669 default:
670 return RP_RPLY;
671 }
672 }
673
674
675 int
676 sm_waend (void)
677 {
678 switch (smtalk (SM_DATA, "DATA")) {
679 case 354:
680 sm_nl = TRUE;
681 return RP_OK;
682
683 case 451:
684 #ifdef SENDMAILBUG
685 sm_nl = TRUE;
686 return RP_OK;
687 #endif /* SENDMAILBUG */
688 case 421:
689 return RP_NO;
690
691 case 500:
692 case 501:
693 case 503:
694 case 554:
695 return RP_NDEL;
696
697 default:
698 return RP_RPLY;
699 }
700 }
701
702
703 int
704 sm_wtxt (char *buffer, int len)
705 {
706 int result;
707
708 sm_alarmed = 0;
709 alarm (SM_TEXT);
710 result = sm_wstream (buffer, len);
711 alarm (0);
712
713 return (result == NOTOK ? RP_BHST : RP_OK);
714 }
715
716
717 int
718 sm_wtend (void)
719 {
720 if (sm_wstream ((char *) NULL, 0) == NOTOK)
721 return RP_BHST;
722
723 switch (smtalk (SM_DOT + 3 * sm_addrs, ".")) {
724 case 250:
725 case 251:
726 return RP_OK;
727
728 case 451:
729 #ifdef SENDMAILBUG
730 return RP_OK;
731 #endif /* SENDMAILBUG */
732 case 452:
733 default:
734 return RP_NO;
735
736 case 552:
737 case 554:
738 return RP_NDEL;
739 }
740 }
741
742
743 int
744 sm_end (int type)
745 {
746 int status;
747 struct smtp sm_note;
748
749 if (sm_mts == MTS_SENDMAIL) {
750 switch (sm_child) {
751 case NOTOK:
752 case OK:
753 return RP_OK;
754
755 default:
756 break;
757 }
758 }
759
760 if (sm_rfp == NULL && sm_wfp == NULL)
761 return RP_OK;
762
763 switch (type) {
764 case OK:
765 smtalk (SM_QUIT, "QUIT");
766 break;
767
768 case NOTOK:
769 sm_note.code = sm_reply.code;
770 sm_note.length = sm_reply.length;
771 memcpy (sm_note.text, sm_reply.text, sm_reply.length + 1);/* fall */
772 case DONE:
773 if (smtalk (SM_RSET, "RSET") == 250 && type == DONE)
774 return RP_OK;
775 if (sm_mts == MTS_SMTP)
776 smtalk (SM_QUIT, "QUIT");
777 else {
778 kill (sm_child, SIGKILL);
779 discard (sm_rfp);
780 discard (sm_wfp);
781 }
782 if (type == NOTOK) {
783 sm_reply.code = sm_note.code;
784 sm_reply.length = sm_note.length;
785 memcpy (sm_reply.text, sm_note.text, sm_note.length + 1);
786 }
787 break;
788 }
789
790 if (tls_active) {
791 SSL_shutdown(ssl);
792 SSL_free(ssl);
793 }
794
795 if (sm_rfp != NULL) {
796 alarm (SM_CLOS);
797 fclose (sm_rfp);
798 alarm (0);
799 }
800 if (sm_wfp != NULL) {
801 alarm (SM_CLOS);
802 fclose (sm_wfp);
803 alarm (0);
804 }
805
806 if (sm_mts == MTS_SMTP) {
807 status = 0;
808 #ifdef CYRUS_SASL
809 if (conn) {
810 sasl_dispose(&conn);
811 if (sasl_outbuffer) {
812 free(sasl_outbuffer);
813 }
814 }
815 if (sasl_inbuffer)
816 free(sasl_inbuffer);
817 #endif /* CYRUS_SASL */
818 } else {
819 status = pidwait (sm_child, OK);
820 sm_child = NOTOK;
821 }
822
823 sm_rfp = sm_wfp = NULL;
824 return (status ? RP_BHST : RP_OK);
825 }
826
827 #ifdef CYRUS_SASL
828 /*
829 * This function implements SASL authentication for SMTP. If this function
830 * completes successfully, then authentication is successful and we've
831 * (optionally) negotiated a security layer.
832 */
833 static int
834 sm_auth_sasl(char *user, char *mechlist, char *inhost)
835 {
836 int result, status;
837 unsigned int buflen, outlen;
838 char *buf, outbuf[BUFSIZ], host[NI_MAXHOST];
839 const char *chosen_mech;
840 sasl_security_properties_t secprops;
841 sasl_ssf_t *ssf;
842 int *outbufmax;
843
844 /*
845 * Initialize the callback contexts
846 */
847
848 if (user == NULL)
849 user = getusername();
850
851 callbacks[SM_SASL_N_CB_USER].context = user;
852 callbacks[SM_SASL_N_CB_AUTHNAME].context = user;
853
854 /*
855 * This is a _bit_ of a hack ... but if the hostname wasn't supplied
856 * to us on the command line, then call getpeername and do a
857 * reverse-address lookup on the IP address to get the name.
858 */
859
860 memset(host, 0, sizeof(host));
861
862 if (!inhost) {
863 struct sockaddr_storage sin;
864 socklen_t len = sizeof(sin);
865 int result;
866
867 if (getpeername(fileno(sm_wfp), (struct sockaddr *) &sin, &len) < 0) {
868 sm_ierror("getpeername on SMTP socket failed: %s",
869 strerror(errno));
870 return NOTOK;
871 }
872
873 result = getnameinfo((struct sockaddr *) &sin, len, host, sizeof(host),
874 NULL, 0, NI_NAMEREQD);
875 if (result != 0) {
876 sm_ierror("Unable to look up name of connected host: %s",
877 gai_strerror(result));
878 return NOTOK;
879 }
880 } else {
881 strncpy(host, inhost, sizeof(host) - 1);
882 }
883
884 sasl_pw_context[0] = host;
885 sasl_pw_context[1] = user;
886
887 callbacks[SM_SASL_N_CB_PASS].context = sasl_pw_context;
888
889 result = sasl_client_init(callbacks);
890
891 if (result != SASL_OK) {
892 sm_ierror("SASL library initialization failed: %s",
893 sasl_errstring(result, NULL, NULL));
894 return NOTOK;
895 }
896
897 result = sasl_client_new("smtp", host, NULL, NULL, NULL, 0, &conn);
898
899 if (result != SASL_OK) {
900 sm_ierror("SASL client initialization failed: %s",
901 sasl_errstring(result, NULL, NULL));
902 return NOTOK;
903 }
904
905 /*
906 * Initialize the security properties. But if TLS is active, then
907 * don't negotiate encryption here.
908 */
909
910 memset(&secprops, 0, sizeof(secprops));
911 secprops.maxbufsize = SASL_MAXRECVBUF;
912 secprops.max_ssf = tls_active ? 0 : UINT_MAX;
913
914 result = sasl_setprop(conn, SASL_SEC_PROPS, &secprops);
915
916 if (result != SASL_OK) {
917 sm_ierror("SASL security property initialization failed: %s",
918 sasl_errstring(result, NULL, NULL));
919 return NOTOK;
920 }
921
922 /*
923 * Start the actual protocol. Feed the mech list into the library
924 * and get out a possible initial challenge
925 */
926
927 result = sasl_client_start(conn, mechlist, NULL, (const char **) &buf,
928 &buflen, (const char **) &chosen_mech);
929
930 if (result != SASL_OK && result != SASL_CONTINUE) {
931 sm_ierror("SASL client start failed: %s", sasl_errdetail(conn));
932 return NOTOK;
933 }
934
935 /*
936 * If we got an initial challenge, send it as part of the AUTH
937 * command; otherwise, just send a plain AUTH command.
938 */
939
940 if (buflen) {
941 status = sasl_encode64(buf, buflen, outbuf, sizeof(outbuf), NULL);
942 if (status != SASL_OK) {
943 sm_ierror("SASL base64 encode failed: %s",
944 sasl_errstring(status, NULL, NULL));
945 return NOTOK;
946 }
947
948 status = smtalk(SM_AUTH, "AUTH %s %s", chosen_mech, outbuf);
949 } else
950 status = smtalk(SM_AUTH, "AUTH %s", chosen_mech);
951
952 /*
953 * Now we loop until we either fail, get a SASL_OK, or a 235
954 * response code. Receive the challenges and process them until
955 * we're all done.
956 */
957
958 while (result == SASL_CONTINUE) {
959
960 /*
961 * If we get a 235 response, that means authentication has
962 * succeeded and we need to break out of the loop (yes, even if
963 * we still get SASL_CONTINUE from sasl_client_step()).
964 *
965 * Otherwise, if we get a message that doesn't seem to be a
966 * valid response, then abort
967 */
968
969 if (status == 235)
970 break;
971 else if (status < 300 || status > 399)
972 return RP_BHST;
973
974 /*
975 * Special case; a zero-length response from the SMTP server
976 * is returned as a single =. If we get that, then set buflen
977 * to be zero. Otherwise, just decode the response.
978 */
979
980 if (strcmp("=", sm_reply.text) == 0) {
981 outlen = 0;
982 } else {
983 result = sasl_decode64(sm_reply.text, sm_reply.length,
984 outbuf, sizeof(outbuf), &outlen);
985
986 if (result != SASL_OK) {
987 smtalk(SM_AUTH, "*");
988 sm_ierror("SASL base64 decode failed: %s",
989 sasl_errstring(result, NULL, NULL));
990 return NOTOK;
991 }
992 }
993
994 result = sasl_client_step(conn, outbuf, outlen, NULL,
995 (const char **) &buf, &buflen);
996
997 if (result != SASL_OK && result != SASL_CONTINUE) {
998 smtalk(SM_AUTH, "*");
999 sm_ierror("SASL client negotiation failed: %s",
1000 sasl_errstring(result, NULL, NULL));
1001 return NOTOK;
1002 }
1003
1004 status = sasl_encode64(buf, buflen, outbuf, sizeof(outbuf), NULL);
1005
1006 if (status != SASL_OK) {
1007 smtalk(SM_AUTH, "*");
1008 sm_ierror("SASL base64 encode failed: %s",
1009 sasl_errstring(status, NULL, NULL));
1010 return NOTOK;
1011 }
1012
1013 status = smtalk(SM_AUTH, outbuf);
1014 }
1015
1016 /*
1017 * Make sure that we got the correct response
1018 */
1019
1020 if (status < 200 || status > 299)
1021 return RP_BHST;
1022
1023 /*
1024 * We _should_ have completed the authentication successfully.
1025 * Get a few properties from the authentication exchange.
1026 */
1027
1028 result = sasl_getprop(conn, SASL_MAXOUTBUF, (const void **) &outbufmax);
1029
1030 if (result != SASL_OK) {
1031 sm_ierror("Cannot retrieve SASL negotiated output buffer size: %s",
1032 sasl_errstring(result, NULL, NULL));
1033 return NOTOK;
1034 }
1035
1036 maxoutbuf = *outbufmax;
1037
1038 result = sasl_getprop(conn, SASL_SSF, (const void **) &ssf);
1039
1040 sasl_ssf = *ssf;
1041
1042 if (result != SASL_OK) {
1043 sm_ierror("Cannot retrieve SASL negotiated security strength "
1044 "factor: %s", sasl_errstring(result, NULL, NULL));
1045 return NOTOK;
1046 }
1047
1048 if (sasl_ssf > 0) {
1049 sasl_outbuffer = malloc(maxoutbuf);
1050
1051 if (sasl_outbuffer == NULL) {
1052 sm_ierror("Unable to allocate %d bytes for SASL output "
1053 "buffer", maxoutbuf);
1054 return NOTOK;
1055 }
1056 sasl_outbuflen = 0;
1057 sasl_inbuflen = 0;
1058 sasl_inptr = sasl_inbuffer;
1059 } else {
1060 sasl_outbuffer = NULL;
1061 /* Don't NULL out sasl_inbuffer because it could be used in
1062 sm_fgetc (). */
1063 }
1064
1065 sasl_complete = 1;
1066
1067 return RP_OK;
1068 }
1069
1070 /*
1071 * Our callback functions to feed data to the SASL library
1072 */
1073
1074 static int
1075 sm_get_user(void *context, int id, const char **result, unsigned *len)
1076 {
1077 char *user = (char *) context;
1078
1079 if (! result || ((id != SASL_CB_USER) && (id != SASL_CB_AUTHNAME)))
1080 return SASL_BADPARAM;
1081
1082 *result = user;
1083 if (len)
1084 *len = strlen(user);
1085
1086 return SASL_OK;
1087 }
1088
1089 static int
1090 sm_get_pass(sasl_conn_t *conn, void *context, int id,
1091 sasl_secret_t **psecret)
1092 {
1093 char **pw_context = (char **) context;
1094 char *pass = NULL;
1095 int len;
1096
1097 if (! psecret || id != SASL_CB_PASS)
1098 return SASL_BADPARAM;
1099
1100 ruserpass(pw_context[0], &(pw_context[1]), &pass);
1101
1102 len = strlen(pass);
1103
1104 *psecret = (sasl_secret_t *) malloc(sizeof(sasl_secret_t) + len);
1105
1106 if (! *psecret) {
1107 free(pass);
1108 return SASL_NOMEM;
1109 }
1110
1111 (*psecret)->len = len;
1112 strcpy((char *) (*psecret)->data, pass);
1113 /* free(pass); */
1114
1115 return SASL_OK;
1116 }
1117 #endif /* CYRUS_SASL */
1118
1119 static int
1120 sm_ierror (char *fmt, ...)
1121 {
1122 va_list ap;
1123
1124 va_start(ap, fmt);
1125 vsnprintf (sm_reply.text, sizeof(sm_reply.text), fmt, ap);
1126 va_end(ap);
1127
1128 sm_reply.length = strlen (sm_reply.text);
1129 sm_reply.code = NOTOK;
1130
1131 return RP_BHST;
1132 }
1133
1134 static int
1135 smtalk (int time, char *fmt, ...)
1136 {
1137 va_list ap;
1138 int result;
1139 char buffer[BUFSIZ];
1140
1141 va_start(ap, fmt);
1142 vsnprintf (buffer, sizeof(buffer), fmt, ap);
1143 va_end(ap);
1144
1145 if (sm_debug) {
1146 if (sasl_ssf)
1147 printf("(sasl-encrypted) ");
1148 if (tls_active)
1149 printf("(tls-encrypted) ");
1150 printf ("=> %s\n", buffer);
1151 fflush (stdout);
1152 }
1153
1154 sm_alarmed = 0;
1155 alarm ((unsigned) time);
1156 if ((result = sm_wrecord (buffer, strlen (buffer))) != NOTOK)
1157 result = smhear ();
1158 alarm (0);
1159
1160 return result;
1161 }
1162
1163
1164 /*
1165 * write the buffer to the open SMTP channel
1166 */
1167
1168 static int
1169 sm_wrecord (char *buffer, int len)
1170 {
1171 if (sm_wfp == NULL)
1172 return sm_werror ();
1173
1174 sm_fwrite (buffer, len);
1175 sm_fputs ("\r\n");
1176 sm_fflush ();
1177
1178 return (ferror (sm_wfp) ? sm_werror () : OK);
1179 }
1180
1181
1182 static int
1183 sm_wstream (char *buffer, int len)
1184 {
1185 char *bp;
1186 static char lc = '\0';
1187
1188 if (sm_wfp == NULL)
1189 return sm_werror ();
1190
1191 if (buffer == NULL && len == 0) {
1192 if (lc != '\n')
1193 sm_fputs ("\r\n");
1194 lc = '\0';
1195 return (ferror (sm_wfp) ? sm_werror () : OK);
1196 }
1197
1198 for (bp = buffer; len > 0; bp++, len--) {
1199 switch (*bp) {
1200 case '\n':
1201 sm_nl = TRUE;
1202 sm_fputc ('\r');
1203 break;
1204
1205 case '.':
1206 if (sm_nl)
1207 sm_fputc ('.');/* FALL THROUGH */
1208 default:
1209 sm_nl = FALSE;
1210 }
1211 sm_fputc (*bp);
1212 if (ferror (sm_wfp))
1213 return sm_werror ();
1214 }
1215
1216 if (bp > buffer)
1217 lc = *--bp;
1218 return (ferror (sm_wfp) ? sm_werror () : OK);
1219 }
1220
1221 /*
1222 * Write out to the network, but do buffering for SASL (if enabled)
1223 */
1224
1225 static int
1226 sm_fwrite(char *buffer, int len)
1227 {
1228 #ifdef CYRUS_SASL
1229 const char *output;
1230 unsigned int outputlen;
1231
1232 if (sasl_complete == 0 || sasl_ssf == 0) {
1233 #endif /* CYRUS_SASL */
1234 #ifdef TLS_SUPPORT
1235 if (tls_active) {
1236 int ret;
1237
1238 ret = SSL_write(ssl, buffer, len);
1239
1240 if (SSL_get_error(ssl, ret) != SSL_ERROR_NONE) {
1241 sm_ierror("TLS error during write: %s",
1242 ERR_error_string(ERR_get_error(), NULL));
1243 return NOTOK;
1244 }
1245 } else
1246 #endif /* TLS_SUPPORT */
1247 fwrite(buffer, sizeof(*buffer), len, sm_wfp);
1248 #ifdef CYRUS_SASL
1249 } else {
1250 while (len >= maxoutbuf - sasl_outbuflen) {
1251 memcpy(sasl_outbuffer + sasl_outbuflen, buffer,
1252 maxoutbuf - sasl_outbuflen);
1253 len -= maxoutbuf - sasl_outbuflen;
1254 sasl_outbuflen = 0;
1255
1256 if (sasl_encode(conn, sasl_outbuffer, maxoutbuf,
1257 &output, &outputlen) != SASL_OK) {
1258 sm_ierror("Unable to SASL encode connection data: %s",
1259 sasl_errdetail(conn));
1260 return NOTOK;
1261 }
1262
1263 fwrite(output, sizeof(*output), outputlen, sm_wfp);
1264 }
1265
1266 if (len > 0) {
1267 memcpy(sasl_outbuffer + sasl_outbuflen, buffer, len);
1268 sasl_outbuflen += len;
1269 }
1270 }
1271 #endif /* CYRUS_SASL */
1272 return ferror(sm_wfp) ? NOTOK : RP_OK;
1273 }
1274
1275 /*
1276 * Convenience functions to replace occurences of fputs() and fputc()
1277 */
1278
1279 static int
1280 sm_fputs(char *buffer)
1281 {
1282 return sm_fwrite(buffer, strlen(buffer));
1283 }
1284
1285 static int
1286 sm_fputc(int c)
1287 {
1288 char h = c;
1289
1290 return sm_fwrite(&h, 1);
1291 }
1292
1293 /*
1294 * Flush out any pending data on the connection
1295 */
1296
1297 static void
1298 sm_fflush(void)
1299 {
1300 #ifdef CYRUS_SASL
1301 const char *output;
1302 unsigned int outputlen;
1303 int result;
1304
1305 if (sasl_complete == 1 && sasl_ssf > 0 && sasl_outbuflen > 0) {
1306 result = sasl_encode(conn, sasl_outbuffer, sasl_outbuflen,
1307 &output, &outputlen);
1308 if (result != SASL_OK) {
1309 sm_ierror("Unable to SASL encode connection data: %s",
1310 sasl_errdetail(conn));
1311 return;
1312 }
1313
1314 fwrite(output, sizeof(*output), outputlen, sm_wfp);
1315 sasl_outbuflen = 0;
1316 }
1317 #endif /* CYRUS_SASL */
1318
1319 fflush(sm_wfp);
1320 }
1321
1322 static int
1323 sm_werror (void)
1324 {
1325 sm_reply.length =
1326 strlen (strcpy (sm_reply.text, sm_wfp == NULL ? "no socket opened"
1327 : sm_alarmed ? "write to socket timed out"
1328 : "error writing to socket"));
1329
1330 return (sm_reply.code = NOTOK);
1331 }
1332
1333
1334 static int
1335 smhear (void)
1336 {
1337 int i, code, cont, bc = 0, rc, more;
1338 unsigned char *bp;
1339 char *rp;
1340 char **ehlo = NULL, buffer[BUFSIZ];
1341
1342 if (doingEHLO) {
1343 static int at_least_once = 0;
1344
1345 if (at_least_once) {
1346 char *ep;
1347
1348 for (ehlo = EHLOkeys; *ehlo; ehlo++) {
1349 ep = *ehlo;
1350 free (ep);
1351 }
1352 } else {
1353 at_least_once = 1;
1354 }
1355
1356 ehlo = EHLOkeys;
1357 *ehlo = NULL;
1358 }
1359
1360 again: ;
1361
1362 sm_reply.length = 0;
1363 sm_reply.text[0] = 0;
1364 rp = sm_reply.text;
1365 rc = sizeof(sm_reply.text) - 1;
1366
1367 for (more = FALSE; sm_rrecord ((char *) (bp = (unsigned char *) buffer),
1368 &bc) != NOTOK ; ) {
1369 if (sm_debug) {
1370 if (sasl_ssf > 0)
1371 printf("(sasl-decrypted) ");
1372 if (tls_active)
1373 printf("(tls-decrypted) ");
1374 printf ("<= %s\n", buffer);
1375 fflush (stdout);
1376 }
1377
1378 if (doingEHLO
1379 && strncmp (buffer, "250", sizeof("250") - 1) == 0
1380 && (buffer[3] == '-' || doingEHLO == 2)
1381 && buffer[4]) {
1382 if (doingEHLO == 2) {
1383 if ((*ehlo = malloc ((size_t) (strlen (buffer + 4) + 1)))) {
1384 strcpy (*ehlo++, buffer + 4);
1385 *ehlo = NULL;
1386 if (ehlo >= EHLOkeys + MAXEHLO)
1387 doingEHLO = 0;
1388 }
1389 else
1390 doingEHLO = 0;
1391 }
1392 else
1393 doingEHLO = 2;
1394 }
1395
1396 for (; bc > 0 && (!isascii (*bp) || !isdigit (*bp)); bp++, bc--)
1397 continue;
1398
1399 cont = FALSE;
1400 code = atoi ((char *) bp);
1401 bp += 3, bc -= 3;
1402 for (; bc > 0 && isspace (*bp); bp++, bc--)
1403 continue;
1404 if (bc > 0 && *bp == '-') {
1405 cont = TRUE;
1406 bp++, bc--;
1407 for (; bc > 0 && isspace (*bp); bp++, bc--)
1408 continue;
1409 }
1410
1411 if (more) {
1412 if (code != sm_reply.code || cont)
1413 continue;
1414 more = FALSE;
1415 } else {
1416 sm_reply.code = code;
1417 more = cont;
1418 if (bc <= 0) {
1419 /* can never fail to 0-terminate because of size of buffer vs fixed string */
1420 strncpy (buffer, sm_noreply, sizeof(buffer));
1421 bp = (unsigned char *) buffer;
1422 bc = strlen (sm_noreply);
1423 }
1424 }
1425
1426 if ((i = min (bc, rc)) > 0) {
1427 memcpy (rp, bp, i);
1428 rp += i;
1429 rc -= i;
1430 i = strlen(sm_moreply);
1431 if (more && rc > i + 1) {
1432 memcpy (rp, sm_moreply, i); /* safe because of check in if() */
1433 rp += i;
1434 rc -= i;
1435 }
1436 }
1437 if (more)
1438 continue;
1439 if (sm_reply.code < 100) {
1440 if (sm_verbose) {
1441 printf ("%s\n", sm_reply.text);
1442 fflush (stdout);
1443 }
1444 goto again;
1445 }
1446
1447 sm_reply.length = rp - sm_reply.text;
1448 sm_reply.text[sm_reply.length] = 0;
1449 return sm_reply.code;
1450 }
1451 return NOTOK;
1452 }
1453
1454
1455 static int
1456 sm_rrecord (char *buffer, int *len)
1457 {
1458 int retval;
1459
1460 if (sm_rfp == NULL)
1461 return sm_rerror(0);
1462
1463 buffer[*len = 0] = 0;
1464
1465 if ((retval = sm_fgets (buffer, BUFSIZ, sm_rfp)) != RP_OK)
1466 return retval;
1467 *len = strlen (buffer);
1468 /* *len should be >0 except on EOF, but check for safety's sake */
1469 if (*len == 0)
1470 return sm_rerror (RP_EOF);
1471 if (buffer[*len - 1] != '\n')
1472 while ((retval = sm_fgetc (sm_rfp)) != '\n' && retval != EOF &&
1473 retval != -2)
1474 continue;
1475 else
1476 if ((*len > 1) && (buffer[*len - 2] == '\r'))
1477 *len -= 1;
1478 *len -= 1;
1479 buffer[*len] = 0;
1480
1481 return OK;
1482 }
1483
1484 /*
1485 * Our version of fgets, which calls our private fgetc function
1486 */
1487
1488 static int
1489 sm_fgets(char *buffer, int size, FILE *f)
1490 {
1491 int c;
1492
1493 do {
1494 c = sm_fgetc(f);
1495
1496 if (c == EOF)
1497 return RP_EOF;
1498
1499 if (c == -2)
1500 return NOTOK;
1501
1502 *buffer++ = c;
1503 } while (size > 1 && c != '\n');
1504
1505 *buffer = '\0';
1506
1507 return RP_OK;
1508 }
1509
1510
1511 #if defined(CYRUS_SASL) || defined(TLS_SUPPORT)
1512 /*
1513 * Read from the network, but do SASL or TLS encryption
1514 */
1515
1516 static int
1517 sm_fgetc(FILE *f)
1518 {
1519 char tmpbuf[BUFSIZ], *retbuf;
1520 unsigned int retbufsize = 0;
1521 int cc, result;
1522
1523 /*
1524 * If we have leftover data, return it
1525 */
1526
1527 if (sasl_inbuflen) {
1528 sasl_inbuflen--;
1529 return (int) *sasl_inptr++;
1530 }
1531
1532 /*
1533 * If not, read from the network until we have some data to return
1534 */
1535
1536 while (retbufsize == 0) {
1537
1538 #ifdef TLS_SUPPORT
1539 if (tls_active) {
1540 cc = SSL_read(ssl, tmpbuf, sizeof(tmpbuf));
1541
1542 if (cc == 0) {
1543 result = SSL_get_error(ssl, cc);
1544
1545 if (result != SSL_ERROR_ZERO_RETURN) {
1546 sm_ierror("TLS peer aborted connection");
1547 }
1548
1549 return EOF;
1550 }
1551
1552 if (cc < 0) {
1553 sm_ierror("SSL_read failed: %s",
1554 ERR_error_string(ERR_get_error(), NULL));
1555 return -2;
1556 }
1557 } else
1558 #endif /* TLS_SUPPORT */
1559
1560 cc = read(fileno(f), tmpbuf, sizeof(tmpbuf));
1561
1562 if (cc == 0)
1563 return EOF;
1564
1565 if (cc < 0) {
1566 sm_ierror("Unable to read from network: %s", strerror(errno));
1567 return -2;
1568 }
1569
1570 /*
1571 * Don't call sasl_decode unless sasl is complete and we have
1572 * encryption working
1573 */
1574
1575 if (sasl_complete == 0 || sasl_ssf == 0) {
1576 retbuf = tmpbuf;
1577 retbufsize = cc;
1578 } else {
1579 result = sasl_decode(conn, tmpbuf, cc, (const char **) &retbuf,
1580 &retbufsize);
1581
1582 if (result != SASL_OK) {
1583 sm_ierror("Unable to decode SASL network data: %s",
1584 sasl_errdetail(conn));
1585 return -2;
1586 }
1587 }
1588 }
1589
1590 if (retbufsize > SASL_MAXRECVBUF) {
1591 sm_ierror("Received data (%d bytes) is larger than the buffer "
1592 "size (%d bytes)", retbufsize, SASL_MAXRECVBUF);
1593 return -2;
1594 }
1595
1596 memcpy(sasl_inbuffer, retbuf, retbufsize);
1597 sasl_inptr = sasl_inbuffer + 1;
1598 sasl_inbuflen = retbufsize - 1;
1599
1600 return (int) sasl_inbuffer[0];
1601 }
1602 #endif /* CYRUS_SASL || TLS_SUPPORT */
1603
1604 static int
1605 sm_rerror (int rc)
1606 {
1607 if (sm_mts == MTS_SMTP)
1608 sm_reply.length =
1609 strlen (strcpy (sm_reply.text, sm_rfp == NULL ? "no socket opened"
1610 : sm_alarmed ? "read from socket timed out"
1611 : rc == RP_EOF ? "premature end-of-file on socket"
1612 : "error reading from socket"));
1613 else
1614 sm_reply.length =
1615 strlen (strcpy (sm_reply.text, sm_rfp == NULL ? "no pipe opened"
1616 : sm_alarmed ? "read from pipe timed out"
1617 : rc == RP_EOF ? "premature end-of-file on pipe"
1618 : "error reading from pipe"));
1619
1620 return (sm_reply.code = NOTOK);
1621 }
1622
1623
1624 static RETSIGTYPE
1625 alrmser (int i)
1626 {
1627 #ifndef RELIABLE_SIGNALS
1628 SIGNAL (SIGALRM, alrmser);
1629 #endif
1630
1631 sm_alarmed++;
1632 if (sm_debug) {
1633 printf ("timed out...\n");
1634 fflush (stdout);
1635 }
1636 }
1637
1638
1639 char *
1640 rp_string (int code)
1641 {
1642 char *text;
1643 static char buffer[BUFSIZ];
1644
1645 switch (sm_reply.code != NOTOK ? code : NOTOK) {
1646 case RP_AOK:
1647 text = "AOK";
1648 break;
1649
1650 case RP_MOK:
1651 text = "MOK";
1652 break;
1653
1654 case RP_OK:
1655 text = "OK";
1656 break;
1657
1658 case RP_RPLY:
1659 text = "RPLY";
1660 break;
1661
1662 case RP_BHST:
1663 default:
1664 text = "BHST";
1665 snprintf (buffer, sizeof(buffer), "[%s] %s", text, sm_reply.text);
1666 return buffer;
1667
1668 case RP_PARM:
1669 text = "PARM";
1670 break;
1671
1672 case RP_NO:
1673 text = "NO";
1674 break;
1675
1676 case RP_USER:
1677 text = "USER";
1678 break;
1679
1680 case RP_NDEL:
1681 text = "NDEL";
1682 break;
1683 }
1684
1685 snprintf (buffer, sizeof(buffer), "[%s] %3d %s",
1686 text, sm_reply.code, sm_reply.text);
1687 return buffer;
1688 }
1689
1690 static char *
1691 EHLOset (char *s)
1692 {
1693 size_t len;
1694 char *ep, **ehlo;
1695
1696 len = strlen (s);
1697
1698 for (ehlo = EHLOkeys; *ehlo; ehlo++) {
1699 ep = *ehlo;
1700 if (strncmp (ep, s, len) == 0) {
1701 for (ep += len; *ep == ' '; ep++)
1702 continue;
1703 return ep;
1704 }
1705 }
1706
1707 return 0;
1708 }
Fork of https://git.savannah.nongnu.org/cgit/nmh.git