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