contrib/sendmail/src/milter.c

   1 /*
   2  * Copyright (c) 1999-2009, 2012, 2013 Proofpoint, 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 <sendmail.h>
  12
  13 SM_RCSID("@(#)$Id: milter.c,v 8.281 2013-11-22 20:51:56 ca Exp $")
  14
  15 #if MILTER
  16 # include <sm/sendmail.h>
  17 # include <libmilter/mfapi.h>
  18 # include <libmilter/mfdef.h>
  19 # if _FFR_8BITENVADDR
  20 #  include <sm/ixlen.h>
  21 # endif
  22
  23 # include <errno.h>
  24 # include <sm/time.h>
  25 # include <sys/uio.h>
  26
  27 # if NETINET || NETINET6
  28 #  include <arpa/inet.h>
  29 #  if MILTER_NO_NAGLE
  30 #   include <netinet/tcp.h>
  31 #  endif
  32 # endif /* NETINET || NETINET6 */
  33
  34 # include <sm/fdset.h>
  35
  36 static void     milter_connect_timeout __P((int));
  37 static void     milter_error __P((struct milter *, ENVELOPE *));
  38 static int      milter_open __P((struct milter *, bool, ENVELOPE *));
  39 static void     milter_parse_timeouts __P((char *, struct milter *));
  40 static char     *milter_sysread __P((struct milter *, char *, ssize_t, time_t,
  41                         ENVELOPE *, const char *));
  42 static char     *milter_read __P((struct milter *, char *, ssize_t *, time_t,
  43                         ENVELOPE *, const char *));
  44 static char     *milter_write __P((struct milter *, int, char *, ssize_t,
  45                         time_t, ENVELOPE *, const char *));
  46 static char     *milter_send_command __P((struct milter *, int, void *,
  47                         ssize_t, ENVELOPE *, char *, const char *));
  48 static char     *milter_command __P((int, void *, ssize_t, int,
  49                         ENVELOPE *, char *, const char *, bool));
  50 static char     *milter_body __P((struct milter *, ENVELOPE *, char *));
  51 static int      milter_reopen_df __P((ENVELOPE *));
  52 static int      milter_reset_df __P((ENVELOPE *));
  53 static void     milter_quit_filter __P((struct milter *, ENVELOPE *));
  54 static void     milter_abort_filter __P((struct milter *, ENVELOPE *));
  55 static void     milter_send_macros __P((struct milter *, char **, int,
  56                         ENVELOPE *));
  57 static int      milter_negotiate __P((struct milter *, ENVELOPE *,
  58                         milters_T *));
  59 static void     milter_per_connection_check __P((ENVELOPE *));
  60 static char     *milter_headers __P((struct milter *, ENVELOPE *, char *));
  61 static void     milter_addheader __P((struct milter *, char *, ssize_t,
  62                         ENVELOPE *));
  63 static void     milter_insheader __P((struct milter *, char *, ssize_t,
  64                         ENVELOPE *));
  65 static void     milter_changeheader __P((struct milter *, char *, ssize_t,
  66                         ENVELOPE *));
  67 static void     milter_chgfrom __P((char *, ssize_t, ENVELOPE *, const char *));
  68 static void     milter_addrcpt __P((char *, ssize_t, ENVELOPE *, const char *));
  69 static void     milter_addrcpt_par __P((char *, ssize_t, ENVELOPE *, const char *));
  70 static void     milter_delrcpt __P((char *, ssize_t, ENVELOPE *, const char *));
  71 static int      milter_replbody __P((char *, ssize_t, bool, ENVELOPE *, const char *));
  72 static int      milter_set_macros __P((char *, char **, char *, int));
  73
  74 /* milter states */
  75 # define SMFS_CLOSED            'C'     /* closed for all further actions */
  76 # define SMFS_OPEN              'O'     /* connected to remote milter filter */
  77 # define SMFS_INMSG             'M'     /* currently servicing a message */
  78 # define SMFS_DONE              'D'     /* done with current message */
  79 # define SMFS_CLOSABLE          'Q'     /* done with current connection */
  80 # define SMFS_ERROR             'E'     /* error state */
  81 # define SMFS_READY             'R'     /* ready for action */
  82 # define SMFS_SKIP              'S'     /* skip body */
  83
  84 /*
  85 **  MilterMacros contains the milter macros for each milter and each stage.
  86 **  indices are (in order): stages, milter-index, macro
  87 **  milter-index == 0: "global" macros (not for a specific milter).
  88 */
  89
  90 static char *MilterMacros[SMFIM_LAST + 1][MAXFILTERS + 1][MAXFILTERMACROS + 1];
  91 static size_t MilterMaxDataSize = MILTER_MAX_DATA_SIZE;
  92
  93 # define MILTER_CHECK_DONE_MSG() \
  94         if (*state == SMFIR_REPLYCODE || \
  95             *state == SMFIR_REJECT || \
  96             *state == SMFIR_DISCARD || \
  97             *state == SMFIR_TEMPFAIL) \
  98         { \
  99                 /* Abort the filters to let them know we are done with msg */ \
 100                 milter_abort(e); \
 101         }
 102
 103 /* set state in case of an error */
 104 # define MILTER_SET_STATE       \
 105         if (bitnset(SMF_TEMPFAIL, m->mf_flags)) \
 106                 *state = SMFIR_TEMPFAIL; \
 107         else if (bitnset(SMF_TEMPDROP, m->mf_flags)) \
 108                 *state = SMFIR_SHUTDOWN; \
 109         else if (bitnset(SMF_REJECT, m->mf_flags)) \
 110                 *state = SMFIR_REJECT
 111
 112 /* flow through code maybe using continue; don't wrap in do {} while */
 113 # define MILTER_CHECK_ERROR(initial, action) \
 114         if (!initial && tTd(71, 100)) \
 115         { \
 116                 if (e->e_quarmsg == NULL) \
 117                 { \
 118                         e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool, \
 119                                                          "filter failure"); \
 120                         macdefine(&e->e_macro, A_PERM, macid("{quarantine}"), \
 121                                   e->e_quarmsg); \
 122                 } \
 123         } \
 124         else if (tTd(71, 101)) \
 125         { \
 126                 if (e->e_quarmsg == NULL) \
 127                 { \
 128                         e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool, \
 129                                                          "filter failure"); \
 130                         macdefine(&e->e_macro, A_PERM, macid("{quarantine}"), \
 131                                   e->e_quarmsg); \
 132                 } \
 133         } \
 134         else MILTER_SET_STATE;  \
 135         else \
 136                 action;
 137
 138 # define MILTER_CHECK_REPLYCODE(default) \
 139         if (response == NULL || \
 140             strlen(response) + 1 != (size_t) rlen || \
 141             rlen < 3 || \
 142             (response[0] != '4' && response[0] != '5') || \
 143             !isascii(response[1]) || !isdigit(response[1]) || \
 144             !isascii(response[2]) || !isdigit(response[2])) \
 145         { \
 146                 if (response != NULL) \
 147                         sm_free(response); /* XXX */ \
 148                 response = newstr(default); \
 149         } \
 150         else \
 151         { \
 152                 char *ptr = response; \
 153  \
 154                 /* Check for unprotected %'s in the string */ \
 155                 while (*ptr != '\0') \
 156                 { \
 157                         if (*ptr == '%' && *++ptr != '%') \
 158                         { \
 159                                 sm_free(response); /* XXX */ \
 160                                 response = newstr(default); \
 161                                 break; \
 162                         } \
 163                         ptr++; \
 164                 } \
 165         }
 166
 167 # define MILTER_DF_ERROR(msg) \
 168 { \
 169         int save_errno = errno; \
 170  \
 171         if (tTd(64, 5)) \
 172         { \
 173                 sm_dprintf(msg, dfname, sm_errstring(save_errno)); \
 174                 sm_dprintf("\n"); \
 175         } \
 176         if (MilterLogLevel > 0) \
 177                 sm_syslog(LOG_ERR, e->e_id, msg, dfname, sm_errstring(save_errno)); \
 178         if (SuperSafe == SAFE_REALLY) \
 179         { \
 180                 SM_CLOSE_FP(e->e_dfp);  \
 181                 e->e_flags &= ~EF_HAS_DF; \
 182         } \
 183         errno = save_errno; \
 184 }
 185
 186 /*
 187 **  MILTER_TIMEOUT -- make sure socket is ready in time
 188 **
 189 **      Parameters:
 190 **              routine -- routine name for debug/logging
 191 **              secs -- number of seconds in timeout
 192 **              write -- waiting to read or write?
 193 **              started -- whether this is part of a previous sequence
 194 **
 195 **      Assumes 'm' is a milter structure for the current socket.
 196 */
 197
 198 # define MILTER_TIMEOUT(routine, secs, write, started, function) \
 199 { \
 200         int ret; \
 201         int save_errno; \
 202         fd_set fds; \
 203         struct timeval tv; \
 204  \
 205         if (!SM_FD_OK_SELECT(m->mf_sock)) \
 206         { \
 207                 if (tTd(64, 5)) \
 208                         sm_dprintf("milter_%s(%s): socket %d is larger than FD_SETSIZE %d\n", \
 209                                    (routine), m->mf_name, m->mf_sock, \
 210                                    SM_FD_SETSIZE); \
 211                 if (MilterLogLevel > 0) \
 212                         sm_syslog(LOG_ERR, e->e_id, \
 213                                   "Milter (%s): socket(%s) %d is larger than FD_SETSIZE %d", \
 214                                   m->mf_name, (routine), m->mf_sock, \
 215                                   SM_FD_SETSIZE); \
 216                 milter_error(m, e); \
 217                 return NULL; \
 218         } \
 219  \
 220         do \
 221         { \
 222                 FD_ZERO(&fds); \
 223                 SM_FD_SET(m->mf_sock, &fds); \
 224                 tv.tv_sec = (secs); \
 225                 tv.tv_usec = 0; \
 226                 ret = select(m->mf_sock + 1, \
 227                              (write) ? NULL : &fds, \
 228                              (write) ? &fds : NULL, \
 229                              NULL, &tv); \
 230         } while (ret < 0 && errno == EINTR); \
 231  \
 232         switch (ret) \
 233         { \
 234           case 0: \
 235                 if (tTd(64, 5)) \
 236                         sm_dprintf("milter_%s(%s): timeout, where=%s\n", \
 237                                 (routine), m->mf_name, (function)); \
 238                 if (MilterLogLevel > 0) \
 239                         sm_syslog(LOG_ERR, e->e_id, \
 240                                   "Milter (%s): timeout %s data %s, where=%s", \
 241                                   m->mf_name, \
 242                                   started ? "during" : "before", \
 243                                   (routine), (function)); \
 244                 milter_error(m, e); \
 245                 return NULL; \
 246  \
 247           case -1: \
 248                 save_errno = errno; \
 249                 if (tTd(64, 5)) \
 250                         sm_dprintf("milter_%s(%s): select: %s\n", (routine), \
 251                                    m->mf_name, sm_errstring(save_errno)); \
 252                 if (MilterLogLevel > 0) \
 253                 { \
 254                         sm_syslog(LOG_ERR, e->e_id, \
 255                                   "Milter (%s): select(%s): %s", \
 256                                   m->mf_name, (routine), \
 257                                   sm_errstring(save_errno)); \
 258                 } \
 259                 milter_error(m, e); \
 260                 return NULL; \
 261  \
 262           default: \
 263                 if (SM_FD_ISSET(m->mf_sock, &fds)) \
 264                         break; \
 265                 if (tTd(64, 5)) \
 266                         sm_dprintf("milter_%s(%s): socket not ready\n", \
 267                                 (routine), m->mf_name); \
 268                 if (MilterLogLevel > 0) \
 269                 { \
 270                         sm_syslog(LOG_ERR, e->e_id, \
 271                                   "Milter (%s): socket(%s) not ready", \
 272                                   m->mf_name, (routine)); \
 273                 } \
 274                 milter_error(m, e); \
 275                 return NULL; \
 276         } \
 277 }
 278
 279 /*
 280 **  Low level functions
 281 */
 282
 283 /*
 284 **  MILTER_READ -- read from a remote milter filter
 285 **
 286 **      Parameters:
 287 **              m -- milter to read from.
 288 **              cmd -- return param for command read.
 289 **              rlen -- return length of response string.
 290 **              to -- timeout in seconds.
 291 **              e -- current envelope.
 292 **
 293 **      Returns:
 294 **              response string (may be NULL)
 295 */
 296
 297 static char *
 298 milter_sysread(m, buf, sz, to, e, where)
 299         struct milter *m;
 300         char *buf;
 301         ssize_t sz;
 302         time_t to;
 303         ENVELOPE *e;
 304         const char *where;
 305 {
 306         time_t readstart = 0;
 307         ssize_t len, curl;
 308         bool started = false;
 309
 310         curl = 0;
 311
 312         if (to > 0)
 313                 readstart = curtime();
 314
 315         for (;;)
 316         {
 317                 if (to > 0)
 318                 {
 319                         time_t now;
 320
 321                         now = curtime();
 322                         if (now - readstart >= to)
 323                         {
 324                                 if (tTd(64, 5))
 325                                         sm_dprintf("milter_sys_read (%s): timeout %s data read in %s",
 326                                                   m->mf_name,
 327                                                   started ? "during" : "before",
 328                                                   where);
 329                                 if (MilterLogLevel > 0)
 330                                         sm_syslog(LOG_ERR, e->e_id,
 331                                                   "Milter (%s): timeout %s data read in %s",
 332                                                   m->mf_name,
 333                                                   started ? "during" : "before",
 334                                                   where);
 335                                 milter_error(m, e);
 336                                 return NULL;
 337                         }
 338                         to -= now - readstart;
 339                         readstart = now;
 340                         MILTER_TIMEOUT("read", to, false, started, where);
 341                 }
 342
 343                 len = read(m->mf_sock, buf + curl, sz - curl);
 344
 345                 if (len < 0)
 346                 {
 347                         int save_errno = errno;
 348
 349                         if (tTd(64, 5))
 350                                 sm_dprintf("milter_sys_read(%s): read returned %ld: %s\n",
 351                                         m->mf_name, (long) len,
 352                                         sm_errstring(save_errno));
 353                         if (MilterLogLevel > 0)
 354                                 sm_syslog(LOG_ERR, e->e_id,
 355                                           "Milter (%s): read returned %ld: %s",
 356                                           m->mf_name, (long) len,
 357                                           sm_errstring(save_errno));
 358                         milter_error(m, e);
 359                         return NULL;
 360                 }
 361
 362                 started = true;
 363                 curl += len;
 364                 if (len == 0 || curl >= sz)
 365                         break;
 366
 367         }
 368
 369         if (curl != sz)
 370         {
 371                 if (tTd(64, 5))
 372                         sm_dprintf("milter_sys_read(%s): cmd read returned %ld, expecting %ld\n",
 373                                 m->mf_name, (long) curl, (long) sz);
 374                 if (MilterLogLevel > 0)
 375                         sm_syslog(LOG_ERR, e->e_id,
 376                                   "milter_sys_read(%s): cmd read returned %ld, expecting %ld",
 377                                   m->mf_name, (long) curl, (long) sz);
 378                 milter_error(m, e);
 379                 return NULL;
 380         }
 381         return buf;
 382 }
 383
 384 static char *
 385 milter_read(m, cmd, rlen, to, e, where)
 386         struct milter *m;
 387         char *cmd;
 388         ssize_t *rlen;
 389         time_t to;
 390         ENVELOPE *e;
 391         const char *where;
 392 {
 393         time_t readstart = 0;
 394         ssize_t expl;
 395         mi_int32 i;
 396 # if MILTER_NO_NAGLE && defined(TCP_CORK)
 397         int cork = 0;
 398 # endif
 399         char *buf;
 400         char data[MILTER_LEN_BYTES + 1];
 401
 402         if (m->mf_sock < 0)
 403         {
 404                 if (MilterLogLevel > 0)
 405                         sm_syslog(LOG_ERR, e->e_id,
 406                                   "milter_read(%s): socket closed, where=%s",
 407                                   m->mf_name, where);
 408                 milter_error(m, e);
 409                 return NULL;
 410         }
 411
 412         *rlen = 0;
 413         *cmd = '\0';
 414
 415         if (to > 0)
 416                 readstart = curtime();
 417
 418 # if MILTER_NO_NAGLE && defined(TCP_CORK)
 419         setsockopt(m->mf_sock, IPPROTO_TCP, TCP_CORK, (char *)&cork,
 420                    sizeof(cork));
 421 # endif
 422
 423         if (milter_sysread(m, data, sizeof(data), to, e, where) == NULL)
 424                 return NULL;
 425
 426 # if MILTER_NO_NAGLE && defined(TCP_CORK)
 427         cork = 1;
 428         setsockopt(m->mf_sock, IPPROTO_TCP, TCP_CORK, (char *)&cork,
 429                    sizeof(cork));
 430 # endif
 431
 432         /* reset timeout */
 433         if (to > 0)
 434         {
 435                 time_t now;
 436
 437                 now = curtime();
 438                 if (now - readstart >= to)
 439                 {
 440                         if (tTd(64, 5))
 441                                 sm_dprintf("milter_read(%s): timeout before data read, where=%s\n",
 442                                         m->mf_name, where);
 443                         if (MilterLogLevel > 0)
 444                                 sm_syslog(LOG_ERR, e->e_id,
 445                                           "Milter read(%s): timeout before data read, where=%s",
 446                                           m->mf_name, where);
 447                         milter_error(m, e);
 448                         return NULL;
 449                 }
 450                 to -= now - readstart;
 451         }
 452
 453         *cmd = data[MILTER_LEN_BYTES];
 454         data[MILTER_LEN_BYTES] = '\0';
 455         (void) memcpy(&i, data, MILTER_LEN_BYTES);
 456         expl = ntohl(i) - 1;
 457
 458         if (tTd(64, 25))
 459                 sm_dprintf("milter_read(%s): expecting %ld bytes\n",
 460                         m->mf_name, (long) expl);
 461
 462         if (expl < 0)
 463         {
 464                 if (tTd(64, 5))
 465                         sm_dprintf("milter_read(%s): read size %ld out of range, where=%s\n",
 466                                 m->mf_name, (long) expl, where);
 467                 if (MilterLogLevel > 0)
 468                         sm_syslog(LOG_ERR, e->e_id,
 469                                   "milter_read(%s): read size %ld out of range, where=%s",
 470                                   m->mf_name, (long) expl, where);
 471                 milter_error(m, e);
 472                 return NULL;
 473         }
 474
 475         if (expl == 0)
 476                 return NULL;
 477
 478         buf = (char *) xalloc(expl);
 479
 480         if (milter_sysread(m, buf, expl, to, e, where) == NULL)
 481         {
 482                 sm_free(buf); /* XXX */
 483                 return NULL;
 484         }
 485
 486         if (tTd(64, 50))
 487                 sm_dprintf("milter_read(%s): Returning %*s\n",
 488                         m->mf_name, (int) expl, buf);
 489         *rlen = expl;
 490         return buf;
 491 }
 492
 493 /*
 494 **  MILTER_WRITE -- write to a remote milter filter
 495 **
 496 **      Parameters:
 497 **              m -- milter to read from.
 498 **              cmd -- command to send.
 499 **              buf -- optional command data.
 500 **              len -- length of buf.
 501 **              to -- timeout in seconds.
 502 **              e -- current envelope.
 503 **
 504 **      Returns:
 505 **              buf if successful, NULL otherwise
 506 **              Not actually used anywhere but function prototype
 507 **                      must match milter_read()
 508 */
 509
 510 static char *
 511 milter_write(m, cmd, buf, len, to, e, where)
 512         struct milter *m;
 513         int cmd;
 514         char *buf;
 515         ssize_t len;
 516         time_t to;
 517         ENVELOPE *e;
 518         const char *where;
 519 {
 520         ssize_t sl, i;
 521         int num_vectors;
 522         mi_int32 nl;
 523         char command = (char) cmd;
 524         char data[MILTER_LEN_BYTES + 1];
 525         bool started = false;
 526         struct iovec vector[2];
 527
 528         /*
 529         **  At most two buffers will be written, though
 530         **  only one may actually be used (see num_vectors).
 531         **  The first is the size/command and the second is the command data.
 532         */
 533
 534         if (len < 0 || len > MilterMaxDataSize)
 535         {
 536                 if (tTd(64, 5))
 537                 {
 538                         sm_dprintf("milter_write(%s): length %ld out of range, mds=%ld, cmd=%c\n",
 539                                 m->mf_name, (long) len,
 540                                 (long) MilterMaxDataSize, command);
 541                         sm_dprintf("milter_write(%s): buf=%s\n",
 542                                 m->mf_name, str2prt(buf));
 543                 }
 544                 if (MilterLogLevel > 0)
 545                         sm_syslog(LOG_ERR, e->e_id,
 546                                   "milter_write(%s): length %ld out of range, cmd=%c",
 547                                   m->mf_name, (long) len, command);
 548                 milter_error(m, e);
 549                 return NULL;
 550         }
 551         if (m->mf_sock < 0)
 552         {
 553                 if (MilterLogLevel > 0)
 554                         sm_syslog(LOG_ERR, e->e_id,
 555                                   "milter_write(%s): socket closed",
 556                                   m->mf_name);
 557                 milter_error(m, e);
 558                 return NULL;
 559         }
 560
 561         if (tTd(64, 20))
 562                 sm_dprintf("milter_write(%s): cmd %c, len %ld\n",
 563                            m->mf_name, command, (long) len);
 564
 565         nl = htonl(len + 1);    /* add 1 for the command char */
 566         (void) memcpy(data, (char *) &nl, MILTER_LEN_BYTES);
 567         data[MILTER_LEN_BYTES] = command;
 568         sl = MILTER_LEN_BYTES + 1;
 569
 570         /* set up the vector for the size / command */
 571         vector[0].iov_base = (void *) data;
 572         vector[0].iov_len  = sl;
 573
 574         /*
 575         **  Determine if there is command data.  If so, there will be two
 576         **  vectors.  If not, there will be only one.  The vectors are set
 577         **  up here and 'num_vectors' and 'sl' are set appropriately.
 578         */
 579
 580         /* NOTE:  len<0 has already been checked for.  Pedantic */
 581         if (len <= 0 || buf == NULL)
 582         {
 583                 /* There is no command data -- only a size / command data */
 584                 num_vectors = 1;
 585         }
 586         else
 587         {
 588                 /*
 589                 **  There is both size / command and command data.
 590                 **  Set up the vector for the command data.
 591                 */
 592
 593                 num_vectors = 2;
 594                 sl += len;
 595                 vector[1].iov_base = (void *) buf;
 596                 vector[1].iov_len  = len;
 597
 598                 if (tTd(64, 50))
 599                         sm_dprintf("milter_write(%s): Sending %*s\n",
 600                                    m->mf_name, (int) len, buf);
 601         }
 602
 603         if (to > 0)
 604                 MILTER_TIMEOUT("write", to, true, started, where);
 605
 606         /* write the vector(s) */
 607         i = writev(m->mf_sock, vector, num_vectors);
 608         if (i != sl)
 609         {
 610                 int save_errno = errno;
 611
 612                 if (tTd(64, 5))
 613                         sm_dprintf("milter_write(%s): write(%c) returned %ld, expected %ld: %s\n",
 614                                    m->mf_name, command, (long) i, (long) sl,
 615                                    sm_errstring(save_errno));
 616                 if (MilterLogLevel > 0)
 617                         sm_syslog(LOG_ERR, e->e_id,
 618                                   "Milter (%s): write(%c) returned %ld, expected %ld: %s",
 619                                   m->mf_name, command, (long) i, (long) sl,
 620                                   sm_errstring(save_errno));
 621                 milter_error(m, e);
 622                 return NULL;
 623         }
 624         return buf;
 625 }
 626
 627 /*
 628 **  Utility functions
 629 */
 630
 631 /*
 632 **  MILTER_OPEN -- connect to remote milter filter
 633 **
 634 **      Parameters:
 635 **              m -- milter to connect to.
 636 **              parseonly -- parse but don't connect.
 637 **              e -- current envelope.
 638 **
 639 **      Returns:
 640 **              connected socket if successful && !parseonly,
 641 **              0 upon parse success if parseonly,
 642 **              -1 otherwise.
 643 */
 644
 645 static jmp_buf  MilterConnectTimeout;
 646
 647 static int
 648 milter_open(m, parseonly, e)
 649         struct milter *m;
 650         bool parseonly;
 651         ENVELOPE *e;
 652 {
 653         int sock = 0;
 654         SOCKADDR_LEN_T addrlen = 0;
 655         int addrno = 0;
 656         int save_errno;
 657         char *p;
 658         char *colon;
 659         char *at;
 660         struct hostent *hp = NULL;
 661         SOCKADDR addr;
 662
 663         if (SM_IS_EMPTY(m->mf_conn))
 664         {
 665                 if (tTd(64, 5))
 666                         sm_dprintf("X%s: empty or missing socket information\n",
 667                                    m->mf_name);
 668                 if (parseonly)
 669                         syserr("X%s: empty or missing socket information",
 670                                m->mf_name);
 671                 else if (MilterLogLevel > 0)
 672                         sm_syslog(LOG_ERR, e->e_id,
 673                                   "Milter (%s): empty or missing socket information",
 674                                   m->mf_name);
 675                 milter_error(m, e);
 676                 return -1;
 677         }
 678
 679         /* protocol:filename or protocol:port@host */
 680         memset(&addr, '\0', sizeof(addr));
 681         p = m->mf_conn;
 682         colon = strchr(p, ':');
 683         if (colon != NULL)
 684         {
 685                 *colon = '\0';
 686
 687                 if (*p == '\0')
 688                 {
 689 # if NETUNIX
 690                         /* default to AF_UNIX */
 691                         addr.sa.sa_family = AF_UNIX;
 692 # else
 693 #  if NETINET
 694                         /* default to AF_INET */
 695                         addr.sa.sa_family = AF_INET;
 696 #  else /* NETINET */
 697 #   if NETINET6
 698                         /* default to AF_INET6 */
 699                         addr.sa.sa_family = AF_INET6;
 700 #   else /* NETINET6 */
 701                         /* no protocols available */
 702                         if (MilterLogLevel > 0)
 703                                 sm_syslog(LOG_ERR, e->e_id,
 704                                           "Milter (%s): no valid socket protocols available",
 705                                           m->mf_name);
 706                         milter_error(m, e);
 707                         return -1;
 708 #   endif /* NETINET6 */
 709 #  endif /* NETINET */
 710 # endif /* NETUNIX */
 711                 }
 712 # if NETUNIX
 713                 else if (SM_STRCASEEQ(p, "unix") ||
 714                          SM_STRCASEEQ(p, "local"))
 715                         addr.sa.sa_family = AF_UNIX;
 716 # endif
 717 # if NETINET
 718                 else if (SM_STRCASEEQ(p, "inet"))
 719                         addr.sa.sa_family = AF_INET;
 720 # endif
 721 # if NETINET6
 722                 else if (SM_STRCASEEQ(p, "inet6"))
 723                         addr.sa.sa_family = AF_INET6;
 724 # endif
 725                 else
 726                 {
 727 # ifdef EPROTONOSUPPORT
 728                         errno = EPROTONOSUPPORT;
 729 # else
 730                         errno = EINVAL;
 731 # endif
 732                         if (tTd(64, 5))
 733                                 sm_dprintf("X%s: unknown socket type %s\n",
 734                                         m->mf_name, p);
 735                         if (parseonly)
 736                                 syserr("X%s: unknown socket type %s",
 737                                        m->mf_name, p);
 738                         else if (MilterLogLevel > 0)
 739                                 sm_syslog(LOG_ERR, e->e_id,
 740                                           "Milter (%s): unknown socket type %s",
 741                                           m->mf_name, p);
 742                         milter_error(m, e);
 743                         return -1;
 744                 }
 745                 *colon++ = ':';
 746         }
 747         else
 748         {
 749                 /* default to AF_UNIX */
 750                 addr.sa.sa_family = AF_UNIX;
 751                 colon = p;
 752         }
 753
 754 # if NETUNIX
 755         if (addr.sa.sa_family == AF_UNIX)
 756         {
 757                 long sff = SFF_SAFEDIRPATH|SFF_OPENASROOT|SFF_NOLINK|SFF_EXECOK;
 758
 759                 at = colon;
 760                 if (strlen(colon) >= sizeof(addr.sunix.sun_path))
 761                 {
 762                         if (tTd(64, 5))
 763                                 sm_dprintf("X%s: local socket name %s too long\n",
 764                                         m->mf_name, colon);
 765                         errno = EINVAL;
 766                         if (parseonly)
 767                                 syserr("X%s: local socket name %s too long",
 768                                        m->mf_name, colon);
 769                         else if (MilterLogLevel > 0)
 770                                 sm_syslog(LOG_ERR, e->e_id,
 771                                           "Milter (%s): local socket name %s too long",
 772                                           m->mf_name, colon);
 773                         milter_error(m, e);
 774                         return -1;
 775                 }
 776                 errno = safefile(colon, RunAsUid, RunAsGid, RunAsUserName, sff,
 777                                  S_IRUSR|S_IWUSR, NULL);
 778
 779                 /* if just parsing .cf file, socket doesn't need to exist */
 780                 if (parseonly && errno == ENOENT)
 781                 {
 782                         if (OpMode == MD_DAEMON ||
 783                             OpMode == MD_FGDAEMON)
 784                                 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT,
 785                                                      "WARNING: X%s: local socket name %s missing\n",
 786                                                      m->mf_name, colon);
 787                 }
 788                 else if (errno != 0)
 789                 {
 790                         /* if not safe, don't create */
 791                         save_errno = errno;
 792                         if (tTd(64, 5))
 793                                 sm_dprintf("X%s: local socket name %s unsafe\n",
 794                                         m->mf_name, colon);
 795                         errno = save_errno;
 796                         if (parseonly)
 797                         {
 798                                 if (OpMode == MD_DAEMON ||
 799                                     OpMode == MD_FGDAEMON ||
 800                                     OpMode == MD_SMTP)
 801                                         syserr("X%s: local socket name %s unsafe",
 802                                                m->mf_name, colon);
 803                         }
 804                         else if (MilterLogLevel > 0)
 805                                 sm_syslog(LOG_ERR, e->e_id,
 806                                           "Milter (%s): local socket name %s unsafe",
 807                                           m->mf_name, colon);
 808                         milter_error(m, e);
 809                         return -1;
 810                 }
 811
 812                 (void) sm_strlcpy(addr.sunix.sun_path, colon,
 813                                sizeof(addr.sunix.sun_path));
 814                 addrlen = sizeof(struct sockaddr_un);
 815         }
 816         else
 817 # endif /* NETUNIX */
 818 # if NETINET || NETINET6
 819         if (false
 820 #  if NETINET
 821                  || addr.sa.sa_family == AF_INET
 822 #  endif
 823 #  if NETINET6
 824                  || addr.sa.sa_family == AF_INET6
 825 #  endif
 826                  )
 827         {
 828                 unsigned short port;
 829
 830                 /* Parse port@host */
 831                 at = strchr(colon, '@');
 832                 if (at == NULL)
 833                 {
 834                         if (tTd(64, 5))
 835                                 sm_dprintf("X%s: bad address %s (expected port@host)\n",
 836                                         m->mf_name, colon);
 837                         if (parseonly)
 838                                 syserr("X%s: bad address %s (expected port@host)",
 839                                        m->mf_name, colon);
 840                         else if (MilterLogLevel > 0)
 841                                 sm_syslog(LOG_ERR, e->e_id,
 842                                           "Milter (%s): bad address %s (expected port@host)",
 843                                           m->mf_name, colon);
 844                         milter_error(m, e);
 845                         return -1;
 846                 }
 847                 *at = '\0';
 848                 if (isascii(*colon) && isdigit(*colon))
 849                         port = htons((unsigned short) atoi(colon));
 850                 else
 851                 {
 852 #  ifdef NO_GETSERVBYNAME
 853                         if (tTd(64, 5))
 854                                 sm_dprintf("X%s: invalid port number %s\n",
 855                                         m->mf_name, colon);
 856                         if (parseonly)
 857                                 syserr("X%s: invalid port number %s",
 858                                        m->mf_name, colon);
 859                         else if (MilterLogLevel > 0)
 860                                 sm_syslog(LOG_ERR, e->e_id,
 861                                           "Milter (%s): invalid port number %s",
 862                                           m->mf_name, colon);
 863                         milter_error(m, e);
 864                         return -1;
 865 #  else /* NO_GETSERVBYNAME */
 866                         struct servent *sp;
 867
 868                         sp = getservbyname(colon, "tcp");
 869                         if (sp == NULL)
 870                         {
 871                                 save_errno = errno;
 872                                 if (tTd(64, 5))
 873                                         sm_dprintf("X%s: unknown port name %s\n",
 874                                                 m->mf_name, colon);
 875                                 errno = save_errno;
 876                                 if (parseonly)
 877                                         syserr("X%s: unknown port name %s",
 878                                                m->mf_name, colon);
 879                                 else if (MilterLogLevel > 0)
 880                                         sm_syslog(LOG_ERR, e->e_id,
 881                                                   "Milter (%s): unknown port name %s",
 882                                                   m->mf_name, colon);
 883                                 milter_error(m, e);
 884                                 return -1;
 885                         }
 886                         port = sp->s_port;
 887 #  endif /* NO_GETSERVBYNAME */
 888                 }
 889                 *at++ = '@';
 890                 if (*at == '[')
 891                 {
 892                         char *end;
 893
 894                         end = strchr(at, ']');
 895                         if (end != NULL)
 896                         {
 897                                 bool found = false;
 898 #  if NETINET
 899                                 unsigned long hid = INADDR_NONE;
 900 #  endif
 901 #  if NETINET6
 902                                 struct sockaddr_in6 hid6;
 903 #  endif
 904
 905                                 *end = '\0';
 906 #  if NETINET
 907                                 if (addr.sa.sa_family == AF_INET &&
 908                                     (hid = inet_addr(&at[1])) != INADDR_NONE)
 909                                 {
 910                                         addr.sin.sin_addr.s_addr = hid;
 911                                         addr.sin.sin_port = port;
 912                                         found = true;
 913                                 }
 914 #  endif /* NETINET */
 915 #  if NETINET6
 916                                 (void) memset(&hid6, '\0', sizeof(hid6));
 917                                 if (addr.sa.sa_family == AF_INET6 &&
 918                                     anynet_pton(AF_INET6, &at[1],
 919                                                 &hid6.sin6_addr) == 1)
 920                                 {
 921                                         addr.sin6.sin6_addr = hid6.sin6_addr;
 922                                         addr.sin6.sin6_port = port;
 923                                         found = true;
 924                                 }
 925 #  endif /* NETINET6 */
 926                                 *end = ']';
 927                                 if (!found)
 928                                 {
 929                                         if (tTd(64, 5))
 930                                                 sm_dprintf("X%s: Invalid numeric domain spec \"%s\"\n",
 931                                                         m->mf_name, at);
 932                                         if (parseonly)
 933                                                 syserr("X%s: Invalid numeric domain spec \"%s\"",
 934                                                        m->mf_name, at);
 935                                         else if (MilterLogLevel > 0)
 936                                                 sm_syslog(LOG_ERR, e->e_id,
 937                                                           "Milter (%s): Invalid numeric domain spec \"%s\"",
 938                                                           m->mf_name, at);
 939                                         milter_error(m, e);
 940                                         return -1;
 941                                 }
 942                         }
 943                         else
 944                         {
 945                                 if (tTd(64, 5))
 946                                         sm_dprintf("X%s: Invalid numeric domain spec \"%s\"\n",
 947                                                 m->mf_name, at);
 948                                 if (parseonly)
 949                                         syserr("X%s: Invalid numeric domain spec \"%s\"",
 950                                                m->mf_name, at);
 951                                 else if (MilterLogLevel > 0)
 952                                         sm_syslog(LOG_ERR, e->e_id,
 953                                                   "Milter (%s): Invalid numeric domain spec \"%s\"",
 954                                                   m->mf_name, at);
 955                                 milter_error(m, e);
 956                                 return -1;
 957                         }
 958                 }
 959                 else
 960                 {
 961                         hp = sm_gethostbyname(at, addr.sa.sa_family);
 962                         if (hp == NULL)
 963                         {
 964                                 save_errno = errno;
 965                                 if (tTd(64, 5))
 966                                         sm_dprintf("X%s: Unknown host name %s\n",
 967                                                    m->mf_name, at);
 968                                 errno = save_errno;
 969                                 if (parseonly)
 970                                         syserr("X%s: Unknown host name %s",
 971                                                m->mf_name, at);
 972                                 else if (MilterLogLevel > 0)
 973                                         sm_syslog(LOG_ERR, e->e_id,
 974                                                   "Milter (%s): Unknown host name %s",
 975                                                   m->mf_name, at);
 976                                 milter_error(m, e);
 977                                 return -1;
 978                         }
 979                         addr.sa.sa_family = hp->h_addrtype;
 980                         switch (hp->h_addrtype)
 981                         {
 982 #  if NETINET
 983                           case AF_INET:
 984                                 memmove(&addr.sin.sin_addr,
 985                                         hp->h_addr, INADDRSZ);
 986                                 addr.sin.sin_port = port;
 987                                 addrlen = sizeof(struct sockaddr_in);
 988                                 addrno = 1;
 989                                 break;
 990 #  endif /* NETINET */
 991
 992 #  if NETINET6
 993                           case AF_INET6:
 994                                 memmove(&addr.sin6.sin6_addr,
 995                                         hp->h_addr, IN6ADDRSZ);
 996                                 addr.sin6.sin6_port = port;
 997                                 addrlen = sizeof(struct sockaddr_in6);
 998                                 addrno = 1;
 999                                 break;
1000 #  endif /* NETINET6 */
1001
1002                           default:
1003                                 if (tTd(64, 5))
1004                                         sm_dprintf("X%s: Unknown protocol for %s (%d)\n",
1005                                                    m->mf_name, at,
1006                                                    hp->h_addrtype);
1007                                 if (parseonly)
1008                                         syserr("X%s: Unknown protocol for %s (%d)",
1009                                                m->mf_name, at, hp->h_addrtype);
1010                                 else if (MilterLogLevel > 0)
1011                                         sm_syslog(LOG_ERR, e->e_id,
1012                                                   "Milter (%s): Unknown protocol for %s (%d)",
1013                                                   m->mf_name, at,
1014                                                   hp->h_addrtype);
1015                                 milter_error(m, e);
1016 #  if NETINET6
1017                                 freehostent(hp);
1018 #  endif
1019                                 return -1;
1020                         }
1021                 }
1022         }
1023         else
1024 # endif /* NETINET || NETINET6 */
1025         {
1026                 if (tTd(64, 5))
1027                         sm_dprintf("X%s: unknown socket protocol\n",
1028                                    m->mf_name);
1029                 if (parseonly)
1030                         syserr("X%s: unknown socket protocol", m->mf_name);
1031                 else if (MilterLogLevel > 0)
1032                         sm_syslog(LOG_ERR, e->e_id,
1033                                   "Milter (%s): unknown socket protocol",
1034                                   m->mf_name);
1035                 milter_error(m, e);
1036                 return -1;
1037         }
1038
1039         /* just parsing through? */
1040         if (parseonly)
1041         {
1042                 m->mf_state = SMFS_READY;
1043 # if NETINET6
1044                 if (hp != NULL)
1045                         freehostent(hp);
1046 # endif
1047                 return 0;
1048         }
1049
1050         /* sanity check */
1051         if (m->mf_state != SMFS_READY &&
1052             m->mf_state != SMFS_CLOSED)
1053         {
1054                 /* shouldn't happen */
1055                 if (tTd(64, 1))
1056                         sm_dprintf("Milter (%s): Trying to open filter in state %c\n",
1057                                    m->mf_name, (char) m->mf_state);
1058                 milter_error(m, e);
1059 # if NETINET6
1060                 if (hp != NULL)
1061                         freehostent(hp);
1062 # endif
1063                 return -1;
1064         }
1065
1066         /* nope, actually connecting */
1067         for (;;)
1068         {
1069                 sock = socket(addr.sa.sa_family, SOCK_STREAM, 0);
1070                 if (sock < 0)
1071                 {
1072                         save_errno = errno;
1073                         if (tTd(64, 5))
1074                                 sm_dprintf("Milter (%s): error creating socket: %s\n",
1075                                            m->mf_name,
1076                                            sm_errstring(save_errno));
1077                         if (MilterLogLevel > 0)
1078                                 sm_syslog(LOG_ERR, e->e_id,
1079                                           "Milter (%s): error creating socket: %s",
1080                                           m->mf_name, sm_errstring(save_errno));
1081                         milter_error(m, e);
1082 # if NETINET6
1083                         if (hp != NULL)
1084                                 freehostent(hp);
1085 # endif
1086                         return -1;
1087                 }
1088
1089                 if (setjmp(MilterConnectTimeout) == 0)
1090                 {
1091                         SM_EVENT *ev = NULL;
1092                         int i;
1093
1094                         if (m->mf_timeout[SMFTO_CONNECT] > 0)
1095                                 ev = sm_setevent(m->mf_timeout[SMFTO_CONNECT],
1096                                                  milter_connect_timeout, 0);
1097
1098                         i = connect(sock, (struct sockaddr *) &addr, addrlen);
1099                         save_errno = errno;
1100                         if (ev != NULL)
1101                                 sm_clrevent(ev);
1102                         errno = save_errno;
1103                         if (i >= 0)
1104                                 break;
1105                 }
1106
1107                 /* couldn't connect.... try next address */
1108                 save_errno = errno;
1109                 p = CurHostName;
1110                 CurHostName = at;
1111                 if (tTd(64, 5))
1112                         sm_dprintf("milter_open (%s): open %s failed: %s\n",
1113                                    m->mf_name, at, sm_errstring(save_errno));
1114                 if (MilterLogLevel > 13)
1115                         sm_syslog(LOG_INFO, e->e_id,
1116                                   "Milter (%s): open %s failed: %s",
1117                                   m->mf_name, at, sm_errstring(save_errno));
1118                 CurHostName = p;
1119                 (void) close(sock);
1120
1121                 /* try next address */
1122                 if (hp != NULL && hp->h_addr_list[addrno] != NULL)
1123                 {
1124                         switch (addr.sa.sa_family)
1125                         {
1126 # if NETINET
1127                           case AF_INET:
1128                                 memmove(&addr.sin.sin_addr,
1129                                         hp->h_addr_list[addrno++],
1130                                         INADDRSZ);
1131                                 break;
1132 # endif /* NETINET */
1133
1134 # if NETINET6
1135                           case AF_INET6:
1136                                 memmove(&addr.sin6.sin6_addr,
1137                                         hp->h_addr_list[addrno++],
1138                                         IN6ADDRSZ);
1139                                 break;
1140 # endif /* NETINET6 */
1141
1142                           default:
1143                                 if (tTd(64, 5))
1144                                         sm_dprintf("X%s: Unknown protocol for %s (%d)\n",
1145                                                    m->mf_name, at,
1146                                                    hp->h_addrtype);
1147                                 if (MilterLogLevel > 0)
1148                                         sm_syslog(LOG_ERR, e->e_id,
1149                                                   "Milter (%s): Unknown protocol for %s (%d)",
1150                                                   m->mf_name, at,
1151                                                   hp->h_addrtype);
1152                                 milter_error(m, e);
1153 # if NETINET6
1154                                 freehostent(hp);
1155 # endif
1156                                 return -1;
1157                         }
1158                         continue;
1159                 }
1160                 p = CurHostName;
1161                 CurHostName = at;
1162                 if (tTd(64, 5))
1163                         sm_dprintf("X%s: error connecting to filter: %s\n",
1164                                    m->mf_name, sm_errstring(save_errno));
1165                 if (MilterLogLevel > 0)
1166                         sm_syslog(LOG_ERR, e->e_id,
1167                                   "Milter (%s): error connecting to filter: %s",
1168                                   m->mf_name, sm_errstring(save_errno));
1169                 CurHostName = p;
1170                 milter_error(m, e);
1171 # if NETINET6
1172                 if (hp != NULL)
1173                         freehostent(hp);
1174 # endif
1175                 return -1;
1176         }
1177         m->mf_state = SMFS_OPEN;
1178 # if NETINET6
1179         if (hp != NULL)
1180         {
1181                 freehostent(hp);
1182                 hp = NULL;
1183         }
1184 # endif /* NETINET6 */
1185 # if MILTER_NO_NAGLE && !defined(TCP_CORK)
1186         {
1187                 int nodelay = 1;
1188
1189                 setsockopt(m->mf_sock, IPPROTO_TCP, TCP_NODELAY,
1190                            (char *)&nodelay, sizeof(nodelay));
1191         }
1192 # endif /* MILTER_NO_NAGLE && !defined(TCP_CORK) */
1193         return sock;
1194 }
1195
1196 static void
1197 milter_connect_timeout(ignore)
1198         int ignore;
1199 {
1200         /*
1201         **  NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER.  DO NOT ADD
1202         **      ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
1203         **      DOING.
1204         */
1205
1206         errno = ETIMEDOUT;
1207         longjmp(MilterConnectTimeout, 1);
1208 }
1209
1210 /*
1211 **  MILTER_SETUP -- setup structure for a mail filter
1212 **
1213 **      Parameters:
1214 **              line -- the options line.
1215 **
1216 **      Returns:
1217 **              none
1218 */
1219
1220 void
1221 milter_setup(line)
1222         char *line;
1223 {
1224         char fcode;
1225         char *p;
1226         struct milter *m;
1227         STAB *s;
1228         static int idx = 0;
1229
1230         /* collect the filter name */
1231         for (p = line;
1232              *p != '\0' && *p != ',' && !(SM_ISSPACE(*p));
1233              p++)
1234                 continue;
1235         if (*p != '\0')
1236                 *p++ = '\0';
1237         if (line[0] == '\0')
1238         {
1239                 syserr("name required for mail filter");
1240                 return;
1241         }
1242         m = (struct milter *) xalloc(sizeof(*m));
1243         memset((char *) m, '\0', sizeof(*m));
1244         m->mf_name = newstr(line);
1245         m->mf_state = SMFS_READY;
1246         m->mf_sock = -1;
1247         m->mf_timeout[SMFTO_CONNECT] = (time_t) 300;
1248         m->mf_timeout[SMFTO_WRITE] = (time_t) 10;
1249         m->mf_timeout[SMFTO_READ] = (time_t) 10;
1250         m->mf_timeout[SMFTO_EOM] = (time_t) 300;
1251 # if _FFR_MILTER_CHECK
1252         m->mf_mta_prot_version = SMFI_PROT_VERSION;
1253         m->mf_mta_prot_flags = SMFI_CURR_PROT;
1254         m->mf_mta_actions = SMFI_CURR_ACTS;
1255 # endif /* _FFR_MILTER_CHECK */
1256
1257         /* now scan through and assign info from the fields */
1258         while (*p != '\0')
1259         {
1260                 char *delimptr;
1261
1262                 while (*p != '\0' &&
1263                        (*p == ',' || (SM_ISSPACE(*p))))
1264                         p++;
1265
1266                 /* p now points to field code */
1267                 fcode = *p;
1268                 while (*p != '\0' && *p != '=' && *p != ',')
1269                         p++;
1270                 if (*p++ != '=')
1271                 {
1272                         syserr("X%s: `=' expected", m->mf_name);
1273                         /* this should not be reached, but just in case */
1274                         SM_FREE(m);
1275                         return;
1276                 }
1277                 while (SM_ISSPACE(*p))
1278                         p++;
1279
1280                 /* p now points to the field body */
1281                 p = munchstring(p, &delimptr, ',');
1282
1283                 /* install the field into the filter struct */
1284                 switch (fcode)
1285                 {
1286                   case 'S':             /* socket */
1287                         if (p == NULL)
1288                                 m->mf_conn = NULL;
1289                         else
1290                                 m->mf_conn = newstr(p);
1291                         break;
1292
1293                   case 'F':             /* Milter flags configured on MTA */
1294                         for (; *p != '\0'; p++)
1295                         {
1296                                 if (!(SM_ISSPACE(*p)))
1297                                         setbitn(bitidx(*p), m->mf_flags);
1298                         }
1299                         break;
1300
1301                   case 'T':             /* timeouts */
1302                         milter_parse_timeouts(p, m);
1303                         break;
1304
1305 # if _FFR_MILTER_CHECK
1306                   case 'a':
1307                         m->mf_mta_actions = strtoul(p, NULL, 0);
1308                         break;
1309                   case 'f':
1310                         m->mf_mta_prot_flags = strtoul(p, NULL, 0);
1311                         break;
1312                   case 'v':
1313                         m->mf_mta_prot_version = strtoul(p, NULL, 0);
1314                         break;
1315 # endif /* _FFR_MILTER_CHECK */
1316
1317                   default:
1318                         syserr("X%s: unknown filter equate %c=",
1319                                m->mf_name, fcode);
1320                         break;
1321                 }
1322                 p = delimptr;
1323         }
1324
1325         /* early check for errors */
1326         (void) milter_open(m, true, CurEnv);
1327
1328         /* enter the filter into the symbol table */
1329         s = stab(m->mf_name, ST_MILTER, ST_ENTER);
1330         if (s->s_milter != NULL)
1331                 syserr("X%s: duplicate filter definition", m->mf_name);
1332         else
1333         {
1334                 s->s_milter = m;
1335                 m->mf_idx = ++idx;
1336         }
1337 }
1338
1339 /*
1340 **  MILTER_CONFIG -- parse option list into an array and check config
1341 **
1342 **      Called when reading configuration file.
1343 **
1344 **      Parameters:
1345 **              spec -- the filter list.
1346 **              list -- the array to fill in.
1347 **              max -- the maximum number of entries in list.
1348 **
1349 **      Returns:
1350 **              none
1351 */
1352
1353 void
1354 milter_config(spec, list, max)
1355         char *spec;
1356         struct milter **list;
1357         int max;
1358 {
1359         int numitems = 0;
1360         char *p;
1361
1362         /* leave one for the NULL signifying the end of the list */
1363         max--;
1364
1365         for (p = spec; p != NULL; )
1366         {
1367                 STAB *s;
1368
1369                 while (SM_ISSPACE(*p))
1370                         p++;
1371                 if (*p == '\0')
1372                         break;
1373                 spec = p;
1374
1375                 if (numitems >= max)
1376                 {
1377                         syserr("Too many filters defined, %d max", max);
1378                         if (max > 0)
1379                                 list[0] = NULL;
1380                         return;
1381                 }
1382                 p = strpbrk(p, ";,");
1383                 if (p != NULL)
1384                         *p++ = '\0';
1385
1386                 s = stab(spec, ST_MILTER, ST_FIND);
1387                 if (s == NULL)
1388                 {
1389                         syserr("InputFilter %s not defined", spec);
1390                         ExitStat = EX_CONFIG;
1391                         return;
1392                 }
1393                 list[numitems++] = s->s_milter;
1394         }
1395         list[numitems] = NULL;
1396
1397         /* if not set, set to LogLevel */
1398         if (MilterLogLevel == -1)
1399                 MilterLogLevel = LogLevel;
1400 }
1401
1402 /*
1403 **  MILTER_PARSE_TIMEOUTS -- parse timeout list
1404 **
1405 **      Called when reading configuration file.
1406 **
1407 **      Parameters:
1408 **              spec -- the timeout list.
1409 **              m -- milter to set.
1410 **
1411 **      Returns:
1412 **              none
1413 */
1414
1415 static void
1416 milter_parse_timeouts(spec, m)
1417         char *spec;
1418         struct milter *m;
1419 {
1420         char fcode;
1421         int tcode;
1422         char *p;
1423
1424         p = spec;
1425
1426         /* now scan through and assign info from the fields */
1427         while (*p != '\0')
1428         {
1429                 char *delimptr;
1430
1431                 while (*p != '\0' && (*p == ';' || (SM_ISSPACE(*p))))
1432                         p++;
1433
1434                 /* p now points to field code */
1435                 fcode = *p;
1436                 while (*p != '\0' && *p != ':')
1437                         p++;
1438                 if (*p++ != ':')
1439                 {
1440                         syserr("X%s, T=: `:' expected", m->mf_name);
1441                         return;
1442                 }
1443                 while (SM_ISSPACE(*p))
1444                         p++;
1445
1446                 /* p now points to the field body */
1447                 p = munchstring(p, &delimptr, ';');
1448                 tcode = -1;
1449
1450                 /* install the field into the filter struct */
1451                 switch (fcode)
1452                 {
1453                   case 'C':
1454                         tcode = SMFTO_CONNECT;
1455                         break;
1456
1457                   case 'S':
1458                         tcode = SMFTO_WRITE;
1459                         break;
1460
1461                   case 'R':
1462                         tcode = SMFTO_READ;
1463                         break;
1464
1465                   case 'E':
1466                         tcode = SMFTO_EOM;
1467                         break;
1468
1469                   default:
1470                         if (tTd(64, 5))
1471                                 sm_dprintf("X%s: %c unknown\n",
1472                                            m->mf_name, fcode);
1473                         syserr("X%s: unknown filter timeout %c",
1474                                m->mf_name, fcode);
1475                         break;
1476                 }
1477                 if (tcode >= 0)
1478                 {
1479                         m->mf_timeout[tcode] = convtime(p, 's');
1480                         if (tTd(64, 5))
1481                                 sm_dprintf("X%s: %c=%ld\n",
1482                                            m->mf_name, fcode,
1483                                            (u_long) m->mf_timeout[tcode]);
1484                 }
1485                 p = delimptr;
1486         }
1487 }
1488
1489 /*
1490 **  MILTER_SET_MACROS -- set milter macros
1491 **
1492 **      Parameters:
1493 **              name -- name of milter.
1494 **              macros -- where to store macros.
1495 **              val -- the value of the option.
1496 **              nummac -- current number of macros
1497 **
1498 **      Returns:
1499 **              new number of macros
1500 */
1501
1502 static int
1503 milter_set_macros(name, macros, val, nummac)
1504         char *name;
1505         char **macros;
1506         char *val;
1507         int nummac;
1508 {
1509         char *p;
1510
1511         p = newstr(val);
1512         while (*p != '\0')
1513         {
1514                 char *macro;
1515
1516                 /* Skip leading commas, spaces */
1517                 while (*p != '\0' && (*p == ',' || (SM_ISSPACE(*p))))
1518                         p++;
1519
1520                 if (*p == '\0')
1521                         break;
1522
1523                 /* Find end of macro */
1524                 macro = p;
1525                 while (*p != '\0' && *p != ',' &&
1526                        isascii(*p) && !isspace(*p))
1527                         p++;
1528                 if (*p != '\0')
1529                         *p++ = '\0';
1530
1531                 if (nummac >= MAXFILTERMACROS)
1532                 {
1533                         syserr("milter_set_option: too many macros in Milter.%s (max %d)",
1534                                name, MAXFILTERMACROS);
1535                         macros[nummac] = NULL;
1536                         return -1;
1537                 }
1538                 macros[nummac++] = macro;
1539         }
1540         macros[nummac] = NULL;
1541         return nummac;
1542 }
1543
1544 /*
1545 **  MILTER_SET_OPTION -- set an individual milter option
1546 **
1547 **      Parameters:
1548 **              name -- the name of the option.
1549 **              val -- the value of the option.
1550 **              sticky -- if set, don't let other setoptions override
1551 **                      this value.
1552 **
1553 **      Returns:
1554 **              none.
1555 */
1556
1557 /* set if Milter sub-option is stuck */
1558 static BITMAP256        StickyMilterOpt;
1559
1560 static struct milteropt
1561 {
1562         char            *mo_name;       /* long name of milter option */
1563         unsigned char   mo_code;        /* code for option */
1564 } MilterOptTab[] =
1565 {
1566         { "macros.connect",             SMFIM_CONNECT                   },
1567         { "macros.helo",                SMFIM_HELO                      },
1568         { "macros.envfrom",             SMFIM_ENVFROM                   },
1569         { "macros.envrcpt",             SMFIM_ENVRCPT                   },
1570         { "macros.data",                SMFIM_DATA                      },
1571         { "macros.eom",                 SMFIM_EOM                       },
1572         { "macros.eoh",                 SMFIM_EOH                       },
1573
1574 # define MO_LOGLEVEL                    0x07
1575         { "loglevel",                   MO_LOGLEVEL                     },
1576 # if _FFR_MAXDATASIZE || _FFR_MDS_NEGOTIATE
1577 #  define MO_MAXDATASIZE                0x08
1578         { "maxdatasize",                MO_MAXDATASIZE                  },
1579 # endif
1580         { NULL,                         (unsigned char)-1               },
1581 };
1582
1583 void
1584 milter_set_option(name, val, sticky)
1585         char *name;
1586         char *val;
1587         bool sticky;
1588 {
1589         int nummac, r;
1590         struct milteropt *mo;
1591         char **macros = NULL;
1592
1593         nummac = 0;
1594         if (tTd(37, 2) || tTd(64, 5))
1595                 sm_dprintf("milter_set_option(%s = %s)", name, val);
1596
1597         if (name == NULL)
1598         {
1599                 syserr("milter_set_option: invalid Milter option, must specify suboption");
1600                 return;
1601         }
1602
1603         for (mo = MilterOptTab; mo->mo_name != NULL; mo++)
1604         {
1605                 if (SM_STRCASEEQ(mo->mo_name, name))
1606                         break;
1607         }
1608
1609         if (mo->mo_name == NULL)
1610         {
1611                 syserr("milter_set_option: invalid Milter option %s", name);
1612                 return;
1613         }
1614
1615         /*
1616         **  See if this option is preset for us.
1617         */
1618
1619         if (!sticky && bitnset(mo->mo_code, StickyMilterOpt))
1620         {
1621                 if (tTd(37, 2) || tTd(64,5))
1622                         sm_dprintf(" (ignored)\n");
1623                 return;
1624         }
1625
1626         if (tTd(37, 2) || tTd(64,5))
1627                 sm_dprintf("\n");
1628
1629         switch (mo->mo_code)
1630         {
1631           case MO_LOGLEVEL:
1632                 MilterLogLevel = atoi(val);
1633                 break;
1634
1635 # if _FFR_MAXDATASIZE || _FFR_MDS_NEGOTIATE
1636           case MO_MAXDATASIZE:
1637 #  if _FFR_MDS_NEGOTIATE
1638                 MilterMaxDataSize = (size_t)atol(val);
1639                 if (MilterMaxDataSize != MILTER_MDS_64K &&
1640                     MilterMaxDataSize != MILTER_MDS_256K &&
1641                     MilterMaxDataSize != MILTER_MDS_1M)
1642                 {
1643                         sm_syslog(LOG_WARNING, NOQID,
1644                                 "WARNING: Milter.%s=%lu, allowed are only %d, %d, and %d",
1645                                 name, (unsigned long) MilterMaxDataSize,
1646                                 MILTER_MDS_64K, MILTER_MDS_256K,
1647                                 MILTER_MDS_1M);
1648                         if (MilterMaxDataSize < MILTER_MDS_64K)
1649                                 MilterMaxDataSize = MILTER_MDS_64K;
1650                         else if (MilterMaxDataSize < MILTER_MDS_256K)
1651                                 MilterMaxDataSize = MILTER_MDS_256K;
1652                         else
1653                                 MilterMaxDataSize = MILTER_MDS_1M;
1654                 }
1655 #  endif /* _FFR_MDS_NEGOTIATE */
1656                 break;
1657 # endif /* _FFR_MAXDATASIZE || _FFR_MDS_NEGOTIATE */
1658
1659           case SMFIM_CONNECT:
1660           case SMFIM_HELO:
1661           case SMFIM_ENVFROM:
1662           case SMFIM_ENVRCPT:
1663           case SMFIM_EOH:
1664           case SMFIM_EOM:
1665           case SMFIM_DATA:
1666                 macros = MilterMacros[mo->mo_code][0];
1667
1668                 r = milter_set_macros(name, macros, val, nummac);
1669                 if (r >= 0)
1670                         nummac = r;
1671                 break;
1672
1673           default:
1674                 syserr("milter_set_option: invalid Milter option %s", name);
1675                 break;
1676         }
1677         if (sticky)
1678                 setbitn(mo->mo_code, StickyMilterOpt);
1679 }
1680
1681 /*
1682 **  MILTER_REOPEN_DF -- open & truncate the data file (for replbody)
1683 **
1684 **      Parameters:
1685 **              e -- current envelope.
1686 **
1687 **      Returns:
1688 **              0 if successful, -1 otherwise
1689 */
1690
1691 static int
1692 milter_reopen_df(e)
1693         ENVELOPE *e;
1694 {
1695         char dfname[MAXPATHLEN];
1696
1697         (void) sm_strlcpy(dfname, queuename(e, DATAFL_LETTER), sizeof(dfname));
1698
1699         /*
1700         **  In SuperSafe == SAFE_REALLY mode, e->e_dfp is a read-only FP so
1701         **  close and reopen writable (later close and reopen
1702         **  read only again).
1703         **
1704         **  In SuperSafe != SAFE_REALLY mode, e->e_dfp still points at the
1705         **  buffered file I/O descriptor, still open for writing so there
1706         **  isn't any work to do here (except checking for consistency).
1707         */
1708
1709         if (SuperSafe == SAFE_REALLY)
1710         {
1711                 /* close read-only data file */
1712                 if (bitset(EF_HAS_DF, e->e_flags) && e->e_dfp != NULL)
1713                 {
1714                         SM_CLOSE_FP(e->e_dfp);
1715                         e->e_flags &= ~EF_HAS_DF;
1716                 }
1717
1718                 /* open writable */
1719                 if ((e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, dfname,
1720                                            SM_IO_RDWR_B, NULL)) == NULL)
1721                 {
1722                         MILTER_DF_ERROR("milter_reopen_df: sm_io_open %s: %s");
1723                         return -1;
1724                 }
1725         }
1726         else if (e->e_dfp == NULL)
1727         {
1728                 /* shouldn't happen */
1729                 errno = ENOENT;
1730                 MILTER_DF_ERROR("milter_reopen_df: NULL e_dfp (%s: %s)");
1731                 return -1;
1732         }
1733         return 0;
1734 }
1735
1736 /*
1737 **  MILTER_RESET_DF -- re-open read-only the data file (for replbody)
1738 **
1739 **      Parameters:
1740 **              e -- current envelope.
1741 **
1742 **      Returns:
1743 **              0 if successful, -1 otherwise
1744 */
1745
1746 static int
1747 milter_reset_df(e)
1748         ENVELOPE *e;
1749 {
1750         int afd;
1751         char dfname[MAXPATHLEN];
1752
1753         (void) sm_strlcpy(dfname, queuename(e, DATAFL_LETTER), sizeof(dfname));
1754
1755         if (sm_io_flush(e->e_dfp, SM_TIME_DEFAULT) != 0 ||
1756             sm_io_error(e->e_dfp))
1757         {
1758                 MILTER_DF_ERROR("milter_reset_df: error writing/flushing %s: %s");
1759                 return -1;
1760         }
1761         else if (SuperSafe != SAFE_REALLY)
1762         {
1763                 /* skip next few clauses */
1764                 /* EMPTY */
1765         }
1766         else if ((afd = sm_io_getinfo(e->e_dfp, SM_IO_WHAT_FD, NULL)) >= 0
1767                  && fsync(afd) < 0)
1768         {
1769                 MILTER_DF_ERROR("milter_reset_df: error sync'ing %s: %s");
1770                 return -1;
1771         }
1772         else if (sm_io_close(e->e_dfp, SM_TIME_DEFAULT) < 0)
1773         {
1774                 MILTER_DF_ERROR("milter_reset_df: error closing %s: %s");
1775                 return -1;
1776         }
1777         else if ((e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, dfname,
1778                                         SM_IO_RDONLY_B, NULL)) == NULL)
1779         {
1780                 MILTER_DF_ERROR("milter_reset_df: error reopening %s: %s");
1781                 return -1;
1782         }
1783         else
1784                 e->e_flags |= EF_HAS_DF;
1785         return 0;
1786 }
1787
1788 /*
1789 **  MILTER_QUIT_FILTER -- close down a single filter
1790 **
1791 **      Parameters:
1792 **              m -- milter structure of filter to close down.
1793 **              e -- current envelope.
1794 **
1795 **      Returns:
1796 **              none
1797 */
1798
1799 static void
1800 milter_quit_filter(m, e)
1801         struct milter *m;
1802         ENVELOPE *e;
1803 {
1804         if (tTd(64, 10))
1805                 sm_dprintf("milter_quit_filter(%s)\n", m->mf_name);
1806         if (MilterLogLevel > 18)
1807                 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): quit filter",
1808                           m->mf_name);
1809
1810         /* Never replace error state */
1811         if (m->mf_state == SMFS_ERROR)
1812                 return;
1813
1814         if (m->mf_sock < 0 ||
1815             m->mf_state == SMFS_CLOSED ||
1816             m->mf_state == SMFS_READY)
1817         {
1818                 m->mf_sock = -1;
1819                 m->mf_state = SMFS_CLOSED;
1820                 return;
1821         }
1822
1823         (void) milter_write(m, SMFIC_QUIT, (char *) NULL, 0,
1824                             m->mf_timeout[SMFTO_WRITE], e, "quit_filter");
1825         if (m->mf_sock >= 0)
1826         {
1827                 (void) close(m->mf_sock);
1828                 m->mf_sock = -1;
1829         }
1830         if (m->mf_state != SMFS_ERROR)
1831                 m->mf_state = SMFS_CLOSED;
1832 }
1833
1834 /*
1835 **  MILTER_ABORT_FILTER -- tell filter to abort current message
1836 **
1837 **      Parameters:
1838 **              m -- milter structure of filter to abort.
1839 **              e -- current envelope.
1840 **
1841 **      Returns:
1842 **              none
1843 */
1844
1845 static void
1846 milter_abort_filter(m, e)
1847         struct milter *m;
1848         ENVELOPE *e;
1849 {
1850         if (tTd(64, 10))
1851                 sm_dprintf("milter_abort_filter(%s)\n", m->mf_name);
1852         if (MilterLogLevel > 10)
1853                 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): abort filter",
1854                           m->mf_name);
1855
1856         if (m->mf_sock < 0 ||
1857             m->mf_state != SMFS_INMSG)
1858                 return;
1859
1860         (void) milter_write(m, SMFIC_ABORT, (char *) NULL, 0,
1861                             m->mf_timeout[SMFTO_WRITE], e, "abort_filter");
1862         if (m->mf_state != SMFS_ERROR)
1863                 m->mf_state = SMFS_DONE;
1864 }
1865
1866 /*
1867 **  MILTER_SEND_MACROS -- provide macros to the filters
1868 **
1869 **      Parameters:
1870 **              m -- milter to send macros to.
1871 **              macros -- macros to send for filter smfi_getsymval().
1872 **              cmd -- which command the macros are associated with.
1873 **              e -- current envelope (for macro access).
1874 **
1875 **      Returns:
1876 **              none
1877 */
1878
1879 #if _FFR_TESTS
1880 # define TST_EO \
1881         do      \
1882         {       \
1883                 if (tTd(86, 100) &&     \
1884                     (SMFIC_EOH == cmd || SMFIC_BODYEOB == cmd) &&       \
1885                     strncmp(macros[i], "{EO", 3) == 0)  \
1886                 {       \
1887                         if (SMFIC_EOH == cmd)   \
1888                                 v = "at_EOH";   \
1889                         else if (SMFIC_BODYEOB == cmd)  \
1890                                 v = "at_EOM";   \
1891                 }       \
1892         } while (0)
1893 #else
1894 # define TST_EO ((void) 0)
1895 #endif
1896
1897 static void
1898 milter_send_macros(m, macros, cmd, e)
1899         struct milter *m;
1900         char **macros;
1901         int cmd;
1902         ENVELOPE *e;
1903 {
1904         int i;
1905         int mid;
1906         char command = (char) cmd;
1907         char *v;
1908         char *buf, *bp;
1909         char exp[MAXLINE];
1910         ssize_t s;
1911
1912         /* sanity check */
1913         if (NULL == macros || NULL == macros[0])
1914                 return;
1915
1916         /* put together data */
1917         s = 1;                  /* for the command character */
1918         for (i = 0; macros[i] != NULL; i++)
1919         {
1920                 mid = macid(macros[i]);
1921                 if (mid == 0)
1922                         continue;
1923                 v = macvalue(mid, e);
1924                 TST_EO;
1925                 if (v == NULL)
1926                         continue;
1927                 expand(v, exp, sizeof(exp), e);
1928                 s += strlen(macros[i]) + 1 +
1929 # if _FFR_8BITENVADDR
1930                         ilenx(exp)
1931 # else
1932                         strlen(exp)
1933 # endif
1934                         + 1;
1935         }
1936
1937         if (s < 0)
1938                 return;
1939
1940         buf = (char *) xalloc(s);
1941         bp = buf;
1942         *bp++ = command;
1943         for (i = 0; macros[i] != NULL; i++)
1944         {
1945                 mid = macid(macros[i]);
1946                 if (mid == 0)
1947                         continue;
1948                 v = macvalue(mid, e);
1949                 TST_EO;
1950                 if (v == NULL)
1951                         continue;
1952                 expand(v, exp, sizeof(exp), e);
1953 # if _FFR_8BITENVADDR
1954                 dequote_internal_chars(exp, exp, sizeof(exp));
1955 # endif
1956
1957                 if (tTd(64, 10))
1958                         sm_dprintf("milter_send_macros(%s, %c): %s=%s\n",
1959                                 m->mf_name, command, macros[i], exp);
1960
1961                 (void) sm_strlcpy(bp, macros[i], s - (bp - buf));
1962                 bp += strlen(bp) + 1;
1963                 (void) sm_strlcpy(bp, exp, s - (bp - buf));
1964                 bp += strlen(bp) + 1;
1965         }
1966         (void) milter_write(m, SMFIC_MACRO, buf, s,
1967                             m->mf_timeout[SMFTO_WRITE], e, "send_macros");
1968         sm_free(buf);
1969 }
1970
1971 /*
1972 **  MILTER_SEND_COMMAND -- send a command and return the response for a filter
1973 **
1974 **      Parameters:
1975 **              m -- current milter filter
1976 **              cmd -- command to send.
1977 **              data -- optional command data.
1978 **              sz -- length of buf.
1979 **              e -- current envelope (for e->e_id).
1980 **              state -- return state word.
1981 **
1982 **      Returns:
1983 **              response string (may be NULL)
1984 */
1985
1986 static char *
1987 milter_send_command(m, cmd, data, sz, e, state, where)
1988         struct milter *m;
1989         int cmd;
1990         void *data;
1991         ssize_t sz;
1992         ENVELOPE *e;
1993         char *state;
1994         const char *where;
1995 {
1996         char rcmd;
1997         ssize_t rlen;
1998         unsigned long skipflag;
1999         unsigned long norespflag = 0;
2000         char command = (char) cmd;
2001         char *action;
2002         char *defresponse;
2003         char *response;
2004
2005         if (tTd(64, 10))
2006                 sm_dprintf("milter_send_command(%s): cmd %c len %ld\n",
2007                         m->mf_name, (char) command, (long) sz);
2008
2009         /* find skip flag and default failure */
2010         switch (command)
2011         {
2012           case SMFIC_CONNECT:
2013                 skipflag = SMFIP_NOCONNECT;
2014                 norespflag = SMFIP_NR_CONN;
2015                 action = "connect";
2016                 defresponse = "554 Command rejected";
2017                 break;
2018
2019           case SMFIC_HELO:
2020                 skipflag = SMFIP_NOHELO;
2021                 norespflag = SMFIP_NR_HELO;
2022                 action = "helo";
2023                 defresponse = "550 Command rejected";
2024                 break;
2025
2026           case SMFIC_MAIL:
2027                 skipflag = SMFIP_NOMAIL;
2028                 norespflag = SMFIP_NR_MAIL;
2029                 action = "mail";
2030                 defresponse = "550 5.7.1 Command rejected";
2031                 break;
2032
2033           case SMFIC_RCPT:
2034                 skipflag = SMFIP_NORCPT;
2035                 norespflag = SMFIP_NR_RCPT;
2036                 action = "rcpt";
2037                 defresponse = "550 5.7.1 Command rejected";
2038                 break;
2039
2040           case SMFIC_HEADER:
2041                 skipflag = SMFIP_NOHDRS;
2042                 norespflag = SMFIP_NR_HDR;
2043                 action = "header";
2044                 defresponse = "550 5.7.1 Command rejected";
2045                 break;
2046
2047           case SMFIC_BODY:
2048                 skipflag = SMFIP_NOBODY;
2049                 norespflag = SMFIP_NR_BODY;
2050                 action = "body";
2051                 defresponse = "554 5.7.1 Command rejected";
2052                 break;
2053
2054           case SMFIC_EOH:
2055                 skipflag = SMFIP_NOEOH;
2056                 norespflag = SMFIP_NR_EOH;
2057                 action = "eoh";
2058                 defresponse = "550 5.7.1 Command rejected";
2059                 break;
2060
2061           case SMFIC_UNKNOWN:
2062                 skipflag = SMFIP_NOUNKNOWN;
2063                 norespflag = SMFIP_NR_UNKN;
2064                 action = "unknown";
2065                 defresponse = "550 5.7.1 Command rejected";
2066                 break;
2067
2068           case SMFIC_DATA:
2069                 skipflag = SMFIP_NODATA;
2070                 norespflag = SMFIP_NR_DATA;
2071                 action = "data";
2072                 defresponse = "550 5.7.1 Command rejected";
2073                 break;
2074
2075           case SMFIC_BODYEOB:
2076           case SMFIC_OPTNEG:
2077           case SMFIC_MACRO:
2078           case SMFIC_ABORT:
2079           case SMFIC_QUIT:
2080                 /* NOTE: not handled by milter_send_command() */
2081                 /* FALLTHROUGH */
2082
2083           default:
2084                 skipflag = 0;
2085                 action = "default";
2086                 defresponse = "550 5.7.1 Command rejected";
2087                 break;
2088         }
2089
2090         if (tTd(64, 10))
2091                 sm_dprintf("milter_send_command(%s): skip=%lx, pflags=%x\n",
2092                         m->mf_name, skipflag, m->mf_pflags);
2093
2094         /* check if filter wants this command */
2095         if (skipflag != 0 && bitset(skipflag, m->mf_pflags))
2096                 return NULL;
2097
2098         /* send the command to the filter */
2099         (void) milter_write(m, command, data, sz,
2100                             m->mf_timeout[SMFTO_WRITE], e, where);
2101         if (m->mf_state == SMFS_ERROR)
2102         {
2103                 MILTER_CHECK_ERROR(false, return NULL);
2104                 return NULL;
2105         }
2106
2107         /* check if filter sends response to this command */
2108         if (norespflag != 0 && bitset(norespflag, m->mf_pflags))
2109                 return NULL;
2110
2111         /* get the response from the filter */
2112         response = milter_read(m, &rcmd, &rlen,
2113                                m->mf_timeout[SMFTO_READ], e, where);
2114         if (m->mf_state == SMFS_ERROR)
2115         {
2116                 MILTER_CHECK_ERROR(false, return NULL);
2117                 return NULL;
2118         }
2119
2120         if (tTd(64, 10))
2121                 sm_dprintf("milter_send_command(%s): returned %c\n",
2122                            m->mf_name, (char) rcmd);
2123
2124         switch (rcmd)
2125         {
2126           case SMFIR_REPLYCODE:
2127                 MILTER_CHECK_REPLYCODE(defresponse);
2128                 if (MilterLogLevel > 10)
2129                         sm_syslog(LOG_INFO, e->e_id,
2130                                   "milter=%s, action=%s, reject=%s",
2131                                   m->mf_name, action, response);
2132                 *state = rcmd;
2133                 break;
2134
2135           case SMFIR_REJECT:
2136                 if (MilterLogLevel > 10)
2137                         sm_syslog(LOG_INFO, e->e_id,
2138                                   "milter=%s, action=%s, reject",
2139                                   m->mf_name, action);
2140                 *state = rcmd;
2141                 break;
2142
2143           case SMFIR_DISCARD:
2144                 if (MilterLogLevel > 10)
2145                         sm_syslog(LOG_INFO, e->e_id,
2146                                   "milter=%s, action=%s, discard",
2147                                   m->mf_name, action);
2148                 *state = rcmd;
2149                 break;
2150
2151           case SMFIR_TEMPFAIL:
2152                 if (MilterLogLevel > 10)
2153                         sm_syslog(LOG_INFO, e->e_id,
2154                                   "milter=%s, action=%s, tempfail",
2155                                   m->mf_name, action);
2156                 *state = rcmd;
2157                 break;
2158
2159           case SMFIR_ACCEPT:
2160                 /* this filter is done with message/connection */
2161                 if (command == SMFIC_HELO ||
2162                     command == SMFIC_CONNECT)
2163                         m->mf_state = SMFS_CLOSABLE;
2164                 else
2165                         m->mf_state = SMFS_DONE;
2166                 if (MilterLogLevel > 10)
2167                         sm_syslog(LOG_INFO, e->e_id,
2168                                   "milter=%s, action=%s, accepted",
2169                                   m->mf_name, action);
2170                 break;
2171
2172           case SMFIR_CONTINUE:
2173                 /* if MAIL command is ok, filter is in message state */
2174                 if (command == SMFIC_MAIL)
2175                         m->mf_state = SMFS_INMSG;
2176                 if (MilterLogLevel > 12)
2177                         sm_syslog(LOG_INFO, e->e_id,
2178                                   "milter=%s, action=%s, continue",
2179                                   m->mf_name, action);
2180                 break;
2181
2182           case SMFIR_SKIP:
2183                 if (MilterLogLevel > 12)
2184                         sm_syslog(LOG_INFO, e->e_id,
2185                                   "milter=%s, action=%s, skip",
2186                                   m->mf_name, action);
2187                 m->mf_state = SMFS_SKIP;
2188                 break;
2189
2190           default:
2191                 /* Invalid response to command */
2192                 if (MilterLogLevel > 0)
2193                         sm_syslog(LOG_ERR, e->e_id,
2194                                   "milter_send_command(%s): action=%s returned bogus response %c",
2195                                   m->mf_name, action, rcmd);
2196                 milter_error(m, e); /* NO ERROR CHECK? */
2197                 break;
2198         }
2199
2200         if (*state != SMFIR_REPLYCODE && response != NULL)
2201         {
2202                 sm_free(response); /* XXX */
2203                 response = NULL;
2204         }
2205         return response;
2206 }
2207
2208 /*
2209 **  MILTER_COMMAND -- send a command and return the response for each filter
2210 **
2211 **      Parameters:
2212 **              cmd -- command to send.
2213 **              data -- optional command data.
2214 **              sz -- length of buf.
2215 **              stage -- index of macros to send for filter smfi_getsymval().
2216 **              e -- current envelope (for macro access).
2217 **              state -- return state word.
2218 **              where -- description of calling function (logging).
2219 **              cmd_error -- did the SMTP command cause an error?
2220 **
2221 **      Returns:
2222 **              response string (may be NULL)
2223 */
2224
2225 static char *
2226 milter_command(cmd, data, sz, stage, e, state, where, cmd_error)
2227         int cmd;
2228         void *data;
2229         ssize_t sz;
2230         int stage;
2231         ENVELOPE *e;
2232         char *state;
2233         const char *where;
2234         bool cmd_error;
2235 {
2236         int i;
2237         char command = (char) cmd;
2238         char *response = NULL;
2239         time_t tn = 0;
2240
2241         if (tTd(64, 10))
2242                 sm_dprintf("milter_command: cmd %c len %ld\n",
2243                         command, (long) sz);
2244
2245         *state = SMFIR_CONTINUE;
2246         for (i = 0; InputFilters[i] != NULL; i++)
2247         {
2248                 struct milter *m = InputFilters[i];
2249
2250                 /* previous problem? */
2251                 if (m->mf_state == SMFS_ERROR)
2252                 {
2253                         MILTER_CHECK_ERROR(false, continue);
2254                         break;
2255                 }
2256
2257                 /* sanity check */
2258                 if (m->mf_sock < 0 ||
2259                     (m->mf_state != SMFS_OPEN && m->mf_state != SMFS_INMSG))
2260                         continue;
2261
2262                 if (stage >= SMFIM_FIRST && stage <= SMFIM_LAST)
2263                 {
2264                         int idx;
2265                         char **macros;
2266
2267                         if ((m->mf_lflags & MI_LFLAGS_SYM(stage)) != 0)
2268                                 idx = m->mf_idx;
2269                         else
2270                                 idx = 0;
2271                         SM_ASSERT(idx >= 0 && idx <= MAXFILTERS);
2272                         macros = MilterMacros[stage][idx];
2273
2274                         /* send macros (regardless of whether we send cmd) */
2275                         if (macros != NULL && macros[0] != NULL)
2276                         {
2277                                 milter_send_macros(m, macros, command, e);
2278                                 if (m->mf_state == SMFS_ERROR)
2279                                 {
2280                                         MILTER_CHECK_ERROR(false, continue);
2281                                         break;
2282                                 }
2283                         }
2284                 }
2285
2286                 if (MilterLogLevel > 21)
2287                         tn = curtime();
2288
2289                 /*
2290                 **  send the command if
2291                 **      there is no error
2292                 **      or it's RCPT and the client asked for it:
2293                 **      !cmd_error ||
2294                 **      where == "rcpt" && m->mf_pflags & SMFIP_RCPT_REJ != 0
2295                 **  negate that condition and use continue
2296                 */
2297
2298                 if (cmd_error &&
2299                     (strcmp(where, "rcpt") != 0 ||
2300                      (m->mf_pflags & SMFIP_RCPT_REJ) == 0))
2301                         continue;
2302
2303                 response = milter_send_command(m, command, data, sz, e, state,
2304                                                 where);
2305
2306                 if (MilterLogLevel > 21)
2307                 {
2308                         /* log the time it took for the command per filter */
2309                         sm_syslog(LOG_INFO, e->e_id,
2310                                   "Milter (%s): time command (%c), %d",
2311                                   m->mf_name, command, (int) (curtime() - tn));
2312                 }
2313
2314                 if (*state != SMFIR_CONTINUE)
2315                         break;
2316         }
2317         return response;
2318 }
2319
2320 static int milter_getsymlist __P((struct milter *, char *, int, int));
2321
2322 static int
2323 milter_getsymlist(m, buf, rlen, offset)
2324         struct milter *m;
2325         char *buf;
2326         int rlen;
2327         int offset;
2328 {
2329         int i, r, nummac;
2330         mi_int32 v;
2331
2332         SM_ASSERT(m != NULL);
2333         SM_ASSERT(buf != NULL);
2334
2335         while (offset + MILTER_LEN_BYTES < rlen)
2336         {
2337                 size_t len;
2338                 char **macros;
2339
2340                 nummac = 0;
2341                 (void) memcpy((char *) &v, buf + offset, MILTER_LEN_BYTES);
2342                 i = ntohl(v);
2343                 if (i < SMFIM_FIRST || i > SMFIM_LAST)
2344                         return -1;
2345                 offset += MILTER_LEN_BYTES;
2346                 macros = NULL;
2347
2348 #define SM_M_MACRO_NAME(i) (((i) < SM_ARRAY_SIZE(MilterOptTab) && (i) >= 0) \
2349                                 ?  MilterOptTab[i].mo_name : "?")
2350                 switch (i)
2351                 {
2352                   case SMFIM_CONNECT:
2353                   case SMFIM_HELO:
2354                   case SMFIM_ENVFROM:
2355                   case SMFIM_ENVRCPT:
2356                   case SMFIM_EOH:
2357                   case SMFIM_EOM:
2358                   case SMFIM_DATA:
2359                         SM_ASSERT(m->mf_idx > 0 && m->mf_idx < MAXFILTERS);
2360                         macros = MilterMacros[i][m->mf_idx];
2361                         m->mf_lflags |= MI_LFLAGS_SYM(i);
2362                         len = strlen(buf + offset);
2363                         r = milter_set_macros(m->mf_name, macros, buf + offset,
2364                                         nummac);
2365                         if (r >= 0)
2366                                 nummac = r;
2367                         if (tTd(64, 5))
2368                                 sm_dprintf("milter_getsymlist(%s, %s, \"%s\")=%d\n",
2369                                         m->mf_name, SM_M_MACRO_NAME(i),
2370                                         buf + offset, r);
2371                         break;
2372
2373                   default:
2374                         return -1;
2375                 }
2376                 offset += len + 1;
2377         }
2378
2379         return 0;
2380 }
2381
2382 /*
2383 **  MILTER_NEGOTIATE -- get version and flags from filter
2384 **
2385 **      Parameters:
2386 **              m -- milter filter structure.
2387 **              e -- current envelope.
2388 **              milters -- milters structure.
2389 **
2390 **      Returns:
2391 **              0 on success, -1 otherwise
2392 */
2393
2394 static int
2395 milter_negotiate(m, e, milters)
2396         struct milter *m;
2397         ENVELOPE *e;
2398         milters_T *milters;
2399 {
2400         char rcmd;
2401         mi_int32 fvers, fflags, pflags;
2402         mi_int32 mta_prot_vers, mta_prot_flags, mta_actions;
2403         ssize_t rlen;
2404         char *response;
2405         char data[MILTER_OPTLEN];
2406
2407         /* sanity check */
2408         if (m->mf_sock < 0 || m->mf_state != SMFS_OPEN)
2409         {
2410                 if (MilterLogLevel > 0)
2411                         sm_syslog(LOG_ERR, e->e_id,
2412                                   "Milter (%s): negotiate, impossible state",
2413                                   m->mf_name);
2414                 milter_error(m, e);
2415                 return -1;
2416         }
2417
2418 # if _FFR_MILTER_CHECK
2419         mta_prot_vers = m->mf_mta_prot_version;
2420         mta_prot_flags = m->mf_mta_prot_flags;
2421         mta_actions = m->mf_mta_actions;
2422 # else /* _FFR_MILTER_CHECK */
2423         mta_prot_vers = SMFI_PROT_VERSION;
2424         mta_prot_flags = SMFI_CURR_PROT;
2425         mta_actions = SMFI_CURR_ACTS;
2426 # endif /* _FFR_MILTER_CHECK */
2427 # if _FFR_MDS_NEGOTIATE
2428         if (MilterMaxDataSize == MILTER_MDS_256K)
2429                 mta_prot_flags |= SMFIP_MDS_256K;
2430         else if (MilterMaxDataSize == MILTER_MDS_1M)
2431                 mta_prot_flags |= SMFIP_MDS_1M;
2432 # endif /* _FFR_MDS_NEGOTIATE */
2433
2434         fvers = htonl(mta_prot_vers);
2435         pflags = htonl(mta_prot_flags);
2436         fflags = htonl(mta_actions);
2437         (void) memcpy(data, (char *) &fvers, MILTER_LEN_BYTES);
2438         (void) memcpy(data + MILTER_LEN_BYTES,
2439                       (char *) &fflags, MILTER_LEN_BYTES);
2440         (void) memcpy(data + (MILTER_LEN_BYTES * 2),
2441                       (char *) &pflags, MILTER_LEN_BYTES);
2442         (void) milter_write(m, SMFIC_OPTNEG, data, sizeof(data),
2443                             m->mf_timeout[SMFTO_WRITE], e, "negotiate");
2444
2445         if (m->mf_state == SMFS_ERROR)
2446                 return -1;
2447
2448         if (tTd(64, 5))
2449                 sm_dprintf("milter_negotiate(%s): send: version %lu, fflags 0x%lx, pflags 0x%lx\n",
2450                         m->mf_name, (unsigned long) ntohl(fvers),
2451                         (unsigned long) ntohl(fflags),
2452                         (unsigned long) ntohl(pflags));
2453
2454         response = milter_read(m, &rcmd, &rlen, m->mf_timeout[SMFTO_READ], e,
2455                                 "negotiate");
2456         if (m->mf_state == SMFS_ERROR)
2457         {
2458                 SM_FREE(response);
2459                 return -1;
2460         }
2461
2462         if (rcmd != SMFIC_OPTNEG)
2463         {
2464                 if (tTd(64, 5))
2465                         sm_dprintf("milter_negotiate(%s): returned %c instead of %c\n",
2466                                 m->mf_name, rcmd, SMFIC_OPTNEG);
2467                 if (MilterLogLevel > 0)
2468                         sm_syslog(LOG_ERR, e->e_id,
2469                                   "Milter (%s): negotiate: returned %c instead of %c",
2470                                   m->mf_name, rcmd, SMFIC_OPTNEG);
2471                 SM_FREE(response);
2472                 milter_error(m, e);
2473                 return -1;
2474         }
2475
2476         /* Make sure we have enough bytes for the version */
2477         if (response == NULL || rlen < MILTER_LEN_BYTES)
2478         {
2479                 if (tTd(64, 5))
2480                         sm_dprintf("milter_negotiate(%s): did not return valid info\n",
2481                                 m->mf_name);
2482                 if (MilterLogLevel > 0)
2483                         sm_syslog(LOG_ERR, e->e_id,
2484                                   "Milter (%s): negotiate: did not return valid info",
2485                                   m->mf_name);
2486                 SM_FREE(response);
2487                 milter_error(m, e);
2488                 return -1;
2489         }
2490
2491         /* extract information */
2492         (void) memcpy((char *) &fvers, response, MILTER_LEN_BYTES);
2493
2494         /* Now make sure we have enough for the feature bitmap */
2495         if (rlen < MILTER_OPTLEN)
2496         {
2497                 if (tTd(64, 5))
2498                         sm_dprintf("milter_negotiate(%s): did not return enough info\n",
2499                                 m->mf_name);
2500                 if (MilterLogLevel > 0)
2501                         sm_syslog(LOG_ERR, e->e_id,
2502                                   "Milter (%s): negotiate: did not return enough info",
2503                                   m->mf_name);
2504                 SM_FREE(response);
2505                 milter_error(m, e);
2506                 return -1;
2507         }
2508
2509         (void) memcpy((char *) &fflags, response + MILTER_LEN_BYTES,
2510                       MILTER_LEN_BYTES);
2511         (void) memcpy((char *) &pflags, response + (MILTER_LEN_BYTES * 2),
2512                       MILTER_LEN_BYTES);
2513
2514         m->mf_fvers = ntohl(fvers);
2515         m->mf_fflags = ntohl(fflags);
2516         m->mf_pflags = ntohl(pflags);
2517
2518         /* check for version compatibility */
2519         if (m->mf_fvers == 1 ||
2520             m->mf_fvers > SMFI_VERSION)
2521         {
2522                 if (tTd(64, 5))
2523                         sm_dprintf("milter_negotiate(%s): version %d != MTA milter version %d\n",
2524                                 m->mf_name, m->mf_fvers, SMFI_VERSION);
2525                 if (MilterLogLevel > 0)
2526                         sm_syslog(LOG_ERR, e->e_id,
2527                                   "Milter (%s): negotiate: version %d != MTA milter version %d",
2528                                   m->mf_name, m->mf_fvers, SMFI_VERSION);
2529                 milter_error(m, e);
2530                 goto error;
2531         }
2532
2533         /* check for filter feature mismatch */
2534         if ((m->mf_fflags & mta_actions) != m->mf_fflags)
2535         {
2536                 if (tTd(64, 5))
2537                         sm_dprintf("milter_negotiate(%s): filter abilities 0x%x != MTA milter abilities 0x%lx\n",
2538                                 m->mf_name, m->mf_fflags,
2539                                 (unsigned long) mta_actions);
2540                 if (MilterLogLevel > 0)
2541                         sm_syslog(LOG_ERR, e->e_id,
2542                                   "Milter (%s): negotiate: filter abilities 0x%x != MTA milter abilities 0x%lx",
2543                                   m->mf_name, m->mf_fflags,
2544                                   (unsigned long) mta_actions);
2545                 milter_error(m, e);
2546                 goto error;
2547         }
2548
2549 # if _FFR_MDS_NEGOTIATE
2550 #  define MDSWARNING(sz) \
2551         do      \
2552         {       \
2553                 sm_syslog(LOG_WARNING, NOQID,   \
2554                           "WARNING: Milter.maxdatasize: configured=%lu, set by milter(%s)=%d",  \
2555                           (unsigned long) MilterMaxDataSize, m->mf_name, sz); \
2556                 MilterMaxDataSize = sz; \
2557         } while (0)
2558
2559         /* use a table instead of sequence? */
2560         if (bitset(SMFIP_MDS_1M, m->mf_pflags))
2561         {
2562                 if (MilterMaxDataSize != MILTER_MDS_1M)
2563                         MDSWARNING(MILTER_MDS_1M);
2564         }
2565         else if (bitset(SMFIP_MDS_256K, m->mf_pflags))
2566         {
2567                 if (MilterMaxDataSize != MILTER_MDS_256K)
2568                         MDSWARNING(MILTER_MDS_256K);
2569         }
2570
2571         /*
2572         **  Note: it is not possible to distinguish between
2573         **  - milter requested 64K
2574         **  - milter did not request anything
2575         **  as there is no SMFIP_MDS_64K flag.
2576         */
2577
2578         else if (MilterMaxDataSize != MILTER_MDS_64K)
2579                 MDSWARNING(MILTER_MDS_64K);
2580         m->mf_pflags &= ~SMFI_INTERNAL;
2581 # endif /* _FFR_MDS_NEGOTIATE */
2582
2583         /* check for protocol feature mismatch */
2584         if ((m->mf_pflags & mta_prot_flags) != m->mf_pflags)
2585         {
2586                 if (tTd(64, 5))
2587                         sm_dprintf("milter_negotiate(%s): protocol abilities 0x%x != MTA milter abilities 0x%lx\n",
2588                                 m->mf_name, m->mf_pflags,
2589                                 (unsigned long) mta_prot_flags);
2590                 if (MilterLogLevel > 0)
2591                         sm_syslog(LOG_ERR, e->e_id,
2592                                   "Milter (%s): negotiate: protocol abilities 0x%x != MTA milter abilities 0x%lx",
2593                                   m->mf_name, m->mf_pflags,
2594                                   (unsigned long) mta_prot_flags);
2595                 milter_error(m, e);
2596                 goto error;
2597         }
2598
2599         if (m->mf_fvers <= 2)
2600                 m->mf_pflags |= SMFIP_NOUNKNOWN;
2601         if (m->mf_fvers <= 3)
2602                 m->mf_pflags |= SMFIP_NODATA;
2603
2604         if (rlen > MILTER_OPTLEN)
2605         {
2606                 milter_getsymlist(m, response, rlen, MILTER_OPTLEN);
2607         }
2608
2609         if (bitset(SMFIF_DELRCPT, m->mf_fflags))
2610                 milters->mis_flags |= MIS_FL_DEL_RCPT;
2611         if (!bitset(SMFIP_NORCPT, m->mf_pflags) &&
2612             !bitset(SMFIP_NR_RCPT, m->mf_pflags))
2613                 milters->mis_flags |= MIS_FL_REJ_RCPT;
2614
2615         if (tTd(64, 5))
2616                 sm_dprintf("milter_negotiate(%s): received: version %u, fflags 0x%x, pflags 0x%x\n",
2617                         m->mf_name, m->mf_fvers, m->mf_fflags, m->mf_pflags);
2618         SM_FREE(response);
2619         return 0;
2620
2621   error:
2622         SM_FREE(response);
2623         return -1;
2624 }
2625
2626 /*
2627 **  MILTER_PER_CONNECTION_CHECK -- checks on per-connection commands
2628 **
2629 **      Reduce code duplication by putting these checks in one place
2630 **
2631 **      Parameters:
2632 **              e -- current envelope.
2633 **
2634 **      Returns:
2635 **              none
2636 */
2637
2638 static void
2639 milter_per_connection_check(e)
2640         ENVELOPE *e;
2641 {
2642         int i;
2643
2644         /* see if we are done with any of the filters */
2645         for (i = 0; InputFilters[i] != NULL; i++)
2646         {
2647                 struct milter *m = InputFilters[i];
2648
2649                 if (m->mf_state == SMFS_CLOSABLE)
2650                         milter_quit_filter(m, e);
2651         }
2652 }
2653
2654 /*
2655 **  MILTER_ERROR -- Put a milter filter into error state
2656 **
2657 **      Parameters:
2658 **              m -- the broken filter.
2659 **              e -- current envelope.
2660 **
2661 **      Returns:
2662 **              none
2663 */
2664
2665 static void
2666 milter_error(m, e)
2667         struct milter *m;
2668         ENVELOPE *e;
2669 {
2670         /*
2671         **  We could send a quit here but we may have gotten here due to
2672         **  an I/O error so we don't want to try to make things worse.
2673         */
2674
2675         if (m->mf_sock >= 0)
2676         {
2677                 (void) close(m->mf_sock);
2678                 m->mf_sock = -1;
2679         }
2680         m->mf_state = SMFS_ERROR;
2681
2682         if (MilterLogLevel > 0)
2683                 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): to error state",
2684                           m->mf_name);
2685 }
2686
2687 /*
2688 **  MILTER_HEADERS -- send headers to a single milter filter
2689 **
2690 **      Parameters:
2691 **              m -- current filter.
2692 **              e -- current envelope.
2693 **              state -- return state from response.
2694 **
2695 **      Returns:
2696 **              response string (may be NULL)
2697 */
2698
2699 static char *
2700 milter_headers(m, e, state)
2701         struct milter *m;
2702         ENVELOPE *e;
2703         char *state;
2704 {
2705         char *response = NULL;
2706         HDR *h;
2707
2708         if (MilterLogLevel > 17)
2709                 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): headers, send",
2710                           m->mf_name);
2711
2712         for (h = e->e_header; h != NULL; h = h->h_link)
2713         {
2714                 int len_n, len_v, len_t, len_f;
2715                 char *buf, *hv;
2716
2717                 /* don't send over deleted headers */
2718                 if (h->h_value == NULL)
2719                 {
2720                         /* strip H_USER so not counted in milter_changeheader() */
2721                         h->h_flags &= ~H_USER;
2722                         continue;
2723                 }
2724
2725                 /* skip auto-generated */
2726                 if (!bitset(H_USER, h->h_flags))
2727                         continue;
2728
2729                 if (tTd(64, 10))
2730                         sm_dprintf("milter_headers: %s:%s\n",
2731                                 h->h_field, h->h_value);
2732                 if (MilterLogLevel > 21)
2733                         sm_syslog(LOG_INFO, e->e_id, "Milter (%s): header, %s",
2734                                   m->mf_name, h->h_field);
2735
2736                 if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags)
2737                     || *(h->h_value) != ' ')
2738                         hv = h->h_value;
2739                 else
2740                         hv = h->h_value + 1;
2741                 len_f = strlen(h->h_field) + 1;
2742                 len_t = len_f + strlen(hv) + 1;
2743                 if (len_t < 0)
2744                         continue;
2745                 buf = (char *) xalloc(len_t);
2746
2747                 /*
2748                 **  Note: currently the call to dequote_internal_chars()
2749                 **  is not required as h_field is supposed to be 7-bit US-ASCII.
2750                 */
2751
2752                 len_n = dequote_internal_chars(h->h_field, buf, len_f);
2753                 SM_ASSERT(len_n < len_f);
2754                 len_v = dequote_internal_chars(hv, buf + len_n + 1,
2755                                                 len_t - len_n - 1);
2756                 SM_ASSERT(len_t >= len_n + 1 + len_v + 1);
2757                 len_t = len_n + 1 + len_v + 1;
2758
2759                 /* send it over */
2760                 response = milter_send_command(m, SMFIC_HEADER, buf,
2761                                                len_t, e, state, "header");
2762                 sm_free(buf);
2763                 if (m->mf_state == SMFS_ERROR ||
2764                     m->mf_state == SMFS_DONE ||
2765                     *state != SMFIR_CONTINUE)
2766                         break;
2767         }
2768         if (MilterLogLevel > 17)
2769                 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): headers, sent",
2770                           m->mf_name);
2771         return response;
2772 }
2773
2774 /*
2775 **  MILTER_BODY -- send the body to a filter
2776 **
2777 **      Parameters:
2778 **              m -- current filter.
2779 **              e -- current envelope.
2780 **              state -- return state from response.
2781 **
2782 **      Returns:
2783 **              response string (may be NULL)
2784 */
2785
2786 static char *
2787 milter_body(m, e, state)
2788         struct milter *m;
2789         ENVELOPE *e;
2790         char *state;
2791 {
2792         char bufchar = '\0';
2793         char prevchar = '\0';
2794         int c;
2795         char *response = NULL;
2796         char *bp;
2797         char buf[MILTER_CHUNK_SIZE];
2798
2799         if (tTd(64, 10))
2800                 sm_dprintf("milter_body\n");
2801
2802         if (bfrewind(e->e_dfp) < 0)
2803         {
2804                 ExitStat = EX_IOERR;
2805                 *state = SMFIR_TEMPFAIL;
2806                 syserr("milter_body: %s/%cf%s: rewind error",
2807                        qid_printqueue(e->e_qgrp, e->e_qdir),
2808                        DATAFL_LETTER, e->e_id);
2809                 return NULL;
2810         }
2811
2812         if (MilterLogLevel > 17)
2813                 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): body, send",
2814                           m->mf_name);
2815         bp = buf;
2816         while ((c = sm_io_getc(e->e_dfp, SM_TIME_DEFAULT)) != SM_IO_EOF)
2817         {
2818                 /*  Change LF to CRLF */
2819                 if (c == '\n')
2820                 {
2821 # if !_FFR_MILTER_CONVERT_ALL_LF_TO_CRLF
2822                         /* Not a CRLF already? */
2823                         if (prevchar != '\r')
2824 # endif
2825                         {
2826                                 /* Room for CR now? */
2827                                 if (bp + 2 > &buf[sizeof(buf)])
2828                                 {
2829                                         /* No room, buffer LF */
2830                                         bufchar = c;
2831
2832                                         /* and send CR now */
2833                                         c = '\r';
2834                                 }
2835                                 else
2836                                 {
2837                                         /* Room to do it now */
2838                                         *bp++ = '\r';
2839                                         prevchar = '\r';
2840                                 }
2841                         }
2842                 }
2843                 *bp++ = (char) c;
2844                 prevchar = c;
2845                 if (bp >= &buf[sizeof(buf)])
2846                 {
2847                         /* send chunk */
2848                         response = milter_send_command(m, SMFIC_BODY, buf,
2849                                                        bp - buf, e, state,
2850                                                         "body chunk");
2851                         bp = buf;
2852                         if (bufchar != '\0')
2853                         {
2854                                 *bp++ = bufchar;
2855                                 bufchar = '\0';
2856                                 prevchar = bufchar;
2857                         }
2858                 }
2859                 if (m->mf_state == SMFS_ERROR ||
2860                     m->mf_state == SMFS_DONE ||
2861                     m->mf_state == SMFS_SKIP ||
2862                     *state != SMFIR_CONTINUE)
2863                         break;
2864         }
2865
2866         /* check for read errors */
2867         if (sm_io_error(e->e_dfp))
2868         {
2869                 ExitStat = EX_IOERR;
2870                 if (*state == SMFIR_CONTINUE ||
2871                     *state == SMFIR_ACCEPT ||
2872                     m->mf_state == SMFS_SKIP)
2873                 {
2874                         *state = SMFIR_TEMPFAIL;
2875                         if (response != NULL)
2876                         {
2877                                 sm_free(response); /* XXX */
2878                                 response = NULL;
2879                         }
2880                 }
2881                 syserr("milter_body: %s/%cf%s: read error",
2882                        qid_printqueue(e->e_qgrp, e->e_qdir),
2883                        DATAFL_LETTER, e->e_id);
2884                 return response;
2885         }
2886
2887         /* send last body chunk */
2888         if (bp > buf &&
2889             m->mf_state != SMFS_ERROR &&
2890             m->mf_state != SMFS_DONE &&
2891             m->mf_state != SMFS_SKIP &&
2892             *state == SMFIR_CONTINUE)
2893         {
2894                 /* send chunk */
2895                 response = milter_send_command(m, SMFIC_BODY, buf, bp - buf,
2896                                                e, state, "last body chunk");
2897                 bp = buf;
2898         }
2899         if (MilterLogLevel > 17)
2900                 sm_syslog(LOG_INFO, e->e_id, "Milter (%s): body, sent",
2901                           m->mf_name);
2902         if (m->mf_state == SMFS_SKIP)
2903         {
2904                 *state = SMFIR_CONTINUE;
2905                 m->mf_state = SMFS_READY;
2906         }
2907
2908         return response;
2909 }
2910
2911 /*
2912 **  Actions
2913 */
2914
2915 /*
2916 **  ADDLEADINGSPACE -- Add a leading space to a string
2917 **
2918 **      Parameters:
2919 **              str -- string
2920 **              rp -- resource pool for allocations
2921 **
2922 **      Returns:
2923 **              pointer to new string
2924 */
2925
2926 static char *addleadingspace __P((char *, SM_RPOOL_T *));
2927
2928 static char *
2929 addleadingspace(str, rp)
2930         char *str;
2931         SM_RPOOL_T *rp;
2932 {
2933         size_t l;
2934         char *new;
2935
2936         SM_ASSERT(str != NULL);
2937         l = strlen(str);
2938         SM_ASSERT(l + 2 > l);
2939         new = sm_rpool_malloc_x(rp, l + 2);
2940         new[0] = ' ';
2941         new[1] = '\0';
2942         sm_strlcpy(new + 1, str, l + 1);
2943         return new;
2944 }
2945
2946 /*
2947 **  MILTER_ADDHEADER -- Add the supplied header to the message
2948 **
2949 **      Parameters:
2950 **              m -- current filter.
2951 **              response -- encoded form of header/value.
2952 **              rlen -- length of response.
2953 **              e -- current envelope.
2954 **
2955 **      Returns:
2956 **              none
2957 */
2958
2959 static void
2960 milter_addheader(m, response, rlen, e)
2961         struct milter *m;
2962         char *response;
2963         ssize_t rlen;
2964         ENVELOPE *e;
2965 {
2966         int mh_v_len;
2967         char *val, *mh_value;
2968         HDR *h;
2969
2970         if (tTd(64, 10))
2971                 sm_dprintf("milter_addheader: ");
2972
2973         /* sanity checks */
2974         if (response == NULL)
2975         {
2976                 if (tTd(64, 10))
2977                         sm_dprintf("NULL response\n");
2978                 return;
2979         }
2980
2981         if (rlen < 2 || strlen(response) + 1 >= (size_t) rlen)
2982         {
2983                 if (tTd(64, 10))
2984                         sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
2985                                    (int) strlen(response), (int) (rlen - 1));
2986                 return;
2987         }
2988
2989         /* Find separating NUL */
2990         val = response + strlen(response) + 1;
2991
2992         /* another sanity check */
2993         if (strlen(response) + strlen(val) + 2 != (size_t) rlen)
2994         {
2995                 if (tTd(64, 10))
2996                         sm_dprintf("didn't follow protocol (part len)\n");
2997                 return;
2998         }
2999
3000         if (*response == '\0')
3001         {
3002                 if (tTd(64, 10))
3003                         sm_dprintf("empty field name\n");
3004                 return;
3005         }
3006
3007         for (h = e->e_header; h != NULL; h = h->h_link)
3008         {
3009                 if (SM_STRCASEEQ(h->h_field, response) &&
3010                     !bitset(H_USER, h->h_flags) &&
3011                     !bitset(H_TRACE, h->h_flags))
3012                         break;
3013         }
3014
3015         mh_v_len = 0;
3016         mh_value = quote_internal_chars(val, NULL, &mh_v_len, NULL);
3017
3018         /* add to e_msgsize */
3019         e->e_msgsize += strlen(response) + 2 + strlen(val);
3020
3021         if (h != NULL)
3022         {
3023                 if (tTd(64, 10))
3024                         sm_dprintf("Replace default header %s value with %s\n",
3025                                    h->h_field, mh_value);
3026                 if (MilterLogLevel > 8)
3027                         sm_syslog(LOG_INFO, e->e_id,
3028                                   "Milter (%s) change: default header %s value with %s",
3029                                   m->mf_name, h->h_field, mh_value);
3030                 if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags))
3031                         h->h_value = mh_value;  /* XXX must be allocated from rpool? */
3032                 else
3033                 {
3034                         h->h_value = addleadingspace(mh_value, e->e_rpool);
3035                         SM_FREE(mh_value);
3036                 }
3037                 h->h_flags |= H_USER;
3038         }
3039         else
3040         {
3041                 if (tTd(64, 10))
3042                         sm_dprintf("Add %s: %s\n", response, mh_value);
3043                 if (MilterLogLevel > 8)
3044                         sm_syslog(LOG_INFO, e->e_id,
3045                                   "Milter (%s) add: header: %s: %s",
3046                                   m->mf_name, response, mh_value);
3047                 addheader(newstr(response), mh_value, H_USER, e,
3048                         !bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3049                 SM_FREE(mh_value);
3050         }
3051 }
3052
3053 /*
3054 **  MILTER_INSHEADER -- Insert the supplied header
3055 **
3056 **      Parameters:
3057 **              m -- current filter.
3058 **              response -- encoded form of header/value.
3059 **              rlen -- length of response.
3060 **              e -- current envelope.
3061 **
3062 **      Returns:
3063 **              none
3064 **
3065 **      Notes:
3066 **              Unlike milter_addheader(), this does not attempt to determine
3067 **              if the header already exists in the envelope, even a
3068 **              deleted version.  It just blindly inserts.
3069 */
3070
3071 static void
3072 milter_insheader(m, response, rlen, e)
3073         struct milter *m;
3074         char *response;
3075         ssize_t rlen;
3076         ENVELOPE *e;
3077 {
3078         mi_int32 idx, i;
3079         int mh_v_len;
3080         char *field, *val, *mh_value;
3081
3082         if (tTd(64, 10))
3083                 sm_dprintf("milter_insheader: ");
3084
3085         /* sanity checks */
3086         if (response == NULL)
3087         {
3088                 if (tTd(64, 10))
3089                         sm_dprintf("NULL response\n");
3090                 return;
3091         }
3092
3093         if (rlen < 2 || strlen(response) + 1 >= (size_t) rlen)
3094         {
3095                 if (tTd(64, 10))
3096                         sm_dprintf("didn't follow protocol (total len)\n");
3097                 return;
3098         }
3099
3100         /* decode */
3101         (void) memcpy((char *) &i, response, MILTER_LEN_BYTES);
3102         idx = ntohl(i);
3103         field = response + MILTER_LEN_BYTES;
3104         val = field + strlen(field) + 1;
3105
3106         /* another sanity check */
3107         if (MILTER_LEN_BYTES + strlen(field) + 1 +
3108             strlen(val) + 1 != (size_t) rlen)
3109         {
3110                 if (tTd(64, 10))
3111                         sm_dprintf("didn't follow protocol (part len)\n");
3112                 return;
3113         }
3114
3115         if (*field == '\0')
3116         {
3117                 if (tTd(64, 10))
3118                         sm_dprintf("empty field name\n");
3119                 return;
3120         }
3121
3122         /* add to e_msgsize */
3123         e->e_msgsize += strlen(response) + 2 + strlen(val);
3124
3125         if (tTd(64, 10))
3126                 sm_dprintf("Insert (%d) %s: %s\n", idx, field, val);
3127         if (MilterLogLevel > 8)
3128                 sm_syslog(LOG_INFO, e->e_id,
3129                           "Milter (%s) insert (%d): header: %s: %s",
3130                            m->mf_name, idx, field, val);
3131         mh_v_len = 0;
3132         mh_value = quote_internal_chars(val, NULL, &mh_v_len, NULL);
3133         insheader(idx, newstr(field), mh_value, H_USER, e,
3134                 !bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3135         SM_FREE(mh_value);
3136 }
3137
3138 /*
3139 **  MILTER_CHANGEHEADER -- Change the supplied header in the message
3140 **
3141 **      Parameters:
3142 **              m -- current filter.
3143 **              response -- encoded form of header/index/value.
3144 **              rlen -- length of response.
3145 **              e -- current envelope.
3146 **
3147 **      Returns:
3148 **              none
3149 */
3150
3151 static void
3152 milter_changeheader(m, response, rlen, e)
3153         struct milter *m;
3154         char *response;
3155         ssize_t rlen;
3156         ENVELOPE *e;
3157 {
3158         mi_int32 i, index;
3159         int mh_v_len;
3160         char *field, *val, *mh_value;
3161         HDR *h, *sysheader;
3162
3163         if (tTd(64, 10))
3164                 sm_dprintf("milter_changeheader: ");
3165
3166         /* sanity checks */
3167         if (response == NULL)
3168         {
3169                 if (tTd(64, 10))
3170                         sm_dprintf("NULL response\n");
3171                 return;
3172         }
3173
3174         if (rlen < 2 || strlen(response) + 1 >= (size_t) rlen)
3175         {
3176                 if (tTd(64, 10))
3177                         sm_dprintf("didn't follow protocol (total len)\n");
3178                 return;
3179         }
3180
3181         /* Find separating NUL */
3182         (void) memcpy((char *) &i, response, MILTER_LEN_BYTES);
3183         index = ntohl(i);
3184         field = response + MILTER_LEN_BYTES;
3185         val = field + strlen(field) + 1;
3186
3187         /* another sanity check */
3188         if (MILTER_LEN_BYTES + strlen(field) + 1 +
3189             strlen(val) + 1 != (size_t) rlen)
3190         {
3191                 if (tTd(64, 10))
3192                         sm_dprintf("didn't follow protocol (part len)\n");
3193                 return;
3194         }
3195
3196         if (*field == '\0')
3197         {
3198                 if (tTd(64, 10))
3199                         sm_dprintf("empty field name\n");
3200                 return;
3201         }
3202
3203         mh_v_len = 0;
3204         mh_value = quote_internal_chars(val, NULL, &mh_v_len, NULL);
3205
3206         sysheader = NULL;
3207         for (h = e->e_header; h != NULL; h = h->h_link)
3208         {
3209                 if (SM_STRCASEEQ(h->h_field, field))
3210                 {
3211                         if (bitset(H_USER, h->h_flags) && --index <= 0)
3212                         {
3213                                 sysheader = NULL;
3214                                 break;
3215                         }
3216                         else if (!bitset(H_USER, h->h_flags) &&
3217                                  !bitset(H_TRACE, h->h_flags))
3218                         {
3219                                 /*
3220                                 **  RFC 2822:
3221                                 **    27. No multiple occurrences of fields
3222                                 **        (except resent and received).*
3223                                 **  so make sure we replace any non-trace,
3224                                 **  non-user field.
3225                                 */
3226
3227                                 sysheader = h;
3228                         }
3229                 }
3230         }
3231
3232         /* if not found as user-provided header at index, use sysheader */
3233         if (h == NULL)
3234                 h = sysheader;
3235
3236         if (h == NULL)
3237         {
3238                 if (*val == '\0')
3239                 {
3240                         if (tTd(64, 10))
3241                                 sm_dprintf("Delete (noop) %s\n", field);
3242                         if (MilterLogLevel > 8)
3243                                 sm_syslog(LOG_INFO, e->e_id,
3244                                         "Milter (%s) delete (noop): header: %s"
3245                                         , m->mf_name, field);
3246                 }
3247                 else
3248                 {
3249                         /* treat modify value with no existing header as add */
3250                         if (tTd(64, 10))
3251                                 sm_dprintf("Add %s: %s\n", field, mh_value);
3252                         if (MilterLogLevel > 8)
3253                                 sm_syslog(LOG_INFO, e->e_id,
3254                                         "Milter (%s) change (add): header: %s: %s"
3255                                         , m->mf_name, field, mh_value);
3256                         addheader(newstr(field), mh_value, H_USER, e,
3257                                 !bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3258                 }
3259                 SM_FREE(mh_value);
3260                 return;
3261         }
3262
3263         if (tTd(64, 10))
3264         {
3265                 if (*val == '\0')
3266                 {
3267                         sm_dprintf("Delete%s %s:%s\n",
3268                                    h == sysheader ? " (default header)" : "",
3269                                    field,
3270                                    h->h_value == NULL ? "<NULL>" : h->h_value);
3271                 }
3272                 else
3273                 {
3274                         sm_dprintf("Change%s %s: from %s to %s\n",
3275                                    h == sysheader ? " (default header)" : "",
3276                                    field,
3277                                    h->h_value == NULL ? "<NULL>" : h->h_value,
3278                                    mh_value);
3279                 }
3280         }
3281
3282         if (MilterLogLevel > 8)
3283         {
3284                 if (*val == '\0')
3285                 {
3286                         sm_syslog(LOG_INFO, e->e_id,
3287                                   "Milter (%s) delete: header%s %s:%s",
3288                                   m->mf_name,
3289                                   h == sysheader ? " (default header)" : "",
3290                                   field,
3291                                   h->h_value == NULL ? "<NULL>" : h->h_value);
3292                 }
3293                 else
3294                 {
3295                         sm_syslog(LOG_INFO, e->e_id,
3296                                   "Milter (%s) change: header%s %s: from %s to %s",
3297                                   m->mf_name,
3298                                   h == sysheader ? " (default header)" : "",
3299                                   field,
3300                                   h->h_value == NULL ? "<NULL>" : h->h_value,
3301                                   mh_value);
3302                 }
3303         }
3304
3305         if (h != sysheader && h->h_value != NULL)
3306         {
3307                 size_t l;
3308
3309                 l = strlen(h->h_value);
3310                 if (l > e->e_msgsize)
3311                         e->e_msgsize = 0;
3312                 else
3313                         e->e_msgsize -= l;
3314                 /* rpool, don't free: sm_free(h->h_value); XXX */
3315         }
3316
3317         if (*val == '\0')
3318         {
3319                 /* Remove "Field: " from message size */
3320                 if (h != sysheader)
3321                 {
3322                         size_t l;
3323
3324                         l = strlen(h->h_field) + 2;
3325                         if (l > e->e_msgsize)
3326                                 e->e_msgsize = 0;
3327                         else
3328                                 e->e_msgsize -= l;
3329                 }
3330                 h->h_value = NULL;
3331                 SM_FREE(mh_value);
3332         }
3333         else
3334         {
3335                 if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags))
3336                         h->h_value = mh_value;  /* XXX must be allocated from rpool? */
3337                 else
3338                 {
3339                         h->h_value = addleadingspace(mh_value, e->e_rpool);
3340                         SM_FREE(mh_value);
3341                 }
3342                 h->h_flags |= H_USER;
3343                 e->e_msgsize += strlen(h->h_value);
3344         }
3345 }
3346
3347 /*
3348 **  MILTER_SPLIT_RESPONSE -- Split response into fields.
3349 **
3350 **      Parameters:
3351 **              response -- encoded response.
3352 **              rlen -- length of response.
3353 **              pargc -- number of arguments (output)
3354 **
3355 **      Returns:
3356 **              array of pointers to the individual strings
3357 */
3358
3359 static char **milter_split_response __P((char *, ssize_t, int *));
3360
3361 static char **
3362 milter_split_response(response, rlen, pargc)
3363         char *response;
3364         ssize_t rlen;
3365         int *pargc;
3366 {
3367         char **s;
3368         size_t i;
3369         int elem, nelem;
3370
3371         SM_ASSERT(response != NULL);
3372         SM_ASSERT(pargc != NULL);
3373         *pargc = 0;
3374         if (rlen < 2 || strlen(response) >= (size_t) rlen)
3375         {
3376                 if (tTd(64, 10))
3377                         sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3378                                    (int) strlen(response), (int) (rlen - 1));
3379                 return NULL;
3380         }
3381
3382         nelem = 0;
3383         for (i = 0; i < rlen; i++)
3384         {
3385                 if (response[i] == '\0')
3386                         ++nelem;
3387         }
3388         if (nelem == 0)
3389                 return NULL;
3390
3391         /* last entry is only for the name */
3392         s = (char **)malloc((nelem + 1) * (sizeof(*s)));
3393         if (s == NULL)
3394                 return NULL;
3395         s[0] = response;
3396         for (i = 0, elem = 0; i < rlen && elem < nelem; i++)
3397         {
3398                 if (response[i] == '\0')
3399                 {
3400                         ++elem;
3401                         if (i + 1 >= rlen)
3402                                 s[elem] = NULL;
3403                         else
3404                                 s[elem] = &(response[i + 1]);
3405                 }
3406         }
3407         *pargc = nelem;
3408
3409         if (tTd(64, 10))
3410         {
3411                 for (elem = 0; elem < nelem; elem++)
3412                         sm_dprintf("argv[%d]=\"%s\"\n", elem, s[elem]);
3413         }
3414
3415         /* overwrite last entry (already done above, just paranoia) */
3416         s[elem] = NULL;
3417         return s;
3418 }
3419
3420 /*
3421 **  MILTER_CHGFROM -- Change the envelope sender address
3422 **
3423 **      Parameters:
3424 **              response -- encoded form of recipient address.
3425 **              rlen -- length of response.
3426 **              e -- current envelope.
3427 **              mname -- name of milter.
3428 **
3429 **      Returns:
3430 **              none
3431 */
3432
3433 static void
3434 milter_chgfrom(response, rlen, e, mname)
3435         char *response;
3436         ssize_t rlen;
3437         ENVELOPE *e;
3438         const char *mname;
3439 {
3440         int olderrors, argc;
3441         char **argv;
3442
3443         if (tTd(64, 10))
3444                 sm_dprintf("milter_chgfrom: ");
3445
3446         /* sanity checks */
3447         if (response == NULL)
3448         {
3449                 if (tTd(64, 10))
3450                         sm_dprintf("NULL response\n");
3451                 return;
3452         }
3453
3454         if (*response == '\0' ||
3455             strlen(response) + 1 > (size_t) rlen)
3456         {
3457                 if (tTd(64, 10))
3458                         sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3459                                    (int) strlen(response), (int) (rlen - 1));
3460                 return;
3461         }
3462
3463         if (tTd(64, 10))
3464                 sm_dprintf("%s\n", response);
3465         if (MilterLogLevel > 8)
3466                 sm_syslog(LOG_INFO, e->e_id, "Milter (%s) chgfrom: %s",
3467                           mname, response);
3468         argv = milter_split_response(response, rlen, &argc);
3469         if (argc < 1 || argc > 2)
3470         {
3471                 if (tTd(64, 10))
3472                         sm_dprintf("didn't follow protocol argc=%d\n", argc);
3473                 if (argv != NULL)
3474                         free(argv);
3475                 return;
3476         }
3477
3478         olderrors = Errors;
3479         setsender(argv[0], e, NULL, '\0', false);
3480         if (argc == 2)
3481         {
3482                 reset_mail_esmtp_args(e);
3483
3484                 /*
3485                 **  need "features" here: how to get those? via e?
3486                 **  "fake" it for now: allow everything.
3487                 */
3488
3489                 parse_esmtp_args(e, NULL, argv[0], argv[1], "MAIL", NULL,
3490                                 mail_esmtp_args);
3491         }
3492         Errors = olderrors;
3493         free(argv);
3494         return;
3495 }
3496
3497 /*
3498 **  MILTER_ADDRCPT_PAR -- Add the supplied recipient to the message
3499 **
3500 **      Parameters:
3501 **              response -- encoded form of recipient address.
3502 **              rlen -- length of response.
3503 **              e -- current envelope.
3504 **              mname -- name of milter.
3505 **
3506 **      Returns:
3507 **              none
3508 */
3509
3510 static void
3511 milter_addrcpt_par(response, rlen, e, mname)
3512         char *response;
3513         ssize_t rlen;
3514         ENVELOPE *e;
3515         const char *mname;
3516 {
3517         int olderrors, argc;
3518         char *delimptr;
3519         char **argv;
3520         ADDRESS *a;
3521
3522         if (tTd(64, 10))
3523                 sm_dprintf("milter_addrcpt_par: ");
3524
3525         /* sanity checks */
3526         if (response == NULL)
3527         {
3528                 if (tTd(64, 10))
3529                         sm_dprintf("NULL response\n");
3530                 return;
3531         }
3532
3533         if (tTd(64, 10))
3534                 sm_dprintf("%s\n", response);
3535         if (MilterLogLevel > 8)
3536                 sm_syslog(LOG_INFO, e->e_id, "Milter (%s) add: rcpt: %s",
3537                           mname, response);
3538
3539         argv = milter_split_response(response, rlen, &argc);
3540         if (argc < 1 || argc > 2)
3541         {
3542                 if (tTd(64, 10))
3543                         sm_dprintf("didn't follow protocol argc=%d\n", argc);
3544                 if (argv != NULL)
3545                         free(argv);
3546                 return;
3547         }
3548         olderrors = Errors;
3549
3550         /* how to set ESMTP arguments? */
3551 /* XXX argv[0] must be [i] */
3552         a = parseaddr(argv[0], NULLADDR, RF_COPYALL, ' ', &delimptr, e, true);
3553
3554         if (a != NULL && olderrors == Errors)
3555         {
3556                 parse_esmtp_args(e, a, argv[0], argv[1], "RCPT", NULL,
3557                                 rcpt_esmtp_args);
3558                 if (olderrors == Errors)
3559                         a = recipient(a, &e->e_sendqueue, 0, e);
3560                 else
3561                         sm_dprintf("olderrors=%d, Errors=%d\n",
3562                                 olderrors, Errors);
3563         }
3564         else
3565         {
3566                 sm_dprintf("a=%p, olderrors=%d, Errors=%d\n",
3567                         (void *)a, olderrors, Errors);
3568         }
3569
3570         Errors = olderrors;
3571         free(argv);
3572         return;
3573 }
3574
3575 /*
3576 **  MILTER_ADDRCPT -- Add the supplied recipient to the message
3577 **
3578 **      Parameters:
3579 **              response -- encoded form of recipient address.
3580 **              rlen -- length of response.
3581 **              e -- current envelope.
3582 **              mname -- name of milter.
3583 **
3584 **      Returns:
3585 **              none
3586 */
3587
3588 static void
3589 milter_addrcpt(response, rlen, e, mname)
3590         char *response;
3591         ssize_t rlen;
3592         ENVELOPE *e;
3593         const char *mname;
3594 {
3595         int olderrors;
3596
3597         if (tTd(64, 10))
3598                 sm_dprintf("milter_addrcpt: ");
3599
3600         /* sanity checks */
3601         if (response == NULL)
3602         {
3603                 if (tTd(64, 10))
3604                         sm_dprintf("NULL response\n");
3605                 return;
3606         }
3607
3608         if (*response == '\0' ||
3609             strlen(response) + 1 != (size_t) rlen)
3610         {
3611                 if (tTd(64, 10))
3612                         sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3613                                    (int) strlen(response), (int) (rlen - 1));
3614                 return;
3615         }
3616
3617         if (tTd(64, 10))
3618                 sm_dprintf("%s\n", response);
3619         if (MilterLogLevel > 8)
3620                 sm_syslog(LOG_INFO, e->e_id, "Milter (%s) add: rcpt: %s",
3621                           mname, response);
3622         olderrors = Errors;
3623         (void) sendtolist(response, NULLADDR, &e->e_sendqueue, 0, e);
3624         Errors = olderrors;
3625         return;
3626 }
3627
3628 /*
3629 **  MILTER_DELRCPT -- Delete the supplied recipient from the message
3630 **
3631 **      Parameters:
3632 **              response -- encoded form of recipient address.
3633 **              rlen -- length of response.
3634 **              e -- current envelope.
3635 **              mname -- name of milter.
3636 **
3637 **      Returns:
3638 **              none
3639 */
3640
3641 static void
3642 milter_delrcpt(response, rlen, e, mname)
3643         char *response;
3644         ssize_t rlen;
3645         ENVELOPE *e;
3646         const char *mname;
3647 {
3648         int r;
3649
3650         if (tTd(64, 10))
3651                 sm_dprintf("milter_delrcpt: ");
3652
3653         /* sanity checks */
3654         if (response == NULL)
3655         {
3656                 if (tTd(64, 10))
3657                         sm_dprintf("NULL response\n");
3658                 return;
3659         }
3660
3661         if (*response == '\0' ||
3662             strlen(response) + 1 != (size_t) rlen)
3663         {
3664                 if (tTd(64, 10))
3665                         sm_dprintf("didn't follow protocol (total len %d != rlen %d)\n",
3666                                    (int) strlen(response), (int) (rlen - 1));
3667                 return;
3668         }
3669
3670         if (tTd(64, 10))
3671                 sm_dprintf("%s\n", response);
3672         r = removefromlist(response, &e->e_sendqueue, e);
3673         if (MilterLogLevel > 8)
3674                 sm_syslog(LOG_INFO, e->e_id, "Milter (%s) delete: rcpt %s, naddrs=%d",
3675                           mname, response, r);
3676         return;
3677 }
3678
3679 /*
3680 **  MILTER_REPLBODY -- Replace the current data file with new body
3681 **
3682 **      Parameters:
3683 **              response -- encoded form of new body.
3684 **              rlen -- length of response.
3685 **              newfilter -- if first time called by a new filter
3686 **              e -- current envelope.
3687 **              mname -- name of milter.
3688 **
3689 **      Returns:
3690 **              0 upon success, -1 upon failure
3691 */
3692
3693 static int
3694 milter_replbody(response, rlen, newfilter, e, mname)
3695         char *response;
3696         ssize_t rlen;
3697         bool newfilter;
3698         ENVELOPE *e;
3699         const char *mname;
3700 {
3701         static char prevchar;
3702         int i;
3703
3704         if (tTd(64, 10))
3705                 sm_dprintf("milter_replbody\n");
3706
3707         /* If a new filter, reset previous character and truncate data file */
3708         if (newfilter)
3709         {
3710                 off_t prevsize;
3711                 char dfname[MAXPATHLEN];
3712
3713                 (void) sm_strlcpy(dfname, queuename(e, DATAFL_LETTER),
3714                                   sizeof(dfname));
3715
3716                 /* Reset prevchar */
3717                 prevchar = '\0';
3718
3719                 /* Get the current data file information */
3720                 prevsize = sm_io_getinfo(e->e_dfp, SM_IO_WHAT_SIZE, NULL);
3721                 if (prevsize < 0)
3722                         prevsize = 0;
3723
3724                 /* truncate current data file */
3725                 if (sm_io_getinfo(e->e_dfp, SM_IO_WHAT_ISTYPE, BF_FILE_TYPE))
3726                 {
3727                         if (sm_io_setinfo(e->e_dfp, SM_BF_TRUNCATE, NULL) < 0)
3728                         {
3729                                 MILTER_DF_ERROR("milter_replbody: sm_io truncate %s: %s");
3730                                 return -1;
3731                         }
3732                 }
3733                 else
3734                 {
3735                         int err;
3736
3737                         err = sm_io_error(e->e_dfp);
3738                         (void) sm_io_flush(e->e_dfp, SM_TIME_DEFAULT);
3739
3740                         /*
3741                         **  Clear error if tried to fflush()
3742                         **  a read-only file pointer and
3743                         **  there wasn't a previous error.
3744                         */
3745
3746                         if (err == 0)
3747                                 sm_io_clearerr(e->e_dfp);
3748
3749                         /* errno is set implicitly by fseek() before return */
3750                         err = sm_io_seek(e->e_dfp, SM_TIME_DEFAULT,
3751                                          0, SEEK_SET);
3752                         if (err < 0)
3753                         {
3754                                 MILTER_DF_ERROR("milter_replbody: sm_io_seek %s: %s");
3755                                 return -1;
3756                         }
3757 # if NOFTRUNCATE
3758                         /* XXX: Not much we can do except rewind it */
3759                         errno = EINVAL;
3760                         MILTER_DF_ERROR("milter_replbody: ftruncate not available on this platform (%s:%s)");
3761                         return -1;
3762 # else /* NOFTRUNCATE */
3763                         err = ftruncate(sm_io_getinfo(e->e_dfp,
3764                                                       SM_IO_WHAT_FD, NULL),
3765                                         0);
3766                         if (err < 0)
3767                         {
3768                                 MILTER_DF_ERROR("milter_replbody: sm_io ftruncate %s: %s");
3769                                 return -1;
3770                         }
3771 # endif /* NOFTRUNCATE */
3772                 }
3773
3774                 if (prevsize > e->e_msgsize)
3775                         e->e_msgsize = 0;
3776                 else
3777                         e->e_msgsize -= prevsize;
3778         }
3779
3780         if (newfilter && MilterLogLevel > 8)
3781                 sm_syslog(LOG_INFO, e->e_id, "Milter (%s) message: body replaced",
3782                           mname);
3783
3784         if (response == NULL)
3785         {
3786                 /* Flush the buffered '\r' */
3787                 if (prevchar == '\r')
3788                 {
3789                         (void) sm_io_putc(e->e_dfp, SM_TIME_DEFAULT, prevchar);
3790                         e->e_msgsize++;
3791                 }
3792                 return 0;
3793         }
3794
3795         for (i = 0; i < rlen; i++)
3796         {
3797                 /* Buffered char from last chunk */
3798                 if (i == 0 && prevchar == '\r')
3799                 {
3800                         /* Not CRLF, output prevchar */
3801                         if (response[i] != '\n')
3802                         {
3803                                 (void) sm_io_putc(e->e_dfp, SM_TIME_DEFAULT,
3804                                                   prevchar);
3805                                 e->e_msgsize++;
3806                         }
3807                         prevchar = '\0';
3808                 }
3809
3810                 /* Turn CRLF into LF */
3811                 if (response[i] == '\r')
3812                 {
3813                         /* check if at end of chunk */
3814                         if (i + 1 < rlen)
3815                         {
3816                                 /* If LF, strip CR */
3817                                 if (response[i + 1] == '\n')
3818                                         i++;
3819                         }
3820                         else
3821                         {
3822                                 /* check next chunk */
3823                                 prevchar = '\r';
3824                                 continue;
3825                         }
3826                 }
3827                 (void) sm_io_putc(e->e_dfp, SM_TIME_DEFAULT, response[i]);
3828                 e->e_msgsize++;
3829         }
3830         return 0;
3831 }
3832
3833 /*
3834 **  MTA callouts
3835 */
3836
3837 /*
3838 **  MILTER_INIT -- open and negotiate with all of the filters
3839 **
3840 **      Parameters:
3841 **              e -- current envelope.
3842 **              state -- return state from response.
3843 **              milters -- milters structure.
3844 **
3845 **      Returns:
3846 **              true iff at least one filter is active
3847 */
3848
3849 /* ARGSUSED */
3850 bool
3851 milter_init(e, state, milters)
3852         ENVELOPE *e;
3853         char *state;
3854         milters_T *milters;
3855 {
3856         int i;
3857
3858         if (tTd(64, 10))
3859                 sm_dprintf("milter_init\n");
3860
3861         memset(milters, '\0', sizeof(*milters));
3862         *state = SMFIR_CONTINUE;
3863         if (InputFilters[0] == NULL)
3864         {
3865                 if (MilterLogLevel > 10)
3866                         sm_syslog(LOG_INFO, e->e_id,
3867                                   "Milter: no active filter");
3868                 return false;
3869         }
3870
3871         for (i = 0; InputFilters[i] != NULL; i++)
3872         {
3873                 struct milter *m = InputFilters[i];
3874
3875                 m->mf_sock = milter_open(m, false, e);
3876                 if (m->mf_state == SMFS_ERROR)
3877                 {
3878                         MILTER_CHECK_ERROR(true, continue);
3879                         break;
3880                 }
3881
3882                 if (m->mf_sock < 0 ||
3883                     milter_negotiate(m, e, milters) < 0 ||
3884                     m->mf_state == SMFS_ERROR)
3885                 {
3886                         if (tTd(64, 5))
3887                                 sm_dprintf("milter_init(%s): failed to %s\n",
3888                                            m->mf_name,
3889                                            m->mf_sock < 0 ? "open" :
3890                                                             "negotiate");
3891                         if (MilterLogLevel > 0)
3892                                 sm_syslog(LOG_ERR, e->e_id,
3893                                           "Milter (%s): init failed to %s",
3894                                           m->mf_name,
3895                                           m->mf_sock < 0 ? "open" :
3896                                                            "negotiate");
3897
3898                         /* if negotiation failure, close socket */
3899                         milter_error(m, e);
3900                         MILTER_CHECK_ERROR(true, continue);
3901                         continue;
3902                 }
3903                 if (MilterLogLevel > 9)
3904                         sm_syslog(LOG_INFO, e->e_id,
3905                                   "Milter (%s): init success to %s",
3906                                   m->mf_name,
3907                                   m->mf_sock < 0 ? "open" : "negotiate");
3908         }
3909
3910         /*
3911         **  If something temp/perm failed with one of the filters,
3912         **  we won't be using any of them, so clear any existing
3913         **  connections.
3914         */
3915
3916         if (*state != SMFIR_CONTINUE)
3917                 milter_quit(e);
3918
3919         return true;
3920 }
3921
3922 /*
3923 **  MILTER_CONNECT -- send connection info to milter filters
3924 **
3925 **      Parameters:
3926 **              hostname -- hostname of remote machine.
3927 **              addr -- address of remote machine.
3928 **              e -- current envelope.
3929 **              state -- return state from response.
3930 **
3931 **      Returns:
3932 **              response string (may be NULL)
3933 */
3934
3935 char *
3936 milter_connect(hostname, addr, e, state)
3937         char *hostname;
3938         SOCKADDR addr;
3939         ENVELOPE *e;
3940         char *state;
3941 {
3942         char family;
3943         unsigned short port;
3944         char *buf, *bp;
3945         char *response;
3946         char *sockinfo = NULL;
3947         ssize_t s;
3948 # if NETINET6
3949         char buf6[INET6_ADDRSTRLEN];
3950 # endif
3951
3952         if (tTd(64, 10))
3953                 sm_dprintf("milter_connect(%s)\n", hostname);
3954         if (MilterLogLevel > 9)
3955                 sm_syslog(LOG_INFO, e->e_id, "Milter: connect to filters");
3956
3957         /* gather data */
3958         switch (addr.sa.sa_family)
3959         {
3960 # if NETUNIX
3961           case AF_UNIX:
3962                 family = SMFIA_UNIX;
3963                 port = htons(0);
3964                 sockinfo = addr.sunix.sun_path;
3965                 break;
3966 # endif /* NETUNIX */
3967
3968 # if NETINET
3969           case AF_INET:
3970                 family = SMFIA_INET;
3971                 port = addr.sin.sin_port;
3972                 sockinfo = (char *) inet_ntoa(addr.sin.sin_addr);
3973                 break;
3974 # endif /* NETINET */
3975
3976 # if NETINET6
3977           case AF_INET6:
3978                 if (IN6_IS_ADDR_V4MAPPED(&addr.sin6.sin6_addr))
3979                         family = SMFIA_INET;
3980                 else
3981                         family = SMFIA_INET6;
3982                 port = addr.sin6.sin6_port;
3983                 sockinfo = anynet_ntop(&addr.sin6.sin6_addr, buf6,
3984                                        sizeof(buf6));
3985                 if (sockinfo == NULL)
3986                         sockinfo = "";
3987                 break;
3988 # endif /* NETINET6 */
3989
3990           default:
3991                 family = SMFIA_UNKNOWN;
3992                 break;
3993         }
3994
3995         s = strlen(hostname) + 1 + sizeof(family);
3996         if (family != SMFIA_UNKNOWN)
3997                 s += sizeof(port) + strlen(sockinfo) + 1;
3998
3999         buf = (char *) xalloc(s);
4000         bp = buf;
4001
4002         /* put together data */
4003         (void) memcpy(bp, hostname, strlen(hostname));
4004         bp += strlen(hostname);
4005         *bp++ = '\0';
4006         (void) memcpy(bp, &family, sizeof(family));
4007         bp += sizeof(family);
4008         if (family != SMFIA_UNKNOWN)
4009         {
4010                 (void) memcpy(bp, &port, sizeof(port));
4011                 bp += sizeof(port);
4012
4013                 /* include trailing '\0' */
4014                 (void) memcpy(bp, sockinfo, strlen(sockinfo) + 1);
4015         }
4016
4017         response = milter_command(SMFIC_CONNECT, buf, s, SMFIM_CONNECT,
4018                                 e, state, "connect", false);
4019         sm_free(buf); /* XXX */
4020
4021         /*
4022         **  If this message connection is done for,
4023         **  close the filters.
4024         */
4025
4026         if (*state != SMFIR_CONTINUE)
4027         {
4028                 if (MilterLogLevel > 9)
4029                         sm_syslog(LOG_INFO, e->e_id, "Milter: connect, ending");
4030                 milter_quit(e);
4031         }
4032         else
4033                 milter_per_connection_check(e);
4034
4035 # if !_FFR_MILTER_CONNECT_REPLYCODE
4036         /*
4037         **  SMFIR_REPLYCODE can't work with connect due to
4038         **  the requirements of SMTP.  Therefore, ignore the
4039         **  reply code text but keep the state it would reflect.
4040         */
4041
4042         if (*state == SMFIR_REPLYCODE)
4043         {
4044                 if (response != NULL &&
4045                     *response == '4')
4046                 {
4047                         if (strncmp(response, "421 ", 4) == 0)
4048                                 *state = SMFIR_SHUTDOWN;
4049                         else
4050                                 *state = SMFIR_TEMPFAIL;
4051                 }
4052                 else
4053                         *state = SMFIR_REJECT;
4054                 if (response != NULL)
4055                 {
4056                         sm_free(response); /* XXX */
4057                         response = NULL;
4058                 }
4059         }
4060 # endif /* !_FFR_MILTER_CONNECT_REPLYCODE */
4061         return response;
4062 }
4063
4064 /*
4065 **  MILTER_HELO -- send SMTP HELO/EHLO command info to milter filters
4066 **
4067 **      Parameters:
4068 **              helo -- argument to SMTP HELO/EHLO command.
4069 **              e -- current envelope.
4070 **              state -- return state from response.
4071 **
4072 **      Returns:
4073 **              response string (may be NULL)
4074 */
4075
4076 char *
4077 milter_helo(helo, e, state)
4078         char *helo;
4079         ENVELOPE *e;
4080         char *state;
4081 {
4082         int i;
4083         char *response;
4084
4085         if (tTd(64, 10))
4086                 sm_dprintf("milter_helo(%s)\n", helo);
4087
4088         /* HELO/EHLO can come at any point */
4089         for (i = 0; InputFilters[i] != NULL; i++)
4090         {
4091                 struct milter *m = InputFilters[i];
4092
4093                 switch (m->mf_state)
4094                 {
4095                   case SMFS_INMSG:
4096                         /* abort in message filters */
4097                         milter_abort_filter(m, e);
4098                         /* FALLTHROUGH */
4099
4100                   case SMFS_DONE:
4101                         /* reset done filters */
4102                         m->mf_state = SMFS_OPEN;
4103                         break;
4104                 }
4105         }
4106
4107         response = milter_command(SMFIC_HELO, helo, strlen(helo) + 1,
4108                                   SMFIM_HELO, e, state, "helo", false);
4109         milter_per_connection_check(e);
4110         return response;
4111 }
4112
4113 /*
4114 **  MILTER_ENVFROM -- send SMTP MAIL command info to milter filters
4115 **
4116 **      Parameters:
4117 **              args -- SMTP MAIL command args (args[0] == sender).
4118 **              e -- current envelope.
4119 **              state -- return state from response.
4120 **
4121 **      Returns:
4122 **              response string (may be NULL)
4123 */
4124
4125 char *
4126 milter_envfrom(args, e, state)
4127         char **args;
4128         ENVELOPE *e;
4129         char *state;
4130 {
4131         int i;
4132         char *buf, *bp;
4133         char *response;
4134         ssize_t s;
4135
4136         if (tTd(64, 10))
4137         {
4138                 sm_dprintf("milter_envfrom:");
4139                 for (i = 0; args[i] != NULL; i++)
4140                         sm_dprintf(" %s", args[i]);
4141                 sm_dprintf("\n");
4142         }
4143
4144         /* sanity check */
4145         if (args[0] == NULL)
4146         {
4147                 *state = SMFIR_REJECT;
4148                 if (MilterLogLevel > 10)
4149                         sm_syslog(LOG_INFO, e->e_id,
4150                                   "Milter: reject, no sender");
4151                 return NULL;
4152         }
4153
4154         /* new message, so ... */
4155         for (i = 0; InputFilters[i] != NULL; i++)
4156         {
4157                 struct milter *m = InputFilters[i];
4158
4159                 switch (m->mf_state)
4160                 {
4161                   case SMFS_INMSG:
4162                         /* abort in message filters */
4163                         milter_abort_filter(m, e);
4164                         /* FALLTHROUGH */
4165
4166                   case SMFS_DONE:
4167                         /* reset done filters */
4168                         m->mf_state = SMFS_OPEN;
4169                         break;
4170                 }
4171         }
4172
4173         /* put together data */
4174         s = 0;
4175         for (i = 0; args[i] != NULL; i++)
4176                 s += strlen(args[i]) + 1;
4177
4178         if (s < 0)
4179         {
4180                 *state = SMFIR_TEMPFAIL;
4181                 return NULL;
4182         }
4183
4184         buf = (char *) xalloc(s);
4185         bp = buf;
4186         for (i = 0; args[i] != NULL; i++)
4187         {
4188                 (void) sm_strlcpy(bp, args[i], s - (bp - buf));
4189                 bp += strlen(bp) + 1;
4190         }
4191
4192         if (MilterLogLevel > 14)
4193                 sm_syslog(LOG_INFO, e->e_id, "Milter: sender: %s", buf);
4194
4195         /* send it over */
4196         response = milter_command(SMFIC_MAIL, buf, s, SMFIM_ENVFROM,
4197                                 e, state, "mail", false);
4198         sm_free(buf); /* XXX */
4199
4200         /*
4201         **  If filter rejects/discards a per message command,
4202         **  abort the other filters since we are done with the
4203         **  current message.
4204         */
4205
4206         MILTER_CHECK_DONE_MSG();
4207         if (MilterLogLevel > 10 && *state == SMFIR_REJECT)
4208                 sm_syslog(LOG_INFO, e->e_id, "Milter: reject, sender");
4209         return response;
4210 }
4211
4212 /*
4213 **  MILTER_ENVRCPT -- send SMTP RCPT command info to milter filters
4214 **
4215 **      Parameters:
4216 **              args -- SMTP RCPT command args (args[0] == recipient).
4217 **              e -- current envelope.
4218 **              state -- return state from response.
4219 **              rcpt_error -- does RCPT have an error?
4220 **
4221 **      Returns:
4222 **              response string (may be NULL)
4223 */
4224
4225 char *
4226 milter_envrcpt(args, e, state, rcpt_error)
4227         char **args;
4228         ENVELOPE *e;
4229         char *state;
4230         bool rcpt_error;
4231 {
4232         int i;
4233         char *buf, *bp;
4234         char *response;
4235         ssize_t s;
4236
4237         if (tTd(64, 10))
4238         {
4239                 sm_dprintf("milter_envrcpt:");
4240                 for (i = 0; args[i] != NULL; i++)
4241                         sm_dprintf(" %s", args[i]);
4242                 sm_dprintf("\n");
4243         }
4244
4245         /* sanity check */
4246         if (args[0] == NULL)
4247         {
4248                 *state = SMFIR_REJECT;
4249                 if (MilterLogLevel > 10)
4250                         sm_syslog(LOG_INFO, e->e_id, "Milter: reject, no rcpt");
4251                 return NULL;
4252         }
4253
4254         /* put together data */
4255         s = 0;
4256         for (i = 0; args[i] != NULL; i++)
4257                 s += strlen(args[i]) + 1;
4258
4259         if (s < 0)
4260         {
4261                 *state = SMFIR_TEMPFAIL;
4262                 return NULL;
4263         }
4264
4265         buf = (char *) xalloc(s);
4266         bp = buf;
4267         for (i = 0; args[i] != NULL; i++)
4268         {
4269                 (void) sm_strlcpy(bp, args[i], s - (bp - buf));
4270                 bp += strlen(bp) + 1;
4271         }
4272
4273         if (MilterLogLevel > 14)
4274                 sm_syslog(LOG_INFO, e->e_id, "Milter: rcpts: %s", buf);
4275
4276         /* send it over */
4277         response = milter_command(SMFIC_RCPT, buf, s, SMFIM_ENVRCPT,
4278                                 e, state, "rcpt", rcpt_error);
4279         sm_free(buf); /* XXX */
4280         return response;
4281 }
4282
4283 /*
4284 **  MILTER_DATA_CMD -- send SMTP DATA command info to milter filters
4285 **
4286 **      Parameters:
4287 **              e -- current envelope.
4288 **              state -- return state from response.
4289 **
4290 **      Returns:
4291 **              response string (may be NULL)
4292 */
4293
4294 char *
4295 milter_data_cmd(e, state)
4296         ENVELOPE *e;
4297         char *state;
4298 {
4299         if (tTd(64, 10))
4300                 sm_dprintf("milter_data_cmd\n");
4301
4302         /* send it over */
4303         return milter_command(SMFIC_DATA, NULL, 0, SMFIM_DATA,
4304                                 e, state, "data", false);
4305 }
4306
4307 /*
4308 **  MILTER_DATA -- send message headers/body and gather final message results
4309 **
4310 **      Parameters:
4311 **              e -- current envelope.
4312 **              state -- return state from response.
4313 **
4314 **      Returns:
4315 **              response string (may be NULL)
4316 **
4317 **      Side effects:
4318 **              - Uses e->e_dfp for access to the body
4319 **              - Can call the various milter action routines to
4320 **                modify the envelope or message.
4321 */
4322
4323 /* flow through code using continue; don't wrap in do {} while */
4324 # define MILTER_CHECK_RESULTS() \
4325         if (m->mf_state == SMFS_ERROR && *state == SMFIR_CONTINUE) \
4326         { \
4327                         MILTER_SET_STATE;       \
4328         } \
4329         if (*state == SMFIR_ACCEPT || \
4330             m->mf_state == SMFS_DONE || \
4331             m->mf_state == SMFS_ERROR) \
4332         { \
4333                 if (m->mf_state != SMFS_ERROR) \
4334                         m->mf_state = SMFS_DONE; \
4335                 continue;       /* to next filter */ \
4336         } \
4337         if (*state != SMFIR_CONTINUE) \
4338         { \
4339                 m->mf_state = SMFS_DONE; \
4340                 goto finishup; \
4341         }
4342
4343 char *
4344 milter_data(e, state)
4345         ENVELOPE *e;
4346         char *state;
4347 {
4348         bool replbody = false;          /* milter_replbody() called? */
4349         bool replfailed = false;        /* milter_replbody() failed? */
4350         bool rewind = false;            /* rewind data file? */
4351         bool dfopen = false;            /* data file open for writing? */
4352         bool newfilter;                 /* reset on each new filter */
4353         char rcmd;
4354         int i;
4355         int save_errno;
4356         char *response = NULL;
4357         time_t eomsent;
4358         ssize_t rlen;
4359
4360         if (tTd(64, 10))
4361                 sm_dprintf("milter_data\n");
4362
4363         *state = SMFIR_CONTINUE;
4364
4365         /*
4366         **  XXX: Should actually send body chunks to each filter
4367         **  a chunk at a time instead of sending the whole body to
4368         **  each filter in turn.  However, only if the filters don't
4369         **  change the body.
4370         */
4371
4372         for (i = 0; InputFilters[i] != NULL; i++)
4373         {
4374                 int idx;
4375                 char **macros;
4376                 struct milter *m = InputFilters[i];
4377
4378                 if (*state != SMFIR_CONTINUE &&
4379                     *state != SMFIR_ACCEPT)
4380                 {
4381                         /*
4382                         **  A previous filter has dealt with the message,
4383                         **  safe to stop processing the filters.
4384                         */
4385
4386                         break;
4387                 }
4388
4389                 /* Now reset state for later evaluation */
4390                 *state = SMFIR_CONTINUE;
4391                 newfilter = true;
4392
4393                 /* previous problem? */
4394                 if (m->mf_state == SMFS_ERROR)
4395                 {
4396                         MILTER_CHECK_ERROR(false, continue);
4397                         break;
4398                 }
4399
4400                 /* sanity checks */
4401                 if (m->mf_sock < 0 ||
4402                     (m->mf_state != SMFS_OPEN && m->mf_state != SMFS_INMSG))
4403                         continue;
4404
4405                 m->mf_state = SMFS_INMSG;
4406
4407                 /* check if filter wants the headers */
4408                 if (!bitset(SMFIP_NOHDRS, m->mf_pflags))
4409                 {
4410                         response = milter_headers(m, e, state);
4411                         MILTER_CHECK_RESULTS();
4412                 }
4413
4414                 /* check if filter wants EOH */
4415                 if (!bitset(SMFIP_NOEOH, m->mf_pflags))
4416                 {
4417                         if (tTd(64, 10))
4418                                 sm_dprintf("milter_data: eoh\n");
4419
4420                         if ((m->mf_lflags & MI_LFLAGS_SYM(SMFIM_EOH)) != 0)
4421                                 idx = m->mf_idx;
4422                         else
4423                                 idx = 0;
4424                         SM_ASSERT(idx >= 0 && idx <= MAXFILTERS);
4425                         macros = MilterMacros[SMFIM_EOH][idx];
4426
4427                         if (macros != NULL)
4428                         {
4429                                 milter_send_macros(m, macros, SMFIC_EOH, e);
4430                                 MILTER_CHECK_RESULTS();
4431                         }
4432
4433                         /* send it over */
4434                         response = milter_send_command(m, SMFIC_EOH, NULL, 0,
4435                                                        e, state, "eoh");
4436                         MILTER_CHECK_RESULTS();
4437                 }
4438
4439                 /* check if filter wants the body */
4440                 if (!bitset(SMFIP_NOBODY, m->mf_pflags) &&
4441                     e->e_dfp != NULL)
4442                 {
4443                         rewind = true;
4444                         response = milter_body(m, e, state);
4445                         MILTER_CHECK_RESULTS();
4446                 }
4447
4448                 if ((m->mf_lflags & MI_LFLAGS_SYM(SMFIM_EOH)) != 0)
4449                         idx = m->mf_idx;
4450                 else
4451                         idx = 0;
4452                 SM_ASSERT(idx >= 0 && idx <= MAXFILTERS);
4453                 macros = MilterMacros[SMFIM_EOM][idx];
4454                 if (macros != NULL)
4455                 {
4456                         milter_send_macros(m, macros, SMFIC_BODYEOB, e);
4457                         MILTER_CHECK_RESULTS();
4458                 }
4459
4460                 /* send the final body chunk */
4461                 (void) milter_write(m, SMFIC_BODYEOB, NULL, 0,
4462                                     m->mf_timeout[SMFTO_WRITE], e, "eom");
4463
4464                 /* Get time EOM sent for timeout */
4465                 eomsent = curtime();
4466
4467                 /* deal with the possibility of multiple responses */
4468                 while (*state == SMFIR_CONTINUE)
4469                 {
4470                         /* Check total timeout from EOM to final ACK/NAK */
4471                         if (m->mf_timeout[SMFTO_EOM] > 0 &&
4472                             curtime() - eomsent >= m->mf_timeout[SMFTO_EOM])
4473                         {
4474                                 if (tTd(64, 5))
4475                                         sm_dprintf("milter_data(%s): EOM ACK/NAK timeout\n",
4476                                                 m->mf_name);
4477                                 if (MilterLogLevel > 0)
4478                                         sm_syslog(LOG_ERR, e->e_id,
4479                                                   "milter_data(%s): EOM ACK/NAK timeout",
4480                                                   m->mf_name);
4481                                 milter_error(m, e);
4482                                 MILTER_CHECK_ERROR(false, break);
4483                                 break;
4484                         }
4485
4486                         response = milter_read(m, &rcmd, &rlen,
4487                                                m->mf_timeout[SMFTO_READ], e,
4488                                                 "eom");
4489                         if (m->mf_state == SMFS_ERROR)
4490                                 break;
4491
4492                         if (tTd(64, 10))
4493                                 sm_dprintf("milter_data(%s): state %c\n",
4494                                            m->mf_name, (char) rcmd);
4495
4496                         switch (rcmd)
4497                         {
4498                           case SMFIR_REPLYCODE:
4499                                 MILTER_CHECK_REPLYCODE("554 5.7.1 Command rejected");
4500                                 if (MilterLogLevel > 12)
4501                                         sm_syslog(LOG_INFO, e->e_id, "milter=%s, reject=%s",
4502                                                   m->mf_name, response);
4503                                 *state = rcmd;
4504                                 m->mf_state = SMFS_DONE;
4505                                 break;
4506
4507                           case SMFIR_REJECT: /* log msg at end of function */
4508                                 if (MilterLogLevel > 12)
4509                                         sm_syslog(LOG_INFO, e->e_id, "milter=%s, reject",
4510                                                   m->mf_name);
4511                                 *state = rcmd;
4512                                 m->mf_state = SMFS_DONE;
4513                                 break;
4514
4515                           case SMFIR_DISCARD:
4516                                 if (MilterLogLevel > 12)
4517                                         sm_syslog(LOG_INFO, e->e_id, "milter=%s, discard",
4518                                                   m->mf_name);
4519                                 *state = rcmd;
4520                                 m->mf_state = SMFS_DONE;
4521                                 break;
4522
4523                           case SMFIR_TEMPFAIL:
4524                                 if (MilterLogLevel > 12)
4525                                         sm_syslog(LOG_INFO, e->e_id, "milter=%s, tempfail",
4526                                                   m->mf_name);
4527                                 *state = rcmd;
4528                                 m->mf_state = SMFS_DONE;
4529                                 break;
4530
4531                           case SMFIR_CONTINUE:
4532                           case SMFIR_ACCEPT:
4533                                 /* this filter is done with message */
4534                                 if (replfailed)
4535                                         *state = SMFIR_TEMPFAIL;
4536                                 else
4537                                         *state = SMFIR_ACCEPT;
4538                                 m->mf_state = SMFS_DONE;
4539                                 break;
4540
4541                           case SMFIR_PROGRESS:
4542                                 break;
4543
4544                           case SMFIR_QUARANTINE:
4545                                 if (!bitset(SMFIF_QUARANTINE, m->mf_fflags))
4546                                 {
4547                                         if (MilterLogLevel > 9)
4548                                                 sm_syslog(LOG_WARNING, e->e_id,
4549                                                           "milter_data(%s): lied about quarantining, honoring request anyway",
4550                                                           m->mf_name);
4551                                 }
4552                                 if (response == NULL)
4553                                         response = newstr("");
4554                                 if (MilterLogLevel > 3)
4555                                         sm_syslog(LOG_INFO, e->e_id,
4556                                                   "milter=%s, quarantine=%s",
4557                                                   m->mf_name, response);
4558                                 e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool,
4559                                                                  response);
4560                                 macdefine(&e->e_macro, A_PERM,
4561                                           macid("{quarantine}"), e->e_quarmsg);
4562                                 break;
4563
4564                           case SMFIR_ADDHEADER:
4565                                 if (!bitset(SMFIF_ADDHDRS, m->mf_fflags))
4566                                 {
4567                                         if (MilterLogLevel > 9)
4568                                                 sm_syslog(LOG_WARNING, e->e_id,
4569                                                           "milter_data(%s): lied about adding headers, honoring request anyway",
4570                                                           m->mf_name);
4571                                 }
4572                                 milter_addheader(m, response, rlen, e);
4573                                 break;
4574
4575                           case SMFIR_INSHEADER:
4576                                 if (!bitset(SMFIF_ADDHDRS, m->mf_fflags))
4577                                 {
4578                                         if (MilterLogLevel > 9)
4579                                                 sm_syslog(LOG_WARNING, e->e_id,
4580                                                           "milter_data(%s): lied about adding headers, honoring request anyway",
4581                                                           m->mf_name);
4582                                 }
4583                                 milter_insheader(m, response, rlen, e);
4584                                 break;
4585
4586                           case SMFIR_CHGHEADER:
4587                                 if (!bitset(SMFIF_CHGHDRS, m->mf_fflags))
4588                                 {
4589                                         if (MilterLogLevel > 9)
4590                                                 sm_syslog(LOG_WARNING, e->e_id,
4591                                                           "milter_data(%s): lied about changing headers, honoring request anyway",
4592                                                           m->mf_name);
4593                                 }
4594                                 milter_changeheader(m, response, rlen, e);
4595                                 break;
4596
4597                           case SMFIR_CHGFROM:
4598                                 if (!bitset(SMFIF_CHGFROM, m->mf_fflags))
4599                                 {
4600                                         if (MilterLogLevel > 9)
4601                                                 sm_syslog(LOG_WARNING, e->e_id,
4602                                                           "milter_data(%s) lied about changing sender, honoring request anyway",
4603                                                           m->mf_name);
4604                                 }
4605                                 milter_chgfrom(response, rlen, e, m->mf_name);
4606                                 break;
4607
4608                           case SMFIR_ADDRCPT:
4609                                 if (!bitset(SMFIF_ADDRCPT, m->mf_fflags))
4610                                 {
4611                                         if (MilterLogLevel > 9)
4612                                                 sm_syslog(LOG_WARNING, e->e_id,
4613                                                           "milter_data(%s) lied about adding recipients, honoring request anyway",
4614                                                           m->mf_name);
4615                                 }
4616                                 milter_addrcpt(response, rlen, e, m->mf_name);
4617                                 break;
4618
4619                           case SMFIR_ADDRCPT_PAR:
4620                                 if (!bitset(SMFIF_ADDRCPT_PAR, m->mf_fflags))
4621                                 {
4622                                         if (MilterLogLevel > 9)
4623                                                 sm_syslog(LOG_WARNING, e->e_id,
4624                                                           "milter_data(%s) lied about adding recipients with parameters, honoring request anyway",
4625                                                           m->mf_name);
4626                                 }
4627                                 milter_addrcpt_par(response, rlen, e, m->mf_name);
4628                                 break;
4629
4630                           case SMFIR_DELRCPT:
4631                                 if (!bitset(SMFIF_DELRCPT, m->mf_fflags))
4632                                 {
4633                                         if (MilterLogLevel > 9)
4634                                                 sm_syslog(LOG_WARNING, e->e_id,
4635                                                           "milter_data(%s): lied about removing recipients, honoring request anyway",
4636                                                           m->mf_name);
4637                                 }
4638                                 milter_delrcpt(response, rlen, e, m->mf_name);
4639                                 break;
4640
4641                           case SMFIR_REPLBODY:
4642                                 if (!bitset(SMFIF_MODBODY, m->mf_fflags))
4643                                 {
4644                                         if (MilterLogLevel > 0)
4645                                                 sm_syslog(LOG_ERR, e->e_id,
4646                                                           "milter_data(%s): lied about replacing body, rejecting request and tempfailing message",
4647                                                           m->mf_name);
4648                                         replfailed = true;
4649                                         break;
4650                                 }
4651
4652                                 /* already failed in attempt */
4653                                 if (replfailed)
4654                                         break;
4655
4656                                 if (!dfopen)
4657                                 {
4658                                         if (milter_reopen_df(e) < 0)
4659                                         {
4660                                                 replfailed = true;
4661                                                 break;
4662                                         }
4663                                         dfopen = true;
4664                                         rewind = true;
4665                                 }
4666
4667                                 if (milter_replbody(response, rlen, newfilter,
4668                                                     e, m->mf_name) < 0)
4669                                         replfailed = true;
4670                                 newfilter = false;
4671                                 replbody = true;
4672                                 break;
4673
4674                           default:
4675                                 /* Invalid response to command */
4676                                 if (MilterLogLevel > 0)
4677                                         sm_syslog(LOG_ERR, e->e_id,
4678                                                   "milter_data(%s): returned bogus response %c",
4679                                                   m->mf_name, rcmd);
4680                                 milter_error(m, e);
4681                                 break;
4682                         }
4683                         if (rcmd != SMFIR_REPLYCODE && response != NULL)
4684                         {
4685                                 sm_free(response); /* XXX */
4686                                 response = NULL;
4687                         }
4688
4689                         if (m->mf_state == SMFS_ERROR)
4690                                 break;
4691                 }
4692
4693                 if (replbody && !replfailed)
4694                 {
4695                         /* flush possible buffered character */
4696                         milter_replbody(NULL, 0, !replbody, e, m->mf_name);
4697                         replbody = false;
4698                 }
4699
4700                 if (m->mf_state == SMFS_ERROR)
4701                 {
4702                         MILTER_CHECK_ERROR(false, continue);
4703                         goto finishup;
4704                 }
4705         }
4706
4707 finishup:
4708         /* leave things in the expected state if we touched it */
4709         if (replfailed)
4710         {
4711                 if (*state == SMFIR_CONTINUE ||
4712                     *state == SMFIR_ACCEPT)
4713                 {
4714                         *state = SMFIR_TEMPFAIL;
4715                         SM_FREE(response);
4716                 }
4717
4718                 if (dfopen)
4719                 {
4720                         SM_CLOSE_FP(e->e_dfp);
4721                         e->e_flags &= ~EF_HAS_DF;
4722                         dfopen = false;
4723                 }
4724                 rewind = false;
4725         }
4726
4727         if ((dfopen && milter_reset_df(e) < 0) ||
4728             (rewind && bfrewind(e->e_dfp) < 0))
4729         {
4730                 save_errno = errno;
4731                 ExitStat = EX_IOERR;
4732
4733                 /*
4734                 **  If filter told us to keep message but we had
4735                 **  an error, we can't really keep it, tempfail it.
4736                 */
4737
4738                 if (*state == SMFIR_CONTINUE || *state == SMFIR_ACCEPT)
4739                 {
4740                         *state = SMFIR_TEMPFAIL;
4741                         SM_FREE(response);
4742                 }
4743
4744                 errno = save_errno;
4745                 syserr("milter_data: %s/%cf%s: read error",
4746                        qid_printqueue(e->e_qgrp, e->e_qdir),
4747                        DATAFL_LETTER, e->e_id);
4748         }
4749
4750         MILTER_CHECK_DONE_MSG();
4751         if (MilterLogLevel > 10 && *state == SMFIR_REJECT)
4752                 sm_syslog(LOG_INFO, e->e_id, "Milter: reject, data");
4753         return response;
4754 }
4755
4756 /*
4757 **  MILTER_UNKNOWN -- send any unrecognized or unimplemented command
4758 **                      string to milter filters
4759 **
4760 **      Parameters:
4761 **              smtpcmd -- the string itself.
4762 **              e -- current envelope.
4763 **              state -- return state from response.
4764 **
4765 **
4766 **      Returns:
4767 **              response string (may be NULL)
4768 */
4769
4770 char *
4771 milter_unknown(smtpcmd, e, state)
4772         char *smtpcmd;
4773         ENVELOPE *e;
4774         char *state;
4775 {
4776         if (tTd(64, 10))
4777                 sm_dprintf("milter_unknown(%s)\n", smtpcmd);
4778
4779         return milter_command(SMFIC_UNKNOWN, smtpcmd, strlen(smtpcmd) + 1,
4780                                 SMFIM_NOMACROS, e, state, "unknown", false);
4781 }
4782
4783 /*
4784 **  MILTER_QUIT -- informs the filter(s) we are done and closes connection(s)
4785 **
4786 **      Parameters:
4787 **              e -- current envelope.
4788 **
4789 **      Returns:
4790 **              none
4791 */
4792
4793 void
4794 milter_quit(e)
4795         ENVELOPE *e;
4796 {
4797         int i;
4798
4799         if (tTd(64, 10))
4800                 sm_dprintf("milter_quit(%s)\n", e->e_id);
4801
4802         for (i = 0; InputFilters[i] != NULL; i++)
4803                 milter_quit_filter(InputFilters[i], e);
4804 }
4805
4806 /*
4807 **  MILTER_ABORT -- informs the filter(s) that we are aborting current message
4808 **
4809 **      Parameters:
4810 **              e -- current envelope.
4811 **
4812 **      Returns:
4813 **              none
4814 */
4815
4816 void
4817 milter_abort(e)
4818         ENVELOPE *e;
4819 {
4820         int i;
4821
4822         if (tTd(64, 10))
4823                 sm_dprintf("milter_abort\n");
4824
4825         for (i = 0; InputFilters[i] != NULL; i++)
4826         {
4827                 struct milter *m = InputFilters[i];
4828
4829                 /* sanity checks */
4830                 if (m->mf_sock < 0 || m->mf_state != SMFS_INMSG)
4831                         continue;
4832
4833                 milter_abort_filter(m, e);
4834         }
4835 }
4836 #endif /* MILTER */