contrib/sendmail-8.14/sendmail/conf.c

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