1 /* 2 * Copyright (c) 1999-2004, 2006-2008 Proofpoint, Inc. and its suppliers. 3 * All rights reserved. 4 * 5 * By using this file, you agree to the terms and conditions set 6 * forth in the LICENSE file which can be found at the top level of 7 * the sendmail distribution. 8 * 9 */ 10 11 #include <sm/gen.h> 12 SM_RCSID("@(#)$Id: engine.c,v 8.168 2013-11-22 20:51:36 ca Exp $") 13 14 #include "libmilter.h" 15 16 #if NETINET || NETINET6 17 # include <arpa/inet.h> 18 #endif 19 20 /* generic argument for functions in the command table */ 21 struct arg_struct 22 { 23 size_t a_len; /* length of buffer */ 24 char *a_buf; /* argument string */ 25 int a_idx; /* index for macro array */ 26 SMFICTX_PTR a_ctx; /* context */ 27 }; 28 29 typedef struct arg_struct genarg; 30 31 /* structure for commands received from MTA */ 32 struct cmdfct_t 33 { 34 char cm_cmd; /* command */ 35 int cm_argt; /* type of arguments expected */ 36 int cm_next; /* next state */ 37 int cm_todo; /* what to do next */ 38 int cm_macros; /* index for macros */ 39 int (*cm_fct) __P((genarg *)); /* function to execute */ 40 }; 41 42 typedef struct cmdfct_t cmdfct; 43 44 /* possible values for cm_argt */ 45 #define CM_BUF 0 46 #define CM_NULLOK 1 47 48 /* possible values for cm_todo */ 49 #define CT_CONT 0x0000 /* continue reading commands */ 50 #define CT_IGNO 0x0001 /* continue even when error */ 51 52 /* not needed right now, done via return code instead */ 53 #define CT_KEEP 0x0004 /* keep buffer (contains symbols) */ 54 #define CT_END 0x0008 /* last command of session, stop replying */ 55 56 /* index in macro array: macros only for these commands */ 57 #define CI_NONE (-1) 58 #define CI_CONN 0 59 #define CI_HELO 1 60 #define CI_MAIL 2 61 #define CI_RCPT 3 62 #define CI_DATA 4 63 #define CI_EOM 5 64 #define CI_EOH 6 65 #define CI_LAST CI_EOH 66 #if CI_LAST < CI_DATA 67 ERROR: do not compile with CI_LAST < CI_DATA 68 #endif 69 #if CI_LAST < CI_EOM 70 ERROR: do not compile with CI_LAST < CI_EOM 71 #endif 72 #if CI_LAST < CI_EOH 73 ERROR: do not compile with CI_LAST < CI_EOH 74 #endif 75 #if CI_LAST < CI_RCPT 76 ERROR: do not compile with CI_LAST < CI_RCPT 77 #endif 78 #if CI_LAST < CI_MAIL 79 ERROR: do not compile with CI_LAST < CI_MAIL 80 #endif 81 #if CI_LAST < CI_HELO 82 ERROR: do not compile with CI_LAST < CI_HELO 83 #endif 84 #if CI_LAST < CI_CONN 85 ERROR: do not compile with CI_LAST < CI_CONN 86 #endif 87 #if CI_LAST >= MAX_MACROS_ENTRIES 88 ERROR: do not compile with CI_LAST >= MAX_MACROS_ENTRIES 89 #endif 90 91 /* function prototypes */ 92 static int st_abortfct __P((genarg *)); 93 static int st_macros __P((genarg *)); 94 static int st_optionneg __P((genarg *)); 95 static int st_bodychunk __P((genarg *)); 96 static int st_connectinfo __P((genarg *)); 97 static int st_bodyend __P((genarg *)); 98 static int st_helo __P((genarg *)); 99 static int st_header __P((genarg *)); 100 static int st_sender __P((genarg *)); 101 static int st_rcpt __P((genarg *)); 102 static int st_unknown __P((genarg *)); 103 static int st_data __P((genarg *)); 104 static int st_eoh __P((genarg *)); 105 static int st_quit __P((genarg *)); 106 static int sendreply __P((sfsistat, socket_t, struct timeval *, SMFICTX_PTR)); 107 static void fix_stm __P((SMFICTX_PTR)); 108 static bool trans_ok __P((int, int)); 109 static char **dec_argv __P((char *, size_t)); 110 static int dec_arg2 __P((char *, size_t, char **, char **)); 111 static void mi_clr_symlist __P((SMFICTX_PTR)); 112 113 #if _FFR_WORKERS_POOL 114 static bool mi_rd_socket_ready __P((int)); 115 #endif 116 117 /* states */ 118 #define ST_NONE (-1) 119 #define ST_INIT 0 /* initial state */ 120 #define ST_OPTS 1 /* option negotiation */ 121 #define ST_CONN 2 /* connection info */ 122 #define ST_HELO 3 /* helo */ 123 #define ST_MAIL 4 /* mail from */ 124 #define ST_RCPT 5 /* rcpt to */ 125 #define ST_DATA 6 /* data */ 126 #define ST_HDRS 7 /* headers */ 127 #define ST_EOHS 8 /* end of headers */ 128 #define ST_BODY 9 /* body */ 129 #define ST_ENDM 10 /* end of message */ 130 #define ST_QUIT 11 /* quit */ 131 #define ST_ABRT 12 /* abort */ 132 #define ST_UNKN 13 /* unknown SMTP command */ 133 #define ST_Q_NC 14 /* quit, new connection follows */ 134 #define ST_LAST ST_Q_NC /* last valid state */ 135 #define ST_SKIP 16 /* not a state but required for the state table */ 136 137 /* in a mail transaction? must be before eom according to spec. */ 138 #define ST_IN_MAIL(st) ((st) >= ST_MAIL && (st) < ST_ENDM) 139 140 /* 141 ** set of next states 142 ** each state (ST_*) corresponds to bit in an int value (1 << state) 143 ** each state has a set of allowed transitions ('or' of bits of states) 144 ** so a state transition is valid if the mask of the next state 145 ** is set in the NX_* value 146 ** this function is coded in trans_ok(), see below. 147 */ 148 149 #define MI_MASK(x) (0x0001 << (x)) /* generate a bit "mask" for a state */ 150 #define NX_INIT (MI_MASK(ST_OPTS)) 151 #define NX_OPTS (MI_MASK(ST_CONN) | MI_MASK(ST_UNKN)) 152 #define NX_CONN (MI_MASK(ST_HELO) | MI_MASK(ST_MAIL) | MI_MASK(ST_UNKN)) 153 #define NX_HELO (MI_MASK(ST_HELO) | MI_MASK(ST_MAIL) | MI_MASK(ST_UNKN)) 154 #define NX_MAIL (MI_MASK(ST_RCPT) | MI_MASK(ST_ABRT) | MI_MASK(ST_UNKN)) 155 #define NX_RCPT (MI_MASK(ST_HDRS) | MI_MASK(ST_EOHS) | MI_MASK(ST_DATA) | \ 156 MI_MASK(ST_BODY) | MI_MASK(ST_ENDM) | \ 157 MI_MASK(ST_RCPT) | MI_MASK(ST_ABRT) | MI_MASK(ST_UNKN)) 158 #define NX_DATA (MI_MASK(ST_EOHS) | MI_MASK(ST_HDRS) | MI_MASK(ST_ABRT)) 159 #define NX_HDRS (MI_MASK(ST_EOHS) | MI_MASK(ST_HDRS) | MI_MASK(ST_ABRT)) 160 #define NX_EOHS (MI_MASK(ST_BODY) | MI_MASK(ST_ENDM) | MI_MASK(ST_ABRT)) 161 #define NX_BODY (MI_MASK(ST_ENDM) | MI_MASK(ST_BODY) | MI_MASK(ST_ABRT)) 162 #define NX_ENDM (MI_MASK(ST_QUIT) | MI_MASK(ST_MAIL) | MI_MASK(ST_UNKN) | \ 163 MI_MASK(ST_Q_NC)) 164 #define NX_QUIT 0 165 #define NX_ABRT 0 166 #define NX_UNKN (MI_MASK(ST_HELO) | MI_MASK(ST_MAIL) | \ 167 MI_MASK(ST_RCPT) | MI_MASK(ST_ABRT) | \ 168 MI_MASK(ST_DATA) | \ 169 MI_MASK(ST_BODY) | MI_MASK(ST_UNKN) | \ 170 MI_MASK(ST_ABRT) | MI_MASK(ST_QUIT) | MI_MASK(ST_Q_NC)) 171 #define NX_Q_NC (MI_MASK(ST_CONN) | MI_MASK(ST_UNKN)) 172 #define NX_SKIP MI_MASK(ST_SKIP) 173 174 static int next_states[] = 175 { 176 NX_INIT 177 , NX_OPTS 178 , NX_CONN 179 , NX_HELO 180 , NX_MAIL 181 , NX_RCPT 182 , NX_DATA 183 , NX_HDRS 184 , NX_EOHS 185 , NX_BODY 186 , NX_ENDM 187 , NX_QUIT 188 , NX_ABRT 189 , NX_UNKN 190 , NX_Q_NC 191 }; 192 193 #define SIZE_NEXT_STATES (sizeof(next_states) / sizeof(next_states[0])) 194 195 /* commands received by milter */ 196 static cmdfct cmds[] = 197 { 198 {SMFIC_ABORT, CM_NULLOK, ST_ABRT, CT_CONT, CI_NONE, st_abortfct} 199 , {SMFIC_MACRO, CM_BUF, ST_NONE, CT_KEEP, CI_NONE, st_macros } 200 , {SMFIC_BODY, CM_BUF, ST_BODY, CT_CONT, CI_NONE, st_bodychunk} 201 , {SMFIC_CONNECT, CM_BUF, ST_CONN, CT_CONT, CI_CONN, st_connectinfo} 202 , {SMFIC_BODYEOB, CM_NULLOK, ST_ENDM, CT_CONT, CI_EOM, st_bodyend } 203 , {SMFIC_HELO, CM_BUF, ST_HELO, CT_CONT, CI_HELO, st_helo } 204 , {SMFIC_HEADER, CM_BUF, ST_HDRS, CT_CONT, CI_NONE, st_header } 205 , {SMFIC_MAIL, CM_BUF, ST_MAIL, CT_CONT, CI_MAIL, st_sender } 206 , {SMFIC_OPTNEG, CM_BUF, ST_OPTS, CT_CONT, CI_NONE, st_optionneg} 207 , {SMFIC_EOH, CM_NULLOK, ST_EOHS, CT_CONT, CI_EOH, st_eoh } 208 , {SMFIC_QUIT, CM_NULLOK, ST_QUIT, CT_END, CI_NONE, st_quit } 209 , {SMFIC_DATA, CM_NULLOK, ST_DATA, CT_CONT, CI_DATA, st_data } 210 , {SMFIC_RCPT, CM_BUF, ST_RCPT, CT_IGNO, CI_RCPT, st_rcpt } 211 , {SMFIC_UNKNOWN, CM_BUF, ST_UNKN, CT_IGNO, CI_NONE, st_unknown } 212 , {SMFIC_QUIT_NC, CM_NULLOK, ST_Q_NC, CT_CONT, CI_NONE, st_quit } 213 }; 214 215 /* 216 ** Additional (internal) reply codes; 217 ** must be coordinated wit libmilter/mfapi.h 218 */ 219 220 #define _SMFIS_KEEP 20 221 #define _SMFIS_ABORT 21 222 #define _SMFIS_OPTIONS 22 223 #define _SMFIS_NOREPLY SMFIS_NOREPLY 224 #define _SMFIS_FAIL (-1) 225 #define _SMFIS_NONE (-2) 226 227 /* 228 ** MI_ENGINE -- receive commands and process them 229 ** 230 ** Parameters: 231 ** ctx -- context structure 232 ** 233 ** Returns: 234 ** MI_FAILURE/MI_SUCCESS 235 */ 236 237 int 238 mi_engine(ctx) 239 SMFICTX_PTR ctx; 240 { 241 size_t len; 242 int i; 243 socket_t sd; 244 int ret = MI_SUCCESS; 245 int ncmds = sizeof(cmds) / sizeof(cmdfct); 246 int curstate = ST_INIT; 247 int newstate; 248 bool call_abort; 249 sfsistat r; 250 char cmd; 251 char *buf = NULL; 252 genarg arg; 253 struct timeval timeout; 254 int (*f) __P((genarg *)); 255 sfsistat (*fi_abort) __P((SMFICTX *)); 256 sfsistat (*fi_close) __P((SMFICTX *)); 257 258 arg.a_ctx = ctx; 259 sd = ctx->ctx_sd; 260 fi_abort = ctx->ctx_smfi->xxfi_abort; 261 #if _FFR_WORKERS_POOL 262 curstate = ctx->ctx_state; 263 if (curstate == ST_INIT) 264 { 265 mi_clr_macros(ctx, 0); 266 fix_stm(ctx); 267 } 268 #else /* _FFR_WORKERS_POOL */ 269 mi_clr_macros(ctx, 0); 270 fix_stm(ctx); 271 #endif /* _FFR_WORKERS_POOL */ 272 r = _SMFIS_NONE; 273 do 274 { 275 /* call abort only if in a mail transaction */ 276 call_abort = ST_IN_MAIL(curstate); 277 timeout.tv_sec = ctx->ctx_timeout; 278 timeout.tv_usec = 0; 279 if (mi_stop() == MILTER_ABRT) 280 { 281 if (ctx->ctx_dbg > 3) 282 sm_dprintf("[%lu] milter_abort\n", 283 (long) ctx->ctx_id); 284 ret = MI_FAILURE; 285 break; 286 } 287 288 /* 289 ** Notice: buf is allocated by mi_rd_cmd() and it will 290 ** usually be free()d after it has been used in f(). 291 ** However, if the function returns _SMFIS_KEEP then buf 292 ** contains macros and will not be free()d. 293 ** Hence r must be set to _SMFIS_NONE if a new buf is 294 ** allocated to avoid problem with housekeeping, esp. 295 ** if the code "break"s out of the loop. 296 */ 297 298 #if _FFR_WORKERS_POOL 299 /* Is the socket ready to be read ??? */ 300 if (!mi_rd_socket_ready(sd)) 301 { 302 ret = MI_CONTINUE; 303 break; 304 } 305 #endif /* _FFR_WORKERS_POOL */ 306 307 r = _SMFIS_NONE; 308 if ((buf = mi_rd_cmd(sd, &timeout, &cmd, &len, 309 ctx->ctx_smfi->xxfi_name)) == NULL && 310 cmd < SMFIC_VALIDCMD) 311 { 312 if (ctx->ctx_dbg > 5) 313 sm_dprintf("[%lu] mi_engine: mi_rd_cmd error (%x)\n", 314 (long) ctx->ctx_id, (int) cmd); 315 316 /* 317 ** eof is currently treated as failure -> 318 ** abort() instead of close(), otherwise use: 319 ** if (cmd != SMFIC_EOF) 320 */ 321 322 ret = MI_FAILURE; 323 break; 324 } 325 if (ctx->ctx_dbg > 4) 326 sm_dprintf("[%lu] got cmd '%c' len %d\n", 327 (long) ctx->ctx_id, cmd, (int) len); 328 for (i = 0; i < ncmds; i++) 329 { 330 if (cmd == cmds[i].cm_cmd) 331 break; 332 } 333 if (i >= ncmds) 334 { 335 /* unknown command */ 336 if (ctx->ctx_dbg > 1) 337 sm_dprintf("[%lu] cmd '%c' unknown\n", 338 (long) ctx->ctx_id, cmd); 339 ret = MI_FAILURE; 340 break; 341 } 342 if ((f = cmds[i].cm_fct) == NULL) 343 { 344 /* stop for now */ 345 if (ctx->ctx_dbg > 1) 346 sm_dprintf("[%lu] cmd '%c' not impl\n", 347 (long) ctx->ctx_id, cmd); 348 ret = MI_FAILURE; 349 break; 350 } 351 352 /* is new state ok? */ 353 newstate = cmds[i].cm_next; 354 if (ctx->ctx_dbg > 5) 355 sm_dprintf("[%lu] cur %x new %x nextmask %x\n", 356 (long) ctx->ctx_id, 357 curstate, newstate, next_states[curstate]); 358 359 if (newstate != ST_NONE && !trans_ok(curstate, newstate)) 360 { 361 if (ctx->ctx_dbg > 1) 362 sm_dprintf("[%lu] abort: cur %d (%x) new %d (%x) next %x\n", 363 (long) ctx->ctx_id, 364 curstate, MI_MASK(curstate), 365 newstate, MI_MASK(newstate), 366 next_states[curstate]); 367 368 /* call abort only if in a mail transaction */ 369 if (fi_abort != NULL && call_abort) 370 (void) (*fi_abort)(ctx); 371 372 /* 373 ** try to reach the new state from HELO 374 ** if it can't be reached, ignore the command. 375 */ 376 377 curstate = ST_HELO; 378 if (!trans_ok(curstate, newstate)) 379 { 380 if (buf != NULL) 381 { 382 free(buf); 383 buf = NULL; 384 } 385 continue; 386 } 387 } 388 if (cmds[i].cm_argt != CM_NULLOK && buf == NULL) 389 { 390 /* stop for now */ 391 if (ctx->ctx_dbg > 1) 392 sm_dprintf("[%lu] cmd='%c', buf=NULL\n", 393 (long) ctx->ctx_id, cmd); 394 ret = MI_FAILURE; 395 break; 396 } 397 arg.a_len = len; 398 arg.a_buf = buf; 399 if (newstate != ST_NONE) 400 { 401 curstate = newstate; 402 ctx->ctx_state = curstate; 403 } 404 arg.a_idx = cmds[i].cm_macros; 405 call_abort = ST_IN_MAIL(curstate); 406 407 /* call function to deal with command */ 408 MI_MONITOR_BEGIN(ctx, cmd); 409 r = (*f)(&arg); 410 MI_MONITOR_END(ctx, cmd); 411 if (r != _SMFIS_KEEP && buf != NULL) 412 { 413 free(buf); 414 buf = NULL; 415 } 416 if (sendreply(r, sd, &timeout, ctx) != MI_SUCCESS) 417 { 418 ret = MI_FAILURE; 419 break; 420 } 421 422 if (r == SMFIS_ACCEPT) 423 { 424 /* accept mail, no further actions taken */ 425 curstate = ST_HELO; 426 } 427 else if (r == SMFIS_REJECT || r == SMFIS_DISCARD || 428 r == SMFIS_TEMPFAIL) 429 { 430 /* 431 ** further actions depend on current state 432 ** if the IGNO bit is set: "ignore" the error, 433 ** i.e., stay in the current state 434 */ 435 if (!bitset(CT_IGNO, cmds[i].cm_todo)) 436 curstate = ST_HELO; 437 } 438 else if (r == _SMFIS_ABORT) 439 { 440 if (ctx->ctx_dbg > 5) 441 sm_dprintf("[%lu] function returned abort\n", 442 (long) ctx->ctx_id); 443 ret = MI_FAILURE; 444 break; 445 } 446 } while (!bitset(CT_END, cmds[i].cm_todo)); 447 448 ctx->ctx_state = curstate; 449 450 if (ret == MI_FAILURE) 451 { 452 /* call abort only if in a mail transaction */ 453 if (fi_abort != NULL && call_abort) 454 (void) (*fi_abort)(ctx); 455 } 456 457 /* has close been called? */ 458 if (ctx->ctx_state != ST_QUIT 459 #if _FFR_WORKERS_POOL 460 && ret != MI_CONTINUE 461 #endif 462 ) 463 { 464 if ((fi_close = ctx->ctx_smfi->xxfi_close) != NULL) 465 (void) (*fi_close)(ctx); 466 } 467 if (r != _SMFIS_KEEP && buf != NULL) 468 free(buf); 469 #if !_FFR_WORKERS_POOL 470 mi_clr_macros(ctx, 0); 471 #endif 472 return ret; 473 } 474 475 static size_t milter_addsymlist __P((SMFICTX_PTR, char *, char **)); 476 477 static size_t 478 milter_addsymlist(ctx, buf, newbuf) 479 SMFICTX_PTR ctx; 480 char *buf; 481 char **newbuf; 482 { 483 size_t len; 484 int i; 485 mi_int32 v; 486 char *buffer; 487 488 SM_ASSERT(ctx != NULL); 489 SM_ASSERT(buf != NULL); 490 SM_ASSERT(newbuf != NULL); 491 len = 0; 492 for (i = 0; i < MAX_MACROS_ENTRIES; i++) 493 { 494 if (ctx->ctx_mac_list[i] != NULL) 495 { 496 len += strlen(ctx->ctx_mac_list[i]) + 1 + 497 MILTER_LEN_BYTES; 498 } 499 } 500 if (len > 0) 501 { 502 size_t offset; 503 504 SM_ASSERT(len + MILTER_OPTLEN > len); 505 len += MILTER_OPTLEN; 506 buffer = malloc(len); 507 if (buffer != NULL) 508 { 509 (void) memcpy(buffer, buf, MILTER_OPTLEN); 510 offset = MILTER_OPTLEN; 511 for (i = 0; i < MAX_MACROS_ENTRIES; i++) 512 { 513 size_t l; 514 515 if (ctx->ctx_mac_list[i] == NULL) 516 continue; 517 518 SM_ASSERT(offset + MILTER_LEN_BYTES < len); 519 v = htonl(i); 520 (void) memcpy(buffer + offset, (void *) &v, 521 MILTER_LEN_BYTES); 522 offset += MILTER_LEN_BYTES; 523 l = strlen(ctx->ctx_mac_list[i]) + 1; 524 SM_ASSERT(offset + l <= len); 525 (void) memcpy(buffer + offset, 526 ctx->ctx_mac_list[i], l); 527 offset += l; 528 } 529 } 530 else 531 { 532 /* oops ... */ 533 } 534 } 535 else 536 { 537 len = MILTER_OPTLEN; 538 buffer = buf; 539 } 540 *newbuf = buffer; 541 return len; 542 } 543 544 /* 545 ** GET_NR_BIT -- get "no reply" bit matching state 546 ** 547 ** Parameters: 548 ** state -- current protocol stage 549 ** 550 ** Returns: 551 ** 0: no matching bit 552 ** >0: the matching "no reply" bit 553 */ 554 555 static unsigned long get_nr_bit __P((int)); 556 557 static unsigned long 558 get_nr_bit(state) 559 int state; 560 { 561 unsigned long bit; 562 563 switch (state) 564 { 565 case ST_CONN: 566 bit = SMFIP_NR_CONN; 567 break; 568 case ST_HELO: 569 bit = SMFIP_NR_HELO; 570 break; 571 case ST_MAIL: 572 bit = SMFIP_NR_MAIL; 573 break; 574 case ST_RCPT: 575 bit = SMFIP_NR_RCPT; 576 break; 577 case ST_DATA: 578 bit = SMFIP_NR_DATA; 579 break; 580 case ST_UNKN: 581 bit = SMFIP_NR_UNKN; 582 break; 583 case ST_HDRS: 584 bit = SMFIP_NR_HDR; 585 break; 586 case ST_EOHS: 587 bit = SMFIP_NR_EOH; 588 break; 589 case ST_BODY: 590 bit = SMFIP_NR_BODY; 591 break; 592 default: 593 bit = 0; 594 break; 595 } 596 return bit; 597 } 598 599 /* 600 ** SENDREPLY -- send a reply to the MTA 601 ** 602 ** Parameters: 603 ** r -- reply code 604 ** sd -- socket descriptor 605 ** timeout_ptr -- (ptr to) timeout to use for sending 606 ** ctx -- context structure 607 ** 608 ** Returns: 609 ** MI_SUCCESS/MI_FAILURE 610 */ 611 612 static int 613 sendreply(r, sd, timeout_ptr, ctx) 614 sfsistat r; 615 socket_t sd; 616 struct timeval *timeout_ptr; 617 SMFICTX_PTR ctx; 618 { 619 int ret; 620 unsigned long bit; 621 622 ret = MI_SUCCESS; 623 624 bit = get_nr_bit(ctx->ctx_state); 625 if (bit != 0 && (ctx->ctx_pflags & bit) != 0 && r != SMFIS_NOREPLY) 626 { 627 if (r >= SMFIS_CONTINUE && r < _SMFIS_KEEP) 628 { 629 /* milter said it wouldn't reply, but it lied... */ 630 smi_log(SMI_LOG_ERR, 631 "%s: milter claimed not to reply in state %d but did anyway %d", 632 ctx->ctx_smfi->xxfi_name, 633 ctx->ctx_state, r); 634 635 } 636 637 /* 638 ** Force specified behavior, otherwise libmilter 639 ** and MTA will fail to communicate properly. 640 */ 641 642 switch (r) 643 { 644 case SMFIS_CONTINUE: 645 case SMFIS_TEMPFAIL: 646 case SMFIS_REJECT: 647 case SMFIS_DISCARD: 648 case SMFIS_ACCEPT: 649 case SMFIS_SKIP: 650 case _SMFIS_OPTIONS: 651 r = SMFIS_NOREPLY; 652 break; 653 } 654 } 655 656 switch (r) 657 { 658 case SMFIS_CONTINUE: 659 ret = mi_wr_cmd(sd, timeout_ptr, SMFIR_CONTINUE, NULL, 0); 660 break; 661 case SMFIS_TEMPFAIL: 662 case SMFIS_REJECT: 663 if (ctx->ctx_reply != NULL && 664 ((r == SMFIS_TEMPFAIL && *ctx->ctx_reply == '4') || 665 (r == SMFIS_REJECT && *ctx->ctx_reply == '5'))) 666 { 667 ret = mi_wr_cmd(sd, timeout_ptr, SMFIR_REPLYCODE, 668 ctx->ctx_reply, 669 strlen(ctx->ctx_reply) + 1); 670 free(ctx->ctx_reply); 671 ctx->ctx_reply = NULL; 672 } 673 else 674 { 675 ret = mi_wr_cmd(sd, timeout_ptr, r == SMFIS_REJECT ? 676 SMFIR_REJECT : SMFIR_TEMPFAIL, NULL, 0); 677 } 678 break; 679 case SMFIS_DISCARD: 680 ret = mi_wr_cmd(sd, timeout_ptr, SMFIR_DISCARD, NULL, 0); 681 break; 682 case SMFIS_ACCEPT: 683 ret = mi_wr_cmd(sd, timeout_ptr, SMFIR_ACCEPT, NULL, 0); 684 break; 685 case SMFIS_SKIP: 686 ret = mi_wr_cmd(sd, timeout_ptr, SMFIR_SKIP, NULL, 0); 687 break; 688 case _SMFIS_OPTIONS: 689 { 690 mi_int32 v; 691 size_t len; 692 char *buffer; 693 char buf[MILTER_OPTLEN]; 694 695 v = htonl(ctx->ctx_prot_vers2mta); 696 (void) memcpy(&(buf[0]), (void *) &v, 697 MILTER_LEN_BYTES); 698 v = htonl(ctx->ctx_aflags); 699 (void) memcpy(&(buf[MILTER_LEN_BYTES]), (void *) &v, 700 MILTER_LEN_BYTES); 701 v = htonl(ctx->ctx_pflags2mta); 702 (void) memcpy(&(buf[MILTER_LEN_BYTES * 2]), 703 (void *) &v, MILTER_LEN_BYTES); 704 len = milter_addsymlist(ctx, buf, &buffer); 705 if (buffer != NULL) 706 { 707 ret = mi_wr_cmd(sd, timeout_ptr, SMFIC_OPTNEG, 708 buffer, len); 709 if (buffer != buf) 710 free(buffer); 711 } 712 else 713 ret = MI_FAILURE; 714 } 715 break; 716 case SMFIS_NOREPLY: 717 if (bit != 0 && 718 (ctx->ctx_pflags & bit) != 0 && 719 (ctx->ctx_mta_pflags & bit) == 0) 720 { 721 /* 722 ** milter doesn't want to send a reply, 723 ** but the MTA doesn't have that feature: fake it. 724 */ 725 726 ret = mi_wr_cmd(sd, timeout_ptr, SMFIR_CONTINUE, NULL, 727 0); 728 } 729 break; 730 default: /* don't send a reply */ 731 break; 732 } 733 return ret; 734 } 735 736 /* 737 ** MI_CLR_MACROS -- clear set of macros starting from a given index 738 ** 739 ** Parameters: 740 ** ctx -- context structure 741 ** m -- index from which to clear all macros 742 ** 743 ** Returns: 744 ** None. 745 */ 746 747 void 748 mi_clr_macros(ctx, m) 749 SMFICTX_PTR ctx; 750 int m; 751 { 752 int i; 753 754 for (i = m; i < MAX_MACROS_ENTRIES; i++) 755 { 756 if (ctx->ctx_mac_ptr[i] != NULL) 757 { 758 free(ctx->ctx_mac_ptr[i]); 759 ctx->ctx_mac_ptr[i] = NULL; 760 } 761 if (ctx->ctx_mac_buf[i] != NULL) 762 { 763 free(ctx->ctx_mac_buf[i]); 764 ctx->ctx_mac_buf[i] = NULL; 765 } 766 } 767 } 768 769 /* 770 ** MI_CLR_SYMLIST -- clear list of macros 771 ** 772 ** Parameters: 773 ** ctx -- context structure 774 ** 775 ** Returns: 776 ** None. 777 */ 778 779 static void 780 mi_clr_symlist(ctx) 781 SMFICTX *ctx; 782 { 783 int i; 784 785 SM_ASSERT(ctx != NULL); 786 for (i = SMFIM_FIRST; i <= SMFIM_LAST; i++) 787 { 788 if (ctx->ctx_mac_list[i] != NULL) 789 { 790 free(ctx->ctx_mac_list[i]); 791 ctx->ctx_mac_list[i] = NULL; 792 } 793 } 794 } 795 796 /* 797 ** MI_CLR_CTX -- clear context 798 ** 799 ** Parameters: 800 ** ctx -- context structure 801 ** 802 ** Returns: 803 ** None. 804 */ 805 806 void 807 mi_clr_ctx(ctx) 808 SMFICTX *ctx; 809 { 810 SM_ASSERT(ctx != NULL); 811 if (ValidSocket(ctx->ctx_sd)) 812 { 813 (void) closesocket(ctx->ctx_sd); 814 ctx->ctx_sd = INVALID_SOCKET; 815 } 816 if (ctx->ctx_reply != NULL) 817 { 818 free(ctx->ctx_reply); 819 ctx->ctx_reply = NULL; 820 } 821 if (ctx->ctx_privdata != NULL) 822 { 823 smi_log(SMI_LOG_WARN, 824 "%s: private data not NULL", 825 ctx->ctx_smfi->xxfi_name); 826 } 827 mi_clr_macros(ctx, 0); 828 mi_clr_symlist(ctx); 829 free(ctx); 830 } 831 832 /* 833 ** ST_OPTIONNEG -- negotiate options 834 ** 835 ** Parameters: 836 ** g -- generic argument structure 837 ** 838 ** Returns: 839 ** abort/send options/continue 840 */ 841 842 static int 843 st_optionneg(g) 844 genarg *g; 845 { 846 mi_int32 i, v, fake_pflags, internal_pflags; 847 SMFICTX_PTR ctx; 848 #if _FFR_MILTER_CHECK 849 bool testmode = false; 850 #endif 851 int (*fi_negotiate) __P((SMFICTX *, 852 unsigned long, unsigned long, 853 unsigned long, unsigned long, 854 unsigned long *, unsigned long *, 855 unsigned long *, unsigned long *)); 856 857 if (g == NULL || g->a_ctx->ctx_smfi == NULL) 858 return SMFIS_CONTINUE; 859 ctx = g->a_ctx; 860 mi_clr_macros(ctx, g->a_idx + 1); 861 ctx->ctx_prot_vers = SMFI_PROT_VERSION; 862 863 /* check for minimum length */ 864 if (g->a_len < MILTER_OPTLEN) 865 { 866 smi_log(SMI_LOG_ERR, 867 "%s: st_optionneg[%ld]: len too short %d < %d", 868 ctx->ctx_smfi->xxfi_name, 869 (long) ctx->ctx_id, (int) g->a_len, 870 MILTER_OPTLEN); 871 return _SMFIS_ABORT; 872 } 873 874 /* protocol version */ 875 (void) memcpy((void *) &i, (void *) &(g->a_buf[0]), MILTER_LEN_BYTES); 876 v = ntohl(i); 877 878 #define SMFI_PROT_VERSION_MIN 2 879 880 /* check for minimum version */ 881 if (v < SMFI_PROT_VERSION_MIN) 882 { 883 smi_log(SMI_LOG_ERR, 884 "%s: st_optionneg[%ld]: protocol version too old %d < %d", 885 ctx->ctx_smfi->xxfi_name, 886 (long) ctx->ctx_id, v, SMFI_PROT_VERSION_MIN); 887 return _SMFIS_ABORT; 888 } 889 ctx->ctx_mta_prot_vers = v; 890 if (ctx->ctx_prot_vers < ctx->ctx_mta_prot_vers) 891 ctx->ctx_prot_vers2mta = ctx->ctx_prot_vers; 892 else 893 ctx->ctx_prot_vers2mta = ctx->ctx_mta_prot_vers; 894 895 (void) memcpy((void *) &i, (void *) &(g->a_buf[MILTER_LEN_BYTES]), 896 MILTER_LEN_BYTES); 897 v = ntohl(i); 898 899 /* no flags? set to default value for V1 actions */ 900 if (v == 0) 901 v = SMFI_V1_ACTS; 902 ctx->ctx_mta_aflags = v; /* MTA action flags */ 903 904 internal_pflags = 0; 905 (void) memcpy((void *) &i, (void *) &(g->a_buf[MILTER_LEN_BYTES * 2]), 906 MILTER_LEN_BYTES); 907 v = ntohl(i); 908 909 /* no flags? set to default value for V1 protocol */ 910 if (v == 0) 911 v = SMFI_V1_PROT; 912 #if _FFR_MDS_NEGOTIATE 913 else if (ctx->ctx_smfi->xxfi_version >= SMFI_VERSION_MDS) 914 { 915 /* 916 ** Allow changing the size only if milter is compiled 917 ** against a version that supports this. 918 ** If a milter is dynamically linked against a newer 919 ** libmilter version, we don't want to "surprise" 920 ** it with a larger buffer as it may rely on it 921 ** even though it is not documented as a limit. 922 */ 923 924 if (bitset(SMFIP_MDS_1M, v)) 925 { 926 internal_pflags |= SMFIP_MDS_1M; 927 (void) smfi_setmaxdatasize(MILTER_MDS_1M); 928 } 929 else if (bitset(SMFIP_MDS_256K, v)) 930 { 931 internal_pflags |= SMFIP_MDS_256K; 932 (void) smfi_setmaxdatasize(MILTER_MDS_256K); 933 } 934 } 935 # if 0 936 /* don't log this for now... */ 937 else if (ctx->ctx_smfi->xxfi_version < SMFI_VERSION_MDS && 938 bitset(SMFIP_MDS_1M|SMFIP_MDS_256K, v)) 939 { 940 smi_log(SMI_LOG_WARN, 941 "%s: st_optionneg[%ld]: milter version=%X, trying flags=%X", 942 ctx->ctx_smfi->xxfi_name, 943 (long) ctx->ctx_id, ctx->ctx_smfi->xxfi_version, v); 944 } 945 # endif /* 0 */ 946 #endif /* _FFR_MDS_NEGOTIATE */ 947 948 /* 949 ** MTA protocol flags. 950 ** We pass the internal flags to the milter as "read only", 951 ** i.e., a milter can read them so it knows which size 952 ** will be used, but any changes by a milter will be ignored 953 ** (see below, search for SMFI_INTERNAL). 954 */ 955 956 ctx->ctx_mta_pflags = (v & ~SMFI_INTERNAL) | internal_pflags; 957 958 /* 959 ** Copy flags from milter struct into libmilter context; 960 ** this variable will be used later on to check whether 961 ** the MTA "actions" can fulfill the milter requirements, 962 ** but it may be overwritten by the negotiate callback. 963 */ 964 965 ctx->ctx_aflags = ctx->ctx_smfi->xxfi_flags; 966 fake_pflags = SMFIP_NR_CONN 967 |SMFIP_NR_HELO 968 |SMFIP_NR_MAIL 969 |SMFIP_NR_RCPT 970 |SMFIP_NR_DATA 971 |SMFIP_NR_UNKN 972 |SMFIP_NR_HDR 973 |SMFIP_NR_EOH 974 |SMFIP_NR_BODY 975 ; 976 977 if (g->a_ctx->ctx_smfi != NULL && 978 g->a_ctx->ctx_smfi->xxfi_version > 4 && 979 (fi_negotiate = g->a_ctx->ctx_smfi->xxfi_negotiate) != NULL) 980 { 981 int r; 982 unsigned long m_aflags, m_pflags, m_f2, m_f3; 983 984 /* 985 ** let milter decide whether the features offered by the 986 ** MTA are "good enough". 987 ** Notes: 988 ** - libmilter can "fake" some features (e.g., SMFIP_NR_HDR) 989 ** - m_f2, m_f3 are for future extensions 990 */ 991 992 m_f2 = m_f3 = 0; 993 m_aflags = ctx->ctx_mta_aflags; 994 m_pflags = ctx->ctx_pflags; 995 if ((SMFIP_SKIP & ctx->ctx_mta_pflags) != 0) 996 m_pflags |= SMFIP_SKIP; 997 r = fi_negotiate(g->a_ctx, 998 ctx->ctx_mta_aflags, 999 ctx->ctx_mta_pflags|fake_pflags, 1000 0, 0, 1001 &m_aflags, &m_pflags, &m_f2, &m_f3); 1002 1003 #if _FFR_MILTER_CHECK 1004 testmode = bitset(SMFIP_TEST, m_pflags); 1005 if (testmode) 1006 m_pflags &= ~SMFIP_TEST; 1007 #endif 1008 1009 /* 1010 ** Types of protocol flags (pflags): 1011 ** 1. do NOT send protocol step X 1012 ** 2. MTA can do/understand something extra (SKIP, 1013 ** send unknown RCPTs) 1014 ** 3. MTA can deal with "no reply" for various protocol steps 1015 ** Note: this mean that it isn't possible to simply set all 1016 ** flags to get "everything": 1017 ** setting a flag of type 1 turns off a step 1018 ** (it should be the other way around: 1019 ** a flag means a protocol step can be sent) 1020 ** setting a flag of type 3 requires that milter 1021 ** never sends a reply for the corresponding step. 1022 ** Summary: the "negation" of protocol flags is causing 1023 ** problems, but at least for type 3 there is no simple 1024 ** solution. 1025 ** 1026 ** What should "all options" mean? 1027 ** send all protocol steps _except_ those for which there is 1028 ** no callback (currently registered in ctx_pflags) 1029 ** expect SKIP as return code? Yes 1030 ** send unknown RCPTs? No, 1031 ** must be explicitly requested? 1032 ** "no reply" for some protocol steps? No, 1033 ** must be explicitly requested. 1034 */ 1035 1036 if (SMFIS_ALL_OPTS == r) 1037 { 1038 ctx->ctx_aflags = ctx->ctx_mta_aflags; 1039 ctx->ctx_pflags2mta = ctx->ctx_pflags; 1040 if ((SMFIP_SKIP & ctx->ctx_mta_pflags) != 0) 1041 ctx->ctx_pflags2mta |= SMFIP_SKIP; 1042 } 1043 else if (r != SMFIS_CONTINUE) 1044 { 1045 smi_log(SMI_LOG_ERR, 1046 "%s: st_optionneg[%ld]: xxfi_negotiate returned %d (protocol options=0x%lx, actions=0x%lx)", 1047 ctx->ctx_smfi->xxfi_name, 1048 (long) ctx->ctx_id, r, ctx->ctx_mta_pflags, 1049 ctx->ctx_mta_aflags); 1050 return _SMFIS_ABORT; 1051 } 1052 else 1053 { 1054 ctx->ctx_aflags = m_aflags; 1055 ctx->ctx_pflags = m_pflags; 1056 ctx->ctx_pflags2mta = m_pflags; 1057 } 1058 1059 /* check whether some flags need to be "faked" */ 1060 i = ctx->ctx_pflags2mta; 1061 if ((ctx->ctx_mta_pflags & i) != i) 1062 { 1063 unsigned int idx; 1064 unsigned long b; 1065 1066 /* 1067 ** If some behavior can be faked (set in fake_pflags), 1068 ** but the MTA doesn't support it, then unset 1069 ** that flag in the value that is sent to the MTA. 1070 */ 1071 1072 for (idx = 0; idx < 32; idx++) 1073 { 1074 b = 1 << idx; 1075 if ((ctx->ctx_mta_pflags & b) != b && 1076 (fake_pflags & b) == b) 1077 ctx->ctx_pflags2mta &= ~b; 1078 } 1079 } 1080 } 1081 else 1082 { 1083 /* 1084 ** Set the protocol flags based on the values determined 1085 ** in mi_listener() which checked the defined callbacks. 1086 */ 1087 1088 ctx->ctx_pflags2mta = ctx->ctx_pflags; 1089 } 1090 1091 /* check whether actions and protocol requirements can be satisfied */ 1092 i = ctx->ctx_aflags; 1093 if ((i & ctx->ctx_mta_aflags) != i) 1094 { 1095 smi_log(SMI_LOG_ERR, 1096 "%s: st_optionneg[%ld]: 0x%lx does not fulfill action requirements 0x%x", 1097 ctx->ctx_smfi->xxfi_name, 1098 (long) ctx->ctx_id, ctx->ctx_mta_aflags, i); 1099 return _SMFIS_ABORT; 1100 } 1101 1102 i = ctx->ctx_pflags2mta; 1103 if ((ctx->ctx_mta_pflags & i) != i) 1104 { 1105 /* 1106 ** Older MTAs do not support some protocol steps. 1107 ** As this protocol is a bit "weird" (it asks for steps 1108 ** NOT to be taken/sent) we have to check whether we 1109 ** should turn off those "negative" requests. 1110 ** Currently these are only SMFIP_NODATA and SMFIP_NOUNKNOWN. 1111 */ 1112 1113 if (bitset(SMFIP_NODATA, ctx->ctx_pflags2mta) && 1114 !bitset(SMFIP_NODATA, ctx->ctx_mta_pflags)) 1115 ctx->ctx_pflags2mta &= ~SMFIP_NODATA; 1116 if (bitset(SMFIP_NOUNKNOWN, ctx->ctx_pflags2mta) && 1117 !bitset(SMFIP_NOUNKNOWN, ctx->ctx_mta_pflags)) 1118 ctx->ctx_pflags2mta &= ~SMFIP_NOUNKNOWN; 1119 i = ctx->ctx_pflags2mta; 1120 } 1121 1122 if ((ctx->ctx_mta_pflags & i) != i) 1123 { 1124 smi_log(SMI_LOG_ERR, 1125 "%s: st_optionneg[%ld]: 0x%lx does not fulfill protocol requirements 0x%x", 1126 ctx->ctx_smfi->xxfi_name, 1127 (long) ctx->ctx_id, ctx->ctx_mta_pflags, i); 1128 return _SMFIS_ABORT; 1129 } 1130 fix_stm(ctx); 1131 1132 if (ctx->ctx_dbg > 3) 1133 sm_dprintf("[%lu] milter_negotiate:" 1134 " mta_actions=0x%lx, mta_flags=0x%lx" 1135 " actions=0x%lx, flags=0x%lx\n" 1136 , (long) ctx->ctx_id 1137 , ctx->ctx_mta_aflags, ctx->ctx_mta_pflags 1138 , ctx->ctx_aflags, ctx->ctx_pflags); 1139 1140 #if _FFR_MILTER_CHECK 1141 if (ctx->ctx_dbg > 3) 1142 sm_dprintf("[%lu] milter_negotiate:" 1143 " testmode=%d, pflags2mta=%X, internal_pflags=%X\n" 1144 , (long) ctx->ctx_id, testmode 1145 , ctx->ctx_pflags2mta, internal_pflags); 1146 1147 /* in test mode: take flags without further modifications */ 1148 if (!testmode) 1149 /* Warning: check statement below! */ 1150 #endif /* _FFR_MILTER_CHECK */ 1151 1152 /* 1153 ** Remove the internal flags that might have been set by a milter 1154 ** and set only those determined above. 1155 */ 1156 1157 ctx->ctx_pflags2mta = (ctx->ctx_pflags2mta & ~SMFI_INTERNAL) 1158 | internal_pflags; 1159 return _SMFIS_OPTIONS; 1160 } 1161 1162 /* 1163 ** ST_CONNECTINFO -- receive connection information 1164 ** 1165 ** Parameters: 1166 ** g -- generic argument structure 1167 ** 1168 ** Returns: 1169 ** continue or filter-specified value 1170 */ 1171 1172 static int 1173 st_connectinfo(g) 1174 genarg *g; 1175 { 1176 size_t l; 1177 size_t i; 1178 char *s, family; 1179 unsigned short port = 0; 1180 _SOCK_ADDR sockaddr; 1181 sfsistat (*fi_connect) __P((SMFICTX *, char *, _SOCK_ADDR *)); 1182 1183 if (g == NULL) 1184 return _SMFIS_ABORT; 1185 mi_clr_macros(g->a_ctx, g->a_idx + 1); 1186 if (g->a_ctx->ctx_smfi == NULL || 1187 (fi_connect = g->a_ctx->ctx_smfi->xxfi_connect) == NULL) 1188 return SMFIS_CONTINUE; 1189 1190 s = g->a_buf; 1191 i = 0; 1192 l = g->a_len; 1193 while (i <= l && s[i] != '\0') 1194 ++i; 1195 if (i + 1 >= l) 1196 return _SMFIS_ABORT; 1197 1198 /* Move past trailing \0 in host string */ 1199 i++; 1200 family = s[i++]; 1201 (void) memset(&sockaddr, '\0', sizeof sockaddr); 1202 if (family != SMFIA_UNKNOWN) 1203 { 1204 if (i + sizeof port >= l) 1205 { 1206 smi_log(SMI_LOG_ERR, 1207 "%s: connect[%ld]: wrong len %d >= %d", 1208 g->a_ctx->ctx_smfi->xxfi_name, 1209 (long) g->a_ctx->ctx_id, (int) i, (int) l); 1210 return _SMFIS_ABORT; 1211 } 1212 (void) memcpy((void *) &port, (void *) (s + i), 1213 sizeof port); 1214 i += sizeof port; 1215 1216 /* make sure string is terminated */ 1217 if (s[l - 1] != '\0') 1218 return _SMFIS_ABORT; 1219 # if NETINET 1220 if (family == SMFIA_INET) 1221 { 1222 if (inet_aton(s + i, (struct in_addr *) &sockaddr.sin.sin_addr) 1223 != 1) 1224 { 1225 smi_log(SMI_LOG_ERR, 1226 "%s: connect[%ld]: inet_aton failed", 1227 g->a_ctx->ctx_smfi->xxfi_name, 1228 (long) g->a_ctx->ctx_id); 1229 return _SMFIS_ABORT; 1230 } 1231 sockaddr.sa.sa_family = AF_INET; 1232 if (port > 0) 1233 sockaddr.sin.sin_port = port; 1234 } 1235 else 1236 # endif /* NETINET */ 1237 # if NETINET6 1238 if (family == SMFIA_INET6) 1239 { 1240 if (mi_inet_pton(AF_INET6, s + i, 1241 &sockaddr.sin6.sin6_addr) != 1) 1242 { 1243 smi_log(SMI_LOG_ERR, 1244 "%s: connect[%ld]: mi_inet_pton failed", 1245 g->a_ctx->ctx_smfi->xxfi_name, 1246 (long) g->a_ctx->ctx_id); 1247 return _SMFIS_ABORT; 1248 } 1249 sockaddr.sa.sa_family = AF_INET6; 1250 if (port > 0) 1251 sockaddr.sin6.sin6_port = port; 1252 } 1253 else 1254 # endif /* NETINET6 */ 1255 # if NETUNIX 1256 if (family == SMFIA_UNIX) 1257 { 1258 if (sm_strlcpy(sockaddr.sunix.sun_path, s + i, 1259 sizeof sockaddr.sunix.sun_path) >= 1260 sizeof sockaddr.sunix.sun_path) 1261 { 1262 smi_log(SMI_LOG_ERR, 1263 "%s: connect[%ld]: path too long", 1264 g->a_ctx->ctx_smfi->xxfi_name, 1265 (long) g->a_ctx->ctx_id); 1266 return _SMFIS_ABORT; 1267 } 1268 sockaddr.sunix.sun_family = AF_UNIX; 1269 } 1270 else 1271 # endif /* NETUNIX */ 1272 { 1273 smi_log(SMI_LOG_ERR, 1274 "%s: connect[%ld]: unknown family %d", 1275 g->a_ctx->ctx_smfi->xxfi_name, 1276 (long) g->a_ctx->ctx_id, family); 1277 return _SMFIS_ABORT; 1278 } 1279 } 1280 return (*fi_connect)(g->a_ctx, g->a_buf, 1281 family != SMFIA_UNKNOWN ? &sockaddr : NULL); 1282 } 1283 1284 /* 1285 ** ST_EOH -- end of headers 1286 ** 1287 ** Parameters: 1288 ** g -- generic argument structure 1289 ** 1290 ** Returns: 1291 ** continue or filter-specified value 1292 */ 1293 1294 static int 1295 st_eoh(g) 1296 genarg *g; 1297 { 1298 sfsistat (*fi_eoh) __P((SMFICTX *)); 1299 1300 if (g == NULL) 1301 return _SMFIS_ABORT; 1302 if (g->a_ctx->ctx_smfi != NULL && 1303 (fi_eoh = g->a_ctx->ctx_smfi->xxfi_eoh) != NULL) 1304 return (*fi_eoh)(g->a_ctx); 1305 return SMFIS_CONTINUE; 1306 } 1307 1308 /* 1309 ** ST_DATA -- DATA command 1310 ** 1311 ** Parameters: 1312 ** g -- generic argument structure 1313 ** 1314 ** Returns: 1315 ** continue or filter-specified value 1316 */ 1317 1318 static int 1319 st_data(g) 1320 genarg *g; 1321 { 1322 sfsistat (*fi_data) __P((SMFICTX *)); 1323 1324 if (g == NULL) 1325 return _SMFIS_ABORT; 1326 if (g->a_ctx->ctx_smfi != NULL && 1327 g->a_ctx->ctx_smfi->xxfi_version > 3 && 1328 (fi_data = g->a_ctx->ctx_smfi->xxfi_data) != NULL) 1329 return (*fi_data)(g->a_ctx); 1330 return SMFIS_CONTINUE; 1331 } 1332 1333 /* 1334 ** ST_HELO -- helo/ehlo command 1335 ** 1336 ** Parameters: 1337 ** g -- generic argument structure 1338 ** 1339 ** Returns: 1340 ** continue or filter-specified value 1341 */ 1342 1343 static int 1344 st_helo(g) 1345 genarg *g; 1346 { 1347 sfsistat (*fi_helo) __P((SMFICTX *, char *)); 1348 1349 if (g == NULL) 1350 return _SMFIS_ABORT; 1351 mi_clr_macros(g->a_ctx, g->a_idx + 1); 1352 if (g->a_ctx->ctx_smfi != NULL && 1353 (fi_helo = g->a_ctx->ctx_smfi->xxfi_helo) != NULL) 1354 { 1355 /* paranoia: check for terminating '\0' */ 1356 if (g->a_len == 0 || g->a_buf[g->a_len - 1] != '\0') 1357 return MI_FAILURE; 1358 return (*fi_helo)(g->a_ctx, g->a_buf); 1359 } 1360 return SMFIS_CONTINUE; 1361 } 1362 1363 /* 1364 ** ST_HEADER -- header line 1365 ** 1366 ** Parameters: 1367 ** g -- generic argument structure 1368 ** 1369 ** Returns: 1370 ** continue or filter-specified value 1371 */ 1372 1373 static int 1374 st_header(g) 1375 genarg *g; 1376 { 1377 char *hf, *hv; 1378 sfsistat (*fi_header) __P((SMFICTX *, char *, char *)); 1379 1380 if (g == NULL) 1381 return _SMFIS_ABORT; 1382 if (g->a_ctx->ctx_smfi == NULL || 1383 (fi_header = g->a_ctx->ctx_smfi->xxfi_header) == NULL) 1384 return SMFIS_CONTINUE; 1385 if (dec_arg2(g->a_buf, g->a_len, &hf, &hv) == MI_SUCCESS) 1386 return (*fi_header)(g->a_ctx, hf, hv); 1387 else 1388 return _SMFIS_ABORT; 1389 } 1390 1391 #define ARGV_FCT(lf, rf, idx) \ 1392 char **argv; \ 1393 sfsistat (*lf) __P((SMFICTX *, char **)); \ 1394 int r; \ 1395 \ 1396 if (g == NULL) \ 1397 return _SMFIS_ABORT; \ 1398 mi_clr_macros(g->a_ctx, g->a_idx + 1); \ 1399 if (g->a_ctx->ctx_smfi == NULL || \ 1400 (lf = g->a_ctx->ctx_smfi->rf) == NULL) \ 1401 return SMFIS_CONTINUE; \ 1402 if ((argv = dec_argv(g->a_buf, g->a_len)) == NULL) \ 1403 return _SMFIS_ABORT; \ 1404 r = (*lf)(g->a_ctx, argv); \ 1405 free(argv); \ 1406 return r; 1407 1408 /* 1409 ** ST_SENDER -- MAIL FROM command 1410 ** 1411 ** Parameters: 1412 ** g -- generic argument structure 1413 ** 1414 ** Returns: 1415 ** continue or filter-specified value 1416 */ 1417 1418 static int 1419 st_sender(g) 1420 genarg *g; 1421 { 1422 ARGV_FCT(fi_envfrom, xxfi_envfrom, CI_MAIL) 1423 } 1424 1425 /* 1426 ** ST_RCPT -- RCPT TO command 1427 ** 1428 ** Parameters: 1429 ** g -- generic argument structure 1430 ** 1431 ** Returns: 1432 ** continue or filter-specified value 1433 */ 1434 1435 static int 1436 st_rcpt(g) 1437 genarg *g; 1438 { 1439 ARGV_FCT(fi_envrcpt, xxfi_envrcpt, CI_RCPT) 1440 } 1441 1442 /* 1443 ** ST_UNKNOWN -- unrecognized or unimplemented command 1444 ** 1445 ** Parameters: 1446 ** g -- generic argument structure 1447 ** 1448 ** Returns: 1449 ** continue or filter-specified value 1450 */ 1451 1452 static int 1453 st_unknown(g) 1454 genarg *g; 1455 { 1456 sfsistat (*fi_unknown) __P((SMFICTX *, const char *)); 1457 1458 if (g == NULL) 1459 return _SMFIS_ABORT; 1460 if (g->a_ctx->ctx_smfi != NULL && 1461 g->a_ctx->ctx_smfi->xxfi_version > 2 && 1462 (fi_unknown = g->a_ctx->ctx_smfi->xxfi_unknown) != NULL) 1463 return (*fi_unknown)(g->a_ctx, (const char *) g->a_buf); 1464 return SMFIS_CONTINUE; 1465 } 1466 1467 /* 1468 ** ST_MACROS -- deal with macros received from the MTA 1469 ** 1470 ** Parameters: 1471 ** g -- generic argument structure 1472 ** 1473 ** Returns: 1474 ** continue/keep 1475 ** 1476 ** Side effects: 1477 ** set pointer in macro array to current values. 1478 */ 1479 1480 static int 1481 st_macros(g) 1482 genarg *g; 1483 { 1484 int i; 1485 char **argv; 1486 1487 if (g == NULL || g->a_len < 1) 1488 return _SMFIS_FAIL; 1489 if ((argv = dec_argv(g->a_buf + 1, g->a_len - 1)) == NULL) 1490 return _SMFIS_FAIL; 1491 switch (g->a_buf[0]) 1492 { 1493 case SMFIC_CONNECT: 1494 i = CI_CONN; 1495 break; 1496 case SMFIC_HELO: 1497 i = CI_HELO; 1498 break; 1499 case SMFIC_MAIL: 1500 i = CI_MAIL; 1501 break; 1502 case SMFIC_RCPT: 1503 i = CI_RCPT; 1504 break; 1505 case SMFIC_DATA: 1506 i = CI_DATA; 1507 break; 1508 case SMFIC_BODYEOB: 1509 i = CI_EOM; 1510 break; 1511 case SMFIC_EOH: 1512 i = CI_EOH; 1513 break; 1514 default: 1515 free(argv); 1516 return _SMFIS_FAIL; 1517 } 1518 if (g->a_ctx->ctx_mac_ptr[i] != NULL) 1519 free(g->a_ctx->ctx_mac_ptr[i]); 1520 if (g->a_ctx->ctx_mac_buf[i] != NULL) 1521 free(g->a_ctx->ctx_mac_buf[i]); 1522 g->a_ctx->ctx_mac_ptr[i] = argv; 1523 g->a_ctx->ctx_mac_buf[i] = g->a_buf; 1524 return _SMFIS_KEEP; 1525 } 1526 1527 /* 1528 ** ST_QUIT -- quit command 1529 ** 1530 ** Parameters: 1531 ** g -- generic argument structure 1532 ** 1533 ** Returns: 1534 ** noreply 1535 */ 1536 1537 /* ARGSUSED */ 1538 static int 1539 st_quit(g) 1540 genarg *g; 1541 { 1542 sfsistat (*fi_close) __P((SMFICTX *)); 1543 1544 if (g == NULL) 1545 return _SMFIS_ABORT; 1546 if (g->a_ctx->ctx_smfi != NULL && 1547 (fi_close = g->a_ctx->ctx_smfi->xxfi_close) != NULL) 1548 (void) (*fi_close)(g->a_ctx); 1549 mi_clr_macros(g->a_ctx, 0); 1550 return _SMFIS_NOREPLY; 1551 } 1552 1553 /* 1554 ** ST_BODYCHUNK -- deal with a piece of the mail body 1555 ** 1556 ** Parameters: 1557 ** g -- generic argument structure 1558 ** 1559 ** Returns: 1560 ** continue or filter-specified value 1561 */ 1562 1563 static int 1564 st_bodychunk(g) 1565 genarg *g; 1566 { 1567 sfsistat (*fi_body) __P((SMFICTX *, unsigned char *, size_t)); 1568 1569 if (g == NULL) 1570 return _SMFIS_ABORT; 1571 if (g->a_ctx->ctx_smfi != NULL && 1572 (fi_body = g->a_ctx->ctx_smfi->xxfi_body) != NULL) 1573 return (*fi_body)(g->a_ctx, (unsigned char *)g->a_buf, 1574 g->a_len); 1575 return SMFIS_CONTINUE; 1576 } 1577 1578 /* 1579 ** ST_BODYEND -- deal with the last piece of the mail body 1580 ** 1581 ** Parameters: 1582 ** g -- generic argument structure 1583 ** 1584 ** Returns: 1585 ** continue or filter-specified value 1586 ** 1587 ** Side effects: 1588 ** sends a reply for the body part (if non-empty). 1589 */ 1590 1591 static int 1592 st_bodyend(g) 1593 genarg *g; 1594 { 1595 sfsistat r; 1596 sfsistat (*fi_body) __P((SMFICTX *, unsigned char *, size_t)); 1597 sfsistat (*fi_eom) __P((SMFICTX *)); 1598 1599 if (g == NULL) 1600 return _SMFIS_ABORT; 1601 r = SMFIS_CONTINUE; 1602 if (g->a_ctx->ctx_smfi != NULL) 1603 { 1604 if ((fi_body = g->a_ctx->ctx_smfi->xxfi_body) != NULL && 1605 g->a_len > 0) 1606 { 1607 socket_t sd; 1608 struct timeval timeout; 1609 1610 timeout.tv_sec = g->a_ctx->ctx_timeout; 1611 timeout.tv_usec = 0; 1612 sd = g->a_ctx->ctx_sd; 1613 r = (*fi_body)(g->a_ctx, (unsigned char *)g->a_buf, 1614 g->a_len); 1615 if (r != SMFIS_CONTINUE && 1616 sendreply(r, sd, &timeout, g->a_ctx) != MI_SUCCESS) 1617 return _SMFIS_ABORT; 1618 } 1619 } 1620 if (r == SMFIS_CONTINUE && 1621 (fi_eom = g->a_ctx->ctx_smfi->xxfi_eom) != NULL) 1622 return (*fi_eom)(g->a_ctx); 1623 return r; 1624 } 1625 1626 /* 1627 ** ST_ABORTFCT -- deal with aborts 1628 ** 1629 ** Parameters: 1630 ** g -- generic argument structure 1631 ** 1632 ** Returns: 1633 ** abort or filter-specified value 1634 */ 1635 1636 static int 1637 st_abortfct(g) 1638 genarg *g; 1639 { 1640 sfsistat (*fi_abort) __P((SMFICTX *)); 1641 1642 if (g == NULL) 1643 return _SMFIS_ABORT; 1644 if (g != NULL && g->a_ctx->ctx_smfi != NULL && 1645 (fi_abort = g->a_ctx->ctx_smfi->xxfi_abort) != NULL) 1646 (void) (*fi_abort)(g->a_ctx); 1647 return _SMFIS_NOREPLY; 1648 } 1649 1650 /* 1651 ** TRANS_OK -- is the state transition ok? 1652 ** 1653 ** Parameters: 1654 ** old -- old state 1655 ** new -- new state 1656 ** 1657 ** Returns: 1658 ** state transition ok 1659 */ 1660 1661 static bool 1662 trans_ok(old, new) 1663 int old, new; 1664 { 1665 int s, n; 1666 1667 s = old; 1668 if (s >= SIZE_NEXT_STATES) 1669 return false; 1670 do 1671 { 1672 /* is this state transition allowed? */ 1673 if ((MI_MASK(new) & next_states[s]) != 0) 1674 return true; 1675 1676 /* 1677 ** no: try next state; 1678 ** this works since the relevant states are ordered 1679 ** strict sequentially 1680 */ 1681 1682 n = s + 1; 1683 if (n >= SIZE_NEXT_STATES) 1684 return false; 1685 1686 /* 1687 ** can we actually "skip" this state? 1688 ** see fix_stm() which sets this bit for those 1689 ** states which the filter program is not interested in 1690 */ 1691 1692 if (bitset(NX_SKIP, next_states[n])) 1693 s = n; 1694 else 1695 return false; 1696 } while (s < SIZE_NEXT_STATES); 1697 return false; 1698 } 1699 1700 /* 1701 ** FIX_STM -- add "skip" bits to the state transition table 1702 ** 1703 ** Parameters: 1704 ** ctx -- context structure 1705 ** 1706 ** Returns: 1707 ** None. 1708 ** 1709 ** Side effects: 1710 ** may change state transition table. 1711 */ 1712 1713 static void 1714 fix_stm(ctx) 1715 SMFICTX_PTR ctx; 1716 { 1717 unsigned long fl; 1718 1719 if (ctx == NULL || ctx->ctx_smfi == NULL) 1720 return; 1721 fl = ctx->ctx_pflags; 1722 if (bitset(SMFIP_NOCONNECT, fl)) 1723 next_states[ST_CONN] |= NX_SKIP; 1724 if (bitset(SMFIP_NOHELO, fl)) 1725 next_states[ST_HELO] |= NX_SKIP; 1726 if (bitset(SMFIP_NOMAIL, fl)) 1727 next_states[ST_MAIL] |= NX_SKIP; 1728 if (bitset(SMFIP_NORCPT, fl)) 1729 next_states[ST_RCPT] |= NX_SKIP; 1730 if (bitset(SMFIP_NOHDRS, fl)) 1731 next_states[ST_HDRS] |= NX_SKIP; 1732 if (bitset(SMFIP_NOEOH, fl)) 1733 next_states[ST_EOHS] |= NX_SKIP; 1734 if (bitset(SMFIP_NOBODY, fl)) 1735 next_states[ST_BODY] |= NX_SKIP; 1736 if (bitset(SMFIP_NODATA, fl)) 1737 next_states[ST_DATA] |= NX_SKIP; 1738 if (bitset(SMFIP_NOUNKNOWN, fl)) 1739 next_states[ST_UNKN] |= NX_SKIP; 1740 } 1741 1742 /* 1743 ** DEC_ARGV -- split a buffer into a list of strings, NULL terminated 1744 ** 1745 ** Parameters: 1746 ** buf -- buffer with several strings 1747 ** len -- length of buffer 1748 ** 1749 ** Returns: 1750 ** array of pointers to the individual strings 1751 */ 1752 1753 static char ** 1754 dec_argv(buf, len) 1755 char *buf; 1756 size_t len; 1757 { 1758 char **s; 1759 size_t i; 1760 int elem, nelem; 1761 1762 nelem = 0; 1763 for (i = 0; i < len; i++) 1764 { 1765 if (buf[i] == '\0') 1766 ++nelem; 1767 } 1768 if (nelem == 0) 1769 return NULL; 1770 1771 /* last entry is only for the name */ 1772 s = (char **)malloc((nelem + 1) * (sizeof *s)); 1773 if (s == NULL) 1774 return NULL; 1775 s[0] = buf; 1776 for (i = 0, elem = 0; i < len && elem < nelem; i++) 1777 { 1778 if (buf[i] == '\0') 1779 { 1780 ++elem; 1781 if (i + 1 >= len) 1782 s[elem] = NULL; 1783 else 1784 s[elem] = &(buf[i + 1]); 1785 } 1786 } 1787 1788 /* overwrite last entry (already done above, just paranoia) */ 1789 s[elem] = NULL; 1790 return s; 1791 } 1792 1793 /* 1794 ** DEC_ARG2 -- split a buffer into two strings 1795 ** 1796 ** Parameters: 1797 ** buf -- buffer with two strings 1798 ** len -- length of buffer 1799 ** s1,s2 -- pointer to result strings 1800 ** 1801 ** Returns: 1802 ** MI_FAILURE/MI_SUCCESS 1803 */ 1804 1805 static int 1806 dec_arg2(buf, len, s1, s2) 1807 char *buf; 1808 size_t len; 1809 char **s1; 1810 char **s2; 1811 { 1812 size_t i; 1813 1814 /* paranoia: check for terminating '\0' */ 1815 if (len == 0 || buf[len - 1] != '\0') 1816 return MI_FAILURE; 1817 *s1 = buf; 1818 for (i = 1; i < len && buf[i] != '\0'; i++) 1819 continue; 1820 if (i >= len - 1) 1821 return MI_FAILURE; 1822 *s2 = buf + i + 1; 1823 return MI_SUCCESS; 1824 } 1825 1826 /* 1827 ** MI_SENDOK -- is it ok for the filter to send stuff to the MTA? 1828 ** 1829 ** Parameters: 1830 ** ctx -- context structure 1831 ** flag -- flag to check 1832 ** 1833 ** Returns: 1834 ** sending allowed (in current state) 1835 */ 1836 1837 bool 1838 mi_sendok(ctx, flag) 1839 SMFICTX_PTR ctx; 1840 int flag; 1841 { 1842 if (ctx == NULL || ctx->ctx_smfi == NULL) 1843 return false; 1844 1845 /* did the milter request this operation? */ 1846 if (flag != 0 && !bitset(flag, ctx->ctx_aflags)) 1847 return false; 1848 1849 /* are we in the correct state? It must be "End of Message". */ 1850 return ctx->ctx_state == ST_ENDM; 1851 } 1852 1853 #if _FFR_WORKERS_POOL 1854 /* 1855 ** MI_RD_SOCKET_READY - checks if the socket is ready for read(2) 1856 ** 1857 ** Parameters: 1858 ** sd -- socket_t 1859 ** 1860 ** Returns: 1861 ** true iff socket is ready for read(2) 1862 */ 1863 1864 #define MI_RD_CMD_TO 1 1865 #define MI_RD_MAX_ERR 16 1866 1867 static bool 1868 mi_rd_socket_ready (sd) 1869 socket_t sd; 1870 { 1871 int n; 1872 int nerr = 0; 1873 #if SM_CONF_POLL 1874 struct pollfd pfd; 1875 #else 1876 fd_set rd_set, exc_set; 1877 #endif 1878 1879 do 1880 { 1881 #if SM_CONF_POLL 1882 pfd.fd = sd; 1883 pfd.events = POLLIN; 1884 pfd.revents = 0; 1885 1886 n = poll(&pfd, 1, MI_RD_CMD_TO); 1887 #else /* SM_CONF_POLL */ 1888 struct timeval timeout; 1889 1890 FD_ZERO(&rd_set); 1891 FD_ZERO(&exc_set); 1892 FD_SET(sd, &rd_set); 1893 FD_SET(sd, &exc_set); 1894 1895 timeout.tv_sec = MI_RD_CMD_TO / 1000; 1896 timeout.tv_usec = 0; 1897 n = select(sd + 1, &rd_set, NULL, &exc_set, &timeout); 1898 #endif /* SM_CONF_POLL */ 1899 1900 if (n < 0) 1901 { 1902 if (errno == EINTR) 1903 { 1904 nerr++; 1905 continue; 1906 } 1907 return true; 1908 } 1909 1910 if (n == 0) 1911 return false; 1912 break; 1913 } while (nerr < MI_RD_MAX_ERR); 1914 if (nerr >= MI_RD_MAX_ERR) 1915 return false; 1916 1917 #if SM_CONF_POLL 1918 return (pfd.revents != 0); 1919 #else 1920 return FD_ISSET(sd, &rd_set) || FD_ISSET(sd, &exc_set); 1921 #endif 1922 } 1923 #endif /* _FFR_WORKERS_POOL */ 1924