1 /* 2 * Copyright (c) 1983 Eric P. Allman 3 * Copyright (c) 1988 Regents of the University of California. 4 * All rights reserved. 5 * 6 * %sccs.include.redist.c% 7 */ 8 9 #ifndef lint 10 static char sccsid[] = "@(#)conf.c 6.51 (Berkeley) 05/03/93"; 11 #endif /* not lint */ 12 13 # include <sys/ioctl.h> 14 # include <sys/param.h> 15 # include <signal.h> 16 # include <pwd.h> 17 # include "sendmail.h" 18 # include "pathnames.h" 19 20 /* 21 ** CONF.C -- Sendmail Configuration Tables. 22 ** 23 ** Defines the configuration of this installation. 24 ** 25 ** Configuration Variables: 26 ** HdrInfo -- a table describing well-known header fields. 27 ** Each entry has the field name and some flags, 28 ** which are described in sendmail.h. 29 ** 30 ** Notes: 31 ** I have tried to put almost all the reasonable 32 ** configuration information into the configuration 33 ** file read at runtime. My intent is that anything 34 ** here is a function of the version of UNIX you 35 ** are running, or is really static -- for example 36 ** the headers are a superset of widely used 37 ** protocols. If you find yourself playing with 38 ** this file too much, you may be making a mistake! 39 */ 40 41 42 43 44 /* 45 ** Header info table 46 ** Final (null) entry contains the flags used for any other field. 47 ** 48 ** Not all of these are actually handled specially by sendmail 49 ** at this time. They are included as placeholders, to let 50 ** you know that "someday" I intend to have sendmail do 51 ** something with them. 52 */ 53 54 struct hdrinfo HdrInfo[] = 55 { 56 /* originator fields, most to least significant */ 57 "resent-sender", H_FROM|H_RESENT, 58 "resent-from", H_FROM|H_RESENT, 59 "resent-reply-to", H_FROM|H_RESENT, 60 "sender", H_FROM, 61 "from", H_FROM, 62 "reply-to", H_FROM, 63 "full-name", H_ACHECK, 64 "return-receipt-to", H_FROM /* |H_RECEIPTTO */, 65 "errors-to", H_FROM|H_ERRORSTO, 66 67 /* destination fields */ 68 "to", H_RCPT, 69 "resent-to", H_RCPT|H_RESENT, 70 "cc", H_RCPT, 71 "resent-cc", H_RCPT|H_RESENT, 72 "bcc", H_RCPT|H_ACHECK, 73 "resent-bcc", H_RCPT|H_ACHECK|H_RESENT, 74 "apparently-to", H_RCPT, 75 76 /* message identification and control */ 77 "message-id", 0, 78 "resent-message-id", H_RESENT, 79 "message", H_EOH, 80 "text", H_EOH, 81 82 /* date fields */ 83 "date", 0, 84 "resent-date", H_RESENT, 85 86 /* trace fields */ 87 "received", H_TRACE|H_FORCE, 88 "x400-received", H_TRACE|H_FORCE, 89 "via", H_TRACE|H_FORCE, 90 "mail-from", H_TRACE|H_FORCE, 91 92 /* miscellaneous fields */ 93 "comments", H_FORCE, 94 "return-path", H_ACHECK, 95 96 NULL, 0, 97 }; 98 99 100 101 /* 102 ** Location of system files/databases/etc. 103 */ 104 105 char *ConfFile = _PATH_SENDMAILCF; /* runtime configuration */ 106 char *FreezeFile = _PATH_SENDMAILFC; /* frozen version of above */ 107 char *PidFile = _PATH_SENDMAILPID; /* stores daemon proc id */ 108 109 110 111 /* 112 ** Privacy values 113 */ 114 115 struct prival PrivacyValues[] = 116 { 117 "public", PRIV_PUBLIC, 118 "needmailhelo", PRIV_NEEDMAILHELO, 119 "needexpnhelo", PRIV_NEEDEXPNHELO, 120 "needvrfyhelo", PRIV_NEEDVRFYHELO, 121 "noexpn", PRIV_NOEXPN, 122 "novrfy", PRIV_NOVRFY, 123 "restrictmailq", PRIV_RESTRMAILQ, 124 "authwarnings", PRIV_AUTHWARNINGS, 125 "goaway", PRIV_GOAWAY, 126 NULL, 0, 127 }; 128 129 130 131 /* 132 ** Miscellaneous stuff. 133 */ 134 135 int DtableSize = 50; /* max open files; reset in 4.2bsd */ 136 /* 137 ** SETDEFAULTS -- set default values 138 ** 139 ** Because of the way freezing is done, these must be initialized 140 ** using direct code. 141 ** 142 ** Parameters: 143 ** e -- the default envelope. 144 ** 145 ** Returns: 146 ** none. 147 ** 148 ** Side Effects: 149 ** Initializes a bunch of global variables to their 150 ** default values. 151 */ 152 153 #define DAYS * 24 * 60 * 60 154 155 setdefaults(e) 156 register ENVELOPE *e; 157 { 158 SpaceSub = ' '; /* option B */ 159 QueueLA = 8; /* option x */ 160 RefuseLA = 12; /* option X */ 161 WkRecipFact = 30000L; /* option y */ 162 WkClassFact = 1800L; /* option z */ 163 WkTimeFact = 90000L; /* option Z */ 164 QueueFactor = WkRecipFact * 20; /* option q */ 165 FileMode = (getuid() != geteuid()) ? 0644 : 0600; 166 /* option F */ 167 DefUid = 1; /* option u */ 168 DefGid = 1; /* option g */ 169 CheckpointInterval = 10; /* option C */ 170 MaxHopCount = 25; /* option h */ 171 e->e_sendmode = SM_FORK; /* option d */ 172 e->e_errormode = EM_PRINT; /* option e */ 173 EightBit = FALSE; /* option 8 */ 174 MaxMciCache = 1; /* option k */ 175 MciCacheTimeout = 300; /* option K */ 176 LogLevel = 9; /* option L */ 177 settimeouts(NULL); /* option r */ 178 TimeOuts.to_q_return = 5 DAYS; /* option T */ 179 TimeOuts.to_q_warning = 0; /* option T */ 180 PrivacyFlags = 0; /* option p */ 181 setdefuser(); 182 setupaliases(); 183 setupmaps(); 184 setupmailers(); 185 } 186 187 188 /* 189 ** SETDEFUSER -- set/reset DefUser using DefUid (for initgroups()) 190 */ 191 192 setdefuser() 193 { 194 struct passwd *defpwent; 195 static char defuserbuf[40]; 196 197 DefUser = defuserbuf; 198 if ((defpwent = getpwuid(DefUid)) != NULL) 199 strcpy(defuserbuf, defpwent->pw_name); 200 else 201 strcpy(defuserbuf, "nobody"); 202 } 203 /* 204 ** SETUPMAPS -- set up map classes 205 ** 206 ** Since these are compiled in, they cannot be in the config file. 207 ** 208 */ 209 210 setupmaps() 211 { 212 register STAB *s; 213 214 /* host name lookup map */ 215 { 216 extern bool host_map_init(); 217 extern char *maphostname(); 218 219 s = stab("host", ST_MAPCLASS, ST_ENTER); 220 s->s_mapclass.map_init = host_map_init; 221 s->s_mapclass.map_lookup = maphostname; 222 } 223 224 /* dequote map */ 225 { 226 extern bool dequote_init(); 227 extern char *dequote_map(); 228 229 s = stab("dequote", ST_MAPCLASS, ST_ENTER); 230 s->s_mapclass.map_init = dequote_init; 231 s->s_mapclass.map_lookup = dequote_map; 232 } 233 234 # ifdef DBM_MAP 235 /* dbm file access */ 236 { 237 extern bool dbm_map_init(); 238 extern char *dbm_map_lookup(); 239 240 s = stab("dbm", ST_MAPCLASS, ST_ENTER); 241 s->s_mapclass.map_init = dbm_map_init; 242 s->s_mapclass.map_lookup = dbm_map_lookup; 243 } 244 # endif 245 246 # ifdef BTREE_MAP 247 /* new database file access -- btree files */ 248 { 249 extern bool bt_map_init(); 250 extern char *db_map_lookup(); 251 252 s = stab("btree", ST_MAPCLASS, ST_ENTER); 253 s->s_mapclass.map_init = bt_map_init; 254 s->s_mapclass.map_lookup = db_map_lookup; 255 } 256 # endif 257 258 # ifdef HASH_MAP 259 /* new database file access -- hash files */ 260 { 261 extern bool hash_map_init(); 262 extern char *db_map_lookup(); 263 264 s = stab("hash", ST_MAPCLASS, ST_ENTER); 265 s->s_mapclass.map_init = hash_map_init; 266 s->s_mapclass.map_lookup = db_map_lookup; 267 } 268 # endif 269 270 # ifdef NIS_MAP 271 /* NIS map access */ 272 { 273 extern bool nis_map_init(); 274 extern char *nis_map_lookup(); 275 276 s = stab("nis", ST_MAPCLASS, ST_ENTER); 277 s->s_mapclass.map_init = nis_map_init; 278 s->s_mapclass.map_lookup = nis_map_lookup; 279 } 280 # endif 281 282 # ifdef USERDB_MAP 283 /* user database */ 284 { 285 extern bool udb_map_init(); 286 extern char *udb_map_lookup(); 287 288 s = stab("udb", ST_MAPCLASS, ST_ENTER); 289 s->s_mapclass.map_init = udb_map_init; 290 s->s_mapclass.map_lookup = udb_map_lookup; 291 } 292 # endif 293 } 294 /* 295 ** HOST_MAP_INIT -- initialize host class structures 296 */ 297 298 bool 299 host_map_init(map, mapname, args) 300 MAP *map; 301 char *mapname; 302 char *args; 303 { 304 register char *p = args; 305 306 for (;;) 307 { 308 while (isascii(*p) && isspace(*p)) 309 p++; 310 if (*p != '-') 311 break; 312 switch (*++p) 313 { 314 case 'a': 315 map->map_app = ++p; 316 break; 317 } 318 while (*p != '\0' && !(isascii(*p) && isspace(*p))) 319 p++; 320 if (*p != '\0') 321 *p++ = '\0'; 322 } 323 if (map->map_app != NULL) 324 map->map_app = newstr(map->map_app); 325 return TRUE; 326 } 327 /* 328 ** SETUPMAILERS -- initialize default mailers 329 */ 330 331 setupmailers() 332 { 333 char buf[100]; 334 335 strcpy(buf, "prog, P=/bin/sh, F=lsD, A=sh -c $u"); 336 makemailer(buf); 337 338 strcpy(buf, "*file*, P=/dev/null, F=lsDEu, A=FILE"); 339 makemailer(buf); 340 341 strcpy(buf, "*include*, P=/dev/null, F=su, A=INCLUDE"); 342 makemailer(buf); 343 } 344 /* 345 ** GETRUID -- get real user id (V7) 346 */ 347 348 getruid() 349 { 350 if (OpMode == MD_DAEMON) 351 return (RealUid); 352 else 353 return (getuid()); 354 } 355 356 357 /* 358 ** GETRGID -- get real group id (V7). 359 */ 360 361 getrgid() 362 { 363 if (OpMode == MD_DAEMON) 364 return (RealGid); 365 else 366 return (getgid()); 367 } 368 /* 369 ** USERNAME -- return the user id of the logged in user. 370 ** 371 ** Parameters: 372 ** none. 373 ** 374 ** Returns: 375 ** The login name of the logged in user. 376 ** 377 ** Side Effects: 378 ** none. 379 ** 380 ** Notes: 381 ** The return value is statically allocated. 382 */ 383 384 char * 385 username() 386 { 387 static char *myname = NULL; 388 extern char *getlogin(); 389 register struct passwd *pw; 390 391 /* cache the result */ 392 if (myname == NULL) 393 { 394 myname = getlogin(); 395 if (myname == NULL || myname[0] == '\0') 396 { 397 pw = getpwuid(getruid()); 398 if (pw != NULL) 399 myname = newstr(pw->pw_name); 400 } 401 else 402 { 403 uid_t uid = getuid(); 404 405 myname = newstr(myname); 406 if ((pw = getpwnam(myname)) == NULL || 407 (uid != 0 && uid != pw->pw_uid)) 408 { 409 pw = getpwuid(uid); 410 if (pw != NULL) 411 myname = newstr(pw->pw_name); 412 } 413 } 414 if (myname == NULL || myname[0] == '\0') 415 { 416 syserr("554 Who are you?"); 417 myname = "postmaster"; 418 } 419 } 420 421 return (myname); 422 } 423 /* 424 ** TTYPATH -- Get the path of the user's tty 425 ** 426 ** Returns the pathname of the user's tty. Returns NULL if 427 ** the user is not logged in or if s/he has write permission 428 ** denied. 429 ** 430 ** Parameters: 431 ** none 432 ** 433 ** Returns: 434 ** pathname of the user's tty. 435 ** NULL if not logged in or write permission denied. 436 ** 437 ** Side Effects: 438 ** none. 439 ** 440 ** WARNING: 441 ** Return value is in a local buffer. 442 ** 443 ** Called By: 444 ** savemail 445 */ 446 447 char * 448 ttypath() 449 { 450 struct stat stbuf; 451 register char *pathn; 452 extern char *ttyname(); 453 extern char *getlogin(); 454 455 /* compute the pathname of the controlling tty */ 456 if ((pathn = ttyname(2)) == NULL && (pathn = ttyname(1)) == NULL && 457 (pathn = ttyname(0)) == NULL) 458 { 459 errno = 0; 460 return (NULL); 461 } 462 463 /* see if we have write permission */ 464 if (stat(pathn, &stbuf) < 0 || !bitset(02, stbuf.st_mode)) 465 { 466 errno = 0; 467 return (NULL); 468 } 469 470 /* see if the user is logged in */ 471 if (getlogin() == NULL) 472 return (NULL); 473 474 /* looks good */ 475 return (pathn); 476 } 477 /* 478 ** CHECKCOMPAT -- check for From and To person compatible. 479 ** 480 ** This routine can be supplied on a per-installation basis 481 ** to determine whether a person is allowed to send a message. 482 ** This allows restriction of certain types of internet 483 ** forwarding or registration of users. 484 ** 485 ** If the hosts are found to be incompatible, an error 486 ** message should be given using "usrerr" and 0 should 487 ** be returned. 488 ** 489 ** 'NoReturn' can be set to suppress the return-to-sender 490 ** function; this should be done on huge messages. 491 ** 492 ** Parameters: 493 ** to -- the person being sent to. 494 ** 495 ** Returns: 496 ** an exit status 497 ** 498 ** Side Effects: 499 ** none (unless you include the usrerr stuff) 500 */ 501 502 checkcompat(to, e) 503 register ADDRESS *to; 504 register ENVELOPE *e; 505 { 506 # ifdef lint 507 if (to == NULL) 508 to++; 509 # endif lint 510 # ifdef EXAMPLE_CODE 511 /* this code is intended as an example only */ 512 register STAB *s; 513 514 s = stab("arpa", ST_MAILER, ST_FIND); 515 if (s != NULL && e->e_from.q_mailer != LocalMailer && 516 to->q_mailer == s->s_mailer) 517 { 518 usrerr("553 No ARPA mail through this machine: see your system administration"); 519 /* NoReturn = TRUE; to supress return copy */ 520 return (EX_UNAVAILABLE); 521 } 522 # endif /* EXAMPLE_CODE */ 523 return (EX_OK); 524 } 525 /* 526 ** HOLDSIGS -- arrange to hold all signals 527 ** 528 ** Parameters: 529 ** none. 530 ** 531 ** Returns: 532 ** none. 533 ** 534 ** Side Effects: 535 ** Arranges that signals are held. 536 */ 537 538 holdsigs() 539 { 540 } 541 /* 542 ** RLSESIGS -- arrange to release all signals 543 ** 544 ** This undoes the effect of holdsigs. 545 ** 546 ** Parameters: 547 ** none. 548 ** 549 ** Returns: 550 ** none. 551 ** 552 ** Side Effects: 553 ** Arranges that signals are released. 554 */ 555 556 rlsesigs() 557 { 558 } 559 /* 560 ** GETLA -- get the current load average 561 ** 562 ** This code stolen from la.c. 563 ** 564 ** Parameters: 565 ** none. 566 ** 567 ** Returns: 568 ** The current load average as an integer. 569 ** 570 ** Side Effects: 571 ** none. 572 */ 573 574 /* try to guess what style of load average we have */ 575 #define LA_ZERO 1 /* always return load average as zero */ 576 #define LA_INT 2 /* read kmem for avenrun; interpret as int */ 577 #define LA_FLOAT 3 /* read kmem for avenrun; interpret as float */ 578 #define LA_SUBR 4 /* call getloadavg */ 579 580 #ifndef LA_TYPE 581 # if defined(sun) 582 # define LA_TYPE LA_INT 583 # endif 584 # if defined(mips) || defined(__alpha) 585 /* Ultrix or OSF/1 or RISC/os */ 586 # define LA_TYPE LA_INT 587 # define LA_AVENRUN "avenrun" 588 # endif 589 # if defined(__hpux) 590 # define LA_TYPE LA_FLOAT 591 # define LA_AVENRUN "avenrun" 592 # endif 593 594 # ifndef LA_TYPE 595 # if defined(SYSTEM5) 596 # define LA_TYPE LA_INT 597 # define LA_AVENRUN "avenrun" 598 # else 599 # if defined(BSD) 600 # define LA_TYPE LA_SUBR 601 # else 602 # define LA_TYPE LA_ZERO 603 # endif 604 # endif 605 # endif 606 #endif 607 608 #if (LA_TYPE == LA_INT) || (LA_TYPE == LA_FLOAT) 609 610 #include <nlist.h> 611 612 #ifndef LA_AVENRUN 613 #define LA_AVENRUN "_avenrun" 614 #endif 615 616 /* _PATH_UNIX should be defined in <paths.h> */ 617 #ifndef _PATH_UNIX 618 # if defined(__hpux) 619 # define _PATH_UNIX "/hp-ux" 620 # endif 621 # if defined(mips) && !defined(ultrix) 622 /* powerful RISC/os */ 623 # define _PATH_UNIX "/unix" 624 # endif 625 # if defined(SYSTEM5) 626 # ifndef _PATH_UNIX 627 # define _PATH_UNIX "/unix" 628 # endif 629 # endif 630 # ifndef _PATH_UNIX 631 # define _PATH_UNIX "/vmunix" 632 # endif 633 #endif 634 635 struct nlist Nl[] = 636 { 637 { LA_AVENRUN }, 638 #define X_AVENRUN 0 639 { 0 }, 640 }; 641 642 #if defined(unixpc) 643 # define FSHIFT 5 644 #endif 645 646 #if defined(__alpha) 647 # define FSHIFT 10 648 #endif 649 650 #if (LA_TYPE == LA_INT) && !defined(FSHIFT) 651 # define FSHIFT 8 652 #endif 653 #if (LA_TYPE == LA_INT) && !defined(FSCALE) 654 # define FSCALE (1 << FSHIFT) 655 #endif 656 657 getla() 658 { 659 static int kmem = -1; 660 #if LA_TYPE == LA_INT 661 long avenrun[3]; 662 #else 663 double avenrun[3]; 664 #endif 665 extern off_t lseek(); 666 extern char *errstring(); 667 extern int errno; 668 669 if (kmem < 0) 670 { 671 kmem = open("/dev/kmem", 0, 0); 672 if (kmem < 0) 673 { 674 if (tTd(3, 1)) 675 printf("getla: open(/dev/kmem): %s\n", 676 errstring(errno)); 677 return (-1); 678 } 679 (void) fcntl(kmem, F_SETFD, 1); 680 if (nlist(_PATH_UNIX, Nl) < 0) 681 { 682 if (tTd(3, 1)) 683 printf("getla: nlist(%s): %s\n", _PATH_UNIX, 684 errstring(errno)); 685 return (-1); 686 } 687 if (Nl[X_AVENRUN].n_value == 0) 688 { 689 if (tTd(3, 1)) 690 printf("getla: nlist(%s, %s) ==> 0\n", 691 _PATH_UNIX, LA_AVENRUN); 692 return (-1); 693 } 694 } 695 if (tTd(3, 20)) 696 printf("getla: symbol address = %#x\n", Nl[X_AVENRUN].n_value); 697 if (lseek(kmem, (off_t) Nl[X_AVENRUN].n_value, 0) == -1 || 698 read(kmem, (char *) avenrun, sizeof(avenrun)) < sizeof(avenrun)) 699 { 700 /* thank you Ian */ 701 if (tTd(3, 1)) 702 printf("getla: lseek or read: %s\n", errstring(errno)); 703 return (-1); 704 } 705 #if LA_TYPE == LA_INT 706 if (tTd(3, 5)) 707 { 708 printf("getla: avenrun = %d", avenrun[0]); 709 if (tTd(3, 15)) 710 printf(", %d, %d", avenrun[1], avenrun[2]); 711 printf("\n"); 712 } 713 if (tTd(3, 1)) 714 printf("getla: %d\n", (int) (avenrun[0] + FSCALE/2) >> FSHIFT); 715 return ((int) (avenrun[0] + FSCALE/2) >> FSHIFT); 716 #else 717 if (tTd(3, 5)) 718 { 719 printf("getla: avenrun = %g", avenrun[0]); 720 if (tTd(3, 15)) 721 printf(", %g, %g", avenrun[1], avenrun[2]); 722 printf("\n"); 723 } 724 if (tTd(3, 1)) 725 printf("getla: %d\n", (int) (avenrun[0] +0.5)); 726 return ((int) (avenrun[0] + 0.5)); 727 #endif 728 } 729 730 #else 731 #if LA_TYPE == LA_SUBR 732 733 getla() 734 { 735 double avenrun[3]; 736 737 if (getloadavg(avenrun, sizeof(avenrun) / sizeof(avenrun[0])) < 0) 738 { 739 if (tTd(3, 1)) 740 perror("getla: getloadavg failed:"); 741 return (-1); 742 } 743 if (tTd(3, 1)) 744 printf("getla: %d\n", (int) (avenrun[0] +0.5)); 745 return ((int) (avenrun[0] + 0.5)); 746 } 747 748 #else 749 750 getla() 751 { 752 if (tTd(3, 1)) 753 printf("getla: ZERO\n"); 754 return (0); 755 } 756 757 #endif 758 #endif 759 /* 760 ** SHOULDQUEUE -- should this message be queued or sent? 761 ** 762 ** Compares the message cost to the load average to decide. 763 ** 764 ** Parameters: 765 ** pri -- the priority of the message in question. 766 ** ctime -- the message creation time. 767 ** 768 ** Returns: 769 ** TRUE -- if this message should be queued up for the 770 ** time being. 771 ** FALSE -- if the load is low enough to send this message. 772 ** 773 ** Side Effects: 774 ** none. 775 */ 776 777 bool 778 shouldqueue(pri, ctime) 779 long pri; 780 time_t ctime; 781 { 782 if (CurrentLA < QueueLA) 783 return (FALSE); 784 if (CurrentLA >= RefuseLA) 785 return (TRUE); 786 return (pri > (QueueFactor / (CurrentLA - QueueLA + 1))); 787 } 788 /* 789 ** REFUSECONNECTIONS -- decide if connections should be refused 790 ** 791 ** Parameters: 792 ** none. 793 ** 794 ** Returns: 795 ** TRUE if incoming SMTP connections should be refused 796 ** (for now). 797 ** FALSE if we should accept new work. 798 ** 799 ** Side Effects: 800 ** none. 801 */ 802 803 bool 804 refuseconnections() 805 { 806 #ifdef XLA 807 if (!xla_smtp_ok()) 808 return TRUE; 809 #endif 810 811 /* this is probably too simplistic */ 812 return (CurrentLA >= RefuseLA); 813 } 814 /* 815 ** SETPROCTITLE -- set process title for ps 816 ** 817 ** Parameters: 818 ** fmt -- a printf style format string. 819 ** a, b, c -- possible parameters to fmt. 820 ** 821 ** Returns: 822 ** none. 823 ** 824 ** Side Effects: 825 ** Clobbers argv of our main procedure so ps(1) will 826 ** display the title. 827 */ 828 829 #ifdef SETPROCTITLE 830 # ifdef __hpux 831 # include <sys/pstat.h> 832 # endif 833 #endif 834 835 /*VARARGS1*/ 836 #ifdef __STDC__ 837 setproctitle(char *fmt, ...) 838 #else 839 setproctitle(fmt, va_alist) 840 char *fmt; 841 va_dcl 842 #endif 843 { 844 # ifdef SETPROCTITLE 845 register char *p; 846 register int i; 847 char buf[MAXLINE]; 848 VA_LOCAL_DECL 849 # ifdef __hpux 850 union pstun pst; 851 # endif 852 extern char **Argv; 853 extern char *LastArgv; 854 855 p = buf; 856 857 /* print sendmail: heading for grep */ 858 (void) strcpy(p, "sendmail: "); 859 p += strlen(p); 860 861 /* print the argument string */ 862 VA_START(fmt); 863 (void) vsprintf(p, fmt, ap); 864 VA_END; 865 866 i = strlen(buf); 867 868 # ifdef __hpux 869 pst.pst_command = buf; 870 pstat(PSTAT_SETCMD, pst, i, 0, 0); 871 # else 872 873 if (i > LastArgv - Argv[0] - 2) 874 { 875 i = LastArgv - Argv[0] - 2; 876 buf[i] = '\0'; 877 } 878 (void) strcpy(Argv[0], buf); 879 p = &Argv[0][i]; 880 while (p < LastArgv) 881 *p++ = ' '; 882 # endif 883 # endif /* SETPROCTITLE */ 884 } 885 /* 886 ** REAPCHILD -- pick up the body of my child, lest it become a zombie 887 ** 888 ** Parameters: 889 ** none. 890 ** 891 ** Returns: 892 ** none. 893 ** 894 ** Side Effects: 895 ** Picks up extant zombies. 896 */ 897 898 # include <sys/wait.h> 899 900 void 901 reapchild() 902 { 903 # ifdef WNOHANG 904 union wait status; 905 906 while (wait3((int *)&status, WNOHANG, (struct rusage *) NULL) > 0) 907 continue; 908 # else /* WNOHANG */ 909 auto int status; 910 911 while (wait((int *)&status) > 0) 912 continue; 913 # endif /* WNOHANG */ 914 # ifdef SYSTEM5 915 (void) signal(SIGCHLD, reapchild); 916 # endif 917 } 918 /* 919 ** UNSETENV -- remove a variable from the environment 920 ** 921 ** Not needed on newer systems. 922 ** 923 ** Parameters: 924 ** name -- the string name of the environment variable to be 925 ** deleted from the current environment. 926 ** 927 ** Returns: 928 ** none. 929 ** 930 ** Globals: 931 ** environ -- a pointer to the current environment. 932 ** 933 ** Side Effects: 934 ** Modifies environ. 935 */ 936 937 #ifdef UNSETENV 938 939 void 940 unsetenv(name) 941 char *name; 942 { 943 extern char **environ; 944 register char **pp; 945 int len = strlen(name); 946 947 for (pp = environ; *pp != NULL; pp++) 948 { 949 if (strncmp(name, *pp, len) == 0 && 950 ((*pp)[len] == '=' || (*pp)[len] == '\0')) 951 break; 952 } 953 954 for (; *pp != NULL; pp++) 955 *pp = pp[1]; 956 } 957 958 #endif /* UNSETENV */ 959 /* 960 ** GETDTABLESIZE -- return number of file descriptors 961 ** 962 ** Only on non-BSD systems 963 ** 964 ** Parameters: 965 ** none 966 ** 967 ** Returns: 968 ** size of file descriptor table 969 ** 970 ** Side Effects: 971 ** none 972 */ 973 974 #ifdef SYSTEM5 975 976 int 977 getdtablesize() 978 { 979 # ifdef _SC_OPEN_MAX 980 return sysconf(_SC_OPEN_MAX); 981 # else 982 return NOFILE; 983 # endif 984 } 985 986 #endif 987 /* 988 ** UNAME -- get the UUCP name of this system. 989 */ 990 991 #ifndef HASUNAME 992 993 int 994 uname(name) 995 struct utsname *name; 996 { 997 FILE *file; 998 char *n; 999 1000 name->nodename[0] = '\0'; 1001 1002 /* try /etc/whoami -- one line with the node name */ 1003 if ((file = fopen("/etc/whoami", "r")) != NULL) 1004 { 1005 (void) fgets(name->nodename, NODE_LENGTH + 1, file); 1006 (void) fclose(file); 1007 n = strchr(name->nodename, '\n'); 1008 if (n != NULL) 1009 *n = '\0'; 1010 if (name->nodename[0] != '\0') 1011 return (0); 1012 } 1013 1014 /* try /usr/include/whoami.h -- has a #define somewhere */ 1015 if ((file = fopen("/usr/include/whoami.h", "r")) != NULL) 1016 { 1017 char buf[MAXLINE]; 1018 1019 while (fgets(buf, MAXLINE, file) != NULL) 1020 if (sscanf(buf, "#define sysname \"%*[^\"]\"", 1021 NODE_LENGTH, name->nodename) > 0) 1022 break; 1023 (void) fclose(file); 1024 if (name->nodename[0] != '\0') 1025 return (0); 1026 } 1027 1028 #ifdef TRUST_POPEN 1029 /* 1030 ** Popen is known to have security holes. 1031 */ 1032 1033 /* try uuname -l to return local name */ 1034 if ((file = popen("uuname -l", "r")) != NULL) 1035 { 1036 (void) fgets(name, NODE_LENGTH + 1, file); 1037 (void) pclose(file); 1038 n = strchr(name, '\n'); 1039 if (n != NULL) 1040 *n = '\0'; 1041 if (name->nodename[0] != '\0') 1042 return (0); 1043 } 1044 #endif 1045 1046 return (-1); 1047 } 1048 #endif /* HASUNAME */ 1049 /* 1050 ** INITGROUPS -- initialize groups 1051 ** 1052 ** Stub implementation for System V style systems 1053 */ 1054 1055 #ifndef HASINITGROUPS 1056 # if !defined(SYSTEM5) || defined(__hpux) 1057 # define HASINITGROUPS 1058 # endif 1059 #endif 1060 1061 #ifndef HASINITGROUPS 1062 1063 initgroups(name, basegid) 1064 char *name; 1065 int basegid; 1066 { 1067 return 0; 1068 } 1069 1070 #endif 1071 /* 1072 ** SETSID -- set session id (for non-POSIX systems) 1073 */ 1074 1075 #ifndef HASSETSID 1076 1077 setsid() 1078 { 1079 # ifdef SYSTEM5 1080 setpgrp(); 1081 # endif 1082 } 1083 1084 #endif 1085 /* 1086 ** ENOUGHSPACE -- check to see if there is enough free space on the queue fs 1087 ** 1088 ** Only implemented if you have statfs. 1089 ** 1090 ** Parameters: 1091 ** msize -- the size to check against. If zero, we don't yet 1092 ** know how big the message will be, so just check for 1093 ** a "reasonable" amount. 1094 ** 1095 ** Returns: 1096 ** TRUE if there is enough space. 1097 ** FALSE otherwise. 1098 */ 1099 1100 #ifndef HASSTATFS 1101 # if defined(BSD4_4) || defined(__osf__) 1102 # define HASSTATFS 1103 # endif 1104 #endif 1105 1106 #ifdef HASSTATFS 1107 # undef HASUSTAT 1108 #endif 1109 1110 #if defined(HASUSTAT) 1111 # include <ustat.h> 1112 #endif 1113 1114 #ifdef HASSTATFS 1115 # if defined(sgi) || defined(apollo) 1116 # include <sys/statfs.h> 1117 # else 1118 # if defined(sun) || defined(__hpux) 1119 # include <sys/vfs.h> 1120 # else 1121 # include <sys/mount.h> 1122 # endif 1123 # endif 1124 #endif 1125 1126 bool 1127 enoughspace(msize) 1128 long msize; 1129 { 1130 #if defined(HASSTATFS) || defined(HASUSTAT) 1131 # if defined(HASUSTAT) 1132 struct ustat fs; 1133 struct stat statbuf; 1134 # define FSBLOCKSIZE DEV_BSIZE 1135 # define f_bavail f_tfree 1136 # else 1137 # if defined(ultrix) 1138 struct fs_data fs; 1139 # define f_bavail fd_bfreen 1140 # define FSBLOCKSIZE fs.fd_bsize 1141 # else 1142 struct statfs fs; 1143 # define FSBLOCKSIZE fs.f_bsize 1144 # endif 1145 # endif 1146 long blocksneeded; 1147 extern int errno; 1148 extern char *errstring(); 1149 1150 if (MinBlocksFree <= 0 && msize <= 0) 1151 { 1152 if (tTd(4, 80)) 1153 printf("enoughspace: no threshold\n"); 1154 return TRUE; 1155 } 1156 1157 # if defined(HASUSTAT) 1158 if (stat(QueueDir, &statbuf) == 0 && ustat(statbuf.st_dev, &fs) == 0) 1159 # else 1160 # if defined(sgi) || defined(apollo) 1161 if (statfs(QueueDir, &fs, sizeof fs, 0) == 0) 1162 # else 1163 # if defined(ultrix) 1164 if (statfs(QueueDir, &fs) > 0) 1165 # else 1166 if (statfs(QueueDir, &fs) == 0) 1167 # endif 1168 # endif 1169 # endif 1170 { 1171 if (tTd(4, 80)) 1172 printf("enoughspace: bavail=%ld, need=%ld\n", 1173 fs.f_bavail, msize); 1174 1175 /* convert msize to block count */ 1176 msize = msize / FSBLOCKSIZE + 1; 1177 if (MinBlocksFree >= 0) 1178 msize += MinBlocksFree; 1179 1180 if (fs.f_bavail < msize) 1181 { 1182 #ifdef LOG 1183 if (LogLevel > 0) 1184 syslog(LOG_ALERT, "%s: low on space (have %ld, need %ld)", 1185 QueueDir, fs.f_bavail, msize); 1186 #endif 1187 return FALSE; 1188 } 1189 } 1190 else if (tTd(4, 80)) 1191 printf("enoughspace failure: min=%ld, need=%ld: %s\n", 1192 MinBlocksFree, msize, errstring(errno)); 1193 #endif 1194 return TRUE; 1195 } 1196 /* 1197 ** TRANSIENTERROR -- tell if an error code indicates a transient failure 1198 ** 1199 ** This looks at an errno value and tells if this is likely to 1200 ** go away if retried later. 1201 ** 1202 ** Parameters: 1203 ** err -- the errno code to classify. 1204 ** 1205 ** Returns: 1206 ** TRUE if this is probably transient. 1207 ** FALSE otherwise. 1208 */ 1209 1210 bool 1211 transienterror(err) 1212 int err; 1213 { 1214 switch (err) 1215 { 1216 case EIO: /* I/O error */ 1217 case ENXIO: /* Device not configured */ 1218 case EAGAIN: /* Resource temporarily unavailable */ 1219 case ENOMEM: /* Cannot allocate memory */ 1220 case ENODEV: /* Operation not supported by device */ 1221 case ENFILE: /* Too many open files in system */ 1222 case EMFILE: /* Too many open files */ 1223 case ENOSPC: /* No space left on device */ 1224 #ifdef ETIMEDOUT 1225 case ETIMEDOUT: /* Connection timed out */ 1226 #endif 1227 #ifdef ESTALE 1228 case ESTALE: /* Stale NFS file handle */ 1229 #endif 1230 #ifdef ENETDOWN 1231 case ENETDOWN: /* Network is down */ 1232 #endif 1233 #ifdef ENETUNREACH 1234 case ENETUNREACH: /* Network is unreachable */ 1235 #endif 1236 #ifdef ENETRESET 1237 case ENETRESET: /* Network dropped connection on reset */ 1238 #endif 1239 #ifdef ECONNABORTED 1240 case ECONNABORTED: /* Software caused connection abort */ 1241 #endif 1242 #ifdef ECONNRESET 1243 case ECONNRESET: /* Connection reset by peer */ 1244 #endif 1245 #ifdef ENOBUFS 1246 case ENOBUFS: /* No buffer space available */ 1247 #endif 1248 #ifdef ESHUTDOWN 1249 case ESHUTDOWN: /* Can't send after socket shutdown */ 1250 #endif 1251 #ifdef ECONNREFUSED 1252 case ECONNREFUSED: /* Connection refused */ 1253 #endif 1254 #ifdef EHOSTDOWN 1255 case EHOSTDOWN: /* Host is down */ 1256 #endif 1257 #ifdef EHOSTUNREACH 1258 case EHOSTUNREACH: /* No route to host */ 1259 #endif 1260 #ifdef EDQUOT 1261 case EDQUOT: /* Disc quota exceeded */ 1262 #endif 1263 #ifdef EPROCLIM 1264 case EPROCLIM: /* Too many processes */ 1265 #endif 1266 #ifdef EUSERS 1267 case EUSERS: /* Too many users */ 1268 #endif 1269 #ifdef EDEADLK 1270 case EDEADLK: /* Resource deadlock avoided */ 1271 #endif 1272 #ifdef EISCONN 1273 case EISCONN: /* Socket already connected */ 1274 #endif 1275 #ifdef EINPROGRESS 1276 case EINPROGRESS: /* Operation now in progress */ 1277 #endif 1278 #ifdef EALREADY 1279 case EALREADY: /* Operation already in progress */ 1280 #endif 1281 #ifdef EADDRINUSE 1282 case EADDRINUSE: /* Address already in use */ 1283 #endif 1284 #ifdef EADDRNOTAVAIL 1285 case EADDRNOTAVAIL: /* Can't assign requested address */ 1286 #endif 1287 #ifdef ENOSR 1288 case ENOSR: /* Out of streams resources */ 1289 #endif 1290 return TRUE; 1291 } 1292 1293 /* nope, must be permanent */ 1294 return FALSE; 1295 } 1296 /* 1297 ** LOCKFILE -- lock a file using flock or (shudder) lockf 1298 ** 1299 ** Parameters: 1300 ** fd -- the file descriptor of the file. 1301 ** filename -- the file name (for error messages). 1302 ** type -- type of the lock. Bits can be: 1303 ** LOCK_EX -- exclusive lock. 1304 ** LOCK_NB -- non-blocking. 1305 ** 1306 ** Returns: 1307 ** TRUE if the lock was acquired. 1308 ** FALSE otherwise. 1309 */ 1310 1311 bool 1312 lockfile(fd, filename, type) 1313 int fd; 1314 char *filename; 1315 int type; 1316 { 1317 # ifdef LOCKF 1318 int action; 1319 struct flock lfd; 1320 1321 if (bitset(LOCK_UN, type)) 1322 lfd.l_type = F_UNLCK; 1323 else if (bitset(LOCK_EX, type)) 1324 lfd.l_type = F_WRLCK; 1325 else 1326 lfd.l_type = F_RDLCK; 1327 1328 if (bitset(LOCK_NB, type)) 1329 action = F_SETLK; 1330 else 1331 action = F_SETLKW; 1332 1333 lfd.l_whence = lfd.l_start = lfd.l_len = 0; 1334 1335 if (fcntl(fd, action, &lfd) >= 0) 1336 return TRUE; 1337 1338 if (!bitset(LOCK_NB, type) || (errno != EACCES && errno != EAGAIN)) 1339 syserr("cannot lockf(%s, %o)", filename, type); 1340 # else 1341 if (flock(fd, type) >= 0) 1342 return TRUE; 1343 1344 if (!bitset(LOCK_NB, type) || errno != EWOULDBLOCK) 1345 syserr("cannot flock(%s, %o)", filename, type); 1346 # endif 1347 return FALSE; 1348 } 1349