?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sendmail: Update vendor branch to v8.14.15
[dragonfly.git] / contrib / sendmail-8.14 / sendmail / conf.c
blobffc6f205c701847e1b485da726c98b66220f5c0a
1 /*
2 * Copyright (c) 1998-2010 Sendmail, Inc. and its suppliers.
3 * All rights reserved.
4 * Copyright (c) 1983, 1995-1997 Eric P. Allman. All rights reserved.
5 * Copyright (c) 1988, 1993
6 * The Regents of the University of California. All rights reserved.
7 *
8 * By using this file, you agree to the terms and conditions set
9 * forth in the LICENSE file which can be found at the top level of
10 * the sendmail distribution.
11 *
12 */
13
14 #include <sendmail.h>
15
16 SM_RCSID("@(#)$Id: conf.c,v 8.1168 2011/01/25 18:31:30 ca Exp $")
17
18 #include <sm/sendmail.h>
19 #include <sendmail/pathnames.h>
20 #if NEWDB
21 # include "sm/bdb.h"
22 #endif /* NEWDB */
23
24 #include <daemon.h>
25 #include "map.h"
26
27 #ifdef DEC
28 # if NETINET6
29 /* for the IPv6 device lookup */
30 # define _SOCKADDR_LEN
31 # include <macros.h>
32 # endif /* NETINET6 */
33 #endif /* DEC */
34
35 # include <sys/ioctl.h>
36 # include <sys/param.h>
37
38 #include <limits.h>
39 #if NETINET || NETINET6
40 # include <arpa/inet.h>
41 #endif /* NETINET || NETINET6 */
42 #if HASULIMIT && defined(HPUX11)
43 # include <ulimit.h>
44 #endif /* HASULIMIT && defined(HPUX11) */
45
46 static void setupmaps __P((void));
47 static void setupmailers __P((void));
48 static void setupqueues __P((void));
49 static int get_num_procs_online __P((void));
50 static int add_hostnames __P((SOCKADDR *));
51
52 #if NETINET6 && NEEDSGETIPNODE
53 static struct hostent *sm_getipnodebyname __P((const char *, int, int, int *));
54 static struct hostent *sm_getipnodebyaddr __P((const void *, size_t, int, int *));
55 #else /* NETINET6 && NEEDSGETIPNODE */
56 #define sm_getipnodebyname getipnodebyname
57 #define sm_getipnodebyaddr getipnodebyaddr
58 #endif /* NETINET6 && NEEDSGETIPNODE */
59
60
61 /*
62 ** CONF.C -- Sendmail Configuration Tables.
63 **
64 ** Defines the configuration of this installation.
65 **
66 ** Configuration Variables:
67 ** HdrInfo -- a table describing well-known header fields.
68 ** Each entry has the field name and some flags,
69 ** which are described in sendmail.h.
70 **
71 ** Notes:
72 ** I have tried to put almost all the reasonable
73 ** configuration information into the configuration
74 ** file read at runtime. My intent is that anything
75 ** here is a function of the version of UNIX you
76 ** are running, or is really static -- for example
77 ** the headers are a superset of widely used
78 ** protocols. If you find yourself playing with
79 ** this file too much, you may be making a mistake!
80 */
81
82
83 /*
84 ** Header info table
85 ** Final (null) entry contains the flags used for any other field.
86 **
87 ** Not all of these are actually handled specially by sendmail
88 ** at this time. They are included as placeholders, to let
89 ** you know that "someday" I intend to have sendmail do
90 ** something with them.
91 */
92
93 struct hdrinfo HdrInfo[] =
94 {
95 /* originator fields, most to least significant */
96 { "resent-sender", H_FROM|H_RESENT, NULL },
97 { "resent-from", H_FROM|H_RESENT, NULL },
98 { "resent-reply-to", H_FROM|H_RESENT, NULL },
99 { "sender", H_FROM, NULL },
100 { "from", H_FROM, NULL },
101 { "reply-to", H_FROM, NULL },
102 { "errors-to", H_FROM|H_ERRORSTO, NULL },
103 { "full-name", H_ACHECK, NULL },
104 { "return-receipt-to", H_RECEIPTTO, NULL },
105 { "delivery-receipt-to", H_RECEIPTTO, NULL },
106 { "disposition-notification-to", H_FROM, NULL },
107
108 /* destination fields */
109 { "to", H_RCPT, NULL },
110 { "resent-to", H_RCPT|H_RESENT, NULL },
111 { "cc", H_RCPT, NULL },
112 { "resent-cc", H_RCPT|H_RESENT, NULL },
113 { "bcc", H_RCPT|H_BCC, NULL },
114 { "resent-bcc", H_RCPT|H_BCC|H_RESENT, NULL },
115 { "apparently-to", H_RCPT, NULL },
116
117 /* message identification and control */
118 { "message-id", 0, NULL },
119 { "resent-message-id", H_RESENT, NULL },
120 { "message", H_EOH, NULL },
121 { "text", H_EOH, NULL },
122
123 /* date fields */
124 { "date", 0, NULL },
125 { "resent-date", H_RESENT, NULL },
126
127 /* trace fields */
128 { "received", H_TRACE|H_FORCE, NULL },
129 { "x400-received", H_TRACE|H_FORCE, NULL },
130 { "via", H_TRACE|H_FORCE, NULL },
131 { "mail-from", H_TRACE|H_FORCE, NULL },
132
133 /* miscellaneous fields */
134 { "comments", H_FORCE|H_ENCODABLE, NULL },
135 { "return-path", H_FORCE|H_ACHECK|H_BINDLATE, NULL },
136 { "content-transfer-encoding", H_CTE, NULL },
137 { "content-type", H_CTYPE, NULL },
138 { "content-length", H_ACHECK, NULL },
139 { "subject", H_ENCODABLE, NULL },
140 { "x-authentication-warning", H_FORCE, NULL },
141
142 { NULL, 0, NULL }
143 };
144
145
146
147 /*
148 ** Privacy values
149 */
150
151 struct prival PrivacyValues[] =
152 {
153 { "public", PRIV_PUBLIC },
154 { "needmailhelo", PRIV_NEEDMAILHELO },
155 { "needexpnhelo", PRIV_NEEDEXPNHELO },
156 { "needvrfyhelo", PRIV_NEEDVRFYHELO },
157 { "noexpn", PRIV_NOEXPN },
158 { "novrfy", PRIV_NOVRFY },
159 { "restrictexpand", PRIV_RESTRICTEXPAND },
160 { "restrictmailq", PRIV_RESTRICTMAILQ },
161 { "restrictqrun", PRIV_RESTRICTQRUN },
162 { "noetrn", PRIV_NOETRN },
163 { "noverb", PRIV_NOVERB },
164 { "authwarnings", PRIV_AUTHWARNINGS },
165 { "noreceipts", PRIV_NORECEIPTS },
166 { "nobodyreturn", PRIV_NOBODYRETN },
167 { "goaway", PRIV_GOAWAY },
168 { "noactualrecipient", PRIV_NOACTUALRECIPIENT },
169 { NULL, 0 }
170 };
171
172 /*
173 ** DontBlameSendmail values
174 */
175
176 struct dbsval DontBlameSendmailValues[] =
177 {
178 { "safe", DBS_SAFE },
179 { "assumesafechown", DBS_ASSUMESAFECHOWN },
180 { "groupwritabledirpathsafe", DBS_GROUPWRITABLEDIRPATHSAFE },
181 { "groupwritableforwardfilesafe",
182 DBS_GROUPWRITABLEFORWARDFILESAFE },
183 { "groupwritableincludefilesafe",
184 DBS_GROUPWRITABLEINCLUDEFILESAFE },
185 { "groupwritablealiasfile", DBS_GROUPWRITABLEALIASFILE },
186 { "worldwritablealiasfile", DBS_WORLDWRITABLEALIASFILE },
187 { "forwardfileinunsafedirpath", DBS_FORWARDFILEINUNSAFEDIRPATH },
188 { "includefileinunsafedirpath", DBS_INCLUDEFILEINUNSAFEDIRPATH },
189 { "mapinunsafedirpath", DBS_MAPINUNSAFEDIRPATH },
190 { "linkedaliasfileinwritabledir",
191 DBS_LINKEDALIASFILEINWRITABLEDIR },
192 { "linkedclassfileinwritabledir",
193 DBS_LINKEDCLASSFILEINWRITABLEDIR },
194 { "linkedforwardfileinwritabledir",
195 DBS_LINKEDFORWARDFILEINWRITABLEDIR },
196 { "linkedincludefileinwritabledir",
197 DBS_LINKEDINCLUDEFILEINWRITABLEDIR },
198 { "linkedmapinwritabledir", DBS_LINKEDMAPINWRITABLEDIR },
199 { "linkedserviceswitchfileinwritabledir",
200 DBS_LINKEDSERVICESWITCHFILEINWRITABLEDIR },
201 { "filedeliverytohardlink", DBS_FILEDELIVERYTOHARDLINK },
202 { "filedeliverytosymlink", DBS_FILEDELIVERYTOSYMLINK },
203 { "writemaptohardlink", DBS_WRITEMAPTOHARDLINK },
204 { "writemaptosymlink", DBS_WRITEMAPTOSYMLINK },
205 { "writestatstohardlink", DBS_WRITESTATSTOHARDLINK },
206 { "writestatstosymlink", DBS_WRITESTATSTOSYMLINK },
207 { "forwardfileingroupwritabledirpath",
208 DBS_FORWARDFILEINGROUPWRITABLEDIRPATH },
209 { "includefileingroupwritabledirpath",
210 DBS_INCLUDEFILEINGROUPWRITABLEDIRPATH },
211 { "classfileinunsafedirpath", DBS_CLASSFILEINUNSAFEDIRPATH },
212 { "errorheaderinunsafedirpath", DBS_ERRORHEADERINUNSAFEDIRPATH },
213 { "helpfileinunsafedirpath", DBS_HELPFILEINUNSAFEDIRPATH },
214 { "forwardfileinunsafedirpathsafe",
215 DBS_FORWARDFILEINUNSAFEDIRPATHSAFE },
216 { "includefileinunsafedirpathsafe",
217 DBS_INCLUDEFILEINUNSAFEDIRPATHSAFE },
218 { "runprograminunsafedirpath", DBS_RUNPROGRAMINUNSAFEDIRPATH },
219 { "runwritableprogram", DBS_RUNWRITABLEPROGRAM },
220 { "nonrootsafeaddr", DBS_NONROOTSAFEADDR },
221 { "truststickybit", DBS_TRUSTSTICKYBIT },
222 { "dontwarnforwardfileinunsafedirpath",
223 DBS_DONTWARNFORWARDFILEINUNSAFEDIRPATH },
224 { "insufficiententropy", DBS_INSUFFICIENTENTROPY },
225 { "groupreadablesasldbfile", DBS_GROUPREADABLESASLDBFILE },
226 { "groupwritablesasldbfile", DBS_GROUPWRITABLESASLDBFILE },
227 { "groupwritableforwardfile", DBS_GROUPWRITABLEFORWARDFILE },
228 { "groupwritableincludefile", DBS_GROUPWRITABLEINCLUDEFILE },
229 { "worldwritableforwardfile", DBS_WORLDWRITABLEFORWARDFILE },
230 { "worldwritableincludefile", DBS_WORLDWRITABLEINCLUDEFILE },
231 { "groupreadablekeyfile", DBS_GROUPREADABLEKEYFILE },
232 #if _FFR_GROUPREADABLEAUTHINFOFILE
233 { "groupreadableadefaultauthinfofile",
234 DBS_GROUPREADABLEAUTHINFOFILE },
235 #endif /* _FFR_GROUPREADABLEAUTHINFOFILE */
236 { NULL, 0 }
237 };
238
239 /*
240 ** Miscellaneous stuff.
241 */
242
243 int DtableSize = 50; /* max open files; reset in 4.2bsd */
244 /*
245 ** SETDEFAULTS -- set default values
246 **
247 ** Some of these must be initialized using direct code since they
248 ** depend on run-time values. So let's do all of them this way.
249 **
250 ** Parameters:
251 ** e -- the default envelope.
252 **
253 ** Returns:
254 ** none.
255 **
256 ** Side Effects:
257 ** Initializes a bunch of global variables to their
258 ** default values.
259 */
260
261 #define MINUTES * 60
262 #define HOURS * 60 MINUTES
263 #define DAYS * 24 HOURS
264
265 #ifndef MAXRULERECURSION
266 # define MAXRULERECURSION 50 /* max ruleset recursion depth */
267 #endif /* ! MAXRULERECURSION */
268
269 void
270 setdefaults(e)
271 register ENVELOPE *e;
272 {
273 int i;
274 int numprocs;
275 struct passwd *pw;
276
277 numprocs = get_num_procs_online();
278 SpaceSub = ' '; /* option B */
279 QueueLA = 8 * numprocs; /* option x */
280 RefuseLA = 12 * numprocs; /* option X */
281 WkRecipFact = 30000L; /* option y */
282 WkClassFact = 1800L; /* option z */
283 WkTimeFact = 90000L; /* option Z */
284 QueueFactor = WkRecipFact * 20; /* option q */
285 QueueMode = QM_NORMAL; /* what queue items to act upon */
286 FileMode = (RealUid != geteuid()) ? 0644 : 0600;
287 /* option F */
288 QueueFileMode = (RealUid != geteuid()) ? 0644 : 0600;
289 /* option QueueFileMode */
290
291 if (((pw = sm_getpwnam("mailnull")) != NULL && pw->pw_uid != 0) ||
292 ((pw = sm_getpwnam("sendmail")) != NULL && pw->pw_uid != 0) ||
293 ((pw = sm_getpwnam("daemon")) != NULL && pw->pw_uid != 0))
294 {
295 DefUid = pw->pw_uid; /* option u */
296 DefGid = pw->pw_gid; /* option g */
297 DefUser = newstr(pw->pw_name);
298 }
299 else
300 {
301 DefUid = 1; /* option u */
302 DefGid = 1; /* option g */
303 setdefuser();
304 }
305 TrustedUid = 0;
306 if (tTd(37, 4))
307 sm_dprintf("setdefaults: DefUser=%s, DefUid=%d, DefGid=%d\n",
308 DefUser != NULL ? DefUser : "<1:1>",
309 (int) DefUid, (int) DefGid);
310 CheckpointInterval = 10; /* option C */
311 MaxHopCount = 25; /* option h */
312 set_delivery_mode(SM_FORK, e); /* option d */
313 e->e_errormode = EM_PRINT; /* option e */
314 e->e_qgrp = NOQGRP;
315 e->e_qdir = NOQDIR;
316 e->e_xfqgrp = NOQGRP;
317 e->e_xfqdir = NOQDIR;
318 e->e_ctime = curtime();
319 SevenBitInput = false; /* option 7 */
320 MaxMciCache = 1; /* option k */
321 MciCacheTimeout = 5 MINUTES; /* option K */
322 LogLevel = 9; /* option L */
323 #if MILTER
324 MilterLogLevel = -1;
325 #endif /* MILTER */
326 inittimeouts(NULL, false); /* option r */
327 PrivacyFlags = PRIV_PUBLIC; /* option p */
328 MeToo = true; /* option m */
329 SendMIMEErrors = true; /* option f */
330 SuperSafe = SAFE_REALLY; /* option s */
331 clrbitmap(DontBlameSendmail); /* DontBlameSendmail option */
332 #if MIME8TO7
333 MimeMode = MM_CVTMIME|MM_PASS8BIT; /* option 8 */
334 #else /* MIME8TO7 */
335 MimeMode = MM_PASS8BIT;
336 #endif /* MIME8TO7 */
337 for (i = 0; i < MAXTOCLASS; i++)
338 {
339 TimeOuts.to_q_return[i] = 5 DAYS; /* option T */
340 TimeOuts.to_q_warning[i] = 0; /* option T */
341 }
342 ServiceSwitchFile = "/etc/mail/service.switch";
343 ServiceCacheMaxAge = (time_t) 10;
344 HostsFile = _PATH_HOSTS;
345 PidFile = newstr(_PATH_SENDMAILPID);
346 MustQuoteChars = "@,;:\\()[].'";
347 MciInfoTimeout = 30 MINUTES;
348 MaxRuleRecursion = MAXRULERECURSION;
349 MaxAliasRecursion = 10;
350 MaxMacroRecursion = 10;
351 ColonOkInAddr = true;
352 DontLockReadFiles = true;
353 DontProbeInterfaces = DPI_PROBEALL;
354 DoubleBounceAddr = "postmaster";
355 MaxHeadersLength = MAXHDRSLEN;
356 MaxMimeHeaderLength = MAXLINE;
357 MaxMimeFieldLength = MaxMimeHeaderLength / 2;
358 MaxForwardEntries = 0;
359 FastSplit = 1;
360 MaxNOOPCommands = MAXNOOPCOMMANDS;
361 #if SASL
362 AuthMechanisms = newstr(AUTH_MECHANISMS);
363 AuthRealm = NULL;
364 MaxSLBits = INT_MAX;
365 #endif /* SASL */
366 #if STARTTLS
367 TLS_Srv_Opts = TLS_I_SRV;
368 #endif /* STARTTLS */
369 #ifdef HESIOD_INIT
370 HesiodContext = NULL;
371 #endif /* HESIOD_INIT */
372 #if NETINET6
373 /* Detect if IPv6 is available at run time */
374 i = socket(AF_INET6, SOCK_STREAM, 0);
375 if (i >= 0)
376 {
377 InetMode = AF_INET6;
378 (void) close(i);
379 }
380 else
381 InetMode = AF_INET;
382 #else /* NETINET6 */
383 InetMode = AF_INET;
384 #endif /* NETINET6 */
385 ControlSocketName = NULL;
386 memset(&ConnectOnlyTo, '\0', sizeof(ConnectOnlyTo));
387 DataFileBufferSize = 4096;
388 XscriptFileBufferSize = 4096;
389 for (i = 0; i < MAXRWSETS; i++)
390 RuleSetNames[i] = NULL;
391 #if MILTER
392 InputFilters[0] = NULL;
393 #endif /* MILTER */
394 RejectLogInterval = 3 HOURS;
395 #if REQUIRES_DIR_FSYNC
396 RequiresDirfsync = true;
397 #endif /* REQUIRES_DIR_FSYNC */
398 #if _FFR_RCPTTHROTDELAY
399 BadRcptThrottleDelay = 1;
400 #endif /* _FFR_RCPTTHROTDELAY */
401 ConnectionRateWindowSize = 60;
402 setupmaps();
403 setupqueues();
404 setupmailers();
405 setupheaders();
406 }
407
408
409 /*
410 ** SETDEFUSER -- set/reset DefUser using DefUid (for initgroups())
411 */
412
413 void
414 setdefuser()
415 {
416 struct passwd *defpwent;
417 static char defuserbuf[40];
418
419 DefUser = defuserbuf;
420 defpwent = sm_getpwuid(DefUid);
421 (void) sm_strlcpy(defuserbuf,
422 (defpwent == NULL || defpwent->pw_name == NULL)
423 ? "nobody" : defpwent->pw_name,
424 sizeof(defuserbuf));
425 if (tTd(37, 4))
426 sm_dprintf("setdefuser: DefUid=%d, DefUser=%s\n",
427 (int) DefUid, DefUser);
428 }
429 /*
430 ** SETUPQUEUES -- initialize default queues
431 **
432 ** The mqueue QUEUE structure gets filled in after readcf() but
433 ** we need something to point to now for the mailer setup,
434 ** which use "mqueue" as default queue.
435 */
436
437 static void
438 setupqueues()
439 {
440 char buf[100];
441
442 MaxRunnersPerQueue = 1;
443 (void) sm_strlcpy(buf, "mqueue, P=/var/spool/mqueue", sizeof(buf));
444 makequeue(buf, false);
445 }
446 /*
447 ** SETUPMAILERS -- initialize default mailers
448 */
449
450 static void
451 setupmailers()
452 {
453 char buf[100];
454
455 (void) sm_strlcpy(buf, "prog, P=/bin/sh, F=lsouDq9, T=X-Unix/X-Unix/X-Unix, A=sh -c \201u",
456 sizeof(buf));
457 makemailer(buf);
458
459 (void) sm_strlcpy(buf, "*file*, P=[FILE], F=lsDFMPEouq9, T=X-Unix/X-Unix/X-Unix, A=FILE \201u",
460 sizeof(buf));
461 makemailer(buf);
462
463 (void) sm_strlcpy(buf, "*include*, P=/dev/null, F=su, A=INCLUDE \201u",
464 sizeof(buf));
465 makemailer(buf);
466 initerrmailers();
467 }
468 /*
469 ** SETUPMAPS -- set up map classes
470 */
471
472 #define MAPDEF(name, ext, flags, parse, open, close, lookup, store) \
473 { \
474 extern bool parse __P((MAP *, char *)); \
475 extern bool open __P((MAP *, int)); \
476 extern void close __P((MAP *)); \
477 extern char *lookup __P((MAP *, char *, char **, int *)); \
478 extern void store __P((MAP *, char *, char *)); \
479 s = stab(name, ST_MAPCLASS, ST_ENTER); \
480 s->s_mapclass.map_cname = name; \
481 s->s_mapclass.map_ext = ext; \
482 s->s_mapclass.map_cflags = flags; \
483 s->s_mapclass.map_parse = parse; \
484 s->s_mapclass.map_open = open; \
485 s->s_mapclass.map_close = close; \
486 s->s_mapclass.map_lookup = lookup; \
487 s->s_mapclass.map_store = store; \
488 }
489
490 static void
491 setupmaps()
492 {
493 register STAB *s;
494
495 #if NEWDB
496 # if DB_VERSION_MAJOR > 1
497 int major_v, minor_v, patch_v;
498
499 (void) db_version(&major_v, &minor_v, &patch_v);
500 if (major_v != DB_VERSION_MAJOR || minor_v != DB_VERSION_MINOR)
501 {
502 errno = 0;
503 syserr("Berkeley DB version mismatch: compiled against %d.%d.%d, run-time linked against %d.%d.%d",
504 DB_VERSION_MAJOR, DB_VERSION_MINOR, DB_VERSION_PATCH,
505 major_v, minor_v, patch_v);
506 }
507 # endif /* DB_VERSION_MAJOR > 1 */
508
509 MAPDEF("hash", ".db", MCF_ALIASOK|MCF_REBUILDABLE,
510 map_parseargs, hash_map_open, db_map_close,
511 db_map_lookup, db_map_store);
512
513 MAPDEF("btree", ".db", MCF_ALIASOK|MCF_REBUILDABLE,
514 map_parseargs, bt_map_open, db_map_close,
515 db_map_lookup, db_map_store);
516 #endif /* NEWDB */
517
518 #if NDBM
519 MAPDEF("dbm", ".dir", MCF_ALIASOK|MCF_REBUILDABLE,
520 map_parseargs, ndbm_map_open, ndbm_map_close,
521 ndbm_map_lookup, ndbm_map_store);
522 #endif /* NDBM */
523
524 #if NIS
525 MAPDEF("nis", NULL, MCF_ALIASOK,
526 map_parseargs, nis_map_open, null_map_close,
527 nis_map_lookup, null_map_store);
528 #endif /* NIS */
529
530 #if NISPLUS
531 MAPDEF("nisplus", NULL, MCF_ALIASOK,
532 map_parseargs, nisplus_map_open, null_map_close,
533 nisplus_map_lookup, null_map_store);
534 #endif /* NISPLUS */
535
536 #if LDAPMAP
537 MAPDEF("ldap", NULL, MCF_ALIASOK|MCF_NOTPERSIST,
538 ldapmap_parseargs, ldapmap_open, ldapmap_close,
539 ldapmap_lookup, null_map_store);
540 #endif /* LDAPMAP */
541
542 #if PH_MAP
543 MAPDEF("ph", NULL, MCF_NOTPERSIST,
544 ph_map_parseargs, ph_map_open, ph_map_close,
545 ph_map_lookup, null_map_store);
546 #endif /* PH_MAP */
547
548 #if MAP_NSD
549 /* IRIX 6.5 nsd support */
550 MAPDEF("nsd", NULL, MCF_ALIASOK,
551 map_parseargs, null_map_open, null_map_close,
552 nsd_map_lookup, null_map_store);
553 #endif /* MAP_NSD */
554
555 #if HESIOD
556 MAPDEF("hesiod", NULL, MCF_ALIASOK|MCF_ALIASONLY,
557 map_parseargs, hes_map_open, hes_map_close,
558 hes_map_lookup, null_map_store);
559 #endif /* HESIOD */
560
561 #if NETINFO
562 MAPDEF("netinfo", NULL, MCF_ALIASOK,
563 map_parseargs, ni_map_open, null_map_close,
564 ni_map_lookup, null_map_store);
565 #endif /* NETINFO */
566
567 #if 0
568 MAPDEF("dns", NULL, 0,
569 dns_map_init, null_map_open, null_map_close,
570 dns_map_lookup, null_map_store);
571 #endif /* 0 */
572
573 #if NAMED_BIND
574 # if DNSMAP
575 # if _FFR_DNSMAP_ALIASABLE
576 MAPDEF("dns", NULL, MCF_ALIASOK,
577 dns_map_parseargs, dns_map_open, null_map_close,
578 dns_map_lookup, null_map_store);
579 # else /* _FFR_DNSMAP_ALIASABLE */
580 MAPDEF("dns", NULL, 0,
581 dns_map_parseargs, dns_map_open, null_map_close,
582 dns_map_lookup, null_map_store);
583 # endif /* _FFR_DNSMAP_ALIASABLE */
584 # endif /* DNSMAP */
585 #endif /* NAMED_BIND */
586
587 #if NAMED_BIND
588 /* best MX DNS lookup */
589 MAPDEF("bestmx", NULL, MCF_OPTFILE,
590 map_parseargs, null_map_open, null_map_close,
591 bestmx_map_lookup, null_map_store);
592 #endif /* NAMED_BIND */
593
594 MAPDEF("host", NULL, 0,
595 host_map_init, null_map_open, null_map_close,
596 host_map_lookup, null_map_store);
597
598 MAPDEF("text", NULL, MCF_ALIASOK,
599 map_parseargs, text_map_open, null_map_close,
600 text_map_lookup, null_map_store);
601
602 MAPDEF("stab", NULL, MCF_ALIASOK|MCF_ALIASONLY,
603 map_parseargs, stab_map_open, null_map_close,
604 stab_map_lookup, stab_map_store);
605
606 MAPDEF("implicit", NULL, MCF_ALIASOK|MCF_ALIASONLY|MCF_REBUILDABLE,
607 map_parseargs, impl_map_open, impl_map_close,
608 impl_map_lookup, impl_map_store);
609
610 /* access to system passwd file */
611 MAPDEF("user", NULL, MCF_OPTFILE,
612 map_parseargs, user_map_open, null_map_close,
613 user_map_lookup, null_map_store);
614
615 /* dequote map */
616 MAPDEF("dequote", NULL, 0,
617 dequote_init, null_map_open, null_map_close,
618 dequote_map, null_map_store);
619
620 #if MAP_REGEX
621 MAPDEF("regex", NULL, 0,
622 regex_map_init, null_map_open, null_map_close,
623 regex_map_lookup, null_map_store);
624 #endif /* MAP_REGEX */
625
626 #if USERDB
627 /* user database */
628 MAPDEF("userdb", ".db", 0,
629 map_parseargs, null_map_open, null_map_close,
630 udb_map_lookup, null_map_store);
631 #endif /* USERDB */
632
633 /* arbitrary programs */
634 MAPDEF("program", NULL, MCF_ALIASOK,
635 map_parseargs, null_map_open, null_map_close,
636 prog_map_lookup, null_map_store);
637
638 /* sequenced maps */
639 MAPDEF("sequence", NULL, MCF_ALIASOK,
640 seq_map_parse, null_map_open, null_map_close,
641 seq_map_lookup, seq_map_store);
642
643 /* switched interface to sequenced maps */
644 MAPDEF("switch", NULL, MCF_ALIASOK,
645 map_parseargs, switch_map_open, null_map_close,
646 seq_map_lookup, seq_map_store);
647
648 /* null map lookup -- really for internal use only */
649 MAPDEF("null", NULL, MCF_ALIASOK|MCF_OPTFILE,
650 map_parseargs, null_map_open, null_map_close,
651 null_map_lookup, null_map_store);
652
653 /* syslog map -- logs information to syslog */
654 MAPDEF("syslog", NULL, 0,
655 syslog_map_parseargs, null_map_open, null_map_close,
656 syslog_map_lookup, null_map_store);
657
658 /* macro storage map -- rulesets can set macros */
659 MAPDEF("macro", NULL, 0,
660 dequote_init, null_map_open, null_map_close,
661 macro_map_lookup, null_map_store);
662
663 /* arithmetic map -- add/subtract/compare */
664 MAPDEF("arith", NULL, 0,
665 dequote_init, null_map_open, null_map_close,
666 arith_map_lookup, null_map_store);
667
668 #if SOCKETMAP
669 /* arbitrary daemons */
670 MAPDEF("socket", NULL, MCF_ALIASOK,
671 map_parseargs, socket_map_open, socket_map_close,
672 socket_map_lookup, null_map_store);
673 #endif /* SOCKETMAP */
674
675 #if _FFR_DPRINTF_MAP
676 /* dprintf map -- logs information to syslog */
677 MAPDEF("dprintf", NULL, 0,
678 dprintf_map_parseargs, null_map_open, null_map_close,
679 dprintf_map_lookup, null_map_store);
680 #endif /* _FFR_DPRINTF_MAP */
681
682 if (tTd(38, 2))
683 {
684 /* bogus map -- always return tempfail */
685 MAPDEF("bogus", NULL, MCF_ALIASOK|MCF_OPTFILE,
686 map_parseargs, null_map_open, null_map_close,
687 bogus_map_lookup, null_map_store);
688 }
689 }
690
691 #undef MAPDEF
692 /*
693 ** INITHOSTMAPS -- initial host-dependent maps
694 **
695 ** This should act as an interface to any local service switch
696 ** provided by the host operating system.
697 **
698 ** Parameters:
699 ** none
700 **
701 ** Returns:
702 ** none
703 **
704 ** Side Effects:
705 ** Should define maps "host" and "users" as necessary
706 ** for this OS. If they are not defined, they will get
707 ** a default value later. It should check to make sure
708 ** they are not defined first, since it's possible that
709 ** the config file has provided an override.
710 */
711
712 void
713 inithostmaps()
714 {
715 register int i;
716 int nmaps;
717 char *maptype[MAXMAPSTACK];
718 short mapreturn[MAXMAPACTIONS];
719 char buf[MAXLINE];
720
721 /*
722 ** Make sure we have a host map.
723 */
724
725 if (stab("host", ST_MAP, ST_FIND) == NULL)
726 {
727 /* user didn't initialize: set up host map */
728 (void) sm_strlcpy(buf, "host host", sizeof(buf));
729 #if NAMED_BIND
730 if (ConfigLevel >= 2)
731 (void) sm_strlcat(buf, " -a. -D", sizeof(buf));
732 #endif /* NAMED_BIND */
733 (void) makemapentry(buf);
734 }
735
736 /*
737 ** Set up default aliases maps
738 */
739
740 nmaps = switch_map_find("aliases", maptype, mapreturn);
741 for (i = 0; i < nmaps; i++)
742 {
743 if (strcmp(maptype[i], "files") == 0 &&
744 stab("aliases.files", ST_MAP, ST_FIND) == NULL)
745 {
746 (void) sm_strlcpy(buf, "aliases.files null",
747 sizeof(buf));
748 (void) makemapentry(buf);
749 }
750 #if NISPLUS
751 else if (strcmp(maptype[i], "nisplus") == 0 &&
752 stab("aliases.nisplus", ST_MAP, ST_FIND) == NULL)
753 {
754 (void) sm_strlcpy(buf, "aliases.nisplus nisplus -kalias -vexpansion mail_aliases.org_dir",
755 sizeof(buf));
756 (void) makemapentry(buf);
757 }
758 #endif /* NISPLUS */
759 #if NIS
760 else if (strcmp(maptype[i], "nis") == 0 &&
761 stab("aliases.nis", ST_MAP, ST_FIND) == NULL)
762 {
763 (void) sm_strlcpy(buf, "aliases.nis nis mail.aliases",
764 sizeof(buf));
765 (void) makemapentry(buf);
766 }
767 #endif /* NIS */
768 #if NETINFO
769 else if (strcmp(maptype[i], "netinfo") == 0 &&
770 stab("aliases.netinfo", ST_MAP, ST_FIND) == NULL)
771 {
772 (void) sm_strlcpy(buf, "aliases.netinfo netinfo -z, /aliases",
773 sizeof(buf));
774 (void) makemapentry(buf);
775 }
776 #endif /* NETINFO */
777 #if HESIOD
778 else if (strcmp(maptype[i], "hesiod") == 0 &&
779 stab("aliases.hesiod", ST_MAP, ST_FIND) == NULL)
780 {
781 (void) sm_strlcpy(buf, "aliases.hesiod hesiod aliases",
782 sizeof(buf));
783 (void) makemapentry(buf);
784 }
785 #endif /* HESIOD */
786 #if LDAPMAP && defined(SUN_EXTENSIONS) && \
787 defined(SUN_SIMPLIFIED_LDAP) && HASLDAPGETALIASBYNAME
788 else if (strcmp(maptype[i], "ldap") == 0 &&
789 stab("aliases.ldap", ST_MAP, ST_FIND) == NULL)
790 {
791 (void) sm_strlcpy(buf, "aliases.ldap ldap -b . -h localhost -k mail=%0 -v mailgroup",
792 sizeof buf);
793 (void) makemapentry(buf);
794 }
795 #endif /* LDAPMAP && defined(SUN_EXTENSIONS) && ... */
796 }
797 if (stab("aliases", ST_MAP, ST_FIND) == NULL)
798 {
799 (void) sm_strlcpy(buf, "aliases switch aliases", sizeof(buf));
800 (void) makemapentry(buf);
801 }
802 }
803
804 /*
805 ** SWITCH_MAP_FIND -- find the list of types associated with a map
806 **
807 ** This is the system-dependent interface to the service switch.
808 **
809 ** Parameters:
810 ** service -- the name of the service of interest.
811 ** maptype -- an out-array of strings containing the types
812 ** of access to use for this service. There can
813 ** be at most MAXMAPSTACK types for a single service.
814 ** mapreturn -- an out-array of return information bitmaps
815 ** for the map.
816 **
817 ** Returns:
818 ** The number of map types filled in, or -1 for failure.
819 **
820 ** Side effects:
821 ** Preserves errno so nothing in the routine clobbers it.
822 */
823
824 #if defined(SOLARIS) || (defined(sony_news) && defined(__svr4))
825 # define _USE_SUN_NSSWITCH_
826 #endif /* defined(SOLARIS) || (defined(sony_news) && defined(__svr4)) */
827
828 #if _FFR_HPUX_NSSWITCH
829 # ifdef __hpux
830 # define _USE_SUN_NSSWITCH_
831 # endif /* __hpux */
832 #endif /* _FFR_HPUX_NSSWITCH */
833
834 #ifdef _USE_SUN_NSSWITCH_
835 # include <nsswitch.h>
836 #endif /* _USE_SUN_NSSWITCH_ */
837
838 #if defined(ultrix) || (defined(__osf__) && defined(__alpha))
839 # define _USE_DEC_SVC_CONF_
840 #endif /* defined(ultrix) || (defined(__osf__) && defined(__alpha)) */
841
842 #ifdef _USE_DEC_SVC_CONF_
843 # include <sys/svcinfo.h>
844 #endif /* _USE_DEC_SVC_CONF_ */
845
846 int
847 switch_map_find(service, maptype, mapreturn)
848 char *service;
849 char *maptype[MAXMAPSTACK];
850 short mapreturn[MAXMAPACTIONS];
851 {
852 int svcno = 0;
853 int save_errno = errno;
854
855 #ifdef _USE_SUN_NSSWITCH_
856 struct __nsw_switchconfig *nsw_conf;
857 enum __nsw_parse_err pserr;
858 struct __nsw_lookup *lk;
859 static struct __nsw_lookup lkp0 =
860 { "files", {1, 0, 0, 0}, NULL, NULL };
861 static struct __nsw_switchconfig lkp_default =
862 { 0, "sendmail", 3, &lkp0 };
863
864 for (svcno = 0; svcno < MAXMAPACTIONS; svcno++)
865 mapreturn[svcno] = 0;
866
867 if ((nsw_conf = __nsw_getconfig(service, &pserr)) == NULL)
868 lk = lkp_default.lookups;
869 else
870 lk = nsw_conf->lookups;
871 svcno = 0;
872 while (lk != NULL && svcno < MAXMAPSTACK)
873 {
874 maptype[svcno] = lk->service_name;
875 if (lk->actions[__NSW_NOTFOUND] == __NSW_RETURN)
876 mapreturn[MA_NOTFOUND] |= 1 << svcno;
877 if (lk->actions[__NSW_TRYAGAIN] == __NSW_RETURN)
878 mapreturn[MA_TRYAGAIN] |= 1 << svcno;
879 if (lk->actions[__NSW_UNAVAIL] == __NSW_RETURN)
880 mapreturn[MA_TRYAGAIN] |= 1 << svcno;
881 svcno++;
882 lk = lk->next;
883 }
884 errno = save_errno;
885 return svcno;
886 #endif /* _USE_SUN_NSSWITCH_ */
887
888 #ifdef _USE_DEC_SVC_CONF_
889 struct svcinfo *svcinfo;
890 int svc;
891
892 for (svcno = 0; svcno < MAXMAPACTIONS; svcno++)
893 mapreturn[svcno] = 0;
894
895 svcinfo = getsvc();
896 if (svcinfo == NULL)
897 goto punt;
898 if (strcmp(service, "hosts") == 0)
899 svc = SVC_HOSTS;
900 else if (strcmp(service, "aliases") == 0)
901 svc = SVC_ALIASES;
902 else if (strcmp(service, "passwd") == 0)
903 svc = SVC_PASSWD;
904 else
905 {
906 errno = save_errno;
907 return -1;
908 }
909 for (svcno = 0; svcno < SVC_PATHSIZE && svcno < MAXMAPSTACK; svcno++)
910 {
911 switch (svcinfo->svcpath[svc][svcno])
912 {
913 case SVC_LOCAL:
914 maptype[svcno] = "files";
915 break;
916
917 case SVC_YP:
918 maptype[svcno] = "nis";
919 break;
920
921 case SVC_BIND:
922 maptype[svcno] = "dns";
923 break;
924
925 # ifdef SVC_HESIOD
926 case SVC_HESIOD:
927 maptype[svcno] = "hesiod";
928 break;
929 # endif /* SVC_HESIOD */
930
931 case SVC_LAST:
932 errno = save_errno;
933 return svcno;
934 }
935 }
936 errno = save_errno;
937 return svcno;
938 #endif /* _USE_DEC_SVC_CONF_ */
939
940 #if !defined(_USE_SUN_NSSWITCH_) && !defined(_USE_DEC_SVC_CONF_)
941 /*
942 ** Fall-back mechanism.
943 */
944
945 STAB *st;
946 static time_t servicecachetime; /* time service switch was cached */
947 time_t now = curtime();
948
949 for (svcno = 0; svcno < MAXMAPACTIONS; svcno++)
950 mapreturn[svcno] = 0;
951
952 if ((now - servicecachetime) > (time_t) ServiceCacheMaxAge)
953 {
954 /* (re)read service switch */
955 register SM_FILE_T *fp;
956 long sff = SFF_REGONLY|SFF_OPENASROOT|SFF_NOLOCK;
957
958 if (!bitnset(DBS_LINKEDSERVICESWITCHFILEINWRITABLEDIR,
959 DontBlameSendmail))
960 sff |= SFF_NOWLINK;
961
962 if (ConfigFileRead)
963 servicecachetime = now;
964 fp = safefopen(ServiceSwitchFile, O_RDONLY, 0, sff);
965 if (fp != NULL)
966 {
967 char buf[MAXLINE];
968
969 while (sm_io_fgets(fp, SM_TIME_DEFAULT, buf,
970 sizeof(buf)) != NULL)
971 {
972 register char *p;
973
974 p = strpbrk(buf, "#\n");
975 if (p != NULL)
976 *p = '\0';
977 #ifndef SM_NSSWITCH_DELIMS
978 # define SM_NSSWITCH_DELIMS " \t"
979 #endif /* SM_NSSWITCH_DELIMS */
980 p = strpbrk(buf, SM_NSSWITCH_DELIMS);
981 if (p != NULL)
982 *p++ = '\0';
983 if (buf[0] == '\0')
984 continue;
985 if (p == NULL)
986 {
987 sm_syslog(LOG_ERR, NOQID,
988 "Bad line on %.100s: %.100s",
989 ServiceSwitchFile,
990 buf);
991 continue;
992 }
993 while (isascii(*p) && isspace(*p))
994 p++;
995 if (*p == '\0')
996 continue;
997
998 /*
999 ** Find/allocate space for this service entry.
1000 ** Space for all of the service strings
1001 ** are allocated at once. This means
1002 ** that we only have to free the first
1003 ** one to free all of them.
1004 */
1005
1006 st = stab(buf, ST_SERVICE, ST_ENTER);
1007 if (st->s_service[0] != NULL)
1008 sm_free((void *) st->s_service[0]); /* XXX */
1009 p = newstr(p);
1010 for (svcno = 0; svcno < MAXMAPSTACK; )
1011 {
1012 if (*p == '\0')
1013 break;
1014 st->s_service[svcno++] = p;
1015 p = strpbrk(p, " \t");
1016 if (p == NULL)
1017 break;
1018 *p++ = '\0';
1019 while (isascii(*p) && isspace(*p))
1020 p++;
1021 }
1022 if (svcno < MAXMAPSTACK)
1023 st->s_service[svcno] = NULL;
1024 }
1025 (void) sm_io_close(fp, SM_TIME_DEFAULT);
1026 }
1027 }
1028
1029 /* look up entry in cache */
1030 st = stab(service, ST_SERVICE, ST_FIND);
1031 if (st != NULL && st->s_service[0] != NULL)
1032 {
1033 /* extract data */
1034 svcno = 0;
1035 while (svcno < MAXMAPSTACK)
1036 {
1037 maptype[svcno] = st->s_service[svcno];
1038 if (maptype[svcno++] == NULL)
1039 break;
1040 }
1041 errno = save_errno;
1042 return --svcno;
1043 }
1044 #endif /* !defined(_USE_SUN_NSSWITCH_) && !defined(_USE_DEC_SVC_CONF_) */
1045
1046 #if !defined(_USE_SUN_NSSWITCH_)
1047 /* if the service file doesn't work, use an absolute fallback */
1048 # ifdef _USE_DEC_SVC_CONF_
1049 punt:
1050 # endif /* _USE_DEC_SVC_CONF_ */
1051 for (svcno = 0; svcno < MAXMAPACTIONS; svcno++)
1052 mapreturn[svcno] = 0;
1053 svcno = 0;
1054 if (strcmp(service, "aliases") == 0)
1055 {
1056 maptype[svcno++] = "files";
1057 # if defined(AUTO_NETINFO_ALIASES) && defined (NETINFO)
1058 maptype[svcno++] = "netinfo";
1059 # endif /* defined(AUTO_NETINFO_ALIASES) && defined (NETINFO) */
1060 # ifdef AUTO_NIS_ALIASES
1061 # if NISPLUS
1062 maptype[svcno++] = "nisplus";
1063 # endif /* NISPLUS */
1064 # if NIS
1065 maptype[svcno++] = "nis";
1066 # endif /* NIS */
1067 # endif /* AUTO_NIS_ALIASES */
1068 errno = save_errno;
1069 return svcno;
1070 }
1071 if (strcmp(service, "hosts") == 0)
1072 {
1073 # if NAMED_BIND
1074 maptype[svcno++] = "dns";
1075 # else /* NAMED_BIND */
1076 # if defined(sun) && !defined(BSD)
1077 /* SunOS */
1078 maptype[svcno++] = "nis";
1079 # endif /* defined(sun) && !defined(BSD) */
1080 # endif /* NAMED_BIND */
1081 # if defined(AUTO_NETINFO_HOSTS) && defined (NETINFO)
1082 maptype[svcno++] = "netinfo";
1083 # endif /* defined(AUTO_NETINFO_HOSTS) && defined (NETINFO) */
1084 maptype[svcno++] = "files";
1085 errno = save_errno;
1086 return svcno;
1087 }
1088 errno = save_errno;
1089 return -1;
1090 #endif /* !defined(_USE_SUN_NSSWITCH_) */
1091 }
1092 /*
1093 ** USERNAME -- return the user id of the logged in user.
1094 **
1095 ** Parameters:
1096 ** none.
1097 **
1098 ** Returns:
1099 ** The login name of the logged in user.
1100 **
1101 ** Side Effects:
1102 ** none.
1103 **
1104 ** Notes:
1105 ** The return value is statically allocated.
1106 */
1107
1108 char *
1109 username()
1110 {
1111 static char *myname = NULL;
1112 extern char *getlogin();
1113 register struct passwd *pw;
1114
1115 /* cache the result */
1116 if (myname == NULL)
1117 {
1118 myname = getlogin();
1119 if (myname == NULL || myname[0] == '\0')
1120 {
1121 pw = sm_getpwuid(RealUid);
1122 if (pw != NULL)
1123 myname = pw->pw_name;
1124 }
1125 else
1126 {
1127 uid_t uid = RealUid;
1128
1129 if ((pw = sm_getpwnam(myname)) == NULL ||
1130 (uid != 0 && uid != pw->pw_uid))
1131 {
1132 pw = sm_getpwuid(uid);
1133 if (pw != NULL)
1134 myname = pw->pw_name;
1135 }
1136 }
1137 if (myname == NULL || myname[0] == '\0')
1138 {
1139 syserr("554 5.3.0 Who are you?");
1140 myname = "postmaster";
1141 }
1142 else if (strpbrk(myname, ",;:/|\"\\") != NULL)
1143 myname = addquotes(myname, NULL);
1144 else
1145 myname = sm_pstrdup_x(myname);
1146 }
1147 return myname;
1148 }
1149 /*
1150 ** TTYPATH -- Get the path of the user's tty
1151 **
1152 ** Returns the pathname of the user's tty. Returns NULL if
1153 ** the user is not logged in or if s/he has write permission
1154 ** denied.
1155 **
1156 ** Parameters:
1157 ** none
1158 **
1159 ** Returns:
1160 ** pathname of the user's tty.
1161 ** NULL if not logged in or write permission denied.
1162 **
1163 ** Side Effects:
1164 ** none.
1165 **
1166 ** WARNING:
1167 ** Return value is in a local buffer.
1168 **
1169 ** Called By:
1170 ** savemail
1171 */
1172
1173 char *
1174 ttypath()
1175 {
1176 struct stat stbuf;
1177 register char *pathn;
1178 extern char *ttyname();
1179 extern char *getlogin();
1180
1181 /* compute the pathname of the controlling tty */
1182 if ((pathn = ttyname(2)) == NULL && (pathn = ttyname(1)) == NULL &&
1183 (pathn = ttyname(0)) == NULL)
1184 {
1185 errno = 0;
1186 return NULL;
1187 }
1188
1189 /* see if we have write permission */
1190 if (stat(pathn, &stbuf) < 0 || !bitset(S_IWOTH, stbuf.st_mode))
1191 {
1192 errno = 0;
1193 return NULL;
1194 }
1195
1196 /* see if the user is logged in */
1197 if (getlogin() == NULL)
1198 return NULL;
1199
1200 /* looks good */
1201 return pathn;
1202 }
1203 /*
1204 ** CHECKCOMPAT -- check for From and To person compatible.
1205 **
1206 ** This routine can be supplied on a per-installation basis
1207 ** to determine whether a person is allowed to send a message.
1208 ** This allows restriction of certain types of internet
1209 ** forwarding or registration of users.
1210 **
1211 ** If the hosts are found to be incompatible, an error
1212 ** message should be given using "usrerr" and an EX_ code
1213 ** should be returned. You can also set to->q_status to
1214 ** a DSN-style status code.
1215 **
1216 ** EF_NO_BODY_RETN can be set in e->e_flags to suppress the
1217 ** body during the return-to-sender function; this should be done
1218 ** on huge messages. This bit may already be set by the ESMTP
1219 ** protocol.
1220 **
1221 ** Parameters:
1222 ** to -- the person being sent to.
1223 **
1224 ** Returns:
1225 ** an exit status
1226 **
1227 ** Side Effects:
1228 ** none (unless you include the usrerr stuff)
1229 */
1230
1231 int
1232 checkcompat(to, e)
1233 register ADDRESS *to;
1234 register ENVELOPE *e;
1235 {
1236 if (tTd(49, 1))
1237 sm_dprintf("checkcompat(to=%s, from=%s)\n",
1238 to->q_paddr, e->e_from.q_paddr);
1239
1240 #ifdef EXAMPLE_CODE
1241 /* this code is intended as an example only */
1242 register STAB *s;
1243
1244 s = stab("arpa", ST_MAILER, ST_FIND);
1245 if (s != NULL && strcmp(e->e_from.q_mailer->m_name, "local") != 0 &&
1246 to->q_mailer == s->s_mailer)
1247 {
1248 usrerr("553 No ARPA mail through this machine: see your system administration");
1249 /* e->e_flags |= EF_NO_BODY_RETN; to suppress body on return */
1250 to->q_status = "5.7.1";
1251 return EX_UNAVAILABLE;
1252 }
1253 #endif /* EXAMPLE_CODE */
1254 return EX_OK;
1255 }
1256
1257 #ifdef SUN_EXTENSIONS
1258 static void
1259 init_md_sun()
1260 {
1261 struct stat sbuf;
1262
1263 /* Check for large file descriptor */
1264 if (fstat(fileno(stdin), &sbuf) < 0)
1265 {
1266 if (errno == EOVERFLOW)
1267 {
1268 perror("stdin");
1269 exit(EX_NOINPUT);
1270 }
1271 }
1272 }
1273 #endif /* SUN_EXTENSIONS */
1274
1275 /*
1276 ** INIT_MD -- do machine dependent initializations
1277 **
1278 ** Systems that have global modes that should be set should do
1279 ** them here rather than in main.
1280 */
1281
1282 #ifdef _AUX_SOURCE
1283 # include <compat.h>
1284 #endif /* _AUX_SOURCE */
1285
1286 #if SHARE_V1
1287 # include <shares.h>
1288 #endif /* SHARE_V1 */
1289
1290 void
1291 init_md(argc, argv)
1292 int argc;
1293 char **argv;
1294 {
1295 #ifdef _AUX_SOURCE
1296 setcompat(getcompat() | COMPAT_BSDPROT);
1297 #endif /* _AUX_SOURCE */
1298
1299 #ifdef SUN_EXTENSIONS
1300 init_md_sun();
1301 #endif /* SUN_EXTENSIONS */
1302
1303 #if _CONVEX_SOURCE
1304 /* keep gethostby*() from stripping the local domain name */
1305 set_domain_trim_off();
1306 #endif /* _CONVEX_SOURCE */
1307 #if defined(__QNX__) && !defined(__QNXNTO__)
1308 /*
1309 ** Due to QNX's network distributed nature, you can target a tcpip
1310 ** stack on a different node in the qnx network; this patch lets
1311 ** this feature work. The __sock_locate() must be done before the
1312 ** environment is clear.
1313 */
1314 __sock_locate();
1315 #endif /* __QNX__ */
1316 #if SECUREWARE || defined(_SCO_unix_)
1317 set_auth_parameters(argc, argv);
1318
1319 # ifdef _SCO_unix_
1320 /*
1321 ** This is required for highest security levels (the kernel
1322 ** won't let it call set*uid() or run setuid binaries without
1323 ** it). It may be necessary on other SECUREWARE systems.
1324 */
1325
1326 if (getluid() == -1)
1327 setluid(0);
1328 # endif /* _SCO_unix_ */
1329 #endif /* SECUREWARE || defined(_SCO_unix_) */
1330
1331
1332 #ifdef VENDOR_DEFAULT
1333 VendorCode = VENDOR_DEFAULT;
1334 #else /* VENDOR_DEFAULT */
1335 VendorCode = VENDOR_BERKELEY;
1336 #endif /* VENDOR_DEFAULT */
1337 }
1338 /*
1339 ** INIT_VENDOR_MACROS -- vendor-dependent macro initializations
1340 **
1341 ** Called once, on startup.
1342 **
1343 ** Parameters:
1344 ** e -- the global envelope.
1345 **
1346 ** Returns:
1347 ** none.
1348 **
1349 ** Side Effects:
1350 ** vendor-dependent.
1351 */
1352
1353 void
1354 init_vendor_macros(e)
1355 register ENVELOPE *e;
1356 {
1357 }
1358 /*
1359 ** GETLA -- get the current load average
1360 **
1361 ** This code stolen from la.c.
1362 **
1363 ** Parameters:
1364 ** none.
1365 **
1366 ** Returns:
1367 ** The current load average as an integer.
1368 **
1369 ** Side Effects:
1370 ** none.
1371 */
1372
1373 /* try to guess what style of load average we have */
1374 #define LA_ZERO 1 /* always return load average as zero */
1375 #define LA_INT 2 /* read kmem for avenrun; interpret as long */
1376 #define LA_FLOAT 3 /* read kmem for avenrun; interpret as float */
1377 #define LA_SUBR 4 /* call getloadavg */
1378 #define LA_MACH 5 /* MACH load averages (as on NeXT boxes) */
1379 #define LA_SHORT 6 /* read kmem for avenrun; interpret as short */
1380 #define LA_PROCSTR 7 /* read string ("1.17") from /proc/loadavg */
1381 #define LA_READKSYM 8 /* SVR4: use MIOC_READKSYM ioctl call */
1382 #define LA_DGUX 9 /* special DGUX implementation */
1383 #define LA_HPUX 10 /* special HPUX implementation */
1384 #define LA_IRIX6 11 /* special IRIX 6.2 implementation */
1385 #define LA_KSTAT 12 /* special Solaris kstat(3k) implementation */
1386 #define LA_DEVSHORT 13 /* read short from a device */
1387 #define LA_ALPHAOSF 14 /* Digital UNIX (OSF/1 on Alpha) table() call */
1388 #define LA_PSET 15 /* Solaris per-processor-set load average */
1389 #define LA_LONGLONG 17 /* read kmem for avenrun; interpret as long long */
1390
1391 /* do guesses based on general OS type */
1392 #ifndef LA_TYPE
1393 # define LA_TYPE LA_ZERO
1394 #endif /* ! LA_TYPE */
1395
1396 #ifndef FSHIFT
1397 # if defined(unixpc)
1398 # define FSHIFT 5
1399 # endif /* defined(unixpc) */
1400
1401 # if defined(__alpha) || defined(IRIX)
1402 # define FSHIFT 10
1403 # endif /* defined(__alpha) || defined(IRIX) */
1404
1405 #endif /* ! FSHIFT */
1406
1407 #ifndef FSHIFT
1408 # define FSHIFT 8
1409 #endif /* ! FSHIFT */
1410
1411 #ifndef FSCALE
1412 # define FSCALE (1 << FSHIFT)
1413 #endif /* ! FSCALE */
1414
1415 #ifndef LA_AVENRUN
1416 # ifdef SYSTEM5
1417 # define LA_AVENRUN "avenrun"
1418 # else /* SYSTEM5 */
1419 # define LA_AVENRUN "_avenrun"
1420 # endif /* SYSTEM5 */
1421 #endif /* ! LA_AVENRUN */
1422
1423 /* _PATH_KMEM should be defined in <paths.h> */
1424 #ifndef _PATH_KMEM
1425 # define _PATH_KMEM "/dev/kmem"
1426 #endif /* ! _PATH_KMEM */
1427
1428 #if (LA_TYPE == LA_INT) || (LA_TYPE == LA_FLOAT) || (LA_TYPE == LA_SHORT) || (LA_TYPE == LA_LONGLONG)
1429
1430 # include <nlist.h>
1431
1432 /* _PATH_UNIX should be defined in <paths.h> */
1433 # ifndef _PATH_UNIX
1434 # if defined(SYSTEM5)
1435 # define _PATH_UNIX "/unix"
1436 # else /* defined(SYSTEM5) */
1437 # define _PATH_UNIX "/vmunix"
1438 # endif /* defined(SYSTEM5) */
1439 # endif /* ! _PATH_UNIX */
1440
1441 # ifdef _AUX_SOURCE
1442 struct nlist Nl[2];
1443 # else /* _AUX_SOURCE */
1444 struct nlist Nl[] =
1445 {
1446 { LA_AVENRUN },
1447 { 0 },
1448 };
1449 # endif /* _AUX_SOURCE */
1450 # define X_AVENRUN 0
1451
1452 int
1453 getla()
1454 {
1455 int j;
1456 static int kmem = -1;
1457 # if LA_TYPE == LA_INT
1458 long avenrun[3];
1459 # else /* LA_TYPE == LA_INT */
1460 # if LA_TYPE == LA_SHORT
1461 short avenrun[3];
1462 # else
1463 # if LA_TYPE == LA_LONGLONG
1464 long long avenrun[3];
1465 # else /* LA_TYPE == LA_LONGLONG */
1466 double avenrun[3];
1467 # endif /* LA_TYPE == LA_LONGLONG */
1468 # endif /* LA_TYPE == LA_SHORT */
1469 # endif /* LA_TYPE == LA_INT */
1470 extern off_t lseek();
1471
1472 if (kmem < 0)
1473 {
1474 # ifdef _AUX_SOURCE
1475 (void) sm_strlcpy(Nl[X_AVENRUN].n_name, LA_AVENRUN,
1476 sizeof(Nl[X_AVENRUN].n_name));
1477 Nl[1].n_name[0] = '\0';
1478 # endif /* _AUX_SOURCE */
1479
1480 # if defined(_AIX3) || defined(_AIX4)
1481 if (knlist(Nl, 1, sizeof(Nl[0])) < 0)
1482 # else /* defined(_AIX3) || defined(_AIX4) */
1483 if (nlist(_PATH_UNIX, Nl) < 0)
1484 # endif /* defined(_AIX3) || defined(_AIX4) */
1485 {
1486 if (tTd(3, 1))
1487 sm_dprintf("getla: nlist(%s): %s\n", _PATH_UNIX,
1488 sm_errstring(errno));
1489 return -1;
1490 }
1491 if (Nl[X_AVENRUN].n_value == 0)
1492 {
1493 if (tTd(3, 1))
1494 sm_dprintf("getla: nlist(%s, %s) ==> 0\n",
1495 _PATH_UNIX, LA_AVENRUN);
1496 return -1;
1497 }
1498 # ifdef NAMELISTMASK
1499 Nl[X_AVENRUN].n_value &= NAMELISTMASK;
1500 # endif /* NAMELISTMASK */
1501
1502 kmem = open(_PATH_KMEM, 0, 0);
1503 if (kmem < 0)
1504 {
1505 if (tTd(3, 1))
1506 sm_dprintf("getla: open(/dev/kmem): %s\n",
1507 sm_errstring(errno));
1508 return -1;
1509 }
1510 if ((j = fcntl(kmem, F_GETFD, 0)) < 0 ||
1511 fcntl(kmem, F_SETFD, j | FD_CLOEXEC) < 0)
1512 {
1513 if (tTd(3, 1))
1514 sm_dprintf("getla: fcntl(/dev/kmem, FD_CLOEXEC): %s\n",
1515 sm_errstring(errno));
1516 (void) close(kmem);
1517 kmem = -1;
1518 return -1;
1519 }
1520 }
1521 if (tTd(3, 20))
1522 sm_dprintf("getla: symbol address = %#lx\n",
1523 (unsigned long) Nl[X_AVENRUN].n_value);
1524 if (lseek(kmem, (off_t) Nl[X_AVENRUN].n_value, SEEK_SET) == -1 ||
1525 read(kmem, (char *) avenrun, sizeof(avenrun)) != sizeof(avenrun))
1526 {
1527 /* thank you Ian */
1528 if (tTd(3, 1))
1529 sm_dprintf("getla: lseek or read: %s\n",
1530 sm_errstring(errno));
1531 return -1;
1532 }
1533 # if (LA_TYPE == LA_INT) || (LA_TYPE == LA_SHORT) || (LA_TYPE == LA_LONGLONG)
1534 if (tTd(3, 5))
1535 {
1536 # if LA_TYPE == LA_SHORT
1537 sm_dprintf("getla: avenrun = %d", avenrun[0]);
1538 if (tTd(3, 15))
1539 sm_dprintf(", %d, %d", avenrun[1], avenrun[2]);
1540 # else /* LA_TYPE == LA_SHORT */
1541 # if LA_TYPE == LA_LONGLONG
1542 sm_dprintf("getla: avenrun = %lld", avenrun[0]);
1543 if (tTd(3, 15))
1544 sm_dprintf(", %lld, %lld", avenrun[1], avenrun[2]);
1545 # else /* LA_TYPE == LA_LONGLONG */
1546 sm_dprintf("getla: avenrun = %ld", avenrun[0]);
1547 if (tTd(3, 15))
1548 sm_dprintf(", %ld, %ld", avenrun[1], avenrun[2]);
1549 # endif /* LA_TYPE == LA_LONGLONG */
1550 # endif /* LA_TYPE == LA_SHORT */
1551 sm_dprintf("\n");
1552 }
1553 if (tTd(3, 1))
1554 sm_dprintf("getla: %d\n",
1555 (int) (avenrun[0] + FSCALE/2) >> FSHIFT);
1556 return ((int) (avenrun[0] + FSCALE/2) >> FSHIFT);
1557 # else /* (LA_TYPE == LA_INT) || (LA_TYPE == LA_SHORT) || (LA_TYPE == LA_LONGLONG) */
1558 if (tTd(3, 5))
1559 {
1560 sm_dprintf("getla: avenrun = %g", avenrun[0]);
1561 if (tTd(3, 15))
1562 sm_dprintf(", %g, %g", avenrun[1], avenrun[2]);
1563 sm_dprintf("\n");
1564 }
1565 if (tTd(3, 1))
1566 sm_dprintf("getla: %d\n", (int) (avenrun[0] +0.5));
1567 return ((int) (avenrun[0] + 0.5));
1568 # endif /* (LA_TYPE == LA_INT) || (LA_TYPE == LA_SHORT) || (LA_TYPE == LA_LONGLONG) */
1569 }
1570
1571 #endif /* (LA_TYPE == LA_INT) || (LA_TYPE == LA_FLOAT) || (LA_TYPE == LA_SHORT) || (LA_TYPE == LA_LONGLONG) */
1572
1573 #if LA_TYPE == LA_READKSYM
1574
1575 # include <sys/ksym.h>
1576
1577 int
1578 getla()
1579 {
1580 int j;
1581 static int kmem = -1;
1582 long avenrun[3];
1583 struct mioc_rksym mirk;
1584
1585 if (kmem < 0)
1586 {
1587 kmem = open("/dev/kmem", 0, 0);
1588 if (kmem < 0)
1589 {
1590 if (tTd(3, 1))
1591 sm_dprintf("getla: open(/dev/kmem): %s\n",
1592 sm_errstring(errno));
1593 return -1;
1594 }
1595 if ((j = fcntl(kmem, F_GETFD, 0)) < 0 ||
1596 fcntl(kmem, F_SETFD, j | FD_CLOEXEC) < 0)
1597 {
1598 if (tTd(3, 1))
1599 sm_dprintf("getla: fcntl(/dev/kmem, FD_CLOEXEC): %s\n",
1600 sm_errstring(errno));
1601 (void) close(kmem);
1602 kmem = -1;
1603 return -1;
1604 }
1605 }
1606 mirk.mirk_symname = LA_AVENRUN;
1607 mirk.mirk_buf = avenrun;
1608 mirk.mirk_buflen = sizeof(avenrun);
1609 if (ioctl(kmem, MIOC_READKSYM, &mirk) < 0)
1610 {
1611 if (tTd(3, 1))
1612 sm_dprintf("getla: ioctl(MIOC_READKSYM) failed: %s\n",
1613 sm_errstring(errno));
1614 return -1;
1615 }
1616 if (tTd(3, 5))
1617 {
1618 sm_dprintf("getla: avenrun = %d", avenrun[0]);
1619 if (tTd(3, 15))
1620 sm_dprintf(", %d, %d", avenrun[1], avenrun[2]);
1621 sm_dprintf("\n");
1622 }
1623 if (tTd(3, 1))
1624 sm_dprintf("getla: %d\n",
1625 (int) (avenrun[0] + FSCALE/2) >> FSHIFT);
1626 return ((int) (avenrun[0] + FSCALE/2) >> FSHIFT);
1627 }
1628
1629 #endif /* LA_TYPE == LA_READKSYM */
1630
1631 #if LA_TYPE == LA_DGUX
1632
1633 # include <sys/dg_sys_info.h>
1634
1635 int
1636 getla()
1637 {
1638 struct dg_sys_info_load_info load_info;
1639
1640 dg_sys_info((long *)&load_info,
1641 DG_SYS_INFO_LOAD_INFO_TYPE, DG_SYS_INFO_LOAD_VERSION_0);
1642
1643 if (tTd(3, 1))
1644 sm_dprintf("getla: %d\n", (int) (load_info.one_minute + 0.5));
1645
1646 return ((int) (load_info.one_minute + 0.5));
1647 }
1648
1649 #endif /* LA_TYPE == LA_DGUX */
1650
1651 #if LA_TYPE == LA_HPUX
1652
1653 /* forward declarations to keep gcc from complaining */
1654 struct pst_dynamic;
1655 struct pst_status;
1656 struct pst_static;
1657 struct pst_vminfo;
1658 struct pst_diskinfo;
1659 struct pst_processor;
1660 struct pst_lv;
1661 struct pst_swapinfo;
1662
1663 # include <sys/param.h>
1664 # include <sys/pstat.h>
1665
1666 int
1667 getla()
1668 {
1669 struct pst_dynamic pstd;
1670
1671 if (pstat_getdynamic(&pstd, sizeof(struct pst_dynamic),
1672 (size_t) 1, 0) == -1)
1673 return 0;
1674
1675 if (tTd(3, 1))
1676 sm_dprintf("getla: %d\n", (int) (pstd.psd_avg_1_min + 0.5));
1677
1678 return (int) (pstd.psd_avg_1_min + 0.5);
1679 }
1680
1681 #endif /* LA_TYPE == LA_HPUX */
1682
1683 #if LA_TYPE == LA_SUBR
1684
1685 int
1686 getla()
1687 {
1688 double avenrun[3];
1689
1690 if (getloadavg(avenrun, sizeof(avenrun) / sizeof(avenrun[0])) < 0)
1691 {
1692 if (tTd(3, 1))
1693 sm_dprintf("getla: getloadavg failed: %s",
1694 sm_errstring(errno));
1695 return -1;
1696 }
1697 if (tTd(3, 1))
1698 sm_dprintf("getla: %d\n", (int) (avenrun[0] +0.5));
1699 return ((int) (avenrun[0] + 0.5));
1700 }
1701
1702 #endif /* LA_TYPE == LA_SUBR */
1703
1704 #if LA_TYPE == LA_MACH
1705
1706 /*
1707 ** This has been tested on NEXTSTEP release 2.1/3.X.
1708 */
1709
1710 # if defined(NX_CURRENT_COMPILER_RELEASE) && NX_CURRENT_COMPILER_RELEASE > NX_COMPILER_RELEASE_3_0
1711 # include <mach/mach.h>
1712 # else /* defined(NX_CURRENT_COMPILER_RELEASE) && NX_CURRENT_COMPILER_RELEASE > NX_COMPILER_RELEASE_3_0 */
1713 # include <mach.h>
1714 # endif /* defined(NX_CURRENT_COMPILER_RELEASE) && NX_CURRENT_COMPILER_RELEASE > NX_COMPILER_RELEASE_3_0 */
1715
1716 int
1717 getla()
1718 {
1719 processor_set_t default_set;
1720 kern_return_t error;
1721 unsigned int info_count;
1722 struct processor_set_basic_info info;
1723 host_t host;
1724
1725 error = processor_set_default(host_self(), &default_set);
1726 if (error != KERN_SUCCESS)
1727 {
1728 if (tTd(3, 1))
1729 sm_dprintf("getla: processor_set_default failed: %s",
1730 sm_errstring(errno));
1731 return -1;
1732 }
1733 info_count = PROCESSOR_SET_BASIC_INFO_COUNT;
1734 if (processor_set_info(default_set, PROCESSOR_SET_BASIC_INFO,
1735 &host, (processor_set_info_t)&info,
1736 &info_count) != KERN_SUCCESS)
1737 {
1738 if (tTd(3, 1))
1739 sm_dprintf("getla: processor_set_info failed: %s",
1740 sm_errstring(errno));
1741 return -1;
1742 }
1743 if (tTd(3, 1))
1744 sm_dprintf("getla: %d\n",
1745 (int) ((info.load_average + (LOAD_SCALE / 2)) /
1746 LOAD_SCALE));
1747 return (int) (info.load_average + (LOAD_SCALE / 2)) / LOAD_SCALE;
1748 }
1749
1750 #endif /* LA_TYPE == LA_MACH */
1751
1752 #if LA_TYPE == LA_PROCSTR
1753 # if SM_CONF_BROKEN_STRTOD
1754 ERROR: This OS has most likely a broken strtod() implemenentation.
1755 ERROR: The function is required for getla().
1756 ERROR: Check the compilation options _LA_PROCSTR and
1757 ERROR: _SM_CONF_BROKEN_STRTOD (without the leading _).
1758 # endif /* SM_CONF_BROKEN_STRTOD */
1759
1760 /*
1761 ** Read /proc/loadavg for the load average. This is assumed to be
1762 ** in a format like "0.15 0.12 0.06".
1763 **
1764 ** Initially intended for Linux. This has been in the kernel
1765 ** since at least 0.99.15.
1766 */
1767
1768 # ifndef _PATH_LOADAVG
1769 # define _PATH_LOADAVG "/proc/loadavg"
1770 # endif /* ! _PATH_LOADAVG */
1771
1772 int
1773 getla()
1774 {
1775 double avenrun;
1776 register int result;
1777 SM_FILE_T *fp;
1778
1779 fp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, _PATH_LOADAVG, SM_IO_RDONLY,
1780 NULL);
1781 if (fp == NULL)
1782 {
1783 if (tTd(3, 1))
1784 sm_dprintf("getla: sm_io_open(%s): %s\n",
1785 _PATH_LOADAVG, sm_errstring(errno));
1786 return -1;
1787 }
1788 result = sm_io_fscanf(fp, SM_TIME_DEFAULT, "%lf", &avenrun);
1789 (void) sm_io_close(fp, SM_TIME_DEFAULT);
1790 if (result != 1)
1791 {
1792 if (tTd(3, 1))
1793 sm_dprintf("getla: sm_io_fscanf() = %d: %s\n",
1794 result, sm_errstring(errno));
1795 return -1;
1796 }
1797
1798 if (tTd(3, 1))
1799 sm_dprintf("getla(): %.2f\n", avenrun);
1800
1801 return ((int) (avenrun + 0.5));
1802 }
1803
1804 #endif /* LA_TYPE == LA_PROCSTR */
1805
1806 #if LA_TYPE == LA_IRIX6
1807
1808 # include <sys/sysmp.h>
1809
1810 # ifdef _UNICOSMP
1811 # define CAST_SYSMP(x) (x)
1812 # else /* _UNICOSMP */
1813 # define CAST_SYSMP(x) ((x) & 0x7fffffff)
1814 # endif /* _UNICOSMP */
1815
1816 int
1817 getla(void)
1818 {
1819 int j;
1820 static int kmem = -1;
1821 int avenrun[3];
1822
1823 if (kmem < 0)
1824 {
1825 kmem = open(_PATH_KMEM, 0, 0);
1826 if (kmem < 0)
1827 {
1828 if (tTd(3, 1))
1829 sm_dprintf("getla: open(%s): %s\n", _PATH_KMEM,
1830 sm_errstring(errno));
1831 return -1;
1832 }
1833 if ((j = fcntl(kmem, F_GETFD, 0)) < 0 ||
1834 fcntl(kmem, F_SETFD, j | FD_CLOEXEC) < 0)
1835 {
1836 if (tTd(3, 1))
1837 sm_dprintf("getla: fcntl(/dev/kmem, FD_CLOEXEC): %s\n",
1838 sm_errstring(errno));
1839 (void) close(kmem);
1840 kmem = -1;
1841 return -1;
1842 }
1843 }
1844
1845 if (lseek(kmem, CAST_SYSMP(sysmp(MP_KERNADDR, MPKA_AVENRUN)), SEEK_SET)
1846 == -1 ||
1847 read(kmem, (char *) avenrun, sizeof(avenrun)) != sizeof(avenrun))
1848 {
1849 if (tTd(3, 1))
1850 sm_dprintf("getla: lseek or read: %s\n",
1851 sm_errstring(errno));
1852 return -1;
1853 }
1854 if (tTd(3, 5))
1855 {
1856 sm_dprintf("getla: avenrun = %ld", (long int) avenrun[0]);
1857 if (tTd(3, 15))
1858 sm_dprintf(", %ld, %ld",
1859 (long int) avenrun[1], (long int) avenrun[2]);
1860 sm_dprintf("\n");
1861 }
1862
1863 if (tTd(3, 1))
1864 sm_dprintf("getla: %d\n",
1865 (int) (avenrun[0] + FSCALE/2) >> FSHIFT);
1866 return ((int) (avenrun[0] + FSCALE/2) >> FSHIFT);
1867
1868 }
1869 #endif /* LA_TYPE == LA_IRIX6 */
1870
1871 #if LA_TYPE == LA_KSTAT
1872
1873 # include <kstat.h>
1874
1875 int
1876 getla()
1877 {
1878 static kstat_ctl_t *kc = NULL;
1879 static kstat_t *ksp = NULL;
1880 kstat_named_t *ksn;
1881 int la;
1882
1883 if (kc == NULL) /* if not initialized before */
1884 kc = kstat_open();
1885 if (kc == NULL)
1886 {
1887 if (tTd(3, 1))
1888 sm_dprintf("getla: kstat_open(): %s\n",
1889 sm_errstring(errno));
1890 return -1;
1891 }
1892 if (ksp == NULL)
1893 ksp = kstat_lookup(kc, "unix", 0, "system_misc");
1894 if (ksp == NULL)
1895 {
1896 if (tTd(3, 1))
1897 sm_dprintf("getla: kstat_lookup(): %s\n",
1898 sm_errstring(errno));
1899 return -1;
1900 }
1901 if (kstat_read(kc, ksp, NULL) < 0)
1902 {
1903 if (tTd(3, 1))
1904 sm_dprintf("getla: kstat_read(): %s\n",
1905 sm_errstring(errno));
1906 return -1;
1907 }
1908 ksn = (kstat_named_t *) kstat_data_lookup(ksp, "avenrun_1min");
1909 la = ((double) ksn->value.ul + FSCALE/2) / FSCALE;
1910 /* kstat_close(kc); /o do not close for fast access */
1911 return la;
1912 }
1913
1914 #endif /* LA_TYPE == LA_KSTAT */
1915
1916 #if LA_TYPE == LA_DEVSHORT
1917
1918 /*
1919 ** Read /dev/table/avenrun for the load average. This should contain
1920 ** three shorts for the 1, 5, and 15 minute loads. We only read the
1921 ** first, since that's all we care about.
1922 **
1923 ** Intended for SCO OpenServer 5.
1924 */
1925
1926 # ifndef _PATH_AVENRUN
1927 # define _PATH_AVENRUN "/dev/table/avenrun"
1928 # endif /* ! _PATH_AVENRUN */
1929
1930 int
1931 getla()
1932 {
1933 static int afd = -1;
1934 short avenrun;
1935 int loadav;
1936 int r;
1937
1938 errno = EBADF;
1939
1940 if (afd == -1 || lseek(afd, 0L, SEEK_SET) == -1)
1941 {
1942 if (errno != EBADF)
1943 return -1;
1944 afd = open(_PATH_AVENRUN, O_RDONLY|O_SYNC);
1945 if (afd < 0)
1946 {
1947 sm_syslog(LOG_ERR, NOQID,
1948 "can't open %s: %s",
1949 _PATH_AVENRUN, sm_errstring(errno));
1950 return -1;
1951 }
1952 }
1953
1954 r = read(afd, &avenrun, sizeof(avenrun));
1955 if (r != sizeof(avenrun))
1956 {
1957 sm_syslog(LOG_ERR, NOQID,
1958 "can't read %s: %s", _PATH_AVENRUN,
1959 r == -1 ? sm_errstring(errno) : "short read");
1960 return -1;
1961 }
1962
1963 if (tTd(3, 5))
1964 sm_dprintf("getla: avenrun = %d\n", avenrun);
1965 loadav = (int) (avenrun + FSCALE/2) >> FSHIFT;
1966 if (tTd(3, 1))
1967 sm_dprintf("getla: %d\n", loadav);
1968 return loadav;
1969 }
1970
1971 #endif /* LA_TYPE == LA_DEVSHORT */
1972
1973 #if LA_TYPE == LA_ALPHAOSF
1974 struct rtentry;
1975 struct mbuf;
1976 # include <sys/table.h>
1977
1978 int
1979 getla()
1980 {
1981 int ave = 0;
1982 struct tbl_loadavg tab;
1983
1984 if (table(TBL_LOADAVG, 0, &tab, 1, sizeof(tab)) == -1)
1985 {
1986 if (tTd(3, 1))
1987 sm_dprintf("getla: table %s\n", sm_errstring(errno));
1988 return -1;
1989 }
1990
1991 if (tTd(3, 1))
1992 sm_dprintf("getla: scale = %d\n", tab.tl_lscale);
1993
1994 if (tab.tl_lscale)
1995 ave = ((tab.tl_avenrun.l[2] + (tab.tl_lscale/2)) /
1996 tab.tl_lscale);
1997 else
1998 ave = (int) (tab.tl_avenrun.d[2] + 0.5);
1999
2000 if (tTd(3, 1))
2001 sm_dprintf("getla: %d\n", ave);
2002
2003 return ave;
2004 }
2005
2006 #endif /* LA_TYPE == LA_ALPHAOSF */
2007
2008 #if LA_TYPE == LA_PSET
2009
2010 int
2011 getla()
2012 {
2013 double avenrun[3];
2014
2015 if (pset_getloadavg(PS_MYID, avenrun,
2016 sizeof(avenrun) / sizeof(avenrun[0])) < 0)
2017 {
2018 if (tTd(3, 1))
2019 sm_dprintf("getla: pset_getloadavg failed: %s",
2020 sm_errstring(errno));
2021 return -1;
2022 }
2023 if (tTd(3, 1))
2024 sm_dprintf("getla: %d\n", (int) (avenrun[0] +0.5));
2025 return ((int) (avenrun[0] + 0.5));
2026 }
2027
2028 #endif /* LA_TYPE == LA_PSET */
2029
2030 #if LA_TYPE == LA_ZERO
2031
2032 int
2033 getla()
2034 {
2035 if (tTd(3, 1))
2036 sm_dprintf("getla: ZERO\n");
2037 return 0;
2038 }
2039
2040 #endif /* LA_TYPE == LA_ZERO */
2041
2042 /*
2043 * Copyright 1989 Massachusetts Institute of Technology
2044 *
2045 * Permission to use, copy, modify, distribute, and sell this software and its
2046 * documentation for any purpose is hereby granted without fee, provided that
2047 * the above copyright notice appear in all copies and that both that
2048 * copyright notice and this permission notice appear in supporting
2049 * documentation, and that the name of M.I.T. not be used in advertising or
2050 * publicity pertaining to distribution of the software without specific,
2051 * written prior permission. M.I.T. makes no representations about the
2052 * suitability of this software for any purpose. It is provided "as is"
2053 * without express or implied warranty.
2054 *
2055 * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
2056 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
2057 * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
2058 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
2059 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
2060 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
2061 *
2062 * Authors: Many and varied...
2063 */
2064
2065 /* Non Apollo stuff removed by Don Lewis 11/15/93 */
2066 #ifndef lint
2067 SM_UNUSED(static char rcsid[]) = "@(#)$OrigId: getloadavg.c,v 1.16 1991/06/21 12:51:15 paul Exp $";
2068 #endif /* ! lint */
2069
2070 #ifdef apollo
2071 # undef volatile
2072 # include <apollo/base.h>
2073
2074 /* ARGSUSED */
2075 int getloadavg( call_data )
2076 caddr_t call_data; /* pointer to (double) return value */
2077 {
2078 double *avenrun = (double *) call_data;
2079 int i;
2080 status_$t st;
2081 long loadav[3];
2082
2083 proc1_$get_loadav(loadav, &st);
2084 *avenrun = loadav[0] / (double) (1 << 16);
2085 return 0;
2086 }
2087 #endif /* apollo */
2088 /*
2089 ** SM_GETLA -- get the current load average
2090 **
2091 ** Parameters:
2092 ** none
2093 **
2094 ** Returns:
2095 ** none
2096 **
2097 ** Side Effects:
2098 ** Set CurrentLA to the current load average.
2099 ** Set {load_avg} in GlobalMacros to the current load average.
2100 */
2101
2102 void
2103 sm_getla()
2104 {
2105 char labuf[8];
2106
2107 CurrentLA = getla();
2108 (void) sm_snprintf(labuf, sizeof(labuf), "%d", CurrentLA);
2109 macdefine(&GlobalMacros, A_TEMP, macid("{load_avg}"), labuf);
2110 }
2111 /*
2112 ** SHOULDQUEUE -- should this message be queued or sent?
2113 **
2114 ** Compares the message cost to the load average to decide.
2115 **
2116 ** Note: Do NOT change this API! It is documented in op.me
2117 ** and theoretically the user can change this function...
2118 **
2119 ** Parameters:
2120 ** pri -- the priority of the message in question.
2121 ** ct -- the message creation time (unused, but see above).
2122 **
2123 ** Returns:
2124 ** true -- if this message should be queued up for the
2125 ** time being.
2126 ** false -- if the load is low enough to send this message.
2127 **
2128 ** Side Effects:
2129 ** none.
2130 */
2131
2132 /* ARGSUSED1 */
2133 bool
2134 shouldqueue(pri, ct)
2135 long pri;
2136 time_t ct;
2137 {
2138 bool rval;
2139 #if _FFR_MEMSTAT
2140 long memfree;
2141 #endif /* _FFR_MEMSTAT */
2142
2143 if (tTd(3, 30))
2144 sm_dprintf("shouldqueue: CurrentLA=%d, pri=%ld: ",
2145 CurrentLA, pri);
2146
2147 #if _FFR_MEMSTAT
2148 if (QueueLowMem > 0 &&
2149 sm_memstat_get(MemoryResource, &memfree) >= 0 &&
2150 memfree < QueueLowMem)
2151 {
2152 if (tTd(3, 30))
2153 sm_dprintf("true (memfree=%ld < QueueLowMem=%ld)\n",
2154 memfree, QueueLowMem);
2155 return true;
2156 }
2157 #endif /* _FFR_MEMSTAT */
2158 if (CurrentLA < QueueLA)
2159 {
2160 if (tTd(3, 30))
2161 sm_dprintf("false (CurrentLA < QueueLA)\n");
2162 return false;
2163 }
2164 rval = pri > (QueueFactor / (CurrentLA - QueueLA + 1));
2165 if (tTd(3, 30))
2166 sm_dprintf("%s (by calculation)\n", rval ? "true" : "false");
2167 return rval;
2168 }
2169
2170 /*
2171 ** REFUSECONNECTIONS -- decide if connections should be refused
2172 **
2173 ** Parameters:
2174 ** e -- the current envelope.
2175 ** dn -- number of daemon.
2176 ** active -- was this daemon actually active?
2177 **
2178 ** Returns:
2179 ** true if incoming SMTP connections should be refused
2180 ** (for now).
2181 ** false if we should accept new work.
2182 **
2183 ** Side Effects:
2184 ** Sets process title when it is rejecting connections.
2185 */
2186
2187 bool
2188 refuseconnections(e, dn, active)
2189 ENVELOPE *e;
2190 int dn;
2191 bool active;
2192 {
2193 static time_t lastconn[MAXDAEMONS];
2194 static int conncnt[MAXDAEMONS];
2195 static time_t firstrejtime[MAXDAEMONS];
2196 static time_t nextlogtime[MAXDAEMONS];
2197 int limit;
2198 #if _FFR_MEMSTAT
2199 long memfree;
2200 #endif /* _FFR_MEMSTAT */
2201
2202 #if XLA
2203 if (!xla_smtp_ok())
2204 return true;
2205 #endif /* XLA */
2206
2207 SM_ASSERT(dn >= 0);
2208 SM_ASSERT(dn < MAXDAEMONS);
2209 if (ConnRateThrottle > 0)
2210 {
2211 time_t now;
2212
2213 now = curtime();
2214 if (active)
2215 {
2216 if (now != lastconn[dn])
2217 {
2218 lastconn[dn] = now;
2219 conncnt[dn] = 1;
2220 }
2221 else if (conncnt[dn]++ > ConnRateThrottle)
2222 {
2223 #define D_MSG_CRT "deferring connections on daemon %s: %d per second"
2224 /* sleep to flatten out connection load */
2225 sm_setproctitle(true, e, D_MSG_CRT,
2226 Daemons[dn].d_name,
2227 ConnRateThrottle);
2228 if (LogLevel > 8)
2229 sm_syslog(LOG_INFO, NOQID, D_MSG_CRT,
2230 Daemons[dn].d_name,
2231 ConnRateThrottle);
2232 (void) sleep(1);
2233 }
2234 }
2235 else if (now != lastconn[dn])
2236 conncnt[dn] = 0;
2237 }
2238
2239
2240 #if _FFR_MEMSTAT
2241 if (RefuseLowMem > 0 &&
2242 sm_memstat_get(MemoryResource, &memfree) >= 0 &&
2243 memfree < RefuseLowMem)
2244 {
2245 # define R_MSG_LM "rejecting connections on daemon %s: free memory: %ld"
2246 sm_setproctitle(true, e, R_MSG_LM, Daemons[dn].d_name, memfree);
2247 if (LogLevel > 8)
2248 sm_syslog(LOG_NOTICE, NOQID, R_MSG_LM,
2249 Daemons[dn].d_name, memfree);
2250 return true;
2251 }
2252 #endif /* _FFR_MEMSTAT */
2253 sm_getla();
2254 limit = (Daemons[dn].d_refuseLA != DPO_NOTSET) ?
2255 Daemons[dn].d_refuseLA : RefuseLA;
2256 if (limit > 0 && CurrentLA >= limit)
2257 {
2258 time_t now;
2259
2260 # define R_MSG_LA "rejecting connections on daemon %s: load average: %d"
2261 # define R2_MSG_LA "have been rejecting connections on daemon %s for %s"
2262 sm_setproctitle(true, e, R_MSG_LA, Daemons[dn].d_name,
2263 CurrentLA);
2264 if (LogLevel > 8)
2265 sm_syslog(LOG_NOTICE, NOQID, R_MSG_LA,
2266 Daemons[dn].d_name, CurrentLA);
2267 now = curtime();
2268 if (firstrejtime[dn] == 0)
2269 {
2270 firstrejtime[dn] = now;
2271 nextlogtime[dn] = now + RejectLogInterval;
2272 }
2273 else if (nextlogtime[dn] < now)
2274 {
2275 sm_syslog(LOG_ERR, NOQID, R2_MSG_LA, Daemons[dn].d_name,
2276 pintvl(now - firstrejtime[dn], true));
2277 nextlogtime[dn] = now + RejectLogInterval;
2278 }
2279 return true;
2280 }
2281 else
2282 firstrejtime[dn] = 0;
2283
2284 limit = (Daemons[dn].d_delayLA != DPO_NOTSET) ?
2285 Daemons[dn].d_delayLA : DelayLA;
2286 if (limit > 0 && CurrentLA >= limit)
2287 {
2288 time_t now;
2289 static time_t log_delay = (time_t) 0;
2290
2291 # define MIN_DELAY_LOG 90 /* wait before logging this again */
2292 # define D_MSG_LA "delaying connections on daemon %s: load average=%d >= %d"
2293 /* sleep to flatten out connection load */
2294 sm_setproctitle(true, e, D_MSG_LA, Daemons[dn].d_name,
2295 CurrentLA, limit);
2296 if (LogLevel > 8 && (now = curtime()) > log_delay)
2297 {
2298 sm_syslog(LOG_INFO, NOQID, D_MSG_LA,
2299 Daemons[dn].d_name, CurrentLA, limit);
2300 log_delay = now + MIN_DELAY_LOG;
2301 }
2302 (void) sleep(1);
2303 }
2304
2305 limit = (Daemons[dn].d_maxchildren != DPO_NOTSET) ?
2306 Daemons[dn].d_maxchildren : MaxChildren;
2307 if (limit > 0 && CurChildren >= limit)
2308 {
2309 proc_list_probe();
2310 if (CurChildren >= limit)
2311 {
2312 #define R_MSG_CHILD "rejecting connections on daemon %s: %d children, max %d"
2313 sm_setproctitle(true, e, R_MSG_CHILD,
2314 Daemons[dn].d_name, CurChildren,
2315 limit);
2316 if (LogLevel > 8)
2317 sm_syslog(LOG_INFO, NOQID, R_MSG_CHILD,
2318 Daemons[dn].d_name, CurChildren,
2319 limit);
2320 return true;
2321 }
2322 }
2323 return false;
2324 }
2325
2326 /*
2327 ** SETPROCTITLE -- set process title for ps
2328 **
2329 ** Parameters:
2330 ** fmt -- a printf style format string.
2331 ** a, b, c -- possible parameters to fmt.
2332 **
2333 ** Returns:
2334 ** none.
2335 **
2336 ** Side Effects:
2337 ** Clobbers argv of our main procedure so ps(1) will
2338 ** display the title.
2339 */
2340
2341 #define SPT_NONE 0 /* don't use it at all */
2342 #define SPT_REUSEARGV 1 /* cover argv with title information */
2343 #define SPT_BUILTIN 2 /* use libc builtin */
2344 #define SPT_PSTAT 3 /* use pstat(PSTAT_SETCMD, ...) */
2345 #define SPT_PSSTRINGS 4 /* use PS_STRINGS->... */
2346 #define SPT_SYSMIPS 5 /* use sysmips() supported by NEWS-OS 6 */
2347 #define SPT_SCO 6 /* write kernel u. area */
2348 #define SPT_CHANGEARGV 7 /* write our own strings into argv[] */
2349
2350 #ifndef SPT_TYPE
2351 # define SPT_TYPE SPT_REUSEARGV
2352 #endif /* ! SPT_TYPE */
2353
2354
2355 #if SPT_TYPE != SPT_NONE && SPT_TYPE != SPT_BUILTIN
2356
2357 # if SPT_TYPE == SPT_PSTAT
2358 # include <sys/pstat.h>
2359 # endif /* SPT_TYPE == SPT_PSTAT */
2360 # if SPT_TYPE == SPT_PSSTRINGS
2361 # include <machine/vmparam.h>
2362 # include <sys/exec.h>
2363 # ifndef PS_STRINGS /* hmmmm.... apparently not available after all */
2364 # undef SPT_TYPE
2365 # define SPT_TYPE SPT_REUSEARGV
2366 # else /* ! PS_STRINGS */
2367 # ifndef NKPDE /* FreeBSD 2.0 */
2368 # define NKPDE 63
2369 typedef unsigned int *pt_entry_t;
2370 # endif /* ! NKPDE */
2371 # endif /* ! PS_STRINGS */
2372 # endif /* SPT_TYPE == SPT_PSSTRINGS */
2373
2374 # if SPT_TYPE == SPT_PSSTRINGS || SPT_TYPE == SPT_CHANGEARGV
2375 # define SETPROC_STATIC static
2376 # else /* SPT_TYPE == SPT_PSSTRINGS || SPT_TYPE == SPT_CHANGEARGV */
2377 # define SETPROC_STATIC
2378 # endif /* SPT_TYPE == SPT_PSSTRINGS || SPT_TYPE == SPT_CHANGEARGV */
2379
2380 # if SPT_TYPE == SPT_SYSMIPS
2381 # include <sys/sysmips.h>
2382 # include <sys/sysnews.h>
2383 # endif /* SPT_TYPE == SPT_SYSMIPS */
2384
2385 # if SPT_TYPE == SPT_SCO
2386 # include <sys/immu.h>
2387 # include <sys/dir.h>
2388 # include <sys/user.h>
2389 # include <sys/fs/s5param.h>
2390 # if PSARGSZ > MAXLINE
2391 # define SPT_BUFSIZE PSARGSZ
2392 # endif /* PSARGSZ > MAXLINE */
2393 # endif /* SPT_TYPE == SPT_SCO */
2394
2395 # ifndef SPT_PADCHAR
2396 # define SPT_PADCHAR ' '
2397 # endif /* ! SPT_PADCHAR */
2398
2399 #endif /* SPT_TYPE != SPT_NONE && SPT_TYPE != SPT_BUILTIN */
2400
2401 #ifndef SPT_BUFSIZE
2402 # define SPT_BUFSIZE MAXLINE
2403 #endif /* ! SPT_BUFSIZE */
2404
2405 #if _FFR_SPT_ALIGN
2406
2407 /*
2408 ** It looks like the Compaq Tru64 5.1A now aligns argv and envp to
2409 ** 64 bit alignment, so unless each piece of argv and envp is a multiple
2410 ** of 8 bytes (including terminating NULL), initsetproctitle() won't use
2411 ** any of the space beyond argv[0]. Be sure to set SPT_ALIGN_SIZE if
2412 ** you use this FFR.
2413 */
2414
2415 # ifdef SPT_ALIGN_SIZE
2416 # define SPT_ALIGN(x, align) (((((x) + SPT_ALIGN_SIZE) >> (align)) << (align)) - 1)
2417 # else /* SPT_ALIGN_SIZE */
2418 # define SPT_ALIGN(x, align) (x)
2419 # endif /* SPT_ALIGN_SIZE */
2420 #else /* _FFR_SPT_ALIGN */
2421 # define SPT_ALIGN(x, align) (x)
2422 #endif /* _FFR_SPT_ALIGN */
2423
2424 /*
2425 ** Pointers for setproctitle.
2426 ** This allows "ps" listings to give more useful information.
2427 */
2428
2429 static char **Argv = NULL; /* pointer to argument vector */
2430 static char *LastArgv = NULL; /* end of argv */
2431 #if SPT_TYPE != SPT_BUILTIN
2432 static void setproctitle __P((const char *, ...));
2433 #endif /* SPT_TYPE != SPT_BUILTIN */
2434
2435 void
2436 initsetproctitle(argc, argv, envp)
2437 int argc;
2438 char **argv;
2439 char **envp;
2440 {
2441 register int i;
2442 int align;
2443 extern char **environ;
2444
2445 /*
2446 ** Move the environment so setproctitle can use the space at
2447 ** the top of memory.
2448 */
2449
2450 if (envp != NULL)
2451 {
2452 for (i = 0; envp[i] != NULL; i++)
2453 continue;
2454 environ = (char **) xalloc(sizeof(char *) * (i + 1));
2455 for (i = 0; envp[i] != NULL; i++)
2456 environ[i] = newstr(envp[i]);
2457 environ[i] = NULL;
2458 }
2459
2460 /*
2461 ** Save start and extent of argv for setproctitle.
2462 */
2463
2464 Argv = argv;
2465
2466 /*
2467 ** Determine how much space we can use for setproctitle.
2468 ** Use all contiguous argv and envp pointers starting at argv[0]
2469 */
2470
2471 align = -1;
2472 # if _FFR_SPT_ALIGN
2473 # ifdef SPT_ALIGN_SIZE
2474 for (i = SPT_ALIGN_SIZE; i > 0; i >>= 1)
2475 align++;
2476 # endif /* SPT_ALIGN_SIZE */
2477 # endif /* _FFR_SPT_ALIGN */
2478
2479 for (i = 0; i < argc; i++)
2480 {
2481 if (i == 0 || LastArgv + 1 == argv[i])
2482 LastArgv = argv[i] + SPT_ALIGN(strlen(argv[i]), align);
2483 }
2484 for (i = 0; LastArgv != NULL && envp != NULL && envp[i] != NULL; i++)
2485 {
2486 if (LastArgv + 1 == envp[i])
2487 LastArgv = envp[i] + SPT_ALIGN(strlen(envp[i]), align);
2488 }
2489 }
2490
2491 #if SPT_TYPE != SPT_BUILTIN
2492
2493 /*VARARGS1*/
2494 static void
2495 # ifdef __STDC__
2496 setproctitle(const char *fmt, ...)
2497 # else /* __STDC__ */
2498 setproctitle(fmt, va_alist)
2499 const char *fmt;
2500 va_dcl
2501 # endif /* __STDC__ */
2502 {
2503 # if SPT_TYPE != SPT_NONE
2504 register int i;
2505 register char *p;
2506 SETPROC_STATIC char buf[SPT_BUFSIZE];
2507 SM_VA_LOCAL_DECL
2508 # if SPT_TYPE == SPT_PSTAT
2509 union pstun pst;
2510 # endif /* SPT_TYPE == SPT_PSTAT */
2511 # if SPT_TYPE == SPT_SCO
2512 int j;
2513 off_t seek_off;
2514 static int kmem = -1;
2515 static pid_t kmempid = -1;
2516 struct user u;
2517 # endif /* SPT_TYPE == SPT_SCO */
2518
2519 p = buf;
2520
2521 /* print sendmail: heading for grep */
2522 (void) sm_strlcpy(p, "sendmail: ", SPACELEFT(buf, p));
2523 p += strlen(p);
2524
2525 /* print the argument string */
2526 SM_VA_START(ap, fmt);
2527 (void) sm_vsnprintf(p, SPACELEFT(buf, p), fmt, ap);
2528 SM_VA_END(ap);
2529
2530 i = (int) strlen(buf);
2531 if (i < 0)
2532 return;
2533
2534 # if SPT_TYPE == SPT_PSTAT
2535 pst.pst_command = buf;
2536 pstat(PSTAT_SETCMD, pst, i, 0, 0);
2537 # endif /* SPT_TYPE == SPT_PSTAT */
2538 # if SPT_TYPE == SPT_PSSTRINGS
2539 PS_STRINGS->ps_nargvstr = 1;
2540 PS_STRINGS->ps_argvstr = buf;
2541 # endif /* SPT_TYPE == SPT_PSSTRINGS */
2542 # if SPT_TYPE == SPT_SYSMIPS
2543 sysmips(SONY_SYSNEWS, NEWS_SETPSARGS, buf);
2544 # endif /* SPT_TYPE == SPT_SYSMIPS */
2545 # if SPT_TYPE == SPT_SCO
2546 if (kmem < 0 || kmempid != CurrentPid)
2547 {
2548 if (kmem >= 0)
2549 (void) close(kmem);
2550 kmem = open(_PATH_KMEM, O_RDWR, 0);
2551 if (kmem < 0)
2552 return;
2553 if ((j = fcntl(kmem, F_GETFD, 0)) < 0 ||
2554 fcntl(kmem, F_SETFD, j | FD_CLOEXEC) < 0)
2555 {
2556 (void) close(kmem);
2557 kmem = -1;
2558 return;
2559 }
2560 kmempid = CurrentPid;
2561 }
2562 buf[PSARGSZ - 1] = '\0';
2563 seek_off = UVUBLK + (off_t) u.u_psargs - (off_t) &u;
2564 if (lseek(kmem, (off_t) seek_off, SEEK_SET) == seek_off)
2565 (void) write(kmem, buf, PSARGSZ);
2566 # endif /* SPT_TYPE == SPT_SCO */
2567 # if SPT_TYPE == SPT_REUSEARGV
2568 if (LastArgv == NULL)
2569 return;
2570
2571 if (i > LastArgv - Argv[0] - 2)
2572 {
2573 i = LastArgv - Argv[0] - 2;
2574 buf[i] = '\0';
2575 }
2576 (void) sm_strlcpy(Argv[0], buf, i + 1);
2577 p = &Argv[0][i];
2578 while (p < LastArgv)
2579 *p++ = SPT_PADCHAR;
2580 Argv[1] = NULL;
2581 # endif /* SPT_TYPE == SPT_REUSEARGV */
2582 # if SPT_TYPE == SPT_CHANGEARGV
2583 Argv[0] = buf;
2584 Argv[1] = 0;
2585 # endif /* SPT_TYPE == SPT_CHANGEARGV */
2586 # endif /* SPT_TYPE != SPT_NONE */
2587 }
2588
2589 #endif /* SPT_TYPE != SPT_BUILTIN */
2590 /*
2591 ** SM_SETPROCTITLE -- set process task and set process title for ps
2592 **
2593 ** Possibly set process status and call setproctitle() to
2594 ** change the ps display.
2595 **
2596 ** Parameters:
2597 ** status -- whether or not to store as process status
2598 ** e -- the current envelope.
2599 ** fmt -- a printf style format string.
2600 ** a, b, c -- possible parameters to fmt.
2601 **
2602 ** Returns:
2603 ** none.
2604 */
2605
2606 /*VARARGS3*/
2607 void
2608 #ifdef __STDC__
2609 sm_setproctitle(bool status, ENVELOPE *e, const char *fmt, ...)
2610 #else /* __STDC__ */
2611 sm_setproctitle(status, e, fmt, va_alist)
2612 bool status;
2613 ENVELOPE *e;
2614 const char *fmt;
2615 va_dcl
2616 #endif /* __STDC__ */
2617 {
2618 char buf[SPT_BUFSIZE];
2619 SM_VA_LOCAL_DECL
2620
2621 /* print the argument string */
2622 SM_VA_START(ap, fmt);
2623 (void) sm_vsnprintf(buf, sizeof(buf), fmt, ap);
2624 SM_VA_END(ap);
2625
2626 if (status)
2627 proc_list_set(CurrentPid, buf);
2628
2629 if (ProcTitlePrefix != NULL)
2630 {
2631 char prefix[SPT_BUFSIZE];
2632
2633 expand(ProcTitlePrefix, prefix, sizeof(prefix), e);
2634 setproctitle("%s: %s", prefix, buf);
2635 }
2636 else
2637 setproctitle("%s", buf);
2638 }
2639 /*
2640 ** WAITFOR -- wait for a particular process id.
2641 **
2642 ** Parameters:
2643 ** pid -- process id to wait for.
2644 **
2645 ** Returns:
2646 ** status of pid.
2647 ** -1 if pid never shows up.
2648 **
2649 ** Side Effects:
2650 ** none.
2651 */
2652
2653 int
2654 waitfor(pid)
2655 pid_t pid;
2656 {
2657 int st;
2658 pid_t i;
2659
2660 do
2661 {
2662 errno = 0;
2663 i = sm_wait(&st);
2664 if (i > 0)
2665 proc_list_drop(i, st, NULL);
2666 } while ((i >= 0 || errno == EINTR) && i != pid);
2667 if (i < 0)
2668 return -1;
2669 return st;
2670 }
2671 /*
2672 ** SM_WAIT -- wait
2673 **
2674 ** Parameters:
2675 ** status -- pointer to status (return value)
2676 **
2677 ** Returns:
2678 ** pid
2679 */
2680
2681 pid_t
2682 sm_wait(status)
2683 int *status;
2684 {
2685 # ifdef WAITUNION
2686 union wait st;
2687 # else /* WAITUNION */
2688 auto int st;
2689 # endif /* WAITUNION */
2690 pid_t i;
2691 # if defined(ISC_UNIX) || defined(_SCO_unix_)
2692 int savesig;
2693 # endif /* defined(ISC_UNIX) || defined(_SCO_unix_) */
2694
2695 # if defined(ISC_UNIX) || defined(_SCO_unix_)
2696 savesig = sm_releasesignal(SIGCHLD);
2697 # endif /* defined(ISC_UNIX) || defined(_SCO_unix_) */
2698 i = wait(&st);
2699 # if defined(ISC_UNIX) || defined(_SCO_unix_)
2700 if (savesig > 0)
2701 sm_blocksignal(SIGCHLD);
2702 # endif /* defined(ISC_UNIX) || defined(_SCO_unix_) */
2703 # ifdef WAITUNION
2704 *status = st.w_status;
2705 # else /* WAITUNION */
2706 *status = st;
2707 # endif /* WAITUNION */
2708 return i;
2709 }
2710 /*
2711 ** REAPCHILD -- pick up the body of my child, lest it become a zombie
2712 **
2713 ** Parameters:
2714 ** sig -- the signal that got us here (unused).
2715 **
2716 ** Returns:
2717 ** none.
2718 **
2719 ** Side Effects:
2720 ** Picks up extant zombies.
2721 ** Control socket exits may restart/shutdown daemon.
2722 **
2723 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
2724 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
2725 ** DOING.
2726 */
2727
2728 /* ARGSUSED0 */
2729 SIGFUNC_DECL
2730 reapchild(sig)
2731 int sig;
2732 {
2733 int save_errno = errno;
2734 int st;
2735 pid_t pid;
2736 # if HASWAITPID
2737 auto int status;
2738 int count;
2739
2740 count = 0;
2741 while ((pid = waitpid(-1, &status, WNOHANG)) > 0)
2742 {
2743 st = status;
2744 if (count++ > 1000)
2745 break;
2746 # else /* HASWAITPID */
2747 # ifdef WNOHANG
2748 union wait status;
2749
2750 while ((pid = wait3(&status, WNOHANG, (struct rusage *) NULL)) > 0)
2751 {
2752 st = status.w_status;
2753 # else /* WNOHANG */
2754 auto int status;
2755
2756 /*
2757 ** Catch one zombie -- we will be re-invoked (we hope) if there
2758 ** are more. Unreliable signals probably break this, but this
2759 ** is the "old system" situation -- waitpid or wait3 are to be
2760 ** strongly preferred.
2761 */
2762
2763 if ((pid = wait(&status)) > 0)
2764 {
2765 st = status;
2766 # endif /* WNOHANG */
2767 # endif /* HASWAITPID */
2768 /* Drop PID and check if it was a control socket child */
2769 proc_list_drop(pid, st, NULL);
2770 }
2771 FIX_SYSV_SIGNAL(sig, reapchild);
2772 errno = save_errno;
2773 return SIGFUNC_RETURN;
2774 }
2775 /*
2776 ** GETDTABLESIZE -- return number of file descriptors
2777 **
2778 ** Only on non-BSD systems
2779 **
2780 ** Parameters:
2781 ** none
2782 **
2783 ** Returns:
2784 ** size of file descriptor table
2785 **
2786 ** Side Effects:
2787 ** none
2788 */
2789
2790 #ifdef SOLARIS
2791 # include <sys/resource.h>
2792 #endif /* SOLARIS */
2793
2794 int
2795 getdtsize()
2796 {
2797 # ifdef RLIMIT_NOFILE
2798 struct rlimit rl;
2799
2800 if (getrlimit(RLIMIT_NOFILE, &rl) >= 0)
2801 return rl.rlim_cur;
2802 # endif /* RLIMIT_NOFILE */
2803
2804 # if HASGETDTABLESIZE
2805 return getdtablesize();
2806 # else /* HASGETDTABLESIZE */
2807 # ifdef _SC_OPEN_MAX
2808 return sysconf(_SC_OPEN_MAX);
2809 # else /* _SC_OPEN_MAX */
2810 return NOFILE;
2811 # endif /* _SC_OPEN_MAX */
2812 # endif /* HASGETDTABLESIZE */
2813 }
2814 /*
2815 ** UNAME -- get the UUCP name of this system.
2816 */
2817
2818 #if !HASUNAME
2819
2820 int
2821 uname(name)
2822 struct utsname *name;
2823 {
2824 SM_FILE_T *file;
2825 char *n;
2826
2827 name->nodename[0] = '\0';
2828
2829 /* try /etc/whoami -- one line with the node name */
2830 if ((file = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, "/etc/whoami",
2831 SM_IO_RDONLY, NULL)) != NULL)
2832 {
2833 (void) sm_io_fgets(file, SM_TIME_DEFAULT, name->nodename,
2834 NODE_LENGTH + 1);
2835 (void) sm_io_close(file, SM_TIME_DEFAULT);
2836 n = strchr(name->nodename, '\n');
2837 if (n != NULL)
2838 *n = '\0';
2839 if (name->nodename[0] != '\0')
2840 return 0;
2841 }
2842
2843 /* try /usr/include/whoami.h -- has a #define somewhere */
2844 if ((file = sm_io_open(SmFtStdio, SM_TIME_DEFAULT,
2845 "/usr/include/whoami.h", SM_IO_RDONLY, NULL))
2846 != NULL)
2847 {
2848 char buf[MAXLINE];
2849
2850 while (sm_io_fgets(file, SM_TIME_DEFAULT,
2851 buf, sizeof(buf)) != NULL)
2852 {
2853 if (sm_io_sscanf(buf, "#define sysname \"%*[^\"]\"",
2854 NODE_LENGTH, name->nodename) > 0)
2855 break;
2856 }
2857 (void) sm_io_close(file, SM_TIME_DEFAULT);
2858 if (name->nodename[0] != '\0')
2859 return 0;
2860 }
2861
2862 return -1;
2863 }
2864 #endif /* !HASUNAME */
2865 /*
2866 ** INITGROUPS -- initialize groups
2867 **
2868 ** Stub implementation for System V style systems
2869 */
2870
2871 #if !HASINITGROUPS
2872
2873 initgroups(name, basegid)
2874 char *name;
2875 int basegid;
2876 {
2877 return 0;
2878 }
2879
2880 #endif /* !HASINITGROUPS */
2881 /*
2882 ** SETGROUPS -- set group list
2883 **
2884 ** Stub implementation for systems that don't have group lists
2885 */
2886
2887 #ifndef NGROUPS_MAX
2888
2889 int
2890 setgroups(ngroups, grouplist)
2891 int ngroups;
2892 GIDSET_T grouplist[];
2893 {
2894 return 0;
2895 }
2896
2897 #endif /* ! NGROUPS_MAX */
2898 /*
2899 ** SETSID -- set session id (for non-POSIX systems)
2900 */
2901
2902 #if !HASSETSID
2903
2904 pid_t
2905 setsid __P ((void))
2906 {
2907 # ifdef TIOCNOTTY
2908 int fd;
2909
2910 fd = open("/dev/tty", O_RDWR, 0);
2911 if (fd >= 0)
2912 {
2913 (void) ioctl(fd, TIOCNOTTY, (char *) 0);
2914 (void) close(fd);
2915 }
2916 # endif /* TIOCNOTTY */
2917 # ifdef SYS5SETPGRP
2918 return setpgrp();
2919 # else /* SYS5SETPGRP */
2920 return setpgid(0, CurrentPid);
2921 # endif /* SYS5SETPGRP */
2922 }
2923
2924 #endif /* !HASSETSID */
2925 /*
2926 ** FSYNC -- dummy fsync
2927 */
2928
2929 #if NEEDFSYNC
2930
2931 fsync(fd)
2932 int fd;
2933 {
2934 # ifdef O_SYNC
2935 return fcntl(fd, F_SETFL, O_SYNC);
2936 # else /* O_SYNC */
2937 /* nothing we can do */
2938 return 0;
2939 # endif /* O_SYNC */
2940 }
2941
2942 #endif /* NEEDFSYNC */
2943 /*
2944 ** DGUX_INET_ADDR -- inet_addr for DG/UX
2945 **
2946 ** Data General DG/UX version of inet_addr returns a struct in_addr
2947 ** instead of a long. This patches things. Only needed on versions
2948 ** prior to 5.4.3.
2949 */
2950
2951 #ifdef DGUX_5_4_2
2952
2953 # undef inet_addr
2954
2955 long
2956 dgux_inet_addr(host)
2957 char *host;
2958 {
2959 struct in_addr haddr;
2960
2961 haddr = inet_addr(host);
2962 return haddr.s_addr;
2963 }
2964
2965 #endif /* DGUX_5_4_2 */
2966 /*
2967 ** GETOPT -- for old systems or systems with bogus implementations
2968 */
2969
2970 #if !SM_CONF_GETOPT
2971
2972 /*
2973 * Copyright (c) 1985 Regents of the University of California.
2974 * All rights reserved. The Berkeley software License Agreement
2975 * specifies the terms and conditions for redistribution.
2976 */
2977
2978
2979 /*
2980 ** this version hacked to add `atend' flag to allow state machine
2981 ** to reset if invoked by the program to scan args for a 2nd time
2982 */
2983
2984 # if defined(LIBC_SCCS) && !defined(lint)
2985 static char sccsid[] = "@(#)getopt.c 4.3 (Berkeley) 3/9/86";
2986 # endif /* defined(LIBC_SCCS) && !defined(lint) */
2987
2988 /*
2989 ** get option letter from argument vector
2990 */
2991 # ifdef _CONVEX_SOURCE
2992 extern int optind, opterr, optopt;
2993 extern char *optarg;
2994 # else /* _CONVEX_SOURCE */
2995 int opterr = 1; /* if error message should be printed */
2996 int optind = 1; /* index into parent argv vector */
2997 int optopt = 0; /* character checked for validity */
2998 char *optarg = NULL; /* argument associated with option */
2999 # endif /* _CONVEX_SOURCE */
3000
3001 # define BADCH (int)'?'
3002 # define EMSG ""
3003 # define tell(s) if (opterr) \
3004 {sm_io_fputs(smioerr, SM_TIME_DEFAULT, *nargv); \
3005 (void) sm_io_fputs(smioerr, SM_TIME_DEFAULT, s); \
3006 (void) sm_io_putc(smioerr, SM_TIME_DEFAULT, optopt); \
3007 (void) sm_io_putc(smioerr, SM_TIME_DEFAULT, '\n'); \
3008 return BADCH;}
3009
3010 int
3011 getopt(nargc,nargv,ostr)
3012 int nargc;
3013 char *const *nargv;
3014 const char *ostr;
3015 {
3016 static char *place = EMSG; /* option letter processing */
3017 static char atend = 0;
3018 register char *oli = NULL; /* option letter list index */
3019
3020 if (atend) {
3021 atend = 0;
3022 place = EMSG;
3023 }
3024 if(!*place) { /* update scanning pointer */
3025 if (optind >= nargc || *(place = nargv[optind]) != '-' || !*++place) {
3026 atend++;
3027 return -1;
3028 }
3029 if (*place == '-') { /* found "--" */
3030 ++optind;
3031 atend++;
3032 return -1;
3033 }
3034 } /* option letter okay? */
3035 if ((optopt = (int)*place++) == (int)':' || !(oli = strchr(ostr,optopt))) {
3036 if (!*place) ++optind;
3037 tell(": illegal option -- ");
3038 }
3039 if (oli && *++oli != ':') { /* don't need argument */
3040 optarg = NULL;
3041 if (!*place) ++optind;
3042 }
3043 else { /* need an argument */
3044 if (*place) optarg = place; /* no white space */
3045 else if (nargc <= ++optind) { /* no arg */
3046 place = EMSG;
3047 tell(": option requires an argument -- ");
3048 }
3049 else optarg = nargv[optind]; /* white space */
3050 place = EMSG;
3051 ++optind;
3052 }
3053 return optopt; /* dump back option letter */
3054 }
3055
3056 #endif /* !SM_CONF_GETOPT */
3057 /*
3058 ** USERSHELLOK -- tell if a user's shell is ok for unrestricted use
3059 **
3060 ** Parameters:
3061 ** user -- the name of the user we are checking.
3062 ** shell -- the user's shell from /etc/passwd
3063 **
3064 ** Returns:
3065 ** true -- if it is ok to use this for unrestricted access.
3066 ** false -- if the shell is restricted.
3067 */
3068
3069 #if !HASGETUSERSHELL
3070
3071 # ifndef _PATH_SHELLS
3072 # define _PATH_SHELLS "/etc/shells"
3073 # endif /* ! _PATH_SHELLS */
3074
3075 # if defined(_AIX3) || defined(_AIX4)
3076 # include <userconf.h>
3077 # if _AIX4 >= 40200
3078 # include <userpw.h>
3079 # endif /* _AIX4 >= 40200 */
3080 # include <usersec.h>
3081 # endif /* defined(_AIX3) || defined(_AIX4) */
3082
3083 static char *DefaultUserShells[] =
3084 {
3085 "/bin/sh", /* standard shell */
3086 # ifdef MPE
3087 "/SYS/PUB/CI",
3088 # else /* MPE */
3089 "/usr/bin/sh",
3090 "/bin/csh", /* C shell */
3091 "/usr/bin/csh",
3092 # endif /* MPE */
3093 # ifdef __hpux
3094 # ifdef V4FS
3095 "/usr/bin/rsh", /* restricted Bourne shell */
3096 "/usr/bin/ksh", /* Korn shell */
3097 "/usr/bin/rksh", /* restricted Korn shell */
3098 "/usr/bin/pam",
3099 "/usr/bin/keysh", /* key shell (extended Korn shell) */
3100 "/usr/bin/posix/sh",
3101 # else /* V4FS */
3102 "/bin/rsh", /* restricted Bourne shell */
3103 "/bin/ksh", /* Korn shell */
3104 "/bin/rksh", /* restricted Korn shell */
3105 "/bin/pam",
3106 "/usr/bin/keysh", /* key shell (extended Korn shell) */
3107 "/bin/posix/sh",
3108 "/sbin/sh",
3109 # endif /* V4FS */
3110 # endif /* __hpux */
3111 # if defined(_AIX3) || defined(_AIX4)
3112 "/bin/ksh", /* Korn shell */
3113 "/usr/bin/ksh",
3114 "/bin/tsh", /* trusted shell */
3115 "/usr/bin/tsh",
3116 "/bin/bsh", /* Bourne shell */
3117 "/usr/bin/bsh",
3118 # endif /* defined(_AIX3) || defined(_AIX4) */
3119 # if defined(__svr4__) || defined(__svr5__)
3120 "/bin/ksh", /* Korn shell */
3121 "/usr/bin/ksh",
3122 # endif /* defined(__svr4__) || defined(__svr5__) */
3123 # ifdef sgi
3124 "/sbin/sh", /* SGI's shells really live in /sbin */
3125 "/usr/bin/sh",
3126 "/sbin/bsh", /* classic Bourne shell */
3127 "/bin/bsh",
3128 "/usr/bin/bsh",
3129 "/sbin/csh", /* standard csh */
3130 "/bin/csh",
3131 "/usr/bin/csh",
3132 "/sbin/jsh", /* classic Bourne shell w/ job control*/
3133 "/bin/jsh",
3134 "/usr/bin/jsh",
3135 "/bin/ksh", /* Korn shell */
3136 "/sbin/ksh",
3137 "/usr/bin/ksh",
3138 "/sbin/tcsh", /* Extended csh */
3139 "/bin/tcsh",
3140 "/usr/bin/tcsh",
3141 # endif /* sgi */
3142 NULL
3143 };
3144
3145 #endif /* !HASGETUSERSHELL */
3146
3147 #define WILDCARD_SHELL "/SENDMAIL/ANY/SHELL/"
3148
3149 bool
3150 usershellok(user, shell)
3151 char *user;
3152 char *shell;
3153 {
3154 # if HASGETUSERSHELL
3155 register char *p;
3156 extern char *getusershell();
3157
3158 if (shell == NULL || shell[0] == '\0' || wordinclass(user, 't') ||
3159 ConfigLevel <= 1)
3160 return true;
3161
3162 setusershell();
3163 while ((p = getusershell()) != NULL)
3164 if (strcmp(p, shell) == 0 || strcmp(p, WILDCARD_SHELL) == 0)
3165 break;
3166 endusershell();
3167 return p != NULL;
3168 # else /* HASGETUSERSHELL */
3169 # if USEGETCONFATTR
3170 auto char *v;
3171 # endif /* USEGETCONFATTR */
3172 register SM_FILE_T *shellf;
3173 char buf[MAXLINE];
3174
3175 if (shell == NULL || shell[0] == '\0' || wordinclass(user, 't') ||
3176 ConfigLevel <= 1)
3177 return true;
3178
3179 # if USEGETCONFATTR
3180 /*
3181 ** Naturally IBM has a "better" idea.....
3182 **
3183 ** What a crock. This interface isn't documented, it is
3184 ** considered part of the security library (-ls), and it
3185 ** only works if you are running as root (since the list
3186 ** of valid shells is obviously a source of great concern).
3187 ** I recommend that you do NOT define USEGETCONFATTR,
3188 ** especially since you are going to have to set up an
3189 ** /etc/shells anyhow to handle the cases where getconfattr
3190 ** fails.
3191 */
3192
3193 if (getconfattr(SC_SYS_LOGIN, SC_SHELLS, &v, SEC_LIST) == 0 && v != NULL)
3194 {
3195 while (*v != '\0')
3196 {
3197 if (strcmp(v, shell) == 0 || strcmp(v, WILDCARD_SHELL) == 0)
3198 return true;
3199 v += strlen(v) + 1;
3200 }
3201 return false;
3202 }
3203 # endif /* USEGETCONFATTR */
3204
3205 shellf = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, _PATH_SHELLS,
3206 SM_IO_RDONLY, NULL);
3207 if (shellf == NULL)
3208 {
3209 /* no /etc/shells; see if it is one of the std shells */
3210 char **d;
3211
3212 if (errno != ENOENT && LogLevel > 3)
3213 sm_syslog(LOG_ERR, NOQID,
3214 "usershellok: cannot open %s: %s",
3215 _PATH_SHELLS, sm_errstring(errno));
3216
3217 for (d = DefaultUserShells; *d != NULL; d++)
3218 {
3219 if (strcmp(shell, *d) == 0)
3220 return true;
3221 }
3222 return false;
3223 }
3224
3225 while (sm_io_fgets(shellf, SM_TIME_DEFAULT, buf, sizeof(buf)) != NULL)
3226 {
3227 register char *p, *q;
3228
3229 p = buf;
3230 while (*p != '\0' && *p != '#' && *p != '/')
3231 p++;
3232 if (*p == '#' || *p == '\0')
3233 continue;
3234 q = p;
3235 while (*p != '\0' && *p != '#' && !(isascii(*p) && isspace(*p)))
3236 p++;
3237 *p = '\0';
3238 if (strcmp(shell, q) == 0 || strcmp(WILDCARD_SHELL, q) == 0)
3239 {
3240 (void) sm_io_close(shellf, SM_TIME_DEFAULT);
3241 return true;
3242 }
3243 }
3244 (void) sm_io_close(shellf, SM_TIME_DEFAULT);
3245 return false;
3246 # endif /* HASGETUSERSHELL */
3247 }
3248 /*
3249 ** FREEDISKSPACE -- see how much free space is on the queue filesystem
3250 **
3251 ** Only implemented if you have statfs.
3252 **
3253 ** Parameters:
3254 ** dir -- the directory in question.
3255 ** bsize -- a variable into which the filesystem
3256 ** block size is stored.
3257 **
3258 ** Returns:
3259 ** The number of blocks free on the queue filesystem.
3260 ** -1 if the statfs call fails.
3261 **
3262 ** Side effects:
3263 ** Puts the filesystem block size into bsize.
3264 */
3265
3266 /* statfs types */
3267 # define SFS_NONE 0 /* no statfs implementation */
3268 # define SFS_USTAT 1 /* use ustat */
3269 # define SFS_4ARGS 2 /* use four-argument statfs call */
3270 # define SFS_VFS 3 /* use <sys/vfs.h> implementation */
3271 # define SFS_MOUNT 4 /* use <sys/mount.h> implementation */
3272 # define SFS_STATFS 5 /* use <sys/statfs.h> implementation */
3273 # define SFS_STATVFS 6 /* use <sys/statvfs.h> implementation */
3274
3275 # ifndef SFS_TYPE
3276 # define SFS_TYPE SFS_NONE
3277 # endif /* ! SFS_TYPE */
3278
3279 # if SFS_TYPE == SFS_USTAT
3280 # include <ustat.h>
3281 # endif /* SFS_TYPE == SFS_USTAT */
3282 # if SFS_TYPE == SFS_4ARGS || SFS_TYPE == SFS_STATFS
3283 # include <sys/statfs.h>
3284 # endif /* SFS_TYPE == SFS_4ARGS || SFS_TYPE == SFS_STATFS */
3285 # if SFS_TYPE == SFS_VFS
3286 # include <sys/vfs.h>
3287 # endif /* SFS_TYPE == SFS_VFS */
3288 # if SFS_TYPE == SFS_MOUNT
3289 # include <sys/mount.h>
3290 # endif /* SFS_TYPE == SFS_MOUNT */
3291 # if SFS_TYPE == SFS_STATVFS
3292 # include <sys/statvfs.h>
3293 # endif /* SFS_TYPE == SFS_STATVFS */
3294
3295 long
3296 freediskspace(dir, bsize)
3297 const char *dir;
3298 long *bsize;
3299 {
3300 # if SFS_TYPE == SFS_NONE
3301 if (bsize != NULL)
3302 *bsize = 4096L;
3303
3304 /* assume free space is plentiful */
3305 return (long) LONG_MAX;
3306 # else /* SFS_TYPE == SFS_NONE */
3307 # if SFS_TYPE == SFS_USTAT
3308 struct ustat fs;
3309 struct stat statbuf;
3310 # define FSBLOCKSIZE DEV_BSIZE
3311 # define SFS_BAVAIL f_tfree
3312 # else /* SFS_TYPE == SFS_USTAT */
3313 # if defined(ultrix)
3314 struct fs_data fs;
3315 # define SFS_BAVAIL fd_bfreen
3316 # define FSBLOCKSIZE 1024L
3317 # else /* defined(ultrix) */
3318 # if SFS_TYPE == SFS_STATVFS
3319 struct statvfs fs;
3320 # define FSBLOCKSIZE fs.f_frsize
3321 # else /* SFS_TYPE == SFS_STATVFS */
3322 struct statfs fs;
3323 # define FSBLOCKSIZE fs.f_bsize
3324 # endif /* SFS_TYPE == SFS_STATVFS */
3325 # endif /* defined(ultrix) */
3326 # endif /* SFS_TYPE == SFS_USTAT */
3327 # ifndef SFS_BAVAIL
3328 # define SFS_BAVAIL f_bavail
3329 # endif /* ! SFS_BAVAIL */
3330
3331 # if SFS_TYPE == SFS_USTAT
3332 if (stat(dir, &statbuf) == 0 && ustat(statbuf.st_dev, &fs) == 0)
3333 # else /* SFS_TYPE == SFS_USTAT */
3334 # if SFS_TYPE == SFS_4ARGS
3335 if (statfs(dir, &fs, sizeof(fs), 0) == 0)
3336 # else /* SFS_TYPE == SFS_4ARGS */
3337 # if SFS_TYPE == SFS_STATVFS
3338 if (statvfs(dir, &fs) == 0)
3339 # else /* SFS_TYPE == SFS_STATVFS */
3340 # if defined(ultrix)
3341 if (statfs(dir, &fs) > 0)
3342 # else /* defined(ultrix) */
3343 if (statfs(dir, &fs) == 0)
3344 # endif /* defined(ultrix) */
3345 # endif /* SFS_TYPE == SFS_STATVFS */
3346 # endif /* SFS_TYPE == SFS_4ARGS */
3347 # endif /* SFS_TYPE == SFS_USTAT */
3348 {
3349 if (bsize != NULL)
3350 *bsize = FSBLOCKSIZE;
3351 if (fs.SFS_BAVAIL <= 0)
3352 return 0;
3353 else if (fs.SFS_BAVAIL > LONG_MAX)
3354 return (long) LONG_MAX;
3355 else
3356 return (long) fs.SFS_BAVAIL;
3357 }
3358 return -1;
3359 # endif /* SFS_TYPE == SFS_NONE */
3360 }
3361 /*
3362 ** ENOUGHDISKSPACE -- is there enough free space on the queue file systems?
3363 **
3364 ** Parameters:
3365 ** msize -- the size to check against. If zero, we don't yet
3366 ** know how big the message will be, so just check for
3367 ** a "reasonable" amount.
3368 ** e -- envelope, or NULL -- controls logging
3369 **
3370 ** Returns:
3371 ** true if in every queue group there is at least one
3372 ** queue directory whose file system contains enough free space.
3373 ** false otherwise.
3374 **
3375 ** Side Effects:
3376 ** If there is not enough disk space and e != NULL
3377 ** then sm_syslog is called.
3378 */
3379
3380 bool
3381 enoughdiskspace(msize, e)
3382 long msize;
3383 ENVELOPE *e;
3384 {
3385 int i;
3386
3387 #if _FFR_TESTS
3388 if (tTd(4, 101))
3389 return false;
3390 #endif /* _FFR_TESTS */
3391 if (MinBlocksFree <= 0 && msize <= 0)
3392 {
3393 if (tTd(4, 80))
3394 sm_dprintf("enoughdiskspace: no threshold\n");
3395 return true;
3396 }
3397
3398 filesys_update();
3399 for (i = 0; i < NumQueue; ++i)
3400 {
3401 if (pickqdir(Queue[i], msize, e) < 0)
3402 return false;
3403 }
3404 return true;
3405 }
3406 /*
3407 ** TRANSIENTERROR -- tell if an error code indicates a transient failure
3408 **
3409 ** This looks at an errno value and tells if this is likely to
3410 ** go away if retried later.
3411 **
3412 ** Parameters:
3413 ** err -- the errno code to classify.
3414 **
3415 ** Returns:
3416 ** true if this is probably transient.
3417 ** false otherwise.
3418 */
3419
3420 bool
3421 transienterror(err)
3422 int err;
3423 {
3424 switch (err)
3425 {
3426 case EIO: /* I/O error */
3427 case ENXIO: /* Device not configured */
3428 case EAGAIN: /* Resource temporarily unavailable */
3429 case ENOMEM: /* Cannot allocate memory */
3430 case ENODEV: /* Operation not supported by device */
3431 case ENFILE: /* Too many open files in system */
3432 case EMFILE: /* Too many open files */
3433 case ENOSPC: /* No space left on device */
3434 case ETIMEDOUT: /* Connection timed out */
3435 #ifdef ESTALE
3436 case ESTALE: /* Stale NFS file handle */
3437 #endif /* ESTALE */
3438 #ifdef ENETDOWN
3439 case ENETDOWN: /* Network is down */
3440 #endif /* ENETDOWN */
3441 #ifdef ENETUNREACH
3442 case ENETUNREACH: /* Network is unreachable */
3443 #endif /* ENETUNREACH */
3444 #ifdef ENETRESET
3445 case ENETRESET: /* Network dropped connection on reset */
3446 #endif /* ENETRESET */
3447 #ifdef ECONNABORTED
3448 case ECONNABORTED: /* Software caused connection abort */
3449 #endif /* ECONNABORTED */
3450 #ifdef ECONNRESET
3451 case ECONNRESET: /* Connection reset by peer */
3452 #endif /* ECONNRESET */
3453 #ifdef ENOBUFS
3454 case ENOBUFS: /* No buffer space available */
3455 #endif /* ENOBUFS */
3456 #ifdef ESHUTDOWN
3457 case ESHUTDOWN: /* Can't send after socket shutdown */
3458 #endif /* ESHUTDOWN */
3459 #ifdef ECONNREFUSED
3460 case ECONNREFUSED: /* Connection refused */
3461 #endif /* ECONNREFUSED */
3462 #ifdef EHOSTDOWN
3463 case EHOSTDOWN: /* Host is down */
3464 #endif /* EHOSTDOWN */
3465 #ifdef EHOSTUNREACH
3466 case EHOSTUNREACH: /* No route to host */
3467 #endif /* EHOSTUNREACH */
3468 #ifdef EDQUOT
3469 case EDQUOT: /* Disc quota exceeded */
3470 #endif /* EDQUOT */
3471 #ifdef EPROCLIM
3472 case EPROCLIM: /* Too many processes */
3473 #endif /* EPROCLIM */
3474 #ifdef EUSERS
3475 case EUSERS: /* Too many users */
3476 #endif /* EUSERS */
3477 #ifdef EDEADLK
3478 case EDEADLK: /* Resource deadlock avoided */
3479 #endif /* EDEADLK */
3480 #ifdef EISCONN
3481 case EISCONN: /* Socket already connected */
3482 #endif /* EISCONN */
3483 #ifdef EINPROGRESS
3484 case EINPROGRESS: /* Operation now in progress */
3485 #endif /* EINPROGRESS */
3486 #ifdef EALREADY
3487 case EALREADY: /* Operation already in progress */
3488 #endif /* EALREADY */
3489 #ifdef EADDRINUSE
3490 case EADDRINUSE: /* Address already in use */
3491 #endif /* EADDRINUSE */
3492 #ifdef EADDRNOTAVAIL
3493 case EADDRNOTAVAIL: /* Can't assign requested address */
3494 #endif /* EADDRNOTAVAIL */
3495 #ifdef ETXTBSY
3496 case ETXTBSY: /* (Apollo) file locked */
3497 #endif /* ETXTBSY */
3498 #if defined(ENOSR) && (!defined(ENOBUFS) || (ENOBUFS != ENOSR))
3499 case ENOSR: /* Out of streams resources */
3500 #endif /* defined(ENOSR) && (!defined(ENOBUFS) || (ENOBUFS != ENOSR)) */
3501 #ifdef ENOLCK
3502 case ENOLCK: /* No locks available */
3503 #endif /* ENOLCK */
3504 case E_SM_OPENTIMEOUT: /* PSEUDO: open timed out */
3505 return true;
3506 }
3507
3508 /* nope, must be permanent */
3509 return false;
3510 }
3511 /*
3512 ** LOCKFILE -- lock a file using flock or (shudder) fcntl locking
3513 **
3514 ** Parameters:
3515 ** fd -- the file descriptor of the file.
3516 ** filename -- the file name (for error messages).
3517 ** ext -- the filename extension.
3518 ** type -- type of the lock. Bits can be:
3519 ** LOCK_EX -- exclusive lock.
3520 ** LOCK_NB -- non-blocking.
3521 ** LOCK_UN -- unlock.
3522 **
3523 ** Returns:
3524 ** true if the lock was acquired.
3525 ** false otherwise.
3526 */
3527
3528 bool
3529 lockfile(fd, filename, ext, type)
3530 int fd;
3531 char *filename;
3532 char *ext;
3533 int type;
3534 {
3535 int i;
3536 int save_errno;
3537 # if !HASFLOCK
3538 int action;
3539 struct flock lfd;
3540
3541 if (ext == NULL)
3542 ext = "";
3543
3544 memset(&lfd, '\0', sizeof(lfd));
3545 if (bitset(LOCK_UN, type))
3546 lfd.l_type = F_UNLCK;
3547 else if (bitset(LOCK_EX, type))
3548 lfd.l_type = F_WRLCK;
3549 else
3550 lfd.l_type = F_RDLCK;
3551
3552 if (bitset(LOCK_NB, type))
3553 action = F_SETLK;
3554 else
3555 action = F_SETLKW;
3556
3557 if (tTd(55, 60))
3558 sm_dprintf("lockfile(%s%s, action=%d, type=%d): ",
3559 filename, ext, action, lfd.l_type);
3560
3561 while ((i = fcntl(fd, action, &lfd)) < 0 && errno == EINTR)
3562 continue;
3563 if (i >= 0)
3564 {
3565 if (tTd(55, 60))
3566 sm_dprintf("SUCCESS\n");
3567 return true;
3568 }
3569 save_errno = errno;
3570
3571 if (tTd(55, 60))
3572 sm_dprintf("(%s) ", sm_errstring(save_errno));
3573
3574 /*
3575 ** On SunOS, if you are testing using -oQ/tmp/mqueue or
3576 ** -oA/tmp/aliases or anything like that, and /tmp is mounted
3577 ** as type "tmp" (that is, served from swap space), the
3578 ** previous fcntl will fail with "Invalid argument" errors.
3579 ** Since this is fairly common during testing, we will assume
3580 ** that this indicates that the lock is successfully grabbed.
3581 */
3582
3583 if (save_errno == EINVAL)
3584 {
3585 if (tTd(55, 60))
3586 sm_dprintf("SUCCESS\n");
3587 return true;
3588 }
3589
3590 if (!bitset(LOCK_NB, type) ||
3591 (save_errno != EACCES && save_errno != EAGAIN))
3592 {
3593 int omode = fcntl(fd, F_GETFL, 0);
3594 uid_t euid = geteuid();
3595
3596 errno = save_errno;
3597 syserr("cannot lockf(%s%s, fd=%d, type=%o, omode=%o, euid=%d)",
3598 filename, ext, fd, type, omode, euid);
3599 dumpfd(fd, true, true);
3600 }
3601 # else /* !HASFLOCK */
3602 if (ext == NULL)
3603 ext = "";
3604
3605 if (tTd(55, 60))
3606 sm_dprintf("lockfile(%s%s, type=%o): ", filename, ext, type);
3607
3608 while ((i = flock(fd, type)) < 0 && errno == EINTR)
3609 continue;
3610 if (i >= 0)
3611 {
3612 if (tTd(55, 60))
3613 sm_dprintf("SUCCESS\n");
3614 return true;
3615 }
3616 save_errno = errno;
3617
3618 if (tTd(55, 60))
3619 sm_dprintf("(%s) ", sm_errstring(save_errno));
3620
3621 if (!bitset(LOCK_NB, type) || save_errno != EWOULDBLOCK)
3622 {
3623 int omode = fcntl(fd, F_GETFL, 0);
3624 uid_t euid = geteuid();
3625
3626 errno = save_errno;
3627 syserr("cannot flock(%s%s, fd=%d, type=%o, omode=%o, euid=%d)",
3628 filename, ext, fd, type, omode, euid);
3629 dumpfd(fd, true, true);
3630 }
3631 # endif /* !HASFLOCK */
3632 if (tTd(55, 60))
3633 sm_dprintf("FAIL\n");
3634 errno = save_errno;
3635 return false;
3636 }
3637 /*
3638 ** CHOWNSAFE -- tell if chown is "safe" (executable only by root)
3639 **
3640 ** Unfortunately, given that we can't predict other systems on which
3641 ** a remote mounted (NFS) filesystem will be mounted, the answer is
3642 ** almost always that this is unsafe.
3643 **
3644 ** Note also that many operating systems have non-compliant
3645 ** implementations of the _POSIX_CHOWN_RESTRICTED variable and the
3646 ** fpathconf() routine. According to IEEE 1003.1-1990, if
3647 ** _POSIX_CHOWN_RESTRICTED is defined and not equal to -1, then
3648 ** no non-root process can give away the file. However, vendors
3649 ** don't take NFS into account, so a comfortable value of
3650 ** _POSIX_CHOWN_RESTRICTED tells us nothing.
3651 **
3652 ** Also, some systems (e.g., IRIX 6.2) return 1 from fpathconf()
3653 ** even on files where chown is not restricted. Many systems get
3654 ** this wrong on NFS-based filesystems (that is, they say that chown
3655 ** is restricted [safe] on NFS filesystems where it may not be, since
3656 ** other systems can access the same filesystem and do file giveaway;
3657 ** only the NFS server knows for sure!) Hence, it is important to
3658 ** get the value of SAFENFSPATHCONF correct -- it should be defined
3659 ** _only_ after testing (see test/t_pathconf.c) a system on an unsafe
3660 ** NFS-based filesystem to ensure that you can get meaningful results.
3661 ** If in doubt, assume unsafe!
3662 **
3663 ** You may also need to tweak IS_SAFE_CHOWN -- it should be a
3664 ** condition indicating whether the return from pathconf indicates
3665 ** that chown is safe (typically either > 0 or >= 0 -- there isn't
3666 ** even any agreement about whether a zero return means that a file
3667 ** is or is not safe). It defaults to "> 0".
3668 **
3669 ** If the parent directory is safe (writable only by owner back
3670 ** to the root) then we can relax slightly and trust fpathconf
3671 ** in more circumstances. This is really a crock -- if this is an
3672 ** NFS mounted filesystem then we really know nothing about the
3673 ** underlying implementation. However, most systems pessimize and
3674 ** return an error (EINVAL or EOPNOTSUPP) on NFS filesystems, which
3675 ** we interpret as unsafe, as we should. Thus, this heuristic gets
3676 ** us into a possible problem only on systems that have a broken
3677 ** pathconf implementation and which are also poorly configured
3678 ** (have :include: files in group- or world-writable directories).
3679 **
3680 ** Parameters:
3681 ** fd -- the file descriptor to check.
3682 ** safedir -- set if the parent directory is safe.
3683 **
3684 ** Returns:
3685 ** true -- if the chown(2) operation is "safe" -- that is,
3686 ** only root can chown the file to an arbitrary user.
3687 ** false -- if an arbitrary user can give away a file.
3688 */
3689
3690 #ifndef IS_SAFE_CHOWN
3691 # define IS_SAFE_CHOWN > 0
3692 #endif /* ! IS_SAFE_CHOWN */
3693
3694 bool
3695 chownsafe(fd, safedir)
3696 int fd;
3697 bool safedir;
3698 {
3699 # if (!defined(_POSIX_CHOWN_RESTRICTED) || _POSIX_CHOWN_RESTRICTED != -1) && \
3700 (defined(_PC_CHOWN_RESTRICTED) || defined(_GNU_TYPES_H))
3701 int rval;
3702
3703 /* give the system administrator a chance to override */
3704 if (bitnset(DBS_ASSUMESAFECHOWN, DontBlameSendmail))
3705 return true;
3706
3707 /*
3708 ** Some systems (e.g., SunOS) seem to have the call and the
3709 ** #define _PC_CHOWN_RESTRICTED, but don't actually implement
3710 ** the call. This heuristic checks for that.
3711 */
3712
3713 errno = 0;
3714 rval = fpathconf(fd, _PC_CHOWN_RESTRICTED);
3715 # if SAFENFSPATHCONF
3716 return errno == 0 && rval IS_SAFE_CHOWN;
3717 # else /* SAFENFSPATHCONF */
3718 return safedir && errno == 0 && rval IS_SAFE_CHOWN;
3719 # endif /* SAFENFSPATHCONF */
3720 # else /* (!defined(_POSIX_CHOWN_RESTRICTED) || _POSIX_CHOWN_RESTRICTED != -1) && ... */
3721 return bitnset(DBS_ASSUMESAFECHOWN, DontBlameSendmail);
3722 # endif /* (!defined(_POSIX_CHOWN_RESTRICTED) || _POSIX_CHOWN_RESTRICTED != -1) && ... */
3723 }
3724 /*
3725 ** RESETLIMITS -- reset system controlled resource limits
3726 **
3727 ** This is to avoid denial-of-service attacks
3728 **
3729 ** Parameters:
3730 ** none
3731 **
3732 ** Returns:
3733 ** none
3734 */
3735
3736 #if HASSETRLIMIT
3737 # ifdef RLIMIT_NEEDS_SYS_TIME_H
3738 # include <sm/time.h>
3739 # endif /* RLIMIT_NEEDS_SYS_TIME_H */
3740 # include <sys/resource.h>
3741 #endif /* HASSETRLIMIT */
3742
3743 void
3744 resetlimits()
3745 {
3746 #if HASSETRLIMIT
3747 struct rlimit lim;
3748
3749 lim.rlim_cur = lim.rlim_max = RLIM_INFINITY;
3750 (void) setrlimit(RLIMIT_CPU, &lim);
3751 (void) setrlimit(RLIMIT_FSIZE, &lim);
3752 # ifdef RLIMIT_NOFILE
3753 lim.rlim_cur = lim.rlim_max = FD_SETSIZE;
3754 (void) setrlimit(RLIMIT_NOFILE, &lim);
3755 # endif /* RLIMIT_NOFILE */
3756 #else /* HASSETRLIMIT */
3757 # if HASULIMIT
3758 (void) ulimit(2, 0x3fffff);
3759 (void) ulimit(4, FD_SETSIZE);
3760 # endif /* HASULIMIT */
3761 #endif /* HASSETRLIMIT */
3762 errno = 0;
3763 }
3764 /*
3765 ** SETVENDOR -- process vendor code from V configuration line
3766 **
3767 ** Parameters:
3768 ** vendor -- string representation of vendor.
3769 **
3770 ** Returns:
3771 ** true -- if ok.
3772 ** false -- if vendor code could not be processed.
3773 **
3774 ** Side Effects:
3775 ** It is reasonable to set mode flags here to tweak
3776 ** processing in other parts of the code if necessary.
3777 ** For example, if you are a vendor that uses $%y to
3778 ** indicate YP lookups, you could enable that here.
3779 */
3780
3781 bool
3782 setvendor(vendor)
3783 char *vendor;
3784 {
3785 if (sm_strcasecmp(vendor, "Berkeley") == 0)
3786 {
3787 VendorCode = VENDOR_BERKELEY;
3788 return true;
3789 }
3790
3791 /* add vendor extensions here */
3792
3793 #ifdef SUN_EXTENSIONS
3794 if (sm_strcasecmp(vendor, "Sun") == 0)
3795 {
3796 VendorCode = VENDOR_SUN;
3797 return true;
3798 }
3799 #endif /* SUN_EXTENSIONS */
3800 #ifdef DEC
3801 if (sm_strcasecmp(vendor, "Digital") == 0)
3802 {
3803 VendorCode = VENDOR_DEC;
3804 return true;
3805 }
3806 #endif /* DEC */
3807
3808 #if defined(VENDOR_NAME) && defined(VENDOR_CODE)
3809 if (sm_strcasecmp(vendor, VENDOR_NAME) == 0)
3810 {
3811 VendorCode = VENDOR_CODE;
3812 return true;
3813 }
3814 #endif /* defined(VENDOR_NAME) && defined(VENDOR_CODE) */
3815
3816 return false;
3817 }
3818 /*
3819 ** GETVENDOR -- return vendor name based on vendor code
3820 **
3821 ** Parameters:
3822 ** vendorcode -- numeric representation of vendor.
3823 **
3824 ** Returns:
3825 ** string containing vendor name.
3826 */
3827
3828 char *
3829 getvendor(vendorcode)
3830 int vendorcode;
3831 {
3832 #if defined(VENDOR_NAME) && defined(VENDOR_CODE)
3833 /*
3834 ** Can't have the same switch case twice so need to
3835 ** handle VENDOR_CODE outside of switch. It might
3836 ** match one of the existing VENDOR_* codes.
3837 */
3838
3839 if (vendorcode == VENDOR_CODE)
3840 return VENDOR_NAME;
3841 #endif /* defined(VENDOR_NAME) && defined(VENDOR_CODE) */
3842
3843 switch (vendorcode)
3844 {
3845 case VENDOR_BERKELEY:
3846 return "Berkeley";
3847
3848 case VENDOR_SUN:
3849 return "Sun";
3850
3851 case VENDOR_HP:
3852 return "HP";
3853
3854 case VENDOR_IBM:
3855 return "IBM";
3856
3857 case VENDOR_SENDMAIL:
3858 return "Sendmail";
3859
3860 default:
3861 return "Unknown";
3862 }
3863 }
3864 /*
3865 ** VENDOR_PRE_DEFAULTS, VENDOR_POST_DEFAULTS -- set vendor-specific defaults
3866 **
3867 ** Vendor_pre_defaults is called before reading the configuration
3868 ** file; vendor_post_defaults is called immediately after.
3869 **
3870 ** Parameters:
3871 ** e -- the global environment to initialize.
3872 **
3873 ** Returns:
3874 ** none.
3875 */
3876
3877 #if SHARE_V1
3878 int DefShareUid; /* default share uid to run as -- unused??? */
3879 #endif /* SHARE_V1 */
3880
3881 void
3882 vendor_pre_defaults(e)
3883 ENVELOPE *e;
3884 {
3885 #if SHARE_V1
3886 /* OTHERUID is defined in shares.h, do not be alarmed */
3887 DefShareUid = OTHERUID;
3888 #endif /* SHARE_V1 */
3889 #if defined(SUN_EXTENSIONS) && defined(SUN_DEFAULT_VALUES)
3890 sun_pre_defaults(e);
3891 #endif /* defined(SUN_EXTENSIONS) && defined(SUN_DEFAULT_VALUES) */
3892 #ifdef apollo
3893 /*
3894 ** stupid domain/os can't even open
3895 ** /etc/mail/sendmail.cf without this
3896 */
3897
3898 sm_setuserenv("ISP", NULL);
3899 sm_setuserenv("SYSTYPE", NULL);
3900 #endif /* apollo */
3901 }
3902
3903
3904 void
3905 vendor_post_defaults(e)
3906 ENVELOPE *e;
3907 {
3908 #ifdef __QNX__
3909 /* Makes sure the SOCK environment variable remains */
3910 sm_setuserenv("SOCK", NULL);
3911 #endif /* __QNX__ */
3912 #if defined(SUN_EXTENSIONS) && defined(SUN_DEFAULT_VALUES)
3913 sun_post_defaults(e);
3914 #endif /* defined(SUN_EXTENSIONS) && defined(SUN_DEFAULT_VALUES) */
3915 }
3916 /*
3917 ** VENDOR_DAEMON_SETUP -- special vendor setup needed for daemon mode
3918 */
3919
3920 void
3921 vendor_daemon_setup(e)
3922 ENVELOPE *e;
3923 {
3924 #if HASSETLOGIN
3925 (void) setlogin(RunAsUserName);
3926 #endif /* HASSETLOGIN */
3927 #if SECUREWARE
3928 if (getluid() != -1)
3929 {
3930 usrerr("Daemon cannot have LUID");
3931 finis(false, true, EX_USAGE);
3932 }
3933 #endif /* SECUREWARE */
3934 }
3935 /*
3936 ** VENDOR_SET_UID -- do setup for setting a user id
3937 **
3938 ** This is called when we are still root.
3939 **
3940 ** Parameters:
3941 ** uid -- the uid we are about to become.
3942 **
3943 ** Returns:
3944 ** none.
3945 */
3946
3947 void
3948 vendor_set_uid(uid)
3949 UID_T uid;
3950 {
3951 /*
3952 ** We need to setup the share groups (lnodes)
3953 ** and add auditing information (luid's)
3954 ** before we loose our ``root''ness.
3955 */
3956 #if SHARE_V1
3957 if (setupshares(uid, syserr) != 0)
3958 syserr("Unable to set up shares");
3959 #endif /* SHARE_V1 */
3960 #if SECUREWARE
3961 (void) setup_secure(uid);
3962 #endif /* SECUREWARE */
3963 }
3964 /*
3965 ** VALIDATE_CONNECTION -- check connection for rationality
3966 **
3967 ** If the connection is rejected, this routine should log an
3968 ** appropriate message -- but should never issue any SMTP protocol.
3969 **
3970 ** Parameters:
3971 ** sap -- a pointer to a SOCKADDR naming the peer.
3972 ** hostname -- the name corresponding to sap.
3973 ** e -- the current envelope.
3974 **
3975 ** Returns:
3976 ** error message from rejection.
3977 ** NULL if not rejected.
3978 */
3979
3980 #if TCPWRAPPERS
3981 # include <tcpd.h>
3982
3983 /* tcpwrappers does no logging, but you still have to declare these -- ugh */
3984 int allow_severity = LOG_INFO;
3985 int deny_severity = LOG_NOTICE;
3986 #endif /* TCPWRAPPERS */
3987
3988 char *
3989 validate_connection(sap, hostname, e)
3990 SOCKADDR *sap;
3991 char *hostname;
3992 ENVELOPE *e;
3993 {
3994 #if TCPWRAPPERS
3995 char *host;
3996 char *addr;
3997 extern int hosts_ctl();
3998 #endif /* TCPWRAPPERS */
3999
4000 if (tTd(48, 3))
4001 sm_dprintf("validate_connection(%s, %s)\n",
4002 hostname, anynet_ntoa(sap));
4003
4004 connection_rate_check(sap, e);
4005 if (rscheck("check_relay", hostname, anynet_ntoa(sap),
4006 e, RSF_RMCOMM|RSF_COUNT, 3, NULL, NOQID, NULL) != EX_OK)
4007 {
4008 static char reject[BUFSIZ*2];
4009 extern char MsgBuf[];
4010
4011 if (tTd(48, 4))
4012 sm_dprintf(" ... validate_connection: BAD (rscheck)\n");
4013
4014 if (strlen(MsgBuf) >= 3)
4015 (void) sm_strlcpy(reject, MsgBuf, sizeof(reject));
4016 else
4017 (void) sm_strlcpy(reject, "Access denied", sizeof(reject));
4018
4019 return reject;
4020 }
4021
4022 #if TCPWRAPPERS
4023 if (hostname[0] == '[' && hostname[strlen(hostname) - 1] == ']')
4024 host = "unknown";
4025 else
4026 host = hostname;
4027 addr = anynet_ntoa(sap);
4028
4029 # if NETINET6
4030 /* TCP/Wrappers don't want the IPv6: protocol label */
4031 if (addr != NULL && sm_strncasecmp(addr, "IPv6:", 5) == 0)
4032 addr += 5;
4033 # endif /* NETINET6 */
4034
4035 if (!hosts_ctl("sendmail", host, addr, STRING_UNKNOWN))
4036 {
4037 if (tTd(48, 4))
4038 sm_dprintf(" ... validate_connection: BAD (tcpwrappers)\n");
4039 if (LogLevel > 3)
4040 sm_syslog(LOG_NOTICE, e->e_id,
4041 "tcpwrappers (%s, %s) rejection",
4042 host, addr);
4043 return "Access denied";
4044 }
4045 #endif /* TCPWRAPPERS */
4046 if (tTd(48, 4))
4047 sm_dprintf(" ... validate_connection: OK\n");
4048 return NULL;
4049 }
4050
4051 /*
4052 ** STRTOL -- convert string to long integer
4053 **
4054 ** For systems that don't have it in the C library.
4055 **
4056 ** This is taken verbatim from the 4.4-Lite C library.
4057 */
4058
4059 #if NEEDSTRTOL
4060
4061 # if defined(LIBC_SCCS) && !defined(lint)
4062 static char sccsid[] = "@(#)strtol.c 8.1 (Berkeley) 6/4/93";
4063 # endif /* defined(LIBC_SCCS) && !defined(lint) */
4064
4065 /*
4066 ** Convert a string to a long integer.
4067 **
4068 ** Ignores `locale' stuff. Assumes that the upper and lower case
4069 ** alphabets and digits are each contiguous.
4070 */
4071
4072 long
4073 strtol(nptr, endptr, base)
4074 const char *nptr;
4075 char **endptr;
4076 register int base;
4077 {
4078 register const char *s = nptr;
4079 register unsigned long acc;
4080 register int c;
4081 register unsigned long cutoff;
4082 register int neg = 0, any, cutlim;
4083
4084 /*
4085 ** Skip white space and pick up leading +/- sign if any.
4086 ** If base is 0, allow 0x for hex and 0 for octal, else
4087 ** assume decimal; if base is already 16, allow 0x.
4088 */
4089 do {
4090 c = *s++;
4091 } while (isascii(c) && isspace(c));
4092 if (c == '-') {
4093 neg = 1;
4094 c = *s++;
4095 } else if (c == '+')
4096 c = *s++;
4097 if ((base == 0 || base == 16) &&
4098 c == '0' && (*s == 'x' || *s == 'X')) {
4099 c = s[1];
4100 s += 2;
4101 base = 16;
4102 }
4103 if (base == 0)
4104 base = c == '0' ? 8 : 10;
4105
4106 /*
4107 ** Compute the cutoff value between legal numbers and illegal
4108 ** numbers. That is the largest legal value, divided by the
4109 ** base. An input number that is greater than this value, if
4110 ** followed by a legal input character, is too big. One that
4111 ** is equal to this value may be valid or not; the limit
4112 ** between valid and invalid numbers is then based on the last
4113 ** digit. For instance, if the range for longs is
4114 ** [-2147483648..2147483647] and the input base is 10,
4115 ** cutoff will be set to 214748364 and cutlim to either
4116 ** 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated
4117 ** a value > 214748364, or equal but the next digit is > 7 (or 8),
4118 ** the number is too big, and we will return a range error.
4119 **
4120 ** Set any if any `digits' consumed; make it negative to indicate
4121 ** overflow.
4122 */
4123 cutoff = neg ? -(unsigned long) LONG_MIN : LONG_MAX;
4124 cutlim = cutoff % (unsigned long) base;
4125 cutoff /= (unsigned long) base;
4126 for (acc = 0, any = 0;; c = *s++) {
4127 if (isascii(c) && isdigit(c))
4128 c -= '0';
4129 else if (isascii(c) && isalpha(c))
4130 c -= isupper(c) ? 'A' - 10 : 'a' - 10;
4131 else
4132 break;
4133 if (c >= base)
4134 break;
4135 if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
4136 any = -1;
4137 else {
4138 any = 1;
4139 acc *= base;
4140 acc += c;
4141 }
4142 }
4143 if (any < 0) {
4144 acc = neg ? LONG_MIN : LONG_MAX;
4145 errno = ERANGE;
4146 } else if (neg)
4147 acc = -acc;
4148 if (endptr != 0)
4149 *endptr = (char *)(any ? s - 1 : nptr);
4150 return acc;
4151 }
4152
4153 #endif /* NEEDSTRTOL */
4154 /*
4155 ** STRSTR -- find first substring in string
4156 **
4157 ** Parameters:
4158 ** big -- the big (full) string.
4159 ** little -- the little (sub) string.
4160 **
4161 ** Returns:
4162 ** A pointer to the first instance of little in big.
4163 ** big if little is the null string.
4164 ** NULL if little is not contained in big.
4165 */
4166
4167 #if NEEDSTRSTR
4168
4169 char *
4170 strstr(big, little)
4171 char *big;
4172 char *little;
4173 {
4174 register char *p = big;
4175 int l;
4176
4177 if (*little == '\0')
4178 return big;
4179 l = strlen(little);
4180
4181 while ((p = strchr(p, *little)) != NULL)
4182 {
4183 if (strncmp(p, little, l) == 0)
4184 return p;
4185 p++;
4186 }
4187 return NULL;
4188 }
4189
4190 #endif /* NEEDSTRSTR */
4191 /*
4192 ** SM_GETHOSTBY{NAME,ADDR} -- compatibility routines for gethostbyXXX
4193 **
4194 ** Some operating systems have weird problems with the gethostbyXXX
4195 ** routines. For example, Solaris versions at least through 2.3
4196 ** don't properly deliver a canonical h_name field. This tries to
4197 ** work around these problems.
4198 **
4199 ** Support IPv6 as well as IPv4.
4200 */
4201
4202 #if NETINET6 && NEEDSGETIPNODE
4203
4204 # ifndef AI_DEFAULT
4205 # define AI_DEFAULT 0 /* dummy */
4206 # endif /* ! AI_DEFAULT */
4207 # ifndef AI_ADDRCONFIG
4208 # define AI_ADDRCONFIG 0 /* dummy */
4209 # endif /* ! AI_ADDRCONFIG */
4210 # ifndef AI_V4MAPPED
4211 # define AI_V4MAPPED 0 /* dummy */
4212 # endif /* ! AI_V4MAPPED */
4213 # ifndef AI_ALL
4214 # define AI_ALL 0 /* dummy */
4215 # endif /* ! AI_ALL */
4216
4217 static struct hostent *
4218 sm_getipnodebyname(name, family, flags, err)
4219 const char *name;
4220 int family;
4221 int flags;
4222 int *err;
4223 {
4224 bool resv6 = true;
4225 struct hostent *h;
4226
4227 if (family == AF_INET6)
4228 {
4229 /* From RFC2133, section 6.1 */
4230 resv6 = bitset(RES_USE_INET6, _res.options);
4231 _res.options |= RES_USE_INET6;
4232 }
4233 SM_SET_H_ERRNO(0);
4234 h = gethostbyname(name);
4235 if (!resv6)
4236 _res.options &= ~RES_USE_INET6;
4237 *err = h_errno;
4238 return h;
4239 }
4240
4241 static struct hostent *
4242 sm_getipnodebyaddr(addr, len, family, err)
4243 const void *addr;
4244 size_t len;
4245 int family;
4246 int *err;
4247 {
4248 struct hostent *h;
4249
4250 SM_SET_H_ERRNO(0);
4251 h = gethostbyaddr(addr, len, family);
4252 *err = h_errno;
4253 return h;
4254 }
4255
4256 void
4257 freehostent(h)
4258 struct hostent *h;
4259 {
4260 /*
4261 ** Stub routine -- if they don't have getipnodeby*(),
4262 ** they probably don't have the free routine either.
4263 */
4264
4265 return;
4266 }
4267 #endif /* NETINET6 && NEEDSGETIPNODE */
4268
4269 struct hostent *
4270 sm_gethostbyname(name, family)
4271 char *name;
4272 int family;
4273 {
4274 int save_errno;
4275 struct hostent *h = NULL;
4276 #if (SOLARIS > 10000 && SOLARIS < 20400) || (defined(SOLARIS) && SOLARIS < 204) || (defined(sony_news) && defined(__svr4))
4277 # if SOLARIS == 20300 || SOLARIS == 203
4278 static struct hostent hp;
4279 static char buf[1000];
4280 extern struct hostent *_switch_gethostbyname_r();
4281
4282 if (tTd(61, 10))
4283 sm_dprintf("_switch_gethostbyname_r(%s)... ", name);
4284 h = _switch_gethostbyname_r(name, &hp, buf, sizeof(buf), &h_errno);
4285 save_errno = errno;
4286 # else /* SOLARIS == 20300 || SOLARIS == 203 */
4287 extern struct hostent *__switch_gethostbyname();
4288
4289 if (tTd(61, 10))
4290 sm_dprintf("__switch_gethostbyname(%s)... ", name);
4291 h = __switch_gethostbyname(name);
4292 save_errno = errno;
4293 # endif /* SOLARIS == 20300 || SOLARIS == 203 */
4294 #else /* (SOLARIS > 10000 && SOLARIS < 20400) || (defined(SOLARIS) && SOLARIS < 204) || (defined(sony_news) && defined(__svr4)) */
4295 int nmaps;
4296 # if NETINET6
4297 int flags = AI_DEFAULT|AI_ALL;
4298 int err;
4299 # endif /* NETINET6 */
4300 char *maptype[MAXMAPSTACK];
4301 short mapreturn[MAXMAPACTIONS];
4302 char hbuf[MAXNAME];
4303
4304 if (tTd(61, 10))
4305 sm_dprintf("sm_gethostbyname(%s, %d)... ", name, family);
4306
4307 # if NETINET6
4308 # if ADDRCONFIG_IS_BROKEN
4309 flags &= ~AI_ADDRCONFIG;
4310 # endif /* ADDRCONFIG_IS_BROKEN */
4311 h = sm_getipnodebyname(name, family, flags, &err);
4312 SM_SET_H_ERRNO(err);
4313 # else /* NETINET6 */
4314 h = gethostbyname(name);
4315 # endif /* NETINET6 */
4316
4317 save_errno = errno;
4318 if (h == NULL)
4319 {
4320 if (tTd(61, 10))
4321 sm_dprintf("failure\n");
4322
4323 nmaps = switch_map_find("hosts", maptype, mapreturn);
4324 while (--nmaps >= 0)
4325 {
4326 if (strcmp(maptype[nmaps], "nis") == 0 ||
4327 strcmp(maptype[nmaps], "files") == 0)
4328 break;
4329 }
4330
4331 if (nmaps >= 0)
4332 {
4333 /* try short name */
4334 if (strlen(name) > sizeof(hbuf) - 1)
4335 {
4336 errno = save_errno;
4337 return NULL;
4338 }
4339 (void) sm_strlcpy(hbuf, name, sizeof(hbuf));
4340 (void) shorten_hostname(hbuf);
4341
4342 /* if it hasn't been shortened, there's no point */
4343 if (strcmp(hbuf, name) != 0)
4344 {
4345 if (tTd(61, 10))
4346 sm_dprintf("sm_gethostbyname(%s, %d)... ",
4347 hbuf, family);
4348
4349 # if NETINET6
4350 h = sm_getipnodebyname(hbuf, family, flags, &err);
4351 SM_SET_H_ERRNO(err);
4352 save_errno = errno;
4353 # else /* NETINET6 */
4354 h = gethostbyname(hbuf);
4355 save_errno = errno;
4356 # endif /* NETINET6 */
4357 }
4358 }
4359 }
4360 #endif /* (SOLARIS > 10000 && SOLARIS < 20400) || (defined(SOLARIS) && SOLARIS < 204) || (defined(sony_news) && defined(__svr4)) */
4361 if (tTd(61, 10))
4362 {
4363 if (h == NULL)
4364 sm_dprintf("failure\n");
4365 else
4366 {
4367 sm_dprintf("%s\n", h->h_name);
4368 if (tTd(61, 11))
4369 {
4370 #if NETINET6
4371 struct in6_addr ia6;
4372 char buf6[INET6_ADDRSTRLEN];
4373 #else /* NETINET6 */
4374 struct in_addr ia;
4375 #endif /* NETINET6 */
4376 size_t i;
4377
4378 if (h->h_aliases != NULL)
4379 for (i = 0; h->h_aliases[i] != NULL;
4380 i++)
4381 sm_dprintf("\talias: %s\n",
4382 h->h_aliases[i]);
4383 for (i = 0; h->h_addr_list[i] != NULL; i++)
4384 {
4385 char *addr;
4386
4387 #if NETINET6
4388 memmove(&ia6, h->h_addr_list[i],
4389 IN6ADDRSZ);
4390 addr = anynet_ntop(&ia6,
4391 buf6, sizeof(buf6));
4392 #else /* NETINET6 */
4393 memmove(&ia, h->h_addr_list[i],
4394 INADDRSZ);
4395 addr = (char *) inet_ntoa(ia);
4396 #endif /* NETINET6 */
4397 if (addr != NULL)
4398 sm_dprintf("\taddr: %s\n", addr);
4399 }
4400 }
4401 }
4402 }
4403 errno = save_errno;
4404 return h;
4405 }
4406
4407 struct hostent *
4408 sm_gethostbyaddr(addr, len, type)
4409 char *addr;
4410 int len;
4411 int type;
4412 {
4413 struct hostent *hp;
4414
4415 #if NETINET6
4416 if (type == AF_INET6 &&
4417 IN6_IS_ADDR_UNSPECIFIED((struct in6_addr *) addr))
4418 {
4419 /* Avoid reverse lookup for IPv6 unspecified address */
4420 SM_SET_H_ERRNO(HOST_NOT_FOUND);
4421 return NULL;
4422 }
4423 #endif /* NETINET6 */
4424
4425 #if (SOLARIS > 10000 && SOLARIS < 20400) || (defined(SOLARIS) && SOLARIS < 204)
4426 # if SOLARIS == 20300 || SOLARIS == 203
4427 {
4428 static struct hostent he;
4429 static char buf[1000];
4430 extern struct hostent *_switch_gethostbyaddr_r();
4431
4432 hp = _switch_gethostbyaddr_r(addr, len, type, &he,
4433 buf, sizeof(buf), &h_errno);
4434 }
4435 # else /* SOLARIS == 20300 || SOLARIS == 203 */
4436 {
4437 extern struct hostent *__switch_gethostbyaddr();
4438
4439 hp = __switch_gethostbyaddr(addr, len, type);
4440 }
4441 # endif /* SOLARIS == 20300 || SOLARIS == 203 */
4442 #else /* (SOLARIS > 10000 && SOLARIS < 20400) || (defined(SOLARIS) && SOLARIS < 204) */
4443 # if NETINET6
4444 {
4445 int err;
4446
4447 hp = sm_getipnodebyaddr(addr, len, type, &err);
4448 SM_SET_H_ERRNO(err);
4449 }
4450 # else /* NETINET6 */
4451 hp = gethostbyaddr(addr, len, type);
4452 # endif /* NETINET6 */
4453 #endif /* (SOLARIS > 10000 && SOLARIS < 20400) || (defined(SOLARIS) && SOLARIS < 204) */
4454 return hp;
4455 }
4456 /*
4457 ** SM_GETPW{NAM,UID} -- wrapper for getpwnam and getpwuid
4458 */
4459
4460 struct passwd *
4461 sm_getpwnam(user)
4462 char *user;
4463 {
4464 #ifdef _AIX4
4465 extern struct passwd *_getpwnam_shadow(const char *, const int);
4466
4467 return _getpwnam_shadow(user, 0);
4468 #else /* _AIX4 */
4469 return getpwnam(user);
4470 #endif /* _AIX4 */
4471 }
4472
4473 struct passwd *
4474 sm_getpwuid(uid)
4475 UID_T uid;
4476 {
4477 #if defined(_AIX4) && 0
4478 extern struct passwd *_getpwuid_shadow(const int, const int);
4479
4480 return _getpwuid_shadow(uid,0);
4481 #else /* defined(_AIX4) && 0 */
4482 return getpwuid(uid);
4483 #endif /* defined(_AIX4) && 0 */
4484 }
4485 /*
4486 ** SECUREWARE_SETUP_SECURE -- Convex SecureWare setup
4487 **
4488 ** Set up the trusted computing environment for C2 level security
4489 ** under SecureWare.
4490 **
4491 ** Parameters:
4492 ** uid -- uid of the user to initialize in the TCB
4493 **
4494 ** Returns:
4495 ** none
4496 **
4497 ** Side Effects:
4498 ** Initialized the user in the trusted computing base
4499 */
4500
4501 #if SECUREWARE
4502
4503 # include <sys/security.h>
4504 # include <prot.h>
4505
4506 void
4507 secureware_setup_secure(uid)
4508 UID_T uid;
4509 {
4510 int rc;
4511
4512 if (getluid() != -1)
4513 return;
4514
4515 if ((rc = set_secure_info(uid)) != SSI_GOOD_RETURN)
4516 {
4517 switch (rc)
4518 {
4519 case SSI_NO_PRPW_ENTRY:
4520 syserr("No protected passwd entry, uid = %d",
4521 (int) uid);
4522 break;
4523
4524 case SSI_LOCKED:
4525 syserr("Account has been disabled, uid = %d",
4526 (int) uid);
4527 break;
4528
4529 case SSI_RETIRED:
4530 syserr("Account has been retired, uid = %d",
4531 (int) uid);
4532 break;
4533
4534 case SSI_BAD_SET_LUID:
4535 syserr("Could not set LUID, uid = %d", (int) uid);
4536 break;
4537
4538 case SSI_BAD_SET_PRIVS:
4539 syserr("Could not set kernel privs, uid = %d",
4540 (int) uid);
4541
4542 default:
4543 syserr("Unknown return code (%d) from set_secure_info(%d)",
4544 rc, (int) uid);
4545 break;
4546 }
4547 finis(false, true, EX_NOPERM);
4548 }
4549 }
4550 #endif /* SECUREWARE */
4551 /*
4552 ** ADD_HOSTNAMES -- Add a hostname to class 'w' based on IP address
4553 **
4554 ** Add hostnames to class 'w' based on the IP address read from
4555 ** the network interface.
4556 **
4557 ** Parameters:
4558 ** sa -- a pointer to a SOCKADDR containing the address
4559 **
4560 ** Returns:
4561 ** 0 if successful, -1 if host lookup fails.
4562 */
4563
4564 static int
4565 add_hostnames(sa)
4566 SOCKADDR *sa;
4567 {
4568 struct hostent *hp;
4569 char **ha;
4570 char hnb[MAXHOSTNAMELEN];
4571
4572 /* lookup name with IP address */
4573 switch (sa->sa.sa_family)
4574 {
4575 #if NETINET
4576 case AF_INET:
4577 hp = sm_gethostbyaddr((char *) &sa->sin.sin_addr,
4578 sizeof(sa->sin.sin_addr),
4579 sa->sa.sa_family);
4580 break;
4581 #endif /* NETINET */
4582
4583 #if NETINET6
4584 case AF_INET6:
4585 hp = sm_gethostbyaddr((char *) &sa->sin6.sin6_addr,
4586 sizeof(sa->sin6.sin6_addr),
4587 sa->sa.sa_family);
4588 break;
4589 #endif /* NETINET6 */
4590
4591 default:
4592 /* Give warning about unsupported family */
4593 if (LogLevel > 3)
4594 sm_syslog(LOG_WARNING, NOQID,
4595 "Unsupported address family %d: %.100s",
4596 sa->sa.sa_family, anynet_ntoa(sa));
4597 return -1;
4598 }
4599
4600 if (hp == NULL)
4601 {
4602 int save_errno = errno;
4603
4604 if (LogLevel > 3 &&
4605 #if NETINET6
4606 !(sa->sa.sa_family == AF_INET6 &&
4607 IN6_IS_ADDR_LINKLOCAL(&sa->sin6.sin6_addr)) &&
4608 #endif /* NETINET6 */
4609 true)
4610 sm_syslog(LOG_WARNING, NOQID,
4611 "gethostbyaddr(%.100s) failed: %d",
4612 anynet_ntoa(sa),
4613 #if NAMED_BIND
4614 h_errno
4615 #else /* NAMED_BIND */
4616 -1
4617 #endif /* NAMED_BIND */
4618 );
4619 errno = save_errno;
4620 return -1;
4621 }
4622
4623 /* save its cname */
4624 if (!wordinclass((char *) hp->h_name, 'w'))
4625 {
4626 setclass('w', (char *) hp->h_name);
4627 if (tTd(0, 4))
4628 sm_dprintf("\ta.k.a.: %s\n", hp->h_name);
4629
4630 if (sm_snprintf(hnb, sizeof(hnb), "[%s]", hp->h_name) <
4631 sizeof(hnb)
4632 && !wordinclass((char *) hnb, 'w'))
4633 setclass('w', hnb);
4634 }
4635 else
4636 {
4637 if (tTd(0, 43))
4638 sm_dprintf("\ta.k.a.: %s (already in $=w)\n", hp->h_name);
4639 }
4640
4641 /* save all it aliases name */
4642 for (ha = hp->h_aliases; ha != NULL && *ha != NULL; ha++)
4643 {
4644 if (!wordinclass(*ha, 'w'))
4645 {
4646 setclass('w', *ha);
4647 if (tTd(0, 4))
4648 sm_dprintf("\ta.k.a.: %s\n", *ha);
4649 if (sm_snprintf(hnb, sizeof(hnb),
4650 "[%s]", *ha) < sizeof(hnb) &&
4651 !wordinclass((char *) hnb, 'w'))
4652 setclass('w', hnb);
4653 }
4654 else
4655 {
4656 if (tTd(0, 43))
4657 sm_dprintf("\ta.k.a.: %s (already in $=w)\n",
4658 *ha);
4659 }
4660 }
4661 #if NETINET6
4662 freehostent(hp);
4663 #endif /* NETINET6 */
4664 return 0;
4665 }
4666 /*
4667 ** LOAD_IF_NAMES -- load interface-specific names into $=w
4668 **
4669 ** Parameters:
4670 ** none.
4671 **
4672 ** Returns:
4673 ** none.
4674 **
4675 ** Side Effects:
4676 ** Loads $=w with the names of all the interfaces.
4677 */
4678
4679 #if !NETINET
4680 # define SIOCGIFCONF_IS_BROKEN 1 /* XXX */
4681 #endif /* !NETINET */
4682
4683 #if defined(SIOCGIFCONF) && !SIOCGIFCONF_IS_BROKEN
4684 struct rtentry;
4685 struct mbuf;
4686 # ifndef SUNOS403
4687 # include <sm/time.h>
4688 # endif /* ! SUNOS403 */
4689 # if (_AIX4 >= 40300) && !defined(_NET_IF_H)
4690 # undef __P
4691 # endif /* (_AIX4 >= 40300) && !defined(_NET_IF_H) */
4692 # include <net/if.h>
4693 #endif /* defined(SIOCGIFCONF) && !SIOCGIFCONF_IS_BROKEN */
4694
4695 void
4696 load_if_names()
4697 {
4698 # if NETINET6 && defined(SIOCGLIFCONF)
4699 # ifdef __hpux
4700
4701 /*
4702 ** Unfortunately, HP has changed all of the structures,
4703 ** making life difficult for implementors.
4704 */
4705
4706 # define lifconf if_laddrconf
4707 # define lifc_len iflc_len
4708 # define lifc_buf iflc_buf
4709 # define lifreq if_laddrreq
4710 # define lifr_addr iflr_addr
4711 # define lifr_name iflr_name
4712 # define lifr_flags iflr_flags
4713 # define ss_family sa_family
4714 # undef SIOCGLIFNUM
4715 # endif /* __hpux */
4716
4717 int s;
4718 int i;
4719 size_t len;
4720 int numifs;
4721 char *buf;
4722 struct lifconf lifc;
4723 # ifdef SIOCGLIFNUM
4724 struct lifnum lifn;
4725 # endif /* SIOCGLIFNUM */
4726
4727 s = socket(InetMode, SOCK_DGRAM, 0);
4728 if (s == -1)
4729 return;
4730
4731 /* get the list of known IP address from the kernel */
4732 # ifdef __hpux
4733 i = ioctl(s, SIOCGIFNUM, (char *) &numifs);
4734 # endif /* __hpux */
4735 # ifdef SIOCGLIFNUM
4736 lifn.lifn_family = AF_UNSPEC;
4737 lifn.lifn_flags = 0;
4738 i = ioctl(s, SIOCGLIFNUM, (char *)&lifn);
4739 numifs = lifn.lifn_count;
4740 # endif /* SIOCGLIFNUM */
4741
4742 # if defined(__hpux) || defined(SIOCGLIFNUM)
4743 if (i < 0)
4744 {
4745 /* can't get number of interfaces -- fall back */
4746 if (tTd(0, 4))
4747 sm_dprintf("SIOCGLIFNUM failed: %s\n",
4748 sm_errstring(errno));
4749 numifs = -1;
4750 }
4751 else if (tTd(0, 42))
4752 sm_dprintf("system has %d interfaces\n", numifs);
4753 if (numifs < 0)
4754 # endif /* defined(__hpux) || defined(SIOCGLIFNUM) */
4755 numifs = MAXINTERFACES;
4756
4757 if (numifs <= 0)
4758 {
4759 (void) close(s);
4760 return;
4761 }
4762
4763 len = lifc.lifc_len = numifs * sizeof(struct lifreq);
4764 buf = lifc.lifc_buf = xalloc(lifc.lifc_len);
4765 # ifndef __hpux
4766 lifc.lifc_family = AF_UNSPEC;
4767 lifc.lifc_flags = 0;
4768 # endif /* ! __hpux */
4769 if (ioctl(s, SIOCGLIFCONF, (char *)&lifc) < 0)
4770 {
4771 if (tTd(0, 4))
4772 sm_dprintf("SIOCGLIFCONF failed: %s\n",
4773 sm_errstring(errno));
4774 (void) close(s);
4775 sm_free(buf);
4776 return;
4777 }
4778
4779 /* scan the list of IP address */
4780 if (tTd(0, 40))
4781 sm_dprintf("scanning for interface specific names, lifc_len=%ld\n",
4782 (long) len);
4783
4784 for (i = 0; i < len && i >= 0; )
4785 {
4786 int flags;
4787 struct lifreq *ifr = (struct lifreq *)&buf[i];
4788 SOCKADDR *sa = (SOCKADDR *) &ifr->lifr_addr;
4789 int af = ifr->lifr_addr.ss_family;
4790 char *addr;
4791 char *name;
4792 struct in6_addr ia6;
4793 struct in_addr ia;
4794 # ifdef SIOCGLIFFLAGS
4795 struct lifreq ifrf;
4796 # endif /* SIOCGLIFFLAGS */
4797 char ip_addr[256];
4798 char buf6[INET6_ADDRSTRLEN];
4799
4800 /*
4801 ** We must close and recreate the socket each time
4802 ** since we don't know what type of socket it is now
4803 ** (each status function may change it).
4804 */
4805
4806 (void) close(s);
4807
4808 s = socket(af, SOCK_DGRAM, 0);
4809 if (s == -1)
4810 {
4811 sm_free(buf); /* XXX */
4812 return;
4813 }
4814
4815 /*
4816 ** If we don't have a complete ifr structure,
4817 ** don't try to use it.
4818 */
4819
4820 if ((len - i) < sizeof(*ifr))
4821 break;
4822
4823 # ifdef BSD4_4_SOCKADDR
4824 if (sa->sa.sa_len > sizeof(ifr->lifr_addr))
4825 i += sizeof(ifr->lifr_name) + sa->sa.sa_len;
4826 else
4827 # endif /* BSD4_4_SOCKADDR */
4828 # ifdef DEC
4829 /* fix for IPv6 size differences */
4830 i += sizeof(ifr->ifr_name) +
4831 max(sizeof(ifr->ifr_addr), ifr->ifr_addr.sa_len);
4832 # else /* DEC */
4833 i += sizeof(*ifr);
4834 # endif /* DEC */
4835
4836 if (tTd(0, 20))
4837 sm_dprintf("%s\n", anynet_ntoa(sa));
4838
4839 if (af != AF_INET && af != AF_INET6)
4840 continue;
4841
4842 # ifdef SIOCGLIFFLAGS
4843 memset(&ifrf, '\0', sizeof(struct lifreq));
4844 (void) sm_strlcpy(ifrf.lifr_name, ifr->lifr_name,
4845 sizeof(ifrf.lifr_name));
4846 if (ioctl(s, SIOCGLIFFLAGS, (char *) &ifrf) < 0)
4847 {
4848 if (tTd(0, 4))
4849 sm_dprintf("SIOCGLIFFLAGS failed: %s\n",
4850 sm_errstring(errno));
4851 continue;
4852 }
4853
4854 name = ifr->lifr_name;
4855 flags = ifrf.lifr_flags;
4856
4857 if (tTd(0, 41))
4858 sm_dprintf("\tflags: %lx\n", (unsigned long) flags);
4859
4860 if (!bitset(IFF_UP, flags))
4861 continue;
4862 # endif /* SIOCGLIFFLAGS */
4863
4864 ip_addr[0] = '\0';
4865
4866 /* extract IP address from the list*/
4867 switch (af)
4868 {
4869 case AF_INET6:
4870 SETV6LOOPBACKADDRFOUND(*sa);
4871 # ifdef __KAME__
4872 /* convert into proper scoped address */
4873 if ((IN6_IS_ADDR_LINKLOCAL(&sa->sin6.sin6_addr) ||
4874 IN6_IS_ADDR_SITELOCAL(&sa->sin6.sin6_addr)) &&
4875 sa->sin6.sin6_scope_id == 0)
4876 {
4877 struct in6_addr *ia6p;
4878
4879 ia6p = &sa->sin6.sin6_addr;
4880 sa->sin6.sin6_scope_id = ntohs(ia6p->s6_addr[3] |
4881 ((unsigned int)ia6p->s6_addr[2] << 8));
4882 ia6p->s6_addr[2] = ia6p->s6_addr[3] = 0;
4883 }
4884 # endif /* __KAME__ */
4885 ia6 = sa->sin6.sin6_addr;
4886 if (IN6_IS_ADDR_UNSPECIFIED(&ia6))
4887 {
4888 addr = anynet_ntop(&ia6, buf6, sizeof(buf6));
4889 message("WARNING: interface %s is UP with %s address",
4890 name, addr == NULL ? "(NULL)" : addr);
4891 continue;
4892 }
4893
4894 /* save IP address in text from */
4895 addr = anynet_ntop(&ia6, buf6, sizeof(buf6));
4896 if (addr != NULL)
4897 (void) sm_snprintf(ip_addr, sizeof(ip_addr),
4898 "[%.*s]",
4899 (int) sizeof(ip_addr) - 3,
4900 addr);
4901 break;
4902
4903 case AF_INET:
4904 ia = sa->sin.sin_addr;
4905 if (ia.s_addr == INADDR_ANY ||
4906 ia.s_addr == INADDR_NONE)
4907 {
4908 message("WARNING: interface %s is UP with %s address",
4909 name, inet_ntoa(ia));
4910 continue;
4911 }
4912
4913 /* save IP address in text from */
4914 (void) sm_snprintf(ip_addr, sizeof(ip_addr), "[%.*s]",
4915 (int) sizeof(ip_addr) - 3, inet_ntoa(ia));
4916 break;
4917 }
4918
4919 if (*ip_addr == '\0')
4920 continue;
4921
4922 if (!wordinclass(ip_addr, 'w'))
4923 {
4924 setclass('w', ip_addr);
4925 if (tTd(0, 4))
4926 sm_dprintf("\ta.k.a.: %s\n", ip_addr);
4927 }
4928
4929 # ifdef SIOCGLIFFLAGS
4930 /* skip "loopback" interface "lo" */
4931 if (DontProbeInterfaces == DPI_SKIPLOOPBACK &&
4932 bitset(IFF_LOOPBACK, flags))
4933 continue;
4934 # endif /* SIOCGLIFFLAGS */
4935 (void) add_hostnames(sa);
4936 }
4937 sm_free(buf); /* XXX */
4938 (void) close(s);
4939 # else /* NETINET6 && defined(SIOCGLIFCONF) */
4940 # if defined(SIOCGIFCONF) && !SIOCGIFCONF_IS_BROKEN
4941 int s;
4942 int i;
4943 struct ifconf ifc;
4944 int numifs;
4945
4946 s = socket(AF_INET, SOCK_DGRAM, 0);
4947 if (s == -1)
4948 return;
4949
4950 /* get the list of known IP address from the kernel */
4951 # if defined(SIOCGIFNUM) && !SIOCGIFNUM_IS_BROKEN
4952 if (ioctl(s, SIOCGIFNUM, (char *) &numifs) < 0)
4953 {
4954 /* can't get number of interfaces -- fall back */
4955 if (tTd(0, 4))
4956 sm_dprintf("SIOCGIFNUM failed: %s\n",
4957 sm_errstring(errno));
4958 numifs = -1;
4959 }
4960 else if (tTd(0, 42))
4961 sm_dprintf("system has %d interfaces\n", numifs);
4962 if (numifs < 0)
4963 # endif /* defined(SIOCGIFNUM) && !SIOCGIFNUM_IS_BROKEN */
4964 numifs = MAXINTERFACES;
4965
4966 if (numifs <= 0)
4967 {
4968 (void) close(s);
4969 return;
4970 }
4971 ifc.ifc_len = numifs * sizeof(struct ifreq);
4972 ifc.ifc_buf = xalloc(ifc.ifc_len);
4973 if (ioctl(s, SIOCGIFCONF, (char *)&ifc) < 0)
4974 {
4975 if (tTd(0, 4))
4976 sm_dprintf("SIOCGIFCONF failed: %s\n",
4977 sm_errstring(errno));
4978 (void) close(s);
4979 return;
4980 }
4981
4982 /* scan the list of IP address */
4983 if (tTd(0, 40))
4984 sm_dprintf("scanning for interface specific names, ifc_len=%d\n",
4985 ifc.ifc_len);
4986
4987 for (i = 0; i < ifc.ifc_len && i >= 0; )
4988 {
4989 int af;
4990 struct ifreq *ifr = (struct ifreq *) &ifc.ifc_buf[i];
4991 SOCKADDR *sa = (SOCKADDR *) &ifr->ifr_addr;
4992 # if NETINET6
4993 char *addr;
4994 struct in6_addr ia6;
4995 # endif /* NETINET6 */
4996 struct in_addr ia;
4997 # ifdef SIOCGIFFLAGS
4998 struct ifreq ifrf;
4999 # endif /* SIOCGIFFLAGS */
5000 char ip_addr[256];
5001 # if NETINET6
5002 char buf6[INET6_ADDRSTRLEN];
5003 # endif /* NETINET6 */
5004
5005 /*
5006 ** If we don't have a complete ifr structure,
5007 ** don't try to use it.
5008 */
5009
5010 if ((ifc.ifc_len - i) < sizeof(*ifr))
5011 break;
5012
5013 # ifdef BSD4_4_SOCKADDR
5014 if (sa->sa.sa_len > sizeof(ifr->ifr_addr))
5015 i += sizeof(ifr->ifr_name) + sa->sa.sa_len;
5016 else
5017 # endif /* BSD4_4_SOCKADDR */
5018 i += sizeof(*ifr);
5019
5020 if (tTd(0, 20))
5021 sm_dprintf("%s\n", anynet_ntoa(sa));
5022
5023 af = ifr->ifr_addr.sa_family;
5024 if (af != AF_INET
5025 # if NETINET6
5026 && af != AF_INET6
5027 # endif /* NETINET6 */
5028 )
5029 continue;
5030
5031 # ifdef SIOCGIFFLAGS
5032 memset(&ifrf, '\0', sizeof(struct ifreq));
5033 (void) sm_strlcpy(ifrf.ifr_name, ifr->ifr_name,
5034 sizeof(ifrf.ifr_name));
5035 (void) ioctl(s, SIOCGIFFLAGS, (char *) &ifrf);
5036 if (tTd(0, 41))
5037 sm_dprintf("\tflags: %lx\n",
5038 (unsigned long) ifrf.ifr_flags);
5039 # define IFRFREF ifrf
5040 # else /* SIOCGIFFLAGS */
5041 # define IFRFREF (*ifr)
5042 # endif /* SIOCGIFFLAGS */
5043
5044 if (!bitset(IFF_UP, IFRFREF.ifr_flags))
5045 continue;
5046
5047 ip_addr[0] = '\0';
5048
5049 /* extract IP address from the list*/
5050 switch (af)
5051 {
5052 case AF_INET:
5053 ia = sa->sin.sin_addr;
5054 if (ia.s_addr == INADDR_ANY ||
5055 ia.s_addr == INADDR_NONE)
5056 {
5057 message("WARNING: interface %s is UP with %s address",
5058 ifr->ifr_name, inet_ntoa(ia));
5059 continue;
5060 }
5061
5062 /* save IP address in text from */
5063 (void) sm_snprintf(ip_addr, sizeof(ip_addr), "[%.*s]",
5064 (int) sizeof(ip_addr) - 3,
5065 inet_ntoa(ia));
5066 break;
5067
5068 # if NETINET6
5069 case AF_INET6:
5070 SETV6LOOPBACKADDRFOUND(*sa);
5071 # ifdef __KAME__
5072 /* convert into proper scoped address */
5073 if ((IN6_IS_ADDR_LINKLOCAL(&sa->sin6.sin6_addr) ||
5074 IN6_IS_ADDR_SITELOCAL(&sa->sin6.sin6_addr)) &&
5075 sa->sin6.sin6_scope_id == 0)
5076 {
5077 struct in6_addr *ia6p;
5078
5079 ia6p = &sa->sin6.sin6_addr;
5080 sa->sin6.sin6_scope_id = ntohs(ia6p->s6_addr[3] |
5081 ((unsigned int)ia6p->s6_addr[2] << 8));
5082 ia6p->s6_addr[2] = ia6p->s6_addr[3] = 0;
5083 }
5084 # endif /* __KAME__ */
5085 ia6 = sa->sin6.sin6_addr;
5086 if (IN6_IS_ADDR_UNSPECIFIED(&ia6))
5087 {
5088 addr = anynet_ntop(&ia6, buf6, sizeof(buf6));
5089 message("WARNING: interface %s is UP with %s address",
5090 ifr->ifr_name,
5091 addr == NULL ? "(NULL)" : addr);
5092 continue;
5093 }
5094
5095 /* save IP address in text from */
5096 addr = anynet_ntop(&ia6, buf6, sizeof(buf6));
5097 if (addr != NULL)
5098 (void) sm_snprintf(ip_addr, sizeof(ip_addr),
5099 "[%.*s]",
5100 (int) sizeof(ip_addr) - 3,
5101 addr);
5102 break;
5103
5104 # endif /* NETINET6 */
5105 }
5106
5107 if (ip_addr[0] == '\0')
5108 continue;
5109
5110 if (!wordinclass(ip_addr, 'w'))
5111 {
5112 setclass('w', ip_addr);
5113 if (tTd(0, 4))
5114 sm_dprintf("\ta.k.a.: %s\n", ip_addr);
5115 }
5116
5117 /* skip "loopback" interface "lo" */
5118 if (DontProbeInterfaces == DPI_SKIPLOOPBACK &&
5119 bitset(IFF_LOOPBACK, IFRFREF.ifr_flags))
5120 continue;
5121
5122 (void) add_hostnames(sa);
5123 }
5124 sm_free(ifc.ifc_buf); /* XXX */
5125 (void) close(s);
5126 # undef IFRFREF
5127 # endif /* defined(SIOCGIFCONF) && !SIOCGIFCONF_IS_BROKEN */
5128 # endif /* NETINET6 && defined(SIOCGLIFCONF) */
5129 }
5130 /*
5131 ** ISLOOPBACK -- is socket address in the loopback net?
5132 **
5133 ** Parameters:
5134 ** sa -- socket address.
5135 **
5136 ** Returns:
5137 ** true -- is socket address in the loopback net?
5138 ** false -- otherwise
5139 **
5140 */
5141
5142 bool
5143 isloopback(sa)
5144 SOCKADDR sa;
5145 {
5146 #if NETINET6
5147 if (IN6_IS_ADDR_LOOPBACK(&sa.sin6.sin6_addr))
5148 return true;
5149 #else /* NETINET6 */
5150 /* XXX how to correctly extract IN_LOOPBACKNET part? */
5151 if (((ntohl(sa.sin.sin_addr.s_addr) & IN_CLASSA_NET)
5152 >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET)
5153 return true;
5154 #endif /* NETINET6 */
5155 return false;
5156 }
5157 /*
5158 ** GET_NUM_PROCS_ONLINE -- return the number of processors currently online
5159 **
5160 ** Parameters:
5161 ** none.
5162 **
5163 ** Returns:
5164 ** The number of processors online.
5165 */
5166
5167 static int
5168 get_num_procs_online()
5169 {
5170 int nproc = 0;
5171
5172 #ifdef USESYSCTL
5173 # if defined(CTL_HW) && defined(HW_NCPU)
5174 size_t sz;
5175 int mib[2];
5176
5177 mib[0] = CTL_HW;
5178 mib[1] = HW_NCPU;
5179 sz = (size_t) sizeof(nproc);
5180 (void) sysctl(mib, 2, &nproc, &sz, NULL, 0);
5181 # endif /* defined(CTL_HW) && defined(HW_NCPU) */
5182 #else /* USESYSCTL */
5183 # ifdef _SC_NPROCESSORS_ONLN
5184 nproc = (int) sysconf(_SC_NPROCESSORS_ONLN);
5185 # else /* _SC_NPROCESSORS_ONLN */
5186 # ifdef __hpux
5187 # include <sys/pstat.h>
5188 struct pst_dynamic psd;
5189
5190 if (pstat_getdynamic(&psd, sizeof(psd), (size_t)1, 0) != -1)
5191 nproc = psd.psd_proc_cnt;
5192 # endif /* __hpux */
5193 # endif /* _SC_NPROCESSORS_ONLN */
5194 #endif /* USESYSCTL */
5195
5196 if (nproc <= 0)
5197 nproc = 1;
5198 return nproc;
5199 }
5200 /*
5201 ** SM_CLOSEFROM -- close file descriptors
5202 **
5203 ** Parameters:
5204 ** lowest -- first fd to close
5205 ** highest -- last fd + 1 to close
5206 **
5207 ** Returns:
5208 ** none
5209 */
5210
5211 void
5212 sm_closefrom(lowest, highest)
5213 int lowest, highest;
5214 {
5215 #if HASCLOSEFROM
5216 closefrom(lowest);
5217 #else /* HASCLOSEFROM */
5218 int i;
5219
5220 for (i = lowest; i < highest; i++)
5221 (void) close(i);
5222 #endif /* HASCLOSEFROM */
5223 }
5224 #if HASFDWALK
5225 /*
5226 ** CLOSEFD_WALK -- walk fd's arranging to close them
5227 ** Callback for fdwalk()
5228 **
5229 ** Parameters:
5230 ** lowest -- first fd to arrange to be closed
5231 ** fd -- fd to arrange to be closed
5232 **
5233 ** Returns:
5234 ** zero
5235 */
5236
5237 static int
5238 closefd_walk(lowest, fd)
5239 void *lowest;
5240 int fd;
5241 {
5242 if (fd >= *(int *)lowest)
5243 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
5244 return 0;
5245 }
5246 #endif /* HASFDWALK */
5247 /*
5248 ** SM_CLOSE_ON_EXEC -- arrange for file descriptors to be closed
5249 **
5250 ** Parameters:
5251 ** lowest -- first fd to arrange to be closed
5252 ** highest -- last fd + 1 to arrange to be closed
5253 **
5254 ** Returns:
5255 ** none
5256 */
5257
5258 void
5259 sm_close_on_exec(highest, lowest)
5260 int highest, lowest;
5261 {
5262 #if HASFDWALK
5263 (void) fdwalk(closefd_walk, &lowest);
5264 #else /* HASFDWALK */
5265 int i, j;
5266
5267 for (i = lowest; i < highest; i++)
5268 {
5269 if ((j = fcntl(i, F_GETFD, 0)) != -1)
5270 (void) fcntl(i, F_SETFD, j | FD_CLOEXEC);
5271 }
5272 #endif /* HASFDWALK */
5273 }
5274 /*
5275 ** SEED_RANDOM -- seed the random number generator
5276 **
5277 ** Parameters:
5278 ** none
5279 **
5280 ** Returns:
5281 ** none
5282 */
5283
5284 void
5285 seed_random()
5286 {
5287 #if HASSRANDOMDEV
5288 srandomdev();
5289 #else /* HASSRANDOMDEV */
5290 long seed;
5291 struct timeval t;
5292
5293 seed = (long) CurrentPid;
5294 if (gettimeofday(&t, NULL) >= 0)
5295 seed += t.tv_sec + t.tv_usec;
5296
5297 # if HASRANDOM
5298 (void) srandom(seed);
5299 # else /* HASRANDOM */
5300 (void) srand((unsigned int) seed);
5301 # endif /* HASRANDOM */
5302 #endif /* HASSRANDOMDEV */
5303 }
5304 /*
5305 ** SM_SYSLOG -- syslog wrapper to keep messages under SYSLOG_BUFSIZE
5306 **
5307 ** Parameters:
5308 ** level -- syslog level
5309 ** id -- envelope ID or NULL (NOQUEUE)
5310 ** fmt -- format string
5311 ** arg... -- arguments as implied by fmt.
5312 **
5313 ** Returns:
5314 ** none
5315 */
5316
5317 /* VARARGS3 */
5318 void
5319 #ifdef __STDC__
5320 sm_syslog(int level, const char *id, const char *fmt, ...)
5321 #else /* __STDC__ */
5322 sm_syslog(level, id, fmt, va_alist)
5323 int level;
5324 const char *id;
5325 const char *fmt;
5326 va_dcl
5327 #endif /* __STDC__ */
5328 {
5329 char *buf;
5330 size_t bufsize;
5331 char *begin, *end;
5332 int save_errno;
5333 int seq = 1;
5334 int idlen;
5335 char buf0[MAXLINE];
5336 char *newstring;
5337 extern int SyslogPrefixLen;
5338 SM_VA_LOCAL_DECL
5339
5340 save_errno = errno;
5341 if (id == NULL)
5342 id = "NOQUEUE";
5343 idlen = strlen(id) + SyslogPrefixLen;
5344
5345 buf = buf0;
5346 bufsize = sizeof(buf0);
5347
5348 for (;;)
5349 {
5350 int n;
5351
5352 /* print log message into buf */
5353 SM_VA_START(ap, fmt);
5354 n = sm_vsnprintf(buf, bufsize, fmt, ap);
5355 SM_VA_END(ap);
5356 SM_ASSERT(n > 0);
5357 if (n < bufsize)
5358 break;
5359
5360 /* String too small, redo with correct size */
5361 bufsize = n + 1;
5362 if (buf != buf0)
5363 {
5364 sm_free(buf);
5365 buf = NULL;
5366 }
5367 buf = sm_malloc_x(bufsize);
5368 }
5369
5370 /* clean up buf after it has been expanded with args */
5371 newstring = str2prt(buf);
5372 if ((strlen(newstring) + idlen + 1) < SYSLOG_BUFSIZE)
5373 {
5374 #if LOG
5375 if (*id == '\0')
5376 {
5377 if (tTd(89, 8))
5378 sm_dprintf("%s\n", newstring);
5379 else
5380 syslog(level, "%s", newstring);
5381 }
5382 else
5383 {
5384 if (tTd(89, 8))
5385 sm_dprintf("%s: %s\n", id, newstring);
5386 else
5387 syslog(level, "%s: %s", id, newstring);
5388 }
5389 #else /* LOG */
5390 /*XXX should do something more sensible */
5391 if (*id == '\0')
5392 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT, "%s\n",
5393 newstring);
5394 else
5395 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT,
5396 "%s: %s\n", id, newstring);
5397 #endif /* LOG */
5398 if (buf != buf0)
5399 sm_free(buf);
5400 errno = save_errno;
5401 return;
5402 }
5403
5404 /*
5405 ** additional length for splitting: " ..." + 3, where 3 is magic to
5406 ** have some data for the next entry.
5407 */
5408
5409 #define SL_SPLIT 7
5410
5411 begin = newstring;
5412 idlen += 5; /* strlen("[999]"), see below */
5413 while (*begin != '\0' &&
5414 (strlen(begin) + idlen) > SYSLOG_BUFSIZE)
5415 {
5416 char save;
5417
5418 if (seq >= 999)
5419 {
5420 /* Too many messages */
5421 break;
5422 }
5423 end = begin + SYSLOG_BUFSIZE - idlen - SL_SPLIT;
5424 while (end > begin)
5425 {
5426 /* Break on comma or space */
5427 if (*end == ',' || *end == ' ')
5428 {
5429 end++; /* Include separator */
5430 break;
5431 }
5432 end--;
5433 }
5434 /* No separator, break midstring... */
5435 if (end == begin)
5436 end = begin + SYSLOG_BUFSIZE - idlen - SL_SPLIT;
5437 save = *end;
5438 *end = 0;
5439 #if LOG
5440 if (tTd(89, 8))
5441 sm_dprintf("%s[%d]: %s ...\n", id, seq++, begin);
5442 else
5443 syslog(level, "%s[%d]: %s ...", id, seq++, begin);
5444 #else /* LOG */
5445 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT,
5446 "%s[%d]: %s ...\n", id, seq++, begin);
5447 #endif /* LOG */
5448 *end = save;
5449 begin = end;
5450 }
5451 if (seq >= 999)
5452 {
5453 #if LOG
5454 if (tTd(89, 8))
5455 sm_dprintf("%s[%d]: log terminated, too many parts\n",
5456 id, seq);
5457 else
5458 syslog(level, "%s[%d]: log terminated, too many parts",
5459 id, seq);
5460 #else /* LOG */
5461 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT,
5462 "%s[%d]: log terminated, too many parts\n", id, seq);
5463 #endif /* LOG */
5464 }
5465 else if (*begin != '\0')
5466 {
5467 #if LOG
5468 if (tTd(89, 8))
5469 sm_dprintf("%s[%d]: %s\n", id, seq, begin);
5470 else
5471 syslog(level, "%s[%d]: %s", id, seq, begin);
5472 #else /* LOG */
5473 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT,
5474 "%s[%d]: %s\n", id, seq, begin);
5475 #endif /* LOG */
5476 }
5477 if (buf != buf0)
5478 sm_free(buf);
5479 errno = save_errno;
5480 }
5481 /*
5482 ** HARD_SYSLOG -- call syslog repeatedly until it works
5483 **
5484 ** Needed on HP-UX, which apparently doesn't guarantee that
5485 ** syslog succeeds during interrupt handlers.
5486 */
5487
5488 #if defined(__hpux) && !defined(HPUX11)
5489
5490 # define MAXSYSLOGTRIES 100
5491 # undef syslog
5492 # ifdef V4FS
5493 # define XCNST const
5494 # define CAST (const char *)
5495 # else /* V4FS */
5496 # define XCNST
5497 # define CAST
5498 # endif /* V4FS */
5499
5500 void
5501 # ifdef __STDC__
5502 hard_syslog(int pri, XCNST char *msg, ...)
5503 # else /* __STDC__ */
5504 hard_syslog(pri, msg, va_alist)
5505 int pri;
5506 XCNST char *msg;
5507 va_dcl
5508 # endif /* __STDC__ */
5509 {
5510 int i;
5511 char buf[SYSLOG_BUFSIZE];
5512 SM_VA_LOCAL_DECL
5513
5514 SM_VA_START(ap, msg);
5515 (void) sm_vsnprintf(buf, sizeof(buf), msg, ap);
5516 SM_VA_END(ap);
5517
5518 for (i = MAXSYSLOGTRIES; --i >= 0 && syslog(pri, CAST "%s", buf) < 0; )
5519 continue;
5520 }
5521
5522 # undef CAST
5523 #endif /* defined(__hpux) && !defined(HPUX11) */
5524 #if NEEDLOCAL_HOSTNAME_LENGTH
5525 /*
5526 ** LOCAL_HOSTNAME_LENGTH
5527 **
5528 ** This is required to get sendmail to compile against BIND 4.9.x
5529 ** on Ultrix.
5530 **
5531 ** Unfortunately, a Compaq Y2K patch kit provides it without
5532 ** bumping __RES in /usr/include/resolv.h so we can't automatically
5533 ** figure out whether it is needed.
5534 */
5535
5536 int
5537 local_hostname_length(hostname)
5538 char *hostname;
5539 {
5540 size_t len_host, len_domain;
5541
5542 if (!*_res.defdname)
5543 res_init();
5544 len_host = strlen(hostname);
5545 len_domain = strlen(_res.defdname);
5546 if (len_host > len_domain &&
5547 (sm_strcasecmp(hostname + len_host - len_domain,
5548 _res.defdname) == 0) &&
5549 hostname[len_host - len_domain - 1] == '.')
5550 return len_host - len_domain - 1;
5551 else
5552 return 0;
5553 }
5554 #endif /* NEEDLOCAL_HOSTNAME_LENGTH */
5555
5556 #if NEEDLINK
5557 /*
5558 ** LINK -- clone a file
5559 **
5560 ** Some OS's lacks link() and hard links. Since sendmail is using
5561 ** link() as an efficient way to clone files, this implementation
5562 ** will simply do a file copy.
5563 **
5564 ** NOTE: This link() replacement is not a generic replacement as it
5565 ** does not handle all of the semantics of the real link(2).
5566 **
5567 ** Parameters:
5568 ** source -- pathname of existing file.
5569 ** target -- pathname of link (clone) to be created.
5570 **
5571 ** Returns:
5572 ** 0 -- success.
5573 ** -1 -- failure, see errno for details.
5574 */
5575
5576 int
5577 link(source, target)
5578 const char *source;
5579 const char *target;
5580 {
5581 int save_errno;
5582 int sff;
5583 int src = -1, dst = -1;
5584 ssize_t readlen;
5585 ssize_t writelen;
5586 char buf[BUFSIZ];
5587 struct stat st;
5588
5589 sff = SFF_REGONLY|SFF_OPENASROOT;
5590 if (DontLockReadFiles)
5591 sff |= SFF_NOLOCK;
5592
5593 /* Open the original file */
5594 src = safeopen((char *)source, O_RDONLY, 0, sff);
5595 if (src < 0)
5596 goto fail;
5597
5598 /* Obtain the size and the mode */
5599 if (fstat(src, &st) < 0)
5600 goto fail;
5601
5602 /* Create the duplicate copy */
5603 sff &= ~SFF_NOLOCK;
5604 sff |= SFF_CREAT;
5605 dst = safeopen((char *)target, O_CREAT|O_EXCL|O_WRONLY,
5606 st.st_mode, sff);
5607 if (dst < 0)
5608 goto fail;
5609
5610 /* Copy all of the bytes one buffer at a time */
5611 while ((readlen = read(src, &buf, sizeof(buf))) > 0)
5612 {
5613 ssize_t left = readlen;
5614 char *p = buf;
5615
5616 while (left > 0 &&
5617 (writelen = write(dst, p, (size_t) left)) >= 0)
5618 {
5619 left -= writelen;
5620 p += writelen;
5621 }
5622 if (writelen < 0)
5623 break;
5624 }
5625
5626 /* Any trouble reading? */
5627 if (readlen < 0 || writelen < 0)
5628 goto fail;
5629
5630 /* Close the input file */
5631 if (close(src) < 0)
5632 {
5633 src = -1;
5634 goto fail;
5635 }
5636 src = -1;
5637
5638 /* Close the output file */
5639 if (close(dst) < 0)
5640 {
5641 /* don't set dst = -1 here so we unlink the file */
5642 goto fail;
5643 }
5644
5645 /* Success */
5646 return 0;
5647
5648 fail:
5649 save_errno = errno;
5650 if (src >= 0)
5651 (void) close(src);
5652 if (dst >= 0)
5653 {
5654 (void) unlink(target);
5655 (void) close(dst);
5656 }
5657 errno = save_errno;
5658 return -1;
5659 }
5660 #endif /* NEEDLINK */
5661
5662 /*
5663 ** Compile-Time options
5664 */
5665
5666 char *CompileOptions[] =
5667 {
5668 #if ALLOW_255
5669 "ALLOW_255",
5670 #endif /* ALLOW_255 */
5671 #if NAMED_BIND
5672 # if DNSMAP
5673 "DNSMAP",
5674 # endif /* DNSMAP */
5675 #endif /* NAMED_BIND */
5676 #if EGD
5677 "EGD",
5678 #endif /* EGD */
5679 #if HESIOD
5680 "HESIOD",
5681 #endif /* HESIOD */
5682 #if HES_GETMAILHOST
5683 "HES_GETMAILHOST",
5684 #endif /* HES_GETMAILHOST */
5685 #if LDAPMAP
5686 "LDAPMAP",
5687 #endif /* LDAPMAP */
5688 #if LDAP_REFERRALS
5689 "LDAP_REFERRALS",
5690 #endif /* LDAP_REFERRALS */
5691 #if LOG
5692 "LOG",
5693 #endif /* LOG */
5694 #if MAP_NSD
5695 "MAP_NSD",
5696 #endif /* MAP_NSD */
5697 #if MAP_REGEX
5698 "MAP_REGEX",
5699 #endif /* MAP_REGEX */
5700 #if MATCHGECOS
5701 "MATCHGECOS",
5702 #endif /* MATCHGECOS */
5703 #if MILTER
5704 "MILTER",
5705 #endif /* MILTER */
5706 #if MIME7TO8
5707 "MIME7TO8",
5708 #endif /* MIME7TO8 */
5709 #if MIME7TO8_OLD
5710 "MIME7TO8_OLD",
5711 #endif /* MIME7TO8_OLD */
5712 #if MIME8TO7
5713 "MIME8TO7",
5714 #endif /* MIME8TO7 */
5715 #if NAMED_BIND
5716 "NAMED_BIND",
5717 #endif /* NAMED_BIND */
5718 #if NDBM
5719 "NDBM",
5720 #endif /* NDBM */
5721 #if NETINET
5722 "NETINET",
5723 #endif /* NETINET */
5724 #if NETINET6
5725 "NETINET6",
5726 #endif /* NETINET6 */
5727 #if NETINFO
5728 "NETINFO",
5729 #endif /* NETINFO */
5730 #if NETISO
5731 "NETISO",
5732 #endif /* NETISO */
5733 #if NETNS
5734 "NETNS",
5735 #endif /* NETNS */
5736 #if NETUNIX
5737 "NETUNIX",
5738 #endif /* NETUNIX */
5739 #if NETX25
5740 "NETX25",
5741 #endif /* NETX25 */
5742 #if NEWDB
5743 "NEWDB",
5744 #endif /* NEWDB */
5745 #if NIS
5746 "NIS",
5747 #endif /* NIS */
5748 #if NISPLUS
5749 "NISPLUS",
5750 #endif /* NISPLUS */
5751 #if NO_DH
5752 "NO_DH",
5753 #endif /* NO_DH */
5754 #if PH_MAP
5755 "PH_MAP",
5756 #endif /* PH_MAP */
5757 #ifdef PICKY_HELO_CHECK
5758 "PICKY_HELO_CHECK",
5759 #endif /* PICKY_HELO_CHECK */
5760 #if PIPELINING
5761 "PIPELINING",
5762 #endif /* PIPELINING */
5763 #if SASL
5764 # if SASL >= 20000
5765 "SASLv2",
5766 # else /* SASL >= 20000 */
5767 "SASL",
5768 # endif /* SASL >= 20000 */
5769 #endif /* SASL */
5770 #if SCANF
5771 "SCANF",
5772 #endif /* SCANF */
5773 #if SM_LDAP_ERROR_ON_MISSING_ARGS
5774 "SM_LDAP_ERROR_ON_MISSING_ARGS",
5775 #endif /* SM_LDAP_ERROR_ON_MISSING_ARGS */
5776 #if SMTPDEBUG
5777 "SMTPDEBUG",
5778 #endif /* SMTPDEBUG */
5779 #if SOCKETMAP
5780 "SOCKETMAP",
5781 #endif /* SOCKETMAP */
5782 #if STARTTLS
5783 "STARTTLS",
5784 #endif /* STARTTLS */
5785 #if SUID_ROOT_FILES_OK
5786 "SUID_ROOT_FILES_OK",
5787 #endif /* SUID_ROOT_FILES_OK */
5788 #if TCPWRAPPERS
5789 "TCPWRAPPERS",
5790 #endif /* TCPWRAPPERS */
5791 #if TLS_NO_RSA
5792 "TLS_NO_RSA",
5793 #endif /* TLS_NO_RSA */
5794 #if TLS_VRFY_PER_CTX
5795 "TLS_VRFY_PER_CTX",
5796 #endif /* TLS_VRFY_PER_CTX */
5797 #if USERDB
5798 "USERDB",
5799 #endif /* USERDB */
5800 #if USE_LDAP_INIT
5801 "USE_LDAP_INIT",
5802 #endif /* USE_LDAP_INIT */
5803 #if USE_TTYPATH
5804 "USE_TTYPATH",
5805 #endif /* USE_TTYPATH */
5806 #if XDEBUG
5807 "XDEBUG",
5808 #endif /* XDEBUG */
5809 #if XLA
5810 "XLA",
5811 #endif /* XLA */
5812 NULL
5813 };
5814
5815
5816 /*
5817 ** OS compile options.
5818 */
5819
5820 char *OsCompileOptions[] =
5821 {
5822 #if ADDRCONFIG_IS_BROKEN
5823 "ADDRCONFIG_IS_BROKEN",
5824 #endif /* ADDRCONFIG_IS_BROKEN */
5825 #ifdef AUTO_NETINFO_HOSTS
5826 "AUTO_NETINFO_HOSTS",
5827 #endif /* AUTO_NETINFO_HOSTS */
5828 #ifdef AUTO_NIS_ALIASES
5829 "AUTO_NIS_ALIASES",
5830 #endif /* AUTO_NIS_ALIASES */
5831 #if BROKEN_RES_SEARCH
5832 "BROKEN_RES_SEARCH",
5833 #endif /* BROKEN_RES_SEARCH */
5834 #ifdef BSD4_4_SOCKADDR
5835 "BSD4_4_SOCKADDR",
5836 #endif /* BSD4_4_SOCKADDR */
5837 #if BOGUS_O_EXCL
5838 "BOGUS_O_EXCL",
5839 #endif /* BOGUS_O_EXCL */
5840 #if DEC_OSF_BROKEN_GETPWENT
5841 "DEC_OSF_BROKEN_GETPWENT",
5842 #endif /* DEC_OSF_BROKEN_GETPWENT */
5843 #if FAST_PID_RECYCLE
5844 "FAST_PID_RECYCLE",
5845 #endif /* FAST_PID_RECYCLE */
5846 #if HASCLOSEFROM
5847 "HASCLOSEFROM",
5848 #endif /* HASCLOSEFROM */
5849 #if HASFCHOWN
5850 "HASFCHOWN",
5851 #endif /* HASFCHOWN */
5852 #if HASFCHMOD
5853 "HASFCHMOD",
5854 #endif /* HASFCHMOD */
5855 #if HASFDWALK
5856 "HASFDWALK",
5857 #endif /* HASFDWALK */
5858 #if HASFLOCK
5859 "HASFLOCK",
5860 #endif /* HASFLOCK */
5861 #if HASGETDTABLESIZE
5862 "HASGETDTABLESIZE",
5863 #endif /* HASGETDTABLESIZE */
5864 #if HASGETUSERSHELL
5865 "HASGETUSERSHELL",
5866 #endif /* HASGETUSERSHELL */
5867 #if HASINITGROUPS
5868 "HASINITGROUPS",
5869 #endif /* HASINITGROUPS */
5870 #if HASLDAPGETALIASBYNAME
5871 "HASLDAPGETALIASBYNAME",
5872 #endif /* HASLDAPGETALIASBYNAME */
5873 #if HASLSTAT
5874 "HASLSTAT",
5875 #endif /* HASLSTAT */
5876 #if HASNICE
5877 "HASNICE",
5878 #endif /* HASNICE */
5879 #if HASRANDOM
5880 "HASRANDOM",
5881 #endif /* HASRANDOM */
5882 #if HASRRESVPORT
5883 "HASRRESVPORT",
5884 #endif /* HASRRESVPORT */
5885 #if HASSETEGID
5886 "HASSETEGID",
5887 #endif /* HASSETEGID */
5888 #if HASSETLOGIN
5889 "HASSETLOGIN",
5890 #endif /* HASSETLOGIN */
5891 #if HASSETREGID
5892 "HASSETREGID",
5893 #endif /* HASSETREGID */
5894 #if HASSETRESGID
5895 "HASSETRESGID",
5896 #endif /* HASSETRESGID */
5897 #if HASSETREUID
5898 "HASSETREUID",
5899 #endif /* HASSETREUID */
5900 #if HASSETRLIMIT
5901 "HASSETRLIMIT",
5902 #endif /* HASSETRLIMIT */
5903 #if HASSETSID
5904 "HASSETSID",
5905 #endif /* HASSETSID */
5906 #if HASSETUSERCONTEXT
5907 "HASSETUSERCONTEXT",
5908 #endif /* HASSETUSERCONTEXT */
5909 #if HASSETVBUF
5910 "HASSETVBUF",
5911 #endif /* HASSETVBUF */
5912 #if HAS_ST_GEN
5913 "HAS_ST_GEN",
5914 #endif /* HAS_ST_GEN */
5915 #if HASSRANDOMDEV
5916 "HASSRANDOMDEV",
5917 #endif /* HASSRANDOMDEV */
5918 #if HASURANDOMDEV
5919 "HASURANDOMDEV",
5920 #endif /* HASURANDOMDEV */
5921 #if HASSTRERROR
5922 "HASSTRERROR",
5923 #endif /* HASSTRERROR */
5924 #if HASULIMIT
5925 "HASULIMIT",
5926 #endif /* HASULIMIT */
5927 #if HASUNAME
5928 "HASUNAME",
5929 #endif /* HASUNAME */
5930 #if HASUNSETENV
5931 "HASUNSETENV",
5932 #endif /* HASUNSETENV */
5933 #if HASWAITPID
5934 "HASWAITPID",
5935 #endif /* HASWAITPID */
5936 #if HAVE_NANOSLEEP
5937 "HAVE_NANOSLEEP",
5938 #endif /* HAVE_NANOSLEEP */
5939 #if IDENTPROTO
5940 "IDENTPROTO",
5941 #endif /* IDENTPROTO */
5942 #if IP_SRCROUTE
5943 "IP_SRCROUTE",
5944 #endif /* IP_SRCROUTE */
5945 #if O_EXLOCK && HASFLOCK && !BOGUS_O_EXCL
5946 "LOCK_ON_OPEN",
5947 #endif /* O_EXLOCK && HASFLOCK && !BOGUS_O_EXCL */
5948 #if MILTER_NO_NAGLE
5949 "MILTER_NO_NAGLE ",
5950 #endif /* MILTER_NO_NAGLE */
5951 #if NEEDFSYNC
5952 "NEEDFSYNC",
5953 #endif /* NEEDFSYNC */
5954 #if NEEDLINK
5955 "NEEDLINK",
5956 #endif /* NEEDLINK */
5957 #if NEEDLOCAL_HOSTNAME_LENGTH
5958 "NEEDLOCAL_HOSTNAME_LENGTH",
5959 #endif /* NEEDLOCAL_HOSTNAME_LENGTH */
5960 #if NEEDSGETIPNODE
5961 "NEEDSGETIPNODE",
5962 #endif /* NEEDSGETIPNODE */
5963 #if NEEDSTRSTR
5964 "NEEDSTRSTR",
5965 #endif /* NEEDSTRSTR */
5966 #if NEEDSTRTOL
5967 "NEEDSTRTOL",
5968 #endif /* NEEDSTRTOL */
5969 #ifdef NO_GETSERVBYNAME
5970 "NO_GETSERVBYNAME",
5971 #endif /* NO_GETSERVBYNAME */
5972 #if NOFTRUNCATE
5973 "NOFTRUNCATE",
5974 #endif /* NOFTRUNCATE */
5975 #if REQUIRES_DIR_FSYNC
5976 "REQUIRES_DIR_FSYNC",
5977 #endif /* REQUIRES_DIR_FSYNC */
5978 #if RLIMIT_NEEDS_SYS_TIME_H
5979 "RLIMIT_NEEDS_SYS_TIME_H",
5980 #endif /* RLIMIT_NEEDS_SYS_TIME_H */
5981 #if SAFENFSPATHCONF
5982 "SAFENFSPATHCONF",
5983 #endif /* SAFENFSPATHCONF */
5984 #if SECUREWARE
5985 "SECUREWARE",
5986 #endif /* SECUREWARE */
5987 #if SHARE_V1
5988 "SHARE_V1",
5989 #endif /* SHARE_V1 */
5990 #if SIOCGIFCONF_IS_BROKEN
5991 "SIOCGIFCONF_IS_BROKEN",
5992 #endif /* SIOCGIFCONF_IS_BROKEN */
5993 #if SIOCGIFNUM_IS_BROKEN
5994 "SIOCGIFNUM_IS_BROKEN",
5995 #endif /* SIOCGIFNUM_IS_BROKEN */
5996 #if SNPRINTF_IS_BROKEN
5997 "SNPRINTF_IS_BROKEN",
5998 #endif /* SNPRINTF_IS_BROKEN */
5999 #if SO_REUSEADDR_IS_BROKEN
6000 "SO_REUSEADDR_IS_BROKEN",
6001 #endif /* SO_REUSEADDR_IS_BROKEN */
6002 #if SYS5SETPGRP
6003 "SYS5SETPGRP",
6004 #endif /* SYS5SETPGRP */
6005 #if SYSTEM5
6006 "SYSTEM5",
6007 #endif /* SYSTEM5 */
6008 #if USE_DOUBLE_FORK
6009 "USE_DOUBLE_FORK",
6010 #endif /* USE_DOUBLE_FORK */
6011 #if USE_ENVIRON
6012 "USE_ENVIRON",
6013 #endif /* USE_ENVIRON */
6014 #if USE_SA_SIGACTION
6015 "USE_SA_SIGACTION",
6016 #endif /* USE_SA_SIGACTION */
6017 #if USE_SIGLONGJMP
6018 "USE_SIGLONGJMP",
6019 #endif /* USE_SIGLONGJMP */
6020 #if USEGETCONFATTR
6021 "USEGETCONFATTR",
6022 #endif /* USEGETCONFATTR */
6023 #if USESETEUID
6024 "USESETEUID",
6025 #endif /* USESETEUID */
6026 #ifdef USESYSCTL
6027 "USESYSCTL",
6028 #endif /* USESYSCTL */
6029 #if USE_OPENSSL_ENGINE
6030 "USE_OPENSSL_ENGINE",
6031 #endif /* USE_OPENSSL_ENGINE */
6032 #if USING_NETSCAPE_LDAP
6033 "USING_NETSCAPE_LDAP",
6034 #endif /* USING_NETSCAPE_LDAP */
6035 #ifdef WAITUNION
6036 "WAITUNION",
6037 #endif /* WAITUNION */
6038 NULL
6039 };
6040
6041 /*
6042 ** FFR compile options.
6043 */
6044
6045 char *FFRCompileOptions[] =
6046 {
6047 #if _FFR_ADDR_TYPE_MODES
6048 /* more info in {addr_type}, requires m4 changes! */
6049 "_FFR_ADDR_TYPE_MODES",
6050 #endif /* _FFR_ADDR_TYPE_MODES */
6051 #if _FFR_ALLOW_SASLINFO
6052 /* DefaultAuthInfo can be specified by user. */
6053 /* DefaultAuthInfo doesn't really work in 8.13 anymore. */
6054 "_FFR_ALLOW_SASLINFO",
6055 #endif /* _FFR_ALLOW_SASLINFO */
6056 #if _FFR_BADRCPT_SHUTDOWN
6057 /* shut down connection (421) if there are too many bad RCPTs */
6058 "_FFR_BADRCPT_SHUTDOWN",
6059 #endif /* _FFR_BADRCPT_SHUTDOWN */
6060 #if _FFR_BESTMX_BETTER_TRUNCATION
6061 /* Better truncation of list of MX records for dns map. */
6062 "_FFR_BESTMX_BETTER_TRUNCATION",
6063 #endif /* _FFR_BESTMX_BETTER_TRUNCATION */
6064 #if _FFR_CATCH_BROKEN_MTAS
6065 /* Deal with MTAs that send a reply during the DATA phase. */
6066 "_FFR_CATCH_BROKEN_MTAS",
6067 #endif /* _FFR_CATCH_BROKEN_MTAS */
6068 #if _FFR_CHECKCONFIG
6069 /* New OpMode to check the configuration file */
6070 "_FFR_CHECKCONFIG",
6071 #endif /* _FFR_CHECKCONFIG */
6072 #if _FFR_CHK_QUEUE
6073 /* Stricter checks about queue directory permissions. */
6074 "_FFR_CHK_QUEUE",
6075 #endif /* _FFR_CHK_QUEUE */
6076 #if _FFR_CLIENT_SIZE
6077 /* Don't try to send mail if its size exceeds SIZE= of server. */
6078 "_FFR_CLIENT_SIZE",
6079 #endif /* _FFR_CLIENT_SIZE */
6080 #if _FFR_CRLPATH
6081 /* CRLPath; needs documentation; Al Smith */
6082 "_FFR_CRLPATH",
6083 #endif /* _FFR_CRLPATH */
6084 #if _FFR_DAEMON_NETUNIX
6085 /* Allow local (not just TCP) socket connection to server. */
6086 "_FFR_DAEMON_NETUNIX",
6087 #endif /* _FFR_DAEMON_NETUNIX */
6088 #if _FFR_DEPRECATE_MAILER_FLAG_I
6089 /* What it says :-) */
6090 "_FFR_DEPRECATE_MAILER_FLAG_I",
6091 #endif /* _FFR_DEPRECATE_MAILER_FLAG_I */
6092 #if _FFR_DM_ONE
6093 /* deliver first TA in background, then queue */
6094 "_FFR_DM_ONE",
6095 #endif /* _FFR_DM_ONE */
6096 #if _FFR_DIGUNIX_SAFECHOWN
6097 /* Properly set SAFECHOWN (include/sm/conf.h) for Digital UNIX */
6098 /* Problem noted by Anne Bennett of Concordia University */
6099 "_FFR_DIGUNIX_SAFECHOWN",
6100 #endif /* _FFR_DIGUNIX_SAFECHOWN */
6101 #if _FFR_DNSMAP_ALIASABLE
6102 /* Allow dns map type to be used for aliases. */
6103 /* Don Lewis of TDK */
6104 "_FFR_DNSMAP_ALIASABLE",
6105 #endif /* _FFR_DNSMAP_ALIASABLE */
6106 #if _FFR_DONTLOCKFILESFORREAD_OPTION
6107 /* Enable DontLockFilesForRead option. */
6108 "_FFR_DONTLOCKFILESFORREAD_OPTION",
6109 #endif /* _FFR_DONTLOCKFILESFORREAD_OPTION */
6110 #if _FFR_DOTTED_USERNAMES
6111 /* Allow usernames with '.' */
6112 "_FFR_DOTTED_USERNAMES",
6113 #endif /* _FFR_DOTTED_USERNAMES */
6114 #if _FFR_DPO_CS
6115 /*
6116 ** Make DaemonPortOptions case sensitive.
6117 ** For some unknown reasons the code converted every option
6118 ** to uppercase (first letter only, as that's the only one that
6119 ** is actually checked). This prevented all new lower case options
6120 ** from working...
6121 ** The documentation doesn't say anything about case (in)sensitivity,
6122 ** which means it should be case sensitive by default,
6123 ** but it's not a good idea to change this within a patch release,
6124 ** so let's delay this to 8.15.
6125 */
6126
6127 "_FFR_DPO_CS",
6128 #endif /* _FFR_DPO_CS */
6129 #if _FFR_DPRINTF_MAP
6130 /* dprintf map for logging */
6131 "_FFR_DPRINTF_MAP",
6132 #endif /* _FFR_DPRINTF_MAP */
6133 #if _FFR_DROP_TRUSTUSER_WARNING
6134 /*
6135 ** Don't issue this warning:
6136 ** "readcf: option TrustedUser may cause problems on systems
6137 ** which do not support fchown() if UseMSP is not set.
6138 */
6139
6140 "_FFR_DROP_TRUSTUSER_WARNING",
6141 #endif /* _FFR_DROP_TRUSTUSER_WARNING */
6142 #if _FFR_EIGHT_BIT_ADDR_OK
6143 /* EightBitAddrOK: allow 8-bit e-mail addresses */
6144 "_FFR_EIGHT_BIT_ADDR_OK",
6145 #endif /* _FFR_EIGHT_BIT_ADDR_OK */
6146 #if _FFR_EXPDELAY
6147 /* exponential queue delay */
6148 "_FFR_EXPDELAY",
6149 #endif /* _FFR_EXPDELAY */
6150 #if _FFR_EXTRA_MAP_CHECK
6151 /* perform extra checks on $( $) in R lines */
6152 "_FFR_EXTRA_MAP_CHECK",
6153 #endif /* _FFR_EXTRA_MAP_CHECK */
6154 #if _FFR_GETHBN_ExFILE
6155 /*
6156 ** According to Motonori Nakamura some gethostbyname()
6157 ** implementations (TurboLinux?) may (temporarily) fail
6158 ** due to a lack of file discriptors. Enabling this FFR
6159 ** will check errno for EMFILE and ENFILE and in case of a match
6160 ** cause a temporary error instead of a permanent error.
6161 ** The right solution is of course to file a bug against those
6162 ** systems such that they actually set h_errno = TRY_AGAIN.
6163 */
6164
6165 "_FFR_GETHBN_ExFILE",
6166 #endif /* _FFR_GETHBN_ExFILE */
6167 #if _FFR_FIX_DASHT
6168 /*
6169 ** If using -t, force not sending to argv recipients, even
6170 ** if they are mentioned in the headers.
6171 */
6172
6173 "_FFR_FIX_DASHT",
6174 #endif /* _FFR_FIX_DASHT */
6175 #if _FFR_FORWARD_SYSERR
6176 /* Cause a "syserr" if forward file isn't "safe". */
6177 "_FFR_FORWARD_SYSERR",
6178 #endif /* _FFR_FORWARD_SYSERR */
6179 #if _FFR_GEN_ORCPT
6180 /* Generate a ORCPT DSN arg if not already provided */
6181 "_FFR_GEN_ORCPT",
6182 #endif /* _FFR_GEN_ORCPT */
6183 #if _FFR_GROUPREADABLEAUTHINFOFILE
6184 /* Allow group readable DefaultAuthInfo file. */
6185 "_FFR_GROUPREADABLEAUTHINFOFILE",
6186 #endif /* _FFR_GROUPREADABLEAUTHINFOFILE */
6187 #if _FFR_HANDLE_ISO8859_GECOS
6188 /*
6189 ** Allow ISO 8859 characters in GECOS field: replace them
6190 ** ith ASCII "equivalent".
6191 */
6192
6193 /* Peter Eriksson of Linkopings universitet */
6194 "_FFR_HANDLE_ISO8859_GECOS",
6195 #endif /* _FFR_HANDLE_ISO8859_GECOS */
6196 #if _FFR_HPUX_NSSWITCH
6197 /* Use nsswitch on HP-UX */
6198 "_FFR_HPUX_NSSWITCH",
6199 #endif /* _FFR_HPUX_NSSWITCH */
6200 #if _FFR_IGNORE_BOGUS_ADDR
6201 /* Ignore addresses for which prescan() failed */
6202 "_FFR_IGNORE_BOGUS_ADDR",
6203 #endif /* _FFR_IGNORE_BOGUS_ADDR */
6204 #if _FFR_IGNORE_EXT_ON_HELO
6205 /* Ignore extensions offered in response to HELO */
6206 "_FFR_IGNORE_EXT_ON_HELO",
6207 #endif /* _FFR_IGNORE_EXT_ON_HELO */
6208 #if _FFR_LINUX_MHNL
6209 /* Set MAXHOSTNAMELEN to 256 (Linux) */
6210 "_FFR_LINUX_MHNL",
6211 #endif /* _FFR_LINUX_MHNL */
6212 #if _FFR_LOCAL_DAEMON
6213 /* Local daemon mode (-bl) which only accepts loopback connections */
6214 "_FFR_LOCAL_DAEMON",
6215 #endif /* _FFR_LOCAL_DAEMON */
6216 #if _FFR_MAIL_MACRO
6217 "_FFR_MAIL_MACRO",
6218 #endif /* _FFR_MAIL_MACRO */
6219 #if _FFR_MAXDATASIZE
6220 /*
6221 ** It is possible that a header is larger than MILTER_CHUNK_SIZE,
6222 ** hence this shouldn't be used as limit for milter communication.
6223 ** see also libmilter/comm.c
6224 ** Gurusamy Sarathy of ActiveState
6225 */
6226
6227 "_FFR_MAXDATASIZE",
6228 #endif /* _FFR_MAXDATASIZE */
6229 #if _FFR_MAX_FORWARD_ENTRIES
6230 /* Try to limit number of .forward entries */
6231 /* (doesn't work) */
6232 /* Randall S. Winchester of the University of Maryland */
6233 "_FFR_MAX_FORWARD_ENTRIES",
6234 #endif /* _FFR_MAX_FORWARD_ENTRIES */
6235 #if _FFR_MAX_SLEEP_TIME
6236 /* Limit sleep(2) time in libsm/clock.c */
6237 "_FFR_MAX_SLEEP_TIME",
6238 #endif /* _FFR_MAX_SLEEP_TIME */
6239 #if _FFR_MDS_NEGOTIATE
6240 /* MaxDataSize negotation with libmilter */
6241 "_FFR_MDS_NEGOTIATE",
6242 #endif /* _FFR_MDS_NEGOTIATE */
6243 #if _FFR_MEMSTAT
6244 /* Check free memory */
6245 "_FFR_MEMSTAT",
6246 #endif /* _FFR_MEMSTAT */
6247 #if _FFR_MILTER_CHECK
6248 "_FFR_MILTER_CHECK",
6249 #endif /* _FFR_MILTER_CHECK */
6250 #if _FFR_MILTER_CONVERT_ALL_LF_TO_CRLF
6251 /*
6252 ** milter_body() uses the same conversion algorithm as putbody()
6253 ** to translate the "local" df format (\n) to SMTP format (\r\n).
6254 ** However, putbody() and mime8to7() use different conversion
6255 ** algorithms.
6256 ** If the input date does not follow the SMTP standard
6257 ** (e.g., if it has "naked \r"s), then the output from putbody()
6258 ** and mime8to7() will most likely be different.
6259 ** By turning on this FFR milter_body() will try to "imitate"
6260 ** mime8to7().
6261 ** Note: there is no (simple) way to deal with both conversions
6262 ** in a consistent manner. Moreover, as the "GiGo" principle applies,
6263 ** it's not really worth to fix it.
6264 */
6265
6266 "_FFR_MILTER_CONVERT_ALL_LF_TO_CRLF",
6267 #endif /* _FFR_MILTER_CONVERT_ALL_LF_TO_CRLF */
6268 #if _FFR_MILTER_CHECK_REJECTIONS_TOO
6269 /*
6270 ** Also send RCPTs that are rejected by check_rcpt to a milter
6271 ** (if requested during option negotiation).
6272 */
6273
6274 "_FFR_MILTER_CHECK_REJECTIONS_TOO",
6275 #endif /* _FFR_MILTER_CHECK_REJECTIONS_TOO */
6276 #if _FFR_MILTER_ENHSC
6277 /* extract enhanced status code from milter replies for dsn= logging */
6278 "_FFR_MILTER_ENHSC",
6279 #endif /* _FFR_MILTER_ENHSC */
6280 #if _FFR_MIME7TO8_OLD
6281 /* Old mime7to8 code, the new is broken for at least one example. */
6282 "_FFR_MIME7TO8_OLD",
6283 #endif /* _FFR_MAX_SLEEP_TIME */
6284 #if _FFR_MORE_MACROS
6285 /* allow more long macro names ("unprintable" characters). */
6286 "_FFR_MORE_MACROS",
6287 #endif /* _FFR_MORE_MACROS */
6288 #if _FFR_MSG_ACCEPT
6289 /* allow to override "Message accepted for delivery" */
6290 "_FFR_MSG_ACCEPT",
6291 #endif /* _FFR_MSG_ACCEPT */
6292 #if _FFR_NODELAYDSN_ON_HOLD
6293 /* Do not issue a DELAY DSN for mailers that use the hold flag. */
6294 /* Steven Pitzl */
6295 "_FFR_NODELAYDSN_ON_HOLD",
6296 #endif /* _FFR_NODELAYDSN_ON_HOLD */
6297 #if _FFR_NO_PIPE
6298 /* Disable PIPELINING, delay client if used. */
6299 "_FFR_NO_PIPE",
6300 #endif /* _FFR_NO_PIPE */
6301 #if _FFR_LDAP_NETWORK_TIMEOUT
6302 /* set LDAP_OPT_NETWORK_TIMEOUT if available (-c) */
6303 "_FFR_LDAP_NETWORK_TIMEOUT",
6304 #endif /* _FFR_LDAP_NETWORK_TIMEOUT */
6305 #if _FFR_LOG_NTRIES
6306 /* log ntries=, from Nik Clayton of FreeBSD */
6307 "_FFR_LOG_NTRIES",
6308 #endif /* _FFR_LOG_NTRIES */
6309 #if _FFR_QF_PARANOIA
6310 "_FFR_QF_PARANOIA",
6311 #endif /* _FFR_QF_PARANOIA */
6312 #if _FFR_QUEUEDELAY
6313 /* Exponential queue delay; disabled in 8.13 since it isn't used. */
6314 "_FFR_QUEUEDELAY",
6315 #endif /* _FFR_QUEUEDELAY */
6316 #if _FFR_QUEUE_GROUP_SORTORDER
6317 /* Allow QueueSortOrder per queue group. */
6318 /* XXX: Still need to actually use qgrp->qg_sortorder */
6319 "_FFR_QUEUE_GROUP_SORTORDER",
6320 #endif /* _FFR_QUEUE_GROUP_SORTORDER */
6321 #if _FFR_QUEUE_MACRO
6322 /* Define {queue} macro. */
6323 "_FFR_QUEUE_MACRO",
6324 #endif /* _FFR_QUEUE_MACRO */
6325 #if _FFR_QUEUE_RUN_PARANOIA
6326 /* Additional checks when doing queue runs; interval of checks */
6327 "_FFR_QUEUE_RUN_PARANOIA",
6328 #endif /* _FFR_QUEUE_RUN_PARANOIA */
6329 #if _FFR_QUEUE_SCHED_DBG
6330 /* Debug output for the queue scheduler. */
6331 "_FFR_QUEUE_SCHED_DBG",
6332 #endif /* _FFR_QUEUE_SCHED_DBG */
6333 #if _FFR_RCPTTHROTDELAY
6334 /* configurable delay for BadRcptThrottle */
6335 "_FFR_RCPTTHROTDELAY",
6336 #endif /* _FFR_RCPTTHROTDELAY */
6337 #if _FFR_REDIRECTEMPTY
6338 /*
6339 ** envelope <> can't be sent to mailing lists, only owner-
6340 ** send spam of this type to owner- of the list
6341 ** ---- to stop spam from going to mailing lists.
6342 */
6343
6344 "_FFR_REDIRECTEMPTY",
6345 #endif /* _FFR_REDIRECTEMPTY */
6346 #if _FFR_RESET_MACRO_GLOBALS
6347 /* Allow macro 'j' to be set dynamically via rulesets. */
6348 "_FFR_RESET_MACRO_GLOBALS",
6349 #endif /* _FFR_RESET_MACRO_GLOBALS */
6350 #if _FFR_RHS
6351 /* Random shuffle for queue sorting. */
6352 "_FFR_RHS",
6353 #endif /* _FFR_RHS */
6354 #if _FFR_RUNPQG
6355 /*
6356 ** allow -qGqueue_group -qp to work, i.e.,
6357 ** restrict a persistent queue runner to a queue group.
6358 */
6359
6360 "_FFR_RUNPQG",
6361 #endif /* _FFR_RUNPQG */
6362 #if _FFR_SESSID
6363 /* session id (for logging) */
6364 "_FFR_SESSID",
6365 #endif /* _FFR_SESSID */
6366 #if _FFR_SHM_STATUS
6367 /* Donated code (unused). */
6368 "_FFR_SHM_STATUS",
6369 #endif /* _FFR_SHM_STATUS */
6370 #if _FFR_LDAP_SINGLEDN
6371 /*
6372 ** The LDAP database map code in Sendmail 8.12.10, when
6373 ** given the -1 switch, would match only a single DN,
6374 ** but was able to return multiple attributes for that
6375 ** DN. In Sendmail 8.13 this "bug" was corrected to
6376 ** only return if exactly one attribute matched.
6377 **
6378 ** Unfortunately, our configuration uses the former
6379 ** behaviour. Attached is a relatively simple patch
6380 ** to 8.13.4 which adds a -2 switch (for lack of a
6381 ** better option) which returns the single dn/multiple
6382 ** attributes.
6383 **
6384 ** Jeffrey T. Eaton, Carnegie-Mellon University
6385 */
6386
6387 "_FFR_LDAP_SINGLEDN",
6388 #endif /* _FFR_LDAP_SINGLEDN */
6389 #if _FFR_SKIP_DOMAINS
6390 /* process every N'th domain instead of every N'th message */
6391 "_FFR_SKIP_DOMAINS",
6392 #endif /* _FFR_SKIP_DOMAINS */
6393 #if _FFR_SLEEP_USE_SELECT
6394 /* Use select(2) in libsm/clock.c to emulate sleep(2) */
6395 "_FFR_SLEEP_USE_SELECT ",
6396 #endif /* _FFR_SLEEP_USE_SELECT */
6397 #if _FFR_SPT_ALIGN
6398 /*
6399 ** It looks like the Compaq Tru64 5.1A now aligns argv and envp to 64
6400 ** bit alignment, so unless each piece of argv and envp is a multiple
6401 ** of 8 bytes (including terminating NULL), initsetproctitle() won't
6402 ** use any of the space beyond argv[0]. Be sure to set SPT_ALIGN_SIZE
6403 ** if you use this FFR.
6404 */
6405
6406 /* Chris Adams of HiWAAY Informations Services */
6407 "_FFR_SPT_ALIGN",
6408 #endif /* _FFR_SPT_ALIGN */
6409 #if _FFR_SS_PER_DAEMON
6410 /* SuperSafe per DaemonPortOptions: 'T' (better letter?) */
6411 "_FFR_SS_PER_DAEMON",
6412 #endif /* _FFR_SS_PER_DAEMON */
6413 #if _FFR_TESTS
6414 /* enable some test code */
6415 "_FFR_TESTS",
6416 #endif /* _FFR_TESTS */
6417 #if _FFR_TIMERS
6418 /* Donated code (unused). */
6419 "_FFR_TIMERS",
6420 #endif /* _FFR_TIMERS */
6421 #if _FFR_TLS_1
6422 /* More STARTTLS options, e.g., secondary certs. */
6423 "_FFR_TLS_1",
6424 #endif /* _FFR_TLS_1 */
6425 #if _FFR_TRUSTED_QF
6426 /*
6427 ** If we don't own the file mark it as unsafe.
6428 ** However, allow TrustedUser to own it as well
6429 ** in case TrustedUser manipulates the queue.
6430 */
6431
6432 "_FFR_TRUSTED_QF",
6433 #endif /* _FFR_TRUSTED_QF */
6434 #if _FFR_USE_SEM_LOCKING
6435 "_FFR_USE_SEM_LOCKING",
6436 #endif /* _FFR_USE_SEM_LOCKING */
6437 #if _FFR_USE_SETLOGIN
6438 /* Use setlogin() */
6439 /* Peter Philipp */
6440 "_FFR_USE_SETLOGIN",
6441 #endif /* _FFR_USE_SETLOGIN */
6442 NULL
6443 };
6444
DragonFly BSD