contrib/sendmail/src/sfsasl.c

   1 /*
   2  * Copyright (c) 1999-2006, 2008 Sendmail, Inc. and its suppliers.
   3  *      All rights reserved.
   4  *
   5  * By using this file, you agree to the terms and conditions set
   6  * forth in the LICENSE file which can be found at the top level of
   7  * the sendmail distribution.
   8  *
   9  */
  10
  11 #include <sm/gen.h>
  12 SM_RCSID("@(#)$Id: sfsasl.c,v 8.120 2013/03/15 17:49:12 guenther Exp $")
  13 #include <stdlib.h>
  14 #include <sendmail.h>
  15 #include <sm/time.h>
  16 #include <errno.h>
  17
  18 /* allow to disable error handling code just in case... */
  19 #ifndef DEAL_WITH_ERROR_SSL
  20 # define DEAL_WITH_ERROR_SSL    1
  21 #endif /* ! DEAL_WITH_ERROR_SSL */
  22
  23 #if SASL
  24 # include "sfsasl.h"
  25
  26 /* Structure used by the "sasl" file type */
  27 struct sasl_obj
  28 {
  29         SM_FILE_T *fp;
  30         sasl_conn_t *conn;
  31 };
  32
  33 struct sasl_info
  34 {
  35         SM_FILE_T *fp;
  36         sasl_conn_t *conn;
  37 };
  38
  39 /*
  40 **  SASL_GETINFO - returns requested information about a "sasl" file
  41 **                descriptor.
  42 **
  43 **      Parameters:
  44 **              fp -- the file descriptor
  45 **              what -- the type of information requested
  46 **              valp -- the thang to return the information in
  47 **
  48 **      Returns:
  49 **              -1 for unknown requests
  50 **              >=0 on success with valp filled in (if possible).
  51 */
  52
  53 static int sasl_getinfo __P((SM_FILE_T *, int, void *));
  54
  55 static int
  56 sasl_getinfo(fp, what, valp)
  57         SM_FILE_T *fp;
  58         int what;
  59         void *valp;
  60 {
  61         struct sasl_obj *so = (struct sasl_obj *) fp->f_cookie;
  62
  63         switch (what)
  64         {
  65           case SM_IO_WHAT_FD:
  66                 if (so->fp == NULL)
  67                         return -1;
  68                 return so->fp->f_file; /* for stdio fileno() compatability */
  69
  70           case SM_IO_IS_READABLE:
  71                 if (so->fp == NULL)
  72                         return 0;
  73
  74                 /* get info from underlying file */
  75                 return sm_io_getinfo(so->fp, what, valp);
  76
  77           default:
  78                 return -1;
  79         }
  80 }
  81
  82 /*
  83 **  SASL_OPEN -- creates the sasl specific information for opening a
  84 **              file of the sasl type.
  85 **
  86 **      Parameters:
  87 **              fp -- the file pointer associated with the new open
  88 **              info -- contains the sasl connection information pointer and
  89 **                      the original SM_FILE_T that holds the open
  90 **              flags -- ignored
  91 **              rpool -- ignored
  92 **
  93 **      Returns:
  94 **              0 on success
  95 */
  96
  97 static int sasl_open __P((SM_FILE_T *, const void *, int, const void *));
  98
  99 /* ARGSUSED2 */
 100 static int
 101 sasl_open(fp, info, flags, rpool)
 102         SM_FILE_T *fp;
 103         const void *info;
 104         int flags;
 105         const void *rpool;
 106 {
 107         struct sasl_obj *so;
 108         struct sasl_info *si = (struct sasl_info *) info;
 109
 110         so = (struct sasl_obj *) sm_malloc(sizeof(struct sasl_obj));
 111         if (so == NULL)
 112         {
 113                 errno = ENOMEM;
 114                 return -1;
 115         }
 116         so->fp = si->fp;
 117         so->conn = si->conn;
 118
 119         /*
 120         **  The underlying 'fp' is set to SM_IO_NOW so that the entire
 121         **  encoded string is written in one chunk. Otherwise there is
 122         **  the possibility that it may appear illegal, bogus or
 123         **  mangled to the other side of the connection.
 124         **  We will read or write through 'fp' since it is the opaque
 125         **  connection for the communications. We need to treat it this
 126         **  way in case the encoded string is to be sent down a TLS
 127         **  connection rather than, say, sm_io's stdio.
 128         */
 129
 130         (void) sm_io_setvbuf(so->fp, SM_TIME_DEFAULT, NULL, SM_IO_NOW, 0);
 131         fp->f_cookie = so;
 132         return 0;
 133 }
 134
 135 /*
 136 **  SASL_CLOSE -- close the sasl specific parts of the sasl file pointer
 137 **
 138 **      Parameters:
 139 **              fp -- the file pointer to close
 140 **
 141 **      Returns:
 142 **              0 on success
 143 */
 144
 145 static int sasl_close __P((SM_FILE_T *));
 146
 147 static int
 148 sasl_close(fp)
 149         SM_FILE_T *fp;
 150 {
 151         struct sasl_obj *so;
 152
 153         so = (struct sasl_obj *) fp->f_cookie;
 154         if (so == NULL)
 155                 return 0;
 156         if (so->fp != NULL)
 157         {
 158                 sm_io_close(so->fp, SM_TIME_DEFAULT);
 159                 so->fp = NULL;
 160         }
 161         sm_free(so);
 162         so = NULL;
 163         return 0;
 164 }
 165
 166 /* how to deallocate a buffer allocated by SASL */
 167 extern void     sm_sasl_free __P((void *));
 168 #  define SASL_DEALLOC(b)       sm_sasl_free(b)
 169
 170 /*
 171 **  SASL_READ -- read encrypted information and decrypt it for the caller
 172 **
 173 **      Parameters:
 174 **              fp -- the file pointer
 175 **              buf -- the location to place the decrypted information
 176 **              size -- the number of bytes to read after decryption
 177 **
 178 **      Results:
 179 **              -1 on error
 180 **              otherwise the number of bytes read
 181 */
 182
 183 static ssize_t sasl_read __P((SM_FILE_T *, char *, size_t));
 184
 185 static ssize_t
 186 sasl_read(fp, buf, size)
 187         SM_FILE_T *fp;
 188         char *buf;
 189         size_t size;
 190 {
 191         int result;
 192         ssize_t len;
 193 # if SASL >= 20000
 194         static const char *outbuf = NULL;
 195 # else /* SASL >= 20000 */
 196         static char *outbuf = NULL;
 197 # endif /* SASL >= 20000 */
 198         static unsigned int outlen = 0;
 199         static unsigned int offset = 0;
 200         struct sasl_obj *so = (struct sasl_obj *) fp->f_cookie;
 201
 202         /*
 203         **  sasl_decode() may require more data than a single read() returns.
 204         **  Hence we have to put a loop around the decoding.
 205         **  This also requires that we may have to split up the returned
 206         **  data since it might be larger than the allowed size.
 207         **  Therefore we use a static pointer and return portions of it
 208         **  if necessary.
 209         **  XXX Note: This function is not thread-safe nor can it be used
 210         **  on more than one file. A correct implementation would store
 211         **  this data in fp->f_cookie.
 212         */
 213
 214 # if SASL >= 20000
 215         while (outlen == 0)
 216 # else /* SASL >= 20000 */
 217         while (outbuf == NULL && outlen == 0)
 218 # endif /* SASL >= 20000 */
 219         {
 220                 len = sm_io_read(so->fp, SM_TIME_DEFAULT, buf, size);
 221                 if (len <= 0)
 222                         return len;
 223                 result = sasl_decode(so->conn, buf,
 224                                      (unsigned int) len, &outbuf, &outlen);
 225                 if (result != SASL_OK)
 226                 {
 227                         if (LogLevel > 7)
 228                                 sm_syslog(LOG_WARNING, NOQID,
 229                                         "AUTH: sasl_decode error=%d", result);
 230                         outbuf = NULL;
 231                         offset = 0;
 232                         outlen = 0;
 233                         return -1;
 234                 }
 235         }
 236
 237         if (outbuf == NULL)
 238         {
 239                 /* be paranoid: outbuf == NULL but outlen != 0 */
 240                 syserr("@sasl_read failure: outbuf == NULL but outlen != 0");
 241                 /* NOTREACHED */
 242         }
 243         if (outlen - offset > size)
 244         {
 245                 /* return another part of the buffer */
 246                 (void) memcpy(buf, outbuf + offset, size);
 247                 offset += size;
 248                 len = size;
 249         }
 250         else
 251         {
 252                 /* return the rest of the buffer */
 253                 len = outlen - offset;
 254                 (void) memcpy(buf, outbuf + offset, (size_t) len);
 255 # if SASL < 20000
 256                 SASL_DEALLOC(outbuf);
 257 # endif /* SASL < 20000 */
 258                 outbuf = NULL;
 259                 offset = 0;
 260                 outlen = 0;
 261         }
 262         return len;
 263 }
 264
 265 /*
 266 **  SASL_WRITE -- write information out after encrypting it
 267 **
 268 **      Parameters:
 269 **              fp -- the file pointer
 270 **              buf -- holds the data to be encrypted and written
 271 **              size -- the number of bytes to have encrypted and written
 272 **
 273 **      Returns:
 274 **              -1 on error
 275 **              otherwise number of bytes written
 276 */
 277
 278 static ssize_t sasl_write __P((SM_FILE_T *, const char *, size_t));
 279
 280 static ssize_t
 281 sasl_write(fp, buf, size)
 282         SM_FILE_T *fp;
 283         const char *buf;
 284         size_t size;
 285 {
 286         int result;
 287 # if SASL >= 20000
 288         const char *outbuf;
 289 # else /* SASL >= 20000 */
 290         char *outbuf;
 291 # endif /* SASL >= 20000 */
 292         unsigned int outlen, *maxencode;
 293         size_t ret = 0, total = 0;
 294         struct sasl_obj *so = (struct sasl_obj *) fp->f_cookie;
 295
 296         /*
 297         **  Fetch the maximum input buffer size for sasl_encode().
 298         **  This can be less than the size set in attemptauth()
 299         **  due to a negotiation with the other side, e.g.,
 300         **  Cyrus IMAP lmtp program sets maxbuf=4096,
 301         **  digestmd5 substracts 25 and hence we'll get 4071
 302         **  instead of 8192 (MAXOUTLEN).
 303         **  Hack (for now): simply reduce the size, callers are (must be)
 304         **  able to deal with that and invoke sasl_write() again with
 305         **  the rest of the data.
 306         **  Note: it would be better to store this value in the context
 307         **  after the negotiation.
 308         */
 309
 310         result = sasl_getprop(so->conn, SASL_MAXOUTBUF,
 311                                 (const void **) &maxencode);
 312         if (result == SASL_OK && size > *maxencode && *maxencode > 0)
 313                 size = *maxencode;
 314
 315         result = sasl_encode(so->conn, buf,
 316                              (unsigned int) size, &outbuf, &outlen);
 317
 318         if (result != SASL_OK)
 319         {
 320                 if (LogLevel > 7)
 321                         sm_syslog(LOG_WARNING, NOQID,
 322                                 "AUTH: sasl_encode error=%d", result);
 323                 return -1;
 324         }
 325
 326         if (outbuf != NULL)
 327         {
 328                 while (outlen > 0)
 329                 {
 330                         errno = 0;
 331                         /* XXX result == 0? */
 332                         ret = sm_io_write(so->fp, SM_TIME_DEFAULT,
 333                                           &outbuf[total], outlen);
 334                         if (ret <= 0)
 335                                 return ret;
 336                         outlen -= ret;
 337                         total += ret;
 338                 }
 339 # if SASL < 20000
 340                 SASL_DEALLOC(outbuf);
 341 # endif /* SASL < 20000 */
 342         }
 343         return size;
 344 }
 345
 346 /*
 347 **  SFDCSASL -- create sasl file type and open in and out file pointers
 348 **             for sendmail to read from and write to.
 349 **
 350 **      Parameters:
 351 **              fin -- the sm_io file encrypted data to be read from
 352 **              fout -- the sm_io file encrypted data to be written to
 353 **              conn -- the sasl connection pointer
 354 **              tmo -- timeout
 355 **
 356 **      Returns:
 357 **              -1 on error
 358 **              0 on success
 359 **
 360 **      Side effects:
 361 **              The arguments "fin" and "fout" are replaced with the new
 362 **              SM_FILE_T pointers.
 363 */
 364
 365 int
 366 sfdcsasl(fin, fout, conn, tmo)
 367         SM_FILE_T **fin;
 368         SM_FILE_T **fout;
 369         sasl_conn_t *conn;
 370         int tmo;
 371 {
 372         SM_FILE_T *newin, *newout;
 373         SM_FILE_T  SM_IO_SET_TYPE(sasl_vector, "sasl", sasl_open, sasl_close,
 374                 sasl_read, sasl_write, NULL, sasl_getinfo, NULL,
 375                 SM_TIME_DEFAULT);
 376         struct sasl_info info;
 377
 378         if (conn == NULL)
 379         {
 380                 /* no need to do anything */
 381                 return 0;
 382         }
 383
 384         SM_IO_INIT_TYPE(sasl_vector, "sasl", sasl_open, sasl_close,
 385                 sasl_read, sasl_write, NULL, sasl_getinfo, NULL,
 386                 SM_TIME_DEFAULT);
 387         info.fp = *fin;
 388         info.conn = conn;
 389         newin = sm_io_open(&sasl_vector, SM_TIME_DEFAULT, &info,
 390                         SM_IO_RDONLY_B, NULL);
 391
 392         if (newin == NULL)
 393                 return -1;
 394
 395         info.fp = *fout;
 396         info.conn = conn;
 397         newout = sm_io_open(&sasl_vector, SM_TIME_DEFAULT, &info,
 398                         SM_IO_WRONLY_B, NULL);
 399
 400         if (newout == NULL)
 401         {
 402                 (void) sm_io_close(newin, SM_TIME_DEFAULT);
 403                 return -1;
 404         }
 405         sm_io_automode(newin, newout);
 406
 407         sm_io_setinfo(*fin, SM_IO_WHAT_TIMEOUT, &tmo);
 408         sm_io_setinfo(*fout, SM_IO_WHAT_TIMEOUT, &tmo);
 409
 410         *fin = newin;
 411         *fout = newout;
 412         return 0;
 413 }
 414 #endif /* SASL */
 415
 416 #if STARTTLS
 417 # include "sfsasl.h"
 418 #  include <openssl/err.h>
 419
 420 /* Structure used by the "tls" file type */
 421 struct tls_obj
 422 {
 423         SM_FILE_T *fp;
 424         SSL *con;
 425 };
 426
 427 struct tls_info
 428 {
 429         SM_FILE_T *fp;
 430         SSL *con;
 431 };
 432
 433 /*
 434 **  TLS_GETINFO - returns requested information about a "tls" file
 435 **               descriptor.
 436 **
 437 **      Parameters:
 438 **              fp -- the file descriptor
 439 **              what -- the type of information requested
 440 **              valp -- the thang to return the information in (unused)
 441 **
 442 **      Returns:
 443 **              -1 for unknown requests
 444 **              >=0 on success with valp filled in (if possible).
 445 */
 446
 447 static int tls_getinfo __P((SM_FILE_T *, int, void *));
 448
 449 /* ARGSUSED2 */
 450 static int
 451 tls_getinfo(fp, what, valp)
 452         SM_FILE_T *fp;
 453         int what;
 454         void *valp;
 455 {
 456         struct tls_obj *so = (struct tls_obj *) fp->f_cookie;
 457
 458         switch (what)
 459         {
 460           case SM_IO_WHAT_FD:
 461                 if (so->fp == NULL)
 462                         return -1;
 463                 return so->fp->f_file; /* for stdio fileno() compatability */
 464
 465           case SM_IO_IS_READABLE:
 466                 return SSL_pending(so->con) > 0;
 467
 468           default:
 469                 return -1;
 470         }
 471 }
 472
 473 /*
 474 **  TLS_OPEN -- creates the tls specific information for opening a
 475 **             file of the tls type.
 476 **
 477 **      Parameters:
 478 **              fp -- the file pointer associated with the new open
 479 **              info -- the sm_io file pointer holding the open and the
 480 **                      TLS encryption connection to be read from or written to
 481 **              flags -- ignored
 482 **              rpool -- ignored
 483 **
 484 **      Returns:
 485 **              0 on success
 486 */
 487
 488 static int tls_open __P((SM_FILE_T *, const void *, int, const void *));
 489
 490 /* ARGSUSED2 */
 491 static int
 492 tls_open(fp, info, flags, rpool)
 493         SM_FILE_T *fp;
 494         const void *info;
 495         int flags;
 496         const void *rpool;
 497 {
 498         struct tls_obj *so;
 499         struct tls_info *ti = (struct tls_info *) info;
 500
 501         so = (struct tls_obj *) sm_malloc(sizeof(struct tls_obj));
 502         if (so == NULL)
 503         {
 504                 errno = ENOMEM;
 505                 return -1;
 506         }
 507         so->fp = ti->fp;
 508         so->con = ti->con;
 509
 510         /*
 511         **  We try to get the "raw" file descriptor that TLS uses to
 512         **  do the actual read/write with. This is to allow us control
 513         **  over the file descriptor being a blocking or non-blocking type.
 514         **  Under the covers TLS handles the change and this allows us
 515         **  to do timeouts with sm_io.
 516         */
 517
 518         fp->f_file = sm_io_getinfo(so->fp, SM_IO_WHAT_FD, NULL);
 519         (void) sm_io_setvbuf(so->fp, SM_TIME_DEFAULT, NULL, SM_IO_NOW, 0);
 520         fp->f_cookie = so;
 521         return 0;
 522 }
 523
 524 /*
 525 **  TLS_CLOSE -- close the tls specific parts of the tls file pointer
 526 **
 527 **      Parameters:
 528 **              fp -- the file pointer to close
 529 **
 530 **      Returns:
 531 **              0 on success
 532 */
 533
 534 static int tls_close __P((SM_FILE_T *));
 535
 536 static int
 537 tls_close(fp)
 538         SM_FILE_T *fp;
 539 {
 540         struct tls_obj *so;
 541
 542         so = (struct tls_obj *) fp->f_cookie;
 543         if (so == NULL)
 544                 return 0;
 545         if (so->fp != NULL)
 546         {
 547                 sm_io_close(so->fp, SM_TIME_DEFAULT);
 548                 so->fp = NULL;
 549         }
 550         sm_free(so);
 551         so = NULL;
 552         return 0;
 553 }
 554
 555 /* maximum number of retries for TLS related I/O due to handshakes */
 556 # define MAX_TLS_IOS    4
 557
 558 /*
 559 **  TLS_RETRY -- check whether a failed SSL operation can be retried
 560 **
 561 **      Parameters:
 562 **              ssl -- TLS structure
 563 **              rfd -- read fd
 564 **              wfd -- write fd
 565 **              tlsstart -- start time of TLS operation
 566 **              timeout -- timeout for TLS operation
 567 **              err -- SSL error
 568 **              where -- description of operation
 569 **
 570 **      Results:
 571 **              >0 on success
 572 **              0 on timeout
 573 **              <0 on error
 574 */
 575
 576 int
 577 tls_retry(ssl, rfd, wfd, tlsstart, timeout, err, where)
 578         SSL *ssl;
 579         int rfd;
 580         int wfd;
 581         time_t tlsstart;
 582         int timeout;
 583         int err;
 584         const char *where;
 585 {
 586         int ret;
 587         time_t left;
 588         time_t now = curtime();
 589         struct timeval tv;
 590
 591         ret = -1;
 592
 593         /*
 594         **  For SSL_ERROR_WANT_{READ,WRITE}:
 595         **  There is not a complete SSL record available yet
 596         **  or there is only a partial SSL record removed from
 597         **  the network (socket) buffer into the SSL buffer.
 598         **  The SSL_connect will only succeed when a full
 599         **  SSL record is available (assuming a "real" error
 600         **  doesn't happen). To handle when a "real" error
 601         **  does happen the select is set for exceptions too.
 602         **  The connection may be re-negotiated during this time
 603         **  so both read and write "want errors" need to be handled.
 604         **  A select() exception loops back so that a proper SSL
 605         **  error message can be gotten.
 606         */
 607
 608         left = timeout - (now - tlsstart);
 609         if (left <= 0)
 610                 return 0;       /* timeout */
 611         tv.tv_sec = left;
 612         tv.tv_usec = 0;
 613
 614         if (LogLevel > 14)
 615         {
 616                 sm_syslog(LOG_INFO, NOQID,
 617                           "STARTTLS=%s, info: fds=%d/%d, err=%d",
 618                           where, rfd, wfd, err);
 619         }
 620
 621         if (FD_SETSIZE > 0 &&
 622             ((err == SSL_ERROR_WANT_READ && rfd >= FD_SETSIZE) ||
 623              (err == SSL_ERROR_WANT_WRITE && wfd >= FD_SETSIZE)))
 624         {
 625                 if (LogLevel > 5)
 626                 {
 627                         sm_syslog(LOG_ERR, NOQID,
 628                                   "STARTTLS=%s, error: fd %d/%d too large",
 629                                   where, rfd, wfd);
 630                 if (LogLevel > 8)
 631                         tlslogerr(LOG_WARNING, where);
 632                 }
 633                 errno = EINVAL;
 634         }
 635         else if (err == SSL_ERROR_WANT_READ)
 636         {
 637                 fd_set ssl_maskr, ssl_maskx;
 638                 int save_errno = errno;
 639
 640                 FD_ZERO(&ssl_maskr);
 641                 FD_SET(rfd, &ssl_maskr);
 642                 FD_ZERO(&ssl_maskx);
 643                 FD_SET(rfd, &ssl_maskx);
 644                 do
 645                 {
 646                         ret = select(rfd + 1, &ssl_maskr, NULL, &ssl_maskx,
 647                                         &tv);
 648                 } while (ret < 0 && errno == EINTR);
 649                 if (ret < 0 && errno > 0)
 650                         ret = -errno;
 651                 errno = save_errno;
 652         }
 653         else if (err == SSL_ERROR_WANT_WRITE)
 654         {
 655                 fd_set ssl_maskw, ssl_maskx;
 656                 int save_errno = errno;
 657
 658                 FD_ZERO(&ssl_maskw);
 659                 FD_SET(wfd, &ssl_maskw);
 660                 FD_ZERO(&ssl_maskx);
 661                 FD_SET(rfd, &ssl_maskx);
 662                 do
 663                 {
 664                         ret = select(wfd + 1, NULL, &ssl_maskw, &ssl_maskx,
 665                                         &tv);
 666                 } while (ret < 0 && errno == EINTR);
 667                 if (ret < 0 && errno > 0)
 668                         ret = -errno;
 669                 errno = save_errno;
 670         }
 671         return ret;
 672 }
 673
 674 /* errno to force refill() etc to stop (see IS_IO_ERROR()) */
 675 #ifdef ETIMEDOUT
 676 # define SM_ERR_TIMEOUT ETIMEDOUT
 677 #else /* ETIMEDOUT */
 678 # define SM_ERR_TIMEOUT EIO
 679 #endif /* ETIMEDOUT */
 680
 681 /*
 682 **  SET_TLS_RD_TMO -- read secured information for the caller
 683 **
 684 **      Parameters:
 685 **              rd_tmo -- read timeout
 686 **
 687 **      Results:
 688 **              none
 689 **      This is a hack: there is no way to pass it in
 690 */
 691
 692 static int tls_rd_tmo = -1;
 693
 694 void
 695 set_tls_rd_tmo(rd_tmo)
 696         int rd_tmo;
 697 {
 698         tls_rd_tmo = rd_tmo;
 699 }
 700
 701 /*
 702 **  TLS_READ -- read secured information for the caller
 703 **
 704 **      Parameters:
 705 **              fp -- the file pointer
 706 **              buf -- the location to place the data
 707 **              size -- the number of bytes to read from connection
 708 **
 709 **      Results:
 710 **              -1 on error
 711 **              otherwise the number of bytes read
 712 */
 713
 714 static ssize_t tls_read __P((SM_FILE_T *, char *, size_t));
 715
 716 static ssize_t
 717 tls_read(fp, buf, size)
 718         SM_FILE_T *fp;
 719         char *buf;
 720         size_t size;
 721 {
 722         int r, rfd, wfd, try, ssl_err;
 723         struct tls_obj *so = (struct tls_obj *) fp->f_cookie;
 724         time_t tlsstart;
 725         char *err;
 726
 727         try = 99;
 728         err = NULL;
 729         tlsstart = curtime();
 730
 731   retry:
 732         r = SSL_read(so->con, (char *) buf, size);
 733
 734         if (r > 0)
 735                 return r;
 736
 737         err = NULL;
 738         switch (ssl_err = SSL_get_error(so->con, r))
 739         {
 740           case SSL_ERROR_NONE:
 741           case SSL_ERROR_ZERO_RETURN:
 742                 break;
 743           case SSL_ERROR_WANT_WRITE:
 744                 err = "read W BLOCK";
 745                 /* FALLTHROUGH */
 746           case SSL_ERROR_WANT_READ:
 747                 if (err == NULL)
 748                         err = "read R BLOCK";
 749                 rfd = SSL_get_rfd(so->con);
 750                 wfd = SSL_get_wfd(so->con);
 751                 try = tls_retry(so->con, rfd, wfd, tlsstart,
 752                                 (tls_rd_tmo < 0) ? TimeOuts.to_datablock
 753                                                  : tls_rd_tmo,
 754                                 ssl_err, "read");
 755                 if (try > 0)
 756                         goto retry;
 757                 errno = SM_ERR_TIMEOUT;
 758                 break;
 759
 760           case SSL_ERROR_WANT_X509_LOOKUP:
 761                 err = "write X BLOCK";
 762                 break;
 763           case SSL_ERROR_SYSCALL:
 764                 if (r == 0 && errno == 0) /* out of protocol EOF found */
 765                         break;
 766                 err = "syscall error";
 767 /*
 768                 get_last_socket_error());
 769 */
 770                 break;
 771           case SSL_ERROR_SSL:
 772 #if DEAL_WITH_ERROR_SSL
 773                 if (r == 0 && errno == 0) /* out of protocol EOF found */
 774                         break;
 775 #endif /* DEAL_WITH_ERROR_SSL */
 776                 err = "generic SSL error";
 777
 778                 if (LogLevel > 9)
 779                 {
 780                         int pri;
 781
 782                         if (errno == EAGAIN && try > 0)
 783                                 pri = LOG_DEBUG;
 784                         else
 785                                 pri = LOG_WARNING;
 786                         tlslogerr(pri, "read");
 787                 }
 788
 789 #if DEAL_WITH_ERROR_SSL
 790                 /* avoid repeated calls? */
 791                 if (r == 0)
 792                         r = -1;
 793 #endif /* DEAL_WITH_ERROR_SSL */
 794                 break;
 795         }
 796         if (err != NULL)
 797         {
 798                 int save_errno;
 799
 800                 save_errno = (errno == 0) ? EIO : errno;
 801                 if (try == 0 && save_errno == SM_ERR_TIMEOUT)
 802                 {
 803                         if (LogLevel > 7)
 804                                 sm_syslog(LOG_WARNING, NOQID,
 805                                           "STARTTLS: read error=timeout");
 806                 }
 807                 else if (LogLevel > 8)
 808                 {
 809                         int pri;
 810
 811                         if (save_errno == EAGAIN && try > 0)
 812                                 pri = LOG_DEBUG;
 813                         else
 814                                 pri = LOG_WARNING;
 815                         sm_syslog(pri, NOQID,
 816                                   "STARTTLS: read error=%s (%d), errno=%d, get_error=%s, retry=%d, ssl_err=%d",
 817                                   err, r, errno,
 818                                   ERR_error_string(ERR_get_error(), NULL), try,
 819                                   ssl_err);
 820                 }
 821                 else if (LogLevel > 7)
 822                         sm_syslog(LOG_WARNING, NOQID,
 823                                   "STARTTLS: read error=%s (%d), retry=%d, ssl_err=%d",
 824                                   err, r, errno, try, ssl_err);
 825                 errno = save_errno;
 826         }
 827         return r;
 828 }
 829
 830 /*
 831 **  TLS_WRITE -- write information out through secure connection
 832 **
 833 **      Parameters:
 834 **              fp -- the file pointer
 835 **              buf -- holds the data to be securely written
 836 **              size -- the number of bytes to write
 837 **
 838 **      Returns:
 839 **              -1 on error
 840 **              otherwise number of bytes written
 841 */
 842
 843 static ssize_t tls_write __P((SM_FILE_T *, const char *, size_t));
 844
 845 static ssize_t
 846 tls_write(fp, buf, size)
 847         SM_FILE_T *fp;
 848         const char *buf;
 849         size_t size;
 850 {
 851         int r, rfd, wfd, try, ssl_err;
 852         struct tls_obj *so = (struct tls_obj *) fp->f_cookie;
 853         time_t tlsstart;
 854         char *err;
 855
 856         try = 99;
 857         err = NULL;
 858         tlsstart = curtime();
 859
 860   retry:
 861         r = SSL_write(so->con, (char *) buf, size);
 862
 863         if (r > 0)
 864                 return r;
 865         err = NULL;
 866         switch (ssl_err = SSL_get_error(so->con, r))
 867         {
 868           case SSL_ERROR_NONE:
 869           case SSL_ERROR_ZERO_RETURN:
 870                 break;
 871           case SSL_ERROR_WANT_WRITE:
 872                 err = "read W BLOCK";
 873                 /* FALLTHROUGH */
 874           case SSL_ERROR_WANT_READ:
 875                 if (err == NULL)
 876                         err = "read R BLOCK";
 877                 rfd = SSL_get_rfd(so->con);
 878                 wfd = SSL_get_wfd(so->con);
 879                 try = tls_retry(so->con, rfd, wfd, tlsstart,
 880                                 DATA_PROGRESS_TIMEOUT, ssl_err, "write");
 881                 if (try > 0)
 882                         goto retry;
 883                 errno = SM_ERR_TIMEOUT;
 884                 break;
 885           case SSL_ERROR_WANT_X509_LOOKUP:
 886                 err = "write X BLOCK";
 887                 break;
 888           case SSL_ERROR_SYSCALL:
 889                 if (r == 0 && errno == 0) /* out of protocol EOF found */
 890                         break;
 891                 err = "syscall error";
 892 /*
 893                 get_last_socket_error());
 894 */
 895                 break;
 896           case SSL_ERROR_SSL:
 897                 err = "generic SSL error";
 898 /*
 899                 ERR_GET_REASON(ERR_peek_error()));
 900 */
 901                 if (LogLevel > 9)
 902                         tlslogerr(LOG_WARNING, "write");
 903
 904 #if DEAL_WITH_ERROR_SSL
 905                 /* avoid repeated calls? */
 906                 if (r == 0)
 907                         r = -1;
 908 #endif /* DEAL_WITH_ERROR_SSL */
 909                 break;
 910         }
 911         if (err != NULL)
 912         {
 913                 int save_errno;
 914
 915                 save_errno = (errno == 0) ? EIO : errno;
 916                 if (try == 0 && save_errno == SM_ERR_TIMEOUT)
 917                 {
 918                         if (LogLevel > 7)
 919                                 sm_syslog(LOG_WARNING, NOQID,
 920                                           "STARTTLS: write error=timeout");
 921                 }
 922                 else if (LogLevel > 8)
 923                         sm_syslog(LOG_WARNING, NOQID,
 924                                   "STARTTLS: write error=%s (%d), errno=%d, get_error=%s, retry=%d, ssl_err=%d",
 925                                   err, r, errno,
 926                                   ERR_error_string(ERR_get_error(), NULL), try,
 927                                   ssl_err);
 928                 else if (LogLevel > 7)
 929                         sm_syslog(LOG_WARNING, NOQID,
 930                                   "STARTTLS: write error=%s (%d), errno=%d, retry=%d, ssl_err=%d",
 931                                   err, r, errno, try, ssl_err);
 932                 errno = save_errno;
 933         }
 934         return r;
 935 }
 936
 937 /*
 938 **  SFDCTLS -- create tls file type and open in and out file pointers
 939 **            for sendmail to read from and write to.
 940 **
 941 **      Parameters:
 942 **              fin -- data input source being replaced
 943 **              fout -- data output source being replaced
 944 **              con -- the tls connection pointer
 945 **
 946 **      Returns:
 947 **              -1 on error
 948 **              0 on success
 949 **
 950 **      Side effects:
 951 **              The arguments "fin" and "fout" are replaced with the new
 952 **              SM_FILE_T pointers.
 953 **              The original "fin" and "fout" are preserved in the tls file
 954 **              type but are not actually used because of the design of TLS.
 955 */
 956
 957 int
 958 sfdctls(fin, fout, con)
 959         SM_FILE_T **fin;
 960         SM_FILE_T **fout;
 961         SSL *con;
 962 {
 963         SM_FILE_T *tlsin, *tlsout;
 964         SM_FILE_T SM_IO_SET_TYPE(tls_vector, "tls", tls_open, tls_close,
 965                 tls_read, tls_write, NULL, tls_getinfo, NULL,
 966                 SM_TIME_FOREVER);
 967         struct tls_info info;
 968
 969         SM_ASSERT(con != NULL);
 970
 971         SM_IO_INIT_TYPE(tls_vector, "tls", tls_open, tls_close,
 972                 tls_read, tls_write, NULL, tls_getinfo, NULL,
 973                 SM_TIME_FOREVER);
 974         info.fp = *fin;
 975         info.con = con;
 976         tlsin = sm_io_open(&tls_vector, SM_TIME_DEFAULT, &info, SM_IO_RDONLY_B,
 977                            NULL);
 978         if (tlsin == NULL)
 979                 return -1;
 980
 981         info.fp = *fout;
 982         tlsout = sm_io_open(&tls_vector, SM_TIME_DEFAULT, &info, SM_IO_WRONLY_B,
 983                             NULL);
 984         if (tlsout == NULL)
 985         {
 986                 (void) sm_io_close(tlsin, SM_TIME_DEFAULT);
 987                 return -1;
 988         }
 989         sm_io_automode(tlsin, tlsout);
 990
 991         *fin = tlsin;
 992         *fout = tlsout;
 993         return 0;
 994 }
 995 #endif /* STARTTLS */