1 /* 2 * Copyright (c) 1998-2006, 2008, 2009, 2011 Proofpoint, Inc. and its suppliers. 3 * All rights reserved. 4 * Copyright (c) 1983, 1995-1997 Eric P. Allman. All rights reserved. 5 * Copyright (c) 1988, 1993 6 * The Regents of the University of California. All rights reserved. 7 * 8 * By using this file, you agree to the terms and conditions set 9 * forth in the LICENSE file which can be found at the top level of 10 * the sendmail distribution. 11 * 12 */ 13 14 #define _DEFINE 15 #include <sendmail.h> 16 #include <sm/sendmail.h> 17 #include <sm/xtrap.h> 18 #include <sm/signal.h> 19 20 #ifndef lint 21 SM_UNUSED(static char copyright[]) = 22 "@(#) Copyright (c) 1998-2013 Proofpoint, Inc. and its suppliers.\n\ 23 All rights reserved.\n\ 24 Copyright (c) 1983, 1995-1997 Eric P. Allman. All rights reserved.\n\ 25 Copyright (c) 1988, 1993\n\ 26 The Regents of the University of California. All rights reserved.\n"; 27 #endif /* ! lint */ 28 29 SM_RCSID("@(#)$Id: main.c,v 8.988 2013-11-23 02:52:37 gshapiro Exp $") 30 31 32 #if NETINET || NETINET6 33 # include <arpa/inet.h> 34 #endif /* NETINET || NETINET6 */ 35 36 /* for getcfname() */ 37 #include <sendmail/pathnames.h> 38 39 static SM_DEBUG_T 40 DebugNoPRestart = SM_DEBUG_INITIALIZER("no_persistent_restart", 41 "@(#)$Debug: no_persistent_restart - don't restart, log only $"); 42 43 static void dump_class __P((STAB *, int)); 44 static void obsolete __P((char **)); 45 static void testmodeline __P((char *, ENVELOPE *)); 46 static char *getextenv __P((const char *)); 47 static void sm_printoptions __P((char **)); 48 static SIGFUNC_DECL intindebug __P((int)); 49 static SIGFUNC_DECL sighup __P((int)); 50 static SIGFUNC_DECL sigpipe __P((int)); 51 static SIGFUNC_DECL sigterm __P((int)); 52 #ifdef SIGUSR1 53 static SIGFUNC_DECL sigusr1 __P((int)); 54 #endif /* SIGUSR1 */ 55 56 /* 57 ** SENDMAIL -- Post mail to a set of destinations. 58 ** 59 ** This is the basic mail router. All user mail programs should 60 ** call this routine to actually deliver mail. Sendmail in 61 ** turn calls a bunch of mail servers that do the real work of 62 ** delivering the mail. 63 ** 64 ** Sendmail is driven by settings read in from /etc/mail/sendmail.cf 65 ** (read by readcf.c). 66 ** 67 ** Usage: 68 ** /usr/lib/sendmail [flags] addr ... 69 ** 70 ** See the associated documentation for details. 71 ** 72 ** Authors: 73 ** Eric Allman, UCB/INGRES (until 10/81). 74 ** Britton-Lee, Inc., purveyors of fine 75 ** database computers (11/81 - 10/88). 76 ** International Computer Science Institute 77 ** (11/88 - 9/89). 78 ** UCB/Mammoth Project (10/89 - 7/95). 79 ** InReference, Inc. (8/95 - 1/97). 80 ** Sendmail, Inc. (1/98 - 9/13). 81 ** The support of my employers is gratefully acknowledged. 82 ** Few of them (Britton-Lee in particular) have had 83 ** anything to gain from my involvement in this project. 84 ** 85 ** Gregory Neil Shapiro, 86 ** Worcester Polytechnic Institute (until 3/98). 87 ** Sendmail, Inc. (3/98 - 10/13). 88 ** Proofpoint, Inc. (10/13 - present). 89 ** 90 ** Claus Assmann, 91 ** Sendmail, Inc. (12/98 - 10/13). 92 ** Proofpoint, Inc. (10/13 - present). 93 */ 94 95 char *FullName; /* sender's full name */ 96 ENVELOPE BlankEnvelope; /* a "blank" envelope */ 97 static ENVELOPE MainEnvelope; /* the envelope around the basic letter */ 98 ADDRESS NullAddress = /* a null address */ 99 { "", "", NULL, "" }; 100 char *CommandLineArgs; /* command line args for pid file */ 101 bool Warn_Q_option = false; /* warn about Q option use */ 102 static int MissingFds = 0; /* bit map of fds missing on startup */ 103 char *Mbdb = "pw"; /* mailbox database defaults to /etc/passwd */ 104 105 #ifdef NGROUPS_MAX 106 GIDSET_T InitialGidSet[NGROUPS_MAX]; 107 #endif /* NGROUPS_MAX */ 108 109 #define MAXCONFIGLEVEL 10 /* highest config version level known */ 110 111 #if SASL 112 static sasl_callback_t srvcallbacks[] = 113 { 114 { SASL_CB_VERIFYFILE, (sasl_callback_ft)&safesaslfile, NULL }, 115 { SASL_CB_PROXY_POLICY, (sasl_callback_ft)&proxy_policy, NULL }, 116 { SASL_CB_LIST_END, NULL, NULL } 117 }; 118 #endif /* SASL */ 119 120 unsigned int SubmitMode; 121 int SyslogPrefixLen; /* estimated length of syslog prefix */ 122 #define PIDLEN 6 /* pid length for computing SyslogPrefixLen */ 123 #ifndef SL_FUDGE 124 # define SL_FUDGE 10 /* fudge offset for SyslogPrefixLen */ 125 #endif /* ! SL_FUDGE */ 126 #define SLDLL 8 /* est. length of default syslog label */ 127 128 129 /* Some options are dangerous to allow users to use in non-submit mode */ 130 #define CHECK_AGAINST_OPMODE(cmd) \ 131 { \ 132 if (extraprivs && \ 133 OpMode != MD_DELIVER && OpMode != MD_SMTP && \ 134 OpMode != MD_ARPAFTP && OpMode != MD_CHECKCONFIG && \ 135 OpMode != MD_VERIFY && OpMode != MD_TEST) \ 136 { \ 137 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, \ 138 "WARNING: Ignoring submission mode -%c option (not in submission mode)\n", \ 139 (cmd)); \ 140 break; \ 141 } \ 142 if (extraprivs && queuerun) \ 143 { \ 144 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, \ 145 "WARNING: Ignoring submission mode -%c option with -q\n", \ 146 (cmd)); \ 147 break; \ 148 } \ 149 } 150 151 int 152 main(argc, argv, envp) 153 int argc; 154 char **argv; 155 char **envp; 156 { 157 register char *p; 158 char **av; 159 extern char Version[]; 160 char *ep, *from; 161 STAB *st; 162 register int i; 163 int j; 164 int dp; 165 int fill_errno; 166 int qgrp = NOQGRP; /* queue group to process */ 167 bool safecf = true; 168 BITMAP256 *p_flags = NULL; /* daemon flags */ 169 bool warn_C_flag = false; 170 bool auth = true; /* whether to set e_auth_param */ 171 char warn_f_flag = '\0'; 172 bool run_in_foreground = false; /* -bD mode */ 173 bool queuerun = false, debug = false; 174 struct passwd *pw; 175 struct hostent *hp; 176 char *nullserver = NULL; 177 char *authinfo = NULL; 178 char *sysloglabel = NULL; /* label for syslog */ 179 char *conffile = NULL; /* name of .cf file */ 180 char *queuegroup = NULL; /* queue group to process */ 181 char *quarantining = NULL; /* quarantine queue items? */ 182 bool extraprivs; 183 bool forged, negate; 184 bool queuepersistent = false; /* queue runner process runs forever */ 185 bool foregroundqueue = false; /* queue run in foreground */ 186 bool save_val; /* to save some bool var. */ 187 int cftype; /* which cf file to use? */ 188 SM_FILE_T *smdebug; 189 static time_t starttime = 0; /* when was process started */ 190 struct stat traf_st; /* for TrafficLog FIFO check */ 191 char buf[MAXLINE]; 192 char jbuf[MAXHOSTNAMELEN]; /* holds MyHostName */ 193 static char rnamebuf[MAXNAME]; /* holds RealUserName */ 194 char *emptyenviron[1]; 195 #if STARTTLS 196 bool tls_ok; 197 #endif /* STARTTLS */ 198 QUEUE_CHAR *new; 199 ENVELOPE *e; 200 extern int DtableSize; 201 extern int optind; 202 extern int opterr; 203 extern char *optarg; 204 extern char **environ; 205 #if SASL 206 extern void sm_sasl_init __P((void)); 207 #endif /* SASL */ 208 209 #if USE_ENVIRON 210 envp = environ; 211 #endif /* USE_ENVIRON */ 212 213 /* turn off profiling */ 214 SM_PROF(0); 215 216 /* install default exception handler */ 217 sm_exc_newthread(fatal_error); 218 219 /* set the default in/out channel so errors reported to screen */ 220 InChannel = smioin; 221 OutChannel = smioout; 222 223 /* 224 ** Check to see if we reentered. 225 ** This would normally happen if e_putheader or e_putbody 226 ** were NULL when invoked. 227 */ 228 229 if (starttime != 0) 230 { 231 syserr("main: reentered!"); 232 abort(); 233 } 234 starttime = curtime(); 235 236 /* avoid null pointer dereferences */ 237 TermEscape.te_rv_on = TermEscape.te_under_on = TermEscape.te_normal = ""; 238 239 RealUid = getuid(); 240 RealGid = getgid(); 241 242 /* Check if sendmail is running with extra privs */ 243 extraprivs = (RealUid != 0 && 244 (geteuid() != getuid() || getegid() != getgid())); 245 246 CurrentPid = getpid(); 247 248 /* get whatever .cf file is right for the opmode */ 249 cftype = SM_GET_RIGHT_CF; 250 251 /* in 4.4BSD, the table can be huge; impose a reasonable limit */ 252 DtableSize = getdtsize(); 253 if (DtableSize > 256) 254 DtableSize = 256; 255 256 /* 257 ** Be sure we have enough file descriptors. 258 ** But also be sure that 0, 1, & 2 are open. 259 */ 260 261 /* reset errno and fill_errno; the latter is used way down below */ 262 errno = fill_errno = 0; 263 fill_fd(STDIN_FILENO, NULL); 264 if (errno != 0) 265 fill_errno = errno; 266 fill_fd(STDOUT_FILENO, NULL); 267 if (errno != 0) 268 fill_errno = errno; 269 fill_fd(STDERR_FILENO, NULL); 270 if (errno != 0) 271 fill_errno = errno; 272 273 sm_closefrom(STDERR_FILENO + 1, DtableSize); 274 errno = 0; 275 smdebug = NULL; 276 277 #if LOG 278 # ifndef SM_LOG_STR 279 # define SM_LOG_STR "sendmail" 280 # endif /* ! SM_LOG_STR */ 281 # ifdef LOG_MAIL 282 openlog(SM_LOG_STR, LOG_PID, LOG_MAIL); 283 # else /* LOG_MAIL */ 284 openlog(SM_LOG_STR, LOG_PID); 285 # endif /* LOG_MAIL */ 286 #endif /* LOG */ 287 288 /* 289 ** Seed the random number generator. 290 ** Used for queue file names, picking a queue directory, and 291 ** MX randomization. 292 */ 293 294 seed_random(); 295 296 /* do machine-dependent initializations */ 297 init_md(argc, argv); 298 299 300 SyslogPrefixLen = PIDLEN + (MAXQFNAME - 3) + SL_FUDGE + SLDLL; 301 302 /* reset status from syserr() calls for missing file descriptors */ 303 Errors = 0; 304 ExitStat = EX_OK; 305 306 SubmitMode = SUBMIT_UNKNOWN; 307 #if _FFR_LOCAL_DAEMON 308 LocalDaemon = false; 309 # if NETINET6 310 V6LoopbackAddrFound = false; 311 # endif /* NETINET6 */ 312 #endif /* _FFR_LOCAL_DAEMON */ 313 #if XDEBUG 314 checkfd012("after openlog"); 315 #endif /* XDEBUG */ 316 317 tTsetup(tTdvect, sizeof(tTdvect), "0-99.1,*_trace_*.1"); 318 319 #ifdef NGROUPS_MAX 320 /* save initial group set for future checks */ 321 i = getgroups(NGROUPS_MAX, InitialGidSet); 322 if (i <= 0) 323 { 324 InitialGidSet[0] = (GID_T) -1; 325 i = 0; 326 } 327 while (i < NGROUPS_MAX) 328 InitialGidSet[i++] = InitialGidSet[0]; 329 #endif /* NGROUPS_MAX */ 330 331 /* drop group id privileges (RunAsUser not yet set) */ 332 dp = drop_privileges(false); 333 setstat(dp); 334 335 #ifdef SIGUSR1 336 /* Only allow root (or non-set-*-ID binaries) to use SIGUSR1 */ 337 if (!extraprivs) 338 { 339 /* arrange to dump state on user-1 signal */ 340 (void) sm_signal(SIGUSR1, sigusr1); 341 } 342 else 343 { 344 /* ignore user-1 signal */ 345 (void) sm_signal(SIGUSR1, SIG_IGN); 346 } 347 #endif /* SIGUSR1 */ 348 349 /* initialize for setproctitle */ 350 initsetproctitle(argc, argv, envp); 351 352 /* Handle any non-getoptable constructions. */ 353 obsolete(argv); 354 355 /* 356 ** Do a quick prescan of the argument list. 357 */ 358 359 360 /* find initial opMode */ 361 OpMode = MD_DELIVER; 362 av = argv; 363 p = strrchr(*av, '/'); 364 if (p++ == NULL) 365 p = *av; 366 if (strcmp(p, "newaliases") == 0) 367 OpMode = MD_INITALIAS; 368 else if (strcmp(p, "mailq") == 0) 369 OpMode = MD_PRINT; 370 else if (strcmp(p, "smtpd") == 0) 371 OpMode = MD_DAEMON; 372 else if (strcmp(p, "hoststat") == 0) 373 OpMode = MD_HOSTSTAT; 374 else if (strcmp(p, "purgestat") == 0) 375 OpMode = MD_PURGESTAT; 376 377 #if defined(__osf__) || defined(_AIX3) 378 # define OPTIONS "A:B:b:C:cD:d:e:F:f:Gh:IiL:M:mN:nO:o:p:Q:q:R:r:sTtV:vX:x" 379 #endif /* defined(__osf__) || defined(_AIX3) */ 380 #if defined(sony_news) 381 # define OPTIONS "A:B:b:C:cD:d:E:e:F:f:Gh:IiJ:L:M:mN:nO:o:p:Q:q:R:r:sTtV:vX:" 382 #endif /* defined(sony_news) */ 383 #ifndef OPTIONS 384 # define OPTIONS "A:B:b:C:cD:d:e:F:f:Gh:IiL:M:mN:nO:o:p:Q:q:R:r:sTtV:vX:" 385 #endif /* ! OPTIONS */ 386 387 /* Set to 0 to allow -b; need to check optarg before using it! */ 388 opterr = 0; 389 while ((j = getopt(argc, argv, OPTIONS)) != -1) 390 { 391 switch (j) 392 { 393 case 'b': /* operations mode */ 394 j = (optarg == NULL) ? ' ' : *optarg; 395 switch (j) 396 { 397 case MD_DAEMON: 398 case MD_FGDAEMON: 399 case MD_SMTP: 400 case MD_INITALIAS: 401 case MD_DELIVER: 402 case MD_VERIFY: 403 case MD_TEST: 404 case MD_PRINT: 405 case MD_PRINTNQE: 406 case MD_HOSTSTAT: 407 case MD_PURGESTAT: 408 case MD_ARPAFTP: 409 #if _FFR_CHECKCONFIG 410 case MD_CHECKCONFIG: 411 #endif /* _FFR_CHECKCONFIG */ 412 OpMode = j; 413 break; 414 415 #if _FFR_LOCAL_DAEMON 416 case MD_LOCAL: 417 OpMode = MD_DAEMON; 418 LocalDaemon = true; 419 break; 420 #endif /* _FFR_LOCAL_DAEMON */ 421 422 case MD_FREEZE: 423 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 424 "Frozen configurations unsupported\n"); 425 return EX_USAGE; 426 427 default: 428 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 429 "Invalid operation mode %c\n", 430 j); 431 return EX_USAGE; 432 } 433 break; 434 435 case 'D': 436 if (debug) 437 { 438 errno = 0; 439 syserr("-D file must be before -d"); 440 ExitStat = EX_USAGE; 441 break; 442 } 443 dp = drop_privileges(true); 444 setstat(dp); 445 smdebug = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, 446 optarg, SM_IO_APPEND, NULL); 447 if (smdebug == NULL) 448 { 449 syserr("cannot open %s", optarg); 450 ExitStat = EX_CANTCREAT; 451 break; 452 } 453 sm_debug_setfile(smdebug); 454 break; 455 456 case 'd': 457 debug = true; 458 tTflag(optarg); 459 (void) sm_io_setvbuf(sm_debug_file(), SM_TIME_DEFAULT, 460 (char *) NULL, SM_IO_NBF, 461 SM_IO_BUFSIZ); 462 break; 463 464 case 'G': /* relay (gateway) submission */ 465 SubmitMode = SUBMIT_MTA; 466 break; 467 468 case 'L': 469 if (optarg == NULL) 470 { 471 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 472 "option requires an argument -- '%c'", 473 (char) j); 474 return EX_USAGE; 475 } 476 j = SM_MIN(strlen(optarg), 32) + 1; 477 sysloglabel = xalloc(j); 478 (void) sm_strlcpy(sysloglabel, optarg, j); 479 SyslogPrefixLen = PIDLEN + (MAXQFNAME - 3) + 480 SL_FUDGE + j; 481 break; 482 483 case 'Q': 484 case 'q': 485 /* just check if it is there */ 486 queuerun = true; 487 break; 488 } 489 } 490 opterr = 1; 491 492 /* Don't leak queue information via debug flags */ 493 if (extraprivs && queuerun && debug) 494 { 495 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 496 "WARNING: Can not use -d with -q. Disabling debugging.\n"); 497 sm_debug_close(); 498 sm_debug_setfile(NULL); 499 (void) memset(tTdvect, '\0', sizeof(tTdvect)); 500 } 501 502 #if LOG 503 if (sysloglabel != NULL) 504 { 505 /* Sanitize the string */ 506 for (p = sysloglabel; *p != '\0'; p++) 507 { 508 if (!isascii(*p) || !isprint(*p) || *p == '%') 509 *p = '*'; 510 } 511 closelog(); 512 # ifdef LOG_MAIL 513 openlog(sysloglabel, LOG_PID, LOG_MAIL); 514 # else /* LOG_MAIL */ 515 openlog(sysloglabel, LOG_PID); 516 # endif /* LOG_MAIL */ 517 } 518 #endif /* LOG */ 519 520 /* set up the blank envelope */ 521 BlankEnvelope.e_puthdr = putheader; 522 BlankEnvelope.e_putbody = putbody; 523 BlankEnvelope.e_xfp = NULL; 524 STRUCTCOPY(NullAddress, BlankEnvelope.e_from); 525 CurEnv = &BlankEnvelope; 526 STRUCTCOPY(NullAddress, MainEnvelope.e_from); 527 528 /* 529 ** Set default values for variables. 530 ** These cannot be in initialized data space. 531 */ 532 533 setdefaults(&BlankEnvelope); 534 initmacros(&BlankEnvelope); 535 536 /* reset macro */ 537 set_op_mode(OpMode); 538 if (OpMode == MD_DAEMON) 539 DaemonPid = CurrentPid; /* needed for finis() to work */ 540 541 pw = sm_getpwuid(RealUid); 542 if (pw != NULL) 543 (void) sm_strlcpy(rnamebuf, pw->pw_name, sizeof(rnamebuf)); 544 else 545 (void) sm_snprintf(rnamebuf, sizeof(rnamebuf), "Unknown UID %d", 546 (int) RealUid); 547 548 RealUserName = rnamebuf; 549 550 if (tTd(0, 101)) 551 { 552 sm_dprintf("Version %s\n", Version); 553 finis(false, true, EX_OK); 554 /* NOTREACHED */ 555 } 556 557 /* 558 ** if running non-set-user-ID binary as non-root, pretend 559 ** we are the RunAsUid 560 */ 561 562 if (RealUid != 0 && geteuid() == RealUid) 563 { 564 if (tTd(47, 1)) 565 sm_dprintf("Non-set-user-ID binary: RunAsUid = RealUid = %d\n", 566 (int) RealUid); 567 RunAsUid = RealUid; 568 } 569 else if (geteuid() != 0) 570 RunAsUid = geteuid(); 571 572 EffGid = getegid(); 573 if (RealUid != 0 && EffGid == RealGid) 574 RunAsGid = RealGid; 575 576 if (tTd(47, 5)) 577 { 578 sm_dprintf("main: e/ruid = %d/%d e/rgid = %d/%d\n", 579 (int) geteuid(), (int) getuid(), 580 (int) getegid(), (int) getgid()); 581 sm_dprintf("main: RunAsUser = %d:%d\n", 582 (int) RunAsUid, (int) RunAsGid); 583 } 584 585 /* save command line arguments */ 586 j = 0; 587 for (av = argv; *av != NULL; ) 588 j += strlen(*av++) + 1; 589 SaveArgv = (char **) xalloc(sizeof(char *) * (argc + 1)); 590 CommandLineArgs = xalloc(j); 591 p = CommandLineArgs; 592 for (av = argv, i = 0; *av != NULL; ) 593 { 594 int h; 595 596 SaveArgv[i++] = newstr(*av); 597 if (av != argv) 598 *p++ = ' '; 599 (void) sm_strlcpy(p, *av++, j); 600 h = strlen(p); 601 p += h; 602 j -= h + 1; 603 } 604 SaveArgv[i] = NULL; 605 606 if (tTd(0, 1)) 607 { 608 extern char *CompileOptions[]; 609 610 sm_dprintf("Version %s\n Compiled with:", Version); 611 sm_printoptions(CompileOptions); 612 } 613 if (tTd(0, 10)) 614 { 615 extern char *OsCompileOptions[]; 616 617 sm_dprintf(" OS Defines:"); 618 sm_printoptions(OsCompileOptions); 619 #ifdef _PATH_UNIX 620 sm_dprintf("Kernel symbols:\t%s\n", _PATH_UNIX); 621 #endif /* _PATH_UNIX */ 622 623 sm_dprintf(" Conf file:\t%s (default for MSP)\n", 624 getcfname(OpMode, SubmitMode, SM_GET_SUBMIT_CF, 625 conffile)); 626 sm_dprintf(" Conf file:\t%s (default for MTA)\n", 627 getcfname(OpMode, SubmitMode, SM_GET_SENDMAIL_CF, 628 conffile)); 629 sm_dprintf(" Pid file:\t%s (default)\n", PidFile); 630 } 631 632 if (tTd(0, 12)) 633 { 634 extern char *SmCompileOptions[]; 635 636 sm_dprintf(" libsm Defines:"); 637 sm_printoptions(SmCompileOptions); 638 } 639 640 if (tTd(0, 13)) 641 { 642 extern char *FFRCompileOptions[]; 643 644 sm_dprintf(" FFR Defines:"); 645 sm_printoptions(FFRCompileOptions); 646 } 647 648 /* clear sendmail's environment */ 649 ExternalEnviron = environ; 650 emptyenviron[0] = NULL; 651 environ = emptyenviron; 652 653 /* 654 ** restore any original TZ setting until TimeZoneSpec has been 655 ** determined - or early log messages may get bogus time stamps 656 */ 657 658 if ((p = getextenv("TZ")) != NULL) 659 { 660 char *tz; 661 int tzlen; 662 663 /* XXX check for reasonable length? */ 664 tzlen = strlen(p) + 4; 665 tz = xalloc(tzlen); 666 (void) sm_strlcpyn(tz, tzlen, 2, "TZ=", p); 667 668 /* XXX check return code? */ 669 (void) putenv(tz); 670 } 671 672 /* prime the child environment */ 673 sm_setuserenv("AGENT", "sendmail"); 674 675 (void) sm_signal(SIGPIPE, SIG_IGN); 676 OldUmask = umask(022); 677 FullName = getextenv("NAME"); 678 if (FullName != NULL) 679 FullName = newstr(FullName); 680 681 /* 682 ** Initialize name server if it is going to be used. 683 */ 684 685 #if NAMED_BIND 686 if (!bitset(RES_INIT, _res.options)) 687 (void) res_init(); 688 if (tTd(8, 8)) 689 _res.options |= RES_DEBUG; 690 else 691 _res.options &= ~RES_DEBUG; 692 # ifdef RES_NOALIASES 693 _res.options |= RES_NOALIASES; 694 # endif /* RES_NOALIASES */ 695 TimeOuts.res_retry[RES_TO_DEFAULT] = _res.retry; 696 TimeOuts.res_retry[RES_TO_FIRST] = _res.retry; 697 TimeOuts.res_retry[RES_TO_NORMAL] = _res.retry; 698 TimeOuts.res_retrans[RES_TO_DEFAULT] = _res.retrans; 699 TimeOuts.res_retrans[RES_TO_FIRST] = _res.retrans; 700 TimeOuts.res_retrans[RES_TO_NORMAL] = _res.retrans; 701 #endif /* NAMED_BIND */ 702 703 errno = 0; 704 from = NULL; 705 706 /* initialize some macros, etc. */ 707 init_vendor_macros(&BlankEnvelope); 708 709 /* version */ 710 macdefine(&BlankEnvelope.e_macro, A_PERM, 'v', Version); 711 712 /* hostname */ 713 hp = myhostname(jbuf, sizeof(jbuf)); 714 if (jbuf[0] != '\0') 715 { 716 struct utsname utsname; 717 718 if (tTd(0, 4)) 719 sm_dprintf("Canonical name: %s\n", jbuf); 720 macdefine(&BlankEnvelope.e_macro, A_TEMP, 'w', jbuf); 721 macdefine(&BlankEnvelope.e_macro, A_TEMP, 'j', jbuf); 722 setclass('w', jbuf); 723 724 p = strchr(jbuf, '.'); 725 if (p != NULL && p[1] != '\0') 726 macdefine(&BlankEnvelope.e_macro, A_TEMP, 'm', &p[1]); 727 728 if (uname(&utsname) >= 0) 729 p = utsname.nodename; 730 else 731 { 732 if (tTd(0, 22)) 733 sm_dprintf("uname failed (%s)\n", 734 sm_errstring(errno)); 735 makelower(jbuf); 736 p = jbuf; 737 } 738 if (tTd(0, 4)) 739 sm_dprintf(" UUCP nodename: %s\n", p); 740 macdefine(&BlankEnvelope.e_macro, A_TEMP, 'k', p); 741 setclass('k', p); 742 setclass('w', p); 743 } 744 if (hp != NULL) 745 { 746 for (av = hp->h_aliases; av != NULL && *av != NULL; av++) 747 { 748 if (tTd(0, 4)) 749 sm_dprintf("\ta.k.a.: %s\n", *av); 750 setclass('w', *av); 751 } 752 #if NETINET || NETINET6 753 for (i = 0; i >= 0 && hp->h_addr_list[i] != NULL; i++) 754 { 755 # if NETINET6 756 char *addr; 757 char buf6[INET6_ADDRSTRLEN]; 758 struct in6_addr ia6; 759 # endif /* NETINET6 */ 760 # if NETINET 761 struct in_addr ia; 762 # endif /* NETINET */ 763 char ipbuf[103]; 764 765 ipbuf[0] = '\0'; 766 switch (hp->h_addrtype) 767 { 768 # if NETINET 769 case AF_INET: 770 if (hp->h_length != INADDRSZ) 771 break; 772 773 memmove(&ia, hp->h_addr_list[i], INADDRSZ); 774 (void) sm_snprintf(ipbuf, sizeof(ipbuf), 775 "[%.100s]", inet_ntoa(ia)); 776 break; 777 # endif /* NETINET */ 778 779 # if NETINET6 780 case AF_INET6: 781 if (hp->h_length != IN6ADDRSZ) 782 break; 783 784 memmove(&ia6, hp->h_addr_list[i], IN6ADDRSZ); 785 addr = anynet_ntop(&ia6, buf6, sizeof(buf6)); 786 if (addr != NULL) 787 (void) sm_snprintf(ipbuf, sizeof(ipbuf), 788 "[%.100s]", addr); 789 break; 790 # endif /* NETINET6 */ 791 } 792 if (ipbuf[0] == '\0') 793 break; 794 795 if (tTd(0, 4)) 796 sm_dprintf("\ta.k.a.: %s\n", ipbuf); 797 setclass('w', ipbuf); 798 } 799 #endif /* NETINET || NETINET6 */ 800 #if NETINET6 801 freehostent(hp); 802 hp = NULL; 803 #endif /* NETINET6 */ 804 } 805 806 /* current time */ 807 macdefine(&BlankEnvelope.e_macro, A_TEMP, 'b', arpadate((char *) NULL)); 808 809 /* current load average */ 810 sm_getla(); 811 812 QueueLimitRecipient = (QUEUE_CHAR *) NULL; 813 QueueLimitSender = (QUEUE_CHAR *) NULL; 814 QueueLimitId = (QUEUE_CHAR *) NULL; 815 QueueLimitQuarantine = (QUEUE_CHAR *) NULL; 816 817 /* 818 ** Crack argv. 819 */ 820 821 optind = 1; 822 while ((j = getopt(argc, argv, OPTIONS)) != -1) 823 { 824 switch (j) 825 { 826 case 'b': /* operations mode */ 827 /* already done */ 828 break; 829 830 case 'A': /* use Alternate sendmail/submit.cf */ 831 cftype = optarg[0] == 'c' ? SM_GET_SUBMIT_CF 832 : SM_GET_SENDMAIL_CF; 833 break; 834 835 case 'B': /* body type */ 836 CHECK_AGAINST_OPMODE(j); 837 BlankEnvelope.e_bodytype = newstr(optarg); 838 break; 839 840 case 'C': /* select configuration file (already done) */ 841 if (RealUid != 0) 842 warn_C_flag = true; 843 conffile = newstr(optarg); 844 dp = drop_privileges(true); 845 setstat(dp); 846 safecf = false; 847 break; 848 849 case 'D': 850 case 'd': /* debugging */ 851 /* already done */ 852 break; 853 854 case 'f': /* from address */ 855 case 'r': /* obsolete -f flag */ 856 CHECK_AGAINST_OPMODE(j); 857 if (from != NULL) 858 { 859 usrerr("More than one \"from\" person"); 860 ExitStat = EX_USAGE; 861 break; 862 } 863 if (optarg[0] == '\0') 864 from = newstr("<>"); 865 else 866 from = newstr(denlstring(optarg, true, true)); 867 if (strcmp(RealUserName, from) != 0) 868 warn_f_flag = j; 869 break; 870 871 case 'F': /* set full name */ 872 CHECK_AGAINST_OPMODE(j); 873 FullName = newstr(optarg); 874 break; 875 876 case 'G': /* relay (gateway) submission */ 877 /* already set */ 878 CHECK_AGAINST_OPMODE(j); 879 break; 880 881 case 'h': /* hop count */ 882 CHECK_AGAINST_OPMODE(j); 883 BlankEnvelope.e_hopcount = (short) strtol(optarg, &ep, 884 10); 885 (void) sm_snprintf(buf, sizeof(buf), "%d", 886 BlankEnvelope.e_hopcount); 887 macdefine(&BlankEnvelope.e_macro, A_TEMP, 'c', buf); 888 889 if (*ep) 890 { 891 usrerr("Bad hop count (%s)", optarg); 892 ExitStat = EX_USAGE; 893 } 894 break; 895 896 case 'L': /* program label */ 897 /* already set */ 898 break; 899 900 case 'n': /* don't alias */ 901 CHECK_AGAINST_OPMODE(j); 902 NoAlias = true; 903 break; 904 905 case 'N': /* delivery status notifications */ 906 CHECK_AGAINST_OPMODE(j); 907 DefaultNotify |= QHASNOTIFY; 908 macdefine(&BlankEnvelope.e_macro, A_TEMP, 909 macid("{dsn_notify}"), optarg); 910 if (sm_strcasecmp(optarg, "never") == 0) 911 break; 912 for (p = optarg; p != NULL; optarg = p) 913 { 914 p = strchr(p, ','); 915 if (p != NULL) 916 *p++ = '\0'; 917 if (sm_strcasecmp(optarg, "success") == 0) 918 DefaultNotify |= QPINGONSUCCESS; 919 else if (sm_strcasecmp(optarg, "failure") == 0) 920 DefaultNotify |= QPINGONFAILURE; 921 else if (sm_strcasecmp(optarg, "delay") == 0) 922 DefaultNotify |= QPINGONDELAY; 923 else 924 { 925 usrerr("Invalid -N argument"); 926 ExitStat = EX_USAGE; 927 } 928 } 929 break; 930 931 case 'o': /* set option */ 932 setoption(*optarg, optarg + 1, false, true, 933 &BlankEnvelope); 934 break; 935 936 case 'O': /* set option (long form) */ 937 setoption(' ', optarg, false, true, &BlankEnvelope); 938 break; 939 940 case 'p': /* set protocol */ 941 CHECK_AGAINST_OPMODE(j); 942 p = strchr(optarg, ':'); 943 if (p != NULL) 944 { 945 *p++ = '\0'; 946 if (*p != '\0') 947 { 948 i = strlen(p) + 1; 949 ep = sm_malloc_x(i); 950 cleanstrcpy(ep, p, i); 951 macdefine(&BlankEnvelope.e_macro, 952 A_HEAP, 's', ep); 953 } 954 } 955 if (*optarg != '\0') 956 { 957 i = strlen(optarg) + 1; 958 ep = sm_malloc_x(i); 959 cleanstrcpy(ep, optarg, i); 960 macdefine(&BlankEnvelope.e_macro, A_HEAP, 961 'r', ep); 962 } 963 break; 964 965 case 'Q': /* change quarantining on queued items */ 966 /* sanity check */ 967 if (OpMode != MD_DELIVER && 968 OpMode != MD_QUEUERUN) 969 { 970 usrerr("Can not use -Q with -b%c", OpMode); 971 ExitStat = EX_USAGE; 972 break; 973 } 974 975 if (OpMode == MD_DELIVER) 976 set_op_mode(MD_QUEUERUN); 977 978 FullName = NULL; 979 980 quarantining = newstr(optarg); 981 break; 982 983 case 'q': /* run queue files at intervals */ 984 /* sanity check */ 985 if (OpMode != MD_DELIVER && 986 OpMode != MD_DAEMON && 987 OpMode != MD_FGDAEMON && 988 OpMode != MD_PRINT && 989 OpMode != MD_PRINTNQE && 990 OpMode != MD_QUEUERUN) 991 { 992 usrerr("Can not use -q with -b%c", OpMode); 993 ExitStat = EX_USAGE; 994 break; 995 } 996 997 /* don't override -bd, -bD or -bp */ 998 if (OpMode == MD_DELIVER) 999 set_op_mode(MD_QUEUERUN); 1000 1001 FullName = NULL; 1002 negate = optarg[0] == '!'; 1003 if (negate) 1004 { 1005 /* negate meaning of pattern match */ 1006 optarg++; /* skip '!' for next switch */ 1007 } 1008 1009 switch (optarg[0]) 1010 { 1011 case 'G': /* Limit by queue group name */ 1012 if (negate) 1013 { 1014 usrerr("Can not use -q!G"); 1015 ExitStat = EX_USAGE; 1016 break; 1017 } 1018 if (queuegroup != NULL) 1019 { 1020 usrerr("Can not use multiple -qG options"); 1021 ExitStat = EX_USAGE; 1022 break; 1023 } 1024 queuegroup = newstr(&optarg[1]); 1025 break; 1026 1027 case 'I': /* Limit by ID */ 1028 new = (QUEUE_CHAR *) xalloc(sizeof(*new)); 1029 new->queue_match = newstr(&optarg[1]); 1030 new->queue_negate = negate; 1031 new->queue_next = QueueLimitId; 1032 QueueLimitId = new; 1033 break; 1034 1035 case 'R': /* Limit by recipient */ 1036 new = (QUEUE_CHAR *) xalloc(sizeof(*new)); 1037 new->queue_match = newstr(&optarg[1]); 1038 new->queue_negate = negate; 1039 new->queue_next = QueueLimitRecipient; 1040 QueueLimitRecipient = new; 1041 break; 1042 1043 case 'S': /* Limit by sender */ 1044 new = (QUEUE_CHAR *) xalloc(sizeof(*new)); 1045 new->queue_match = newstr(&optarg[1]); 1046 new->queue_negate = negate; 1047 new->queue_next = QueueLimitSender; 1048 QueueLimitSender = new; 1049 break; 1050 1051 case 'f': /* foreground queue run */ 1052 foregroundqueue = true; 1053 break; 1054 1055 case 'Q': /* Limit by quarantine message */ 1056 if (optarg[1] != '\0') 1057 { 1058 new = (QUEUE_CHAR *) xalloc(sizeof(*new)); 1059 new->queue_match = newstr(&optarg[1]); 1060 new->queue_negate = negate; 1061 new->queue_next = QueueLimitQuarantine; 1062 QueueLimitQuarantine = new; 1063 } 1064 QueueMode = QM_QUARANTINE; 1065 break; 1066 1067 case 'L': /* act on lost items */ 1068 QueueMode = QM_LOST; 1069 break; 1070 1071 case 'p': /* Persistent queue */ 1072 queuepersistent = true; 1073 if (QueueIntvl == 0) 1074 QueueIntvl = 1; 1075 if (optarg[1] == '\0') 1076 break; 1077 ++optarg; 1078 /* FALLTHROUGH */ 1079 1080 default: 1081 i = Errors; 1082 QueueIntvl = convtime(optarg, 'm'); 1083 if (QueueIntvl < 0) 1084 { 1085 usrerr("Invalid -q value"); 1086 ExitStat = EX_USAGE; 1087 } 1088 1089 /* check for bad conversion */ 1090 if (i < Errors) 1091 ExitStat = EX_USAGE; 1092 break; 1093 } 1094 break; 1095 1096 case 'R': /* DSN RET: what to return */ 1097 CHECK_AGAINST_OPMODE(j); 1098 if (bitset(EF_RET_PARAM, BlankEnvelope.e_flags)) 1099 { 1100 usrerr("Duplicate -R flag"); 1101 ExitStat = EX_USAGE; 1102 break; 1103 } 1104 BlankEnvelope.e_flags |= EF_RET_PARAM; 1105 if (sm_strcasecmp(optarg, "hdrs") == 0) 1106 BlankEnvelope.e_flags |= EF_NO_BODY_RETN; 1107 else if (sm_strcasecmp(optarg, "full") != 0) 1108 { 1109 usrerr("Invalid -R value"); 1110 ExitStat = EX_USAGE; 1111 } 1112 macdefine(&BlankEnvelope.e_macro, A_TEMP, 1113 macid("{dsn_ret}"), optarg); 1114 break; 1115 1116 case 't': /* read recipients from message */ 1117 CHECK_AGAINST_OPMODE(j); 1118 GrabTo = true; 1119 break; 1120 1121 case 'V': /* DSN ENVID: set "original" envelope id */ 1122 CHECK_AGAINST_OPMODE(j); 1123 if (!xtextok(optarg)) 1124 { 1125 usrerr("Invalid syntax in -V flag"); 1126 ExitStat = EX_USAGE; 1127 } 1128 else 1129 { 1130 BlankEnvelope.e_envid = newstr(optarg); 1131 macdefine(&BlankEnvelope.e_macro, A_TEMP, 1132 macid("{dsn_envid}"), optarg); 1133 } 1134 break; 1135 1136 case 'X': /* traffic log file */ 1137 dp = drop_privileges(true); 1138 setstat(dp); 1139 if (stat(optarg, &traf_st) == 0 && 1140 S_ISFIFO(traf_st.st_mode)) 1141 TrafficLogFile = sm_io_open(SmFtStdio, 1142 SM_TIME_DEFAULT, 1143 optarg, 1144 SM_IO_WRONLY, NULL); 1145 else 1146 TrafficLogFile = sm_io_open(SmFtStdio, 1147 SM_TIME_DEFAULT, 1148 optarg, 1149 SM_IO_APPEND, NULL); 1150 if (TrafficLogFile == NULL) 1151 { 1152 syserr("cannot open %s", optarg); 1153 ExitStat = EX_CANTCREAT; 1154 break; 1155 } 1156 (void) sm_io_setvbuf(TrafficLogFile, SM_TIME_DEFAULT, 1157 NULL, SM_IO_LBF, 0); 1158 break; 1159 1160 /* compatibility flags */ 1161 case 'c': /* connect to non-local mailers */ 1162 case 'i': /* don't let dot stop me */ 1163 case 'm': /* send to me too */ 1164 case 'T': /* set timeout interval */ 1165 case 'v': /* give blow-by-blow description */ 1166 setoption(j, "T", false, true, &BlankEnvelope); 1167 break; 1168 1169 case 'e': /* error message disposition */ 1170 case 'M': /* define macro */ 1171 setoption(j, optarg, false, true, &BlankEnvelope); 1172 break; 1173 1174 case 's': /* save From lines in headers */ 1175 setoption('f', "T", false, true, &BlankEnvelope); 1176 break; 1177 1178 #ifdef DBM 1179 case 'I': /* initialize alias DBM file */ 1180 set_op_mode(MD_INITALIAS); 1181 break; 1182 #endif /* DBM */ 1183 1184 #if defined(__osf__) || defined(_AIX3) 1185 case 'x': /* random flag that OSF/1 & AIX mailx passes */ 1186 break; 1187 #endif /* defined(__osf__) || defined(_AIX3) */ 1188 #if defined(sony_news) 1189 case 'E': 1190 case 'J': /* ignore flags for Japanese code conversion 1191 implemented on Sony NEWS */ 1192 break; 1193 #endif /* defined(sony_news) */ 1194 1195 default: 1196 finis(true, true, EX_USAGE); 1197 /* NOTREACHED */ 1198 break; 1199 } 1200 } 1201 1202 /* if we've had errors so far, exit now */ 1203 if ((ExitStat != EX_OK && OpMode != MD_TEST && OpMode != MD_CHECKCONFIG) || 1204 ExitStat == EX_OSERR) 1205 { 1206 finis(false, true, ExitStat); 1207 /* NOTREACHED */ 1208 } 1209 1210 if (bitset(SUBMIT_MTA, SubmitMode)) 1211 { 1212 /* If set daemon_flags on command line, don't reset it */ 1213 if (macvalue(macid("{daemon_flags}"), &BlankEnvelope) == NULL) 1214 macdefine(&BlankEnvelope.e_macro, A_PERM, 1215 macid("{daemon_flags}"), "CC f"); 1216 } 1217 else if (OpMode == MD_DELIVER || OpMode == MD_SMTP) 1218 { 1219 SubmitMode = SUBMIT_MSA; 1220 1221 /* If set daemon_flags on command line, don't reset it */ 1222 if (macvalue(macid("{daemon_flags}"), &BlankEnvelope) == NULL) 1223 macdefine(&BlankEnvelope.e_macro, A_PERM, 1224 macid("{daemon_flags}"), "c u"); 1225 } 1226 1227 /* 1228 ** Do basic initialization. 1229 ** Read system control file. 1230 ** Extract special fields for local use. 1231 */ 1232 1233 #if XDEBUG 1234 checkfd012("before readcf"); 1235 #endif /* XDEBUG */ 1236 vendor_pre_defaults(&BlankEnvelope); 1237 1238 readcf(getcfname(OpMode, SubmitMode, cftype, conffile), 1239 safecf, &BlankEnvelope); 1240 #if !defined(_USE_SUN_NSSWITCH_) && !defined(_USE_DEC_SVC_CONF_) 1241 ConfigFileRead = true; 1242 #endif /* !defined(_USE_SUN_NSSWITCH_) && !defined(_USE_DEC_SVC_CONF_) */ 1243 vendor_post_defaults(&BlankEnvelope); 1244 1245 /* now we can complain about missing fds */ 1246 if (MissingFds != 0 && LogLevel > 8) 1247 { 1248 char mbuf[MAXLINE]; 1249 1250 mbuf[0] = '\0'; 1251 if (bitset(1 << STDIN_FILENO, MissingFds)) 1252 (void) sm_strlcat(mbuf, ", stdin", sizeof(mbuf)); 1253 if (bitset(1 << STDOUT_FILENO, MissingFds)) 1254 (void) sm_strlcat(mbuf, ", stdout", sizeof(mbuf)); 1255 if (bitset(1 << STDERR_FILENO, MissingFds)) 1256 (void) sm_strlcat(mbuf, ", stderr", sizeof(mbuf)); 1257 1258 /* Notice: fill_errno is from high above: fill_fd() */ 1259 sm_syslog(LOG_WARNING, NOQID, 1260 "File descriptors missing on startup: %s; %s", 1261 &mbuf[2], sm_errstring(fill_errno)); 1262 } 1263 1264 /* Remove the ability for a normal user to send signals */ 1265 if (RealUid != 0 && RealUid != geteuid()) 1266 { 1267 uid_t new_uid = geteuid(); 1268 1269 #if HASSETREUID 1270 /* 1271 ** Since we can differentiate between uid and euid, 1272 ** make the uid a different user so the real user 1273 ** can't send signals. However, it doesn't need to be 1274 ** root (euid has root). 1275 */ 1276 1277 if (new_uid == 0) 1278 new_uid = DefUid; 1279 if (tTd(47, 5)) 1280 sm_dprintf("Changing real uid to %d\n", (int) new_uid); 1281 if (setreuid(new_uid, geteuid()) < 0) 1282 { 1283 syserr("main: setreuid(%d, %d) failed", 1284 (int) new_uid, (int) geteuid()); 1285 finis(false, true, EX_OSERR); 1286 /* NOTREACHED */ 1287 } 1288 if (tTd(47, 10)) 1289 sm_dprintf("Now running as e/ruid %d:%d\n", 1290 (int) geteuid(), (int) getuid()); 1291 #else /* HASSETREUID */ 1292 /* 1293 ** Have to change both effective and real so need to 1294 ** change them both to effective to keep privs. 1295 */ 1296 1297 if (tTd(47, 5)) 1298 sm_dprintf("Changing uid to %d\n", (int) new_uid); 1299 if (setuid(new_uid) < 0) 1300 { 1301 syserr("main: setuid(%d) failed", (int) new_uid); 1302 finis(false, true, EX_OSERR); 1303 /* NOTREACHED */ 1304 } 1305 if (tTd(47, 10)) 1306 sm_dprintf("Now running as e/ruid %d:%d\n", 1307 (int) geteuid(), (int) getuid()); 1308 #endif /* HASSETREUID */ 1309 } 1310 1311 #if NAMED_BIND 1312 if (FallbackMX != NULL) 1313 (void) getfallbackmxrr(FallbackMX); 1314 #endif /* NAMED_BIND */ 1315 1316 if (SuperSafe == SAFE_INTERACTIVE && !SM_IS_INTERACTIVE(CurEnv->e_sendmode)) 1317 { 1318 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 1319 "WARNING: SuperSafe=interactive should only be used with\n DeliveryMode=interactive\n"); 1320 } 1321 1322 if (UseMSP && (OpMode == MD_DAEMON || OpMode == MD_FGDAEMON)) 1323 { 1324 usrerr("Mail submission program cannot be used as daemon"); 1325 finis(false, true, EX_USAGE); 1326 } 1327 1328 if (OpMode == MD_DELIVER || OpMode == MD_SMTP || 1329 OpMode == MD_QUEUERUN || OpMode == MD_ARPAFTP || 1330 OpMode == MD_DAEMON || OpMode == MD_FGDAEMON) 1331 makeworkgroups(); 1332 1333 /* set up the basic signal handlers */ 1334 if (sm_signal(SIGINT, SIG_IGN) != SIG_IGN) 1335 (void) sm_signal(SIGINT, intsig); 1336 (void) sm_signal(SIGTERM, intsig); 1337 1338 /* Enforce use of local time (null string overrides this) */ 1339 if (TimeZoneSpec == NULL) 1340 unsetenv("TZ"); 1341 else if (TimeZoneSpec[0] != '\0') 1342 sm_setuserenv("TZ", TimeZoneSpec); 1343 else 1344 sm_setuserenv("TZ", NULL); 1345 tzset(); 1346 1347 /* initialize mailbox database */ 1348 i = sm_mbdb_initialize(Mbdb); 1349 if (i != EX_OK) 1350 { 1351 usrerr("Can't initialize mailbox database \"%s\": %s", 1352 Mbdb, sm_strexit(i)); 1353 ExitStat = i; 1354 } 1355 1356 /* avoid denial-of-service attacks */ 1357 resetlimits(); 1358 1359 if (OpMode == MD_TEST) 1360 { 1361 /* can't be done after readcf if RunAs* is used */ 1362 dp = drop_privileges(true); 1363 if (dp != EX_OK) 1364 { 1365 finis(false, true, dp); 1366 /* NOTREACHED */ 1367 } 1368 } 1369 else if (OpMode != MD_DAEMON && OpMode != MD_FGDAEMON) 1370 { 1371 /* drop privileges -- daemon mode done after socket/bind */ 1372 dp = drop_privileges(false); 1373 setstat(dp); 1374 if (dp == EX_OK && UseMSP && (geteuid() == 0 || getuid() == 0)) 1375 { 1376 usrerr("Mail submission program must have RunAsUser set to non root user"); 1377 finis(false, true, EX_CONFIG); 1378 /* NOTREACHED */ 1379 } 1380 } 1381 1382 #if NAMED_BIND 1383 _res.retry = TimeOuts.res_retry[RES_TO_DEFAULT]; 1384 _res.retrans = TimeOuts.res_retrans[RES_TO_DEFAULT]; 1385 #endif /* NAMED_BIND */ 1386 1387 /* 1388 ** Find our real host name for future logging. 1389 */ 1390 1391 authinfo = getauthinfo(STDIN_FILENO, &forged); 1392 macdefine(&BlankEnvelope.e_macro, A_TEMP, '_', authinfo); 1393 1394 /* suppress error printing if errors mailed back or whatever */ 1395 if (BlankEnvelope.e_errormode != EM_PRINT) 1396 HoldErrs = true; 1397 1398 /* set up the $=m class now, after .cf has a chance to redefine $m */ 1399 expand("\201m", jbuf, sizeof(jbuf), &BlankEnvelope); 1400 if (jbuf[0] != '\0') 1401 setclass('m', jbuf); 1402 1403 /* probe interfaces and locate any additional names */ 1404 if (DontProbeInterfaces != DPI_PROBENONE) 1405 load_if_names(); 1406 1407 if (tTd(0, 10)) 1408 { 1409 char pidpath[MAXPATHLEN]; 1410 1411 /* Now we know which .cf file we use */ 1412 sm_dprintf(" Conf file:\t%s (selected)\n", 1413 getcfname(OpMode, SubmitMode, cftype, conffile)); 1414 expand(PidFile, pidpath, sizeof(pidpath), &BlankEnvelope); 1415 sm_dprintf(" Pid file:\t%s (selected)\n", pidpath); 1416 } 1417 1418 if (tTd(0, 1)) 1419 { 1420 sm_dprintf("\n============ SYSTEM IDENTITY (after readcf) ============"); 1421 sm_dprintf("\n (short domain name) $w = "); 1422 xputs(sm_debug_file(), macvalue('w', &BlankEnvelope)); 1423 sm_dprintf("\n (canonical domain name) $j = "); 1424 xputs(sm_debug_file(), macvalue('j', &BlankEnvelope)); 1425 sm_dprintf("\n (subdomain name) $m = "); 1426 xputs(sm_debug_file(), macvalue('m', &BlankEnvelope)); 1427 sm_dprintf("\n (node name) $k = "); 1428 xputs(sm_debug_file(), macvalue('k', &BlankEnvelope)); 1429 sm_dprintf("\n========================================================\n\n"); 1430 } 1431 1432 /* 1433 ** Do more command line checking -- these are things that 1434 ** have to modify the results of reading the config file. 1435 */ 1436 1437 /* process authorization warnings from command line */ 1438 if (warn_C_flag) 1439 auth_warning(&BlankEnvelope, "Processed by %s with -C %s", 1440 RealUserName, conffile); 1441 if (Warn_Q_option && !wordinclass(RealUserName, 't')) 1442 auth_warning(&BlankEnvelope, "Processed from queue %s", 1443 QueueDir); 1444 if (sysloglabel != NULL && !wordinclass(RealUserName, 't') && 1445 RealUid != 0 && RealUid != TrustedUid && LogLevel > 1) 1446 sm_syslog(LOG_WARNING, NOQID, "user %d changed syslog label", 1447 (int) RealUid); 1448 1449 /* check body type for legality */ 1450 i = check_bodytype(BlankEnvelope.e_bodytype); 1451 if (i == BODYTYPE_ILLEGAL) 1452 { 1453 usrerr("Illegal body type %s", BlankEnvelope.e_bodytype); 1454 BlankEnvelope.e_bodytype = NULL; 1455 } 1456 else if (i != BODYTYPE_NONE) 1457 SevenBitInput = (i == BODYTYPE_7BIT); 1458 1459 /* tweak default DSN notifications */ 1460 if (DefaultNotify == 0) 1461 DefaultNotify = QPINGONFAILURE|QPINGONDELAY; 1462 1463 /* check for sane configuration level */ 1464 if (ConfigLevel > MAXCONFIGLEVEL) 1465 { 1466 syserr("Warning: .cf version level (%d) exceeds sendmail version %s functionality (%d)", 1467 ConfigLevel, Version, MAXCONFIGLEVEL); 1468 } 1469 1470 /* need MCI cache to have persistence */ 1471 if (HostStatDir != NULL && MaxMciCache == 0) 1472 { 1473 HostStatDir = NULL; 1474 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 1475 "Warning: HostStatusDirectory disabled with ConnectionCacheSize = 0\n"); 1476 } 1477 1478 /* need HostStatusDir in order to have SingleThreadDelivery */ 1479 if (SingleThreadDelivery && HostStatDir == NULL) 1480 { 1481 SingleThreadDelivery = false; 1482 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 1483 "Warning: HostStatusDirectory required for SingleThreadDelivery\n"); 1484 } 1485 1486 #if _FFR_MEMSTAT 1487 j = sm_memstat_open(); 1488 if (j < 0 && (RefuseLowMem > 0 || QueueLowMem > 0) && LogLevel > 4) 1489 { 1490 sm_syslog(LOG_WARNING, NOQID, 1491 "cannot get memory statistics, settings ignored, error=%d" 1492 , j); 1493 } 1494 #endif /* _FFR_MEMSTAT */ 1495 1496 /* check for permissions */ 1497 if (RealUid != 0 && 1498 RealUid != TrustedUid) 1499 { 1500 char *action = NULL; 1501 1502 switch (OpMode) 1503 { 1504 case MD_QUEUERUN: 1505 if (quarantining != NULL) 1506 action = "quarantine jobs"; 1507 else 1508 { 1509 /* Normal users can do a single queue run */ 1510 if (QueueIntvl == 0) 1511 break; 1512 } 1513 1514 /* but not persistent queue runners */ 1515 if (action == NULL) 1516 action = "start a queue runner daemon"; 1517 /* FALLTHROUGH */ 1518 1519 case MD_PURGESTAT: 1520 if (action == NULL) 1521 action = "purge host status"; 1522 /* FALLTHROUGH */ 1523 1524 case MD_DAEMON: 1525 case MD_FGDAEMON: 1526 if (action == NULL) 1527 action = "run daemon"; 1528 1529 if (tTd(65, 1)) 1530 sm_dprintf("Deny user %d attempt to %s\n", 1531 (int) RealUid, action); 1532 1533 if (LogLevel > 1) 1534 sm_syslog(LOG_ALERT, NOQID, 1535 "user %d attempted to %s", 1536 (int) RealUid, action); 1537 HoldErrs = false; 1538 usrerr("Permission denied (real uid not trusted)"); 1539 finis(false, true, EX_USAGE); 1540 /* NOTREACHED */ 1541 break; 1542 1543 case MD_VERIFY: 1544 if (bitset(PRIV_RESTRICTEXPAND, PrivacyFlags)) 1545 { 1546 /* 1547 ** If -bv and RestrictExpand, 1548 ** drop privs to prevent normal 1549 ** users from reading private 1550 ** aliases/forwards/:include:s 1551 */ 1552 1553 if (tTd(65, 1)) 1554 sm_dprintf("Drop privs for user %d attempt to expand (RestrictExpand)\n", 1555 (int) RealUid); 1556 1557 dp = drop_privileges(true); 1558 1559 /* Fake address safety */ 1560 if (tTd(65, 1)) 1561 sm_dprintf("Faking DontBlameSendmail=NonRootSafeAddr\n"); 1562 setbitn(DBS_NONROOTSAFEADDR, DontBlameSendmail); 1563 1564 if (dp != EX_OK) 1565 { 1566 if (tTd(65, 1)) 1567 sm_dprintf("Failed to drop privs for user %d attempt to expand, exiting\n", 1568 (int) RealUid); 1569 CurEnv->e_id = NULL; 1570 finis(true, true, dp); 1571 /* NOTREACHED */ 1572 } 1573 } 1574 break; 1575 1576 case MD_TEST: 1577 case MD_CHECKCONFIG: 1578 case MD_PRINT: 1579 case MD_PRINTNQE: 1580 case MD_FREEZE: 1581 case MD_HOSTSTAT: 1582 /* Nothing special to check */ 1583 break; 1584 1585 case MD_INITALIAS: 1586 if (!wordinclass(RealUserName, 't')) 1587 { 1588 if (tTd(65, 1)) 1589 sm_dprintf("Deny user %d attempt to rebuild the alias map\n", 1590 (int) RealUid); 1591 if (LogLevel > 1) 1592 sm_syslog(LOG_ALERT, NOQID, 1593 "user %d attempted to rebuild the alias map", 1594 (int) RealUid); 1595 HoldErrs = false; 1596 usrerr("Permission denied (real uid not trusted)"); 1597 finis(false, true, EX_USAGE); 1598 /* NOTREACHED */ 1599 } 1600 if (UseMSP) 1601 { 1602 HoldErrs = false; 1603 usrerr("User %d cannot rebuild aliases in mail submission program", 1604 (int) RealUid); 1605 finis(false, true, EX_USAGE); 1606 /* NOTREACHED */ 1607 } 1608 /* FALLTHROUGH */ 1609 1610 default: 1611 if (bitset(PRIV_RESTRICTEXPAND, PrivacyFlags) && 1612 Verbose != 0) 1613 { 1614 /* 1615 ** If -v and RestrictExpand, reset 1616 ** Verbose to prevent normal users 1617 ** from seeing the expansion of 1618 ** aliases/forwards/:include:s 1619 */ 1620 1621 if (tTd(65, 1)) 1622 sm_dprintf("Dropping verbosity for user %d (RestrictExpand)\n", 1623 (int) RealUid); 1624 Verbose = 0; 1625 } 1626 break; 1627 } 1628 } 1629 1630 if (MeToo) 1631 BlankEnvelope.e_flags |= EF_METOO; 1632 1633 switch (OpMode) 1634 { 1635 case MD_TEST: 1636 /* don't have persistent host status in test mode */ 1637 HostStatDir = NULL; 1638 /* FALLTHROUGH */ 1639 1640 case MD_CHECKCONFIG: 1641 if (Verbose == 0) 1642 Verbose = 2; 1643 BlankEnvelope.e_errormode = EM_PRINT; 1644 HoldErrs = false; 1645 break; 1646 1647 case MD_VERIFY: 1648 BlankEnvelope.e_errormode = EM_PRINT; 1649 HoldErrs = false; 1650 /* arrange to exit cleanly on hangup signal */ 1651 if (sm_signal(SIGHUP, SIG_IGN) == (sigfunc_t) SIG_DFL) 1652 (void) sm_signal(SIGHUP, intsig); 1653 if (geteuid() != 0) 1654 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 1655 "Notice: -bv may give misleading output for non-privileged user\n"); 1656 break; 1657 1658 case MD_FGDAEMON: 1659 run_in_foreground = true; 1660 set_op_mode(MD_DAEMON); 1661 /* FALLTHROUGH */ 1662 1663 case MD_DAEMON: 1664 vendor_daemon_setup(&BlankEnvelope); 1665 1666 /* remove things that don't make sense in daemon mode */ 1667 FullName = NULL; 1668 GrabTo = false; 1669 1670 /* arrange to restart on hangup signal */ 1671 if (SaveArgv[0] == NULL || SaveArgv[0][0] != '/') 1672 sm_syslog(LOG_WARNING, NOQID, 1673 "daemon invoked without full pathname; kill -1 won't work"); 1674 break; 1675 1676 case MD_INITALIAS: 1677 Verbose = 2; 1678 BlankEnvelope.e_errormode = EM_PRINT; 1679 HoldErrs = false; 1680 /* FALLTHROUGH */ 1681 1682 default: 1683 /* arrange to exit cleanly on hangup signal */ 1684 if (sm_signal(SIGHUP, SIG_IGN) == (sigfunc_t) SIG_DFL) 1685 (void) sm_signal(SIGHUP, intsig); 1686 break; 1687 } 1688 1689 /* special considerations for FullName */ 1690 if (FullName != NULL) 1691 { 1692 char *full = NULL; 1693 1694 /* full names can't have newlines */ 1695 if (strchr(FullName, '\n') != NULL) 1696 { 1697 full = newstr(denlstring(FullName, true, true)); 1698 FullName = full; 1699 } 1700 1701 /* check for characters that may have to be quoted */ 1702 if (!rfc822_string(FullName)) 1703 { 1704 /* 1705 ** Quote a full name with special characters 1706 ** as a comment so crackaddr() doesn't destroy 1707 ** the name portion of the address. 1708 */ 1709 1710 FullName = addquotes(FullName, NULL); 1711 if (full != NULL) 1712 sm_free(full); /* XXX */ 1713 } 1714 } 1715 1716 /* do heuristic mode adjustment */ 1717 if (Verbose) 1718 { 1719 /* turn off noconnect option */ 1720 setoption('c', "F", true, false, &BlankEnvelope); 1721 1722 /* turn on interactive delivery */ 1723 setoption('d', "", true, false, &BlankEnvelope); 1724 } 1725 1726 #ifdef VENDOR_CODE 1727 /* check for vendor mismatch */ 1728 if (VendorCode != VENDOR_CODE) 1729 { 1730 message("Warning: .cf file vendor code mismatch: sendmail expects vendor %s, .cf file vendor is %s", 1731 getvendor(VENDOR_CODE), getvendor(VendorCode)); 1732 } 1733 #endif /* VENDOR_CODE */ 1734 1735 /* check for out of date configuration level */ 1736 if (ConfigLevel < MAXCONFIGLEVEL) 1737 { 1738 message("Warning: .cf file is out of date: sendmail %s supports version %d, .cf file is version %d", 1739 Version, MAXCONFIGLEVEL, ConfigLevel); 1740 } 1741 1742 if (ConfigLevel < 3) 1743 UseErrorsTo = true; 1744 1745 /* set options that were previous macros */ 1746 if (SmtpGreeting == NULL) 1747 { 1748 if (ConfigLevel < 7 && 1749 (p = macvalue('e', &BlankEnvelope)) != NULL) 1750 SmtpGreeting = newstr(p); 1751 else 1752 SmtpGreeting = "\201j Sendmail \201v ready at \201b"; 1753 } 1754 if (UnixFromLine == NULL) 1755 { 1756 if (ConfigLevel < 7 && 1757 (p = macvalue('l', &BlankEnvelope)) != NULL) 1758 UnixFromLine = newstr(p); 1759 else 1760 UnixFromLine = "From \201g \201d"; 1761 } 1762 SmtpError[0] = '\0'; 1763 1764 /* our name for SMTP codes */ 1765 expand("\201j", jbuf, sizeof(jbuf), &BlankEnvelope); 1766 if (jbuf[0] == '\0') 1767 PSTRSET(MyHostName, "localhost"); 1768 else 1769 PSTRSET(MyHostName, jbuf); 1770 if (strchr(MyHostName, '.') == NULL) 1771 message("WARNING: local host name (%s) is not qualified; see cf/README: WHO AM I?", 1772 MyHostName); 1773 1774 /* make certain that this name is part of the $=w class */ 1775 setclass('w', MyHostName); 1776 1777 /* fill in the structure of the *default* queue */ 1778 st = stab("mqueue", ST_QUEUE, ST_FIND); 1779 if (st == NULL) 1780 syserr("No default queue (mqueue) defined"); 1781 else 1782 set_def_queueval(st->s_quegrp, true); 1783 1784 /* the indices of built-in mailers */ 1785 st = stab("local", ST_MAILER, ST_FIND); 1786 if (st != NULL) 1787 LocalMailer = st->s_mailer; 1788 else if (OpMode != MD_TEST || !warn_C_flag) 1789 syserr("No local mailer defined"); 1790 1791 st = stab("prog", ST_MAILER, ST_FIND); 1792 if (st == NULL) 1793 syserr("No prog mailer defined"); 1794 else 1795 { 1796 ProgMailer = st->s_mailer; 1797 clrbitn(M_MUSER, ProgMailer->m_flags); 1798 } 1799 1800 st = stab("*file*", ST_MAILER, ST_FIND); 1801 if (st == NULL) 1802 syserr("No *file* mailer defined"); 1803 else 1804 { 1805 FileMailer = st->s_mailer; 1806 clrbitn(M_MUSER, FileMailer->m_flags); 1807 } 1808 1809 st = stab("*include*", ST_MAILER, ST_FIND); 1810 if (st == NULL) 1811 syserr("No *include* mailer defined"); 1812 else 1813 InclMailer = st->s_mailer; 1814 1815 if (ConfigLevel < 6) 1816 { 1817 /* heuristic tweaking of local mailer for back compat */ 1818 if (LocalMailer != NULL) 1819 { 1820 setbitn(M_ALIASABLE, LocalMailer->m_flags); 1821 setbitn(M_HASPWENT, LocalMailer->m_flags); 1822 setbitn(M_TRYRULESET5, LocalMailer->m_flags); 1823 setbitn(M_CHECKINCLUDE, LocalMailer->m_flags); 1824 setbitn(M_CHECKPROG, LocalMailer->m_flags); 1825 setbitn(M_CHECKFILE, LocalMailer->m_flags); 1826 setbitn(M_CHECKUDB, LocalMailer->m_flags); 1827 } 1828 if (ProgMailer != NULL) 1829 setbitn(M_RUNASRCPT, ProgMailer->m_flags); 1830 if (FileMailer != NULL) 1831 setbitn(M_RUNASRCPT, FileMailer->m_flags); 1832 } 1833 if (ConfigLevel < 7) 1834 { 1835 if (LocalMailer != NULL) 1836 setbitn(M_VRFY250, LocalMailer->m_flags); 1837 if (ProgMailer != NULL) 1838 setbitn(M_VRFY250, ProgMailer->m_flags); 1839 if (FileMailer != NULL) 1840 setbitn(M_VRFY250, FileMailer->m_flags); 1841 } 1842 1843 /* MIME Content-Types that cannot be transfer encoded */ 1844 setclass('n', "multipart/signed"); 1845 1846 /* MIME message/xxx subtypes that can be treated as messages */ 1847 setclass('s', "rfc822"); 1848 1849 /* MIME Content-Transfer-Encodings that can be encoded */ 1850 setclass('e', "7bit"); 1851 setclass('e', "8bit"); 1852 setclass('e', "binary"); 1853 1854 #ifdef USE_B_CLASS 1855 /* MIME Content-Types that should be treated as binary */ 1856 setclass('b', "image"); 1857 setclass('b', "audio"); 1858 setclass('b', "video"); 1859 setclass('b', "application/octet-stream"); 1860 #endif /* USE_B_CLASS */ 1861 1862 /* MIME headers which have fields to check for overflow */ 1863 setclass(macid("{checkMIMEFieldHeaders}"), "content-disposition"); 1864 setclass(macid("{checkMIMEFieldHeaders}"), "content-type"); 1865 1866 /* MIME headers to check for length overflow */ 1867 setclass(macid("{checkMIMETextHeaders}"), "content-description"); 1868 1869 /* MIME headers to check for overflow and rebalance */ 1870 setclass(macid("{checkMIMEHeaders}"), "content-disposition"); 1871 setclass(macid("{checkMIMEHeaders}"), "content-id"); 1872 setclass(macid("{checkMIMEHeaders}"), "content-transfer-encoding"); 1873 setclass(macid("{checkMIMEHeaders}"), "content-type"); 1874 setclass(macid("{checkMIMEHeaders}"), "mime-version"); 1875 1876 /* Macros to save in the queue file -- don't remove any */ 1877 setclass(macid("{persistentMacros}"), "r"); 1878 setclass(macid("{persistentMacros}"), "s"); 1879 setclass(macid("{persistentMacros}"), "_"); 1880 setclass(macid("{persistentMacros}"), "{if_addr}"); 1881 setclass(macid("{persistentMacros}"), "{daemon_flags}"); 1882 1883 /* operate in queue directory */ 1884 if (QueueDir == NULL || *QueueDir == '\0') 1885 { 1886 if (OpMode != MD_TEST) 1887 { 1888 syserr("QueueDirectory (Q) option must be set"); 1889 ExitStat = EX_CONFIG; 1890 } 1891 } 1892 else 1893 { 1894 if (OpMode != MD_TEST) 1895 setup_queues(OpMode == MD_DAEMON); 1896 } 1897 1898 /* check host status directory for validity */ 1899 if (HostStatDir != NULL && !path_is_dir(HostStatDir, false)) 1900 { 1901 /* cannot use this value */ 1902 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 1903 "Warning: Cannot use HostStatusDirectory = %s: %s\n", 1904 HostStatDir, sm_errstring(errno)); 1905 HostStatDir = NULL; 1906 } 1907 1908 if (OpMode == MD_QUEUERUN && 1909 RealUid != 0 && bitset(PRIV_RESTRICTQRUN, PrivacyFlags)) 1910 { 1911 struct stat stbuf; 1912 1913 /* check to see if we own the queue directory */ 1914 if (stat(".", &stbuf) < 0) 1915 syserr("main: cannot stat %s", QueueDir); 1916 if (stbuf.st_uid != RealUid) 1917 { 1918 /* nope, really a botch */ 1919 HoldErrs = false; 1920 usrerr("You do not have permission to process the queue"); 1921 finis(false, true, EX_NOPERM); 1922 /* NOTREACHED */ 1923 } 1924 } 1925 1926 #if MILTER 1927 /* sanity checks on milter filters */ 1928 if (OpMode == MD_DAEMON || OpMode == MD_SMTP) 1929 { 1930 milter_config(InputFilterList, InputFilters, MAXFILTERS); 1931 setup_daemon_milters(); 1932 } 1933 #endif /* MILTER */ 1934 1935 /* Convert queuegroup string to qgrp number */ 1936 if (queuegroup != NULL) 1937 { 1938 qgrp = name2qid(queuegroup); 1939 if (qgrp == NOQGRP) 1940 { 1941 HoldErrs = false; 1942 usrerr("Queue group %s unknown", queuegroup); 1943 finis(false, true, ExitStat); 1944 /* NOTREACHED */ 1945 } 1946 } 1947 1948 /* if checking config or have had errors so far, exit now */ 1949 if (OpMode == MD_CHECKCONFIG || (ExitStat != EX_OK && OpMode != MD_TEST)) 1950 { 1951 finis(false, true, ExitStat); 1952 /* NOTREACHED */ 1953 } 1954 1955 #if SASL 1956 /* sendmail specific SASL initialization */ 1957 sm_sasl_init(); 1958 #endif /* SASL */ 1959 1960 #if XDEBUG 1961 checkfd012("before main() initmaps"); 1962 #endif /* XDEBUG */ 1963 1964 /* 1965 ** Do operation-mode-dependent initialization. 1966 */ 1967 1968 switch (OpMode) 1969 { 1970 case MD_PRINT: 1971 /* print the queue */ 1972 HoldErrs = false; 1973 (void) dropenvelope(&BlankEnvelope, true, false); 1974 (void) sm_signal(SIGPIPE, sigpipe); 1975 if (qgrp != NOQGRP) 1976 { 1977 int j; 1978 1979 /* Selecting a particular queue group to run */ 1980 for (j = 0; j < Queue[qgrp]->qg_numqueues; j++) 1981 { 1982 if (StopRequest) 1983 stop_sendmail(); 1984 (void) print_single_queue(qgrp, j); 1985 } 1986 finis(false, true, EX_OK); 1987 /* NOTREACHED */ 1988 } 1989 printqueue(); 1990 finis(false, true, EX_OK); 1991 /* NOTREACHED */ 1992 break; 1993 1994 case MD_PRINTNQE: 1995 /* print number of entries in queue */ 1996 (void) dropenvelope(&BlankEnvelope, true, false); 1997 (void) sm_signal(SIGPIPE, sigpipe); 1998 printnqe(smioout, NULL); 1999 finis(false, true, EX_OK); 2000 /* NOTREACHED */ 2001 break; 2002 2003 case MD_QUEUERUN: 2004 /* only handle quarantining here */ 2005 if (quarantining == NULL) 2006 break; 2007 2008 if (QueueMode != QM_QUARANTINE && 2009 QueueMode != QM_NORMAL) 2010 { 2011 HoldErrs = false; 2012 usrerr("Can not use -Q with -q%c", QueueMode); 2013 ExitStat = EX_USAGE; 2014 finis(false, true, ExitStat); 2015 /* NOTREACHED */ 2016 } 2017 quarantine_queue(quarantining, qgrp); 2018 finis(false, true, EX_OK); 2019 break; 2020 2021 case MD_HOSTSTAT: 2022 (void) sm_signal(SIGPIPE, sigpipe); 2023 (void) mci_traverse_persistent(mci_print_persistent, NULL); 2024 finis(false, true, EX_OK); 2025 /* NOTREACHED */ 2026 break; 2027 2028 case MD_PURGESTAT: 2029 (void) mci_traverse_persistent(mci_purge_persistent, NULL); 2030 finis(false, true, EX_OK); 2031 /* NOTREACHED */ 2032 break; 2033 2034 case MD_INITALIAS: 2035 /* initialize maps */ 2036 initmaps(); 2037 finis(false, true, ExitStat); 2038 /* NOTREACHED */ 2039 break; 2040 2041 case MD_SMTP: 2042 case MD_DAEMON: 2043 /* reset DSN parameters */ 2044 DefaultNotify = QPINGONFAILURE|QPINGONDELAY; 2045 macdefine(&BlankEnvelope.e_macro, A_PERM, 2046 macid("{dsn_notify}"), NULL); 2047 BlankEnvelope.e_envid = NULL; 2048 macdefine(&BlankEnvelope.e_macro, A_PERM, 2049 macid("{dsn_envid}"), NULL); 2050 BlankEnvelope.e_flags &= ~(EF_RET_PARAM|EF_NO_BODY_RETN); 2051 macdefine(&BlankEnvelope.e_macro, A_PERM, 2052 macid("{dsn_ret}"), NULL); 2053 2054 /* don't open maps for daemon -- done below in child */ 2055 break; 2056 } 2057 2058 if (tTd(0, 15)) 2059 { 2060 /* print configuration table (or at least part of it) */ 2061 if (tTd(0, 90)) 2062 printrules(); 2063 for (i = 0; i < MAXMAILERS; i++) 2064 { 2065 if (Mailer[i] != NULL) 2066 printmailer(sm_debug_file(), Mailer[i]); 2067 } 2068 } 2069 2070 /* 2071 ** Switch to the main envelope. 2072 */ 2073 2074 CurEnv = newenvelope(&MainEnvelope, &BlankEnvelope, 2075 sm_rpool_new_x(NULL)); 2076 MainEnvelope.e_flags = BlankEnvelope.e_flags; 2077 2078 /* 2079 ** If test mode, read addresses from stdin and process. 2080 */ 2081 2082 if (OpMode == MD_TEST) 2083 { 2084 if (isatty(sm_io_getinfo(smioin, SM_IO_WHAT_FD, NULL))) 2085 Verbose = 2; 2086 2087 if (Verbose) 2088 { 2089 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 2090 "ADDRESS TEST MODE (ruleset 3 NOT automatically invoked)\n"); 2091 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 2092 "Enter <ruleset> <address>\n"); 2093 } 2094 macdefine(&(MainEnvelope.e_macro), A_PERM, 2095 macid("{addr_type}"), "e r"); 2096 for (;;) 2097 { 2098 SM_TRY 2099 { 2100 (void) sm_signal(SIGINT, intindebug); 2101 (void) sm_releasesignal(SIGINT); 2102 if (Verbose == 2) 2103 (void) sm_io_fprintf(smioout, 2104 SM_TIME_DEFAULT, 2105 "> "); 2106 (void) sm_io_flush(smioout, SM_TIME_DEFAULT); 2107 if (sm_io_fgets(smioin, SM_TIME_DEFAULT, buf, 2108 sizeof(buf)) < 0) 2109 testmodeline("/quit", &MainEnvelope); 2110 p = strchr(buf, '\n'); 2111 if (p != NULL) 2112 *p = '\0'; 2113 if (Verbose < 2) 2114 (void) sm_io_fprintf(smioout, 2115 SM_TIME_DEFAULT, 2116 "> %s\n", buf); 2117 testmodeline(buf, &MainEnvelope); 2118 } 2119 SM_EXCEPT(exc, "[!F]*") 2120 { 2121 /* 2122 ** 8.10 just prints \n on interrupt. 2123 ** I'm printing the exception here in case 2124 ** sendmail is extended to raise additional 2125 ** exceptions in this context. 2126 */ 2127 2128 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 2129 "\n"); 2130 sm_exc_print(exc, smioout); 2131 } 2132 SM_END_TRY 2133 } 2134 } 2135 2136 #if STARTTLS 2137 tls_ok = true; 2138 if (OpMode == MD_QUEUERUN || OpMode == MD_DELIVER || 2139 OpMode == MD_ARPAFTP) 2140 { 2141 /* check whether STARTTLS is turned off for the client */ 2142 if (chkclientmodifiers(D_NOTLS)) 2143 tls_ok = false; 2144 } 2145 else if (OpMode == MD_DAEMON || OpMode == MD_FGDAEMON || 2146 OpMode == MD_SMTP) 2147 { 2148 /* check whether STARTTLS is turned off */ 2149 if (chkdaemonmodifiers(D_NOTLS) && chkclientmodifiers(D_NOTLS)) 2150 tls_ok = false; 2151 } 2152 else /* other modes don't need STARTTLS */ 2153 tls_ok = false; 2154 2155 if (tls_ok) 2156 { 2157 /* basic TLS initialization */ 2158 tls_ok = init_tls_library(FipsMode); 2159 if (!tls_ok && FipsMode) 2160 { 2161 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 2162 "ERROR: FIPSMode failed to initialize\n"); 2163 exit(EX_USAGE); 2164 } 2165 } 2166 2167 if (!tls_ok && (OpMode == MD_QUEUERUN || OpMode == MD_DELIVER)) 2168 { 2169 /* disable TLS for client */ 2170 setclttls(false); 2171 } 2172 #endif /* STARTTLS */ 2173 2174 /* 2175 ** If collecting stuff from the queue, go start doing that. 2176 */ 2177 2178 if (OpMode == MD_QUEUERUN && QueueIntvl == 0) 2179 { 2180 pid_t pid = -1; 2181 2182 #if STARTTLS 2183 /* init TLS for client, ignore result for now */ 2184 (void) initclttls(tls_ok); 2185 #endif /* STARTTLS */ 2186 2187 /* 2188 ** The parent process of the caller of runqueue() needs 2189 ** to stay around for a possible SIGTERM. The SIGTERM will 2190 ** tell this process that all of the queue runners children 2191 ** need to be sent SIGTERM as well. At the same time, we 2192 ** want to return control to the command line. So we do an 2193 ** extra fork(). 2194 */ 2195 2196 if (Verbose || foregroundqueue || (pid = fork()) <= 0) 2197 { 2198 /* 2199 ** If the fork() failed we should still try to do 2200 ** the queue run. If it succeeded then the child 2201 ** is going to start the run and wait for all 2202 ** of the children to finish. 2203 */ 2204 2205 if (pid == 0) 2206 { 2207 /* Reset global flags */ 2208 RestartRequest = NULL; 2209 ShutdownRequest = NULL; 2210 PendingSignal = 0; 2211 2212 /* disconnect from terminal */ 2213 disconnect(2, CurEnv); 2214 } 2215 2216 CurrentPid = getpid(); 2217 if (qgrp != NOQGRP) 2218 { 2219 int rwgflags = RWG_NONE; 2220 2221 /* 2222 ** To run a specific queue group mark it to 2223 ** be run, select the work group it's in and 2224 ** increment the work counter. 2225 */ 2226 2227 for (i = 0; i < NumQueue && Queue[i] != NULL; 2228 i++) 2229 Queue[i]->qg_nextrun = (time_t) -1; 2230 Queue[qgrp]->qg_nextrun = 0; 2231 if (Verbose) 2232 rwgflags |= RWG_VERBOSE; 2233 if (queuepersistent) 2234 rwgflags |= RWG_PERSISTENT; 2235 rwgflags |= RWG_FORCE; 2236 (void) run_work_group(Queue[qgrp]->qg_wgrp, 2237 rwgflags); 2238 } 2239 else 2240 (void) runqueue(false, Verbose, 2241 queuepersistent, true); 2242 2243 /* set the title to make it easier to find */ 2244 sm_setproctitle(true, CurEnv, "Queue control"); 2245 (void) sm_signal(SIGCHLD, SIG_DFL); 2246 while (CurChildren > 0) 2247 { 2248 int status; 2249 pid_t ret; 2250 2251 errno = 0; 2252 while ((ret = sm_wait(&status)) <= 0) 2253 { 2254 if (errno == ECHILD) 2255 { 2256 /* 2257 ** Oops... something got messed 2258 ** up really bad. Waiting for 2259 ** non-existent children 2260 ** shouldn't happen. Let's get 2261 ** out of here. 2262 */ 2263 2264 CurChildren = 0; 2265 break; 2266 } 2267 continue; 2268 } 2269 2270 /* something is really really wrong */ 2271 if (errno == ECHILD) 2272 { 2273 sm_syslog(LOG_ERR, NOQID, 2274 "queue control process: lost all children: wait returned ECHILD"); 2275 break; 2276 } 2277 2278 /* Only drop when a child gives status */ 2279 if (WIFSTOPPED(status)) 2280 continue; 2281 2282 proc_list_drop(ret, status, NULL); 2283 } 2284 } 2285 finis(true, true, ExitStat); 2286 /* NOTREACHED */ 2287 } 2288 2289 # if SASL 2290 if (OpMode == MD_SMTP || OpMode == MD_DAEMON) 2291 { 2292 /* check whether AUTH is turned off for the server */ 2293 if (!chkdaemonmodifiers(D_NOAUTH) && 2294 (i = sasl_server_init(srvcallbacks, "Sendmail")) != SASL_OK) 2295 syserr("!sasl_server_init failed! [%s]", 2296 sasl_errstring(i, NULL, NULL)); 2297 } 2298 # endif /* SASL */ 2299 2300 if (OpMode == MD_SMTP) 2301 { 2302 proc_list_add(CurrentPid, "Sendmail SMTP Agent", 2303 PROC_DAEMON, 0, -1, NULL); 2304 2305 /* clean up background delivery children */ 2306 (void) sm_signal(SIGCHLD, reapchild); 2307 } 2308 2309 /* 2310 ** If a daemon, wait for a request. 2311 ** getrequests will always return in a child. 2312 ** If we should also be processing the queue, start 2313 ** doing it in background. 2314 ** We check for any errors that might have happened 2315 ** during startup. 2316 */ 2317 2318 if (OpMode == MD_DAEMON || QueueIntvl > 0) 2319 { 2320 char dtype[200]; 2321 2322 /* avoid cleanup in finis(), DaemonPid will be set below */ 2323 DaemonPid = 0; 2324 if (!run_in_foreground && !tTd(99, 100)) 2325 { 2326 /* put us in background */ 2327 i = fork(); 2328 if (i < 0) 2329 syserr("daemon: cannot fork"); 2330 if (i != 0) 2331 { 2332 finis(false, true, EX_OK); 2333 /* NOTREACHED */ 2334 } 2335 2336 /* 2337 ** Initialize exception stack and default exception 2338 ** handler for child process. 2339 */ 2340 2341 /* Reset global flags */ 2342 RestartRequest = NULL; 2343 RestartWorkGroup = false; 2344 ShutdownRequest = NULL; 2345 PendingSignal = 0; 2346 CurrentPid = getpid(); 2347 2348 sm_exc_newthread(fatal_error); 2349 2350 /* disconnect from our controlling tty */ 2351 disconnect(2, &MainEnvelope); 2352 } 2353 2354 dtype[0] = '\0'; 2355 if (OpMode == MD_DAEMON) 2356 { 2357 (void) sm_strlcat(dtype, "+SMTP", sizeof(dtype)); 2358 DaemonPid = CurrentPid; 2359 } 2360 if (QueueIntvl > 0) 2361 { 2362 (void) sm_strlcat2(dtype, 2363 queuepersistent 2364 ? "+persistent-queueing@" 2365 : "+queueing@", 2366 pintvl(QueueIntvl, true), 2367 sizeof(dtype)); 2368 } 2369 if (tTd(0, 1)) 2370 (void) sm_strlcat(dtype, "+debugging", sizeof(dtype)); 2371 2372 sm_syslog(LOG_INFO, NOQID, 2373 "starting daemon (%s): %s", Version, dtype + 1); 2374 #if XLA 2375 xla_create_file(); 2376 #endif /* XLA */ 2377 2378 /* save daemon type in a macro for possible PidFile use */ 2379 macdefine(&BlankEnvelope.e_macro, A_TEMP, 2380 macid("{daemon_info}"), dtype + 1); 2381 2382 /* save queue interval in a macro for possible PidFile use */ 2383 macdefine(&MainEnvelope.e_macro, A_TEMP, 2384 macid("{queue_interval}"), pintvl(QueueIntvl, true)); 2385 2386 /* workaround: can't seem to release the signal in the parent */ 2387 (void) sm_signal(SIGHUP, sighup); 2388 (void) sm_releasesignal(SIGHUP); 2389 (void) sm_signal(SIGTERM, sigterm); 2390 2391 if (QueueIntvl > 0) 2392 { 2393 #if _FFR_RUNPQG 2394 if (qgrp != NOQGRP) 2395 { 2396 int rwgflags = RWG_NONE; 2397 2398 /* 2399 ** To run a specific queue group mark it to 2400 ** be run, select the work group it's in and 2401 ** increment the work counter. 2402 */ 2403 2404 for (i = 0; i < NumQueue && Queue[i] != NULL; 2405 i++) 2406 Queue[i]->qg_nextrun = (time_t) -1; 2407 Queue[qgrp]->qg_nextrun = 0; 2408 if (Verbose) 2409 rwgflags |= RWG_VERBOSE; 2410 if (queuepersistent) 2411 rwgflags |= RWG_PERSISTENT; 2412 rwgflags |= RWG_FORCE; 2413 (void) run_work_group(Queue[qgrp]->qg_wgrp, 2414 rwgflags); 2415 } 2416 else 2417 #endif /* _FFR_RUNPQG */ 2418 (void) runqueue(true, false, queuepersistent, 2419 true); 2420 2421 /* 2422 ** If queuepersistent but not in daemon mode then 2423 ** we're going to do the queue runner monitoring here. 2424 ** If in daemon mode then the monitoring will happen 2425 ** elsewhere. 2426 */ 2427 2428 if (OpMode != MD_DAEMON && queuepersistent) 2429 { 2430 /* 2431 ** Write the pid to file 2432 ** XXX Overwrites sendmail.pid 2433 */ 2434 2435 log_sendmail_pid(&MainEnvelope); 2436 2437 /* set the title to make it easier to find */ 2438 sm_setproctitle(true, CurEnv, "Queue control"); 2439 (void) sm_signal(SIGCHLD, SIG_DFL); 2440 while (CurChildren > 0) 2441 { 2442 int status; 2443 pid_t ret; 2444 int group; 2445 2446 CHECK_RESTART; 2447 errno = 0; 2448 while ((ret = sm_wait(&status)) <= 0) 2449 { 2450 /* 2451 ** Waiting for non-existent 2452 ** children shouldn't happen. 2453 ** Let's get out of here if 2454 ** it occurs. 2455 */ 2456 2457 if (errno == ECHILD) 2458 { 2459 CurChildren = 0; 2460 break; 2461 } 2462 continue; 2463 } 2464 2465 /* something is really really wrong */ 2466 if (errno == ECHILD) 2467 { 2468 sm_syslog(LOG_ERR, NOQID, 2469 "persistent queue runner control process: lost all children: wait returned ECHILD"); 2470 break; 2471 } 2472 2473 if (WIFSTOPPED(status)) 2474 continue; 2475 2476 /* Probe only on a child status */ 2477 proc_list_drop(ret, status, &group); 2478 2479 if (WIFSIGNALED(status)) 2480 { 2481 if (WCOREDUMP(status)) 2482 { 2483 sm_syslog(LOG_ERR, NOQID, 2484 "persistent queue runner=%d core dumped, signal=%d", 2485 group, WTERMSIG(status)); 2486 2487 /* don't restart this */ 2488 mark_work_group_restart( 2489 group, -1); 2490 continue; 2491 } 2492 2493 sm_syslog(LOG_ERR, NOQID, 2494 "persistent queue runner=%d died, pid=%ld, signal=%d", 2495 group, (long) ret, 2496 WTERMSIG(status)); 2497 } 2498 2499 /* 2500 ** When debugging active, don't 2501 ** restart the persistent queues. 2502 ** But do log this as info. 2503 */ 2504 2505 if (sm_debug_active(&DebugNoPRestart, 2506 1)) 2507 { 2508 sm_syslog(LOG_DEBUG, NOQID, 2509 "persistent queue runner=%d, exited", 2510 group); 2511 mark_work_group_restart(group, 2512 -1); 2513 } 2514 CHECK_RESTART; 2515 } 2516 finis(true, true, ExitStat); 2517 /* NOTREACHED */ 2518 } 2519 2520 if (OpMode != MD_DAEMON) 2521 { 2522 char qtype[200]; 2523 2524 /* 2525 ** Write the pid to file 2526 ** XXX Overwrites sendmail.pid 2527 */ 2528 2529 log_sendmail_pid(&MainEnvelope); 2530 2531 /* set the title to make it easier to find */ 2532 qtype[0] = '\0'; 2533 (void) sm_strlcpyn(qtype, sizeof(qtype), 4, 2534 "Queue runner@", 2535 pintvl(QueueIntvl, true), 2536 " for ", 2537 QueueDir); 2538 sm_setproctitle(true, CurEnv, qtype); 2539 for (;;) 2540 { 2541 (void) pause(); 2542 2543 CHECK_RESTART; 2544 2545 if (doqueuerun()) 2546 (void) runqueue(true, false, 2547 false, false); 2548 } 2549 } 2550 } 2551 (void) dropenvelope(&MainEnvelope, true, false); 2552 2553 #if STARTTLS 2554 /* init TLS for server, ignore result for now */ 2555 (void) initsrvtls(tls_ok); 2556 #endif /* STARTTLS */ 2557 2558 nextreq: 2559 p_flags = getrequests(&MainEnvelope); 2560 2561 /* drop privileges */ 2562 (void) drop_privileges(false); 2563 2564 /* 2565 ** Get authentication data 2566 ** Set _ macro in BlankEnvelope before calling newenvelope(). 2567 */ 2568 2569 authinfo = getauthinfo(sm_io_getinfo(InChannel, SM_IO_WHAT_FD, 2570 NULL), &forged); 2571 macdefine(&BlankEnvelope.e_macro, A_TEMP, '_', authinfo); 2572 if (tTd(75, 9)) 2573 sm_syslog(LOG_INFO, NOQID, 2574 "main: where=after_getauthinfo, RealHostAddr=%s", 2575 anynet_ntoa(&RealHostAddr)); 2576 2577 /* at this point we are in a child: reset state */ 2578 sm_rpool_free(MainEnvelope.e_rpool); 2579 (void) newenvelope(&MainEnvelope, &MainEnvelope, 2580 sm_rpool_new_x(NULL)); 2581 } 2582 2583 if (LogLevel > 9) 2584 { 2585 /* log connection information */ 2586 sm_syslog(LOG_INFO, NULL, "connect from %s", authinfo); 2587 } 2588 2589 /* 2590 ** If running SMTP protocol, start collecting and executing 2591 ** commands. This will never return. 2592 */ 2593 2594 if (OpMode == MD_SMTP || OpMode == MD_DAEMON) 2595 { 2596 char pbuf[20]; 2597 2598 /* 2599 ** Save some macros for check_* rulesets. 2600 */ 2601 2602 if (forged) 2603 { 2604 char ipbuf[103]; 2605 2606 (void) sm_snprintf(ipbuf, sizeof(ipbuf), "[%.100s]", 2607 anynet_ntoa(&RealHostAddr)); 2608 macdefine(&BlankEnvelope.e_macro, A_TEMP, 2609 macid("{client_name}"), ipbuf); 2610 } 2611 else 2612 macdefine(&BlankEnvelope.e_macro, A_PERM, 2613 macid("{client_name}"), RealHostName); 2614 macdefine(&BlankEnvelope.e_macro, A_PERM, 2615 macid("{client_ptr}"), RealHostName); 2616 macdefine(&BlankEnvelope.e_macro, A_TEMP, 2617 macid("{client_addr}"), anynet_ntoa(&RealHostAddr)); 2618 sm_getla(); 2619 2620 switch (RealHostAddr.sa.sa_family) 2621 { 2622 #if NETINET 2623 case AF_INET: 2624 (void) sm_snprintf(pbuf, sizeof(pbuf), "%d", 2625 RealHostAddr.sin.sin_port); 2626 break; 2627 #endif /* NETINET */ 2628 #if NETINET6 2629 case AF_INET6: 2630 (void) sm_snprintf(pbuf, sizeof(pbuf), "%d", 2631 RealHostAddr.sin6.sin6_port); 2632 break; 2633 #endif /* NETINET6 */ 2634 default: 2635 (void) sm_snprintf(pbuf, sizeof(pbuf), "0"); 2636 break; 2637 } 2638 macdefine(&BlankEnvelope.e_macro, A_TEMP, 2639 macid("{client_port}"), pbuf); 2640 2641 if (OpMode == MD_DAEMON) 2642 { 2643 ENVELOPE *saved_env; 2644 2645 /* validate the connection */ 2646 HoldErrs = true; 2647 saved_env = CurEnv; 2648 CurEnv = &BlankEnvelope; 2649 nullserver = validate_connection(&RealHostAddr, 2650 macvalue(macid("{client_name}"), 2651 &BlankEnvelope), 2652 &BlankEnvelope); 2653 if (bitset(EF_DISCARD, BlankEnvelope.e_flags)) 2654 MainEnvelope.e_flags |= EF_DISCARD; 2655 CurEnv = saved_env; 2656 HoldErrs = false; 2657 } 2658 else if (p_flags == NULL) 2659 { 2660 p_flags = (BITMAP256 *) xalloc(sizeof(*p_flags)); 2661 clrbitmap(p_flags); 2662 } 2663 #if STARTTLS 2664 if (OpMode == MD_SMTP) 2665 (void) initsrvtls(tls_ok); 2666 #endif /* STARTTLS */ 2667 2668 /* turn off profiling */ 2669 SM_PROF(1); 2670 smtp(nullserver, *p_flags, &MainEnvelope); 2671 2672 if (tTd(93, 100)) 2673 { 2674 /* turn off profiling */ 2675 SM_PROF(0); 2676 if (OpMode == MD_DAEMON) 2677 goto nextreq; 2678 } 2679 } 2680 2681 sm_rpool_free(MainEnvelope.e_rpool); 2682 clearenvelope(&MainEnvelope, false, sm_rpool_new_x(NULL)); 2683 if (OpMode == MD_VERIFY) 2684 { 2685 set_delivery_mode(SM_VERIFY, &MainEnvelope); 2686 PostMasterCopy = NULL; 2687 } 2688 else 2689 { 2690 /* interactive -- all errors are global */ 2691 MainEnvelope.e_flags |= EF_GLOBALERRS|EF_LOGSENDER; 2692 } 2693 2694 /* 2695 ** Do basic system initialization and set the sender 2696 */ 2697 2698 initsys(&MainEnvelope); 2699 macdefine(&MainEnvelope.e_macro, A_PERM, macid("{ntries}"), "0"); 2700 macdefine(&MainEnvelope.e_macro, A_PERM, macid("{nrcpts}"), "0"); 2701 setsender(from, &MainEnvelope, NULL, '\0', false); 2702 if (warn_f_flag != '\0' && !wordinclass(RealUserName, 't') && 2703 (!bitnset(M_LOCALMAILER, MainEnvelope.e_from.q_mailer->m_flags) || 2704 strcmp(MainEnvelope.e_from.q_user, RealUserName) != 0)) 2705 { 2706 auth_warning(&MainEnvelope, "%s set sender to %s using -%c", 2707 RealUserName, from, warn_f_flag); 2708 #if SASL 2709 auth = false; 2710 #endif /* SASL */ 2711 } 2712 if (auth) 2713 { 2714 char *fv; 2715 2716 /* set the initial sender for AUTH= to $f@$j */ 2717 fv = macvalue('f', &MainEnvelope); 2718 if (fv == NULL || *fv == '\0') 2719 MainEnvelope.e_auth_param = NULL; 2720 else 2721 { 2722 if (strchr(fv, '@') == NULL) 2723 { 2724 i = strlen(fv) + strlen(macvalue('j', 2725 &MainEnvelope)) + 2; 2726 p = sm_malloc_x(i); 2727 (void) sm_strlcpyn(p, i, 3, fv, "@", 2728 macvalue('j', 2729 &MainEnvelope)); 2730 } 2731 else 2732 p = sm_strdup_x(fv); 2733 MainEnvelope.e_auth_param = sm_rpool_strdup_x(MainEnvelope.e_rpool, 2734 xtextify(p, "=")); 2735 sm_free(p); /* XXX */ 2736 } 2737 } 2738 if (macvalue('s', &MainEnvelope) == NULL) 2739 macdefine(&MainEnvelope.e_macro, A_PERM, 's', RealHostName); 2740 2741 av = argv + optind; 2742 if (*av == NULL && !GrabTo) 2743 { 2744 MainEnvelope.e_to = NULL; 2745 MainEnvelope.e_flags |= EF_GLOBALERRS; 2746 HoldErrs = false; 2747 SuperSafe = SAFE_NO; 2748 usrerr("Recipient names must be specified"); 2749 2750 /* collect body for UUCP return */ 2751 if (OpMode != MD_VERIFY) 2752 collect(InChannel, false, NULL, &MainEnvelope, true); 2753 finis(true, true, EX_USAGE); 2754 /* NOTREACHED */ 2755 } 2756 2757 /* 2758 ** Scan argv and deliver the message to everyone. 2759 */ 2760 2761 save_val = LogUsrErrs; 2762 LogUsrErrs = true; 2763 sendtoargv(av, &MainEnvelope); 2764 LogUsrErrs = save_val; 2765 2766 /* if we have had errors sofar, arrange a meaningful exit stat */ 2767 if (Errors > 0 && ExitStat == EX_OK) 2768 ExitStat = EX_USAGE; 2769 2770 #if _FFR_FIX_DASHT 2771 /* 2772 ** If using -t, force not sending to argv recipients, even 2773 ** if they are mentioned in the headers. 2774 */ 2775 2776 if (GrabTo) 2777 { 2778 ADDRESS *q; 2779 2780 for (q = MainEnvelope.e_sendqueue; q != NULL; q = q->q_next) 2781 q->q_state = QS_REMOVED; 2782 } 2783 #endif /* _FFR_FIX_DASHT */ 2784 2785 /* 2786 ** Read the input mail. 2787 */ 2788 2789 MainEnvelope.e_to = NULL; 2790 if (OpMode != MD_VERIFY || GrabTo) 2791 { 2792 int savederrors; 2793 unsigned long savedflags; 2794 2795 /* 2796 ** workaround for compiler warning on Irix: 2797 ** do not initialize variable in the definition, but 2798 ** later on: 2799 ** warning(1548): transfer of control bypasses 2800 ** initialization of: 2801 ** variable "savederrors" (declared at line 2570) 2802 ** variable "savedflags" (declared at line 2571) 2803 ** goto giveup; 2804 */ 2805 2806 savederrors = Errors; 2807 savedflags = MainEnvelope.e_flags & EF_FATALERRS; 2808 MainEnvelope.e_flags |= EF_GLOBALERRS; 2809 MainEnvelope.e_flags &= ~EF_FATALERRS; 2810 Errors = 0; 2811 buffer_errors(); 2812 collect(InChannel, false, NULL, &MainEnvelope, true); 2813 2814 /* header checks failed */ 2815 if (Errors > 0) 2816 { 2817 giveup: 2818 if (!GrabTo) 2819 { 2820 /* Log who the mail would have gone to */ 2821 logundelrcpts(&MainEnvelope, 2822 MainEnvelope.e_message, 2823 8, false); 2824 } 2825 flush_errors(true); 2826 finis(true, true, ExitStat); 2827 /* NOTREACHED */ 2828 return -1; 2829 } 2830 2831 /* bail out if message too large */ 2832 if (bitset(EF_CLRQUEUE, MainEnvelope.e_flags)) 2833 { 2834 finis(true, true, ExitStat != EX_OK ? ExitStat 2835 : EX_DATAERR); 2836 /* NOTREACHED */ 2837 return -1; 2838 } 2839 2840 /* set message size */ 2841 (void) sm_snprintf(buf, sizeof(buf), "%ld", 2842 PRT_NONNEGL(MainEnvelope.e_msgsize)); 2843 macdefine(&MainEnvelope.e_macro, A_TEMP, 2844 macid("{msg_size}"), buf); 2845 2846 Errors = savederrors; 2847 MainEnvelope.e_flags |= savedflags; 2848 } 2849 errno = 0; 2850 2851 if (tTd(1, 1)) 2852 sm_dprintf("From person = \"%s\"\n", 2853 MainEnvelope.e_from.q_paddr); 2854 2855 /* Check if quarantining stats should be updated */ 2856 if (MainEnvelope.e_quarmsg != NULL) 2857 markstats(&MainEnvelope, NULL, STATS_QUARANTINE); 2858 2859 /* 2860 ** Actually send everything. 2861 ** If verifying, just ack. 2862 */ 2863 2864 if (Errors == 0) 2865 { 2866 if (!split_by_recipient(&MainEnvelope) && 2867 bitset(EF_FATALERRS, MainEnvelope.e_flags)) 2868 goto giveup; 2869 } 2870 2871 /* make sure we deliver at least the first envelope */ 2872 i = FastSplit > 0 ? 0 : -1; 2873 for (e = &MainEnvelope; e != NULL; e = e->e_sibling, i++) 2874 { 2875 ENVELOPE *next; 2876 2877 e->e_from.q_state = QS_SENDER; 2878 if (tTd(1, 5)) 2879 { 2880 sm_dprintf("main[%d]: QS_SENDER ", i); 2881 printaddr(sm_debug_file(), &e->e_from, false); 2882 } 2883 e->e_to = NULL; 2884 sm_getla(); 2885 GrabTo = false; 2886 #if NAMED_BIND 2887 _res.retry = TimeOuts.res_retry[RES_TO_FIRST]; 2888 _res.retrans = TimeOuts.res_retrans[RES_TO_FIRST]; 2889 #endif /* NAMED_BIND */ 2890 next = e->e_sibling; 2891 e->e_sibling = NULL; 2892 2893 /* after FastSplit envelopes: queue up */ 2894 sendall(e, i >= FastSplit ? SM_QUEUE : SM_DEFAULT); 2895 e->e_sibling = next; 2896 } 2897 2898 /* 2899 ** All done. 2900 ** Don't send return error message if in VERIFY mode. 2901 */ 2902 2903 finis(true, true, ExitStat); 2904 /* NOTREACHED */ 2905 return ExitStat; 2906 } 2907 /* 2908 ** STOP_SENDMAIL -- Stop the running program 2909 ** 2910 ** Parameters: 2911 ** none. 2912 ** 2913 ** Returns: 2914 ** none. 2915 ** 2916 ** Side Effects: 2917 ** exits. 2918 */ 2919 2920 void 2921 stop_sendmail() 2922 { 2923 /* reset uid for process accounting */ 2924 endpwent(); 2925 (void) setuid(RealUid); 2926 exit(EX_OK); 2927 } 2928 /* 2929 ** FINIS -- Clean up and exit. 2930 ** 2931 ** Parameters: 2932 ** drop -- whether or not to drop CurEnv envelope 2933 ** cleanup -- call exit() or _exit()? 2934 ** exitstat -- exit status to use for exit() call 2935 ** 2936 ** Returns: 2937 ** never 2938 ** 2939 ** Side Effects: 2940 ** exits sendmail 2941 */ 2942 2943 void 2944 finis(drop, cleanup, exitstat) 2945 bool drop; 2946 bool cleanup; 2947 volatile int exitstat; 2948 { 2949 char pidpath[MAXPATHLEN]; 2950 pid_t pid; 2951 2952 /* Still want to process new timeouts added below */ 2953 sm_clear_events(); 2954 (void) sm_releasesignal(SIGALRM); 2955 2956 if (tTd(2, 1)) 2957 { 2958 sm_dprintf("\n====finis: stat %d e_id=%s e_flags=", 2959 exitstat, 2960 CurEnv->e_id == NULL ? "NOQUEUE" : CurEnv->e_id); 2961 printenvflags(CurEnv); 2962 } 2963 if (tTd(2, 9)) 2964 printopenfds(false); 2965 2966 SM_TRY 2967 /* 2968 ** Clean up. This might raise E:mta.quickabort 2969 */ 2970 2971 /* clean up temp files */ 2972 CurEnv->e_to = NULL; 2973 if (drop) 2974 { 2975 if (CurEnv->e_id != NULL) 2976 { 2977 int r; 2978 2979 r = dropenvelope(CurEnv, true, false); 2980 if (exitstat == EX_OK) 2981 exitstat = r; 2982 sm_rpool_free(CurEnv->e_rpool); 2983 CurEnv->e_rpool = NULL; 2984 2985 /* these may have pointed to the rpool */ 2986 CurEnv->e_to = NULL; 2987 CurEnv->e_message = NULL; 2988 CurEnv->e_statmsg = NULL; 2989 CurEnv->e_quarmsg = NULL; 2990 CurEnv->e_bodytype = NULL; 2991 CurEnv->e_id = NULL; 2992 CurEnv->e_envid = NULL; 2993 CurEnv->e_auth_param = NULL; 2994 } 2995 else 2996 poststats(StatFile); 2997 } 2998 2999 /* flush any cached connections */ 3000 mci_flush(true, NULL); 3001 3002 /* close maps belonging to this pid */ 3003 closemaps(false); 3004 3005 #if USERDB 3006 /* close UserDatabase */ 3007 _udbx_close(); 3008 #endif /* USERDB */ 3009 3010 #if SASL 3011 stop_sasl_client(); 3012 #endif /* SASL */ 3013 3014 #if XLA 3015 /* clean up extended load average stuff */ 3016 xla_all_end(); 3017 #endif /* XLA */ 3018 3019 SM_FINALLY 3020 /* 3021 ** And exit. 3022 */ 3023 3024 if (LogLevel > 78) 3025 sm_syslog(LOG_DEBUG, CurEnv->e_id, "finis, pid=%d", 3026 (int) CurrentPid); 3027 if (exitstat == EX_TEMPFAIL || 3028 CurEnv->e_errormode == EM_BERKNET) 3029 exitstat = EX_OK; 3030 3031 /* XXX clean up queues and related data structures */ 3032 cleanup_queues(); 3033 pid = getpid(); 3034 #if SM_CONF_SHM 3035 cleanup_shm(DaemonPid == pid); 3036 #endif /* SM_CONF_SHM */ 3037 3038 /* close locked pid file */ 3039 close_sendmail_pid(); 3040 3041 if (DaemonPid == pid || PidFilePid == pid) 3042 { 3043 /* blow away the pid file */ 3044 expand(PidFile, pidpath, sizeof(pidpath), CurEnv); 3045 (void) unlink(pidpath); 3046 } 3047 3048 /* reset uid for process accounting */ 3049 endpwent(); 3050 sm_mbdb_terminate(); 3051 #if _FFR_MEMSTAT 3052 (void) sm_memstat_close(); 3053 #endif /* _FFR_MEMSTAT */ 3054 (void) setuid(RealUid); 3055 #if SM_HEAP_CHECK 3056 /* dump the heap, if we are checking for memory leaks */ 3057 if (sm_debug_active(&SmHeapCheck, 2)) 3058 sm_heap_report(smioout, 3059 sm_debug_level(&SmHeapCheck) - 1); 3060 #endif /* SM_HEAP_CHECK */ 3061 if (sm_debug_active(&SmXtrapReport, 1)) 3062 sm_dprintf("xtrap count = %d\n", SmXtrapCount); 3063 if (cleanup) 3064 exit(exitstat); 3065 else 3066 _exit(exitstat); 3067 SM_END_TRY 3068 } 3069 /* 3070 ** INTINDEBUG -- signal handler for SIGINT in -bt mode 3071 ** 3072 ** Parameters: 3073 ** sig -- incoming signal. 3074 ** 3075 ** Returns: 3076 ** none. 3077 ** 3078 ** Side Effects: 3079 ** longjmps back to test mode loop. 3080 ** 3081 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD 3082 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE 3083 ** DOING. 3084 */ 3085 3086 /* Type of an exception generated on SIGINT during address test mode. */ 3087 static const SM_EXC_TYPE_T EtypeInterrupt = 3088 { 3089 SmExcTypeMagic, 3090 "S:mta.interrupt", 3091 "", 3092 sm_etype_printf, 3093 "interrupt", 3094 }; 3095 3096 /* ARGSUSED */ 3097 static SIGFUNC_DECL 3098 intindebug(sig) 3099 int sig; 3100 { 3101 int save_errno = errno; 3102 3103 FIX_SYSV_SIGNAL(sig, intindebug); 3104 errno = save_errno; 3105 CHECK_CRITICAL(sig); 3106 errno = save_errno; 3107 sm_exc_raisenew_x(&EtypeInterrupt); 3108 errno = save_errno; 3109 return SIGFUNC_RETURN; 3110 } 3111 /* 3112 ** SIGTERM -- SIGTERM handler for the daemon 3113 ** 3114 ** Parameters: 3115 ** sig -- signal number. 3116 ** 3117 ** Returns: 3118 ** none. 3119 ** 3120 ** Side Effects: 3121 ** Sets ShutdownRequest which will hopefully trigger 3122 ** the daemon to exit. 3123 ** 3124 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD 3125 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE 3126 ** DOING. 3127 */ 3128 3129 /* ARGSUSED */ 3130 static SIGFUNC_DECL 3131 sigterm(sig) 3132 int sig; 3133 { 3134 int save_errno = errno; 3135 3136 FIX_SYSV_SIGNAL(sig, sigterm); 3137 ShutdownRequest = "signal"; 3138 errno = save_errno; 3139 return SIGFUNC_RETURN; 3140 } 3141 /* 3142 ** SIGHUP -- handle a SIGHUP signal 3143 ** 3144 ** Parameters: 3145 ** sig -- incoming signal. 3146 ** 3147 ** Returns: 3148 ** none. 3149 ** 3150 ** Side Effects: 3151 ** Sets RestartRequest which should cause the daemon 3152 ** to restart. 3153 ** 3154 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD 3155 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE 3156 ** DOING. 3157 */ 3158 3159 /* ARGSUSED */ 3160 static SIGFUNC_DECL 3161 sighup(sig) 3162 int sig; 3163 { 3164 int save_errno = errno; 3165 3166 FIX_SYSV_SIGNAL(sig, sighup); 3167 RestartRequest = "signal"; 3168 errno = save_errno; 3169 return SIGFUNC_RETURN; 3170 } 3171 /* 3172 ** SIGPIPE -- signal handler for SIGPIPE 3173 ** 3174 ** Parameters: 3175 ** sig -- incoming signal. 3176 ** 3177 ** Returns: 3178 ** none. 3179 ** 3180 ** Side Effects: 3181 ** Sets StopRequest which should cause the mailq/hoststatus 3182 ** display to stop. 3183 ** 3184 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD 3185 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE 3186 ** DOING. 3187 */ 3188 3189 /* ARGSUSED */ 3190 static SIGFUNC_DECL 3191 sigpipe(sig) 3192 int sig; 3193 { 3194 int save_errno = errno; 3195 3196 FIX_SYSV_SIGNAL(sig, sigpipe); 3197 StopRequest = true; 3198 errno = save_errno; 3199 return SIGFUNC_RETURN; 3200 } 3201 /* 3202 ** INTSIG -- clean up on interrupt 3203 ** 3204 ** This just arranges to exit. It pessimizes in that it 3205 ** may resend a message. 3206 ** 3207 ** Parameters: 3208 ** sig -- incoming signal. 3209 ** 3210 ** Returns: 3211 ** none. 3212 ** 3213 ** Side Effects: 3214 ** Unlocks the current job. 3215 ** 3216 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD 3217 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE 3218 ** DOING. 3219 */ 3220 3221 /* ARGSUSED */ 3222 SIGFUNC_DECL 3223 intsig(sig) 3224 int sig; 3225 { 3226 bool drop = false; 3227 int save_errno = errno; 3228 3229 FIX_SYSV_SIGNAL(sig, intsig); 3230 errno = save_errno; 3231 CHECK_CRITICAL(sig); 3232 sm_allsignals(true); 3233 IntSig = true; 3234 3235 FileName = NULL; 3236 3237 /* Clean-up on aborted stdin message submission */ 3238 if (OpMode == MD_SMTP || 3239 OpMode == MD_DELIVER || 3240 OpMode == MD_ARPAFTP) 3241 { 3242 if (CurEnv->e_id != NULL) 3243 { 3244 char *fn; 3245 3246 fn = queuename(CurEnv, DATAFL_LETTER); 3247 if (fn != NULL) 3248 (void) unlink(fn); 3249 fn = queuename(CurEnv, ANYQFL_LETTER); 3250 if (fn != NULL) 3251 (void) unlink(fn); 3252 } 3253 _exit(EX_OK); 3254 /* NOTREACHED */ 3255 } 3256 3257 if (sig != 0 && LogLevel > 79) 3258 sm_syslog(LOG_DEBUG, CurEnv->e_id, "interrupt"); 3259 if (OpMode != MD_TEST) 3260 unlockqueue(CurEnv); 3261 3262 finis(drop, false, EX_OK); 3263 /* NOTREACHED */ 3264 } 3265 /* 3266 ** DISCONNECT -- remove our connection with any foreground process 3267 ** 3268 ** Parameters: 3269 ** droplev -- how "deeply" we should drop the line. 3270 ** 0 -- ignore signals, mail back errors, make sure 3271 ** output goes to stdout. 3272 ** 1 -- also, make stdout go to /dev/null. 3273 ** 2 -- also, disconnect from controlling terminal 3274 ** (only for daemon mode). 3275 ** e -- the current envelope. 3276 ** 3277 ** Returns: 3278 ** none 3279 ** 3280 ** Side Effects: 3281 ** Trys to insure that we are immune to vagaries of 3282 ** the controlling tty. 3283 */ 3284 3285 void 3286 disconnect(droplev, e) 3287 int droplev; 3288 register ENVELOPE *e; 3289 { 3290 int fd; 3291 3292 if (tTd(52, 1)) 3293 sm_dprintf("disconnect: In %d Out %d, e=%p\n", 3294 sm_io_getinfo(InChannel, SM_IO_WHAT_FD, NULL), 3295 sm_io_getinfo(OutChannel, SM_IO_WHAT_FD, NULL), e); 3296 if (tTd(52, 100)) 3297 { 3298 sm_dprintf("don't\n"); 3299 return; 3300 } 3301 if (LogLevel > 93) 3302 sm_syslog(LOG_DEBUG, e->e_id, 3303 "disconnect level %d", 3304 droplev); 3305 3306 /* be sure we don't get nasty signals */ 3307 (void) sm_signal(SIGINT, SIG_IGN); 3308 (void) sm_signal(SIGQUIT, SIG_IGN); 3309 3310 /* we can't communicate with our caller, so.... */ 3311 HoldErrs = true; 3312 CurEnv->e_errormode = EM_MAIL; 3313 Verbose = 0; 3314 DisConnected = true; 3315 3316 /* all input from /dev/null */ 3317 if (InChannel != smioin) 3318 { 3319 (void) sm_io_close(InChannel, SM_TIME_DEFAULT); 3320 InChannel = smioin; 3321 } 3322 if (sm_io_reopen(SmFtStdio, SM_TIME_DEFAULT, SM_PATH_DEVNULL, 3323 SM_IO_RDONLY, NULL, smioin) == NULL) 3324 sm_syslog(LOG_ERR, e->e_id, 3325 "disconnect: sm_io_reopen(\"%s\") failed: %s", 3326 SM_PATH_DEVNULL, sm_errstring(errno)); 3327 3328 /* 3329 ** output to the transcript 3330 ** We also compare the fd numbers here since OutChannel 3331 ** might be a layer on top of smioout due to encryption 3332 ** (see sfsasl.c). 3333 */ 3334 3335 if (OutChannel != smioout && 3336 sm_io_getinfo(OutChannel, SM_IO_WHAT_FD, NULL) != 3337 sm_io_getinfo(smioout, SM_IO_WHAT_FD, NULL)) 3338 { 3339 (void) sm_io_close(OutChannel, SM_TIME_DEFAULT); 3340 OutChannel = smioout; 3341 3342 #if 0 3343 /* 3344 ** Has smioout been closed? Reopen it. 3345 ** This shouldn't happen anymore, the code is here 3346 ** just as a reminder. 3347 */ 3348 3349 if (smioout->sm_magic == NULL && 3350 sm_io_reopen(SmFtStdio, SM_TIME_DEFAULT, SM_PATH_DEVNULL, 3351 SM_IO_WRONLY, NULL, smioout) == NULL) 3352 sm_syslog(LOG_ERR, e->e_id, 3353 "disconnect: sm_io_reopen(\"%s\") failed: %s", 3354 SM_PATH_DEVNULL, sm_errstring(errno)); 3355 #endif /* 0 */ 3356 } 3357 if (droplev > 0) 3358 { 3359 fd = open(SM_PATH_DEVNULL, O_WRONLY, 0666); 3360 if (fd == -1) 3361 { 3362 sm_syslog(LOG_ERR, e->e_id, 3363 "disconnect: open(\"%s\") failed: %s", 3364 SM_PATH_DEVNULL, sm_errstring(errno)); 3365 } 3366 (void) sm_io_flush(smioout, SM_TIME_DEFAULT); 3367 if (fd >= 0) 3368 { 3369 (void) dup2(fd, STDOUT_FILENO); 3370 (void) dup2(fd, STDERR_FILENO); 3371 (void) close(fd); 3372 } 3373 } 3374 3375 /* drop our controlling TTY completely if possible */ 3376 if (droplev > 1) 3377 { 3378 (void) setsid(); 3379 errno = 0; 3380 } 3381 3382 #if XDEBUG 3383 checkfd012("disconnect"); 3384 #endif /* XDEBUG */ 3385 3386 if (LogLevel > 71) 3387 sm_syslog(LOG_DEBUG, e->e_id, "in background, pid=%d", 3388 (int) CurrentPid); 3389 3390 errno = 0; 3391 } 3392 3393 static void 3394 obsolete(argv) 3395 char *argv[]; 3396 { 3397 register char *ap; 3398 register char *op; 3399 3400 while ((ap = *++argv) != NULL) 3401 { 3402 /* Return if "--" or not an option of any form. */ 3403 if (ap[0] != '-' || ap[1] == '-') 3404 return; 3405 3406 /* Don't allow users to use "-Q." or "-Q ." */ 3407 if ((ap[1] == 'Q' && ap[2] == '.') || 3408 (ap[1] == 'Q' && argv[1] != NULL && 3409 argv[1][0] == '.' && argv[1][1] == '\0')) 3410 { 3411 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 3412 "Can not use -Q.\n"); 3413 exit(EX_USAGE); 3414 } 3415 3416 /* skip over options that do have a value */ 3417 op = strchr(OPTIONS, ap[1]); 3418 if (op != NULL && *++op == ':' && ap[2] == '\0' && 3419 ap[1] != 'd' && 3420 #if defined(sony_news) 3421 ap[1] != 'E' && ap[1] != 'J' && 3422 #endif /* defined(sony_news) */ 3423 argv[1] != NULL && argv[1][0] != '-') 3424 { 3425 argv++; 3426 continue; 3427 } 3428 3429 /* If -C doesn't have an argument, use sendmail.cf. */ 3430 #define __DEFPATH "sendmail.cf" 3431 if (ap[1] == 'C' && ap[2] == '\0') 3432 { 3433 *argv = xalloc(sizeof(__DEFPATH) + 2); 3434 (void) sm_strlcpyn(argv[0], sizeof(__DEFPATH) + 2, 2, 3435 "-C", __DEFPATH); 3436 } 3437 3438 /* If -q doesn't have an argument, run it once. */ 3439 if (ap[1] == 'q' && ap[2] == '\0') 3440 *argv = "-q0"; 3441 3442 /* If -Q doesn't have an argument, disable quarantining */ 3443 if (ap[1] == 'Q' && ap[2] == '\0') 3444 *argv = "-Q."; 3445 3446 /* if -d doesn't have an argument, use 0-99.1 */ 3447 if (ap[1] == 'd' && ap[2] == '\0') 3448 *argv = "-d0-99.1"; 3449 3450 #if defined(sony_news) 3451 /* if -E doesn't have an argument, use -EC */ 3452 if (ap[1] == 'E' && ap[2] == '\0') 3453 *argv = "-EC"; 3454 3455 /* if -J doesn't have an argument, use -JJ */ 3456 if (ap[1] == 'J' && ap[2] == '\0') 3457 *argv = "-JJ"; 3458 #endif /* defined(sony_news) */ 3459 } 3460 } 3461 /* 3462 ** AUTH_WARNING -- specify authorization warning 3463 ** 3464 ** Parameters: 3465 ** e -- the current envelope. 3466 ** msg -- the text of the message. 3467 ** args -- arguments to the message. 3468 ** 3469 ** Returns: 3470 ** none. 3471 */ 3472 3473 void 3474 #ifdef __STDC__ 3475 auth_warning(register ENVELOPE *e, const char *msg, ...) 3476 #else /* __STDC__ */ 3477 auth_warning(e, msg, va_alist) 3478 register ENVELOPE *e; 3479 const char *msg; 3480 va_dcl 3481 #endif /* __STDC__ */ 3482 { 3483 char buf[MAXLINE]; 3484 SM_VA_LOCAL_DECL 3485 3486 if (bitset(PRIV_AUTHWARNINGS, PrivacyFlags)) 3487 { 3488 register char *p; 3489 static char hostbuf[48]; 3490 3491 if (hostbuf[0] == '\0') 3492 { 3493 struct hostent *hp; 3494 3495 hp = myhostname(hostbuf, sizeof(hostbuf)); 3496 #if NETINET6 3497 if (hp != NULL) 3498 { 3499 freehostent(hp); 3500 hp = NULL; 3501 } 3502 #endif /* NETINET6 */ 3503 } 3504 3505 (void) sm_strlcpyn(buf, sizeof(buf), 2, hostbuf, ": "); 3506 p = &buf[strlen(buf)]; 3507 SM_VA_START(ap, msg); 3508 (void) sm_vsnprintf(p, SPACELEFT(buf, p), msg, ap); 3509 SM_VA_END(ap); 3510 addheader("X-Authentication-Warning", buf, 0, e, true); 3511 if (LogLevel > 3) 3512 sm_syslog(LOG_INFO, e->e_id, 3513 "Authentication-Warning: %.400s", 3514 buf); 3515 } 3516 } 3517 /* 3518 ** GETEXTENV -- get from external environment 3519 ** 3520 ** Parameters: 3521 ** envar -- the name of the variable to retrieve 3522 ** 3523 ** Returns: 3524 ** The value, if any. 3525 */ 3526 3527 static char * 3528 getextenv(envar) 3529 const char *envar; 3530 { 3531 char **envp; 3532 int l; 3533 3534 l = strlen(envar); 3535 for (envp = ExternalEnviron; envp != NULL && *envp != NULL; envp++) 3536 { 3537 if (strncmp(*envp, envar, l) == 0 && (*envp)[l] == '=') 3538 return &(*envp)[l + 1]; 3539 } 3540 return NULL; 3541 } 3542 /* 3543 ** SM_SETUSERENV -- set an environment variable in the propagated environment 3544 ** 3545 ** Parameters: 3546 ** envar -- the name of the environment variable. 3547 ** value -- the value to which it should be set. If 3548 ** null, this is extracted from the incoming 3549 ** environment. If that is not set, the call 3550 ** to sm_setuserenv is ignored. 3551 ** 3552 ** Returns: 3553 ** none. 3554 */ 3555 3556 void 3557 sm_setuserenv(envar, value) 3558 const char *envar; 3559 const char *value; 3560 { 3561 int i, l; 3562 char **evp = UserEnviron; 3563 char *p; 3564 3565 if (value == NULL) 3566 { 3567 value = getextenv(envar); 3568 if (value == NULL) 3569 return; 3570 } 3571 3572 /* XXX enforce reasonable size? */ 3573 i = strlen(envar) + 1; 3574 l = strlen(value) + i + 1; 3575 p = (char *) xalloc(l); 3576 (void) sm_strlcpyn(p, l, 3, envar, "=", value); 3577 3578 while (*evp != NULL && strncmp(*evp, p, i) != 0) 3579 evp++; 3580 if (*evp != NULL) 3581 { 3582 *evp++ = p; 3583 } 3584 else if (evp < &UserEnviron[MAXUSERENVIRON]) 3585 { 3586 *evp++ = p; 3587 *evp = NULL; 3588 } 3589 3590 /* make sure it is in our environment as well */ 3591 if (putenv(p) < 0) 3592 syserr("sm_setuserenv: putenv(%s) failed", p); 3593 } 3594 /* 3595 ** DUMPSTATE -- dump state 3596 ** 3597 ** For debugging. 3598 */ 3599 3600 void 3601 dumpstate(when) 3602 char *when; 3603 { 3604 register char *j = macvalue('j', CurEnv); 3605 int rs; 3606 extern int NextMacroId; 3607 3608 sm_syslog(LOG_DEBUG, CurEnv->e_id, 3609 "--- dumping state on %s: $j = %s ---", 3610 when, 3611 j == NULL ? "<NULL>" : j); 3612 if (j != NULL) 3613 { 3614 if (!wordinclass(j, 'w')) 3615 sm_syslog(LOG_DEBUG, CurEnv->e_id, 3616 "*** $j not in $=w ***"); 3617 } 3618 sm_syslog(LOG_DEBUG, CurEnv->e_id, "CurChildren = %d", CurChildren); 3619 sm_syslog(LOG_DEBUG, CurEnv->e_id, "NextMacroId = %d (Max %d)", 3620 NextMacroId, MAXMACROID); 3621 sm_syslog(LOG_DEBUG, CurEnv->e_id, "--- open file descriptors: ---"); 3622 printopenfds(true); 3623 sm_syslog(LOG_DEBUG, CurEnv->e_id, "--- connection cache: ---"); 3624 mci_dump_all(smioout, true); 3625 rs = strtorwset("debug_dumpstate", NULL, ST_FIND); 3626 if (rs > 0) 3627 { 3628 int status; 3629 register char **pvp; 3630 char *pv[MAXATOM + 1]; 3631 3632 pv[0] = NULL; 3633 status = REWRITE(pv, rs, CurEnv); 3634 sm_syslog(LOG_DEBUG, CurEnv->e_id, 3635 "--- ruleset debug_dumpstate returns stat %d, pv: ---", 3636 status); 3637 for (pvp = pv; *pvp != NULL; pvp++) 3638 sm_syslog(LOG_DEBUG, CurEnv->e_id, "%s", *pvp); 3639 } 3640 sm_syslog(LOG_DEBUG, CurEnv->e_id, "--- end of state dump ---"); 3641 } 3642 3643 #ifdef SIGUSR1 3644 /* 3645 ** SIGUSR1 -- Signal a request to dump state. 3646 ** 3647 ** Parameters: 3648 ** sig -- calling signal. 3649 ** 3650 ** Returns: 3651 ** none. 3652 ** 3653 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD 3654 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE 3655 ** DOING. 3656 ** 3657 ** XXX: More work is needed for this signal handler. 3658 */ 3659 3660 /* ARGSUSED */ 3661 static SIGFUNC_DECL 3662 sigusr1(sig) 3663 int sig; 3664 { 3665 int save_errno = errno; 3666 3667 FIX_SYSV_SIGNAL(sig, sigusr1); 3668 errno = save_errno; 3669 CHECK_CRITICAL(sig); 3670 dumpstate("user signal"); 3671 # if SM_HEAP_CHECK 3672 dumpstab(); 3673 # endif /* SM_HEAP_CHECK */ 3674 errno = save_errno; 3675 return SIGFUNC_RETURN; 3676 } 3677 #endif /* SIGUSR1 */ 3678 3679 /* 3680 ** DROP_PRIVILEGES -- reduce privileges to those of the RunAsUser option 3681 ** 3682 ** Parameters: 3683 ** to_real_uid -- if set, drop to the real uid instead 3684 ** of the RunAsUser. 3685 ** 3686 ** Returns: 3687 ** EX_OSERR if the setuid failed. 3688 ** EX_OK otherwise. 3689 */ 3690 3691 int 3692 drop_privileges(to_real_uid) 3693 bool to_real_uid; 3694 { 3695 int rval = EX_OK; 3696 GIDSET_T emptygidset[1]; 3697 3698 if (tTd(47, 1)) 3699 sm_dprintf("drop_privileges(%d): Real[UG]id=%d:%d, get[ug]id=%d:%d, gete[ug]id=%d:%d, RunAs[UG]id=%d:%d\n", 3700 (int) to_real_uid, 3701 (int) RealUid, (int) RealGid, 3702 (int) getuid(), (int) getgid(), 3703 (int) geteuid(), (int) getegid(), 3704 (int) RunAsUid, (int) RunAsGid); 3705 3706 if (to_real_uid) 3707 { 3708 RunAsUserName = RealUserName; 3709 RunAsUid = RealUid; 3710 RunAsGid = RealGid; 3711 EffGid = RunAsGid; 3712 } 3713 3714 /* make sure no one can grab open descriptors for secret files */ 3715 endpwent(); 3716 sm_mbdb_terminate(); 3717 3718 /* reset group permissions; these can be set later */ 3719 emptygidset[0] = (to_real_uid || RunAsGid != 0) ? RunAsGid : getegid(); 3720 3721 /* 3722 ** Notice: on some OS (Linux...) the setgroups() call causes 3723 ** a logfile entry if sendmail is not run by root. 3724 ** However, it is unclear (no POSIX standard) whether 3725 ** setgroups() can only succeed if executed by root. 3726 ** So for now we keep it as it is; if you want to change it, use 3727 ** if (geteuid() == 0 && setgroups(1, emptygidset) == -1) 3728 */ 3729 3730 if (setgroups(1, emptygidset) == -1 && geteuid() == 0) 3731 { 3732 syserr("drop_privileges: setgroups(1, %d) failed", 3733 (int) emptygidset[0]); 3734 rval = EX_OSERR; 3735 } 3736 3737 /* reset primary group id */ 3738 if (to_real_uid) 3739 { 3740 /* 3741 ** Drop gid to real gid. 3742 ** On some OS we must reset the effective[/real[/saved]] gid, 3743 ** and then use setgid() to finally drop all group privileges. 3744 ** Later on we check whether we can get back the 3745 ** effective gid. 3746 */ 3747 3748 #if HASSETEGID 3749 if (setegid(RunAsGid) < 0) 3750 { 3751 syserr("drop_privileges: setegid(%d) failed", 3752 (int) RunAsGid); 3753 rval = EX_OSERR; 3754 } 3755 #else /* HASSETEGID */ 3756 # if HASSETREGID 3757 if (setregid(RunAsGid, RunAsGid) < 0) 3758 { 3759 syserr("drop_privileges: setregid(%d, %d) failed", 3760 (int) RunAsGid, (int) RunAsGid); 3761 rval = EX_OSERR; 3762 } 3763 # else /* HASSETREGID */ 3764 # if HASSETRESGID 3765 if (setresgid(RunAsGid, RunAsGid, RunAsGid) < 0) 3766 { 3767 syserr("drop_privileges: setresgid(%d, %d, %d) failed", 3768 (int) RunAsGid, (int) RunAsGid, (int) RunAsGid); 3769 rval = EX_OSERR; 3770 } 3771 # endif /* HASSETRESGID */ 3772 # endif /* HASSETREGID */ 3773 #endif /* HASSETEGID */ 3774 } 3775 if (rval == EX_OK && (to_real_uid || RunAsGid != 0)) 3776 { 3777 if (setgid(RunAsGid) < 0 && (!UseMSP || getegid() != RunAsGid)) 3778 { 3779 syserr("drop_privileges: setgid(%d) failed", 3780 (int) RunAsGid); 3781 rval = EX_OSERR; 3782 } 3783 errno = 0; 3784 if (rval == EX_OK && getegid() != RunAsGid) 3785 { 3786 syserr("drop_privileges: Unable to set effective gid=%d to RunAsGid=%d", 3787 (int) getegid(), (int) RunAsGid); 3788 rval = EX_OSERR; 3789 } 3790 } 3791 3792 /* fiddle with uid */ 3793 if (to_real_uid || RunAsUid != 0) 3794 { 3795 uid_t euid; 3796 3797 /* 3798 ** Try to setuid(RunAsUid). 3799 ** euid must be RunAsUid, 3800 ** ruid must be RunAsUid unless (e|r)uid wasn't 0 3801 ** and we didn't have to drop privileges to the real uid. 3802 */ 3803 3804 if (setuid(RunAsUid) < 0 || 3805 geteuid() != RunAsUid || 3806 (getuid() != RunAsUid && 3807 (to_real_uid || geteuid() == 0 || getuid() == 0))) 3808 { 3809 #if HASSETREUID 3810 /* 3811 ** if ruid != RunAsUid, euid == RunAsUid, then 3812 ** try resetting just the real uid, then using 3813 ** setuid() to drop the saved-uid as well. 3814 */ 3815 3816 if (geteuid() == RunAsUid) 3817 { 3818 if (setreuid(RunAsUid, -1) < 0) 3819 { 3820 syserr("drop_privileges: setreuid(%d, -1) failed", 3821 (int) RunAsUid); 3822 rval = EX_OSERR; 3823 } 3824 if (setuid(RunAsUid) < 0) 3825 { 3826 syserr("drop_privileges: second setuid(%d) attempt failed", 3827 (int) RunAsUid); 3828 rval = EX_OSERR; 3829 } 3830 } 3831 else 3832 #endif /* HASSETREUID */ 3833 { 3834 syserr("drop_privileges: setuid(%d) failed", 3835 (int) RunAsUid); 3836 rval = EX_OSERR; 3837 } 3838 } 3839 euid = geteuid(); 3840 if (RunAsUid != 0 && setuid(0) == 0) 3841 { 3842 /* 3843 ** Believe it or not, the Linux capability model 3844 ** allows a non-root process to override setuid() 3845 ** on a process running as root and prevent that 3846 ** process from dropping privileges. 3847 */ 3848 3849 syserr("drop_privileges: setuid(0) succeeded (when it should not)"); 3850 rval = EX_OSERR; 3851 } 3852 else if (RunAsUid != euid && setuid(euid) == 0) 3853 { 3854 /* 3855 ** Some operating systems will keep the saved-uid 3856 ** if a non-root effective-uid calls setuid(real-uid) 3857 ** making it possible to set it back again later. 3858 */ 3859 3860 syserr("drop_privileges: Unable to drop non-root set-user-ID privileges"); 3861 rval = EX_OSERR; 3862 } 3863 } 3864 3865 if ((to_real_uid || RunAsGid != 0) && 3866 rval == EX_OK && RunAsGid != EffGid && 3867 getuid() != 0 && geteuid() != 0) 3868 { 3869 errno = 0; 3870 if (setgid(EffGid) == 0) 3871 { 3872 syserr("drop_privileges: setgid(%d) succeeded (when it should not)", 3873 (int) EffGid); 3874 rval = EX_OSERR; 3875 } 3876 } 3877 3878 if (tTd(47, 5)) 3879 { 3880 sm_dprintf("drop_privileges: e/ruid = %d/%d e/rgid = %d/%d\n", 3881 (int) geteuid(), (int) getuid(), 3882 (int) getegid(), (int) getgid()); 3883 sm_dprintf("drop_privileges: RunAsUser = %d:%d\n", 3884 (int) RunAsUid, (int) RunAsGid); 3885 if (tTd(47, 10)) 3886 sm_dprintf("drop_privileges: rval = %d\n", rval); 3887 } 3888 return rval; 3889 } 3890 /* 3891 ** FILL_FD -- make sure a file descriptor has been properly allocated 3892 ** 3893 ** Used to make sure that stdin/out/err are allocated on startup 3894 ** 3895 ** Parameters: 3896 ** fd -- the file descriptor to be filled. 3897 ** where -- a string used for logging. If NULL, this is 3898 ** being called on startup, and logging should 3899 ** not be done. 3900 ** 3901 ** Returns: 3902 ** none 3903 ** 3904 ** Side Effects: 3905 ** possibly changes MissingFds 3906 */ 3907 3908 void 3909 fill_fd(fd, where) 3910 int fd; 3911 char *where; 3912 { 3913 int i; 3914 struct stat stbuf; 3915 3916 if (fstat(fd, &stbuf) >= 0 || errno != EBADF) 3917 return; 3918 3919 if (where != NULL) 3920 syserr("fill_fd: %s: fd %d not open", where, fd); 3921 else 3922 MissingFds |= 1 << fd; 3923 i = open(SM_PATH_DEVNULL, fd == 0 ? O_RDONLY : O_WRONLY, 0666); 3924 if (i < 0) 3925 { 3926 syserr("!fill_fd: %s: cannot open %s", 3927 where == NULL ? "startup" : where, SM_PATH_DEVNULL); 3928 } 3929 if (fd != i) 3930 { 3931 (void) dup2(i, fd); 3932 (void) close(i); 3933 } 3934 } 3935 /* 3936 ** SM_PRINTOPTIONS -- print options 3937 ** 3938 ** Parameters: 3939 ** options -- array of options. 3940 ** 3941 ** Returns: 3942 ** none. 3943 */ 3944 3945 static void 3946 sm_printoptions(options) 3947 char **options; 3948 { 3949 int ll; 3950 char **av; 3951 3952 av = options; 3953 ll = 7; 3954 while (*av != NULL) 3955 { 3956 if (ll + strlen(*av) > 63) 3957 { 3958 sm_dprintf("\n"); 3959 ll = 0; 3960 } 3961 if (ll == 0) 3962 sm_dprintf("\t\t"); 3963 else 3964 sm_dprintf(" "); 3965 sm_dprintf("%s", *av); 3966 ll += strlen(*av++) + 1; 3967 } 3968 sm_dprintf("\n"); 3969 } 3970 3971 /* 3972 ** TO8BIT -- convert \octal sequences in a test mode input line 3973 ** 3974 ** Parameters: 3975 ** str -- the input line. 3976 ** 3977 ** Returns: 3978 ** none. 3979 ** 3980 ** Side Effects: 3981 ** replaces \0octal in str with octal value. 3982 */ 3983 3984 static bool to8bit __P((char *)); 3985 3986 static bool 3987 to8bit(str) 3988 char *str; 3989 { 3990 int c, len; 3991 char *out, *in; 3992 bool changed; 3993 3994 if (str == NULL) 3995 return false; 3996 in = out = str; 3997 changed = false; 3998 len = 0; 3999 while ((c = (*str++ & 0377)) != '\0') 4000 { 4001 int oct, nxtc; 4002 4003 ++len; 4004 if (c == '\\' && 4005 (nxtc = (*str & 0377)) == '0') 4006 { 4007 oct = 0; 4008 while ((nxtc = (*str & 0377)) != '\0' && 4009 isascii(nxtc) && isdigit(nxtc)) 4010 { 4011 oct <<= 3; 4012 oct += nxtc - '0'; 4013 ++str; 4014 ++len; 4015 } 4016 changed = true; 4017 c = oct; 4018 } 4019 *out++ = c; 4020 } 4021 *out++ = c; 4022 if (changed) 4023 { 4024 char *q; 4025 4026 q = quote_internal_chars(in, in, &len); 4027 if (q != in) 4028 sm_strlcpy(in, q, len); 4029 } 4030 return changed; 4031 } 4032 4033 /* 4034 ** TESTMODELINE -- process a test mode input line 4035 ** 4036 ** Parameters: 4037 ** line -- the input line. 4038 ** e -- the current environment. 4039 ** Syntax: 4040 ** # a comment 4041 ** .X process X as a configuration line 4042 ** =X dump a configuration item (such as mailers) 4043 ** $X dump a macro or class 4044 ** /X try an activity 4045 ** X normal process through rule set X 4046 */ 4047 4048 static void 4049 testmodeline(line, e) 4050 char *line; 4051 ENVELOPE *e; 4052 { 4053 register char *p; 4054 char *q; 4055 auto char *delimptr; 4056 int mid; 4057 int i, rs; 4058 STAB *map; 4059 char **s; 4060 struct rewrite *rw; 4061 ADDRESS a; 4062 char *lbp; 4063 auto int lbs; 4064 static int tryflags = RF_COPYNONE; 4065 char exbuf[MAXLINE]; 4066 char lbuf[MAXLINE]; 4067 extern unsigned char TokTypeNoC[]; 4068 bool eightbit; 4069 4070 /* skip leading spaces */ 4071 while (*line == ' ') 4072 line++; 4073 4074 lbp = NULL; 4075 eightbit = false; 4076 switch (line[0]) 4077 { 4078 case '#': 4079 case '\0': 4080 return; 4081 4082 case '?': 4083 help("-bt", e); 4084 return; 4085 4086 case '.': /* config-style settings */ 4087 switch (line[1]) 4088 { 4089 case 'D': 4090 mid = macid_parse(&line[2], &delimptr); 4091 if (mid == 0) 4092 return; 4093 lbs = sizeof(lbuf); 4094 lbp = translate_dollars(delimptr, lbuf, &lbs); 4095 macdefine(&e->e_macro, A_TEMP, mid, lbp); 4096 if (lbp != lbuf) 4097 SM_FREE(lbp); 4098 break; 4099 4100 case 'C': 4101 if (line[2] == '\0') /* not to call syserr() */ 4102 return; 4103 4104 mid = macid_parse(&line[2], &delimptr); 4105 if (mid == 0) 4106 return; 4107 lbs = sizeof(lbuf); 4108 lbp = translate_dollars(delimptr, lbuf, &lbs); 4109 expand(lbp, exbuf, sizeof(exbuf), e); 4110 if (lbp != lbuf) 4111 SM_FREE(lbp); 4112 p = exbuf; 4113 while (*p != '\0') 4114 { 4115 register char *wd; 4116 char delim; 4117 4118 while (*p != '\0' && isascii(*p) && isspace(*p)) 4119 p++; 4120 wd = p; 4121 while (*p != '\0' && !(isascii(*p) && isspace(*p))) 4122 p++; 4123 delim = *p; 4124 *p = '\0'; 4125 if (wd[0] != '\0') 4126 setclass(mid, wd); 4127 *p = delim; 4128 } 4129 break; 4130 4131 case '\0': 4132 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4133 "Usage: .[DC]macro value(s)\n"); 4134 break; 4135 4136 default: 4137 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4138 "Unknown \".\" command %s\n", line); 4139 break; 4140 } 4141 return; 4142 4143 case '=': /* config-style settings */ 4144 switch (line[1]) 4145 { 4146 case 'S': /* dump rule set */ 4147 rs = strtorwset(&line[2], NULL, ST_FIND); 4148 if (rs < 0) 4149 { 4150 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4151 "Undefined ruleset %s\n", &line[2]); 4152 return; 4153 } 4154 rw = RewriteRules[rs]; 4155 if (rw == NULL) 4156 return; 4157 do 4158 { 4159 (void) sm_io_putc(smioout, SM_TIME_DEFAULT, 4160 'R'); 4161 s = rw->r_lhs; 4162 while (*s != NULL) 4163 { 4164 xputs(smioout, *s++); 4165 (void) sm_io_putc(smioout, 4166 SM_TIME_DEFAULT, ' '); 4167 } 4168 (void) sm_io_putc(smioout, SM_TIME_DEFAULT, 4169 '\t'); 4170 (void) sm_io_putc(smioout, SM_TIME_DEFAULT, 4171 '\t'); 4172 s = rw->r_rhs; 4173 while (*s != NULL) 4174 { 4175 xputs(smioout, *s++); 4176 (void) sm_io_putc(smioout, 4177 SM_TIME_DEFAULT, ' '); 4178 } 4179 (void) sm_io_putc(smioout, SM_TIME_DEFAULT, 4180 '\n'); 4181 } while ((rw = rw->r_next) != NULL); 4182 break; 4183 4184 case 'M': 4185 for (i = 0; i < MAXMAILERS; i++) 4186 { 4187 if (Mailer[i] != NULL) 4188 printmailer(smioout, Mailer[i]); 4189 } 4190 break; 4191 4192 case '\0': 4193 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4194 "Usage: =Sruleset or =M\n"); 4195 break; 4196 4197 default: 4198 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4199 "Unknown \"=\" command %s\n", line); 4200 break; 4201 } 4202 return; 4203 4204 case '-': /* set command-line-like opts */ 4205 switch (line[1]) 4206 { 4207 case 'd': 4208 tTflag(&line[2]); 4209 break; 4210 4211 case '\0': 4212 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4213 "Usage: -d{debug arguments}\n"); 4214 break; 4215 4216 default: 4217 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4218 "Unknown \"-\" command %s\n", line); 4219 break; 4220 } 4221 return; 4222 4223 case '$': 4224 if (line[1] == '=') 4225 { 4226 mid = macid(&line[2]); 4227 if (mid != 0) 4228 stabapply(dump_class, mid); 4229 return; 4230 } 4231 mid = macid(&line[1]); 4232 if (mid == 0) 4233 return; 4234 p = macvalue(mid, e); 4235 if (p == NULL) 4236 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4237 "Undefined\n"); 4238 else 4239 { 4240 xputs(smioout, p); 4241 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4242 "\n"); 4243 } 4244 return; 4245 4246 case '/': /* miscellaneous commands */ 4247 p = &line[strlen(line)]; 4248 while (--p >= line && isascii(*p) && isspace(*p)) 4249 *p = '\0'; 4250 p = strpbrk(line, " \t"); 4251 if (p != NULL) 4252 { 4253 while (isascii(*p) && isspace(*p)) 4254 *p++ = '\0'; 4255 } 4256 else 4257 p = ""; 4258 if (line[1] == '\0') 4259 { 4260 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4261 "Usage: /[canon|map|mx|parse|try|tryflags]\n"); 4262 return; 4263 } 4264 if (sm_strcasecmp(&line[1], "quit") == 0) 4265 { 4266 CurEnv->e_id = NULL; 4267 finis(true, true, ExitStat); 4268 /* NOTREACHED */ 4269 } 4270 if (sm_strcasecmp(&line[1], "mx") == 0) 4271 { 4272 #if NAMED_BIND 4273 /* look up MX records */ 4274 int nmx; 4275 auto int rcode; 4276 char *mxhosts[MAXMXHOSTS + 1]; 4277 4278 if (*p == '\0') 4279 { 4280 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4281 "Usage: /mx address\n"); 4282 return; 4283 } 4284 nmx = getmxrr(p, mxhosts, NULL, false, &rcode, true, 4285 NULL); 4286 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4287 "getmxrr(%s) returns %d value(s):\n", 4288 p, nmx); 4289 for (i = 0; i < nmx; i++) 4290 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4291 "\t%s\n", mxhosts[i]); 4292 #else /* NAMED_BIND */ 4293 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4294 "No MX code compiled in\n"); 4295 #endif /* NAMED_BIND */ 4296 } 4297 else if (sm_strcasecmp(&line[1], "canon") == 0) 4298 { 4299 char host[MAXHOSTNAMELEN]; 4300 4301 if (*p == '\0') 4302 { 4303 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4304 "Usage: /canon address\n"); 4305 return; 4306 } 4307 else if (sm_strlcpy(host, p, sizeof(host)) >= sizeof(host)) 4308 { 4309 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4310 "Name too long\n"); 4311 return; 4312 } 4313 (void) getcanonname(host, sizeof(host), !HasWildcardMX, 4314 NULL); 4315 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4316 "getcanonname(%s) returns %s\n", 4317 p, host); 4318 } 4319 else if (sm_strcasecmp(&line[1], "map") == 0) 4320 { 4321 auto int rcode = EX_OK; 4322 char *av[2]; 4323 4324 if (*p == '\0') 4325 { 4326 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4327 "Usage: /map mapname key\n"); 4328 return; 4329 } 4330 for (q = p; *q != '\0' && !(isascii(*q) && isspace(*q)); q++) 4331 continue; 4332 if (*q == '\0') 4333 { 4334 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4335 "No key specified\n"); 4336 return; 4337 } 4338 *q++ = '\0'; 4339 map = stab(p, ST_MAP, ST_FIND); 4340 if (map == NULL) 4341 { 4342 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4343 "Map named \"%s\" not found\n", p); 4344 return; 4345 } 4346 if (!bitset(MF_OPEN, map->s_map.map_mflags) && 4347 !openmap(&(map->s_map))) 4348 { 4349 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4350 "Map named \"%s\" not open\n", p); 4351 return; 4352 } 4353 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4354 "map_lookup: %s (%s) ", p, q); 4355 av[0] = q; 4356 av[1] = NULL; 4357 p = (*map->s_map.map_class->map_lookup) 4358 (&map->s_map, q, av, &rcode); 4359 if (p == NULL) 4360 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4361 "no match (%d)\n", 4362 rcode); 4363 else 4364 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4365 "returns %s (%d)\n", p, 4366 rcode); 4367 } 4368 else if (sm_strcasecmp(&line[1], "try") == 0) 4369 { 4370 MAILER *m; 4371 STAB *st; 4372 auto int rcode = EX_OK; 4373 4374 q = strpbrk(p, " \t"); 4375 if (q != NULL) 4376 { 4377 while (isascii(*q) && isspace(*q)) 4378 *q++ = '\0'; 4379 } 4380 if (q == NULL || *q == '\0') 4381 { 4382 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4383 "Usage: /try mailer address\n"); 4384 return; 4385 } 4386 st = stab(p, ST_MAILER, ST_FIND); 4387 if (st == NULL) 4388 { 4389 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4390 "Unknown mailer %s\n", p); 4391 return; 4392 } 4393 m = st->s_mailer; 4394 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4395 "Trying %s %s address %s for mailer %s\n", 4396 bitset(RF_HEADERADDR, tryflags) ? "header" 4397 : "envelope", 4398 bitset(RF_SENDERADDR, tryflags) ? "sender" 4399 : "recipient", q, p); 4400 p = remotename(q, m, tryflags, &rcode, CurEnv); 4401 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4402 "Rcode = %d, addr = %s\n", 4403 rcode, p == NULL ? "<NULL>" : p); 4404 e->e_to = NULL; 4405 } 4406 else if (sm_strcasecmp(&line[1], "tryflags") == 0) 4407 { 4408 if (*p == '\0') 4409 { 4410 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4411 "Usage: /tryflags [Hh|Ee][Ss|Rr]\n"); 4412 return; 4413 } 4414 for (; *p != '\0'; p++) 4415 { 4416 switch (*p) 4417 { 4418 case 'H': 4419 case 'h': 4420 tryflags |= RF_HEADERADDR; 4421 break; 4422 4423 case 'E': 4424 case 'e': 4425 tryflags &= ~RF_HEADERADDR; 4426 break; 4427 4428 case 'S': 4429 case 's': 4430 tryflags |= RF_SENDERADDR; 4431 break; 4432 4433 case 'R': 4434 case 'r': 4435 tryflags &= ~RF_SENDERADDR; 4436 break; 4437 } 4438 } 4439 exbuf[0] = bitset(RF_HEADERADDR, tryflags) ? 'h' : 'e'; 4440 exbuf[1] = ' '; 4441 exbuf[2] = bitset(RF_SENDERADDR, tryflags) ? 's' : 'r'; 4442 exbuf[3] = '\0'; 4443 macdefine(&e->e_macro, A_TEMP, 4444 macid("{addr_type}"), exbuf); 4445 } 4446 else if (sm_strcasecmp(&line[1], "parse") == 0) 4447 { 4448 if (*p == '\0') 4449 { 4450 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4451 "Usage: /parse address\n"); 4452 return; 4453 } 4454 q = crackaddr(p, e); 4455 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4456 "Cracked address = "); 4457 xputs(smioout, q); 4458 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4459 "\nParsing %s %s address\n", 4460 bitset(RF_HEADERADDR, tryflags) ? 4461 "header" : "envelope", 4462 bitset(RF_SENDERADDR, tryflags) ? 4463 "sender" : "recipient"); 4464 if (parseaddr(p, &a, tryflags, '\0', NULL, e, true) 4465 == NULL) 4466 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4467 "Cannot parse\n"); 4468 else if (a.q_host != NULL && a.q_host[0] != '\0') 4469 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4470 "mailer %s, host %s, user %s\n", 4471 a.q_mailer->m_name, 4472 a.q_host, 4473 a.q_user); 4474 else 4475 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4476 "mailer %s, user %s\n", 4477 a.q_mailer->m_name, 4478 a.q_user); 4479 e->e_to = NULL; 4480 } 4481 else if (sm_strcasecmp(&line[1], "header") == 0) 4482 { 4483 unsigned long ul; 4484 4485 ul = chompheader(p, CHHDR_CHECK|CHHDR_USER, NULL, e); 4486 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4487 "ul = %lu\n", ul); 4488 } 4489 #if NETINET || NETINET6 4490 else if (sm_strcasecmp(&line[1], "gethostbyname") == 0) 4491 { 4492 int family = AF_INET; 4493 4494 q = strpbrk(p, " \t"); 4495 if (q != NULL) 4496 { 4497 while (isascii(*q) && isspace(*q)) 4498 *q++ = '\0'; 4499 # if NETINET6 4500 if (*q != '\0' && (strcmp(q, "inet6") == 0 || 4501 strcmp(q, "AAAA") == 0)) 4502 family = AF_INET6; 4503 # endif /* NETINET6 */ 4504 } 4505 (void) sm_gethostbyname(p, family); 4506 } 4507 #endif /* NETINET || NETINET6 */ 4508 else 4509 { 4510 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4511 "Unknown \"/\" command %s\n", 4512 line); 4513 } 4514 (void) sm_io_flush(smioout, SM_TIME_DEFAULT); 4515 return; 4516 } 4517 4518 for (p = line; isascii(*p) && isspace(*p); p++) 4519 continue; 4520 q = p; 4521 while (*p != '\0' && !(isascii(*p) && isspace(*p))) 4522 p++; 4523 if (*p == '\0') 4524 { 4525 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4526 "No address!\n"); 4527 return; 4528 } 4529 *p = '\0'; 4530 if (tTd(23, 101)) 4531 eightbit = to8bit(p + 1); 4532 if (invalidaddr(p + 1, NULL, true)) 4533 return; 4534 do 4535 { 4536 register char **pvp; 4537 char pvpbuf[PSBUFSIZE]; 4538 4539 pvp = prescan(++p, ',', pvpbuf, sizeof(pvpbuf), &delimptr, 4540 ConfigLevel >= 9 ? TokTypeNoC : ExtTokenTab, false); 4541 if (pvp == NULL) 4542 continue; 4543 p = q; 4544 while (*p != '\0') 4545 { 4546 int status; 4547 4548 rs = strtorwset(p, NULL, ST_FIND); 4549 if (rs < 0) 4550 { 4551 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4552 "Undefined ruleset %s\n", 4553 p); 4554 break; 4555 } 4556 status = REWRITE(pvp, rs, e); 4557 if (status != EX_OK) 4558 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4559 "== Ruleset %s (%d) status %d\n", 4560 p, rs, status); 4561 else if (eightbit) 4562 { 4563 cataddr(pvp, NULL, exbuf, sizeof(exbuf), '\0', 4564 true); 4565 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4566 "cataddr: %s\n", 4567 str2prt(exbuf)); 4568 } 4569 while (*p != '\0' && *p++ != ',') 4570 continue; 4571 } 4572 } while (*(p = delimptr) != '\0'); 4573 (void) sm_io_flush(smioout, SM_TIME_DEFAULT); 4574 } 4575 4576 static void 4577 dump_class(s, id) 4578 register STAB *s; 4579 int id; 4580 { 4581 if (s->s_symtype != ST_CLASS) 4582 return; 4583 if (bitnset(bitidx(id), s->s_class)) 4584 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 4585 "%s\n", s->s_name); 4586 } 4587 4588 /* 4589 ** An exception type used to create QuickAbort exceptions. 4590 ** This is my first cut at converting QuickAbort from longjmp to exceptions. 4591 ** These exceptions have a single integer argument, which is the argument 4592 ** to longjmp in the original code (either 1 or 2). I don't know the 4593 ** significance of 1 vs 2: the calls to setjmp don't care. 4594 */ 4595 4596 const SM_EXC_TYPE_T EtypeQuickAbort = 4597 { 4598 SmExcTypeMagic, 4599 "E:mta.quickabort", 4600 "i", 4601 sm_etype_printf, 4602 "quick abort %0", 4603 }; 4604