engine.c revision 285303
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> 12SM_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 /* NETINET || NETINET6 */ 19 20/* generic argument for functions in the command table */ 21struct 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 29typedef struct arg_struct genarg; 30 31/* structure for commands received from MTA */ 32struct 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 42typedef 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 67ERROR: do not compile with CI_LAST < CI_DATA 68#endif 69#if CI_LAST < CI_EOM 70ERROR: do not compile with CI_LAST < CI_EOM 71#endif 72#if CI_LAST < CI_EOH 73ERROR: do not compile with CI_LAST < CI_EOH 74#endif 75#if CI_LAST < CI_ENVRCPT 76ERROR: do not compile with CI_LAST < CI_ENVRCPT 77#endif 78#if CI_LAST < CI_ENVFROM 79ERROR: do not compile with CI_LAST < CI_ENVFROM 80#endif 81#if CI_LAST < CI_HELO 82ERROR: do not compile with CI_LAST < CI_HELO 83#endif 84#if CI_LAST < CI_CONNECT 85ERROR: do not compile with CI_LAST < CI_CONNECT 86#endif 87#if CI_LAST >= MAX_MACROS_ENTRIES 88ERROR: do not compile with CI_LAST >= MAX_MACROS_ENTRIES 89#endif 90 91/* function prototypes */ 92static int st_abortfct __P((genarg *)); 93static int st_macros __P((genarg *)); 94static int st_optionneg __P((genarg *)); 95static int st_bodychunk __P((genarg *)); 96static int st_connectinfo __P((genarg *)); 97static int st_bodyend __P((genarg *)); 98static int st_helo __P((genarg *)); 99static int st_header __P((genarg *)); 100static int st_sender __P((genarg *)); 101static int st_rcpt __P((genarg *)); 102static int st_unknown __P((genarg *)); 103static int st_data __P((genarg *)); 104static int st_eoh __P((genarg *)); 105static int st_quit __P((genarg *)); 106static int sendreply __P((sfsistat, socket_t, struct timeval *, SMFICTX_PTR)); 107static void fix_stm __P((SMFICTX_PTR)); 108static bool trans_ok __P((int, int)); 109static char **dec_argv __P((char *, size_t)); 110static int dec_arg2 __P((char *, size_t, char **, char **)); 111static void mi_clr_symlist __P((SMFICTX_PTR)); 112 113#if _FFR_WORKERS_POOL 114static bool mi_rd_socket_ready __P((int)); 115#endif /* _FFR_WORKERS_POOL */ 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 174static 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 */ 196static 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 237int 238mi_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 /* _FFR_WORKERS_POOL */ 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 /* _FFR_WORKERS_POOL */ 472 return ret; 473} 474 475static size_t milter_addsymlist __P((SMFICTX_PTR, char *, char **)); 476 477static size_t 478milter_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 555static unsigned long get_nr_bit __P((int)); 556 557static unsigned long 558get_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 612static int 613sendreply(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\n", 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 ret = mi_wr_cmd(sd, timeout_ptr, SMFIC_OPTNEG, 707 buffer, len); 708 else 709 ret = MI_FAILURE; 710 } 711 break; 712 case SMFIS_NOREPLY: 713 if (bit != 0 && 714 (ctx->ctx_pflags & bit) != 0 && 715 (ctx->ctx_mta_pflags & bit) == 0) 716 { 717 /* 718 ** milter doesn't want to send a reply, 719 ** but the MTA doesn't have that feature: fake it. 720 */ 721 722 ret = mi_wr_cmd(sd, timeout_ptr, SMFIR_CONTINUE, NULL, 723 0); 724 } 725 break; 726 default: /* don't send a reply */ 727 break; 728 } 729 return ret; 730} 731 732/* 733** MI_CLR_MACROS -- clear set of macros starting from a given index 734** 735** Parameters: 736** ctx -- context structure 737** m -- index from which to clear all macros 738** 739** Returns: 740** None. 741*/ 742 743void 744mi_clr_macros(ctx, m) 745 SMFICTX_PTR ctx; 746 int m; 747{ 748 int i; 749 750 for (i = m; i < MAX_MACROS_ENTRIES; i++) 751 { 752 if (ctx->ctx_mac_ptr[i] != NULL) 753 { 754 free(ctx->ctx_mac_ptr[i]); 755 ctx->ctx_mac_ptr[i] = NULL; 756 } 757 if (ctx->ctx_mac_buf[i] != NULL) 758 { 759 free(ctx->ctx_mac_buf[i]); 760 ctx->ctx_mac_buf[i] = NULL; 761 } 762 } 763} 764 765/* 766** MI_CLR_SYMLIST -- clear list of macros 767** 768** Parameters: 769** ctx -- context structure 770** 771** Returns: 772** None. 773*/ 774 775static void 776mi_clr_symlist(ctx) 777 SMFICTX *ctx; 778{ 779 int i; 780 781 SM_ASSERT(ctx != NULL); 782 for (i = SMFIM_FIRST; i <= SMFIM_LAST; i++) 783 { 784 if (ctx->ctx_mac_list[i] != NULL) 785 { 786 free(ctx->ctx_mac_list[i]); 787 ctx->ctx_mac_list[i] = NULL; 788 } 789 } 790} 791 792/* 793** MI_CLR_CTX -- clear context 794** 795** Parameters: 796** ctx -- context structure 797** 798** Returns: 799** None. 800*/ 801 802void 803mi_clr_ctx(ctx) 804 SMFICTX *ctx; 805{ 806 SM_ASSERT(ctx != NULL); 807 if (ValidSocket(ctx->ctx_sd)) 808 { 809 (void) closesocket(ctx->ctx_sd); 810 ctx->ctx_sd = INVALID_SOCKET; 811 } 812 if (ctx->ctx_reply != NULL) 813 { 814 free(ctx->ctx_reply); 815 ctx->ctx_reply = NULL; 816 } 817 if (ctx->ctx_privdata != NULL) 818 { 819 smi_log(SMI_LOG_WARN, 820 "%s: private data not NULL", 821 ctx->ctx_smfi->xxfi_name); 822 } 823 mi_clr_macros(ctx, 0); 824 mi_clr_symlist(ctx); 825 free(ctx); 826} 827 828/* 829** ST_OPTIONNEG -- negotiate options 830** 831** Parameters: 832** g -- generic argument structure 833** 834** Returns: 835** abort/send options/continue 836*/ 837 838static int 839st_optionneg(g) 840 genarg *g; 841{ 842 mi_int32 i, v, fake_pflags, internal_pflags; 843 SMFICTX_PTR ctx; 844#if _FFR_MILTER_CHECK 845 bool testmode = false; 846#endif /* _FFR_MILTER_CHECK */ 847 int (*fi_negotiate) __P((SMFICTX *, 848 unsigned long, unsigned long, 849 unsigned long, unsigned long, 850 unsigned long *, unsigned long *, 851 unsigned long *, unsigned long *)); 852 853 if (g == NULL || g->a_ctx->ctx_smfi == NULL) 854 return SMFIS_CONTINUE; 855 ctx = g->a_ctx; 856 mi_clr_macros(ctx, g->a_idx + 1); 857 ctx->ctx_prot_vers = SMFI_PROT_VERSION; 858 859 /* check for minimum length */ 860 if (g->a_len < MILTER_OPTLEN) 861 { 862 smi_log(SMI_LOG_ERR, 863 "%s: st_optionneg[%ld]: len too short %d < %d", 864 ctx->ctx_smfi->xxfi_name, 865 (long) ctx->ctx_id, (int) g->a_len, 866 MILTER_OPTLEN); 867 return _SMFIS_ABORT; 868 } 869 870 /* protocol version */ 871 (void) memcpy((void *) &i, (void *) &(g->a_buf[0]), MILTER_LEN_BYTES); 872 v = ntohl(i); 873 874#define SMFI_PROT_VERSION_MIN 2 875 876 /* check for minimum version */ 877 if (v < SMFI_PROT_VERSION_MIN) 878 { 879 smi_log(SMI_LOG_ERR, 880 "%s: st_optionneg[%ld]: protocol version too old %d < %d", 881 ctx->ctx_smfi->xxfi_name, 882 (long) ctx->ctx_id, v, SMFI_PROT_VERSION_MIN); 883 return _SMFIS_ABORT; 884 } 885 ctx->ctx_mta_prot_vers = v; 886 if (ctx->ctx_prot_vers < ctx->ctx_mta_prot_vers) 887 ctx->ctx_prot_vers2mta = ctx->ctx_prot_vers; 888 else 889 ctx->ctx_prot_vers2mta = ctx->ctx_mta_prot_vers; 890 891 (void) memcpy((void *) &i, (void *) &(g->a_buf[MILTER_LEN_BYTES]), 892 MILTER_LEN_BYTES); 893 v = ntohl(i); 894 895 /* no flags? set to default value for V1 actions */ 896 if (v == 0) 897 v = SMFI_V1_ACTS; 898 ctx->ctx_mta_aflags = v; /* MTA action flags */ 899 900 internal_pflags = 0; 901 (void) memcpy((void *) &i, (void *) &(g->a_buf[MILTER_LEN_BYTES * 2]), 902 MILTER_LEN_BYTES); 903 v = ntohl(i); 904 905 /* no flags? set to default value for V1 protocol */ 906 if (v == 0) 907 v = SMFI_V1_PROT; 908#if _FFR_MDS_NEGOTIATE 909 else if (ctx->ctx_smfi->xxfi_version >= SMFI_VERSION_MDS) 910 { 911 /* 912 ** Allow changing the size only if milter is compiled 913 ** against a version that supports this. 914 ** If a milter is dynamically linked against a newer 915 ** libmilter version, we don't want to "surprise" 916 ** it with a larger buffer as it may rely on it 917 ** even though it is not documented as a limit. 918 */ 919 920 if (bitset(SMFIP_MDS_1M, v)) 921 { 922 internal_pflags |= SMFIP_MDS_1M; 923 (void) smfi_setmaxdatasize(MILTER_MDS_1M); 924 } 925 else if (bitset(SMFIP_MDS_256K, v)) 926 { 927 internal_pflags |= SMFIP_MDS_256K; 928 (void) smfi_setmaxdatasize(MILTER_MDS_256K); 929 } 930 } 931# if 0 932 /* don't log this for now... */ 933 else if (ctx->ctx_smfi->xxfi_version < SMFI_VERSION_MDS && 934 bitset(SMFIP_MDS_1M|SMFIP_MDS_256K, v)) 935 { 936 smi_log(SMI_LOG_WARN, 937 "%s: st_optionneg[%ld]: milter version=%X, trying flags=%X", 938 ctx->ctx_smfi->xxfi_name, 939 (long) ctx->ctx_id, ctx->ctx_smfi->xxfi_version, v); 940 } 941# endif /* 0 */ 942#endif /* _FFR_MDS_NEGOTIATE */ 943 944 /* 945 ** MTA protocol flags. 946 ** We pass the internal flags to the milter as "read only", 947 ** i.e., a milter can read them so it knows which size 948 ** will be used, but any changes by a milter will be ignored 949 ** (see below, search for SMFI_INTERNAL). 950 */ 951 952 ctx->ctx_mta_pflags = (v & ~SMFI_INTERNAL) | internal_pflags; 953 954 /* 955 ** Copy flags from milter struct into libmilter context; 956 ** this variable will be used later on to check whether 957 ** the MTA "actions" can fulfill the milter requirements, 958 ** but it may be overwritten by the negotiate callback. 959 */ 960 961 ctx->ctx_aflags = ctx->ctx_smfi->xxfi_flags; 962 fake_pflags = SMFIP_NR_CONN 963 |SMFIP_NR_HELO 964 |SMFIP_NR_MAIL 965 |SMFIP_NR_RCPT 966 |SMFIP_NR_DATA 967 |SMFIP_NR_UNKN 968 |SMFIP_NR_HDR 969 |SMFIP_NR_EOH 970 |SMFIP_NR_BODY 971 ; 972 973 if (g->a_ctx->ctx_smfi != NULL && 974 g->a_ctx->ctx_smfi->xxfi_version > 4 && 975 (fi_negotiate = g->a_ctx->ctx_smfi->xxfi_negotiate) != NULL) 976 { 977 int r; 978 unsigned long m_aflags, m_pflags, m_f2, m_f3; 979 980 /* 981 ** let milter decide whether the features offered by the 982 ** MTA are "good enough". 983 ** Notes: 984 ** - libmilter can "fake" some features (e.g., SMFIP_NR_HDR) 985 ** - m_f2, m_f3 are for future extensions 986 */ 987 988 m_f2 = m_f3 = 0; 989 m_aflags = ctx->ctx_mta_aflags; 990 m_pflags = ctx->ctx_pflags; 991 if ((SMFIP_SKIP & ctx->ctx_mta_pflags) != 0) 992 m_pflags |= SMFIP_SKIP; 993 r = fi_negotiate(g->a_ctx, 994 ctx->ctx_mta_aflags, 995 ctx->ctx_mta_pflags|fake_pflags, 996 0, 0, 997 &m_aflags, &m_pflags, &m_f2, &m_f3); 998 999#if _FFR_MILTER_CHECK 1000 testmode = bitset(SMFIP_TEST, m_pflags); 1001 if (testmode) 1002 m_pflags &= ~SMFIP_TEST; 1003#endif /* _FFR_MILTER_CHECK */ 1004 1005 /* 1006 ** Types of protocol flags (pflags): 1007 ** 1. do NOT send protocol step X 1008 ** 2. MTA can do/understand something extra (SKIP, 1009 ** send unknown RCPTs) 1010 ** 3. MTA can deal with "no reply" for various protocol steps 1011 ** Note: this mean that it isn't possible to simply set all 1012 ** flags to get "everything": 1013 ** setting a flag of type 1 turns off a step 1014 ** (it should be the other way around: 1015 ** a flag means a protocol step can be sent) 1016 ** setting a flag of type 3 requires that milter 1017 ** never sends a reply for the corresponding step. 1018 ** Summary: the "negation" of protocol flags is causing 1019 ** problems, but at least for type 3 there is no simple 1020 ** solution. 1021 ** 1022 ** What should "all options" mean? 1023 ** send all protocol steps _except_ those for which there is 1024 ** no callback (currently registered in ctx_pflags) 1025 ** expect SKIP as return code? Yes 1026 ** send unknown RCPTs? No, 1027 ** must be explicitly requested? 1028 ** "no reply" for some protocol steps? No, 1029 ** must be explicitly requested. 1030 */ 1031 1032 if (SMFIS_ALL_OPTS == r) 1033 { 1034 ctx->ctx_aflags = ctx->ctx_mta_aflags; 1035 ctx->ctx_pflags2mta = ctx->ctx_pflags; 1036 if ((SMFIP_SKIP & ctx->ctx_mta_pflags) != 0) 1037 ctx->ctx_pflags2mta |= SMFIP_SKIP; 1038 } 1039 else if (r != SMFIS_CONTINUE) 1040 { 1041 smi_log(SMI_LOG_ERR, 1042 "%s: st_optionneg[%ld]: xxfi_negotiate returned %d (protocol options=0x%lx, actions=0x%lx)", 1043 ctx->ctx_smfi->xxfi_name, 1044 (long) ctx->ctx_id, r, ctx->ctx_mta_pflags, 1045 ctx->ctx_mta_aflags); 1046 return _SMFIS_ABORT; 1047 } 1048 else 1049 { 1050 ctx->ctx_aflags = m_aflags; 1051 ctx->ctx_pflags = m_pflags; 1052 ctx->ctx_pflags2mta = m_pflags; 1053 } 1054 1055 /* check whether some flags need to be "faked" */ 1056 i = ctx->ctx_pflags2mta; 1057 if ((ctx->ctx_mta_pflags & i) != i) 1058 { 1059 unsigned int idx; 1060 unsigned long b; 1061 1062 /* 1063 ** If some behavior can be faked (set in fake_pflags), 1064 ** but the MTA doesn't support it, then unset 1065 ** that flag in the value that is sent to the MTA. 1066 */ 1067 1068 for (idx = 0; idx < 32; idx++) 1069 { 1070 b = 1 << idx; 1071 if ((ctx->ctx_mta_pflags & b) != b && 1072 (fake_pflags & b) == b) 1073 ctx->ctx_pflags2mta &= ~b; 1074 } 1075 } 1076 } 1077 else 1078 { 1079 /* 1080 ** Set the protocol flags based on the values determined 1081 ** in mi_listener() which checked the defined callbacks. 1082 */ 1083 1084 ctx->ctx_pflags2mta = ctx->ctx_pflags; 1085 } 1086 1087 /* check whether actions and protocol requirements can be satisfied */ 1088 i = ctx->ctx_aflags; 1089 if ((i & ctx->ctx_mta_aflags) != i) 1090 { 1091 smi_log(SMI_LOG_ERR, 1092 "%s: st_optionneg[%ld]: 0x%lx does not fulfill action requirements 0x%x", 1093 ctx->ctx_smfi->xxfi_name, 1094 (long) ctx->ctx_id, ctx->ctx_mta_aflags, i); 1095 return _SMFIS_ABORT; 1096 } 1097 1098 i = ctx->ctx_pflags2mta; 1099 if ((ctx->ctx_mta_pflags & i) != i) 1100 { 1101 /* 1102 ** Older MTAs do not support some protocol steps. 1103 ** As this protocol is a bit "wierd" (it asks for steps 1104 ** NOT to be taken/sent) we have to check whether we 1105 ** should turn off those "negative" requests. 1106 ** Currently these are only SMFIP_NODATA and SMFIP_NOUNKNOWN. 1107 */ 1108 1109 if (bitset(SMFIP_NODATA, ctx->ctx_pflags2mta) && 1110 !bitset(SMFIP_NODATA, ctx->ctx_mta_pflags)) 1111 ctx->ctx_pflags2mta &= ~SMFIP_NODATA; 1112 if (bitset(SMFIP_NOUNKNOWN, ctx->ctx_pflags2mta) && 1113 !bitset(SMFIP_NOUNKNOWN, ctx->ctx_mta_pflags)) 1114 ctx->ctx_pflags2mta &= ~SMFIP_NOUNKNOWN; 1115 i = ctx->ctx_pflags2mta; 1116 } 1117 1118 if ((ctx->ctx_mta_pflags & i) != i) 1119 { 1120 smi_log(SMI_LOG_ERR, 1121 "%s: st_optionneg[%ld]: 0x%lx does not fulfill protocol requirements 0x%x", 1122 ctx->ctx_smfi->xxfi_name, 1123 (long) ctx->ctx_id, ctx->ctx_mta_pflags, i); 1124 return _SMFIS_ABORT; 1125 } 1126 fix_stm(ctx); 1127 1128 if (ctx->ctx_dbg > 3) 1129 sm_dprintf("[%lu] milter_negotiate:" 1130 " mta_actions=0x%lx, mta_flags=0x%lx" 1131 " actions=0x%lx, flags=0x%lx\n" 1132 , (long) ctx->ctx_id 1133 , ctx->ctx_mta_aflags, ctx->ctx_mta_pflags 1134 , ctx->ctx_aflags, ctx->ctx_pflags); 1135 1136#if _FFR_MILTER_CHECK 1137 if (ctx->ctx_dbg > 3) 1138 sm_dprintf("[%lu] milter_negotiate:" 1139 " testmode=%d, pflags2mta=%X, internal_pflags=%X\n" 1140 , (long) ctx->ctx_id, testmode 1141 , ctx->ctx_pflags2mta, internal_pflags); 1142 1143 /* in test mode: take flags without further modifications */ 1144 if (!testmode) 1145 /* Warning: check statement below! */ 1146#endif /* _FFR_MILTER_CHECK */ 1147 1148 /* 1149 ** Remove the internal flags that might have been set by a milter 1150 ** and set only those determined above. 1151 */ 1152 1153 ctx->ctx_pflags2mta = (ctx->ctx_pflags2mta & ~SMFI_INTERNAL) 1154 | internal_pflags; 1155 return _SMFIS_OPTIONS; 1156} 1157 1158/* 1159** ST_CONNECTINFO -- receive connection information 1160** 1161** Parameters: 1162** g -- generic argument structure 1163** 1164** Returns: 1165** continue or filter-specified value 1166*/ 1167 1168static int 1169st_connectinfo(g) 1170 genarg *g; 1171{ 1172 size_t l; 1173 size_t i; 1174 char *s, family; 1175 unsigned short port = 0; 1176 _SOCK_ADDR sockaddr; 1177 sfsistat (*fi_connect) __P((SMFICTX *, char *, _SOCK_ADDR *)); 1178 1179 if (g == NULL) 1180 return _SMFIS_ABORT; 1181 mi_clr_macros(g->a_ctx, g->a_idx + 1); 1182 if (g->a_ctx->ctx_smfi == NULL || 1183 (fi_connect = g->a_ctx->ctx_smfi->xxfi_connect) == NULL) 1184 return SMFIS_CONTINUE; 1185 1186 s = g->a_buf; 1187 i = 0; 1188 l = g->a_len; 1189 while (s[i] != '\0' && i <= l) 1190 ++i; 1191 if (i + 1 >= l) 1192 return _SMFIS_ABORT; 1193 1194 /* Move past trailing \0 in host string */ 1195 i++; 1196 family = s[i++]; 1197 (void) memset(&sockaddr, '\0', sizeof sockaddr); 1198 if (family != SMFIA_UNKNOWN) 1199 { 1200 if (i + sizeof port >= l) 1201 { 1202 smi_log(SMI_LOG_ERR, 1203 "%s: connect[%ld]: wrong len %d >= %d", 1204 g->a_ctx->ctx_smfi->xxfi_name, 1205 (long) g->a_ctx->ctx_id, (int) i, (int) l); 1206 return _SMFIS_ABORT; 1207 } 1208 (void) memcpy((void *) &port, (void *) (s + i), 1209 sizeof port); 1210 i += sizeof port; 1211 1212 /* make sure string is terminated */ 1213 if (s[l - 1] != '\0') 1214 return _SMFIS_ABORT; 1215# if NETINET 1216 if (family == SMFIA_INET) 1217 { 1218 if (inet_aton(s + i, (struct in_addr *) &sockaddr.sin.sin_addr) 1219 != 1) 1220 { 1221 smi_log(SMI_LOG_ERR, 1222 "%s: connect[%ld]: inet_aton failed", 1223 g->a_ctx->ctx_smfi->xxfi_name, 1224 (long) g->a_ctx->ctx_id); 1225 return _SMFIS_ABORT; 1226 } 1227 sockaddr.sa.sa_family = AF_INET; 1228 if (port > 0) 1229 sockaddr.sin.sin_port = port; 1230 } 1231 else 1232# endif /* NETINET */ 1233# if NETINET6 1234 if (family == SMFIA_INET6) 1235 { 1236 if (mi_inet_pton(AF_INET6, s + i, 1237 &sockaddr.sin6.sin6_addr) != 1) 1238 { 1239 smi_log(SMI_LOG_ERR, 1240 "%s: connect[%ld]: mi_inet_pton failed", 1241 g->a_ctx->ctx_smfi->xxfi_name, 1242 (long) g->a_ctx->ctx_id); 1243 return _SMFIS_ABORT; 1244 } 1245 sockaddr.sa.sa_family = AF_INET6; 1246 if (port > 0) 1247 sockaddr.sin6.sin6_port = port; 1248 } 1249 else 1250# endif /* NETINET6 */ 1251# if NETUNIX 1252 if (family == SMFIA_UNIX) 1253 { 1254 if (sm_strlcpy(sockaddr.sunix.sun_path, s + i, 1255 sizeof sockaddr.sunix.sun_path) >= 1256 sizeof sockaddr.sunix.sun_path) 1257 { 1258 smi_log(SMI_LOG_ERR, 1259 "%s: connect[%ld]: path too long", 1260 g->a_ctx->ctx_smfi->xxfi_name, 1261 (long) g->a_ctx->ctx_id); 1262 return _SMFIS_ABORT; 1263 } 1264 sockaddr.sunix.sun_family = AF_UNIX; 1265 } 1266 else 1267# endif /* NETUNIX */ 1268 { 1269 smi_log(SMI_LOG_ERR, 1270 "%s: connect[%ld]: unknown family %d", 1271 g->a_ctx->ctx_smfi->xxfi_name, 1272 (long) g->a_ctx->ctx_id, family); 1273 return _SMFIS_ABORT; 1274 } 1275 } 1276 return (*fi_connect)(g->a_ctx, g->a_buf, 1277 family != SMFIA_UNKNOWN ? &sockaddr : NULL); 1278} 1279 1280/* 1281** ST_EOH -- end of headers 1282** 1283** Parameters: 1284** g -- generic argument structure 1285** 1286** Returns: 1287** continue or filter-specified value 1288*/ 1289 1290static int 1291st_eoh(g) 1292 genarg *g; 1293{ 1294 sfsistat (*fi_eoh) __P((SMFICTX *)); 1295 1296 if (g == NULL) 1297 return _SMFIS_ABORT; 1298 if (g->a_ctx->ctx_smfi != NULL && 1299 (fi_eoh = g->a_ctx->ctx_smfi->xxfi_eoh) != NULL) 1300 return (*fi_eoh)(g->a_ctx); 1301 return SMFIS_CONTINUE; 1302} 1303 1304/* 1305** ST_DATA -- DATA command 1306** 1307** Parameters: 1308** g -- generic argument structure 1309** 1310** Returns: 1311** continue or filter-specified value 1312*/ 1313 1314static int 1315st_data(g) 1316 genarg *g; 1317{ 1318 sfsistat (*fi_data) __P((SMFICTX *)); 1319 1320 if (g == NULL) 1321 return _SMFIS_ABORT; 1322 if (g->a_ctx->ctx_smfi != NULL && 1323 g->a_ctx->ctx_smfi->xxfi_version > 3 && 1324 (fi_data = g->a_ctx->ctx_smfi->xxfi_data) != NULL) 1325 return (*fi_data)(g->a_ctx); 1326 return SMFIS_CONTINUE; 1327} 1328 1329/* 1330** ST_HELO -- helo/ehlo command 1331** 1332** Parameters: 1333** g -- generic argument structure 1334** 1335** Returns: 1336** continue or filter-specified value 1337*/ 1338 1339static int 1340st_helo(g) 1341 genarg *g; 1342{ 1343 sfsistat (*fi_helo) __P((SMFICTX *, char *)); 1344 1345 if (g == NULL) 1346 return _SMFIS_ABORT; 1347 mi_clr_macros(g->a_ctx, g->a_idx + 1); 1348 if (g->a_ctx->ctx_smfi != NULL && 1349 (fi_helo = g->a_ctx->ctx_smfi->xxfi_helo) != NULL) 1350 { 1351 /* paranoia: check for terminating '\0' */ 1352 if (g->a_len == 0 || g->a_buf[g->a_len - 1] != '\0') 1353 return MI_FAILURE; 1354 return (*fi_helo)(g->a_ctx, g->a_buf); 1355 } 1356 return SMFIS_CONTINUE; 1357} 1358 1359/* 1360** ST_HEADER -- header line 1361** 1362** Parameters: 1363** g -- generic argument structure 1364** 1365** Returns: 1366** continue or filter-specified value 1367*/ 1368 1369static int 1370st_header(g) 1371 genarg *g; 1372{ 1373 char *hf, *hv; 1374 sfsistat (*fi_header) __P((SMFICTX *, char *, char *)); 1375 1376 if (g == NULL) 1377 return _SMFIS_ABORT; 1378 if (g->a_ctx->ctx_smfi == NULL || 1379 (fi_header = g->a_ctx->ctx_smfi->xxfi_header) == NULL) 1380 return SMFIS_CONTINUE; 1381 if (dec_arg2(g->a_buf, g->a_len, &hf, &hv) == MI_SUCCESS) 1382 return (*fi_header)(g->a_ctx, hf, hv); 1383 else 1384 return _SMFIS_ABORT; 1385} 1386 1387#define ARGV_FCT(lf, rf, idx) \ 1388 char **argv; \ 1389 sfsistat (*lf) __P((SMFICTX *, char **)); \ 1390 int r; \ 1391 \ 1392 if (g == NULL) \ 1393 return _SMFIS_ABORT; \ 1394 mi_clr_macros(g->a_ctx, g->a_idx + 1); \ 1395 if (g->a_ctx->ctx_smfi == NULL || \ 1396 (lf = g->a_ctx->ctx_smfi->rf) == NULL) \ 1397 return SMFIS_CONTINUE; \ 1398 if ((argv = dec_argv(g->a_buf, g->a_len)) == NULL) \ 1399 return _SMFIS_ABORT; \ 1400 r = (*lf)(g->a_ctx, argv); \ 1401 free(argv); \ 1402 return r; 1403 1404/* 1405** ST_SENDER -- MAIL FROM command 1406** 1407** Parameters: 1408** g -- generic argument structure 1409** 1410** Returns: 1411** continue or filter-specified value 1412*/ 1413 1414static int 1415st_sender(g) 1416 genarg *g; 1417{ 1418 ARGV_FCT(fi_envfrom, xxfi_envfrom, CI_MAIL) 1419} 1420 1421/* 1422** ST_RCPT -- RCPT TO command 1423** 1424** Parameters: 1425** g -- generic argument structure 1426** 1427** Returns: 1428** continue or filter-specified value 1429*/ 1430 1431static int 1432st_rcpt(g) 1433 genarg *g; 1434{ 1435 ARGV_FCT(fi_envrcpt, xxfi_envrcpt, CI_RCPT) 1436} 1437 1438/* 1439** ST_UNKNOWN -- unrecognized or unimplemented command 1440** 1441** Parameters: 1442** g -- generic argument structure 1443** 1444** Returns: 1445** continue or filter-specified value 1446*/ 1447 1448static int 1449st_unknown(g) 1450 genarg *g; 1451{ 1452 sfsistat (*fi_unknown) __P((SMFICTX *, const char *)); 1453 1454 if (g == NULL) 1455 return _SMFIS_ABORT; 1456 if (g->a_ctx->ctx_smfi != NULL && 1457 g->a_ctx->ctx_smfi->xxfi_version > 2 && 1458 (fi_unknown = g->a_ctx->ctx_smfi->xxfi_unknown) != NULL) 1459 return (*fi_unknown)(g->a_ctx, (const char *) g->a_buf); 1460 return SMFIS_CONTINUE; 1461} 1462 1463/* 1464** ST_MACROS -- deal with macros received from the MTA 1465** 1466** Parameters: 1467** g -- generic argument structure 1468** 1469** Returns: 1470** continue/keep 1471** 1472** Side effects: 1473** set pointer in macro array to current values. 1474*/ 1475 1476static int 1477st_macros(g) 1478 genarg *g; 1479{ 1480 int i; 1481 char **argv; 1482 1483 if (g == NULL || g->a_len < 1) 1484 return _SMFIS_FAIL; 1485 if ((argv = dec_argv(g->a_buf + 1, g->a_len - 1)) == NULL) 1486 return _SMFIS_FAIL; 1487 switch (g->a_buf[0]) 1488 { 1489 case SMFIC_CONNECT: 1490 i = CI_CONN; 1491 break; 1492 case SMFIC_HELO: 1493 i = CI_HELO; 1494 break; 1495 case SMFIC_MAIL: 1496 i = CI_MAIL; 1497 break; 1498 case SMFIC_RCPT: 1499 i = CI_RCPT; 1500 break; 1501 case SMFIC_DATA: 1502 i = CI_DATA; 1503 break; 1504 case SMFIC_BODYEOB: 1505 i = CI_EOM; 1506 break; 1507 case SMFIC_EOH: 1508 i = CI_EOH; 1509 break; 1510 default: 1511 free(argv); 1512 return _SMFIS_FAIL; 1513 } 1514 if (g->a_ctx->ctx_mac_ptr[i] != NULL) 1515 free(g->a_ctx->ctx_mac_ptr[i]); 1516 if (g->a_ctx->ctx_mac_buf[i] != NULL) 1517 free(g->a_ctx->ctx_mac_buf[i]); 1518 g->a_ctx->ctx_mac_ptr[i] = argv; 1519 g->a_ctx->ctx_mac_buf[i] = g->a_buf; 1520 return _SMFIS_KEEP; 1521} 1522 1523/* 1524** ST_QUIT -- quit command 1525** 1526** Parameters: 1527** g -- generic argument structure 1528** 1529** Returns: 1530** noreply 1531*/ 1532 1533/* ARGSUSED */ 1534static int 1535st_quit(g) 1536 genarg *g; 1537{ 1538 sfsistat (*fi_close) __P((SMFICTX *)); 1539 1540 if (g == NULL) 1541 return _SMFIS_ABORT; 1542 if (g->a_ctx->ctx_smfi != NULL && 1543 (fi_close = g->a_ctx->ctx_smfi->xxfi_close) != NULL) 1544 (void) (*fi_close)(g->a_ctx); 1545 mi_clr_macros(g->a_ctx, 0); 1546 return _SMFIS_NOREPLY; 1547} 1548 1549/* 1550** ST_BODYCHUNK -- deal with a piece of the mail body 1551** 1552** Parameters: 1553** g -- generic argument structure 1554** 1555** Returns: 1556** continue or filter-specified value 1557*/ 1558 1559static int 1560st_bodychunk(g) 1561 genarg *g; 1562{ 1563 sfsistat (*fi_body) __P((SMFICTX *, unsigned char *, size_t)); 1564 1565 if (g == NULL) 1566 return _SMFIS_ABORT; 1567 if (g->a_ctx->ctx_smfi != NULL && 1568 (fi_body = g->a_ctx->ctx_smfi->xxfi_body) != NULL) 1569 return (*fi_body)(g->a_ctx, (unsigned char *)g->a_buf, 1570 g->a_len); 1571 return SMFIS_CONTINUE; 1572} 1573 1574/* 1575** ST_BODYEND -- deal with the last piece of the mail body 1576** 1577** Parameters: 1578** g -- generic argument structure 1579** 1580** Returns: 1581** continue or filter-specified value 1582** 1583** Side effects: 1584** sends a reply for the body part (if non-empty). 1585*/ 1586 1587static int 1588st_bodyend(g) 1589 genarg *g; 1590{ 1591 sfsistat r; 1592 sfsistat (*fi_body) __P((SMFICTX *, unsigned char *, size_t)); 1593 sfsistat (*fi_eom) __P((SMFICTX *)); 1594 1595 if (g == NULL) 1596 return _SMFIS_ABORT; 1597 r = SMFIS_CONTINUE; 1598 if (g->a_ctx->ctx_smfi != NULL) 1599 { 1600 if ((fi_body = g->a_ctx->ctx_smfi->xxfi_body) != NULL && 1601 g->a_len > 0) 1602 { 1603 socket_t sd; 1604 struct timeval timeout; 1605 1606 timeout.tv_sec = g->a_ctx->ctx_timeout; 1607 timeout.tv_usec = 0; 1608 sd = g->a_ctx->ctx_sd; 1609 r = (*fi_body)(g->a_ctx, (unsigned char *)g->a_buf, 1610 g->a_len); 1611 if (r != SMFIS_CONTINUE && 1612 sendreply(r, sd, &timeout, g->a_ctx) != MI_SUCCESS) 1613 return _SMFIS_ABORT; 1614 } 1615 } 1616 if (r == SMFIS_CONTINUE && 1617 (fi_eom = g->a_ctx->ctx_smfi->xxfi_eom) != NULL) 1618 return (*fi_eom)(g->a_ctx); 1619 return r; 1620} 1621 1622/* 1623** ST_ABORTFCT -- deal with aborts 1624** 1625** Parameters: 1626** g -- generic argument structure 1627** 1628** Returns: 1629** abort or filter-specified value 1630*/ 1631 1632static int 1633st_abortfct(g) 1634 genarg *g; 1635{ 1636 sfsistat (*fi_abort) __P((SMFICTX *)); 1637 1638 if (g == NULL) 1639 return _SMFIS_ABORT; 1640 if (g != NULL && g->a_ctx->ctx_smfi != NULL && 1641 (fi_abort = g->a_ctx->ctx_smfi->xxfi_abort) != NULL) 1642 (void) (*fi_abort)(g->a_ctx); 1643 return _SMFIS_NOREPLY; 1644} 1645 1646/* 1647** TRANS_OK -- is the state transition ok? 1648** 1649** Parameters: 1650** old -- old state 1651** new -- new state 1652** 1653** Returns: 1654** state transition ok 1655*/ 1656 1657static bool 1658trans_ok(old, new) 1659 int old, new; 1660{ 1661 int s, n; 1662 1663 s = old; 1664 if (s >= SIZE_NEXT_STATES) 1665 return false; 1666 do 1667 { 1668 /* is this state transition allowed? */ 1669 if ((MI_MASK(new) & next_states[s]) != 0) 1670 return true; 1671 1672 /* 1673 ** no: try next state; 1674 ** this works since the relevant states are ordered 1675 ** strict sequentially 1676 */ 1677 1678 n = s + 1; 1679 if (n >= SIZE_NEXT_STATES) 1680 return false; 1681 1682 /* 1683 ** can we actually "skip" this state? 1684 ** see fix_stm() which sets this bit for those 1685 ** states which the filter program is not interested in 1686 */ 1687 1688 if (bitset(NX_SKIP, next_states[n])) 1689 s = n; 1690 else 1691 return false; 1692 } while (s < SIZE_NEXT_STATES); 1693 return false; 1694} 1695 1696/* 1697** FIX_STM -- add "skip" bits to the state transition table 1698** 1699** Parameters: 1700** ctx -- context structure 1701** 1702** Returns: 1703** None. 1704** 1705** Side effects: 1706** may change state transition table. 1707*/ 1708 1709static void 1710fix_stm(ctx) 1711 SMFICTX_PTR ctx; 1712{ 1713 unsigned long fl; 1714 1715 if (ctx == NULL || ctx->ctx_smfi == NULL) 1716 return; 1717 fl = ctx->ctx_pflags; 1718 if (bitset(SMFIP_NOCONNECT, fl)) 1719 next_states[ST_CONN] |= NX_SKIP; 1720 if (bitset(SMFIP_NOHELO, fl)) 1721 next_states[ST_HELO] |= NX_SKIP; 1722 if (bitset(SMFIP_NOMAIL, fl)) 1723 next_states[ST_MAIL] |= NX_SKIP; 1724 if (bitset(SMFIP_NORCPT, fl)) 1725 next_states[ST_RCPT] |= NX_SKIP; 1726 if (bitset(SMFIP_NOHDRS, fl)) 1727 next_states[ST_HDRS] |= NX_SKIP; 1728 if (bitset(SMFIP_NOEOH, fl)) 1729 next_states[ST_EOHS] |= NX_SKIP; 1730 if (bitset(SMFIP_NOBODY, fl)) 1731 next_states[ST_BODY] |= NX_SKIP; 1732 if (bitset(SMFIP_NODATA, fl)) 1733 next_states[ST_DATA] |= NX_SKIP; 1734 if (bitset(SMFIP_NOUNKNOWN, fl)) 1735 next_states[ST_UNKN] |= NX_SKIP; 1736} 1737 1738/* 1739** DEC_ARGV -- split a buffer into a list of strings, NULL terminated 1740** 1741** Parameters: 1742** buf -- buffer with several strings 1743** len -- length of buffer 1744** 1745** Returns: 1746** array of pointers to the individual strings 1747*/ 1748 1749static char ** 1750dec_argv(buf, len) 1751 char *buf; 1752 size_t len; 1753{ 1754 char **s; 1755 size_t i; 1756 int elem, nelem; 1757 1758 nelem = 0; 1759 for (i = 0; i < len; i++) 1760 { 1761 if (buf[i] == '\0') 1762 ++nelem; 1763 } 1764 if (nelem == 0) 1765 return NULL; 1766 1767 /* last entry is only for the name */ 1768 s = (char **)malloc((nelem + 1) * (sizeof *s)); 1769 if (s == NULL) 1770 return NULL; 1771 s[0] = buf; 1772 for (i = 0, elem = 0; i < len && elem < nelem; i++) 1773 { 1774 if (buf[i] == '\0') 1775 { 1776 ++elem; 1777 if (i + 1 >= len) 1778 s[elem] = NULL; 1779 else 1780 s[elem] = &(buf[i + 1]); 1781 } 1782 } 1783 1784 /* overwrite last entry (already done above, just paranoia) */ 1785 s[elem] = NULL; 1786 return s; 1787} 1788 1789/* 1790** DEC_ARG2 -- split a buffer into two strings 1791** 1792** Parameters: 1793** buf -- buffer with two strings 1794** len -- length of buffer 1795** s1,s2 -- pointer to result strings 1796** 1797** Returns: 1798** MI_FAILURE/MI_SUCCESS 1799*/ 1800 1801static int 1802dec_arg2(buf, len, s1, s2) 1803 char *buf; 1804 size_t len; 1805 char **s1; 1806 char **s2; 1807{ 1808 size_t i; 1809 1810 /* paranoia: check for terminating '\0' */ 1811 if (len == 0 || buf[len - 1] != '\0') 1812 return MI_FAILURE; 1813 *s1 = buf; 1814 for (i = 1; i < len && buf[i] != '\0'; i++) 1815 continue; 1816 if (i >= len - 1) 1817 return MI_FAILURE; 1818 *s2 = buf + i + 1; 1819 return MI_SUCCESS; 1820} 1821 1822/* 1823** MI_SENDOK -- is it ok for the filter to send stuff to the MTA? 1824** 1825** Parameters: 1826** ctx -- context structure 1827** flag -- flag to check 1828** 1829** Returns: 1830** sending allowed (in current state) 1831*/ 1832 1833bool 1834mi_sendok(ctx, flag) 1835 SMFICTX_PTR ctx; 1836 int flag; 1837{ 1838 if (ctx == NULL || ctx->ctx_smfi == NULL) 1839 return false; 1840 1841 /* did the milter request this operation? */ 1842 if (flag != 0 && !bitset(flag, ctx->ctx_aflags)) 1843 return false; 1844 1845 /* are we in the correct state? It must be "End of Message". */ 1846 return ctx->ctx_state == ST_ENDM; 1847} 1848 1849#if _FFR_WORKERS_POOL 1850/* 1851** MI_RD_SOCKET_READY - checks if the socket is ready for read(2) 1852** 1853** Parameters: 1854** sd -- socket_t 1855** 1856** Returns: 1857** true iff socket is ready for read(2) 1858*/ 1859 1860#define MI_RD_CMD_TO 1 1861#define MI_RD_MAX_ERR 16 1862 1863static bool 1864mi_rd_socket_ready (sd) 1865 socket_t sd; 1866{ 1867 int n; 1868 int nerr = 0; 1869#if SM_CONF_POLL 1870 struct pollfd pfd; 1871#else /* SM_CONF_POLL */ 1872 fd_set rd_set, exc_set; 1873#endif /* SM_CONF_POLL */ 1874 1875 do 1876 { 1877#if SM_CONF_POLL 1878 pfd.fd = sd; 1879 pfd.events = POLLIN; 1880 pfd.revents = 0; 1881 1882 n = poll(&pfd, 1, MI_RD_CMD_TO); 1883#else /* SM_CONF_POLL */ 1884 struct timeval timeout; 1885 1886 FD_ZERO(&rd_set); 1887 FD_ZERO(&exc_set); 1888 FD_SET(sd, &rd_set); 1889 FD_SET(sd, &exc_set); 1890 1891 timeout.tv_sec = MI_RD_CMD_TO / 1000; 1892 timeout.tv_usec = 0; 1893 n = select(sd + 1, &rd_set, NULL, &exc_set, &timeout); 1894#endif /* SM_CONF_POLL */ 1895 1896 if (n < 0) 1897 { 1898 if (errno == EINTR) 1899 { 1900 nerr++; 1901 continue; 1902 } 1903 return true; 1904 } 1905 1906 if (n == 0) 1907 return false; 1908 break; 1909 } while (nerr < MI_RD_MAX_ERR); 1910 if (nerr >= MI_RD_MAX_ERR) 1911 return false; 1912 1913#if SM_CONF_POLL 1914 return (pfd.revents != 0); 1915#else /* SM_CONF_POLL */ 1916 return FD_ISSET(sd, &rd_set) || FD_ISSET(sd, &exc_set); 1917#endif /* SM_CONF_POLL */ 1918} 1919#endif /* _FFR_WORKERS_POOL */ 1920