git.marmaro.de Git - mmh/blob - 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 }