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