1 /* 2 * Copyright (c) 1998-2007, 2009 Proofpoint, Inc. and its suppliers. 3 * All rights reserved. 4 * Copyright (c) 1983, 1995-1997 Eric P. Allman. All rights reserved. 5 * Copyright (c) 1988, 1993 6 * The Regents of the University of California. All rights reserved. 7 * 8 * By using this file, you agree to the terms and conditions set 9 * forth in the LICENSE file which can be found at the top level of 10 * the sendmail distribution. 11 * 12 */ 13 14 #include <sendmail.h> 15 16 SM_RCSID("@(#)$Id: util.c,v 8.427 2013-11-22 20:51:57 ca Exp $") 17 18 #include <sm/sendmail.h> 19 #include <sysexits.h> 20 #include <sm/xtrap.h> 21 22 /* 23 ** NEWSTR -- Create a copy of a C string 24 ** 25 ** Parameters: 26 ** s -- the string to copy. 27 ** 28 ** Returns: 29 ** pointer to newly allocated string. 30 */ 31 32 char * 33 newstr(s) 34 const char *s; 35 { 36 size_t l; 37 char *n; 38 39 l = strlen(s); 40 SM_ASSERT(l + 1 > l); 41 n = xalloc(l + 1); 42 sm_strlcpy(n, s, l + 1); 43 return n; 44 } 45 46 /* 47 ** ADDQUOTES -- Adds quotes & quote bits to a string. 48 ** 49 ** Runs through a string and adds backslashes and quote bits. 50 ** 51 ** Parameters: 52 ** s -- the string to modify. 53 ** rpool -- resource pool from which to allocate result 54 ** 55 ** Returns: 56 ** pointer to quoted string. 57 */ 58 59 char * 60 addquotes(s, rpool) 61 char *s; 62 SM_RPOOL_T *rpool; 63 { 64 int len = 0; 65 char c; 66 char *p = s, *q, *r; 67 68 if (s == NULL) 69 return NULL; 70 71 /* Find length of quoted string */ 72 while ((c = *p++) != '\0') 73 { 74 len++; 75 if (c == '\\' || c == '"') 76 len++; 77 } 78 79 q = r = sm_rpool_malloc_x(rpool, len + 3); 80 p = s; 81 82 /* add leading quote */ 83 *q++ = '"'; 84 while ((c = *p++) != '\0') 85 { 86 /* quote \ or " */ 87 if (c == '\\' || c == '"') 88 *q++ = '\\'; 89 *q++ = c; 90 } 91 *q++ = '"'; 92 *q = '\0'; 93 return r; 94 } 95 96 /* 97 ** STRIPBACKSLASH -- Strip all leading backslashes from a string, provided 98 ** the following character is alpha-numerical. 99 ** 100 ** This is done in place. 101 ** 102 ** Parameters: 103 ** s -- the string to strip. 104 ** 105 ** Returns: 106 ** none. 107 */ 108 109 void 110 stripbackslash(s) 111 char *s; 112 { 113 char *p, *q, c; 114 115 if (s == NULL || *s == '\0') 116 return; 117 p = q = s; 118 while (*p == '\\' && (p[1] == '\\' || (isascii(p[1]) && isalnum(p[1])))) 119 p++; 120 do 121 { 122 c = *q++ = *p++; 123 } while (c != '\0'); 124 } 125 126 /* 127 ** RFC822_STRING -- Checks string for proper RFC822 string quoting. 128 ** 129 ** Runs through a string and verifies RFC822 special characters 130 ** are only found inside comments, quoted strings, or backslash 131 ** escaped. Also verified balanced quotes and parenthesis. 132 ** 133 ** Parameters: 134 ** s -- the string to modify. 135 ** 136 ** Returns: 137 ** true iff the string is RFC822 compliant, false otherwise. 138 */ 139 140 bool 141 rfc822_string(s) 142 char *s; 143 { 144 bool quoted = false; 145 int commentlev = 0; 146 char *c = s; 147 148 if (s == NULL) 149 return false; 150 151 while (*c != '\0') 152 { 153 /* escaped character */ 154 if (*c == '\\') 155 { 156 c++; 157 if (*c == '\0') 158 return false; 159 } 160 else if (commentlev == 0 && *c == '"') 161 quoted = !quoted; 162 else if (!quoted) 163 { 164 if (*c == ')') 165 { 166 /* unbalanced ')' */ 167 if (commentlev == 0) 168 return false; 169 else 170 commentlev--; 171 } 172 else if (*c == '(') 173 commentlev++; 174 else if (commentlev == 0 && 175 strchr(MustQuoteChars, *c) != NULL) 176 return false; 177 } 178 c++; 179 } 180 181 /* unbalanced '"' or '(' */ 182 return !quoted && commentlev == 0; 183 } 184 185 /* 186 ** SHORTEN_RFC822_STRING -- Truncate and rebalance an RFC822 string 187 ** 188 ** Arbitrarily shorten (in place) an RFC822 string and rebalance 189 ** comments and quotes. 190 ** 191 ** Parameters: 192 ** string -- the string to shorten 193 ** length -- the maximum size, 0 if no maximum 194 ** 195 ** Returns: 196 ** true if string is changed, false otherwise 197 ** 198 ** Side Effects: 199 ** Changes string in place, possibly resulting 200 ** in a shorter string. 201 */ 202 203 bool 204 shorten_rfc822_string(string, length) 205 char *string; 206 size_t length; 207 { 208 bool backslash = false; 209 bool modified = false; 210 bool quoted = false; 211 size_t slen; 212 int parencount = 0; 213 char *ptr = string; 214 215 /* 216 ** If have to rebalance an already short enough string, 217 ** need to do it within allocated space. 218 */ 219 220 slen = strlen(string); 221 if (length == 0 || slen < length) 222 length = slen; 223 224 while (*ptr != '\0') 225 { 226 if (backslash) 227 { 228 backslash = false; 229 goto increment; 230 } 231 232 if (*ptr == '\\') 233 backslash = true; 234 else if (*ptr == '(') 235 { 236 if (!quoted) 237 parencount++; 238 } 239 else if (*ptr == ')') 240 { 241 if (--parencount < 0) 242 parencount = 0; 243 } 244 245 /* Inside a comment, quotes don't matter */ 246 if (parencount <= 0 && *ptr == '"') 247 quoted = !quoted; 248 249 increment: 250 /* Check for sufficient space for next character */ 251 if (length - (ptr - string) <= (size_t) ((backslash ? 1 : 0) + 252 parencount + 253 (quoted ? 1 : 0))) 254 { 255 /* Not enough, backtrack */ 256 if (*ptr == '\\') 257 backslash = false; 258 else if (*ptr == '(' && !quoted) 259 parencount--; 260 else if (*ptr == '"' && parencount == 0) 261 quoted = false; 262 break; 263 } 264 ptr++; 265 } 266 267 /* Rebalance */ 268 while (parencount-- > 0) 269 { 270 if (*ptr != ')') 271 { 272 modified = true; 273 *ptr = ')'; 274 } 275 ptr++; 276 } 277 if (quoted) 278 { 279 if (*ptr != '"') 280 { 281 modified = true; 282 *ptr = '"'; 283 } 284 ptr++; 285 } 286 if (*ptr != '\0') 287 { 288 modified = true; 289 *ptr = '\0'; 290 } 291 return modified; 292 } 293 294 /* 295 ** FIND_CHARACTER -- find an unquoted character in an RFC822 string 296 ** 297 ** Find an unquoted, non-commented character in an RFC822 298 ** string and return a pointer to its location in the 299 ** string. 300 ** 301 ** Parameters: 302 ** string -- the string to search 303 ** character -- the character to find 304 ** 305 ** Returns: 306 ** pointer to the character, or 307 ** a pointer to the end of the line if character is not found 308 */ 309 310 char * 311 find_character(string, character) 312 char *string; 313 int character; 314 { 315 bool backslash = false; 316 bool quoted = false; 317 int parencount = 0; 318 319 while (string != NULL && *string != '\0') 320 { 321 if (backslash) 322 { 323 backslash = false; 324 if (!quoted && character == '\\' && *string == '\\') 325 break; 326 string++; 327 continue; 328 } 329 switch (*string) 330 { 331 case '\\': 332 backslash = true; 333 break; 334 335 case '(': 336 if (!quoted) 337 parencount++; 338 break; 339 340 case ')': 341 if (--parencount < 0) 342 parencount = 0; 343 break; 344 } 345 346 /* Inside a comment, nothing matters */ 347 if (parencount > 0) 348 { 349 string++; 350 continue; 351 } 352 353 if (*string == '"') 354 quoted = !quoted; 355 else if (*string == character && !quoted) 356 break; 357 string++; 358 } 359 360 /* Return pointer to the character */ 361 return string; 362 } 363 364 /* 365 ** CHECK_BODYTYPE -- check bodytype parameter 366 ** 367 ** Parameters: 368 ** bodytype -- bodytype parameter 369 ** 370 ** Returns: 371 ** BODYTYPE_* according to parameter 372 ** 373 */ 374 375 int 376 check_bodytype(bodytype) 377 char *bodytype; 378 { 379 /* check body type for legality */ 380 if (bodytype == NULL) 381 return BODYTYPE_NONE; 382 if (sm_strcasecmp(bodytype, "7BIT") == 0) 383 return BODYTYPE_7BIT; 384 if (sm_strcasecmp(bodytype, "8BITMIME") == 0) 385 return BODYTYPE_8BITMIME; 386 return BODYTYPE_ILLEGAL; 387 } 388 389 /* 390 ** TRUNCATE_AT_DELIM -- truncate string at a delimiter and append "..." 391 ** 392 ** Parameters: 393 ** str -- string to truncate 394 ** len -- maximum length (including '\0') (0 for unlimited) 395 ** delim -- delimiter character 396 ** 397 ** Returns: 398 ** None. 399 */ 400 401 void 402 truncate_at_delim(str, len, delim) 403 char *str; 404 size_t len; 405 int delim; 406 { 407 char *p; 408 409 if (str == NULL || len == 0 || strlen(str) < len) 410 return; 411 412 *(str + len - 1) = '\0'; 413 while ((p = strrchr(str, delim)) != NULL) 414 { 415 *p = '\0'; 416 if (p - str + 4 < len) 417 { 418 *p++ = (char) delim; 419 *p = '\0'; 420 (void) sm_strlcat(str, "...", len); 421 return; 422 } 423 } 424 425 /* Couldn't find a place to append "..." */ 426 if (len > 3) 427 (void) sm_strlcpy(str, "...", len); 428 else 429 str[0] = '\0'; 430 } 431 432 /* 433 ** XALLOC -- Allocate memory, raise an exception on error 434 ** 435 ** Parameters: 436 ** sz -- size of area to allocate. 437 ** 438 ** Returns: 439 ** pointer to data region. 440 ** 441 ** Exceptions: 442 ** SmHeapOutOfMemory (F:sm.heap) -- cannot allocate memory 443 ** 444 ** Side Effects: 445 ** Memory is allocated. 446 */ 447 448 char * 449 #if SM_HEAP_CHECK 450 xalloc_tagged(sz, file, line) 451 register int sz; 452 char *file; 453 int line; 454 #else /* SM_HEAP_CHECK */ 455 xalloc(sz) 456 register int sz; 457 #endif /* SM_HEAP_CHECK */ 458 { 459 register char *p; 460 461 SM_REQUIRE(sz >= 0); 462 463 /* some systems can't handle size zero mallocs */ 464 if (sz <= 0) 465 sz = 1; 466 467 /* scaffolding for testing error handling code */ 468 sm_xtrap_raise_x(&SmHeapOutOfMemory); 469 470 p = sm_malloc_tagged((unsigned) sz, file, line, sm_heap_group()); 471 if (p == NULL) 472 { 473 sm_exc_raise_x(&SmHeapOutOfMemory); 474 } 475 return p; 476 } 477 478 /* 479 ** COPYPLIST -- copy list of pointers. 480 ** 481 ** This routine is the equivalent of strdup for lists of 482 ** pointers. 483 ** 484 ** Parameters: 485 ** list -- list of pointers to copy. 486 ** Must be NULL terminated. 487 ** copycont -- if true, copy the contents of the vector 488 ** (which must be a string) also. 489 ** rpool -- resource pool from which to allocate storage, 490 ** or NULL 491 ** 492 ** Returns: 493 ** a copy of 'list'. 494 */ 495 496 char ** 497 copyplist(list, copycont, rpool) 498 char **list; 499 bool copycont; 500 SM_RPOOL_T *rpool; 501 { 502 register char **vp; 503 register char **newvp; 504 505 for (vp = list; *vp != NULL; vp++) 506 continue; 507 508 vp++; 509 510 newvp = (char **) sm_rpool_malloc_x(rpool, (vp - list) * sizeof(*vp)); 511 memmove((char *) newvp, (char *) list, (int) (vp - list) * sizeof(*vp)); 512 513 if (copycont) 514 { 515 for (vp = newvp; *vp != NULL; vp++) 516 *vp = sm_rpool_strdup_x(rpool, *vp); 517 } 518 519 return newvp; 520 } 521 522 /* 523 ** COPYQUEUE -- copy address queue. 524 ** 525 ** This routine is the equivalent of strdup for address queues; 526 ** addresses marked as QS_IS_DEAD() aren't copied 527 ** 528 ** Parameters: 529 ** addr -- list of address structures to copy. 530 ** rpool -- resource pool from which to allocate storage 531 ** 532 ** Returns: 533 ** a copy of 'addr'. 534 */ 535 536 ADDRESS * 537 copyqueue(addr, rpool) 538 ADDRESS *addr; 539 SM_RPOOL_T *rpool; 540 { 541 register ADDRESS *newaddr; 542 ADDRESS *ret; 543 register ADDRESS **tail = &ret; 544 545 while (addr != NULL) 546 { 547 if (!QS_IS_DEAD(addr->q_state)) 548 { 549 newaddr = (ADDRESS *) sm_rpool_malloc_x(rpool, 550 sizeof(*newaddr)); 551 STRUCTCOPY(*addr, *newaddr); 552 *tail = newaddr; 553 tail = &newaddr->q_next; 554 } 555 addr = addr->q_next; 556 } 557 *tail = NULL; 558 559 return ret; 560 } 561 562 /* 563 ** LOG_SENDMAIL_PID -- record sendmail pid and command line. 564 ** 565 ** Parameters: 566 ** e -- the current envelope. 567 ** 568 ** Returns: 569 ** none. 570 ** 571 ** Side Effects: 572 ** writes pidfile, logs command line. 573 ** keeps file open and locked to prevent overwrite of active file 574 */ 575 576 static SM_FILE_T *Pidf = NULL; 577 578 void 579 log_sendmail_pid(e) 580 ENVELOPE *e; 581 { 582 long sff; 583 char pidpath[MAXPATHLEN]; 584 extern char *CommandLineArgs; 585 586 /* write the pid to the log file for posterity */ 587 sff = SFF_NOLINK|SFF_ROOTOK|SFF_REGONLY|SFF_CREAT|SFF_NBLOCK; 588 if (TrustedUid != 0 && RealUid == TrustedUid) 589 sff |= SFF_OPENASROOT; 590 expand(PidFile, pidpath, sizeof(pidpath), e); 591 Pidf = safefopen(pidpath, O_WRONLY|O_TRUNC, FileMode, sff); 592 if (Pidf == NULL) 593 { 594 if (errno == EWOULDBLOCK) 595 sm_syslog(LOG_ERR, NOQID, 596 "unable to write pid to %s: file in use by another process", 597 pidpath); 598 else 599 sm_syslog(LOG_ERR, NOQID, 600 "unable to write pid to %s: %s", 601 pidpath, sm_errstring(errno)); 602 } 603 else 604 { 605 PidFilePid = getpid(); 606 607 /* write the process id on line 1 */ 608 (void) sm_io_fprintf(Pidf, SM_TIME_DEFAULT, "%ld\n", 609 (long) PidFilePid); 610 611 /* line 2 contains all command line flags */ 612 (void) sm_io_fprintf(Pidf, SM_TIME_DEFAULT, "%s\n", 613 CommandLineArgs); 614 615 /* flush */ 616 (void) sm_io_flush(Pidf, SM_TIME_DEFAULT); 617 618 /* 619 ** Leave pid file open until process ends 620 ** so it's not overwritten by another 621 ** process. 622 */ 623 } 624 if (LogLevel > 9) 625 sm_syslog(LOG_INFO, NOQID, "started as: %s", CommandLineArgs); 626 } 627 628 /* 629 ** CLOSE_SENDMAIL_PID -- close sendmail pid file 630 ** 631 ** Parameters: 632 ** none. 633 ** 634 ** Returns: 635 ** none. 636 */ 637 638 void 639 close_sendmail_pid() 640 { 641 if (Pidf == NULL) 642 return; 643 644 (void) sm_io_close(Pidf, SM_TIME_DEFAULT); 645 Pidf = NULL; 646 } 647 648 /* 649 ** SET_DELIVERY_MODE -- set and record the delivery mode 650 ** 651 ** Parameters: 652 ** mode -- delivery mode 653 ** e -- the current envelope. 654 ** 655 ** Returns: 656 ** none. 657 ** 658 ** Side Effects: 659 ** sets {deliveryMode} macro 660 */ 661 662 void 663 set_delivery_mode(mode, e) 664 int mode; 665 ENVELOPE *e; 666 { 667 char buf[2]; 668 669 e->e_sendmode = (char) mode; 670 buf[0] = (char) mode; 671 buf[1] = '\0'; 672 macdefine(&e->e_macro, A_TEMP, macid("{deliveryMode}"), buf); 673 } 674 675 /* 676 ** SET_OP_MODE -- set and record the op mode 677 ** 678 ** Parameters: 679 ** mode -- op mode 680 ** e -- the current envelope. 681 ** 682 ** Returns: 683 ** none. 684 ** 685 ** Side Effects: 686 ** sets {opMode} macro 687 */ 688 689 void 690 set_op_mode(mode) 691 int mode; 692 { 693 char buf[2]; 694 extern ENVELOPE BlankEnvelope; 695 696 OpMode = (char) mode; 697 buf[0] = (char) mode; 698 buf[1] = '\0'; 699 macdefine(&BlankEnvelope.e_macro, A_TEMP, MID_OPMODE, buf); 700 } 701 702 /* 703 ** PRINTAV -- print argument vector. 704 ** 705 ** Parameters: 706 ** fp -- output file pointer. 707 ** av -- argument vector. 708 ** 709 ** Returns: 710 ** none. 711 ** 712 ** Side Effects: 713 ** prints av. 714 */ 715 716 void 717 printav(fp, av) 718 SM_FILE_T *fp; 719 char **av; 720 { 721 while (*av != NULL) 722 { 723 if (tTd(0, 44)) 724 sm_dprintf("\n\t%08lx=", (unsigned long) *av); 725 else 726 (void) sm_io_putc(fp, SM_TIME_DEFAULT, ' '); 727 if (tTd(0, 99)) 728 sm_dprintf("%s", str2prt(*av++)); 729 else 730 xputs(fp, *av++); 731 } 732 (void) sm_io_putc(fp, SM_TIME_DEFAULT, '\n'); 733 } 734 735 /* 736 ** XPUTS -- put string doing control escapes. 737 ** 738 ** Parameters: 739 ** fp -- output file pointer. 740 ** s -- string to put. 741 ** 742 ** Returns: 743 ** none. 744 ** 745 ** Side Effects: 746 ** output to stdout 747 */ 748 749 void 750 xputs(fp, s) 751 SM_FILE_T *fp; 752 const char *s; 753 { 754 int c; 755 struct metamac *mp; 756 bool shiftout = false; 757 extern struct metamac MetaMacros[]; 758 static SM_DEBUG_T DebugANSI = SM_DEBUG_INITIALIZER("ANSI", 759 "@(#)$Debug: ANSI - enable reverse video in debug output $"); 760 761 /* 762 ** TermEscape is set here, rather than in main(), 763 ** because ANSI mode can be turned on or off at any time 764 ** if we are in -bt rule testing mode. 765 */ 766 767 if (sm_debug_unknown(&DebugANSI)) 768 { 769 if (sm_debug_active(&DebugANSI, 1)) 770 { 771 TermEscape.te_rv_on = "\033[7m"; 772 TermEscape.te_normal = "\033[0m"; 773 } 774 else 775 { 776 TermEscape.te_rv_on = ""; 777 TermEscape.te_normal = ""; 778 } 779 } 780 781 if (s == NULL) 782 { 783 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s<null>%s", 784 TermEscape.te_rv_on, TermEscape.te_normal); 785 return; 786 } 787 while ((c = (*s++ & 0377)) != '\0') 788 { 789 if (shiftout) 790 { 791 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s", 792 TermEscape.te_normal); 793 shiftout = false; 794 } 795 if (!isascii(c) && !tTd(84, 1)) 796 { 797 if (c == MATCHREPL) 798 { 799 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 800 "%s$", 801 TermEscape.te_rv_on); 802 shiftout = true; 803 if (*s == '\0') 804 continue; 805 c = *s++ & 0377; 806 goto printchar; 807 } 808 if (c == MACROEXPAND || c == MACRODEXPAND) 809 { 810 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 811 "%s$", 812 TermEscape.te_rv_on); 813 if (c == MACRODEXPAND) 814 (void) sm_io_putc(fp, 815 SM_TIME_DEFAULT, '&'); 816 shiftout = true; 817 if (*s == '\0') 818 continue; 819 if (strchr("=~&?", *s) != NULL) 820 (void) sm_io_putc(fp, 821 SM_TIME_DEFAULT, 822 *s++); 823 if (bitset(0200, *s)) 824 (void) sm_io_fprintf(fp, 825 SM_TIME_DEFAULT, 826 "{%s}", 827 macname(bitidx(*s++))); 828 else 829 (void) sm_io_fprintf(fp, 830 SM_TIME_DEFAULT, 831 "%c", 832 *s++); 833 continue; 834 } 835 for (mp = MetaMacros; mp->metaname != '\0'; mp++) 836 { 837 if (bitidx(mp->metaval) == c) 838 { 839 (void) sm_io_fprintf(fp, 840 SM_TIME_DEFAULT, 841 "%s$%c", 842 TermEscape.te_rv_on, 843 mp->metaname); 844 shiftout = true; 845 break; 846 } 847 } 848 if (c == MATCHCLASS || c == MATCHNCLASS) 849 { 850 if (bitset(0200, *s)) 851 (void) sm_io_fprintf(fp, 852 SM_TIME_DEFAULT, 853 "{%s}", 854 macname(bitidx(*s++))); 855 else if (*s != '\0') 856 (void) sm_io_fprintf(fp, 857 SM_TIME_DEFAULT, 858 "%c", 859 *s++); 860 } 861 if (mp->metaname != '\0') 862 continue; 863 864 /* unrecognized meta character */ 865 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%sM-", 866 TermEscape.te_rv_on); 867 shiftout = true; 868 c &= 0177; 869 } 870 printchar: 871 if (isascii(c) && isprint(c)) 872 { 873 (void) sm_io_putc(fp, SM_TIME_DEFAULT, c); 874 continue; 875 } 876 877 /* wasn't a meta-macro -- find another way to print it */ 878 switch (c) 879 { 880 case '\n': 881 c = 'n'; 882 break; 883 884 case '\r': 885 c = 'r'; 886 break; 887 888 case '\t': 889 c = 't'; 890 break; 891 } 892 if (!shiftout) 893 { 894 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s", 895 TermEscape.te_rv_on); 896 shiftout = true; 897 } 898 if (isascii(c) && isprint(c)) 899 { 900 (void) sm_io_putc(fp, SM_TIME_DEFAULT, '\\'); 901 (void) sm_io_putc(fp, SM_TIME_DEFAULT, c); 902 } 903 else if (tTd(84, 2)) 904 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, " %o ", c); 905 else if (tTd(84, 1)) 906 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, " %#x ", c); 907 else if (!isascii(c) && !tTd(84, 1)) 908 { 909 (void) sm_io_putc(fp, SM_TIME_DEFAULT, '^'); 910 (void) sm_io_putc(fp, SM_TIME_DEFAULT, c ^ 0100); 911 } 912 } 913 if (shiftout) 914 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s", 915 TermEscape.te_normal); 916 (void) sm_io_flush(fp, SM_TIME_DEFAULT); 917 } 918 919 /* 920 ** MAKELOWER -- Translate a line into lower case 921 ** 922 ** Parameters: 923 ** p -- the string to translate. If NULL, return is 924 ** immediate. 925 ** 926 ** Returns: 927 ** none. 928 ** 929 ** Side Effects: 930 ** String pointed to by p is translated to lower case. 931 */ 932 933 void 934 makelower(p) 935 register char *p; 936 { 937 register char c; 938 939 if (p == NULL) 940 return; 941 for (; (c = *p) != '\0'; p++) 942 if (isascii(c) && isupper(c)) 943 *p = tolower(c); 944 } 945 946 /* 947 ** FIXCRLF -- fix <CR><LF> in line. 948 ** 949 ** Looks for the <CR><LF> combination and turns it into the 950 ** UNIX canonical <NL> character. It only takes one line, 951 ** i.e., it is assumed that the first <NL> found is the end 952 ** of the line. 953 ** 954 ** Parameters: 955 ** line -- the line to fix. 956 ** stripnl -- if true, strip the newline also. 957 ** 958 ** Returns: 959 ** none. 960 ** 961 ** Side Effects: 962 ** line is changed in place. 963 */ 964 965 void 966 fixcrlf(line, stripnl) 967 char *line; 968 bool stripnl; 969 { 970 register char *p; 971 972 p = strchr(line, '\n'); 973 if (p == NULL) 974 return; 975 if (p > line && p[-1] == '\r') 976 p--; 977 if (!stripnl) 978 *p++ = '\n'; 979 *p = '\0'; 980 } 981 982 /* 983 ** PUTLINE -- put a line like fputs obeying SMTP conventions 984 ** 985 ** This routine always guarantees outputing a newline (or CRLF, 986 ** as appropriate) at the end of the string. 987 ** 988 ** Parameters: 989 ** l -- line to put. 990 ** mci -- the mailer connection information. 991 ** 992 ** Returns: 993 ** true iff line was written successfully 994 ** 995 ** Side Effects: 996 ** output of l to mci->mci_out. 997 */ 998 999 bool 1000 putline(l, mci) 1001 register char *l; 1002 register MCI *mci; 1003 { 1004 return putxline(l, strlen(l), mci, PXLF_MAPFROM); 1005 } 1006 1007 /* 1008 ** PUTXLINE -- putline with flags bits. 1009 ** 1010 ** This routine always guarantees outputing a newline (or CRLF, 1011 ** as appropriate) at the end of the string. 1012 ** 1013 ** Parameters: 1014 ** l -- line to put. 1015 ** len -- the length of the line. 1016 ** mci -- the mailer connection information. 1017 ** pxflags -- flag bits: 1018 ** PXLF_MAPFROM -- map From_ to >From_. 1019 ** PXLF_STRIP8BIT -- strip 8th bit. 1020 ** PXLF_HEADER -- map bare newline in header to newline space. 1021 ** PXLF_NOADDEOL -- don't add an EOL if one wasn't present. 1022 ** PXLF_STRIPMQUOTE -- strip METAQUOTE bytes. 1023 ** 1024 ** Returns: 1025 ** true iff line was written successfully 1026 ** 1027 ** Side Effects: 1028 ** output of l to mci->mci_out. 1029 */ 1030 1031 1032 #define PUTX(limit) \ 1033 do \ 1034 { \ 1035 quotenext = false; \ 1036 while (l < limit) \ 1037 { \ 1038 unsigned char c = (unsigned char) *l++; \ 1039 \ 1040 if (bitset(PXLF_STRIPMQUOTE, pxflags) && \ 1041 !quotenext && c == METAQUOTE) \ 1042 { \ 1043 quotenext = true; \ 1044 continue; \ 1045 } \ 1046 quotenext = false; \ 1047 if (strip8bit) \ 1048 c &= 0177; \ 1049 if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT, \ 1050 c) == SM_IO_EOF) \ 1051 { \ 1052 dead = true; \ 1053 break; \ 1054 } \ 1055 if (TrafficLogFile != NULL) \ 1056 (void) sm_io_putc(TrafficLogFile, \ 1057 SM_TIME_DEFAULT, \ 1058 c); \ 1059 } \ 1060 } while (0) 1061 1062 bool 1063 putxline(l, len, mci, pxflags) 1064 register char *l; 1065 size_t len; 1066 register MCI *mci; 1067 int pxflags; 1068 { 1069 register char *p, *end; 1070 int slop; 1071 bool dead, quotenext, strip8bit; 1072 1073 /* strip out 0200 bits -- these can look like TELNET protocol */ 1074 strip8bit = bitset(MCIF_7BIT, mci->mci_flags) || 1075 bitset(PXLF_STRIP8BIT, pxflags); 1076 dead = false; 1077 slop = 0; 1078 1079 end = l + len; 1080 do 1081 { 1082 bool noeol = false; 1083 1084 /* find the end of the line */ 1085 p = memchr(l, '\n', end - l); 1086 if (p == NULL) 1087 { 1088 p = end; 1089 noeol = true; 1090 } 1091 1092 if (TrafficLogFile != NULL) 1093 (void) sm_io_fprintf(TrafficLogFile, SM_TIME_DEFAULT, 1094 "%05d >>> ", (int) CurrentPid); 1095 1096 /* check for line overflow */ 1097 while (mci->mci_mailer->m_linelimit > 0 && 1098 (p - l + slop) > mci->mci_mailer->m_linelimit) 1099 { 1100 register char *q = &l[mci->mci_mailer->m_linelimit - slop - 1]; 1101 1102 if (l[0] == '.' && slop == 0 && 1103 bitnset(M_XDOT, mci->mci_mailer->m_flags)) 1104 { 1105 if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT, 1106 '.') == SM_IO_EOF) 1107 dead = true; 1108 if (TrafficLogFile != NULL) 1109 (void) sm_io_putc(TrafficLogFile, 1110 SM_TIME_DEFAULT, '.'); 1111 } 1112 else if (l[0] == 'F' && slop == 0 && 1113 bitset(PXLF_MAPFROM, pxflags) && 1114 strncmp(l, "From ", 5) == 0 && 1115 bitnset(M_ESCFROM, mci->mci_mailer->m_flags)) 1116 { 1117 if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT, 1118 '>') == SM_IO_EOF) 1119 dead = true; 1120 if (TrafficLogFile != NULL) 1121 (void) sm_io_putc(TrafficLogFile, 1122 SM_TIME_DEFAULT, 1123 '>'); 1124 } 1125 if (dead) 1126 break; 1127 1128 PUTX(q); 1129 if (dead) 1130 break; 1131 1132 if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT, 1133 '!') == SM_IO_EOF || 1134 sm_io_fputs(mci->mci_out, SM_TIME_DEFAULT, 1135 mci->mci_mailer->m_eol) == SM_IO_EOF || 1136 sm_io_putc(mci->mci_out, SM_TIME_DEFAULT, 1137 ' ') == SM_IO_EOF) 1138 { 1139 dead = true; 1140 break; 1141 } 1142 if (TrafficLogFile != NULL) 1143 { 1144 (void) sm_io_fprintf(TrafficLogFile, 1145 SM_TIME_DEFAULT, 1146 "!\n%05d >>> ", 1147 (int) CurrentPid); 1148 } 1149 slop = 1; 1150 } 1151 1152 if (dead) 1153 break; 1154 1155 /* output last part */ 1156 if (l[0] == '.' && slop == 0 && 1157 bitnset(M_XDOT, mci->mci_mailer->m_flags) && 1158 !bitset(MCIF_INLONGLINE, mci->mci_flags)) 1159 { 1160 if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT, '.') == 1161 SM_IO_EOF) 1162 { 1163 dead = true; 1164 break; 1165 } 1166 if (TrafficLogFile != NULL) 1167 (void) sm_io_putc(TrafficLogFile, 1168 SM_TIME_DEFAULT, '.'); 1169 } 1170 else if (l[0] == 'F' && slop == 0 && 1171 bitset(PXLF_MAPFROM, pxflags) && 1172 strncmp(l, "From ", 5) == 0 && 1173 bitnset(M_ESCFROM, mci->mci_mailer->m_flags) && 1174 !bitset(MCIF_INLONGLINE, mci->mci_flags)) 1175 { 1176 if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT, '>') == 1177 SM_IO_EOF) 1178 { 1179 dead = true; 1180 break; 1181 } 1182 if (TrafficLogFile != NULL) 1183 (void) sm_io_putc(TrafficLogFile, 1184 SM_TIME_DEFAULT, '>'); 1185 } 1186 PUTX(p); 1187 if (dead) 1188 break; 1189 1190 if (TrafficLogFile != NULL) 1191 (void) sm_io_putc(TrafficLogFile, SM_TIME_DEFAULT, 1192 '\n'); 1193 if ((!bitset(PXLF_NOADDEOL, pxflags) || !noeol)) 1194 { 1195 mci->mci_flags &= ~MCIF_INLONGLINE; 1196 if (sm_io_fputs(mci->mci_out, SM_TIME_DEFAULT, 1197 mci->mci_mailer->m_eol) == SM_IO_EOF) 1198 { 1199 dead = true; 1200 break; 1201 } 1202 } 1203 else 1204 mci->mci_flags |= MCIF_INLONGLINE; 1205 1206 if (l < end && *l == '\n') 1207 { 1208 if (*++l != ' ' && *l != '\t' && *l != '\0' && 1209 bitset(PXLF_HEADER, pxflags)) 1210 { 1211 if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT, 1212 ' ') == SM_IO_EOF) 1213 { 1214 dead = true; 1215 break; 1216 } 1217 1218 if (TrafficLogFile != NULL) 1219 (void) sm_io_putc(TrafficLogFile, 1220 SM_TIME_DEFAULT, ' '); 1221 } 1222 } 1223 1224 } while (l < end); 1225 return !dead; 1226 } 1227 1228 /* 1229 ** XUNLINK -- unlink a file, doing logging as appropriate. 1230 ** 1231 ** Parameters: 1232 ** f -- name of file to unlink. 1233 ** 1234 ** Returns: 1235 ** return value of unlink() 1236 ** 1237 ** Side Effects: 1238 ** f is unlinked. 1239 */ 1240 1241 int 1242 xunlink(f) 1243 char *f; 1244 { 1245 register int i; 1246 int save_errno; 1247 1248 if (LogLevel > 98) 1249 sm_syslog(LOG_DEBUG, CurEnv->e_id, "unlink %s", f); 1250 1251 i = unlink(f); 1252 save_errno = errno; 1253 if (i < 0 && LogLevel > 97) 1254 sm_syslog(LOG_DEBUG, CurEnv->e_id, "%s: unlink-fail %d", 1255 f, errno); 1256 if (i >= 0) 1257 SYNC_DIR(f, false); 1258 errno = save_errno; 1259 return i; 1260 } 1261 1262 /* 1263 ** SFGETS -- "safe" fgets -- times out and ignores random interrupts. 1264 ** 1265 ** Parameters: 1266 ** buf -- place to put the input line. 1267 ** siz -- size of buf. 1268 ** fp -- file to read from. 1269 ** timeout -- the timeout before error occurs. 1270 ** during -- what we are trying to read (for error messages). 1271 ** 1272 ** Returns: 1273 ** NULL on error (including timeout). This may also leave 1274 ** buf containing a null string. 1275 ** buf otherwise. 1276 */ 1277 1278 1279 char * 1280 sfgets(buf, siz, fp, timeout, during) 1281 char *buf; 1282 int siz; 1283 SM_FILE_T *fp; 1284 time_t timeout; 1285 char *during; 1286 { 1287 register char *p; 1288 int save_errno, io_timeout, l; 1289 1290 SM_REQUIRE(siz > 0); 1291 SM_REQUIRE(buf != NULL); 1292 1293 if (fp == NULL) 1294 { 1295 buf[0] = '\0'; 1296 errno = EBADF; 1297 return NULL; 1298 } 1299 1300 /* try to read */ 1301 l = -1; 1302 errno = 0; 1303 1304 /* convert the timeout to sm_io notation */ 1305 io_timeout = (timeout <= 0) ? SM_TIME_DEFAULT : timeout * 1000; 1306 while (!sm_io_eof(fp) && !sm_io_error(fp)) 1307 { 1308 errno = 0; 1309 l = sm_io_fgets(fp, io_timeout, buf, siz); 1310 if (l < 0 && errno == EAGAIN) 1311 { 1312 /* The sm_io_fgets() call timedout */ 1313 if (LogLevel > 1) 1314 sm_syslog(LOG_NOTICE, CurEnv->e_id, 1315 "timeout waiting for input from %.100s during %s", 1316 CURHOSTNAME, 1317 during); 1318 buf[0] = '\0'; 1319 #if XDEBUG 1320 checkfd012(during); 1321 #endif /* XDEBUG */ 1322 if (TrafficLogFile != NULL) 1323 (void) sm_io_fprintf(TrafficLogFile, 1324 SM_TIME_DEFAULT, 1325 "%05d <<< [TIMEOUT]\n", 1326 (int) CurrentPid); 1327 errno = ETIMEDOUT; 1328 return NULL; 1329 } 1330 if (l >= 0 || errno != EINTR) 1331 break; 1332 (void) sm_io_clearerr(fp); 1333 } 1334 save_errno = errno; 1335 1336 /* clean up the books and exit */ 1337 LineNumber++; 1338 if (l < 0) 1339 { 1340 buf[0] = '\0'; 1341 if (TrafficLogFile != NULL) 1342 (void) sm_io_fprintf(TrafficLogFile, SM_TIME_DEFAULT, 1343 "%05d <<< [EOF]\n", 1344 (int) CurrentPid); 1345 errno = save_errno; 1346 return NULL; 1347 } 1348 if (TrafficLogFile != NULL) 1349 (void) sm_io_fprintf(TrafficLogFile, SM_TIME_DEFAULT, 1350 "%05d <<< %s", (int) CurrentPid, buf); 1351 if (SevenBitInput) 1352 { 1353 for (p = buf; *p != '\0'; p++) 1354 *p &= ~0200; 1355 } 1356 else if (!HasEightBits) 1357 { 1358 for (p = buf; *p != '\0'; p++) 1359 { 1360 if (bitset(0200, *p)) 1361 { 1362 HasEightBits = true; 1363 break; 1364 } 1365 } 1366 } 1367 return buf; 1368 } 1369 1370 /* 1371 ** FGETFOLDED -- like fgets, but knows about folded lines. 1372 ** 1373 ** Parameters: 1374 ** buf -- place to put result. 1375 ** np -- pointer to bytes available; will be updated with 1376 ** the actual buffer size (not number of bytes filled) 1377 ** on return. 1378 ** f -- file to read from. 1379 ** 1380 ** Returns: 1381 ** input line(s) on success, NULL on error or SM_IO_EOF. 1382 ** This will normally be buf -- unless the line is too 1383 ** long, when it will be sm_malloc_x()ed. 1384 ** 1385 ** Side Effects: 1386 ** buf gets lines from f, with continuation lines (lines 1387 ** with leading white space) appended. CRLF's are mapped 1388 ** into single newlines. Any trailing NL is stripped. 1389 */ 1390 1391 char * 1392 fgetfolded(buf, np, f) 1393 char *buf; 1394 int *np; 1395 SM_FILE_T *f; 1396 { 1397 register char *p = buf; 1398 char *bp = buf; 1399 register int i; 1400 int n; 1401 1402 SM_REQUIRE(np != NULL); 1403 n = *np; 1404 SM_REQUIRE(n > 0); 1405 SM_REQUIRE(buf != NULL); 1406 if (f == NULL) 1407 { 1408 buf[0] = '\0'; 1409 errno = EBADF; 1410 return NULL; 1411 } 1412 1413 n--; 1414 while ((i = sm_io_getc(f, SM_TIME_DEFAULT)) != SM_IO_EOF) 1415 { 1416 if (i == '\r') 1417 { 1418 i = sm_io_getc(f, SM_TIME_DEFAULT); 1419 if (i != '\n') 1420 { 1421 if (i != SM_IO_EOF) 1422 (void) sm_io_ungetc(f, SM_TIME_DEFAULT, 1423 i); 1424 i = '\r'; 1425 } 1426 } 1427 if (--n <= 0) 1428 { 1429 /* allocate new space */ 1430 char *nbp; 1431 int nn; 1432 1433 nn = (p - bp); 1434 if (nn < MEMCHUNKSIZE) 1435 nn *= 2; 1436 else 1437 nn += MEMCHUNKSIZE; 1438 nbp = sm_malloc_x(nn); 1439 memmove(nbp, bp, p - bp); 1440 p = &nbp[p - bp]; 1441 if (bp != buf) 1442 sm_free(bp); 1443 bp = nbp; 1444 n = nn - (p - bp); 1445 *np = nn; 1446 } 1447 *p++ = i; 1448 if (i == '\n') 1449 { 1450 LineNumber++; 1451 i = sm_io_getc(f, SM_TIME_DEFAULT); 1452 if (i != SM_IO_EOF) 1453 (void) sm_io_ungetc(f, SM_TIME_DEFAULT, i); 1454 if (i != ' ' && i != '\t') 1455 break; 1456 } 1457 } 1458 if (p == bp) 1459 return NULL; 1460 if (p[-1] == '\n') 1461 p--; 1462 *p = '\0'; 1463 return bp; 1464 } 1465 1466 /* 1467 ** CURTIME -- return current time. 1468 ** 1469 ** Parameters: 1470 ** none. 1471 ** 1472 ** Returns: 1473 ** the current time. 1474 */ 1475 1476 time_t 1477 curtime() 1478 { 1479 auto time_t t; 1480 1481 (void) time(&t); 1482 return t; 1483 } 1484 1485 /* 1486 ** ATOBOOL -- convert a string representation to boolean. 1487 ** 1488 ** Defaults to false 1489 ** 1490 ** Parameters: 1491 ** s -- string to convert. Takes "tTyY", empty, and NULL as true, 1492 ** others as false. 1493 ** 1494 ** Returns: 1495 ** A boolean representation of the string. 1496 */ 1497 1498 bool 1499 atobool(s) 1500 register char *s; 1501 { 1502 if (s == NULL || *s == '\0' || strchr("tTyY", *s) != NULL) 1503 return true; 1504 return false; 1505 } 1506 1507 /* 1508 ** ATOOCT -- convert a string representation to octal. 1509 ** 1510 ** Parameters: 1511 ** s -- string to convert. 1512 ** 1513 ** Returns: 1514 ** An integer representing the string interpreted as an 1515 ** octal number. 1516 */ 1517 1518 int 1519 atooct(s) 1520 register char *s; 1521 { 1522 register int i = 0; 1523 1524 while (*s >= '0' && *s <= '7') 1525 i = (i << 3) | (*s++ - '0'); 1526 return i; 1527 } 1528 1529 /* 1530 ** BITINTERSECT -- tell if two bitmaps intersect 1531 ** 1532 ** Parameters: 1533 ** a, b -- the bitmaps in question 1534 ** 1535 ** Returns: 1536 ** true if they have a non-null intersection 1537 ** false otherwise 1538 */ 1539 1540 bool 1541 bitintersect(a, b) 1542 BITMAP256 a; 1543 BITMAP256 b; 1544 { 1545 int i; 1546 1547 for (i = BITMAPBYTES / sizeof(int); --i >= 0; ) 1548 { 1549 if ((a[i] & b[i]) != 0) 1550 return true; 1551 } 1552 return false; 1553 } 1554 1555 /* 1556 ** BITZEROP -- tell if a bitmap is all zero 1557 ** 1558 ** Parameters: 1559 ** map -- the bit map to check 1560 ** 1561 ** Returns: 1562 ** true if map is all zero. 1563 ** false if there are any bits set in map. 1564 */ 1565 1566 bool 1567 bitzerop(map) 1568 BITMAP256 map; 1569 { 1570 int i; 1571 1572 for (i = BITMAPBYTES / sizeof(int); --i >= 0; ) 1573 { 1574 if (map[i] != 0) 1575 return false; 1576 } 1577 return true; 1578 } 1579 1580 /* 1581 ** STRCONTAINEDIN -- tell if one string is contained in another 1582 ** 1583 ** Parameters: 1584 ** icase -- ignore case? 1585 ** a -- possible substring. 1586 ** b -- possible superstring. 1587 ** 1588 ** Returns: 1589 ** true if a is contained in b (case insensitive). 1590 ** false otherwise. 1591 */ 1592 1593 bool 1594 strcontainedin(icase, a, b) 1595 bool icase; 1596 register char *a; 1597 register char *b; 1598 { 1599 int la; 1600 int lb; 1601 int c; 1602 1603 la = strlen(a); 1604 lb = strlen(b); 1605 c = *a; 1606 if (icase && isascii(c) && isupper(c)) 1607 c = tolower(c); 1608 for (; lb-- >= la; b++) 1609 { 1610 if (icase) 1611 { 1612 if (*b != c && 1613 isascii(*b) && isupper(*b) && tolower(*b) != c) 1614 continue; 1615 if (sm_strncasecmp(a, b, la) == 0) 1616 return true; 1617 } 1618 else 1619 { 1620 if (*b != c) 1621 continue; 1622 if (strncmp(a, b, la) == 0) 1623 return true; 1624 } 1625 } 1626 return false; 1627 } 1628 1629 /* 1630 ** CHECKFD012 -- check low numbered file descriptors 1631 ** 1632 ** File descriptors 0, 1, and 2 should be open at all times. 1633 ** This routine verifies that, and fixes it if not true. 1634 ** 1635 ** Parameters: 1636 ** where -- a tag printed if the assertion failed 1637 ** 1638 ** Returns: 1639 ** none 1640 */ 1641 1642 void 1643 checkfd012(where) 1644 char *where; 1645 { 1646 #if XDEBUG 1647 register int i; 1648 1649 for (i = 0; i < 3; i++) 1650 fill_fd(i, where); 1651 #endif /* XDEBUG */ 1652 } 1653 1654 /* 1655 ** CHECKFDOPEN -- make sure file descriptor is open -- for extended debugging 1656 ** 1657 ** Parameters: 1658 ** fd -- file descriptor to check. 1659 ** where -- tag to print on failure. 1660 ** 1661 ** Returns: 1662 ** none. 1663 */ 1664 1665 void 1666 checkfdopen(fd, where) 1667 int fd; 1668 char *where; 1669 { 1670 #if XDEBUG 1671 struct stat st; 1672 1673 if (fstat(fd, &st) < 0 && errno == EBADF) 1674 { 1675 syserr("checkfdopen(%d): %s not open as expected!", fd, where); 1676 printopenfds(true); 1677 } 1678 #endif /* XDEBUG */ 1679 } 1680 1681 /* 1682 ** CHECKFDS -- check for new or missing file descriptors 1683 ** 1684 ** Parameters: 1685 ** where -- tag for printing. If null, take a base line. 1686 ** 1687 ** Returns: 1688 ** none 1689 ** 1690 ** Side Effects: 1691 ** If where is set, shows changes since the last call. 1692 */ 1693 1694 void 1695 checkfds(where) 1696 char *where; 1697 { 1698 int maxfd; 1699 register int fd; 1700 bool printhdr = true; 1701 int save_errno = errno; 1702 static BITMAP256 baseline; 1703 extern int DtableSize; 1704 1705 if (DtableSize > BITMAPBITS) 1706 maxfd = BITMAPBITS; 1707 else 1708 maxfd = DtableSize; 1709 if (where == NULL) 1710 clrbitmap(baseline); 1711 1712 for (fd = 0; fd < maxfd; fd++) 1713 { 1714 struct stat stbuf; 1715 1716 if (fstat(fd, &stbuf) < 0 && errno != EOPNOTSUPP) 1717 { 1718 if (!bitnset(fd, baseline)) 1719 continue; 1720 clrbitn(fd, baseline); 1721 } 1722 else if (!bitnset(fd, baseline)) 1723 setbitn(fd, baseline); 1724 else 1725 continue; 1726 1727 /* file state has changed */ 1728 if (where == NULL) 1729 continue; 1730 if (printhdr) 1731 { 1732 sm_syslog(LOG_DEBUG, CurEnv->e_id, 1733 "%s: changed fds:", 1734 where); 1735 printhdr = false; 1736 } 1737 dumpfd(fd, true, true); 1738 } 1739 errno = save_errno; 1740 } 1741 1742 /* 1743 ** PRINTOPENFDS -- print the open file descriptors (for debugging) 1744 ** 1745 ** Parameters: 1746 ** logit -- if set, send output to syslog; otherwise 1747 ** print for debugging. 1748 ** 1749 ** Returns: 1750 ** none. 1751 */ 1752 1753 #if NETINET || NETINET6 1754 # include <arpa/inet.h> 1755 #endif /* NETINET || NETINET6 */ 1756 1757 void 1758 printopenfds(logit) 1759 bool logit; 1760 { 1761 register int fd; 1762 extern int DtableSize; 1763 1764 for (fd = 0; fd < DtableSize; fd++) 1765 dumpfd(fd, false, logit); 1766 } 1767 1768 /* 1769 ** DUMPFD -- dump a file descriptor 1770 ** 1771 ** Parameters: 1772 ** fd -- the file descriptor to dump. 1773 ** printclosed -- if set, print a notification even if 1774 ** it is closed; otherwise print nothing. 1775 ** logit -- if set, use sm_syslog instead of sm_dprintf() 1776 ** 1777 ** Returns: 1778 ** none. 1779 */ 1780 1781 void 1782 dumpfd(fd, printclosed, logit) 1783 int fd; 1784 bool printclosed; 1785 bool logit; 1786 { 1787 register char *p; 1788 char *hp; 1789 #ifdef S_IFSOCK 1790 SOCKADDR sa; 1791 #endif /* S_IFSOCK */ 1792 auto SOCKADDR_LEN_T slen; 1793 int i; 1794 #if STAT64 > 0 1795 struct stat64 st; 1796 #else /* STAT64 > 0 */ 1797 struct stat st; 1798 #endif /* STAT64 > 0 */ 1799 char buf[200]; 1800 1801 p = buf; 1802 (void) sm_snprintf(p, SPACELEFT(buf, p), "%3d: ", fd); 1803 p += strlen(p); 1804 1805 if ( 1806 #if STAT64 > 0 1807 fstat64(fd, &st) 1808 #else /* STAT64 > 0 */ 1809 fstat(fd, &st) 1810 #endif /* STAT64 > 0 */ 1811 < 0) 1812 { 1813 if (errno != EBADF) 1814 { 1815 (void) sm_snprintf(p, SPACELEFT(buf, p), 1816 "CANNOT STAT (%s)", 1817 sm_errstring(errno)); 1818 goto printit; 1819 } 1820 else if (printclosed) 1821 { 1822 (void) sm_snprintf(p, SPACELEFT(buf, p), "CLOSED"); 1823 goto printit; 1824 } 1825 return; 1826 } 1827 1828 i = fcntl(fd, F_GETFL, 0); 1829 if (i != -1) 1830 { 1831 (void) sm_snprintf(p, SPACELEFT(buf, p), "fl=0x%x, ", i); 1832 p += strlen(p); 1833 } 1834 1835 (void) sm_snprintf(p, SPACELEFT(buf, p), "mode=%o: ", 1836 (unsigned int) st.st_mode); 1837 p += strlen(p); 1838 switch (st.st_mode & S_IFMT) 1839 { 1840 #ifdef S_IFSOCK 1841 case S_IFSOCK: 1842 (void) sm_snprintf(p, SPACELEFT(buf, p), "SOCK "); 1843 p += strlen(p); 1844 memset(&sa, '\0', sizeof(sa)); 1845 slen = sizeof(sa); 1846 if (getsockname(fd, &sa.sa, &slen) < 0) 1847 (void) sm_snprintf(p, SPACELEFT(buf, p), "(%s)", 1848 sm_errstring(errno)); 1849 else 1850 { 1851 hp = hostnamebyanyaddr(&sa); 1852 if (hp == NULL) 1853 { 1854 /* EMPTY */ 1855 /* do nothing */ 1856 } 1857 # if NETINET 1858 else if (sa.sa.sa_family == AF_INET) 1859 (void) sm_snprintf(p, SPACELEFT(buf, p), 1860 "%s/%d", hp, ntohs(sa.sin.sin_port)); 1861 # endif /* NETINET */ 1862 # if NETINET6 1863 else if (sa.sa.sa_family == AF_INET6) 1864 (void) sm_snprintf(p, SPACELEFT(buf, p), 1865 "%s/%d", hp, ntohs(sa.sin6.sin6_port)); 1866 # endif /* NETINET6 */ 1867 else 1868 (void) sm_snprintf(p, SPACELEFT(buf, p), 1869 "%s", hp); 1870 } 1871 p += strlen(p); 1872 (void) sm_snprintf(p, SPACELEFT(buf, p), "->"); 1873 p += strlen(p); 1874 slen = sizeof(sa); 1875 if (getpeername(fd, &sa.sa, &slen) < 0) 1876 (void) sm_snprintf(p, SPACELEFT(buf, p), "(%s)", 1877 sm_errstring(errno)); 1878 else 1879 { 1880 hp = hostnamebyanyaddr(&sa); 1881 if (hp == NULL) 1882 { 1883 /* EMPTY */ 1884 /* do nothing */ 1885 } 1886 # if NETINET 1887 else if (sa.sa.sa_family == AF_INET) 1888 (void) sm_snprintf(p, SPACELEFT(buf, p), 1889 "%s/%d", hp, ntohs(sa.sin.sin_port)); 1890 # endif /* NETINET */ 1891 # if NETINET6 1892 else if (sa.sa.sa_family == AF_INET6) 1893 (void) sm_snprintf(p, SPACELEFT(buf, p), 1894 "%s/%d", hp, ntohs(sa.sin6.sin6_port)); 1895 # endif /* NETINET6 */ 1896 else 1897 (void) sm_snprintf(p, SPACELEFT(buf, p), 1898 "%s", hp); 1899 } 1900 break; 1901 #endif /* S_IFSOCK */ 1902 1903 case S_IFCHR: 1904 (void) sm_snprintf(p, SPACELEFT(buf, p), "CHR: "); 1905 p += strlen(p); 1906 goto defprint; 1907 1908 #ifdef S_IFBLK 1909 case S_IFBLK: 1910 (void) sm_snprintf(p, SPACELEFT(buf, p), "BLK: "); 1911 p += strlen(p); 1912 goto defprint; 1913 #endif /* S_IFBLK */ 1914 1915 #if defined(S_IFIFO) && (!defined(S_IFSOCK) || S_IFIFO != S_IFSOCK) 1916 case S_IFIFO: 1917 (void) sm_snprintf(p, SPACELEFT(buf, p), "FIFO: "); 1918 p += strlen(p); 1919 goto defprint; 1920 #endif /* defined(S_IFIFO) && (!defined(S_IFSOCK) || S_IFIFO != S_IFSOCK) */ 1921 1922 #ifdef S_IFDIR 1923 case S_IFDIR: 1924 (void) sm_snprintf(p, SPACELEFT(buf, p), "DIR: "); 1925 p += strlen(p); 1926 goto defprint; 1927 #endif /* S_IFDIR */ 1928 1929 #ifdef S_IFLNK 1930 case S_IFLNK: 1931 (void) sm_snprintf(p, SPACELEFT(buf, p), "LNK: "); 1932 p += strlen(p); 1933 goto defprint; 1934 #endif /* S_IFLNK */ 1935 1936 default: 1937 defprint: 1938 (void) sm_snprintf(p, SPACELEFT(buf, p), 1939 "dev=%ld/%ld, ino=%llu, nlink=%d, u/gid=%ld/%ld, ", 1940 (long) major(st.st_dev), (long) minor(st.st_dev), 1941 (ULONGLONG_T) st.st_ino, 1942 (int) st.st_nlink, (long) st.st_uid, 1943 (long) st.st_gid); 1944 p += strlen(p); 1945 (void) sm_snprintf(p, SPACELEFT(buf, p), "size=%llu", 1946 (ULONGLONG_T) st.st_size); 1947 break; 1948 } 1949 1950 printit: 1951 if (logit) 1952 sm_syslog(LOG_DEBUG, CurEnv ? CurEnv->e_id : NULL, 1953 "%.800s", buf); 1954 else 1955 sm_dprintf("%s\n", buf); 1956 } 1957 1958 /* 1959 ** SHORTEN_HOSTNAME -- strip local domain information off of hostname. 1960 ** 1961 ** Parameters: 1962 ** host -- the host to shorten (stripped in place). 1963 ** 1964 ** Returns: 1965 ** place where string was truncated, NULL if not truncated. 1966 */ 1967 1968 char * 1969 shorten_hostname(host) 1970 char host[]; 1971 { 1972 register char *p; 1973 char *mydom; 1974 int i; 1975 bool canon = false; 1976 1977 /* strip off final dot */ 1978 i = strlen(host); 1979 p = &host[(i == 0) ? 0 : i - 1]; 1980 if (*p == '.') 1981 { 1982 *p = '\0'; 1983 canon = true; 1984 } 1985 1986 /* see if there is any domain at all -- if not, we are done */ 1987 p = strchr(host, '.'); 1988 if (p == NULL) 1989 return NULL; 1990 1991 /* yes, we have a domain -- see if it looks like us */ 1992 mydom = macvalue('m', CurEnv); 1993 if (mydom == NULL) 1994 mydom = ""; 1995 i = strlen(++p); 1996 if ((canon ? sm_strcasecmp(p, mydom) 1997 : sm_strncasecmp(p, mydom, i)) == 0 && 1998 (mydom[i] == '.' || mydom[i] == '\0')) 1999 { 2000 *--p = '\0'; 2001 return p; 2002 } 2003 return NULL; 2004 } 2005 2006 /* 2007 ** PROG_OPEN -- open a program for reading 2008 ** 2009 ** Parameters: 2010 ** argv -- the argument list. 2011 ** pfd -- pointer to a place to store the file descriptor. 2012 ** e -- the current envelope. 2013 ** 2014 ** Returns: 2015 ** pid of the process -- -1 if it failed. 2016 */ 2017 2018 pid_t 2019 prog_open(argv, pfd, e) 2020 char **argv; 2021 int *pfd; 2022 ENVELOPE *e; 2023 { 2024 pid_t pid; 2025 int save_errno; 2026 int sff; 2027 int ret; 2028 int fdv[2]; 2029 char *p, *q; 2030 char buf[MAXPATHLEN]; 2031 extern int DtableSize; 2032 2033 if (pipe(fdv) < 0) 2034 { 2035 syserr("%s: cannot create pipe for stdout", argv[0]); 2036 return -1; 2037 } 2038 pid = fork(); 2039 if (pid < 0) 2040 { 2041 syserr("%s: cannot fork", argv[0]); 2042 (void) close(fdv[0]); 2043 (void) close(fdv[1]); 2044 return -1; 2045 } 2046 if (pid > 0) 2047 { 2048 /* parent */ 2049 (void) close(fdv[1]); 2050 *pfd = fdv[0]; 2051 return pid; 2052 } 2053 2054 /* Reset global flags */ 2055 RestartRequest = NULL; 2056 RestartWorkGroup = false; 2057 ShutdownRequest = NULL; 2058 PendingSignal = 0; 2059 CurrentPid = getpid(); 2060 2061 /* 2062 ** Initialize exception stack and default exception 2063 ** handler for child process. 2064 */ 2065 2066 sm_exc_newthread(fatal_error); 2067 2068 /* child -- close stdin */ 2069 (void) close(0); 2070 2071 /* stdout goes back to parent */ 2072 (void) close(fdv[0]); 2073 if (dup2(fdv[1], 1) < 0) 2074 { 2075 syserr("%s: cannot dup2 for stdout", argv[0]); 2076 _exit(EX_OSERR); 2077 } 2078 (void) close(fdv[1]); 2079 2080 /* stderr goes to transcript if available */ 2081 if (e->e_xfp != NULL) 2082 { 2083 int xfd; 2084 2085 xfd = sm_io_getinfo(e->e_xfp, SM_IO_WHAT_FD, NULL); 2086 if (xfd >= 0 && dup2(xfd, 2) < 0) 2087 { 2088 syserr("%s: cannot dup2 for stderr", argv[0]); 2089 _exit(EX_OSERR); 2090 } 2091 } 2092 2093 /* this process has no right to the queue file */ 2094 if (e->e_lockfp != NULL) 2095 { 2096 int fd; 2097 2098 fd = sm_io_getinfo(e->e_lockfp, SM_IO_WHAT_FD, NULL); 2099 if (fd >= 0) 2100 (void) close(fd); 2101 else 2102 syserr("%s: lockfp does not have a fd", argv[0]); 2103 } 2104 2105 /* chroot to the program mailer directory, if defined */ 2106 if (ProgMailer != NULL && ProgMailer->m_rootdir != NULL) 2107 { 2108 expand(ProgMailer->m_rootdir, buf, sizeof(buf), e); 2109 if (chroot(buf) < 0) 2110 { 2111 syserr("prog_open: cannot chroot(%s)", buf); 2112 exit(EX_TEMPFAIL); 2113 } 2114 if (chdir("/") < 0) 2115 { 2116 syserr("prog_open: cannot chdir(/)"); 2117 exit(EX_TEMPFAIL); 2118 } 2119 } 2120 2121 /* run as default user */ 2122 endpwent(); 2123 sm_mbdb_terminate(); 2124 #if _FFR_MEMSTAT 2125 (void) sm_memstat_close(); 2126 #endif /* _FFR_MEMSTAT */ 2127 if (setgid(DefGid) < 0 && geteuid() == 0) 2128 { 2129 syserr("prog_open: setgid(%ld) failed", (long) DefGid); 2130 exit(EX_TEMPFAIL); 2131 } 2132 if (setuid(DefUid) < 0 && geteuid() == 0) 2133 { 2134 syserr("prog_open: setuid(%ld) failed", (long) DefUid); 2135 exit(EX_TEMPFAIL); 2136 } 2137 2138 /* run in some directory */ 2139 if (ProgMailer != NULL) 2140 p = ProgMailer->m_execdir; 2141 else 2142 p = NULL; 2143 for (; p != NULL; p = q) 2144 { 2145 q = strchr(p, ':'); 2146 if (q != NULL) 2147 *q = '\0'; 2148 expand(p, buf, sizeof(buf), e); 2149 if (q != NULL) 2150 *q++ = ':'; 2151 if (buf[0] != '\0' && chdir(buf) >= 0) 2152 break; 2153 } 2154 if (p == NULL) 2155 { 2156 /* backup directories */ 2157 if (chdir("/tmp") < 0) 2158 (void) chdir("/"); 2159 } 2160 2161 /* Check safety of program to be run */ 2162 sff = SFF_ROOTOK|SFF_EXECOK; 2163 if (!bitnset(DBS_RUNWRITABLEPROGRAM, DontBlameSendmail)) 2164 sff |= SFF_NOGWFILES|SFF_NOWWFILES; 2165 if (bitnset(DBS_RUNPROGRAMINUNSAFEDIRPATH, DontBlameSendmail)) 2166 sff |= SFF_NOPATHCHECK; 2167 else 2168 sff |= SFF_SAFEDIRPATH; 2169 ret = safefile(argv[0], DefUid, DefGid, DefUser, sff, 0, NULL); 2170 if (ret != 0) 2171 sm_syslog(LOG_INFO, e->e_id, 2172 "Warning: prog_open: program %s unsafe: %s", 2173 argv[0], sm_errstring(ret)); 2174 2175 /* arrange for all the files to be closed */ 2176 sm_close_on_exec(STDERR_FILENO + 1, DtableSize); 2177 2178 /* now exec the process */ 2179 (void) execve(argv[0], (ARGV_T) argv, (ARGV_T) UserEnviron); 2180 2181 /* woops! failed */ 2182 save_errno = errno; 2183 syserr("%s: cannot exec", argv[0]); 2184 if (transienterror(save_errno)) 2185 _exit(EX_OSERR); 2186 _exit(EX_CONFIG); 2187 return -1; /* avoid compiler warning on IRIX */ 2188 } 2189 2190 /* 2191 ** GET_COLUMN -- look up a Column in a line buffer 2192 ** 2193 ** Parameters: 2194 ** line -- the raw text line to search. 2195 ** col -- the column number to fetch. 2196 ** delim -- the delimiter between columns. If null, 2197 ** use white space. 2198 ** buf -- the output buffer. 2199 ** buflen -- the length of buf. 2200 ** 2201 ** Returns: 2202 ** buf if successful. 2203 ** NULL otherwise. 2204 */ 2205 2206 char * 2207 get_column(line, col, delim, buf, buflen) 2208 char line[]; 2209 int col; 2210 int delim; 2211 char buf[]; 2212 int buflen; 2213 { 2214 char *p; 2215 char *begin, *end; 2216 int i; 2217 char delimbuf[4]; 2218 2219 if ((char) delim == '\0') 2220 (void) sm_strlcpy(delimbuf, "\n\t ", sizeof(delimbuf)); 2221 else 2222 { 2223 delimbuf[0] = (char) delim; 2224 delimbuf[1] = '\0'; 2225 } 2226 2227 p = line; 2228 if (*p == '\0') 2229 return NULL; /* line empty */ 2230 if (*p == (char) delim && col == 0) 2231 return NULL; /* first column empty */ 2232 2233 begin = line; 2234 2235 if (col == 0 && (char) delim == '\0') 2236 { 2237 while (*begin != '\0' && isascii(*begin) && isspace(*begin)) 2238 begin++; 2239 } 2240 2241 for (i = 0; i < col; i++) 2242 { 2243 if ((begin = strpbrk(begin, delimbuf)) == NULL) 2244 return NULL; /* no such column */ 2245 begin++; 2246 if ((char) delim == '\0') 2247 { 2248 while (*begin != '\0' && isascii(*begin) && isspace(*begin)) 2249 begin++; 2250 } 2251 } 2252 2253 end = strpbrk(begin, delimbuf); 2254 if (end == NULL) 2255 i = strlen(begin); 2256 else 2257 i = end - begin; 2258 if (i >= buflen) 2259 i = buflen - 1; 2260 (void) sm_strlcpy(buf, begin, i + 1); 2261 return buf; 2262 } 2263 2264 /* 2265 ** CLEANSTRCPY -- copy string keeping out bogus characters 2266 ** 2267 ** Parameters: 2268 ** t -- "to" string. 2269 ** f -- "from" string. 2270 ** l -- length of space available in "to" string. 2271 ** 2272 ** Returns: 2273 ** none. 2274 */ 2275 2276 void 2277 cleanstrcpy(t, f, l) 2278 register char *t; 2279 register char *f; 2280 int l; 2281 { 2282 /* check for newlines and log if necessary */ 2283 (void) denlstring(f, true, true); 2284 2285 if (l <= 0) 2286 syserr("!cleanstrcpy: length == 0"); 2287 2288 l--; 2289 while (l > 0 && *f != '\0') 2290 { 2291 if (isascii(*f) && 2292 (isalnum(*f) || strchr("!#$%&'*+-./^_`{|}~", *f) != NULL)) 2293 { 2294 l--; 2295 *t++ = *f; 2296 } 2297 f++; 2298 } 2299 *t = '\0'; 2300 } 2301 2302 /* 2303 ** DENLSTRING -- convert newlines in a string to spaces 2304 ** 2305 ** Parameters: 2306 ** s -- the input string 2307 ** strict -- if set, don't permit continuation lines. 2308 ** logattacks -- if set, log attempted attacks. 2309 ** 2310 ** Returns: 2311 ** A pointer to a version of the string with newlines 2312 ** mapped to spaces. This should be copied. 2313 */ 2314 2315 char * 2316 denlstring(s, strict, logattacks) 2317 char *s; 2318 bool strict; 2319 bool logattacks; 2320 { 2321 register char *p; 2322 int l; 2323 static char *bp = NULL; 2324 static int bl = 0; 2325 2326 p = s; 2327 while ((p = strchr(p, '\n')) != NULL) 2328 if (strict || (*++p != ' ' && *p != '\t')) 2329 break; 2330 if (p == NULL) 2331 return s; 2332 2333 l = strlen(s) + 1; 2334 if (bl < l) 2335 { 2336 /* allocate more space */ 2337 char *nbp = sm_pmalloc_x(l); 2338 2339 if (bp != NULL) 2340 sm_free(bp); 2341 bp = nbp; 2342 bl = l; 2343 } 2344 (void) sm_strlcpy(bp, s, l); 2345 for (p = bp; (p = strchr(p, '\n')) != NULL; ) 2346 *p++ = ' '; 2347 2348 if (logattacks) 2349 { 2350 sm_syslog(LOG_NOTICE, CurEnv ? CurEnv->e_id : NULL, 2351 "POSSIBLE ATTACK from %.100s: newline in string \"%s\"", 2352 RealHostName == NULL ? "[UNKNOWN]" : RealHostName, 2353 shortenstring(bp, MAXSHORTSTR)); 2354 } 2355 2356 return bp; 2357 } 2358 2359 /* 2360 ** STRREPLNONPRT -- replace "unprintable" characters in a string with subst 2361 ** 2362 ** Parameters: 2363 ** s -- string to manipulate (in place) 2364 ** subst -- character to use as replacement 2365 ** 2366 ** Returns: 2367 ** true iff string did not contain "unprintable" characters 2368 */ 2369 2370 bool 2371 strreplnonprt(s, c) 2372 char *s; 2373 int c; 2374 { 2375 bool ok; 2376 2377 ok = true; 2378 if (s == NULL) 2379 return ok; 2380 while (*s != '\0') 2381 { 2382 if (!(isascii(*s) && isprint(*s))) 2383 { 2384 *s = c; 2385 ok = false; 2386 } 2387 ++s; 2388 } 2389 return ok; 2390 } 2391 2392 /* 2393 ** PATH_IS_DIR -- check to see if file exists and is a directory. 2394 ** 2395 ** There are some additional checks for security violations in 2396 ** here. This routine is intended to be used for the host status 2397 ** support. 2398 ** 2399 ** Parameters: 2400 ** pathname -- pathname to check for directory-ness. 2401 ** createflag -- if set, create directory if needed. 2402 ** 2403 ** Returns: 2404 ** true -- if the indicated pathname is a directory 2405 ** false -- otherwise 2406 */ 2407 2408 bool 2409 path_is_dir(pathname, createflag) 2410 char *pathname; 2411 bool createflag; 2412 { 2413 struct stat statbuf; 2414 2415 #if HASLSTAT 2416 if (lstat(pathname, &statbuf) < 0) 2417 #else /* HASLSTAT */ 2418 if (stat(pathname, &statbuf) < 0) 2419 #endif /* HASLSTAT */ 2420 { 2421 if (errno != ENOENT || !createflag) 2422 return false; 2423 if (mkdir(pathname, 0755) < 0) 2424 return false; 2425 return true; 2426 } 2427 if (!S_ISDIR(statbuf.st_mode)) 2428 { 2429 errno = ENOTDIR; 2430 return false; 2431 } 2432 2433 /* security: don't allow writable directories */ 2434 if (bitset(S_IWGRP|S_IWOTH, statbuf.st_mode)) 2435 { 2436 errno = EACCES; 2437 return false; 2438 } 2439 return true; 2440 } 2441 2442 /* 2443 ** PROC_LIST_ADD -- add process id to list of our children 2444 ** 2445 ** Parameters: 2446 ** pid -- pid to add to list. 2447 ** task -- task of pid. 2448 ** type -- type of process. 2449 ** count -- number of processes. 2450 ** other -- other information for this type. 2451 ** 2452 ** Returns: 2453 ** none 2454 ** 2455 ** Side Effects: 2456 ** May increase CurChildren. May grow ProcList. 2457 */ 2458 2459 typedef struct procs PROCS_T; 2460 2461 struct procs 2462 { 2463 pid_t proc_pid; 2464 char *proc_task; 2465 int proc_type; 2466 int proc_count; 2467 int proc_other; 2468 SOCKADDR proc_hostaddr; 2469 }; 2470 2471 static PROCS_T *volatile ProcListVec = NULL; 2472 static int ProcListSize = 0; 2473 2474 void 2475 proc_list_add(pid, task, type, count, other, hostaddr) 2476 pid_t pid; 2477 char *task; 2478 int type; 2479 int count; 2480 int other; 2481 SOCKADDR *hostaddr; 2482 { 2483 int i; 2484 2485 for (i = 0; i < ProcListSize; i++) 2486 { 2487 if (ProcListVec[i].proc_pid == NO_PID) 2488 break; 2489 } 2490 if (i >= ProcListSize) 2491 { 2492 /* probe the existing vector to avoid growing infinitely */ 2493 proc_list_probe(); 2494 2495 /* now scan again */ 2496 for (i = 0; i < ProcListSize; i++) 2497 { 2498 if (ProcListVec[i].proc_pid == NO_PID) 2499 break; 2500 } 2501 } 2502 if (i >= ProcListSize) 2503 { 2504 /* grow process list */ 2505 int chldwasblocked; 2506 PROCS_T *npv; 2507 2508 SM_ASSERT(ProcListSize < INT_MAX - PROC_LIST_SEG); 2509 npv = (PROCS_T *) sm_pmalloc_x((sizeof(*npv)) * 2510 (ProcListSize + PROC_LIST_SEG)); 2511 2512 /* Block SIGCHLD so reapchild() doesn't mess with us */ 2513 chldwasblocked = sm_blocksignal(SIGCHLD); 2514 if (ProcListSize > 0) 2515 { 2516 memmove(npv, ProcListVec, 2517 ProcListSize * sizeof(PROCS_T)); 2518 sm_free(ProcListVec); 2519 } 2520 2521 /* XXX just use memset() to initialize this part? */ 2522 for (i = ProcListSize; i < ProcListSize + PROC_LIST_SEG; i++) 2523 { 2524 npv[i].proc_pid = NO_PID; 2525 npv[i].proc_task = NULL; 2526 npv[i].proc_type = PROC_NONE; 2527 } 2528 i = ProcListSize; 2529 ProcListSize += PROC_LIST_SEG; 2530 ProcListVec = npv; 2531 if (chldwasblocked == 0) 2532 (void) sm_releasesignal(SIGCHLD); 2533 } 2534 ProcListVec[i].proc_pid = pid; 2535 PSTRSET(ProcListVec[i].proc_task, task); 2536 ProcListVec[i].proc_type = type; 2537 ProcListVec[i].proc_count = count; 2538 ProcListVec[i].proc_other = other; 2539 if (hostaddr != NULL) 2540 ProcListVec[i].proc_hostaddr = *hostaddr; 2541 else 2542 memset(&ProcListVec[i].proc_hostaddr, 0, 2543 sizeof(ProcListVec[i].proc_hostaddr)); 2544 2545 /* if process adding itself, it's not a child */ 2546 if (pid != CurrentPid) 2547 { 2548 SM_ASSERT(CurChildren < INT_MAX); 2549 CurChildren++; 2550 } 2551 } 2552 2553 /* 2554 ** PROC_LIST_SET -- set pid task in process list 2555 ** 2556 ** Parameters: 2557 ** pid -- pid to set 2558 ** task -- task of pid 2559 ** 2560 ** Returns: 2561 ** none. 2562 */ 2563 2564 void 2565 proc_list_set(pid, task) 2566 pid_t pid; 2567 char *task; 2568 { 2569 int i; 2570 2571 for (i = 0; i < ProcListSize; i++) 2572 { 2573 if (ProcListVec[i].proc_pid == pid) 2574 { 2575 PSTRSET(ProcListVec[i].proc_task, task); 2576 break; 2577 } 2578 } 2579 } 2580 2581 /* 2582 ** PROC_LIST_DROP -- drop pid from process list 2583 ** 2584 ** Parameters: 2585 ** pid -- pid to drop 2586 ** st -- process status 2587 ** other -- storage for proc_other (return). 2588 ** 2589 ** Returns: 2590 ** none. 2591 ** 2592 ** Side Effects: 2593 ** May decrease CurChildren, CurRunners, or 2594 ** set RestartRequest or ShutdownRequest. 2595 ** 2596 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD 2597 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE 2598 ** DOING. 2599 */ 2600 2601 void 2602 proc_list_drop(pid, st, other) 2603 pid_t pid; 2604 int st; 2605 int *other; 2606 { 2607 int i; 2608 int type = PROC_NONE; 2609 2610 for (i = 0; i < ProcListSize; i++) 2611 { 2612 if (ProcListVec[i].proc_pid == pid) 2613 { 2614 ProcListVec[i].proc_pid = NO_PID; 2615 type = ProcListVec[i].proc_type; 2616 if (other != NULL) 2617 *other = ProcListVec[i].proc_other; 2618 if (CurChildren > 0) 2619 CurChildren--; 2620 break; 2621 } 2622 } 2623 2624 2625 if (type == PROC_CONTROL && WIFEXITED(st)) 2626 { 2627 /* if so, see if we need to restart or shutdown */ 2628 if (WEXITSTATUS(st) == EX_RESTART) 2629 RestartRequest = "control socket"; 2630 else if (WEXITSTATUS(st) == EX_SHUTDOWN) 2631 ShutdownRequest = "control socket"; 2632 } 2633 else if (type == PROC_QUEUE_CHILD && !WIFSTOPPED(st) && 2634 ProcListVec[i].proc_other > -1) 2635 { 2636 /* restart this persistent runner */ 2637 mark_work_group_restart(ProcListVec[i].proc_other, st); 2638 } 2639 else if (type == PROC_QUEUE) 2640 { 2641 CurRunners -= ProcListVec[i].proc_count; 2642 2643 /* CHK_CUR_RUNNERS() can't be used here: uses syslog() */ 2644 if (CurRunners < 0) 2645 CurRunners = 0; 2646 } 2647 } 2648 2649 /* 2650 ** PROC_LIST_CLEAR -- clear the process list 2651 ** 2652 ** Parameters: 2653 ** none. 2654 ** 2655 ** Returns: 2656 ** none. 2657 ** 2658 ** Side Effects: 2659 ** Sets CurChildren to zero. 2660 */ 2661 2662 void 2663 proc_list_clear() 2664 { 2665 int i; 2666 2667 /* start from 1 since 0 is the daemon itself */ 2668 for (i = 1; i < ProcListSize; i++) 2669 ProcListVec[i].proc_pid = NO_PID; 2670 CurChildren = 0; 2671 } 2672 2673 /* 2674 ** PROC_LIST_PROBE -- probe processes in the list to see if they still exist 2675 ** 2676 ** Parameters: 2677 ** none 2678 ** 2679 ** Returns: 2680 ** none 2681 ** 2682 ** Side Effects: 2683 ** May decrease CurChildren. 2684 */ 2685 2686 void 2687 proc_list_probe() 2688 { 2689 int i, children; 2690 int chldwasblocked; 2691 pid_t pid; 2692 2693 children = 0; 2694 chldwasblocked = sm_blocksignal(SIGCHLD); 2695 2696 /* start from 1 since 0 is the daemon itself */ 2697 for (i = 1; i < ProcListSize; i++) 2698 { 2699 pid = ProcListVec[i].proc_pid; 2700 if (pid == NO_PID || pid == CurrentPid) 2701 continue; 2702 if (kill(pid, 0) < 0) 2703 { 2704 if (LogLevel > 3) 2705 sm_syslog(LOG_DEBUG, CurEnv->e_id, 2706 "proc_list_probe: lost pid %d", 2707 (int) ProcListVec[i].proc_pid); 2708 ProcListVec[i].proc_pid = NO_PID; 2709 SM_FREE_CLR(ProcListVec[i].proc_task); 2710 2711 if (ProcListVec[i].proc_type == PROC_QUEUE) 2712 { 2713 CurRunners -= ProcListVec[i].proc_count; 2714 CHK_CUR_RUNNERS("proc_list_probe", i, 2715 ProcListVec[i].proc_count); 2716 } 2717 2718 CurChildren--; 2719 } 2720 else 2721 { 2722 ++children; 2723 } 2724 } 2725 if (CurChildren < 0) 2726 CurChildren = 0; 2727 if (chldwasblocked == 0) 2728 (void) sm_releasesignal(SIGCHLD); 2729 if (LogLevel > 10 && children != CurChildren && CurrentPid == DaemonPid) 2730 { 2731 sm_syslog(LOG_ERR, NOQID, 2732 "proc_list_probe: found %d children, expected %d", 2733 children, CurChildren); 2734 } 2735 } 2736 2737 /* 2738 ** PROC_LIST_DISPLAY -- display the process list 2739 ** 2740 ** Parameters: 2741 ** out -- output file pointer 2742 ** prefix -- string to output in front of each line. 2743 ** 2744 ** Returns: 2745 ** none. 2746 */ 2747 2748 void 2749 proc_list_display(out, prefix) 2750 SM_FILE_T *out; 2751 char *prefix; 2752 { 2753 int i; 2754 2755 for (i = 0; i < ProcListSize; i++) 2756 { 2757 if (ProcListVec[i].proc_pid == NO_PID) 2758 continue; 2759 2760 (void) sm_io_fprintf(out, SM_TIME_DEFAULT, "%s%d %s%s\n", 2761 prefix, 2762 (int) ProcListVec[i].proc_pid, 2763 ProcListVec[i].proc_task != NULL ? 2764 ProcListVec[i].proc_task : "(unknown)", 2765 (OpMode == MD_SMTP || 2766 OpMode == MD_DAEMON || 2767 OpMode == MD_ARPAFTP) ? "\r" : ""); 2768 } 2769 } 2770 2771 /* 2772 ** PROC_LIST_SIGNAL -- send a signal to a type of process in the list 2773 ** 2774 ** Parameters: 2775 ** type -- type of process to signal 2776 ** signal -- the type of signal to send 2777 ** 2778 ** Results: 2779 ** none. 2780 ** 2781 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD 2782 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE 2783 ** DOING. 2784 */ 2785 2786 void 2787 proc_list_signal(type, signal) 2788 int type; 2789 int signal; 2790 { 2791 int chldwasblocked; 2792 int alrmwasblocked; 2793 int i; 2794 pid_t mypid = getpid(); 2795 2796 /* block these signals so that we may signal cleanly */ 2797 chldwasblocked = sm_blocksignal(SIGCHLD); 2798 alrmwasblocked = sm_blocksignal(SIGALRM); 2799 2800 /* Find all processes of type and send signal */ 2801 for (i = 0; i < ProcListSize; i++) 2802 { 2803 if (ProcListVec[i].proc_pid == NO_PID || 2804 ProcListVec[i].proc_pid == mypid) 2805 continue; 2806 if (ProcListVec[i].proc_type != type) 2807 continue; 2808 (void) kill(ProcListVec[i].proc_pid, signal); 2809 } 2810 2811 /* restore the signals */ 2812 if (alrmwasblocked == 0) 2813 (void) sm_releasesignal(SIGALRM); 2814 if (chldwasblocked == 0) 2815 (void) sm_releasesignal(SIGCHLD); 2816 } 2817 2818 /* 2819 ** COUNT_OPEN_CONNECTIONS 2820 ** 2821 ** Parameters: 2822 ** hostaddr - ClientAddress 2823 ** 2824 ** Returns: 2825 ** the number of open connections for this client 2826 ** 2827 */ 2828 2829 int 2830 count_open_connections(hostaddr) 2831 SOCKADDR *hostaddr; 2832 { 2833 int i, n; 2834 2835 if (hostaddr == NULL) 2836 return 0; 2837 2838 /* 2839 ** This code gets called before proc_list_add() gets called, 2840 ** so we (the daemon child for this connection) have not yet 2841 ** counted ourselves. Hence initialize the counter to 1 2842 ** instead of 0 to compensate. 2843 */ 2844 2845 n = 1; 2846 for (i = 0; i < ProcListSize; i++) 2847 { 2848 if (ProcListVec[i].proc_pid == NO_PID) 2849 continue; 2850 if (hostaddr->sa.sa_family != 2851 ProcListVec[i].proc_hostaddr.sa.sa_family) 2852 continue; 2853 #if NETINET 2854 if (hostaddr->sa.sa_family == AF_INET && 2855 (hostaddr->sin.sin_addr.s_addr == 2856 ProcListVec[i].proc_hostaddr.sin.sin_addr.s_addr)) 2857 n++; 2858 #endif /* NETINET */ 2859 #if NETINET6 2860 if (hostaddr->sa.sa_family == AF_INET6 && 2861 IN6_ARE_ADDR_EQUAL(&(hostaddr->sin6.sin6_addr), 2862 &(ProcListVec[i].proc_hostaddr.sin6.sin6_addr))) 2863 n++; 2864 #endif /* NETINET6 */ 2865 } 2866 return n; 2867 } 2868 2869 #if _FFR_XCNCT 2870 /* 2871 ** XCONNECT -- get X-CONNECT info 2872 ** 2873 ** Parameters: 2874 ** inchannel -- FILE to check 2875 ** 2876 ** Returns: 2877 ** -1 on error 2878 ** 0 if X-CONNECT was not given 2879 ** >0 if X-CONNECT was used successfully (D_XCNCT*) 2880 */ 2881 2882 int 2883 xconnect(inchannel) 2884 SM_FILE_T *inchannel; 2885 { 2886 int r, i; 2887 char *p, *b, delim, inp[MAXINPLINE]; 2888 SOCKADDR addr; 2889 char **pvp; 2890 char pvpbuf[PSBUFSIZE]; 2891 char *peerhostname; /* name of SMTP peer or "localhost" */ 2892 extern ENVELOPE BlankEnvelope; 2893 2894 #define XCONNECT "X-CONNECT " 2895 #define XCNNCTLEN (sizeof(XCONNECT) - 1) 2896 2897 /* Ask the ruleset whether to use x-connect */ 2898 pvp = NULL; 2899 peerhostname = RealHostName; 2900 if (peerhostname == NULL) 2901 peerhostname = "localhost"; 2902 r = rscap("x_connect", peerhostname, 2903 anynet_ntoa(&RealHostAddr), &BlankEnvelope, 2904 &pvp, pvpbuf, sizeof(pvpbuf)); 2905 if (tTd(75, 8)) 2906 sm_syslog(LOG_INFO, NOQID, "x-connect: rscap=%d", r); 2907 if (r == EX_UNAVAILABLE) 2908 return 0; 2909 if (r != EX_OK) 2910 { 2911 /* ruleset error */ 2912 sm_syslog(LOG_INFO, NOQID, "x-connect: rscap=%d", r); 2913 return 0; 2914 } 2915 if (pvp != NULL && pvp[0] != NULL && (pvp[0][0] & 0377) == CANONNET) 2916 { 2917 /* $#: no x-connect */ 2918 if (tTd(75, 7)) 2919 sm_syslog(LOG_INFO, NOQID, "x-connect: nope"); 2920 return 0; 2921 } 2922 2923 p = sfgets(inp, sizeof(inp), InChannel, TimeOuts.to_nextcommand, "pre"); 2924 if (tTd(75, 6)) 2925 sm_syslog(LOG_INFO, NOQID, "x-connect: input=%s", p); 2926 if (p == NULL || strncasecmp(p, XCONNECT, XCNNCTLEN) != 0) 2927 return -1; 2928 p += XCNNCTLEN; 2929 while (isascii(*p) && isspace(*p)) 2930 p++; 2931 2932 /* parameters: IPAddress [Hostname[ M]] */ 2933 b = p; 2934 while (*p != '\0' && isascii(*p) && 2935 (isalnum(*p) || *p == '.' || *p== ':')) 2936 p++; 2937 delim = *p; 2938 *p = '\0'; 2939 2940 memset(&addr, '\0', sizeof(addr)); 2941 addr.sin.sin_addr.s_addr = inet_addr(b); 2942 if (addr.sin.sin_addr.s_addr != INADDR_NONE) 2943 { 2944 addr.sa.sa_family = AF_INET; 2945 memcpy(&RealHostAddr, &addr, sizeof(addr)); 2946 if (tTd(75, 2)) 2947 sm_syslog(LOG_INFO, NOQID, "x-connect: addr=%s", 2948 anynet_ntoa(&RealHostAddr)); 2949 } 2950 # if NETINET6 2951 else if ((r = inet_pton(AF_INET6, b, &addr.sin6.sin6_addr)) == 1) 2952 { 2953 addr.sa.sa_family = AF_INET6; 2954 memcpy(&RealHostAddr, &addr, sizeof(addr)); 2955 } 2956 # endif /* NETINET6 */ 2957 else 2958 return -1; 2959 2960 /* more parameters? */ 2961 if (delim != ' ') 2962 return D_XCNCT; 2963 while (*p != '\0' && isascii(*p) && isspace(*p)) 2964 p++; 2965 2966 for (b = ++p, i = 0; 2967 *p != '\0' && isascii(*p) && (isalnum(*p) || *p == '.' || *p == '-'); 2968 p++, i++) 2969 ; 2970 if (i == 0) 2971 return D_XCNCT; 2972 delim = *p; 2973 if (i > MAXNAME) 2974 b[MAXNAME] = '\0'; 2975 else 2976 b[i] = '\0'; 2977 SM_FREE_CLR(RealHostName); 2978 RealHostName = newstr(b); 2979 if (tTd(75, 2)) 2980 sm_syslog(LOG_INFO, NOQID, "x-connect: host=%s", b); 2981 *p = delim; 2982 2983 b = p; 2984 if (*p != ' ') 2985 return D_XCNCT; 2986 2987 while (*p != '\0' && isascii(*p) && isspace(*p)) 2988 p++; 2989 2990 if (tTd(75, 4)) 2991 { 2992 char *e; 2993 2994 e = strpbrk(p, "\r\n"); 2995 if (e != NULL) 2996 *e = '\0'; 2997 sm_syslog(LOG_INFO, NOQID, "x-connect: rest=%s", p); 2998 } 2999 if (*p == 'M') 3000 return D_XCNCT_M; 3001 3002 return D_XCNCT; 3003 } 3004 #endif /* _FFR_XCNCT */ 3005