17c478bd9Sstevel@tonic-gate /* 2*d4660949Sjbeck * Copyright (c) 1999-2004, 2006-2008 Sendmail, Inc. and its suppliers. 37c478bd9Sstevel@tonic-gate * All rights reserved. 47c478bd9Sstevel@tonic-gate * 57c478bd9Sstevel@tonic-gate * By using this file, you agree to the terms and conditions set 67c478bd9Sstevel@tonic-gate * forth in the LICENSE file which can be found at the top level of 77c478bd9Sstevel@tonic-gate * the sendmail distribution. 87c478bd9Sstevel@tonic-gate * 97c478bd9Sstevel@tonic-gate */ 107c478bd9Sstevel@tonic-gate 117c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 127c478bd9Sstevel@tonic-gate 137c478bd9Sstevel@tonic-gate #include <sm/gen.h> 14*d4660949Sjbeck SM_RCSID("@(#)$Id: engine.c,v 8.162 2008/02/27 01:34:14 ca Exp $") 157c478bd9Sstevel@tonic-gate 167c478bd9Sstevel@tonic-gate #include "libmilter.h" 177c478bd9Sstevel@tonic-gate 187c478bd9Sstevel@tonic-gate #if NETINET || NETINET6 197c478bd9Sstevel@tonic-gate # include <arpa/inet.h> 207c478bd9Sstevel@tonic-gate #endif /* NETINET || NETINET6 */ 217c478bd9Sstevel@tonic-gate 227c478bd9Sstevel@tonic-gate /* generic argument for functions in the command table */ 237c478bd9Sstevel@tonic-gate struct arg_struct 247c478bd9Sstevel@tonic-gate { 257c478bd9Sstevel@tonic-gate size_t a_len; /* length of buffer */ 267c478bd9Sstevel@tonic-gate char *a_buf; /* argument string */ 277c478bd9Sstevel@tonic-gate int a_idx; /* index for macro array */ 287c478bd9Sstevel@tonic-gate SMFICTX_PTR a_ctx; /* context */ 297c478bd9Sstevel@tonic-gate }; 307c478bd9Sstevel@tonic-gate 317c478bd9Sstevel@tonic-gate typedef struct arg_struct genarg; 327c478bd9Sstevel@tonic-gate 337c478bd9Sstevel@tonic-gate /* structure for commands received from MTA */ 347c478bd9Sstevel@tonic-gate struct cmdfct_t 357c478bd9Sstevel@tonic-gate { 367c478bd9Sstevel@tonic-gate char cm_cmd; /* command */ 377c478bd9Sstevel@tonic-gate int cm_argt; /* type of arguments expected */ 387c478bd9Sstevel@tonic-gate int cm_next; /* next state */ 397c478bd9Sstevel@tonic-gate int cm_todo; /* what to do next */ 407c478bd9Sstevel@tonic-gate int cm_macros; /* index for macros */ 417c478bd9Sstevel@tonic-gate int (*cm_fct) __P((genarg *)); /* function to execute */ 427c478bd9Sstevel@tonic-gate }; 437c478bd9Sstevel@tonic-gate 447c478bd9Sstevel@tonic-gate typedef struct cmdfct_t cmdfct; 457c478bd9Sstevel@tonic-gate 467c478bd9Sstevel@tonic-gate /* possible values for cm_argt */ 477c478bd9Sstevel@tonic-gate #define CM_ARG0 0 /* no args */ 487c478bd9Sstevel@tonic-gate #define CM_ARG1 1 /* one arg (string) */ 497c478bd9Sstevel@tonic-gate #define CM_ARG2 2 /* two args (strings) */ 507c478bd9Sstevel@tonic-gate #define CM_ARGA 4 /* one string and _SOCK_ADDR */ 517c478bd9Sstevel@tonic-gate #define CM_ARGO 5 /* two integers */ 527c478bd9Sstevel@tonic-gate #define CM_ARGV 8 /* \0 separated list of args, NULL-terminated */ 537c478bd9Sstevel@tonic-gate #define CM_ARGN 9 /* \0 separated list of args (strings) */ 547c478bd9Sstevel@tonic-gate 557c478bd9Sstevel@tonic-gate /* possible values for cm_todo */ 567c478bd9Sstevel@tonic-gate #define CT_CONT 0x0000 /* continue reading commands */ 577c478bd9Sstevel@tonic-gate #define CT_IGNO 0x0001 /* continue even when error */ 587c478bd9Sstevel@tonic-gate 597c478bd9Sstevel@tonic-gate /* not needed right now, done via return code instead */ 607c478bd9Sstevel@tonic-gate #define CT_KEEP 0x0004 /* keep buffer (contains symbols) */ 61058561cbSjbeck #define CT_END 0x0008 /* last command of session, stop replying */ 627c478bd9Sstevel@tonic-gate 637c478bd9Sstevel@tonic-gate /* index in macro array: macros only for these commands */ 647c478bd9Sstevel@tonic-gate #define CI_NONE (-1) 657c478bd9Sstevel@tonic-gate #define CI_CONN 0 667c478bd9Sstevel@tonic-gate #define CI_HELO 1 677c478bd9Sstevel@tonic-gate #define CI_MAIL 2 687c478bd9Sstevel@tonic-gate #define CI_RCPT 3 69058561cbSjbeck #define CI_DATA 4 70058561cbSjbeck #define CI_EOM 5 71058561cbSjbeck #define CI_EOH 6 72058561cbSjbeck #define CI_LAST CI_EOH 73058561cbSjbeck #if CI_LAST < CI_DATA 74058561cbSjbeck ERROR: do not compile with CI_LAST < CI_DATA 75058561cbSjbeck #endif 76058561cbSjbeck #if CI_LAST < CI_EOM 77058561cbSjbeck ERROR: do not compile with CI_LAST < CI_EOM 78058561cbSjbeck #endif 79058561cbSjbeck #if CI_LAST < CI_EOH 80058561cbSjbeck ERROR: do not compile with CI_LAST < CI_EOH 81058561cbSjbeck #endif 82058561cbSjbeck #if CI_LAST < CI_ENVRCPT 83058561cbSjbeck ERROR: do not compile with CI_LAST < CI_ENVRCPT 84058561cbSjbeck #endif 85058561cbSjbeck #if CI_LAST < CI_ENVFROM 86058561cbSjbeck ERROR: do not compile with CI_LAST < CI_ENVFROM 87058561cbSjbeck #endif 88058561cbSjbeck #if CI_LAST < CI_HELO 89058561cbSjbeck ERROR: do not compile with CI_LAST < CI_HELO 90058561cbSjbeck #endif 91058561cbSjbeck #if CI_LAST < CI_CONNECT 92058561cbSjbeck ERROR: do not compile with CI_LAST < CI_CONNECT 93058561cbSjbeck #endif 94058561cbSjbeck #if CI_LAST >= MAX_MACROS_ENTRIES 95058561cbSjbeck ERROR: do not compile with CI_LAST >= MAX_MACROS_ENTRIES 967c478bd9Sstevel@tonic-gate #endif 977c478bd9Sstevel@tonic-gate 987c478bd9Sstevel@tonic-gate /* function prototypes */ 997c478bd9Sstevel@tonic-gate static int st_abortfct __P((genarg *)); 1007c478bd9Sstevel@tonic-gate static int st_macros __P((genarg *)); 1017c478bd9Sstevel@tonic-gate static int st_optionneg __P((genarg *)); 1027c478bd9Sstevel@tonic-gate static int st_bodychunk __P((genarg *)); 1037c478bd9Sstevel@tonic-gate static int st_connectinfo __P((genarg *)); 1047c478bd9Sstevel@tonic-gate static int st_bodyend __P((genarg *)); 1057c478bd9Sstevel@tonic-gate static int st_helo __P((genarg *)); 1067c478bd9Sstevel@tonic-gate static int st_header __P((genarg *)); 1077c478bd9Sstevel@tonic-gate static int st_sender __P((genarg *)); 1087c478bd9Sstevel@tonic-gate static int st_rcpt __P((genarg *)); 1097c478bd9Sstevel@tonic-gate static int st_unknown __P((genarg *)); 1107c478bd9Sstevel@tonic-gate static int st_data __P((genarg *)); 1117c478bd9Sstevel@tonic-gate static int st_eoh __P((genarg *)); 1127c478bd9Sstevel@tonic-gate static int st_quit __P((genarg *)); 1137c478bd9Sstevel@tonic-gate static int sendreply __P((sfsistat, socket_t, struct timeval *, SMFICTX_PTR)); 1147c478bd9Sstevel@tonic-gate static void fix_stm __P((SMFICTX_PTR)); 1157c478bd9Sstevel@tonic-gate static bool trans_ok __P((int, int)); 1167c478bd9Sstevel@tonic-gate static char **dec_argv __P((char *, size_t)); 1177c478bd9Sstevel@tonic-gate static int dec_arg2 __P((char *, size_t, char **, char **)); 1187c478bd9Sstevel@tonic-gate 119058561cbSjbeck #if _FFR_WORKERS_POOL 120058561cbSjbeck static bool mi_rd_socket_ready __P((int)); 121058561cbSjbeck #endif /* _FFR_WORKERS_POOL */ 122058561cbSjbeck 1237c478bd9Sstevel@tonic-gate /* states */ 1247c478bd9Sstevel@tonic-gate #define ST_NONE (-1) 1257c478bd9Sstevel@tonic-gate #define ST_INIT 0 /* initial state */ 1267c478bd9Sstevel@tonic-gate #define ST_OPTS 1 /* option negotiation */ 1277c478bd9Sstevel@tonic-gate #define ST_CONN 2 /* connection info */ 1287c478bd9Sstevel@tonic-gate #define ST_HELO 3 /* helo */ 1297c478bd9Sstevel@tonic-gate #define ST_MAIL 4 /* mail from */ 1307c478bd9Sstevel@tonic-gate #define ST_RCPT 5 /* rcpt to */ 1317c478bd9Sstevel@tonic-gate #define ST_DATA 6 /* data */ 1327c478bd9Sstevel@tonic-gate #define ST_HDRS 7 /* headers */ 1337c478bd9Sstevel@tonic-gate #define ST_EOHS 8 /* end of headers */ 1347c478bd9Sstevel@tonic-gate #define ST_BODY 9 /* body */ 1357c478bd9Sstevel@tonic-gate #define ST_ENDM 10 /* end of message */ 1367c478bd9Sstevel@tonic-gate #define ST_QUIT 11 /* quit */ 1377c478bd9Sstevel@tonic-gate #define ST_ABRT 12 /* abort */ 1387c478bd9Sstevel@tonic-gate #define ST_UNKN 13 /* unknown SMTP command */ 139058561cbSjbeck #define ST_Q_NC 14 /* quit, new connection follows */ 140058561cbSjbeck #define ST_LAST ST_Q_NC /* last valid state */ 141058561cbSjbeck #define ST_SKIP 16 /* not a state but required for the state table */ 1427c478bd9Sstevel@tonic-gate 1437c478bd9Sstevel@tonic-gate /* in a mail transaction? must be before eom according to spec. */ 1447c478bd9Sstevel@tonic-gate #define ST_IN_MAIL(st) ((st) >= ST_MAIL && (st) < ST_ENDM) 1457c478bd9Sstevel@tonic-gate 1467c478bd9Sstevel@tonic-gate /* 1477c478bd9Sstevel@tonic-gate ** set of next states 1487c478bd9Sstevel@tonic-gate ** each state (ST_*) corresponds to bit in an int value (1 << state) 1497c478bd9Sstevel@tonic-gate ** each state has a set of allowed transitions ('or' of bits of states) 1507c478bd9Sstevel@tonic-gate ** so a state transition is valid if the mask of the next state 1517c478bd9Sstevel@tonic-gate ** is set in the NX_* value 1527c478bd9Sstevel@tonic-gate ** this function is coded in trans_ok(), see below. 1537c478bd9Sstevel@tonic-gate */ 1547c478bd9Sstevel@tonic-gate 1557c478bd9Sstevel@tonic-gate #define MI_MASK(x) (0x0001 << (x)) /* generate a bit "mask" for a state */ 1567c478bd9Sstevel@tonic-gate #define NX_INIT (MI_MASK(ST_OPTS)) 1577c478bd9Sstevel@tonic-gate #define NX_OPTS (MI_MASK(ST_CONN) | MI_MASK(ST_UNKN)) 1587c478bd9Sstevel@tonic-gate #define NX_CONN (MI_MASK(ST_HELO) | MI_MASK(ST_MAIL) | MI_MASK(ST_UNKN)) 1597c478bd9Sstevel@tonic-gate #define NX_HELO (MI_MASK(ST_HELO) | MI_MASK(ST_MAIL) | MI_MASK(ST_UNKN)) 1607c478bd9Sstevel@tonic-gate #define NX_MAIL (MI_MASK(ST_RCPT) | MI_MASK(ST_ABRT) | MI_MASK(ST_UNKN)) 1617c478bd9Sstevel@tonic-gate #define NX_RCPT (MI_MASK(ST_HDRS) | MI_MASK(ST_EOHS) | MI_MASK(ST_DATA) | \ 1627c478bd9Sstevel@tonic-gate MI_MASK(ST_BODY) | MI_MASK(ST_ENDM) | \ 1637c478bd9Sstevel@tonic-gate MI_MASK(ST_RCPT) | MI_MASK(ST_ABRT) | MI_MASK(ST_UNKN)) 1647c478bd9Sstevel@tonic-gate #define NX_DATA (MI_MASK(ST_EOHS) | MI_MASK(ST_HDRS) | MI_MASK(ST_ABRT)) 1657c478bd9Sstevel@tonic-gate #define NX_HDRS (MI_MASK(ST_EOHS) | MI_MASK(ST_HDRS) | MI_MASK(ST_ABRT)) 1667c478bd9Sstevel@tonic-gate #define NX_EOHS (MI_MASK(ST_BODY) | MI_MASK(ST_ENDM) | MI_MASK(ST_ABRT)) 1677c478bd9Sstevel@tonic-gate #define NX_BODY (MI_MASK(ST_ENDM) | MI_MASK(ST_BODY) | MI_MASK(ST_ABRT)) 168058561cbSjbeck #define NX_ENDM (MI_MASK(ST_QUIT) | MI_MASK(ST_MAIL) | MI_MASK(ST_UNKN) | \ 169058561cbSjbeck MI_MASK(ST_Q_NC)) 1707c478bd9Sstevel@tonic-gate #define NX_QUIT 0 1717c478bd9Sstevel@tonic-gate #define NX_ABRT 0 1727c478bd9Sstevel@tonic-gate #define NX_UNKN (MI_MASK(ST_HELO) | MI_MASK(ST_MAIL) | \ 1737c478bd9Sstevel@tonic-gate MI_MASK(ST_RCPT) | MI_MASK(ST_ABRT) | \ 1747c478bd9Sstevel@tonic-gate MI_MASK(ST_DATA) | \ 1757c478bd9Sstevel@tonic-gate MI_MASK(ST_BODY) | MI_MASK(ST_UNKN) | \ 176058561cbSjbeck MI_MASK(ST_ABRT) | MI_MASK(ST_QUIT) | MI_MASK(ST_Q_NC)) 177058561cbSjbeck #define NX_Q_NC (MI_MASK(ST_CONN) | MI_MASK(ST_UNKN)) 1787c478bd9Sstevel@tonic-gate #define NX_SKIP MI_MASK(ST_SKIP) 1797c478bd9Sstevel@tonic-gate 1807c478bd9Sstevel@tonic-gate static int next_states[] = 1817c478bd9Sstevel@tonic-gate { 182058561cbSjbeck NX_INIT 183058561cbSjbeck , NX_OPTS 184058561cbSjbeck , NX_CONN 185058561cbSjbeck , NX_HELO 186058561cbSjbeck , NX_MAIL 187058561cbSjbeck , NX_RCPT 188058561cbSjbeck , NX_DATA 189058561cbSjbeck , NX_HDRS 190058561cbSjbeck , NX_EOHS 191058561cbSjbeck , NX_BODY 192058561cbSjbeck , NX_ENDM 193058561cbSjbeck , NX_QUIT 194058561cbSjbeck , NX_ABRT 195058561cbSjbeck , NX_UNKN 196058561cbSjbeck , NX_Q_NC 1977c478bd9Sstevel@tonic-gate }; 1987c478bd9Sstevel@tonic-gate 1993ee0e492Sjbeck #define SIZE_NEXT_STATES (sizeof(next_states) / sizeof(next_states[0])) 2003ee0e492Sjbeck 2017c478bd9Sstevel@tonic-gate /* commands received by milter */ 2027c478bd9Sstevel@tonic-gate static cmdfct cmds[] = 2037c478bd9Sstevel@tonic-gate { 204058561cbSjbeck {SMFIC_ABORT, CM_ARG0, ST_ABRT, CT_CONT, CI_NONE, st_abortfct } 205058561cbSjbeck , {SMFIC_MACRO, CM_ARGV, ST_NONE, CT_KEEP, CI_NONE, st_macros } 206058561cbSjbeck , {SMFIC_BODY, CM_ARG1, ST_BODY, CT_CONT, CI_NONE, st_bodychunk } 207058561cbSjbeck , {SMFIC_CONNECT, CM_ARG2, ST_CONN, CT_CONT, CI_CONN, st_connectinfo } 208058561cbSjbeck , {SMFIC_BODYEOB, CM_ARG1, ST_ENDM, CT_CONT, CI_EOM, st_bodyend } 209058561cbSjbeck , {SMFIC_HELO, CM_ARG1, ST_HELO, CT_CONT, CI_HELO, st_helo } 210058561cbSjbeck , {SMFIC_HEADER, CM_ARG2, ST_HDRS, CT_CONT, CI_NONE, st_header } 211058561cbSjbeck , {SMFIC_MAIL, CM_ARGV, ST_MAIL, CT_CONT, CI_MAIL, st_sender } 212058561cbSjbeck , {SMFIC_OPTNEG, CM_ARGO, ST_OPTS, CT_CONT, CI_NONE, st_optionneg } 213058561cbSjbeck , {SMFIC_EOH, CM_ARG0, ST_EOHS, CT_CONT, CI_EOH, st_eoh } 214058561cbSjbeck , {SMFIC_QUIT, CM_ARG0, ST_QUIT, CT_END, CI_NONE, st_quit } 215058561cbSjbeck , {SMFIC_DATA, CM_ARG0, ST_DATA, CT_CONT, CI_DATA, st_data } 216058561cbSjbeck , {SMFIC_RCPT, CM_ARGV, ST_RCPT, CT_IGNO, CI_RCPT, st_rcpt } 2177c478bd9Sstevel@tonic-gate , {SMFIC_UNKNOWN, CM_ARG1, ST_UNKN, CT_IGNO, CI_NONE, st_unknown } 218058561cbSjbeck , {SMFIC_QUIT_NC, CM_ARG0, ST_Q_NC, CT_CONT, CI_NONE, st_quit } 2197c478bd9Sstevel@tonic-gate }; 2207c478bd9Sstevel@tonic-gate 221058561cbSjbeck /* 222058561cbSjbeck ** Additional (internal) reply codes; 223058561cbSjbeck ** must be coordinated wit libmilter/mfapi.h 224058561cbSjbeck */ 225058561cbSjbeck 2267c478bd9Sstevel@tonic-gate #define _SMFIS_KEEP 20 2277c478bd9Sstevel@tonic-gate #define _SMFIS_ABORT 21 2287c478bd9Sstevel@tonic-gate #define _SMFIS_OPTIONS 22 229058561cbSjbeck #define _SMFIS_NOREPLY SMFIS_NOREPLY 2307c478bd9Sstevel@tonic-gate #define _SMFIS_FAIL (-1) 2317c478bd9Sstevel@tonic-gate #define _SMFIS_NONE (-2) 2327c478bd9Sstevel@tonic-gate 2337c478bd9Sstevel@tonic-gate /* 2347c478bd9Sstevel@tonic-gate ** MI_ENGINE -- receive commands and process them 2357c478bd9Sstevel@tonic-gate ** 2367c478bd9Sstevel@tonic-gate ** Parameters: 2377c478bd9Sstevel@tonic-gate ** ctx -- context structure 2387c478bd9Sstevel@tonic-gate ** 2397c478bd9Sstevel@tonic-gate ** Returns: 2407c478bd9Sstevel@tonic-gate ** MI_FAILURE/MI_SUCCESS 2417c478bd9Sstevel@tonic-gate */ 242058561cbSjbeck 2437c478bd9Sstevel@tonic-gate int 2447c478bd9Sstevel@tonic-gate mi_engine(ctx) 2457c478bd9Sstevel@tonic-gate SMFICTX_PTR ctx; 2467c478bd9Sstevel@tonic-gate { 2477c478bd9Sstevel@tonic-gate size_t len; 2487c478bd9Sstevel@tonic-gate int i; 2497c478bd9Sstevel@tonic-gate socket_t sd; 2507c478bd9Sstevel@tonic-gate int ret = MI_SUCCESS; 2517c478bd9Sstevel@tonic-gate int ncmds = sizeof(cmds) / sizeof(cmdfct); 2527c478bd9Sstevel@tonic-gate int curstate = ST_INIT; 2537c478bd9Sstevel@tonic-gate int newstate; 2547c478bd9Sstevel@tonic-gate bool call_abort; 2557c478bd9Sstevel@tonic-gate sfsistat r; 2567c478bd9Sstevel@tonic-gate char cmd; 2577c478bd9Sstevel@tonic-gate char *buf = NULL; 2587c478bd9Sstevel@tonic-gate genarg arg; 2597c478bd9Sstevel@tonic-gate struct timeval timeout; 2607c478bd9Sstevel@tonic-gate int (*f) __P((genarg *)); 2617c478bd9Sstevel@tonic-gate sfsistat (*fi_abort) __P((SMFICTX *)); 2627c478bd9Sstevel@tonic-gate sfsistat (*fi_close) __P((SMFICTX *)); 2637c478bd9Sstevel@tonic-gate 2647c478bd9Sstevel@tonic-gate arg.a_ctx = ctx; 2657c478bd9Sstevel@tonic-gate sd = ctx->ctx_sd; 2667c478bd9Sstevel@tonic-gate fi_abort = ctx->ctx_smfi->xxfi_abort; 267058561cbSjbeck #if _FFR_WORKERS_POOL 268058561cbSjbeck curstate = ctx->ctx_state; 269058561cbSjbeck if (curstate == ST_INIT) 270058561cbSjbeck { 2717c478bd9Sstevel@tonic-gate mi_clr_macros(ctx, 0); 2727c478bd9Sstevel@tonic-gate fix_stm(ctx); 273058561cbSjbeck } 274058561cbSjbeck #else /* _FFR_WORKERS_POOL */ 275058561cbSjbeck mi_clr_macros(ctx, 0); 276058561cbSjbeck fix_stm(ctx); 277058561cbSjbeck #endif /* _FFR_WORKERS_POOL */ 2787c478bd9Sstevel@tonic-gate r = _SMFIS_NONE; 2797c478bd9Sstevel@tonic-gate do 2807c478bd9Sstevel@tonic-gate { 2817c478bd9Sstevel@tonic-gate /* call abort only if in a mail transaction */ 2827c478bd9Sstevel@tonic-gate call_abort = ST_IN_MAIL(curstate); 2837c478bd9Sstevel@tonic-gate timeout.tv_sec = ctx->ctx_timeout; 2847c478bd9Sstevel@tonic-gate timeout.tv_usec = 0; 2857c478bd9Sstevel@tonic-gate if (mi_stop() == MILTER_ABRT) 2867c478bd9Sstevel@tonic-gate { 2877c478bd9Sstevel@tonic-gate if (ctx->ctx_dbg > 3) 288058561cbSjbeck sm_dprintf("[%ld] milter_abort\n", 289058561cbSjbeck (long) ctx->ctx_id); 2907c478bd9Sstevel@tonic-gate ret = MI_FAILURE; 2917c478bd9Sstevel@tonic-gate break; 2927c478bd9Sstevel@tonic-gate } 2937c478bd9Sstevel@tonic-gate 2947c478bd9Sstevel@tonic-gate /* 2957c478bd9Sstevel@tonic-gate ** Notice: buf is allocated by mi_rd_cmd() and it will 2967c478bd9Sstevel@tonic-gate ** usually be free()d after it has been used in f(). 2977c478bd9Sstevel@tonic-gate ** However, if the function returns _SMFIS_KEEP then buf 2987c478bd9Sstevel@tonic-gate ** contains macros and will not be free()d. 2997c478bd9Sstevel@tonic-gate ** Hence r must be set to _SMFIS_NONE if a new buf is 3007c478bd9Sstevel@tonic-gate ** allocated to avoid problem with housekeeping, esp. 3017c478bd9Sstevel@tonic-gate ** if the code "break"s out of the loop. 3027c478bd9Sstevel@tonic-gate */ 3037c478bd9Sstevel@tonic-gate 304058561cbSjbeck #if _FFR_WORKERS_POOL 305058561cbSjbeck /* Is the socket ready to be read ??? */ 306058561cbSjbeck if (!mi_rd_socket_ready(sd)) 307058561cbSjbeck { 308058561cbSjbeck ret = MI_CONTINUE; 309058561cbSjbeck break; 310058561cbSjbeck } 311058561cbSjbeck #endif /* _FFR_WORKERS_POOL */ 312058561cbSjbeck 3137c478bd9Sstevel@tonic-gate r = _SMFIS_NONE; 3147c478bd9Sstevel@tonic-gate if ((buf = mi_rd_cmd(sd, &timeout, &cmd, &len, 3157c478bd9Sstevel@tonic-gate ctx->ctx_smfi->xxfi_name)) == NULL && 3167c478bd9Sstevel@tonic-gate cmd < SMFIC_VALIDCMD) 3177c478bd9Sstevel@tonic-gate { 3187c478bd9Sstevel@tonic-gate if (ctx->ctx_dbg > 5) 319058561cbSjbeck sm_dprintf("[%ld] mi_engine: mi_rd_cmd error (%x)\n", 320058561cbSjbeck (long) ctx->ctx_id, (int) cmd); 3217c478bd9Sstevel@tonic-gate 3227c478bd9Sstevel@tonic-gate /* 3237c478bd9Sstevel@tonic-gate ** eof is currently treated as failure -> 3247c478bd9Sstevel@tonic-gate ** abort() instead of close(), otherwise use: 3257c478bd9Sstevel@tonic-gate ** if (cmd != SMFIC_EOF) 3267c478bd9Sstevel@tonic-gate */ 3277c478bd9Sstevel@tonic-gate 3287c478bd9Sstevel@tonic-gate ret = MI_FAILURE; 3297c478bd9Sstevel@tonic-gate break; 3307c478bd9Sstevel@tonic-gate } 3317c478bd9Sstevel@tonic-gate if (ctx->ctx_dbg > 4) 332058561cbSjbeck sm_dprintf("[%ld] got cmd '%c' len %d\n", 333058561cbSjbeck (long) ctx->ctx_id, cmd, (int) len); 3347c478bd9Sstevel@tonic-gate for (i = 0; i < ncmds; i++) 3357c478bd9Sstevel@tonic-gate { 3367c478bd9Sstevel@tonic-gate if (cmd == cmds[i].cm_cmd) 3377c478bd9Sstevel@tonic-gate break; 3387c478bd9Sstevel@tonic-gate } 3397c478bd9Sstevel@tonic-gate if (i >= ncmds) 3407c478bd9Sstevel@tonic-gate { 3417c478bd9Sstevel@tonic-gate /* unknown command */ 3427c478bd9Sstevel@tonic-gate if (ctx->ctx_dbg > 1) 343058561cbSjbeck sm_dprintf("[%ld] cmd '%c' unknown\n", 344058561cbSjbeck (long) ctx->ctx_id, cmd); 3457c478bd9Sstevel@tonic-gate ret = MI_FAILURE; 3467c478bd9Sstevel@tonic-gate break; 3477c478bd9Sstevel@tonic-gate } 3487c478bd9Sstevel@tonic-gate if ((f = cmds[i].cm_fct) == NULL) 3497c478bd9Sstevel@tonic-gate { 3507c478bd9Sstevel@tonic-gate /* stop for now */ 3517c478bd9Sstevel@tonic-gate if (ctx->ctx_dbg > 1) 352058561cbSjbeck sm_dprintf("[%ld] cmd '%c' not impl\n", 353058561cbSjbeck (long) ctx->ctx_id, cmd); 3547c478bd9Sstevel@tonic-gate ret = MI_FAILURE; 3557c478bd9Sstevel@tonic-gate break; 3567c478bd9Sstevel@tonic-gate } 3577c478bd9Sstevel@tonic-gate 3587c478bd9Sstevel@tonic-gate /* is new state ok? */ 3597c478bd9Sstevel@tonic-gate newstate = cmds[i].cm_next; 3607c478bd9Sstevel@tonic-gate if (ctx->ctx_dbg > 5) 361058561cbSjbeck sm_dprintf("[%ld] cur %x new %x nextmask %x\n", 362058561cbSjbeck (long) ctx->ctx_id, 3637c478bd9Sstevel@tonic-gate curstate, newstate, next_states[curstate]); 3647c478bd9Sstevel@tonic-gate 3657c478bd9Sstevel@tonic-gate if (newstate != ST_NONE && !trans_ok(curstate, newstate)) 3667c478bd9Sstevel@tonic-gate { 3677c478bd9Sstevel@tonic-gate if (ctx->ctx_dbg > 1) 368058561cbSjbeck sm_dprintf("[%ld] abort: cur %d (%x) new %d (%x) next %x\n", 369058561cbSjbeck (long) ctx->ctx_id, 3707c478bd9Sstevel@tonic-gate curstate, MI_MASK(curstate), 3717c478bd9Sstevel@tonic-gate newstate, MI_MASK(newstate), 3727c478bd9Sstevel@tonic-gate next_states[curstate]); 3737c478bd9Sstevel@tonic-gate 3747c478bd9Sstevel@tonic-gate /* call abort only if in a mail transaction */ 3757c478bd9Sstevel@tonic-gate if (fi_abort != NULL && call_abort) 3767c478bd9Sstevel@tonic-gate (void) (*fi_abort)(ctx); 3777c478bd9Sstevel@tonic-gate 3787c478bd9Sstevel@tonic-gate /* 3797c478bd9Sstevel@tonic-gate ** try to reach the new state from HELO 3807c478bd9Sstevel@tonic-gate ** if it can't be reached, ignore the command. 3817c478bd9Sstevel@tonic-gate */ 3827c478bd9Sstevel@tonic-gate 3837c478bd9Sstevel@tonic-gate curstate = ST_HELO; 3847c478bd9Sstevel@tonic-gate if (!trans_ok(curstate, newstate)) 3857c478bd9Sstevel@tonic-gate { 3867c478bd9Sstevel@tonic-gate if (buf != NULL) 3877c478bd9Sstevel@tonic-gate { 3887c478bd9Sstevel@tonic-gate free(buf); 3897c478bd9Sstevel@tonic-gate buf = NULL; 3907c478bd9Sstevel@tonic-gate } 3917c478bd9Sstevel@tonic-gate continue; 3927c478bd9Sstevel@tonic-gate } 3937c478bd9Sstevel@tonic-gate } 3947c478bd9Sstevel@tonic-gate arg.a_len = len; 3957c478bd9Sstevel@tonic-gate arg.a_buf = buf; 3967c478bd9Sstevel@tonic-gate if (newstate != ST_NONE) 3977c478bd9Sstevel@tonic-gate { 3987c478bd9Sstevel@tonic-gate curstate = newstate; 3997c478bd9Sstevel@tonic-gate ctx->ctx_state = curstate; 4007c478bd9Sstevel@tonic-gate } 4017c478bd9Sstevel@tonic-gate arg.a_idx = cmds[i].cm_macros; 4027c478bd9Sstevel@tonic-gate call_abort = ST_IN_MAIL(curstate); 4037c478bd9Sstevel@tonic-gate 4047c478bd9Sstevel@tonic-gate /* call function to deal with command */ 405058561cbSjbeck MI_MONITOR_BEGIN(ctx, cmd); 4067c478bd9Sstevel@tonic-gate r = (*f)(&arg); 407058561cbSjbeck MI_MONITOR_END(ctx, cmd); 4087c478bd9Sstevel@tonic-gate if (r != _SMFIS_KEEP && buf != NULL) 4097c478bd9Sstevel@tonic-gate { 4107c478bd9Sstevel@tonic-gate free(buf); 4117c478bd9Sstevel@tonic-gate buf = NULL; 4127c478bd9Sstevel@tonic-gate } 4137c478bd9Sstevel@tonic-gate if (sendreply(r, sd, &timeout, ctx) != MI_SUCCESS) 4147c478bd9Sstevel@tonic-gate { 4157c478bd9Sstevel@tonic-gate ret = MI_FAILURE; 4167c478bd9Sstevel@tonic-gate break; 4177c478bd9Sstevel@tonic-gate } 4187c478bd9Sstevel@tonic-gate 4197c478bd9Sstevel@tonic-gate if (r == SMFIS_ACCEPT) 4207c478bd9Sstevel@tonic-gate { 4217c478bd9Sstevel@tonic-gate /* accept mail, no further actions taken */ 4227c478bd9Sstevel@tonic-gate curstate = ST_HELO; 4237c478bd9Sstevel@tonic-gate } 4247c478bd9Sstevel@tonic-gate else if (r == SMFIS_REJECT || r == SMFIS_DISCARD || 4257c478bd9Sstevel@tonic-gate r == SMFIS_TEMPFAIL) 4267c478bd9Sstevel@tonic-gate { 4277c478bd9Sstevel@tonic-gate /* 4287c478bd9Sstevel@tonic-gate ** further actions depend on current state 4297c478bd9Sstevel@tonic-gate ** if the IGNO bit is set: "ignore" the error, 4307c478bd9Sstevel@tonic-gate ** i.e., stay in the current state 4317c478bd9Sstevel@tonic-gate */ 4327c478bd9Sstevel@tonic-gate if (!bitset(CT_IGNO, cmds[i].cm_todo)) 4337c478bd9Sstevel@tonic-gate curstate = ST_HELO; 4347c478bd9Sstevel@tonic-gate } 4357c478bd9Sstevel@tonic-gate else if (r == _SMFIS_ABORT) 4367c478bd9Sstevel@tonic-gate { 4377c478bd9Sstevel@tonic-gate if (ctx->ctx_dbg > 5) 438058561cbSjbeck sm_dprintf("[%ld] function returned abort\n", 439058561cbSjbeck (long) ctx->ctx_id); 4407c478bd9Sstevel@tonic-gate ret = MI_FAILURE; 4417c478bd9Sstevel@tonic-gate break; 4427c478bd9Sstevel@tonic-gate } 4437c478bd9Sstevel@tonic-gate } while (!bitset(CT_END, cmds[i].cm_todo)); 4447c478bd9Sstevel@tonic-gate 445058561cbSjbeck ctx->ctx_state = curstate; 446058561cbSjbeck 447058561cbSjbeck if (ret == MI_FAILURE) 4487c478bd9Sstevel@tonic-gate { 4497c478bd9Sstevel@tonic-gate /* call abort only if in a mail transaction */ 4507c478bd9Sstevel@tonic-gate if (fi_abort != NULL && call_abort) 4517c478bd9Sstevel@tonic-gate (void) (*fi_abort)(ctx); 4527c478bd9Sstevel@tonic-gate } 4537c478bd9Sstevel@tonic-gate 454058561cbSjbeck /* has close been called? */ 455058561cbSjbeck if (ctx->ctx_state != ST_QUIT 456058561cbSjbeck #if _FFR_WORKERS_POOL 457058561cbSjbeck && ret != MI_CONTINUE 458058561cbSjbeck #endif /* _FFR_WORKERS_POOL */ 459058561cbSjbeck ) 460058561cbSjbeck { 4617c478bd9Sstevel@tonic-gate if ((fi_close = ctx->ctx_smfi->xxfi_close) != NULL) 4627c478bd9Sstevel@tonic-gate (void) (*fi_close)(ctx); 463058561cbSjbeck } 4647c478bd9Sstevel@tonic-gate if (r != _SMFIS_KEEP && buf != NULL) 4657c478bd9Sstevel@tonic-gate free(buf); 466058561cbSjbeck #if !_FFR_WORKERS_POOL 4677c478bd9Sstevel@tonic-gate mi_clr_macros(ctx, 0); 468058561cbSjbeck #endif /* _FFR_WORKERS_POOL */ 4697c478bd9Sstevel@tonic-gate return ret; 4707c478bd9Sstevel@tonic-gate } 471058561cbSjbeck 472058561cbSjbeck static size_t milter_addsymlist __P((SMFICTX_PTR, char *, char **)); 473058561cbSjbeck 474058561cbSjbeck static size_t 475058561cbSjbeck milter_addsymlist(ctx, buf, newbuf) 476058561cbSjbeck SMFICTX_PTR ctx; 477058561cbSjbeck char *buf; 478058561cbSjbeck char **newbuf; 479058561cbSjbeck { 480058561cbSjbeck size_t len; 481058561cbSjbeck int i; 482058561cbSjbeck mi_int32 v; 483058561cbSjbeck char *buffer; 484058561cbSjbeck 485058561cbSjbeck SM_ASSERT(ctx != NULL); 486058561cbSjbeck SM_ASSERT(buf != NULL); 487058561cbSjbeck SM_ASSERT(newbuf != NULL); 488058561cbSjbeck len = 0; 489058561cbSjbeck for (i = 0; i < MAX_MACROS_ENTRIES; i++) 490058561cbSjbeck { 491058561cbSjbeck if (ctx->ctx_mac_list[i] != NULL) 492058561cbSjbeck { 493058561cbSjbeck len += strlen(ctx->ctx_mac_list[i]) + 1 + 494058561cbSjbeck MILTER_LEN_BYTES; 495058561cbSjbeck } 496058561cbSjbeck } 497058561cbSjbeck if (len > 0) 498058561cbSjbeck { 499058561cbSjbeck size_t offset; 500058561cbSjbeck 501058561cbSjbeck SM_ASSERT(len + MILTER_OPTLEN > len); 502058561cbSjbeck len += MILTER_OPTLEN; 503058561cbSjbeck buffer = malloc(len); 504058561cbSjbeck if (buffer != NULL) 505058561cbSjbeck { 506058561cbSjbeck (void) memcpy(buffer, buf, MILTER_OPTLEN); 507058561cbSjbeck offset = MILTER_OPTLEN; 508058561cbSjbeck for (i = 0; i < MAX_MACROS_ENTRIES; i++) 509058561cbSjbeck { 510058561cbSjbeck size_t l; 511058561cbSjbeck 512058561cbSjbeck if (ctx->ctx_mac_list[i] == NULL) 513058561cbSjbeck continue; 514058561cbSjbeck 515058561cbSjbeck SM_ASSERT(offset + MILTER_LEN_BYTES < len); 516058561cbSjbeck v = htonl(i); 517058561cbSjbeck (void) memcpy(buffer + offset, (void *) &v, 518058561cbSjbeck MILTER_LEN_BYTES); 519058561cbSjbeck offset += MILTER_LEN_BYTES; 520058561cbSjbeck l = strlen(ctx->ctx_mac_list[i]) + 1; 521058561cbSjbeck SM_ASSERT(offset + l <= len); 522058561cbSjbeck (void) memcpy(buffer + offset, 523058561cbSjbeck ctx->ctx_mac_list[i], l); 524058561cbSjbeck offset += l; 525058561cbSjbeck } 526058561cbSjbeck } 527058561cbSjbeck else 528058561cbSjbeck { 529058561cbSjbeck /* oops ... */ 530058561cbSjbeck } 531058561cbSjbeck } 532058561cbSjbeck else 533058561cbSjbeck { 534058561cbSjbeck len = MILTER_OPTLEN; 535058561cbSjbeck buffer = buf; 536058561cbSjbeck } 537058561cbSjbeck *newbuf = buffer; 538058561cbSjbeck return len; 539058561cbSjbeck } 540058561cbSjbeck 541058561cbSjbeck /* 542058561cbSjbeck ** GET_NR_BIT -- get "no reply" bit matching state 543058561cbSjbeck ** 544058561cbSjbeck ** Parameters: 545058561cbSjbeck ** state -- current protocol stage 546058561cbSjbeck ** 547058561cbSjbeck ** Returns: 548058561cbSjbeck ** 0: no matching bit 549058561cbSjbeck ** >0: the matching "no reply" bit 550058561cbSjbeck */ 551058561cbSjbeck 552058561cbSjbeck static unsigned long get_nr_bit __P((int)); 553058561cbSjbeck 554058561cbSjbeck static unsigned long 555058561cbSjbeck get_nr_bit(state) 556058561cbSjbeck int state; 557058561cbSjbeck { 558058561cbSjbeck unsigned long bit; 559058561cbSjbeck 560058561cbSjbeck switch (state) 561058561cbSjbeck { 562058561cbSjbeck case ST_CONN: 563058561cbSjbeck bit = SMFIP_NR_CONN; 564058561cbSjbeck break; 565058561cbSjbeck case ST_HELO: 566058561cbSjbeck bit = SMFIP_NR_HELO; 567058561cbSjbeck break; 568058561cbSjbeck case ST_MAIL: 569058561cbSjbeck bit = SMFIP_NR_MAIL; 570058561cbSjbeck break; 571058561cbSjbeck case ST_RCPT: 572058561cbSjbeck bit = SMFIP_NR_RCPT; 573058561cbSjbeck break; 574058561cbSjbeck case ST_DATA: 575058561cbSjbeck bit = SMFIP_NR_DATA; 576058561cbSjbeck break; 577058561cbSjbeck case ST_UNKN: 578058561cbSjbeck bit = SMFIP_NR_UNKN; 579058561cbSjbeck break; 580058561cbSjbeck case ST_HDRS: 581058561cbSjbeck bit = SMFIP_NR_HDR; 582058561cbSjbeck break; 583058561cbSjbeck case ST_EOHS: 584058561cbSjbeck bit = SMFIP_NR_EOH; 585058561cbSjbeck break; 586058561cbSjbeck case ST_BODY: 587058561cbSjbeck bit = SMFIP_NR_BODY; 588058561cbSjbeck break; 589058561cbSjbeck default: 590058561cbSjbeck bit = 0; 591058561cbSjbeck break; 592058561cbSjbeck } 593058561cbSjbeck return bit; 594058561cbSjbeck } 595058561cbSjbeck 5967c478bd9Sstevel@tonic-gate /* 5977c478bd9Sstevel@tonic-gate ** SENDREPLY -- send a reply to the MTA 5987c478bd9Sstevel@tonic-gate ** 5997c478bd9Sstevel@tonic-gate ** Parameters: 6007c478bd9Sstevel@tonic-gate ** r -- reply code 6017c478bd9Sstevel@tonic-gate ** sd -- socket descriptor 6027c478bd9Sstevel@tonic-gate ** timeout_ptr -- (ptr to) timeout to use for sending 6037c478bd9Sstevel@tonic-gate ** ctx -- context structure 6047c478bd9Sstevel@tonic-gate ** 6057c478bd9Sstevel@tonic-gate ** Returns: 6067c478bd9Sstevel@tonic-gate ** MI_SUCCESS/MI_FAILURE 6077c478bd9Sstevel@tonic-gate */ 6087c478bd9Sstevel@tonic-gate 6097c478bd9Sstevel@tonic-gate static int 6107c478bd9Sstevel@tonic-gate sendreply(r, sd, timeout_ptr, ctx) 6117c478bd9Sstevel@tonic-gate sfsistat r; 6127c478bd9Sstevel@tonic-gate socket_t sd; 6137c478bd9Sstevel@tonic-gate struct timeval *timeout_ptr; 6147c478bd9Sstevel@tonic-gate SMFICTX_PTR ctx; 6157c478bd9Sstevel@tonic-gate { 616058561cbSjbeck int ret; 617058561cbSjbeck unsigned long bit; 618058561cbSjbeck 619058561cbSjbeck ret = MI_SUCCESS; 620058561cbSjbeck 621058561cbSjbeck bit = get_nr_bit(ctx->ctx_state); 622058561cbSjbeck if (bit != 0 && (ctx->ctx_pflags & bit) != 0 && r != SMFIS_NOREPLY) 623058561cbSjbeck { 624058561cbSjbeck if (r >= SMFIS_CONTINUE && r < _SMFIS_KEEP) 625058561cbSjbeck { 626058561cbSjbeck /* milter said it wouldn't reply, but it lied... */ 627058561cbSjbeck smi_log(SMI_LOG_ERR, 628058561cbSjbeck "%s: milter claimed not to reply in state %d but did anyway %d\n", 629058561cbSjbeck ctx->ctx_smfi->xxfi_name, 630058561cbSjbeck ctx->ctx_state, r); 631058561cbSjbeck 632058561cbSjbeck } 633058561cbSjbeck 634058561cbSjbeck /* 635058561cbSjbeck ** Force specified behavior, otherwise libmilter 636058561cbSjbeck ** and MTA will fail to communicate properly. 637058561cbSjbeck */ 638058561cbSjbeck 639058561cbSjbeck switch (r) 640058561cbSjbeck { 641058561cbSjbeck case SMFIS_CONTINUE: 642058561cbSjbeck case SMFIS_TEMPFAIL: 643058561cbSjbeck case SMFIS_REJECT: 644058561cbSjbeck case SMFIS_DISCARD: 645058561cbSjbeck case SMFIS_ACCEPT: 646058561cbSjbeck case SMFIS_SKIP: 647058561cbSjbeck case _SMFIS_OPTIONS: 648058561cbSjbeck r = SMFIS_NOREPLY; 649058561cbSjbeck break; 650058561cbSjbeck } 651058561cbSjbeck } 6527c478bd9Sstevel@tonic-gate 6537c478bd9Sstevel@tonic-gate switch (r) 6547c478bd9Sstevel@tonic-gate { 6557c478bd9Sstevel@tonic-gate case SMFIS_CONTINUE: 6567c478bd9Sstevel@tonic-gate ret = mi_wr_cmd(sd, timeout_ptr, SMFIR_CONTINUE, NULL, 0); 6577c478bd9Sstevel@tonic-gate break; 6587c478bd9Sstevel@tonic-gate case SMFIS_TEMPFAIL: 6597c478bd9Sstevel@tonic-gate case SMFIS_REJECT: 6607c478bd9Sstevel@tonic-gate if (ctx->ctx_reply != NULL && 6617c478bd9Sstevel@tonic-gate ((r == SMFIS_TEMPFAIL && *ctx->ctx_reply == '4') || 6627c478bd9Sstevel@tonic-gate (r == SMFIS_REJECT && *ctx->ctx_reply == '5'))) 6637c478bd9Sstevel@tonic-gate { 6647c478bd9Sstevel@tonic-gate ret = mi_wr_cmd(sd, timeout_ptr, SMFIR_REPLYCODE, 6657c478bd9Sstevel@tonic-gate ctx->ctx_reply, 6667c478bd9Sstevel@tonic-gate strlen(ctx->ctx_reply) + 1); 6677c478bd9Sstevel@tonic-gate free(ctx->ctx_reply); 6687c478bd9Sstevel@tonic-gate ctx->ctx_reply = NULL; 6697c478bd9Sstevel@tonic-gate } 6707c478bd9Sstevel@tonic-gate else 6717c478bd9Sstevel@tonic-gate { 6727c478bd9Sstevel@tonic-gate ret = mi_wr_cmd(sd, timeout_ptr, r == SMFIS_REJECT ? 6737c478bd9Sstevel@tonic-gate SMFIR_REJECT : SMFIR_TEMPFAIL, NULL, 0); 6747c478bd9Sstevel@tonic-gate } 6757c478bd9Sstevel@tonic-gate break; 6767c478bd9Sstevel@tonic-gate case SMFIS_DISCARD: 6777c478bd9Sstevel@tonic-gate ret = mi_wr_cmd(sd, timeout_ptr, SMFIR_DISCARD, NULL, 0); 6787c478bd9Sstevel@tonic-gate break; 6797c478bd9Sstevel@tonic-gate case SMFIS_ACCEPT: 6807c478bd9Sstevel@tonic-gate ret = mi_wr_cmd(sd, timeout_ptr, SMFIR_ACCEPT, NULL, 0); 6817c478bd9Sstevel@tonic-gate break; 682058561cbSjbeck case SMFIS_SKIP: 683058561cbSjbeck ret = mi_wr_cmd(sd, timeout_ptr, SMFIR_SKIP, NULL, 0); 684058561cbSjbeck break; 6857c478bd9Sstevel@tonic-gate case _SMFIS_OPTIONS: 6867c478bd9Sstevel@tonic-gate { 6877c478bd9Sstevel@tonic-gate mi_int32 v; 688058561cbSjbeck size_t len; 689058561cbSjbeck char *buffer; 690058561cbSjbeck char buf[MILTER_OPTLEN]; 6917c478bd9Sstevel@tonic-gate 692058561cbSjbeck v = htonl(ctx->ctx_prot_vers2mta); 693058561cbSjbeck (void) memcpy(&(buf[0]), (void *) &v, 694058561cbSjbeck MILTER_LEN_BYTES); 695058561cbSjbeck v = htonl(ctx->ctx_aflags); 6967c478bd9Sstevel@tonic-gate (void) memcpy(&(buf[MILTER_LEN_BYTES]), (void *) &v, 6977c478bd9Sstevel@tonic-gate MILTER_LEN_BYTES); 698058561cbSjbeck v = htonl(ctx->ctx_pflags2mta); 699058561cbSjbeck (void) memcpy(&(buf[MILTER_LEN_BYTES * 2]), 700058561cbSjbeck (void *) &v, MILTER_LEN_BYTES); 701058561cbSjbeck len = milter_addsymlist(ctx, buf, &buffer); 702058561cbSjbeck if (buffer != NULL) 703058561cbSjbeck ret = mi_wr_cmd(sd, timeout_ptr, SMFIC_OPTNEG, 704058561cbSjbeck buffer, len); 705058561cbSjbeck else 706058561cbSjbeck ret = MI_FAILURE; 707058561cbSjbeck } 708058561cbSjbeck break; 709058561cbSjbeck case SMFIS_NOREPLY: 710058561cbSjbeck if (bit != 0 && 711058561cbSjbeck (ctx->ctx_pflags & bit) != 0 && 712058561cbSjbeck (ctx->ctx_mta_pflags & bit) == 0) 713058561cbSjbeck { 714058561cbSjbeck /* 715058561cbSjbeck ** milter doesn't want to send a reply, 716058561cbSjbeck ** but the MTA doesn't have that feature: fake it. 717058561cbSjbeck */ 718058561cbSjbeck 719058561cbSjbeck ret = mi_wr_cmd(sd, timeout_ptr, SMFIR_CONTINUE, NULL, 720058561cbSjbeck 0); 7217c478bd9Sstevel@tonic-gate } 7227c478bd9Sstevel@tonic-gate break; 7237c478bd9Sstevel@tonic-gate default: /* don't send a reply */ 7247c478bd9Sstevel@tonic-gate break; 7257c478bd9Sstevel@tonic-gate } 7267c478bd9Sstevel@tonic-gate return ret; 7277c478bd9Sstevel@tonic-gate } 7287c478bd9Sstevel@tonic-gate 7297c478bd9Sstevel@tonic-gate /* 7307c478bd9Sstevel@tonic-gate ** CLR_MACROS -- clear set of macros starting from a given index 7317c478bd9Sstevel@tonic-gate ** 7327c478bd9Sstevel@tonic-gate ** Parameters: 7337c478bd9Sstevel@tonic-gate ** ctx -- context structure 7347c478bd9Sstevel@tonic-gate ** m -- index from which to clear all macros 7357c478bd9Sstevel@tonic-gate ** 7367c478bd9Sstevel@tonic-gate ** Returns: 7377c478bd9Sstevel@tonic-gate ** None. 7387c478bd9Sstevel@tonic-gate */ 7394aac33d3Sjbeck 7407c478bd9Sstevel@tonic-gate void 7417c478bd9Sstevel@tonic-gate mi_clr_macros(ctx, m) 7427c478bd9Sstevel@tonic-gate SMFICTX_PTR ctx; 7437c478bd9Sstevel@tonic-gate int m; 7447c478bd9Sstevel@tonic-gate { 7457c478bd9Sstevel@tonic-gate int i; 7467c478bd9Sstevel@tonic-gate 7477c478bd9Sstevel@tonic-gate for (i = m; i < MAX_MACROS_ENTRIES; i++) 7487c478bd9Sstevel@tonic-gate { 7497c478bd9Sstevel@tonic-gate if (ctx->ctx_mac_ptr[i] != NULL) 7507c478bd9Sstevel@tonic-gate { 7517c478bd9Sstevel@tonic-gate free(ctx->ctx_mac_ptr[i]); 7527c478bd9Sstevel@tonic-gate ctx->ctx_mac_ptr[i] = NULL; 7537c478bd9Sstevel@tonic-gate } 7547c478bd9Sstevel@tonic-gate if (ctx->ctx_mac_buf[i] != NULL) 7557c478bd9Sstevel@tonic-gate { 7567c478bd9Sstevel@tonic-gate free(ctx->ctx_mac_buf[i]); 7577c478bd9Sstevel@tonic-gate ctx->ctx_mac_buf[i] = NULL; 7587c478bd9Sstevel@tonic-gate } 7597c478bd9Sstevel@tonic-gate } 7607c478bd9Sstevel@tonic-gate } 761058561cbSjbeck 7627c478bd9Sstevel@tonic-gate /* 7637c478bd9Sstevel@tonic-gate ** ST_OPTIONNEG -- negotiate options 7647c478bd9Sstevel@tonic-gate ** 7657c478bd9Sstevel@tonic-gate ** Parameters: 7667c478bd9Sstevel@tonic-gate ** g -- generic argument structure 7677c478bd9Sstevel@tonic-gate ** 7687c478bd9Sstevel@tonic-gate ** Returns: 7697c478bd9Sstevel@tonic-gate ** abort/send options/continue 7707c478bd9Sstevel@tonic-gate */ 7717c478bd9Sstevel@tonic-gate 7727c478bd9Sstevel@tonic-gate static int 7737c478bd9Sstevel@tonic-gate st_optionneg(g) 7747c478bd9Sstevel@tonic-gate genarg *g; 7757c478bd9Sstevel@tonic-gate { 776058561cbSjbeck mi_int32 i, v, fake_pflags; 777058561cbSjbeck SMFICTX_PTR ctx; 778058561cbSjbeck int (*fi_negotiate) __P((SMFICTX *, 779058561cbSjbeck unsigned long, unsigned long, 780058561cbSjbeck unsigned long, unsigned long, 781058561cbSjbeck unsigned long *, unsigned long *, 782058561cbSjbeck unsigned long *, unsigned long *)); 7837c478bd9Sstevel@tonic-gate 7847c478bd9Sstevel@tonic-gate if (g == NULL || g->a_ctx->ctx_smfi == NULL) 7857c478bd9Sstevel@tonic-gate return SMFIS_CONTINUE; 786058561cbSjbeck ctx = g->a_ctx; 787058561cbSjbeck mi_clr_macros(ctx, g->a_idx + 1); 788058561cbSjbeck ctx->ctx_prot_vers = SMFI_PROT_VERSION; 7897c478bd9Sstevel@tonic-gate 7907c478bd9Sstevel@tonic-gate /* check for minimum length */ 7917c478bd9Sstevel@tonic-gate if (g->a_len < MILTER_OPTLEN) 7927c478bd9Sstevel@tonic-gate { 7937c478bd9Sstevel@tonic-gate smi_log(SMI_LOG_ERR, 794058561cbSjbeck "%s: st_optionneg[%ld]: len too short %d < %d", 795058561cbSjbeck ctx->ctx_smfi->xxfi_name, 796058561cbSjbeck (long) ctx->ctx_id, (int) g->a_len, 7977c478bd9Sstevel@tonic-gate MILTER_OPTLEN); 7987c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 7997c478bd9Sstevel@tonic-gate } 8007c478bd9Sstevel@tonic-gate 801058561cbSjbeck /* protocol version */ 802058561cbSjbeck (void) memcpy((void *) &i, (void *) &(g->a_buf[0]), MILTER_LEN_BYTES); 8037c478bd9Sstevel@tonic-gate v = ntohl(i); 804058561cbSjbeck 805058561cbSjbeck #define SMFI_PROT_VERSION_MIN 2 806058561cbSjbeck 807058561cbSjbeck /* check for minimum version */ 808058561cbSjbeck if (v < SMFI_PROT_VERSION_MIN) 8097c478bd9Sstevel@tonic-gate { 8107c478bd9Sstevel@tonic-gate smi_log(SMI_LOG_ERR, 811058561cbSjbeck "%s: st_optionneg[%ld]: protocol version too old %d < %d", 812058561cbSjbeck ctx->ctx_smfi->xxfi_name, 813058561cbSjbeck (long) ctx->ctx_id, v, SMFI_PROT_VERSION_MIN); 8147c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 8157c478bd9Sstevel@tonic-gate } 816058561cbSjbeck ctx->ctx_mta_prot_vers = v; 817058561cbSjbeck if (ctx->ctx_prot_vers < ctx->ctx_mta_prot_vers) 818058561cbSjbeck ctx->ctx_prot_vers2mta = ctx->ctx_prot_vers; 819058561cbSjbeck else 820058561cbSjbeck ctx->ctx_prot_vers2mta = ctx->ctx_mta_prot_vers; 8217c478bd9Sstevel@tonic-gate 8227c478bd9Sstevel@tonic-gate (void) memcpy((void *) &i, (void *) &(g->a_buf[MILTER_LEN_BYTES]), 8237c478bd9Sstevel@tonic-gate MILTER_LEN_BYTES); 8247c478bd9Sstevel@tonic-gate v = ntohl(i); 8257c478bd9Sstevel@tonic-gate 8267c478bd9Sstevel@tonic-gate /* no flags? set to default value for V1 actions */ 8277c478bd9Sstevel@tonic-gate if (v == 0) 8287c478bd9Sstevel@tonic-gate v = SMFI_V1_ACTS; 829058561cbSjbeck ctx->ctx_mta_aflags = v; /* MTA action flags */ 8307c478bd9Sstevel@tonic-gate 8317c478bd9Sstevel@tonic-gate (void) memcpy((void *) &i, (void *) &(g->a_buf[MILTER_LEN_BYTES * 2]), 8327c478bd9Sstevel@tonic-gate MILTER_LEN_BYTES); 8337c478bd9Sstevel@tonic-gate v = ntohl(i); 8347c478bd9Sstevel@tonic-gate 8357c478bd9Sstevel@tonic-gate /* no flags? set to default value for V1 protocol */ 8367c478bd9Sstevel@tonic-gate if (v == 0) 8377c478bd9Sstevel@tonic-gate v = SMFI_V1_PROT; 838058561cbSjbeck ctx->ctx_mta_pflags = v; /* MTA protocol flags */ 839058561cbSjbeck 840058561cbSjbeck /* 841058561cbSjbeck ** Copy flags from milter struct into libmilter context; 842058561cbSjbeck ** this variable will be used later on to check whether 843058561cbSjbeck ** the MTA "actions" can fulfill the milter requirements, 844058561cbSjbeck ** but it may be overwritten by the negotiate callback. 845058561cbSjbeck */ 846058561cbSjbeck 847058561cbSjbeck ctx->ctx_aflags = ctx->ctx_smfi->xxfi_flags; 848058561cbSjbeck fake_pflags = SMFIP_NR_CONN 849058561cbSjbeck |SMFIP_NR_HELO 850058561cbSjbeck |SMFIP_NR_MAIL 851058561cbSjbeck |SMFIP_NR_RCPT 852058561cbSjbeck |SMFIP_NR_DATA 853058561cbSjbeck |SMFIP_NR_UNKN 854058561cbSjbeck |SMFIP_NR_HDR 855058561cbSjbeck |SMFIP_NR_EOH 856058561cbSjbeck |SMFIP_NR_BODY 857058561cbSjbeck ; 858058561cbSjbeck 859058561cbSjbeck if (g->a_ctx->ctx_smfi != NULL && 86024472db6Sjbeck g->a_ctx->ctx_smfi->xxfi_version > 4 && 861058561cbSjbeck (fi_negotiate = g->a_ctx->ctx_smfi->xxfi_negotiate) != NULL) 862058561cbSjbeck { 863058561cbSjbeck int r; 864058561cbSjbeck unsigned long m_aflags, m_pflags, m_f2, m_f3; 865058561cbSjbeck 866058561cbSjbeck /* 867058561cbSjbeck ** let milter decide whether the features offered by the 868058561cbSjbeck ** MTA are "good enough". 869058561cbSjbeck ** Notes: 870058561cbSjbeck ** - libmilter can "fake" some features (e.g., SMFIP_NR_HDR) 871058561cbSjbeck ** - m_f2, m_f3 are for future extensions 872058561cbSjbeck */ 873058561cbSjbeck 874058561cbSjbeck m_f2 = m_f3 = 0; 875058561cbSjbeck m_aflags = ctx->ctx_mta_aflags; 876058561cbSjbeck m_pflags = ctx->ctx_pflags; 877058561cbSjbeck if ((SMFIP_SKIP & ctx->ctx_mta_pflags) != 0) 878058561cbSjbeck m_pflags |= SMFIP_SKIP; 879058561cbSjbeck r = fi_negotiate(g->a_ctx, 880058561cbSjbeck ctx->ctx_mta_aflags, 881058561cbSjbeck ctx->ctx_mta_pflags|fake_pflags, 882058561cbSjbeck 0, 0, 883058561cbSjbeck &m_aflags, &m_pflags, &m_f2, &m_f3); 884058561cbSjbeck 885058561cbSjbeck /* 886058561cbSjbeck ** Types of protocol flags (pflags): 887058561cbSjbeck ** 1. do NOT send protocol step X 888058561cbSjbeck ** 2. MTA can do/understand something extra (SKIP, 889058561cbSjbeck ** send unknown RCPTs) 890058561cbSjbeck ** 3. MTA can deal with "no reply" for various protocol steps 891058561cbSjbeck ** Note: this mean that it isn't possible to simply set all 892058561cbSjbeck ** flags to get "everything": 893058561cbSjbeck ** setting a flag of type 1 turns off a step 894058561cbSjbeck ** (it should be the other way around: 895058561cbSjbeck ** a flag means a protocol step can be sent) 896058561cbSjbeck ** setting a flag of type 3 requires that milter 897058561cbSjbeck ** never sends a reply for the corresponding step. 898058561cbSjbeck ** Summary: the "negation" of protocol flags is causing 899058561cbSjbeck ** problems, but at least for type 3 there is no simple 900058561cbSjbeck ** solution. 901058561cbSjbeck ** 902058561cbSjbeck ** What should "all options" mean? 903058561cbSjbeck ** send all protocol steps _except_ those for which there is 904058561cbSjbeck ** no callback (currently registered in ctx_pflags) 905058561cbSjbeck ** expect SKIP as return code? Yes 906058561cbSjbeck ** send unknown RCPTs? No, 907058561cbSjbeck ** must be explicitly requested? 908058561cbSjbeck ** "no reply" for some protocol steps? No, 909058561cbSjbeck ** must be explicitly requested. 910058561cbSjbeck */ 911058561cbSjbeck 912058561cbSjbeck if (SMFIS_ALL_OPTS == r) 913058561cbSjbeck { 914058561cbSjbeck ctx->ctx_aflags = ctx->ctx_mta_aflags; 915058561cbSjbeck ctx->ctx_pflags2mta = ctx->ctx_pflags; 916058561cbSjbeck if ((SMFIP_SKIP & ctx->ctx_mta_pflags) != 0) 917058561cbSjbeck ctx->ctx_pflags2mta |= SMFIP_SKIP; 918058561cbSjbeck } 919058561cbSjbeck else if (r != SMFIS_CONTINUE) 9207c478bd9Sstevel@tonic-gate { 9217c478bd9Sstevel@tonic-gate smi_log(SMI_LOG_ERR, 922058561cbSjbeck "%s: st_optionneg[%ld]: xxfi_negotiate returned %d (protocol options=0x%lx, actions=0x%lx)", 923058561cbSjbeck ctx->ctx_smfi->xxfi_name, 924058561cbSjbeck (long) ctx->ctx_id, r, ctx->ctx_mta_pflags, 925058561cbSjbeck ctx->ctx_mta_aflags); 926058561cbSjbeck return _SMFIS_ABORT; 927058561cbSjbeck } 928058561cbSjbeck else 929058561cbSjbeck { 930058561cbSjbeck ctx->ctx_aflags = m_aflags; 931058561cbSjbeck ctx->ctx_pflags = m_pflags; 932058561cbSjbeck ctx->ctx_pflags2mta = m_pflags; 933058561cbSjbeck } 934058561cbSjbeck 935058561cbSjbeck /* check whether some flags need to be "faked" */ 936058561cbSjbeck i = ctx->ctx_pflags2mta; 937058561cbSjbeck if ((ctx->ctx_mta_pflags & i) != i) 938058561cbSjbeck { 939058561cbSjbeck unsigned int idx; 940058561cbSjbeck unsigned long b; 941058561cbSjbeck 942058561cbSjbeck /* 943058561cbSjbeck ** If some behavior can be faked (set in fake_pflags), 944058561cbSjbeck ** but the MTA doesn't support it, then unset 945058561cbSjbeck ** that flag in the value that is sent to the MTA. 946058561cbSjbeck */ 947058561cbSjbeck 948058561cbSjbeck for (idx = 0; idx < 32; idx++) 949058561cbSjbeck { 950058561cbSjbeck b = 1 << idx; 951058561cbSjbeck if ((ctx->ctx_mta_pflags & b) != b && 952058561cbSjbeck (fake_pflags & b) == b) 953058561cbSjbeck ctx->ctx_pflags2mta &= ~b; 954058561cbSjbeck } 955058561cbSjbeck } 956058561cbSjbeck } 957058561cbSjbeck else 958058561cbSjbeck { 959058561cbSjbeck /* 960058561cbSjbeck ** Set the protocol flags based on the values determined 961058561cbSjbeck ** in mi_listener() which checked the defined callbacks. 962058561cbSjbeck */ 963058561cbSjbeck 964058561cbSjbeck ctx->ctx_pflags2mta = ctx->ctx_pflags; 965058561cbSjbeck } 966058561cbSjbeck 967058561cbSjbeck /* check whether actions and protocol requirements can be satisfied */ 968058561cbSjbeck i = ctx->ctx_aflags; 969058561cbSjbeck if ((i & ctx->ctx_mta_aflags) != i) 970058561cbSjbeck { 971058561cbSjbeck smi_log(SMI_LOG_ERR, 972058561cbSjbeck "%s: st_optionneg[%ld]: 0x%lx does not fulfill action requirements 0x%x", 973058561cbSjbeck ctx->ctx_smfi->xxfi_name, 974058561cbSjbeck (long) ctx->ctx_id, ctx->ctx_mta_aflags, i); 9757c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 9767c478bd9Sstevel@tonic-gate } 9777c478bd9Sstevel@tonic-gate 978058561cbSjbeck i = ctx->ctx_pflags2mta; 979058561cbSjbeck if ((ctx->ctx_mta_pflags & i) != i) 980058561cbSjbeck { 981058561cbSjbeck /* 982058561cbSjbeck ** Older MTAs do not support some protocol steps. 983058561cbSjbeck ** As this protocol is a bit "wierd" (it asks for steps 984058561cbSjbeck ** NOT to be taken/sent) we have to check whether we 985058561cbSjbeck ** should turn off those "negative" requests. 986058561cbSjbeck ** Currently these are only SMFIP_NODATA and SMFIP_NOUNKNOWN. 987058561cbSjbeck */ 988058561cbSjbeck 989058561cbSjbeck if (bitset(SMFIP_NODATA, ctx->ctx_pflags2mta) && 990058561cbSjbeck !bitset(SMFIP_NODATA, ctx->ctx_mta_pflags)) 991058561cbSjbeck ctx->ctx_pflags2mta &= ~SMFIP_NODATA; 992058561cbSjbeck if (bitset(SMFIP_NOUNKNOWN, ctx->ctx_pflags2mta) && 993058561cbSjbeck !bitset(SMFIP_NOUNKNOWN, ctx->ctx_mta_pflags)) 994058561cbSjbeck ctx->ctx_pflags2mta &= ~SMFIP_NOUNKNOWN; 995058561cbSjbeck i = ctx->ctx_pflags2mta; 996058561cbSjbeck } 997058561cbSjbeck 998058561cbSjbeck if ((ctx->ctx_mta_pflags & i) != i) 999058561cbSjbeck { 1000058561cbSjbeck smi_log(SMI_LOG_ERR, 1001058561cbSjbeck "%s: st_optionneg[%ld]: 0x%lx does not fulfill protocol requirements 0x%x", 1002058561cbSjbeck ctx->ctx_smfi->xxfi_name, 1003058561cbSjbeck (long) ctx->ctx_id, ctx->ctx_mta_pflags, i); 1004058561cbSjbeck return _SMFIS_ABORT; 1005058561cbSjbeck } 1006*d4660949Sjbeck fix_stm(ctx); 1007058561cbSjbeck 1008058561cbSjbeck if (ctx->ctx_dbg > 3) 1009058561cbSjbeck sm_dprintf("[%ld] milter_negotiate:" 1010058561cbSjbeck " mta_actions=0x%lx, mta_flags=0x%lx" 1011058561cbSjbeck " actions=0x%lx, flags=0x%lx\n" 1012058561cbSjbeck , (long) ctx->ctx_id 1013058561cbSjbeck , ctx->ctx_mta_aflags, ctx->ctx_mta_pflags 1014058561cbSjbeck , ctx->ctx_aflags, ctx->ctx_pflags); 1015058561cbSjbeck 10167c478bd9Sstevel@tonic-gate return _SMFIS_OPTIONS; 10177c478bd9Sstevel@tonic-gate } 1018058561cbSjbeck 10197c478bd9Sstevel@tonic-gate /* 10207c478bd9Sstevel@tonic-gate ** ST_CONNECTINFO -- receive connection information 10217c478bd9Sstevel@tonic-gate ** 10227c478bd9Sstevel@tonic-gate ** Parameters: 10237c478bd9Sstevel@tonic-gate ** g -- generic argument structure 10247c478bd9Sstevel@tonic-gate ** 10257c478bd9Sstevel@tonic-gate ** Returns: 10267c478bd9Sstevel@tonic-gate ** continue or filter-specified value 10277c478bd9Sstevel@tonic-gate */ 10287c478bd9Sstevel@tonic-gate 10297c478bd9Sstevel@tonic-gate static int 10307c478bd9Sstevel@tonic-gate st_connectinfo(g) 10317c478bd9Sstevel@tonic-gate genarg *g; 10327c478bd9Sstevel@tonic-gate { 10337c478bd9Sstevel@tonic-gate size_t l; 10347c478bd9Sstevel@tonic-gate size_t i; 10357c478bd9Sstevel@tonic-gate char *s, family; 10367c478bd9Sstevel@tonic-gate unsigned short port = 0; 10377c478bd9Sstevel@tonic-gate _SOCK_ADDR sockaddr; 10387c478bd9Sstevel@tonic-gate sfsistat (*fi_connect) __P((SMFICTX *, char *, _SOCK_ADDR *)); 10397c478bd9Sstevel@tonic-gate 10407c478bd9Sstevel@tonic-gate if (g == NULL) 10417c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 10427c478bd9Sstevel@tonic-gate mi_clr_macros(g->a_ctx, g->a_idx + 1); 10437c478bd9Sstevel@tonic-gate if (g->a_ctx->ctx_smfi == NULL || 10447c478bd9Sstevel@tonic-gate (fi_connect = g->a_ctx->ctx_smfi->xxfi_connect) == NULL) 10457c478bd9Sstevel@tonic-gate return SMFIS_CONTINUE; 10467c478bd9Sstevel@tonic-gate 10477c478bd9Sstevel@tonic-gate s = g->a_buf; 10487c478bd9Sstevel@tonic-gate i = 0; 10497c478bd9Sstevel@tonic-gate l = g->a_len; 10507c478bd9Sstevel@tonic-gate while (s[i] != '\0' && i <= l) 10517c478bd9Sstevel@tonic-gate ++i; 10527c478bd9Sstevel@tonic-gate if (i + 1 >= l) 10537c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 10547c478bd9Sstevel@tonic-gate 10557c478bd9Sstevel@tonic-gate /* Move past trailing \0 in host string */ 10567c478bd9Sstevel@tonic-gate i++; 10577c478bd9Sstevel@tonic-gate family = s[i++]; 10587c478bd9Sstevel@tonic-gate (void) memset(&sockaddr, '\0', sizeof sockaddr); 10597c478bd9Sstevel@tonic-gate if (family != SMFIA_UNKNOWN) 10607c478bd9Sstevel@tonic-gate { 10617c478bd9Sstevel@tonic-gate if (i + sizeof port >= l) 10627c478bd9Sstevel@tonic-gate { 10637c478bd9Sstevel@tonic-gate smi_log(SMI_LOG_ERR, 1064058561cbSjbeck "%s: connect[%ld]: wrong len %d >= %d", 10657c478bd9Sstevel@tonic-gate g->a_ctx->ctx_smfi->xxfi_name, 1066058561cbSjbeck (long) g->a_ctx->ctx_id, (int) i, (int) l); 10677c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 10687c478bd9Sstevel@tonic-gate } 10697c478bd9Sstevel@tonic-gate (void) memcpy((void *) &port, (void *) (s + i), 10707c478bd9Sstevel@tonic-gate sizeof port); 10717c478bd9Sstevel@tonic-gate i += sizeof port; 10727c478bd9Sstevel@tonic-gate 10737c478bd9Sstevel@tonic-gate /* make sure string is terminated */ 10747c478bd9Sstevel@tonic-gate if (s[l - 1] != '\0') 10757c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 10767c478bd9Sstevel@tonic-gate # if NETINET 10777c478bd9Sstevel@tonic-gate if (family == SMFIA_INET) 10787c478bd9Sstevel@tonic-gate { 10797c478bd9Sstevel@tonic-gate if (inet_aton(s + i, (struct in_addr *) &sockaddr.sin.sin_addr) 10807c478bd9Sstevel@tonic-gate != 1) 10817c478bd9Sstevel@tonic-gate { 10827c478bd9Sstevel@tonic-gate smi_log(SMI_LOG_ERR, 1083058561cbSjbeck "%s: connect[%ld]: inet_aton failed", 10847c478bd9Sstevel@tonic-gate g->a_ctx->ctx_smfi->xxfi_name, 1085058561cbSjbeck (long) g->a_ctx->ctx_id); 10867c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 10877c478bd9Sstevel@tonic-gate } 10887c478bd9Sstevel@tonic-gate sockaddr.sa.sa_family = AF_INET; 10897c478bd9Sstevel@tonic-gate if (port > 0) 10907c478bd9Sstevel@tonic-gate sockaddr.sin.sin_port = port; 10917c478bd9Sstevel@tonic-gate } 10927c478bd9Sstevel@tonic-gate else 10937c478bd9Sstevel@tonic-gate # endif /* NETINET */ 10947c478bd9Sstevel@tonic-gate # if NETINET6 10957c478bd9Sstevel@tonic-gate if (family == SMFIA_INET6) 10967c478bd9Sstevel@tonic-gate { 10977c478bd9Sstevel@tonic-gate if (mi_inet_pton(AF_INET6, s + i, 10987c478bd9Sstevel@tonic-gate &sockaddr.sin6.sin6_addr) != 1) 10997c478bd9Sstevel@tonic-gate { 11007c478bd9Sstevel@tonic-gate smi_log(SMI_LOG_ERR, 1101058561cbSjbeck "%s: connect[%ld]: mi_inet_pton failed", 11027c478bd9Sstevel@tonic-gate g->a_ctx->ctx_smfi->xxfi_name, 1103058561cbSjbeck (long) g->a_ctx->ctx_id); 11047c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 11057c478bd9Sstevel@tonic-gate } 11067c478bd9Sstevel@tonic-gate sockaddr.sa.sa_family = AF_INET6; 11077c478bd9Sstevel@tonic-gate if (port > 0) 11087c478bd9Sstevel@tonic-gate sockaddr.sin6.sin6_port = port; 11097c478bd9Sstevel@tonic-gate } 11107c478bd9Sstevel@tonic-gate else 11117c478bd9Sstevel@tonic-gate # endif /* NETINET6 */ 11127c478bd9Sstevel@tonic-gate # if NETUNIX 11137c478bd9Sstevel@tonic-gate if (family == SMFIA_UNIX) 11147c478bd9Sstevel@tonic-gate { 11157c478bd9Sstevel@tonic-gate if (sm_strlcpy(sockaddr.sunix.sun_path, s + i, 11167c478bd9Sstevel@tonic-gate sizeof sockaddr.sunix.sun_path) >= 11177c478bd9Sstevel@tonic-gate sizeof sockaddr.sunix.sun_path) 11187c478bd9Sstevel@tonic-gate { 11197c478bd9Sstevel@tonic-gate smi_log(SMI_LOG_ERR, 1120058561cbSjbeck "%s: connect[%ld]: path too long", 11217c478bd9Sstevel@tonic-gate g->a_ctx->ctx_smfi->xxfi_name, 1122058561cbSjbeck (long) g->a_ctx->ctx_id); 11237c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 11247c478bd9Sstevel@tonic-gate } 11257c478bd9Sstevel@tonic-gate sockaddr.sunix.sun_family = AF_UNIX; 11267c478bd9Sstevel@tonic-gate } 11277c478bd9Sstevel@tonic-gate else 11287c478bd9Sstevel@tonic-gate # endif /* NETUNIX */ 11297c478bd9Sstevel@tonic-gate { 11307c478bd9Sstevel@tonic-gate smi_log(SMI_LOG_ERR, 1131058561cbSjbeck "%s: connect[%ld]: unknown family %d", 11327c478bd9Sstevel@tonic-gate g->a_ctx->ctx_smfi->xxfi_name, 1133058561cbSjbeck (long) g->a_ctx->ctx_id, family); 11347c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 11357c478bd9Sstevel@tonic-gate } 11367c478bd9Sstevel@tonic-gate } 11377c478bd9Sstevel@tonic-gate return (*fi_connect)(g->a_ctx, g->a_buf, 11387c478bd9Sstevel@tonic-gate family != SMFIA_UNKNOWN ? &sockaddr : NULL); 11397c478bd9Sstevel@tonic-gate } 11407c478bd9Sstevel@tonic-gate 11417c478bd9Sstevel@tonic-gate /* 11427c478bd9Sstevel@tonic-gate ** ST_EOH -- end of headers 11437c478bd9Sstevel@tonic-gate ** 11447c478bd9Sstevel@tonic-gate ** Parameters: 11457c478bd9Sstevel@tonic-gate ** g -- generic argument structure 11467c478bd9Sstevel@tonic-gate ** 11477c478bd9Sstevel@tonic-gate ** Returns: 11487c478bd9Sstevel@tonic-gate ** continue or filter-specified value 11497c478bd9Sstevel@tonic-gate */ 11507c478bd9Sstevel@tonic-gate 11517c478bd9Sstevel@tonic-gate static int 11527c478bd9Sstevel@tonic-gate st_eoh(g) 11537c478bd9Sstevel@tonic-gate genarg *g; 11547c478bd9Sstevel@tonic-gate { 11557c478bd9Sstevel@tonic-gate sfsistat (*fi_eoh) __P((SMFICTX *)); 11567c478bd9Sstevel@tonic-gate 11577c478bd9Sstevel@tonic-gate if (g == NULL) 11587c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 11597c478bd9Sstevel@tonic-gate if (g->a_ctx->ctx_smfi != NULL && 11607c478bd9Sstevel@tonic-gate (fi_eoh = g->a_ctx->ctx_smfi->xxfi_eoh) != NULL) 11617c478bd9Sstevel@tonic-gate return (*fi_eoh)(g->a_ctx); 11627c478bd9Sstevel@tonic-gate return SMFIS_CONTINUE; 11637c478bd9Sstevel@tonic-gate } 11647c478bd9Sstevel@tonic-gate 11657c478bd9Sstevel@tonic-gate /* 11667c478bd9Sstevel@tonic-gate ** ST_DATA -- DATA command 11677c478bd9Sstevel@tonic-gate ** 11687c478bd9Sstevel@tonic-gate ** Parameters: 11697c478bd9Sstevel@tonic-gate ** g -- generic argument structure 11707c478bd9Sstevel@tonic-gate ** 11717c478bd9Sstevel@tonic-gate ** Returns: 11727c478bd9Sstevel@tonic-gate ** continue or filter-specified value 11737c478bd9Sstevel@tonic-gate */ 11747c478bd9Sstevel@tonic-gate 11757c478bd9Sstevel@tonic-gate static int 11767c478bd9Sstevel@tonic-gate st_data(g) 11777c478bd9Sstevel@tonic-gate genarg *g; 11787c478bd9Sstevel@tonic-gate { 11797c478bd9Sstevel@tonic-gate sfsistat (*fi_data) __P((SMFICTX *)); 11807c478bd9Sstevel@tonic-gate 11817c478bd9Sstevel@tonic-gate if (g == NULL) 11827c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 11837c478bd9Sstevel@tonic-gate if (g->a_ctx->ctx_smfi != NULL && 118424472db6Sjbeck g->a_ctx->ctx_smfi->xxfi_version > 3 && 11857c478bd9Sstevel@tonic-gate (fi_data = g->a_ctx->ctx_smfi->xxfi_data) != NULL) 11867c478bd9Sstevel@tonic-gate return (*fi_data)(g->a_ctx); 11877c478bd9Sstevel@tonic-gate return SMFIS_CONTINUE; 11887c478bd9Sstevel@tonic-gate } 11897c478bd9Sstevel@tonic-gate 11907c478bd9Sstevel@tonic-gate /* 11917c478bd9Sstevel@tonic-gate ** ST_HELO -- helo/ehlo command 11927c478bd9Sstevel@tonic-gate ** 11937c478bd9Sstevel@tonic-gate ** Parameters: 11947c478bd9Sstevel@tonic-gate ** g -- generic argument structure 11957c478bd9Sstevel@tonic-gate ** 11967c478bd9Sstevel@tonic-gate ** Returns: 11977c478bd9Sstevel@tonic-gate ** continue or filter-specified value 11987c478bd9Sstevel@tonic-gate */ 11994aac33d3Sjbeck 12007c478bd9Sstevel@tonic-gate static int 12017c478bd9Sstevel@tonic-gate st_helo(g) 12027c478bd9Sstevel@tonic-gate genarg *g; 12037c478bd9Sstevel@tonic-gate { 12047c478bd9Sstevel@tonic-gate sfsistat (*fi_helo) __P((SMFICTX *, char *)); 12057c478bd9Sstevel@tonic-gate 12067c478bd9Sstevel@tonic-gate if (g == NULL) 12077c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 12087c478bd9Sstevel@tonic-gate mi_clr_macros(g->a_ctx, g->a_idx + 1); 12097c478bd9Sstevel@tonic-gate if (g->a_ctx->ctx_smfi != NULL && 12107c478bd9Sstevel@tonic-gate (fi_helo = g->a_ctx->ctx_smfi->xxfi_helo) != NULL) 12117c478bd9Sstevel@tonic-gate { 12127c478bd9Sstevel@tonic-gate /* paranoia: check for terminating '\0' */ 12137c478bd9Sstevel@tonic-gate if (g->a_len == 0 || g->a_buf[g->a_len - 1] != '\0') 12147c478bd9Sstevel@tonic-gate return MI_FAILURE; 12157c478bd9Sstevel@tonic-gate return (*fi_helo)(g->a_ctx, g->a_buf); 12167c478bd9Sstevel@tonic-gate } 12177c478bd9Sstevel@tonic-gate return SMFIS_CONTINUE; 12187c478bd9Sstevel@tonic-gate } 12194aac33d3Sjbeck 12207c478bd9Sstevel@tonic-gate /* 12217c478bd9Sstevel@tonic-gate ** ST_HEADER -- header line 12227c478bd9Sstevel@tonic-gate ** 12237c478bd9Sstevel@tonic-gate ** Parameters: 12247c478bd9Sstevel@tonic-gate ** g -- generic argument structure 12257c478bd9Sstevel@tonic-gate ** 12267c478bd9Sstevel@tonic-gate ** Returns: 12277c478bd9Sstevel@tonic-gate ** continue or filter-specified value 12287c478bd9Sstevel@tonic-gate */ 12297c478bd9Sstevel@tonic-gate 12307c478bd9Sstevel@tonic-gate static int 12317c478bd9Sstevel@tonic-gate st_header(g) 12327c478bd9Sstevel@tonic-gate genarg *g; 12337c478bd9Sstevel@tonic-gate { 12347c478bd9Sstevel@tonic-gate char *hf, *hv; 12357c478bd9Sstevel@tonic-gate sfsistat (*fi_header) __P((SMFICTX *, char *, char *)); 12367c478bd9Sstevel@tonic-gate 12377c478bd9Sstevel@tonic-gate if (g == NULL) 12387c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 12397c478bd9Sstevel@tonic-gate if (g->a_ctx->ctx_smfi == NULL || 12407c478bd9Sstevel@tonic-gate (fi_header = g->a_ctx->ctx_smfi->xxfi_header) == NULL) 12417c478bd9Sstevel@tonic-gate return SMFIS_CONTINUE; 12427c478bd9Sstevel@tonic-gate if (dec_arg2(g->a_buf, g->a_len, &hf, &hv) == MI_SUCCESS) 12437c478bd9Sstevel@tonic-gate return (*fi_header)(g->a_ctx, hf, hv); 12447c478bd9Sstevel@tonic-gate else 12457c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 12467c478bd9Sstevel@tonic-gate } 12477c478bd9Sstevel@tonic-gate 12487c478bd9Sstevel@tonic-gate #define ARGV_FCT(lf, rf, idx) \ 12497c478bd9Sstevel@tonic-gate char **argv; \ 12507c478bd9Sstevel@tonic-gate sfsistat (*lf) __P((SMFICTX *, char **)); \ 12517c478bd9Sstevel@tonic-gate int r; \ 12527c478bd9Sstevel@tonic-gate \ 12537c478bd9Sstevel@tonic-gate if (g == NULL) \ 12547c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; \ 12557c478bd9Sstevel@tonic-gate mi_clr_macros(g->a_ctx, g->a_idx + 1); \ 12567c478bd9Sstevel@tonic-gate if (g->a_ctx->ctx_smfi == NULL || \ 12577c478bd9Sstevel@tonic-gate (lf = g->a_ctx->ctx_smfi->rf) == NULL) \ 12587c478bd9Sstevel@tonic-gate return SMFIS_CONTINUE; \ 12597c478bd9Sstevel@tonic-gate if ((argv = dec_argv(g->a_buf, g->a_len)) == NULL) \ 12607c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; \ 12617c478bd9Sstevel@tonic-gate r = (*lf)(g->a_ctx, argv); \ 12627c478bd9Sstevel@tonic-gate free(argv); \ 12637c478bd9Sstevel@tonic-gate return r; 12647c478bd9Sstevel@tonic-gate 12657c478bd9Sstevel@tonic-gate /* 12667c478bd9Sstevel@tonic-gate ** ST_SENDER -- MAIL FROM command 12677c478bd9Sstevel@tonic-gate ** 12687c478bd9Sstevel@tonic-gate ** Parameters: 12697c478bd9Sstevel@tonic-gate ** g -- generic argument structure 12707c478bd9Sstevel@tonic-gate ** 12717c478bd9Sstevel@tonic-gate ** Returns: 12727c478bd9Sstevel@tonic-gate ** continue or filter-specified value 12737c478bd9Sstevel@tonic-gate */ 12747c478bd9Sstevel@tonic-gate 12757c478bd9Sstevel@tonic-gate static int 12767c478bd9Sstevel@tonic-gate st_sender(g) 12777c478bd9Sstevel@tonic-gate genarg *g; 12787c478bd9Sstevel@tonic-gate { 12797c478bd9Sstevel@tonic-gate ARGV_FCT(fi_envfrom, xxfi_envfrom, CI_MAIL) 12807c478bd9Sstevel@tonic-gate } 1281058561cbSjbeck 12827c478bd9Sstevel@tonic-gate /* 12837c478bd9Sstevel@tonic-gate ** ST_RCPT -- RCPT TO command 12847c478bd9Sstevel@tonic-gate ** 12857c478bd9Sstevel@tonic-gate ** Parameters: 12867c478bd9Sstevel@tonic-gate ** g -- generic argument structure 12877c478bd9Sstevel@tonic-gate ** 12887c478bd9Sstevel@tonic-gate ** Returns: 12897c478bd9Sstevel@tonic-gate ** continue or filter-specified value 12907c478bd9Sstevel@tonic-gate */ 12917c478bd9Sstevel@tonic-gate 12927c478bd9Sstevel@tonic-gate static int 12937c478bd9Sstevel@tonic-gate st_rcpt(g) 12947c478bd9Sstevel@tonic-gate genarg *g; 12957c478bd9Sstevel@tonic-gate { 12967c478bd9Sstevel@tonic-gate ARGV_FCT(fi_envrcpt, xxfi_envrcpt, CI_RCPT) 12977c478bd9Sstevel@tonic-gate } 12987c478bd9Sstevel@tonic-gate 12997c478bd9Sstevel@tonic-gate /* 13007c478bd9Sstevel@tonic-gate ** ST_UNKNOWN -- unrecognized or unimplemented command 13017c478bd9Sstevel@tonic-gate ** 13027c478bd9Sstevel@tonic-gate ** Parameters: 13037c478bd9Sstevel@tonic-gate ** g -- generic argument structure 13047c478bd9Sstevel@tonic-gate ** 13057c478bd9Sstevel@tonic-gate ** Returns: 13067c478bd9Sstevel@tonic-gate ** continue or filter-specified value 13077c478bd9Sstevel@tonic-gate */ 13087c478bd9Sstevel@tonic-gate 13097c478bd9Sstevel@tonic-gate static int 13107c478bd9Sstevel@tonic-gate st_unknown(g) 13117c478bd9Sstevel@tonic-gate genarg *g; 13127c478bd9Sstevel@tonic-gate { 1313058561cbSjbeck sfsistat (*fi_unknown) __P((SMFICTX *, const char *)); 13147c478bd9Sstevel@tonic-gate 13157c478bd9Sstevel@tonic-gate if (g == NULL) 13167c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 13177c478bd9Sstevel@tonic-gate if (g->a_ctx->ctx_smfi != NULL && 131824472db6Sjbeck g->a_ctx->ctx_smfi->xxfi_version > 2 && 13197c478bd9Sstevel@tonic-gate (fi_unknown = g->a_ctx->ctx_smfi->xxfi_unknown) != NULL) 1320058561cbSjbeck return (*fi_unknown)(g->a_ctx, (const char *) g->a_buf); 13217c478bd9Sstevel@tonic-gate return SMFIS_CONTINUE; 13227c478bd9Sstevel@tonic-gate } 13237c478bd9Sstevel@tonic-gate 13247c478bd9Sstevel@tonic-gate /* 13257c478bd9Sstevel@tonic-gate ** ST_MACROS -- deal with macros received from the MTA 13267c478bd9Sstevel@tonic-gate ** 13277c478bd9Sstevel@tonic-gate ** Parameters: 13287c478bd9Sstevel@tonic-gate ** g -- generic argument structure 13297c478bd9Sstevel@tonic-gate ** 13307c478bd9Sstevel@tonic-gate ** Returns: 13317c478bd9Sstevel@tonic-gate ** continue/keep 13327c478bd9Sstevel@tonic-gate ** 13337c478bd9Sstevel@tonic-gate ** Side effects: 13347c478bd9Sstevel@tonic-gate ** set pointer in macro array to current values. 13357c478bd9Sstevel@tonic-gate */ 13367c478bd9Sstevel@tonic-gate 13377c478bd9Sstevel@tonic-gate static int 13387c478bd9Sstevel@tonic-gate st_macros(g) 13397c478bd9Sstevel@tonic-gate genarg *g; 13407c478bd9Sstevel@tonic-gate { 13417c478bd9Sstevel@tonic-gate int i; 13427c478bd9Sstevel@tonic-gate char **argv; 13437c478bd9Sstevel@tonic-gate 13447c478bd9Sstevel@tonic-gate if (g == NULL || g->a_len < 1) 13457c478bd9Sstevel@tonic-gate return _SMFIS_FAIL; 13467c478bd9Sstevel@tonic-gate if ((argv = dec_argv(g->a_buf + 1, g->a_len - 1)) == NULL) 13477c478bd9Sstevel@tonic-gate return _SMFIS_FAIL; 13487c478bd9Sstevel@tonic-gate switch (g->a_buf[0]) 13497c478bd9Sstevel@tonic-gate { 13507c478bd9Sstevel@tonic-gate case SMFIC_CONNECT: 13517c478bd9Sstevel@tonic-gate i = CI_CONN; 13527c478bd9Sstevel@tonic-gate break; 13537c478bd9Sstevel@tonic-gate case SMFIC_HELO: 13547c478bd9Sstevel@tonic-gate i = CI_HELO; 13557c478bd9Sstevel@tonic-gate break; 13567c478bd9Sstevel@tonic-gate case SMFIC_MAIL: 13577c478bd9Sstevel@tonic-gate i = CI_MAIL; 13587c478bd9Sstevel@tonic-gate break; 13597c478bd9Sstevel@tonic-gate case SMFIC_RCPT: 13607c478bd9Sstevel@tonic-gate i = CI_RCPT; 13617c478bd9Sstevel@tonic-gate break; 1362058561cbSjbeck case SMFIC_DATA: 1363058561cbSjbeck i = CI_DATA; 1364058561cbSjbeck break; 13657c478bd9Sstevel@tonic-gate case SMFIC_BODYEOB: 13667c478bd9Sstevel@tonic-gate i = CI_EOM; 13677c478bd9Sstevel@tonic-gate break; 1368058561cbSjbeck case SMFIC_EOH: 1369058561cbSjbeck i = CI_EOH; 1370058561cbSjbeck break; 13717c478bd9Sstevel@tonic-gate default: 13727c478bd9Sstevel@tonic-gate free(argv); 13737c478bd9Sstevel@tonic-gate return _SMFIS_FAIL; 13747c478bd9Sstevel@tonic-gate } 13757c478bd9Sstevel@tonic-gate if (g->a_ctx->ctx_mac_ptr[i] != NULL) 13767c478bd9Sstevel@tonic-gate free(g->a_ctx->ctx_mac_ptr[i]); 13777c478bd9Sstevel@tonic-gate if (g->a_ctx->ctx_mac_buf[i] != NULL) 13787c478bd9Sstevel@tonic-gate free(g->a_ctx->ctx_mac_buf[i]); 13797c478bd9Sstevel@tonic-gate g->a_ctx->ctx_mac_ptr[i] = argv; 13807c478bd9Sstevel@tonic-gate g->a_ctx->ctx_mac_buf[i] = g->a_buf; 13817c478bd9Sstevel@tonic-gate return _SMFIS_KEEP; 13827c478bd9Sstevel@tonic-gate } 13834aac33d3Sjbeck 13847c478bd9Sstevel@tonic-gate /* 13857c478bd9Sstevel@tonic-gate ** ST_QUIT -- quit command 13867c478bd9Sstevel@tonic-gate ** 13877c478bd9Sstevel@tonic-gate ** Parameters: 13887c478bd9Sstevel@tonic-gate ** g -- generic argument structure 13897c478bd9Sstevel@tonic-gate ** 13907c478bd9Sstevel@tonic-gate ** Returns: 13917c478bd9Sstevel@tonic-gate ** noreply 13927c478bd9Sstevel@tonic-gate */ 13937c478bd9Sstevel@tonic-gate 13947c478bd9Sstevel@tonic-gate /* ARGSUSED */ 13957c478bd9Sstevel@tonic-gate static int 13967c478bd9Sstevel@tonic-gate st_quit(g) 13977c478bd9Sstevel@tonic-gate genarg *g; 13987c478bd9Sstevel@tonic-gate { 1399058561cbSjbeck sfsistat (*fi_close) __P((SMFICTX *)); 1400058561cbSjbeck 1401058561cbSjbeck if (g == NULL) 1402058561cbSjbeck return _SMFIS_ABORT; 1403058561cbSjbeck if (g->a_ctx->ctx_smfi != NULL && 1404058561cbSjbeck (fi_close = g->a_ctx->ctx_smfi->xxfi_close) != NULL) 1405058561cbSjbeck (void) (*fi_close)(g->a_ctx); 1406058561cbSjbeck mi_clr_macros(g->a_ctx, 0); 14077c478bd9Sstevel@tonic-gate return _SMFIS_NOREPLY; 14087c478bd9Sstevel@tonic-gate } 14094aac33d3Sjbeck 14107c478bd9Sstevel@tonic-gate /* 14117c478bd9Sstevel@tonic-gate ** ST_BODYCHUNK -- deal with a piece of the mail body 14127c478bd9Sstevel@tonic-gate ** 14137c478bd9Sstevel@tonic-gate ** Parameters: 14147c478bd9Sstevel@tonic-gate ** g -- generic argument structure 14157c478bd9Sstevel@tonic-gate ** 14167c478bd9Sstevel@tonic-gate ** Returns: 14177c478bd9Sstevel@tonic-gate ** continue or filter-specified value 14187c478bd9Sstevel@tonic-gate */ 14197c478bd9Sstevel@tonic-gate 14207c478bd9Sstevel@tonic-gate static int 14217c478bd9Sstevel@tonic-gate st_bodychunk(g) 14227c478bd9Sstevel@tonic-gate genarg *g; 14237c478bd9Sstevel@tonic-gate { 14247c478bd9Sstevel@tonic-gate sfsistat (*fi_body) __P((SMFICTX *, unsigned char *, size_t)); 14257c478bd9Sstevel@tonic-gate 14267c478bd9Sstevel@tonic-gate if (g == NULL) 14277c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 14287c478bd9Sstevel@tonic-gate if (g->a_ctx->ctx_smfi != NULL && 14297c478bd9Sstevel@tonic-gate (fi_body = g->a_ctx->ctx_smfi->xxfi_body) != NULL) 14307c478bd9Sstevel@tonic-gate return (*fi_body)(g->a_ctx, (unsigned char *)g->a_buf, 14317c478bd9Sstevel@tonic-gate g->a_len); 14327c478bd9Sstevel@tonic-gate return SMFIS_CONTINUE; 14337c478bd9Sstevel@tonic-gate } 14344aac33d3Sjbeck 14357c478bd9Sstevel@tonic-gate /* 14367c478bd9Sstevel@tonic-gate ** ST_BODYEND -- deal with the last piece of the mail body 14377c478bd9Sstevel@tonic-gate ** 14387c478bd9Sstevel@tonic-gate ** Parameters: 14397c478bd9Sstevel@tonic-gate ** g -- generic argument structure 14407c478bd9Sstevel@tonic-gate ** 14417c478bd9Sstevel@tonic-gate ** Returns: 14427c478bd9Sstevel@tonic-gate ** continue or filter-specified value 14437c478bd9Sstevel@tonic-gate ** 14447c478bd9Sstevel@tonic-gate ** Side effects: 14457c478bd9Sstevel@tonic-gate ** sends a reply for the body part (if non-empty). 14467c478bd9Sstevel@tonic-gate */ 14477c478bd9Sstevel@tonic-gate 14487c478bd9Sstevel@tonic-gate static int 14497c478bd9Sstevel@tonic-gate st_bodyend(g) 14507c478bd9Sstevel@tonic-gate genarg *g; 14517c478bd9Sstevel@tonic-gate { 14527c478bd9Sstevel@tonic-gate sfsistat r; 14537c478bd9Sstevel@tonic-gate sfsistat (*fi_body) __P((SMFICTX *, unsigned char *, size_t)); 14547c478bd9Sstevel@tonic-gate sfsistat (*fi_eom) __P((SMFICTX *)); 14557c478bd9Sstevel@tonic-gate 14567c478bd9Sstevel@tonic-gate if (g == NULL) 14577c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 14587c478bd9Sstevel@tonic-gate r = SMFIS_CONTINUE; 14597c478bd9Sstevel@tonic-gate if (g->a_ctx->ctx_smfi != NULL) 14607c478bd9Sstevel@tonic-gate { 14617c478bd9Sstevel@tonic-gate if ((fi_body = g->a_ctx->ctx_smfi->xxfi_body) != NULL && 14627c478bd9Sstevel@tonic-gate g->a_len > 0) 14637c478bd9Sstevel@tonic-gate { 14647c478bd9Sstevel@tonic-gate socket_t sd; 14657c478bd9Sstevel@tonic-gate struct timeval timeout; 14667c478bd9Sstevel@tonic-gate 14677c478bd9Sstevel@tonic-gate timeout.tv_sec = g->a_ctx->ctx_timeout; 14687c478bd9Sstevel@tonic-gate timeout.tv_usec = 0; 14697c478bd9Sstevel@tonic-gate sd = g->a_ctx->ctx_sd; 14707c478bd9Sstevel@tonic-gate r = (*fi_body)(g->a_ctx, (unsigned char *)g->a_buf, 14717c478bd9Sstevel@tonic-gate g->a_len); 14727c478bd9Sstevel@tonic-gate if (r != SMFIS_CONTINUE && 14737c478bd9Sstevel@tonic-gate sendreply(r, sd, &timeout, g->a_ctx) != MI_SUCCESS) 14747c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 14757c478bd9Sstevel@tonic-gate } 14767c478bd9Sstevel@tonic-gate } 14777c478bd9Sstevel@tonic-gate if (r == SMFIS_CONTINUE && 14787c478bd9Sstevel@tonic-gate (fi_eom = g->a_ctx->ctx_smfi->xxfi_eom) != NULL) 14797c478bd9Sstevel@tonic-gate return (*fi_eom)(g->a_ctx); 14807c478bd9Sstevel@tonic-gate return r; 14817c478bd9Sstevel@tonic-gate } 14824aac33d3Sjbeck 14837c478bd9Sstevel@tonic-gate /* 14847c478bd9Sstevel@tonic-gate ** ST_ABORTFCT -- deal with aborts 14857c478bd9Sstevel@tonic-gate ** 14867c478bd9Sstevel@tonic-gate ** Parameters: 14877c478bd9Sstevel@tonic-gate ** g -- generic argument structure 14887c478bd9Sstevel@tonic-gate ** 14897c478bd9Sstevel@tonic-gate ** Returns: 14907c478bd9Sstevel@tonic-gate ** abort or filter-specified value 14917c478bd9Sstevel@tonic-gate */ 14927c478bd9Sstevel@tonic-gate 14937c478bd9Sstevel@tonic-gate static int 14947c478bd9Sstevel@tonic-gate st_abortfct(g) 14957c478bd9Sstevel@tonic-gate genarg *g; 14967c478bd9Sstevel@tonic-gate { 14977c478bd9Sstevel@tonic-gate sfsistat (*fi_abort) __P((SMFICTX *)); 14987c478bd9Sstevel@tonic-gate 14997c478bd9Sstevel@tonic-gate if (g == NULL) 15007c478bd9Sstevel@tonic-gate return _SMFIS_ABORT; 15017c478bd9Sstevel@tonic-gate if (g != NULL && g->a_ctx->ctx_smfi != NULL && 15027c478bd9Sstevel@tonic-gate (fi_abort = g->a_ctx->ctx_smfi->xxfi_abort) != NULL) 15037c478bd9Sstevel@tonic-gate (void) (*fi_abort)(g->a_ctx); 15047c478bd9Sstevel@tonic-gate return _SMFIS_NOREPLY; 15057c478bd9Sstevel@tonic-gate } 15064aac33d3Sjbeck 15077c478bd9Sstevel@tonic-gate /* 15087c478bd9Sstevel@tonic-gate ** TRANS_OK -- is the state transition ok? 15097c478bd9Sstevel@tonic-gate ** 15107c478bd9Sstevel@tonic-gate ** Parameters: 15117c478bd9Sstevel@tonic-gate ** old -- old state 15127c478bd9Sstevel@tonic-gate ** new -- new state 15137c478bd9Sstevel@tonic-gate ** 15147c478bd9Sstevel@tonic-gate ** Returns: 15157c478bd9Sstevel@tonic-gate ** state transition ok 15167c478bd9Sstevel@tonic-gate */ 15177c478bd9Sstevel@tonic-gate 15187c478bd9Sstevel@tonic-gate static bool 15197c478bd9Sstevel@tonic-gate trans_ok(old, new) 15207c478bd9Sstevel@tonic-gate int old, new; 15217c478bd9Sstevel@tonic-gate { 15227c478bd9Sstevel@tonic-gate int s, n; 15237c478bd9Sstevel@tonic-gate 15247c478bd9Sstevel@tonic-gate s = old; 15253ee0e492Sjbeck if (s >= SIZE_NEXT_STATES) 15263ee0e492Sjbeck return false; 15277c478bd9Sstevel@tonic-gate do 15287c478bd9Sstevel@tonic-gate { 15297c478bd9Sstevel@tonic-gate /* is this state transition allowed? */ 15307c478bd9Sstevel@tonic-gate if ((MI_MASK(new) & next_states[s]) != 0) 15317c478bd9Sstevel@tonic-gate return true; 15327c478bd9Sstevel@tonic-gate 15337c478bd9Sstevel@tonic-gate /* 15347c478bd9Sstevel@tonic-gate ** no: try next state; 15357c478bd9Sstevel@tonic-gate ** this works since the relevant states are ordered 15367c478bd9Sstevel@tonic-gate ** strict sequentially 15377c478bd9Sstevel@tonic-gate */ 15387c478bd9Sstevel@tonic-gate 15397c478bd9Sstevel@tonic-gate n = s + 1; 15403ee0e492Sjbeck if (n >= SIZE_NEXT_STATES) 15413ee0e492Sjbeck return false; 15427c478bd9Sstevel@tonic-gate 15437c478bd9Sstevel@tonic-gate /* 15447c478bd9Sstevel@tonic-gate ** can we actually "skip" this state? 15457c478bd9Sstevel@tonic-gate ** see fix_stm() which sets this bit for those 15467c478bd9Sstevel@tonic-gate ** states which the filter program is not interested in 15477c478bd9Sstevel@tonic-gate */ 15487c478bd9Sstevel@tonic-gate 15497c478bd9Sstevel@tonic-gate if (bitset(NX_SKIP, next_states[n])) 15507c478bd9Sstevel@tonic-gate s = n; 15517c478bd9Sstevel@tonic-gate else 15527c478bd9Sstevel@tonic-gate return false; 15533ee0e492Sjbeck } while (s < SIZE_NEXT_STATES); 15547c478bd9Sstevel@tonic-gate return false; 15557c478bd9Sstevel@tonic-gate } 15564aac33d3Sjbeck 15577c478bd9Sstevel@tonic-gate /* 15587c478bd9Sstevel@tonic-gate ** FIX_STM -- add "skip" bits to the state transition table 15597c478bd9Sstevel@tonic-gate ** 15607c478bd9Sstevel@tonic-gate ** Parameters: 15617c478bd9Sstevel@tonic-gate ** ctx -- context structure 15627c478bd9Sstevel@tonic-gate ** 15637c478bd9Sstevel@tonic-gate ** Returns: 15647c478bd9Sstevel@tonic-gate ** None. 15657c478bd9Sstevel@tonic-gate ** 15667c478bd9Sstevel@tonic-gate ** Side effects: 15677c478bd9Sstevel@tonic-gate ** may change state transition table. 15687c478bd9Sstevel@tonic-gate */ 15697c478bd9Sstevel@tonic-gate 15707c478bd9Sstevel@tonic-gate static void 15717c478bd9Sstevel@tonic-gate fix_stm(ctx) 15727c478bd9Sstevel@tonic-gate SMFICTX_PTR ctx; 15737c478bd9Sstevel@tonic-gate { 15747c478bd9Sstevel@tonic-gate unsigned long fl; 15757c478bd9Sstevel@tonic-gate 15767c478bd9Sstevel@tonic-gate if (ctx == NULL || ctx->ctx_smfi == NULL) 15777c478bd9Sstevel@tonic-gate return; 15787c478bd9Sstevel@tonic-gate fl = ctx->ctx_pflags; 15797c478bd9Sstevel@tonic-gate if (bitset(SMFIP_NOCONNECT, fl)) 15807c478bd9Sstevel@tonic-gate next_states[ST_CONN] |= NX_SKIP; 15817c478bd9Sstevel@tonic-gate if (bitset(SMFIP_NOHELO, fl)) 15827c478bd9Sstevel@tonic-gate next_states[ST_HELO] |= NX_SKIP; 15837c478bd9Sstevel@tonic-gate if (bitset(SMFIP_NOMAIL, fl)) 15847c478bd9Sstevel@tonic-gate next_states[ST_MAIL] |= NX_SKIP; 15857c478bd9Sstevel@tonic-gate if (bitset(SMFIP_NORCPT, fl)) 15867c478bd9Sstevel@tonic-gate next_states[ST_RCPT] |= NX_SKIP; 15877c478bd9Sstevel@tonic-gate if (bitset(SMFIP_NOHDRS, fl)) 15887c478bd9Sstevel@tonic-gate next_states[ST_HDRS] |= NX_SKIP; 15897c478bd9Sstevel@tonic-gate if (bitset(SMFIP_NOEOH, fl)) 15907c478bd9Sstevel@tonic-gate next_states[ST_EOHS] |= NX_SKIP; 15917c478bd9Sstevel@tonic-gate if (bitset(SMFIP_NOBODY, fl)) 15927c478bd9Sstevel@tonic-gate next_states[ST_BODY] |= NX_SKIP; 1593058561cbSjbeck if (bitset(SMFIP_NODATA, fl)) 1594058561cbSjbeck next_states[ST_DATA] |= NX_SKIP; 1595058561cbSjbeck if (bitset(SMFIP_NOUNKNOWN, fl)) 1596058561cbSjbeck next_states[ST_UNKN] |= NX_SKIP; 15977c478bd9Sstevel@tonic-gate } 1598058561cbSjbeck 15997c478bd9Sstevel@tonic-gate /* 16007c478bd9Sstevel@tonic-gate ** DEC_ARGV -- split a buffer into a list of strings, NULL terminated 16017c478bd9Sstevel@tonic-gate ** 16027c478bd9Sstevel@tonic-gate ** Parameters: 16037c478bd9Sstevel@tonic-gate ** buf -- buffer with several strings 16047c478bd9Sstevel@tonic-gate ** len -- length of buffer 16057c478bd9Sstevel@tonic-gate ** 16067c478bd9Sstevel@tonic-gate ** Returns: 16077c478bd9Sstevel@tonic-gate ** array of pointers to the individual strings 16087c478bd9Sstevel@tonic-gate */ 16097c478bd9Sstevel@tonic-gate 16107c478bd9Sstevel@tonic-gate static char ** 16117c478bd9Sstevel@tonic-gate dec_argv(buf, len) 16127c478bd9Sstevel@tonic-gate char *buf; 16137c478bd9Sstevel@tonic-gate size_t len; 16147c478bd9Sstevel@tonic-gate { 16157c478bd9Sstevel@tonic-gate char **s; 16167c478bd9Sstevel@tonic-gate size_t i; 16177c478bd9Sstevel@tonic-gate int elem, nelem; 16187c478bd9Sstevel@tonic-gate 16197c478bd9Sstevel@tonic-gate nelem = 0; 16207c478bd9Sstevel@tonic-gate for (i = 0; i < len; i++) 16217c478bd9Sstevel@tonic-gate { 16227c478bd9Sstevel@tonic-gate if (buf[i] == '\0') 16237c478bd9Sstevel@tonic-gate ++nelem; 16247c478bd9Sstevel@tonic-gate } 16257c478bd9Sstevel@tonic-gate if (nelem == 0) 16267c478bd9Sstevel@tonic-gate return NULL; 16277c478bd9Sstevel@tonic-gate 16287c478bd9Sstevel@tonic-gate /* last entry is only for the name */ 16297c478bd9Sstevel@tonic-gate s = (char **)malloc((nelem + 1) * (sizeof *s)); 16307c478bd9Sstevel@tonic-gate if (s == NULL) 16317c478bd9Sstevel@tonic-gate return NULL; 16327c478bd9Sstevel@tonic-gate s[0] = buf; 16337c478bd9Sstevel@tonic-gate for (i = 0, elem = 0; i < len && elem < nelem; i++) 16347c478bd9Sstevel@tonic-gate { 16357c478bd9Sstevel@tonic-gate if (buf[i] == '\0') 16367c478bd9Sstevel@tonic-gate { 16377c478bd9Sstevel@tonic-gate ++elem; 16387c478bd9Sstevel@tonic-gate if (i + 1 >= len) 16397c478bd9Sstevel@tonic-gate s[elem] = NULL; 16407c478bd9Sstevel@tonic-gate else 16417c478bd9Sstevel@tonic-gate s[elem] = &(buf[i + 1]); 16427c478bd9Sstevel@tonic-gate } 16437c478bd9Sstevel@tonic-gate } 16447c478bd9Sstevel@tonic-gate 16457c478bd9Sstevel@tonic-gate /* overwrite last entry (already done above, just paranoia) */ 16467c478bd9Sstevel@tonic-gate s[elem] = NULL; 16477c478bd9Sstevel@tonic-gate return s; 16487c478bd9Sstevel@tonic-gate } 16494aac33d3Sjbeck 16507c478bd9Sstevel@tonic-gate /* 16517c478bd9Sstevel@tonic-gate ** DEC_ARG2 -- split a buffer into two strings 16527c478bd9Sstevel@tonic-gate ** 16537c478bd9Sstevel@tonic-gate ** Parameters: 16547c478bd9Sstevel@tonic-gate ** buf -- buffer with two strings 16557c478bd9Sstevel@tonic-gate ** len -- length of buffer 16567c478bd9Sstevel@tonic-gate ** s1,s2 -- pointer to result strings 16577c478bd9Sstevel@tonic-gate ** 16587c478bd9Sstevel@tonic-gate ** Returns: 16597c478bd9Sstevel@tonic-gate ** MI_FAILURE/MI_SUCCESS 16607c478bd9Sstevel@tonic-gate */ 16617c478bd9Sstevel@tonic-gate 16627c478bd9Sstevel@tonic-gate static int 16637c478bd9Sstevel@tonic-gate dec_arg2(buf, len, s1, s2) 16647c478bd9Sstevel@tonic-gate char *buf; 16657c478bd9Sstevel@tonic-gate size_t len; 16667c478bd9Sstevel@tonic-gate char **s1; 16677c478bd9Sstevel@tonic-gate char **s2; 16687c478bd9Sstevel@tonic-gate { 16697c478bd9Sstevel@tonic-gate size_t i; 16707c478bd9Sstevel@tonic-gate 16717c478bd9Sstevel@tonic-gate /* paranoia: check for terminating '\0' */ 16727c478bd9Sstevel@tonic-gate if (len == 0 || buf[len - 1] != '\0') 16737c478bd9Sstevel@tonic-gate return MI_FAILURE; 16747c478bd9Sstevel@tonic-gate *s1 = buf; 16757c478bd9Sstevel@tonic-gate for (i = 1; i < len && buf[i] != '\0'; i++) 16767c478bd9Sstevel@tonic-gate continue; 16777c478bd9Sstevel@tonic-gate if (i >= len - 1) 16787c478bd9Sstevel@tonic-gate return MI_FAILURE; 16797c478bd9Sstevel@tonic-gate *s2 = buf + i + 1; 16807c478bd9Sstevel@tonic-gate return MI_SUCCESS; 16817c478bd9Sstevel@tonic-gate } 16824aac33d3Sjbeck 16837c478bd9Sstevel@tonic-gate /* 16847c478bd9Sstevel@tonic-gate ** SENDOK -- is it ok for the filter to send stuff to the MTA? 16857c478bd9Sstevel@tonic-gate ** 16867c478bd9Sstevel@tonic-gate ** Parameters: 16877c478bd9Sstevel@tonic-gate ** ctx -- context structure 16887c478bd9Sstevel@tonic-gate ** flag -- flag to check 16897c478bd9Sstevel@tonic-gate ** 16907c478bd9Sstevel@tonic-gate ** Returns: 16917c478bd9Sstevel@tonic-gate ** sending allowed (in current state) 16927c478bd9Sstevel@tonic-gate */ 16937c478bd9Sstevel@tonic-gate 16947c478bd9Sstevel@tonic-gate bool 16957c478bd9Sstevel@tonic-gate mi_sendok(ctx, flag) 16967c478bd9Sstevel@tonic-gate SMFICTX_PTR ctx; 16977c478bd9Sstevel@tonic-gate int flag; 16987c478bd9Sstevel@tonic-gate { 16997c478bd9Sstevel@tonic-gate if (ctx == NULL || ctx->ctx_smfi == NULL) 17007c478bd9Sstevel@tonic-gate return false; 17017c478bd9Sstevel@tonic-gate 17027c478bd9Sstevel@tonic-gate /* did the milter request this operation? */ 1703058561cbSjbeck if (flag != 0 && !bitset(flag, ctx->ctx_aflags)) 17047c478bd9Sstevel@tonic-gate return false; 17057c478bd9Sstevel@tonic-gate 17067c478bd9Sstevel@tonic-gate /* are we in the correct state? It must be "End of Message". */ 17077c478bd9Sstevel@tonic-gate return ctx->ctx_state == ST_ENDM; 17087c478bd9Sstevel@tonic-gate } 1709058561cbSjbeck 1710058561cbSjbeck #if _FFR_WORKERS_POOL 1711058561cbSjbeck /* 1712058561cbSjbeck ** MI_RD_SOCKET_READY - checks if the socket is ready for read(2) 1713058561cbSjbeck ** 1714058561cbSjbeck ** Parameters: 1715058561cbSjbeck ** sd -- socket_t 1716058561cbSjbeck ** 1717058561cbSjbeck ** Returns: 1718058561cbSjbeck ** true iff socket is ready for read(2) 1719058561cbSjbeck */ 1720058561cbSjbeck 1721058561cbSjbeck #define MI_RD_CMD_TO 1 1722058561cbSjbeck #define MI_RD_MAX_ERR 16 1723058561cbSjbeck 1724058561cbSjbeck static bool 1725058561cbSjbeck mi_rd_socket_ready (sd) 1726058561cbSjbeck socket_t sd; 1727058561cbSjbeck { 1728058561cbSjbeck int n; 1729058561cbSjbeck int nerr = 0; 1730058561cbSjbeck #if SM_CONF_POLL 1731058561cbSjbeck struct pollfd pfd; 1732058561cbSjbeck #else /* SM_CONF_POLL */ 1733058561cbSjbeck fd_set rd_set, exc_set; 1734058561cbSjbeck #endif /* SM_CONF_POLL */ 1735058561cbSjbeck 1736058561cbSjbeck do 1737058561cbSjbeck { 1738058561cbSjbeck #if SM_CONF_POLL 1739058561cbSjbeck pfd.fd = sd; 1740058561cbSjbeck pfd.events = POLLIN; 1741058561cbSjbeck pfd.revents = 0; 1742058561cbSjbeck 1743058561cbSjbeck n = poll(&pfd, 1, MI_RD_CMD_TO); 1744058561cbSjbeck #else /* SM_CONF_POLL */ 1745058561cbSjbeck struct timeval timeout; 1746058561cbSjbeck 1747058561cbSjbeck FD_ZERO(&rd_set); 1748058561cbSjbeck FD_ZERO(&exc_set); 1749058561cbSjbeck FD_SET(sd, &rd_set); 1750058561cbSjbeck FD_SET(sd, &exc_set); 1751058561cbSjbeck 1752058561cbSjbeck timeout.tv_sec = MI_RD_CMD_TO / 1000; 1753058561cbSjbeck timeout.tv_usec = 0; 1754058561cbSjbeck n = select(sd + 1, &rd_set, NULL, &exc_set, &timeout); 1755058561cbSjbeck #endif /* SM_CONF_POLL */ 1756058561cbSjbeck 1757058561cbSjbeck if (n < 0) 1758058561cbSjbeck { 1759058561cbSjbeck if (errno == EINTR) 1760058561cbSjbeck { 1761058561cbSjbeck nerr++; 1762058561cbSjbeck continue; 1763058561cbSjbeck } 1764058561cbSjbeck return true; 1765058561cbSjbeck } 1766058561cbSjbeck 1767058561cbSjbeck if (n == 0) 1768058561cbSjbeck return false; 1769058561cbSjbeck break; 1770058561cbSjbeck } while (nerr < MI_RD_MAX_ERR); 1771058561cbSjbeck if (nerr >= MI_RD_MAX_ERR) 1772058561cbSjbeck return false; 1773058561cbSjbeck 1774058561cbSjbeck #if SM_CONF_POLL 1775058561cbSjbeck return (pfd.revents != 0); 1776058561cbSjbeck #else /* SM_CONF_POLL */ 1777058561cbSjbeck return FD_ISSET(sd, &rd_set) || FD_ISSET(sd, &exc_set); 1778058561cbSjbeck #endif /* SM_CONF_POLL */ 1779058561cbSjbeck } 1780058561cbSjbeck #endif /* _FFR_WORKERS_POOL */ 1781