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