contrib/sendmail-8.13.8/libmilter/engine.c

   1 /*
   2  *  Copyright (c) 1999-2004, 2006 Sendmail, Inc. and its suppliers.
   3  *      All rights reserved.
   4  *
   5  * By using this file, you agree to the terms and conditions set
   6  * forth in the LICENSE file which can be found at the top level of
   7  * the sendmail distribution.
   8  *
   9  */
  10
  11 #include <sm/gen.h>
  12 SM_RCSID("@(#)$Id: engine.c,v 8.121 2006/04/18 21:01:46 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 */
  21 struct arg_struct
  22 {
  23         size_t          a_len;          /* length of buffer */
  24         char            *a_buf;         /* argument string */
  25         int             a_idx;          /* index for macro array */
  26         SMFICTX_PTR     a_ctx;          /* context */
  27 };
  28
  29 typedef struct arg_struct genarg;
  30
  31 /* structure for commands received from MTA */
  32 struct cmdfct_t
  33 {
  34         char    cm_cmd;                         /* command */
  35         int     cm_argt;                        /* type of arguments expected */
  36         int     cm_next;                        /* next state */
  37         int     cm_todo;                        /* what to do next */
  38         int     cm_macros;                      /* index for macros */
  39         int     (*cm_fct) __P((genarg *));      /* function to execute */
  40 };
  41
  42 typedef struct cmdfct_t cmdfct;
  43
  44 /* possible values for cm_argt */
  45 #define CM_ARG0 0       /* no args */
  46 #define CM_ARG1 1       /* one arg (string) */
  47 #define CM_ARG2 2       /* two args (strings) */
  48 #define CM_ARGA 4       /* one string and _SOCK_ADDR */
  49 #define CM_ARGO 5       /* two integers */
  50 #define CM_ARGV 8       /* \0 separated list of args, NULL-terminated */
  51 #define CM_ARGN 9       /* \0 separated list of args (strings) */
  52
  53 /* possible values for cm_todo */
  54 #define CT_CONT         0x0000  /* continue reading commands */
  55 #define CT_IGNO         0x0001  /* continue even when error  */
  56
  57 /* not needed right now, done via return code instead */
  58 #define CT_KEEP         0x0004  /* keep buffer (contains symbols) */
  59 #define CT_END          0x0008  /* start replying */
  60
  61 /* index in macro array: macros only for these commands */
  62 #define CI_NONE         (-1)
  63 #define CI_CONN         0
  64 #define CI_HELO         1
  65 #define CI_MAIL         2
  66 #define CI_RCPT         3
  67 #define CI_EOM          4
  68 #if CI_EOM >= MAX_MACROS_ENTRIES
  69 ERROR: do not compile with CI_EOM >= MAX_MACROS_ENTRIES
  70 #endif
  71
  72 /* function prototypes */
  73 static int      st_abortfct __P((genarg *));
  74 static int      st_macros __P((genarg *));
  75 static int      st_optionneg __P((genarg *));
  76 static int      st_bodychunk __P((genarg *));
  77 static int      st_connectinfo __P((genarg *));
  78 static int      st_bodyend __P((genarg *));
  79 static int      st_helo __P((genarg *));
  80 static int      st_header __P((genarg *));
  81 static int      st_sender __P((genarg *));
  82 static int      st_rcpt __P((genarg *));
  83 #if SMFI_VERSION > 2
  84 static int      st_unknown __P((genarg *));
  85 #endif /* SMFI_VERSION > 2 */
  86 #if SMFI_VERSION > 3
  87 static int      st_data __P((genarg *));
  88 #endif /* SMFI_VERSION > 3 */
  89 static int      st_eoh __P((genarg *));
  90 static int      st_quit __P((genarg *));
  91 static int      sendreply __P((sfsistat, socket_t, struct timeval *, SMFICTX_PTR));
  92 static void     fix_stm __P((SMFICTX_PTR));
  93 static bool     trans_ok __P((int, int));
  94 static char     **dec_argv __P((char *, size_t));
  95 static int      dec_arg2 __P((char *, size_t, char **, char **));
  96
  97 /* states */
  98 #define ST_NONE (-1)
  99 #define ST_INIT 0       /* initial state */
 100 #define ST_OPTS 1       /* option negotiation */
 101 #define ST_CONN 2       /* connection info */
 102 #define ST_HELO 3       /* helo */
 103 #define ST_MAIL 4       /* mail from */
 104 #define ST_RCPT 5       /* rcpt to */
 105 #define ST_DATA 6       /* data */
 106 #define ST_HDRS 7       /* headers */
 107 #define ST_EOHS 8       /* end of headers */
 108 #define ST_BODY 9       /* body */
 109 #define ST_ENDM 10      /* end of message */
 110 #define ST_QUIT 11      /* quit */
 111 #define ST_ABRT 12      /* abort */
 112 #define ST_UNKN 13      /* unknown SMTP command */
 113 #define ST_LAST ST_UNKN /* last valid state */
 114 #define ST_SKIP 15      /* not a state but required for the state table */
 115
 116 /* in a mail transaction? must be before eom according to spec. */
 117 #define ST_IN_MAIL(st)  ((st) >= ST_MAIL && (st) < ST_ENDM)
 118
 119 /*
 120 **  set of next states
 121 **  each state (ST_*) corresponds to bit in an int value (1 << state)
 122 **  each state has a set of allowed transitions ('or' of bits of states)
 123 **  so a state transition is valid if the mask of the next state
 124 **  is set in the NX_* value
 125 **  this function is coded in trans_ok(), see below.
 126 */
 127
 128 #define MI_MASK(x)      (0x0001 << (x)) /* generate a bit "mask" for a state */
 129 #define NX_INIT (MI_MASK(ST_OPTS))
 130 #define NX_OPTS (MI_MASK(ST_CONN) | MI_MASK(ST_UNKN))
 131 #define NX_CONN (MI_MASK(ST_HELO) | MI_MASK(ST_MAIL) | MI_MASK(ST_UNKN))
 132 #define NX_HELO (MI_MASK(ST_HELO) | MI_MASK(ST_MAIL) | MI_MASK(ST_UNKN))
 133 #define NX_MAIL (MI_MASK(ST_RCPT) | MI_MASK(ST_ABRT) | MI_MASK(ST_UNKN))
 134 #define NX_RCPT (MI_MASK(ST_HDRS) | MI_MASK(ST_EOHS) | MI_MASK(ST_DATA) | \
 135                  MI_MASK(ST_BODY) | MI_MASK(ST_ENDM) | \
 136                  MI_MASK(ST_RCPT) | MI_MASK(ST_ABRT) | MI_MASK(ST_UNKN))
 137 #define NX_DATA (MI_MASK(ST_EOHS) | MI_MASK(ST_HDRS) | MI_MASK(ST_ABRT))
 138 #define NX_HDRS (MI_MASK(ST_EOHS) | MI_MASK(ST_HDRS) | MI_MASK(ST_ABRT))
 139 #define NX_EOHS (MI_MASK(ST_BODY) | MI_MASK(ST_ENDM) | MI_MASK(ST_ABRT))
 140 #define NX_BODY (MI_MASK(ST_ENDM) | MI_MASK(ST_BODY) | MI_MASK(ST_ABRT))
 141 #define NX_ENDM (MI_MASK(ST_QUIT) | MI_MASK(ST_MAIL) | MI_MASK(ST_UNKN))
 142 #define NX_QUIT 0
 143 #define NX_ABRT 0
 144 #define NX_UNKN (MI_MASK(ST_HELO) | MI_MASK(ST_MAIL) | \
 145                  MI_MASK(ST_RCPT) | MI_MASK(ST_ABRT) | \
 146                  MI_MASK(ST_DATA) | \
 147                  MI_MASK(ST_BODY) | MI_MASK(ST_UNKN) | \
 148                  MI_MASK(ST_ABRT) | MI_MASK(ST_QUIT))
 149 #define NX_SKIP MI_MASK(ST_SKIP)
 150
 151 static int next_states[] =
 152 {
 153         NX_INIT,
 154         NX_OPTS,
 155         NX_CONN,
 156         NX_HELO,
 157         NX_MAIL,
 158         NX_RCPT,
 159         NX_DATA,
 160         NX_HDRS,
 161         NX_EOHS,
 162         NX_BODY,
 163         NX_ENDM,
 164         NX_QUIT,
 165         NX_ABRT,
 166         NX_UNKN
 167 };
 168
 169 #define SIZE_NEXT_STATES        (sizeof(next_states) / sizeof(next_states[0]))
 170
 171 /* commands received by milter */
 172 static cmdfct cmds[] =
 173 {
 174 {SMFIC_ABORT,   CM_ARG0, ST_ABRT,  CT_CONT,     CI_NONE, st_abortfct    },
 175 {SMFIC_MACRO,   CM_ARGV, ST_NONE,  CT_KEEP,     CI_NONE, st_macros      },
 176 {SMFIC_BODY,    CM_ARG1, ST_BODY,  CT_CONT,     CI_NONE, st_bodychunk   },
 177 {SMFIC_CONNECT, CM_ARG2, ST_CONN,  CT_CONT,     CI_CONN, st_connectinfo },
 178 {SMFIC_BODYEOB, CM_ARG1, ST_ENDM,  CT_CONT,     CI_EOM,  st_bodyend     },
 179 {SMFIC_HELO,    CM_ARG1, ST_HELO,  CT_CONT,     CI_HELO, st_helo        },
 180 {SMFIC_HEADER,  CM_ARG2, ST_HDRS,  CT_CONT,     CI_NONE, st_header      },
 181 {SMFIC_MAIL,    CM_ARGV, ST_MAIL,  CT_CONT,     CI_MAIL, st_sender      },
 182 {SMFIC_OPTNEG,  CM_ARGO, ST_OPTS,  CT_CONT,     CI_NONE, st_optionneg   },
 183 {SMFIC_EOH,     CM_ARG0, ST_EOHS,  CT_CONT,     CI_NONE, st_eoh         },
 184 {SMFIC_QUIT,    CM_ARG0, ST_QUIT,  CT_END,      CI_NONE, st_quit        },
 185 #if SMFI_VERSION > 3
 186 {SMFIC_DATA,    CM_ARG0, ST_DATA,  CT_CONT,     CI_NONE, st_data        },
 187 #endif /* SMFI_VERSION > 3 */
 188 {SMFIC_RCPT,    CM_ARGV, ST_RCPT,  CT_IGNO,     CI_RCPT, st_rcpt        }
 189 #if SMFI_VERSION > 2
 190 ,{SMFIC_UNKNOWN,CM_ARG1, ST_UNKN,  CT_IGNO,     CI_NONE, st_unknown     }
 191 #endif /* SMFI_VERSION > 2 */
 192 };
 193
 194 /* additional (internal) reply codes */
 195 #define _SMFIS_KEEP     20
 196 #define _SMFIS_ABORT    21
 197 #define _SMFIS_OPTIONS  22
 198 #define _SMFIS_NOREPLY  23
 199 #define _SMFIS_FAIL     (-1)
 200 #define _SMFIS_NONE     (-2)
 201
 202 /*
 203 **  MI_ENGINE -- receive commands and process them
 204 **
 205 **      Parameters:
 206 **              ctx -- context structure
 207 **
 208 **      Returns:
 209 **              MI_FAILURE/MI_SUCCESS
 210 */
 211 int
 212 mi_engine(ctx)
 213         SMFICTX_PTR ctx;
 214 {
 215         size_t len;
 216         int i;
 217         socket_t sd;
 218         int ret = MI_SUCCESS;
 219         int ncmds = sizeof(cmds) / sizeof(cmdfct);
 220         int curstate = ST_INIT;
 221         int newstate;
 222         bool call_abort;
 223         sfsistat r;
 224         char cmd;
 225         char *buf = NULL;
 226         genarg arg;
 227         struct timeval timeout;
 228         int (*f) __P((genarg *));
 229         sfsistat (*fi_abort) __P((SMFICTX *));
 230         sfsistat (*fi_close) __P((SMFICTX *));
 231
 232         arg.a_ctx = ctx;
 233         sd = ctx->ctx_sd;
 234         fi_abort = ctx->ctx_smfi->xxfi_abort;
 235         mi_clr_macros(ctx, 0);
 236         fix_stm(ctx);
 237         r = _SMFIS_NONE;
 238         do
 239         {
 240                 /* call abort only if in a mail transaction */
 241                 call_abort = ST_IN_MAIL(curstate);
 242                 timeout.tv_sec = ctx->ctx_timeout;
 243                 timeout.tv_usec = 0;
 244                 if (mi_stop() == MILTER_ABRT)
 245                 {
 246                         if (ctx->ctx_dbg > 3)
 247                                 sm_dprintf("[%d] milter_abort\n",
 248                                         (int) ctx->ctx_id);
 249                         ret = MI_FAILURE;
 250                         break;
 251                 }
 252
 253                 /*
 254                 **  Notice: buf is allocated by mi_rd_cmd() and it will
 255                 **  usually be free()d after it has been used in f().
 256                 **  However, if the function returns _SMFIS_KEEP then buf
 257                 **  contains macros and will not be free()d.
 258                 **  Hence r must be set to _SMFIS_NONE if a new buf is
 259                 **  allocated to avoid problem with housekeeping, esp.
 260                 **  if the code "break"s out of the loop.
 261                 */
 262
 263                 r = _SMFIS_NONE;
 264                 if ((buf = mi_rd_cmd(sd, &timeout, &cmd, &len,
 265                                      ctx->ctx_smfi->xxfi_name)) == NULL &&
 266                     cmd < SMFIC_VALIDCMD)
 267                 {
 268                         if (ctx->ctx_dbg > 5)
 269                                 sm_dprintf("[%d] mi_engine: mi_rd_cmd error (%x)\n",
 270                                         (int) ctx->ctx_id, (int) cmd);
 271
 272                         /*
 273                         **  eof is currently treated as failure ->
 274                         **  abort() instead of close(), otherwise use:
 275                         **  if (cmd != SMFIC_EOF)
 276                         */
 277
 278                         ret = MI_FAILURE;
 279                         break;
 280                 }
 281                 if (ctx->ctx_dbg > 4)
 282                         sm_dprintf("[%d] got cmd '%c' len %d\n",
 283                                 (int) ctx->ctx_id, cmd, (int) len);
 284                 for (i = 0; i < ncmds; i++)
 285                 {
 286                         if (cmd == cmds[i].cm_cmd)
 287                                 break;
 288                 }
 289                 if (i >= ncmds)
 290                 {
 291                         /* unknown command */
 292                         if (ctx->ctx_dbg > 1)
 293                                 sm_dprintf("[%d] cmd '%c' unknown\n",
 294                                         (int) ctx->ctx_id, cmd);
 295                         ret = MI_FAILURE;
 296                         break;
 297                 }
 298                 if ((f = cmds[i].cm_fct) == NULL)
 299                 {
 300                         /* stop for now */
 301                         if (ctx->ctx_dbg > 1)
 302                                 sm_dprintf("[%d] cmd '%c' not impl\n",
 303                                         (int) ctx->ctx_id, cmd);
 304                         ret = MI_FAILURE;
 305                         break;
 306                 }
 307
 308                 /* is new state ok? */
 309                 newstate = cmds[i].cm_next;
 310                 if (ctx->ctx_dbg > 5)
 311                         sm_dprintf("[%d] cur %x new %x nextmask %x\n",
 312                                 (int) ctx->ctx_id,
 313                                 curstate, newstate, next_states[curstate]);
 314
 315                 if (newstate != ST_NONE && !trans_ok(curstate, newstate))
 316                 {
 317                         if (ctx->ctx_dbg > 1)
 318                                 sm_dprintf("[%d] abort: cur %d (%x) new %d (%x) next %x\n",
 319                                         (int) ctx->ctx_id,
 320                                         curstate, MI_MASK(curstate),
 321                                         newstate, MI_MASK(newstate),
 322                                         next_states[curstate]);
 323
 324                         /* call abort only if in a mail transaction */
 325                         if (fi_abort != NULL && call_abort)
 326                                 (void) (*fi_abort)(ctx);
 327
 328                         /*
 329                         **  try to reach the new state from HELO
 330                         **  if it can't be reached, ignore the command.
 331                         */
 332
 333                         curstate = ST_HELO;
 334                         if (!trans_ok(curstate, newstate))
 335                         {
 336                                 if (buf != NULL)
 337                                 {
 338                                         free(buf);
 339                                         buf = NULL;
 340                                 }
 341                                 continue;
 342                         }
 343                 }
 344                 arg.a_len = len;
 345                 arg.a_buf = buf;
 346                 if (newstate != ST_NONE)
 347                 {
 348                         curstate = newstate;
 349                         ctx->ctx_state = curstate;
 350                 }
 351                 arg.a_idx = cmds[i].cm_macros;
 352                 call_abort = ST_IN_MAIL(curstate);
 353
 354                 /* call function to deal with command */
 355                 r = (*f)(&arg);
 356                 if (r != _SMFIS_KEEP && buf != NULL)
 357                 {
 358                         free(buf);
 359                         buf = NULL;
 360                 }
 361                 if (sendreply(r, sd, &timeout, ctx) != MI_SUCCESS)
 362                 {
 363                         ret = MI_FAILURE;
 364                         break;
 365                 }
 366
 367                 if (r == SMFIS_ACCEPT)
 368                 {
 369                         /* accept mail, no further actions taken */
 370                         curstate = ST_HELO;
 371                 }
 372                 else if (r == SMFIS_REJECT || r == SMFIS_DISCARD ||
 373                          r ==  SMFIS_TEMPFAIL)
 374                 {
 375                         /*
 376                         **  further actions depend on current state
 377                         **  if the IGNO bit is set: "ignore" the error,
 378                         **  i.e., stay in the current state
 379                         */
 380                         if (!bitset(CT_IGNO, cmds[i].cm_todo))
 381                                 curstate = ST_HELO;
 382                 }
 383                 else if (r == _SMFIS_ABORT)
 384                 {
 385                         if (ctx->ctx_dbg > 5)
 386                                 sm_dprintf("[%d] function returned abort\n",
 387                                         (int) ctx->ctx_id);
 388                         ret = MI_FAILURE;
 389                         break;
 390                 }
 391         } while (!bitset(CT_END, cmds[i].cm_todo));
 392
 393         if (ret != MI_SUCCESS)
 394         {
 395                 /* call abort only if in a mail transaction */
 396                 if (fi_abort != NULL && call_abort)
 397                         (void) (*fi_abort)(ctx);
 398         }
 399
 400         /* close must always be called */
 401         if ((fi_close = ctx->ctx_smfi->xxfi_close) != NULL)
 402                 (void) (*fi_close)(ctx);
 403         if (r != _SMFIS_KEEP && buf != NULL)
 404                 free(buf);
 405         mi_clr_macros(ctx, 0);
 406         return ret;
 407 }
 408 /*
 409 **  SENDREPLY -- send a reply to the MTA
 410 **
 411 **      Parameters:
 412 **              r -- reply code
 413 **              sd -- socket descriptor
 414 **              timeout_ptr -- (ptr to) timeout to use for sending
 415 **              ctx -- context structure
 416 **
 417 **      Returns:
 418 **              MI_SUCCESS/MI_FAILURE
 419 */
 420
 421 static int
 422 sendreply(r, sd, timeout_ptr, ctx)
 423         sfsistat r;
 424         socket_t sd;
 425         struct timeval *timeout_ptr;
 426         SMFICTX_PTR ctx;
 427 {
 428         int ret = MI_SUCCESS;
 429
 430         switch (r)
 431         {
 432           case SMFIS_CONTINUE:
 433                 ret = mi_wr_cmd(sd, timeout_ptr, SMFIR_CONTINUE, NULL, 0);
 434                 break;
 435           case SMFIS_TEMPFAIL:
 436           case SMFIS_REJECT:
 437                 if (ctx->ctx_reply != NULL &&
 438                     ((r == SMFIS_TEMPFAIL && *ctx->ctx_reply == '4') ||
 439                      (r == SMFIS_REJECT && *ctx->ctx_reply == '5')))
 440                 {
 441                         ret = mi_wr_cmd(sd, timeout_ptr, SMFIR_REPLYCODE,
 442                                         ctx->ctx_reply,
 443                                         strlen(ctx->ctx_reply) + 1);
 444                         free(ctx->ctx_reply);
 445                         ctx->ctx_reply = NULL;
 446                 }
 447                 else
 448                 {
 449                         ret = mi_wr_cmd(sd, timeout_ptr, r == SMFIS_REJECT ?
 450                                         SMFIR_REJECT : SMFIR_TEMPFAIL, NULL, 0);
 451                 }
 452                 break;
 453           case SMFIS_DISCARD:
 454                 ret = mi_wr_cmd(sd, timeout_ptr, SMFIR_DISCARD, NULL, 0);
 455                 break;
 456           case SMFIS_ACCEPT:
 457                 ret = mi_wr_cmd(sd, timeout_ptr, SMFIR_ACCEPT, NULL, 0);
 458                 break;
 459           case _SMFIS_OPTIONS:
 460                 {
 461                         char buf[MILTER_OPTLEN];
 462                         mi_int32 v;
 463
 464                         v = htonl(ctx->ctx_smfi->xxfi_version);
 465                         (void) memcpy(&(buf[0]), (void *) &v, MILTER_LEN_BYTES);
 466                         v = htonl(ctx->ctx_smfi->xxfi_flags);
 467                         (void) memcpy(&(buf[MILTER_LEN_BYTES]), (void *) &v,
 468                                       MILTER_LEN_BYTES);
 469                         v = htonl(ctx->ctx_pflags);
 470                         (void) memcpy(&(buf[MILTER_LEN_BYTES * 2]), (void *) &v,
 471                                       MILTER_LEN_BYTES);
 472                         ret = mi_wr_cmd(sd, timeout_ptr, SMFIC_OPTNEG, buf,
 473                                        MILTER_OPTLEN);
 474                 }
 475                 break;
 476           default:      /* don't send a reply */
 477                 break;
 478         }
 479         return ret;
 480 }
 481
 482 /*
 483 **  CLR_MACROS -- clear set of macros starting from a given index
 484 **
 485 **      Parameters:
 486 **              ctx -- context structure
 487 **              m -- index from which to clear all macros
 488 **
 489 **      Returns:
 490 **              None.
 491 */
 492 void
 493 mi_clr_macros(ctx, m)
 494         SMFICTX_PTR ctx;
 495         int m;
 496 {
 497         int i;
 498
 499         for (i = m; i < MAX_MACROS_ENTRIES; i++)
 500         {
 501                 if (ctx->ctx_mac_ptr[i] != NULL)
 502                 {
 503                         free(ctx->ctx_mac_ptr[i]);
 504                         ctx->ctx_mac_ptr[i] = NULL;
 505                 }
 506                 if (ctx->ctx_mac_buf[i] != NULL)
 507                 {
 508                         free(ctx->ctx_mac_buf[i]);
 509                         ctx->ctx_mac_buf[i] = NULL;
 510                 }
 511         }
 512 }
 513 /*
 514 **  ST_OPTIONNEG -- negotiate options
 515 **
 516 **      Parameters:
 517 **              g -- generic argument structure
 518 **
 519 **      Returns:
 520 **              abort/send options/continue
 521 */
 522
 523 static int
 524 st_optionneg(g)
 525         genarg *g;
 526 {
 527         mi_int32 i, v;
 528
 529         if (g == NULL || g->a_ctx->ctx_smfi == NULL)
 530                 return SMFIS_CONTINUE;
 531         mi_clr_macros(g->a_ctx, g->a_idx + 1);
 532
 533         /* check for minimum length */
 534         if (g->a_len < MILTER_OPTLEN)
 535         {
 536                 smi_log(SMI_LOG_ERR,
 537                         "%s: st_optionneg[%d]: len too short %d < %d",
 538                         g->a_ctx->ctx_smfi->xxfi_name,
 539                         (int) g->a_ctx->ctx_id, (int) g->a_len,
 540                         MILTER_OPTLEN);
 541                 return _SMFIS_ABORT;
 542         }
 543
 544         (void) memcpy((void *) &i, (void *) &(g->a_buf[0]),
 545                       MILTER_LEN_BYTES);
 546         v = ntohl(i);
 547         if (v < g->a_ctx->ctx_smfi->xxfi_version)
 548         {
 549                 /* hard failure for now! */
 550                 smi_log(SMI_LOG_ERR,
 551                         "%s: st_optionneg[%d]: version mismatch MTA: %d < milter: %d",
 552                         g->a_ctx->ctx_smfi->xxfi_name,
 553                         (int) g->a_ctx->ctx_id, (int) v,
 554                         g->a_ctx->ctx_smfi->xxfi_version);
 555                 return _SMFIS_ABORT;
 556         }
 557
 558         (void) memcpy((void *) &i, (void *) &(g->a_buf[MILTER_LEN_BYTES]),
 559                       MILTER_LEN_BYTES);
 560         v = ntohl(i);
 561
 562         /* no flags? set to default value for V1 actions */
 563         if (v == 0)
 564                 v = SMFI_V1_ACTS;
 565         i = g->a_ctx->ctx_smfi->xxfi_flags;
 566         if ((v & i) != i)
 567         {
 568                 smi_log(SMI_LOG_ERR,
 569                         "%s: st_optionneg[%d]: 0x%x does not fulfill action requirements 0x%x",
 570                         g->a_ctx->ctx_smfi->xxfi_name,
 571                         (int) g->a_ctx->ctx_id, v, i);
 572                 return _SMFIS_ABORT;
 573         }
 574
 575         (void) memcpy((void *) &i, (void *) &(g->a_buf[MILTER_LEN_BYTES * 2]),
 576                       MILTER_LEN_BYTES);
 577         v = ntohl(i);
 578
 579         /* no flags? set to default value for V1 protocol */
 580         if (v == 0)
 581                 v = SMFI_V1_PROT;
 582         i = g->a_ctx->ctx_pflags;
 583         if ((v & i) != i)
 584         {
 585                 smi_log(SMI_LOG_ERR,
 586                         "%s: st_optionneg[%d]: 0x%x does not fulfill protocol requirements 0x%x",
 587                         g->a_ctx->ctx_smfi->xxfi_name,
 588                         (int) g->a_ctx->ctx_id, v, i);
 589                 return _SMFIS_ABORT;
 590         }
 591
 592         return _SMFIS_OPTIONS;
 593 }
 594 /*
 595 **  ST_CONNECTINFO -- receive connection information
 596 **
 597 **      Parameters:
 598 **              g -- generic argument structure
 599 **
 600 **      Returns:
 601 **              continue or filter-specified value
 602 */
 603
 604 static int
 605 st_connectinfo(g)
 606         genarg *g;
 607 {
 608         size_t l;
 609         size_t i;
 610         char *s, family;
 611         unsigned short port = 0;
 612         _SOCK_ADDR sockaddr;
 613         sfsistat (*fi_connect) __P((SMFICTX *, char *, _SOCK_ADDR *));
 614
 615         if (g == NULL)
 616                 return _SMFIS_ABORT;
 617         mi_clr_macros(g->a_ctx, g->a_idx + 1);
 618         if (g->a_ctx->ctx_smfi == NULL ||
 619             (fi_connect = g->a_ctx->ctx_smfi->xxfi_connect) == NULL)
 620                 return SMFIS_CONTINUE;
 621
 622         s = g->a_buf;
 623         i = 0;
 624         l = g->a_len;
 625         while (s[i] != '\0' && i <= l)
 626                 ++i;
 627         if (i + 1 >= l)
 628                 return _SMFIS_ABORT;
 629
 630         /* Move past trailing \0 in host string */
 631         i++;
 632         family = s[i++];
 633         (void) memset(&sockaddr, '\0', sizeof sockaddr);
 634         if (family != SMFIA_UNKNOWN)
 635         {
 636                 if (i + sizeof port >= l)
 637                 {
 638                         smi_log(SMI_LOG_ERR,
 639                                 "%s: connect[%d]: wrong len %d >= %d",
 640                                 g->a_ctx->ctx_smfi->xxfi_name,
 641                                 (int) g->a_ctx->ctx_id, (int) i, (int) l);
 642                         return _SMFIS_ABORT;
 643                 }
 644                 (void) memcpy((void *) &port, (void *) (s + i),
 645                               sizeof port);
 646                 i += sizeof port;
 647
 648                 /* make sure string is terminated */
 649                 if (s[l - 1] != '\0')
 650                         return _SMFIS_ABORT;
 651 # if NETINET
 652                 if (family == SMFIA_INET)
 653                 {
 654                         if (inet_aton(s + i, (struct in_addr *) &sockaddr.sin.sin_addr)
 655                             != 1)
 656                         {
 657                                 smi_log(SMI_LOG_ERR,
 658                                         "%s: connect[%d]: inet_aton failed",
 659                                         g->a_ctx->ctx_smfi->xxfi_name,
 660                                         (int) g->a_ctx->ctx_id);
 661                                 return _SMFIS_ABORT;
 662                         }
 663                         sockaddr.sa.sa_family = AF_INET;
 664                         if (port > 0)
 665                                 sockaddr.sin.sin_port = port;
 666                 }
 667                 else
 668 # endif /* NETINET */
 669 # if NETINET6
 670                 if (family == SMFIA_INET6)
 671                 {
 672                         if (mi_inet_pton(AF_INET6, s + i,
 673                                          &sockaddr.sin6.sin6_addr) != 1)
 674                         {
 675                                 smi_log(SMI_LOG_ERR,
 676                                         "%s: connect[%d]: mi_inet_pton failed",
 677                                         g->a_ctx->ctx_smfi->xxfi_name,
 678                                         (int) g->a_ctx->ctx_id);
 679                                 return _SMFIS_ABORT;
 680                         }
 681                         sockaddr.sa.sa_family = AF_INET6;
 682                         if (port > 0)
 683                                 sockaddr.sin6.sin6_port = port;
 684                 }
 685                 else
 686 # endif /* NETINET6 */
 687 # if NETUNIX
 688                 if (family == SMFIA_UNIX)
 689                 {
 690                         if (sm_strlcpy(sockaddr.sunix.sun_path, s + i,
 691                             sizeof sockaddr.sunix.sun_path) >=
 692                             sizeof sockaddr.sunix.sun_path)
 693                         {
 694                                 smi_log(SMI_LOG_ERR,
 695                                         "%s: connect[%d]: path too long",
 696                                         g->a_ctx->ctx_smfi->xxfi_name,
 697                                         (int) g->a_ctx->ctx_id);
 698                                 return _SMFIS_ABORT;
 699                         }
 700                         sockaddr.sunix.sun_family = AF_UNIX;
 701                 }
 702                 else
 703 # endif /* NETUNIX */
 704                 {
 705                         smi_log(SMI_LOG_ERR,
 706                                 "%s: connect[%d]: unknown family %d",
 707                                 g->a_ctx->ctx_smfi->xxfi_name,
 708                                 (int) g->a_ctx->ctx_id, family);
 709                         return _SMFIS_ABORT;
 710                 }
 711         }
 712         return (*fi_connect)(g->a_ctx, g->a_buf,
 713                              family != SMFIA_UNKNOWN ? &sockaddr : NULL);
 714 }
 715
 716 /*
 717 **  ST_EOH -- end of headers
 718 **
 719 **      Parameters:
 720 **              g -- generic argument structure
 721 **
 722 **      Returns:
 723 **              continue or filter-specified value
 724 */
 725
 726 static int
 727 st_eoh(g)
 728         genarg *g;
 729 {
 730         sfsistat (*fi_eoh) __P((SMFICTX *));
 731
 732         if (g == NULL)
 733                 return _SMFIS_ABORT;
 734         if (g->a_ctx->ctx_smfi != NULL &&
 735             (fi_eoh = g->a_ctx->ctx_smfi->xxfi_eoh) != NULL)
 736                 return (*fi_eoh)(g->a_ctx);
 737         return SMFIS_CONTINUE;
 738 }
 739
 740 #if SMFI_VERSION > 3
 741 /*
 742 **  ST_DATA -- DATA command
 743 **
 744 **      Parameters:
 745 **              g -- generic argument structure
 746 **
 747 **      Returns:
 748 **              continue or filter-specified value
 749 */
 750
 751 static int
 752 st_data(g)
 753         genarg *g;
 754 {
 755         sfsistat (*fi_data) __P((SMFICTX *));
 756
 757         if (g == NULL)
 758                 return _SMFIS_ABORT;
 759         if (g->a_ctx->ctx_smfi != NULL &&
 760             (fi_data = g->a_ctx->ctx_smfi->xxfi_data) != NULL)
 761                 return (*fi_data)(g->a_ctx);
 762         return SMFIS_CONTINUE;
 763 }
 764 #endif /* SMFI_VERSION > 3 */
 765
 766 /*
 767 **  ST_HELO -- helo/ehlo command
 768 **
 769 **      Parameters:
 770 **              g -- generic argument structure
 771 **
 772 **      Returns:
 773 **              continue or filter-specified value
 774 */
 775 static int
 776 st_helo(g)
 777         genarg *g;
 778 {
 779         sfsistat (*fi_helo) __P((SMFICTX *, char *));
 780
 781         if (g == NULL)
 782                 return _SMFIS_ABORT;
 783         mi_clr_macros(g->a_ctx, g->a_idx + 1);
 784         if (g->a_ctx->ctx_smfi != NULL &&
 785             (fi_helo = g->a_ctx->ctx_smfi->xxfi_helo) != NULL)
 786         {
 787                 /* paranoia: check for terminating '\0' */
 788                 if (g->a_len == 0 || g->a_buf[g->a_len - 1] != '\0')
 789                         return MI_FAILURE;
 790                 return (*fi_helo)(g->a_ctx, g->a_buf);
 791         }
 792         return SMFIS_CONTINUE;
 793 }
 794 /*
 795 **  ST_HEADER -- header line
 796 **
 797 **      Parameters:
 798 **              g -- generic argument structure
 799 **
 800 **      Returns:
 801 **              continue or filter-specified value
 802 */
 803
 804 static int
 805 st_header(g)
 806         genarg *g;
 807 {
 808         char *hf, *hv;
 809         sfsistat (*fi_header) __P((SMFICTX *, char *, char *));
 810
 811         if (g == NULL)
 812                 return _SMFIS_ABORT;
 813         if (g->a_ctx->ctx_smfi == NULL ||
 814             (fi_header = g->a_ctx->ctx_smfi->xxfi_header) == NULL)
 815                 return SMFIS_CONTINUE;
 816         if (dec_arg2(g->a_buf, g->a_len, &hf, &hv) == MI_SUCCESS)
 817                 return (*fi_header)(g->a_ctx, hf, hv);
 818         else
 819                 return _SMFIS_ABORT;
 820 }
 821
 822 #define ARGV_FCT(lf, rf, idx)                                   \
 823         char **argv;                                            \
 824         sfsistat (*lf) __P((SMFICTX *, char **));               \
 825         int r;                                                  \
 826                                                                 \
 827         if (g == NULL)                                          \
 828                 return _SMFIS_ABORT;                            \
 829         mi_clr_macros(g->a_ctx, g->a_idx + 1);                  \
 830         if (g->a_ctx->ctx_smfi == NULL ||                       \
 831             (lf = g->a_ctx->ctx_smfi->rf) == NULL)              \
 832                 return SMFIS_CONTINUE;                          \
 833         if ((argv = dec_argv(g->a_buf, g->a_len)) == NULL)      \
 834                 return _SMFIS_ABORT;                            \
 835         r = (*lf)(g->a_ctx, argv);                              \
 836         free(argv);                                             \
 837         return r;
 838
 839 /*
 840 **  ST_SENDER -- MAIL FROM command
 841 **
 842 **      Parameters:
 843 **              g -- generic argument structure
 844 **
 845 **      Returns:
 846 **              continue or filter-specified value
 847 */
 848
 849 static int
 850 st_sender(g)
 851         genarg *g;
 852 {
 853         ARGV_FCT(fi_envfrom, xxfi_envfrom, CI_MAIL)
 854 }
 855 /*
 856 **  ST_RCPT -- RCPT TO command
 857 **
 858 **      Parameters:
 859 **              g -- generic argument structure
 860 **
 861 **      Returns:
 862 **              continue or filter-specified value
 863 */
 864
 865 static int
 866 st_rcpt(g)
 867         genarg *g;
 868 {
 869         ARGV_FCT(fi_envrcpt, xxfi_envrcpt, CI_RCPT)
 870 }
 871
 872 #if SMFI_VERSION > 2
 873 /*
 874 **  ST_UNKNOWN -- unrecognized or unimplemented command
 875 **
 876 **      Parameters:
 877 **              g -- generic argument structure
 878 **
 879 **      Returns:
 880 **              continue or filter-specified value
 881 */
 882
 883 static int
 884 st_unknown(g)
 885         genarg *g;
 886 {
 887         sfsistat (*fi_unknown) __P((SMFICTX *, char *));
 888
 889         if (g == NULL)
 890                 return _SMFIS_ABORT;
 891         mi_clr_macros(g->a_ctx, g->a_idx + 1);
 892         if (g->a_ctx->ctx_smfi != NULL &&
 893             (fi_unknown = g->a_ctx->ctx_smfi->xxfi_unknown) != NULL)
 894                 return (*fi_unknown)(g->a_ctx, g->a_buf);
 895         return SMFIS_CONTINUE;
 896 }
 897 #endif /* SMFI_VERSION > 2 */
 898
 899 /*
 900 **  ST_MACROS -- deal with macros received from the MTA
 901 **
 902 **      Parameters:
 903 **              g -- generic argument structure
 904 **
 905 **      Returns:
 906 **              continue/keep
 907 **
 908 **      Side effects:
 909 **              set pointer in macro array to current values.
 910 */
 911
 912 static int
 913 st_macros(g)
 914         genarg *g;
 915 {
 916         int i;
 917         char **argv;
 918
 919         if (g == NULL || g->a_len < 1)
 920                 return _SMFIS_FAIL;
 921         if ((argv = dec_argv(g->a_buf + 1, g->a_len - 1)) == NULL)
 922                 return _SMFIS_FAIL;
 923         switch (g->a_buf[0])
 924         {
 925           case SMFIC_CONNECT:
 926                 i = CI_CONN;
 927                 break;
 928           case SMFIC_HELO:
 929                 i = CI_HELO;
 930                 break;
 931           case SMFIC_MAIL:
 932                 i = CI_MAIL;
 933                 break;
 934           case SMFIC_RCPT:
 935                 i = CI_RCPT;
 936                 break;
 937           case SMFIC_BODYEOB:
 938                 i = CI_EOM;
 939                 break;
 940           default:
 941                 free(argv);
 942                 return _SMFIS_FAIL;
 943         }
 944         if (g->a_ctx->ctx_mac_ptr[i] != NULL)
 945                 free(g->a_ctx->ctx_mac_ptr[i]);
 946         if (g->a_ctx->ctx_mac_buf[i] != NULL)
 947                 free(g->a_ctx->ctx_mac_buf[i]);
 948         g->a_ctx->ctx_mac_ptr[i] = argv;
 949         g->a_ctx->ctx_mac_buf[i] = g->a_buf;
 950         return _SMFIS_KEEP;
 951 }
 952 /*
 953 **  ST_QUIT -- quit command
 954 **
 955 **      Parameters:
 956 **              g -- generic argument structure
 957 **
 958 **      Returns:
 959 **              noreply
 960 */
 961
 962 /* ARGSUSED */
 963 static int
 964 st_quit(g)
 965         genarg *g;
 966 {
 967         return _SMFIS_NOREPLY;
 968 }
 969 /*
 970 **  ST_BODYCHUNK -- deal with a piece of the mail body
 971 **
 972 **      Parameters:
 973 **              g -- generic argument structure
 974 **
 975 **      Returns:
 976 **              continue or filter-specified value
 977 */
 978
 979 static int
 980 st_bodychunk(g)
 981         genarg *g;
 982 {
 983         sfsistat (*fi_body) __P((SMFICTX *, unsigned char *, size_t));
 984
 985         if (g == NULL)
 986                 return _SMFIS_ABORT;
 987         if (g->a_ctx->ctx_smfi != NULL &&
 988             (fi_body = g->a_ctx->ctx_smfi->xxfi_body) != NULL)
 989                 return (*fi_body)(g->a_ctx, (unsigned char *)g->a_buf,
 990                                   g->a_len);
 991         return SMFIS_CONTINUE;
 992 }
 993 /*
 994 **  ST_BODYEND -- deal with the last piece of the mail body
 995 **
 996 **      Parameters:
 997 **              g -- generic argument structure
 998 **
 999 **      Returns:
1000 **              continue or filter-specified value
1001 **
1002 **      Side effects:
1003 **              sends a reply for the body part (if non-empty).
1004 */
1005
1006 static int
1007 st_bodyend(g)
1008         genarg *g;
1009 {
1010         sfsistat r;
1011         sfsistat (*fi_body) __P((SMFICTX *, unsigned char *, size_t));
1012         sfsistat (*fi_eom) __P((SMFICTX *));
1013
1014         if (g == NULL)
1015                 return _SMFIS_ABORT;
1016         r = SMFIS_CONTINUE;
1017         if (g->a_ctx->ctx_smfi != NULL)
1018         {
1019                 if ((fi_body = g->a_ctx->ctx_smfi->xxfi_body) != NULL &&
1020                     g->a_len > 0)
1021                 {
1022                         socket_t sd;
1023                         struct timeval timeout;
1024
1025                         timeout.tv_sec = g->a_ctx->ctx_timeout;
1026                         timeout.tv_usec = 0;
1027                         sd = g->a_ctx->ctx_sd;
1028                         r = (*fi_body)(g->a_ctx, (unsigned char *)g->a_buf,
1029                                        g->a_len);
1030                         if (r != SMFIS_CONTINUE &&
1031                             sendreply(r, sd, &timeout, g->a_ctx) != MI_SUCCESS)
1032                                 return _SMFIS_ABORT;
1033                 }
1034         }
1035         if (r == SMFIS_CONTINUE &&
1036             (fi_eom = g->a_ctx->ctx_smfi->xxfi_eom) != NULL)
1037                 return (*fi_eom)(g->a_ctx);
1038         return r;
1039 }
1040 /*
1041 **  ST_ABORTFCT -- deal with aborts
1042 **
1043 **      Parameters:
1044 **              g -- generic argument structure
1045 **
1046 **      Returns:
1047 **              abort or filter-specified value
1048 */
1049
1050 static int
1051 st_abortfct(g)
1052         genarg *g;
1053 {
1054         sfsistat (*fi_abort) __P((SMFICTX *));
1055
1056         if (g == NULL)
1057                 return _SMFIS_ABORT;
1058         if (g != NULL && g->a_ctx->ctx_smfi != NULL &&
1059             (fi_abort = g->a_ctx->ctx_smfi->xxfi_abort) != NULL)
1060                 (void) (*fi_abort)(g->a_ctx);
1061         return _SMFIS_NOREPLY;
1062 }
1063 /*
1064 **  TRANS_OK -- is the state transition ok?
1065 **
1066 **      Parameters:
1067 **              old -- old state
1068 **              new -- new state
1069 **
1070 **      Returns:
1071 **              state transition ok
1072 */
1073
1074 static bool
1075 trans_ok(old, new)
1076         int old, new;
1077 {
1078         int s, n;
1079
1080         s = old;
1081         if (s >= SIZE_NEXT_STATES)
1082                 return false;
1083         do
1084         {
1085                 /* is this state transition allowed? */
1086                 if ((MI_MASK(new) & next_states[s]) != 0)
1087                         return true;
1088
1089                 /*
1090                 **  no: try next state;
1091                 **  this works since the relevant states are ordered
1092                 **  strict sequentially
1093                 */
1094
1095                 n = s + 1;
1096                 if (n >= SIZE_NEXT_STATES)
1097                         return false;
1098
1099                 /*
1100                 **  can we actually "skip" this state?
1101                 **  see fix_stm() which sets this bit for those
1102                 **  states which the filter program is not interested in
1103                 */
1104
1105                 if (bitset(NX_SKIP, next_states[n]))
1106                         s = n;
1107                 else
1108                         return false;
1109         } while (s < SIZE_NEXT_STATES);
1110         return false;
1111 }
1112 /*
1113 **  FIX_STM -- add "skip" bits to the state transition table
1114 **
1115 **      Parameters:
1116 **              ctx -- context structure
1117 **
1118 **      Returns:
1119 **              None.
1120 **
1121 **      Side effects:
1122 **              may change state transition table.
1123 */
1124
1125 static void
1126 fix_stm(ctx)
1127         SMFICTX_PTR ctx;
1128 {
1129         unsigned long fl;
1130
1131         if (ctx == NULL || ctx->ctx_smfi == NULL)
1132                 return;
1133         fl = ctx->ctx_pflags;
1134         if (bitset(SMFIP_NOCONNECT, fl))
1135                 next_states[ST_CONN] |= NX_SKIP;
1136         if (bitset(SMFIP_NOHELO, fl))
1137                 next_states[ST_HELO] |= NX_SKIP;
1138         if (bitset(SMFIP_NOMAIL, fl))
1139                 next_states[ST_MAIL] |= NX_SKIP;
1140         if (bitset(SMFIP_NORCPT, fl))
1141                 next_states[ST_RCPT] |= NX_SKIP;
1142         if (bitset(SMFIP_NOHDRS, fl))
1143                 next_states[ST_HDRS] |= NX_SKIP;
1144         if (bitset(SMFIP_NOEOH, fl))
1145                 next_states[ST_EOHS] |= NX_SKIP;
1146         if (bitset(SMFIP_NOBODY, fl))
1147                 next_states[ST_BODY] |= NX_SKIP;
1148 }
1149 /*
1150 **  DEC_ARGV -- split a buffer into a list of strings, NULL terminated
1151 **
1152 **      Parameters:
1153 **              buf -- buffer with several strings
1154 **              len -- length of buffer
1155 **
1156 **      Returns:
1157 **              array of pointers to the individual strings
1158 */
1159
1160 static char **
1161 dec_argv(buf, len)
1162         char *buf;
1163         size_t len;
1164 {
1165         char **s;
1166         size_t i;
1167         int elem, nelem;
1168
1169         nelem = 0;
1170         for (i = 0; i < len; i++)
1171         {
1172                 if (buf[i] == '\0')
1173                         ++nelem;
1174         }
1175         if (nelem == 0)
1176                 return NULL;
1177
1178         /* last entry is only for the name */
1179         s = (char **)malloc((nelem + 1) * (sizeof *s));
1180         if (s == NULL)
1181                 return NULL;
1182         s[0] = buf;
1183         for (i = 0, elem = 0; i < len && elem < nelem; i++)
1184         {
1185                 if (buf[i] == '\0')
1186                 {
1187                         ++elem;
1188                         if (i + 1 >= len)
1189                                 s[elem] = NULL;
1190                         else
1191                                 s[elem] = &(buf[i + 1]);
1192                 }
1193         }
1194
1195         /* overwrite last entry (already done above, just paranoia) */
1196         s[elem] = NULL;
1197         return s;
1198 }
1199 /*
1200 **  DEC_ARG2 -- split a buffer into two strings
1201 **
1202 **      Parameters:
1203 **              buf -- buffer with two strings
1204 **              len -- length of buffer
1205 **              s1,s2 -- pointer to result strings
1206 **
1207 **      Returns:
1208 **              MI_FAILURE/MI_SUCCESS
1209 */
1210
1211 static int
1212 dec_arg2(buf, len, s1, s2)
1213         char *buf;
1214         size_t len;
1215         char **s1;
1216         char **s2;
1217 {
1218         size_t i;
1219
1220         /* paranoia: check for terminating '\0' */
1221         if (len == 0 || buf[len - 1] != '\0')
1222                 return MI_FAILURE;
1223         *s1 = buf;
1224         for (i = 1; i < len && buf[i] != '\0'; i++)
1225                 continue;
1226         if (i >= len - 1)
1227                 return MI_FAILURE;
1228         *s2 = buf + i + 1;
1229         return MI_SUCCESS;
1230 }
1231 /*
1232 **  SENDOK -- is it ok for the filter to send stuff to the MTA?
1233 **
1234 **      Parameters:
1235 **              ctx -- context structure
1236 **              flag -- flag to check
1237 **
1238 **      Returns:
1239 **              sending allowed (in current state)
1240 */
1241
1242 bool
1243 mi_sendok(ctx, flag)
1244         SMFICTX_PTR ctx;
1245         int flag;
1246 {
1247         if (ctx == NULL || ctx->ctx_smfi == NULL)
1248                 return false;
1249
1250         /* did the milter request this operation? */
1251         if (flag != 0 && !bitset(flag, ctx->ctx_smfi->xxfi_flags))
1252                 return false;
1253
1254         /* are we in the correct state? It must be "End of Message". */
1255         return ctx->ctx_state == ST_ENDM;
1256 }