contrib/sendmail/libmilter/smfi.c

   1 /*
   2  *  Copyright (c) 1999-2002 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: smfi.c,v 8.64 2002/04/30 22:22:02 msk Exp $")
  13 #include <sm/varargs.h>
  14 #include "libmilter.h"
  15
  16 /* for smfi_set{ml}reply, let's be generous. 256/16 should be sufficient */
  17 #define MAXREPLYLEN     980     /* max. length of a reply string */
  18 #define MAXREPLIES      32      /* max. number of reply strings */
  19
  20 /*
  21 **  SMFI_ADDHEADER -- send a new header to the MTA
  22 **
  23 **      Parameters:
  24 **              ctx -- Opaque context structure
  25 **              headerf -- Header field name
  26 **              headerv -- Header field value
  27 **
  28 **      Returns:
  29 **              MI_SUCCESS/MI_FAILURE
  30 */
  31
  32 int
  33 smfi_addheader(ctx, headerf, headerv)
  34         SMFICTX *ctx;
  35         char *headerf;
  36         char *headerv;
  37 {
  38         /* do we want to copy the stuff or have a special mi_wr_cmd call? */
  39         size_t len, l1, l2;
  40         int r;
  41         char *buf;
  42         struct timeval timeout;
  43
  44         if (headerf == NULL || *headerf == '\0' || headerv == NULL)
  45                 return MI_FAILURE;
  46         if (!mi_sendok(ctx, SMFIF_ADDHDRS))
  47                 return MI_FAILURE;
  48         timeout.tv_sec = ctx->ctx_timeout;
  49         timeout.tv_usec = 0;
  50         l1 = strlen(headerf);
  51         l2 = strlen(headerv);
  52         len = l1 + l2 + 2;
  53         buf = malloc(len);
  54         if (buf == NULL)
  55                 return MI_FAILURE;
  56         (void) memcpy(buf, headerf, l1 + 1);
  57         (void) memcpy(buf + l1 + 1, headerv, l2 + 1);
  58         r = mi_wr_cmd(ctx->ctx_sd, &timeout, SMFIR_ADDHEADER, buf, len);
  59         free(buf);
  60         return r;
  61 }
  62
  63 /*
  64 **  SMFI_CHGHEADER -- send a changed header to the MTA
  65 **
  66 **      Parameters:
  67 **              ctx -- Opaque context structure
  68 **              headerf -- Header field name
  69 **              hdridx -- Header index value
  70 **              headerv -- Header field value
  71 **
  72 **      Returns:
  73 **              MI_SUCCESS/MI_FAILURE
  74 */
  75
  76 int
  77 smfi_chgheader(ctx, headerf, hdridx, headerv)
  78         SMFICTX *ctx;
  79         char *headerf;
  80         mi_int32 hdridx;
  81         char *headerv;
  82 {
  83         /* do we want to copy the stuff or have a special mi_wr_cmd call? */
  84         size_t len, l1, l2;
  85         int r;
  86         mi_int32 v;
  87         char *buf;
  88         struct timeval timeout;
  89
  90         if (headerf == NULL || *headerf == '\0')
  91                 return MI_FAILURE;
  92         if (hdridx < 0)
  93                 return MI_FAILURE;
  94         if (!mi_sendok(ctx, SMFIF_CHGHDRS))
  95                 return MI_FAILURE;
  96         timeout.tv_sec = ctx->ctx_timeout;
  97         timeout.tv_usec = 0;
  98         if (headerv == NULL)
  99                 headerv = "";
 100         l1 = strlen(headerf);
 101         l2 = strlen(headerv);
 102         len = l1 + l2 + 2 + MILTER_LEN_BYTES;
 103         buf = malloc(len);
 104         if (buf == NULL)
 105                 return MI_FAILURE;
 106         v = htonl(hdridx);
 107         (void) memcpy(&(buf[0]), (void *) &v, MILTER_LEN_BYTES);
 108         (void) memcpy(buf + MILTER_LEN_BYTES, headerf, l1 + 1);
 109         (void) memcpy(buf + MILTER_LEN_BYTES + l1 + 1, headerv, l2 + 1);
 110         r = mi_wr_cmd(ctx->ctx_sd, &timeout, SMFIR_CHGHEADER, buf, len);
 111         free(buf);
 112         return r;
 113 }
 114
 115 /*
 116 **  SMFI_ADDRCPT -- send an additional recipient to the MTA
 117 **
 118 **      Parameters:
 119 **              ctx -- Opaque context structure
 120 **              rcpt -- recipient address
 121 **
 122 **      Returns:
 123 **              MI_SUCCESS/MI_FAILURE
 124 */
 125
 126 int
 127 smfi_addrcpt(ctx, rcpt)
 128         SMFICTX *ctx;
 129         char *rcpt;
 130 {
 131         size_t len;
 132         struct timeval timeout;
 133
 134         if (rcpt == NULL || *rcpt == '\0')
 135                 return MI_FAILURE;
 136         if (!mi_sendok(ctx, SMFIF_ADDRCPT))
 137                 return MI_FAILURE;
 138         timeout.tv_sec = ctx->ctx_timeout;
 139         timeout.tv_usec = 0;
 140         len = strlen(rcpt) + 1;
 141         return mi_wr_cmd(ctx->ctx_sd, &timeout, SMFIR_ADDRCPT, rcpt, len);
 142 }
 143
 144 /*
 145 **  SMFI_DELRCPT -- send a recipient to be removed to the MTA
 146 **
 147 **      Parameters:
 148 **              ctx -- Opaque context structure
 149 **              rcpt -- recipient address
 150 **
 151 **      Returns:
 152 **              MI_SUCCESS/MI_FAILURE
 153 */
 154
 155 int
 156 smfi_delrcpt(ctx, rcpt)
 157         SMFICTX *ctx;
 158         char *rcpt;
 159 {
 160         size_t len;
 161         struct timeval timeout;
 162
 163         if (rcpt == NULL || *rcpt == '\0')
 164                 return MI_FAILURE;
 165         if (!mi_sendok(ctx, SMFIF_DELRCPT))
 166                 return MI_FAILURE;
 167         timeout.tv_sec = ctx->ctx_timeout;
 168         timeout.tv_usec = 0;
 169         len = strlen(rcpt) + 1;
 170         return mi_wr_cmd(ctx->ctx_sd, &timeout, SMFIR_DELRCPT, rcpt, len);
 171 }
 172
 173 /*
 174 **  SMFI_REPLACEBODY -- send a body chunk to the MTA
 175 **
 176 **      Parameters:
 177 **              ctx -- Opaque context structure
 178 **              bodyp -- body chunk
 179 **              bodylen -- length of body chunk
 180 **
 181 **      Returns:
 182 **              MI_SUCCESS/MI_FAILURE
 183 */
 184
 185 int
 186 smfi_replacebody(ctx, bodyp, bodylen)
 187         SMFICTX *ctx;
 188         unsigned char *bodyp;
 189         int bodylen;
 190 {
 191         int len, off, r;
 192         struct timeval timeout;
 193
 194         if (bodylen < 0 ||
 195             (bodyp == NULL && bodylen > 0))
 196                 return MI_FAILURE;
 197         if (!mi_sendok(ctx, SMFIF_CHGBODY))
 198                 return MI_FAILURE;
 199         timeout.tv_sec = ctx->ctx_timeout;
 200         timeout.tv_usec = 0;
 201
 202         /* split body chunk if necessary */
 203         off = 0;
 204         while (bodylen > 0)
 205         {
 206                 len = (bodylen >= MILTER_CHUNK_SIZE) ? MILTER_CHUNK_SIZE :
 207                                                        bodylen;
 208                 if ((r = mi_wr_cmd(ctx->ctx_sd, &timeout, SMFIR_REPLBODY,
 209                                 (char *) (bodyp + off), len)) != MI_SUCCESS)
 210                         return r;
 211                 off += len;
 212                 bodylen -= len;
 213         }
 214         return MI_SUCCESS;
 215 }
 216
 217 #if _FFR_QUARANTINE
 218 /*
 219 **  SMFI_QUARANTINE -- quarantine an envelope
 220 **
 221 **      Parameters:
 222 **              ctx -- Opaque context structure
 223 **              reason -- why?
 224 **
 225 **      Returns:
 226 **              MI_SUCCESS/MI_FAILURE
 227 */
 228
 229 int
 230 smfi_quarantine(ctx, reason)
 231         SMFICTX *ctx;
 232         char *reason;
 233 {
 234         size_t len;
 235         int r;
 236         char *buf;
 237         struct timeval timeout;
 238
 239         if (reason == NULL || *reason == '\0')
 240                 return MI_FAILURE;
 241         if (!mi_sendok(ctx, SMFIF_QUARANTINE))
 242                 return MI_FAILURE;
 243         timeout.tv_sec = ctx->ctx_timeout;
 244         timeout.tv_usec = 0;
 245         len = strlen(reason) + 1;
 246         buf = malloc(len);
 247         if (buf == NULL)
 248                 return MI_FAILURE;
 249         (void) memcpy(buf, reason, len);
 250         r = mi_wr_cmd(ctx->ctx_sd, &timeout, SMFIR_QUARANTINE, buf, len);
 251         free(buf);
 252         return r;
 253 }
 254 #endif /* _FFR_QUARANTINE */
 255
 256 /*
 257 **  MYISENHSC -- check whether a string contains an enhanced status code
 258 **
 259 **      Parameters:
 260 **              s -- string with possible enhanced status code.
 261 **              delim -- delim for enhanced status code.
 262 **
 263 **      Returns:
 264 **              0  -- no enhanced status code.
 265 **              >4 -- length of enhanced status code.
 266 **
 267 **      Side Effects:
 268 **              none.
 269 */
 270
 271 static int
 272 myisenhsc(s, delim)
 273         const char *s;
 274         int delim;
 275 {
 276         int l, h;
 277
 278         if (s == NULL)
 279                 return 0;
 280         if (!((*s == '2' || *s == '4' || *s == '5') && s[1] == '.'))
 281                 return 0;
 282         h = 0;
 283         l = 2;
 284         while (h < 3 && isascii(s[l + h]) && isdigit(s[l + h]))
 285                 ++h;
 286         if (h == 0 || s[l + h] != '.')
 287                 return 0;
 288         l += h + 1;
 289         h = 0;
 290         while (h < 3 && isascii(s[l + h]) && isdigit(s[l + h]))
 291                 ++h;
 292         if (h == 0 || s[l + h] != delim)
 293                 return 0;
 294         return l + h;
 295 }
 296
 297 /*
 298 **  SMFI_SETREPLY -- set the reply code for the next reply to the MTA
 299 **
 300 **      Parameters:
 301 **              ctx -- Opaque context structure
 302 **              rcode -- The three-digit (RFC 821) SMTP reply code.
 303 **              xcode -- The extended (RFC 2034) reply code.
 304 **              message -- The text part of the SMTP reply.
 305 **
 306 **      Returns:
 307 **              MI_SUCCESS/MI_FAILURE
 308 */
 309
 310 int
 311 smfi_setreply(ctx, rcode, xcode, message)
 312         SMFICTX *ctx;
 313         char *rcode;
 314         char *xcode;
 315         char *message;
 316 {
 317         size_t len;
 318         char *buf;
 319
 320         if (rcode == NULL || ctx == NULL)
 321                 return MI_FAILURE;
 322
 323         /* ### <sp> \0 */
 324         len = strlen(rcode) + 2;
 325         if (len != 5)
 326                 return MI_FAILURE;
 327         if ((rcode[0] != '4' && rcode[0] != '5') ||
 328             !isascii(rcode[1]) || !isdigit(rcode[1]) ||
 329             !isascii(rcode[2]) || !isdigit(rcode[2]))
 330                 return MI_FAILURE;
 331         if (xcode != NULL)
 332         {
 333                 if (!myisenhsc(xcode, '\0'))
 334                         return MI_FAILURE;
 335                 len += strlen(xcode) + 1;
 336         }
 337         if (message != NULL)
 338         {
 339                 size_t ml;
 340
 341                 /* XXX check also for unprintable chars? */
 342                 if (strpbrk(message, "\r\n") != NULL)
 343                         return MI_FAILURE;
 344                 ml = strlen(message);
 345                 if (ml > MAXREPLYLEN)
 346                         return MI_FAILURE;
 347                 len += ml + 1;
 348         }
 349         buf = malloc(len);
 350         if (buf == NULL)
 351                 return MI_FAILURE;              /* oops */
 352         (void) sm_strlcpy(buf, rcode, len);
 353         (void) sm_strlcat(buf, " ", len);
 354         if (xcode != NULL)
 355                 (void) sm_strlcat(buf, xcode, len);
 356         if (message != NULL)
 357         {
 358                 if (xcode != NULL)
 359                         (void) sm_strlcat(buf, " ", len);
 360                 (void) sm_strlcat(buf, message, len);
 361         }
 362         if (ctx->ctx_reply != NULL)
 363                 free(ctx->ctx_reply);
 364         ctx->ctx_reply = buf;
 365         return MI_SUCCESS;
 366 }
 367
 368 #if _FFR_MULTILINE
 369 /*
 370 **  SMFI_SETMLREPLY -- set multiline reply code for the next reply to the MTA
 371 **
 372 **      Parameters:
 373 **              ctx -- Opaque context structure
 374 **              rcode -- The three-digit (RFC 821) SMTP reply code.
 375 **              xcode -- The extended (RFC 2034) reply code.
 376 **              txt, ... -- The text part of the SMTP reply,
 377 **                      MUST be terminated with NULL.
 378 **
 379 **      Returns:
 380 **              MI_SUCCESS/MI_FAILURE
 381 */
 382
 383 int
 384 #if SM_VA_STD
 385 smfi_setmlreply(SMFICTX *ctx, const char *rcode, const char *xcode, ...)
 386 #else /* SM_VA_STD */
 387 smfi_setmlreply(ctx, rcode, xcode, va_alist)
 388         SMFICTX *ctx;
 389         const char *rcode;
 390         const char *xcode;
 391         va_dcl
 392 #endif /* SM_VA_STD */
 393 {
 394         size_t len;
 395         size_t rlen;
 396         int args;
 397         char *buf, *txt;
 398         const char *xc;
 399         char repl[16];
 400         SM_VA_LOCAL_DECL
 401
 402         if (rcode == NULL || ctx == NULL)
 403                 return MI_FAILURE;
 404
 405         /* ### <sp> */
 406         len = strlen(rcode) + 1;
 407         if (len != 4)
 408                 return MI_FAILURE;
 409         if ((rcode[0] != '4' && rcode[0] != '5') ||
 410             !isascii(rcode[1]) || !isdigit(rcode[1]) ||
 411             !isascii(rcode[2]) || !isdigit(rcode[2]))
 412                 return MI_FAILURE;
 413         if (xcode != NULL)
 414         {
 415                 if (!myisenhsc(xcode, '\0'))
 416                         return MI_FAILURE;
 417                 xc = xcode;
 418         }
 419         else
 420         {
 421                 if (rcode[0] == '4')
 422                         xc = "4.0.0";
 423                 else
 424                         xc = "5.0.0";
 425         }
 426
 427         /* add trailing space */
 428         len += strlen(xc) + 1;
 429         rlen = len;
 430         args = 0;
 431         SM_VA_START(ap, xcode);
 432         while ((txt = SM_VA_ARG(ap, char *)) != NULL)
 433         {
 434                 size_t tl;
 435
 436                 tl = strlen(txt);
 437                 if (tl > MAXREPLYLEN)
 438                         break;
 439
 440                 /* this text, reply codes, \r\n */
 441                 len += tl + 2 + rlen;
 442                 if (++args > MAXREPLIES)
 443                         break;
 444
 445                 /* XXX check also for unprintable chars? */
 446                 if (strpbrk(txt, "\r\n") != NULL)
 447                         break;
 448         }
 449         SM_VA_END(ap);
 450         if (txt != NULL)
 451                 return MI_FAILURE;
 452
 453         /* trailing '\0' */
 454         ++len;
 455         buf = malloc(len);
 456         if (buf == NULL)
 457                 return MI_FAILURE;              /* oops */
 458         (void) sm_strlcpyn(buf, len, 3, rcode, args == 1 ? " " : "-", xc);
 459         (void) sm_strlcpyn(repl, sizeof repl, 4, rcode, args == 1 ? " " : "-",
 460                            xc, " ");
 461         SM_VA_START(ap, xcode);
 462         txt = SM_VA_ARG(ap, char *);
 463         if (txt != NULL)
 464         {
 465                 (void) sm_strlcat2(buf, " ", txt, len);
 466                 while ((txt = SM_VA_ARG(ap, char *)) != NULL)
 467                 {
 468                         if (--args <= 1)
 469                                 repl[3] = ' ';
 470                         (void) sm_strlcat2(buf, "\r\n", repl, len);
 471                         (void) sm_strlcat(buf, txt, len);
 472                 }
 473         }
 474         if (ctx->ctx_reply != NULL)
 475                 free(ctx->ctx_reply);
 476         ctx->ctx_reply = buf;
 477         SM_VA_END(ap);
 478         return MI_SUCCESS;
 479 }
 480 #endif /* _FFR_MULTILINE */
 481
 482 /*
 483 **  SMFI_SETPRIV -- set private data
 484 **
 485 **      Parameters:
 486 **              ctx -- Opaque context structure
 487 **              privatedata -- pointer to private data
 488 **
 489 **      Returns:
 490 **              MI_SUCCESS/MI_FAILURE
 491 */
 492
 493 int
 494 smfi_setpriv(ctx, privatedata)
 495         SMFICTX *ctx;
 496         void *privatedata;
 497 {
 498         if (ctx == NULL)
 499                 return MI_FAILURE;
 500         ctx->ctx_privdata = privatedata;
 501         return MI_SUCCESS;
 502 }
 503
 504 /*
 505 **  SMFI_GETPRIV -- get private data
 506 **
 507 **      Parameters:
 508 **              ctx -- Opaque context structure
 509 **
 510 **      Returns:
 511 **              pointer to private data
 512 */
 513
 514 void *
 515 smfi_getpriv(ctx)
 516         SMFICTX *ctx;
 517 {
 518         if (ctx == NULL)
 519                 return NULL;
 520         return ctx->ctx_privdata;
 521 }
 522
 523 /*
 524 **  SMFI_GETSYMVAL -- get the value of a macro
 525 **
 526 **      See explanation in mfapi.h about layout of the structures.
 527 **
 528 **      Parameters:
 529 **              ctx -- Opaque context structure
 530 **              symname -- name of macro
 531 **
 532 **      Returns:
 533 **              value of macro (NULL in case of failure)
 534 */
 535
 536 char *
 537 smfi_getsymval(ctx, symname)
 538         SMFICTX *ctx;
 539         char *symname;
 540 {
 541         int i;
 542         char **s;
 543         char one[2];
 544         char braces[4];
 545
 546         if (ctx == NULL || symname == NULL || *symname == '\0')
 547                 return NULL;
 548
 549         if (strlen(symname) == 3 && symname[0] == '{' && symname[2] == '}')
 550         {
 551                 one[0] = symname[1];
 552                 one[1] = '\0';
 553         }
 554         else
 555                 one[0] = '\0';
 556         if (strlen(symname) == 1)
 557         {
 558                 braces[0] = '{';
 559                 braces[1] = *symname;
 560                 braces[2] = '}';
 561                 braces[3] = '\0';
 562         }
 563         else
 564                 braces[0] = '\0';
 565
 566         /* search backwards through the macro array */
 567         for (i = MAX_MACROS_ENTRIES - 1 ; i >= 0; --i)
 568         {
 569                 if ((s = ctx->ctx_mac_ptr[i]) == NULL ||
 570                     ctx->ctx_mac_buf[i] == NULL)
 571                         continue;
 572                 while (s != NULL && *s != NULL)
 573                 {
 574                         if (strcmp(*s, symname) == 0)
 575                                 return *++s;
 576                         if (one[0] != '\0' && strcmp(*s, one) == 0)
 577                                 return *++s;
 578                         if (braces[0] != '\0' && strcmp(*s, braces) == 0)
 579                                 return *++s;
 580                         ++s;    /* skip over macro value */
 581                         ++s;    /* points to next macro name */
 582                 }
 583         }
 584         return NULL;
 585 }
 586
 587 #if _FFR_SMFI_PROGRESS
 588 /*
 589 **  SMFI_PROGRESS -- send "progress" message to the MTA to prevent premature
 590 **                   timeouts during long milter-side operations
 591 **
 592 **      Parameters:
 593 **              ctx -- Opaque context structure
 594 **
 595 **      Return value:
 596 **              MI_SUCCESS/MI_FAILURE
 597 */
 598
 599 int
 600 smfi_progress(ctx)
 601         SMFICTX *ctx;
 602 {
 603         struct timeval timeout;
 604
 605         if (ctx == NULL)
 606                 return MI_FAILURE;
 607
 608         timeout.tv_sec = ctx->ctx_timeout;
 609         timeout.tv_usec = 0;
 610
 611         return mi_wr_cmd(ctx->ctx_sd, &timeout, SMFIR_PROGRESS, NULL, 0);
 612 }
 613 #endif /* _FFR_SMFI_PROGRESS */