17c478bd9Sstevel@tonic-gate /* 2*445f2479Sjbeck * Copyright (c) 1998-2006 Sendmail, Inc. and its suppliers. 37c478bd9Sstevel@tonic-gate * All rights reserved. 47c478bd9Sstevel@tonic-gate * Copyright (c) 1983, 1995-1997 Eric P. Allman. All rights reserved. 57c478bd9Sstevel@tonic-gate * Copyright (c) 1988, 1993 67c478bd9Sstevel@tonic-gate * The Regents of the University of California. All rights reserved. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * By using this file, you agree to the terms and conditions set 97c478bd9Sstevel@tonic-gate * forth in the LICENSE file which can be found at the top level of 107c478bd9Sstevel@tonic-gate * the sendmail distribution. 117c478bd9Sstevel@tonic-gate * 127c478bd9Sstevel@tonic-gate */ 137c478bd9Sstevel@tonic-gate 147c478bd9Sstevel@tonic-gate /* 157c478bd9Sstevel@tonic-gate * Copyright 1999-2004 Sun Microsystems, Inc. All rights reserved. 167c478bd9Sstevel@tonic-gate * Use is subject to license terms. 177c478bd9Sstevel@tonic-gate */ 187c478bd9Sstevel@tonic-gate 197c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 207c478bd9Sstevel@tonic-gate 217c478bd9Sstevel@tonic-gate #include <sendmail.h> 227c478bd9Sstevel@tonic-gate 23*445f2479Sjbeck SM_RCSID("@(#)$Id: conf.c,v 8.1081 2006/02/24 02:21:53 ca Exp $") 247c478bd9Sstevel@tonic-gate SM_IDSTR(i2, "%W% (Sun) %G%") 257c478bd9Sstevel@tonic-gate 267c478bd9Sstevel@tonic-gate #include <sendmail/pathnames.h> 277c478bd9Sstevel@tonic-gate #if NEWDB 287c478bd9Sstevel@tonic-gate # include "sm/bdb.h" 297c478bd9Sstevel@tonic-gate #endif /* NEWDB */ 307c478bd9Sstevel@tonic-gate 3149218d4fSjbeck #ifdef DEC 3249218d4fSjbeck # if NETINET6 3349218d4fSjbeck /* for the IPv6 device lookup */ 3449218d4fSjbeck # define _SOCKADDR_LEN 3549218d4fSjbeck # include <macros.h> 3649218d4fSjbeck # endif /* NETINET6 */ 3749218d4fSjbeck #endif /* DEC */ 3849218d4fSjbeck 397c478bd9Sstevel@tonic-gate # include <sys/ioctl.h> 407c478bd9Sstevel@tonic-gate # include <sys/param.h> 417c478bd9Sstevel@tonic-gate 427c478bd9Sstevel@tonic-gate #include <limits.h> 437c478bd9Sstevel@tonic-gate #if NETINET || NETINET6 447c478bd9Sstevel@tonic-gate # include <arpa/inet.h> 457c478bd9Sstevel@tonic-gate #endif /* NETINET || NETINET6 */ 467c478bd9Sstevel@tonic-gate #if HASULIMIT && defined(HPUX11) 477c478bd9Sstevel@tonic-gate # include <ulimit.h> 487c478bd9Sstevel@tonic-gate #endif /* HASULIMIT && defined(HPUX11) */ 497c478bd9Sstevel@tonic-gate 507c478bd9Sstevel@tonic-gate static void setupmaps __P((void)); 517c478bd9Sstevel@tonic-gate static void setupmailers __P((void)); 527c478bd9Sstevel@tonic-gate static void setupqueues __P((void)); 537c478bd9Sstevel@tonic-gate static int get_num_procs_online __P((void)); 547c478bd9Sstevel@tonic-gate static int add_hostnames __P((SOCKADDR *)); 557c478bd9Sstevel@tonic-gate 567c478bd9Sstevel@tonic-gate #if NETINET6 && NEEDSGETIPNODE 577c478bd9Sstevel@tonic-gate static struct hostent *getipnodebyname __P((char *, int, int, int *)); 587c478bd9Sstevel@tonic-gate static struct hostent *getipnodebyaddr __P((char *, int, int, int *)); 597c478bd9Sstevel@tonic-gate #endif /* NETINET6 && NEEDSGETIPNODE */ 607c478bd9Sstevel@tonic-gate 617c478bd9Sstevel@tonic-gate 627c478bd9Sstevel@tonic-gate /* 637c478bd9Sstevel@tonic-gate ** CONF.C -- Sendmail Configuration Tables. 647c478bd9Sstevel@tonic-gate ** 657c478bd9Sstevel@tonic-gate ** Defines the configuration of this installation. 667c478bd9Sstevel@tonic-gate ** 677c478bd9Sstevel@tonic-gate ** Configuration Variables: 687c478bd9Sstevel@tonic-gate ** HdrInfo -- a table describing well-known header fields. 697c478bd9Sstevel@tonic-gate ** Each entry has the field name and some flags, 707c478bd9Sstevel@tonic-gate ** which are described in sendmail.h. 717c478bd9Sstevel@tonic-gate ** 727c478bd9Sstevel@tonic-gate ** Notes: 737c478bd9Sstevel@tonic-gate ** I have tried to put almost all the reasonable 747c478bd9Sstevel@tonic-gate ** configuration information into the configuration 757c478bd9Sstevel@tonic-gate ** file read at runtime. My intent is that anything 767c478bd9Sstevel@tonic-gate ** here is a function of the version of UNIX you 777c478bd9Sstevel@tonic-gate ** are running, or is really static -- for example 787c478bd9Sstevel@tonic-gate ** the headers are a superset of widely used 797c478bd9Sstevel@tonic-gate ** protocols. If you find yourself playing with 807c478bd9Sstevel@tonic-gate ** this file too much, you may be making a mistake! 817c478bd9Sstevel@tonic-gate */ 827c478bd9Sstevel@tonic-gate 837c478bd9Sstevel@tonic-gate 847c478bd9Sstevel@tonic-gate /* 857c478bd9Sstevel@tonic-gate ** Header info table 867c478bd9Sstevel@tonic-gate ** Final (null) entry contains the flags used for any other field. 877c478bd9Sstevel@tonic-gate ** 887c478bd9Sstevel@tonic-gate ** Not all of these are actually handled specially by sendmail 897c478bd9Sstevel@tonic-gate ** at this time. They are included as placeholders, to let 907c478bd9Sstevel@tonic-gate ** you know that "someday" I intend to have sendmail do 917c478bd9Sstevel@tonic-gate ** something with them. 927c478bd9Sstevel@tonic-gate */ 937c478bd9Sstevel@tonic-gate 947c478bd9Sstevel@tonic-gate struct hdrinfo HdrInfo[] = 957c478bd9Sstevel@tonic-gate { 967c478bd9Sstevel@tonic-gate /* originator fields, most to least significant */ 977c478bd9Sstevel@tonic-gate { "resent-sender", H_FROM|H_RESENT, NULL }, 987c478bd9Sstevel@tonic-gate { "resent-from", H_FROM|H_RESENT, NULL }, 997c478bd9Sstevel@tonic-gate { "resent-reply-to", H_FROM|H_RESENT, NULL }, 1007c478bd9Sstevel@tonic-gate { "sender", H_FROM, NULL }, 1017c478bd9Sstevel@tonic-gate { "from", H_FROM, NULL }, 1027c478bd9Sstevel@tonic-gate { "reply-to", H_FROM, NULL }, 1037c478bd9Sstevel@tonic-gate { "errors-to", H_FROM|H_ERRORSTO, NULL }, 1047c478bd9Sstevel@tonic-gate { "full-name", H_ACHECK, NULL }, 1057c478bd9Sstevel@tonic-gate { "return-receipt-to", H_RECEIPTTO, NULL }, 1067c478bd9Sstevel@tonic-gate { "delivery-receipt-to", H_RECEIPTTO, NULL }, 1077c478bd9Sstevel@tonic-gate { "disposition-notification-to", H_FROM, NULL }, 1087c478bd9Sstevel@tonic-gate 1097c478bd9Sstevel@tonic-gate /* destination fields */ 1107c478bd9Sstevel@tonic-gate { "to", H_RCPT, NULL }, 1117c478bd9Sstevel@tonic-gate { "resent-to", H_RCPT|H_RESENT, NULL }, 1127c478bd9Sstevel@tonic-gate { "cc", H_RCPT, NULL }, 1137c478bd9Sstevel@tonic-gate { "resent-cc", H_RCPT|H_RESENT, NULL }, 1147c478bd9Sstevel@tonic-gate { "bcc", H_RCPT|H_BCC, NULL }, 1157c478bd9Sstevel@tonic-gate { "resent-bcc", H_RCPT|H_BCC|H_RESENT, NULL }, 1167c478bd9Sstevel@tonic-gate { "apparently-to", H_RCPT, NULL }, 1177c478bd9Sstevel@tonic-gate 1187c478bd9Sstevel@tonic-gate /* message identification and control */ 1197c478bd9Sstevel@tonic-gate { "message-id", 0, NULL }, 1207c478bd9Sstevel@tonic-gate { "resent-message-id", H_RESENT, NULL }, 1217c478bd9Sstevel@tonic-gate { "message", H_EOH, NULL }, 1227c478bd9Sstevel@tonic-gate { "text", H_EOH, NULL }, 1237c478bd9Sstevel@tonic-gate 1247c478bd9Sstevel@tonic-gate /* date fields */ 1257c478bd9Sstevel@tonic-gate { "date", 0, NULL }, 1267c478bd9Sstevel@tonic-gate { "resent-date", H_RESENT, NULL }, 1277c478bd9Sstevel@tonic-gate 1287c478bd9Sstevel@tonic-gate /* trace fields */ 1297c478bd9Sstevel@tonic-gate { "received", H_TRACE|H_FORCE, NULL }, 1307c478bd9Sstevel@tonic-gate { "x400-received", H_TRACE|H_FORCE, NULL }, 1317c478bd9Sstevel@tonic-gate { "via", H_TRACE|H_FORCE, NULL }, 1327c478bd9Sstevel@tonic-gate { "mail-from", H_TRACE|H_FORCE, NULL }, 1337c478bd9Sstevel@tonic-gate 1347c478bd9Sstevel@tonic-gate /* miscellaneous fields */ 1357c478bd9Sstevel@tonic-gate { "comments", H_FORCE|H_ENCODABLE, NULL }, 1367c478bd9Sstevel@tonic-gate { "return-path", H_FORCE|H_ACHECK|H_BINDLATE, NULL }, 1377c478bd9Sstevel@tonic-gate { "content-transfer-encoding", H_CTE, NULL }, 1387c478bd9Sstevel@tonic-gate { "content-type", H_CTYPE, NULL }, 1397c478bd9Sstevel@tonic-gate { "content-length", H_ACHECK, NULL }, 1407c478bd9Sstevel@tonic-gate { "subject", H_ENCODABLE, NULL }, 1417c478bd9Sstevel@tonic-gate { "x-authentication-warning", H_FORCE, NULL }, 1427c478bd9Sstevel@tonic-gate 1437c478bd9Sstevel@tonic-gate { NULL, 0, NULL } 1447c478bd9Sstevel@tonic-gate }; 1457c478bd9Sstevel@tonic-gate 1467c478bd9Sstevel@tonic-gate 1477c478bd9Sstevel@tonic-gate 1487c478bd9Sstevel@tonic-gate /* 1497c478bd9Sstevel@tonic-gate ** Privacy values 1507c478bd9Sstevel@tonic-gate */ 1517c478bd9Sstevel@tonic-gate 1527c478bd9Sstevel@tonic-gate struct prival PrivacyValues[] = 1537c478bd9Sstevel@tonic-gate { 1547c478bd9Sstevel@tonic-gate { "public", PRIV_PUBLIC }, 1557c478bd9Sstevel@tonic-gate { "needmailhelo", PRIV_NEEDMAILHELO }, 1567c478bd9Sstevel@tonic-gate { "needexpnhelo", PRIV_NEEDEXPNHELO }, 1577c478bd9Sstevel@tonic-gate { "needvrfyhelo", PRIV_NEEDVRFYHELO }, 1587c478bd9Sstevel@tonic-gate { "noexpn", PRIV_NOEXPN }, 1597c478bd9Sstevel@tonic-gate { "novrfy", PRIV_NOVRFY }, 1607c478bd9Sstevel@tonic-gate { "restrictexpand", PRIV_RESTRICTEXPAND }, 1617c478bd9Sstevel@tonic-gate { "restrictmailq", PRIV_RESTRICTMAILQ }, 1627c478bd9Sstevel@tonic-gate { "restrictqrun", PRIV_RESTRICTQRUN }, 1637c478bd9Sstevel@tonic-gate { "noetrn", PRIV_NOETRN }, 1647c478bd9Sstevel@tonic-gate { "noverb", PRIV_NOVERB }, 1657c478bd9Sstevel@tonic-gate { "authwarnings", PRIV_AUTHWARNINGS }, 1667c478bd9Sstevel@tonic-gate { "noreceipts", PRIV_NORECEIPTS }, 1677c478bd9Sstevel@tonic-gate { "nobodyreturn", PRIV_NOBODYRETN }, 1687c478bd9Sstevel@tonic-gate { "goaway", PRIV_GOAWAY }, 1697c478bd9Sstevel@tonic-gate #if _FFR_PRIV_NOACTUALRECIPIENT 1707c478bd9Sstevel@tonic-gate { "noactualrecipient", PRIV_NOACTUALRECIPIENT }, 1717c478bd9Sstevel@tonic-gate #endif /* _FFR_PRIV_NOACTUALRECIPIENT */ 1727c478bd9Sstevel@tonic-gate { NULL, 0 } 1737c478bd9Sstevel@tonic-gate }; 1747c478bd9Sstevel@tonic-gate 1757c478bd9Sstevel@tonic-gate /* 1767c478bd9Sstevel@tonic-gate ** DontBlameSendmail values 1777c478bd9Sstevel@tonic-gate */ 1787c478bd9Sstevel@tonic-gate 1797c478bd9Sstevel@tonic-gate struct dbsval DontBlameSendmailValues[] = 1807c478bd9Sstevel@tonic-gate { 1817c478bd9Sstevel@tonic-gate { "safe", DBS_SAFE }, 1827c478bd9Sstevel@tonic-gate { "assumesafechown", DBS_ASSUMESAFECHOWN }, 1837c478bd9Sstevel@tonic-gate { "groupwritabledirpathsafe", DBS_GROUPWRITABLEDIRPATHSAFE }, 1847c478bd9Sstevel@tonic-gate { "groupwritableforwardfilesafe", 1857c478bd9Sstevel@tonic-gate DBS_GROUPWRITABLEFORWARDFILESAFE }, 1867c478bd9Sstevel@tonic-gate { "groupwritableincludefilesafe", 1877c478bd9Sstevel@tonic-gate DBS_GROUPWRITABLEINCLUDEFILESAFE }, 1887c478bd9Sstevel@tonic-gate { "groupwritablealiasfile", DBS_GROUPWRITABLEALIASFILE }, 1897c478bd9Sstevel@tonic-gate { "worldwritablealiasfile", DBS_WORLDWRITABLEALIASFILE }, 1907c478bd9Sstevel@tonic-gate { "forwardfileinunsafedirpath", DBS_FORWARDFILEINUNSAFEDIRPATH }, 1917c478bd9Sstevel@tonic-gate { "includefileinunsafedirpath", DBS_INCLUDEFILEINUNSAFEDIRPATH }, 1927c478bd9Sstevel@tonic-gate { "mapinunsafedirpath", DBS_MAPINUNSAFEDIRPATH }, 1937c478bd9Sstevel@tonic-gate { "linkedaliasfileinwritabledir", 1947c478bd9Sstevel@tonic-gate DBS_LINKEDALIASFILEINWRITABLEDIR }, 1957c478bd9Sstevel@tonic-gate { "linkedclassfileinwritabledir", 1967c478bd9Sstevel@tonic-gate DBS_LINKEDCLASSFILEINWRITABLEDIR }, 1977c478bd9Sstevel@tonic-gate { "linkedforwardfileinwritabledir", 1987c478bd9Sstevel@tonic-gate DBS_LINKEDFORWARDFILEINWRITABLEDIR }, 1997c478bd9Sstevel@tonic-gate { "linkedincludefileinwritabledir", 2007c478bd9Sstevel@tonic-gate DBS_LINKEDINCLUDEFILEINWRITABLEDIR }, 2017c478bd9Sstevel@tonic-gate { "linkedmapinwritabledir", DBS_LINKEDMAPINWRITABLEDIR }, 2027c478bd9Sstevel@tonic-gate { "linkedserviceswitchfileinwritabledir", 2037c478bd9Sstevel@tonic-gate DBS_LINKEDSERVICESWITCHFILEINWRITABLEDIR }, 2047c478bd9Sstevel@tonic-gate { "filedeliverytohardlink", DBS_FILEDELIVERYTOHARDLINK }, 2057c478bd9Sstevel@tonic-gate { "filedeliverytosymlink", DBS_FILEDELIVERYTOSYMLINK }, 2067c478bd9Sstevel@tonic-gate { "writemaptohardlink", DBS_WRITEMAPTOHARDLINK }, 2077c478bd9Sstevel@tonic-gate { "writemaptosymlink", DBS_WRITEMAPTOSYMLINK }, 2087c478bd9Sstevel@tonic-gate { "writestatstohardlink", DBS_WRITESTATSTOHARDLINK }, 2097c478bd9Sstevel@tonic-gate { "writestatstosymlink", DBS_WRITESTATSTOSYMLINK }, 2107c478bd9Sstevel@tonic-gate { "forwardfileingroupwritabledirpath", 2117c478bd9Sstevel@tonic-gate DBS_FORWARDFILEINGROUPWRITABLEDIRPATH }, 2127c478bd9Sstevel@tonic-gate { "includefileingroupwritabledirpath", 2137c478bd9Sstevel@tonic-gate DBS_INCLUDEFILEINGROUPWRITABLEDIRPATH }, 2147c478bd9Sstevel@tonic-gate { "classfileinunsafedirpath", DBS_CLASSFILEINUNSAFEDIRPATH }, 2157c478bd9Sstevel@tonic-gate { "errorheaderinunsafedirpath", DBS_ERRORHEADERINUNSAFEDIRPATH }, 2167c478bd9Sstevel@tonic-gate { "helpfileinunsafedirpath", DBS_HELPFILEINUNSAFEDIRPATH }, 2177c478bd9Sstevel@tonic-gate { "forwardfileinunsafedirpathsafe", 2187c478bd9Sstevel@tonic-gate DBS_FORWARDFILEINUNSAFEDIRPATHSAFE }, 2197c478bd9Sstevel@tonic-gate { "includefileinunsafedirpathsafe", 2207c478bd9Sstevel@tonic-gate DBS_INCLUDEFILEINUNSAFEDIRPATHSAFE }, 2217c478bd9Sstevel@tonic-gate { "runprograminunsafedirpath", DBS_RUNPROGRAMINUNSAFEDIRPATH }, 2227c478bd9Sstevel@tonic-gate { "runwritableprogram", DBS_RUNWRITABLEPROGRAM }, 2237c478bd9Sstevel@tonic-gate { "nonrootsafeaddr", DBS_NONROOTSAFEADDR }, 2247c478bd9Sstevel@tonic-gate { "truststickybit", DBS_TRUSTSTICKYBIT }, 2257c478bd9Sstevel@tonic-gate { "dontwarnforwardfileinunsafedirpath", 2267c478bd9Sstevel@tonic-gate DBS_DONTWARNFORWARDFILEINUNSAFEDIRPATH }, 2277c478bd9Sstevel@tonic-gate { "insufficiententropy", DBS_INSUFFICIENTENTROPY }, 2287c478bd9Sstevel@tonic-gate { "groupreadablesasldbfile", DBS_GROUPREADABLESASLDBFILE }, 2297c478bd9Sstevel@tonic-gate { "groupwritablesasldbfile", DBS_GROUPWRITABLESASLDBFILE }, 2307c478bd9Sstevel@tonic-gate { "groupwritableforwardfile", DBS_GROUPWRITABLEFORWARDFILE }, 2317c478bd9Sstevel@tonic-gate { "groupwritableincludefile", DBS_GROUPWRITABLEINCLUDEFILE }, 2327c478bd9Sstevel@tonic-gate { "worldwritableforwardfile", DBS_WORLDWRITABLEFORWARDFILE }, 2337c478bd9Sstevel@tonic-gate { "worldwritableincludefile", DBS_WORLDWRITABLEINCLUDEFILE }, 2347c478bd9Sstevel@tonic-gate { "groupreadablekeyfile", DBS_GROUPREADABLEKEYFILE }, 2357c478bd9Sstevel@tonic-gate #if _FFR_GROUPREADABLEAUTHINFOFILE 2367c478bd9Sstevel@tonic-gate { "groupreadableadefaultauthinfofile", 2377c478bd9Sstevel@tonic-gate DBS_GROUPREADABLEAUTHINFOFILE }, 2387c478bd9Sstevel@tonic-gate #endif /* _FFR_GROUPREADABLEAUTHINFOFILE */ 2397c478bd9Sstevel@tonic-gate { NULL, 0 } 2407c478bd9Sstevel@tonic-gate }; 2417c478bd9Sstevel@tonic-gate 2427c478bd9Sstevel@tonic-gate /* 2437c478bd9Sstevel@tonic-gate ** Miscellaneous stuff. 2447c478bd9Sstevel@tonic-gate */ 2457c478bd9Sstevel@tonic-gate 2467c478bd9Sstevel@tonic-gate int DtableSize = 50; /* max open files; reset in 4.2bsd */ 2477c478bd9Sstevel@tonic-gate /* 2487c478bd9Sstevel@tonic-gate ** SETDEFAULTS -- set default values 2497c478bd9Sstevel@tonic-gate ** 2507c478bd9Sstevel@tonic-gate ** Some of these must be initialized using direct code since they 2517c478bd9Sstevel@tonic-gate ** depend on run-time values. So let's do all of them this way. 2527c478bd9Sstevel@tonic-gate ** 2537c478bd9Sstevel@tonic-gate ** Parameters: 2547c478bd9Sstevel@tonic-gate ** e -- the default envelope. 2557c478bd9Sstevel@tonic-gate ** 2567c478bd9Sstevel@tonic-gate ** Returns: 2577c478bd9Sstevel@tonic-gate ** none. 2587c478bd9Sstevel@tonic-gate ** 2597c478bd9Sstevel@tonic-gate ** Side Effects: 2607c478bd9Sstevel@tonic-gate ** Initializes a bunch of global variables to their 2617c478bd9Sstevel@tonic-gate ** default values. 2627c478bd9Sstevel@tonic-gate */ 2637c478bd9Sstevel@tonic-gate 2647c478bd9Sstevel@tonic-gate #define MINUTES * 60 2657c478bd9Sstevel@tonic-gate #define HOURS * 60 MINUTES 2667c478bd9Sstevel@tonic-gate #define DAYS * 24 HOURS 2677c478bd9Sstevel@tonic-gate 2687c478bd9Sstevel@tonic-gate #ifndef MAXRULERECURSION 2697c478bd9Sstevel@tonic-gate # define MAXRULERECURSION 50 /* max ruleset recursion depth */ 2707c478bd9Sstevel@tonic-gate #endif /* ! MAXRULERECURSION */ 2717c478bd9Sstevel@tonic-gate 2727c478bd9Sstevel@tonic-gate void 2737c478bd9Sstevel@tonic-gate setdefaults(e) 2747c478bd9Sstevel@tonic-gate register ENVELOPE *e; 2757c478bd9Sstevel@tonic-gate { 2767c478bd9Sstevel@tonic-gate int i; 2777c478bd9Sstevel@tonic-gate int numprocs; 2787c478bd9Sstevel@tonic-gate struct passwd *pw; 2797c478bd9Sstevel@tonic-gate 2807c478bd9Sstevel@tonic-gate numprocs = get_num_procs_online(); 2817c478bd9Sstevel@tonic-gate SpaceSub = ' '; /* option B */ 2827c478bd9Sstevel@tonic-gate QueueLA = 8 * numprocs; /* option x */ 2837c478bd9Sstevel@tonic-gate RefuseLA = 12 * numprocs; /* option X */ 2847c478bd9Sstevel@tonic-gate WkRecipFact = 30000L; /* option y */ 2857c478bd9Sstevel@tonic-gate WkClassFact = 1800L; /* option z */ 2867c478bd9Sstevel@tonic-gate WkTimeFact = 90000L; /* option Z */ 2877c478bd9Sstevel@tonic-gate QueueFactor = WkRecipFact * 20; /* option q */ 2887c478bd9Sstevel@tonic-gate QueueMode = QM_NORMAL; /* what queue items to act upon */ 2897c478bd9Sstevel@tonic-gate FileMode = (RealUid != geteuid()) ? 0644 : 0600; 2907c478bd9Sstevel@tonic-gate /* option F */ 2917c478bd9Sstevel@tonic-gate QueueFileMode = (RealUid != geteuid()) ? 0644 : 0600; 2927c478bd9Sstevel@tonic-gate /* option QueueFileMode */ 2937c478bd9Sstevel@tonic-gate 2947c478bd9Sstevel@tonic-gate if (((pw = sm_getpwnam("mailnull")) != NULL && pw->pw_uid != 0) || 2957c478bd9Sstevel@tonic-gate ((pw = sm_getpwnam("sendmail")) != NULL && pw->pw_uid != 0) || 2967c478bd9Sstevel@tonic-gate ((pw = sm_getpwnam("daemon")) != NULL && pw->pw_uid != 0)) 2977c478bd9Sstevel@tonic-gate { 2987c478bd9Sstevel@tonic-gate DefUid = pw->pw_uid; /* option u */ 2997c478bd9Sstevel@tonic-gate DefGid = pw->pw_gid; /* option g */ 3007c478bd9Sstevel@tonic-gate DefUser = newstr(pw->pw_name); 3017c478bd9Sstevel@tonic-gate } 3027c478bd9Sstevel@tonic-gate else 3037c478bd9Sstevel@tonic-gate { 3047c478bd9Sstevel@tonic-gate DefUid = 1; /* option u */ 3057c478bd9Sstevel@tonic-gate DefGid = 1; /* option g */ 3067c478bd9Sstevel@tonic-gate setdefuser(); 3077c478bd9Sstevel@tonic-gate } 3087c478bd9Sstevel@tonic-gate TrustedUid = 0; 3097c478bd9Sstevel@tonic-gate if (tTd(37, 4)) 3107c478bd9Sstevel@tonic-gate sm_dprintf("setdefaults: DefUser=%s, DefUid=%d, DefGid=%d\n", 3117c478bd9Sstevel@tonic-gate DefUser != NULL ? DefUser : "<1:1>", 3127c478bd9Sstevel@tonic-gate (int) DefUid, (int) DefGid); 3137c478bd9Sstevel@tonic-gate CheckpointInterval = 10; /* option C */ 3147c478bd9Sstevel@tonic-gate MaxHopCount = 25; /* option h */ 3157c478bd9Sstevel@tonic-gate set_delivery_mode(SM_FORK, e); /* option d */ 3167c478bd9Sstevel@tonic-gate e->e_errormode = EM_PRINT; /* option e */ 3177c478bd9Sstevel@tonic-gate e->e_qgrp = NOQGRP; 3187c478bd9Sstevel@tonic-gate e->e_qdir = NOQDIR; 3197c478bd9Sstevel@tonic-gate e->e_xfqgrp = NOQGRP; 3207c478bd9Sstevel@tonic-gate e->e_xfqdir = NOQDIR; 3217c478bd9Sstevel@tonic-gate e->e_ctime = curtime(); 3227c478bd9Sstevel@tonic-gate SevenBitInput = false; /* option 7 */ 3237c478bd9Sstevel@tonic-gate MaxMciCache = 1; /* option k */ 3247c478bd9Sstevel@tonic-gate MciCacheTimeout = 5 MINUTES; /* option K */ 3257c478bd9Sstevel@tonic-gate LogLevel = 9; /* option L */ 3267c478bd9Sstevel@tonic-gate #if MILTER 3277c478bd9Sstevel@tonic-gate MilterLogLevel = -1; 3287c478bd9Sstevel@tonic-gate #endif /* MILTER */ 3297c478bd9Sstevel@tonic-gate inittimeouts(NULL, false); /* option r */ 3307c478bd9Sstevel@tonic-gate PrivacyFlags = PRIV_PUBLIC; /* option p */ 3317c478bd9Sstevel@tonic-gate MeToo = true; /* option m */ 3327c478bd9Sstevel@tonic-gate SendMIMEErrors = true; /* option f */ 3337c478bd9Sstevel@tonic-gate SuperSafe = SAFE_REALLY; /* option s */ 3347c478bd9Sstevel@tonic-gate clrbitmap(DontBlameSendmail); /* DontBlameSendmail option */ 3357c478bd9Sstevel@tonic-gate #if MIME8TO7 3367c478bd9Sstevel@tonic-gate MimeMode = MM_CVTMIME|MM_PASS8BIT; /* option 8 */ 3377c478bd9Sstevel@tonic-gate #else /* MIME8TO7 */ 3387c478bd9Sstevel@tonic-gate MimeMode = MM_PASS8BIT; 3397c478bd9Sstevel@tonic-gate #endif /* MIME8TO7 */ 3407c478bd9Sstevel@tonic-gate for (i = 0; i < MAXTOCLASS; i++) 3417c478bd9Sstevel@tonic-gate { 3427c478bd9Sstevel@tonic-gate TimeOuts.to_q_return[i] = 5 DAYS; /* option T */ 3437c478bd9Sstevel@tonic-gate TimeOuts.to_q_warning[i] = 0; /* option T */ 3447c478bd9Sstevel@tonic-gate } 3457c478bd9Sstevel@tonic-gate ServiceSwitchFile = "/etc/mail/service.switch"; 3467c478bd9Sstevel@tonic-gate ServiceCacheMaxAge = (time_t) 10; 3477c478bd9Sstevel@tonic-gate HostsFile = _PATH_HOSTS; 3487c478bd9Sstevel@tonic-gate PidFile = newstr(_PATH_SENDMAILPID); 3497c478bd9Sstevel@tonic-gate MustQuoteChars = "@,;:\\()[].'"; 3507c478bd9Sstevel@tonic-gate MciInfoTimeout = 30 MINUTES; 3517c478bd9Sstevel@tonic-gate MaxRuleRecursion = MAXRULERECURSION; 3527c478bd9Sstevel@tonic-gate MaxAliasRecursion = 10; 3537c478bd9Sstevel@tonic-gate MaxMacroRecursion = 10; 3547c478bd9Sstevel@tonic-gate ColonOkInAddr = true; 3557c478bd9Sstevel@tonic-gate DontLockReadFiles = true; 3567c478bd9Sstevel@tonic-gate DontProbeInterfaces = DPI_PROBEALL; 3577c478bd9Sstevel@tonic-gate DoubleBounceAddr = "postmaster"; 3587c478bd9Sstevel@tonic-gate MaxHeadersLength = MAXHDRSLEN; 3597c478bd9Sstevel@tonic-gate MaxMimeHeaderLength = MAXLINE; 3607c478bd9Sstevel@tonic-gate MaxMimeFieldLength = MaxMimeHeaderLength / 2; 3617c478bd9Sstevel@tonic-gate MaxForwardEntries = 0; 3627c478bd9Sstevel@tonic-gate FastSplit = 1; 363*445f2479Sjbeck MaxNOOPCommands = MAXNOOPCOMMANDS; 3647c478bd9Sstevel@tonic-gate #if SASL 3657c478bd9Sstevel@tonic-gate AuthMechanisms = newstr(AUTH_MECHANISMS); 3667c478bd9Sstevel@tonic-gate AuthRealm = NULL; 3677c478bd9Sstevel@tonic-gate MaxSLBits = INT_MAX; 3687c478bd9Sstevel@tonic-gate #endif /* SASL */ 3697c478bd9Sstevel@tonic-gate #if STARTTLS 3707c478bd9Sstevel@tonic-gate TLS_Srv_Opts = TLS_I_SRV; 3717c478bd9Sstevel@tonic-gate #endif /* STARTTLS */ 3727c478bd9Sstevel@tonic-gate #ifdef HESIOD_INIT 3737c478bd9Sstevel@tonic-gate HesiodContext = NULL; 3747c478bd9Sstevel@tonic-gate #endif /* HESIOD_INIT */ 3757c478bd9Sstevel@tonic-gate #if NETINET6 3767c478bd9Sstevel@tonic-gate /* Detect if IPv6 is available at run time */ 3777c478bd9Sstevel@tonic-gate i = socket(AF_INET6, SOCK_STREAM, 0); 3787c478bd9Sstevel@tonic-gate if (i >= 0) 3797c478bd9Sstevel@tonic-gate { 3807c478bd9Sstevel@tonic-gate InetMode = AF_INET6; 3817c478bd9Sstevel@tonic-gate (void) close(i); 3827c478bd9Sstevel@tonic-gate } 3837c478bd9Sstevel@tonic-gate else 3847c478bd9Sstevel@tonic-gate InetMode = AF_INET; 3857c478bd9Sstevel@tonic-gate #else /* NETINET6 */ 3867c478bd9Sstevel@tonic-gate InetMode = AF_INET; 3877c478bd9Sstevel@tonic-gate #endif /* NETINET6 */ 3887c478bd9Sstevel@tonic-gate ControlSocketName = NULL; 3897c478bd9Sstevel@tonic-gate memset(&ConnectOnlyTo, '\0', sizeof ConnectOnlyTo); 3907c478bd9Sstevel@tonic-gate DataFileBufferSize = 4096; 3917c478bd9Sstevel@tonic-gate XscriptFileBufferSize = 4096; 3927c478bd9Sstevel@tonic-gate for (i = 0; i < MAXRWSETS; i++) 3937c478bd9Sstevel@tonic-gate RuleSetNames[i] = NULL; 3947c478bd9Sstevel@tonic-gate #if MILTER 3957c478bd9Sstevel@tonic-gate InputFilters[0] = NULL; 3967c478bd9Sstevel@tonic-gate #endif /* MILTER */ 3977c478bd9Sstevel@tonic-gate RejectLogInterval = 3 HOURS; 3987c478bd9Sstevel@tonic-gate #if REQUIRES_DIR_FSYNC 3997c478bd9Sstevel@tonic-gate RequiresDirfsync = true; 4007c478bd9Sstevel@tonic-gate #endif /* REQUIRES_DIR_FSYNC */ 4017c478bd9Sstevel@tonic-gate ConnectionRateWindowSize = 60; 4027c478bd9Sstevel@tonic-gate setupmaps(); 4037c478bd9Sstevel@tonic-gate setupqueues(); 4047c478bd9Sstevel@tonic-gate setupmailers(); 4057c478bd9Sstevel@tonic-gate setupheaders(); 4067c478bd9Sstevel@tonic-gate } 4077c478bd9Sstevel@tonic-gate 4087c478bd9Sstevel@tonic-gate 4097c478bd9Sstevel@tonic-gate /* 4107c478bd9Sstevel@tonic-gate ** SETDEFUSER -- set/reset DefUser using DefUid (for initgroups()) 4117c478bd9Sstevel@tonic-gate */ 4127c478bd9Sstevel@tonic-gate 4137c478bd9Sstevel@tonic-gate void 4147c478bd9Sstevel@tonic-gate setdefuser() 4157c478bd9Sstevel@tonic-gate { 4167c478bd9Sstevel@tonic-gate struct passwd *defpwent; 4177c478bd9Sstevel@tonic-gate static char defuserbuf[40]; 4187c478bd9Sstevel@tonic-gate 4197c478bd9Sstevel@tonic-gate DefUser = defuserbuf; 4207c478bd9Sstevel@tonic-gate defpwent = sm_getpwuid(DefUid); 4217c478bd9Sstevel@tonic-gate (void) sm_strlcpy(defuserbuf, 4227c478bd9Sstevel@tonic-gate (defpwent == NULL || defpwent->pw_name == NULL) 4237c478bd9Sstevel@tonic-gate ? "nobody" : defpwent->pw_name, 4247c478bd9Sstevel@tonic-gate sizeof defuserbuf); 4257c478bd9Sstevel@tonic-gate if (tTd(37, 4)) 4267c478bd9Sstevel@tonic-gate sm_dprintf("setdefuser: DefUid=%d, DefUser=%s\n", 4277c478bd9Sstevel@tonic-gate (int) DefUid, DefUser); 4287c478bd9Sstevel@tonic-gate } 4297c478bd9Sstevel@tonic-gate /* 4307c478bd9Sstevel@tonic-gate ** SETUPQUEUES -- initialize default queues 4317c478bd9Sstevel@tonic-gate ** 4327c478bd9Sstevel@tonic-gate ** The mqueue QUEUE structure gets filled in after readcf() but 4337c478bd9Sstevel@tonic-gate ** we need something to point to now for the mailer setup, 4347c478bd9Sstevel@tonic-gate ** which use "mqueue" as default queue. 4357c478bd9Sstevel@tonic-gate */ 4367c478bd9Sstevel@tonic-gate 4377c478bd9Sstevel@tonic-gate static void 4387c478bd9Sstevel@tonic-gate setupqueues() 4397c478bd9Sstevel@tonic-gate { 4407c478bd9Sstevel@tonic-gate char buf[100]; 4417c478bd9Sstevel@tonic-gate 4427c478bd9Sstevel@tonic-gate MaxRunnersPerQueue = 1; 4437c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "mqueue, P=/var/spool/mqueue", sizeof buf); 4447c478bd9Sstevel@tonic-gate makequeue(buf, false); 4457c478bd9Sstevel@tonic-gate } 4467c478bd9Sstevel@tonic-gate /* 4477c478bd9Sstevel@tonic-gate ** SETUPMAILERS -- initialize default mailers 4487c478bd9Sstevel@tonic-gate */ 4497c478bd9Sstevel@tonic-gate 4507c478bd9Sstevel@tonic-gate static void 4517c478bd9Sstevel@tonic-gate setupmailers() 4527c478bd9Sstevel@tonic-gate { 4537c478bd9Sstevel@tonic-gate char buf[100]; 4547c478bd9Sstevel@tonic-gate 4557c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "prog, P=/bin/sh, F=lsouDq9, T=X-Unix/X-Unix/X-Unix, A=sh -c \201u", 4567c478bd9Sstevel@tonic-gate sizeof buf); 4577c478bd9Sstevel@tonic-gate makemailer(buf); 4587c478bd9Sstevel@tonic-gate 4597c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "*file*, P=[FILE], F=lsDFMPEouq9, T=X-Unix/X-Unix/X-Unix, A=FILE \201u", 4607c478bd9Sstevel@tonic-gate sizeof buf); 4617c478bd9Sstevel@tonic-gate makemailer(buf); 4627c478bd9Sstevel@tonic-gate 4637c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "*include*, P=/dev/null, F=su, A=INCLUDE \201u", 4647c478bd9Sstevel@tonic-gate sizeof buf); 4657c478bd9Sstevel@tonic-gate makemailer(buf); 4667c478bd9Sstevel@tonic-gate initerrmailers(); 4677c478bd9Sstevel@tonic-gate } 4687c478bd9Sstevel@tonic-gate /* 4697c478bd9Sstevel@tonic-gate ** SETUPMAPS -- set up map classes 4707c478bd9Sstevel@tonic-gate */ 4717c478bd9Sstevel@tonic-gate 4727c478bd9Sstevel@tonic-gate #define MAPDEF(name, ext, flags, parse, open, close, lookup, store) \ 4737c478bd9Sstevel@tonic-gate { \ 4747c478bd9Sstevel@tonic-gate extern bool parse __P((MAP *, char *)); \ 4757c478bd9Sstevel@tonic-gate extern bool open __P((MAP *, int)); \ 4767c478bd9Sstevel@tonic-gate extern void close __P((MAP *)); \ 4777c478bd9Sstevel@tonic-gate extern char *lookup __P((MAP *, char *, char **, int *)); \ 4787c478bd9Sstevel@tonic-gate extern void store __P((MAP *, char *, char *)); \ 4797c478bd9Sstevel@tonic-gate s = stab(name, ST_MAPCLASS, ST_ENTER); \ 4807c478bd9Sstevel@tonic-gate s->s_mapclass.map_cname = name; \ 4817c478bd9Sstevel@tonic-gate s->s_mapclass.map_ext = ext; \ 4827c478bd9Sstevel@tonic-gate s->s_mapclass.map_cflags = flags; \ 4837c478bd9Sstevel@tonic-gate s->s_mapclass.map_parse = parse; \ 4847c478bd9Sstevel@tonic-gate s->s_mapclass.map_open = open; \ 4857c478bd9Sstevel@tonic-gate s->s_mapclass.map_close = close; \ 4867c478bd9Sstevel@tonic-gate s->s_mapclass.map_lookup = lookup; \ 4877c478bd9Sstevel@tonic-gate s->s_mapclass.map_store = store; \ 4887c478bd9Sstevel@tonic-gate } 4897c478bd9Sstevel@tonic-gate 4907c478bd9Sstevel@tonic-gate static void 4917c478bd9Sstevel@tonic-gate setupmaps() 4927c478bd9Sstevel@tonic-gate { 4937c478bd9Sstevel@tonic-gate register STAB *s; 4947c478bd9Sstevel@tonic-gate 4957c478bd9Sstevel@tonic-gate #if NEWDB 4967c478bd9Sstevel@tonic-gate # if DB_VERSION_MAJOR > 1 4977c478bd9Sstevel@tonic-gate int major_v, minor_v, patch_v; 4987c478bd9Sstevel@tonic-gate 4997c478bd9Sstevel@tonic-gate (void) db_version(&major_v, &minor_v, &patch_v); 5007c478bd9Sstevel@tonic-gate if (major_v != DB_VERSION_MAJOR || minor_v != DB_VERSION_MINOR) 5017c478bd9Sstevel@tonic-gate { 5027c478bd9Sstevel@tonic-gate errno = 0; 5037c478bd9Sstevel@tonic-gate syserr("Berkeley DB version mismatch: compiled against %d.%d.%d, run-time linked against %d.%d.%d", 5047c478bd9Sstevel@tonic-gate DB_VERSION_MAJOR, DB_VERSION_MINOR, DB_VERSION_PATCH, 5057c478bd9Sstevel@tonic-gate major_v, minor_v, patch_v); 5067c478bd9Sstevel@tonic-gate } 5077c478bd9Sstevel@tonic-gate # endif /* DB_VERSION_MAJOR > 1 */ 5087c478bd9Sstevel@tonic-gate 5097c478bd9Sstevel@tonic-gate MAPDEF("hash", ".db", MCF_ALIASOK|MCF_REBUILDABLE, 5107c478bd9Sstevel@tonic-gate map_parseargs, hash_map_open, db_map_close, 5117c478bd9Sstevel@tonic-gate db_map_lookup, db_map_store); 5127c478bd9Sstevel@tonic-gate 5137c478bd9Sstevel@tonic-gate MAPDEF("btree", ".db", MCF_ALIASOK|MCF_REBUILDABLE, 5147c478bd9Sstevel@tonic-gate map_parseargs, bt_map_open, db_map_close, 5157c478bd9Sstevel@tonic-gate db_map_lookup, db_map_store); 5167c478bd9Sstevel@tonic-gate #endif /* NEWDB */ 5177c478bd9Sstevel@tonic-gate 5187c478bd9Sstevel@tonic-gate #if NDBM 5197c478bd9Sstevel@tonic-gate MAPDEF("dbm", ".dir", MCF_ALIASOK|MCF_REBUILDABLE, 5207c478bd9Sstevel@tonic-gate map_parseargs, ndbm_map_open, ndbm_map_close, 5217c478bd9Sstevel@tonic-gate ndbm_map_lookup, ndbm_map_store); 5227c478bd9Sstevel@tonic-gate #endif /* NDBM */ 5237c478bd9Sstevel@tonic-gate 5247c478bd9Sstevel@tonic-gate #if NIS 5257c478bd9Sstevel@tonic-gate MAPDEF("nis", NULL, MCF_ALIASOK, 5267c478bd9Sstevel@tonic-gate map_parseargs, nis_map_open, null_map_close, 5277c478bd9Sstevel@tonic-gate nis_map_lookup, null_map_store); 5287c478bd9Sstevel@tonic-gate #endif /* NIS */ 5297c478bd9Sstevel@tonic-gate 5307c478bd9Sstevel@tonic-gate #if NISPLUS 5317c478bd9Sstevel@tonic-gate MAPDEF("nisplus", NULL, MCF_ALIASOK, 5327c478bd9Sstevel@tonic-gate map_parseargs, nisplus_map_open, null_map_close, 5337c478bd9Sstevel@tonic-gate nisplus_map_lookup, null_map_store); 5347c478bd9Sstevel@tonic-gate #endif /* NISPLUS */ 5357c478bd9Sstevel@tonic-gate 5367c478bd9Sstevel@tonic-gate #if LDAPMAP 5377c478bd9Sstevel@tonic-gate MAPDEF("ldap", NULL, MCF_ALIASOK|MCF_NOTPERSIST, 5387c478bd9Sstevel@tonic-gate ldapmap_parseargs, ldapmap_open, ldapmap_close, 5397c478bd9Sstevel@tonic-gate ldapmap_lookup, null_map_store); 5407c478bd9Sstevel@tonic-gate #endif /* LDAPMAP */ 5417c478bd9Sstevel@tonic-gate 5427c478bd9Sstevel@tonic-gate #if PH_MAP 5437c478bd9Sstevel@tonic-gate MAPDEF("ph", NULL, MCF_NOTPERSIST, 5447c478bd9Sstevel@tonic-gate ph_map_parseargs, ph_map_open, ph_map_close, 5457c478bd9Sstevel@tonic-gate ph_map_lookup, null_map_store); 5467c478bd9Sstevel@tonic-gate #endif /* PH_MAP */ 5477c478bd9Sstevel@tonic-gate 5487c478bd9Sstevel@tonic-gate #if MAP_NSD 5497c478bd9Sstevel@tonic-gate /* IRIX 6.5 nsd support */ 5507c478bd9Sstevel@tonic-gate MAPDEF("nsd", NULL, MCF_ALIASOK, 5517c478bd9Sstevel@tonic-gate map_parseargs, null_map_open, null_map_close, 5527c478bd9Sstevel@tonic-gate nsd_map_lookup, null_map_store); 5537c478bd9Sstevel@tonic-gate #endif /* MAP_NSD */ 5547c478bd9Sstevel@tonic-gate 5557c478bd9Sstevel@tonic-gate #if HESIOD 5567c478bd9Sstevel@tonic-gate MAPDEF("hesiod", NULL, MCF_ALIASOK|MCF_ALIASONLY, 5577c478bd9Sstevel@tonic-gate map_parseargs, hes_map_open, hes_map_close, 5587c478bd9Sstevel@tonic-gate hes_map_lookup, null_map_store); 5597c478bd9Sstevel@tonic-gate #endif /* HESIOD */ 5607c478bd9Sstevel@tonic-gate 5617c478bd9Sstevel@tonic-gate #if NETINFO 5627c478bd9Sstevel@tonic-gate MAPDEF("netinfo", NULL, MCF_ALIASOK, 5637c478bd9Sstevel@tonic-gate map_parseargs, ni_map_open, null_map_close, 5647c478bd9Sstevel@tonic-gate ni_map_lookup, null_map_store); 5657c478bd9Sstevel@tonic-gate #endif /* NETINFO */ 5667c478bd9Sstevel@tonic-gate 5677c478bd9Sstevel@tonic-gate #if 0 5687c478bd9Sstevel@tonic-gate MAPDEF("dns", NULL, 0, 5697c478bd9Sstevel@tonic-gate dns_map_init, null_map_open, null_map_close, 5707c478bd9Sstevel@tonic-gate dns_map_lookup, null_map_store); 5717c478bd9Sstevel@tonic-gate #endif /* 0 */ 5727c478bd9Sstevel@tonic-gate 5737c478bd9Sstevel@tonic-gate #if NAMED_BIND 5747c478bd9Sstevel@tonic-gate # if DNSMAP 5757c478bd9Sstevel@tonic-gate # if _FFR_DNSMAP_ALIASABLE 5767c478bd9Sstevel@tonic-gate MAPDEF("dns", NULL, MCF_ALIASOK, 5777c478bd9Sstevel@tonic-gate dns_map_parseargs, dns_map_open, null_map_close, 5787c478bd9Sstevel@tonic-gate dns_map_lookup, null_map_store); 5797c478bd9Sstevel@tonic-gate # else /* _FFR_DNSMAP_ALIASABLE */ 5807c478bd9Sstevel@tonic-gate MAPDEF("dns", NULL, 0, 5817c478bd9Sstevel@tonic-gate dns_map_parseargs, dns_map_open, null_map_close, 5827c478bd9Sstevel@tonic-gate dns_map_lookup, null_map_store); 5837c478bd9Sstevel@tonic-gate # endif /* _FFR_DNSMAP_ALIASABLE */ 5847c478bd9Sstevel@tonic-gate # endif /* DNSMAP */ 5857c478bd9Sstevel@tonic-gate #endif /* NAMED_BIND */ 5867c478bd9Sstevel@tonic-gate 5877c478bd9Sstevel@tonic-gate #if NAMED_BIND 5887c478bd9Sstevel@tonic-gate /* best MX DNS lookup */ 5897c478bd9Sstevel@tonic-gate MAPDEF("bestmx", NULL, MCF_OPTFILE, 5907c478bd9Sstevel@tonic-gate map_parseargs, null_map_open, null_map_close, 5917c478bd9Sstevel@tonic-gate bestmx_map_lookup, null_map_store); 5927c478bd9Sstevel@tonic-gate #endif /* NAMED_BIND */ 5937c478bd9Sstevel@tonic-gate 5947c478bd9Sstevel@tonic-gate MAPDEF("host", NULL, 0, 5957c478bd9Sstevel@tonic-gate host_map_init, null_map_open, null_map_close, 5967c478bd9Sstevel@tonic-gate host_map_lookup, null_map_store); 5977c478bd9Sstevel@tonic-gate 5987c478bd9Sstevel@tonic-gate MAPDEF("text", NULL, MCF_ALIASOK, 5997c478bd9Sstevel@tonic-gate map_parseargs, text_map_open, null_map_close, 6007c478bd9Sstevel@tonic-gate text_map_lookup, null_map_store); 6017c478bd9Sstevel@tonic-gate 6027c478bd9Sstevel@tonic-gate MAPDEF("stab", NULL, MCF_ALIASOK|MCF_ALIASONLY, 6037c478bd9Sstevel@tonic-gate map_parseargs, stab_map_open, null_map_close, 6047c478bd9Sstevel@tonic-gate stab_map_lookup, stab_map_store); 6057c478bd9Sstevel@tonic-gate 6067c478bd9Sstevel@tonic-gate MAPDEF("implicit", NULL, MCF_ALIASOK|MCF_ALIASONLY|MCF_REBUILDABLE, 6077c478bd9Sstevel@tonic-gate map_parseargs, impl_map_open, impl_map_close, 6087c478bd9Sstevel@tonic-gate impl_map_lookup, impl_map_store); 6097c478bd9Sstevel@tonic-gate 6107c478bd9Sstevel@tonic-gate /* access to system passwd file */ 6117c478bd9Sstevel@tonic-gate MAPDEF("user", NULL, MCF_OPTFILE, 6127c478bd9Sstevel@tonic-gate map_parseargs, user_map_open, null_map_close, 6137c478bd9Sstevel@tonic-gate user_map_lookup, null_map_store); 6147c478bd9Sstevel@tonic-gate 6157c478bd9Sstevel@tonic-gate /* dequote map */ 6167c478bd9Sstevel@tonic-gate MAPDEF("dequote", NULL, 0, 6177c478bd9Sstevel@tonic-gate dequote_init, null_map_open, null_map_close, 6187c478bd9Sstevel@tonic-gate dequote_map, null_map_store); 6197c478bd9Sstevel@tonic-gate 6207c478bd9Sstevel@tonic-gate #if MAP_REGEX 6217c478bd9Sstevel@tonic-gate MAPDEF("regex", NULL, 0, 6227c478bd9Sstevel@tonic-gate regex_map_init, null_map_open, null_map_close, 6237c478bd9Sstevel@tonic-gate regex_map_lookup, null_map_store); 6247c478bd9Sstevel@tonic-gate #endif /* MAP_REGEX */ 6257c478bd9Sstevel@tonic-gate 6267c478bd9Sstevel@tonic-gate #if USERDB 6277c478bd9Sstevel@tonic-gate /* user database */ 6287c478bd9Sstevel@tonic-gate MAPDEF("userdb", ".db", 0, 6297c478bd9Sstevel@tonic-gate map_parseargs, null_map_open, null_map_close, 6307c478bd9Sstevel@tonic-gate udb_map_lookup, null_map_store); 6317c478bd9Sstevel@tonic-gate #endif /* USERDB */ 6327c478bd9Sstevel@tonic-gate 6337c478bd9Sstevel@tonic-gate /* arbitrary programs */ 6347c478bd9Sstevel@tonic-gate MAPDEF("program", NULL, MCF_ALIASOK, 6357c478bd9Sstevel@tonic-gate map_parseargs, null_map_open, null_map_close, 6367c478bd9Sstevel@tonic-gate prog_map_lookup, null_map_store); 6377c478bd9Sstevel@tonic-gate 6387c478bd9Sstevel@tonic-gate /* sequenced maps */ 6397c478bd9Sstevel@tonic-gate MAPDEF("sequence", NULL, MCF_ALIASOK, 6407c478bd9Sstevel@tonic-gate seq_map_parse, null_map_open, null_map_close, 6417c478bd9Sstevel@tonic-gate seq_map_lookup, seq_map_store); 6427c478bd9Sstevel@tonic-gate 6437c478bd9Sstevel@tonic-gate /* switched interface to sequenced maps */ 6447c478bd9Sstevel@tonic-gate MAPDEF("switch", NULL, MCF_ALIASOK, 6457c478bd9Sstevel@tonic-gate map_parseargs, switch_map_open, null_map_close, 6467c478bd9Sstevel@tonic-gate seq_map_lookup, seq_map_store); 6477c478bd9Sstevel@tonic-gate 6487c478bd9Sstevel@tonic-gate /* null map lookup -- really for internal use only */ 6497c478bd9Sstevel@tonic-gate MAPDEF("null", NULL, MCF_ALIASOK|MCF_OPTFILE, 6507c478bd9Sstevel@tonic-gate map_parseargs, null_map_open, null_map_close, 6517c478bd9Sstevel@tonic-gate null_map_lookup, null_map_store); 6527c478bd9Sstevel@tonic-gate 6537c478bd9Sstevel@tonic-gate /* syslog map -- logs information to syslog */ 6547c478bd9Sstevel@tonic-gate MAPDEF("syslog", NULL, 0, 6557c478bd9Sstevel@tonic-gate syslog_map_parseargs, null_map_open, null_map_close, 6567c478bd9Sstevel@tonic-gate syslog_map_lookup, null_map_store); 6577c478bd9Sstevel@tonic-gate 6587c478bd9Sstevel@tonic-gate /* macro storage map -- rulesets can set macros */ 6597c478bd9Sstevel@tonic-gate MAPDEF("macro", NULL, 0, 6607c478bd9Sstevel@tonic-gate dequote_init, null_map_open, null_map_close, 6617c478bd9Sstevel@tonic-gate macro_map_lookup, null_map_store); 6627c478bd9Sstevel@tonic-gate 6637c478bd9Sstevel@tonic-gate /* arithmetic map -- add/subtract/compare */ 6647c478bd9Sstevel@tonic-gate MAPDEF("arith", NULL, 0, 6657c478bd9Sstevel@tonic-gate dequote_init, null_map_open, null_map_close, 6667c478bd9Sstevel@tonic-gate arith_map_lookup, null_map_store); 6677c478bd9Sstevel@tonic-gate 6687c478bd9Sstevel@tonic-gate #if SOCKETMAP 6697c478bd9Sstevel@tonic-gate /* arbitrary daemons */ 6707c478bd9Sstevel@tonic-gate MAPDEF("socket", NULL, MCF_ALIASOK, 6717c478bd9Sstevel@tonic-gate map_parseargs, socket_map_open, socket_map_close, 6727c478bd9Sstevel@tonic-gate socket_map_lookup, null_map_store); 6737c478bd9Sstevel@tonic-gate #endif /* SOCKETMAP */ 6747c478bd9Sstevel@tonic-gate 6757c478bd9Sstevel@tonic-gate if (tTd(38, 2)) 6767c478bd9Sstevel@tonic-gate { 6777c478bd9Sstevel@tonic-gate /* bogus map -- always return tempfail */ 6787c478bd9Sstevel@tonic-gate MAPDEF("bogus", NULL, MCF_ALIASOK|MCF_OPTFILE, 6797c478bd9Sstevel@tonic-gate map_parseargs, null_map_open, null_map_close, 6807c478bd9Sstevel@tonic-gate bogus_map_lookup, null_map_store); 6817c478bd9Sstevel@tonic-gate } 6827c478bd9Sstevel@tonic-gate } 6837c478bd9Sstevel@tonic-gate 6847c478bd9Sstevel@tonic-gate #undef MAPDEF 6857c478bd9Sstevel@tonic-gate /* 6867c478bd9Sstevel@tonic-gate ** INITHOSTMAPS -- initial host-dependent maps 6877c478bd9Sstevel@tonic-gate ** 6887c478bd9Sstevel@tonic-gate ** This should act as an interface to any local service switch 6897c478bd9Sstevel@tonic-gate ** provided by the host operating system. 6907c478bd9Sstevel@tonic-gate ** 6917c478bd9Sstevel@tonic-gate ** Parameters: 6927c478bd9Sstevel@tonic-gate ** none 6937c478bd9Sstevel@tonic-gate ** 6947c478bd9Sstevel@tonic-gate ** Returns: 6957c478bd9Sstevel@tonic-gate ** none 6967c478bd9Sstevel@tonic-gate ** 6977c478bd9Sstevel@tonic-gate ** Side Effects: 6987c478bd9Sstevel@tonic-gate ** Should define maps "host" and "users" as necessary 6997c478bd9Sstevel@tonic-gate ** for this OS. If they are not defined, they will get 7007c478bd9Sstevel@tonic-gate ** a default value later. It should check to make sure 7017c478bd9Sstevel@tonic-gate ** they are not defined first, since it's possible that 7027c478bd9Sstevel@tonic-gate ** the config file has provided an override. 7037c478bd9Sstevel@tonic-gate */ 7047c478bd9Sstevel@tonic-gate 7057c478bd9Sstevel@tonic-gate void 7067c478bd9Sstevel@tonic-gate inithostmaps() 7077c478bd9Sstevel@tonic-gate { 7087c478bd9Sstevel@tonic-gate register int i; 7097c478bd9Sstevel@tonic-gate int nmaps; 7107c478bd9Sstevel@tonic-gate char *maptype[MAXMAPSTACK]; 7117c478bd9Sstevel@tonic-gate short mapreturn[MAXMAPACTIONS]; 7127c478bd9Sstevel@tonic-gate char buf[MAXLINE]; 7137c478bd9Sstevel@tonic-gate 7147c478bd9Sstevel@tonic-gate /* 7157c478bd9Sstevel@tonic-gate ** Set up default hosts maps. 7167c478bd9Sstevel@tonic-gate */ 7177c478bd9Sstevel@tonic-gate 7187c478bd9Sstevel@tonic-gate #if 0 7197c478bd9Sstevel@tonic-gate nmaps = switch_map_find("hosts", maptype, mapreturn); 7207c478bd9Sstevel@tonic-gate for (i = 0; i < nmaps; i++) 7217c478bd9Sstevel@tonic-gate { 7227c478bd9Sstevel@tonic-gate if (strcmp(maptype[i], "files") == 0 && 7237c478bd9Sstevel@tonic-gate stab("hosts.files", ST_MAP, ST_FIND) == NULL) 7247c478bd9Sstevel@tonic-gate { 7257c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "hosts.files text -k 0 -v 1 /etc/hosts", 7267c478bd9Sstevel@tonic-gate sizeof buf); 7277c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 7287c478bd9Sstevel@tonic-gate } 7297c478bd9Sstevel@tonic-gate # if NAMED_BIND 7307c478bd9Sstevel@tonic-gate else if (strcmp(maptype[i], "dns") == 0 && 7317c478bd9Sstevel@tonic-gate stab("hosts.dns", ST_MAP, ST_FIND) == NULL) 7327c478bd9Sstevel@tonic-gate { 7337c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "hosts.dns dns A", sizeof buf); 7347c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 7357c478bd9Sstevel@tonic-gate } 7367c478bd9Sstevel@tonic-gate # endif /* NAMED_BIND */ 7377c478bd9Sstevel@tonic-gate # if NISPLUS 7387c478bd9Sstevel@tonic-gate else if (strcmp(maptype[i], "nisplus") == 0 && 7397c478bd9Sstevel@tonic-gate stab("hosts.nisplus", ST_MAP, ST_FIND) == NULL) 7407c478bd9Sstevel@tonic-gate { 7417c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "hosts.nisplus nisplus -k name -v address hosts.org_dir", 7427c478bd9Sstevel@tonic-gate sizeof buf); 7437c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 7447c478bd9Sstevel@tonic-gate } 7457c478bd9Sstevel@tonic-gate # endif /* NISPLUS */ 7467c478bd9Sstevel@tonic-gate # if NIS 7477c478bd9Sstevel@tonic-gate else if (strcmp(maptype[i], "nis") == 0 && 7487c478bd9Sstevel@tonic-gate stab("hosts.nis", ST_MAP, ST_FIND) == NULL) 7497c478bd9Sstevel@tonic-gate { 7507c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "hosts.nis nis -k 0 -v 1 hosts.byname", 7517c478bd9Sstevel@tonic-gate sizeof buf); 7527c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 7537c478bd9Sstevel@tonic-gate } 7547c478bd9Sstevel@tonic-gate # endif /* NIS */ 7557c478bd9Sstevel@tonic-gate # if NETINFO 7567c478bd9Sstevel@tonic-gate else if (strcmp(maptype[i], "netinfo") == 0 && 7577c478bd9Sstevel@tonic-gate stab("hosts.netinfo", ST_MAP, ST_FIND) == NULL) 7587c478bd9Sstevel@tonic-gate { 7597c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "hosts.netinfo netinfo -v name /machines", 7607c478bd9Sstevel@tonic-gate sizeof buf); 7617c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 7627c478bd9Sstevel@tonic-gate } 7637c478bd9Sstevel@tonic-gate # endif /* NETINFO */ 7647c478bd9Sstevel@tonic-gate } 7657c478bd9Sstevel@tonic-gate #endif /* 0 */ 7667c478bd9Sstevel@tonic-gate 7677c478bd9Sstevel@tonic-gate /* 7687c478bd9Sstevel@tonic-gate ** Make sure we have a host map. 7697c478bd9Sstevel@tonic-gate */ 7707c478bd9Sstevel@tonic-gate 7717c478bd9Sstevel@tonic-gate if (stab("host", ST_MAP, ST_FIND) == NULL) 7727c478bd9Sstevel@tonic-gate { 7737c478bd9Sstevel@tonic-gate /* user didn't initialize: set up host map */ 7747c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "host host", sizeof buf); 7757c478bd9Sstevel@tonic-gate #if NAMED_BIND 7767c478bd9Sstevel@tonic-gate if (ConfigLevel >= 2) 7777c478bd9Sstevel@tonic-gate (void) sm_strlcat(buf, " -a. -D", sizeof buf); 7787c478bd9Sstevel@tonic-gate #endif /* NAMED_BIND */ 7797c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 7807c478bd9Sstevel@tonic-gate } 7817c478bd9Sstevel@tonic-gate 7827c478bd9Sstevel@tonic-gate /* 7837c478bd9Sstevel@tonic-gate ** Set up default aliases maps 7847c478bd9Sstevel@tonic-gate */ 7857c478bd9Sstevel@tonic-gate 7867c478bd9Sstevel@tonic-gate nmaps = switch_map_find("aliases", maptype, mapreturn); 7877c478bd9Sstevel@tonic-gate for (i = 0; i < nmaps; i++) 7887c478bd9Sstevel@tonic-gate { 7897c478bd9Sstevel@tonic-gate if (strcmp(maptype[i], "files") == 0 && 7907c478bd9Sstevel@tonic-gate stab("aliases.files", ST_MAP, ST_FIND) == NULL) 7917c478bd9Sstevel@tonic-gate { 7927c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "aliases.files null", 7937c478bd9Sstevel@tonic-gate sizeof buf); 7947c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 7957c478bd9Sstevel@tonic-gate } 7967c478bd9Sstevel@tonic-gate #if NISPLUS 7977c478bd9Sstevel@tonic-gate else if (strcmp(maptype[i], "nisplus") == 0 && 7987c478bd9Sstevel@tonic-gate stab("aliases.nisplus", ST_MAP, ST_FIND) == NULL) 7997c478bd9Sstevel@tonic-gate { 8007c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "aliases.nisplus nisplus -kalias -vexpansion mail_aliases.org_dir", 8017c478bd9Sstevel@tonic-gate sizeof buf); 8027c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 8037c478bd9Sstevel@tonic-gate } 8047c478bd9Sstevel@tonic-gate #endif /* NISPLUS */ 8057c478bd9Sstevel@tonic-gate #if NIS 8067c478bd9Sstevel@tonic-gate else if (strcmp(maptype[i], "nis") == 0 && 8077c478bd9Sstevel@tonic-gate stab("aliases.nis", ST_MAP, ST_FIND) == NULL) 8087c478bd9Sstevel@tonic-gate { 8097c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "aliases.nis nis mail.aliases", 8107c478bd9Sstevel@tonic-gate sizeof buf); 8117c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 8127c478bd9Sstevel@tonic-gate } 8137c478bd9Sstevel@tonic-gate #endif /* NIS */ 8147c478bd9Sstevel@tonic-gate #if NETINFO 8157c478bd9Sstevel@tonic-gate else if (strcmp(maptype[i], "netinfo") == 0 && 8167c478bd9Sstevel@tonic-gate stab("aliases.netinfo", ST_MAP, ST_FIND) == NULL) 8177c478bd9Sstevel@tonic-gate { 8187c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "aliases.netinfo netinfo -z, /aliases", 8197c478bd9Sstevel@tonic-gate sizeof buf); 8207c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 8217c478bd9Sstevel@tonic-gate } 8227c478bd9Sstevel@tonic-gate #endif /* NETINFO */ 8237c478bd9Sstevel@tonic-gate #if HESIOD 8247c478bd9Sstevel@tonic-gate else if (strcmp(maptype[i], "hesiod") == 0 && 8257c478bd9Sstevel@tonic-gate stab("aliases.hesiod", ST_MAP, ST_FIND) == NULL) 8267c478bd9Sstevel@tonic-gate { 8277c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "aliases.hesiod hesiod aliases", 8287c478bd9Sstevel@tonic-gate sizeof buf); 8297c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 8307c478bd9Sstevel@tonic-gate } 8317c478bd9Sstevel@tonic-gate #endif /* HESIOD */ 8327c478bd9Sstevel@tonic-gate #if defined(LDAPMAP) && defined(SUN_EXTENSIONS) && \ 8337c478bd9Sstevel@tonic-gate defined(SUN_SIMPLIFIED_LDAP) && defined(HASLDAPGETALIASBYNAME) 8347c478bd9Sstevel@tonic-gate else if (strcmp(maptype[i], "ldap") == 0 && 8357c478bd9Sstevel@tonic-gate stab("aliases.ldap", ST_MAP, ST_FIND) == NULL) 8367c478bd9Sstevel@tonic-gate { 8377c478bd9Sstevel@tonic-gate (void) strlcpy(buf, "aliases.ldap ldap -b . -h localhost -k mail=%0 -v mailgroup", 8387c478bd9Sstevel@tonic-gate sizeof buf); 8397c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 8407c478bd9Sstevel@tonic-gate } 8417c478bd9Sstevel@tonic-gate #endif 8427c478bd9Sstevel@tonic-gate } 8437c478bd9Sstevel@tonic-gate if (stab("aliases", ST_MAP, ST_FIND) == NULL) 8447c478bd9Sstevel@tonic-gate { 8457c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "aliases switch aliases", sizeof buf); 8467c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 8477c478bd9Sstevel@tonic-gate } 8487c478bd9Sstevel@tonic-gate 8497c478bd9Sstevel@tonic-gate #if 0 /* "user" map class is a better choice */ 8507c478bd9Sstevel@tonic-gate /* 8517c478bd9Sstevel@tonic-gate ** Set up default users maps. 8527c478bd9Sstevel@tonic-gate */ 8537c478bd9Sstevel@tonic-gate 8547c478bd9Sstevel@tonic-gate nmaps = switch_map_find("passwd", maptype, mapreturn); 8557c478bd9Sstevel@tonic-gate for (i = 0; i < nmaps; i++) 8567c478bd9Sstevel@tonic-gate { 8577c478bd9Sstevel@tonic-gate if (strcmp(maptype[i], "files") == 0 && 8587c478bd9Sstevel@tonic-gate stab("users.files", ST_MAP, ST_FIND) == NULL) 8597c478bd9Sstevel@tonic-gate { 8607c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "users.files text -m -z: -k0 -v6 /etc/passwd", 8617c478bd9Sstevel@tonic-gate sizeof buf); 8627c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 8637c478bd9Sstevel@tonic-gate } 8647c478bd9Sstevel@tonic-gate # if NISPLUS 8657c478bd9Sstevel@tonic-gate else if (strcmp(maptype[i], "nisplus") == 0 && 8667c478bd9Sstevel@tonic-gate stab("users.nisplus", ST_MAP, ST_FIND) == NULL) 8677c478bd9Sstevel@tonic-gate { 8687c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "users.nisplus nisplus -m -kname -vhome passwd.org_dir", 8697c478bd9Sstevel@tonic-gate sizeof buf); 8707c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 8717c478bd9Sstevel@tonic-gate } 8727c478bd9Sstevel@tonic-gate # endif /* NISPLUS */ 8737c478bd9Sstevel@tonic-gate # if NIS 8747c478bd9Sstevel@tonic-gate else if (strcmp(maptype[i], "nis") == 0 && 8757c478bd9Sstevel@tonic-gate stab("users.nis", ST_MAP, ST_FIND) == NULL) 8767c478bd9Sstevel@tonic-gate { 8777c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "users.nis nis -m passwd.byname", 8787c478bd9Sstevel@tonic-gate sizeof buf); 8797c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 8807c478bd9Sstevel@tonic-gate } 8817c478bd9Sstevel@tonic-gate # endif /* NIS */ 8827c478bd9Sstevel@tonic-gate # if HESIOD 8837c478bd9Sstevel@tonic-gate else if (strcmp(maptype[i], "hesiod") == 0 && 8847c478bd9Sstevel@tonic-gate stab("users.hesiod", ST_MAP, ST_FIND) == NULL) 8857c478bd9Sstevel@tonic-gate { 8867c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "users.hesiod hesiod", sizeof buf); 8877c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 8887c478bd9Sstevel@tonic-gate } 8897c478bd9Sstevel@tonic-gate # endif /* HESIOD */ 8907c478bd9Sstevel@tonic-gate } 8917c478bd9Sstevel@tonic-gate if (stab("users", ST_MAP, ST_FIND) == NULL) 8927c478bd9Sstevel@tonic-gate { 8937c478bd9Sstevel@tonic-gate (void) sm_strlcpy(buf, "users switch -m passwd", sizeof buf); 8947c478bd9Sstevel@tonic-gate (void) makemapentry(buf); 8957c478bd9Sstevel@tonic-gate } 8967c478bd9Sstevel@tonic-gate #endif /* 0 */ 8977c478bd9Sstevel@tonic-gate } 8987c478bd9Sstevel@tonic-gate /* 8997c478bd9Sstevel@tonic-gate ** SWITCH_MAP_FIND -- find the list of types associated with a map 9007c478bd9Sstevel@tonic-gate ** 9017c478bd9Sstevel@tonic-gate ** This is the system-dependent interface to the service switch. 9027c478bd9Sstevel@tonic-gate ** 9037c478bd9Sstevel@tonic-gate ** Parameters: 9047c478bd9Sstevel@tonic-gate ** service -- the name of the service of interest. 9057c478bd9Sstevel@tonic-gate ** maptype -- an out-array of strings containing the types 9067c478bd9Sstevel@tonic-gate ** of access to use for this service. There can 9077c478bd9Sstevel@tonic-gate ** be at most MAXMAPSTACK types for a single service. 9087c478bd9Sstevel@tonic-gate ** mapreturn -- an out-array of return information bitmaps 9097c478bd9Sstevel@tonic-gate ** for the map. 9107c478bd9Sstevel@tonic-gate ** 9117c478bd9Sstevel@tonic-gate ** Returns: 9127c478bd9Sstevel@tonic-gate ** The number of map types filled in, or -1 for failure. 9137c478bd9Sstevel@tonic-gate ** 9147c478bd9Sstevel@tonic-gate ** Side effects: 9157c478bd9Sstevel@tonic-gate ** Preserves errno so nothing in the routine clobbers it. 9167c478bd9Sstevel@tonic-gate */ 9177c478bd9Sstevel@tonic-gate 9187c478bd9Sstevel@tonic-gate #if defined(SOLARIS) || (defined(sony_news) && defined(__svr4)) 9197c478bd9Sstevel@tonic-gate # define _USE_SUN_NSSWITCH_ 9207c478bd9Sstevel@tonic-gate #endif /* defined(SOLARIS) || (defined(sony_news) && defined(__svr4)) */ 9217c478bd9Sstevel@tonic-gate 9227c478bd9Sstevel@tonic-gate #if _FFR_HPUX_NSSWITCH 9237c478bd9Sstevel@tonic-gate # ifdef __hpux 9247c478bd9Sstevel@tonic-gate # define _USE_SUN_NSSWITCH_ 9257c478bd9Sstevel@tonic-gate # endif /* __hpux */ 9267c478bd9Sstevel@tonic-gate #endif /* _FFR_HPUX_NSSWITCH */ 9277c478bd9Sstevel@tonic-gate 9287c478bd9Sstevel@tonic-gate #ifdef _USE_SUN_NSSWITCH_ 9297c478bd9Sstevel@tonic-gate # include <nsswitch.h> 9307c478bd9Sstevel@tonic-gate #endif /* _USE_SUN_NSSWITCH_ */ 9317c478bd9Sstevel@tonic-gate 9327c478bd9Sstevel@tonic-gate #if defined(ultrix) || (defined(__osf__) && defined(__alpha)) 9337c478bd9Sstevel@tonic-gate # define _USE_DEC_SVC_CONF_ 9347c478bd9Sstevel@tonic-gate #endif /* defined(ultrix) || (defined(__osf__) && defined(__alpha)) */ 9357c478bd9Sstevel@tonic-gate 9367c478bd9Sstevel@tonic-gate #ifdef _USE_DEC_SVC_CONF_ 9377c478bd9Sstevel@tonic-gate # include <sys/svcinfo.h> 9387c478bd9Sstevel@tonic-gate #endif /* _USE_DEC_SVC_CONF_ */ 9397c478bd9Sstevel@tonic-gate 9407c478bd9Sstevel@tonic-gate int 9417c478bd9Sstevel@tonic-gate switch_map_find(service, maptype, mapreturn) 9427c478bd9Sstevel@tonic-gate char *service; 9437c478bd9Sstevel@tonic-gate char *maptype[MAXMAPSTACK]; 9447c478bd9Sstevel@tonic-gate short mapreturn[MAXMAPACTIONS]; 9457c478bd9Sstevel@tonic-gate { 9467c478bd9Sstevel@tonic-gate int svcno = 0; 9477c478bd9Sstevel@tonic-gate int save_errno = errno; 9487c478bd9Sstevel@tonic-gate 9497c478bd9Sstevel@tonic-gate #ifdef _USE_SUN_NSSWITCH_ 9507c478bd9Sstevel@tonic-gate struct __nsw_switchconfig *nsw_conf; 9517c478bd9Sstevel@tonic-gate enum __nsw_parse_err pserr; 9527c478bd9Sstevel@tonic-gate struct __nsw_lookup *lk; 9537c478bd9Sstevel@tonic-gate static struct __nsw_lookup lkp0 = 9547c478bd9Sstevel@tonic-gate { "files", {1, 0, 0, 0}, NULL, NULL }; 9557c478bd9Sstevel@tonic-gate static struct __nsw_switchconfig lkp_default = 9567c478bd9Sstevel@tonic-gate { 0, "sendmail", 3, &lkp0 }; 9577c478bd9Sstevel@tonic-gate 9587c478bd9Sstevel@tonic-gate for (svcno = 0; svcno < MAXMAPACTIONS; svcno++) 9597c478bd9Sstevel@tonic-gate mapreturn[svcno] = 0; 9607c478bd9Sstevel@tonic-gate 9617c478bd9Sstevel@tonic-gate if ((nsw_conf = __nsw_getconfig(service, &pserr)) == NULL) 9627c478bd9Sstevel@tonic-gate lk = lkp_default.lookups; 9637c478bd9Sstevel@tonic-gate else 9647c478bd9Sstevel@tonic-gate lk = nsw_conf->lookups; 9657c478bd9Sstevel@tonic-gate svcno = 0; 9667c478bd9Sstevel@tonic-gate while (lk != NULL && svcno < MAXMAPSTACK) 9677c478bd9Sstevel@tonic-gate { 9687c478bd9Sstevel@tonic-gate maptype[svcno] = lk->service_name; 9697c478bd9Sstevel@tonic-gate if (lk->actions[__NSW_NOTFOUND] == __NSW_RETURN) 9707c478bd9Sstevel@tonic-gate mapreturn[MA_NOTFOUND] |= 1 << svcno; 9717c478bd9Sstevel@tonic-gate if (lk->actions[__NSW_TRYAGAIN] == __NSW_RETURN) 9727c478bd9Sstevel@tonic-gate mapreturn[MA_TRYAGAIN] |= 1 << svcno; 9737c478bd9Sstevel@tonic-gate if (lk->actions[__NSW_UNAVAIL] == __NSW_RETURN) 9747c478bd9Sstevel@tonic-gate mapreturn[MA_TRYAGAIN] |= 1 << svcno; 9757c478bd9Sstevel@tonic-gate svcno++; 9767c478bd9Sstevel@tonic-gate lk = lk->next; 9777c478bd9Sstevel@tonic-gate } 9787c478bd9Sstevel@tonic-gate errno = save_errno; 9797c478bd9Sstevel@tonic-gate return svcno; 9807c478bd9Sstevel@tonic-gate #endif /* _USE_SUN_NSSWITCH_ */ 9817c478bd9Sstevel@tonic-gate 9827c478bd9Sstevel@tonic-gate #ifdef _USE_DEC_SVC_CONF_ 9837c478bd9Sstevel@tonic-gate struct svcinfo *svcinfo; 9847c478bd9Sstevel@tonic-gate int svc; 9857c478bd9Sstevel@tonic-gate 9867c478bd9Sstevel@tonic-gate for (svcno = 0; svcno < MAXMAPACTIONS; svcno++) 9877c478bd9Sstevel@tonic-gate mapreturn[svcno] = 0; 9887c478bd9Sstevel@tonic-gate 9897c478bd9Sstevel@tonic-gate svcinfo = getsvc(); 9907c478bd9Sstevel@tonic-gate if (svcinfo == NULL) 9917c478bd9Sstevel@tonic-gate goto punt; 9927c478bd9Sstevel@tonic-gate if (strcmp(service, "hosts") == 0) 9937c478bd9Sstevel@tonic-gate svc = SVC_HOSTS; 9947c478bd9Sstevel@tonic-gate else if (strcmp(service, "aliases") == 0) 9957c478bd9Sstevel@tonic-gate svc = SVC_ALIASES; 9967c478bd9Sstevel@tonic-gate else if (strcmp(service, "passwd") == 0) 9977c478bd9Sstevel@tonic-gate svc = SVC_PASSWD; 9987c478bd9Sstevel@tonic-gate else 9997c478bd9Sstevel@tonic-gate { 10007c478bd9Sstevel@tonic-gate errno = save_errno; 10017c478bd9Sstevel@tonic-gate return -1; 10027c478bd9Sstevel@tonic-gate } 10037c478bd9Sstevel@tonic-gate for (svcno = 0; svcno < SVC_PATHSIZE && svcno < MAXMAPSTACK; svcno++) 10047c478bd9Sstevel@tonic-gate { 10057c478bd9Sstevel@tonic-gate switch (svcinfo->svcpath[svc][svcno]) 10067c478bd9Sstevel@tonic-gate { 10077c478bd9Sstevel@tonic-gate case SVC_LOCAL: 10087c478bd9Sstevel@tonic-gate maptype[svcno] = "files"; 10097c478bd9Sstevel@tonic-gate break; 10107c478bd9Sstevel@tonic-gate 10117c478bd9Sstevel@tonic-gate case SVC_YP: 10127c478bd9Sstevel@tonic-gate maptype[svcno] = "nis"; 10137c478bd9Sstevel@tonic-gate break; 10147c478bd9Sstevel@tonic-gate 10157c478bd9Sstevel@tonic-gate case SVC_BIND: 10167c478bd9Sstevel@tonic-gate maptype[svcno] = "dns"; 10177c478bd9Sstevel@tonic-gate break; 10187c478bd9Sstevel@tonic-gate 10197c478bd9Sstevel@tonic-gate # ifdef SVC_HESIOD 10207c478bd9Sstevel@tonic-gate case SVC_HESIOD: 10217c478bd9Sstevel@tonic-gate maptype[svcno] = "hesiod"; 10227c478bd9Sstevel@tonic-gate break; 10237c478bd9Sstevel@tonic-gate # endif /* SVC_HESIOD */ 10247c478bd9Sstevel@tonic-gate 10257c478bd9Sstevel@tonic-gate case SVC_LAST: 10267c478bd9Sstevel@tonic-gate errno = save_errno; 10277c478bd9Sstevel@tonic-gate return svcno; 10287c478bd9Sstevel@tonic-gate } 10297c478bd9Sstevel@tonic-gate } 10307c478bd9Sstevel@tonic-gate errno = save_errno; 10317c478bd9Sstevel@tonic-gate return svcno; 10327c478bd9Sstevel@tonic-gate #endif /* _USE_DEC_SVC_CONF_ */ 10337c478bd9Sstevel@tonic-gate 10347c478bd9Sstevel@tonic-gate #if !defined(_USE_SUN_NSSWITCH_) && !defined(_USE_DEC_SVC_CONF_) 10357c478bd9Sstevel@tonic-gate /* 10367c478bd9Sstevel@tonic-gate ** Fall-back mechanism. 10377c478bd9Sstevel@tonic-gate */ 10387c478bd9Sstevel@tonic-gate 10397c478bd9Sstevel@tonic-gate STAB *st; 10407c478bd9Sstevel@tonic-gate static time_t servicecachetime; /* time service switch was cached */ 10417c478bd9Sstevel@tonic-gate time_t now = curtime(); 10427c478bd9Sstevel@tonic-gate 10437c478bd9Sstevel@tonic-gate for (svcno = 0; svcno < MAXMAPACTIONS; svcno++) 10447c478bd9Sstevel@tonic-gate mapreturn[svcno] = 0; 10457c478bd9Sstevel@tonic-gate 10467c478bd9Sstevel@tonic-gate if ((now - servicecachetime) > (time_t) ServiceCacheMaxAge) 10477c478bd9Sstevel@tonic-gate { 10487c478bd9Sstevel@tonic-gate /* (re)read service switch */ 10497c478bd9Sstevel@tonic-gate register SM_FILE_T *fp; 10507c478bd9Sstevel@tonic-gate long sff = SFF_REGONLY|SFF_OPENASROOT|SFF_NOLOCK; 10517c478bd9Sstevel@tonic-gate 10527c478bd9Sstevel@tonic-gate if (!bitnset(DBS_LINKEDSERVICESWITCHFILEINWRITABLEDIR, 10537c478bd9Sstevel@tonic-gate DontBlameSendmail)) 10547c478bd9Sstevel@tonic-gate sff |= SFF_NOWLINK; 10557c478bd9Sstevel@tonic-gate 10567c478bd9Sstevel@tonic-gate if (ConfigFileRead) 10577c478bd9Sstevel@tonic-gate servicecachetime = now; 10587c478bd9Sstevel@tonic-gate fp = safefopen(ServiceSwitchFile, O_RDONLY, 0, sff); 10597c478bd9Sstevel@tonic-gate if (fp != NULL) 10607c478bd9Sstevel@tonic-gate { 10617c478bd9Sstevel@tonic-gate char buf[MAXLINE]; 10627c478bd9Sstevel@tonic-gate 10637c478bd9Sstevel@tonic-gate while (sm_io_fgets(fp, SM_TIME_DEFAULT, buf, 10647c478bd9Sstevel@tonic-gate sizeof buf) != NULL) 10657c478bd9Sstevel@tonic-gate { 10667c478bd9Sstevel@tonic-gate register char *p; 10677c478bd9Sstevel@tonic-gate 10687c478bd9Sstevel@tonic-gate p = strpbrk(buf, "#\n"); 10697c478bd9Sstevel@tonic-gate if (p != NULL) 10707c478bd9Sstevel@tonic-gate *p = '\0'; 10717c478bd9Sstevel@tonic-gate p = strpbrk(buf, " \t"); 10727c478bd9Sstevel@tonic-gate if (p != NULL) 10737c478bd9Sstevel@tonic-gate *p++ = '\0'; 10747c478bd9Sstevel@tonic-gate if (buf[0] == '\0') 10757c478bd9Sstevel@tonic-gate continue; 10767c478bd9Sstevel@tonic-gate if (p == NULL) 10777c478bd9Sstevel@tonic-gate { 10787c478bd9Sstevel@tonic-gate sm_syslog(LOG_ERR, NOQID, 10797c478bd9Sstevel@tonic-gate "Bad line on %.100s: %.100s", 10807c478bd9Sstevel@tonic-gate ServiceSwitchFile, 10817c478bd9Sstevel@tonic-gate buf); 10827c478bd9Sstevel@tonic-gate continue; 10837c478bd9Sstevel@tonic-gate } 10847c478bd9Sstevel@tonic-gate while (isspace(*p)) 10857c478bd9Sstevel@tonic-gate p++; 10867c478bd9Sstevel@tonic-gate if (*p == '\0') 10877c478bd9Sstevel@tonic-gate continue; 10887c478bd9Sstevel@tonic-gate 10897c478bd9Sstevel@tonic-gate /* 10907c478bd9Sstevel@tonic-gate ** Find/allocate space for this service entry. 10917c478bd9Sstevel@tonic-gate ** Space for all of the service strings 10927c478bd9Sstevel@tonic-gate ** are allocated at once. This means 10937c478bd9Sstevel@tonic-gate ** that we only have to free the first 10947c478bd9Sstevel@tonic-gate ** one to free all of them. 10957c478bd9Sstevel@tonic-gate */ 10967c478bd9Sstevel@tonic-gate 10977c478bd9Sstevel@tonic-gate st = stab(buf, ST_SERVICE, ST_ENTER); 10987c478bd9Sstevel@tonic-gate if (st->s_service[0] != NULL) 10997c478bd9Sstevel@tonic-gate sm_free((void *) st->s_service[0]); /* XXX */ 11007c478bd9Sstevel@tonic-gate p = newstr(p); 11017c478bd9Sstevel@tonic-gate for (svcno = 0; svcno < MAXMAPSTACK; ) 11027c478bd9Sstevel@tonic-gate { 11037c478bd9Sstevel@tonic-gate if (*p == '\0') 11047c478bd9Sstevel@tonic-gate break; 11057c478bd9Sstevel@tonic-gate st->s_service[svcno++] = p; 11067c478bd9Sstevel@tonic-gate p = strpbrk(p, " \t"); 11077c478bd9Sstevel@tonic-gate if (p == NULL) 11087c478bd9Sstevel@tonic-gate break; 11097c478bd9Sstevel@tonic-gate *p++ = '\0'; 11107c478bd9Sstevel@tonic-gate while (isspace(*p)) 11117c478bd9Sstevel@tonic-gate p++; 11127c478bd9Sstevel@tonic-gate } 11137c478bd9Sstevel@tonic-gate if (svcno < MAXMAPSTACK) 11147c478bd9Sstevel@tonic-gate st->s_service[svcno] = NULL; 11157c478bd9Sstevel@tonic-gate } 11167c478bd9Sstevel@tonic-gate (void) sm_io_close(fp, SM_TIME_DEFAULT); 11177c478bd9Sstevel@tonic-gate } 11187c478bd9Sstevel@tonic-gate } 11197c478bd9Sstevel@tonic-gate 11207c478bd9Sstevel@tonic-gate /* look up entry in cache */ 11217c478bd9Sstevel@tonic-gate st = stab(service, ST_SERVICE, ST_FIND); 11227c478bd9Sstevel@tonic-gate if (st != NULL && st->s_service[0] != NULL) 11237c478bd9Sstevel@tonic-gate { 11247c478bd9Sstevel@tonic-gate /* extract data */ 11257c478bd9Sstevel@tonic-gate svcno = 0; 11267c478bd9Sstevel@tonic-gate while (svcno < MAXMAPSTACK) 11277c478bd9Sstevel@tonic-gate { 11287c478bd9Sstevel@tonic-gate maptype[svcno] = st->s_service[svcno]; 11297c478bd9Sstevel@tonic-gate if (maptype[svcno++] == NULL) 11307c478bd9Sstevel@tonic-gate break; 11317c478bd9Sstevel@tonic-gate } 11327c478bd9Sstevel@tonic-gate errno = save_errno; 11337c478bd9Sstevel@tonic-gate return --svcno; 11347c478bd9Sstevel@tonic-gate } 11357c478bd9Sstevel@tonic-gate #endif /* !defined(_USE_SUN_NSSWITCH_) && !defined(_USE_DEC_SVC_CONF_) */ 11367c478bd9Sstevel@tonic-gate 11377c478bd9Sstevel@tonic-gate #if !defined(_USE_SUN_NSSWITCH_) 11387c478bd9Sstevel@tonic-gate /* if the service file doesn't work, use an absolute fallback */ 11397c478bd9Sstevel@tonic-gate # ifdef _USE_DEC_SVC_CONF_ 11407c478bd9Sstevel@tonic-gate punt: 11417c478bd9Sstevel@tonic-gate # endif /* _USE_DEC_SVC_CONF_ */ 11427c478bd9Sstevel@tonic-gate for (svcno = 0; svcno < MAXMAPACTIONS; svcno++) 11437c478bd9Sstevel@tonic-gate mapreturn[svcno] = 0; 11447c478bd9Sstevel@tonic-gate svcno = 0; 11457c478bd9Sstevel@tonic-gate if (strcmp(service, "aliases") == 0) 11467c478bd9Sstevel@tonic-gate { 11477c478bd9Sstevel@tonic-gate maptype[svcno++] = "files"; 11487c478bd9Sstevel@tonic-gate # if defined(AUTO_NETINFO_ALIASES) && defined (NETINFO) 11497c478bd9Sstevel@tonic-gate maptype[svcno++] = "netinfo"; 11507c478bd9Sstevel@tonic-gate # endif /* defined(AUTO_NETINFO_ALIASES) && defined (NETINFO) */ 11517c478bd9Sstevel@tonic-gate # ifdef AUTO_NIS_ALIASES 11527c478bd9Sstevel@tonic-gate # if NISPLUS 11537c478bd9Sstevel@tonic-gate maptype[svcno++] = "nisplus"; 11547c478bd9Sstevel@tonic-gate # endif /* NISPLUS */ 11557c478bd9Sstevel@tonic-gate # if NIS 11567c478bd9Sstevel@tonic-gate maptype[svcno++] = "nis"; 11577c478bd9Sstevel@tonic-gate # endif /* NIS */ 11587c478bd9Sstevel@tonic-gate # endif /* AUTO_NIS_ALIASES */ 11597c478bd9Sstevel@tonic-gate errno = save_errno; 11607c478bd9Sstevel@tonic-gate return svcno; 11617c478bd9Sstevel@tonic-gate } 11627c478bd9Sstevel@tonic-gate if (strcmp(service, "hosts") == 0) 11637c478bd9Sstevel@tonic-gate { 11647c478bd9Sstevel@tonic-gate # if NAMED_BIND 11657c478bd9Sstevel@tonic-gate maptype[svcno++] = "dns"; 11667c478bd9Sstevel@tonic-gate # else /* NAMED_BIND */ 11677c478bd9Sstevel@tonic-gate # if defined(sun) && !defined(BSD) 11687c478bd9Sstevel@tonic-gate /* SunOS */ 11697c478bd9Sstevel@tonic-gate maptype[svcno++] = "nis"; 11707c478bd9Sstevel@tonic-gate # endif /* defined(sun) && !defined(BSD) */ 11717c478bd9Sstevel@tonic-gate # endif /* NAMED_BIND */ 11727c478bd9Sstevel@tonic-gate # if defined(AUTO_NETINFO_HOSTS) && defined (NETINFO) 11737c478bd9Sstevel@tonic-gate maptype[svcno++] = "netinfo"; 11747c478bd9Sstevel@tonic-gate # endif /* defined(AUTO_NETINFO_HOSTS) && defined (NETINFO) */ 11757c478bd9Sstevel@tonic-gate maptype[svcno++] = "files"; 11767c478bd9Sstevel@tonic-gate errno = save_errno; 11777c478bd9Sstevel@tonic-gate return svcno; 11787c478bd9Sstevel@tonic-gate } 11797c478bd9Sstevel@tonic-gate errno = save_errno; 11807c478bd9Sstevel@tonic-gate return -1; 11817c478bd9Sstevel@tonic-gate #endif /* !defined(_USE_SUN_NSSWITCH_) */ 11827c478bd9Sstevel@tonic-gate } 11837c478bd9Sstevel@tonic-gate /* 11847c478bd9Sstevel@tonic-gate ** USERNAME -- return the user id of the logged in user. 11857c478bd9Sstevel@tonic-gate ** 11867c478bd9Sstevel@tonic-gate ** Parameters: 11877c478bd9Sstevel@tonic-gate ** none. 11887c478bd9Sstevel@tonic-gate ** 11897c478bd9Sstevel@tonic-gate ** Returns: 11907c478bd9Sstevel@tonic-gate ** The login name of the logged in user. 11917c478bd9Sstevel@tonic-gate ** 11927c478bd9Sstevel@tonic-gate ** Side Effects: 11937c478bd9Sstevel@tonic-gate ** none. 11947c478bd9Sstevel@tonic-gate ** 11957c478bd9Sstevel@tonic-gate ** Notes: 11967c478bd9Sstevel@tonic-gate ** The return value is statically allocated. 11977c478bd9Sstevel@tonic-gate */ 11987c478bd9Sstevel@tonic-gate 11997c478bd9Sstevel@tonic-gate char * 12007c478bd9Sstevel@tonic-gate username() 12017c478bd9Sstevel@tonic-gate { 12027c478bd9Sstevel@tonic-gate static char *myname = NULL; 12037c478bd9Sstevel@tonic-gate extern char *getlogin(); 12047c478bd9Sstevel@tonic-gate register struct passwd *pw; 12057c478bd9Sstevel@tonic-gate 12067c478bd9Sstevel@tonic-gate /* cache the result */ 12077c478bd9Sstevel@tonic-gate if (myname == NULL) 12087c478bd9Sstevel@tonic-gate { 12097c478bd9Sstevel@tonic-gate myname = getlogin(); 12107c478bd9Sstevel@tonic-gate if (myname == NULL || myname[0] == '\0') 12117c478bd9Sstevel@tonic-gate { 12127c478bd9Sstevel@tonic-gate pw = sm_getpwuid(RealUid); 12137c478bd9Sstevel@tonic-gate if (pw != NULL) 12147c478bd9Sstevel@tonic-gate myname = pw->pw_name; 12157c478bd9Sstevel@tonic-gate } 12167c478bd9Sstevel@tonic-gate else 12177c478bd9Sstevel@tonic-gate { 12187c478bd9Sstevel@tonic-gate uid_t uid = RealUid; 12197c478bd9Sstevel@tonic-gate 12207c478bd9Sstevel@tonic-gate if ((pw = sm_getpwnam(myname)) == NULL || 12217c478bd9Sstevel@tonic-gate (uid != 0 && uid != pw->pw_uid)) 12227c478bd9Sstevel@tonic-gate { 12237c478bd9Sstevel@tonic-gate pw = sm_getpwuid(uid); 12247c478bd9Sstevel@tonic-gate if (pw != NULL) 12257c478bd9Sstevel@tonic-gate myname = pw->pw_name; 12267c478bd9Sstevel@tonic-gate } 12277c478bd9Sstevel@tonic-gate } 12287c478bd9Sstevel@tonic-gate if (myname == NULL || myname[0] == '\0') 12297c478bd9Sstevel@tonic-gate { 12307c478bd9Sstevel@tonic-gate syserr("554 5.3.0 Who are you?"); 12317c478bd9Sstevel@tonic-gate myname = "postmaster"; 12327c478bd9Sstevel@tonic-gate } 12337c478bd9Sstevel@tonic-gate else if (strpbrk(myname, ",;:/|\"\\") != NULL) 12347c478bd9Sstevel@tonic-gate myname = addquotes(myname, NULL); 12357c478bd9Sstevel@tonic-gate else 12367c478bd9Sstevel@tonic-gate myname = sm_pstrdup_x(myname); 12377c478bd9Sstevel@tonic-gate } 12387c478bd9Sstevel@tonic-gate return myname; 12397c478bd9Sstevel@tonic-gate } 12407c478bd9Sstevel@tonic-gate /* 12417c478bd9Sstevel@tonic-gate ** TTYPATH -- Get the path of the user's tty 12427c478bd9Sstevel@tonic-gate ** 12437c478bd9Sstevel@tonic-gate ** Returns the pathname of the user's tty. Returns NULL if 12447c478bd9Sstevel@tonic-gate ** the user is not logged in or if s/he has write permission 12457c478bd9Sstevel@tonic-gate ** denied. 12467c478bd9Sstevel@tonic-gate ** 12477c478bd9Sstevel@tonic-gate ** Parameters: 12487c478bd9Sstevel@tonic-gate ** none 12497c478bd9Sstevel@tonic-gate ** 12507c478bd9Sstevel@tonic-gate ** Returns: 12517c478bd9Sstevel@tonic-gate ** pathname of the user's tty. 12527c478bd9Sstevel@tonic-gate ** NULL if not logged in or write permission denied. 12537c478bd9Sstevel@tonic-gate ** 12547c478bd9Sstevel@tonic-gate ** Side Effects: 12557c478bd9Sstevel@tonic-gate ** none. 12567c478bd9Sstevel@tonic-gate ** 12577c478bd9Sstevel@tonic-gate ** WARNING: 12587c478bd9Sstevel@tonic-gate ** Return value is in a local buffer. 12597c478bd9Sstevel@tonic-gate ** 12607c478bd9Sstevel@tonic-gate ** Called By: 12617c478bd9Sstevel@tonic-gate ** savemail 12627c478bd9Sstevel@tonic-gate */ 12637c478bd9Sstevel@tonic-gate 12647c478bd9Sstevel@tonic-gate char * 12657c478bd9Sstevel@tonic-gate ttypath() 12667c478bd9Sstevel@tonic-gate { 12677c478bd9Sstevel@tonic-gate struct stat stbuf; 12687c478bd9Sstevel@tonic-gate register char *pathn; 12697c478bd9Sstevel@tonic-gate extern char *ttyname(); 12707c478bd9Sstevel@tonic-gate extern char *getlogin(); 12717c478bd9Sstevel@tonic-gate 12727c478bd9Sstevel@tonic-gate /* compute the pathname of the controlling tty */ 12737c478bd9Sstevel@tonic-gate if ((pathn = ttyname(2)) == NULL && (pathn = ttyname(1)) == NULL && 12747c478bd9Sstevel@tonic-gate (pathn = ttyname(0)) == NULL) 12757c478bd9Sstevel@tonic-gate { 12767c478bd9Sstevel@tonic-gate errno = 0; 12777c478bd9Sstevel@tonic-gate return NULL; 12787c478bd9Sstevel@tonic-gate } 12797c478bd9Sstevel@tonic-gate 12807c478bd9Sstevel@tonic-gate /* see if we have write permission */ 12817c478bd9Sstevel@tonic-gate if (stat(pathn, &stbuf) < 0 || !bitset(S_IWOTH, stbuf.st_mode)) 12827c478bd9Sstevel@tonic-gate { 12837c478bd9Sstevel@tonic-gate errno = 0; 12847c478bd9Sstevel@tonic-gate return NULL; 12857c478bd9Sstevel@tonic-gate } 12867c478bd9Sstevel@tonic-gate 12877c478bd9Sstevel@tonic-gate /* see if the user is logged in */ 12887c478bd9Sstevel@tonic-gate if (getlogin() == NULL) 12897c478bd9Sstevel@tonic-gate return NULL; 12907c478bd9Sstevel@tonic-gate 12917c478bd9Sstevel@tonic-gate /* looks good */ 12927c478bd9Sstevel@tonic-gate return pathn; 12937c478bd9Sstevel@tonic-gate } 12947c478bd9Sstevel@tonic-gate /* 12957c478bd9Sstevel@tonic-gate ** CHECKCOMPAT -- check for From and To person compatible. 12967c478bd9Sstevel@tonic-gate ** 12977c478bd9Sstevel@tonic-gate ** This routine can be supplied on a per-installation basis 12987c478bd9Sstevel@tonic-gate ** to determine whether a person is allowed to send a message. 12997c478bd9Sstevel@tonic-gate ** This allows restriction of certain types of internet 13007c478bd9Sstevel@tonic-gate ** forwarding or registration of users. 13017c478bd9Sstevel@tonic-gate ** 13027c478bd9Sstevel@tonic-gate ** If the hosts are found to be incompatible, an error 13037c478bd9Sstevel@tonic-gate ** message should be given using "usrerr" and an EX_ code 13047c478bd9Sstevel@tonic-gate ** should be returned. You can also set to->q_status to 13057c478bd9Sstevel@tonic-gate ** a DSN-style status code. 13067c478bd9Sstevel@tonic-gate ** 13077c478bd9Sstevel@tonic-gate ** EF_NO_BODY_RETN can be set in e->e_flags to suppress the 13087c478bd9Sstevel@tonic-gate ** body during the return-to-sender function; this should be done 13097c478bd9Sstevel@tonic-gate ** on huge messages. This bit may already be set by the ESMTP 13107c478bd9Sstevel@tonic-gate ** protocol. 13117c478bd9Sstevel@tonic-gate ** 13127c478bd9Sstevel@tonic-gate ** Parameters: 13137c478bd9Sstevel@tonic-gate ** to -- the person being sent to. 13147c478bd9Sstevel@tonic-gate ** 13157c478bd9Sstevel@tonic-gate ** Returns: 13167c478bd9Sstevel@tonic-gate ** an exit status 13177c478bd9Sstevel@tonic-gate ** 13187c478bd9Sstevel@tonic-gate ** Side Effects: 13197c478bd9Sstevel@tonic-gate ** none (unless you include the usrerr stuff) 13207c478bd9Sstevel@tonic-gate */ 13217c478bd9Sstevel@tonic-gate 13227c478bd9Sstevel@tonic-gate int 13237c478bd9Sstevel@tonic-gate checkcompat(to, e) 13247c478bd9Sstevel@tonic-gate register ADDRESS *to; 13257c478bd9Sstevel@tonic-gate register ENVELOPE *e; 13267c478bd9Sstevel@tonic-gate { 13277c478bd9Sstevel@tonic-gate if (tTd(49, 1)) 13287c478bd9Sstevel@tonic-gate sm_dprintf("checkcompat(to=%s, from=%s)\n", 13297c478bd9Sstevel@tonic-gate to->q_paddr, e->e_from.q_paddr); 13307c478bd9Sstevel@tonic-gate 13317c478bd9Sstevel@tonic-gate #ifdef EXAMPLE_CODE 13327c478bd9Sstevel@tonic-gate /* this code is intended as an example only */ 13337c478bd9Sstevel@tonic-gate register STAB *s; 13347c478bd9Sstevel@tonic-gate 13357c478bd9Sstevel@tonic-gate s = stab("arpa", ST_MAILER, ST_FIND); 13367c478bd9Sstevel@tonic-gate if (s != NULL && strcmp(e->e_from.q_mailer->m_name, "local") != 0 && 13377c478bd9Sstevel@tonic-gate to->q_mailer == s->s_mailer) 13387c478bd9Sstevel@tonic-gate { 13397c478bd9Sstevel@tonic-gate usrerr("553 No ARPA mail through this machine: see your system administration"); 13407c478bd9Sstevel@tonic-gate /* e->e_flags |= EF_NO_BODY_RETN; to suppress body on return */ 13417c478bd9Sstevel@tonic-gate to->q_status = "5.7.1"; 13427c478bd9Sstevel@tonic-gate return EX_UNAVAILABLE; 13437c478bd9Sstevel@tonic-gate } 13447c478bd9Sstevel@tonic-gate #endif /* EXAMPLE_CODE */ 13457c478bd9Sstevel@tonic-gate return EX_OK; 13467c478bd9Sstevel@tonic-gate } 13477c478bd9Sstevel@tonic-gate /* 13487c478bd9Sstevel@tonic-gate ** INIT_MD -- do machine dependent initializations 13497c478bd9Sstevel@tonic-gate ** 13507c478bd9Sstevel@tonic-gate ** Systems that have global modes that should be set should do 13517c478bd9Sstevel@tonic-gate ** them here rather than in main. 13527c478bd9Sstevel@tonic-gate */ 13537c478bd9Sstevel@tonic-gate 13547c478bd9Sstevel@tonic-gate #ifdef _AUX_SOURCE 13557c478bd9Sstevel@tonic-gate # include <compat.h> 13567c478bd9Sstevel@tonic-gate #endif /* _AUX_SOURCE */ 13577c478bd9Sstevel@tonic-gate 13587c478bd9Sstevel@tonic-gate #if SHARE_V1 13597c478bd9Sstevel@tonic-gate # include <shares.h> 13607c478bd9Sstevel@tonic-gate #endif /* SHARE_V1 */ 13617c478bd9Sstevel@tonic-gate 13627c478bd9Sstevel@tonic-gate void 13637c478bd9Sstevel@tonic-gate init_md(argc, argv) 13647c478bd9Sstevel@tonic-gate int argc; 13657c478bd9Sstevel@tonic-gate char **argv; 13667c478bd9Sstevel@tonic-gate { 13677c478bd9Sstevel@tonic-gate #ifdef _AUX_SOURCE 13687c478bd9Sstevel@tonic-gate setcompat(getcompat() | COMPAT_BSDPROT); 13697c478bd9Sstevel@tonic-gate #endif /* _AUX_SOURCE */ 13707c478bd9Sstevel@tonic-gate 13717c478bd9Sstevel@tonic-gate #ifdef SUN_EXTENSIONS 13727c478bd9Sstevel@tonic-gate init_md_sun(); 13737c478bd9Sstevel@tonic-gate #endif /* SUN_EXTENSIONS */ 13747c478bd9Sstevel@tonic-gate 13757c478bd9Sstevel@tonic-gate #if _CONVEX_SOURCE 13767c478bd9Sstevel@tonic-gate /* keep gethostby*() from stripping the local domain name */ 13777c478bd9Sstevel@tonic-gate set_domain_trim_off(); 13787c478bd9Sstevel@tonic-gate #endif /* _CONVEX_SOURCE */ 13797c478bd9Sstevel@tonic-gate #ifdef __QNX__ 13807c478bd9Sstevel@tonic-gate /* 13817c478bd9Sstevel@tonic-gate ** Due to QNX's network distributed nature, you can target a tcpip 13827c478bd9Sstevel@tonic-gate ** stack on a different node in the qnx network; this patch lets 13837c478bd9Sstevel@tonic-gate ** this feature work. The __sock_locate() must be done before the 13847c478bd9Sstevel@tonic-gate ** environment is clear. 13857c478bd9Sstevel@tonic-gate */ 13867c478bd9Sstevel@tonic-gate __sock_locate(); 13877c478bd9Sstevel@tonic-gate #endif /* __QNX__ */ 13887c478bd9Sstevel@tonic-gate #if SECUREWARE || defined(_SCO_unix_) 13897c478bd9Sstevel@tonic-gate set_auth_parameters(argc, argv); 13907c478bd9Sstevel@tonic-gate 13917c478bd9Sstevel@tonic-gate # ifdef _SCO_unix_ 13927c478bd9Sstevel@tonic-gate /* 13937c478bd9Sstevel@tonic-gate ** This is required for highest security levels (the kernel 13947c478bd9Sstevel@tonic-gate ** won't let it call set*uid() or run setuid binaries without 13957c478bd9Sstevel@tonic-gate ** it). It may be necessary on other SECUREWARE systems. 13967c478bd9Sstevel@tonic-gate */ 13977c478bd9Sstevel@tonic-gate 13987c478bd9Sstevel@tonic-gate if (getluid() == -1) 13997c478bd9Sstevel@tonic-gate setluid(0); 14007c478bd9Sstevel@tonic-gate # endif /* _SCO_unix_ */ 14017c478bd9Sstevel@tonic-gate #endif /* SECUREWARE || defined(_SCO_unix_) */ 14027c478bd9Sstevel@tonic-gate 14037c478bd9Sstevel@tonic-gate 14047c478bd9Sstevel@tonic-gate #ifdef VENDOR_DEFAULT 14057c478bd9Sstevel@tonic-gate VendorCode = VENDOR_DEFAULT; 14067c478bd9Sstevel@tonic-gate #else /* VENDOR_DEFAULT */ 14077c478bd9Sstevel@tonic-gate VendorCode = VENDOR_BERKELEY; 14087c478bd9Sstevel@tonic-gate #endif /* VENDOR_DEFAULT */ 14097c478bd9Sstevel@tonic-gate } 14107c478bd9Sstevel@tonic-gate /* 14117c478bd9Sstevel@tonic-gate ** INIT_VENDOR_MACROS -- vendor-dependent macro initializations 14127c478bd9Sstevel@tonic-gate ** 14137c478bd9Sstevel@tonic-gate ** Called once, on startup. 14147c478bd9Sstevel@tonic-gate ** 14157c478bd9Sstevel@tonic-gate ** Parameters: 14167c478bd9Sstevel@tonic-gate ** e -- the global envelope. 14177c478bd9Sstevel@tonic-gate ** 14187c478bd9Sstevel@tonic-gate ** Returns: 14197c478bd9Sstevel@tonic-gate ** none. 14207c478bd9Sstevel@tonic-gate ** 14217c478bd9Sstevel@tonic-gate ** Side Effects: 14227c478bd9Sstevel@tonic-gate ** vendor-dependent. 14237c478bd9Sstevel@tonic-gate */ 14247c478bd9Sstevel@tonic-gate 14257c478bd9Sstevel@tonic-gate void 14267c478bd9Sstevel@tonic-gate init_vendor_macros(e) 14277c478bd9Sstevel@tonic-gate register ENVELOPE *e; 14287c478bd9Sstevel@tonic-gate { 14297c478bd9Sstevel@tonic-gate } 14307c478bd9Sstevel@tonic-gate /* 14317c478bd9Sstevel@tonic-gate ** GETLA -- get the current load average 14327c478bd9Sstevel@tonic-gate ** 14337c478bd9Sstevel@tonic-gate ** This code stolen from la.c. 14347c478bd9Sstevel@tonic-gate ** 14357c478bd9Sstevel@tonic-gate ** Parameters: 14367c478bd9Sstevel@tonic-gate ** none. 14377c478bd9Sstevel@tonic-gate ** 14387c478bd9Sstevel@tonic-gate ** Returns: 14397c478bd9Sstevel@tonic-gate ** The current load average as an integer. 14407c478bd9Sstevel@tonic-gate ** 14417c478bd9Sstevel@tonic-gate ** Side Effects: 14427c478bd9Sstevel@tonic-gate ** none. 14437c478bd9Sstevel@tonic-gate */ 14447c478bd9Sstevel@tonic-gate 14457c478bd9Sstevel@tonic-gate /* try to guess what style of load average we have */ 14467c478bd9Sstevel@tonic-gate #define LA_ZERO 1 /* always return load average as zero */ 14477c478bd9Sstevel@tonic-gate #define LA_INT 2 /* read kmem for avenrun; interpret as long */ 14487c478bd9Sstevel@tonic-gate #define LA_FLOAT 3 /* read kmem for avenrun; interpret as float */ 14497c478bd9Sstevel@tonic-gate #define LA_SUBR 4 /* call getloadavg */ 14507c478bd9Sstevel@tonic-gate #define LA_MACH 5 /* MACH load averages (as on NeXT boxes) */ 14517c478bd9Sstevel@tonic-gate #define LA_SHORT 6 /* read kmem for avenrun; interpret as short */ 14527c478bd9Sstevel@tonic-gate #define LA_PROCSTR 7 /* read string ("1.17") from /proc/loadavg */ 14537c478bd9Sstevel@tonic-gate #define LA_READKSYM 8 /* SVR4: use MIOC_READKSYM ioctl call */ 14547c478bd9Sstevel@tonic-gate #define LA_DGUX 9 /* special DGUX implementation */ 14557c478bd9Sstevel@tonic-gate #define LA_HPUX 10 /* special HPUX implementation */ 14567c478bd9Sstevel@tonic-gate #define LA_IRIX6 11 /* special IRIX 6.2 implementation */ 14577c478bd9Sstevel@tonic-gate #define LA_KSTAT 12 /* special Solaris kstat(3k) implementation */ 14587c478bd9Sstevel@tonic-gate #define LA_DEVSHORT 13 /* read short from a device */ 14597c478bd9Sstevel@tonic-gate #define LA_ALPHAOSF 14 /* Digital UNIX (OSF/1 on Alpha) table() call */ 14607c478bd9Sstevel@tonic-gate #define LA_PSET 15 /* Solaris per-processor-set load average */ 14617c478bd9Sstevel@tonic-gate #define LA_LONGLONG 17 /* read kmem for avenrun; interpret as long long */ 14627c478bd9Sstevel@tonic-gate 14637c478bd9Sstevel@tonic-gate /* do guesses based on general OS type */ 14647c478bd9Sstevel@tonic-gate #ifndef LA_TYPE 14657c478bd9Sstevel@tonic-gate # define LA_TYPE LA_ZERO 14667c478bd9Sstevel@tonic-gate #endif /* ! LA_TYPE */ 14677c478bd9Sstevel@tonic-gate 14687c478bd9Sstevel@tonic-gate #ifndef FSHIFT 14697c478bd9Sstevel@tonic-gate # if defined(unixpc) 14707c478bd9Sstevel@tonic-gate # define FSHIFT 5 14717c478bd9Sstevel@tonic-gate # endif /* defined(unixpc) */ 14727c478bd9Sstevel@tonic-gate 14737c478bd9Sstevel@tonic-gate # if defined(__alpha) || defined(IRIX) 14747c478bd9Sstevel@tonic-gate # define FSHIFT 10 14757c478bd9Sstevel@tonic-gate # endif /* defined(__alpha) || defined(IRIX) */ 14767c478bd9Sstevel@tonic-gate 14777c478bd9Sstevel@tonic-gate #endif /* ! FSHIFT */ 14787c478bd9Sstevel@tonic-gate 14797c478bd9Sstevel@tonic-gate #ifndef FSHIFT 14807c478bd9Sstevel@tonic-gate # define FSHIFT 8 14817c478bd9Sstevel@tonic-gate #endif /* ! FSHIFT */ 14827c478bd9Sstevel@tonic-gate 14837c478bd9Sstevel@tonic-gate #ifndef FSCALE 14847c478bd9Sstevel@tonic-gate # define FSCALE (1 << FSHIFT) 14857c478bd9Sstevel@tonic-gate #endif /* ! FSCALE */ 14867c478bd9Sstevel@tonic-gate 14877c478bd9Sstevel@tonic-gate #ifndef LA_AVENRUN 14887c478bd9Sstevel@tonic-gate # ifdef SYSTEM5 14897c478bd9Sstevel@tonic-gate # define LA_AVENRUN "avenrun" 14907c478bd9Sstevel@tonic-gate # else /* SYSTEM5 */ 14917c478bd9Sstevel@tonic-gate # define LA_AVENRUN "_avenrun" 14927c478bd9Sstevel@tonic-gate # endif /* SYSTEM5 */ 14937c478bd9Sstevel@tonic-gate #endif /* ! LA_AVENRUN */ 14947c478bd9Sstevel@tonic-gate 14957c478bd9Sstevel@tonic-gate /* _PATH_KMEM should be defined in <paths.h> */ 14967c478bd9Sstevel@tonic-gate #ifndef _PATH_KMEM 14977c478bd9Sstevel@tonic-gate # define _PATH_KMEM "/dev/kmem" 14987c478bd9Sstevel@tonic-gate #endif /* ! _PATH_KMEM */ 14997c478bd9Sstevel@tonic-gate 15007c478bd9Sstevel@tonic-gate #if (LA_TYPE == LA_INT) || (LA_TYPE == LA_FLOAT) || (LA_TYPE == LA_SHORT) || (LA_TYPE == LA_LONGLONG) 15017c478bd9Sstevel@tonic-gate 15027c478bd9Sstevel@tonic-gate # include <nlist.h> 15037c478bd9Sstevel@tonic-gate 15047c478bd9Sstevel@tonic-gate /* _PATH_UNIX should be defined in <paths.h> */ 15057c478bd9Sstevel@tonic-gate # ifndef _PATH_UNIX 15067c478bd9Sstevel@tonic-gate # if defined(SYSTEM5) 15077c478bd9Sstevel@tonic-gate # define _PATH_UNIX "/unix" 15087c478bd9Sstevel@tonic-gate # else /* defined(SYSTEM5) */ 15097c478bd9Sstevel@tonic-gate # define _PATH_UNIX "/vmunix" 15107c478bd9Sstevel@tonic-gate # endif /* defined(SYSTEM5) */ 15117c478bd9Sstevel@tonic-gate # endif /* ! _PATH_UNIX */ 15127c478bd9Sstevel@tonic-gate 15137c478bd9Sstevel@tonic-gate # ifdef _AUX_SOURCE 15147c478bd9Sstevel@tonic-gate struct nlist Nl[2]; 15157c478bd9Sstevel@tonic-gate # else /* _AUX_SOURCE */ 15167c478bd9Sstevel@tonic-gate struct nlist Nl[] = 15177c478bd9Sstevel@tonic-gate { 15187c478bd9Sstevel@tonic-gate { LA_AVENRUN }, 15197c478bd9Sstevel@tonic-gate { 0 }, 15207c478bd9Sstevel@tonic-gate }; 15217c478bd9Sstevel@tonic-gate # endif /* _AUX_SOURCE */ 15227c478bd9Sstevel@tonic-gate # define X_AVENRUN 0 15237c478bd9Sstevel@tonic-gate 15247c478bd9Sstevel@tonic-gate int 15257c478bd9Sstevel@tonic-gate getla() 15267c478bd9Sstevel@tonic-gate { 15277c478bd9Sstevel@tonic-gate int j; 15287c478bd9Sstevel@tonic-gate static int kmem = -1; 15297c478bd9Sstevel@tonic-gate # if LA_TYPE == LA_INT 15307c478bd9Sstevel@tonic-gate long avenrun[3]; 15317c478bd9Sstevel@tonic-gate # else /* LA_TYPE == LA_INT */ 15327c478bd9Sstevel@tonic-gate # if LA_TYPE == LA_SHORT 15337c478bd9Sstevel@tonic-gate short avenrun[3]; 15347c478bd9Sstevel@tonic-gate # else 15357c478bd9Sstevel@tonic-gate # if LA_TYPE == LA_LONGLONG 15367c478bd9Sstevel@tonic-gate long long avenrun[3]; 15377c478bd9Sstevel@tonic-gate # else /* LA_TYPE == LA_LONGLONG */ 15387c478bd9Sstevel@tonic-gate double avenrun[3]; 15397c478bd9Sstevel@tonic-gate # endif /* LA_TYPE == LA_LONGLONG */ 15407c478bd9Sstevel@tonic-gate # endif /* LA_TYPE == LA_SHORT */ 15417c478bd9Sstevel@tonic-gate # endif /* LA_TYPE == LA_INT */ 15427c478bd9Sstevel@tonic-gate extern off_t lseek(); 15437c478bd9Sstevel@tonic-gate 15447c478bd9Sstevel@tonic-gate if (kmem < 0) 15457c478bd9Sstevel@tonic-gate { 15467c478bd9Sstevel@tonic-gate # ifdef _AUX_SOURCE 15477c478bd9Sstevel@tonic-gate (void) sm_strlcpy(Nl[X_AVENRUN].n_name, LA_AVENRUN, 15487c478bd9Sstevel@tonic-gate sizeof Nl[X_AVENRUN].n_name); 15497c478bd9Sstevel@tonic-gate Nl[1].n_name[0] = '\0'; 15507c478bd9Sstevel@tonic-gate # endif /* _AUX_SOURCE */ 15517c478bd9Sstevel@tonic-gate 15527c478bd9Sstevel@tonic-gate # if defined(_AIX3) || defined(_AIX4) 15537c478bd9Sstevel@tonic-gate if (knlist(Nl, 1, sizeof Nl[0]) < 0) 15547c478bd9Sstevel@tonic-gate # else /* defined(_AIX3) || defined(_AIX4) */ 15557c478bd9Sstevel@tonic-gate if (nlist(_PATH_UNIX, Nl) < 0) 15567c478bd9Sstevel@tonic-gate # endif /* defined(_AIX3) || defined(_AIX4) */ 15577c478bd9Sstevel@tonic-gate { 15587c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 15597c478bd9Sstevel@tonic-gate sm_dprintf("getla: nlist(%s): %s\n", _PATH_UNIX, 15607c478bd9Sstevel@tonic-gate sm_errstring(errno)); 15617c478bd9Sstevel@tonic-gate return -1; 15627c478bd9Sstevel@tonic-gate } 15637c478bd9Sstevel@tonic-gate if (Nl[X_AVENRUN].n_value == 0) 15647c478bd9Sstevel@tonic-gate { 15657c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 15667c478bd9Sstevel@tonic-gate sm_dprintf("getla: nlist(%s, %s) ==> 0\n", 15677c478bd9Sstevel@tonic-gate _PATH_UNIX, LA_AVENRUN); 15687c478bd9Sstevel@tonic-gate return -1; 15697c478bd9Sstevel@tonic-gate } 15707c478bd9Sstevel@tonic-gate # ifdef NAMELISTMASK 15717c478bd9Sstevel@tonic-gate Nl[X_AVENRUN].n_value &= NAMELISTMASK; 15727c478bd9Sstevel@tonic-gate # endif /* NAMELISTMASK */ 15737c478bd9Sstevel@tonic-gate 15747c478bd9Sstevel@tonic-gate kmem = open(_PATH_KMEM, 0, 0); 15757c478bd9Sstevel@tonic-gate if (kmem < 0) 15767c478bd9Sstevel@tonic-gate { 15777c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 15787c478bd9Sstevel@tonic-gate sm_dprintf("getla: open(/dev/kmem): %s\n", 15797c478bd9Sstevel@tonic-gate sm_errstring(errno)); 15807c478bd9Sstevel@tonic-gate return -1; 15817c478bd9Sstevel@tonic-gate } 15827c478bd9Sstevel@tonic-gate if ((j = fcntl(kmem, F_GETFD, 0)) < 0 || 15837c478bd9Sstevel@tonic-gate fcntl(kmem, F_SETFD, j | FD_CLOEXEC) < 0) 15847c478bd9Sstevel@tonic-gate { 15857c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 15867c478bd9Sstevel@tonic-gate sm_dprintf("getla: fcntl(/dev/kmem, FD_CLOEXEC): %s\n", 15877c478bd9Sstevel@tonic-gate sm_errstring(errno)); 15887c478bd9Sstevel@tonic-gate (void) close(kmem); 15897c478bd9Sstevel@tonic-gate kmem = -1; 15907c478bd9Sstevel@tonic-gate return -1; 15917c478bd9Sstevel@tonic-gate } 15927c478bd9Sstevel@tonic-gate } 15937c478bd9Sstevel@tonic-gate if (tTd(3, 20)) 15947c478bd9Sstevel@tonic-gate sm_dprintf("getla: symbol address = %#lx\n", 15957c478bd9Sstevel@tonic-gate (unsigned long) Nl[X_AVENRUN].n_value); 15967c478bd9Sstevel@tonic-gate if (lseek(kmem, (off_t) Nl[X_AVENRUN].n_value, SEEK_SET) == -1 || 15977c478bd9Sstevel@tonic-gate read(kmem, (char *) avenrun, sizeof(avenrun)) < sizeof(avenrun)) 15987c478bd9Sstevel@tonic-gate { 15997c478bd9Sstevel@tonic-gate /* thank you Ian */ 16007c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 16017c478bd9Sstevel@tonic-gate sm_dprintf("getla: lseek or read: %s\n", 16027c478bd9Sstevel@tonic-gate sm_errstring(errno)); 16037c478bd9Sstevel@tonic-gate return -1; 16047c478bd9Sstevel@tonic-gate } 16057c478bd9Sstevel@tonic-gate # if (LA_TYPE == LA_INT) || (LA_TYPE == LA_SHORT) || (LA_TYPE == LA_LONGLONG) 16067c478bd9Sstevel@tonic-gate if (tTd(3, 5)) 16077c478bd9Sstevel@tonic-gate { 16087c478bd9Sstevel@tonic-gate # if LA_TYPE == LA_SHORT 16097c478bd9Sstevel@tonic-gate sm_dprintf("getla: avenrun = %d", avenrun[0]); 16107c478bd9Sstevel@tonic-gate if (tTd(3, 15)) 16117c478bd9Sstevel@tonic-gate sm_dprintf(", %d, %d", avenrun[1], avenrun[2]); 16127c478bd9Sstevel@tonic-gate # else /* LA_TYPE == LA_SHORT */ 16137c478bd9Sstevel@tonic-gate # if LA_TYPE == LA_LONGLONG 16147c478bd9Sstevel@tonic-gate sm_dprintf("getla: avenrun = %lld", avenrun[0]); 16157c478bd9Sstevel@tonic-gate if (tTd(3, 15)) 16167c478bd9Sstevel@tonic-gate sm_dprintf(", %lld, %lld", avenrun[1], avenrun[2]); 16177c478bd9Sstevel@tonic-gate # else /* LA_TYPE == LA_LONGLONG */ 16187c478bd9Sstevel@tonic-gate sm_dprintf("getla: avenrun = %ld", avenrun[0]); 16197c478bd9Sstevel@tonic-gate if (tTd(3, 15)) 16207c478bd9Sstevel@tonic-gate sm_dprintf(", %ld, %ld", avenrun[1], avenrun[2]); 16217c478bd9Sstevel@tonic-gate # endif /* LA_TYPE == LA_LONGLONG */ 16227c478bd9Sstevel@tonic-gate # endif /* LA_TYPE == LA_SHORT */ 16237c478bd9Sstevel@tonic-gate sm_dprintf("\n"); 16247c478bd9Sstevel@tonic-gate } 16257c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 16267c478bd9Sstevel@tonic-gate sm_dprintf("getla: %d\n", 16277c478bd9Sstevel@tonic-gate (int) (avenrun[0] + FSCALE/2) >> FSHIFT); 16287c478bd9Sstevel@tonic-gate return ((int) (avenrun[0] + FSCALE/2) >> FSHIFT); 16297c478bd9Sstevel@tonic-gate # else /* (LA_TYPE == LA_INT) || (LA_TYPE == LA_SHORT) || (LA_TYPE == LA_LONGLONG) */ 16307c478bd9Sstevel@tonic-gate if (tTd(3, 5)) 16317c478bd9Sstevel@tonic-gate { 16327c478bd9Sstevel@tonic-gate sm_dprintf("getla: avenrun = %g", avenrun[0]); 16337c478bd9Sstevel@tonic-gate if (tTd(3, 15)) 16347c478bd9Sstevel@tonic-gate sm_dprintf(", %g, %g", avenrun[1], avenrun[2]); 16357c478bd9Sstevel@tonic-gate sm_dprintf("\n"); 16367c478bd9Sstevel@tonic-gate } 16377c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 16387c478bd9Sstevel@tonic-gate sm_dprintf("getla: %d\n", (int) (avenrun[0] +0.5)); 16397c478bd9Sstevel@tonic-gate return ((int) (avenrun[0] + 0.5)); 16407c478bd9Sstevel@tonic-gate # endif /* (LA_TYPE == LA_INT) || (LA_TYPE == LA_SHORT) || (LA_TYPE == LA_LONGLONG) */ 16417c478bd9Sstevel@tonic-gate } 16427c478bd9Sstevel@tonic-gate 16437c478bd9Sstevel@tonic-gate #endif /* (LA_TYPE == LA_INT) || (LA_TYPE == LA_FLOAT) || (LA_TYPE == LA_SHORT) || (LA_TYPE == LA_LONGLONG) */ 16447c478bd9Sstevel@tonic-gate 16457c478bd9Sstevel@tonic-gate #if LA_TYPE == LA_READKSYM 16467c478bd9Sstevel@tonic-gate 16477c478bd9Sstevel@tonic-gate # include <sys/ksym.h> 16487c478bd9Sstevel@tonic-gate 16497c478bd9Sstevel@tonic-gate int 16507c478bd9Sstevel@tonic-gate getla() 16517c478bd9Sstevel@tonic-gate { 16527c478bd9Sstevel@tonic-gate int j; 16537c478bd9Sstevel@tonic-gate static int kmem = -1; 16547c478bd9Sstevel@tonic-gate long avenrun[3]; 16557c478bd9Sstevel@tonic-gate struct mioc_rksym mirk; 16567c478bd9Sstevel@tonic-gate 16577c478bd9Sstevel@tonic-gate if (kmem < 0) 16587c478bd9Sstevel@tonic-gate { 16597c478bd9Sstevel@tonic-gate kmem = open("/dev/kmem", 0, 0); 16607c478bd9Sstevel@tonic-gate if (kmem < 0) 16617c478bd9Sstevel@tonic-gate { 16627c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 16637c478bd9Sstevel@tonic-gate sm_dprintf("getla: open(/dev/kmem): %s\n", 16647c478bd9Sstevel@tonic-gate sm_errstring(errno)); 16657c478bd9Sstevel@tonic-gate return -1; 16667c478bd9Sstevel@tonic-gate } 16677c478bd9Sstevel@tonic-gate if ((j = fcntl(kmem, F_GETFD, 0)) < 0 || 16687c478bd9Sstevel@tonic-gate fcntl(kmem, F_SETFD, j | FD_CLOEXEC) < 0) 16697c478bd9Sstevel@tonic-gate { 16707c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 16717c478bd9Sstevel@tonic-gate sm_dprintf("getla: fcntl(/dev/kmem, FD_CLOEXEC): %s\n", 16727c478bd9Sstevel@tonic-gate sm_errstring(errno)); 16737c478bd9Sstevel@tonic-gate (void) close(kmem); 16747c478bd9Sstevel@tonic-gate kmem = -1; 16757c478bd9Sstevel@tonic-gate return -1; 16767c478bd9Sstevel@tonic-gate } 16777c478bd9Sstevel@tonic-gate } 16787c478bd9Sstevel@tonic-gate mirk.mirk_symname = LA_AVENRUN; 16797c478bd9Sstevel@tonic-gate mirk.mirk_buf = avenrun; 16807c478bd9Sstevel@tonic-gate mirk.mirk_buflen = sizeof(avenrun); 16817c478bd9Sstevel@tonic-gate if (ioctl(kmem, MIOC_READKSYM, &mirk) < 0) 16827c478bd9Sstevel@tonic-gate { 16837c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 16847c478bd9Sstevel@tonic-gate sm_dprintf("getla: ioctl(MIOC_READKSYM) failed: %s\n", 16857c478bd9Sstevel@tonic-gate sm_errstring(errno)); 16867c478bd9Sstevel@tonic-gate return -1; 16877c478bd9Sstevel@tonic-gate } 16887c478bd9Sstevel@tonic-gate if (tTd(3, 5)) 16897c478bd9Sstevel@tonic-gate { 16907c478bd9Sstevel@tonic-gate sm_dprintf("getla: avenrun = %d", avenrun[0]); 16917c478bd9Sstevel@tonic-gate if (tTd(3, 15)) 16927c478bd9Sstevel@tonic-gate sm_dprintf(", %d, %d", avenrun[1], avenrun[2]); 16937c478bd9Sstevel@tonic-gate sm_dprintf("\n"); 16947c478bd9Sstevel@tonic-gate } 16957c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 16967c478bd9Sstevel@tonic-gate sm_dprintf("getla: %d\n", 16977c478bd9Sstevel@tonic-gate (int) (avenrun[0] + FSCALE/2) >> FSHIFT); 16987c478bd9Sstevel@tonic-gate return ((int) (avenrun[0] + FSCALE/2) >> FSHIFT); 16997c478bd9Sstevel@tonic-gate } 17007c478bd9Sstevel@tonic-gate 17017c478bd9Sstevel@tonic-gate #endif /* LA_TYPE == LA_READKSYM */ 17027c478bd9Sstevel@tonic-gate 17037c478bd9Sstevel@tonic-gate #if LA_TYPE == LA_DGUX 17047c478bd9Sstevel@tonic-gate 17057c478bd9Sstevel@tonic-gate # include <sys/dg_sys_info.h> 17067c478bd9Sstevel@tonic-gate 17077c478bd9Sstevel@tonic-gate int 17087c478bd9Sstevel@tonic-gate getla() 17097c478bd9Sstevel@tonic-gate { 17107c478bd9Sstevel@tonic-gate struct dg_sys_info_load_info load_info; 17117c478bd9Sstevel@tonic-gate 17127c478bd9Sstevel@tonic-gate dg_sys_info((long *)&load_info, 17137c478bd9Sstevel@tonic-gate DG_SYS_INFO_LOAD_INFO_TYPE, DG_SYS_INFO_LOAD_VERSION_0); 17147c478bd9Sstevel@tonic-gate 17157c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 17167c478bd9Sstevel@tonic-gate sm_dprintf("getla: %d\n", (int) (load_info.one_minute + 0.5)); 17177c478bd9Sstevel@tonic-gate 17187c478bd9Sstevel@tonic-gate return ((int) (load_info.one_minute + 0.5)); 17197c478bd9Sstevel@tonic-gate } 17207c478bd9Sstevel@tonic-gate 17217c478bd9Sstevel@tonic-gate #endif /* LA_TYPE == LA_DGUX */ 17227c478bd9Sstevel@tonic-gate 17237c478bd9Sstevel@tonic-gate #if LA_TYPE == LA_HPUX 17247c478bd9Sstevel@tonic-gate 17257c478bd9Sstevel@tonic-gate /* forward declarations to keep gcc from complaining */ 17267c478bd9Sstevel@tonic-gate struct pst_dynamic; 17277c478bd9Sstevel@tonic-gate struct pst_status; 17287c478bd9Sstevel@tonic-gate struct pst_static; 17297c478bd9Sstevel@tonic-gate struct pst_vminfo; 17307c478bd9Sstevel@tonic-gate struct pst_diskinfo; 17317c478bd9Sstevel@tonic-gate struct pst_processor; 17327c478bd9Sstevel@tonic-gate struct pst_lv; 17337c478bd9Sstevel@tonic-gate struct pst_swapinfo; 17347c478bd9Sstevel@tonic-gate 17357c478bd9Sstevel@tonic-gate # include <sys/param.h> 17367c478bd9Sstevel@tonic-gate # include <sys/pstat.h> 17377c478bd9Sstevel@tonic-gate 17387c478bd9Sstevel@tonic-gate int 17397c478bd9Sstevel@tonic-gate getla() 17407c478bd9Sstevel@tonic-gate { 17417c478bd9Sstevel@tonic-gate struct pst_dynamic pstd; 17427c478bd9Sstevel@tonic-gate 17437c478bd9Sstevel@tonic-gate if (pstat_getdynamic(&pstd, sizeof(struct pst_dynamic), 17447c478bd9Sstevel@tonic-gate (size_t) 1, 0) == -1) 17457c478bd9Sstevel@tonic-gate return 0; 17467c478bd9Sstevel@tonic-gate 17477c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 17487c478bd9Sstevel@tonic-gate sm_dprintf("getla: %d\n", (int) (pstd.psd_avg_1_min + 0.5)); 17497c478bd9Sstevel@tonic-gate 17507c478bd9Sstevel@tonic-gate return (int) (pstd.psd_avg_1_min + 0.5); 17517c478bd9Sstevel@tonic-gate } 17527c478bd9Sstevel@tonic-gate 17537c478bd9Sstevel@tonic-gate #endif /* LA_TYPE == LA_HPUX */ 17547c478bd9Sstevel@tonic-gate 17557c478bd9Sstevel@tonic-gate #if LA_TYPE == LA_SUBR 17567c478bd9Sstevel@tonic-gate 17577c478bd9Sstevel@tonic-gate int 17587c478bd9Sstevel@tonic-gate getla() 17597c478bd9Sstevel@tonic-gate { 17607c478bd9Sstevel@tonic-gate double avenrun[3]; 17617c478bd9Sstevel@tonic-gate 17627c478bd9Sstevel@tonic-gate if (getloadavg(avenrun, sizeof(avenrun) / sizeof(avenrun[0])) < 0) 17637c478bd9Sstevel@tonic-gate { 17647c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 17657c478bd9Sstevel@tonic-gate sm_dprintf("getla: getloadavg failed: %s", 17667c478bd9Sstevel@tonic-gate sm_errstring(errno)); 17677c478bd9Sstevel@tonic-gate return -1; 17687c478bd9Sstevel@tonic-gate } 17697c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 17707c478bd9Sstevel@tonic-gate sm_dprintf("getla: %d\n", (int) (avenrun[0] +0.5)); 17717c478bd9Sstevel@tonic-gate return ((int) (avenrun[0] + 0.5)); 17727c478bd9Sstevel@tonic-gate } 17737c478bd9Sstevel@tonic-gate 17747c478bd9Sstevel@tonic-gate #endif /* LA_TYPE == LA_SUBR */ 17757c478bd9Sstevel@tonic-gate 17767c478bd9Sstevel@tonic-gate #if LA_TYPE == LA_MACH 17777c478bd9Sstevel@tonic-gate 17787c478bd9Sstevel@tonic-gate /* 17797c478bd9Sstevel@tonic-gate ** This has been tested on NEXTSTEP release 2.1/3.X. 17807c478bd9Sstevel@tonic-gate */ 17817c478bd9Sstevel@tonic-gate 17827c478bd9Sstevel@tonic-gate # if defined(NX_CURRENT_COMPILER_RELEASE) && NX_CURRENT_COMPILER_RELEASE > NX_COMPILER_RELEASE_3_0 17837c478bd9Sstevel@tonic-gate # include <mach/mach.h> 17847c478bd9Sstevel@tonic-gate # else /* defined(NX_CURRENT_COMPILER_RELEASE) && NX_CURRENT_COMPILER_RELEASE > NX_COMPILER_RELEASE_3_0 */ 17857c478bd9Sstevel@tonic-gate # include <mach.h> 17867c478bd9Sstevel@tonic-gate # endif /* defined(NX_CURRENT_COMPILER_RELEASE) && NX_CURRENT_COMPILER_RELEASE > NX_COMPILER_RELEASE_3_0 */ 17877c478bd9Sstevel@tonic-gate 17887c478bd9Sstevel@tonic-gate int 17897c478bd9Sstevel@tonic-gate getla() 17907c478bd9Sstevel@tonic-gate { 17917c478bd9Sstevel@tonic-gate processor_set_t default_set; 17927c478bd9Sstevel@tonic-gate kern_return_t error; 17937c478bd9Sstevel@tonic-gate unsigned int info_count; 17947c478bd9Sstevel@tonic-gate struct processor_set_basic_info info; 17957c478bd9Sstevel@tonic-gate host_t host; 17967c478bd9Sstevel@tonic-gate 17977c478bd9Sstevel@tonic-gate error = processor_set_default(host_self(), &default_set); 17987c478bd9Sstevel@tonic-gate if (error != KERN_SUCCESS) 17997c478bd9Sstevel@tonic-gate { 18007c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 18017c478bd9Sstevel@tonic-gate sm_dprintf("getla: processor_set_default failed: %s", 18027c478bd9Sstevel@tonic-gate sm_errstring(errno)); 18037c478bd9Sstevel@tonic-gate return -1; 18047c478bd9Sstevel@tonic-gate } 18057c478bd9Sstevel@tonic-gate info_count = PROCESSOR_SET_BASIC_INFO_COUNT; 18067c478bd9Sstevel@tonic-gate if (processor_set_info(default_set, PROCESSOR_SET_BASIC_INFO, 18077c478bd9Sstevel@tonic-gate &host, (processor_set_info_t)&info, 18087c478bd9Sstevel@tonic-gate &info_count) != KERN_SUCCESS) 18097c478bd9Sstevel@tonic-gate { 18107c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 18117c478bd9Sstevel@tonic-gate sm_dprintf("getla: processor_set_info failed: %s", 18127c478bd9Sstevel@tonic-gate sm_errstring(errno)); 18137c478bd9Sstevel@tonic-gate return -1; 18147c478bd9Sstevel@tonic-gate } 18157c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 18167c478bd9Sstevel@tonic-gate sm_dprintf("getla: %d\n", 18177c478bd9Sstevel@tonic-gate (int) ((info.load_average + (LOAD_SCALE / 2)) / 18187c478bd9Sstevel@tonic-gate LOAD_SCALE)); 18197c478bd9Sstevel@tonic-gate return (int) (info.load_average + (LOAD_SCALE / 2)) / LOAD_SCALE; 18207c478bd9Sstevel@tonic-gate } 18217c478bd9Sstevel@tonic-gate 18227c478bd9Sstevel@tonic-gate #endif /* LA_TYPE == LA_MACH */ 18237c478bd9Sstevel@tonic-gate 18247c478bd9Sstevel@tonic-gate #if LA_TYPE == LA_PROCSTR 18257c478bd9Sstevel@tonic-gate # if SM_CONF_BROKEN_STRTOD 18267c478bd9Sstevel@tonic-gate ERROR: This OS has most likely a broken strtod() implemenentation. 18277c478bd9Sstevel@tonic-gate ERROR: The function is required for getla(). 18287c478bd9Sstevel@tonic-gate ERROR: Check the compilation options _LA_PROCSTR and 18297c478bd9Sstevel@tonic-gate ERROR: _SM_CONF_BROKEN_STRTOD (without the leading _). 18307c478bd9Sstevel@tonic-gate # endif /* SM_CONF_BROKEN_STRTOD */ 18317c478bd9Sstevel@tonic-gate 18327c478bd9Sstevel@tonic-gate /* 18337c478bd9Sstevel@tonic-gate ** Read /proc/loadavg for the load average. This is assumed to be 18347c478bd9Sstevel@tonic-gate ** in a format like "0.15 0.12 0.06". 18357c478bd9Sstevel@tonic-gate ** 18367c478bd9Sstevel@tonic-gate ** Initially intended for Linux. This has been in the kernel 18377c478bd9Sstevel@tonic-gate ** since at least 0.99.15. 18387c478bd9Sstevel@tonic-gate */ 18397c478bd9Sstevel@tonic-gate 18407c478bd9Sstevel@tonic-gate # ifndef _PATH_LOADAVG 18417c478bd9Sstevel@tonic-gate # define _PATH_LOADAVG "/proc/loadavg" 18427c478bd9Sstevel@tonic-gate # endif /* ! _PATH_LOADAVG */ 18437c478bd9Sstevel@tonic-gate 18447c478bd9Sstevel@tonic-gate int 18457c478bd9Sstevel@tonic-gate getla() 18467c478bd9Sstevel@tonic-gate { 18477c478bd9Sstevel@tonic-gate double avenrun; 18487c478bd9Sstevel@tonic-gate register int result; 18497c478bd9Sstevel@tonic-gate SM_FILE_T *fp; 18507c478bd9Sstevel@tonic-gate 18517c478bd9Sstevel@tonic-gate fp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, _PATH_LOADAVG, SM_IO_RDONLY, 18527c478bd9Sstevel@tonic-gate NULL); 18537c478bd9Sstevel@tonic-gate if (fp == NULL) 18547c478bd9Sstevel@tonic-gate { 18557c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 18567c478bd9Sstevel@tonic-gate sm_dprintf("getla: sm_io_open(%s): %s\n", 18577c478bd9Sstevel@tonic-gate _PATH_LOADAVG, sm_errstring(errno)); 18587c478bd9Sstevel@tonic-gate return -1; 18597c478bd9Sstevel@tonic-gate } 18607c478bd9Sstevel@tonic-gate result = sm_io_fscanf(fp, SM_TIME_DEFAULT, "%lf", &avenrun); 18617c478bd9Sstevel@tonic-gate (void) sm_io_close(fp, SM_TIME_DEFAULT); 18627c478bd9Sstevel@tonic-gate if (result != 1) 18637c478bd9Sstevel@tonic-gate { 18647c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 18657c478bd9Sstevel@tonic-gate sm_dprintf("getla: sm_io_fscanf() = %d: %s\n", 18667c478bd9Sstevel@tonic-gate result, sm_errstring(errno)); 18677c478bd9Sstevel@tonic-gate return -1; 18687c478bd9Sstevel@tonic-gate } 18697c478bd9Sstevel@tonic-gate 18707c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 18717c478bd9Sstevel@tonic-gate sm_dprintf("getla(): %.2f\n", avenrun); 18727c478bd9Sstevel@tonic-gate 18737c478bd9Sstevel@tonic-gate return ((int) (avenrun + 0.5)); 18747c478bd9Sstevel@tonic-gate } 18757c478bd9Sstevel@tonic-gate 18767c478bd9Sstevel@tonic-gate #endif /* LA_TYPE == LA_PROCSTR */ 18777c478bd9Sstevel@tonic-gate 18787c478bd9Sstevel@tonic-gate #if LA_TYPE == LA_IRIX6 18797c478bd9Sstevel@tonic-gate 18807c478bd9Sstevel@tonic-gate # include <sys/sysmp.h> 18817c478bd9Sstevel@tonic-gate 18827c478bd9Sstevel@tonic-gate # ifdef _UNICOSMP 18837c478bd9Sstevel@tonic-gate # define CAST_SYSMP(x) (x) 18847c478bd9Sstevel@tonic-gate # else /* _UNICOSMP */ 18857c478bd9Sstevel@tonic-gate # define CAST_SYSMP(x) ((x) & 0x7fffffff) 18867c478bd9Sstevel@tonic-gate # endif /* _UNICOSMP */ 18877c478bd9Sstevel@tonic-gate 18887c478bd9Sstevel@tonic-gate int 18897c478bd9Sstevel@tonic-gate getla(void) 18907c478bd9Sstevel@tonic-gate { 18917c478bd9Sstevel@tonic-gate int j; 18927c478bd9Sstevel@tonic-gate static int kmem = -1; 18937c478bd9Sstevel@tonic-gate int avenrun[3]; 18947c478bd9Sstevel@tonic-gate 18957c478bd9Sstevel@tonic-gate if (kmem < 0) 18967c478bd9Sstevel@tonic-gate { 18977c478bd9Sstevel@tonic-gate kmem = open(_PATH_KMEM, 0, 0); 18987c478bd9Sstevel@tonic-gate if (kmem < 0) 18997c478bd9Sstevel@tonic-gate { 19007c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 19017c478bd9Sstevel@tonic-gate sm_dprintf("getla: open(%s): %s\n", _PATH_KMEM, 19027c478bd9Sstevel@tonic-gate sm_errstring(errno)); 19037c478bd9Sstevel@tonic-gate return -1; 19047c478bd9Sstevel@tonic-gate } 19057c478bd9Sstevel@tonic-gate if ((j = fcntl(kmem, F_GETFD, 0)) < 0 || 19067c478bd9Sstevel@tonic-gate fcntl(kmem, F_SETFD, j | FD_CLOEXEC) < 0) 19077c478bd9Sstevel@tonic-gate { 19087c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 19097c478bd9Sstevel@tonic-gate sm_dprintf("getla: fcntl(/dev/kmem, FD_CLOEXEC): %s\n", 19107c478bd9Sstevel@tonic-gate sm_errstring(errno)); 19117c478bd9Sstevel@tonic-gate (void) close(kmem); 19127c478bd9Sstevel@tonic-gate kmem = -1; 19137c478bd9Sstevel@tonic-gate return -1; 19147c478bd9Sstevel@tonic-gate } 19157c478bd9Sstevel@tonic-gate } 19167c478bd9Sstevel@tonic-gate 19177c478bd9Sstevel@tonic-gate if (lseek(kmem, CAST_SYSMP(sysmp(MP_KERNADDR, MPKA_AVENRUN)), SEEK_SET) 19187c478bd9Sstevel@tonic-gate == -1 || 19197c478bd9Sstevel@tonic-gate read(kmem, (char *) avenrun, sizeof(avenrun)) < sizeof(avenrun)) 19207c478bd9Sstevel@tonic-gate { 19217c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 19227c478bd9Sstevel@tonic-gate sm_dprintf("getla: lseek or read: %s\n", 19237c478bd9Sstevel@tonic-gate sm_errstring(errno)); 19247c478bd9Sstevel@tonic-gate return -1; 19257c478bd9Sstevel@tonic-gate } 19267c478bd9Sstevel@tonic-gate if (tTd(3, 5)) 19277c478bd9Sstevel@tonic-gate { 19287c478bd9Sstevel@tonic-gate sm_dprintf("getla: avenrun = %ld", (long int) avenrun[0]); 19297c478bd9Sstevel@tonic-gate if (tTd(3, 15)) 19307c478bd9Sstevel@tonic-gate sm_dprintf(", %ld, %ld", 19317c478bd9Sstevel@tonic-gate (long int) avenrun[1], (long int) avenrun[2]); 19327c478bd9Sstevel@tonic-gate sm_dprintf("\n"); 19337c478bd9Sstevel@tonic-gate } 19347c478bd9Sstevel@tonic-gate 19357c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 19367c478bd9Sstevel@tonic-gate sm_dprintf("getla: %d\n", 19377c478bd9Sstevel@tonic-gate (int) (avenrun[0] + FSCALE/2) >> FSHIFT); 19387c478bd9Sstevel@tonic-gate return ((int) (avenrun[0] + FSCALE/2) >> FSHIFT); 19397c478bd9Sstevel@tonic-gate 19407c478bd9Sstevel@tonic-gate } 19417c478bd9Sstevel@tonic-gate #endif /* LA_TYPE == LA_IRIX6 */ 19427c478bd9Sstevel@tonic-gate 19437c478bd9Sstevel@tonic-gate #if LA_TYPE == LA_KSTAT 19447c478bd9Sstevel@tonic-gate 19457c478bd9Sstevel@tonic-gate # include <kstat.h> 19467c478bd9Sstevel@tonic-gate 19477c478bd9Sstevel@tonic-gate int 19487c478bd9Sstevel@tonic-gate getla() 19497c478bd9Sstevel@tonic-gate { 19507c478bd9Sstevel@tonic-gate static kstat_ctl_t *kc = NULL; 19517c478bd9Sstevel@tonic-gate static kstat_t *ksp = NULL; 19527c478bd9Sstevel@tonic-gate kstat_named_t *ksn; 19537c478bd9Sstevel@tonic-gate int la; 19547c478bd9Sstevel@tonic-gate 19557c478bd9Sstevel@tonic-gate if (kc == NULL) /* if not initialized before */ 19567c478bd9Sstevel@tonic-gate kc = kstat_open(); 19577c478bd9Sstevel@tonic-gate if (kc == NULL) 19587c478bd9Sstevel@tonic-gate { 19597c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 19607c478bd9Sstevel@tonic-gate sm_dprintf("getla: kstat_open(): %s\n", 19617c478bd9Sstevel@tonic-gate sm_errstring(errno)); 19627c478bd9Sstevel@tonic-gate return -1; 19637c478bd9Sstevel@tonic-gate } 19647c478bd9Sstevel@tonic-gate if (ksp == NULL) 19657c478bd9Sstevel@tonic-gate ksp = kstat_lookup(kc, "unix", 0, "system_misc"); 19667c478bd9Sstevel@tonic-gate if (ksp == NULL) 19677c478bd9Sstevel@tonic-gate { 19687c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 19697c478bd9Sstevel@tonic-gate sm_dprintf("getla: kstat_lookup(): %s\n", 19707c478bd9Sstevel@tonic-gate sm_errstring(errno)); 19717c478bd9Sstevel@tonic-gate return -1; 19727c478bd9Sstevel@tonic-gate } 19737c478bd9Sstevel@tonic-gate if (kstat_read(kc, ksp, NULL) < 0) 19747c478bd9Sstevel@tonic-gate { 19757c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 19767c478bd9Sstevel@tonic-gate sm_dprintf("getla: kstat_read(): %s\n", 19777c478bd9Sstevel@tonic-gate sm_errstring(errno)); 19787c478bd9Sstevel@tonic-gate return -1; 19797c478bd9Sstevel@tonic-gate } 19807c478bd9Sstevel@tonic-gate ksn = (kstat_named_t *) kstat_data_lookup(ksp, "avenrun_1min"); 19817c478bd9Sstevel@tonic-gate la = ((double) ksn->value.ul + FSCALE/2) / FSCALE; 19827c478bd9Sstevel@tonic-gate /* kstat_close(kc); /o do not close for fast access */ 19837c478bd9Sstevel@tonic-gate return la; 19847c478bd9Sstevel@tonic-gate } 19857c478bd9Sstevel@tonic-gate 19867c478bd9Sstevel@tonic-gate #endif /* LA_TYPE == LA_KSTAT */ 19877c478bd9Sstevel@tonic-gate 19887c478bd9Sstevel@tonic-gate #if LA_TYPE == LA_DEVSHORT 19897c478bd9Sstevel@tonic-gate 19907c478bd9Sstevel@tonic-gate /* 19917c478bd9Sstevel@tonic-gate ** Read /dev/table/avenrun for the load average. This should contain 19927c478bd9Sstevel@tonic-gate ** three shorts for the 1, 5, and 15 minute loads. We only read the 19937c478bd9Sstevel@tonic-gate ** first, since that's all we care about. 19947c478bd9Sstevel@tonic-gate ** 19957c478bd9Sstevel@tonic-gate ** Intended for SCO OpenServer 5. 19967c478bd9Sstevel@tonic-gate */ 19977c478bd9Sstevel@tonic-gate 19987c478bd9Sstevel@tonic-gate # ifndef _PATH_AVENRUN 19997c478bd9Sstevel@tonic-gate # define _PATH_AVENRUN "/dev/table/avenrun" 20007c478bd9Sstevel@tonic-gate # endif /* ! _PATH_AVENRUN */ 20017c478bd9Sstevel@tonic-gate 20027c478bd9Sstevel@tonic-gate int 20037c478bd9Sstevel@tonic-gate getla() 20047c478bd9Sstevel@tonic-gate { 20057c478bd9Sstevel@tonic-gate static int afd = -1; 20067c478bd9Sstevel@tonic-gate short avenrun; 20077c478bd9Sstevel@tonic-gate int loadav; 20087c478bd9Sstevel@tonic-gate int r; 20097c478bd9Sstevel@tonic-gate 20107c478bd9Sstevel@tonic-gate errno = EBADF; 20117c478bd9Sstevel@tonic-gate 20127c478bd9Sstevel@tonic-gate if (afd == -1 || lseek(afd, 0L, SEEK_SET) == -1) 20137c478bd9Sstevel@tonic-gate { 20147c478bd9Sstevel@tonic-gate if (errno != EBADF) 20157c478bd9Sstevel@tonic-gate return -1; 20167c478bd9Sstevel@tonic-gate afd = open(_PATH_AVENRUN, O_RDONLY|O_SYNC); 20177c478bd9Sstevel@tonic-gate if (afd < 0) 20187c478bd9Sstevel@tonic-gate { 20197c478bd9Sstevel@tonic-gate sm_syslog(LOG_ERR, NOQID, 20207c478bd9Sstevel@tonic-gate "can't open %s: %s", 20217c478bd9Sstevel@tonic-gate _PATH_AVENRUN, sm_errstring(errno)); 20227c478bd9Sstevel@tonic-gate return -1; 20237c478bd9Sstevel@tonic-gate } 20247c478bd9Sstevel@tonic-gate } 20257c478bd9Sstevel@tonic-gate 20267c478bd9Sstevel@tonic-gate r = read(afd, &avenrun, sizeof avenrun); 20277c478bd9Sstevel@tonic-gate 20287c478bd9Sstevel@tonic-gate if (tTd(3, 5)) 20297c478bd9Sstevel@tonic-gate sm_dprintf("getla: avenrun = %d\n", avenrun); 20307c478bd9Sstevel@tonic-gate loadav = (int) (avenrun + FSCALE/2) >> FSHIFT; 20317c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 20327c478bd9Sstevel@tonic-gate sm_dprintf("getla: %d\n", loadav); 20337c478bd9Sstevel@tonic-gate return loadav; 20347c478bd9Sstevel@tonic-gate } 20357c478bd9Sstevel@tonic-gate 20367c478bd9Sstevel@tonic-gate #endif /* LA_TYPE == LA_DEVSHORT */ 20377c478bd9Sstevel@tonic-gate 20387c478bd9Sstevel@tonic-gate #if LA_TYPE == LA_ALPHAOSF 20397c478bd9Sstevel@tonic-gate struct rtentry; 20407c478bd9Sstevel@tonic-gate struct mbuf; 20417c478bd9Sstevel@tonic-gate # include <sys/table.h> 20427c478bd9Sstevel@tonic-gate 20437c478bd9Sstevel@tonic-gate int 20447c478bd9Sstevel@tonic-gate getla() 20457c478bd9Sstevel@tonic-gate { 20467c478bd9Sstevel@tonic-gate int ave = 0; 20477c478bd9Sstevel@tonic-gate struct tbl_loadavg tab; 20487c478bd9Sstevel@tonic-gate 20497c478bd9Sstevel@tonic-gate if (table(TBL_LOADAVG, 0, &tab, 1, sizeof(tab)) == -1) 20507c478bd9Sstevel@tonic-gate { 20517c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 20527c478bd9Sstevel@tonic-gate sm_dprintf("getla: table %s\n", sm_errstring(errno)); 20537c478bd9Sstevel@tonic-gate return -1; 20547c478bd9Sstevel@tonic-gate } 20557c478bd9Sstevel@tonic-gate 20567c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 20577c478bd9Sstevel@tonic-gate sm_dprintf("getla: scale = %d\n", tab.tl_lscale); 20587c478bd9Sstevel@tonic-gate 20597c478bd9Sstevel@tonic-gate if (tab.tl_lscale) 20607c478bd9Sstevel@tonic-gate ave = ((tab.tl_avenrun.l[2] + (tab.tl_lscale/2)) / 20617c478bd9Sstevel@tonic-gate tab.tl_lscale); 20627c478bd9Sstevel@tonic-gate else 20637c478bd9Sstevel@tonic-gate ave = (int) (tab.tl_avenrun.d[2] + 0.5); 20647c478bd9Sstevel@tonic-gate 20657c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 20667c478bd9Sstevel@tonic-gate sm_dprintf("getla: %d\n", ave); 20677c478bd9Sstevel@tonic-gate 20687c478bd9Sstevel@tonic-gate return ave; 20697c478bd9Sstevel@tonic-gate } 20707c478bd9Sstevel@tonic-gate 20717c478bd9Sstevel@tonic-gate #endif /* LA_TYPE == LA_ALPHAOSF */ 20727c478bd9Sstevel@tonic-gate 20737c478bd9Sstevel@tonic-gate #if LA_TYPE == LA_PSET 20747c478bd9Sstevel@tonic-gate 20757c478bd9Sstevel@tonic-gate int 20767c478bd9Sstevel@tonic-gate getla() 20777c478bd9Sstevel@tonic-gate { 20787c478bd9Sstevel@tonic-gate double avenrun[3]; 20797c478bd9Sstevel@tonic-gate 20807c478bd9Sstevel@tonic-gate if (pset_getloadavg(PS_MYID, avenrun, 20817c478bd9Sstevel@tonic-gate sizeof(avenrun) / sizeof(avenrun[0])) < 0) 20827c478bd9Sstevel@tonic-gate { 20837c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 20847c478bd9Sstevel@tonic-gate sm_dprintf("getla: pset_getloadavg failed: %s", 20857c478bd9Sstevel@tonic-gate sm_errstring(errno)); 20867c478bd9Sstevel@tonic-gate return -1; 20877c478bd9Sstevel@tonic-gate } 20887c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 20897c478bd9Sstevel@tonic-gate sm_dprintf("getla: %d\n", (int) (avenrun[0] +0.5)); 20907c478bd9Sstevel@tonic-gate return ((int) (avenrun[0] + 0.5)); 20917c478bd9Sstevel@tonic-gate } 20927c478bd9Sstevel@tonic-gate 20937c478bd9Sstevel@tonic-gate #endif /* LA_TYPE == LA_PSET */ 20947c478bd9Sstevel@tonic-gate 20957c478bd9Sstevel@tonic-gate #if LA_TYPE == LA_ZERO 20967c478bd9Sstevel@tonic-gate 20977c478bd9Sstevel@tonic-gate int 20987c478bd9Sstevel@tonic-gate getla() 20997c478bd9Sstevel@tonic-gate { 21007c478bd9Sstevel@tonic-gate if (tTd(3, 1)) 21017c478bd9Sstevel@tonic-gate sm_dprintf("getla: ZERO\n"); 21027c478bd9Sstevel@tonic-gate return 0; 21037c478bd9Sstevel@tonic-gate } 21047c478bd9Sstevel@tonic-gate 21057c478bd9Sstevel@tonic-gate #endif /* LA_TYPE == LA_ZERO */ 21067c478bd9Sstevel@tonic-gate 21077c478bd9Sstevel@tonic-gate /* 21087c478bd9Sstevel@tonic-gate * Copyright 1989 Massachusetts Institute of Technology 21097c478bd9Sstevel@tonic-gate * 21107c478bd9Sstevel@tonic-gate * Permission to use, copy, modify, distribute, and sell this software and its 21117c478bd9Sstevel@tonic-gate * documentation for any purpose is hereby granted without fee, provided that 21127c478bd9Sstevel@tonic-gate * the above copyright notice appear in all copies and that both that 21137c478bd9Sstevel@tonic-gate * copyright notice and this permission notice appear in supporting 21147c478bd9Sstevel@tonic-gate * documentation, and that the name of M.I.T. not be used in advertising or 21157c478bd9Sstevel@tonic-gate * publicity pertaining to distribution of the software without specific, 21167c478bd9Sstevel@tonic-gate * written prior permission. M.I.T. makes no representations about the 21177c478bd9Sstevel@tonic-gate * suitability of this software for any purpose. It is provided "as is" 21187c478bd9Sstevel@tonic-gate * without express or implied warranty. 21197c478bd9Sstevel@tonic-gate * 21207c478bd9Sstevel@tonic-gate * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL 21217c478bd9Sstevel@tonic-gate * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T. 21227c478bd9Sstevel@tonic-gate * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 21237c478bd9Sstevel@tonic-gate * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION 21247c478bd9Sstevel@tonic-gate * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 21257c478bd9Sstevel@tonic-gate * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 21267c478bd9Sstevel@tonic-gate * 21277c478bd9Sstevel@tonic-gate * Authors: Many and varied... 21287c478bd9Sstevel@tonic-gate */ 21297c478bd9Sstevel@tonic-gate 21307c478bd9Sstevel@tonic-gate /* Non Apollo stuff removed by Don Lewis 11/15/93 */ 21317c478bd9Sstevel@tonic-gate #ifndef lint 21327c478bd9Sstevel@tonic-gate SM_UNUSED(static char rcsid[]) = "@(#)$OrigId: getloadavg.c,v 1.16 1991/06/21 12:51:15 paul Exp $"; 21337c478bd9Sstevel@tonic-gate #endif /* ! lint */ 21347c478bd9Sstevel@tonic-gate 21357c478bd9Sstevel@tonic-gate #ifdef apollo 21367c478bd9Sstevel@tonic-gate # undef volatile 21377c478bd9Sstevel@tonic-gate # include <apollo/base.h> 21387c478bd9Sstevel@tonic-gate 21397c478bd9Sstevel@tonic-gate /* ARGSUSED */ 21407c478bd9Sstevel@tonic-gate int getloadavg( call_data ) 21417c478bd9Sstevel@tonic-gate caddr_t call_data; /* pointer to (double) return value */ 21427c478bd9Sstevel@tonic-gate { 21437c478bd9Sstevel@tonic-gate double *avenrun = (double *) call_data; 21447c478bd9Sstevel@tonic-gate int i; 21457c478bd9Sstevel@tonic-gate status_$t st; 21467c478bd9Sstevel@tonic-gate long loadav[3]; 21477c478bd9Sstevel@tonic-gate 21487c478bd9Sstevel@tonic-gate proc1_$get_loadav(loadav, &st); 21497c478bd9Sstevel@tonic-gate *avenrun = loadav[0] / (double) (1 << 16); 21507c478bd9Sstevel@tonic-gate return 0; 21517c478bd9Sstevel@tonic-gate } 21527c478bd9Sstevel@tonic-gate #endif /* apollo */ 21537c478bd9Sstevel@tonic-gate /* 21547c478bd9Sstevel@tonic-gate ** SM_GETLA -- get the current load average 21557c478bd9Sstevel@tonic-gate ** 21567c478bd9Sstevel@tonic-gate ** Parameters: 21577c478bd9Sstevel@tonic-gate ** none 21587c478bd9Sstevel@tonic-gate ** 21597c478bd9Sstevel@tonic-gate ** Returns: 21607c478bd9Sstevel@tonic-gate ** none 21617c478bd9Sstevel@tonic-gate ** 21627c478bd9Sstevel@tonic-gate ** Side Effects: 21637c478bd9Sstevel@tonic-gate ** Set CurrentLA to the current load average. 21647c478bd9Sstevel@tonic-gate ** Set {load_avg} in GlobalMacros to the current load average. 21657c478bd9Sstevel@tonic-gate */ 21667c478bd9Sstevel@tonic-gate 21677c478bd9Sstevel@tonic-gate void 21687c478bd9Sstevel@tonic-gate sm_getla() 21697c478bd9Sstevel@tonic-gate { 21707c478bd9Sstevel@tonic-gate char labuf[8]; 21717c478bd9Sstevel@tonic-gate 21727c478bd9Sstevel@tonic-gate CurrentLA = getla(); 21737c478bd9Sstevel@tonic-gate (void) sm_snprintf(labuf, sizeof labuf, "%d", CurrentLA); 21747c478bd9Sstevel@tonic-gate macdefine(&GlobalMacros, A_TEMP, macid("{load_avg}"), labuf); 21757c478bd9Sstevel@tonic-gate } 21767c478bd9Sstevel@tonic-gate /* 21777c478bd9Sstevel@tonic-gate ** SHOULDQUEUE -- should this message be queued or sent? 21787c478bd9Sstevel@tonic-gate ** 21797c478bd9Sstevel@tonic-gate ** Compares the message cost to the load average to decide. 21807c478bd9Sstevel@tonic-gate ** 21817c478bd9Sstevel@tonic-gate ** Note: Do NOT change this API! It is documented in op.me 21827c478bd9Sstevel@tonic-gate ** and theoretically the user can change this function... 21837c478bd9Sstevel@tonic-gate ** 21847c478bd9Sstevel@tonic-gate ** Parameters: 21857c478bd9Sstevel@tonic-gate ** pri -- the priority of the message in question. 21867c478bd9Sstevel@tonic-gate ** ct -- the message creation time (unused, but see above). 21877c478bd9Sstevel@tonic-gate ** 21887c478bd9Sstevel@tonic-gate ** Returns: 21897c478bd9Sstevel@tonic-gate ** true -- if this message should be queued up for the 21907c478bd9Sstevel@tonic-gate ** time being. 21917c478bd9Sstevel@tonic-gate ** false -- if the load is low enough to send this message. 21927c478bd9Sstevel@tonic-gate ** 21937c478bd9Sstevel@tonic-gate ** Side Effects: 21947c478bd9Sstevel@tonic-gate ** none. 21957c478bd9Sstevel@tonic-gate */ 21967c478bd9Sstevel@tonic-gate 21977c478bd9Sstevel@tonic-gate /* ARGSUSED1 */ 21987c478bd9Sstevel@tonic-gate bool 21997c478bd9Sstevel@tonic-gate shouldqueue(pri, ct) 22007c478bd9Sstevel@tonic-gate long pri; 22017c478bd9Sstevel@tonic-gate time_t ct; 22027c478bd9Sstevel@tonic-gate { 22037c478bd9Sstevel@tonic-gate bool rval; 2204*445f2479Sjbeck #if _FFR_MEMSTAT 2205*445f2479Sjbeck long memfree; 2206*445f2479Sjbeck #endif /* _FFR_MEMSTAT */ 22077c478bd9Sstevel@tonic-gate 22087c478bd9Sstevel@tonic-gate if (tTd(3, 30)) 22097c478bd9Sstevel@tonic-gate sm_dprintf("shouldqueue: CurrentLA=%d, pri=%ld: ", 22107c478bd9Sstevel@tonic-gate CurrentLA, pri); 2211*445f2479Sjbeck 2212*445f2479Sjbeck #if _FFR_MEMSTAT 2213*445f2479Sjbeck if (QueueLowMem > 0 && 2214*445f2479Sjbeck sm_memstat_get(MemoryResource, &memfree) >= 0 && 2215*445f2479Sjbeck memfree < QueueLowMem) 2216*445f2479Sjbeck { 2217*445f2479Sjbeck if (tTd(3, 30)) 2218*445f2479Sjbeck sm_dprintf("true (memfree=%ld < QueueLowMem)\n", 2219*445f2479Sjbeck memfree, QueueLowMem); 2220*445f2479Sjbeck return true; 2221*445f2479Sjbeck } 2222*445f2479Sjbeck #endif /* _FFR_MEMSTAT */ 22237c478bd9Sstevel@tonic-gate if (CurrentLA < QueueLA) 22247c478bd9Sstevel@tonic-gate { 22257c478bd9Sstevel@tonic-gate if (tTd(3, 30)) 22267c478bd9Sstevel@tonic-gate sm_dprintf("false (CurrentLA < QueueLA)\n"); 22277c478bd9Sstevel@tonic-gate return false; 22287c478bd9Sstevel@tonic-gate } 22297c478bd9Sstevel@tonic-gate # if 0 /* this code is reported to cause oscillation around RefuseLA */ 22307c478bd9Sstevel@tonic-gate if (CurrentLA >= RefuseLA && QueueLA < RefuseLA) 22317c478bd9Sstevel@tonic-gate { 22327c478bd9Sstevel@tonic-gate if (tTd(3, 30)) 22337c478bd9Sstevel@tonic-gate sm_dprintf("TRUE (CurrentLA >= RefuseLA)\n"); 22347c478bd9Sstevel@tonic-gate return true; 22357c478bd9Sstevel@tonic-gate } 22367c478bd9Sstevel@tonic-gate # endif /* 0 */ 22377c478bd9Sstevel@tonic-gate rval = pri > (QueueFactor / (CurrentLA - QueueLA + 1)); 22387c478bd9Sstevel@tonic-gate if (tTd(3, 30)) 22397c478bd9Sstevel@tonic-gate sm_dprintf("%s (by calculation)\n", rval ? "true" : "false"); 22407c478bd9Sstevel@tonic-gate return rval; 22417c478bd9Sstevel@tonic-gate } 22427c478bd9Sstevel@tonic-gate /* 22437c478bd9Sstevel@tonic-gate ** REFUSECONNECTIONS -- decide if connections should be refused 22447c478bd9Sstevel@tonic-gate ** 22457c478bd9Sstevel@tonic-gate ** Parameters: 22467c478bd9Sstevel@tonic-gate ** name -- daemon name (for error messages only) 22477c478bd9Sstevel@tonic-gate ** e -- the current envelope. 22487c478bd9Sstevel@tonic-gate ** d -- number of daemon 22497c478bd9Sstevel@tonic-gate ** active -- was this daemon actually active? 22507c478bd9Sstevel@tonic-gate ** 22517c478bd9Sstevel@tonic-gate ** Returns: 22527c478bd9Sstevel@tonic-gate ** true if incoming SMTP connections should be refused 22537c478bd9Sstevel@tonic-gate ** (for now). 22547c478bd9Sstevel@tonic-gate ** false if we should accept new work. 22557c478bd9Sstevel@tonic-gate ** 22567c478bd9Sstevel@tonic-gate ** Side Effects: 22577c478bd9Sstevel@tonic-gate ** Sets process title when it is rejecting connections. 22587c478bd9Sstevel@tonic-gate */ 22597c478bd9Sstevel@tonic-gate 22607c478bd9Sstevel@tonic-gate bool 22617c478bd9Sstevel@tonic-gate refuseconnections(name, e, d, active) 22627c478bd9Sstevel@tonic-gate char *name; 22637c478bd9Sstevel@tonic-gate ENVELOPE *e; 22647c478bd9Sstevel@tonic-gate int d; 22657c478bd9Sstevel@tonic-gate bool active; 22667c478bd9Sstevel@tonic-gate { 22677c478bd9Sstevel@tonic-gate static time_t lastconn[MAXDAEMONS]; 22687c478bd9Sstevel@tonic-gate static int conncnt[MAXDAEMONS]; 22697c478bd9Sstevel@tonic-gate static time_t firstrejtime[MAXDAEMONS]; 22707c478bd9Sstevel@tonic-gate static time_t nextlogtime[MAXDAEMONS]; 2271*445f2479Sjbeck #if _FFR_MEMSTAT 2272*445f2479Sjbeck long memfree; 2273*445f2479Sjbeck #endif /* _FFR_MEMSTAT */ 22747c478bd9Sstevel@tonic-gate 22757c478bd9Sstevel@tonic-gate #if XLA 22767c478bd9Sstevel@tonic-gate if (!xla_smtp_ok()) 22777c478bd9Sstevel@tonic-gate return true; 22787c478bd9Sstevel@tonic-gate #endif /* XLA */ 22797c478bd9Sstevel@tonic-gate 22807c478bd9Sstevel@tonic-gate SM_ASSERT(d >= 0); 22817c478bd9Sstevel@tonic-gate SM_ASSERT(d < MAXDAEMONS); 22827c478bd9Sstevel@tonic-gate if (ConnRateThrottle > 0) 22837c478bd9Sstevel@tonic-gate { 22847c478bd9Sstevel@tonic-gate time_t now; 22857c478bd9Sstevel@tonic-gate 22867c478bd9Sstevel@tonic-gate now = curtime(); 22877c478bd9Sstevel@tonic-gate if (active) 22887c478bd9Sstevel@tonic-gate { 22897c478bd9Sstevel@tonic-gate if (now != lastconn[d]) 22907c478bd9Sstevel@tonic-gate { 22917c478bd9Sstevel@tonic-gate lastconn[d] = now; 22927c478bd9Sstevel@tonic-gate conncnt[d] = 1; 22937c478bd9Sstevel@tonic-gate } 22947c478bd9Sstevel@tonic-gate else if (conncnt[d]++ > ConnRateThrottle) 22957c478bd9Sstevel@tonic-gate { 22967c478bd9Sstevel@tonic-gate #define D_MSG_CRT "deferring connections on daemon %s: %d per second" 22977c478bd9Sstevel@tonic-gate /* sleep to flatten out connection load */ 22987c478bd9Sstevel@tonic-gate sm_setproctitle(true, e, D_MSG_CRT, 22997c478bd9Sstevel@tonic-gate name, ConnRateThrottle); 23007c478bd9Sstevel@tonic-gate if (LogLevel > 8) 23017c478bd9Sstevel@tonic-gate sm_syslog(LOG_INFO, NOQID, D_MSG_CRT, 23027c478bd9Sstevel@tonic-gate name, ConnRateThrottle); 23037c478bd9Sstevel@tonic-gate (void) sleep(1); 23047c478bd9Sstevel@tonic-gate } 23057c478bd9Sstevel@tonic-gate } 23067c478bd9Sstevel@tonic-gate else if (now != lastconn[d]) 23077c478bd9Sstevel@tonic-gate conncnt[d] = 0; 23087c478bd9Sstevel@tonic-gate } 23097c478bd9Sstevel@tonic-gate 2310*445f2479Sjbeck 2311*445f2479Sjbeck #if _FFR_MEMSTAT 2312*445f2479Sjbeck if (RefuseLowMem > 0 && 2313*445f2479Sjbeck sm_memstat_get(MemoryResource, &memfree) >= 0 && 2314*445f2479Sjbeck memfree < RefuseLowMem) 2315*445f2479Sjbeck { 2316*445f2479Sjbeck # define R_MSG_LM "rejecting connections on daemon %s: free memory: %ld" 2317*445f2479Sjbeck sm_setproctitle(true, e, R_MSG_LM, name, memfree); 2318*445f2479Sjbeck if (LogLevel > 8) 2319*445f2479Sjbeck sm_syslog(LOG_NOTICE, NOQID, R_MSG_LM, name, memfree); 2320*445f2479Sjbeck return true; 2321*445f2479Sjbeck } 2322*445f2479Sjbeck #endif /* _FFR_MEMSTAT */ 23237c478bd9Sstevel@tonic-gate sm_getla(); 23247c478bd9Sstevel@tonic-gate if (RefuseLA > 0 && CurrentLA >= RefuseLA) 23257c478bd9Sstevel@tonic-gate { 23267c478bd9Sstevel@tonic-gate time_t now; 23277c478bd9Sstevel@tonic-gate 23287c478bd9Sstevel@tonic-gate # define R_MSG_LA "rejecting connections on daemon %s: load average: %d" 23297c478bd9Sstevel@tonic-gate # define R2_MSG_LA "have been rejecting connections on daemon %s for %s" 23307c478bd9Sstevel@tonic-gate sm_setproctitle(true, e, R_MSG_LA, name, CurrentLA); 23317c478bd9Sstevel@tonic-gate if (LogLevel > 8) 23327c478bd9Sstevel@tonic-gate sm_syslog(LOG_NOTICE, NOQID, R_MSG_LA, name, CurrentLA); 23337c478bd9Sstevel@tonic-gate now = curtime(); 23347c478bd9Sstevel@tonic-gate if (firstrejtime[d] == 0) 23357c478bd9Sstevel@tonic-gate { 23367c478bd9Sstevel@tonic-gate firstrejtime[d] = now; 23377c478bd9Sstevel@tonic-gate nextlogtime[d] = now + RejectLogInterval; 23387c478bd9Sstevel@tonic-gate } 23397c478bd9Sstevel@tonic-gate else if (nextlogtime[d] < now) 23407c478bd9Sstevel@tonic-gate { 23417c478bd9Sstevel@tonic-gate sm_syslog(LOG_ERR, NOQID, R2_MSG_LA, name, 23427c478bd9Sstevel@tonic-gate pintvl(now - firstrejtime[d], true)); 23437c478bd9Sstevel@tonic-gate nextlogtime[d] = now + RejectLogInterval; 23447c478bd9Sstevel@tonic-gate } 23457c478bd9Sstevel@tonic-gate return true; 23467c478bd9Sstevel@tonic-gate } 23477c478bd9Sstevel@tonic-gate else 23487c478bd9Sstevel@tonic-gate firstrejtime[d] = 0; 23497c478bd9Sstevel@tonic-gate 23507c478bd9Sstevel@tonic-gate if (DelayLA > 0 && CurrentLA >= DelayLA) 23517c478bd9Sstevel@tonic-gate { 23527c478bd9Sstevel@tonic-gate time_t now; 23537c478bd9Sstevel@tonic-gate static time_t log_delay = (time_t) 0; 23547c478bd9Sstevel@tonic-gate 23557c478bd9Sstevel@tonic-gate # define MIN_DELAY_LOG 90 /* wait before logging this again */ 23567c478bd9Sstevel@tonic-gate # define D_MSG_LA "delaying connections on daemon %s: load average=%d >= %d" 23577c478bd9Sstevel@tonic-gate /* sleep to flatten out connection load */ 23587c478bd9Sstevel@tonic-gate sm_setproctitle(true, e, D_MSG_LA, name, DelayLA); 23597c478bd9Sstevel@tonic-gate if (LogLevel > 8 && (now = curtime()) > log_delay) 23607c478bd9Sstevel@tonic-gate { 23617c478bd9Sstevel@tonic-gate sm_syslog(LOG_INFO, NOQID, D_MSG_LA, 23627c478bd9Sstevel@tonic-gate name, CurrentLA, DelayLA); 23637c478bd9Sstevel@tonic-gate log_delay = now + MIN_DELAY_LOG; 23647c478bd9Sstevel@tonic-gate } 23657c478bd9Sstevel@tonic-gate (void) sleep(1); 23667c478bd9Sstevel@tonic-gate } 23677c478bd9Sstevel@tonic-gate 23687c478bd9Sstevel@tonic-gate if (MaxChildren > 0 && CurChildren >= MaxChildren) 23697c478bd9Sstevel@tonic-gate { 23707c478bd9Sstevel@tonic-gate proc_list_probe(); 23717c478bd9Sstevel@tonic-gate if (CurChildren >= MaxChildren) 23727c478bd9Sstevel@tonic-gate { 23737c478bd9Sstevel@tonic-gate #define R_MSG_CHILD "rejecting connections on daemon %s: %d children, max %d" 23747c478bd9Sstevel@tonic-gate sm_setproctitle(true, e, R_MSG_CHILD, 23757c478bd9Sstevel@tonic-gate name, CurChildren, MaxChildren); 23767c478bd9Sstevel@tonic-gate if (LogLevel > 8) 23777c478bd9Sstevel@tonic-gate sm_syslog(LOG_INFO, NOQID, R_MSG_CHILD, 23787c478bd9Sstevel@tonic-gate name, CurChildren, MaxChildren); 23797c478bd9Sstevel@tonic-gate return true; 23807c478bd9Sstevel@tonic-gate } 23817c478bd9Sstevel@tonic-gate } 23827c478bd9Sstevel@tonic-gate return false; 23837c478bd9Sstevel@tonic-gate } 23847c478bd9Sstevel@tonic-gate /* 23857c478bd9Sstevel@tonic-gate ** SETPROCTITLE -- set process title for ps 23867c478bd9Sstevel@tonic-gate ** 23877c478bd9Sstevel@tonic-gate ** Parameters: 23887c478bd9Sstevel@tonic-gate ** fmt -- a printf style format string. 23897c478bd9Sstevel@tonic-gate ** a, b, c -- possible parameters to fmt. 23907c478bd9Sstevel@tonic-gate ** 23917c478bd9Sstevel@tonic-gate ** Returns: 23927c478bd9Sstevel@tonic-gate ** none. 23937c478bd9Sstevel@tonic-gate ** 23947c478bd9Sstevel@tonic-gate ** Side Effects: 23957c478bd9Sstevel@tonic-gate ** Clobbers argv of our main procedure so ps(1) will 23967c478bd9Sstevel@tonic-gate ** display the title. 23977c478bd9Sstevel@tonic-gate */ 23987c478bd9Sstevel@tonic-gate 23997c478bd9Sstevel@tonic-gate #define SPT_NONE 0 /* don't use it at all */ 24007c478bd9Sstevel@tonic-gate #define SPT_REUSEARGV 1 /* cover argv with title information */ 24017c478bd9Sstevel@tonic-gate #define SPT_BUILTIN 2 /* use libc builtin */ 24027c478bd9Sstevel@tonic-gate #define SPT_PSTAT 3 /* use pstat(PSTAT_SETCMD, ...) */ 24037c478bd9Sstevel@tonic-gate #define SPT_PSSTRINGS 4 /* use PS_STRINGS->... */ 24047c478bd9Sstevel@tonic-gate #define SPT_SYSMIPS 5 /* use sysmips() supported by NEWS-OS 6 */ 24057c478bd9Sstevel@tonic-gate #define SPT_SCO 6 /* write kernel u. area */ 24067c478bd9Sstevel@tonic-gate #define SPT_CHANGEARGV 7 /* write our own strings into argv[] */ 24077c478bd9Sstevel@tonic-gate 24087c478bd9Sstevel@tonic-gate #ifndef SPT_TYPE 24097c478bd9Sstevel@tonic-gate # define SPT_TYPE SPT_REUSEARGV 24107c478bd9Sstevel@tonic-gate #endif /* ! SPT_TYPE */ 24117c478bd9Sstevel@tonic-gate 24127c478bd9Sstevel@tonic-gate 24137c478bd9Sstevel@tonic-gate #if SPT_TYPE != SPT_NONE && SPT_TYPE != SPT_BUILTIN 24147c478bd9Sstevel@tonic-gate 24157c478bd9Sstevel@tonic-gate # if SPT_TYPE == SPT_PSTAT 24167c478bd9Sstevel@tonic-gate # include <sys/pstat.h> 24177c478bd9Sstevel@tonic-gate # endif /* SPT_TYPE == SPT_PSTAT */ 24187c478bd9Sstevel@tonic-gate # if SPT_TYPE == SPT_PSSTRINGS 24197c478bd9Sstevel@tonic-gate # include <machine/vmparam.h> 24207c478bd9Sstevel@tonic-gate # include <sys/exec.h> 24217c478bd9Sstevel@tonic-gate # ifndef PS_STRINGS /* hmmmm.... apparently not available after all */ 24227c478bd9Sstevel@tonic-gate # undef SPT_TYPE 24237c478bd9Sstevel@tonic-gate # define SPT_TYPE SPT_REUSEARGV 24247c478bd9Sstevel@tonic-gate # else /* ! PS_STRINGS */ 24257c478bd9Sstevel@tonic-gate # ifndef NKPDE /* FreeBSD 2.0 */ 24267c478bd9Sstevel@tonic-gate # define NKPDE 63 24277c478bd9Sstevel@tonic-gate typedef unsigned int *pt_entry_t; 24287c478bd9Sstevel@tonic-gate # endif /* ! NKPDE */ 24297c478bd9Sstevel@tonic-gate # endif /* ! PS_STRINGS */ 24307c478bd9Sstevel@tonic-gate # endif /* SPT_TYPE == SPT_PSSTRINGS */ 24317c478bd9Sstevel@tonic-gate 24327c478bd9Sstevel@tonic-gate # if SPT_TYPE == SPT_PSSTRINGS || SPT_TYPE == SPT_CHANGEARGV 24337c478bd9Sstevel@tonic-gate # define SETPROC_STATIC static 24347c478bd9Sstevel@tonic-gate # else /* SPT_TYPE == SPT_PSSTRINGS || SPT_TYPE == SPT_CHANGEARGV */ 24357c478bd9Sstevel@tonic-gate # define SETPROC_STATIC 24367c478bd9Sstevel@tonic-gate # endif /* SPT_TYPE == SPT_PSSTRINGS || SPT_TYPE == SPT_CHANGEARGV */ 24377c478bd9Sstevel@tonic-gate 24387c478bd9Sstevel@tonic-gate # if SPT_TYPE == SPT_SYSMIPS 24397c478bd9Sstevel@tonic-gate # include <sys/sysmips.h> 24407c478bd9Sstevel@tonic-gate # include <sys/sysnews.h> 24417c478bd9Sstevel@tonic-gate # endif /* SPT_TYPE == SPT_SYSMIPS */ 24427c478bd9Sstevel@tonic-gate 24437c478bd9Sstevel@tonic-gate # if SPT_TYPE == SPT_SCO 24447c478bd9Sstevel@tonic-gate # include <sys/immu.h> 24457c478bd9Sstevel@tonic-gate # include <sys/dir.h> 24467c478bd9Sstevel@tonic-gate # include <sys/user.h> 24477c478bd9Sstevel@tonic-gate # include <sys/fs/s5param.h> 24487c478bd9Sstevel@tonic-gate # if PSARGSZ > MAXLINE 24497c478bd9Sstevel@tonic-gate # define SPT_BUFSIZE PSARGSZ 24507c478bd9Sstevel@tonic-gate # endif /* PSARGSZ > MAXLINE */ 24517c478bd9Sstevel@tonic-gate # endif /* SPT_TYPE == SPT_SCO */ 24527c478bd9Sstevel@tonic-gate 24537c478bd9Sstevel@tonic-gate # ifndef SPT_PADCHAR 24547c478bd9Sstevel@tonic-gate # define SPT_PADCHAR ' ' 24557c478bd9Sstevel@tonic-gate # endif /* ! SPT_PADCHAR */ 24567c478bd9Sstevel@tonic-gate 24577c478bd9Sstevel@tonic-gate #endif /* SPT_TYPE != SPT_NONE && SPT_TYPE != SPT_BUILTIN */ 24587c478bd9Sstevel@tonic-gate 24597c478bd9Sstevel@tonic-gate #ifndef SPT_BUFSIZE 24607c478bd9Sstevel@tonic-gate # define SPT_BUFSIZE MAXLINE 24617c478bd9Sstevel@tonic-gate #endif /* ! SPT_BUFSIZE */ 24627c478bd9Sstevel@tonic-gate 24637c478bd9Sstevel@tonic-gate #if _FFR_SPT_ALIGN 24647c478bd9Sstevel@tonic-gate 24657c478bd9Sstevel@tonic-gate /* 24667c478bd9Sstevel@tonic-gate ** It looks like the Compaq Tru64 5.1A now aligns argv and envp to 24677c478bd9Sstevel@tonic-gate ** 64 bit alignment, so unless each piece of argv and envp is a multiple 24687c478bd9Sstevel@tonic-gate ** of 8 bytes (including terminating NULL), initsetproctitle() won't use 24697c478bd9Sstevel@tonic-gate ** any of the space beyond argv[0]. Be sure to set SPT_ALIGN_SIZE if 24707c478bd9Sstevel@tonic-gate ** you use this FFR. 24717c478bd9Sstevel@tonic-gate */ 24727c478bd9Sstevel@tonic-gate 24737c478bd9Sstevel@tonic-gate # ifdef SPT_ALIGN_SIZE 24747c478bd9Sstevel@tonic-gate # define SPT_ALIGN(x, align) (((((x) + SPT_ALIGN_SIZE) >> (align)) << (align)) - 1) 24757c478bd9Sstevel@tonic-gate # else /* SPT_ALIGN_SIZE */ 24767c478bd9Sstevel@tonic-gate # define SPT_ALIGN(x, align) (x) 24777c478bd9Sstevel@tonic-gate # endif /* SPT_ALIGN_SIZE */ 24787c478bd9Sstevel@tonic-gate #else /* _FFR_SPT_ALIGN */ 24797c478bd9Sstevel@tonic-gate # define SPT_ALIGN(x, align) (x) 24807c478bd9Sstevel@tonic-gate #endif /* _FFR_SPT_ALIGN */ 24817c478bd9Sstevel@tonic-gate 24827c478bd9Sstevel@tonic-gate /* 24837c478bd9Sstevel@tonic-gate ** Pointers for setproctitle. 24847c478bd9Sstevel@tonic-gate ** This allows "ps" listings to give more useful information. 24857c478bd9Sstevel@tonic-gate */ 24867c478bd9Sstevel@tonic-gate 24877c478bd9Sstevel@tonic-gate static char **Argv = NULL; /* pointer to argument vector */ 24887c478bd9Sstevel@tonic-gate static char *LastArgv = NULL; /* end of argv */ 24897c478bd9Sstevel@tonic-gate #if SPT_TYPE != SPT_BUILTIN 24907c478bd9Sstevel@tonic-gate static void setproctitle __P((const char *, ...)); 24917c478bd9Sstevel@tonic-gate #endif /* SPT_TYPE != SPT_BUILTIN */ 24927c478bd9Sstevel@tonic-gate 24937c478bd9Sstevel@tonic-gate void 24947c478bd9Sstevel@tonic-gate initsetproctitle(argc, argv, envp) 24957c478bd9Sstevel@tonic-gate int argc; 24967c478bd9Sstevel@tonic-gate char **argv; 24977c478bd9Sstevel@tonic-gate char **envp; 24987c478bd9Sstevel@tonic-gate { 24997c478bd9Sstevel@tonic-gate register int i; 25007c478bd9Sstevel@tonic-gate int align; 25017c478bd9Sstevel@tonic-gate extern char **environ; 25027c478bd9Sstevel@tonic-gate 25037c478bd9Sstevel@tonic-gate /* 25047c478bd9Sstevel@tonic-gate ** Move the environment so setproctitle can use the space at 25057c478bd9Sstevel@tonic-gate ** the top of memory. 25067c478bd9Sstevel@tonic-gate */ 25077c478bd9Sstevel@tonic-gate 25087c478bd9Sstevel@tonic-gate if (envp != NULL) 25097c478bd9Sstevel@tonic-gate { 25107c478bd9Sstevel@tonic-gate for (i = 0; envp[i] != NULL; i++) 25117c478bd9Sstevel@tonic-gate continue; 25127c478bd9Sstevel@tonic-gate environ = (char **) xalloc(sizeof (char *) * (i + 1)); 25137c478bd9Sstevel@tonic-gate for (i = 0; envp[i] != NULL; i++) 25147c478bd9Sstevel@tonic-gate environ[i] = newstr(envp[i]); 25157c478bd9Sstevel@tonic-gate environ[i] = NULL; 25167c478bd9Sstevel@tonic-gate } 25177c478bd9Sstevel@tonic-gate 25187c478bd9Sstevel@tonic-gate /* 25197c478bd9Sstevel@tonic-gate ** Save start and extent of argv for setproctitle. 25207c478bd9Sstevel@tonic-gate */ 25217c478bd9Sstevel@tonic-gate 25227c478bd9Sstevel@tonic-gate Argv = argv; 25237c478bd9Sstevel@tonic-gate 25247c478bd9Sstevel@tonic-gate /* 25257c478bd9Sstevel@tonic-gate ** Determine how much space we can use for setproctitle. 25267c478bd9Sstevel@tonic-gate ** Use all contiguous argv and envp pointers starting at argv[0] 25277c478bd9Sstevel@tonic-gate */ 25287c478bd9Sstevel@tonic-gate 25297c478bd9Sstevel@tonic-gate align = -1; 25307c478bd9Sstevel@tonic-gate # if _FFR_SPT_ALIGN 25317c478bd9Sstevel@tonic-gate # ifdef SPT_ALIGN_SIZE 25327c478bd9Sstevel@tonic-gate for (i = SPT_ALIGN_SIZE; i > 0; i >>= 1) 25337c478bd9Sstevel@tonic-gate align++; 25347c478bd9Sstevel@tonic-gate # endif /* SPT_ALIGN_SIZE */ 25357c478bd9Sstevel@tonic-gate # endif /* _FFR_SPT_ALIGN */ 25367c478bd9Sstevel@tonic-gate 25377c478bd9Sstevel@tonic-gate for (i = 0; i < argc; i++) 25387c478bd9Sstevel@tonic-gate { 25397c478bd9Sstevel@tonic-gate if (i == 0 || LastArgv + 1 == argv[i]) 25407c478bd9Sstevel@tonic-gate LastArgv = argv[i] + SPT_ALIGN(strlen(argv[i]), align); 25417c478bd9Sstevel@tonic-gate } 25427c478bd9Sstevel@tonic-gate for (i = 0; LastArgv != NULL && envp != NULL && envp[i] != NULL; i++) 25437c478bd9Sstevel@tonic-gate { 25447c478bd9Sstevel@tonic-gate if (LastArgv + 1 == envp[i]) 25457c478bd9Sstevel@tonic-gate LastArgv = envp[i] + SPT_ALIGN(strlen(envp[i]), align); 25467c478bd9Sstevel@tonic-gate } 25477c478bd9Sstevel@tonic-gate } 25487c478bd9Sstevel@tonic-gate 25497c478bd9Sstevel@tonic-gate #if SPT_TYPE != SPT_BUILTIN 25507c478bd9Sstevel@tonic-gate 25517c478bd9Sstevel@tonic-gate /*VARARGS1*/ 25527c478bd9Sstevel@tonic-gate static void 25537c478bd9Sstevel@tonic-gate # ifdef __STDC__ 25547c478bd9Sstevel@tonic-gate setproctitle(const char *fmt, ...) 25557c478bd9Sstevel@tonic-gate # else /* __STDC__ */ 25567c478bd9Sstevel@tonic-gate setproctitle(fmt, va_alist) 25577c478bd9Sstevel@tonic-gate const char *fmt; 25587c478bd9Sstevel@tonic-gate va_dcl 25597c478bd9Sstevel@tonic-gate # endif /* __STDC__ */ 25607c478bd9Sstevel@tonic-gate { 25617c478bd9Sstevel@tonic-gate # if SPT_TYPE != SPT_NONE 25627c478bd9Sstevel@tonic-gate register int i; 25637c478bd9Sstevel@tonic-gate register char *p; 25647c478bd9Sstevel@tonic-gate SETPROC_STATIC char buf[SPT_BUFSIZE]; 25657c478bd9Sstevel@tonic-gate SM_VA_LOCAL_DECL 25667c478bd9Sstevel@tonic-gate # if SPT_TYPE == SPT_PSTAT 25677c478bd9Sstevel@tonic-gate union pstun pst; 25687c478bd9Sstevel@tonic-gate # endif /* SPT_TYPE == SPT_PSTAT */ 25697c478bd9Sstevel@tonic-gate # if SPT_TYPE == SPT_SCO 25707c478bd9Sstevel@tonic-gate int j; 25717c478bd9Sstevel@tonic-gate off_t seek_off; 25727c478bd9Sstevel@tonic-gate static int kmem = -1; 25737c478bd9Sstevel@tonic-gate static pid_t kmempid = -1; 25747c478bd9Sstevel@tonic-gate struct user u; 25757c478bd9Sstevel@tonic-gate # endif /* SPT_TYPE == SPT_SCO */ 25767c478bd9Sstevel@tonic-gate 25777c478bd9Sstevel@tonic-gate p = buf; 25787c478bd9Sstevel@tonic-gate 25797c478bd9Sstevel@tonic-gate /* print sendmail: heading for grep */ 25807c478bd9Sstevel@tonic-gate (void) sm_strlcpy(p, "sendmail: ", SPACELEFT(buf, p)); 25817c478bd9Sstevel@tonic-gate p += strlen(p); 25827c478bd9Sstevel@tonic-gate 25837c478bd9Sstevel@tonic-gate /* print the argument string */ 25847c478bd9Sstevel@tonic-gate SM_VA_START(ap, fmt); 25857c478bd9Sstevel@tonic-gate (void) sm_vsnprintf(p, SPACELEFT(buf, p), fmt, ap); 25867c478bd9Sstevel@tonic-gate SM_VA_END(ap); 25877c478bd9Sstevel@tonic-gate 25887c478bd9Sstevel@tonic-gate i = (int) strlen(buf); 25897c478bd9Sstevel@tonic-gate if (i < 0) 25907c478bd9Sstevel@tonic-gate return; 25917c478bd9Sstevel@tonic-gate 25927c478bd9Sstevel@tonic-gate # if SPT_TYPE == SPT_PSTAT 25937c478bd9Sstevel@tonic-gate pst.pst_command = buf; 25947c478bd9Sstevel@tonic-gate pstat(PSTAT_SETCMD, pst, i, 0, 0); 25957c478bd9Sstevel@tonic-gate # endif /* SPT_TYPE == SPT_PSTAT */ 25967c478bd9Sstevel@tonic-gate # if SPT_TYPE == SPT_PSSTRINGS 25977c478bd9Sstevel@tonic-gate PS_STRINGS->ps_nargvstr = 1; 25987c478bd9Sstevel@tonic-gate PS_STRINGS->ps_argvstr = buf; 25997c478bd9Sstevel@tonic-gate # endif /* SPT_TYPE == SPT_PSSTRINGS */ 26007c478bd9Sstevel@tonic-gate # if SPT_TYPE == SPT_SYSMIPS 26017c478bd9Sstevel@tonic-gate sysmips(SONY_SYSNEWS, NEWS_SETPSARGS, buf); 26027c478bd9Sstevel@tonic-gate # endif /* SPT_TYPE == SPT_SYSMIPS */ 26037c478bd9Sstevel@tonic-gate # if SPT_TYPE == SPT_SCO 26047c478bd9Sstevel@tonic-gate if (kmem < 0 || kmempid != CurrentPid) 26057c478bd9Sstevel@tonic-gate { 26067c478bd9Sstevel@tonic-gate if (kmem >= 0) 26077c478bd9Sstevel@tonic-gate (void) close(kmem); 26087c478bd9Sstevel@tonic-gate kmem = open(_PATH_KMEM, O_RDWR, 0); 26097c478bd9Sstevel@tonic-gate if (kmem < 0) 26107c478bd9Sstevel@tonic-gate return; 26117c478bd9Sstevel@tonic-gate if ((j = fcntl(kmem, F_GETFD, 0)) < 0 || 26127c478bd9Sstevel@tonic-gate fcntl(kmem, F_SETFD, j | FD_CLOEXEC) < 0) 26137c478bd9Sstevel@tonic-gate { 26147c478bd9Sstevel@tonic-gate (void) close(kmem); 26157c478bd9Sstevel@tonic-gate kmem = -1; 26167c478bd9Sstevel@tonic-gate return; 26177c478bd9Sstevel@tonic-gate } 26187c478bd9Sstevel@tonic-gate kmempid = CurrentPid; 26197c478bd9Sstevel@tonic-gate } 26207c478bd9Sstevel@tonic-gate buf[PSARGSZ - 1] = '\0'; 26217c478bd9Sstevel@tonic-gate seek_off = UVUBLK + (off_t) u.u_psargs - (off_t) &u; 26227c478bd9Sstevel@tonic-gate if (lseek(kmem, (off_t) seek_off, SEEK_SET) == seek_off) 26237c478bd9Sstevel@tonic-gate (void) write(kmem, buf, PSARGSZ); 26247c478bd9Sstevel@tonic-gate # endif /* SPT_TYPE == SPT_SCO */ 26257c478bd9Sstevel@tonic-gate # if SPT_TYPE == SPT_REUSEARGV 26267c478bd9Sstevel@tonic-gate if (LastArgv == NULL) 26277c478bd9Sstevel@tonic-gate return; 26287c478bd9Sstevel@tonic-gate 26297c478bd9Sstevel@tonic-gate if (i > LastArgv - Argv[0] - 2) 26307c478bd9Sstevel@tonic-gate { 26317c478bd9Sstevel@tonic-gate i = LastArgv - Argv[0] - 2; 26327c478bd9Sstevel@tonic-gate buf[i] = '\0'; 26337c478bd9Sstevel@tonic-gate } 26347c478bd9Sstevel@tonic-gate (void) sm_strlcpy(Argv[0], buf, i + 1); 26357c478bd9Sstevel@tonic-gate p = &Argv[0][i]; 26367c478bd9Sstevel@tonic-gate while (p < LastArgv) 26377c478bd9Sstevel@tonic-gate *p++ = SPT_PADCHAR; 26387c478bd9Sstevel@tonic-gate Argv[1] = NULL; 26397c478bd9Sstevel@tonic-gate # endif /* SPT_TYPE == SPT_REUSEARGV */ 26407c478bd9Sstevel@tonic-gate # if SPT_TYPE == SPT_CHANGEARGV 26417c478bd9Sstevel@tonic-gate Argv[0] = buf; 26427c478bd9Sstevel@tonic-gate Argv[1] = 0; 26437c478bd9Sstevel@tonic-gate # endif /* SPT_TYPE == SPT_CHANGEARGV */ 26447c478bd9Sstevel@tonic-gate # endif /* SPT_TYPE != SPT_NONE */ 26457c478bd9Sstevel@tonic-gate } 26467c478bd9Sstevel@tonic-gate 26477c478bd9Sstevel@tonic-gate #endif /* SPT_TYPE != SPT_BUILTIN */ 26487c478bd9Sstevel@tonic-gate /* 26497c478bd9Sstevel@tonic-gate ** SM_SETPROCTITLE -- set process task and set process title for ps 26507c478bd9Sstevel@tonic-gate ** 26517c478bd9Sstevel@tonic-gate ** Possibly set process status and call setproctitle() to 26527c478bd9Sstevel@tonic-gate ** change the ps display. 26537c478bd9Sstevel@tonic-gate ** 26547c478bd9Sstevel@tonic-gate ** Parameters: 26557c478bd9Sstevel@tonic-gate ** status -- whether or not to store as process status 26567c478bd9Sstevel@tonic-gate ** e -- the current envelope. 26577c478bd9Sstevel@tonic-gate ** fmt -- a printf style format string. 26587c478bd9Sstevel@tonic-gate ** a, b, c -- possible parameters to fmt. 26597c478bd9Sstevel@tonic-gate ** 26607c478bd9Sstevel@tonic-gate ** Returns: 26617c478bd9Sstevel@tonic-gate ** none. 26627c478bd9Sstevel@tonic-gate */ 26637c478bd9Sstevel@tonic-gate 26647c478bd9Sstevel@tonic-gate /*VARARGS2*/ 26657c478bd9Sstevel@tonic-gate void 26667c478bd9Sstevel@tonic-gate #ifdef __STDC__ 26677c478bd9Sstevel@tonic-gate sm_setproctitle(bool status, ENVELOPE *e, const char *fmt, ...) 26687c478bd9Sstevel@tonic-gate #else /* __STDC__ */ 26697c478bd9Sstevel@tonic-gate sm_setproctitle(status, e, fmt, va_alist) 26707c478bd9Sstevel@tonic-gate bool status; 26717c478bd9Sstevel@tonic-gate ENVELOPE *e; 26727c478bd9Sstevel@tonic-gate const char *fmt; 26737c478bd9Sstevel@tonic-gate va_dcl 26747c478bd9Sstevel@tonic-gate #endif /* __STDC__ */ 26757c478bd9Sstevel@tonic-gate { 26767c478bd9Sstevel@tonic-gate char buf[SPT_BUFSIZE]; 26777c478bd9Sstevel@tonic-gate SM_VA_LOCAL_DECL 26787c478bd9Sstevel@tonic-gate 26797c478bd9Sstevel@tonic-gate /* print the argument string */ 26807c478bd9Sstevel@tonic-gate SM_VA_START(ap, fmt); 26817c478bd9Sstevel@tonic-gate (void) sm_vsnprintf(buf, sizeof buf, fmt, ap); 26827c478bd9Sstevel@tonic-gate SM_VA_END(ap); 26837c478bd9Sstevel@tonic-gate 26847c478bd9Sstevel@tonic-gate if (status) 26857c478bd9Sstevel@tonic-gate proc_list_set(CurrentPid, buf); 26867c478bd9Sstevel@tonic-gate 26877c478bd9Sstevel@tonic-gate if (ProcTitlePrefix != NULL) 26887c478bd9Sstevel@tonic-gate { 26897c478bd9Sstevel@tonic-gate char prefix[SPT_BUFSIZE]; 26907c478bd9Sstevel@tonic-gate 26917c478bd9Sstevel@tonic-gate expand(ProcTitlePrefix, prefix, sizeof prefix, e); 26927c478bd9Sstevel@tonic-gate setproctitle("%s: %s", prefix, buf); 26937c478bd9Sstevel@tonic-gate } 26947c478bd9Sstevel@tonic-gate else 26957c478bd9Sstevel@tonic-gate setproctitle("%s", buf); 26967c478bd9Sstevel@tonic-gate } 26977c478bd9Sstevel@tonic-gate /* 26987c478bd9Sstevel@tonic-gate ** WAITFOR -- wait for a particular process id. 26997c478bd9Sstevel@tonic-gate ** 27007c478bd9Sstevel@tonic-gate ** Parameters: 27017c478bd9Sstevel@tonic-gate ** pid -- process id to wait for. 27027c478bd9Sstevel@tonic-gate ** 27037c478bd9Sstevel@tonic-gate ** Returns: 27047c478bd9Sstevel@tonic-gate ** status of pid. 27057c478bd9Sstevel@tonic-gate ** -1 if pid never shows up. 27067c478bd9Sstevel@tonic-gate ** 27077c478bd9Sstevel@tonic-gate ** Side Effects: 27087c478bd9Sstevel@tonic-gate ** none. 27097c478bd9Sstevel@tonic-gate */ 27107c478bd9Sstevel@tonic-gate 27117c478bd9Sstevel@tonic-gate int 27127c478bd9Sstevel@tonic-gate waitfor(pid) 27137c478bd9Sstevel@tonic-gate pid_t pid; 27147c478bd9Sstevel@tonic-gate { 27157c478bd9Sstevel@tonic-gate int st; 27167c478bd9Sstevel@tonic-gate pid_t i; 27177c478bd9Sstevel@tonic-gate 27187c478bd9Sstevel@tonic-gate do 27197c478bd9Sstevel@tonic-gate { 27207c478bd9Sstevel@tonic-gate errno = 0; 27217c478bd9Sstevel@tonic-gate i = sm_wait(&st); 27227c478bd9Sstevel@tonic-gate if (i > 0) 27237c478bd9Sstevel@tonic-gate proc_list_drop(i, st, NULL); 27247c478bd9Sstevel@tonic-gate } while ((i >= 0 || errno == EINTR) && i != pid); 27257c478bd9Sstevel@tonic-gate if (i < 0) 27267c478bd9Sstevel@tonic-gate return -1; 27277c478bd9Sstevel@tonic-gate return st; 27287c478bd9Sstevel@tonic-gate } 27297c478bd9Sstevel@tonic-gate /* 27307c478bd9Sstevel@tonic-gate ** SM_WAIT -- wait 27317c478bd9Sstevel@tonic-gate ** 27327c478bd9Sstevel@tonic-gate ** Parameters: 27337c478bd9Sstevel@tonic-gate ** status -- pointer to status (return value) 27347c478bd9Sstevel@tonic-gate ** 27357c478bd9Sstevel@tonic-gate ** Returns: 27367c478bd9Sstevel@tonic-gate ** pid 27377c478bd9Sstevel@tonic-gate */ 27387c478bd9Sstevel@tonic-gate 27397c478bd9Sstevel@tonic-gate pid_t 27407c478bd9Sstevel@tonic-gate sm_wait(status) 27417c478bd9Sstevel@tonic-gate int *status; 27427c478bd9Sstevel@tonic-gate { 27437c478bd9Sstevel@tonic-gate # ifdef WAITUNION 27447c478bd9Sstevel@tonic-gate union wait st; 27457c478bd9Sstevel@tonic-gate # else /* WAITUNION */ 27467c478bd9Sstevel@tonic-gate auto int st; 27477c478bd9Sstevel@tonic-gate # endif /* WAITUNION */ 27487c478bd9Sstevel@tonic-gate pid_t i; 27497c478bd9Sstevel@tonic-gate # if defined(ISC_UNIX) || defined(_SCO_unix_) 27507c478bd9Sstevel@tonic-gate int savesig; 27517c478bd9Sstevel@tonic-gate # endif /* defined(ISC_UNIX) || defined(_SCO_unix_) */ 27527c478bd9Sstevel@tonic-gate 27537c478bd9Sstevel@tonic-gate # if defined(ISC_UNIX) || defined(_SCO_unix_) 27547c478bd9Sstevel@tonic-gate savesig = sm_releasesignal(SIGCHLD); 27557c478bd9Sstevel@tonic-gate # endif /* defined(ISC_UNIX) || defined(_SCO_unix_) */ 27567c478bd9Sstevel@tonic-gate i = wait(&st); 27577c478bd9Sstevel@tonic-gate # if defined(ISC_UNIX) || defined(_SCO_unix_) 27587c478bd9Sstevel@tonic-gate if (savesig > 0) 27597c478bd9Sstevel@tonic-gate sm_blocksignal(SIGCHLD); 27607c478bd9Sstevel@tonic-gate # endif /* defined(ISC_UNIX) || defined(_SCO_unix_) */ 27617c478bd9Sstevel@tonic-gate # ifdef WAITUNION 27627c478bd9Sstevel@tonic-gate *status = st.w_status; 27637c478bd9Sstevel@tonic-gate # else /* WAITUNION */ 27647c478bd9Sstevel@tonic-gate *status = st; 27657c478bd9Sstevel@tonic-gate # endif /* WAITUNION */ 27667c478bd9Sstevel@tonic-gate return i; 27677c478bd9Sstevel@tonic-gate } 27687c478bd9Sstevel@tonic-gate /* 27697c478bd9Sstevel@tonic-gate ** REAPCHILD -- pick up the body of my child, lest it become a zombie 27707c478bd9Sstevel@tonic-gate ** 27717c478bd9Sstevel@tonic-gate ** Parameters: 27727c478bd9Sstevel@tonic-gate ** sig -- the signal that got us here (unused). 27737c478bd9Sstevel@tonic-gate ** 27747c478bd9Sstevel@tonic-gate ** Returns: 27757c478bd9Sstevel@tonic-gate ** none. 27767c478bd9Sstevel@tonic-gate ** 27777c478bd9Sstevel@tonic-gate ** Side Effects: 27787c478bd9Sstevel@tonic-gate ** Picks up extant zombies. 27797c478bd9Sstevel@tonic-gate ** Control socket exits may restart/shutdown daemon. 27807c478bd9Sstevel@tonic-gate ** 27817c478bd9Sstevel@tonic-gate ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD 27827c478bd9Sstevel@tonic-gate ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE 27837c478bd9Sstevel@tonic-gate ** DOING. 27847c478bd9Sstevel@tonic-gate */ 27857c478bd9Sstevel@tonic-gate 27867c478bd9Sstevel@tonic-gate /* ARGSUSED0 */ 27877c478bd9Sstevel@tonic-gate SIGFUNC_DECL 27887c478bd9Sstevel@tonic-gate reapchild(sig) 27897c478bd9Sstevel@tonic-gate int sig; 27907c478bd9Sstevel@tonic-gate { 27917c478bd9Sstevel@tonic-gate int save_errno = errno; 27927c478bd9Sstevel@tonic-gate int st; 27937c478bd9Sstevel@tonic-gate pid_t pid; 27947c478bd9Sstevel@tonic-gate # if HASWAITPID 27957c478bd9Sstevel@tonic-gate auto int status; 27967c478bd9Sstevel@tonic-gate int count; 27977c478bd9Sstevel@tonic-gate 27987c478bd9Sstevel@tonic-gate count = 0; 27997c478bd9Sstevel@tonic-gate while ((pid = waitpid(-1, &status, WNOHANG)) > 0) 28007c478bd9Sstevel@tonic-gate { 28017c478bd9Sstevel@tonic-gate st = status; 28027c478bd9Sstevel@tonic-gate if (count++ > 1000) 28037c478bd9Sstevel@tonic-gate break; 28047c478bd9Sstevel@tonic-gate # else /* HASWAITPID */ 28057c478bd9Sstevel@tonic-gate # ifdef WNOHANG 28067c478bd9Sstevel@tonic-gate union wait status; 28077c478bd9Sstevel@tonic-gate 28087c478bd9Sstevel@tonic-gate while ((pid = wait3(&status, WNOHANG, (struct rusage *) NULL)) > 0) 28097c478bd9Sstevel@tonic-gate { 28107c478bd9Sstevel@tonic-gate st = status.w_status; 28117c478bd9Sstevel@tonic-gate # else /* WNOHANG */ 28127c478bd9Sstevel@tonic-gate auto int status; 28137c478bd9Sstevel@tonic-gate 28147c478bd9Sstevel@tonic-gate /* 28157c478bd9Sstevel@tonic-gate ** Catch one zombie -- we will be re-invoked (we hope) if there 28167c478bd9Sstevel@tonic-gate ** are more. Unreliable signals probably break this, but this 28177c478bd9Sstevel@tonic-gate ** is the "old system" situation -- waitpid or wait3 are to be 28187c478bd9Sstevel@tonic-gate ** strongly preferred. 28197c478bd9Sstevel@tonic-gate */ 28207c478bd9Sstevel@tonic-gate 28217c478bd9Sstevel@tonic-gate if ((pid = wait(&status)) > 0) 28227c478bd9Sstevel@tonic-gate { 28237c478bd9Sstevel@tonic-gate st = status; 28247c478bd9Sstevel@tonic-gate # endif /* WNOHANG */ 28257c478bd9Sstevel@tonic-gate # endif /* HASWAITPID */ 28267c478bd9Sstevel@tonic-gate /* Drop PID and check if it was a control socket child */ 28277c478bd9Sstevel@tonic-gate proc_list_drop(pid, st, NULL); 28287c478bd9Sstevel@tonic-gate } 28297c478bd9Sstevel@tonic-gate FIX_SYSV_SIGNAL(sig, reapchild); 28307c478bd9Sstevel@tonic-gate errno = save_errno; 28317c478bd9Sstevel@tonic-gate return SIGFUNC_RETURN; 28327c478bd9Sstevel@tonic-gate } 28337c478bd9Sstevel@tonic-gate /* 28347c478bd9Sstevel@tonic-gate ** GETDTABLESIZE -- return number of file descriptors 28357c478bd9Sstevel@tonic-gate ** 28367c478bd9Sstevel@tonic-gate ** Only on non-BSD systems 28377c478bd9Sstevel@tonic-gate ** 28387c478bd9Sstevel@tonic-gate ** Parameters: 28397c478bd9Sstevel@tonic-gate ** none 28407c478bd9Sstevel@tonic-gate ** 28417c478bd9Sstevel@tonic-gate ** Returns: 28427c478bd9Sstevel@tonic-gate ** size of file descriptor table 28437c478bd9Sstevel@tonic-gate ** 28447c478bd9Sstevel@tonic-gate ** Side Effects: 28457c478bd9Sstevel@tonic-gate ** none 28467c478bd9Sstevel@tonic-gate */ 28477c478bd9Sstevel@tonic-gate 28487c478bd9Sstevel@tonic-gate #ifdef SOLARIS 28497c478bd9Sstevel@tonic-gate # include <sys/resource.h> 28507c478bd9Sstevel@tonic-gate #endif /* SOLARIS */ 28517c478bd9Sstevel@tonic-gate 28527c478bd9Sstevel@tonic-gate int 28537c478bd9Sstevel@tonic-gate getdtsize() 28547c478bd9Sstevel@tonic-gate { 28557c478bd9Sstevel@tonic-gate # ifdef RLIMIT_NOFILE 28567c478bd9Sstevel@tonic-gate struct rlimit rl; 28577c478bd9Sstevel@tonic-gate 28587c478bd9Sstevel@tonic-gate if (getrlimit(RLIMIT_NOFILE, &rl) >= 0) 28597c478bd9Sstevel@tonic-gate return rl.rlim_cur; 28607c478bd9Sstevel@tonic-gate # endif /* RLIMIT_NOFILE */ 28617c478bd9Sstevel@tonic-gate 28627c478bd9Sstevel@tonic-gate # if HASGETDTABLESIZE 28637c478bd9Sstevel@tonic-gate return getdtablesize(); 28647c478bd9Sstevel@tonic-gate # else /* HASGETDTABLESIZE */ 28657c478bd9Sstevel@tonic-gate # ifdef _SC_OPEN_MAX 28667c478bd9Sstevel@tonic-gate return sysconf(_SC_OPEN_MAX); 28677c478bd9Sstevel@tonic-gate # else /* _SC_OPEN_MAX */ 28687c478bd9Sstevel@tonic-gate return NOFILE; 28697c478bd9Sstevel@tonic-gate # endif /* _SC_OPEN_MAX */ 28707c478bd9Sstevel@tonic-gate # endif /* HASGETDTABLESIZE */ 28717c478bd9Sstevel@tonic-gate } 28727c478bd9Sstevel@tonic-gate /* 28737c478bd9Sstevel@tonic-gate ** UNAME -- get the UUCP name of this system. 28747c478bd9Sstevel@tonic-gate */ 28757c478bd9Sstevel@tonic-gate 28767c478bd9Sstevel@tonic-gate #if !HASUNAME 28777c478bd9Sstevel@tonic-gate 28787c478bd9Sstevel@tonic-gate int 28797c478bd9Sstevel@tonic-gate uname(name) 28807c478bd9Sstevel@tonic-gate struct utsname *name; 28817c478bd9Sstevel@tonic-gate { 28827c478bd9Sstevel@tonic-gate SM_FILE_T *file; 28837c478bd9Sstevel@tonic-gate char *n; 28847c478bd9Sstevel@tonic-gate 28857c478bd9Sstevel@tonic-gate name->nodename[0] = '\0'; 28867c478bd9Sstevel@tonic-gate 28877c478bd9Sstevel@tonic-gate /* try /etc/whoami -- one line with the node name */ 28887c478bd9Sstevel@tonic-gate if ((file = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, "/etc/whoami", 28897c478bd9Sstevel@tonic-gate SM_IO_RDONLY, NULL)) != NULL) 28907c478bd9Sstevel@tonic-gate { 28917c478bd9Sstevel@tonic-gate (void) sm_io_fgets(file, SM_TIME_DEFAULT, name->nodename, 28927c478bd9Sstevel@tonic-gate NODE_LENGTH + 1); 28937c478bd9Sstevel@tonic-gate (void) sm_io_close(file, SM_TIME_DEFAULT); 28947c478bd9Sstevel@tonic-gate n = strchr(name->nodename, '\n'); 28957c478bd9Sstevel@tonic-gate if (n != NULL) 28967c478bd9Sstevel@tonic-gate *n = '\0'; 28977c478bd9Sstevel@tonic-gate if (name->nodename[0] != '\0') 28987c478bd9Sstevel@tonic-gate return 0; 28997c478bd9Sstevel@tonic-gate } 29007c478bd9Sstevel@tonic-gate 29017c478bd9Sstevel@tonic-gate /* try /usr/include/whoami.h -- has a #define somewhere */ 29027c478bd9Sstevel@tonic-gate if ((file = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, 29037c478bd9Sstevel@tonic-gate "/usr/include/whoami.h", SM_IO_RDONLY, NULL)) 29047c478bd9Sstevel@tonic-gate != NULL) 29057c478bd9Sstevel@tonic-gate { 29067c478bd9Sstevel@tonic-gate char buf[MAXLINE]; 29077c478bd9Sstevel@tonic-gate 29087c478bd9Sstevel@tonic-gate while (sm_io_fgets(file, SM_TIME_DEFAULT, 29097c478bd9Sstevel@tonic-gate buf, sizeof buf) != NULL) 29107c478bd9Sstevel@tonic-gate { 29117c478bd9Sstevel@tonic-gate if (sm_io_sscanf(buf, "#define sysname \"%*[^\"]\"", 29127c478bd9Sstevel@tonic-gate NODE_LENGTH, name->nodename) > 0) 29137c478bd9Sstevel@tonic-gate break; 29147c478bd9Sstevel@tonic-gate } 29157c478bd9Sstevel@tonic-gate (void) sm_io_close(file, SM_TIME_DEFAULT); 29167c478bd9Sstevel@tonic-gate if (name->nodename[0] != '\0') 29177c478bd9Sstevel@tonic-gate return 0; 29187c478bd9Sstevel@tonic-gate } 29197c478bd9Sstevel@tonic-gate 29207c478bd9Sstevel@tonic-gate return -1; 29217c478bd9Sstevel@tonic-gate } 29227c478bd9Sstevel@tonic-gate #endif /* !HASUNAME */ 29237c478bd9Sstevel@tonic-gate /* 29247c478bd9Sstevel@tonic-gate ** INITGROUPS -- initialize groups 29257c478bd9Sstevel@tonic-gate ** 29267c478bd9Sstevel@tonic-gate ** Stub implementation for System V style systems 29277c478bd9Sstevel@tonic-gate */ 29287c478bd9Sstevel@tonic-gate 29297c478bd9Sstevel@tonic-gate #if !HASINITGROUPS 29307c478bd9Sstevel@tonic-gate 29317c478bd9Sstevel@tonic-gate initgroups(name, basegid) 29327c478bd9Sstevel@tonic-gate char *name; 29337c478bd9Sstevel@tonic-gate int basegid; 29347c478bd9Sstevel@tonic-gate { 29357c478bd9Sstevel@tonic-gate return 0; 29367c478bd9Sstevel@tonic-gate } 29377c478bd9Sstevel@tonic-gate 29387c478bd9Sstevel@tonic-gate #endif /* !HASINITGROUPS */ 29397c478bd9Sstevel@tonic-gate /* 29407c478bd9Sstevel@tonic-gate ** SETGROUPS -- set group list 29417c478bd9Sstevel@tonic-gate ** 29427c478bd9Sstevel@tonic-gate ** Stub implementation for systems that don't have group lists 29437c478bd9Sstevel@tonic-gate */ 29447c478bd9Sstevel@tonic-gate 29457c478bd9Sstevel@tonic-gate #ifndef NGROUPS_MAX 29467c478bd9Sstevel@tonic-gate 29477c478bd9Sstevel@tonic-gate int 29487c478bd9Sstevel@tonic-gate setgroups(ngroups, grouplist) 29497c478bd9Sstevel@tonic-gate int ngroups; 29507c478bd9Sstevel@tonic-gate GIDSET_T grouplist[]; 29517c478bd9Sstevel@tonic-gate { 29527c478bd9Sstevel@tonic-gate return 0; 29537c478bd9Sstevel@tonic-gate } 29547c478bd9Sstevel@tonic-gate 29557c478bd9Sstevel@tonic-gate #endif /* ! NGROUPS_MAX */ 29567c478bd9Sstevel@tonic-gate /* 29577c478bd9Sstevel@tonic-gate ** SETSID -- set session id (for non-POSIX systems) 29587c478bd9Sstevel@tonic-gate */ 29597c478bd9Sstevel@tonic-gate 29607c478bd9Sstevel@tonic-gate #if !HASSETSID 29617c478bd9Sstevel@tonic-gate 29627c478bd9Sstevel@tonic-gate pid_t 29637c478bd9Sstevel@tonic-gate setsid __P ((void)) 29647c478bd9Sstevel@tonic-gate { 29657c478bd9Sstevel@tonic-gate # ifdef TIOCNOTTY 29667c478bd9Sstevel@tonic-gate int fd; 29677c478bd9Sstevel@tonic-gate 29687c478bd9Sstevel@tonic-gate fd = open("/dev/tty", O_RDWR, 0); 29697c478bd9Sstevel@tonic-gate if (fd >= 0) 29707c478bd9Sstevel@tonic-gate { 29717c478bd9Sstevel@tonic-gate (void) ioctl(fd, TIOCNOTTY, (char *) 0); 29727c478bd9Sstevel@tonic-gate (void) close(fd); 29737c478bd9Sstevel@tonic-gate } 29747c478bd9Sstevel@tonic-gate # endif /* TIOCNOTTY */ 29757c478bd9Sstevel@tonic-gate # ifdef SYS5SETPGRP 29767c478bd9Sstevel@tonic-gate return setpgrp(); 29777c478bd9Sstevel@tonic-gate # else /* SYS5SETPGRP */ 29787c478bd9Sstevel@tonic-gate return setpgid(0, CurrentPid); 29797c478bd9Sstevel@tonic-gate # endif /* SYS5SETPGRP */ 29807c478bd9Sstevel@tonic-gate } 29817c478bd9Sstevel@tonic-gate 29827c478bd9Sstevel@tonic-gate #endif /* !HASSETSID */ 29837c478bd9Sstevel@tonic-gate /* 29847c478bd9Sstevel@tonic-gate ** FSYNC -- dummy fsync 29857c478bd9Sstevel@tonic-gate */ 29867c478bd9Sstevel@tonic-gate 29877c478bd9Sstevel@tonic-gate #if NEEDFSYNC 29887c478bd9Sstevel@tonic-gate 29897c478bd9Sstevel@tonic-gate fsync(fd) 29907c478bd9Sstevel@tonic-gate int fd; 29917c478bd9Sstevel@tonic-gate { 29927c478bd9Sstevel@tonic-gate # ifdef O_SYNC 29937c478bd9Sstevel@tonic-gate return fcntl(fd, F_SETFL, O_SYNC); 29947c478bd9Sstevel@tonic-gate # else /* O_SYNC */ 29957c478bd9Sstevel@tonic-gate /* nothing we can do */ 29967c478bd9Sstevel@tonic-gate return 0; 29977c478bd9Sstevel@tonic-gate # endif /* O_SYNC */ 29987c478bd9Sstevel@tonic-gate } 29997c478bd9Sstevel@tonic-gate 30007c478bd9Sstevel@tonic-gate #endif /* NEEDFSYNC */ 30017c478bd9Sstevel@tonic-gate /* 30027c478bd9Sstevel@tonic-gate ** DGUX_INET_ADDR -- inet_addr for DG/UX 30037c478bd9Sstevel@tonic-gate ** 30047c478bd9Sstevel@tonic-gate ** Data General DG/UX version of inet_addr returns a struct in_addr 30057c478bd9Sstevel@tonic-gate ** instead of a long. This patches things. Only needed on versions 30067c478bd9Sstevel@tonic-gate ** prior to 5.4.3. 30077c478bd9Sstevel@tonic-gate */ 30087c478bd9Sstevel@tonic-gate 30097c478bd9Sstevel@tonic-gate #ifdef DGUX_5_4_2 30107c478bd9Sstevel@tonic-gate 30117c478bd9Sstevel@tonic-gate # undef inet_addr 30127c478bd9Sstevel@tonic-gate 30137c478bd9Sstevel@tonic-gate long 30147c478bd9Sstevel@tonic-gate dgux_inet_addr(host) 30157c478bd9Sstevel@tonic-gate char *host; 30167c478bd9Sstevel@tonic-gate { 30177c478bd9Sstevel@tonic-gate struct in_addr haddr; 30187c478bd9Sstevel@tonic-gate 30197c478bd9Sstevel@tonic-gate haddr = inet_addr(host); 30207c478bd9Sstevel@tonic-gate return haddr.s_addr; 30217c478bd9Sstevel@tonic-gate } 30227c478bd9Sstevel@tonic-gate 30237c478bd9Sstevel@tonic-gate #endif /* DGUX_5_4_2 */ 30247c478bd9Sstevel@tonic-gate /* 30257c478bd9Sstevel@tonic-gate ** GETOPT -- for old systems or systems with bogus implementations 30267c478bd9Sstevel@tonic-gate */ 30277c478bd9Sstevel@tonic-gate 30287c478bd9Sstevel@tonic-gate #if !SM_CONF_GETOPT 30297c478bd9Sstevel@tonic-gate 30307c478bd9Sstevel@tonic-gate /* 30317c478bd9Sstevel@tonic-gate * Copyright (c) 1985 Regents of the University of California. 30327c478bd9Sstevel@tonic-gate * All rights reserved. The Berkeley software License Agreement 30337c478bd9Sstevel@tonic-gate * specifies the terms and conditions for redistribution. 30347c478bd9Sstevel@tonic-gate */ 30357c478bd9Sstevel@tonic-gate 30367c478bd9Sstevel@tonic-gate 30377c478bd9Sstevel@tonic-gate /* 30387c478bd9Sstevel@tonic-gate ** this version hacked to add `atend' flag to allow state machine 30397c478bd9Sstevel@tonic-gate ** to reset if invoked by the program to scan args for a 2nd time 30407c478bd9Sstevel@tonic-gate */ 30417c478bd9Sstevel@tonic-gate 30427c478bd9Sstevel@tonic-gate # if defined(LIBC_SCCS) && !defined(lint) 30437c478bd9Sstevel@tonic-gate static char sccsid[] = "@(#)getopt.c 4.3 (Berkeley) 3/9/86"; 30447c478bd9Sstevel@tonic-gate # endif /* defined(LIBC_SCCS) && !defined(lint) */ 30457c478bd9Sstevel@tonic-gate 30467c478bd9Sstevel@tonic-gate /* 30477c478bd9Sstevel@tonic-gate ** get option letter from argument vector 30487c478bd9Sstevel@tonic-gate */ 30497c478bd9Sstevel@tonic-gate # ifdef _CONVEX_SOURCE 30507c478bd9Sstevel@tonic-gate extern int optind, opterr, optopt; 30517c478bd9Sstevel@tonic-gate extern char *optarg; 30527c478bd9Sstevel@tonic-gate # else /* _CONVEX_SOURCE */ 30537c478bd9Sstevel@tonic-gate int opterr = 1; /* if error message should be printed */ 30547c478bd9Sstevel@tonic-gate int optind = 1; /* index into parent argv vector */ 30557c478bd9Sstevel@tonic-gate int optopt = 0; /* character checked for validity */ 30567c478bd9Sstevel@tonic-gate char *optarg = NULL; /* argument associated with option */ 30577c478bd9Sstevel@tonic-gate # endif /* _CONVEX_SOURCE */ 30587c478bd9Sstevel@tonic-gate 30597c478bd9Sstevel@tonic-gate # define BADCH (int)'?' 30607c478bd9Sstevel@tonic-gate # define EMSG "" 30617c478bd9Sstevel@tonic-gate # define tell(s) if (opterr) \ 30627c478bd9Sstevel@tonic-gate {sm_io_fputs(smioerr, SM_TIME_DEFAULT, *nargv); \ 30637c478bd9Sstevel@tonic-gate (void) sm_io_fputs(smioerr, SM_TIME_DEFAULT, s); \ 30647c478bd9Sstevel@tonic-gate (void) sm_io_putc(smioerr, SM_TIME_DEFAULT, optopt); \ 30657c478bd9Sstevel@tonic-gate (void) sm_io_putc(smioerr, SM_TIME_DEFAULT, '\n'); \ 30667c478bd9Sstevel@tonic-gate return BADCH;} 30677c478bd9Sstevel@tonic-gate 30687c478bd9Sstevel@tonic-gate int 30697c478bd9Sstevel@tonic-gate getopt(nargc,nargv,ostr) 30707c478bd9Sstevel@tonic-gate int nargc; 30717c478bd9Sstevel@tonic-gate char *const *nargv; 30727c478bd9Sstevel@tonic-gate const char *ostr; 30737c478bd9Sstevel@tonic-gate { 30747c478bd9Sstevel@tonic-gate static char *place = EMSG; /* option letter processing */ 30757c478bd9Sstevel@tonic-gate static char atend = 0; 30767c478bd9Sstevel@tonic-gate register char *oli = NULL; /* option letter list index */ 30777c478bd9Sstevel@tonic-gate 30787c478bd9Sstevel@tonic-gate if (atend) { 30797c478bd9Sstevel@tonic-gate atend = 0; 30807c478bd9Sstevel@tonic-gate place = EMSG; 30817c478bd9Sstevel@tonic-gate } 30827c478bd9Sstevel@tonic-gate if(!*place) { /* update scanning pointer */ 30837c478bd9Sstevel@tonic-gate if (optind >= nargc || *(place = nargv[optind]) != '-' || !*++place) { 30847c478bd9Sstevel@tonic-gate atend++; 30857c478bd9Sstevel@tonic-gate return -1; 30867c478bd9Sstevel@tonic-gate } 30877c478bd9Sstevel@tonic-gate if (*place == '-') { /* found "--" */ 30887c478bd9Sstevel@tonic-gate ++optind; 30897c478bd9Sstevel@tonic-gate atend++; 30907c478bd9Sstevel@tonic-gate return -1; 30917c478bd9Sstevel@tonic-gate } 30927c478bd9Sstevel@tonic-gate } /* option letter okay? */ 30937c478bd9Sstevel@tonic-gate if ((optopt = (int)*place++) == (int)':' || !(oli = strchr(ostr,optopt))) { 30947c478bd9Sstevel@tonic-gate if (!*place) ++optind; 30957c478bd9Sstevel@tonic-gate tell(": illegal option -- "); 30967c478bd9Sstevel@tonic-gate } 30977c478bd9Sstevel@tonic-gate if (oli && *++oli != ':') { /* don't need argument */ 30987c478bd9Sstevel@tonic-gate optarg = NULL; 30997c478bd9Sstevel@tonic-gate if (!*place) ++optind; 31007c478bd9Sstevel@tonic-gate } 31017c478bd9Sstevel@tonic-gate else { /* need an argument */ 31027c478bd9Sstevel@tonic-gate if (*place) optarg = place; /* no white space */ 31037c478bd9Sstevel@tonic-gate else if (nargc <= ++optind) { /* no arg */ 31047c478bd9Sstevel@tonic-gate place = EMSG; 31057c478bd9Sstevel@tonic-gate tell(": option requires an argument -- "); 31067c478bd9Sstevel@tonic-gate } 31077c478bd9Sstevel@tonic-gate else optarg = nargv[optind]; /* white space */ 31087c478bd9Sstevel@tonic-gate place = EMSG; 31097c478bd9Sstevel@tonic-gate ++optind; 31107c478bd9Sstevel@tonic-gate } 31117c478bd9Sstevel@tonic-gate return optopt; /* dump back option letter */ 31127c478bd9Sstevel@tonic-gate } 31137c478bd9Sstevel@tonic-gate 31147c478bd9Sstevel@tonic-gate #endif /* !SM_CONF_GETOPT */ 31157c478bd9Sstevel@tonic-gate /* 31167c478bd9Sstevel@tonic-gate ** USERSHELLOK -- tell if a user's shell is ok for unrestricted use 31177c478bd9Sstevel@tonic-gate ** 31187c478bd9Sstevel@tonic-gate ** Parameters: 31197c478bd9Sstevel@tonic-gate ** user -- the name of the user we are checking. 31207c478bd9Sstevel@tonic-gate ** shell -- the user's shell from /etc/passwd 31217c478bd9Sstevel@tonic-gate ** 31227c478bd9Sstevel@tonic-gate ** Returns: 31237c478bd9Sstevel@tonic-gate ** true -- if it is ok to use this for unrestricted access. 31247c478bd9Sstevel@tonic-gate ** false -- if the shell is restricted. 31257c478bd9Sstevel@tonic-gate */ 31267c478bd9Sstevel@tonic-gate 31277c478bd9Sstevel@tonic-gate #if !HASGETUSERSHELL 31287c478bd9Sstevel@tonic-gate 31297c478bd9Sstevel@tonic-gate # ifndef _PATH_SHELLS 31307c478bd9Sstevel@tonic-gate # define _PATH_SHELLS "/etc/shells" 31317c478bd9Sstevel@tonic-gate # endif /* ! _PATH_SHELLS */ 31327c478bd9Sstevel@tonic-gate 31337c478bd9Sstevel@tonic-gate # if defined(_AIX3) || defined(_AIX4) 31347c478bd9Sstevel@tonic-gate # include <userconf.h> 31357c478bd9Sstevel@tonic-gate # if _AIX4 >= 40200 31367c478bd9Sstevel@tonic-gate # include <userpw.h> 31377c478bd9Sstevel@tonic-gate # endif /* _AIX4 >= 40200 */ 31387c478bd9Sstevel@tonic-gate # include <usersec.h> 31397c478bd9Sstevel@tonic-gate # endif /* defined(_AIX3) || defined(_AIX4) */ 31407c478bd9Sstevel@tonic-gate 31417c478bd9Sstevel@tonic-gate static char *DefaultUserShells[] = 31427c478bd9Sstevel@tonic-gate { 31437c478bd9Sstevel@tonic-gate "/bin/sh", /* standard shell */ 31447c478bd9Sstevel@tonic-gate # ifdef MPE 31457c478bd9Sstevel@tonic-gate "/SYS/PUB/CI", 31467c478bd9Sstevel@tonic-gate # else /* MPE */ 31477c478bd9Sstevel@tonic-gate "/usr/bin/sh", 31487c478bd9Sstevel@tonic-gate "/bin/csh", /* C shell */ 31497c478bd9Sstevel@tonic-gate "/usr/bin/csh", 31507c478bd9Sstevel@tonic-gate # endif /* MPE */ 31517c478bd9Sstevel@tonic-gate # ifdef __hpux 31527c478bd9Sstevel@tonic-gate # ifdef V4FS 31537c478bd9Sstevel@tonic-gate "/usr/bin/rsh", /* restricted Bourne shell */ 31547c478bd9Sstevel@tonic-gate "/usr/bin/ksh", /* Korn shell */ 31557c478bd9Sstevel@tonic-gate "/usr/bin/rksh", /* restricted Korn shell */ 31567c478bd9Sstevel@tonic-gate "/usr/bin/pam", 31577c478bd9Sstevel@tonic-gate "/usr/bin/keysh", /* key shell (extended Korn shell) */ 31587c478bd9Sstevel@tonic-gate "/usr/bin/posix/sh", 31597c478bd9Sstevel@tonic-gate # else /* V4FS */ 31607c478bd9Sstevel@tonic-gate "/bin/rsh", /* restricted Bourne shell */ 31617c478bd9Sstevel@tonic-gate "/bin/ksh", /* Korn shell */ 31627c478bd9Sstevel@tonic-gate "/bin/rksh", /* restricted Korn shell */ 31637c478bd9Sstevel@tonic-gate "/bin/pam", 31647c478bd9Sstevel@tonic-gate "/usr/bin/keysh", /* key shell (extended Korn shell) */ 31657c478bd9Sstevel@tonic-gate "/bin/posix/sh", 31667c478bd9Sstevel@tonic-gate "/sbin/sh", 31677c478bd9Sstevel@tonic-gate # endif /* V4FS */ 31687c478bd9Sstevel@tonic-gate # endif /* __hpux */ 31697c478bd9Sstevel@tonic-gate # if defined(_AIX3) || defined(_AIX4) 31707c478bd9Sstevel@tonic-gate "/bin/ksh", /* Korn shell */ 31717c478bd9Sstevel@tonic-gate "/usr/bin/ksh", 31727c478bd9Sstevel@tonic-gate "/bin/tsh", /* trusted shell */ 31737c478bd9Sstevel@tonic-gate "/usr/bin/tsh", 31747c478bd9Sstevel@tonic-gate "/bin/bsh", /* Bourne shell */ 31757c478bd9Sstevel@tonic-gate "/usr/bin/bsh", 31767c478bd9Sstevel@tonic-gate # endif /* defined(_AIX3) || defined(_AIX4) */ 31777c478bd9Sstevel@tonic-gate # if defined(__svr4__) || defined(__svr5__) 31787c478bd9Sstevel@tonic-gate "/bin/ksh", /* Korn shell */ 31797c478bd9Sstevel@tonic-gate "/usr/bin/ksh", 31807c478bd9Sstevel@tonic-gate # endif /* defined(__svr4__) || defined(__svr5__) */ 31817c478bd9Sstevel@tonic-gate # ifdef sgi 31827c478bd9Sstevel@tonic-gate "/sbin/sh", /* SGI's shells really live in /sbin */ 31837c478bd9Sstevel@tonic-gate "/usr/bin/sh", 31847c478bd9Sstevel@tonic-gate "/sbin/bsh", /* classic Bourne shell */ 31857c478bd9Sstevel@tonic-gate "/bin/bsh", 31867c478bd9Sstevel@tonic-gate "/usr/bin/bsh", 31877c478bd9Sstevel@tonic-gate "/sbin/csh", /* standard csh */ 31887c478bd9Sstevel@tonic-gate "/bin/csh", 31897c478bd9Sstevel@tonic-gate "/usr/bin/csh", 31907c478bd9Sstevel@tonic-gate "/sbin/jsh", /* classic Bourne shell w/ job control*/ 31917c478bd9Sstevel@tonic-gate "/bin/jsh", 31927c478bd9Sstevel@tonic-gate "/usr/bin/jsh", 31937c478bd9Sstevel@tonic-gate "/bin/ksh", /* Korn shell */ 31947c478bd9Sstevel@tonic-gate "/sbin/ksh", 31957c478bd9Sstevel@tonic-gate "/usr/bin/ksh", 31967c478bd9Sstevel@tonic-gate "/sbin/tcsh", /* Extended csh */ 31977c478bd9Sstevel@tonic-gate "/bin/tcsh", 31987c478bd9Sstevel@tonic-gate "/usr/bin/tcsh", 31997c478bd9Sstevel@tonic-gate # endif /* sgi */ 32007c478bd9Sstevel@tonic-gate NULL 32017c478bd9Sstevel@tonic-gate }; 32027c478bd9Sstevel@tonic-gate 32037c478bd9Sstevel@tonic-gate #endif /* !HASGETUSERSHELL */ 32047c478bd9Sstevel@tonic-gate 32057c478bd9Sstevel@tonic-gate #define WILDCARD_SHELL "/SENDMAIL/ANY/SHELL/" 32067c478bd9Sstevel@tonic-gate 32077c478bd9Sstevel@tonic-gate bool 32087c478bd9Sstevel@tonic-gate usershellok(user, shell) 32097c478bd9Sstevel@tonic-gate char *user; 32107c478bd9Sstevel@tonic-gate char *shell; 32117c478bd9Sstevel@tonic-gate { 32127c478bd9Sstevel@tonic-gate # if HASGETUSERSHELL 32137c478bd9Sstevel@tonic-gate register char *p; 32147c478bd9Sstevel@tonic-gate extern char *getusershell(); 32157c478bd9Sstevel@tonic-gate 32167c478bd9Sstevel@tonic-gate if (shell == NULL || shell[0] == '\0' || wordinclass(user, 't') || 32177c478bd9Sstevel@tonic-gate ConfigLevel <= 1) 32187c478bd9Sstevel@tonic-gate return true; 32197c478bd9Sstevel@tonic-gate 32207c478bd9Sstevel@tonic-gate setusershell(); 32217c478bd9Sstevel@tonic-gate while ((p = getusershell()) != NULL) 32227c478bd9Sstevel@tonic-gate if (strcmp(p, shell) == 0 || strcmp(p, WILDCARD_SHELL) == 0) 32237c478bd9Sstevel@tonic-gate break; 32247c478bd9Sstevel@tonic-gate endusershell(); 32257c478bd9Sstevel@tonic-gate return p != NULL; 32267c478bd9Sstevel@tonic-gate # else /* HASGETUSERSHELL */ 32277c478bd9Sstevel@tonic-gate # if USEGETCONFATTR 32287c478bd9Sstevel@tonic-gate auto char *v; 32297c478bd9Sstevel@tonic-gate # endif /* USEGETCONFATTR */ 32307c478bd9Sstevel@tonic-gate register SM_FILE_T *shellf; 32317c478bd9Sstevel@tonic-gate char buf[MAXLINE]; 32327c478bd9Sstevel@tonic-gate 32337c478bd9Sstevel@tonic-gate if (shell == NULL || shell[0] == '\0' || wordinclass(user, 't') || 32347c478bd9Sstevel@tonic-gate ConfigLevel <= 1) 32357c478bd9Sstevel@tonic-gate return true; 32367c478bd9Sstevel@tonic-gate 32377c478bd9Sstevel@tonic-gate # if USEGETCONFATTR 32387c478bd9Sstevel@tonic-gate /* 32397c478bd9Sstevel@tonic-gate ** Naturally IBM has a "better" idea..... 32407c478bd9Sstevel@tonic-gate ** 32417c478bd9Sstevel@tonic-gate ** What a crock. This interface isn't documented, it is 32427c478bd9Sstevel@tonic-gate ** considered part of the security library (-ls), and it 32437c478bd9Sstevel@tonic-gate ** only works if you are running as root (since the list 32447c478bd9Sstevel@tonic-gate ** of valid shells is obviously a source of great concern). 32457c478bd9Sstevel@tonic-gate ** I recommend that you do NOT define USEGETCONFATTR, 32467c478bd9Sstevel@tonic-gate ** especially since you are going to have to set up an 32477c478bd9Sstevel@tonic-gate ** /etc/shells anyhow to handle the cases where getconfattr 32487c478bd9Sstevel@tonic-gate ** fails. 32497c478bd9Sstevel@tonic-gate */ 32507c478bd9Sstevel@tonic-gate 32517c478bd9Sstevel@tonic-gate if (getconfattr(SC_SYS_LOGIN, SC_SHELLS, &v, SEC_LIST) == 0 && v != NULL) 32527c478bd9Sstevel@tonic-gate { 32537c478bd9Sstevel@tonic-gate while (*v != '\0') 32547c478bd9Sstevel@tonic-gate { 32557c478bd9Sstevel@tonic-gate if (strcmp(v, shell) == 0 || strcmp(v, WILDCARD_SHELL) == 0) 32567c478bd9Sstevel@tonic-gate return true; 32577c478bd9Sstevel@tonic-gate v += strlen(v) + 1; 32587c478bd9Sstevel@tonic-gate } 32597c478bd9Sstevel@tonic-gate return false; 32607c478bd9Sstevel@tonic-gate } 32617c478bd9Sstevel@tonic-gate # endif /* USEGETCONFATTR */ 32627c478bd9Sstevel@tonic-gate 32637c478bd9Sstevel@tonic-gate shellf = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, _PATH_SHELLS, 32647c478bd9Sstevel@tonic-gate SM_IO_RDONLY, NULL); 32657c478bd9Sstevel@tonic-gate if (shellf == NULL) 32667c478bd9Sstevel@tonic-gate { 32677c478bd9Sstevel@tonic-gate /* no /etc/shells; see if it is one of the std shells */ 32687c478bd9Sstevel@tonic-gate char **d; 32697c478bd9Sstevel@tonic-gate 32707c478bd9Sstevel@tonic-gate if (errno != ENOENT && LogLevel > 3) 32717c478bd9Sstevel@tonic-gate sm_syslog(LOG_ERR, NOQID, 32727c478bd9Sstevel@tonic-gate "usershellok: cannot open %s: %s", 32737c478bd9Sstevel@tonic-gate _PATH_SHELLS, sm_errstring(errno)); 32747c478bd9Sstevel@tonic-gate 32757c478bd9Sstevel@tonic-gate for (d = DefaultUserShells; *d != NULL; d++) 32767c478bd9Sstevel@tonic-gate { 32777c478bd9Sstevel@tonic-gate if (strcmp(shell, *d) == 0) 32787c478bd9Sstevel@tonic-gate return true; 32797c478bd9Sstevel@tonic-gate } 32807c478bd9Sstevel@tonic-gate return false; 32817c478bd9Sstevel@tonic-gate } 32827c478bd9Sstevel@tonic-gate 32837c478bd9Sstevel@tonic-gate while (sm_io_fgets(shellf, SM_TIME_DEFAULT, buf, sizeof buf) != NULL) 32847c478bd9Sstevel@tonic-gate { 32857c478bd9Sstevel@tonic-gate register char *p, *q; 32867c478bd9Sstevel@tonic-gate 32877c478bd9Sstevel@tonic-gate p = buf; 32887c478bd9Sstevel@tonic-gate while (*p != '\0' && *p != '#' && *p != '/') 32897c478bd9Sstevel@tonic-gate p++; 32907c478bd9Sstevel@tonic-gate if (*p == '#' || *p == '\0') 32917c478bd9Sstevel@tonic-gate continue; 32927c478bd9Sstevel@tonic-gate q = p; 32937c478bd9Sstevel@tonic-gate while (*p != '\0' && *p != '#' && !(isascii(*p) && isspace(*p))) 32947c478bd9Sstevel@tonic-gate p++; 32957c478bd9Sstevel@tonic-gate *p = '\0'; 32967c478bd9Sstevel@tonic-gate if (strcmp(shell, q) == 0 || strcmp(WILDCARD_SHELL, q) == 0) 32977c478bd9Sstevel@tonic-gate { 32987c478bd9Sstevel@tonic-gate (void) sm_io_close(shellf, SM_TIME_DEFAULT); 32997c478bd9Sstevel@tonic-gate return true; 33007c478bd9Sstevel@tonic-gate } 33017c478bd9Sstevel@tonic-gate } 33027c478bd9Sstevel@tonic-gate (void) sm_io_close(shellf, SM_TIME_DEFAULT); 33037c478bd9Sstevel@tonic-gate return false; 33047c478bd9Sstevel@tonic-gate # endif /* HASGETUSERSHELL */ 33057c478bd9Sstevel@tonic-gate } 33067c478bd9Sstevel@tonic-gate /* 33077c478bd9Sstevel@tonic-gate ** FREEDISKSPACE -- see how much free space is on the queue filesystem 33087c478bd9Sstevel@tonic-gate ** 33097c478bd9Sstevel@tonic-gate ** Only implemented if you have statfs. 33107c478bd9Sstevel@tonic-gate ** 33117c478bd9Sstevel@tonic-gate ** Parameters: 33127c478bd9Sstevel@tonic-gate ** dir -- the directory in question. 33137c478bd9Sstevel@tonic-gate ** bsize -- a variable into which the filesystem 33147c478bd9Sstevel@tonic-gate ** block size is stored. 33157c478bd9Sstevel@tonic-gate ** 33167c478bd9Sstevel@tonic-gate ** Returns: 33177c478bd9Sstevel@tonic-gate ** The number of blocks free on the queue filesystem. 33187c478bd9Sstevel@tonic-gate ** -1 if the statfs call fails. 33197c478bd9Sstevel@tonic-gate ** 33207c478bd9Sstevel@tonic-gate ** Side effects: 33217c478bd9Sstevel@tonic-gate ** Puts the filesystem block size into bsize. 33227c478bd9Sstevel@tonic-gate */ 33237c478bd9Sstevel@tonic-gate 33247c478bd9Sstevel@tonic-gate /* statfs types */ 33257c478bd9Sstevel@tonic-gate # define SFS_NONE 0 /* no statfs implementation */ 33267c478bd9Sstevel@tonic-gate # define SFS_USTAT 1 /* use ustat */ 33277c478bd9Sstevel@tonic-gate # define SFS_4ARGS 2 /* use four-argument statfs call */ 33287c478bd9Sstevel@tonic-gate # define SFS_VFS 3 /* use <sys/vfs.h> implementation */ 33297c478bd9Sstevel@tonic-gate # define SFS_MOUNT 4 /* use <sys/mount.h> implementation */ 33307c478bd9Sstevel@tonic-gate # define SFS_STATFS 5 /* use <sys/statfs.h> implementation */ 33317c478bd9Sstevel@tonic-gate # define SFS_STATVFS 6 /* use <sys/statvfs.h> implementation */ 33327c478bd9Sstevel@tonic-gate 33337c478bd9Sstevel@tonic-gate # ifndef SFS_TYPE 33347c478bd9Sstevel@tonic-gate # define SFS_TYPE SFS_NONE 33357c478bd9Sstevel@tonic-gate # endif /* ! SFS_TYPE */ 33367c478bd9Sstevel@tonic-gate 33377c478bd9Sstevel@tonic-gate # if SFS_TYPE == SFS_USTAT 33387c478bd9Sstevel@tonic-gate # include <ustat.h> 33397c478bd9Sstevel@tonic-gate # endif /* SFS_TYPE == SFS_USTAT */ 33407c478bd9Sstevel@tonic-gate # if SFS_TYPE == SFS_4ARGS || SFS_TYPE == SFS_STATFS 33417c478bd9Sstevel@tonic-gate # include <sys/statfs.h> 33427c478bd9Sstevel@tonic-gate # endif /* SFS_TYPE == SFS_4ARGS || SFS_TYPE == SFS_STATFS */ 33437c478bd9Sstevel@tonic-gate # if SFS_TYPE == SFS_VFS 33447c478bd9Sstevel@tonic-gate # include <sys/vfs.h> 33457c478bd9Sstevel@tonic-gate # endif /* SFS_TYPE == SFS_VFS */ 33467c478bd9Sstevel@tonic-gate # if SFS_TYPE == SFS_MOUNT 33477c478bd9Sstevel@tonic-gate # include <sys/mount.h> 33487c478bd9Sstevel@tonic-gate # endif /* SFS_TYPE == SFS_MOUNT */ 33497c478bd9Sstevel@tonic-gate # if SFS_TYPE == SFS_STATVFS 33507c478bd9Sstevel@tonic-gate # include <sys/statvfs.h> 33517c478bd9Sstevel@tonic-gate # endif /* SFS_TYPE == SFS_STATVFS */ 33527c478bd9Sstevel@tonic-gate 33537c478bd9Sstevel@tonic-gate long 33547c478bd9Sstevel@tonic-gate freediskspace(dir, bsize) 33557c478bd9Sstevel@tonic-gate char *dir; 33567c478bd9Sstevel@tonic-gate long *bsize; 33577c478bd9Sstevel@tonic-gate { 33587c478bd9Sstevel@tonic-gate # if SFS_TYPE == SFS_NONE 33597c478bd9Sstevel@tonic-gate if (bsize != NULL) 33607c478bd9Sstevel@tonic-gate *bsize = 4096L; 33617c478bd9Sstevel@tonic-gate 33627c478bd9Sstevel@tonic-gate /* assume free space is plentiful */ 33637c478bd9Sstevel@tonic-gate return (long) LONG_MAX; 33647c478bd9Sstevel@tonic-gate # else /* SFS_TYPE == SFS_NONE */ 33657c478bd9Sstevel@tonic-gate # if SFS_TYPE == SFS_USTAT 33667c478bd9Sstevel@tonic-gate struct ustat fs; 33677c478bd9Sstevel@tonic-gate struct stat statbuf; 33687c478bd9Sstevel@tonic-gate # define FSBLOCKSIZE DEV_BSIZE 33697c478bd9Sstevel@tonic-gate # define SFS_BAVAIL f_tfree 33707c478bd9Sstevel@tonic-gate # else /* SFS_TYPE == SFS_USTAT */ 33717c478bd9Sstevel@tonic-gate # if defined(ultrix) 33727c478bd9Sstevel@tonic-gate struct fs_data fs; 33737c478bd9Sstevel@tonic-gate # define SFS_BAVAIL fd_bfreen 33747c478bd9Sstevel@tonic-gate # define FSBLOCKSIZE 1024L 33757c478bd9Sstevel@tonic-gate # else /* defined(ultrix) */ 33767c478bd9Sstevel@tonic-gate # if SFS_TYPE == SFS_STATVFS 33777c478bd9Sstevel@tonic-gate struct statvfs fs; 33787c478bd9Sstevel@tonic-gate # define FSBLOCKSIZE fs.f_frsize 33797c478bd9Sstevel@tonic-gate # else /* SFS_TYPE == SFS_STATVFS */ 33807c478bd9Sstevel@tonic-gate struct statfs fs; 33817c478bd9Sstevel@tonic-gate # define FSBLOCKSIZE fs.f_bsize 33827c478bd9Sstevel@tonic-gate # endif /* SFS_TYPE == SFS_STATVFS */ 33837c478bd9Sstevel@tonic-gate # endif /* defined(ultrix) */ 33847c478bd9Sstevel@tonic-gate # endif /* SFS_TYPE == SFS_USTAT */ 33857c478bd9Sstevel@tonic-gate # ifndef SFS_BAVAIL 33867c478bd9Sstevel@tonic-gate # define SFS_BAVAIL f_bavail 33877c478bd9Sstevel@tonic-gate # endif /* ! SFS_BAVAIL */ 33887c478bd9Sstevel@tonic-gate 33897c478bd9Sstevel@tonic-gate # if SFS_TYPE == SFS_USTAT 33907c478bd9Sstevel@tonic-gate if (stat(dir, &statbuf) == 0 && ustat(statbuf.st_dev, &fs) == 0) 33917c478bd9Sstevel@tonic-gate # else /* SFS_TYPE == SFS_USTAT */ 33927c478bd9Sstevel@tonic-gate # if SFS_TYPE == SFS_4ARGS 33937c478bd9Sstevel@tonic-gate if (statfs(dir, &fs, sizeof fs, 0) == 0) 33947c478bd9Sstevel@tonic-gate # else /* SFS_TYPE == SFS_4ARGS */ 33957c478bd9Sstevel@tonic-gate # if SFS_TYPE == SFS_STATVFS 33967c478bd9Sstevel@tonic-gate if (statvfs(dir, &fs) == 0) 33977c478bd9Sstevel@tonic-gate # else /* SFS_TYPE == SFS_STATVFS */ 33987c478bd9Sstevel@tonic-gate # if defined(ultrix) 33997c478bd9Sstevel@tonic-gate if (statfs(dir, &fs) > 0) 34007c478bd9Sstevel@tonic-gate # else /* defined(ultrix) */ 34017c478bd9Sstevel@tonic-gate if (statfs(dir, &fs) == 0) 34027c478bd9Sstevel@tonic-gate # endif /* defined(ultrix) */ 34037c478bd9Sstevel@tonic-gate # endif /* SFS_TYPE == SFS_STATVFS */ 34047c478bd9Sstevel@tonic-gate # endif /* SFS_TYPE == SFS_4ARGS */ 34057c478bd9Sstevel@tonic-gate # endif /* SFS_TYPE == SFS_USTAT */ 34067c478bd9Sstevel@tonic-gate { 34077c478bd9Sstevel@tonic-gate if (bsize != NULL) 34087c478bd9Sstevel@tonic-gate *bsize = FSBLOCKSIZE; 34097c478bd9Sstevel@tonic-gate if (fs.SFS_BAVAIL <= 0) 34107c478bd9Sstevel@tonic-gate return 0; 34117c478bd9Sstevel@tonic-gate else if (fs.SFS_BAVAIL > LONG_MAX) 34127c478bd9Sstevel@tonic-gate return (long) LONG_MAX; 34137c478bd9Sstevel@tonic-gate else 34147c478bd9Sstevel@tonic-gate return (long) fs.SFS_BAVAIL; 34157c478bd9Sstevel@tonic-gate } 34167c478bd9Sstevel@tonic-gate return -1; 34177c478bd9Sstevel@tonic-gate # endif /* SFS_TYPE == SFS_NONE */ 34187c478bd9Sstevel@tonic-gate } 34197c478bd9Sstevel@tonic-gate /* 34207c478bd9Sstevel@tonic-gate ** ENOUGHDISKSPACE -- is there enough free space on the queue file systems? 34217c478bd9Sstevel@tonic-gate ** 34227c478bd9Sstevel@tonic-gate ** Parameters: 34237c478bd9Sstevel@tonic-gate ** msize -- the size to check against. If zero, we don't yet 34247c478bd9Sstevel@tonic-gate ** know how big the message will be, so just check for 34257c478bd9Sstevel@tonic-gate ** a "reasonable" amount. 34267c478bd9Sstevel@tonic-gate ** e -- envelope, or NULL -- controls logging 34277c478bd9Sstevel@tonic-gate ** 34287c478bd9Sstevel@tonic-gate ** Returns: 34297c478bd9Sstevel@tonic-gate ** true if in every queue group there is at least one 34307c478bd9Sstevel@tonic-gate ** queue directory whose file system contains enough free space. 34317c478bd9Sstevel@tonic-gate ** false otherwise. 34327c478bd9Sstevel@tonic-gate ** 34337c478bd9Sstevel@tonic-gate ** Side Effects: 34347c478bd9Sstevel@tonic-gate ** If there is not enough disk space and e != NULL 34357c478bd9Sstevel@tonic-gate ** then sm_syslog is called. 34367c478bd9Sstevel@tonic-gate */ 34377c478bd9Sstevel@tonic-gate 34387c478bd9Sstevel@tonic-gate bool 34397c478bd9Sstevel@tonic-gate enoughdiskspace(msize, e) 34407c478bd9Sstevel@tonic-gate long msize; 34417c478bd9Sstevel@tonic-gate ENVELOPE *e; 34427c478bd9Sstevel@tonic-gate { 34437c478bd9Sstevel@tonic-gate int i; 34447c478bd9Sstevel@tonic-gate 34457c478bd9Sstevel@tonic-gate if (MinBlocksFree <= 0 && msize <= 0) 34467c478bd9Sstevel@tonic-gate { 34477c478bd9Sstevel@tonic-gate if (tTd(4, 80)) 34487c478bd9Sstevel@tonic-gate sm_dprintf("enoughdiskspace: no threshold\n"); 34497c478bd9Sstevel@tonic-gate return true; 34507c478bd9Sstevel@tonic-gate } 34517c478bd9Sstevel@tonic-gate 34527c478bd9Sstevel@tonic-gate filesys_update(); 34537c478bd9Sstevel@tonic-gate for (i = 0; i < NumQueue; ++i) 34547c478bd9Sstevel@tonic-gate { 34557c478bd9Sstevel@tonic-gate if (pickqdir(Queue[i], msize, e) < 0) 34567c478bd9Sstevel@tonic-gate return false; 34577c478bd9Sstevel@tonic-gate } 34587c478bd9Sstevel@tonic-gate return true; 34597c478bd9Sstevel@tonic-gate } 34607c478bd9Sstevel@tonic-gate /* 34617c478bd9Sstevel@tonic-gate ** TRANSIENTERROR -- tell if an error code indicates a transient failure 34627c478bd9Sstevel@tonic-gate ** 34637c478bd9Sstevel@tonic-gate ** This looks at an errno value and tells if this is likely to 34647c478bd9Sstevel@tonic-gate ** go away if retried later. 34657c478bd9Sstevel@tonic-gate ** 34667c478bd9Sstevel@tonic-gate ** Parameters: 34677c478bd9Sstevel@tonic-gate ** err -- the errno code to classify. 34687c478bd9Sstevel@tonic-gate ** 34697c478bd9Sstevel@tonic-gate ** Returns: 34707c478bd9Sstevel@tonic-gate ** true if this is probably transient. 34717c478bd9Sstevel@tonic-gate ** false otherwise. 34727c478bd9Sstevel@tonic-gate */ 34737c478bd9Sstevel@tonic-gate 34747c478bd9Sstevel@tonic-gate bool 34757c478bd9Sstevel@tonic-gate transienterror(err) 34767c478bd9Sstevel@tonic-gate int err; 34777c478bd9Sstevel@tonic-gate { 34787c478bd9Sstevel@tonic-gate switch (err) 34797c478bd9Sstevel@tonic-gate { 34807c478bd9Sstevel@tonic-gate case EIO: /* I/O error */ 34817c478bd9Sstevel@tonic-gate case ENXIO: /* Device not configured */ 34827c478bd9Sstevel@tonic-gate case EAGAIN: /* Resource temporarily unavailable */ 34837c478bd9Sstevel@tonic-gate case ENOMEM: /* Cannot allocate memory */ 34847c478bd9Sstevel@tonic-gate case ENODEV: /* Operation not supported by device */ 34857c478bd9Sstevel@tonic-gate case ENFILE: /* Too many open files in system */ 34867c478bd9Sstevel@tonic-gate case EMFILE: /* Too many open files */ 34877c478bd9Sstevel@tonic-gate case ENOSPC: /* No space left on device */ 34887c478bd9Sstevel@tonic-gate case ETIMEDOUT: /* Connection timed out */ 34897c478bd9Sstevel@tonic-gate #ifdef ESTALE 34907c478bd9Sstevel@tonic-gate case ESTALE: /* Stale NFS file handle */ 34917c478bd9Sstevel@tonic-gate #endif /* ESTALE */ 34927c478bd9Sstevel@tonic-gate #ifdef ENETDOWN 34937c478bd9Sstevel@tonic-gate case ENETDOWN: /* Network is down */ 34947c478bd9Sstevel@tonic-gate #endif /* ENETDOWN */ 34957c478bd9Sstevel@tonic-gate #ifdef ENETUNREACH 34967c478bd9Sstevel@tonic-gate case ENETUNREACH: /* Network is unreachable */ 34977c478bd9Sstevel@tonic-gate #endif /* ENETUNREACH */ 34987c478bd9Sstevel@tonic-gate #ifdef ENETRESET 34997c478bd9Sstevel@tonic-gate case ENETRESET: /* Network dropped connection on reset */ 35007c478bd9Sstevel@tonic-gate #endif /* ENETRESET */ 35017c478bd9Sstevel@tonic-gate #ifdef ECONNABORTED 35027c478bd9Sstevel@tonic-gate case ECONNABORTED: /* Software caused connection abort */ 35037c478bd9Sstevel@tonic-gate #endif /* ECONNABORTED */ 35047c478bd9Sstevel@tonic-gate #ifdef ECONNRESET 35057c478bd9Sstevel@tonic-gate case ECONNRESET: /* Connection reset by peer */ 35067c478bd9Sstevel@tonic-gate #endif /* ECONNRESET */ 35077c478bd9Sstevel@tonic-gate #ifdef ENOBUFS 35087c478bd9Sstevel@tonic-gate case ENOBUFS: /* No buffer space available */ 35097c478bd9Sstevel@tonic-gate #endif /* ENOBUFS */ 35107c478bd9Sstevel@tonic-gate #ifdef ESHUTDOWN 35117c478bd9Sstevel@tonic-gate case ESHUTDOWN: /* Can't send after socket shutdown */ 35127c478bd9Sstevel@tonic-gate #endif /* ESHUTDOWN */ 35137c478bd9Sstevel@tonic-gate #ifdef ECONNREFUSED 35147c478bd9Sstevel@tonic-gate case ECONNREFUSED: /* Connection refused */ 35157c478bd9Sstevel@tonic-gate #endif /* ECONNREFUSED */ 35167c478bd9Sstevel@tonic-gate #ifdef EHOSTDOWN 35177c478bd9Sstevel@tonic-gate case EHOSTDOWN: /* Host is down */ 35187c478bd9Sstevel@tonic-gate #endif /* EHOSTDOWN */ 35197c478bd9Sstevel@tonic-gate #ifdef EHOSTUNREACH 35207c478bd9Sstevel@tonic-gate case EHOSTUNREACH: /* No route to host */ 35217c478bd9Sstevel@tonic-gate #endif /* EHOSTUNREACH */ 35227c478bd9Sstevel@tonic-gate #ifdef EDQUOT 35237c478bd9Sstevel@tonic-gate case EDQUOT: /* Disc quota exceeded */ 35247c478bd9Sstevel@tonic-gate #endif /* EDQUOT */ 35257c478bd9Sstevel@tonic-gate #ifdef EPROCLIM 35267c478bd9Sstevel@tonic-gate case EPROCLIM: /* Too many processes */ 35277c478bd9Sstevel@tonic-gate #endif /* EPROCLIM */ 35287c478bd9Sstevel@tonic-gate #ifdef EUSERS 35297c478bd9Sstevel@tonic-gate case EUSERS: /* Too many users */ 35307c478bd9Sstevel@tonic-gate #endif /* EUSERS */ 35317c478bd9Sstevel@tonic-gate #ifdef EDEADLK 35327c478bd9Sstevel@tonic-gate case EDEADLK: /* Resource deadlock avoided */ 35337c478bd9Sstevel@tonic-gate #endif /* EDEADLK */ 35347c478bd9Sstevel@tonic-gate #ifdef EISCONN 35357c478bd9Sstevel@tonic-gate case EISCONN: /* Socket already connected */ 35367c478bd9Sstevel@tonic-gate #endif /* EISCONN */ 35377c478bd9Sstevel@tonic-gate #ifdef EINPROGRESS 35387c478bd9Sstevel@tonic-gate case EINPROGRESS: /* Operation now in progress */ 35397c478bd9Sstevel@tonic-gate #endif /* EINPROGRESS */ 35407c478bd9Sstevel@tonic-gate #ifdef EALREADY 35417c478bd9Sstevel@tonic-gate case EALREADY: /* Operation already in progress */ 35427c478bd9Sstevel@tonic-gate #endif /* EALREADY */ 35437c478bd9Sstevel@tonic-gate #ifdef EADDRINUSE 35447c478bd9Sstevel@tonic-gate case EADDRINUSE: /* Address already in use */ 35457c478bd9Sstevel@tonic-gate #endif /* EADDRINUSE */ 35467c478bd9Sstevel@tonic-gate #ifdef EADDRNOTAVAIL 35477c478bd9Sstevel@tonic-gate case EADDRNOTAVAIL: /* Can't assign requested address */ 35487c478bd9Sstevel@tonic-gate #endif /* EADDRNOTAVAIL */ 35497c478bd9Sstevel@tonic-gate #ifdef ETXTBSY 35507c478bd9Sstevel@tonic-gate case ETXTBSY: /* (Apollo) file locked */ 35517c478bd9Sstevel@tonic-gate #endif /* ETXTBSY */ 35527c478bd9Sstevel@tonic-gate #if defined(ENOSR) && (!defined(ENOBUFS) || (ENOBUFS != ENOSR)) 35537c478bd9Sstevel@tonic-gate case ENOSR: /* Out of streams resources */ 35547c478bd9Sstevel@tonic-gate #endif /* defined(ENOSR) && (!defined(ENOBUFS) || (ENOBUFS != ENOSR)) */ 35557c478bd9Sstevel@tonic-gate #ifdef ENOLCK 35567c478bd9Sstevel@tonic-gate case ENOLCK: /* No locks available */ 35577c478bd9Sstevel@tonic-gate #endif /* ENOLCK */ 35587c478bd9Sstevel@tonic-gate case E_SM_OPENTIMEOUT: /* PSEUDO: open timed out */ 35597c478bd9Sstevel@tonic-gate return true; 35607c478bd9Sstevel@tonic-gate } 35617c478bd9Sstevel@tonic-gate 35627c478bd9Sstevel@tonic-gate /* nope, must be permanent */ 35637c478bd9Sstevel@tonic-gate return false; 35647c478bd9Sstevel@tonic-gate } 35657c478bd9Sstevel@tonic-gate /* 35667c478bd9Sstevel@tonic-gate ** LOCKFILE -- lock a file using flock or (shudder) fcntl locking 35677c478bd9Sstevel@tonic-gate ** 35687c478bd9Sstevel@tonic-gate ** Parameters: 35697c478bd9Sstevel@tonic-gate ** fd -- the file descriptor of the file. 35707c478bd9Sstevel@tonic-gate ** filename -- the file name (for error messages). 35717c478bd9Sstevel@tonic-gate ** ext -- the filename extension. 35727c478bd9Sstevel@tonic-gate ** type -- type of the lock. Bits can be: 35737c478bd9Sstevel@tonic-gate ** LOCK_EX -- exclusive lock. 35747c478bd9Sstevel@tonic-gate ** LOCK_NB -- non-blocking. 35757c478bd9Sstevel@tonic-gate ** LOCK_UN -- unlock. 35767c478bd9Sstevel@tonic-gate ** 35777c478bd9Sstevel@tonic-gate ** Returns: 35787c478bd9Sstevel@tonic-gate ** true if the lock was acquired. 35797c478bd9Sstevel@tonic-gate ** false otherwise. 35807c478bd9Sstevel@tonic-gate */ 35817c478bd9Sstevel@tonic-gate 35827c478bd9Sstevel@tonic-gate bool 35837c478bd9Sstevel@tonic-gate lockfile(fd, filename, ext, type) 35847c478bd9Sstevel@tonic-gate int fd; 35857c478bd9Sstevel@tonic-gate char *filename; 35867c478bd9Sstevel@tonic-gate char *ext; 35877c478bd9Sstevel@tonic-gate int type; 35887c478bd9Sstevel@tonic-gate { 35897c478bd9Sstevel@tonic-gate int i; 35907c478bd9Sstevel@tonic-gate int save_errno; 35917c478bd9Sstevel@tonic-gate # if !HASFLOCK 35927c478bd9Sstevel@tonic-gate int action; 35937c478bd9Sstevel@tonic-gate struct flock lfd; 35947c478bd9Sstevel@tonic-gate 35957c478bd9Sstevel@tonic-gate if (ext == NULL) 35967c478bd9Sstevel@tonic-gate ext = ""; 35977c478bd9Sstevel@tonic-gate 35987c478bd9Sstevel@tonic-gate memset(&lfd, '\0', sizeof lfd); 35997c478bd9Sstevel@tonic-gate if (bitset(LOCK_UN, type)) 36007c478bd9Sstevel@tonic-gate lfd.l_type = F_UNLCK; 36017c478bd9Sstevel@tonic-gate else if (bitset(LOCK_EX, type)) 36027c478bd9Sstevel@tonic-gate lfd.l_type = F_WRLCK; 36037c478bd9Sstevel@tonic-gate else 36047c478bd9Sstevel@tonic-gate lfd.l_type = F_RDLCK; 36057c478bd9Sstevel@tonic-gate 36067c478bd9Sstevel@tonic-gate if (bitset(LOCK_NB, type)) 36077c478bd9Sstevel@tonic-gate action = F_SETLK; 36087c478bd9Sstevel@tonic-gate else 36097c478bd9Sstevel@tonic-gate action = F_SETLKW; 36107c478bd9Sstevel@tonic-gate 36117c478bd9Sstevel@tonic-gate if (tTd(55, 60)) 36127c478bd9Sstevel@tonic-gate sm_dprintf("lockfile(%s%s, action=%d, type=%d): ", 36137c478bd9Sstevel@tonic-gate filename, ext, action, lfd.l_type); 36147c478bd9Sstevel@tonic-gate 36157c478bd9Sstevel@tonic-gate while ((i = fcntl(fd, action, &lfd)) < 0 && errno == EINTR) 36167c478bd9Sstevel@tonic-gate continue; 36177c478bd9Sstevel@tonic-gate if (i >= 0) 36187c478bd9Sstevel@tonic-gate { 36197c478bd9Sstevel@tonic-gate if (tTd(55, 60)) 36207c478bd9Sstevel@tonic-gate sm_dprintf("SUCCESS\n"); 36217c478bd9Sstevel@tonic-gate return true; 36227c478bd9Sstevel@tonic-gate } 36237c478bd9Sstevel@tonic-gate save_errno = errno; 36247c478bd9Sstevel@tonic-gate 36257c478bd9Sstevel@tonic-gate if (tTd(55, 60)) 36267c478bd9Sstevel@tonic-gate sm_dprintf("(%s) ", sm_errstring(save_errno)); 36277c478bd9Sstevel@tonic-gate 36287c478bd9Sstevel@tonic-gate /* 36297c478bd9Sstevel@tonic-gate ** On SunOS, if you are testing using -oQ/tmp/mqueue or 36307c478bd9Sstevel@tonic-gate ** -oA/tmp/aliases or anything like that, and /tmp is mounted 36317c478bd9Sstevel@tonic-gate ** as type "tmp" (that is, served from swap space), the 36327c478bd9Sstevel@tonic-gate ** previous fcntl will fail with "Invalid argument" errors. 36337c478bd9Sstevel@tonic-gate ** Since this is fairly common during testing, we will assume 36347c478bd9Sstevel@tonic-gate ** that this indicates that the lock is successfully grabbed. 36357c478bd9Sstevel@tonic-gate */ 36367c478bd9Sstevel@tonic-gate 36377c478bd9Sstevel@tonic-gate if (save_errno == EINVAL) 36387c478bd9Sstevel@tonic-gate { 36397c478bd9Sstevel@tonic-gate if (tTd(55, 60)) 36407c478bd9Sstevel@tonic-gate sm_dprintf("SUCCESS\n"); 36417c478bd9Sstevel@tonic-gate return true; 36427c478bd9Sstevel@tonic-gate } 36437c478bd9Sstevel@tonic-gate 36447c478bd9Sstevel@tonic-gate if (!bitset(LOCK_NB, type) || 36457c478bd9Sstevel@tonic-gate (save_errno != EACCES && save_errno != EAGAIN)) 36467c478bd9Sstevel@tonic-gate { 36477c478bd9Sstevel@tonic-gate int omode = fcntl(fd, F_GETFL, 0); 36487c478bd9Sstevel@tonic-gate uid_t euid = geteuid(); 36497c478bd9Sstevel@tonic-gate 36507c478bd9Sstevel@tonic-gate errno = save_errno; 36517c478bd9Sstevel@tonic-gate syserr("cannot lockf(%s%s, fd=%d, type=%o, omode=%o, euid=%d)", 36527c478bd9Sstevel@tonic-gate filename, ext, fd, type, omode, euid); 36537c478bd9Sstevel@tonic-gate dumpfd(fd, true, true); 36547c478bd9Sstevel@tonic-gate } 36557c478bd9Sstevel@tonic-gate # else /* !HASFLOCK */ 36567c478bd9Sstevel@tonic-gate if (ext == NULL) 36577c478bd9Sstevel@tonic-gate ext = ""; 36587c478bd9Sstevel@tonic-gate 36597c478bd9Sstevel@tonic-gate if (tTd(55, 60)) 36607c478bd9Sstevel@tonic-gate sm_dprintf("lockfile(%s%s, type=%o): ", filename, ext, type); 36617c478bd9Sstevel@tonic-gate 36627c478bd9Sstevel@tonic-gate while ((i = flock(fd, type)) < 0 && errno == EINTR) 36637c478bd9Sstevel@tonic-gate continue; 36647c478bd9Sstevel@tonic-gate if (i >= 0) 36657c478bd9Sstevel@tonic-gate { 36667c478bd9Sstevel@tonic-gate if (tTd(55, 60)) 36677c478bd9Sstevel@tonic-gate sm_dprintf("SUCCESS\n"); 36687c478bd9Sstevel@tonic-gate return true; 36697c478bd9Sstevel@tonic-gate } 36707c478bd9Sstevel@tonic-gate save_errno = errno; 36717c478bd9Sstevel@tonic-gate 36727c478bd9Sstevel@tonic-gate if (tTd(55, 60)) 36737c478bd9Sstevel@tonic-gate sm_dprintf("(%s) ", sm_errstring(save_errno)); 36747c478bd9Sstevel@tonic-gate 36757c478bd9Sstevel@tonic-gate if (!bitset(LOCK_NB, type) || save_errno != EWOULDBLOCK) 36767c478bd9Sstevel@tonic-gate { 36777c478bd9Sstevel@tonic-gate int omode = fcntl(fd, F_GETFL, 0); 36787c478bd9Sstevel@tonic-gate uid_t euid = geteuid(); 36797c478bd9Sstevel@tonic-gate 36807c478bd9Sstevel@tonic-gate errno = save_errno; 36817c478bd9Sstevel@tonic-gate syserr("cannot flock(%s%s, fd=%d, type=%o, omode=%o, euid=%d)", 36827c478bd9Sstevel@tonic-gate filename, ext, fd, type, omode, euid); 36837c478bd9Sstevel@tonic-gate dumpfd(fd, true, true); 36847c478bd9Sstevel@tonic-gate } 36857c478bd9Sstevel@tonic-gate # endif /* !HASFLOCK */ 36867c478bd9Sstevel@tonic-gate if (tTd(55, 60)) 36877c478bd9Sstevel@tonic-gate sm_dprintf("FAIL\n"); 36887c478bd9Sstevel@tonic-gate errno = save_errno; 36897c478bd9Sstevel@tonic-gate return false; 36907c478bd9Sstevel@tonic-gate } 36917c478bd9Sstevel@tonic-gate /* 36927c478bd9Sstevel@tonic-gate ** CHOWNSAFE -- tell if chown is "safe" (executable only by root) 36937c478bd9Sstevel@tonic-gate ** 36947c478bd9Sstevel@tonic-gate ** Unfortunately, given that we can't predict other systems on which 36957c478bd9Sstevel@tonic-gate ** a remote mounted (NFS) filesystem will be mounted, the answer is 36967c478bd9Sstevel@tonic-gate ** almost always that this is unsafe. 36977c478bd9Sstevel@tonic-gate ** 36987c478bd9Sstevel@tonic-gate ** Note also that many operating systems have non-compliant 36997c478bd9Sstevel@tonic-gate ** implementations of the _POSIX_CHOWN_RESTRICTED variable and the 37007c478bd9Sstevel@tonic-gate ** fpathconf() routine. According to IEEE 1003.1-1990, if 37017c478bd9Sstevel@tonic-gate ** _POSIX_CHOWN_RESTRICTED is defined and not equal to -1, then 37027c478bd9Sstevel@tonic-gate ** no non-root process can give away the file. However, vendors 37037c478bd9Sstevel@tonic-gate ** don't take NFS into account, so a comfortable value of 37047c478bd9Sstevel@tonic-gate ** _POSIX_CHOWN_RESTRICTED tells us nothing. 37057c478bd9Sstevel@tonic-gate ** 37067c478bd9Sstevel@tonic-gate ** Also, some systems (e.g., IRIX 6.2) return 1 from fpathconf() 37077c478bd9Sstevel@tonic-gate ** even on files where chown is not restricted. Many systems get 37087c478bd9Sstevel@tonic-gate ** this wrong on NFS-based filesystems (that is, they say that chown 37097c478bd9Sstevel@tonic-gate ** is restricted [safe] on NFS filesystems where it may not be, since 37107c478bd9Sstevel@tonic-gate ** other systems can access the same filesystem and do file giveaway; 37117c478bd9Sstevel@tonic-gate ** only the NFS server knows for sure!) Hence, it is important to 37127c478bd9Sstevel@tonic-gate ** get the value of SAFENFSPATHCONF correct -- it should be defined 37137c478bd9Sstevel@tonic-gate ** _only_ after testing (see test/t_pathconf.c) a system on an unsafe 37147c478bd9Sstevel@tonic-gate ** NFS-based filesystem to ensure that you can get meaningful results. 37157c478bd9Sstevel@tonic-gate ** If in doubt, assume unsafe! 37167c478bd9Sstevel@tonic-gate ** 37177c478bd9Sstevel@tonic-gate ** You may also need to tweak IS_SAFE_CHOWN -- it should be a 37187c478bd9Sstevel@tonic-gate ** condition indicating whether the return from pathconf indicates 37197c478bd9Sstevel@tonic-gate ** that chown is safe (typically either > 0 or >= 0 -- there isn't 37207c478bd9Sstevel@tonic-gate ** even any agreement about whether a zero return means that a file 37217c478bd9Sstevel@tonic-gate ** is or is not safe). It defaults to "> 0". 37227c478bd9Sstevel@tonic-gate ** 37237c478bd9Sstevel@tonic-gate ** If the parent directory is safe (writable only by owner back 37247c478bd9Sstevel@tonic-gate ** to the root) then we can relax slightly and trust fpathconf 37257c478bd9Sstevel@tonic-gate ** in more circumstances. This is really a crock -- if this is an 37267c478bd9Sstevel@tonic-gate ** NFS mounted filesystem then we really know nothing about the 37277c478bd9Sstevel@tonic-gate ** underlying implementation. However, most systems pessimize and 37287c478bd9Sstevel@tonic-gate ** return an error (EINVAL or EOPNOTSUPP) on NFS filesystems, which 37297c478bd9Sstevel@tonic-gate ** we interpret as unsafe, as we should. Thus, this heuristic gets 37307c478bd9Sstevel@tonic-gate ** us into a possible problem only on systems that have a broken 37317c478bd9Sstevel@tonic-gate ** pathconf implementation and which are also poorly configured 37327c478bd9Sstevel@tonic-gate ** (have :include: files in group- or world-writable directories). 37337c478bd9Sstevel@tonic-gate ** 37347c478bd9Sstevel@tonic-gate ** Parameters: 37357c478bd9Sstevel@tonic-gate ** fd -- the file descriptor to check. 37367c478bd9Sstevel@tonic-gate ** safedir -- set if the parent directory is safe. 37377c478bd9Sstevel@tonic-gate ** 37387c478bd9Sstevel@tonic-gate ** Returns: 37397c478bd9Sstevel@tonic-gate ** true -- if the chown(2) operation is "safe" -- that is, 37407c478bd9Sstevel@tonic-gate ** only root can chown the file to an arbitrary user. 37417c478bd9Sstevel@tonic-gate ** false -- if an arbitrary user can give away a file. 37427c478bd9Sstevel@tonic-gate */ 37437c478bd9Sstevel@tonic-gate 37447c478bd9Sstevel@tonic-gate #ifndef IS_SAFE_CHOWN 37457c478bd9Sstevel@tonic-gate # define IS_SAFE_CHOWN > 0 37467c478bd9Sstevel@tonic-gate #endif /* ! IS_SAFE_CHOWN */ 37477c478bd9Sstevel@tonic-gate 37487c478bd9Sstevel@tonic-gate bool 37497c478bd9Sstevel@tonic-gate chownsafe(fd, safedir) 37507c478bd9Sstevel@tonic-gate int fd; 37517c478bd9Sstevel@tonic-gate bool safedir; 37527c478bd9Sstevel@tonic-gate { 37537c478bd9Sstevel@tonic-gate # if (!defined(_POSIX_CHOWN_RESTRICTED) || _POSIX_CHOWN_RESTRICTED != -1) && \ 37547c478bd9Sstevel@tonic-gate (defined(_PC_CHOWN_RESTRICTED) || defined(_GNU_TYPES_H)) 37557c478bd9Sstevel@tonic-gate int rval; 37567c478bd9Sstevel@tonic-gate 37577c478bd9Sstevel@tonic-gate /* give the system administrator a chance to override */ 37587c478bd9Sstevel@tonic-gate if (bitnset(DBS_ASSUMESAFECHOWN, DontBlameSendmail)) 37597c478bd9Sstevel@tonic-gate return true; 37607c478bd9Sstevel@tonic-gate 37617c478bd9Sstevel@tonic-gate /* 37627c478bd9Sstevel@tonic-gate ** Some systems (e.g., SunOS) seem to have the call and the 37637c478bd9Sstevel@tonic-gate ** #define _PC_CHOWN_RESTRICTED, but don't actually implement 37647c478bd9Sstevel@tonic-gate ** the call. This heuristic checks for that. 37657c478bd9Sstevel@tonic-gate */ 37667c478bd9Sstevel@tonic-gate 37677c478bd9Sstevel@tonic-gate errno = 0; 37687c478bd9Sstevel@tonic-gate rval = fpathconf(fd, _PC_CHOWN_RESTRICTED); 37697c478bd9Sstevel@tonic-gate # if SAFENFSPATHCONF 37707c478bd9Sstevel@tonic-gate return errno == 0 && rval IS_SAFE_CHOWN; 37717c478bd9Sstevel@tonic-gate # else /* SAFENFSPATHCONF */ 37727c478bd9Sstevel@tonic-gate return safedir && errno == 0 && rval IS_SAFE_CHOWN; 37737c478bd9Sstevel@tonic-gate # endif /* SAFENFSPATHCONF */ 37747c478bd9Sstevel@tonic-gate # else /* (!defined(_POSIX_CHOWN_RESTRICTED) || _POSIX_CHOWN_RESTRICTED != -1) && ... */ 37757c478bd9Sstevel@tonic-gate return bitnset(DBS_ASSUMESAFECHOWN, DontBlameSendmail); 37767c478bd9Sstevel@tonic-gate # endif /* (!defined(_POSIX_CHOWN_RESTRICTED) || _POSIX_CHOWN_RESTRICTED != -1) && ... */ 37777c478bd9Sstevel@tonic-gate } 37787c478bd9Sstevel@tonic-gate /* 37797c478bd9Sstevel@tonic-gate ** RESETLIMITS -- reset system controlled resource limits 37807c478bd9Sstevel@tonic-gate ** 37817c478bd9Sstevel@tonic-gate ** This is to avoid denial-of-service attacks 37827c478bd9Sstevel@tonic-gate ** 37837c478bd9Sstevel@tonic-gate ** Parameters: 37847c478bd9Sstevel@tonic-gate ** none 37857c478bd9Sstevel@tonic-gate ** 37867c478bd9Sstevel@tonic-gate ** Returns: 37877c478bd9Sstevel@tonic-gate ** none 37887c478bd9Sstevel@tonic-gate */ 37897c478bd9Sstevel@tonic-gate 37907c478bd9Sstevel@tonic-gate #if HASSETRLIMIT 37917c478bd9Sstevel@tonic-gate # ifdef RLIMIT_NEEDS_SYS_TIME_H 379249218d4fSjbeck # include <sm/time.h> 37937c478bd9Sstevel@tonic-gate # endif /* RLIMIT_NEEDS_SYS_TIME_H */ 37947c478bd9Sstevel@tonic-gate # include <sys/resource.h> 37957c478bd9Sstevel@tonic-gate #endif /* HASSETRLIMIT */ 37967c478bd9Sstevel@tonic-gate 37977c478bd9Sstevel@tonic-gate void 37987c478bd9Sstevel@tonic-gate resetlimits() 37997c478bd9Sstevel@tonic-gate { 38007c478bd9Sstevel@tonic-gate #if HASSETRLIMIT 38017c478bd9Sstevel@tonic-gate struct rlimit lim; 38027c478bd9Sstevel@tonic-gate 38037c478bd9Sstevel@tonic-gate lim.rlim_cur = lim.rlim_max = RLIM_INFINITY; 38047c478bd9Sstevel@tonic-gate (void) setrlimit(RLIMIT_CPU, &lim); 38057c478bd9Sstevel@tonic-gate (void) setrlimit(RLIMIT_FSIZE, &lim); 38067c478bd9Sstevel@tonic-gate # ifdef RLIMIT_NOFILE 38077c478bd9Sstevel@tonic-gate lim.rlim_cur = lim.rlim_max = FD_SETSIZE; 38087c478bd9Sstevel@tonic-gate (void) setrlimit(RLIMIT_NOFILE, &lim); 38097c478bd9Sstevel@tonic-gate # endif /* RLIMIT_NOFILE */ 38107c478bd9Sstevel@tonic-gate #else /* HASSETRLIMIT */ 38117c478bd9Sstevel@tonic-gate # if HASULIMIT 38127c478bd9Sstevel@tonic-gate (void) ulimit(2, 0x3fffff); 38137c478bd9Sstevel@tonic-gate (void) ulimit(4, FD_SETSIZE); 38147c478bd9Sstevel@tonic-gate # endif /* HASULIMIT */ 38157c478bd9Sstevel@tonic-gate #endif /* HASSETRLIMIT */ 38167c478bd9Sstevel@tonic-gate errno = 0; 38177c478bd9Sstevel@tonic-gate } 38187c478bd9Sstevel@tonic-gate /* 38197c478bd9Sstevel@tonic-gate ** SETVENDOR -- process vendor code from V configuration line 38207c478bd9Sstevel@tonic-gate ** 38217c478bd9Sstevel@tonic-gate ** Parameters: 38227c478bd9Sstevel@tonic-gate ** vendor -- string representation of vendor. 38237c478bd9Sstevel@tonic-gate ** 38247c478bd9Sstevel@tonic-gate ** Returns: 38257c478bd9Sstevel@tonic-gate ** true -- if ok. 38267c478bd9Sstevel@tonic-gate ** false -- if vendor code could not be processed. 38277c478bd9Sstevel@tonic-gate ** 38287c478bd9Sstevel@tonic-gate ** Side Effects: 38297c478bd9Sstevel@tonic-gate ** It is reasonable to set mode flags here to tweak 38307c478bd9Sstevel@tonic-gate ** processing in other parts of the code if necessary. 38317c478bd9Sstevel@tonic-gate ** For example, if you are a vendor that uses $%y to 38327c478bd9Sstevel@tonic-gate ** indicate YP lookups, you could enable that here. 38337c478bd9Sstevel@tonic-gate */ 38347c478bd9Sstevel@tonic-gate 38357c478bd9Sstevel@tonic-gate bool 38367c478bd9Sstevel@tonic-gate setvendor(vendor) 38377c478bd9Sstevel@tonic-gate char *vendor; 38387c478bd9Sstevel@tonic-gate { 38397c478bd9Sstevel@tonic-gate if (sm_strcasecmp(vendor, "Berkeley") == 0) 38407c478bd9Sstevel@tonic-gate { 38417c478bd9Sstevel@tonic-gate VendorCode = VENDOR_BERKELEY; 38427c478bd9Sstevel@tonic-gate return true; 38437c478bd9Sstevel@tonic-gate } 38447c478bd9Sstevel@tonic-gate 38457c478bd9Sstevel@tonic-gate /* add vendor extensions here */ 38467c478bd9Sstevel@tonic-gate 38477c478bd9Sstevel@tonic-gate #ifdef SUN_EXTENSIONS 38487c478bd9Sstevel@tonic-gate if (sm_strcasecmp(vendor, "Sun") == 0) 38497c478bd9Sstevel@tonic-gate { 38507c478bd9Sstevel@tonic-gate VendorCode = VENDOR_SUN; 38517c478bd9Sstevel@tonic-gate return true; 38527c478bd9Sstevel@tonic-gate } 38537c478bd9Sstevel@tonic-gate #endif /* SUN_EXTENSIONS */ 385449218d4fSjbeck #ifdef DEC 385549218d4fSjbeck if (sm_strcasecmp(vendor, "Digital") == 0) 385649218d4fSjbeck { 385749218d4fSjbeck VendorCode = VENDOR_DEC; 385849218d4fSjbeck return true; 385949218d4fSjbeck } 386049218d4fSjbeck #endif /* DEC */ 38617c478bd9Sstevel@tonic-gate 38627c478bd9Sstevel@tonic-gate #if defined(VENDOR_NAME) && defined(VENDOR_CODE) 38637c478bd9Sstevel@tonic-gate if (sm_strcasecmp(vendor, VENDOR_NAME) == 0) 38647c478bd9Sstevel@tonic-gate { 38657c478bd9Sstevel@tonic-gate VendorCode = VENDOR_CODE; 38667c478bd9Sstevel@tonic-gate return true; 38677c478bd9Sstevel@tonic-gate } 38687c478bd9Sstevel@tonic-gate #endif /* defined(VENDOR_NAME) && defined(VENDOR_CODE) */ 38697c478bd9Sstevel@tonic-gate 38707c478bd9Sstevel@tonic-gate return false; 38717c478bd9Sstevel@tonic-gate } 38727c478bd9Sstevel@tonic-gate /* 38737c478bd9Sstevel@tonic-gate ** GETVENDOR -- return vendor name based on vendor code 38747c478bd9Sstevel@tonic-gate ** 38757c478bd9Sstevel@tonic-gate ** Parameters: 38767c478bd9Sstevel@tonic-gate ** vendorcode -- numeric representation of vendor. 38777c478bd9Sstevel@tonic-gate ** 38787c478bd9Sstevel@tonic-gate ** Returns: 38797c478bd9Sstevel@tonic-gate ** string containing vendor name. 38807c478bd9Sstevel@tonic-gate */ 38817c478bd9Sstevel@tonic-gate 38827c478bd9Sstevel@tonic-gate char * 38837c478bd9Sstevel@tonic-gate getvendor(vendorcode) 38847c478bd9Sstevel@tonic-gate int vendorcode; 38857c478bd9Sstevel@tonic-gate { 38867c478bd9Sstevel@tonic-gate #if defined(VENDOR_NAME) && defined(VENDOR_CODE) 38877c478bd9Sstevel@tonic-gate /* 38887c478bd9Sstevel@tonic-gate ** Can't have the same switch case twice so need to 38897c478bd9Sstevel@tonic-gate ** handle VENDOR_CODE outside of switch. It might 38907c478bd9Sstevel@tonic-gate ** match one of the existing VENDOR_* codes. 38917c478bd9Sstevel@tonic-gate */ 38927c478bd9Sstevel@tonic-gate 38937c478bd9Sstevel@tonic-gate if (vendorcode == VENDOR_CODE) 38947c478bd9Sstevel@tonic-gate return VENDOR_NAME; 38957c478bd9Sstevel@tonic-gate #endif /* defined(VENDOR_NAME) && defined(VENDOR_CODE) */ 38967c478bd9Sstevel@tonic-gate 38977c478bd9Sstevel@tonic-gate switch (vendorcode) 38987c478bd9Sstevel@tonic-gate { 38997c478bd9Sstevel@tonic-gate case VENDOR_BERKELEY: 39007c478bd9Sstevel@tonic-gate return "Berkeley"; 39017c478bd9Sstevel@tonic-gate 39027c478bd9Sstevel@tonic-gate case VENDOR_SUN: 39037c478bd9Sstevel@tonic-gate return "Sun"; 39047c478bd9Sstevel@tonic-gate 39057c478bd9Sstevel@tonic-gate case VENDOR_HP: 39067c478bd9Sstevel@tonic-gate return "HP"; 39077c478bd9Sstevel@tonic-gate 39087c478bd9Sstevel@tonic-gate case VENDOR_IBM: 39097c478bd9Sstevel@tonic-gate return "IBM"; 39107c478bd9Sstevel@tonic-gate 39117c478bd9Sstevel@tonic-gate case VENDOR_SENDMAIL: 39127c478bd9Sstevel@tonic-gate return "Sendmail"; 39137c478bd9Sstevel@tonic-gate 39147c478bd9Sstevel@tonic-gate default: 39157c478bd9Sstevel@tonic-gate return "Unknown"; 39167c478bd9Sstevel@tonic-gate } 39177c478bd9Sstevel@tonic-gate } 39187c478bd9Sstevel@tonic-gate /* 39197c478bd9Sstevel@tonic-gate ** VENDOR_PRE_DEFAULTS, VENDOR_POST_DEFAULTS -- set vendor-specific defaults 39207c478bd9Sstevel@tonic-gate ** 39217c478bd9Sstevel@tonic-gate ** Vendor_pre_defaults is called before reading the configuration 39227c478bd9Sstevel@tonic-gate ** file; vendor_post_defaults is called immediately after. 39237c478bd9Sstevel@tonic-gate ** 39247c478bd9Sstevel@tonic-gate ** Parameters: 39257c478bd9Sstevel@tonic-gate ** e -- the global environment to initialize. 39267c478bd9Sstevel@tonic-gate ** 39277c478bd9Sstevel@tonic-gate ** Returns: 39287c478bd9Sstevel@tonic-gate ** none. 39297c478bd9Sstevel@tonic-gate */ 39307c478bd9Sstevel@tonic-gate 39317c478bd9Sstevel@tonic-gate #if SHARE_V1 39327c478bd9Sstevel@tonic-gate int DefShareUid; /* default share uid to run as -- unused??? */ 39337c478bd9Sstevel@tonic-gate #endif /* SHARE_V1 */ 39347c478bd9Sstevel@tonic-gate 39357c478bd9Sstevel@tonic-gate void 39367c478bd9Sstevel@tonic-gate vendor_pre_defaults(e) 39377c478bd9Sstevel@tonic-gate ENVELOPE *e; 39387c478bd9Sstevel@tonic-gate { 39397c478bd9Sstevel@tonic-gate #if SHARE_V1 39407c478bd9Sstevel@tonic-gate /* OTHERUID is defined in shares.h, do not be alarmed */ 39417c478bd9Sstevel@tonic-gate DefShareUid = OTHERUID; 39427c478bd9Sstevel@tonic-gate #endif /* SHARE_V1 */ 39437c478bd9Sstevel@tonic-gate #if defined(SUN_EXTENSIONS) && defined(SUN_DEFAULT_VALUES) 39447c478bd9Sstevel@tonic-gate sun_pre_defaults(e); 39457c478bd9Sstevel@tonic-gate #endif /* defined(SUN_EXTENSIONS) && defined(SUN_DEFAULT_VALUES) */ 39467c478bd9Sstevel@tonic-gate #ifdef apollo 39477c478bd9Sstevel@tonic-gate /* 39487c478bd9Sstevel@tonic-gate ** stupid domain/os can't even open 39497c478bd9Sstevel@tonic-gate ** /etc/mail/sendmail.cf without this 39507c478bd9Sstevel@tonic-gate */ 39517c478bd9Sstevel@tonic-gate 3952*445f2479Sjbeck sm_setuserenv("ISP", NULL); 3953*445f2479Sjbeck sm_setuserenv("SYSTYPE", NULL); 39547c478bd9Sstevel@tonic-gate #endif /* apollo */ 39557c478bd9Sstevel@tonic-gate } 39567c478bd9Sstevel@tonic-gate 39577c478bd9Sstevel@tonic-gate 39587c478bd9Sstevel@tonic-gate void 39597c478bd9Sstevel@tonic-gate vendor_post_defaults(e) 39607c478bd9Sstevel@tonic-gate ENVELOPE *e; 39617c478bd9Sstevel@tonic-gate { 39627c478bd9Sstevel@tonic-gate #ifdef __QNX__ 39637c478bd9Sstevel@tonic-gate char *p; 39647c478bd9Sstevel@tonic-gate 39657c478bd9Sstevel@tonic-gate /* Makes sure the SOCK environment variable remains */ 39667c478bd9Sstevel@tonic-gate if (p = getextenv("SOCK")) 3967*445f2479Sjbeck sm_setuserenv("SOCK", p); 39687c478bd9Sstevel@tonic-gate #endif /* __QNX__ */ 39697c478bd9Sstevel@tonic-gate #if defined(SUN_EXTENSIONS) && defined(SUN_DEFAULT_VALUES) 39707c478bd9Sstevel@tonic-gate sun_post_defaults(e); 39717c478bd9Sstevel@tonic-gate #endif /* defined(SUN_EXTENSIONS) && defined(SUN_DEFAULT_VALUES) */ 39727c478bd9Sstevel@tonic-gate } 39737c478bd9Sstevel@tonic-gate /* 39747c478bd9Sstevel@tonic-gate ** VENDOR_DAEMON_SETUP -- special vendor setup needed for daemon mode 39757c478bd9Sstevel@tonic-gate */ 39767c478bd9Sstevel@tonic-gate 39777c478bd9Sstevel@tonic-gate void 39787c478bd9Sstevel@tonic-gate vendor_daemon_setup(e) 39797c478bd9Sstevel@tonic-gate ENVELOPE *e; 39807c478bd9Sstevel@tonic-gate { 39817c478bd9Sstevel@tonic-gate #if HASSETLOGIN 39827c478bd9Sstevel@tonic-gate (void) setlogin(RunAsUserName); 39837c478bd9Sstevel@tonic-gate #endif /* HASSETLOGIN */ 39847c478bd9Sstevel@tonic-gate #if SECUREWARE 39857c478bd9Sstevel@tonic-gate if (getluid() != -1) 39867c478bd9Sstevel@tonic-gate { 39877c478bd9Sstevel@tonic-gate usrerr("Daemon cannot have LUID"); 39887c478bd9Sstevel@tonic-gate finis(false, true, EX_USAGE); 39897c478bd9Sstevel@tonic-gate } 39907c478bd9Sstevel@tonic-gate #endif /* SECUREWARE */ 39917c478bd9Sstevel@tonic-gate } 39927c478bd9Sstevel@tonic-gate /* 39937c478bd9Sstevel@tonic-gate ** VENDOR_SET_UID -- do setup for setting a user id 39947c478bd9Sstevel@tonic-gate ** 39957c478bd9Sstevel@tonic-gate ** This is called when we are still root. 39967c478bd9Sstevel@tonic-gate ** 39977c478bd9Sstevel@tonic-gate ** Parameters: 39987c478bd9Sstevel@tonic-gate ** uid -- the uid we are about to become. 39997c478bd9Sstevel@tonic-gate ** 40007c478bd9Sstevel@tonic-gate ** Returns: 40017c478bd9Sstevel@tonic-gate ** none. 40027c478bd9Sstevel@tonic-gate */ 40037c478bd9Sstevel@tonic-gate 40047c478bd9Sstevel@tonic-gate void 40057c478bd9Sstevel@tonic-gate vendor_set_uid(uid) 40067c478bd9Sstevel@tonic-gate UID_T uid; 40077c478bd9Sstevel@tonic-gate { 40087c478bd9Sstevel@tonic-gate /* 40097c478bd9Sstevel@tonic-gate ** We need to setup the share groups (lnodes) 40107c478bd9Sstevel@tonic-gate ** and add auditing information (luid's) 40117c478bd9Sstevel@tonic-gate ** before we loose our ``root''ness. 40127c478bd9Sstevel@tonic-gate */ 40137c478bd9Sstevel@tonic-gate #if SHARE_V1 40147c478bd9Sstevel@tonic-gate if (setupshares(uid, syserr) != 0) 40157c478bd9Sstevel@tonic-gate syserr("Unable to set up shares"); 40167c478bd9Sstevel@tonic-gate #endif /* SHARE_V1 */ 40177c478bd9Sstevel@tonic-gate #if SECUREWARE 40187c478bd9Sstevel@tonic-gate (void) setup_secure(uid); 40197c478bd9Sstevel@tonic-gate #endif /* SECUREWARE */ 40207c478bd9Sstevel@tonic-gate } 40217c478bd9Sstevel@tonic-gate /* 40227c478bd9Sstevel@tonic-gate ** VALIDATE_CONNECTION -- check connection for rationality 40237c478bd9Sstevel@tonic-gate ** 40247c478bd9Sstevel@tonic-gate ** If the connection is rejected, this routine should log an 40257c478bd9Sstevel@tonic-gate ** appropriate message -- but should never issue any SMTP protocol. 40267c478bd9Sstevel@tonic-gate ** 40277c478bd9Sstevel@tonic-gate ** Parameters: 40287c478bd9Sstevel@tonic-gate ** sap -- a pointer to a SOCKADDR naming the peer. 40297c478bd9Sstevel@tonic-gate ** hostname -- the name corresponding to sap. 40307c478bd9Sstevel@tonic-gate ** e -- the current envelope. 40317c478bd9Sstevel@tonic-gate ** 40327c478bd9Sstevel@tonic-gate ** Returns: 40337c478bd9Sstevel@tonic-gate ** error message from rejection. 40347c478bd9Sstevel@tonic-gate ** NULL if not rejected. 40357c478bd9Sstevel@tonic-gate */ 40367c478bd9Sstevel@tonic-gate 40377c478bd9Sstevel@tonic-gate #if TCPWRAPPERS 40387c478bd9Sstevel@tonic-gate # include <tcpd.h> 40397c478bd9Sstevel@tonic-gate 40407c478bd9Sstevel@tonic-gate /* tcpwrappers does no logging, but you still have to declare these -- ugh */ 40417c478bd9Sstevel@tonic-gate int allow_severity = LOG_INFO; 40427c478bd9Sstevel@tonic-gate int deny_severity = LOG_NOTICE; 40437c478bd9Sstevel@tonic-gate #endif /* TCPWRAPPERS */ 40447c478bd9Sstevel@tonic-gate 40457c478bd9Sstevel@tonic-gate char * 40467c478bd9Sstevel@tonic-gate validate_connection(sap, hostname, e) 40477c478bd9Sstevel@tonic-gate SOCKADDR *sap; 40487c478bd9Sstevel@tonic-gate char *hostname; 40497c478bd9Sstevel@tonic-gate ENVELOPE *e; 40507c478bd9Sstevel@tonic-gate { 40517c478bd9Sstevel@tonic-gate #if TCPWRAPPERS 40527c478bd9Sstevel@tonic-gate char *host; 40537c478bd9Sstevel@tonic-gate char *addr; 40547c478bd9Sstevel@tonic-gate extern int hosts_ctl(); 40557c478bd9Sstevel@tonic-gate #endif /* TCPWRAPPERS */ 40567c478bd9Sstevel@tonic-gate 40577c478bd9Sstevel@tonic-gate if (tTd(48, 3)) 40587c478bd9Sstevel@tonic-gate sm_dprintf("validate_connection(%s, %s)\n", 40597c478bd9Sstevel@tonic-gate hostname, anynet_ntoa(sap)); 40607c478bd9Sstevel@tonic-gate 40617c478bd9Sstevel@tonic-gate connection_rate_check(sap, e); 40627c478bd9Sstevel@tonic-gate if (rscheck("check_relay", hostname, anynet_ntoa(sap), 40637c478bd9Sstevel@tonic-gate e, RSF_RMCOMM|RSF_COUNT, 3, NULL, NOQID) != EX_OK) 40647c478bd9Sstevel@tonic-gate { 40657c478bd9Sstevel@tonic-gate static char reject[BUFSIZ*2]; 40667c478bd9Sstevel@tonic-gate extern char MsgBuf[]; 40677c478bd9Sstevel@tonic-gate 40687c478bd9Sstevel@tonic-gate if (tTd(48, 4)) 40697c478bd9Sstevel@tonic-gate sm_dprintf(" ... validate_connection: BAD (rscheck)\n"); 40707c478bd9Sstevel@tonic-gate 40717c478bd9Sstevel@tonic-gate if (strlen(MsgBuf) >= 3) 40727c478bd9Sstevel@tonic-gate (void) sm_strlcpy(reject, MsgBuf, sizeof reject); 40737c478bd9Sstevel@tonic-gate else 40747c478bd9Sstevel@tonic-gate (void) sm_strlcpy(reject, "Access denied", sizeof reject); 40757c478bd9Sstevel@tonic-gate 40767c478bd9Sstevel@tonic-gate return reject; 40777c478bd9Sstevel@tonic-gate } 40787c478bd9Sstevel@tonic-gate 40797c478bd9Sstevel@tonic-gate #if TCPWRAPPERS 40807c478bd9Sstevel@tonic-gate if (hostname[0] == '[' && hostname[strlen(hostname) - 1] == ']') 40817c478bd9Sstevel@tonic-gate host = "unknown"; 40827c478bd9Sstevel@tonic-gate else 40837c478bd9Sstevel@tonic-gate host = hostname; 40847c478bd9Sstevel@tonic-gate addr = anynet_ntoa(sap); 40857c478bd9Sstevel@tonic-gate 40867c478bd9Sstevel@tonic-gate # if NETINET6 40877c478bd9Sstevel@tonic-gate /* TCP/Wrappers don't want the IPv6: protocol label */ 40887c478bd9Sstevel@tonic-gate if (addr != NULL && sm_strncasecmp(addr, "IPv6:", 5) == 0) 40897c478bd9Sstevel@tonic-gate addr += 5; 40907c478bd9Sstevel@tonic-gate # endif /* NETINET6 */ 40917c478bd9Sstevel@tonic-gate 40927c478bd9Sstevel@tonic-gate if (!hosts_ctl("sendmail", host, addr, STRING_UNKNOWN)) 40937c478bd9Sstevel@tonic-gate { 40947c478bd9Sstevel@tonic-gate if (tTd(48, 4)) 40957c478bd9Sstevel@tonic-gate sm_dprintf(" ... validate_connection: BAD (tcpwrappers)\n"); 40967c478bd9Sstevel@tonic-gate if (LogLevel > 3) 40977c478bd9Sstevel@tonic-gate sm_syslog(LOG_NOTICE, e->e_id, 40987c478bd9Sstevel@tonic-gate "tcpwrappers (%s, %s) rejection", 40997c478bd9Sstevel@tonic-gate host, addr); 41007c478bd9Sstevel@tonic-gate return "Access denied"; 41017c478bd9Sstevel@tonic-gate } 41027c478bd9Sstevel@tonic-gate #endif /* TCPWRAPPERS */ 41037c478bd9Sstevel@tonic-gate if (tTd(48, 4)) 41047c478bd9Sstevel@tonic-gate sm_dprintf(" ... validate_connection: OK\n"); 41057c478bd9Sstevel@tonic-gate return NULL; 41067c478bd9Sstevel@tonic-gate } 41077c478bd9Sstevel@tonic-gate 41087c478bd9Sstevel@tonic-gate /* 41097c478bd9Sstevel@tonic-gate ** STRTOL -- convert string to long integer 41107c478bd9Sstevel@tonic-gate ** 41117c478bd9Sstevel@tonic-gate ** For systems that don't have it in the C library. 41127c478bd9Sstevel@tonic-gate ** 41137c478bd9Sstevel@tonic-gate ** This is taken verbatim from the 4.4-Lite C library. 41147c478bd9Sstevel@tonic-gate */ 41157c478bd9Sstevel@tonic-gate 41167c478bd9Sstevel@tonic-gate #if NEEDSTRTOL 41177c478bd9Sstevel@tonic-gate 41187c478bd9Sstevel@tonic-gate # if defined(LIBC_SCCS) && !defined(lint) 41197c478bd9Sstevel@tonic-gate static char sccsid[] = "@(#)strtol.c 8.1 (Berkeley) 6/4/93"; 41207c478bd9Sstevel@tonic-gate # endif /* defined(LIBC_SCCS) && !defined(lint) */ 41217c478bd9Sstevel@tonic-gate 41227c478bd9Sstevel@tonic-gate /* 41237c478bd9Sstevel@tonic-gate ** Convert a string to a long integer. 41247c478bd9Sstevel@tonic-gate ** 41257c478bd9Sstevel@tonic-gate ** Ignores `locale' stuff. Assumes that the upper and lower case 41267c478bd9Sstevel@tonic-gate ** alphabets and digits are each contiguous. 41277c478bd9Sstevel@tonic-gate */ 41287c478bd9Sstevel@tonic-gate 41297c478bd9Sstevel@tonic-gate long 41307c478bd9Sstevel@tonic-gate strtol(nptr, endptr, base) 41317c478bd9Sstevel@tonic-gate const char *nptr; 41327c478bd9Sstevel@tonic-gate char **endptr; 41337c478bd9Sstevel@tonic-gate register int base; 41347c478bd9Sstevel@tonic-gate { 41357c478bd9Sstevel@tonic-gate register const char *s = nptr; 41367c478bd9Sstevel@tonic-gate register unsigned long acc; 41377c478bd9Sstevel@tonic-gate register int c; 41387c478bd9Sstevel@tonic-gate register unsigned long cutoff; 41397c478bd9Sstevel@tonic-gate register int neg = 0, any, cutlim; 41407c478bd9Sstevel@tonic-gate 41417c478bd9Sstevel@tonic-gate /* 41427c478bd9Sstevel@tonic-gate ** Skip white space and pick up leading +/- sign if any. 41437c478bd9Sstevel@tonic-gate ** If base is 0, allow 0x for hex and 0 for octal, else 41447c478bd9Sstevel@tonic-gate ** assume decimal; if base is already 16, allow 0x. 41457c478bd9Sstevel@tonic-gate */ 41467c478bd9Sstevel@tonic-gate do { 41477c478bd9Sstevel@tonic-gate c = *s++; 41487c478bd9Sstevel@tonic-gate } while (isspace(c)); 41497c478bd9Sstevel@tonic-gate if (c == '-') { 41507c478bd9Sstevel@tonic-gate neg = 1; 41517c478bd9Sstevel@tonic-gate c = *s++; 41527c478bd9Sstevel@tonic-gate } else if (c == '+') 41537c478bd9Sstevel@tonic-gate c = *s++; 41547c478bd9Sstevel@tonic-gate if ((base == 0 || base == 16) && 41557c478bd9Sstevel@tonic-gate c == '0' && (*s == 'x' || *s == 'X')) { 41567c478bd9Sstevel@tonic-gate c = s[1]; 41577c478bd9Sstevel@tonic-gate s += 2; 41587c478bd9Sstevel@tonic-gate base = 16; 41597c478bd9Sstevel@tonic-gate } 41607c478bd9Sstevel@tonic-gate if (base == 0) 41617c478bd9Sstevel@tonic-gate base = c == '0' ? 8 : 10; 41627c478bd9Sstevel@tonic-gate 41637c478bd9Sstevel@tonic-gate /* 41647c478bd9Sstevel@tonic-gate ** Compute the cutoff value between legal numbers and illegal 41657c478bd9Sstevel@tonic-gate ** numbers. That is the largest legal value, divided by the 41667c478bd9Sstevel@tonic-gate ** base. An input number that is greater than this value, if 41677c478bd9Sstevel@tonic-gate ** followed by a legal input character, is too big. One that 41687c478bd9Sstevel@tonic-gate ** is equal to this value may be valid or not; the limit 41697c478bd9Sstevel@tonic-gate ** between valid and invalid numbers is then based on the last 41707c478bd9Sstevel@tonic-gate ** digit. For instance, if the range for longs is 41717c478bd9Sstevel@tonic-gate ** [-2147483648..2147483647] and the input base is 10, 41727c478bd9Sstevel@tonic-gate ** cutoff will be set to 214748364 and cutlim to either 41737c478bd9Sstevel@tonic-gate ** 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated 41747c478bd9Sstevel@tonic-gate ** a value > 214748364, or equal but the next digit is > 7 (or 8), 41757c478bd9Sstevel@tonic-gate ** the number is too big, and we will return a range error. 41767c478bd9Sstevel@tonic-gate ** 41777c478bd9Sstevel@tonic-gate ** Set any if any `digits' consumed; make it negative to indicate 41787c478bd9Sstevel@tonic-gate ** overflow. 41797c478bd9Sstevel@tonic-gate */ 41807c478bd9Sstevel@tonic-gate cutoff = neg ? -(unsigned long) LONG_MIN : LONG_MAX; 41817c478bd9Sstevel@tonic-gate cutlim = cutoff % (unsigned long) base; 41827c478bd9Sstevel@tonic-gate cutoff /= (unsigned long) base; 41837c478bd9Sstevel@tonic-gate for (acc = 0, any = 0;; c = *s++) { 41847c478bd9Sstevel@tonic-gate if (isdigit(c)) 41857c478bd9Sstevel@tonic-gate c -= '0'; 41867c478bd9Sstevel@tonic-gate else if (isalpha(c)) 41877c478bd9Sstevel@tonic-gate c -= isupper(c) ? 'A' - 10 : 'a' - 10; 41887c478bd9Sstevel@tonic-gate else 41897c478bd9Sstevel@tonic-gate break; 41907c478bd9Sstevel@tonic-gate if (c >= base) 41917c478bd9Sstevel@tonic-gate break; 41927c478bd9Sstevel@tonic-gate if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim) 41937c478bd9Sstevel@tonic-gate any = -1; 41947c478bd9Sstevel@tonic-gate else { 41957c478bd9Sstevel@tonic-gate any = 1; 41967c478bd9Sstevel@tonic-gate acc *= base; 41977c478bd9Sstevel@tonic-gate acc += c; 41987c478bd9Sstevel@tonic-gate } 41997c478bd9Sstevel@tonic-gate } 42007c478bd9Sstevel@tonic-gate if (any < 0) { 42017c478bd9Sstevel@tonic-gate acc = neg ? LONG_MIN : LONG_MAX; 42027c478bd9Sstevel@tonic-gate errno = ERANGE; 42037c478bd9Sstevel@tonic-gate } else if (neg) 42047c478bd9Sstevel@tonic-gate acc = -acc; 42057c478bd9Sstevel@tonic-gate if (endptr != 0) 42067c478bd9Sstevel@tonic-gate *endptr = (char *)(any ? s - 1 : nptr); 42077c478bd9Sstevel@tonic-gate return acc; 42087c478bd9Sstevel@tonic-gate } 42097c478bd9Sstevel@tonic-gate 42107c478bd9Sstevel@tonic-gate #endif /* NEEDSTRTOL */ 42117c478bd9Sstevel@tonic-gate /* 42127c478bd9Sstevel@tonic-gate ** STRSTR -- find first substring in string 42137c478bd9Sstevel@tonic-gate ** 42147c478bd9Sstevel@tonic-gate ** Parameters: 42157c478bd9Sstevel@tonic-gate ** big -- the big (full) string. 42167c478bd9Sstevel@tonic-gate ** little -- the little (sub) string. 42177c478bd9Sstevel@tonic-gate ** 42187c478bd9Sstevel@tonic-gate ** Returns: 42197c478bd9Sstevel@tonic-gate ** A pointer to the first instance of little in big. 42207c478bd9Sstevel@tonic-gate ** big if little is the null string. 42217c478bd9Sstevel@tonic-gate ** NULL if little is not contained in big. 42227c478bd9Sstevel@tonic-gate */ 42237c478bd9Sstevel@tonic-gate 42247c478bd9Sstevel@tonic-gate #if NEEDSTRSTR 42257c478bd9Sstevel@tonic-gate 42267c478bd9Sstevel@tonic-gate char * 42277c478bd9Sstevel@tonic-gate strstr(big, little) 42287c478bd9Sstevel@tonic-gate char *big; 42297c478bd9Sstevel@tonic-gate char *little; 42307c478bd9Sstevel@tonic-gate { 42317c478bd9Sstevel@tonic-gate register char *p = big; 42327c478bd9Sstevel@tonic-gate int l; 42337c478bd9Sstevel@tonic-gate 42347c478bd9Sstevel@tonic-gate if (*little == '\0') 42357c478bd9Sstevel@tonic-gate return big; 42367c478bd9Sstevel@tonic-gate l = strlen(little); 42377c478bd9Sstevel@tonic-gate 42387c478bd9Sstevel@tonic-gate while ((p = strchr(p, *little)) != NULL) 42397c478bd9Sstevel@tonic-gate { 42407c478bd9Sstevel@tonic-gate if (strncmp(p, little, l) == 0) 42417c478bd9Sstevel@tonic-gate return p; 42427c478bd9Sstevel@tonic-gate p++; 42437c478bd9Sstevel@tonic-gate } 42447c478bd9Sstevel@tonic-gate return NULL; 42457c478bd9Sstevel@tonic-gate } 42467c478bd9Sstevel@tonic-gate 42477c478bd9Sstevel@tonic-gate #endif /* NEEDSTRSTR */ 42487c478bd9Sstevel@tonic-gate /* 42497c478bd9Sstevel@tonic-gate ** SM_GETHOSTBY{NAME,ADDR} -- compatibility routines for gethostbyXXX 42507c478bd9Sstevel@tonic-gate ** 42517c478bd9Sstevel@tonic-gate ** Some operating systems have wierd problems with the gethostbyXXX 42527c478bd9Sstevel@tonic-gate ** routines. For example, Solaris versions at least through 2.3 42537c478bd9Sstevel@tonic-gate ** don't properly deliver a canonical h_name field. This tries to 42547c478bd9Sstevel@tonic-gate ** work around these problems. 42557c478bd9Sstevel@tonic-gate ** 42567c478bd9Sstevel@tonic-gate ** Support IPv6 as well as IPv4. 42577c478bd9Sstevel@tonic-gate */ 42587c478bd9Sstevel@tonic-gate 42597c478bd9Sstevel@tonic-gate #if NETINET6 && NEEDSGETIPNODE 42607c478bd9Sstevel@tonic-gate 42617c478bd9Sstevel@tonic-gate # ifndef AI_DEFAULT 42627c478bd9Sstevel@tonic-gate # define AI_DEFAULT 0 /* dummy */ 42637c478bd9Sstevel@tonic-gate # endif /* ! AI_DEFAULT */ 42647c478bd9Sstevel@tonic-gate # ifndef AI_ADDRCONFIG 42657c478bd9Sstevel@tonic-gate # define AI_ADDRCONFIG 0 /* dummy */ 42667c478bd9Sstevel@tonic-gate # endif /* ! AI_ADDRCONFIG */ 42677c478bd9Sstevel@tonic-gate # ifndef AI_V4MAPPED 42687c478bd9Sstevel@tonic-gate # define AI_V4MAPPED 0 /* dummy */ 42697c478bd9Sstevel@tonic-gate # endif /* ! AI_V4MAPPED */ 42707c478bd9Sstevel@tonic-gate # ifndef AI_ALL 42717c478bd9Sstevel@tonic-gate # define AI_ALL 0 /* dummy */ 42727c478bd9Sstevel@tonic-gate # endif /* ! AI_ALL */ 42737c478bd9Sstevel@tonic-gate 42747c478bd9Sstevel@tonic-gate static struct hostent * 42757c478bd9Sstevel@tonic-gate getipnodebyname(name, family, flags, err) 42767c478bd9Sstevel@tonic-gate char *name; 42777c478bd9Sstevel@tonic-gate int family; 42787c478bd9Sstevel@tonic-gate int flags; 42797c478bd9Sstevel@tonic-gate int *err; 42807c478bd9Sstevel@tonic-gate { 42817c478bd9Sstevel@tonic-gate bool resv6 = true; 42827c478bd9Sstevel@tonic-gate struct hostent *h; 42837c478bd9Sstevel@tonic-gate 42847c478bd9Sstevel@tonic-gate if (family == AF_INET6) 42857c478bd9Sstevel@tonic-gate { 42867c478bd9Sstevel@tonic-gate /* From RFC2133, section 6.1 */ 42877c478bd9Sstevel@tonic-gate resv6 = bitset(RES_USE_INET6, _res.options); 42887c478bd9Sstevel@tonic-gate _res.options |= RES_USE_INET6; 42897c478bd9Sstevel@tonic-gate } 42907c478bd9Sstevel@tonic-gate SM_SET_H_ERRNO(0); 42917c478bd9Sstevel@tonic-gate h = gethostbyname(name); 42927c478bd9Sstevel@tonic-gate if (!resv6) 42937c478bd9Sstevel@tonic-gate _res.options &= ~RES_USE_INET6; 42947c478bd9Sstevel@tonic-gate *err = h_errno; 42957c478bd9Sstevel@tonic-gate return h; 42967c478bd9Sstevel@tonic-gate } 42977c478bd9Sstevel@tonic-gate 42987c478bd9Sstevel@tonic-gate static struct hostent * 42997c478bd9Sstevel@tonic-gate getipnodebyaddr(addr, len, family, err) 43007c478bd9Sstevel@tonic-gate char *addr; 43017c478bd9Sstevel@tonic-gate int len; 43027c478bd9Sstevel@tonic-gate int family; 43037c478bd9Sstevel@tonic-gate int *err; 43047c478bd9Sstevel@tonic-gate { 43057c478bd9Sstevel@tonic-gate struct hostent *h; 43067c478bd9Sstevel@tonic-gate 43077c478bd9Sstevel@tonic-gate SM_SET_H_ERRNO(0); 43087c478bd9Sstevel@tonic-gate h = gethostbyaddr(addr, len, family); 43097c478bd9Sstevel@tonic-gate *err = h_errno; 43107c478bd9Sstevel@tonic-gate return h; 43117c478bd9Sstevel@tonic-gate } 43127c478bd9Sstevel@tonic-gate 43137c478bd9Sstevel@tonic-gate void 43147c478bd9Sstevel@tonic-gate freehostent(h) 43157c478bd9Sstevel@tonic-gate struct hostent *h; 43167c478bd9Sstevel@tonic-gate { 43177c478bd9Sstevel@tonic-gate /* 43187c478bd9Sstevel@tonic-gate ** Stub routine -- if they don't have getipnodeby*(), 43197c478bd9Sstevel@tonic-gate ** they probably don't have the free routine either. 43207c478bd9Sstevel@tonic-gate */ 43217c478bd9Sstevel@tonic-gate 43227c478bd9Sstevel@tonic-gate return; 43237c478bd9Sstevel@tonic-gate } 43247c478bd9Sstevel@tonic-gate #endif /* NETINET6 && NEEDSGETIPNODE */ 43257c478bd9Sstevel@tonic-gate 43267c478bd9Sstevel@tonic-gate struct hostent * 43277c478bd9Sstevel@tonic-gate sm_gethostbyname(name, family) 43287c478bd9Sstevel@tonic-gate char *name; 43297c478bd9Sstevel@tonic-gate int family; 43307c478bd9Sstevel@tonic-gate { 43317c478bd9Sstevel@tonic-gate int save_errno; 43327c478bd9Sstevel@tonic-gate struct hostent *h = NULL; 43337c478bd9Sstevel@tonic-gate #if (SOLARIS > 10000 && SOLARIS < 20400) || (defined(SOLARIS) && SOLARIS < 204) || (defined(sony_news) && defined(__svr4)) 43347c478bd9Sstevel@tonic-gate # if SOLARIS == 20300 || SOLARIS == 203 43357c478bd9Sstevel@tonic-gate static struct hostent hp; 43367c478bd9Sstevel@tonic-gate static char buf[1000]; 43377c478bd9Sstevel@tonic-gate extern struct hostent *_switch_gethostbyname_r(); 43387c478bd9Sstevel@tonic-gate 43397c478bd9Sstevel@tonic-gate if (tTd(61, 10)) 43407c478bd9Sstevel@tonic-gate sm_dprintf("_switch_gethostbyname_r(%s)... ", name); 43417c478bd9Sstevel@tonic-gate h = _switch_gethostbyname_r(name, &hp, buf, sizeof(buf), &h_errno); 43427c478bd9Sstevel@tonic-gate save_errno = errno; 43437c478bd9Sstevel@tonic-gate # else /* SOLARIS == 20300 || SOLARIS == 203 */ 43447c478bd9Sstevel@tonic-gate extern struct hostent *__switch_gethostbyname(); 43457c478bd9Sstevel@tonic-gate 43467c478bd9Sstevel@tonic-gate if (tTd(61, 10)) 43477c478bd9Sstevel@tonic-gate sm_dprintf("__switch_gethostbyname(%s)... ", name); 43487c478bd9Sstevel@tonic-gate h = __switch_gethostbyname(name); 43497c478bd9Sstevel@tonic-gate save_errno = errno; 43507c478bd9Sstevel@tonic-gate # endif /* SOLARIS == 20300 || SOLARIS == 203 */ 43517c478bd9Sstevel@tonic-gate #else /* (SOLARIS > 10000 && SOLARIS < 20400) || (defined(SOLARIS) && SOLARIS < 204) || (defined(sony_news) && defined(__svr4)) */ 43527c478bd9Sstevel@tonic-gate int nmaps; 43537c478bd9Sstevel@tonic-gate # if NETINET6 43547c478bd9Sstevel@tonic-gate int flags = AI_DEFAULT|AI_ALL; 43557c478bd9Sstevel@tonic-gate int err; 43567c478bd9Sstevel@tonic-gate # endif /* NETINET6 */ 43577c478bd9Sstevel@tonic-gate char *maptype[MAXMAPSTACK]; 43587c478bd9Sstevel@tonic-gate short mapreturn[MAXMAPACTIONS]; 43597c478bd9Sstevel@tonic-gate char hbuf[MAXNAME]; 43607c478bd9Sstevel@tonic-gate 43617c478bd9Sstevel@tonic-gate if (tTd(61, 10)) 43627c478bd9Sstevel@tonic-gate sm_dprintf("sm_gethostbyname(%s, %d)... ", name, family); 43637c478bd9Sstevel@tonic-gate 43647c478bd9Sstevel@tonic-gate # if NETINET6 43657c478bd9Sstevel@tonic-gate # if ADDRCONFIG_IS_BROKEN 43667c478bd9Sstevel@tonic-gate flags &= ~AI_ADDRCONFIG; 43677c478bd9Sstevel@tonic-gate # endif /* ADDRCONFIG_IS_BROKEN */ 43687c478bd9Sstevel@tonic-gate h = getipnodebyname(name, family, flags, &err); 43697c478bd9Sstevel@tonic-gate SM_SET_H_ERRNO(err); 43707c478bd9Sstevel@tonic-gate # else /* NETINET6 */ 43717c478bd9Sstevel@tonic-gate h = gethostbyname(name); 43727c478bd9Sstevel@tonic-gate # endif /* NETINET6 */ 43737c478bd9Sstevel@tonic-gate 43747c478bd9Sstevel@tonic-gate save_errno = errno; 43757c478bd9Sstevel@tonic-gate if (h == NULL) 43767c478bd9Sstevel@tonic-gate { 43777c478bd9Sstevel@tonic-gate if (tTd(61, 10)) 43787c478bd9Sstevel@tonic-gate sm_dprintf("failure\n"); 43797c478bd9Sstevel@tonic-gate 43807c478bd9Sstevel@tonic-gate nmaps = switch_map_find("hosts", maptype, mapreturn); 43817c478bd9Sstevel@tonic-gate while (--nmaps >= 0) 43827c478bd9Sstevel@tonic-gate { 43837c478bd9Sstevel@tonic-gate if (strcmp(maptype[nmaps], "nis") == 0 || 43847c478bd9Sstevel@tonic-gate strcmp(maptype[nmaps], "files") == 0) 43857c478bd9Sstevel@tonic-gate break; 43867c478bd9Sstevel@tonic-gate } 43877c478bd9Sstevel@tonic-gate 43887c478bd9Sstevel@tonic-gate if (nmaps >= 0) 43897c478bd9Sstevel@tonic-gate { 43907c478bd9Sstevel@tonic-gate /* try short name */ 43917c478bd9Sstevel@tonic-gate if (strlen(name) > sizeof hbuf - 1) 43927c478bd9Sstevel@tonic-gate { 43937c478bd9Sstevel@tonic-gate errno = save_errno; 43947c478bd9Sstevel@tonic-gate return NULL; 43957c478bd9Sstevel@tonic-gate } 43967c478bd9Sstevel@tonic-gate (void) sm_strlcpy(hbuf, name, sizeof hbuf); 43977c478bd9Sstevel@tonic-gate (void) shorten_hostname(hbuf); 43987c478bd9Sstevel@tonic-gate 43997c478bd9Sstevel@tonic-gate /* if it hasn't been shortened, there's no point */ 44007c478bd9Sstevel@tonic-gate if (strcmp(hbuf, name) != 0) 44017c478bd9Sstevel@tonic-gate { 44027c478bd9Sstevel@tonic-gate if (tTd(61, 10)) 44037c478bd9Sstevel@tonic-gate sm_dprintf("sm_gethostbyname(%s, %d)... ", 44047c478bd9Sstevel@tonic-gate hbuf, family); 44057c478bd9Sstevel@tonic-gate 44067c478bd9Sstevel@tonic-gate # if NETINET6 44077c478bd9Sstevel@tonic-gate h = getipnodebyname(hbuf, family, flags, &err); 44087c478bd9Sstevel@tonic-gate SM_SET_H_ERRNO(err); 44097c478bd9Sstevel@tonic-gate save_errno = errno; 44107c478bd9Sstevel@tonic-gate # else /* NETINET6 */ 44117c478bd9Sstevel@tonic-gate h = gethostbyname(hbuf); 44127c478bd9Sstevel@tonic-gate save_errno = errno; 44137c478bd9Sstevel@tonic-gate # endif /* NETINET6 */ 44147c478bd9Sstevel@tonic-gate } 44157c478bd9Sstevel@tonic-gate } 44167c478bd9Sstevel@tonic-gate } 44177c478bd9Sstevel@tonic-gate #endif /* (SOLARIS > 10000 && SOLARIS < 20400) || (defined(SOLARIS) && SOLARIS < 204) || (defined(sony_news) && defined(__svr4)) */ 44187c478bd9Sstevel@tonic-gate if (tTd(61, 10)) 44197c478bd9Sstevel@tonic-gate { 44207c478bd9Sstevel@tonic-gate if (h == NULL) 44217c478bd9Sstevel@tonic-gate sm_dprintf("failure\n"); 44227c478bd9Sstevel@tonic-gate else 44237c478bd9Sstevel@tonic-gate { 44247c478bd9Sstevel@tonic-gate sm_dprintf("%s\n", h->h_name); 44257c478bd9Sstevel@tonic-gate if (tTd(61, 11)) 44267c478bd9Sstevel@tonic-gate { 44277c478bd9Sstevel@tonic-gate #if NETINET6 44287c478bd9Sstevel@tonic-gate struct in6_addr ia6; 44297c478bd9Sstevel@tonic-gate char buf6[INET6_ADDRSTRLEN]; 44307c478bd9Sstevel@tonic-gate #else /* NETINET6 */ 44317c478bd9Sstevel@tonic-gate struct in_addr ia; 44327c478bd9Sstevel@tonic-gate #endif /* NETINET6 */ 44337c478bd9Sstevel@tonic-gate size_t i; 44347c478bd9Sstevel@tonic-gate 44357c478bd9Sstevel@tonic-gate if (h->h_aliases != NULL) 44367c478bd9Sstevel@tonic-gate for (i = 0; h->h_aliases[i] != NULL; 44377c478bd9Sstevel@tonic-gate i++) 44387c478bd9Sstevel@tonic-gate sm_dprintf("\talias: %s\n", 44397c478bd9Sstevel@tonic-gate h->h_aliases[i]); 44407c478bd9Sstevel@tonic-gate for (i = 0; h->h_addr_list[i] != NULL; i++) 44417c478bd9Sstevel@tonic-gate { 44427c478bd9Sstevel@tonic-gate char *addr; 44437c478bd9Sstevel@tonic-gate 44447c478bd9Sstevel@tonic-gate #if NETINET6 44457c478bd9Sstevel@tonic-gate memmove(&ia6, h->h_addr_list[i], 44467c478bd9Sstevel@tonic-gate IN6ADDRSZ); 44477c478bd9Sstevel@tonic-gate addr = anynet_ntop(&ia6, 44487c478bd9Sstevel@tonic-gate buf6, sizeof buf6); 44497c478bd9Sstevel@tonic-gate #else /* NETINET6 */ 44507c478bd9Sstevel@tonic-gate memmove(&ia, h->h_addr_list[i], 44517c478bd9Sstevel@tonic-gate INADDRSZ); 44527c478bd9Sstevel@tonic-gate addr = (char *) inet_ntoa(ia); 44537c478bd9Sstevel@tonic-gate #endif /* NETINET6 */ 44547c478bd9Sstevel@tonic-gate if (addr != NULL) 44557c478bd9Sstevel@tonic-gate sm_dprintf("\taddr: %s\n", addr); 44567c478bd9Sstevel@tonic-gate } 44577c478bd9Sstevel@tonic-gate } 44587c478bd9Sstevel@tonic-gate } 44597c478bd9Sstevel@tonic-gate } 44607c478bd9Sstevel@tonic-gate errno = save_errno; 44617c478bd9Sstevel@tonic-gate return h; 44627c478bd9Sstevel@tonic-gate } 44637c478bd9Sstevel@tonic-gate 44647c478bd9Sstevel@tonic-gate struct hostent * 44657c478bd9Sstevel@tonic-gate sm_gethostbyaddr(addr, len, type) 44667c478bd9Sstevel@tonic-gate char *addr; 44677c478bd9Sstevel@tonic-gate int len; 44687c478bd9Sstevel@tonic-gate int type; 44697c478bd9Sstevel@tonic-gate { 44707c478bd9Sstevel@tonic-gate struct hostent *hp; 44717c478bd9Sstevel@tonic-gate 44727c478bd9Sstevel@tonic-gate #if NETINET6 44737c478bd9Sstevel@tonic-gate if (type == AF_INET6 && 44747c478bd9Sstevel@tonic-gate IN6_IS_ADDR_UNSPECIFIED((struct in6_addr *) addr)) 44757c478bd9Sstevel@tonic-gate { 44767c478bd9Sstevel@tonic-gate /* Avoid reverse lookup for IPv6 unspecified address */ 44777c478bd9Sstevel@tonic-gate SM_SET_H_ERRNO(HOST_NOT_FOUND); 44787c478bd9Sstevel@tonic-gate return NULL; 44797c478bd9Sstevel@tonic-gate } 44807c478bd9Sstevel@tonic-gate #endif /* NETINET6 */ 44817c478bd9Sstevel@tonic-gate 44827c478bd9Sstevel@tonic-gate #if (SOLARIS > 10000 && SOLARIS < 20400) || (defined(SOLARIS) && SOLARIS < 204) 44837c478bd9Sstevel@tonic-gate # if SOLARIS == 20300 || SOLARIS == 203 44847c478bd9Sstevel@tonic-gate { 44857c478bd9Sstevel@tonic-gate static struct hostent he; 44867c478bd9Sstevel@tonic-gate static char buf[1000]; 44877c478bd9Sstevel@tonic-gate extern struct hostent *_switch_gethostbyaddr_r(); 44887c478bd9Sstevel@tonic-gate 44897c478bd9Sstevel@tonic-gate hp = _switch_gethostbyaddr_r(addr, len, type, &he, 44907c478bd9Sstevel@tonic-gate buf, sizeof(buf), &h_errno); 44917c478bd9Sstevel@tonic-gate } 44927c478bd9Sstevel@tonic-gate # else /* SOLARIS == 20300 || SOLARIS == 203 */ 44937c478bd9Sstevel@tonic-gate { 44947c478bd9Sstevel@tonic-gate extern struct hostent *__switch_gethostbyaddr(); 44957c478bd9Sstevel@tonic-gate 44967c478bd9Sstevel@tonic-gate hp = __switch_gethostbyaddr(addr, len, type); 44977c478bd9Sstevel@tonic-gate } 44987c478bd9Sstevel@tonic-gate # endif /* SOLARIS == 20300 || SOLARIS == 203 */ 44997c478bd9Sstevel@tonic-gate #else /* (SOLARIS > 10000 && SOLARIS < 20400) || (defined(SOLARIS) && SOLARIS < 204) */ 45007c478bd9Sstevel@tonic-gate # if NETINET6 45017c478bd9Sstevel@tonic-gate { 45027c478bd9Sstevel@tonic-gate int err; 45037c478bd9Sstevel@tonic-gate 45047c478bd9Sstevel@tonic-gate hp = getipnodebyaddr(addr, len, type, &err); 45057c478bd9Sstevel@tonic-gate SM_SET_H_ERRNO(err); 45067c478bd9Sstevel@tonic-gate } 45077c478bd9Sstevel@tonic-gate # else /* NETINET6 */ 45087c478bd9Sstevel@tonic-gate hp = gethostbyaddr(addr, len, type); 45097c478bd9Sstevel@tonic-gate # endif /* NETINET6 */ 45107c478bd9Sstevel@tonic-gate #endif /* (SOLARIS > 10000 && SOLARIS < 20400) || (defined(SOLARIS) && SOLARIS < 204) */ 45117c478bd9Sstevel@tonic-gate return hp; 45127c478bd9Sstevel@tonic-gate } 45137c478bd9Sstevel@tonic-gate /* 45147c478bd9Sstevel@tonic-gate ** SM_GETPW{NAM,UID} -- wrapper for getpwnam and getpwuid 45157c478bd9Sstevel@tonic-gate */ 45167c478bd9Sstevel@tonic-gate 45177c478bd9Sstevel@tonic-gate struct passwd * 45187c478bd9Sstevel@tonic-gate sm_getpwnam(user) 45197c478bd9Sstevel@tonic-gate char *user; 45207c478bd9Sstevel@tonic-gate { 45217c478bd9Sstevel@tonic-gate #ifdef _AIX4 45227c478bd9Sstevel@tonic-gate extern struct passwd *_getpwnam_shadow(const char *, const int); 45237c478bd9Sstevel@tonic-gate 45247c478bd9Sstevel@tonic-gate return _getpwnam_shadow(user, 0); 45257c478bd9Sstevel@tonic-gate #else /* _AIX4 */ 45267c478bd9Sstevel@tonic-gate return getpwnam(user); 45277c478bd9Sstevel@tonic-gate #endif /* _AIX4 */ 45287c478bd9Sstevel@tonic-gate } 45297c478bd9Sstevel@tonic-gate 45307c478bd9Sstevel@tonic-gate struct passwd * 45317c478bd9Sstevel@tonic-gate sm_getpwuid(uid) 45327c478bd9Sstevel@tonic-gate UID_T uid; 45337c478bd9Sstevel@tonic-gate { 45347c478bd9Sstevel@tonic-gate #if defined(_AIX4) && 0 45357c478bd9Sstevel@tonic-gate extern struct passwd *_getpwuid_shadow(const int, const int); 45367c478bd9Sstevel@tonic-gate 45377c478bd9Sstevel@tonic-gate return _getpwuid_shadow(uid,0); 45387c478bd9Sstevel@tonic-gate #else /* defined(_AIX4) && 0 */ 45397c478bd9Sstevel@tonic-gate return getpwuid(uid); 45407c478bd9Sstevel@tonic-gate #endif /* defined(_AIX4) && 0 */ 45417c478bd9Sstevel@tonic-gate } 45427c478bd9Sstevel@tonic-gate /* 45437c478bd9Sstevel@tonic-gate ** SECUREWARE_SETUP_SECURE -- Convex SecureWare setup 45447c478bd9Sstevel@tonic-gate ** 45457c478bd9Sstevel@tonic-gate ** Set up the trusted computing environment for C2 level security 45467c478bd9Sstevel@tonic-gate ** under SecureWare. 45477c478bd9Sstevel@tonic-gate ** 45487c478bd9Sstevel@tonic-gate ** Parameters: 45497c478bd9Sstevel@tonic-gate ** uid -- uid of the user to initialize in the TCB 45507c478bd9Sstevel@tonic-gate ** 45517c478bd9Sstevel@tonic-gate ** Returns: 45527c478bd9Sstevel@tonic-gate ** none 45537c478bd9Sstevel@tonic-gate ** 45547c478bd9Sstevel@tonic-gate ** Side Effects: 45557c478bd9Sstevel@tonic-gate ** Initialized the user in the trusted computing base 45567c478bd9Sstevel@tonic-gate */ 45577c478bd9Sstevel@tonic-gate 45587c478bd9Sstevel@tonic-gate #if SECUREWARE 45597c478bd9Sstevel@tonic-gate 45607c478bd9Sstevel@tonic-gate # include <sys/security.h> 45617c478bd9Sstevel@tonic-gate # include <prot.h> 45627c478bd9Sstevel@tonic-gate 45637c478bd9Sstevel@tonic-gate void 45647c478bd9Sstevel@tonic-gate secureware_setup_secure(uid) 45657c478bd9Sstevel@tonic-gate UID_T uid; 45667c478bd9Sstevel@tonic-gate { 45677c478bd9Sstevel@tonic-gate int rc; 45687c478bd9Sstevel@tonic-gate 45697c478bd9Sstevel@tonic-gate if (getluid() != -1) 45707c478bd9Sstevel@tonic-gate return; 45717c478bd9Sstevel@tonic-gate 45727c478bd9Sstevel@tonic-gate if ((rc = set_secure_info(uid)) != SSI_GOOD_RETURN) 45737c478bd9Sstevel@tonic-gate { 45747c478bd9Sstevel@tonic-gate switch (rc) 45757c478bd9Sstevel@tonic-gate { 45767c478bd9Sstevel@tonic-gate case SSI_NO_PRPW_ENTRY: 45777c478bd9Sstevel@tonic-gate syserr("No protected passwd entry, uid = %d", 45787c478bd9Sstevel@tonic-gate (int) uid); 45797c478bd9Sstevel@tonic-gate break; 45807c478bd9Sstevel@tonic-gate 45817c478bd9Sstevel@tonic-gate case SSI_LOCKED: 45827c478bd9Sstevel@tonic-gate syserr("Account has been disabled, uid = %d", 45837c478bd9Sstevel@tonic-gate (int) uid); 45847c478bd9Sstevel@tonic-gate break; 45857c478bd9Sstevel@tonic-gate 45867c478bd9Sstevel@tonic-gate case SSI_RETIRED: 45877c478bd9Sstevel@tonic-gate syserr("Account has been retired, uid = %d", 45887c478bd9Sstevel@tonic-gate (int) uid); 45897c478bd9Sstevel@tonic-gate break; 45907c478bd9Sstevel@tonic-gate 45917c478bd9Sstevel@tonic-gate case SSI_BAD_SET_LUID: 45927c478bd9Sstevel@tonic-gate syserr("Could not set LUID, uid = %d", (int) uid); 45937c478bd9Sstevel@tonic-gate break; 45947c478bd9Sstevel@tonic-gate 45957c478bd9Sstevel@tonic-gate case SSI_BAD_SET_PRIVS: 45967c478bd9Sstevel@tonic-gate syserr("Could not set kernel privs, uid = %d", 45977c478bd9Sstevel@tonic-gate (int) uid); 45987c478bd9Sstevel@tonic-gate 45997c478bd9Sstevel@tonic-gate default: 46007c478bd9Sstevel@tonic-gate syserr("Unknown return code (%d) from set_secure_info(%d)", 46017c478bd9Sstevel@tonic-gate rc, (int) uid); 46027c478bd9Sstevel@tonic-gate break; 46037c478bd9Sstevel@tonic-gate } 46047c478bd9Sstevel@tonic-gate finis(false, true, EX_NOPERM); 46057c478bd9Sstevel@tonic-gate } 46067c478bd9Sstevel@tonic-gate } 46077c478bd9Sstevel@tonic-gate #endif /* SECUREWARE */ 46087c478bd9Sstevel@tonic-gate /* 46097c478bd9Sstevel@tonic-gate ** ADD_HOSTNAMES -- Add a hostname to class 'w' based on IP address 46107c478bd9Sstevel@tonic-gate ** 46117c478bd9Sstevel@tonic-gate ** Add hostnames to class 'w' based on the IP address read from 46127c478bd9Sstevel@tonic-gate ** the network interface. 46137c478bd9Sstevel@tonic-gate ** 46147c478bd9Sstevel@tonic-gate ** Parameters: 46157c478bd9Sstevel@tonic-gate ** sa -- a pointer to a SOCKADDR containing the address 46167c478bd9Sstevel@tonic-gate ** 46177c478bd9Sstevel@tonic-gate ** Returns: 46187c478bd9Sstevel@tonic-gate ** 0 if successful, -1 if host lookup fails. 46197c478bd9Sstevel@tonic-gate */ 46207c478bd9Sstevel@tonic-gate 46217c478bd9Sstevel@tonic-gate static int 46227c478bd9Sstevel@tonic-gate add_hostnames(sa) 46237c478bd9Sstevel@tonic-gate SOCKADDR *sa; 46247c478bd9Sstevel@tonic-gate { 46257c478bd9Sstevel@tonic-gate struct hostent *hp; 46267c478bd9Sstevel@tonic-gate char **ha; 46277c478bd9Sstevel@tonic-gate char hnb[MAXHOSTNAMELEN]; 46287c478bd9Sstevel@tonic-gate 46297c478bd9Sstevel@tonic-gate /* lookup name with IP address */ 46307c478bd9Sstevel@tonic-gate switch (sa->sa.sa_family) 46317c478bd9Sstevel@tonic-gate { 46327c478bd9Sstevel@tonic-gate #if NETINET 46337c478bd9Sstevel@tonic-gate case AF_INET: 46347c478bd9Sstevel@tonic-gate hp = sm_gethostbyaddr((char *) &sa->sin.sin_addr, 46357c478bd9Sstevel@tonic-gate sizeof(sa->sin.sin_addr), 46367c478bd9Sstevel@tonic-gate sa->sa.sa_family); 46377c478bd9Sstevel@tonic-gate break; 46387c478bd9Sstevel@tonic-gate #endif /* NETINET */ 46397c478bd9Sstevel@tonic-gate 46407c478bd9Sstevel@tonic-gate #if NETINET6 46417c478bd9Sstevel@tonic-gate case AF_INET6: 46427c478bd9Sstevel@tonic-gate hp = sm_gethostbyaddr((char *) &sa->sin6.sin6_addr, 46437c478bd9Sstevel@tonic-gate sizeof(sa->sin6.sin6_addr), 46447c478bd9Sstevel@tonic-gate sa->sa.sa_family); 46457c478bd9Sstevel@tonic-gate break; 46467c478bd9Sstevel@tonic-gate #endif /* NETINET6 */ 46477c478bd9Sstevel@tonic-gate 46487c478bd9Sstevel@tonic-gate default: 46497c478bd9Sstevel@tonic-gate /* Give warning about unsupported family */ 46507c478bd9Sstevel@tonic-gate if (LogLevel > 3) 46517c478bd9Sstevel@tonic-gate sm_syslog(LOG_WARNING, NOQID, 46527c478bd9Sstevel@tonic-gate "Unsupported address family %d: %.100s", 46537c478bd9Sstevel@tonic-gate sa->sa.sa_family, anynet_ntoa(sa)); 46547c478bd9Sstevel@tonic-gate return -1; 46557c478bd9Sstevel@tonic-gate } 46567c478bd9Sstevel@tonic-gate 46577c478bd9Sstevel@tonic-gate if (hp == NULL) 46587c478bd9Sstevel@tonic-gate { 46597c478bd9Sstevel@tonic-gate int save_errno = errno; 46607c478bd9Sstevel@tonic-gate 46617c478bd9Sstevel@tonic-gate if (LogLevel > 3 && 46627c478bd9Sstevel@tonic-gate #if NETINET6 46637c478bd9Sstevel@tonic-gate !(sa->sa.sa_family == AF_INET6 && 46647c478bd9Sstevel@tonic-gate IN6_IS_ADDR_LINKLOCAL(&sa->sin6.sin6_addr)) && 46657c478bd9Sstevel@tonic-gate #endif /* NETINET6 */ 46667c478bd9Sstevel@tonic-gate true) 46677c478bd9Sstevel@tonic-gate sm_syslog(LOG_WARNING, NOQID, 46687c478bd9Sstevel@tonic-gate "gethostbyaddr(%.100s) failed: %d", 46697c478bd9Sstevel@tonic-gate anynet_ntoa(sa), 46707c478bd9Sstevel@tonic-gate #if NAMED_BIND 46717c478bd9Sstevel@tonic-gate h_errno 46727c478bd9Sstevel@tonic-gate #else /* NAMED_BIND */ 46737c478bd9Sstevel@tonic-gate -1 46747c478bd9Sstevel@tonic-gate #endif /* NAMED_BIND */ 46757c478bd9Sstevel@tonic-gate ); 46767c478bd9Sstevel@tonic-gate errno = save_errno; 46777c478bd9Sstevel@tonic-gate return -1; 46787c478bd9Sstevel@tonic-gate } 46797c478bd9Sstevel@tonic-gate 46807c478bd9Sstevel@tonic-gate /* save its cname */ 46817c478bd9Sstevel@tonic-gate if (!wordinclass((char *) hp->h_name, 'w')) 46827c478bd9Sstevel@tonic-gate { 46837c478bd9Sstevel@tonic-gate setclass('w', (char *) hp->h_name); 46847c478bd9Sstevel@tonic-gate if (tTd(0, 4)) 46857c478bd9Sstevel@tonic-gate sm_dprintf("\ta.k.a.: %s\n", hp->h_name); 46867c478bd9Sstevel@tonic-gate 46877c478bd9Sstevel@tonic-gate if (sm_snprintf(hnb, sizeof hnb, "[%s]", hp->h_name) < sizeof hnb 46887c478bd9Sstevel@tonic-gate && !wordinclass((char *) hnb, 'w')) 46897c478bd9Sstevel@tonic-gate setclass('w', hnb); 46907c478bd9Sstevel@tonic-gate } 46917c478bd9Sstevel@tonic-gate else 46927c478bd9Sstevel@tonic-gate { 46937c478bd9Sstevel@tonic-gate if (tTd(0, 43)) 46947c478bd9Sstevel@tonic-gate sm_dprintf("\ta.k.a.: %s (already in $=w)\n", hp->h_name); 46957c478bd9Sstevel@tonic-gate } 46967c478bd9Sstevel@tonic-gate 46977c478bd9Sstevel@tonic-gate /* save all it aliases name */ 46987c478bd9Sstevel@tonic-gate for (ha = hp->h_aliases; ha != NULL && *ha != NULL; ha++) 46997c478bd9Sstevel@tonic-gate { 47007c478bd9Sstevel@tonic-gate if (!wordinclass(*ha, 'w')) 47017c478bd9Sstevel@tonic-gate { 47027c478bd9Sstevel@tonic-gate setclass('w', *ha); 47037c478bd9Sstevel@tonic-gate if (tTd(0, 4)) 47047c478bd9Sstevel@tonic-gate sm_dprintf("\ta.k.a.: %s\n", *ha); 47057c478bd9Sstevel@tonic-gate if (sm_snprintf(hnb, sizeof hnb, 47067c478bd9Sstevel@tonic-gate "[%s]", *ha) < sizeof hnb && 47077c478bd9Sstevel@tonic-gate !wordinclass((char *) hnb, 'w')) 47087c478bd9Sstevel@tonic-gate setclass('w', hnb); 47097c478bd9Sstevel@tonic-gate } 47107c478bd9Sstevel@tonic-gate else 47117c478bd9Sstevel@tonic-gate { 47127c478bd9Sstevel@tonic-gate if (tTd(0, 43)) 47137c478bd9Sstevel@tonic-gate sm_dprintf("\ta.k.a.: %s (already in $=w)\n", 47147c478bd9Sstevel@tonic-gate *ha); 47157c478bd9Sstevel@tonic-gate } 47167c478bd9Sstevel@tonic-gate } 47177c478bd9Sstevel@tonic-gate #if NETINET6 47187c478bd9Sstevel@tonic-gate freehostent(hp); 47197c478bd9Sstevel@tonic-gate #endif /* NETINET6 */ 47207c478bd9Sstevel@tonic-gate return 0; 47217c478bd9Sstevel@tonic-gate } 47227c478bd9Sstevel@tonic-gate /* 47237c478bd9Sstevel@tonic-gate ** LOAD_IF_NAMES -- load interface-specific names into $=w 47247c478bd9Sstevel@tonic-gate ** 47257c478bd9Sstevel@tonic-gate ** Parameters: 47267c478bd9Sstevel@tonic-gate ** none. 47277c478bd9Sstevel@tonic-gate ** 47287c478bd9Sstevel@tonic-gate ** Returns: 47297c478bd9Sstevel@tonic-gate ** none. 47307c478bd9Sstevel@tonic-gate ** 47317c478bd9Sstevel@tonic-gate ** Side Effects: 47327c478bd9Sstevel@tonic-gate ** Loads $=w with the names of all the interfaces. 47337c478bd9Sstevel@tonic-gate */ 47347c478bd9Sstevel@tonic-gate 47357c478bd9Sstevel@tonic-gate #if !NETINET 47367c478bd9Sstevel@tonic-gate # define SIOCGIFCONF_IS_BROKEN 1 /* XXX */ 47377c478bd9Sstevel@tonic-gate #endif /* !NETINET */ 47387c478bd9Sstevel@tonic-gate 47397c478bd9Sstevel@tonic-gate #if defined(SIOCGIFCONF) && !SIOCGIFCONF_IS_BROKEN 47407c478bd9Sstevel@tonic-gate struct rtentry; 47417c478bd9Sstevel@tonic-gate struct mbuf; 47427c478bd9Sstevel@tonic-gate # ifndef SUNOS403 474349218d4fSjbeck # include <sm/time.h> 47447c478bd9Sstevel@tonic-gate # endif /* ! SUNOS403 */ 47457c478bd9Sstevel@tonic-gate # if (_AIX4 >= 40300) && !defined(_NET_IF_H) 47467c478bd9Sstevel@tonic-gate # undef __P 47477c478bd9Sstevel@tonic-gate # endif /* (_AIX4 >= 40300) && !defined(_NET_IF_H) */ 47487c478bd9Sstevel@tonic-gate # include <net/if.h> 47497c478bd9Sstevel@tonic-gate #endif /* defined(SIOCGIFCONF) && !SIOCGIFCONF_IS_BROKEN */ 47507c478bd9Sstevel@tonic-gate 47517c478bd9Sstevel@tonic-gate void 47527c478bd9Sstevel@tonic-gate load_if_names() 47537c478bd9Sstevel@tonic-gate { 47547c478bd9Sstevel@tonic-gate # if NETINET6 && defined(SIOCGLIFCONF) 47557c478bd9Sstevel@tonic-gate # ifdef __hpux 47567c478bd9Sstevel@tonic-gate 47577c478bd9Sstevel@tonic-gate /* 47587c478bd9Sstevel@tonic-gate ** Unfortunately, HP has changed all of the structures, 47597c478bd9Sstevel@tonic-gate ** making life difficult for implementors. 47607c478bd9Sstevel@tonic-gate */ 47617c478bd9Sstevel@tonic-gate 47627c478bd9Sstevel@tonic-gate # define lifconf if_laddrconf 47637c478bd9Sstevel@tonic-gate # define lifc_len iflc_len 47647c478bd9Sstevel@tonic-gate # define lifc_buf iflc_buf 47657c478bd9Sstevel@tonic-gate # define lifreq if_laddrreq 47667c478bd9Sstevel@tonic-gate # define lifr_addr iflr_addr 47677c478bd9Sstevel@tonic-gate # define lifr_name iflr_name 47687c478bd9Sstevel@tonic-gate # define lifr_flags iflr_flags 47697c478bd9Sstevel@tonic-gate # define ss_family sa_family 47707c478bd9Sstevel@tonic-gate # undef SIOCGLIFNUM 47717c478bd9Sstevel@tonic-gate # endif /* __hpux */ 47727c478bd9Sstevel@tonic-gate 47737c478bd9Sstevel@tonic-gate int s; 47747c478bd9Sstevel@tonic-gate int i; 47757c478bd9Sstevel@tonic-gate size_t len; 47767c478bd9Sstevel@tonic-gate int numifs; 47777c478bd9Sstevel@tonic-gate char *buf; 47787c478bd9Sstevel@tonic-gate struct lifconf lifc; 47797c478bd9Sstevel@tonic-gate # ifdef SIOCGLIFNUM 47807c478bd9Sstevel@tonic-gate struct lifnum lifn; 47817c478bd9Sstevel@tonic-gate # endif /* SIOCGLIFNUM */ 47827c478bd9Sstevel@tonic-gate 47837c478bd9Sstevel@tonic-gate s = socket(InetMode, SOCK_DGRAM, 0); 47847c478bd9Sstevel@tonic-gate if (s == -1) 47857c478bd9Sstevel@tonic-gate return; 47867c478bd9Sstevel@tonic-gate 47877c478bd9Sstevel@tonic-gate /* get the list of known IP address from the kernel */ 47887c478bd9Sstevel@tonic-gate # ifdef __hpux 47897c478bd9Sstevel@tonic-gate i = ioctl(s, SIOCGIFNUM, (char *) &numifs); 47907c478bd9Sstevel@tonic-gate # endif /* __hpux */ 47917c478bd9Sstevel@tonic-gate # ifdef SIOCGLIFNUM 47927c478bd9Sstevel@tonic-gate lifn.lifn_family = AF_UNSPEC; 47937c478bd9Sstevel@tonic-gate lifn.lifn_flags = 0; 47947c478bd9Sstevel@tonic-gate i = ioctl(s, SIOCGLIFNUM, (char *)&lifn); 47957c478bd9Sstevel@tonic-gate numifs = lifn.lifn_count; 47967c478bd9Sstevel@tonic-gate # endif /* SIOCGLIFNUM */ 47977c478bd9Sstevel@tonic-gate 47987c478bd9Sstevel@tonic-gate # if defined(__hpux) || defined(SIOCGLIFNUM) 47997c478bd9Sstevel@tonic-gate if (i < 0) 48007c478bd9Sstevel@tonic-gate { 48017c478bd9Sstevel@tonic-gate /* can't get number of interfaces -- fall back */ 48027c478bd9Sstevel@tonic-gate if (tTd(0, 4)) 48037c478bd9Sstevel@tonic-gate sm_dprintf("SIOCGLIFNUM failed: %s\n", 48047c478bd9Sstevel@tonic-gate sm_errstring(errno)); 48057c478bd9Sstevel@tonic-gate numifs = -1; 48067c478bd9Sstevel@tonic-gate } 48077c478bd9Sstevel@tonic-gate else if (tTd(0, 42)) 48087c478bd9Sstevel@tonic-gate sm_dprintf("system has %d interfaces\n", numifs); 48097c478bd9Sstevel@tonic-gate if (numifs < 0) 48107c478bd9Sstevel@tonic-gate # endif /* defined(__hpux) || defined(SIOCGLIFNUM) */ 48117c478bd9Sstevel@tonic-gate numifs = MAXINTERFACES; 48127c478bd9Sstevel@tonic-gate 48137c478bd9Sstevel@tonic-gate if (numifs <= 0) 48147c478bd9Sstevel@tonic-gate { 48157c478bd9Sstevel@tonic-gate (void) close(s); 48167c478bd9Sstevel@tonic-gate return; 48177c478bd9Sstevel@tonic-gate } 48187c478bd9Sstevel@tonic-gate 48197c478bd9Sstevel@tonic-gate len = lifc.lifc_len = numifs * sizeof (struct lifreq); 48207c478bd9Sstevel@tonic-gate buf = lifc.lifc_buf = xalloc(lifc.lifc_len); 48217c478bd9Sstevel@tonic-gate # ifndef __hpux 48227c478bd9Sstevel@tonic-gate lifc.lifc_family = AF_UNSPEC; 48237c478bd9Sstevel@tonic-gate lifc.lifc_flags = 0; 48247c478bd9Sstevel@tonic-gate # endif /* ! __hpux */ 48257c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGLIFCONF, (char *)&lifc) < 0) 48267c478bd9Sstevel@tonic-gate { 48277c478bd9Sstevel@tonic-gate if (tTd(0, 4)) 48287c478bd9Sstevel@tonic-gate sm_dprintf("SIOCGLIFCONF failed: %s\n", 48297c478bd9Sstevel@tonic-gate sm_errstring(errno)); 48307c478bd9Sstevel@tonic-gate (void) close(s); 48317c478bd9Sstevel@tonic-gate sm_free(buf); 48327c478bd9Sstevel@tonic-gate return; 48337c478bd9Sstevel@tonic-gate } 48347c478bd9Sstevel@tonic-gate 48357c478bd9Sstevel@tonic-gate /* scan the list of IP address */ 48367c478bd9Sstevel@tonic-gate if (tTd(0, 40)) 48377c478bd9Sstevel@tonic-gate sm_dprintf("scanning for interface specific names, lifc_len=%ld\n", 48387c478bd9Sstevel@tonic-gate (long) len); 48397c478bd9Sstevel@tonic-gate 48407c478bd9Sstevel@tonic-gate for (i = 0; i < len && i >= 0; ) 48417c478bd9Sstevel@tonic-gate { 48427c478bd9Sstevel@tonic-gate int flags; 48437c478bd9Sstevel@tonic-gate struct lifreq *ifr = (struct lifreq *)&buf[i]; 48447c478bd9Sstevel@tonic-gate SOCKADDR *sa = (SOCKADDR *) &ifr->lifr_addr; 48457c478bd9Sstevel@tonic-gate int af = ifr->lifr_addr.ss_family; 48467c478bd9Sstevel@tonic-gate char *addr; 48477c478bd9Sstevel@tonic-gate char *name; 48487c478bd9Sstevel@tonic-gate struct in6_addr ia6; 48497c478bd9Sstevel@tonic-gate struct in_addr ia; 48507c478bd9Sstevel@tonic-gate # ifdef SIOCGLIFFLAGS 48517c478bd9Sstevel@tonic-gate struct lifreq ifrf; 48527c478bd9Sstevel@tonic-gate # endif /* SIOCGLIFFLAGS */ 48537c478bd9Sstevel@tonic-gate char ip_addr[256]; 48547c478bd9Sstevel@tonic-gate char buf6[INET6_ADDRSTRLEN]; 48557c478bd9Sstevel@tonic-gate 48567c478bd9Sstevel@tonic-gate /* 48577c478bd9Sstevel@tonic-gate ** We must close and recreate the socket each time 48587c478bd9Sstevel@tonic-gate ** since we don't know what type of socket it is now 48597c478bd9Sstevel@tonic-gate ** (each status function may change it). 48607c478bd9Sstevel@tonic-gate */ 48617c478bd9Sstevel@tonic-gate 48627c478bd9Sstevel@tonic-gate (void) close(s); 48637c478bd9Sstevel@tonic-gate 48647c478bd9Sstevel@tonic-gate s = socket(af, SOCK_DGRAM, 0); 48657c478bd9Sstevel@tonic-gate if (s == -1) 48667c478bd9Sstevel@tonic-gate { 48677c478bd9Sstevel@tonic-gate sm_free(buf); /* XXX */ 48687c478bd9Sstevel@tonic-gate return; 48697c478bd9Sstevel@tonic-gate } 48707c478bd9Sstevel@tonic-gate 48717c478bd9Sstevel@tonic-gate /* 48727c478bd9Sstevel@tonic-gate ** If we don't have a complete ifr structure, 48737c478bd9Sstevel@tonic-gate ** don't try to use it. 48747c478bd9Sstevel@tonic-gate */ 48757c478bd9Sstevel@tonic-gate 48767c478bd9Sstevel@tonic-gate if ((len - i) < sizeof *ifr) 48777c478bd9Sstevel@tonic-gate break; 48787c478bd9Sstevel@tonic-gate 48797c478bd9Sstevel@tonic-gate # ifdef BSD4_4_SOCKADDR 48807c478bd9Sstevel@tonic-gate if (sa->sa.sa_len > sizeof ifr->lifr_addr) 48817c478bd9Sstevel@tonic-gate i += sizeof ifr->lifr_name + sa->sa.sa_len; 48827c478bd9Sstevel@tonic-gate else 48837c478bd9Sstevel@tonic-gate # endif /* BSD4_4_SOCKADDR */ 488449218d4fSjbeck # ifdef DEC 488549218d4fSjbeck /* fix for IPv6 size differences */ 488649218d4fSjbeck i += sizeof ifr->ifr_name + 488749218d4fSjbeck max(sizeof(ifr->ifr_addr), ifr->ifr_addr.sa_len); 488849218d4fSjbeck # else /* DEC */ 48897c478bd9Sstevel@tonic-gate i += sizeof *ifr; 489049218d4fSjbeck # endif /* DEC */ 48917c478bd9Sstevel@tonic-gate 48927c478bd9Sstevel@tonic-gate if (tTd(0, 20)) 48937c478bd9Sstevel@tonic-gate sm_dprintf("%s\n", anynet_ntoa(sa)); 48947c478bd9Sstevel@tonic-gate 48957c478bd9Sstevel@tonic-gate if (af != AF_INET && af != AF_INET6) 48967c478bd9Sstevel@tonic-gate continue; 48977c478bd9Sstevel@tonic-gate 48987c478bd9Sstevel@tonic-gate # ifdef SIOCGLIFFLAGS 48997c478bd9Sstevel@tonic-gate memset(&ifrf, '\0', sizeof(struct lifreq)); 49007c478bd9Sstevel@tonic-gate (void) sm_strlcpy(ifrf.lifr_name, ifr->lifr_name, 49017c478bd9Sstevel@tonic-gate sizeof(ifrf.lifr_name)); 49027c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGLIFFLAGS, (char *) &ifrf) < 0) 49037c478bd9Sstevel@tonic-gate { 49047c478bd9Sstevel@tonic-gate if (tTd(0, 4)) 49057c478bd9Sstevel@tonic-gate sm_dprintf("SIOCGLIFFLAGS failed: %s\n", 49067c478bd9Sstevel@tonic-gate sm_errstring(errno)); 49077c478bd9Sstevel@tonic-gate continue; 49087c478bd9Sstevel@tonic-gate } 49097c478bd9Sstevel@tonic-gate 49107c478bd9Sstevel@tonic-gate name = ifr->lifr_name; 49117c478bd9Sstevel@tonic-gate flags = ifrf.lifr_flags; 49127c478bd9Sstevel@tonic-gate 49137c478bd9Sstevel@tonic-gate if (tTd(0, 41)) 49147c478bd9Sstevel@tonic-gate sm_dprintf("\tflags: %lx\n", (unsigned long) flags); 49157c478bd9Sstevel@tonic-gate 49167c478bd9Sstevel@tonic-gate if (!bitset(IFF_UP, flags)) 49177c478bd9Sstevel@tonic-gate continue; 49187c478bd9Sstevel@tonic-gate # endif /* SIOCGLIFFLAGS */ 49197c478bd9Sstevel@tonic-gate 49207c478bd9Sstevel@tonic-gate ip_addr[0] = '\0'; 49217c478bd9Sstevel@tonic-gate 49227c478bd9Sstevel@tonic-gate /* extract IP address from the list*/ 49237c478bd9Sstevel@tonic-gate switch (af) 49247c478bd9Sstevel@tonic-gate { 49257c478bd9Sstevel@tonic-gate case AF_INET6: 49267c478bd9Sstevel@tonic-gate # ifdef __KAME__ 49277c478bd9Sstevel@tonic-gate /* convert into proper scoped address */ 49287c478bd9Sstevel@tonic-gate if ((IN6_IS_ADDR_LINKLOCAL(&sa->sin6.sin6_addr) || 49297c478bd9Sstevel@tonic-gate IN6_IS_ADDR_SITELOCAL(&sa->sin6.sin6_addr)) && 49307c478bd9Sstevel@tonic-gate sa->sin6.sin6_scope_id == 0) 49317c478bd9Sstevel@tonic-gate { 49327c478bd9Sstevel@tonic-gate struct in6_addr *ia6p; 49337c478bd9Sstevel@tonic-gate 49347c478bd9Sstevel@tonic-gate ia6p = &sa->sin6.sin6_addr; 49357c478bd9Sstevel@tonic-gate sa->sin6.sin6_scope_id = ntohs(ia6p->s6_addr[3] | 49367c478bd9Sstevel@tonic-gate ((unsigned int)ia6p->s6_addr[2] << 8)); 49377c478bd9Sstevel@tonic-gate ia6p->s6_addr[2] = ia6p->s6_addr[3] = 0; 49387c478bd9Sstevel@tonic-gate } 49397c478bd9Sstevel@tonic-gate # endif /* __KAME__ */ 49407c478bd9Sstevel@tonic-gate ia6 = sa->sin6.sin6_addr; 49417c478bd9Sstevel@tonic-gate if (IN6_IS_ADDR_UNSPECIFIED(&ia6)) 49427c478bd9Sstevel@tonic-gate { 49437c478bd9Sstevel@tonic-gate addr = anynet_ntop(&ia6, buf6, sizeof buf6); 49447c478bd9Sstevel@tonic-gate message("WARNING: interface %s is UP with %s address", 49457c478bd9Sstevel@tonic-gate name, addr == NULL ? "(NULL)" : addr); 49467c478bd9Sstevel@tonic-gate continue; 49477c478bd9Sstevel@tonic-gate } 49487c478bd9Sstevel@tonic-gate 49497c478bd9Sstevel@tonic-gate /* save IP address in text from */ 49507c478bd9Sstevel@tonic-gate addr = anynet_ntop(&ia6, buf6, sizeof buf6); 49517c478bd9Sstevel@tonic-gate if (addr != NULL) 49527c478bd9Sstevel@tonic-gate (void) sm_snprintf(ip_addr, sizeof ip_addr, 49537c478bd9Sstevel@tonic-gate "[%.*s]", 49547c478bd9Sstevel@tonic-gate (int) sizeof ip_addr - 3, 49557c478bd9Sstevel@tonic-gate addr); 49567c478bd9Sstevel@tonic-gate break; 49577c478bd9Sstevel@tonic-gate 49587c478bd9Sstevel@tonic-gate case AF_INET: 49597c478bd9Sstevel@tonic-gate ia = sa->sin.sin_addr; 49607c478bd9Sstevel@tonic-gate if (ia.s_addr == INADDR_ANY || 49617c478bd9Sstevel@tonic-gate ia.s_addr == INADDR_NONE) 49627c478bd9Sstevel@tonic-gate { 49637c478bd9Sstevel@tonic-gate message("WARNING: interface %s is UP with %s address", 49647c478bd9Sstevel@tonic-gate name, inet_ntoa(ia)); 49657c478bd9Sstevel@tonic-gate continue; 49667c478bd9Sstevel@tonic-gate } 49677c478bd9Sstevel@tonic-gate 49687c478bd9Sstevel@tonic-gate /* save IP address in text from */ 49697c478bd9Sstevel@tonic-gate (void) sm_snprintf(ip_addr, sizeof ip_addr, "[%.*s]", 49707c478bd9Sstevel@tonic-gate (int) sizeof ip_addr - 3, inet_ntoa(ia)); 49717c478bd9Sstevel@tonic-gate break; 49727c478bd9Sstevel@tonic-gate } 49737c478bd9Sstevel@tonic-gate 49747c478bd9Sstevel@tonic-gate if (*ip_addr == '\0') 49757c478bd9Sstevel@tonic-gate continue; 49767c478bd9Sstevel@tonic-gate 49777c478bd9Sstevel@tonic-gate if (!wordinclass(ip_addr, 'w')) 49787c478bd9Sstevel@tonic-gate { 49797c478bd9Sstevel@tonic-gate setclass('w', ip_addr); 49807c478bd9Sstevel@tonic-gate if (tTd(0, 4)) 49817c478bd9Sstevel@tonic-gate sm_dprintf("\ta.k.a.: %s\n", ip_addr); 49827c478bd9Sstevel@tonic-gate } 49837c478bd9Sstevel@tonic-gate 49847c478bd9Sstevel@tonic-gate # ifdef SIOCGLIFFLAGS 49857c478bd9Sstevel@tonic-gate /* skip "loopback" interface "lo" */ 49867c478bd9Sstevel@tonic-gate if (DontProbeInterfaces == DPI_SKIPLOOPBACK && 49877c478bd9Sstevel@tonic-gate bitset(IFF_LOOPBACK, flags)) 49887c478bd9Sstevel@tonic-gate continue; 49897c478bd9Sstevel@tonic-gate # endif /* SIOCGLIFFLAGS */ 49907c478bd9Sstevel@tonic-gate (void) add_hostnames(sa); 49917c478bd9Sstevel@tonic-gate } 49927c478bd9Sstevel@tonic-gate sm_free(buf); /* XXX */ 49937c478bd9Sstevel@tonic-gate (void) close(s); 49947c478bd9Sstevel@tonic-gate # else /* NETINET6 && defined(SIOCGLIFCONF) */ 49957c478bd9Sstevel@tonic-gate # if defined(SIOCGIFCONF) && !SIOCGIFCONF_IS_BROKEN 49967c478bd9Sstevel@tonic-gate int s; 49977c478bd9Sstevel@tonic-gate int i; 49987c478bd9Sstevel@tonic-gate struct ifconf ifc; 49997c478bd9Sstevel@tonic-gate int numifs; 50007c478bd9Sstevel@tonic-gate 50017c478bd9Sstevel@tonic-gate s = socket(AF_INET, SOCK_DGRAM, 0); 50027c478bd9Sstevel@tonic-gate if (s == -1) 50037c478bd9Sstevel@tonic-gate return; 50047c478bd9Sstevel@tonic-gate 50057c478bd9Sstevel@tonic-gate /* get the list of known IP address from the kernel */ 50067c478bd9Sstevel@tonic-gate # if defined(SIOCGIFNUM) && !SIOCGIFNUM_IS_BROKEN 50077c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGIFNUM, (char *) &numifs) < 0) 50087c478bd9Sstevel@tonic-gate { 50097c478bd9Sstevel@tonic-gate /* can't get number of interfaces -- fall back */ 50107c478bd9Sstevel@tonic-gate if (tTd(0, 4)) 50117c478bd9Sstevel@tonic-gate sm_dprintf("SIOCGIFNUM failed: %s\n", 50127c478bd9Sstevel@tonic-gate sm_errstring(errno)); 50137c478bd9Sstevel@tonic-gate numifs = -1; 50147c478bd9Sstevel@tonic-gate } 50157c478bd9Sstevel@tonic-gate else if (tTd(0, 42)) 50167c478bd9Sstevel@tonic-gate sm_dprintf("system has %d interfaces\n", numifs); 50177c478bd9Sstevel@tonic-gate if (numifs < 0) 50187c478bd9Sstevel@tonic-gate # endif /* defined(SIOCGIFNUM) && !SIOCGIFNUM_IS_BROKEN */ 50197c478bd9Sstevel@tonic-gate numifs = MAXINTERFACES; 50207c478bd9Sstevel@tonic-gate 50217c478bd9Sstevel@tonic-gate if (numifs <= 0) 50227c478bd9Sstevel@tonic-gate { 50237c478bd9Sstevel@tonic-gate (void) close(s); 50247c478bd9Sstevel@tonic-gate return; 50257c478bd9Sstevel@tonic-gate } 50267c478bd9Sstevel@tonic-gate ifc.ifc_len = numifs * sizeof (struct ifreq); 50277c478bd9Sstevel@tonic-gate ifc.ifc_buf = xalloc(ifc.ifc_len); 50287c478bd9Sstevel@tonic-gate if (ioctl(s, SIOCGIFCONF, (char *)&ifc) < 0) 50297c478bd9Sstevel@tonic-gate { 50307c478bd9Sstevel@tonic-gate if (tTd(0, 4)) 50317c478bd9Sstevel@tonic-gate sm_dprintf("SIOCGIFCONF failed: %s\n", 50327c478bd9Sstevel@tonic-gate sm_errstring(errno)); 50337c478bd9Sstevel@tonic-gate (void) close(s); 50347c478bd9Sstevel@tonic-gate return; 50357c478bd9Sstevel@tonic-gate } 50367c478bd9Sstevel@tonic-gate 50377c478bd9Sstevel@tonic-gate /* scan the list of IP address */ 50387c478bd9Sstevel@tonic-gate if (tTd(0, 40)) 50397c478bd9Sstevel@tonic-gate sm_dprintf("scanning for interface specific names, ifc_len=%d\n", 50407c478bd9Sstevel@tonic-gate ifc.ifc_len); 50417c478bd9Sstevel@tonic-gate 50427c478bd9Sstevel@tonic-gate for (i = 0; i < ifc.ifc_len && i >= 0; ) 50437c478bd9Sstevel@tonic-gate { 50447c478bd9Sstevel@tonic-gate int af; 50457c478bd9Sstevel@tonic-gate struct ifreq *ifr = (struct ifreq *) &ifc.ifc_buf[i]; 50467c478bd9Sstevel@tonic-gate SOCKADDR *sa = (SOCKADDR *) &ifr->ifr_addr; 50477c478bd9Sstevel@tonic-gate # if NETINET6 50487c478bd9Sstevel@tonic-gate char *addr; 50497c478bd9Sstevel@tonic-gate struct in6_addr ia6; 50507c478bd9Sstevel@tonic-gate # endif /* NETINET6 */ 50517c478bd9Sstevel@tonic-gate struct in_addr ia; 50527c478bd9Sstevel@tonic-gate # ifdef SIOCGIFFLAGS 50537c478bd9Sstevel@tonic-gate struct ifreq ifrf; 50547c478bd9Sstevel@tonic-gate # endif /* SIOCGIFFLAGS */ 50557c478bd9Sstevel@tonic-gate char ip_addr[256]; 50567c478bd9Sstevel@tonic-gate # if NETINET6 50577c478bd9Sstevel@tonic-gate char buf6[INET6_ADDRSTRLEN]; 50587c478bd9Sstevel@tonic-gate # endif /* NETINET6 */ 50597c478bd9Sstevel@tonic-gate 50607c478bd9Sstevel@tonic-gate /* 50617c478bd9Sstevel@tonic-gate ** If we don't have a complete ifr structure, 50627c478bd9Sstevel@tonic-gate ** don't try to use it. 50637c478bd9Sstevel@tonic-gate */ 50647c478bd9Sstevel@tonic-gate 50657c478bd9Sstevel@tonic-gate if ((ifc.ifc_len - i) < sizeof *ifr) 50667c478bd9Sstevel@tonic-gate break; 50677c478bd9Sstevel@tonic-gate 50687c478bd9Sstevel@tonic-gate # ifdef BSD4_4_SOCKADDR 50697c478bd9Sstevel@tonic-gate if (sa->sa.sa_len > sizeof ifr->ifr_addr) 50707c478bd9Sstevel@tonic-gate i += sizeof ifr->ifr_name + sa->sa.sa_len; 50717c478bd9Sstevel@tonic-gate else 50727c478bd9Sstevel@tonic-gate # endif /* BSD4_4_SOCKADDR */ 50737c478bd9Sstevel@tonic-gate i += sizeof *ifr; 50747c478bd9Sstevel@tonic-gate 50757c478bd9Sstevel@tonic-gate if (tTd(0, 20)) 50767c478bd9Sstevel@tonic-gate sm_dprintf("%s\n", anynet_ntoa(sa)); 50777c478bd9Sstevel@tonic-gate 50787c478bd9Sstevel@tonic-gate af = ifr->ifr_addr.sa_family; 50797c478bd9Sstevel@tonic-gate if (af != AF_INET 50807c478bd9Sstevel@tonic-gate # if NETINET6 50817c478bd9Sstevel@tonic-gate && af != AF_INET6 50827c478bd9Sstevel@tonic-gate # endif /* NETINET6 */ 50837c478bd9Sstevel@tonic-gate ) 50847c478bd9Sstevel@tonic-gate continue; 50857c478bd9Sstevel@tonic-gate 50867c478bd9Sstevel@tonic-gate # ifdef SIOCGIFFLAGS 50877c478bd9Sstevel@tonic-gate memset(&ifrf, '\0', sizeof(struct ifreq)); 50887c478bd9Sstevel@tonic-gate (void) sm_strlcpy(ifrf.ifr_name, ifr->ifr_name, 50897c478bd9Sstevel@tonic-gate sizeof(ifrf.ifr_name)); 50907c478bd9Sstevel@tonic-gate (void) ioctl(s, SIOCGIFFLAGS, (char *) &ifrf); 50917c478bd9Sstevel@tonic-gate if (tTd(0, 41)) 50927c478bd9Sstevel@tonic-gate sm_dprintf("\tflags: %lx\n", 50937c478bd9Sstevel@tonic-gate (unsigned long) ifrf.ifr_flags); 50947c478bd9Sstevel@tonic-gate # define IFRFREF ifrf 50957c478bd9Sstevel@tonic-gate # else /* SIOCGIFFLAGS */ 50967c478bd9Sstevel@tonic-gate # define IFRFREF (*ifr) 50977c478bd9Sstevel@tonic-gate # endif /* SIOCGIFFLAGS */ 50987c478bd9Sstevel@tonic-gate 50997c478bd9Sstevel@tonic-gate if (!bitset(IFF_UP, IFRFREF.ifr_flags)) 51007c478bd9Sstevel@tonic-gate continue; 51017c478bd9Sstevel@tonic-gate 51027c478bd9Sstevel@tonic-gate ip_addr[0] = '\0'; 51037c478bd9Sstevel@tonic-gate 51047c478bd9Sstevel@tonic-gate /* extract IP address from the list*/ 51057c478bd9Sstevel@tonic-gate switch (af) 51067c478bd9Sstevel@tonic-gate { 51077c478bd9Sstevel@tonic-gate case AF_INET: 51087c478bd9Sstevel@tonic-gate ia = sa->sin.sin_addr; 51097c478bd9Sstevel@tonic-gate if (ia.s_addr == INADDR_ANY || 51107c478bd9Sstevel@tonic-gate ia.s_addr == INADDR_NONE) 51117c478bd9Sstevel@tonic-gate { 51127c478bd9Sstevel@tonic-gate message("WARNING: interface %s is UP with %s address", 51137c478bd9Sstevel@tonic-gate ifr->ifr_name, inet_ntoa(ia)); 51147c478bd9Sstevel@tonic-gate continue; 51157c478bd9Sstevel@tonic-gate } 51167c478bd9Sstevel@tonic-gate 51177c478bd9Sstevel@tonic-gate /* save IP address in text from */ 51187c478bd9Sstevel@tonic-gate (void) sm_snprintf(ip_addr, sizeof ip_addr, "[%.*s]", 51197c478bd9Sstevel@tonic-gate (int) sizeof ip_addr - 3, 51207c478bd9Sstevel@tonic-gate inet_ntoa(ia)); 51217c478bd9Sstevel@tonic-gate break; 51227c478bd9Sstevel@tonic-gate 51237c478bd9Sstevel@tonic-gate # if NETINET6 51247c478bd9Sstevel@tonic-gate case AF_INET6: 51257c478bd9Sstevel@tonic-gate # ifdef __KAME__ 51267c478bd9Sstevel@tonic-gate /* convert into proper scoped address */ 51277c478bd9Sstevel@tonic-gate if ((IN6_IS_ADDR_LINKLOCAL(&sa->sin6.sin6_addr) || 51287c478bd9Sstevel@tonic-gate IN6_IS_ADDR_SITELOCAL(&sa->sin6.sin6_addr)) && 51297c478bd9Sstevel@tonic-gate sa->sin6.sin6_scope_id == 0) 51307c478bd9Sstevel@tonic-gate { 51317c478bd9Sstevel@tonic-gate struct in6_addr *ia6p; 51327c478bd9Sstevel@tonic-gate 51337c478bd9Sstevel@tonic-gate ia6p = &sa->sin6.sin6_addr; 51347c478bd9Sstevel@tonic-gate sa->sin6.sin6_scope_id = ntohs(ia6p->s6_addr[3] | 51357c478bd9Sstevel@tonic-gate ((unsigned int)ia6p->s6_addr[2] << 8)); 51367c478bd9Sstevel@tonic-gate ia6p->s6_addr[2] = ia6p->s6_addr[3] = 0; 51377c478bd9Sstevel@tonic-gate } 51387c478bd9Sstevel@tonic-gate # endif /* __KAME__ */ 51397c478bd9Sstevel@tonic-gate ia6 = sa->sin6.sin6_addr; 51407c478bd9Sstevel@tonic-gate if (IN6_IS_ADDR_UNSPECIFIED(&ia6)) 51417c478bd9Sstevel@tonic-gate { 51427c478bd9Sstevel@tonic-gate addr = anynet_ntop(&ia6, buf6, sizeof buf6); 51437c478bd9Sstevel@tonic-gate message("WARNING: interface %s is UP with %s address", 51447c478bd9Sstevel@tonic-gate ifr->ifr_name, 51457c478bd9Sstevel@tonic-gate addr == NULL ? "(NULL)" : addr); 51467c478bd9Sstevel@tonic-gate continue; 51477c478bd9Sstevel@tonic-gate } 51487c478bd9Sstevel@tonic-gate 51497c478bd9Sstevel@tonic-gate /* save IP address in text from */ 51507c478bd9Sstevel@tonic-gate addr = anynet_ntop(&ia6, buf6, sizeof buf6); 51517c478bd9Sstevel@tonic-gate if (addr != NULL) 51527c478bd9Sstevel@tonic-gate (void) sm_snprintf(ip_addr, sizeof ip_addr, 51537c478bd9Sstevel@tonic-gate "[%.*s]", 51547c478bd9Sstevel@tonic-gate (int) sizeof ip_addr - 3, 51557c478bd9Sstevel@tonic-gate addr); 51567c478bd9Sstevel@tonic-gate break; 51577c478bd9Sstevel@tonic-gate 51587c478bd9Sstevel@tonic-gate # endif /* NETINET6 */ 51597c478bd9Sstevel@tonic-gate } 51607c478bd9Sstevel@tonic-gate 51617c478bd9Sstevel@tonic-gate if (ip_addr[0] == '\0') 51627c478bd9Sstevel@tonic-gate continue; 51637c478bd9Sstevel@tonic-gate 51647c478bd9Sstevel@tonic-gate if (!wordinclass(ip_addr, 'w')) 51657c478bd9Sstevel@tonic-gate { 51667c478bd9Sstevel@tonic-gate setclass('w', ip_addr); 51677c478bd9Sstevel@tonic-gate if (tTd(0, 4)) 51687c478bd9Sstevel@tonic-gate sm_dprintf("\ta.k.a.: %s\n", ip_addr); 51697c478bd9Sstevel@tonic-gate } 51707c478bd9Sstevel@tonic-gate 51717c478bd9Sstevel@tonic-gate /* skip "loopback" interface "lo" */ 51727c478bd9Sstevel@tonic-gate if (DontProbeInterfaces == DPI_SKIPLOOPBACK && 51737c478bd9Sstevel@tonic-gate bitset(IFF_LOOPBACK, IFRFREF.ifr_flags)) 51747c478bd9Sstevel@tonic-gate continue; 51757c478bd9Sstevel@tonic-gate 51767c478bd9Sstevel@tonic-gate (void) add_hostnames(sa); 51777c478bd9Sstevel@tonic-gate } 51787c478bd9Sstevel@tonic-gate sm_free(ifc.ifc_buf); /* XXX */ 51797c478bd9Sstevel@tonic-gate (void) close(s); 51807c478bd9Sstevel@tonic-gate # undef IFRFREF 51817c478bd9Sstevel@tonic-gate # endif /* defined(SIOCGIFCONF) && !SIOCGIFCONF_IS_BROKEN */ 51827c478bd9Sstevel@tonic-gate # endif /* NETINET6 && defined(SIOCGLIFCONF) */ 51837c478bd9Sstevel@tonic-gate } 51847c478bd9Sstevel@tonic-gate /* 51857c478bd9Sstevel@tonic-gate ** ISLOOPBACK -- is socket address in the loopback net? 51867c478bd9Sstevel@tonic-gate ** 51877c478bd9Sstevel@tonic-gate ** Parameters: 51887c478bd9Sstevel@tonic-gate ** sa -- socket address. 51897c478bd9Sstevel@tonic-gate ** 51907c478bd9Sstevel@tonic-gate ** Returns: 51917c478bd9Sstevel@tonic-gate ** true -- is socket address in the loopback net? 51927c478bd9Sstevel@tonic-gate ** false -- otherwise 51937c478bd9Sstevel@tonic-gate ** 51947c478bd9Sstevel@tonic-gate */ 51957c478bd9Sstevel@tonic-gate 51967c478bd9Sstevel@tonic-gate bool 51977c478bd9Sstevel@tonic-gate isloopback(sa) 51987c478bd9Sstevel@tonic-gate SOCKADDR sa; 51997c478bd9Sstevel@tonic-gate { 52007c478bd9Sstevel@tonic-gate #if NETINET6 52017c478bd9Sstevel@tonic-gate if (IN6_IS_ADDR_LOOPBACK(&sa.sin6.sin6_addr)) 52027c478bd9Sstevel@tonic-gate return true; 52037c478bd9Sstevel@tonic-gate #else /* NETINET6 */ 52047c478bd9Sstevel@tonic-gate /* XXX how to correctly extract IN_LOOPBACKNET part? */ 52057c478bd9Sstevel@tonic-gate if (((ntohl(sa.sin.sin_addr.s_addr) & IN_CLASSA_NET) 52067c478bd9Sstevel@tonic-gate >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) 52077c478bd9Sstevel@tonic-gate return true; 52087c478bd9Sstevel@tonic-gate #endif /* NETINET6 */ 52097c478bd9Sstevel@tonic-gate return false; 52107c478bd9Sstevel@tonic-gate } 52117c478bd9Sstevel@tonic-gate /* 52127c478bd9Sstevel@tonic-gate ** GET_NUM_PROCS_ONLINE -- return the number of processors currently online 52137c478bd9Sstevel@tonic-gate ** 52147c478bd9Sstevel@tonic-gate ** Parameters: 52157c478bd9Sstevel@tonic-gate ** none. 52167c478bd9Sstevel@tonic-gate ** 52177c478bd9Sstevel@tonic-gate ** Returns: 52187c478bd9Sstevel@tonic-gate ** The number of processors online. 52197c478bd9Sstevel@tonic-gate */ 52207c478bd9Sstevel@tonic-gate 52217c478bd9Sstevel@tonic-gate static int 52227c478bd9Sstevel@tonic-gate get_num_procs_online() 52237c478bd9Sstevel@tonic-gate { 52247c478bd9Sstevel@tonic-gate int nproc = 0; 52257c478bd9Sstevel@tonic-gate 52267c478bd9Sstevel@tonic-gate #ifdef USESYSCTL 52277c478bd9Sstevel@tonic-gate # if defined(CTL_HW) && defined(HW_NCPU) 52287c478bd9Sstevel@tonic-gate size_t sz; 52297c478bd9Sstevel@tonic-gate int mib[2]; 52307c478bd9Sstevel@tonic-gate 52317c478bd9Sstevel@tonic-gate mib[0] = CTL_HW; 52327c478bd9Sstevel@tonic-gate mib[1] = HW_NCPU; 52337c478bd9Sstevel@tonic-gate sz = (size_t) sizeof nproc; 52347c478bd9Sstevel@tonic-gate (void) sysctl(mib, 2, &nproc, &sz, NULL, 0); 52357c478bd9Sstevel@tonic-gate # endif /* defined(CTL_HW) && defined(HW_NCPU) */ 52367c478bd9Sstevel@tonic-gate #else /* USESYSCTL */ 52377c478bd9Sstevel@tonic-gate # ifdef _SC_NPROCESSORS_ONLN 52387c478bd9Sstevel@tonic-gate nproc = (int) sysconf(_SC_NPROCESSORS_ONLN); 52397c478bd9Sstevel@tonic-gate # else /* _SC_NPROCESSORS_ONLN */ 52407c478bd9Sstevel@tonic-gate # ifdef __hpux 52417c478bd9Sstevel@tonic-gate # include <sys/pstat.h> 52427c478bd9Sstevel@tonic-gate struct pst_dynamic psd; 52437c478bd9Sstevel@tonic-gate 52447c478bd9Sstevel@tonic-gate if (pstat_getdynamic(&psd, sizeof(psd), (size_t)1, 0) != -1) 52457c478bd9Sstevel@tonic-gate nproc = psd.psd_proc_cnt; 52467c478bd9Sstevel@tonic-gate # endif /* __hpux */ 52477c478bd9Sstevel@tonic-gate # endif /* _SC_NPROCESSORS_ONLN */ 52487c478bd9Sstevel@tonic-gate #endif /* USESYSCTL */ 52497c478bd9Sstevel@tonic-gate 52507c478bd9Sstevel@tonic-gate if (nproc <= 0) 52517c478bd9Sstevel@tonic-gate nproc = 1; 52527c478bd9Sstevel@tonic-gate return nproc; 52537c478bd9Sstevel@tonic-gate } 52547c478bd9Sstevel@tonic-gate /* 52557c478bd9Sstevel@tonic-gate ** SM_CLOSEFROM -- close file descriptors 52567c478bd9Sstevel@tonic-gate ** 52577c478bd9Sstevel@tonic-gate ** Parameters: 52587c478bd9Sstevel@tonic-gate ** lowest -- first fd to close 52597c478bd9Sstevel@tonic-gate ** highest -- last fd + 1 to close 52607c478bd9Sstevel@tonic-gate ** 52617c478bd9Sstevel@tonic-gate ** Returns: 52627c478bd9Sstevel@tonic-gate ** none 52637c478bd9Sstevel@tonic-gate */ 52647c478bd9Sstevel@tonic-gate 52657c478bd9Sstevel@tonic-gate void 52667c478bd9Sstevel@tonic-gate sm_closefrom(lowest, highest) 52677c478bd9Sstevel@tonic-gate int lowest, highest; 52687c478bd9Sstevel@tonic-gate { 52697c478bd9Sstevel@tonic-gate #if HASCLOSEFROM 52707c478bd9Sstevel@tonic-gate closefrom(lowest); 52717c478bd9Sstevel@tonic-gate #else /* HASCLOSEFROM */ 52727c478bd9Sstevel@tonic-gate int i; 52737c478bd9Sstevel@tonic-gate 52747c478bd9Sstevel@tonic-gate for (i = lowest; i < highest; i++) 52757c478bd9Sstevel@tonic-gate (void) close(i); 52767c478bd9Sstevel@tonic-gate #endif /* HASCLOSEFROM */ 52777c478bd9Sstevel@tonic-gate } 52787c478bd9Sstevel@tonic-gate #if HASFDWALK 52797c478bd9Sstevel@tonic-gate /* 52807c478bd9Sstevel@tonic-gate ** CLOSEFD_WALK -- walk fd's arranging to close them 52817c478bd9Sstevel@tonic-gate ** Callback for fdwalk() 52827c478bd9Sstevel@tonic-gate ** 52837c478bd9Sstevel@tonic-gate ** Parameters: 52847c478bd9Sstevel@tonic-gate ** lowest -- first fd to arrange to be closed 52857c478bd9Sstevel@tonic-gate ** fd -- fd to arrange to be closed 52867c478bd9Sstevel@tonic-gate ** 52877c478bd9Sstevel@tonic-gate ** Returns: 52887c478bd9Sstevel@tonic-gate ** zero 52897c478bd9Sstevel@tonic-gate */ 52907c478bd9Sstevel@tonic-gate 52917c478bd9Sstevel@tonic-gate static int 52927c478bd9Sstevel@tonic-gate closefd_walk(lowest, fd) 52937c478bd9Sstevel@tonic-gate void *lowest; 52947c478bd9Sstevel@tonic-gate int fd; 52957c478bd9Sstevel@tonic-gate { 52967c478bd9Sstevel@tonic-gate if (fd >= *(int *)lowest) 52977c478bd9Sstevel@tonic-gate (void) fcntl(fd, F_SETFD, FD_CLOEXEC); 52987c478bd9Sstevel@tonic-gate return 0; 52997c478bd9Sstevel@tonic-gate } 53007c478bd9Sstevel@tonic-gate #endif /* HASFDWALK */ 53017c478bd9Sstevel@tonic-gate /* 53027c478bd9Sstevel@tonic-gate ** SM_CLOSE_ON_EXEC -- arrange for file descriptors to be closed 53037c478bd9Sstevel@tonic-gate ** 53047c478bd9Sstevel@tonic-gate ** Parameters: 53057c478bd9Sstevel@tonic-gate ** lowest -- first fd to arrange to be closed 53067c478bd9Sstevel@tonic-gate ** highest -- last fd + 1 to arrange to be closed 53077c478bd9Sstevel@tonic-gate ** 53087c478bd9Sstevel@tonic-gate ** Returns: 53097c478bd9Sstevel@tonic-gate ** none 53107c478bd9Sstevel@tonic-gate */ 53117c478bd9Sstevel@tonic-gate 53127c478bd9Sstevel@tonic-gate void 53137c478bd9Sstevel@tonic-gate sm_close_on_exec(highest, lowest) 53147c478bd9Sstevel@tonic-gate int highest, lowest; 53157c478bd9Sstevel@tonic-gate { 53167c478bd9Sstevel@tonic-gate #if HASFDWALK 53177c478bd9Sstevel@tonic-gate (void) fdwalk(closefd_walk, &lowest); 53187c478bd9Sstevel@tonic-gate #else /* HASFDWALK */ 53197c478bd9Sstevel@tonic-gate int i, j; 53207c478bd9Sstevel@tonic-gate 53217c478bd9Sstevel@tonic-gate for (i = lowest; i < highest; i++) 53227c478bd9Sstevel@tonic-gate { 53237c478bd9Sstevel@tonic-gate if ((j = fcntl(i, F_GETFD, 0)) != -1) 53247c478bd9Sstevel@tonic-gate (void) fcntl(i, F_SETFD, j | FD_CLOEXEC); 53257c478bd9Sstevel@tonic-gate } 53267c478bd9Sstevel@tonic-gate #endif /* HASFDWALK */ 53277c478bd9Sstevel@tonic-gate } 53287c478bd9Sstevel@tonic-gate /* 53297c478bd9Sstevel@tonic-gate ** SEED_RANDOM -- seed the random number generator 53307c478bd9Sstevel@tonic-gate ** 53317c478bd9Sstevel@tonic-gate ** Parameters: 53327c478bd9Sstevel@tonic-gate ** none 53337c478bd9Sstevel@tonic-gate ** 53347c478bd9Sstevel@tonic-gate ** Returns: 53357c478bd9Sstevel@tonic-gate ** none 53367c478bd9Sstevel@tonic-gate */ 53377c478bd9Sstevel@tonic-gate 53387c478bd9Sstevel@tonic-gate void 53397c478bd9Sstevel@tonic-gate seed_random() 53407c478bd9Sstevel@tonic-gate { 53417c478bd9Sstevel@tonic-gate #if HASSRANDOMDEV 53427c478bd9Sstevel@tonic-gate srandomdev(); 53437c478bd9Sstevel@tonic-gate #else /* HASSRANDOMDEV */ 53447c478bd9Sstevel@tonic-gate long seed; 53457c478bd9Sstevel@tonic-gate struct timeval t; 53467c478bd9Sstevel@tonic-gate 53477c478bd9Sstevel@tonic-gate seed = (long) CurrentPid; 53487c478bd9Sstevel@tonic-gate if (gettimeofday(&t, NULL) >= 0) 53497c478bd9Sstevel@tonic-gate seed += t.tv_sec + t.tv_usec; 53507c478bd9Sstevel@tonic-gate 53517c478bd9Sstevel@tonic-gate # if HASRANDOM 53527c478bd9Sstevel@tonic-gate (void) srandom(seed); 53537c478bd9Sstevel@tonic-gate # else /* HASRANDOM */ 53547c478bd9Sstevel@tonic-gate (void) srand((unsigned int) seed); 53557c478bd9Sstevel@tonic-gate # endif /* HASRANDOM */ 53567c478bd9Sstevel@tonic-gate #endif /* HASSRANDOMDEV */ 53577c478bd9Sstevel@tonic-gate } 53587c478bd9Sstevel@tonic-gate /* 53597c478bd9Sstevel@tonic-gate ** SM_SYSLOG -- syslog wrapper to keep messages under SYSLOG_BUFSIZE 53607c478bd9Sstevel@tonic-gate ** 53617c478bd9Sstevel@tonic-gate ** Parameters: 53627c478bd9Sstevel@tonic-gate ** level -- syslog level 53637c478bd9Sstevel@tonic-gate ** id -- envelope ID or NULL (NOQUEUE) 53647c478bd9Sstevel@tonic-gate ** fmt -- format string 53657c478bd9Sstevel@tonic-gate ** arg... -- arguments as implied by fmt. 53667c478bd9Sstevel@tonic-gate ** 53677c478bd9Sstevel@tonic-gate ** Returns: 53687c478bd9Sstevel@tonic-gate ** none 53697c478bd9Sstevel@tonic-gate */ 53707c478bd9Sstevel@tonic-gate 53717c478bd9Sstevel@tonic-gate /* VARARGS3 */ 53727c478bd9Sstevel@tonic-gate void 53737c478bd9Sstevel@tonic-gate #ifdef __STDC__ 53747c478bd9Sstevel@tonic-gate sm_syslog(int level, const char *id, const char *fmt, ...) 53757c478bd9Sstevel@tonic-gate #else /* __STDC__ */ 53767c478bd9Sstevel@tonic-gate sm_syslog(level, id, fmt, va_alist) 53777c478bd9Sstevel@tonic-gate int level; 53787c478bd9Sstevel@tonic-gate const char *id; 53797c478bd9Sstevel@tonic-gate const char *fmt; 53807c478bd9Sstevel@tonic-gate va_dcl 53817c478bd9Sstevel@tonic-gate #endif /* __STDC__ */ 53827c478bd9Sstevel@tonic-gate { 5383*445f2479Sjbeck char *buf; 5384*445f2479Sjbeck size_t bufsize; 53857c478bd9Sstevel@tonic-gate char *begin, *end; 53867c478bd9Sstevel@tonic-gate int save_errno; 53877c478bd9Sstevel@tonic-gate int seq = 1; 53887c478bd9Sstevel@tonic-gate int idlen; 53897c478bd9Sstevel@tonic-gate char buf0[MAXLINE]; 53907c478bd9Sstevel@tonic-gate char *newstring; 53917c478bd9Sstevel@tonic-gate extern int SyslogPrefixLen; 53927c478bd9Sstevel@tonic-gate SM_VA_LOCAL_DECL 53937c478bd9Sstevel@tonic-gate 53947c478bd9Sstevel@tonic-gate save_errno = errno; 53957c478bd9Sstevel@tonic-gate if (id == NULL) 53967c478bd9Sstevel@tonic-gate { 53977c478bd9Sstevel@tonic-gate id = "NOQUEUE"; 53987c478bd9Sstevel@tonic-gate idlen = strlen(id) + SyslogPrefixLen; 53997c478bd9Sstevel@tonic-gate } 54007c478bd9Sstevel@tonic-gate else if (strcmp(id, NOQID) == 0) 54017c478bd9Sstevel@tonic-gate { 54027c478bd9Sstevel@tonic-gate id = ""; 54037c478bd9Sstevel@tonic-gate idlen = SyslogPrefixLen; 54047c478bd9Sstevel@tonic-gate } 54057c478bd9Sstevel@tonic-gate else 54067c478bd9Sstevel@tonic-gate idlen = strlen(id) + SyslogPrefixLen; 54077c478bd9Sstevel@tonic-gate 5408*445f2479Sjbeck buf = buf0; 5409*445f2479Sjbeck bufsize = sizeof buf0; 54107c478bd9Sstevel@tonic-gate 54117c478bd9Sstevel@tonic-gate for (;;) 54127c478bd9Sstevel@tonic-gate { 54137c478bd9Sstevel@tonic-gate int n; 54147c478bd9Sstevel@tonic-gate 54157c478bd9Sstevel@tonic-gate /* print log message into buf */ 54167c478bd9Sstevel@tonic-gate SM_VA_START(ap, fmt); 54177c478bd9Sstevel@tonic-gate n = sm_vsnprintf(buf, bufsize, fmt, ap); 54187c478bd9Sstevel@tonic-gate SM_VA_END(ap); 54197c478bd9Sstevel@tonic-gate SM_ASSERT(n > 0); 54207c478bd9Sstevel@tonic-gate if (n < bufsize) 54217c478bd9Sstevel@tonic-gate break; 54227c478bd9Sstevel@tonic-gate 54237c478bd9Sstevel@tonic-gate /* String too small, redo with correct size */ 54247c478bd9Sstevel@tonic-gate bufsize = n + 1; 54257c478bd9Sstevel@tonic-gate if (buf != buf0) 54267c478bd9Sstevel@tonic-gate { 54277c478bd9Sstevel@tonic-gate sm_free(buf); 54287c478bd9Sstevel@tonic-gate buf = NULL; 54297c478bd9Sstevel@tonic-gate } 54307c478bd9Sstevel@tonic-gate buf = sm_malloc_x(bufsize); 54317c478bd9Sstevel@tonic-gate } 54327c478bd9Sstevel@tonic-gate 54337c478bd9Sstevel@tonic-gate /* clean up buf after it has been expanded with args */ 54347c478bd9Sstevel@tonic-gate newstring = str2prt(buf); 54357c478bd9Sstevel@tonic-gate if ((strlen(newstring) + idlen + 1) < SYSLOG_BUFSIZE) 54367c478bd9Sstevel@tonic-gate { 54377c478bd9Sstevel@tonic-gate #if LOG 54387c478bd9Sstevel@tonic-gate if (*id == '\0') 54397c478bd9Sstevel@tonic-gate syslog(level, "%s", newstring); 54407c478bd9Sstevel@tonic-gate else 54417c478bd9Sstevel@tonic-gate syslog(level, "%s: %s", id, newstring); 54427c478bd9Sstevel@tonic-gate #else /* LOG */ 54437c478bd9Sstevel@tonic-gate /*XXX should do something more sensible */ 54447c478bd9Sstevel@tonic-gate if (*id == '\0') 54457c478bd9Sstevel@tonic-gate (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT, "%s\n", 54467c478bd9Sstevel@tonic-gate newstring); 54477c478bd9Sstevel@tonic-gate else 54487c478bd9Sstevel@tonic-gate (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT, 54497c478bd9Sstevel@tonic-gate "%s: %s\n", id, newstring); 54507c478bd9Sstevel@tonic-gate #endif /* LOG */ 5451*445f2479Sjbeck if (buf != buf0) 5452*445f2479Sjbeck sm_free(buf); 54537c478bd9Sstevel@tonic-gate errno = save_errno; 54547c478bd9Sstevel@tonic-gate return; 54557c478bd9Sstevel@tonic-gate } 54567c478bd9Sstevel@tonic-gate 54577c478bd9Sstevel@tonic-gate /* 54587c478bd9Sstevel@tonic-gate ** additional length for splitting: " ..." + 3, where 3 is magic to 54597c478bd9Sstevel@tonic-gate ** have some data for the next entry. 54607c478bd9Sstevel@tonic-gate */ 54617c478bd9Sstevel@tonic-gate 54627c478bd9Sstevel@tonic-gate #define SL_SPLIT 7 54637c478bd9Sstevel@tonic-gate 54647c478bd9Sstevel@tonic-gate begin = newstring; 54657c478bd9Sstevel@tonic-gate idlen += 5; /* strlen("[999]"), see below */ 54667c478bd9Sstevel@tonic-gate while (*begin != '\0' && 54677c478bd9Sstevel@tonic-gate (strlen(begin) + idlen) > SYSLOG_BUFSIZE) 54687c478bd9Sstevel@tonic-gate { 54697c478bd9Sstevel@tonic-gate char save; 54707c478bd9Sstevel@tonic-gate 54717c478bd9Sstevel@tonic-gate if (seq >= 999) 54727c478bd9Sstevel@tonic-gate { 54737c478bd9Sstevel@tonic-gate /* Too many messages */ 54747c478bd9Sstevel@tonic-gate break; 54757c478bd9Sstevel@tonic-gate } 54767c478bd9Sstevel@tonic-gate end = begin + SYSLOG_BUFSIZE - idlen - SL_SPLIT; 54777c478bd9Sstevel@tonic-gate while (end > begin) 54787c478bd9Sstevel@tonic-gate { 54797c478bd9Sstevel@tonic-gate /* Break on comma or space */ 54807c478bd9Sstevel@tonic-gate if (*end == ',' || *end == ' ') 54817c478bd9Sstevel@tonic-gate { 54827c478bd9Sstevel@tonic-gate end++; /* Include separator */ 54837c478bd9Sstevel@tonic-gate break; 54847c478bd9Sstevel@tonic-gate } 54857c478bd9Sstevel@tonic-gate end--; 54867c478bd9Sstevel@tonic-gate } 54877c478bd9Sstevel@tonic-gate /* No separator, break midstring... */ 54887c478bd9Sstevel@tonic-gate if (end == begin) 54897c478bd9Sstevel@tonic-gate end = begin + SYSLOG_BUFSIZE - idlen - SL_SPLIT; 54907c478bd9Sstevel@tonic-gate save = *end; 54917c478bd9Sstevel@tonic-gate *end = 0; 54927c478bd9Sstevel@tonic-gate #if LOG 54937c478bd9Sstevel@tonic-gate syslog(level, "%s[%d]: %s ...", id, seq++, begin); 54947c478bd9Sstevel@tonic-gate #else /* LOG */ 54957c478bd9Sstevel@tonic-gate (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT, 54967c478bd9Sstevel@tonic-gate "%s[%d]: %s ...\n", id, seq++, begin); 54977c478bd9Sstevel@tonic-gate #endif /* LOG */ 54987c478bd9Sstevel@tonic-gate *end = save; 54997c478bd9Sstevel@tonic-gate begin = end; 55007c478bd9Sstevel@tonic-gate } 55017c478bd9Sstevel@tonic-gate if (seq >= 999) 55027c478bd9Sstevel@tonic-gate #if LOG 55037c478bd9Sstevel@tonic-gate syslog(level, "%s[%d]: log terminated, too many parts", 55047c478bd9Sstevel@tonic-gate id, seq); 55057c478bd9Sstevel@tonic-gate #else /* LOG */ 55067c478bd9Sstevel@tonic-gate (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT, 55077c478bd9Sstevel@tonic-gate "%s[%d]: log terminated, too many parts\n", id, seq); 55087c478bd9Sstevel@tonic-gate #endif /* LOG */ 55097c478bd9Sstevel@tonic-gate else if (*begin != '\0') 55107c478bd9Sstevel@tonic-gate #if LOG 55117c478bd9Sstevel@tonic-gate syslog(level, "%s[%d]: %s", id, seq, begin); 55127c478bd9Sstevel@tonic-gate #else /* LOG */ 55137c478bd9Sstevel@tonic-gate (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT, 55147c478bd9Sstevel@tonic-gate "%s[%d]: %s\n", id, seq, begin); 55157c478bd9Sstevel@tonic-gate #endif /* LOG */ 5516*445f2479Sjbeck if (buf != buf0) 5517*445f2479Sjbeck sm_free(buf); 55187c478bd9Sstevel@tonic-gate errno = save_errno; 55197c478bd9Sstevel@tonic-gate } 55207c478bd9Sstevel@tonic-gate /* 55217c478bd9Sstevel@tonic-gate ** HARD_SYSLOG -- call syslog repeatedly until it works 55227c478bd9Sstevel@tonic-gate ** 55237c478bd9Sstevel@tonic-gate ** Needed on HP-UX, which apparently doesn't guarantee that 55247c478bd9Sstevel@tonic-gate ** syslog succeeds during interrupt handlers. 55257c478bd9Sstevel@tonic-gate */ 55267c478bd9Sstevel@tonic-gate 55277c478bd9Sstevel@tonic-gate #if defined(__hpux) && !defined(HPUX11) 55287c478bd9Sstevel@tonic-gate 55297c478bd9Sstevel@tonic-gate # define MAXSYSLOGTRIES 100 55307c478bd9Sstevel@tonic-gate # undef syslog 55317c478bd9Sstevel@tonic-gate # ifdef V4FS 55327c478bd9Sstevel@tonic-gate # define XCNST const 55337c478bd9Sstevel@tonic-gate # define CAST (const char *) 55347c478bd9Sstevel@tonic-gate # else /* V4FS */ 55357c478bd9Sstevel@tonic-gate # define XCNST 55367c478bd9Sstevel@tonic-gate # define CAST 55377c478bd9Sstevel@tonic-gate # endif /* V4FS */ 55387c478bd9Sstevel@tonic-gate 55397c478bd9Sstevel@tonic-gate void 55407c478bd9Sstevel@tonic-gate # ifdef __STDC__ 55417c478bd9Sstevel@tonic-gate hard_syslog(int pri, XCNST char *msg, ...) 55427c478bd9Sstevel@tonic-gate # else /* __STDC__ */ 55437c478bd9Sstevel@tonic-gate hard_syslog(pri, msg, va_alist) 55447c478bd9Sstevel@tonic-gate int pri; 55457c478bd9Sstevel@tonic-gate XCNST char *msg; 55467c478bd9Sstevel@tonic-gate va_dcl 55477c478bd9Sstevel@tonic-gate # endif /* __STDC__ */ 55487c478bd9Sstevel@tonic-gate { 55497c478bd9Sstevel@tonic-gate int i; 55507c478bd9Sstevel@tonic-gate char buf[SYSLOG_BUFSIZE]; 55517c478bd9Sstevel@tonic-gate SM_VA_LOCAL_DECL 55527c478bd9Sstevel@tonic-gate 55537c478bd9Sstevel@tonic-gate SM_VA_START(ap, msg); 55547c478bd9Sstevel@tonic-gate (void) sm_vsnprintf(buf, sizeof buf, msg, ap); 55557c478bd9Sstevel@tonic-gate SM_VA_END(ap); 55567c478bd9Sstevel@tonic-gate 55577c478bd9Sstevel@tonic-gate for (i = MAXSYSLOGTRIES; --i >= 0 && syslog(pri, CAST "%s", buf) < 0; ) 55587c478bd9Sstevel@tonic-gate continue; 55597c478bd9Sstevel@tonic-gate } 55607c478bd9Sstevel@tonic-gate 55617c478bd9Sstevel@tonic-gate # undef CAST 55627c478bd9Sstevel@tonic-gate #endif /* defined(__hpux) && !defined(HPUX11) */ 55637c478bd9Sstevel@tonic-gate #if NEEDLOCAL_HOSTNAME_LENGTH 55647c478bd9Sstevel@tonic-gate /* 55657c478bd9Sstevel@tonic-gate ** LOCAL_HOSTNAME_LENGTH 55667c478bd9Sstevel@tonic-gate ** 55677c478bd9Sstevel@tonic-gate ** This is required to get sendmail to compile against BIND 4.9.x 55687c478bd9Sstevel@tonic-gate ** on Ultrix. 55697c478bd9Sstevel@tonic-gate ** 55707c478bd9Sstevel@tonic-gate ** Unfortunately, a Compaq Y2K patch kit provides it without 55717c478bd9Sstevel@tonic-gate ** bumping __RES in /usr/include/resolv.h so we can't automatically 55727c478bd9Sstevel@tonic-gate ** figure out whether it is needed. 55737c478bd9Sstevel@tonic-gate */ 55747c478bd9Sstevel@tonic-gate 55757c478bd9Sstevel@tonic-gate int 55767c478bd9Sstevel@tonic-gate local_hostname_length(hostname) 55777c478bd9Sstevel@tonic-gate char *hostname; 55787c478bd9Sstevel@tonic-gate { 55797c478bd9Sstevel@tonic-gate size_t len_host, len_domain; 55807c478bd9Sstevel@tonic-gate 55817c478bd9Sstevel@tonic-gate if (!*_res.defdname) 55827c478bd9Sstevel@tonic-gate res_init(); 55837c478bd9Sstevel@tonic-gate len_host = strlen(hostname); 55847c478bd9Sstevel@tonic-gate len_domain = strlen(_res.defdname); 55857c478bd9Sstevel@tonic-gate if (len_host > len_domain && 55867c478bd9Sstevel@tonic-gate (sm_strcasecmp(hostname + len_host - len_domain, 55877c478bd9Sstevel@tonic-gate _res.defdname) == 0) && 55887c478bd9Sstevel@tonic-gate hostname[len_host - len_domain - 1] == '.') 55897c478bd9Sstevel@tonic-gate return len_host - len_domain - 1; 55907c478bd9Sstevel@tonic-gate else 55917c478bd9Sstevel@tonic-gate return 0; 55927c478bd9Sstevel@tonic-gate } 55937c478bd9Sstevel@tonic-gate #endif /* NEEDLOCAL_HOSTNAME_LENGTH */ 55947c478bd9Sstevel@tonic-gate 55957c478bd9Sstevel@tonic-gate #if NEEDLINK 55967c478bd9Sstevel@tonic-gate /* 55977c478bd9Sstevel@tonic-gate ** LINK -- clone a file 55987c478bd9Sstevel@tonic-gate ** 55997c478bd9Sstevel@tonic-gate ** Some OS's lacks link() and hard links. Since sendmail is using 56007c478bd9Sstevel@tonic-gate ** link() as an efficient way to clone files, this implementation 56017c478bd9Sstevel@tonic-gate ** will simply do a file copy. 56027c478bd9Sstevel@tonic-gate ** 56037c478bd9Sstevel@tonic-gate ** NOTE: This link() replacement is not a generic replacement as it 56047c478bd9Sstevel@tonic-gate ** does not handle all of the semantics of the real link(2). 56057c478bd9Sstevel@tonic-gate ** 56067c478bd9Sstevel@tonic-gate ** Parameters: 56077c478bd9Sstevel@tonic-gate ** source -- pathname of existing file. 56087c478bd9Sstevel@tonic-gate ** target -- pathname of link (clone) to be created. 56097c478bd9Sstevel@tonic-gate ** 56107c478bd9Sstevel@tonic-gate ** Returns: 56117c478bd9Sstevel@tonic-gate ** 0 -- success. 56127c478bd9Sstevel@tonic-gate ** -1 -- failure, see errno for details. 56137c478bd9Sstevel@tonic-gate */ 56147c478bd9Sstevel@tonic-gate 56157c478bd9Sstevel@tonic-gate int 56167c478bd9Sstevel@tonic-gate link(source, target) 56177c478bd9Sstevel@tonic-gate const char *source; 56187c478bd9Sstevel@tonic-gate const char *target; 56197c478bd9Sstevel@tonic-gate { 56207c478bd9Sstevel@tonic-gate int save_errno; 56217c478bd9Sstevel@tonic-gate int sff; 56227c478bd9Sstevel@tonic-gate int src = -1, dst = -1; 56237c478bd9Sstevel@tonic-gate ssize_t readlen; 56247c478bd9Sstevel@tonic-gate ssize_t writelen; 56257c478bd9Sstevel@tonic-gate char buf[BUFSIZ]; 56267c478bd9Sstevel@tonic-gate struct stat st; 56277c478bd9Sstevel@tonic-gate 56287c478bd9Sstevel@tonic-gate sff = SFF_REGONLY|SFF_OPENASROOT; 56297c478bd9Sstevel@tonic-gate if (DontLockReadFiles) 56307c478bd9Sstevel@tonic-gate sff |= SFF_NOLOCK; 56317c478bd9Sstevel@tonic-gate 56327c478bd9Sstevel@tonic-gate /* Open the original file */ 56337c478bd9Sstevel@tonic-gate src = safeopen((char *)source, O_RDONLY, 0, sff); 56347c478bd9Sstevel@tonic-gate if (src < 0) 56357c478bd9Sstevel@tonic-gate goto fail; 56367c478bd9Sstevel@tonic-gate 56377c478bd9Sstevel@tonic-gate /* Obtain the size and the mode */ 56387c478bd9Sstevel@tonic-gate if (fstat(src, &st) < 0) 56397c478bd9Sstevel@tonic-gate goto fail; 56407c478bd9Sstevel@tonic-gate 56417c478bd9Sstevel@tonic-gate /* Create the duplicate copy */ 56427c478bd9Sstevel@tonic-gate sff &= ~SFF_NOLOCK; 56437c478bd9Sstevel@tonic-gate sff |= SFF_CREAT; 56447c478bd9Sstevel@tonic-gate dst = safeopen((char *)target, O_CREAT|O_EXCL|O_WRONLY, 56457c478bd9Sstevel@tonic-gate st.st_mode, sff); 56467c478bd9Sstevel@tonic-gate if (dst < 0) 56477c478bd9Sstevel@tonic-gate goto fail; 56487c478bd9Sstevel@tonic-gate 56497c478bd9Sstevel@tonic-gate /* Copy all of the bytes one buffer at a time */ 56507c478bd9Sstevel@tonic-gate while ((readlen = read(src, &buf, sizeof(buf))) > 0) 56517c478bd9Sstevel@tonic-gate { 56527c478bd9Sstevel@tonic-gate ssize_t left = readlen; 56537c478bd9Sstevel@tonic-gate char *p = buf; 56547c478bd9Sstevel@tonic-gate 56557c478bd9Sstevel@tonic-gate while (left > 0 && 56567c478bd9Sstevel@tonic-gate (writelen = write(dst, p, (size_t) left)) >= 0) 56577c478bd9Sstevel@tonic-gate { 56587c478bd9Sstevel@tonic-gate left -= writelen; 56597c478bd9Sstevel@tonic-gate p += writelen; 56607c478bd9Sstevel@tonic-gate } 56617c478bd9Sstevel@tonic-gate if (writelen < 0) 56627c478bd9Sstevel@tonic-gate break; 56637c478bd9Sstevel@tonic-gate } 56647c478bd9Sstevel@tonic-gate 56657c478bd9Sstevel@tonic-gate /* Any trouble reading? */ 56667c478bd9Sstevel@tonic-gate if (readlen < 0 || writelen < 0) 56677c478bd9Sstevel@tonic-gate goto fail; 56687c478bd9Sstevel@tonic-gate 56697c478bd9Sstevel@tonic-gate /* Close the input file */ 56707c478bd9Sstevel@tonic-gate if (close(src) < 0) 56717c478bd9Sstevel@tonic-gate { 56727c478bd9Sstevel@tonic-gate src = -1; 56737c478bd9Sstevel@tonic-gate goto fail; 56747c478bd9Sstevel@tonic-gate } 56757c478bd9Sstevel@tonic-gate src = -1; 56767c478bd9Sstevel@tonic-gate 56777c478bd9Sstevel@tonic-gate /* Close the output file */ 56787c478bd9Sstevel@tonic-gate if (close(dst) < 0) 56797c478bd9Sstevel@tonic-gate { 56807c478bd9Sstevel@tonic-gate /* don't set dst = -1 here so we unlink the file */ 56817c478bd9Sstevel@tonic-gate goto fail; 56827c478bd9Sstevel@tonic-gate } 56837c478bd9Sstevel@tonic-gate 56847c478bd9Sstevel@tonic-gate /* Success */ 56857c478bd9Sstevel@tonic-gate return 0; 56867c478bd9Sstevel@tonic-gate 56877c478bd9Sstevel@tonic-gate fail: 56887c478bd9Sstevel@tonic-gate save_errno = errno; 56897c478bd9Sstevel@tonic-gate if (src >= 0) 56907c478bd9Sstevel@tonic-gate (void) close(src); 56917c478bd9Sstevel@tonic-gate if (dst >= 0) 56927c478bd9Sstevel@tonic-gate { 56937c478bd9Sstevel@tonic-gate (void) unlink(target); 56947c478bd9Sstevel@tonic-gate (void) close(dst); 56957c478bd9Sstevel@tonic-gate } 56967c478bd9Sstevel@tonic-gate errno = save_errno; 56977c478bd9Sstevel@tonic-gate return -1; 56987c478bd9Sstevel@tonic-gate } 56997c478bd9Sstevel@tonic-gate #endif /* NEEDLINK */ 57007c478bd9Sstevel@tonic-gate 57017c478bd9Sstevel@tonic-gate /* 57027c478bd9Sstevel@tonic-gate ** Compile-Time options 57037c478bd9Sstevel@tonic-gate */ 57047c478bd9Sstevel@tonic-gate 57057c478bd9Sstevel@tonic-gate char *CompileOptions[] = 57067c478bd9Sstevel@tonic-gate { 57077c478bd9Sstevel@tonic-gate #if ALLOW_255 57087c478bd9Sstevel@tonic-gate "ALLOW_255", 57097c478bd9Sstevel@tonic-gate #endif /* ALLOW_255 */ 57107c478bd9Sstevel@tonic-gate #if NAMED_BIND 57117c478bd9Sstevel@tonic-gate # if DNSMAP 57127c478bd9Sstevel@tonic-gate "DNSMAP", 57137c478bd9Sstevel@tonic-gate # endif /* DNSMAP */ 57147c478bd9Sstevel@tonic-gate #endif /* NAMED_BIND */ 57157c478bd9Sstevel@tonic-gate #if EGD 57167c478bd9Sstevel@tonic-gate "EGD", 57177c478bd9Sstevel@tonic-gate #endif /* EGD */ 57187c478bd9Sstevel@tonic-gate #if HESIOD 57197c478bd9Sstevel@tonic-gate "HESIOD", 57207c478bd9Sstevel@tonic-gate #endif /* HESIOD */ 57217c478bd9Sstevel@tonic-gate #if HES_GETMAILHOST 57227c478bd9Sstevel@tonic-gate "HES_GETMAILHOST", 57237c478bd9Sstevel@tonic-gate #endif /* HES_GETMAILHOST */ 57247c478bd9Sstevel@tonic-gate #if LDAPMAP 57257c478bd9Sstevel@tonic-gate "LDAPMAP", 57267c478bd9Sstevel@tonic-gate #endif /* LDAPMAP */ 572749218d4fSjbeck #if LDAP_REFERRALS 572849218d4fSjbeck "LDAP_REFERRALS", 572949218d4fSjbeck #endif /* LDAP_REFERRALS */ 57307c478bd9Sstevel@tonic-gate #if LOG 57317c478bd9Sstevel@tonic-gate "LOG", 57327c478bd9Sstevel@tonic-gate #endif /* LOG */ 57337c478bd9Sstevel@tonic-gate #if MAP_NSD 57347c478bd9Sstevel@tonic-gate "MAP_NSD", 57357c478bd9Sstevel@tonic-gate #endif /* MAP_NSD */ 57367c478bd9Sstevel@tonic-gate #if MAP_REGEX 57377c478bd9Sstevel@tonic-gate "MAP_REGEX", 57387c478bd9Sstevel@tonic-gate #endif /* MAP_REGEX */ 57397c478bd9Sstevel@tonic-gate #if MATCHGECOS 57407c478bd9Sstevel@tonic-gate "MATCHGECOS", 57417c478bd9Sstevel@tonic-gate #endif /* MATCHGECOS */ 57427c478bd9Sstevel@tonic-gate #if MILTER 57437c478bd9Sstevel@tonic-gate "MILTER", 57447c478bd9Sstevel@tonic-gate #endif /* MILTER */ 57457c478bd9Sstevel@tonic-gate #if MIME7TO8 57467c478bd9Sstevel@tonic-gate "MIME7TO8", 57477c478bd9Sstevel@tonic-gate #endif /* MIME7TO8 */ 57487c478bd9Sstevel@tonic-gate #if MIME7TO8_OLD 57497c478bd9Sstevel@tonic-gate "MIME7TO8_OLD", 57507c478bd9Sstevel@tonic-gate #endif /* MIME7TO8_OLD */ 57517c478bd9Sstevel@tonic-gate #if MIME8TO7 57527c478bd9Sstevel@tonic-gate "MIME8TO7", 57537c478bd9Sstevel@tonic-gate #endif /* MIME8TO7 */ 57547c478bd9Sstevel@tonic-gate #if NAMED_BIND 57557c478bd9Sstevel@tonic-gate "NAMED_BIND", 57567c478bd9Sstevel@tonic-gate #endif /* NAMED_BIND */ 57577c478bd9Sstevel@tonic-gate #if NDBM 57587c478bd9Sstevel@tonic-gate "NDBM", 57597c478bd9Sstevel@tonic-gate #endif /* NDBM */ 57607c478bd9Sstevel@tonic-gate #if NETINET 57617c478bd9Sstevel@tonic-gate "NETINET", 57627c478bd9Sstevel@tonic-gate #endif /* NETINET */ 57637c478bd9Sstevel@tonic-gate #if NETINET6 57647c478bd9Sstevel@tonic-gate "NETINET6", 57657c478bd9Sstevel@tonic-gate #endif /* NETINET6 */ 57667c478bd9Sstevel@tonic-gate #if NETINFO 57677c478bd9Sstevel@tonic-gate "NETINFO", 57687c478bd9Sstevel@tonic-gate #endif /* NETINFO */ 57697c478bd9Sstevel@tonic-gate #if NETISO 57707c478bd9Sstevel@tonic-gate "NETISO", 57717c478bd9Sstevel@tonic-gate #endif /* NETISO */ 57727c478bd9Sstevel@tonic-gate #if NETNS 57737c478bd9Sstevel@tonic-gate "NETNS", 57747c478bd9Sstevel@tonic-gate #endif /* NETNS */ 57757c478bd9Sstevel@tonic-gate #if NETUNIX 57767c478bd9Sstevel@tonic-gate "NETUNIX", 57777c478bd9Sstevel@tonic-gate #endif /* NETUNIX */ 57787c478bd9Sstevel@tonic-gate #if NETX25 57797c478bd9Sstevel@tonic-gate "NETX25", 57807c478bd9Sstevel@tonic-gate #endif /* NETX25 */ 57817c478bd9Sstevel@tonic-gate #if NEWDB 57827c478bd9Sstevel@tonic-gate "NEWDB", 57837c478bd9Sstevel@tonic-gate #endif /* NEWDB */ 57847c478bd9Sstevel@tonic-gate #if NIS 57857c478bd9Sstevel@tonic-gate "NIS", 57867c478bd9Sstevel@tonic-gate #endif /* NIS */ 57877c478bd9Sstevel@tonic-gate #if NISPLUS 57887c478bd9Sstevel@tonic-gate "NISPLUS", 57897c478bd9Sstevel@tonic-gate #endif /* NISPLUS */ 57907c478bd9Sstevel@tonic-gate #if NO_DH 57917c478bd9Sstevel@tonic-gate "NO_DH", 57927c478bd9Sstevel@tonic-gate #endif /* NO_DH */ 57937c478bd9Sstevel@tonic-gate #if PH_MAP 57947c478bd9Sstevel@tonic-gate "PH_MAP", 57957c478bd9Sstevel@tonic-gate #endif /* PH_MAP */ 57967c478bd9Sstevel@tonic-gate #ifdef PICKY_HELO_CHECK 57977c478bd9Sstevel@tonic-gate "PICKY_HELO_CHECK", 57987c478bd9Sstevel@tonic-gate #endif /* PICKY_HELO_CHECK */ 57997c478bd9Sstevel@tonic-gate #if PIPELINING 58007c478bd9Sstevel@tonic-gate "PIPELINING", 58017c478bd9Sstevel@tonic-gate #endif /* PIPELINING */ 58027c478bd9Sstevel@tonic-gate #if SASL 58037c478bd9Sstevel@tonic-gate # if SASL >= 20000 58047c478bd9Sstevel@tonic-gate "SASLv2", 58057c478bd9Sstevel@tonic-gate # else /* SASL >= 20000 */ 58067c478bd9Sstevel@tonic-gate "SASL", 58077c478bd9Sstevel@tonic-gate # endif /* SASL >= 20000 */ 58087c478bd9Sstevel@tonic-gate #endif /* SASL */ 58097c478bd9Sstevel@tonic-gate #if SCANF 58107c478bd9Sstevel@tonic-gate "SCANF", 58117c478bd9Sstevel@tonic-gate #endif /* SCANF */ 58127c478bd9Sstevel@tonic-gate #if SMTPDEBUG 58137c478bd9Sstevel@tonic-gate "SMTPDEBUG", 58147c478bd9Sstevel@tonic-gate #endif /* SMTPDEBUG */ 58157c478bd9Sstevel@tonic-gate #if SOCKETMAP 58167c478bd9Sstevel@tonic-gate "SOCKETMAP", 58177c478bd9Sstevel@tonic-gate #endif /* SOCKETMAP */ 58187c478bd9Sstevel@tonic-gate #if STARTTLS 58197c478bd9Sstevel@tonic-gate "STARTTLS", 58207c478bd9Sstevel@tonic-gate #endif /* STARTTLS */ 58217c478bd9Sstevel@tonic-gate #if SUID_ROOT_FILES_OK 58227c478bd9Sstevel@tonic-gate "SUID_ROOT_FILES_OK", 58237c478bd9Sstevel@tonic-gate #endif /* SUID_ROOT_FILES_OK */ 58247c478bd9Sstevel@tonic-gate #if TCPWRAPPERS 58257c478bd9Sstevel@tonic-gate "TCPWRAPPERS", 58267c478bd9Sstevel@tonic-gate #endif /* TCPWRAPPERS */ 58277c478bd9Sstevel@tonic-gate #if TLS_NO_RSA 58287c478bd9Sstevel@tonic-gate "TLS_NO_RSA", 58297c478bd9Sstevel@tonic-gate #endif /* TLS_NO_RSA */ 58307c478bd9Sstevel@tonic-gate #if TLS_VRFY_PER_CTX 58317c478bd9Sstevel@tonic-gate "TLS_VRFY_PER_CTX", 58327c478bd9Sstevel@tonic-gate #endif /* TLS_VRFY_PER_CTX */ 58337c478bd9Sstevel@tonic-gate #if USERDB 58347c478bd9Sstevel@tonic-gate "USERDB", 58357c478bd9Sstevel@tonic-gate #endif /* USERDB */ 58367c478bd9Sstevel@tonic-gate #if USE_LDAP_INIT 58377c478bd9Sstevel@tonic-gate "USE_LDAP_INIT", 58387c478bd9Sstevel@tonic-gate #endif /* USE_LDAP_INIT */ 58397c478bd9Sstevel@tonic-gate #if USE_TTYPATH 58407c478bd9Sstevel@tonic-gate "USE_TTYPATH", 58417c478bd9Sstevel@tonic-gate #endif /* USE_TTYPATH */ 58427c478bd9Sstevel@tonic-gate #if XDEBUG 58437c478bd9Sstevel@tonic-gate "XDEBUG", 58447c478bd9Sstevel@tonic-gate #endif /* XDEBUG */ 58457c478bd9Sstevel@tonic-gate #if XLA 58467c478bd9Sstevel@tonic-gate "XLA", 58477c478bd9Sstevel@tonic-gate #endif /* XLA */ 58487c478bd9Sstevel@tonic-gate NULL 58497c478bd9Sstevel@tonic-gate }; 58507c478bd9Sstevel@tonic-gate 58517c478bd9Sstevel@tonic-gate 58527c478bd9Sstevel@tonic-gate /* 58537c478bd9Sstevel@tonic-gate ** OS compile options. 58547c478bd9Sstevel@tonic-gate */ 58557c478bd9Sstevel@tonic-gate 58567c478bd9Sstevel@tonic-gate char *OsCompileOptions[] = 58577c478bd9Sstevel@tonic-gate { 58587c478bd9Sstevel@tonic-gate #if ADDRCONFIG_IS_BROKEN 58597c478bd9Sstevel@tonic-gate "ADDRCONFIG_IS_BROKEN", 58607c478bd9Sstevel@tonic-gate #endif /* ADDRCONFIG_IS_BROKEN */ 58617c478bd9Sstevel@tonic-gate #ifdef AUTO_NETINFO_HOSTS 58627c478bd9Sstevel@tonic-gate "AUTO_NETINFO_HOSTS", 58637c478bd9Sstevel@tonic-gate #endif /* AUTO_NETINFO_HOSTS */ 58647c478bd9Sstevel@tonic-gate #ifdef AUTO_NIS_ALIASES 58657c478bd9Sstevel@tonic-gate "AUTO_NIS_ALIASES", 58667c478bd9Sstevel@tonic-gate #endif /* AUTO_NIS_ALIASES */ 58677c478bd9Sstevel@tonic-gate #if BROKEN_RES_SEARCH 58687c478bd9Sstevel@tonic-gate "BROKEN_RES_SEARCH", 58697c478bd9Sstevel@tonic-gate #endif /* BROKEN_RES_SEARCH */ 58707c478bd9Sstevel@tonic-gate #ifdef BSD4_4_SOCKADDR 58717c478bd9Sstevel@tonic-gate "BSD4_4_SOCKADDR", 58727c478bd9Sstevel@tonic-gate #endif /* BSD4_4_SOCKADDR */ 58737c478bd9Sstevel@tonic-gate #if BOGUS_O_EXCL 58747c478bd9Sstevel@tonic-gate "BOGUS_O_EXCL", 58757c478bd9Sstevel@tonic-gate #endif /* BOGUS_O_EXCL */ 58767c478bd9Sstevel@tonic-gate #if DEC_OSF_BROKEN_GETPWENT 58777c478bd9Sstevel@tonic-gate "DEC_OSF_BROKEN_GETPWENT", 58787c478bd9Sstevel@tonic-gate #endif /* DEC_OSF_BROKEN_GETPWENT */ 58797c478bd9Sstevel@tonic-gate #if FAST_PID_RECYCLE 58807c478bd9Sstevel@tonic-gate "FAST_PID_RECYCLE", 58817c478bd9Sstevel@tonic-gate #endif /* FAST_PID_RECYCLE */ 58827c478bd9Sstevel@tonic-gate #if HASCLOSEFROM 58837c478bd9Sstevel@tonic-gate "HASCLOSEFROM", 58847c478bd9Sstevel@tonic-gate #endif /* HASCLOSEFROM */ 58857c478bd9Sstevel@tonic-gate #if HASFCHOWN 58867c478bd9Sstevel@tonic-gate "HASFCHOWN", 58877c478bd9Sstevel@tonic-gate #endif /* HASFCHOWN */ 58887c478bd9Sstevel@tonic-gate #if HASFCHMOD 58897c478bd9Sstevel@tonic-gate "HASFCHMOD", 58907c478bd9Sstevel@tonic-gate #endif /* HASFCHMOD */ 58917c478bd9Sstevel@tonic-gate #if HASFDWALK 58927c478bd9Sstevel@tonic-gate "HASFDWALK", 58937c478bd9Sstevel@tonic-gate #endif /* HASFDWALK */ 58947c478bd9Sstevel@tonic-gate #if HASFLOCK 58957c478bd9Sstevel@tonic-gate "HASFLOCK", 58967c478bd9Sstevel@tonic-gate #endif /* HASFLOCK */ 58977c478bd9Sstevel@tonic-gate #if HASGETDTABLESIZE 58987c478bd9Sstevel@tonic-gate "HASGETDTABLESIZE", 58997c478bd9Sstevel@tonic-gate #endif /* HASGETDTABLESIZE */ 59007c478bd9Sstevel@tonic-gate #if HASGETUSERSHELL 59017c478bd9Sstevel@tonic-gate "HASGETUSERSHELL", 59027c478bd9Sstevel@tonic-gate #endif /* HASGETUSERSHELL */ 59037c478bd9Sstevel@tonic-gate #if HASINITGROUPS 59047c478bd9Sstevel@tonic-gate "HASINITGROUPS", 59057c478bd9Sstevel@tonic-gate #endif /* HASINITGROUPS */ 59067c478bd9Sstevel@tonic-gate #if HASLDAPGETALIASBYNAME 59077c478bd9Sstevel@tonic-gate "HASLDAPGETALIASBYNAME", 59087c478bd9Sstevel@tonic-gate #endif /* HASLDAPGETALIASBYNAME */ 59097c478bd9Sstevel@tonic-gate #if HASLSTAT 59107c478bd9Sstevel@tonic-gate "HASLSTAT", 59117c478bd9Sstevel@tonic-gate #endif /* HASLSTAT */ 59127c478bd9Sstevel@tonic-gate #if HASNICE 59137c478bd9Sstevel@tonic-gate "HASNICE", 59147c478bd9Sstevel@tonic-gate #endif /* HASNICE */ 59157c478bd9Sstevel@tonic-gate #if HASRANDOM 59167c478bd9Sstevel@tonic-gate "HASRANDOM", 59177c478bd9Sstevel@tonic-gate #endif /* HASRANDOM */ 59187c478bd9Sstevel@tonic-gate #if HASRRESVPORT 59197c478bd9Sstevel@tonic-gate "HASRRESVPORT", 59207c478bd9Sstevel@tonic-gate #endif /* HASRRESVPORT */ 59217c478bd9Sstevel@tonic-gate #if HASSETEGID 59227c478bd9Sstevel@tonic-gate "HASSETEGID", 59237c478bd9Sstevel@tonic-gate #endif /* HASSETEGID */ 59247c478bd9Sstevel@tonic-gate #if HASSETLOGIN 59257c478bd9Sstevel@tonic-gate "HASSETLOGIN", 59267c478bd9Sstevel@tonic-gate #endif /* HASSETLOGIN */ 59277c478bd9Sstevel@tonic-gate #if HASSETREGID 59287c478bd9Sstevel@tonic-gate "HASSETREGID", 59297c478bd9Sstevel@tonic-gate #endif /* HASSETREGID */ 59307c478bd9Sstevel@tonic-gate #if HASSETRESGID 59317c478bd9Sstevel@tonic-gate "HASSETRESGID", 59327c478bd9Sstevel@tonic-gate #endif /* HASSETRESGID */ 59337c478bd9Sstevel@tonic-gate #if HASSETREUID 59347c478bd9Sstevel@tonic-gate "HASSETREUID", 59357c478bd9Sstevel@tonic-gate #endif /* HASSETREUID */ 59367c478bd9Sstevel@tonic-gate #if HASSETRLIMIT 59377c478bd9Sstevel@tonic-gate "HASSETRLIMIT", 59387c478bd9Sstevel@tonic-gate #endif /* HASSETRLIMIT */ 59397c478bd9Sstevel@tonic-gate #if HASSETSID 59407c478bd9Sstevel@tonic-gate "HASSETSID", 59417c478bd9Sstevel@tonic-gate #endif /* HASSETSID */ 59427c478bd9Sstevel@tonic-gate #if HASSETUSERCONTEXT 59437c478bd9Sstevel@tonic-gate "HASSETUSERCONTEXT", 59447c478bd9Sstevel@tonic-gate #endif /* HASSETUSERCONTEXT */ 59457c478bd9Sstevel@tonic-gate #if HASSETVBUF 59467c478bd9Sstevel@tonic-gate "HASSETVBUF", 59477c478bd9Sstevel@tonic-gate #endif /* HASSETVBUF */ 59487c478bd9Sstevel@tonic-gate #if HAS_ST_GEN 59497c478bd9Sstevel@tonic-gate "HAS_ST_GEN", 59507c478bd9Sstevel@tonic-gate #endif /* HAS_ST_GEN */ 59517c478bd9Sstevel@tonic-gate #if HASSRANDOMDEV 59527c478bd9Sstevel@tonic-gate "HASSRANDOMDEV", 59537c478bd9Sstevel@tonic-gate #endif /* HASSRANDOMDEV */ 59547c478bd9Sstevel@tonic-gate #if HASURANDOMDEV 59557c478bd9Sstevel@tonic-gate "HASURANDOMDEV", 59567c478bd9Sstevel@tonic-gate #endif /* HASURANDOMDEV */ 59577c478bd9Sstevel@tonic-gate #if HASSTRERROR 59587c478bd9Sstevel@tonic-gate "HASSTRERROR", 59597c478bd9Sstevel@tonic-gate #endif /* HASSTRERROR */ 59607c478bd9Sstevel@tonic-gate #if HASULIMIT 59617c478bd9Sstevel@tonic-gate "HASULIMIT", 59627c478bd9Sstevel@tonic-gate #endif /* HASULIMIT */ 59637c478bd9Sstevel@tonic-gate #if HASUNAME 59647c478bd9Sstevel@tonic-gate "HASUNAME", 59657c478bd9Sstevel@tonic-gate #endif /* HASUNAME */ 59667c478bd9Sstevel@tonic-gate #if HASUNSETENV 59677c478bd9Sstevel@tonic-gate "HASUNSETENV", 59687c478bd9Sstevel@tonic-gate #endif /* HASUNSETENV */ 59697c478bd9Sstevel@tonic-gate #if HASWAITPID 59707c478bd9Sstevel@tonic-gate "HASWAITPID", 59717c478bd9Sstevel@tonic-gate #endif /* HASWAITPID */ 59727c478bd9Sstevel@tonic-gate #if IDENTPROTO 59737c478bd9Sstevel@tonic-gate "IDENTPROTO", 59747c478bd9Sstevel@tonic-gate #endif /* IDENTPROTO */ 59757c478bd9Sstevel@tonic-gate #if IP_SRCROUTE 59767c478bd9Sstevel@tonic-gate "IP_SRCROUTE", 59777c478bd9Sstevel@tonic-gate #endif /* IP_SRCROUTE */ 59787c478bd9Sstevel@tonic-gate #if O_EXLOCK && HASFLOCK && !BOGUS_O_EXCL 59797c478bd9Sstevel@tonic-gate "LOCK_ON_OPEN", 59807c478bd9Sstevel@tonic-gate #endif /* O_EXLOCK && HASFLOCK && !BOGUS_O_EXCL */ 59817c478bd9Sstevel@tonic-gate #if NEEDFSYNC 59827c478bd9Sstevel@tonic-gate "NEEDFSYNC", 59837c478bd9Sstevel@tonic-gate #endif /* NEEDFSYNC */ 59847c478bd9Sstevel@tonic-gate #if NEEDLINK 59857c478bd9Sstevel@tonic-gate "NEEDLINK", 59867c478bd9Sstevel@tonic-gate #endif /* NEEDLINK */ 59877c478bd9Sstevel@tonic-gate #if NEEDLOCAL_HOSTNAME_LENGTH 59887c478bd9Sstevel@tonic-gate "NEEDLOCAL_HOSTNAME_LENGTH", 59897c478bd9Sstevel@tonic-gate #endif /* NEEDLOCAL_HOSTNAME_LENGTH */ 59907c478bd9Sstevel@tonic-gate #if NEEDSGETIPNODE 59917c478bd9Sstevel@tonic-gate "NEEDSGETIPNODE", 59927c478bd9Sstevel@tonic-gate #endif /* NEEDSGETIPNODE */ 59937c478bd9Sstevel@tonic-gate #if NEEDSTRSTR 59947c478bd9Sstevel@tonic-gate "NEEDSTRSTR", 59957c478bd9Sstevel@tonic-gate #endif /* NEEDSTRSTR */ 59967c478bd9Sstevel@tonic-gate #if NEEDSTRTOL 59977c478bd9Sstevel@tonic-gate "NEEDSTRTOL", 59987c478bd9Sstevel@tonic-gate #endif /* NEEDSTRTOL */ 59997c478bd9Sstevel@tonic-gate #ifdef NO_GETSERVBYNAME 60007c478bd9Sstevel@tonic-gate "NO_GETSERVBYNAME", 60017c478bd9Sstevel@tonic-gate #endif /* NO_GETSERVBYNAME */ 60027c478bd9Sstevel@tonic-gate #if NOFTRUNCATE 60037c478bd9Sstevel@tonic-gate "NOFTRUNCATE", 60047c478bd9Sstevel@tonic-gate #endif /* NOFTRUNCATE */ 60057c478bd9Sstevel@tonic-gate #if REQUIRES_DIR_FSYNC 60067c478bd9Sstevel@tonic-gate "REQUIRES_DIR_FSYNC", 60077c478bd9Sstevel@tonic-gate #endif /* REQUIRES_DIR_FSYNC */ 60087c478bd9Sstevel@tonic-gate #if RLIMIT_NEEDS_SYS_TIME_H 60097c478bd9Sstevel@tonic-gate "RLIMIT_NEEDS_SYS_TIME_H", 60107c478bd9Sstevel@tonic-gate #endif /* RLIMIT_NEEDS_SYS_TIME_H */ 60117c478bd9Sstevel@tonic-gate #if SAFENFSPATHCONF 60127c478bd9Sstevel@tonic-gate "SAFENFSPATHCONF", 60137c478bd9Sstevel@tonic-gate #endif /* SAFENFSPATHCONF */ 60147c478bd9Sstevel@tonic-gate #if SECUREWARE 60157c478bd9Sstevel@tonic-gate "SECUREWARE", 60167c478bd9Sstevel@tonic-gate #endif /* SECUREWARE */ 60177c478bd9Sstevel@tonic-gate #if SHARE_V1 60187c478bd9Sstevel@tonic-gate "SHARE_V1", 60197c478bd9Sstevel@tonic-gate #endif /* SHARE_V1 */ 60207c478bd9Sstevel@tonic-gate #if SIOCGIFCONF_IS_BROKEN 60217c478bd9Sstevel@tonic-gate "SIOCGIFCONF_IS_BROKEN", 60227c478bd9Sstevel@tonic-gate #endif /* SIOCGIFCONF_IS_BROKEN */ 60237c478bd9Sstevel@tonic-gate #if SIOCGIFNUM_IS_BROKEN 60247c478bd9Sstevel@tonic-gate "SIOCGIFNUM_IS_BROKEN", 60257c478bd9Sstevel@tonic-gate #endif /* SIOCGIFNUM_IS_BROKEN */ 60267c478bd9Sstevel@tonic-gate #if SNPRINTF_IS_BROKEN 60277c478bd9Sstevel@tonic-gate "SNPRINTF_IS_BROKEN", 60287c478bd9Sstevel@tonic-gate #endif /* SNPRINTF_IS_BROKEN */ 60297c478bd9Sstevel@tonic-gate #if SO_REUSEADDR_IS_BROKEN 60307c478bd9Sstevel@tonic-gate "SO_REUSEADDR_IS_BROKEN", 60317c478bd9Sstevel@tonic-gate #endif /* SO_REUSEADDR_IS_BROKEN */ 60327c478bd9Sstevel@tonic-gate #if SYS5SETPGRP 60337c478bd9Sstevel@tonic-gate "SYS5SETPGRP", 60347c478bd9Sstevel@tonic-gate #endif /* SYS5SETPGRP */ 60357c478bd9Sstevel@tonic-gate #if SYSTEM5 60367c478bd9Sstevel@tonic-gate "SYSTEM5", 60377c478bd9Sstevel@tonic-gate #endif /* SYSTEM5 */ 60387c478bd9Sstevel@tonic-gate #if USE_DOUBLE_FORK 60397c478bd9Sstevel@tonic-gate "USE_DOUBLE_FORK", 60407c478bd9Sstevel@tonic-gate #endif /* USE_DOUBLE_FORK */ 60417c478bd9Sstevel@tonic-gate #if USE_ENVIRON 60427c478bd9Sstevel@tonic-gate "USE_ENVIRON", 60437c478bd9Sstevel@tonic-gate #endif /* USE_ENVIRON */ 60447c478bd9Sstevel@tonic-gate #if USE_SA_SIGACTION 60457c478bd9Sstevel@tonic-gate "USE_SA_SIGACTION", 60467c478bd9Sstevel@tonic-gate #endif /* USE_SA_SIGACTION */ 60477c478bd9Sstevel@tonic-gate #if USE_SIGLONGJMP 60487c478bd9Sstevel@tonic-gate "USE_SIGLONGJMP", 60497c478bd9Sstevel@tonic-gate #endif /* USE_SIGLONGJMP */ 60507c478bd9Sstevel@tonic-gate #if USEGETCONFATTR 60517c478bd9Sstevel@tonic-gate "USEGETCONFATTR", 60527c478bd9Sstevel@tonic-gate #endif /* USEGETCONFATTR */ 60537c478bd9Sstevel@tonic-gate #if USESETEUID 60547c478bd9Sstevel@tonic-gate "USESETEUID", 60557c478bd9Sstevel@tonic-gate #endif /* USESETEUID */ 60567c478bd9Sstevel@tonic-gate #ifdef USESYSCTL 60577c478bd9Sstevel@tonic-gate "USESYSCTL", 60587c478bd9Sstevel@tonic-gate #endif /* USESYSCTL */ 60597c478bd9Sstevel@tonic-gate #if USING_NETSCAPE_LDAP 60607c478bd9Sstevel@tonic-gate "USING_NETSCAPE_LDAP", 60617c478bd9Sstevel@tonic-gate #endif /* USING_NETSCAPE_LDAP */ 60627c478bd9Sstevel@tonic-gate #ifdef WAITUNION 60637c478bd9Sstevel@tonic-gate "WAITUNION", 60647c478bd9Sstevel@tonic-gate #endif /* WAITUNION */ 60657c478bd9Sstevel@tonic-gate NULL 60667c478bd9Sstevel@tonic-gate }; 60677c478bd9Sstevel@tonic-gate 60687c478bd9Sstevel@tonic-gate /* 60697c478bd9Sstevel@tonic-gate ** FFR compile options. 60707c478bd9Sstevel@tonic-gate */ 60717c478bd9Sstevel@tonic-gate 60727c478bd9Sstevel@tonic-gate char *FFRCompileOptions[] = 60737c478bd9Sstevel@tonic-gate { 60747c478bd9Sstevel@tonic-gate #if _FFR_ALLOW_SASLINFO 60757c478bd9Sstevel@tonic-gate /* DefaultAuthInfo can be specified by user. */ 60767c478bd9Sstevel@tonic-gate /* DefaultAuthInfo doesn't really work in 8.13 anymore. */ 60777c478bd9Sstevel@tonic-gate "_FFR_ALLOW_SASLINFO", 60787c478bd9Sstevel@tonic-gate #endif /* _FFR_ALLOW_SASLINFO */ 60797c478bd9Sstevel@tonic-gate #if _FFR_BESTMX_BETTER_TRUNCATION 60807c478bd9Sstevel@tonic-gate /* Better truncation of list of MX records for dns map. */ 60817c478bd9Sstevel@tonic-gate "_FFR_BESTMX_BETTER_TRUNCATION", 60827c478bd9Sstevel@tonic-gate #endif /* _FFR_BESTMX_BETTER_TRUNCATION */ 60837c478bd9Sstevel@tonic-gate #if _FFR_BLOCK_PROXIES 60847c478bd9Sstevel@tonic-gate /* 60857c478bd9Sstevel@tonic-gate ** Try to deal with open HTTP proxies that are used to send spam 60867c478bd9Sstevel@tonic-gate ** by recognizing some commands from them. 60877c478bd9Sstevel@tonic-gate */ 60887c478bd9Sstevel@tonic-gate 60897c478bd9Sstevel@tonic-gate "_FFR_BLOCK_PROXIES", 60907c478bd9Sstevel@tonic-gate #endif /* _FFR_BLOCK_PROXIES */ 60917c478bd9Sstevel@tonic-gate #if _FFR_CATCH_BROKEN_MTAS 60927c478bd9Sstevel@tonic-gate /* Deal with MTAs that send a reply during the DATA phase. */ 60937c478bd9Sstevel@tonic-gate "_FFR_CATCH_BROKEN_MTAS", 60947c478bd9Sstevel@tonic-gate #endif /* _FFR_CATCH_BROKEN_MTAS */ 60957c478bd9Sstevel@tonic-gate #if _FFR_CHECK_EOM 60967c478bd9Sstevel@tonic-gate /* Enable check_eom ruleset */ 60977c478bd9Sstevel@tonic-gate "_FFR_CHECK_EOM", 60987c478bd9Sstevel@tonic-gate #endif /* _FFR_CHECK_EOM */ 60997c478bd9Sstevel@tonic-gate #if _FFR_CHK_QUEUE 61007c478bd9Sstevel@tonic-gate /* Stricter checks about queue directory permissions. */ 61017c478bd9Sstevel@tonic-gate "_FFR_CHK_QUEUE", 61027c478bd9Sstevel@tonic-gate #endif /* _FFR_CHK_QUEUE */ 61037c478bd9Sstevel@tonic-gate #if _FFR_CLIENT_SIZE 61047c478bd9Sstevel@tonic-gate /* Don't try to send mail if its size exceeds SIZE= of server. */ 61057c478bd9Sstevel@tonic-gate "_FFR_CLIENT_SIZE", 61067c478bd9Sstevel@tonic-gate #endif /* _FFR_CLIENT_SIZE */ 61077c478bd9Sstevel@tonic-gate #if _FFR_CONTROL_MSTAT 61087c478bd9Sstevel@tonic-gate /* Extended daemon status. */ 61097c478bd9Sstevel@tonic-gate "_FFR_CONTROL_MSTAT", 61107c478bd9Sstevel@tonic-gate #endif /* _FFR_CONTROL_MSTAT */ 61117c478bd9Sstevel@tonic-gate #if _FFR_CRLPATH 61127c478bd9Sstevel@tonic-gate /* CRLPath; needs documentation; Al Smith */ 61137c478bd9Sstevel@tonic-gate "_FFR_CRLPATH", 61147c478bd9Sstevel@tonic-gate #endif /* _FFR_CRLPATH */ 61157c478bd9Sstevel@tonic-gate #if _FFR_DAEMON_NETUNIX 61167c478bd9Sstevel@tonic-gate /* Allow local (not just TCP) socket connection to server. */ 61177c478bd9Sstevel@tonic-gate "_FFR_DAEMON_NETUNIX", 61187c478bd9Sstevel@tonic-gate #endif /* _FFR_DAEMON_NETUNIX */ 61197c478bd9Sstevel@tonic-gate #if _FFR_DEPRECATE_MAILER_FLAG_I 61207c478bd9Sstevel@tonic-gate /* What it says :-) */ 61217c478bd9Sstevel@tonic-gate "_FFR_DEPRECATE_MAILER_FLAG_I", 61227c478bd9Sstevel@tonic-gate #endif /* _FFR_DEPRECATE_MAILER_FLAG_I */ 6123*445f2479Sjbeck #if _FFR_DM_ONE 6124*445f2479Sjbeck /* deliver first TA in background, then queue */ 6125*445f2479Sjbeck "_FFR_DM_ONE", 6126*445f2479Sjbeck #endif /* _FFR_DM_ONE */ 61277c478bd9Sstevel@tonic-gate #if _FFR_DIGUNIX_SAFECHOWN 61287c478bd9Sstevel@tonic-gate /* Properly set SAFECHOWN (include/sm/conf.h) for Digital UNIX */ 61297c478bd9Sstevel@tonic-gate /* Problem noted by Anne Bennett of Concordia University */ 61307c478bd9Sstevel@tonic-gate "_FFR_DIGUNIX_SAFECHOWN", 61317c478bd9Sstevel@tonic-gate #endif /* _FFR_DIGUNIX_SAFECHOWN */ 61327c478bd9Sstevel@tonic-gate #if _FFR_DM_PER_DAEMON 61337c478bd9Sstevel@tonic-gate /* DeliveryMode per DaemonPortOptions: 'D' */ 61347c478bd9Sstevel@tonic-gate "_FFR_DM_PER_DAEMON", 61357c478bd9Sstevel@tonic-gate #endif /* _FFR_DM_PER_DAEMON */ 61367c478bd9Sstevel@tonic-gate #if _FFR_DNSMAP_ALIASABLE 61377c478bd9Sstevel@tonic-gate /* Allow dns map type to be used for aliases. */ 61387c478bd9Sstevel@tonic-gate /* Don Lewis of TDK */ 61397c478bd9Sstevel@tonic-gate "_FFR_DNSMAP_ALIASABLE", 61407c478bd9Sstevel@tonic-gate #endif /* _FFR_DNSMAP_ALIASABLE */ 61417c478bd9Sstevel@tonic-gate #if _FFR_DNSMAP_BASE 61427c478bd9Sstevel@tonic-gate /* Specify a "base" domain for DNS lookups. */ 61437c478bd9Sstevel@tonic-gate "_FFR_DNSMAP_BASE", 61447c478bd9Sstevel@tonic-gate #endif /* _FFR_DNSMAP_BASE */ 61457c478bd9Sstevel@tonic-gate #if _FFR_DNSMAP_MULTI 61467c478bd9Sstevel@tonic-gate /* Allow multiple return values for DNS map. */ 61477c478bd9Sstevel@tonic-gate "_FFR_DNSMAP_MULTI", 61487c478bd9Sstevel@tonic-gate # if _FFR_DNSMAP_MULTILIMIT 61497c478bd9Sstevel@tonic-gate /* Limit number of return values for DNS map. */ 61507c478bd9Sstevel@tonic-gate "_FFR_DNSMAP_MULTILIMIT", 61517c478bd9Sstevel@tonic-gate # endif /* _FFR_DNSMAP_MULTILIMIT */ 61527c478bd9Sstevel@tonic-gate #endif /* _FFR_DNSMAP_MULTI */ 61537c478bd9Sstevel@tonic-gate #if _FFR_DONTLOCKFILESFORREAD_OPTION 61547c478bd9Sstevel@tonic-gate /* Enable DontLockFilesForRead option. */ 61557c478bd9Sstevel@tonic-gate "_FFR_DONTLOCKFILESFORREAD_OPTION", 61567c478bd9Sstevel@tonic-gate #endif /* _FFR_DONTLOCKFILESFORREAD_OPTION */ 61577c478bd9Sstevel@tonic-gate #if _FFR_DOTTED_USERNAMES 61587c478bd9Sstevel@tonic-gate /* Allow usernames with '.' */ 61597c478bd9Sstevel@tonic-gate "_FFR_DOTTED_USERNAMES", 61607c478bd9Sstevel@tonic-gate #endif /* _FFR_DOTTED_USERNAMES */ 61617c478bd9Sstevel@tonic-gate #if _FFR_DROP_TRUSTUSER_WARNING 61627c478bd9Sstevel@tonic-gate /* 61637c478bd9Sstevel@tonic-gate ** Don't issue this warning: 61647c478bd9Sstevel@tonic-gate ** "readcf: option TrustedUser may cause problems on systems 61657c478bd9Sstevel@tonic-gate ** which do not support fchown() if UseMSP is not set. 61667c478bd9Sstevel@tonic-gate */ 61677c478bd9Sstevel@tonic-gate 61687c478bd9Sstevel@tonic-gate "_FFR_DROP_TRUSTUSER_WARNING", 61697c478bd9Sstevel@tonic-gate #endif /* _FFR_DROP_TRUSTUSER_WARNING */ 61707c478bd9Sstevel@tonic-gate #if _FFR_EXTRA_MAP_CHECK 61717c478bd9Sstevel@tonic-gate /* perform extra checks on $( $) in R lines */ 61727c478bd9Sstevel@tonic-gate "_FFR_EXTRA_MAP_CHECK", 61737c478bd9Sstevel@tonic-gate #endif /* _FFR_EXTRA_MAP_CHECK */ 61747c478bd9Sstevel@tonic-gate #if _FFR_FIX_DASHT 61757c478bd9Sstevel@tonic-gate /* 61767c478bd9Sstevel@tonic-gate ** If using -t, force not sending to argv recipients, even 61777c478bd9Sstevel@tonic-gate ** if they are mentioned in the headers. 61787c478bd9Sstevel@tonic-gate */ 61797c478bd9Sstevel@tonic-gate 61807c478bd9Sstevel@tonic-gate "_FFR_FIX_DASHT", 61817c478bd9Sstevel@tonic-gate #endif /* _FFR_FIX_DASHT */ 61827c478bd9Sstevel@tonic-gate #if _FFR_FORWARD_SYSERR 61837c478bd9Sstevel@tonic-gate /* Cause a "syserr" if forward file isn't "safe". */ 61847c478bd9Sstevel@tonic-gate "_FFR_FORWARD_SYSERR", 61857c478bd9Sstevel@tonic-gate #endif /* _FFR_FORWARD_SYSERR */ 61867c478bd9Sstevel@tonic-gate #if _FFR_GEN_ORCPT 61877c478bd9Sstevel@tonic-gate /* Generate a ORCPT DSN arg if not already provided */ 61887c478bd9Sstevel@tonic-gate "_FFR_GEN_ORCPT", 61897c478bd9Sstevel@tonic-gate #endif /* _FFR_GEN_ORCPT */ 619049218d4fSjbeck #if _FFR_LOG_GREET_PAUSE 619149218d4fSjbeck /* log time for greet_pause delay; from Nik Clayton */ 619249218d4fSjbeck "_FFR_LOG_GREET_PAUSE", 619349218d4fSjbeck #endif /* _FFR_LOG_GREET_PAUSE */ 61947c478bd9Sstevel@tonic-gate #if _FFR_GROUPREADABLEAUTHINFOFILE 61957c478bd9Sstevel@tonic-gate /* Allow group readable DefaultAuthInfo file. */ 61967c478bd9Sstevel@tonic-gate "_FFR_GROUPREADABLEAUTHINFOFILE", 61977c478bd9Sstevel@tonic-gate #endif /* _FFR_GROUPREADABLEAUTHINFOFILE */ 61987c478bd9Sstevel@tonic-gate #if _FFR_HANDLE_ISO8859_GECOS 61997c478bd9Sstevel@tonic-gate /* 62007c478bd9Sstevel@tonic-gate ** Allow ISO 8859 characters in GECOS field: replace them 62017c478bd9Sstevel@tonic-gate ** ith ASCII "equivalent". 62027c478bd9Sstevel@tonic-gate */ 62037c478bd9Sstevel@tonic-gate 62047c478bd9Sstevel@tonic-gate /* Peter Eriksson of Linkopings universitet */ 62057c478bd9Sstevel@tonic-gate "_FFR_HANDLE_ISO8859_GECOS", 62067c478bd9Sstevel@tonic-gate #endif /* _FFR_HANDLE_ISO8859_GECOS */ 62077c478bd9Sstevel@tonic-gate #if _FFR_HDR_TYPE 62087c478bd9Sstevel@tonic-gate /* Set 'h' in {addr_type} for headers. */ 62097c478bd9Sstevel@tonic-gate "_FFR_HDR_TYPE", 62107c478bd9Sstevel@tonic-gate #endif /* _FFR_HDR_TYPE */ 62117c478bd9Sstevel@tonic-gate #if _FFR_HELONAME 62127c478bd9Sstevel@tonic-gate /* option to set heloname; Nik Clayton of FreeBSD */ 62137c478bd9Sstevel@tonic-gate "_FFR_HELONAME", 62147c478bd9Sstevel@tonic-gate #endif /* _FFR_HELONAME */ 62157c478bd9Sstevel@tonic-gate #if _FFR_HPUX_NSSWITCH 62167c478bd9Sstevel@tonic-gate /* Use nsswitch on HP-UX */ 62177c478bd9Sstevel@tonic-gate "_FFR_HPUX_NSSWITCH", 62187c478bd9Sstevel@tonic-gate #endif /* _FFR_HPUX_NSSWITCH */ 62197c478bd9Sstevel@tonic-gate #if _FFR_IGNORE_BOGUS_ADDR 62207c478bd9Sstevel@tonic-gate /* Ignore addresses for which prescan() failed */ 62217c478bd9Sstevel@tonic-gate "_FFR_IGNORE_BOGUS_ADDR", 62227c478bd9Sstevel@tonic-gate #endif /* _FFR_IGNORE_BOGUS_ADDR */ 62237c478bd9Sstevel@tonic-gate #if _FFR_IGNORE_EXT_ON_HELO 62247c478bd9Sstevel@tonic-gate /* Ignore extensions offered in response to HELO */ 62257c478bd9Sstevel@tonic-gate "_FFR_IGNORE_EXT_ON_HELO", 62267c478bd9Sstevel@tonic-gate #endif /* _FFR_IGNORE_EXT_ON_HELO */ 62277c478bd9Sstevel@tonic-gate #if _FFR_MAXDATASIZE 62287c478bd9Sstevel@tonic-gate /* 62297c478bd9Sstevel@tonic-gate ** It is possible that a header is larger than MILTER_CHUNK_SIZE, 62307c478bd9Sstevel@tonic-gate ** hence this shouldn't be used as limit for milter communication. 62317c478bd9Sstevel@tonic-gate ** see also libmilter/comm.c 62327c478bd9Sstevel@tonic-gate ** Gurusamy Sarathy of ActiveState 62337c478bd9Sstevel@tonic-gate */ 62347c478bd9Sstevel@tonic-gate 62357c478bd9Sstevel@tonic-gate "_FFR_MAXDATASIZE", 62367c478bd9Sstevel@tonic-gate #endif /* _FFR_MAXDATASIZE */ 62377c478bd9Sstevel@tonic-gate #if _FFR_MAX_FORWARD_ENTRIES 62387c478bd9Sstevel@tonic-gate /* Try to limit number of .forward entries */ 62397c478bd9Sstevel@tonic-gate /* (doesn't work) */ 62407c478bd9Sstevel@tonic-gate /* Randall S. Winchester of the University of Maryland */ 62417c478bd9Sstevel@tonic-gate "_FFR_MAX_FORWARD_ENTRIES", 62427c478bd9Sstevel@tonic-gate #endif /* _FFR_MAX_FORWARD_ENTRIES */ 6243*445f2479Sjbeck #if _FFR_MAXKEY 6244*445f2479Sjbeck /* increase key size for LDAP lookups, see conf.h */ 6245*445f2479Sjbeck "_FFR_MAXKEY", 6246*445f2479Sjbeck #endif /* _FFR_MAXKEY */ 6247*445f2479Sjbeck #if _FFR_MAXNOOPCOMMANDS 6248*445f2479Sjbeck /* runtime option for "MaxNOOPCommands" */ 6249*445f2479Sjbeck "_FFR_MAXNOOPCOMMANDS", 6250*445f2479Sjbeck #endif /* _FFR_MAXNOOPCOMMANDS */ 62517c478bd9Sstevel@tonic-gate #if _FFR_MAX_SLEEP_TIME 62527c478bd9Sstevel@tonic-gate /* Limit sleep(2) time in libsm/clock.c */ 62537c478bd9Sstevel@tonic-gate "_FFR_MAX_SLEEP_TIME", 62547c478bd9Sstevel@tonic-gate #endif /* _FFR_MAX_SLEEP_TIME */ 6255*445f2479Sjbeck #if _FFR_MEMSTAT 6256*445f2479Sjbeck /* Check free memory */ 6257*445f2479Sjbeck "_FFR_MEMSTAT", 6258*445f2479Sjbeck #endif /* _FFR_MEMSTAT */ 62597c478bd9Sstevel@tonic-gate #if _FFR_MILTER_NAGLE 62607c478bd9Sstevel@tonic-gate /* milter: turn off Nagle ("cork" on Linux) */ 62617c478bd9Sstevel@tonic-gate /* John Gardiner Myers of Proofpoint */ 62627c478bd9Sstevel@tonic-gate "_FFR_MILTER_NAGLE ", 62637c478bd9Sstevel@tonic-gate #endif /* _FFR_MILTER_NAGLE */ 62647c478bd9Sstevel@tonic-gate #if _FFR_MILTER_NOHDR_RESP 62657c478bd9Sstevel@tonic-gate /* milter: no response expected when sending headers */ 62667c478bd9Sstevel@tonic-gate /* John Gardiner Myers of Proofpoint */ 62677c478bd9Sstevel@tonic-gate "_FFR_MILTER_NOHDR_RESP", 62687c478bd9Sstevel@tonic-gate #endif /* _FFR_MILTER_NOHDR_RESP */ 62697c478bd9Sstevel@tonic-gate #if _FFR_MIME7TO8_OLD 62707c478bd9Sstevel@tonic-gate /* Old mime7to8 code, the new is broken for at least one example. */ 62717c478bd9Sstevel@tonic-gate "_FFR_MIME7TO8_OLD", 62727c478bd9Sstevel@tonic-gate #endif /* _FFR_MAX_SLEEP_TIME */ 6273*445f2479Sjbeck #if _FFR_MSG_ACCEPT 6274*445f2479Sjbeck /* allow to override "Message accepted for delivery" */ 6275*445f2479Sjbeck "_FFR_MSG_ACCEPT", 6276*445f2479Sjbeck #endif /* _FFR_MSG_ACCEPT */ 62777c478bd9Sstevel@tonic-gate #if _FFR_NODELAYDSN_ON_HOLD 62787c478bd9Sstevel@tonic-gate /* Do not issue a DELAY DSN for mailers that use the hold flag. */ 62797c478bd9Sstevel@tonic-gate /* Steven Pitzl */ 62807c478bd9Sstevel@tonic-gate "_FFR_NODELAYDSN_ON_HOLD", 62817c478bd9Sstevel@tonic-gate #endif /* _FFR_NODELAYDSN_ON_HOLD */ 62827c478bd9Sstevel@tonic-gate #if _FFR_NO_PIPE 62837c478bd9Sstevel@tonic-gate /* Disable PIPELINING, delay client if used. */ 62847c478bd9Sstevel@tonic-gate "_FFR_NO_PIPE", 62857c478bd9Sstevel@tonic-gate #endif /* _FFR_NO_PIPE */ 62867c478bd9Sstevel@tonic-gate #if _FFR_LOG_NTRIES 62877c478bd9Sstevel@tonic-gate /* log ntries=, from Nik Clayton of FreeBSD */ 62887c478bd9Sstevel@tonic-gate "_FFR_LOG_NTRIES", 62897c478bd9Sstevel@tonic-gate #endif /* _FFR_LOG_NTRIES */ 62907c478bd9Sstevel@tonic-gate #if _FFR_PRIV_NOACTUALRECIPIENT 62917c478bd9Sstevel@tonic-gate /* 629249218d4fSjbeck ** PrivacyOptions=noactualrecipient stops sendmail from putting 629349218d4fSjbeck ** X-Actual-Recipient lines in DSNs revealing the actual 629449218d4fSjbeck ** account that addresses map to. Patch from Dan Harkless. 62957c478bd9Sstevel@tonic-gate */ 62967c478bd9Sstevel@tonic-gate 62977c478bd9Sstevel@tonic-gate "_FFR_PRIV_NOACTUALRECIPIENT", 62987c478bd9Sstevel@tonic-gate #endif /* _FFR_PRIV_NOACTUALRECIPIENT */ 62997c478bd9Sstevel@tonic-gate #if _FFR_QUEUEDELAY 63007c478bd9Sstevel@tonic-gate /* Exponential queue delay; disabled in 8.13 since it isn't used. */ 63017c478bd9Sstevel@tonic-gate "_FFR_QUEUEDELAY", 63027c478bd9Sstevel@tonic-gate #endif /* _FFR_QUEUEDELAY */ 63037c478bd9Sstevel@tonic-gate #if _FFR_QUEUE_GROUP_SORTORDER 63047c478bd9Sstevel@tonic-gate /* Allow QueueSortOrder per queue group. */ 63057c478bd9Sstevel@tonic-gate /* XXX: Still need to actually use qgrp->qg_sortorder */ 63067c478bd9Sstevel@tonic-gate "_FFR_QUEUE_GROUP_SORTORDER", 63077c478bd9Sstevel@tonic-gate #endif /* _FFR_QUEUE_GROUP_SORTORDER */ 63087c478bd9Sstevel@tonic-gate #if _FFR_QUEUE_MACRO 63097c478bd9Sstevel@tonic-gate /* Define {queue} macro. */ 63107c478bd9Sstevel@tonic-gate "_FFR_QUEUE_MACRO", 63117c478bd9Sstevel@tonic-gate #endif /* _FFR_QUEUE_MACRO */ 63127c478bd9Sstevel@tonic-gate #if _FFR_QUEUE_RUN_PARANOIA 6313*445f2479Sjbeck /* Additional checks when doing queue runs; interval of checks */ 63147c478bd9Sstevel@tonic-gate "_FFR_QUEUE_RUN_PARANOIA", 63157c478bd9Sstevel@tonic-gate #endif /* _FFR_QUEUE_RUN_PARANOIA */ 63167c478bd9Sstevel@tonic-gate #if _FFR_QUEUE_SCHED_DBG 63177c478bd9Sstevel@tonic-gate /* Debug output for the queue scheduler. */ 63187c478bd9Sstevel@tonic-gate "_FFR_QUEUE_SCHED_DBG", 63197c478bd9Sstevel@tonic-gate #endif /* _FFR_QUEUE_SCHED_DBG */ 63207c478bd9Sstevel@tonic-gate #if _FFR_REDIRECTEMPTY 63217c478bd9Sstevel@tonic-gate /* 63227c478bd9Sstevel@tonic-gate ** envelope <> can't be sent to mailing lists, only owner- 63237c478bd9Sstevel@tonic-gate ** send spam of this type to owner- of the list 63247c478bd9Sstevel@tonic-gate ** ---- to stop spam from going to mailing lists. 63257c478bd9Sstevel@tonic-gate */ 63267c478bd9Sstevel@tonic-gate 63277c478bd9Sstevel@tonic-gate "_FFR_REDIRECTEMPTY", 63287c478bd9Sstevel@tonic-gate #endif /* _FFR_REDIRECTEMPTY */ 63297c478bd9Sstevel@tonic-gate #if _FFR_RESET_MACRO_GLOBALS 63307c478bd9Sstevel@tonic-gate /* Allow macro 'j' to be set dynamically via rulesets. */ 63317c478bd9Sstevel@tonic-gate "_FFR_RESET_MACRO_GLOBALS", 63327c478bd9Sstevel@tonic-gate #endif /* _FFR_RESET_MACRO_GLOBALS */ 63337c478bd9Sstevel@tonic-gate #if _FFR_RHS 63347c478bd9Sstevel@tonic-gate /* Random shuffle for queue sorting. */ 63357c478bd9Sstevel@tonic-gate "_FFR_RHS", 63367c478bd9Sstevel@tonic-gate #endif /* _FFR_RHS */ 63377c478bd9Sstevel@tonic-gate #if _FFR_SELECT_SHM 63387c478bd9Sstevel@tonic-gate /* Auto-select of shared memory key */ 63397c478bd9Sstevel@tonic-gate "_FFR_SELECT_SHM", 63407c478bd9Sstevel@tonic-gate #endif /* _FFR_SELECT_SHM */ 63417c478bd9Sstevel@tonic-gate #if _FFR_SHM_STATUS 63427c478bd9Sstevel@tonic-gate /* Donated code (unused). */ 63437c478bd9Sstevel@tonic-gate "_FFR_SHM_STATUS", 63447c478bd9Sstevel@tonic-gate #endif /* _FFR_SHM_STATUS */ 634549218d4fSjbeck #if _FFR_LDAP_SINGLEDN 634649218d4fSjbeck /* 634749218d4fSjbeck ** The LDAP database map code in Sendmail 8.12.10, when 634849218d4fSjbeck ** given the -1 switch, would match only a single DN, 634949218d4fSjbeck ** but was able to return multiple attributes for that 635049218d4fSjbeck ** DN. In Sendmail 8.13 this "bug" was corrected to 635149218d4fSjbeck ** only return if exactly one attribute matched. 635249218d4fSjbeck ** 6353*445f2479Sjbeck ** Unfortunately, our configuration uses the former 635449218d4fSjbeck ** behaviour. Attached is a relatively simple patch 635549218d4fSjbeck ** to 8.13.4 which adds a -2 switch (for lack of a 635649218d4fSjbeck ** better option) which returns the single dn/multiple 635749218d4fSjbeck ** attributes. 635849218d4fSjbeck ** 635949218d4fSjbeck ** Jeffrey T. Eaton, Carnegie-Mellon University 636049218d4fSjbeck */ 636149218d4fSjbeck 636249218d4fSjbeck "_FFR_LDAP_SINGLEDN", 636349218d4fSjbeck #endif /* _FFR_LDAP_SINGLEDN */ 63647c478bd9Sstevel@tonic-gate #if _FFR_SKIP_DOMAINS 63657c478bd9Sstevel@tonic-gate /* process every N'th domain instead of every N'th message */ 63667c478bd9Sstevel@tonic-gate "_FFR_SKIP_DOMAINS", 63677c478bd9Sstevel@tonic-gate #endif /* _FFR_SKIP_DOMAINS */ 63687c478bd9Sstevel@tonic-gate #if _FFR_SLEEP_USE_SELECT 63697c478bd9Sstevel@tonic-gate /* Use select(2) in libsm/clock.c to emulate sleep(2) */ 63707c478bd9Sstevel@tonic-gate "_FFR_SLEEP_USE_SELECT ", 63717c478bd9Sstevel@tonic-gate #endif /* _FFR_SLEEP_USE_SELECT */ 63727c478bd9Sstevel@tonic-gate #if _FFR_SOFT_BOUNCE 63737c478bd9Sstevel@tonic-gate /* Turn all errors into temporary errors. */ 63747c478bd9Sstevel@tonic-gate "_FFR_SOFT_BOUNCE", 63757c478bd9Sstevel@tonic-gate #endif /* _FFR_SOFT_BOUNCE */ 63767c478bd9Sstevel@tonic-gate #if _FFR_SPT_ALIGN 63777c478bd9Sstevel@tonic-gate /* 63787c478bd9Sstevel@tonic-gate ** It looks like the Compaq Tru64 5.1A now aligns argv and envp to 64 63797c478bd9Sstevel@tonic-gate ** bit alignment, so unless each piece of argv and envp is a multiple 63807c478bd9Sstevel@tonic-gate ** of 8 bytes (including terminating NULL), initsetproctitle() won't 63817c478bd9Sstevel@tonic-gate ** use any of the space beyond argv[0]. Be sure to set SPT_ALIGN_SIZE 63827c478bd9Sstevel@tonic-gate ** if you use this FFR. 63837c478bd9Sstevel@tonic-gate */ 63847c478bd9Sstevel@tonic-gate 63857c478bd9Sstevel@tonic-gate /* Chris Adams of HiWAAY Informations Services */ 63867c478bd9Sstevel@tonic-gate "_FFR_SPT_ALIGN", 63877c478bd9Sstevel@tonic-gate #endif /* _FFR_SPT_ALIGN */ 63887c478bd9Sstevel@tonic-gate #if _FFR_SS_PER_DAEMON 63897c478bd9Sstevel@tonic-gate /* SuperSafe per DaemonPortOptions: 'T' (better letter?) */ 63907c478bd9Sstevel@tonic-gate "_FFR_SS_PER_DAEMON", 63917c478bd9Sstevel@tonic-gate #endif /* _FFR_SS_PER_DAEMON */ 63927c478bd9Sstevel@tonic-gate #if _FFR_TIMERS 63937c478bd9Sstevel@tonic-gate /* Donated code (unused). */ 63947c478bd9Sstevel@tonic-gate "_FFR_TIMERS", 63957c478bd9Sstevel@tonic-gate #endif /* _FFR_TIMERS */ 63967c478bd9Sstevel@tonic-gate #if _FFR_TLS_1 63977c478bd9Sstevel@tonic-gate /* More STARTTLS options, e.g., secondary certs. */ 63987c478bd9Sstevel@tonic-gate "_FFR_TLS_1", 63997c478bd9Sstevel@tonic-gate #endif /* _FFR_TLS_1 */ 64007c478bd9Sstevel@tonic-gate #if _FFR_TRUSTED_QF 64017c478bd9Sstevel@tonic-gate /* 64027c478bd9Sstevel@tonic-gate ** If we don't own the file mark it as unsafe. 64037c478bd9Sstevel@tonic-gate ** However, allow TrustedUser to own it as well 64047c478bd9Sstevel@tonic-gate ** in case TrustedUser manipulates the queue. 64057c478bd9Sstevel@tonic-gate */ 64067c478bd9Sstevel@tonic-gate 64077c478bd9Sstevel@tonic-gate "_FFR_TRUSTED_QF", 64087c478bd9Sstevel@tonic-gate #endif /* _FFR_TRUSTED_QF */ 64097c478bd9Sstevel@tonic-gate #if _FFR_USE_SEM_LOCKING 64107c478bd9Sstevel@tonic-gate "_FFR_USE_SEM_LOCKING", 64117c478bd9Sstevel@tonic-gate #endif /* _FFR_USE_SEM_LOCKING */ 64127c478bd9Sstevel@tonic-gate #if _FFR_USE_SETLOGIN 64137c478bd9Sstevel@tonic-gate /* Use setlogin() */ 64147c478bd9Sstevel@tonic-gate /* Peter Philipp */ 64157c478bd9Sstevel@tonic-gate "_FFR_USE_SETLOGIN", 64167c478bd9Sstevel@tonic-gate #endif /* _FFR_USE_SETLOGIN */ 64177c478bd9Sstevel@tonic-gate NULL 64187c478bd9Sstevel@tonic-gate }; 64197c478bd9Sstevel@tonic-gate 6420