diplodocus.org Git - nmh/blob - mts/smtp/smtp.c

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