开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Email客户端 > 查看源码
readcf.c
资源名称：sendmail.8.10.0.Beta10.tar.Z　[点击查看]
上传用户：xu_441
上传日期：2007-01-04
资源大小：1640k
文件大小：74k
源码类别：

Email客户端

开发平台：

Unix_Linux

readcf.c：源码内容
  1. /*
  2.  * Copyright (c) 1998, 1999 Sendmail, Inc. and its suppliers.
  3.  * All rights reserved.
  4.  * Copyright (c) 1983, 1995-1997 Eric P. Allman.  All rights reserved.
  5.  * Copyright (c) 1988, 1993
  6.  * The Regents of the University of California.  All rights reserved.
  7.  *
  8.  * By using this file, you agree to the terms and conditions set
  9.  * forth in the LICENSE file which can be found at the top level of
  10.  * the sendmail distribution.
  11.  *
  12.  */
  14. #ifndef lint
  15. static char id[] = "@(#)$Id: readcf.c,v 8.362 1999/12/06 22:50:53 gshapiro Exp $";
  16. #endif /* ! lint */
  18. #include <sendmail.h>
  19. #if NETINET || NETINET6
  20. # include <arpa/inet.h>
  21. #endif /* NETINET || NETINET6 */
  23. #define SECONDS
  24. #define MINUTES * 60
  25. #define HOUR * 3600
  26. #define HOURS HOUR
  28. static void fileclass __P((int, char *, char *, bool, bool));
  29. static char **makeargv __P((char *));
  30. static void settimeout __P((char *, char *, bool));
  31. static void toomany __P((int, int));
  32. static char *munchstring __P((char *, char **, int));
  34. /*
  35. **  READCF -- read configuration file.
  36. **
  37. ** This routine reads the configuration file and builds the internal
  38. ** form.
  39. **
  40. ** The file is formatted as a sequence of lines, each taken
  41. ** atomically.  The first character of each line describes how
  42. ** the line is to be interpreted.  The lines are:
  43. ** Dxval Define macro x to have value val.
  44. ** Cxword Put word into class x.
  45. ** Fxfile [fmt] Read file for lines to put into
  46. ** class x.  Use scanf string 'fmt'
  47. ** or "%s" if not present.  Fmt should
  48. ** only produce one string-valued result.
  49. ** Hname: value Define header with field-name 'name'
  50. ** and value as specified; this will be
  51. ** macro expanded immediately before
  52. ** use.
  53. ** Sn Use rewriting set n.
  54. ** Rlhs rhs Rewrite addresses that match lhs to
  55. ** be rhs.
  56. ** Mn arg=val... Define mailer.  n is the internal name.
  57. ** Args specify mailer parameters.
  58. ** Oxvalue Set option x to value.
  59. ** Pname=value Set precedence name to value.
  60. ** Vversioncode[/vendorcode]
  61. ** Version level/vendor name of
  62. ** configuration syntax.
  63. ** Kmapname mapclass arguments....
  64. ** Define keyed lookup of a given class.
  65. ** Arguments are class dependent.
  66. ** Eenvar=value Set the environment value to the given value.
  67. **
  68. ** Parameters:
  69. ** cfname -- configuration file name.
  70. ** safe -- TRUE if this is the system config file;
  71. ** FALSE otherwise.
  72. ** e -- the main envelope.
  73. **
  74. ** Returns:
  75. ** none.
  76. **
  77. ** Side Effects:
  78. ** Builds several internal tables.
  79. */
  81. void
  82. readcf(cfname, safe, e)
  83. char *cfname;
  84. bool safe;
  85. register ENVELOPE *e;
  86. {
  87. FILE *cf;
  88. int ruleset = -1;
  89. char *q;
  90. struct rewrite *rwp = NULL;
  91. char *bp;
  92. auto char *ep;
  93. int nfuzzy;
  94. char *file;
  95. bool optional;
  96. int mid;
  97. int chompflags;
  98. register char *p;
  99. long sff = SFF_OPENASROOT;
  100. struct stat statb;
  101. char buf[MAXLINE];
  102. char exbuf[MAXLINE];
  103. char pvpbuf[MAXLINE + MAXATOM];
  104. static char *null_list[1] = { NULL };
  105. extern u_char TokTypeNoC[];
  107. FileName = cfname;
  108. LineNumber = 0;
  110. if (DontLockReadFiles)
  111. sff |= SFF_NOLOCK;
  112. cf = safefopen(cfname, O_RDONLY, 0444, sff);
  113. if (cf == NULL)
  114. {
  115. syserr("cannot open");
  116. finis(FALSE, EX_OSFILE);
  117. }
  119. if (fstat(fileno(cf), &statb) < 0)
  120. {
  121. syserr("cannot fstat");
  122. finis(FALSE, EX_OSFILE);
  123. }
  125. if (!S_ISREG(statb.st_mode))
  126. {
  127. syserr("not a plain file");
  128. finis(FALSE, EX_OSFILE);
  129. }
  131. if (OpMode != MD_TEST && bitset(S_IWGRP|S_IWOTH, statb.st_mode))
  132. {
  133. if (OpMode == MD_DAEMON || OpMode == MD_INITALIAS)
  134. fprintf(stderr, "%s: WARNING: dangerous write permissionsn",
  135. FileName);
  136. if (LogLevel > 0)
  137. sm_syslog(LOG_CRIT, NOQID,
  138.   "%s: WARNING: dangerous write permissions",
  139.   FileName);
  140. }
  142. #ifdef XLA
  143. xla_zero();
  144. #endif /* XLA */
  146. while ((bp = fgetfolded(buf, sizeof buf, cf)) != NULL)
  147. {
  148. if (bp[0] == '#')
  149. {
  150. if (bp != buf)
  151. free(bp);
  152. continue;
  153. }
  155. /* do macro expansion mappings */
  156. translate_dollars(bp);
  158. /* interpret this line */
  159. errno = 0;
  160. switch (bp[0])
  161. {
  162.   case '':
  163.   case '#': /* comment */
  164. break;
  166.   case 'R': /* rewriting rule */
  167. if (ruleset < 0)
  168. {
  169. syserr("missing valid ruleset for "%s"", bp);
  170. break;
  171. }
  172. for (p = &bp[1]; *p != '' && *p != 't'; p++)
  173. continue;
  175. if (*p == '')
  176. {
  177. syserr("invalid rewrite line "%s" (tab expected)", bp);
  178. break;
  179. }
  181. /* allocate space for the rule header */
  182. if (rwp == NULL)
  183. {
  184. RewriteRules[ruleset] = rwp =
  185. (struct rewrite *) xalloc(sizeof *rwp);
  186. }
  187. else
  188. {
  189. rwp->r_next = (struct rewrite *) xalloc(sizeof *rwp);
  190. rwp = rwp->r_next;
  191. }
  192. rwp->r_next = NULL;
  194. /* expand and save the LHS */
  195. *p = '';
  196. expand(&bp[1], exbuf, sizeof exbuf, e);
  197. rwp->r_lhs = prescan(exbuf, 't', pvpbuf,
  198.      sizeof pvpbuf, NULL,
  199.      ConfigLevel >= 9 ? TokTypeNoC : NULL);
  200. nfuzzy = 0;
  201. if (rwp->r_lhs != NULL)
  202. {
  203. register char **ap;
  205. rwp->r_lhs = copyplist(rwp->r_lhs, TRUE);
  207. /* count the number of fuzzy matches in LHS */
  208. for (ap = rwp->r_lhs; *ap != NULL; ap++)
  209. {
  210. char *botch;
  212. botch = NULL;
  213. switch (**ap & 0377)
  214. {
  215.   case MATCHZANY:
  216.   case MATCHANY:
  217.   case MATCHONE:
  218.   case MATCHCLASS:
  219.   case MATCHNCLASS:
  220. nfuzzy++;
  221. break;
  223.   case MATCHREPL:
  224. botch = "$0-$9";
  225. break;
  227.   case CANONUSER:
  228. botch = "$:";
  229. break;
  231.   case CALLSUBR:
  232. botch = "$>";
  233. break;
  235.   case CONDIF:
  236. botch = "$?";
  237. break;
  239.   case CONDFI:
  240. botch = "$.";
  241. break;
  243.   case HOSTBEGIN:
  244. botch = "$[";
  245. break;
  247.   case HOSTEND:
  248. botch = "$]";
  249. break;
  251.   case LOOKUPBEGIN:
  252. botch = "$(";
  253. break;
  255.   case LOOKUPEND:
  256. botch = "$)";
  257. break;
  258. }
  259. if (botch != NULL)
  260. syserr("Inappropriate use of %s on LHS",
  261. botch);
  262. }
  263. rwp->r_line = LineNumber;
  264. }
  265. else
  266. {
  267. syserr("R line: null LHS");
  268. rwp->r_lhs = null_list;
  269. }
  271. /* expand and save the RHS */
  272. while (*++p == 't')
  273. continue;
  274. q = p;
  275. while (*p != '' && *p != 't')
  276. p++;
  277. *p = '';
  278. expand(q, exbuf, sizeof exbuf, e);
  279. rwp->r_rhs = prescan(exbuf, 't', pvpbuf,
  280.      sizeof pvpbuf, NULL,
  281.      ConfigLevel >= 9 ? TokTypeNoC : NULL);
  282. if (rwp->r_rhs != NULL)
  283. {
  284. register char **ap;
  286. rwp->r_rhs = copyplist(rwp->r_rhs, TRUE);
  288. /* check no out-of-bounds replacements */
  289. nfuzzy += '0';
  290. for (ap = rwp->r_rhs; *ap != NULL; ap++)
  291. {
  292. char *botch;
  294. botch = NULL;
  295. switch (**ap & 0377)
  296. {
  297.   case MATCHREPL:
  298. if ((*ap)[1] <= '0' || (*ap)[1] > nfuzzy)
  299. {
  300. syserr("replacement $%c out of bounds",
  301. (*ap)[1]);
  302. }
  303. break;
  305.   case MATCHZANY:
  306. botch = "$*";
  307. break;
  309.   case MATCHANY:
  310. botch = "$+";
  311. break;
  313.   case MATCHONE:
  314. botch = "$-";
  315. break;
  317.   case MATCHCLASS:
  318. botch = "$=";
  319. break;
  321.   case MATCHNCLASS:
  322. botch = "$~";
  323. break;
  324. }
  325. if (botch != NULL)
  326. syserr("Inappropriate use of %s on RHS",
  327. botch);
  328. }
  329. }
  330. else
  331. {
  332. syserr("R line: null RHS");
  333. rwp->r_rhs = null_list;
  334. }
  335. break;
  337.   case 'S': /* select rewriting set */
  338. expand(&bp[1], exbuf, sizeof exbuf, e);
  339. ruleset = strtorwset(exbuf, NULL, ST_ENTER);
  340. if (ruleset < 0)
  341. break;
  343. rwp = RewriteRules[ruleset];
  344. if (rwp != NULL)
  345. {
  346. if (OpMode == MD_TEST)
  347. printf("WARNING: Ruleset %s has multiple definitionsn",
  348.        &bp[1]);
  349. if (tTd(37, 1))
  350. dprintf("WARNING: Ruleset %s has multiple definitionsn",
  351. &bp[1]);
  352. while (rwp->r_next != NULL)
  353. rwp = rwp->r_next;
  354. }
  355. break;
  357.   case 'D': /* macro definition */
  358. mid = macid(&bp[1], &ep);
  359. p = munchstring(ep, NULL, '');
  360. define(mid, newstr(p), e);
  361. break;
  363.   case 'H': /* required header line */
  364. chompflags = CHHDR_DEF;
  365. (void) chompheader(&bp[1], &chompflags, NULL, e);
  366. break;
  368.   case 'C': /* word class */
  369.   case 'T': /* trusted user (set class `t') */
  370. if (bp[0] == 'C')
  371. {
  372. mid = macid(&bp[1], &ep);
  373. expand(ep, exbuf, sizeof exbuf, e);
  374. p = exbuf;
  375. }
  376. else
  377. {
  378. mid = 't';
  379. p = &bp[1];
  380. }
  381. while (*p != '')
  382. {
  383. register char *wd;
  384. char delim;
  386. while (*p != '' && isascii(*p) && isspace(*p))
  387. p++;
  388. wd = p;
  389. while (*p != '' && !(isascii(*p) && isspace(*p)))
  390. p++;
  391. delim = *p;
  392. *p = '';
  393. if (wd[0] != '')
  394. setclass(mid, wd);
  395. *p = delim;
  396. }
  397. break;
  399.   case 'F': /* word class from file */
  400. mid = macid(&bp[1], &ep);
  401. for (p = ep; isascii(*p) && isspace(*p); )
  402. p++;
  403. if (p[0] == '-' && p[1] == 'o')
  404. {
  405. optional = TRUE;
  406. while (*p != '' && !(isascii(*p) && isspace(*p)))
  407. p++;
  408. while (isascii(*p) && isspace(*p))
  409. p++;
  410. }
  411. else
  412. optional = FALSE;
  413. file = p;
  414. if (*file == '|')
  415. p = "%s";
  416. else
  417. {
  418. while (*p != '' && !(isascii(*p) && isspace(*p)))
  419. p++;
  420. if (*p == '')
  421. p = "%s";
  422. else
  423. {
  424. *p = '';
  425. while (isascii(*++p) && isspace(*p))
  426. continue;
  427. }
  428. }
  429. fileclass(mid, file, p, safe, optional);
  430. break;
  432. #ifdef XLA
  433.   case 'L': /* extended load average description */
  434. xla_init(&bp[1]);
  435. break;
  436. #endif /* XLA */
  438. #if defined(SUN_EXTENSIONS) && defined(SUN_LOOKUP_MACRO)
  439.   case 'L': /* lookup macro */
  440.   case 'G': /* lookup class */
  441. /* reserved for Sun -- NIS+ database lookup */
  442. if (VendorCode != VENDOR_SUN)
  443. goto badline;
  444. sun_lg_config_line(bp, e);
  445. break;
  446. #endif /* defined(SUN_EXTENSIONS) && defined(SUN_LOOKUP_MACRO) */
  448.   case 'M': /* define mailer */
  449. makemailer(&bp[1]);
  450. break;
  452.   case 'O': /* set option */
  453. setoption(bp[1], &bp[2], safe, FALSE, e);
  454. break;
  456.   case 'P': /* set precedence */
  457. if (NumPriorities >= MAXPRIORITIES)
  458. {
  459. toomany('P', MAXPRIORITIES);
  460. break;
  461. }
  462. for (p = &bp[1]; *p != '' && *p != '='; p++)
  463. continue;
  464. if (*p == '')
  465. goto badline;
  466. *p = '';
  467. Priorities[NumPriorities].pri_name = newstr(&bp[1]);
  468. Priorities[NumPriorities].pri_val = atoi(++p);
  469. NumPriorities++;
  470. break;
  472.   case 'V': /* configuration syntax version */
  473. for (p = &bp[1]; isascii(*p) && isspace(*p); p++)
  474. continue;
  475. if (!isascii(*p) || !isdigit(*p))
  476. {
  477. syserr("invalid argument to V line: "%.20s"",
  478. &bp[1]);
  479. break;
  480. }
  481. ConfigLevel = strtol(p, &ep, 10);
  483. /*
  484. **  Do heuristic tweaking for back compatibility.
  485. */
  487. if (ConfigLevel >= 5)
  488. {
  489. /* level 5 configs have short name in $w */
  490. p = macvalue('w', e);
  491. if (p != NULL && (p = strchr(p, '.')) != NULL)
  492. *p = '';
  493. define('w', macvalue('w', e), e);
  494. }
  495. if (ConfigLevel >= 6)
  496. {
  497. ColonOkInAddr = FALSE;
  498. }
  500. /*
  501. **  Look for vendor code.
  502. */
  504. if (*ep++ == '/')
  505. {
  506. /* extract vendor code */
  507. for (p = ep; isascii(*p) && isalpha(*p); )
  508. p++;
  509. *p = '';
  511. if (!setvendor(ep))
  512. syserr("invalid V line vendor code: "%s"",
  513. ep);
  514. }
  515. break;
  517.   case 'K':
  518. expand(&bp[1], exbuf, sizeof exbuf, e);
  519. (void) makemapentry(exbuf);
  520. break;
  522.   case 'E':
  523. p = strchr(bp, '=');
  524. if (p != NULL)
  525. *p++ = '';
  526. setuserenv(&bp[1], p);
  527. break;
  530.   default:
  531.   badline:
  532. syserr("unknown configuration line "%s"", bp);
  533. }
  534. if (bp != buf)
  535. free(bp);
  536. }
  537. if (ferror(cf))
  538. {
  539. syserr("I/O read error");
  540. finis(FALSE, EX_OSFILE);
  541. }
  542. (void) fclose(cf);
  543. FileName = NULL;
  545. /* initialize host maps from local service tables */
  546. inithostmaps();
  548. /* initialize daemon (if not defined yet) */
  549. initdaemon();
  551. /* determine if we need to do special name-server frotz */
  552. {
  553. int nmaps;
  554. char *maptype[MAXMAPSTACK];
  555. short mapreturn[MAXMAPACTIONS];
  557. nmaps = switch_map_find("hosts", maptype, mapreturn);
  558. UseNameServer = FALSE;
  559. if (nmaps > 0 && nmaps <= MAXMAPSTACK)
  560. {
  561. register int mapno;
  563. for (mapno = 0; mapno < nmaps && !UseNameServer; mapno++)
  564. {
  565. if (strcmp(maptype[mapno], "dns") == 0)
  566. UseNameServer = TRUE;
  567. }
  568. }
  570. #ifdef HESIOD
  571. nmaps = switch_map_find("passwd", maptype, mapreturn);
  572. UseHesiod = FALSE;
  573. if (nmaps > 0 && nmaps <= MAXMAPSTACK)
  574. {
  575. register int mapno;
  577. for (mapno = 0; mapno < nmaps && !UseHesiod; mapno++)
  578. {
  579. if (strcmp(maptype[mapno], "hesiod") == 0)
  580. UseHesiod = TRUE;
  581. }
  582. }
  583. #endif /* HESIOD */
  584. }
  585. }
  586. /*
  587. **  TRANSLATE_DOLLARS -- convert $x into internal form
  588. **
  589. ** Actually does all appropriate pre-processing of a config line
  590. ** to turn it into internal form.
  591. **
  592. ** Parameters:
  593. ** bp -- the buffer to translate.
  594. **
  595. ** Returns:
  596. ** None.  The buffer is translated in place.  Since the
  597. ** translations always make the buffer shorter, this is
  598. ** safe without a size parameter.
  599. */
  601. void
  602. translate_dollars(bp)
  603. char *bp;
  604. {
  605. register char *p;
  606. auto char *ep;
  608. for (p = bp; *p != ''; p++)
  609. {
  610. if (*p == '#' && p > bp && ConfigLevel >= 3)
  611. {
  612. /* this is an on-line comment */
  613. register char *e;
  615. switch (*--p & 0377)
  616. {
  617.   case MACROEXPAND:
  618. /* it's from $# -- let it go through */
  619. p++;
  620. break;
  622.   case '\':
  623. /* it's backslash escaped */
  624. (void) strlcpy(p, p + 1, strlen(p));
  625. break;
  627.   default:
  628. /* delete leading white space */
  629. while (isascii(*p) && isspace(*p) &&
  630.        *p != 'n' && p > bp)
  631. p--;
  632. if ((e = strchr(++p, 'n')) != NULL)
  633. (void) strlcpy(p, e, strlen(p));
  634. else
  635. *p-- = '';
  636. break;
  637. }
  638. continue;
  639. }
  641. if (*p != '$' || p[1] == '')
  642. continue;
  644. if (p[1] == '$')
  645. {
  646. /* actual dollar sign.... */
  647. (void) strlcpy(p, p + 1, strlen(p));
  648. continue;
  649. }
  651. /* convert to macro expansion character */
  652. *p++ = MACROEXPAND;
  654. /* special handling for $=, $~, $&, and $? */
  655. if (*p == '=' || *p == '~' || *p == '&' || *p == '?')
  656. p++;
  658. /* convert macro name to code */
  659. *p = macid(p, &ep);
  660. if (ep != p + 1)
  661. (void) strlcpy(p + 1, ep, strlen(p + 1));
  662. }
  664. /* strip trailing white space from the line */
  665. while (--p > bp && isascii(*p) && isspace(*p))
  666. *p = '';
  667. }
  668. /*
  669. **  TOOMANY -- signal too many of some option
  670. **
  671. ** Parameters:
  672. ** id -- the id of the error line
  673. ** maxcnt -- the maximum possible values
  674. **
  675. ** Returns:
  676. ** none.
  677. **
  678. ** Side Effects:
  679. ** gives a syserr.
  680. */
  682. static void
  683. toomany(id, maxcnt)
  684. int id;
  685. int maxcnt;
  686. {
  687. syserr("too many %c lines, %d max", id, maxcnt);
  688. }
  689. /*
  690. **  FILECLASS -- read members of a class from a file
  691. **
  692. ** Parameters:
  693. ** class -- class to define.
  694. ** filename -- name of file to read.
  695. ** fmt -- scanf string to use for match.
  696. ** safe -- if set, this is a safe read.
  697. ** optional -- if set, it is not an error for the file to
  698. ** not exist.
  699. **
  700. ** Returns:
  701. ** none
  702. **
  703. ** Side Effects:
  704. **
  705. ** puts all lines in filename that match a scanf into
  706. ** the named class.
  707. */
  709. static void
  710. fileclass(class, filename, fmt, safe, optional)
  711. int class;
  712. char *filename;
  713. char *fmt;
  714. bool safe;
  715. bool optional;
  716. {
  717. FILE *f;
  718. long sff;
  719. pid_t pid;
  720. register char *p;
  721. char buf[MAXLINE];
  723. if (tTd(37, 2))
  724. dprintf("fileclass(%s, fmt=%s)n", filename, fmt);
  726. if (filename[0] == '|')
  727. {
  728. auto int fd;
  729. int i;
  730. char *argv[MAXPV + 1];
  732. i = 0;
  733. for (p = strtok(&filename[1], " t"); p != NULL; p = strtok(NULL, " t"))
  734. {
  735. if (i >= MAXPV)
  736. break;
  737. argv[i++] = p;
  738. }
  739. argv[i] = NULL;
  740. pid = prog_open(argv, &fd, CurEnv);
  741. if (pid < 0)
  742. f = NULL;
  743. else
  744. f = fdopen(fd, "r");
  745. }
  746. else
  747. {
  748. pid = -1;
  749. sff = SFF_REGONLY;
  750. if (!bitnset(DBS_CLASSFILEINUNSAFEDIRPATH, DontBlameSendmail))
  751. sff |= SFF_SAFEDIRPATH;
  752. if (!bitnset(DBS_LINKEDCLASSFILEINWRITABLEDIR,
  753.      DontBlameSendmail))
  754. sff |= SFF_NOWLINK;
  755. if (safe)
  756. sff |= SFF_OPENASROOT;
  757. if (DontLockReadFiles)
  758. sff |= SFF_NOLOCK;
  759. f = safefopen(filename, O_RDONLY, 0, sff);
  760. }
  761. if (f == NULL)
  762. {
  763. if (!optional)
  764. syserr("fileclass: cannot open %s", filename);
  765. return;
  766. }
  768. while (fgets(buf, sizeof buf, f) != NULL)
  769. {
  770. #if SCANF
  771. char wordbuf[MAXLINE + 1];
  772. #endif /* SCANF */
  774. if (buf[0] == '#')
  775. continue;
  776. #if SCANF
  777. if (sscanf(buf, fmt, wordbuf) != 1)
  778. continue;
  779. p = wordbuf;
  780. #else /* SCANF */
  781. p = buf;
  782. #endif /* SCANF */
  784. /*
  785. **  Break up the match into words.
  786. */
  788. while (*p != '')
  789. {
  790. register char *q;
  792. /* strip leading spaces */
  793. while (isascii(*p) && isspace(*p))
  794. p++;
  795. if (*p == '')
  796. break;
  798. /* find the end of the word */
  799. q = p;
  800. while (*p != '' && !(isascii(*p) && isspace(*p)))
  801. p++;
  802. if (*p != '')
  803. *p++ = '';
  805. /* enter the word in the symbol table */
  806. setclass(class, q);
  807. }
  808. }
  810. (void) fclose(f);
  811. if (pid > 0)
  812. (void) waitfor(pid);
  813. }
  814. /*
  815. **  MAKEMAILER -- define a new mailer.
  816. **
  817. ** Parameters:
  818. ** line -- description of mailer.  This is in labeled
  819. ** fields.  The fields are:
  820. **    A -- the argv for this mailer
  821. **    C -- the character set for MIME conversions
  822. **    D -- the directory to run in
  823. **    E -- the eol string
  824. **    F -- the flags associated with the mailer
  825. **    L -- the maximum line length
  826. **    M -- the maximum message size
  827. **    N -- the niceness at which to run
  828. **    P -- the path to the mailer
  829. **    R -- the recipient rewriting set
  830. **    S -- the sender rewriting set
  831. **    T -- the mailer type (for DSNs)
  832. **    U -- the uid to run as
  833. **    W -- the time to wait at the end
  834. ** The first word is the canonical name of the mailer.
  835. **
  836. ** Returns:
  837. ** none.
  838. **
  839. ** Side Effects:
  840. ** enters the mailer into the mailer table.
  841. */
  843. void
  844. makemailer(line)
  845. char *line;
  846. {
  847. register char *p;
  848. register struct mailer *m;
  849. register STAB *s;
  850. int i;
  851. char fcode;
  852. auto char *endp;
  853. extern int NextMailer;
  855. /* allocate a mailer and set up defaults */
  856. m = (struct mailer *) xalloc(sizeof *m);
  857. memset((char *) m, '', sizeof *m);
  859. /* collect the mailer name */
  860. for (p = line; *p != '' && *p != ',' && !(isascii(*p) && isspace(*p)); p++)
  861. continue;
  862. if (*p != '')
  863. *p++ = '';
  864. if (line[0] == '')
  865. syserr("name required for mailer");
  866. m->m_name = newstr(line);
  868. /* now scan through and assign info from the fields */
  869. while (*p != '')
  870. {
  871. auto char *delimptr;
  873. while (*p != '' && (*p == ',' || (isascii(*p) && isspace(*p))))
  874. p++;
  876. /* p now points to field code */
  877. fcode = *p;
  878. while (*p != '' && *p != '=' && *p != ',')
  879. p++;
  880. if (*p++ != '=')
  881. {
  882. syserr("mailer %s: `=' expected", m->m_name);
  883. return;
  884. }
  885. while (isascii(*p) && isspace(*p))
  886. p++;
  888. /* p now points to the field body */
  889. p = munchstring(p, &delimptr, ',');
  891. /* install the field into the mailer struct */
  892. switch (fcode)
  893. {
  894.   case 'P': /* pathname */
  895. if (*p == '')
  896. syserr("mailer %s: empty path name", m->m_name);
  897. m->m_mailer = newstr(p);
  898. break;
  900.   case 'F': /* flags */
  901. for (; *p != ''; p++)
  902. if (!(isascii(*p) && isspace(*p)))
  903. setbitn(*p, m->m_flags);
  904. break;
  906.   case 'S': /* sender rewriting ruleset */
  907.   case 'R': /* recipient rewriting ruleset */
  908. i = strtorwset(p, &endp, ST_ENTER);
  909. if (i < 0)
  910. return;
  911. if (fcode == 'S')
  912. m->m_sh_rwset = m->m_se_rwset = i;
  913. else
  914. m->m_rh_rwset = m->m_re_rwset = i;
  916. p = endp;
  917. if (*p++ == '/')
  918. {
  919. i = strtorwset(p, NULL, ST_ENTER);
  920. if (i < 0)
  921. return;
  922. if (fcode == 'S')
  923. m->m_sh_rwset = i;
  924. else
  925. m->m_rh_rwset = i;
  926. }
  927. break;
  929.   case 'E': /* end of line string */
  930. if (*p == '')
  931. syserr("mailer %s: null end-of-line string",
  932. m->m_name);
  933. m->m_eol = newstr(p);
  934. break;
  936.   case 'A': /* argument vector */
  937. if (*p == '')
  938. syserr("mailer %s: null argument vector",
  939. m->m_name);
  940. m->m_argv = makeargv(p);
  941. break;
  943.   case 'M': /* maximum message size */
  944. m->m_maxsize = atol(p);
  945. break;
  947.   case 'm': /* maximum messages per connection */
  948. m->m_maxdeliveries = atoi(p);
  949. break;
  951.   case 'L': /* maximum line length */
  952. m->m_linelimit = atoi(p);
  953. if (m->m_linelimit < 0)
  954. m->m_linelimit = 0;
  955. break;
  957.   case 'N': /* run niceness */
  958. m->m_nice = atoi(p);
  959. break;
  961.   case 'D': /* working directory */
  962. if (*p == '')
  963. syserr("mailer %s: null working directory",
  964. m->m_name);
  965. m->m_execdir = newstr(p);
  966. break;
  968.   case 'C': /* default charset */
  969. if (*p == '')
  970. syserr("mailer %s: null charset", m->m_name);
  971. m->m_defcharset = newstr(p);
  972. break;
  974.   case 'T': /* MTA-Name/Address/Diagnostic types */
  975. /* extract MTA name type; default to "dns" */
  976. m->m_mtatype = newstr(p);
  977. p = strchr(m->m_mtatype, '/');
  978. if (p != NULL)
  979. {
  980. *p++ = '';
  981. if (*p == '')
  982. p = NULL;
  983. }
  984. if (*m->m_mtatype == '')
  985. m->m_mtatype = "dns";
  987. /* extract address type; default to "rfc822" */
  988. m->m_addrtype = p;
  989. if (p != NULL)
  990. p = strchr(p, '/');
  991. if (p != NULL)
  992. {
  993. *p++ = '';
  994. if (*p == '')
  995. p = NULL;
  996. }
  997. if (m->m_addrtype == NULL || *m->m_addrtype == '')
  998. m->m_addrtype = "rfc822";
  1000. /* extract diagnostic type; default to "smtp" */
  1001. m->m_diagtype = p;
  1002. if (m->m_diagtype == NULL || *m->m_diagtype == '')
  1003. m->m_diagtype = "smtp";
  1004. break;
  1006.   case 'U': /* user id */
  1007. if (isascii(*p) && !isdigit(*p))
  1008. {
  1009. char *q = p;
  1010. struct passwd *pw;
  1012. while (*p != '' && isascii(*p) &&
  1013.        (isalnum(*p) || strchr("-_", *p) != NULL))
  1014. p++;
  1015. while (isascii(*p) && isspace(*p))
  1016. *p++ = '';
  1017. if (*p != '')
  1018. *p++ = '';
  1019. if (*q == '')
  1020. syserr("mailer %s: null user name",
  1021. m->m_name);
  1022. pw = sm_getpwnam(q);
  1023. if (pw == NULL)
  1024. syserr("readcf: mailer U= flag: unknown user %s", q);
  1025. else
  1026. {
  1027. m->m_uid = pw->pw_uid;
  1028. m->m_gid = pw->pw_gid;
  1029. }
  1030. }
  1031. else
  1032. {
  1033. auto char *q;
  1035. m->m_uid = strtol(p, &q, 0);
  1036. p = q;
  1037. while (isascii(*p) && isspace(*p))
  1038. p++;
  1039. if (*p != '')
  1040. p++;
  1041. }
  1042. while (isascii(*p) && isspace(*p))
  1043. p++;
  1044. if (*p == '')
  1045. break;
  1046. if (isascii(*p) && !isdigit(*p))
  1047. {
  1048. char *q = p;
  1049. struct group *gr;
  1051. while (isascii(*p) && isalnum(*p))
  1052. p++;
  1053. *p++ = '';
  1054. if (*q == '')
  1055. syserr("mailer %s: null group name",
  1056. m->m_name);
  1057. gr = getgrnam(q);
  1058. if (gr == NULL)
  1059. syserr("readcf: mailer U= flag: unknown group %s", q);
  1060. else
  1061. m->m_gid = gr->gr_gid;
  1062. }
  1063. else
  1064. {
  1065. m->m_gid = strtol(p, NULL, 0);
  1066. }
  1067. break;
  1069.   case 'W': /* wait timeout */
  1070. m->m_wait = convtime(p, 's');
  1071. break;
  1073.   case '/': /* new root directory */
  1074. if (*p == '')
  1075. syserr("mailer %s: null root directory",
  1076. m->m_name);
  1077. else
  1078. m->m_rootdir = newstr(p);
  1079. break;
  1081.   default:
  1082. syserr("M%s: unknown mailer equate %c=",
  1083.        m->m_name, fcode);
  1084. break;
  1085. }
  1087. p = delimptr;
  1088. }
  1090. /* do some rationality checking */
  1091. if (m->m_argv == NULL)
  1092. {
  1093. syserr("M%s: A= argument required", m->m_name);
  1094. return;
  1095. }
  1096. if (m->m_mailer == NULL)
  1097. {
  1098. syserr("M%s: P= argument required", m->m_name);
  1099. return;
  1100. }
  1102. if (NextMailer >= MAXMAILERS)
  1103. {
  1104. syserr("too many mailers defined (%d max)", MAXMAILERS);
  1105. return;
  1106. }
  1108. /* do some heuristic cleanup for back compatibility */
  1109. if (bitnset(M_LIMITS, m->m_flags))
  1110. {
  1111. if (m->m_linelimit == 0)
  1112. m->m_linelimit = SMTPLINELIM;
  1113. if (ConfigLevel < 2)
  1114. setbitn(M_7BITS, m->m_flags);
  1115. }
  1117. if (strcmp(m->m_mailer, "[TCP]") == 0)
  1118. {
  1119. #if _FFR_REMOVE_TCP_PATH
  1120. syserr("M%s: P=[TCP] is deprecated, use P=[IPC] insteadn",
  1121.        m->m_name);
  1122. #else /* _FFR_REMOVE_TCP_PATH */
  1123. printf("M%s: Warning: P=[TCP] is deprecated, use P=[IPC] insteadn",
  1124.        m->m_name);
  1125. #endif /* _FFR_REMOVE_TCP_PATH */
  1126. }
  1128. if (strcmp(m->m_mailer, "[IPC]") == 0 ||
  1129. #if !_FFR_REMOVE_TCP_MAILER_PATH
  1130.     strcmp(m->m_mailer, "[TCP]") == 0
  1131. #endif /* !_FFR_REMOVE_TCP_MAILER_PATH */
  1132.     )
  1133. {
  1134. /* Use the second argument for host or path to socket */
  1135. if (m->m_argv[0] == NULL || m->m_argv[1] == NULL ||
  1136.     m->m_argv[1][0] == '')
  1137. {
  1138. syserr("M%s: too few parameters for %s mailer",
  1139.        m->m_name, m->m_mailer);
  1140. }
  1141. if (strcmp(m->m_argv[0], "TCP") != 0 &&
  1142. #if NETUNIX
  1143.     strcmp(m->m_argv[0], "FILE") != 0 &&
  1144. #endif /* NETUNIX */
  1145. #if !_FFR_DEPRECATE_IPC_MAILER_ARG
  1146.     strcmp(m->m_argv[0], "IPC") != 0
  1147. #endif /* !_FFR_DEPRECATE_IPC_MAILER_ARG */
  1148.     )
  1149. {
  1150. printf("M%s: Warning: first argument in %s mailer must be %sn",
  1151.        m->m_name, m->m_mailer,
  1152. #if NETUNIX
  1153.        "TCP or FILE"
  1154. #else /* NETUNIX */
  1155.        "TCP"
  1156. #endif /* NETUNIX */
  1157.        );
  1158. }
  1160. }
  1161. else if (strcmp(m->m_mailer, "[FILE]") == 0)
  1162. {
  1163. /* Use the second argument for filename */
  1164. if (m->m_argv[0] == NULL || m->m_argv[1] == NULL ||
  1165.     m->m_argv[2] != NULL)
  1166. {
  1167. syserr("M%s: too %s parameters for [FILE] mailer",
  1168.        m->m_name,
  1169.        (m->m_argv[0] == NULL ||
  1170. m->m_argv[1] == NULL) ? "few" : "many");
  1171. }
  1172. else if (strcmp(m->m_argv[0], "FILE") != 0)
  1173. {
  1174. syserr("M%s: first argument in [FILE] mailer must be FILE",
  1175.        m->m_name);
  1176. }
  1177. }
  1179. if (strcmp(m->m_mailer, "[IPC]") == 0 ||
  1180.     strcmp(m->m_mailer, "[TCP]") == 0)
  1181. {
  1182. if (m->m_mtatype == NULL)
  1183. m->m_mtatype = "dns";
  1184. if (m->m_addrtype == NULL)
  1185. m->m_addrtype = "rfc822";
  1186. if (m->m_diagtype == NULL)
  1187. {
  1188. if (m->m_argv[0] != NULL &&
  1189.     strcmp(m->m_argv[0], "FILE") == 0)
  1190. m->m_diagtype = "x-unix";
  1191. else
  1192. m->m_diagtype = "smtp";
  1193. }
  1194. }
  1196. if (m->m_eol == NULL)
  1197. {
  1198. char **pp;
  1200. /* default for SMTP is rn; use n for local delivery */
  1201. for (pp = m->m_argv; *pp != NULL; pp++)
  1202. {
  1203. for (p = *pp; *p != ''; )
  1204. {
  1205. if ((*p++ & 0377) == MACROEXPAND && *p == 'u')
  1206. break;
  1207. }
  1208. if (*p != '')
  1209. break;
  1210. }
  1211. if (*pp == NULL)
  1212. m->m_eol = "rn";
  1213. else
  1214. m->m_eol = "n";
  1215. }
  1217. /* enter the mailer into the symbol table */
  1218. s = stab(m->m_name, ST_MAILER, ST_ENTER);
  1219. if (s->s_mailer != NULL)
  1220. {
  1221. i = s->s_mailer->m_mno;
  1222. free(s->s_mailer);
  1223. }
  1224. else
  1225. {
  1226. i = NextMailer++;
  1227. }
  1228. Mailer[i] = s->s_mailer = m;
  1229. m->m_mno = i;
  1230. }
  1231. /*
  1232. **  MUNCHSTRING -- translate a string into internal form.
  1233. **
  1234. ** Parameters:
  1235. ** p -- the string to munch.
  1236. ** delimptr -- if non-NULL, set to the pointer of the
  1237. ** field delimiter character.
  1238. ** delim -- the delimiter for the field.
  1239. **
  1240. ** Returns:
  1241. ** the munched string.
  1242. */
  1244. static char *
  1245. munchstring(p, delimptr, delim)
  1246. register char *p;
  1247. char **delimptr;
  1248. int delim;
  1249. {
  1250. register char *q;
  1251. bool backslash = FALSE;
  1252. bool quotemode = FALSE;
  1253. static char buf[MAXLINE];
  1255. for (q = buf; *p != '' && q < &buf[sizeof buf - 1]; p++)
  1256. {
  1257. if (backslash)
  1258. {
  1259. /* everything is roughly literal */
  1260. backslash = FALSE;
  1261. switch (*p)
  1262. {
  1263.   case 'r': /* carriage return */
  1264. *q++ = 'r';
  1265. continue;
  1267.   case 'n': /* newline */
  1268. *q++ = 'n';
  1269. continue;
  1271.   case 'f': /* form feed */
  1272. *q++ = 'f';
  1273. continue;
  1275.   case 'b': /* backspace */
  1276. *q++ = 'b';
  1277. continue;
  1278. }
  1279. *q++ = *p;
  1280. }
  1281. else
  1282. {
  1283. if (*p == '\')
  1284. backslash = TRUE;
  1285. else if (*p == '"')
  1286. quotemode = !quotemode;
  1287. else if (quotemode || *p != delim)
  1288. *q++ = *p;
  1289. else
  1290. break;
  1291. }
  1292. }
  1294. if (delimptr != NULL)
  1295. *delimptr = p;
  1296. *q++ = '';
  1297. return buf;
  1298. }
  1299. /*
  1300. **  MAKEARGV -- break up a string into words
  1301. **
  1302. ** Parameters:
  1303. ** p -- the string to break up.
  1304. **
  1305. ** Returns:
  1306. ** a char **argv (dynamically allocated)
  1307. **
  1308. ** Side Effects:
  1309. ** munges p.
  1310. */
  1312. static char **
  1313. makeargv(p)
  1314. register char *p;
  1315. {
  1316. char *q;
  1317. int i;
  1318. char **avp;
  1319. char *argv[MAXPV + 1];
  1321. /* take apart the words */
  1322. i = 0;
  1323. while (*p != '' && i < MAXPV)
  1324. {
  1325. q = p;
  1326. while (*p != '' && !(isascii(*p) && isspace(*p)))
  1327. p++;
  1328. while (isascii(*p) && isspace(*p))
  1329. *p++ = '';
  1330. argv[i++] = newstr(q);
  1331. }
  1332. argv[i++] = NULL;
  1334. /* now make a copy of the argv */
  1335. avp = (char **) xalloc(sizeof *avp * i);
  1336. memmove((char *) avp, (char *) argv, sizeof *avp * i);
  1338. return avp;
  1339. }
  1340. /*
  1341. **  PRINTRULES -- print rewrite rules (for debugging)
  1342. **
  1343. ** Parameters:
  1344. ** none.
  1345. **
  1346. ** Returns:
  1347. ** none.
  1348. **
  1349. ** Side Effects:
  1350. ** prints rewrite rules.
  1351. */
  1353. void
  1354. printrules()
  1355. {
  1356. register struct rewrite *rwp;
  1357. register int ruleset;
  1359. for (ruleset = 0; ruleset < 10; ruleset++)
  1360. {
  1361. if (RewriteRules[ruleset] == NULL)
  1362. continue;
  1363. printf("n----Rule Set %d:", ruleset);
  1365. for (rwp = RewriteRules[ruleset]; rwp != NULL; rwp = rwp->r_next)
  1366. {
  1367. printf("nLHS:");
  1368. printav(rwp->r_lhs);
  1369. printf("RHS:");
  1370. printav(rwp->r_rhs);
  1371. }
  1372. }
  1373. }
  1374. /*
  1375. **  PRINTMAILER -- print mailer structure (for debugging)
  1376. **
  1377. ** Parameters:
  1378. ** m -- the mailer to print
  1379. **
  1380. ** Returns:
  1381. ** none.
  1382. */
  1384. void
  1385. printmailer(m)
  1386. register MAILER *m;
  1387. {
  1388. int j;
  1390. printf("mailer %d (%s): P=%s S=", m->m_mno, m->m_name, m->m_mailer);
  1391. if (RuleSetNames[m->m_se_rwset] == NULL)
  1392. printf("%d/", m->m_se_rwset);
  1393. else
  1394. printf("%s/", RuleSetNames[m->m_se_rwset]);
  1395. if (RuleSetNames[m->m_sh_rwset] == NULL)
  1396. printf("%d R=", m->m_sh_rwset);
  1397. else
  1398. printf("%s R=", RuleSetNames[m->m_sh_rwset]);
  1399. if (RuleSetNames[m->m_re_rwset] == NULL)
  1400. printf("%d/", m->m_re_rwset);
  1401. else
  1402. printf("%s/", RuleSetNames[m->m_re_rwset]);
  1403. if (RuleSetNames[m->m_rh_rwset] == NULL)
  1404. printf("%d ", m->m_rh_rwset);
  1405. else
  1406. printf("%s ", RuleSetNames[m->m_rh_rwset]);
  1407. printf("M=%ld U=%d:%d F=", m->m_maxsize,
  1408.        (int) m->m_uid, (int) m->m_gid);
  1409. for (j = ''; j <= '177'; j++)
  1410. if (bitnset(j, m->m_flags))
  1411. (void) putchar(j);
  1412. printf(" L=%d E=", m->m_linelimit);
  1413. xputs(m->m_eol);
  1414. if (m->m_defcharset != NULL)
  1415. printf(" C=%s", m->m_defcharset);
  1416. printf(" T=%s/%s/%s",
  1417. m->m_mtatype == NULL ? "<undefined>" : m->m_mtatype,
  1418. m->m_addrtype == NULL ? "<undefined>" : m->m_addrtype,
  1419. m->m_diagtype == NULL ? "<undefined>" : m->m_diagtype);
  1420. if (m->m_argv != NULL)
  1421. {
  1422. char **a = m->m_argv;
  1424. printf(" A=");
  1425. while (*a != NULL)
  1426. {
  1427. if (a != m->m_argv)
  1428. printf(" ");
  1429. xputs(*a++);
  1430. }
  1431. }
  1432. printf("n");
  1433. }
  1434. /*
  1435. **  SETOPTION -- set global processing option
  1436. **
  1437. ** Parameters:
  1438. ** opt -- option name.
  1439. ** val -- option value (as a text string).
  1440. ** safe -- set if this came from a configuration file.
  1441. ** Some options (if set from the command line) will
  1442. ** reset the user id to avoid security problems.
  1443. ** sticky -- if set, don't let other setoptions override
  1444. ** this value.
  1445. ** e -- the main envelope.
  1446. **
  1447. ** Returns:
  1448. ** none.
  1449. **
  1450. ** Side Effects:
  1451. ** Sets options as implied by the arguments.
  1452. */
  1454. static BITMAP256 StickyOpt; /* set if option is stuck */
  1456. #if NAMED_BIND
  1458. static struct resolverflags
  1459. {
  1460. char *rf_name; /* name of the flag */
  1461. long rf_bits; /* bits to set/clear */
  1462. } ResolverFlags[] =
  1463. {
  1464. { "debug", RES_DEBUG },
  1465. { "aaonly", RES_AAONLY },
  1466. { "usevc", RES_USEVC },
  1467. { "primary", RES_PRIMARY },
  1468. { "igntc", RES_IGNTC },
  1469. { "recurse", RES_RECURSE },
  1470. { "defnames", RES_DEFNAMES },
  1471. { "stayopen", RES_STAYOPEN },
  1472. { "dnsrch", RES_DNSRCH },
  1473. { "true", 0 }, /* avoid error on old syntax */
  1474. { NULL, 0 }
  1475. };
  1477. #endif /* NAMED_BIND */
  1479. #define OI_NONE 0 /* no special treatment */
  1480. #define OI_SAFE 0x0001 /* safe for random people to use */
  1481. #define OI_SUBOPT 0x0002 /* option has suboptions */
  1483. static struct optioninfo
  1484. {
  1485. char *o_name; /* long name of option */
  1486. u_char o_code; /* short name of option */
  1487. u_short o_flags; /* option flags */
  1488. } OptionTab[] =
  1489. {
  1490. #if defined(SUN_EXTENSIONS) && defined(REMOTE_MODE)
  1491. { "RemoteMode", '>', OI_NONE },
  1492. #endif /* defined(SUN_EXTENSIONS) && defined(REMOTE_MODE) */
  1493. { "SevenBitInput", '7', OI_SAFE },
  1494. #if MIME8TO7
  1495. { "EightBitMode", '8', OI_SAFE },
  1496. #endif /* MIME8TO7 */
  1497. { "AliasFile", 'A', OI_NONE },
  1498. { "AliasWait", 'a', OI_NONE },
  1499. { "BlankSub", 'B', OI_NONE },
  1500. { "MinFreeBlocks", 'b', OI_SAFE },
  1501. { "CheckpointInterval", 'C', OI_SAFE },
  1502. { "HoldExpensive", 'c', OI_NONE },
  1503. #if !_FFR_REMOVE_AUTOREBUILD
  1504. { "AutoRebuildAliases", 'D', OI_NONE },
  1505. #endif /* !_FFR_REMOVE_AUTOREBUILD */
  1506. { "DeliveryMode", 'd', OI_SAFE },
  1507. { "ErrorHeader", 'E', OI_NONE },
  1508. { "ErrorMode", 'e', OI_SAFE },
  1509. { "TempFileMode", 'F', OI_NONE },
  1510. { "SaveFromLine", 'f', OI_NONE },
  1511. { "MatchGECOS", 'G', OI_NONE },
  1512. { "HelpFile", 'H', OI_NONE },
  1513. { "MaxHopCount", 'h', OI_NONE },
  1514. { "ResolverOptions", 'I', OI_NONE },
  1515. { "IgnoreDots", 'i', OI_SAFE },
  1516. { "ForwardPath", 'J', OI_NONE },
  1517. { "SendMimeErrors", 'j', OI_SAFE },
  1518. { "ConnectionCacheSize", 'k', OI_NONE },
  1519. { "ConnectionCacheTimeout", 'K', OI_NONE },
  1520. { "UseErrorsTo", 'l', OI_NONE },
  1521. { "LogLevel", 'L', OI_SAFE },
  1522. { "MeToo", 'm', OI_SAFE },
  1523. { "CheckAliases", 'n', OI_NONE },
  1524. { "OldStyleHeaders", 'o', OI_SAFE },
  1525. { "DaemonPortOptions", 'O', OI_NONE },
  1526. { "PrivacyOptions", 'p', OI_SAFE },
  1527. { "PostmasterCopy", 'P', OI_NONE },
  1528. { "QueueFactor", 'q', OI_NONE },
  1529. { "QueueDirectory", 'Q', OI_NONE },
  1530. { "DontPruneRoutes", 'R', OI_NONE },
  1531. { "Timeout", 'r', OI_SUBOPT },
  1532. { "StatusFile", 'S', OI_NONE },
  1533. { "SuperSafe", 's', OI_SAFE },
  1534. { "QueueTimeout", 'T', OI_NONE },
  1535. { "TimeZoneSpec", 't', OI_NONE },
  1536. { "UserDatabaseSpec", 'U', OI_NONE },
  1537. { "DefaultUser", 'u', OI_NONE },
  1538. { "FallbackMXhost", 'V', OI_NONE },
  1539. { "Verbose", 'v', OI_SAFE },
  1540. { "TryNullMXList", 'w', OI_NONE },
  1541. { "QueueLA", 'x', OI_NONE },
  1542. { "RefuseLA", 'X', OI_NONE },
  1543. { "RecipientFactor", 'y', OI_NONE },
  1544. { "ForkEachJob", 'Y', OI_NONE },
  1545. { "ClassFactor", 'z', OI_NONE },
  1546. { "RetryFactor", 'Z', OI_NONE },
  1547. #define O_QUEUESORTORD 0x81
  1548. { "QueueSortOrder", O_QUEUESORTORD, OI_SAFE },
  1549. #define O_HOSTSFILE 0x82
  1550. { "HostsFile", O_HOSTSFILE, OI_NONE },
  1551. #define O_MQA 0x83
  1552. { "MinQueueAge", O_MQA, OI_SAFE },
  1553. #define O_DEFCHARSET 0x85
  1554. { "DefaultCharSet", O_DEFCHARSET, OI_SAFE },
  1555. #define O_SSFILE 0x86
  1556. { "ServiceSwitchFile", O_SSFILE, OI_NONE },
  1557. #define O_DIALDELAY 0x87
  1558. { "DialDelay", O_DIALDELAY, OI_SAFE },
  1559. #define O_NORCPTACTION 0x88
  1560. { "NoRecipientAction", O_NORCPTACTION, OI_SAFE },
  1561. #define O_SAFEFILEENV 0x89
  1562. { "SafeFileEnvironment", O_SAFEFILEENV, OI_NONE },
  1563. #define O_MAXMSGSIZE 0x8a
  1564. { "MaxMessageSize", O_MAXMSGSIZE, OI_NONE },
  1565. #define O_COLONOKINADDR 0x8b
  1566. { "ColonOkInAddr", O_COLONOKINADDR, OI_SAFE },
  1567. #define O_MAXQUEUERUN 0x8c
  1568. { "MaxQueueRunSize", O_MAXQUEUERUN, OI_SAFE },
  1569. #define O_MAXCHILDREN 0x8d
  1570. { "MaxDaemonChildren", O_MAXCHILDREN, OI_NONE },
  1571. #define O_KEEPCNAMES 0x8e
  1572. { "DontExpandCnames", O_KEEPCNAMES, OI_NONE },
  1573. #define O_MUSTQUOTE 0x8f
  1574. { "MustQuoteChars", O_MUSTQUOTE, OI_NONE },
  1575. #define O_SMTPGREETING 0x90
  1576. { "SmtpGreetingMessage", O_SMTPGREETING, OI_NONE },
  1577. #define O_UNIXFROM 0x91
  1578. { "UnixFromLine", O_UNIXFROM, OI_NONE },
  1579. #define O_OPCHARS 0x92
  1580. { "OperatorChars", O_OPCHARS, OI_NONE },
  1581. #define O_DONTINITGRPS 0x93
  1582. { "DontInitGroups", O_DONTINITGRPS, OI_NONE },
  1583. #define O_SLFH 0x94
  1584. { "SingleLineFromHeader", O_SLFH, OI_SAFE },
  1585. #define O_ABH 0x95
  1586. { "AllowBogusHELO", O_ABH, OI_SAFE },
  1587. #define O_CONNTHROT 0x97
  1588. { "ConnectionRateThrottle", O_CONNTHROT, OI_NONE },
  1589. #define O_UGW 0x99
  1590. { "UnsafeGroupWrites", O_UGW, OI_NONE },
  1591. #define O_DBLBOUNCE 0x9a
  1592. { "DoubleBounceAddress", O_DBLBOUNCE, OI_NONE },
  1593. #define O_HSDIR 0x9b
  1594. { "HostStatusDirectory", O_HSDIR, OI_NONE },
  1595. #define O_SINGTHREAD 0x9c
  1596. { "SingleThreadDelivery", O_SINGTHREAD, OI_NONE },
  1597. #define O_RUNASUSER 0x9d
  1598. { "RunAsUser", O_RUNASUSER, OI_NONE },
  1599. #define O_DSN_RRT 0x9e
  1600. { "RrtImpliesDsn", O_DSN_RRT, OI_NONE },
  1601. #define O_PIDFILE 0x9f
  1602. { "PidFile", O_PIDFILE, OI_NONE },
  1603. #define O_DONTBLAMESENDMAIL 0xa0
  1604. { "DontBlameSendmail", O_DONTBLAMESENDMAIL, OI_NONE },
  1605. #define O_DPI 0xa1
  1606. { "DontProbeInterfaces", O_DPI, OI_NONE },
  1607. #define O_MAXRCPT 0xa2
  1608. { "MaxRecipientsPerMessage", O_MAXRCPT, OI_SAFE },
  1609. #define O_DEADLETTER 0xa3
  1610. { "DeadLetterDrop", O_DEADLETTER, OI_NONE },
  1611. #if _FFR_DONTLOCKFILESFORREAD_OPTION
  1612. # define O_DONTLOCK 0xa4
  1613. { "DontLockFilesForRead", O_DONTLOCK, OI_NONE },
  1614. #endif /* _FFR_DONTLOCKFILESFORREAD_OPTION */
  1615. #define O_MAXALIASRCSN 0xa5
  1616. { "MaxAliasRecursion", O_MAXALIASRCSN, OI_NONE },
  1617. #define O_CNCTONLYTO 0xa6
  1618. { "ConnectOnlyTo", O_CNCTONLYTO, OI_NONE },
  1619. #define O_TRUSTUSER 0xa7
  1620. { "TrustedUser", O_TRUSTUSER, OI_NONE },
  1621. #define O_MAXMIMEHDRLEN 0xa8
  1622. { "MaxMimeHeaderLength", O_MAXMIMEHDRLEN, OI_NONE },
  1623. #define O_CONTROLSOCKET 0xa9
  1624. { "ControlSocketName", O_CONTROLSOCKET, OI_NONE },
  1625. #define O_MAXHDRSLEN 0xaa
  1626. { "MaxHeadersLength", O_MAXHDRSLEN, OI_NONE },
  1627. #if _FFR_MAX_FORWARD_ENTRIES
  1628. # define O_MAXFORWARD 0xab
  1629. { "MaxForwardEntries", O_MAXFORWARD, OI_NONE },
  1630. #endif /* _FFR_MAX_FORWARD_ENTRIES */
  1631. #define O_PROCTITLEPREFIX 0xac
  1632. { "ProcessTitlePrefix", O_PROCTITLEPREFIX, OI_NONE },
  1633. #define O_SASLINFO 0xad
  1634. { "DefaultAuthInfo", O_SASLINFO, OI_NONE },
  1635. #define O_SASLMECH 0xae
  1636. { "AuthMechanisms", O_SASLMECH, OI_NONE },
  1637. #define O_CLIENTPORT 0xaf
  1638. { "ClientPortOptions", O_CLIENTPORT, OI_NONE },
  1639. #define O_DF_BUFSIZE 0xb0
  1640. { "DataFileBufferSize", O_DF_BUFSIZE, OI_NONE },
  1641. #define O_XF_BUFSIZE 0xb1
  1642. { "XscriptFileBufferSize", O_XF_BUFSIZE, OI_NONE },
  1643. # define O_LDAPDEFAULTSPEC 0xb2
  1644. { "LDAPDefaultSpec", O_LDAPDEFAULTSPEC, OI_NONE },
  1645. #if _FFR_QUEUEDELAY
  1646. #define O_QUEUEDELAY 0xb3
  1647. { "QueueDelay", O_QUEUEDELAY, OI_NONE },
  1648. #endif /* _FFR_QUEUEDELAY */
  1649. #define O_SASLOPTS 0xbc
  1650. { "AuthOptions", O_SASLOPTS, OI_NONE },
  1651. { NULL, '', OI_NONE }
  1652. };
  1654. void
  1655. setoption(opt, val, safe, sticky, e)
  1656. int opt;
  1657. char *val;
  1658. bool safe;
  1659. bool sticky;
  1660. register ENVELOPE *e;
  1661. {
  1662. register char *p;
  1663. register struct optioninfo *o;
  1664. char *subopt;
  1665. int mid;
  1666. bool can_setuid = RunAsUid == 0;
  1667. auto char *ep;
  1668. char buf[50];
  1669. extern int QueueLA;
  1670. extern int RefuseLA;
  1671. extern bool Warn_Q_option;
  1673. errno = 0;
  1674. if (opt == ' ')
  1675. {
  1676. /* full word options */
  1677. struct optioninfo *sel;
  1679. p = strchr(val, '=');
  1680. if (p == NULL)
  1681. p = &val[strlen(val)];
  1682. while (*--p == ' ')
  1683. continue;
  1684. while (*++p == ' ')
  1685. *p = '';
  1686. if (p == val)
  1687. {
  1688. syserr("readcf: null option name");
  1689. return;
  1690. }
  1691. if (*p == '=')
  1692. *p++ = '';
  1693. while (*p == ' ')
  1694. p++;
  1695. subopt = strchr(val, '.');
  1696. if (subopt != NULL)
  1697. *subopt++ = '';
  1698. sel = NULL;
  1699. for (o = OptionTab; o->o_name != NULL; o++)
  1700. {
  1701. if (strncasecmp(o->o_name, val, strlen(val)) != 0)
  1702. continue;
  1703. if (strlen(o->o_name) == strlen(val))
  1704. {
  1705. /* completely specified -- this must be it */
  1706. sel = NULL;
  1707. break;
  1708. }
  1709. if (sel != NULL)
  1710. break;
  1711. sel = o;
  1712. }
  1713. if (sel != NULL && o->o_name == NULL)
  1714. o = sel;
  1715. else if (o->o_name == NULL)
  1716. {
  1717. syserr("readcf: unknown option name %s", val);
  1718. return;
  1719. }
  1720. else if (sel != NULL)
  1721. {
  1722. syserr("readcf: ambiguous option name %s (matches %s and %s)",
  1723. val, sel->o_name, o->o_name);
  1724. return;
  1725. }
  1726. if (strlen(val) != strlen(o->o_name))
  1727. {
  1728. int oldVerbose = Verbose;
  1730. Verbose = 1;
  1731. message("Option %s used as abbreviation for %s",
  1732. val, o->o_name);
  1733. Verbose = oldVerbose;
  1734. }
  1735. opt = o->o_code;
  1736. val = p;
  1737. }
  1738. else
  1739. {
  1740. for (o = OptionTab; o->o_name != NULL; o++)
  1741. {
  1742. if (o->o_code == opt)
  1743. break;
  1744. }
  1745. subopt = NULL;
  1746. }
  1748. if (subopt != NULL && !bitset(OI_SUBOPT, o->o_flags))
  1749. {
  1750. if (tTd(37, 1))
  1751. dprintf("setoption: %s does not support suboptions, ignoring .%sn",
  1752. o->o_name == NULL ? "<unknown>" : o->o_name,
  1753. subopt);
  1754. subopt = NULL;
  1755. }
  1757. if (tTd(37, 1))
  1758. {
  1759. dprintf(isascii(opt) && isprint(opt) ?
  1760. "setoption %s (%c)%s%s=" :
  1761. "setoption %s (0x%x)%s%s=",
  1762. o->o_name == NULL ? "<unknown>" : o->o_name,
  1763. opt,
  1764. subopt == NULL ? "" : ".",
  1765. subopt == NULL ? "" : subopt);
  1766. xputs(val);
  1767. }
  1769. /*
  1770. **  See if this option is preset for us.
  1771. */
  1773. if (!sticky && bitnset(opt, StickyOpt))
  1774. {
  1775. if (tTd(37, 1))
  1776. dprintf(" (ignored)n");
  1777. return;
  1778. }
  1780. /*
  1781. **  Check to see if this option can be specified by this user.
  1782. */
  1784. if (!safe && RealUid == 0)
  1785. safe = TRUE;
  1786. if (!safe && !bitset(OI_SAFE, o->o_flags))
  1787. {
  1788. if (opt != 'M' || (val[0] != 'r' && val[0] != 's'))
  1789. {
  1790. if (tTd(37, 1))
  1791. dprintf(" (unsafe)");
  1792. (void) drop_privileges(TRUE);
  1793. }
  1794. }
  1795. if (tTd(37, 1))
  1796. dprintf("n");
  1798. switch (opt & 0xff)
  1799. {
  1800.   case '7': /* force seven-bit input */
  1801. SevenBitInput = atobool(val);
  1802. break;
  1804. #if MIME8TO7
  1805.   case '8': /* handling of 8-bit input */
  1806. switch (*val)
  1807. {
  1808.   case 'm': /* convert 8-bit, convert MIME */
  1809. MimeMode = MM_CVTMIME|MM_MIME8BIT;
  1810. break;
  1812.   case 'p': /* pass 8 bit, convert MIME */
  1813. MimeMode = MM_CVTMIME|MM_PASS8BIT;
  1814. break;
  1816.   case 's': /* strict adherence */
  1817. MimeMode = MM_CVTMIME;
  1818. break;
  1820. # if 0
  1821.   case 'r': /* reject 8-bit, don't convert MIME */
  1822. MimeMode = 0;
  1823. break;
  1825.   case 'j': /* "just send 8" */
  1826. MimeMode = MM_PASS8BIT;
  1827. break;
  1829.   case 'a': /* encode 8 bit if available */
  1830. MimeMode = MM_MIME8BIT|MM_PASS8BIT|MM_CVTMIME;
  1831. break;
  1833.   case 'c': /* convert 8 bit to MIME, never 7 bit */
  1834. MimeMode = MM_MIME8BIT;
  1835. break;
  1836. # endif /* 0 */
  1838.   default:
  1839. syserr("Unknown 8-bit mode %c", *val);
  1840. finis(FALSE, EX_USAGE);
  1841. }
  1842. break;
  1843. #endif /* MIME8TO7 */
  1845.   case 'A': /* set default alias file */
  1846. if (val[0] == '')
  1847. setalias("aliases");
  1848. else
  1849. setalias(val);
  1850. break;
  1852.   case 'a': /* look N minutes for "@:@" in alias file */
  1853. if (val[0] == '')
  1854. SafeAlias = 5 * 60; /* five minutes */
  1855. else
  1856. SafeAlias = convtime(val, 'm');
  1857. break;
  1859.   case 'B': /* substitution for blank character */
  1860. SpaceSub = val[0];
  1861. if (SpaceSub == '')
  1862. SpaceSub = ' ';
  1863. break;
  1865.   case 'b': /* min blocks free on queue fs/max msg size */
  1866. p = strchr(val, '/');
  1867. if (p != NULL)
  1868. {
  1869. *p++ = '';
  1870. MaxMessageSize = atol(p);
  1871. }
  1872. MinBlocksFree = atol(val);
  1873. break;
  1875.   case 'c': /* don't connect to "expensive" mailers */
  1876. NoConnect = atobool(val);
  1877. break;
  1879.   case 'C': /* checkpoint every N addresses */
  1880. CheckpointInterval = atoi(val);
  1881. break;
  1883.   case 'd': /* delivery mode */
  1884. switch (*val)
  1885. {
  1886.   case '':
  1887. set_delivery_mode(SM_DELIVER, e);
  1888. break;
  1890.   case SM_QUEUE: /* queue only */
  1891.   case SM_DEFER: /* queue only and defer map lookups */
  1892. #if !QUEUE
  1893. syserr("need QUEUE to set -odqueue or -oddefer");
  1894. #endif /* !QUEUE */
  1895. /* FALLTHROUGH */
  1897.   case SM_DELIVER: /* do everything */
  1898.   case SM_FORK: /* fork after verification */
  1899. set_delivery_mode(*val, e);
  1900. break;
  1902.   default:
  1903. syserr("Unknown delivery mode %c", *val);
  1904. finis(FALSE, EX_USAGE);
  1905. }
  1906. break;
  1908. #if !_FFR_REMOVE_AUTOREBUILD
  1909.   case 'D': /* rebuild alias database as needed */
  1910. AutoRebuild = atobool(val);
  1911. break;
  1912. #endif /* !_FFR_REMOVE_AUTOREBUILD */
  1914.   case 'E': /* error message header/header file */
  1915. if (*val != '')
  1916. ErrMsgFile = newstr(val);
  1917. break;
  1919.   case 'e': /* set error processing mode */
  1920. switch (*val)
  1921. {
  1922.   case EM_QUIET: /* be silent about it */
  1923.   case EM_MAIL: /* mail back */
  1924.   case EM_BERKNET: /* do berknet error processing */
  1925.   case EM_WRITE: /* write back (or mail) */
  1926.   case EM_PRINT: /* print errors normally (default) */
  1927. e->e_errormode = *val;
  1928. break;
  1929. }
  1930. break;
  1932.   case 'F': /* file mode */
  1933. FileMode = atooct(val) & 0777;
  1934. break;
  1936.   case 'f': /* save Unix-style From lines on front */
  1937. SaveFrom = atobool(val);
  1938. break;
  1940.   case 'G': /* match recipients against GECOS field */
  1941. MatchGecos = atobool(val);
  1942. break;
  1944.   case 'g': /* default gid */
  1945.   g_opt:
  1946. if (isascii(*val) && isdigit(*val))
  1947. DefGid = atoi(val);
  1948. else
  1949. {
  1950. register struct group *gr;
  1952. DefGid = -1;
  1953. gr = getgrnam(val);
  1954. if (gr == NULL)
  1955. syserr("readcf: option %c: unknown group %s",
  1956. opt, val);
  1957. else
  1958. DefGid = gr->gr_gid;
  1959. }
  1960. break;
  1962.   case 'H': /* help file */
  1963. if (val[0] == '')
  1964. HelpFile = "helpfile";
  1965. else
  1966. HelpFile = newstr(val);
  1967. break;
  1969.   case 'h': /* maximum hop count */
  1970. MaxHopCount = atoi(val);
  1971. break;
  1973.   case 'I': /* use internet domain name server */
  1974. #if NAMED_BIND
  1975. for (p = val; *p != 0; )
  1976. {
  1977. bool clearmode;
  1978. char *q;
  1979. struct resolverflags *rfp;
  1981. while (*p == ' ')
  1982. p++;
  1983. if (*p == '')
  1984. break;
  1985. clearmode = FALSE;
  1986. if (*p == '-')
  1987. clearmode = TRUE;
  1988. else if (*p != '+')
  1989. p--;
  1990. p++;
  1991. q = p;
  1992. while (*p != '' && !(isascii(*p) && isspace(*p)))
  1993. p++;
  1994. if (*p != '')
  1995. *p++ = '';
  1996. if (strcasecmp(q, "HasWildcardMX") == 0)
  1997. {
  1998. HasWildcardMX = !clearmode;
  1999. continue;
  2000. }
  2001. for (rfp = ResolverFlags; rfp->rf_name != NULL; rfp++)
  2002. {
  2003. if (strcasecmp(q, rfp->rf_name) == 0)
  2004. break;
  2005. }
  2006. if (rfp->rf_name == NULL)
  2007. syserr("readcf: I option value %s unrecognized", q);
  2008. else if (clearmode)
  2009. _res.options &= ~rfp->rf_bits;
  2010. else
  2011. _res.options |= rfp->rf_bits;
  2012. }
  2013. if (tTd(8, 2))
  2014. dprintf("_res.options = %x, HasWildcardMX = %dn",
  2015. (u_int) _res.options, HasWildcardMX);
  2016. #else /* NAMED_BIND */
  2017. usrerr("name server (I option) specified but BIND not compiled in");
  2018. #endif /* NAMED_BIND */
  2019. break;
  2021.   case 'i': /* ignore dot lines in message */
  2022. IgnrDot = atobool(val);
  2023. break;
  2025.   case 'j': /* send errors in MIME (RFC 1341) format */
  2026. SendMIMEErrors = atobool(val);
  2027. break;
  2029.   case 'J': /* .forward search path */
  2030. ForwardPath = newstr(val);
  2031. break;
  2033.   case 'k': /* connection cache size */
  2034. MaxMciCache = atoi(val);
  2035. if (MaxMciCache < 0)
  2036. MaxMciCache = 0;
  2037. break;
  2039.   case 'K': /* connection cache timeout */
  2040. MciCacheTimeout = convtime(val, 'm');
  2041. break;
  2043.   case 'l': /* use Errors-To: header */
  2044. UseErrorsTo = atobool(val);
  2045. break;
  2047.   case 'L': /* log level */
  2048. if (safe || LogLevel < atoi(val))
  2049. LogLevel = atoi(val);
  2050. break;
  2052.   case 'M': /* define macro */
  2053. mid = macid(val, &ep);
  2054. p = newstr(ep);
  2055. if (!safe)
  2056. cleanstrcpy(p, p, MAXNAME);
  2057. define(mid, p, CurEnv);
  2058. sticky = FALSE;
  2059. break;
  2061.   case 'm': /* send to me too */
  2062. MeToo = atobool(val);
  2063. break;
  2065.   case 'n': /* validate RHS in newaliases */
  2066. CheckAliases = atobool(val);
  2067. break;
  2069.     /* 'N' available -- was "net name" */
  2071.   case 'O': /* daemon options */
  2072. #if DAEMON
  2073. if (!setdaemonoptions(val))
  2074. {
  2075. syserr("too many daemons defined (%d max)", MAXDAEMONS);
  2076. }
  2077. #else /* DAEMON */
  2078. syserr("DaemonPortOptions (O option) set but DAEMON not compiled in");
  2079. #endif /* DAEMON */
  2080. break;
  2082.   case 'o': /* assume old style headers */
  2083. if (atobool(val))
  2084. CurEnv->e_flags |= EF_OLDSTYLE;
  2085. else
  2086. CurEnv->e_flags &= ~EF_OLDSTYLE;
  2087. break;
  2089.   case 'p': /* select privacy level */
  2090. p = val;
  2091. for (;;)
  2092. {
  2093. register struct prival *pv;
  2094. extern struct prival PrivacyValues[];
  2096. while (isascii(*p) && (isspace(*p) || ispunct(*p)))
  2097. p++;
  2098. if (*p == '')
  2099. break;
  2100. val = p;
  2101. while (isascii(*p) && isalnum(*p))
  2102. p++;
  2103. if (*p != '')
  2104. *p++ = '';
  2106. for (pv = PrivacyValues; pv->pv_name != NULL; pv++)
  2107. {
  2108. if (strcasecmp(val, pv->pv_name) == 0)
  2109. break;
  2110. }
  2111. if (pv->pv_name == NULL)
  2112. syserr("readcf: Op line: %s unrecognized", val);
  2113. PrivacyFlags |= pv->pv_flag;
  2114. }
  2115. sticky = FALSE;
  2116. break;
  2118.   case 'P': /* postmaster copy address for returned mail */
  2119. PostMasterCopy = newstr(val);
  2120. break;
  2122.   case 'q': /* slope of queue only function */
  2123. QueueFactor = atoi(val);
  2124. break;
  2126.   case 'Q': /* queue directory */
  2127. if (val[0] == '')
  2128. QueueDir = "mqueue";
  2129. else
  2130. QueueDir = newstr(val);
  2131. if (RealUid != 0 && !safe)
  2132. Warn_Q_option = TRUE;
  2133. break;
  2135.   case 'R': /* don't prune routes */
  2136. DontPruneRoutes = atobool(val);
  2137. break;
  2139.   case 'r': /* read timeout */
  2140. if (subopt == NULL)
  2141. inittimeouts(val, sticky);
  2142. else
  2143. settimeout(subopt, val, sticky);
  2144. break;
  2146.   case 'S': /* status file */
  2147. if (val[0] == '')
  2148. StatFile = "statistics";
  2149. else
  2150. StatFile = newstr(val);
  2151. break;
  2153.   case 's': /* be super safe, even if expensive */
  2154. SuperSafe = atobool(val);
  2155. break;
  2157.   case 'T': /* queue timeout */
  2158. p = strchr(val, '/');
  2159. if (p != NULL)
  2160. {
  2161. *p++ = '';
  2162. settimeout("queuewarn", p, sticky);
  2163. }
  2164. settimeout("queuereturn", val, sticky);
  2165. break;
  2167.   case 't': /* time zone name */
  2168. TimeZoneSpec = newstr(val);
  2169. break;
  2171.   case 'U': /* location of user database */
  2172. UdbSpec = newstr(val);
  2173. break;
  2175.   case 'u': /* set default uid */
  2176. for (p = val; *p != ''; p++)
  2177. {
  2178. if (*p == '.' || *p == '/' || *p == ':')
  2179. {
  2180. *p++ = '';
  2181. break;
  2182. }
  2183. }
  2184. if (isascii(*val) && isdigit(*val))
  2185. {
  2186. DefUid = atoi(val);
  2187. setdefuser();
  2188. }
  2189. else
  2190. {
  2191. register struct passwd *pw;
  2193. DefUid = -1;
  2194. pw = sm_getpwnam(val);
  2195. if (pw == NULL)
  2196. syserr("readcf: option u: unknown user %s", val);
  2197. else
  2198. {
  2199. DefUid = pw->pw_uid;
  2200. DefGid = pw->pw_gid;
  2201. DefUser = newstr(pw->pw_name);
  2202. }
  2203. }
  2205. #ifdef UID_MAX
  2206. if (DefUid > UID_MAX)
  2207. {
  2208. syserr("readcf: option u: uid value (%ld) > UID_MAX (%ld); ignored",
  2209. DefUid, UID_MAX);
  2210. }
  2211. #endif /* UID_MAX */
  2213. /* handle the group if it is there */
  2214. if (*p == '')
  2215. break;
  2216. val = p;
  2217. goto g_opt;
  2219.   case 'V': /* fallback MX host */
  2220. if (val[0] != '')
  2221. FallBackMX = newstr(val);
  2222. break;
  2224.   case 'v': /* run in verbose mode */
  2225. Verbose = atobool(val) ? 1 : 0;
  2226. break;
  2228.   case 'w': /* if we are best MX, try host directly */
  2229. TryNullMXList = atobool(val);
  2230. break;
  2232.     /* 'W' available -- was wizard password */
  2234.   case 'x': /* load avg at which to auto-queue msgs */
  2235. QueueLA = atoi(val);
  2236. break;
  2238.   case 'X': /* load avg at which to auto-reject connections */
  2239. RefuseLA = atoi(val);
  2240. break;
  2242.   case 'y': /* work recipient factor */
  2243. WkRecipFact = atoi(val);
  2244. break;
  2246.   case 'Y': /* fork jobs during queue runs */
  2247. ForkQueueRuns = atobool(val);
  2248. break;
  2250.   case 'z': /* work message class factor */
  2251. WkClassFact = atoi(val);
  2252. break;
  2254.   case 'Z': /* work time factor */
  2255. WkTimeFact = atoi(val);
  2256. break;
  2258.   case O_QUEUESORTORD: /* queue sorting order */
  2259. switch (*val)
  2260. {
  2261.   case 'h': /* Host first */
  2262.   case 'H':
  2263. QueueSortOrder = QSO_BYHOST;
  2264. break;
  2266.   case 'p': /* Priority order */
  2267.   case 'P':
  2268. QueueSortOrder = QSO_BYPRIORITY;
  2269. break;
  2271.   case 't': /* Submission time */
  2272.   case 'T':
  2273. QueueSortOrder = QSO_BYTIME;
  2274. break;
  2276.   case 'f': /* File Name */
  2277.   case 'F':
  2278. QueueSortOrder = QSO_BYFILENAME;
  2279. break;
  2281.   default:
  2282. syserr("Invalid queue sort order "%s"", val);
  2283. }
  2284. break;
  2286. #if _FFR_QUEUEDELAY
  2287.   case O_QUEUEDELAY: /* queue delay algorithm */
  2288. switch (*val)
  2289. {
  2290.   case 'e': /* exponential */
  2291.   case 'E':
  2292. QueueAlg = QD_EXP;
  2293. QueueInitDelay = 10 MINUTES;
  2294. QueueMaxDelay = 2 HOURS;
  2295. p = strchr(val, '/');
  2296. if (p != NULL)
  2297. {
  2298. char *q;
  2300. *p++ = '';
  2301. q = strchr(p, '/');
  2302. if (q != NULL)
  2303. *q++ = '';
  2304. QueueInitDelay = convtime(p, 's');
  2305. if (q != NULL)
  2306. {
  2307. QueueMaxDelay = convtime(q, 's');
  2308. }
  2309. }
  2310. break;
  2312.   case 'l': /* linear */
  2313.   case 'L':
  2314. QueueAlg = QD_LINEAR;
  2315. break;
  2317.   default:
  2318. syserr("Invalid queue delay algorithm "%s"", val);
  2319. }
  2320. break;
  2321. #endif /* _FFR_QUEUEDELAY */
  2323.   case O_HOSTSFILE: /* pathname of /etc/hosts file */
  2324. HostsFile = newstr(val);
  2325. break;
  2327.   case O_MQA: /* minimum queue age between deliveries */
  2328. MinQueueAge = convtime(val, 'm');
  2329. break;
  2331.   case O_DEFCHARSET: /* default character set for mimefying */
  2332. DefaultCharSet = newstr(denlstring(val, TRUE, TRUE));
  2333. break;
  2335.   case O_SSFILE: /* service switch file */
  2336. ServiceSwitchFile = newstr(val);
  2337. break;
  2339.   case O_DIALDELAY: /* delay for dial-on-demand operation */
  2340. DialDelay = convtime(val, 's');
  2341. break;
  2343.   case O_NORCPTACTION: /* what to do if no recipient */
  2344. if (strcasecmp(val, "none") == 0)
  2345. NoRecipientAction = NRA_NO_ACTION;
  2346. else if (strcasecmp(val, "add-to") == 0)
  2347. NoRecipientAction = NRA_ADD_TO;
  2348. else if (strcasecmp(val, "add-apparently-to") == 0)
  2349. NoRecipientAction = NRA_ADD_APPARENTLY_TO;
  2350. else if (strcasecmp(val, "add-bcc") == 0)
  2351. NoRecipientAction = NRA_ADD_BCC;
  2352. else if (strcasecmp(val, "add-to-undisclosed") == 0)
  2353. NoRecipientAction = NRA_ADD_TO_UNDISCLOSED;
  2354. else
  2355. syserr("Invalid NoRecipientAction: %s", val);
  2356. break;
  2358.   case O_SAFEFILEENV: /* chroot() environ for writing to files */
  2359. SafeFileEnv = newstr(val);
  2360. break;
  2362.   case O_MAXMSGSIZE: /* maximum message size */
  2363. MaxMessageSize = atol(val);
  2364. break;
  2366.   case O_COLONOKINADDR: /* old style handling of colon addresses */
  2367. ColonOkInAddr = atobool(val);
  2368. break;
  2370.   case O_MAXQUEUERUN: /* max # of jobs in a single queue run */
  2371. MaxQueueRun = atol(val);
  2372. break;
  2374.   case O_MAXCHILDREN: /* max # of children of daemon */
  2375. MaxChildren = atoi(val);
  2376. break;
  2378. #if _FFR_MAX_FORWARD_ENTRIES
  2379.   case O_MAXFORWARD: /* max # of forward entries */
  2380. MaxForwardEntries = atoi(val);
  2381. break;
  2382. #endif /* _FFR_MAX_FORWARD_ENTRIES */
  2384.   case O_KEEPCNAMES: /* don't expand CNAME records */
  2385. DontExpandCnames = atobool(val);
  2386. break;
  2388.   case O_MUSTQUOTE: /* must quote these characters in phrases */
  2389. (void) strlcpy(buf, "@,;:\()[]", sizeof buf);
  2390. if (strlen(val) < (SIZE_T) sizeof buf - 10)
  2391. (void) strlcat(buf, val, sizeof buf);
  2392. else
  2393. printf("Warning: MustQuoteChars too long, ignored.n");
  2394. MustQuoteChars = newstr(buf);
  2395. break;
  2397.   case O_SMTPGREETING: /* SMTP greeting message (old $e macro) */
  2398. SmtpGreeting = newstr(munchstring(val, NULL, ''));
  2399. break;
  2401.   case O_UNIXFROM: /* UNIX From_ line (old $l macro) */
  2402. UnixFromLine = newstr(munchstring(val, NULL, ''));
  2403. break;
  2405.   case O_OPCHARS: /* operator characters (old $o macro) */
  2406. if (OperatorChars != NULL)
  2407. printf("Warning: OperatorChars is being redefined.n         It should only be set before ruleset definitions.n");
  2408. OperatorChars = newstr(munchstring(val, NULL, ''));
  2409. break;
  2411.   case O_DONTINITGRPS: /* don't call initgroups(3) */
  2412. DontInitGroups = atobool(val);
  2413. break;
  2415.   case O_SLFH: /* make sure from fits on one line */
  2416. SingleLineFromHeader = atobool(val);
  2417. break;
  2419.   case O_ABH: /* allow HELO commands with syntax errors */
  2420. AllowBogusHELO = atobool(val);
  2421. break;
  2423.   case O_CONNTHROT: /* connection rate throttle */
  2424. ConnRateThrottle = atoi(val);
  2425. break;
  2427.   case O_UGW: /* group writable files are unsafe */
  2428. if (!atobool(val))
  2429. {
  2430. setbitn(DBS_GROUPWRITABLEFORWARDFILESAFE,
  2431. DontBlameSendmail);
  2432. setbitn(DBS_GROUPWRITABLEINCLUDEFILESAFE,
  2433. DontBlameSendmail);
  2434. }
  2435. break;
  2437.   case O_DBLBOUNCE: /* address to which to send double bounces */
  2438. if (val[0] != '')
  2439. DoubleBounceAddr = newstr(val);
  2440. else
  2441. syserr("readcf: option DoubleBounceAddress: value required");
  2442. break;
  2444.   case O_HSDIR: /* persistent host status directory */
  2445. if (val[0] != '')
  2446. HostStatDir = newstr(val);
  2447. break;
  2449.   case O_SINGTHREAD: /* single thread deliveries (requires hsdir) */
  2450. SingleThreadDelivery = atobool(val);
  2451. break;
  2453.   case O_RUNASUSER: /* run bulk of code as this user */
  2454. for (p = val; *p != ''; p++)
  2455. {
  2456. if (*p == '.' || *p == '/' || *p == ':')
  2457. {
  2458. *p++ = '';
  2459. break;
  2460. }
  2461. }
  2462. if (isascii(*val) && isdigit(*val))
  2463. {
  2464. if (can_setuid)
  2465. RunAsUid = atoi(val);
  2466. }
  2467. else
  2468. {
  2469. register struct passwd *pw;
  2471. pw = sm_getpwnam(val);
  2472. if (pw == NULL)
  2473. syserr("readcf: option RunAsUser: unknown user %s", val);
  2474. else if (can_setuid)
  2475. {
  2476. if (*p == '')
  2477. RunAsUserName = newstr(val);
  2478. RunAsUid = pw->pw_uid;
  2479. RunAsGid = pw->pw_gid;
  2480. }
  2481. }
  2482. #ifdef UID_MAX
  2483. if (RunAsUid > UID_MAX)
  2484. {
  2485. syserr("readcf: option RunAsUser: uid value (%ld) > UID_MAX (%ld); ignored",
  2486. RunAsUid, UID_MAX);
  2487. }
  2488. #endif /* UID_MAX */
  2489. if (*p != '')
  2490. {
  2491. if (isascii(*p) && isdigit(*p))
  2492. {
  2493. if (can_setuid)
  2494. RunAsGid = atoi(p);
  2495. }
  2496. else
  2497. {
  2498. register struct group *gr;
  2500. gr = getgrnam(p);
  2501. if (gr == NULL)
  2502. syserr("readcf: option RunAsUser: unknown group %s",
  2503. p);
  2504. else if (can_setuid)
  2505. RunAsGid = gr->gr_gid;
  2506. }
  2507. }
  2508. if (tTd(47, 5))
  2509. dprintf("readcf: RunAsUser = %d:%dn",
  2510. (int)RunAsUid, (int)RunAsGid);
  2511. break;
  2513.   case O_DSN_RRT:
  2514. RrtImpliesDsn = atobool(val);
  2515. break;
  2517.   case O_PIDFILE:
  2518. if (PidFile != NULL)
  2519. free(PidFile);
  2520. PidFile = newstr(val);
  2521. break;
  2523. case O_DONTBLAMESENDMAIL:
  2524. p = val;
  2525. for (;;)
  2526. {
  2527. register struct dbsval *dbs;
  2528. extern struct dbsval DontBlameSendmailValues[];
  2530. while (isascii(*p) && (isspace(*p) || ispunct(*p)))
  2531. p++;
  2532. if (*p == '')
  2533. break;
  2534. val = p;
  2535. while (isascii(*p) && isalnum(*p))
  2536. p++;
  2537. if (*p != '')
  2538. *p++ = '';
  2540. for (dbs = DontBlameSendmailValues;
  2541.      dbs->dbs_name != NULL; dbs++)
  2542. {
  2543. if (strcasecmp(val, dbs->dbs_name) == 0)
  2544. break;
  2545. }
  2546. if (dbs->dbs_name == NULL)
  2547. syserr("readcf: DontBlameSendmail option: %s unrecognized", val);
  2548. else if (dbs->dbs_flag == DBS_SAFE)
  2549. clrbitmap(DontBlameSendmail);
  2550. else
  2551. setbitn(dbs->dbs_flag, DontBlameSendmail);
  2552. }
  2553. sticky = FALSE;
  2554. break;
  2556.   case O_DPI:
  2557. DontProbeInterfaces = atobool(val);
  2558. break;
  2560.   case O_MAXRCPT:
  2561. MaxRcptPerMsg = atoi(val);
  2562. break;
  2564.   case O_DEADLETTER:
  2565. if (DeadLetterDrop != NULL)
  2566. free(DeadLetterDrop);
  2567. DeadLetterDrop = newstr(val);
  2568. break;
  2570. #if _FFR_DONTLOCKFILESFORREAD_OPTION
  2571.   case O_DONTLOCK:
  2572. DontLockReadFiles = atobool(val);
  2573. break;
  2574. #endif /* _FFR_DONTLOCKFILESFORREAD_OPTION */
  2576.   case O_MAXALIASRCSN:
  2577. MaxAliasRecursion = atoi(val);
  2578. break;
  2580.   case O_CNCTONLYTO:
  2581. /* XXX should probably use gethostbyname */
  2582. #if NETINET || NETINET6
  2583. # if NETINET6
  2584. if (inet_addr(val) == INADDR_NONE)
  2585. {
  2586. ConnectOnlyTo.sa.sa_family = AF_INET6;
  2587. if (inet_pton(AF_INET6, val,
  2588.       &ConnectOnlyTo.sin6.sin6_addr) != 1)
  2589. syserr("readcf: option ConnectOnlyTo: invalid IP address %s",
  2590.        val);
  2591. }
  2592. else
  2593. # endif /* NETINET6 */
  2594. {
  2595. ConnectOnlyTo.sa.sa_family = AF_INET;
  2596. ConnectOnlyTo.sin.sin_addr.s_addr = inet_addr(val);
  2597. }
  2598. #endif /* NETINET || NETINET6 */
  2599. break;
  2601.   case O_TRUSTUSER:
  2602. #if HASFCHOWN
  2603. if (isascii(*val) && isdigit(*val))
  2604. TrustedUid = atoi(val);
  2605. else
  2606. {
  2607. register struct passwd *pw;
  2609. TrustedUid = 0;
  2610. pw = sm_getpwnam(val);
  2611. if (pw == NULL)
  2612. syserr("readcf: option TrustedUser: unknown user %s", val);
  2613. else
  2614. TrustedUid = pw->pw_uid;
  2615. }
  2617. # ifdef UID_MAX
  2618. if (TrustedUid > UID_MAX)
  2619. {
  2620. syserr("readcf: option TrustedUser: uid value (%ld) > UID_MAX (%ld)",
  2621. TrustedUid, UID_MAX);
  2622. TrustedUid = 0;
  2623. }
  2624. # endif /* UID_MAX */
  2625. #else /* HASFCHOWN */
  2626. syserr("readcf: option TrustedUser: can not be used on systems which do not support fchown()");
  2627. #endif /* HASFCHOWN */
  2628. break;
  2630.   case O_MAXMIMEHDRLEN:
  2631. p = strchr(val, '/');
  2632. if (p != NULL)
  2633. *p++ = '';
  2634. MaxMimeHeaderLength = atoi(val);
  2635. if (p != NULL && *p != '')
  2636. MaxMimeFieldLength = atoi(p);
  2637. else
  2638. MaxMimeFieldLength = MaxMimeHeaderLength / 2;
  2640. if (MaxMimeHeaderLength < 0)
  2641. MaxMimeHeaderLength = 0;
  2642. else if (MaxMimeHeaderLength < 128)
  2643. printf("Warning: MaxMimeHeaderLength: header length limit set lower than 128n");
  2645. if (MaxMimeFieldLength < 0)
  2646. MaxMimeFieldLength = 0;
  2647. else if (MaxMimeFieldLength < 40)
  2648. printf("Warning: MaxMimeHeaderLength: field length limit set lower than 40n");
  2649. break;
  2651.   case O_CONTROLSOCKET:
  2652. if (ControlSocketName != NULL)
  2653. free(ControlSocketName);
  2654. ControlSocketName = newstr(val);
  2655. break;
  2657.   case O_MAXHDRSLEN:
  2658. MaxHeadersLength = atoi(val);
  2660. if (MaxHeadersLength > 0 &&
  2661.     MaxHeadersLength < (MAXHDRSLEN / 2))
  2662. printf("Warning: MaxHeadersLength: headers length limit set lower than %dn", (MAXHDRSLEN / 2));
  2663. break;
  2665.   case O_PROCTITLEPREFIX:
  2666. if (ProcTitlePrefix != NULL)
  2667. free(ProcTitlePrefix);
  2668. ProcTitlePrefix = newstr(val);
  2669. break;
  2671. #if SASL
  2672.   case O_SASLINFO:
  2673. if (SASLInfo != NULL)
  2674. free(SASLInfo);
  2675. SASLInfo = newstr(val);
  2676. break;
  2678.   case O_SASLMECH:
  2679. if (AuthMechanisms != NULL)
  2680. free(AuthMechanisms);
  2681. if (*val != '')
  2682. AuthMechanisms = newstr(val);
  2683. else
  2684. AuthMechanisms = NULL;
  2685. break;
  2687.   case O_SASLOPTS:
  2688. if (*val == '')
  2689. {
  2690. printf("Warning: Option: %s requires parameter(s)n",
  2691. o->o_name == NULL ? "<unknown>" : o->o_name);
  2692. break;
  2693. }
  2694. if (*val == 'T' || *val == 't')
  2695. SASLTryAuth = SASL_TRY_AUTH;
  2696. else if (*val == 'A' || *val == 'a')
  2697. SASLTryAuth = SASL_AUTH_AUTH;
  2698. else
  2699. printf("Warning: Option: %s unknown parameter '%c'n",
  2700. o->o_name == NULL ? "<unknown>" : o->o_name,
  2701. (isascii(*val) && isprint(*val)) ? *val : '?');
  2702. break;
  2704. #else /* SASL */
  2705.   case O_SASLINFO:
  2706.   case O_SASLMECH:
  2707.   case O_SASLOPTS:
  2708. printf("Warning: Option: %s requires SASL support (-DSASL)n",
  2709. o->o_name == NULL ? "<unknown>" : o->o_name);
  2710. break;
  2711. #endif /* SASL */
  2714.   case O_CLIENTPORT:
  2715. #if DAEMON
  2716. setclientoptions(val);
  2717. #else /* DAEMON */
  2718. syserr("ClientPortOptions (O option) set but DAEMON not compiled in");
  2719. #endif /* DAEMON */
  2720. break;
  2722.   case O_DF_BUFSIZE:
  2723. DataFileBufferSize = atoi(val);
  2724. break;
  2726.   case O_XF_BUFSIZE:
  2727. XscriptFileBufferSize = atoi(val);
  2728. break;
  2730.   case O_LDAPDEFAULTSPEC:
  2731. #ifdef LDAPMAP
  2732. ldapmap_set_defaults(val);
  2733. #else /* LDAPMAP */
  2734. printf("Warning: Option: %s requires LDAP support (-DLDAPMAP)n",
  2735. o->o_name == NULL ? "<unknown>" : o->o_name);
  2736. #endif /* LDAPMAP */
  2737. break;
  2740.   default:
  2741. if (tTd(37, 1))
  2742. {
  2743. if (isascii(opt) && isprint(opt))
  2744. dprintf("Warning: option %c unknownn", opt);
  2745. else
  2746. dprintf("Warning: option 0x%x unknownn", opt);
  2747. }
  2748. break;
  2749. }
  2751. /*
  2752. **  Options with suboptions are responsible for taking care
  2753. **  of sticky-ness (e.g., that a command line setting is kept
  2754. **  when reading in the sendmail.cf file).  This has to be done
  2755. **  when the suboptions are parsed since each suboption must be
  2756. **  sticky, not the root option.
  2757. */
  2759. if (sticky && !bitset(OI_SUBOPT, o->o_flags))
  2760. setbitn(opt, StickyOpt);
  2761. }
  2762. /*
  2763. **  SETCLASS -- set a string into a class
  2764. **
  2765. ** Parameters:
  2766. ** class -- the class to put the string in.
  2767. ** str -- the string to enter
  2768. **
  2769. ** Returns:
  2770. ** none.
  2771. **
  2772. ** Side Effects:
  2773. ** puts the word into the symbol table.
  2774. */
  2776. void
  2777. setclass(class, str)
  2778. int class;
  2779. char *str;
  2780. {
  2781. register STAB *s;
  2783. if ((*str & 0377) == MATCHCLASS)
  2784. {
  2785. int mid;
  2787. str++;
  2788. mid = macid(str, NULL);
  2789. if (mid == '')
  2790. return;
  2792. if (tTd(37, 8))
  2793. dprintf("setclass(%s, $=%s)n",
  2794. macname(class), macname(mid));
  2795. copy_class(mid, class);
  2796. }
  2797. else
  2798. {
  2799. if (tTd(37, 8))
  2800. dprintf("setclass(%s, %s)n", macname(class), str);
  2802. s = stab(str, ST_CLASS, ST_ENTER);
  2803. setbitn(class, s->s_class);
  2804. }
  2805. }
  2806. /*
  2807. **  MAKEMAPENTRY -- create a map entry
  2808. **
  2809. ** Parameters:
  2810. ** line -- the config file line
  2811. **
  2812. ** Returns:
  2813. ** A pointer to the map that has been created.
  2814. ** NULL if there was a syntax error.
  2815. **
  2816. ** Side Effects:
  2817. ** Enters the map into the dictionary.
  2818. */
  2820. MAP *
  2821. makemapentry(line)
  2822. char *line;
  2823. {
  2824. register char *p;
  2825. char *mapname;
  2826. char *classname;
  2827. register STAB *s;
  2828. STAB *class;
  2830. for (p = line; isascii(*p) && isspace(*p); p++)
  2831. continue;
  2832. if (!(isascii(*p) && isalnum(*p)))
  2833. {
  2834. syserr("readcf: config K line: no map name");
  2835. return NULL;
  2836. }
  2838. mapname = p;
  2839. while ((isascii(*++p) && isalnum(*p)) || *p == '_' || *p == '.')
  2840. continue;
  2841. if (*p != '')
  2842. *p++ = '';
  2843. while (isascii(*p) && isspace(*p))
  2844. p++;
  2845. if (!(isascii(*p) && isalnum(*p)))
  2846. {
  2847. syserr("readcf: config K line, map %s: no map class", mapname);
  2848. return NULL;
  2849. }
  2850. classname = p;
  2851. while (isascii(*++p) && isalnum(*p))
  2852. continue;
  2853. if (*p != '')
  2854. *p++ = '';
  2855. while (isascii(*p) && isspace(*p))
  2856. p++;
  2858. /* look up the class */
  2859. class = stab(classname, ST_MAPCLASS, ST_FIND);
  2860. if (class == NULL)
  2861. {
  2862. syserr("readcf: map %s: class %s not available", mapname, classname);
  2863. return NULL;
  2864. }
  2866. /* enter the map */
  2867. s = stab(mapname, ST_MAP, ST_ENTER);
  2868. s->s_map.map_class = &class->s_mapclass;
  2869. s->s_map.map_mname = newstr(mapname);
  2871. if (class->s_mapclass.map_parse(&s->s_map, p))
  2872. s->s_map.map_mflags |= MF_VALID;
  2874. if (tTd(37, 5))
  2875. {
  2876. dprintf("map %s, class %s, flags %lx, file %s,n",
  2877. s->s_map.map_mname, s->s_map.map_class->map_cname,
  2878. s->s_map.map_mflags,
  2879. s->s_map.map_file == NULL ? "(null)" : s->s_map.map_file);
  2880. dprintf("tapp %s, domain %s, rebuild %sn",
  2881. s->s_map.map_app == NULL ? "(null)" : s->s_map.map_app,
  2882. s->s_map.map_domain == NULL ? "(null)" : s->s_map.map_domain,
  2883. s->s_map.map_rebuild == NULL ? "(null)" : s->s_map.map_rebuild);
  2884. }
  2886. return &s->s_map;
  2887. }
  2888. /*
  2889. **  STRTORWSET -- convert string to rewriting set number
  2890. **
  2891. ** Parameters:
  2892. ** p -- the pointer to the string to decode.
  2893. ** endp -- if set, store the trailing delimiter here.
  2894. ** stabmode -- ST_ENTER to create this entry, ST_FIND if
  2895. ** it must already exist.
  2896. **
  2897. ** Returns:
  2898. ** The appropriate ruleset number.
  2899. ** -1 if it is not valid (error already printed)
  2900. */
  2902. int
  2903. strtorwset(p, endp, stabmode)
  2904. char *p;
  2905. char **endp;
  2906. int stabmode;
  2907. {
  2908. int ruleset;
  2909. static int nextruleset = MAXRWSETS;
  2911. while (isascii(*p) && isspace(*p))
  2912. p++;
  2913. if (!isascii(*p))
  2914. {
  2915. syserr("invalid ruleset name: "%.20s"", p);
  2916. return -1;
  2917. }
  2918. if (isdigit(*p))
  2919. {
  2920. ruleset = strtol(p, endp, 10);
  2921. if (ruleset >= MAXRWSETS / 2 || ruleset < 0)
  2922. {
  2923. syserr("bad ruleset %d (%d max)",
  2924. ruleset, MAXRWSETS / 2);
  2925. ruleset = -1;
  2926. }
  2927. }
  2928. else
  2929. {
  2930. STAB *s;
  2931. char delim;
  2932. char *q = NULL;
  2934. q = p;
  2935. while (*p != '' && isascii(*p) &&
  2936.        (isalnum(*p) || *p == '_'))
  2937. p++;
  2938. if (q == p || !(isascii(*q) && isalpha(*q)))
  2939. {
  2940. /* no valid characters */
  2941. syserr("invalid ruleset name: "%.20s"", q);
  2942. return -1;
  2943. }
  2944. while (isascii(*p) && isspace(*p))
  2945. *p++ = '';
  2946. delim = *p;
  2947. if (delim != '')
  2948. *p = '';
  2949. s = stab(q, ST_RULESET, stabmode);
  2950. if (delim != '')
  2951. *p = delim;
  2953. if (s == NULL)
  2954. return -1;
  2956. if (stabmode == ST_ENTER && delim == '=')
  2957. {
  2958. while (isascii(*++p) && isspace(*p))
  2959. continue;
  2960. if (!(isascii(*p) && isdigit(*p)))
  2961. {
  2962. syserr("bad ruleset definition "%s" (number required after `=')", q);
  2963. ruleset = -1;
  2964. }
  2965. else
  2966. {
  2967. ruleset = strtol(p, endp, 10);
  2968. if (ruleset >= MAXRWSETS / 2 || ruleset < 0)
  2969. {
  2970. syserr("bad ruleset number %d in "%s" (%d max)",
  2971. ruleset, q, MAXRWSETS / 2);
  2972. ruleset = -1;
  2973. }
  2974. }
  2975. }
  2976. else
  2977. {
  2978. if (endp != NULL)
  2979. *endp = p;
  2980. if (s->s_ruleset >= 0)
  2981. ruleset = s->s_ruleset;
  2982. else if ((ruleset = --nextruleset) < MAXRWSETS / 2)
  2983. {
  2984. syserr("%s: too many named rulesets (%d max)",
  2985. q, MAXRWSETS / 2);
  2986. ruleset = -1;
  2987. }
  2988. }
  2989. if (s->s_ruleset >= 0 &&
  2990.     ruleset >= 0 &&
  2991.     ruleset != s->s_ruleset)
  2992. {
  2993. syserr("%s: ruleset changed value (old %d, new %d)",
  2994. q, s->s_ruleset, ruleset);
  2995. ruleset = s->s_ruleset;
  2996. }
  2997. else if (ruleset >= 0)
  2998. {
  2999. s->s_ruleset = ruleset;
  3000. }
  3001. if (stabmode == ST_ENTER)
  3002. {
  3003. char *h = NULL;
  3005. if (RuleSetNames[ruleset] != NULL)
  3006. free(RuleSetNames[ruleset]);
  3007. if (delim != '' && (h = strchr(q, delim)) != NULL)
  3008. *h = '';
  3009. RuleSetNames[ruleset] = newstr(q);
  3010. if (delim == '/' && h != NULL)
  3011. *h = delim; /* put back delim */
  3012. }
  3013. }
  3014. return ruleset;
  3015. }
  3016. /*
  3017. **  SETTIMEOUT -- set an individual timeout
  3018. **
  3019. ** Parameters:
  3020. ** name -- the name of the timeout.
  3021. ** val -- the value of the timeout.
  3022. ** sticky -- if set, don't let other setoptions override
  3023. ** this value.
  3024. **
  3025. ** Returns:
  3026. ** none.
  3027. */
  3029. /* set if Timeout sub-option is stuck */
  3030. static BITMAP256 StickyTimeoutOpt;
  3032. static struct timeoutinfo
  3033. {
  3034. char *to_name; /* long name of timeout */
  3035. u_char to_code; /* code for option */
  3036. } TimeOutTab[] =
  3037. {
  3038. #define TO_INITIAL 0x01
  3039. { "initial", TO_INITIAL },
  3040. #define TO_MAIL 0x02
  3041. { "mail", TO_MAIL },
  3042. #define TO_RCPT 0x03
  3043. { "rcpt", TO_RCPT },
  3044. #define TO_DATAINIT 0x04
  3045. { "datainit", TO_DATAINIT },
  3046. #define TO_DATABLOCK 0x05
  3047. { "datablock", TO_DATABLOCK },
  3048. #define TO_DATAFINAL 0x06
  3049. { "datafinal", TO_DATAFINAL },
  3050. #define TO_COMMAND 0x07
  3051. { "command", TO_COMMAND },
  3052. #define TO_RSET 0x08
  3053. { "rset", TO_RSET },
  3054. #define TO_HELO 0x09
  3055. { "helo", TO_HELO },
  3056. #define TO_QUIT 0x0A
  3057. { "quit", TO_QUIT },
  3058. #define TO_MISC 0x0B
  3059. { "misc", TO_MISC },
  3060. #define TO_IDENT 0x0C
  3061. { "ident", TO_IDENT },
  3062. #define TO_FILEOPEN 0x0D
  3063. { "fileopen", TO_FILEOPEN },
  3064. #define TO_CONNECT 0x0E
  3065. { "connect", TO_CONNECT },
  3066. #define TO_ICONNECT 0x0F
  3067. { "iconnect", TO_ICONNECT },
  3068. #define TO_QUEUEWARN 0x10
  3069. { "queuewarn", TO_QUEUEWARN },
  3070. { "queuewarn.*", TO_QUEUEWARN },
  3071. #define TO_QUEUEWARN_NORMAL 0x11
  3072. { "queuewarn.normal", TO_QUEUEWARN_NORMAL },
  3073. #define TO_QUEUEWARN_URGENT 0x12
  3074. { "queuewarn.urgent", TO_QUEUEWARN_URGENT },
  3075. #define TO_QUEUEWARN_NON_URGENT 0x13
  3076. { "queuewarn.non-urgent", TO_QUEUEWARN_NON_URGENT },
  3077. #define TO_QUEUERETURN 0x14
  3078. { "queuereturn", TO_QUEUERETURN },
  3079. { "queuereturn.*", TO_QUEUERETURN },
  3080. #define TO_QUEUERETURN_NORMAL 0x15
  3081. { "queuereturn.normal", TO_QUEUERETURN_NORMAL },
  3082. #define TO_QUEUERETURN_URGENT 0x16
  3083. { "queuereturn.urgent", TO_QUEUERETURN_URGENT },
  3084. #define TO_QUEUERETURN_NON_URGENT 0x17
  3085. { "queuereturn.non-urgent", TO_QUEUERETURN_NON_URGENT },
  3086. #define TO_HOSTSTATUS 0x18
  3087. { "hoststatus", TO_HOSTSTATUS },
  3088. #define TO_RESOLVER_RETRANS 0x19
  3089. { "resolver.retrans", TO_RESOLVER_RETRANS },
  3090. #define TO_RESOLVER_RETRANS_NORMAL 0x1A
  3091. { "resolver.retrans.normal", TO_RESOLVER_RETRANS_NORMAL },
  3092. #define TO_RESOLVER_RETRANS_FIRST 0x1B
  3093. { "resolver.retrans.first", TO_RESOLVER_RETRANS_FIRST },
  3094. #define TO_RESOLVER_RETRY 0x1C
  3095. { "resolver.retry", TO_RESOLVER_RETRY },
  3096. #define TO_RESOLVER_RETRY_NORMAL 0x1D
  3097. { "resolver.retry.normal", TO_RESOLVER_RETRY_NORMAL },
  3098. #define TO_RESOLVER_RETRY_FIRST 0x1E
  3099. { "resolver.retry.first", TO_RESOLVER_RETRY_FIRST },
  3100. #define TO_CONTROL 0x1F
  3101. { "control", TO_CONTROL },
  3102. { NULL, 0 },
  3103. };
  3106. static void
  3107. settimeout(name, val, sticky)
  3108. char *name;
  3109. char *val;
  3110. bool sticky;
  3111. {
  3112. register struct timeoutinfo *to;
  3113. int i;
  3114. time_t toval;
  3116. if (tTd(37, 2))
  3117. dprintf("settimeout(%s = %s)", name, val);
  3119. for (to = TimeOutTab; to->to_name != NULL; to++)
  3120. {
  3121. if (strcasecmp(to->to_name, name) == 0)
  3122. break;
  3123. }
  3125. if (to->to_name == NULL)
  3126. syserr("settimeout: invalid timeout %s", name);
  3128. /*
  3129. **  See if this option is preset for us.
  3130. */
  3132. if (!sticky && bitnset(to->to_code, StickyTimeoutOpt))
  3133. {
  3134. if (tTd(37, 2))
  3135. dprintf(" (ignored)n");
  3136. return;
  3137. }
  3139. if (tTd(37, 2))
  3140. dprintf("n");
  3142. toval = convtime(val, 'm');
  3144. switch (to->to_code)
  3145. {
  3146.   case TO_INITIAL:
  3147. TimeOuts.to_initial = toval;
  3148. break;
  3150.   case TO_MAIL:
  3151. TimeOuts.to_mail = toval;
  3152. break;
  3154.   case TO_RCPT:
  3155. TimeOuts.to_rcpt = toval;
  3156. break;
  3158.   case TO_DATAINIT:
  3159. TimeOuts.to_datainit = toval;
  3160. break;
  3162.   case TO_DATABLOCK:
  3163. TimeOuts.to_datablock = toval;
  3164. break;
  3166.   case TO_DATAFINAL:
  3167. TimeOuts.to_datafinal = toval;
  3168. break;
  3170.   case TO_COMMAND:
  3171. TimeOuts.to_nextcommand = toval;
  3172. break;
  3174.   case TO_RSET:
  3175. TimeOuts.to_rset = toval;
  3176. break;
  3178.   case TO_HELO:
  3179. TimeOuts.to_helo = toval;
  3180. break;
  3182.   case TO_QUIT:
  3183. TimeOuts.to_quit = toval;
  3184. break;
  3186.   case TO_MISC:
  3187. TimeOuts.to_miscshort = toval;
  3188. break;
  3190.   case TO_IDENT:
  3191. TimeOuts.to_ident = toval;
  3192. break;
  3194.   case TO_FILEOPEN:
  3195. TimeOuts.to_fileopen = toval;
  3196. break;
  3198.   case TO_CONNECT:
  3199. TimeOuts.to_connect = toval;
  3200. break;
  3202.   case TO_ICONNECT:
  3203. TimeOuts.to_iconnect = toval;
  3204. break;
  3206.   case TO_QUEUEWARN:
  3207. toval = convtime(val, 'h');
  3208. TimeOuts.to_q_warning[TOC_NORMAL] = toval;
  3209. TimeOuts.to_q_warning[TOC_URGENT] = toval;
  3210. TimeOuts.to_q_warning[TOC_NONURGENT] = toval;
  3211. break;
  3213.   case TO_QUEUEWARN_NORMAL:
  3214. toval = convtime(val, 'h');
  3215. TimeOuts.to_q_warning[TOC_NORMAL] = toval;
  3216. break;
  3218.   case TO_QUEUEWARN_URGENT:
  3219. toval = convtime(val, 'h');
  3220. TimeOuts.to_q_warning[TOC_URGENT] = toval;
  3221. break;
  3223.   case TO_QUEUEWARN_NON_URGENT:
  3224. toval = convtime(val, 'h');
  3225. TimeOuts.to_q_warning[TOC_NONURGENT] = toval;
  3226. break;
  3228.   case TO_QUEUERETURN:
  3229. toval = convtime(val, 'd');
  3230. TimeOuts.to_q_return[TOC_NORMAL] = toval;
  3231. TimeOuts.to_q_return[TOC_URGENT] = toval;
  3232. TimeOuts.to_q_return[TOC_NONURGENT] = toval;
  3233. break;
  3235.   case TO_QUEUERETURN_NORMAL:
  3236. toval = convtime(val, 'd');
  3237. TimeOuts.to_q_return[TOC_NORMAL] = toval;
  3238. break;
  3240.   case TO_QUEUERETURN_URGENT:
  3241. toval = convtime(val, 'd');
  3242. TimeOuts.to_q_return[TOC_URGENT] = toval;
  3243. break;
  3245.   case TO_QUEUERETURN_NON_URGENT:
  3246. toval = convtime(val, 'd');
  3247. TimeOuts.to_q_return[TOC_NONURGENT] = toval;
  3248. break;
  3251.   case TO_HOSTSTATUS:
  3252. MciInfoTimeout = convtime(val, 'm');
  3253. break;
  3255.   case TO_RESOLVER_RETRANS:
  3256. toval = convtime(val, 's');
  3257. TimeOuts.res_retrans[RES_TO_DEFAULT] = toval;
  3258. TimeOuts.res_retrans[RES_TO_FIRST] = toval;
  3259. TimeOuts.res_retrans[RES_TO_NORMAL] = toval;
  3260. break;
  3262.   case TO_RESOLVER_RETRY:
  3263. i = atoi(val);
  3264. TimeOuts.res_retry[RES_TO_DEFAULT] = i;
  3265. TimeOuts.res_retry[RES_TO_FIRST] = i;
  3266. TimeOuts.res_retry[RES_TO_NORMAL] = i;
  3267. break;
  3269.   case TO_RESOLVER_RETRANS_NORMAL:
  3270. TimeOuts.res_retrans[RES_TO_NORMAL] = convtime(val, 's');
  3271. break;
  3273.   case TO_RESOLVER_RETRY_NORMAL:
  3274. TimeOuts.res_retry[RES_TO_NORMAL] = atoi(val);
  3275. break;
  3277.   case TO_RESOLVER_RETRANS_FIRST:
  3278. TimeOuts.res_retrans[RES_TO_FIRST] = convtime(val, 's');
  3279. break;
  3281.   case TO_RESOLVER_RETRY_FIRST:
  3282. TimeOuts.res_retry[RES_TO_FIRST] = atoi(val);
  3283. break;
  3285.   case TO_CONTROL:
  3286. TimeOuts.to_control = toval;
  3287. break;
  3289.   default:
  3290. syserr("settimeout: invalid timeout %s", name);
  3291. break;
  3292. }
  3294. if (sticky)
  3295. setbitn(to->to_code, StickyTimeoutOpt);
  3296. }
  3297. /*
  3298. **  INITTIMEOUTS -- parse and set timeout values
  3299. **
  3300. ** Parameters:
  3301. ** val -- a pointer to the values.  If NULL, do initial
  3302. ** settings.
  3303. ** sticky -- if set, don't let other setoptions override
  3304. ** this suboption value.
  3305. **
  3306. ** Returns:
  3307. ** none.
  3308. **
  3309. ** Side Effects:
  3310. ** Initializes the TimeOuts structure
  3311. */
  3313. void
  3314. inittimeouts(val, sticky)
  3315. register char *val;
  3316. bool sticky;
  3317. {
  3318. register char *p;
  3320. if (tTd(37, 2))
  3321. dprintf("inittimeouts(%s)n", val == NULL ? "<NULL>" : val);
  3322. if (val == NULL)
  3323. {
  3324. TimeOuts.to_connect = (time_t) 0 SECONDS;
  3325. TimeOuts.to_initial = (time_t) 5 MINUTES;
  3326. TimeOuts.to_helo = (time_t) 5 MINUTES;
  3327. TimeOuts.to_mail = (time_t) 10 MINUTES;
  3328. TimeOuts.to_rcpt = (time_t) 1 HOUR;
  3329. TimeOuts.to_datainit = (time_t) 5 MINUTES;
  3330. TimeOuts.to_datablock = (time_t) 1 HOUR;
  3331. TimeOuts.to_datafinal = (time_t) 1 HOUR;
  3332. TimeOuts.to_rset = (time_t) 5 MINUTES;
  3333. TimeOuts.to_quit = (time_t) 2 MINUTES;
  3334. TimeOuts.to_nextcommand = (time_t) 1 HOUR;
  3335. TimeOuts.to_miscshort = (time_t) 2 MINUTES;
  3336. #if IDENTPROTO
  3337. TimeOuts.to_ident = (time_t) 30 SECONDS;
  3338. #else /* IDENTPROTO */
  3339. TimeOuts.to_ident = (time_t) 0 SECONDS;
  3340. #endif /* IDENTPROTO */
  3341. TimeOuts.to_fileopen = (time_t) 60 SECONDS;
  3342. TimeOuts.to_control = (time_t) 2 MINUTES;
  3343. if (tTd(37, 5))
  3344. {
  3345. dprintf("Timeouts:n");
  3346. dprintf("  connect = %ldn", (long)TimeOuts.to_connect);
  3347. dprintf("  initial = %ldn", (long)TimeOuts.to_initial);
  3348. dprintf("  helo = %ldn", (long)TimeOuts.to_helo);
  3349. dprintf("  mail = %ldn", (long)TimeOuts.to_mail);
  3350. dprintf("  rcpt = %ldn", (long)TimeOuts.to_rcpt);
  3351. dprintf("  datainit = %ldn", (long)TimeOuts.to_datainit);
  3352. dprintf("  datablock = %ldn", (long)TimeOuts.to_datablock);
  3353. dprintf("  datafinal = %ldn", (long)TimeOuts.to_datafinal);
  3354. dprintf("  rset = %ldn", (long)TimeOuts.to_rset);
  3355. dprintf("  quit = %ldn", (long)TimeOuts.to_quit);
  3356. dprintf("  nextcommand = %ldn", (long)TimeOuts.to_nextcommand);
  3357. dprintf("  miscshort = %ldn", (long)TimeOuts.to_miscshort);
  3358. dprintf("  ident = %ldn", (long)TimeOuts.to_ident);
  3359. dprintf("  fileopen = %ldn", (long)TimeOuts.to_fileopen);
  3360. dprintf("  control = %ldn", (long)TimeOuts.to_control);
  3361. }
  3362. return;
  3363. }
  3365. for (;; val = p)
  3366. {
  3367. while (isascii(*val) && isspace(*val))
  3368. val++;
  3369. if (*val == '')
  3370. break;
  3371. for (p = val; *p != '' && *p != ','; p++)
  3372. continue;
  3373. if (*p != '')
  3374. *p++ = '';
  3376. if (isascii(*val) && isdigit(*val))
  3377. {
  3378. /* old syntax -- set everything */
  3379. TimeOuts.to_mail = convtime(val, 'm');
  3380. TimeOuts.to_rcpt = TimeOuts.to_mail;
  3381. TimeOuts.to_datainit = TimeOuts.to_mail;
  3382. TimeOuts.to_datablock = TimeOuts.to_mail;
  3383. TimeOuts.to_datafinal = TimeOuts.to_mail;
  3384. TimeOuts.to_nextcommand = TimeOuts.to_mail;
  3385. if (sticky)
  3386. {
  3387. setbitn(TO_MAIL, StickyTimeoutOpt);
  3388. setbitn(TO_RCPT, StickyTimeoutOpt);
  3389. setbitn(TO_DATAINIT, StickyTimeoutOpt);
  3390. setbitn(TO_DATABLOCK, StickyTimeoutOpt);
  3391. setbitn(TO_DATAFINAL, StickyTimeoutOpt);
  3392. setbitn(TO_COMMAND, StickyTimeoutOpt);
  3393. }
  3394. continue;
  3395. }
  3396. else
  3397. {
  3398. register char *q = strchr(val, ':');
  3400. if (q == NULL && (q = strchr(val, '=')) == NULL)
  3401. {
  3402. /* syntax error */
  3403. continue;
  3404. }
  3405. *q++ = '';
  3406. settimeout(val, q, sticky);
  3407. }
  3408. }
  3409. }