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

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

Email客户端

开发平台：

Unix_Linux

alias.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.  */
  13. #include <sendmail.h>
  15. #ifndef lint
  16. static char id[] = "@(#)$Id: alias.c,v 8.138 1999/11/19 05:44:02 gshapiro Exp $";
  17. #endif /* ! lint */
  19. static MAP *AliasFileMap = NULL; /* the actual aliases.files map */
  20. static int NAliasFileMaps; /* the number of entries in AliasFileMap */
  22. static char *aliaslookup __P((char *, int *));
  24. /*
  25. **  ALIAS -- Compute aliases.
  26. **
  27. ** Scans the alias file for an alias for the given address.
  28. ** If found, it arranges to deliver to the alias list instead.
  29. ** Uses libdbm database if -DDBM.
  30. **
  31. ** Parameters:
  32. ** a -- address to alias.
  33. ** sendq -- a pointer to the head of the send queue
  34. ** to put the aliases in.
  35. ** aliaslevel -- the current alias nesting depth.
  36. ** e -- the current envelope.
  37. **
  38. ** Returns:
  39. ** none
  40. **
  41. ** Side Effects:
  42. ** Aliases found are expanded.
  43. **
  44. ** Deficiencies:
  45. ** It should complain about names that are aliased to
  46. ** nothing.
  47. */
  49. void
  50. alias(a, sendq, aliaslevel, e)
  51. register ADDRESS *a;
  52. ADDRESS **sendq;
  53. int aliaslevel;
  54. register ENVELOPE *e;
  55. {
  56. register char *p;
  57. char *owner;
  58. auto int status = EX_OK;
  59. char obuf[MAXNAME + 7];
  61. if (tTd(27, 1))
  62. dprintf("alias(%s)n", a->q_user);
  64. /* don't realias already aliased names */
  65. if (!QS_IS_OK(a->q_state))
  66. return;
  68. if (NoAlias)
  69. return;
  71. e->e_to = a->q_paddr;
  73. /*
  74. **  Look up this name.
  75. **
  76. ** If the map was unavailable, we will queue this message
  77. ** until the map becomes available; otherwise, we could
  78. ** bounce messages inappropriately.
  79. */
  82. #if _FFR_REDIRECTEMPTY
  83. /*
  84. **  envelope <> can't be sent to mailing lists, only owner-
  85. **  send spam of this type to owner- of the list
  86. **  ----  to stop spam from going to mailing lists!
  87. */
  88. if (e->e_sender != NULL && *e->e_sender == '')
  89. {
  90. /* Look for owner of alias */
  91. (void) strlcpy(obuf, "owner-", sizeof obuf);
  92. (void) strlcat(obuf, a->q_user, sizeof obuf);
  93. if (aliaslookup(obuf, &status) != NULL)
  94. {
  95. if (LogLevel > 8)
  96. syslog(LOG_WARNING,
  97.        "possible spam from <> to list: %s, redirected to %sn",
  98.        a->q_user, obuf);
  99. a->q_user = newstr(obuf);
  100. }
  101. }
  102. #endif /* _FFR_REDIRECTEMPTY */
  104. p = aliaslookup(a->q_user, &status);
  105. if (status == EX_TEMPFAIL || status == EX_UNAVAILABLE)
  106. {
  107. a->q_state = QS_QUEUEUP;
  108. if (e->e_message == NULL)
  109. e->e_message = newstr("alias database unavailable");
  110. return;
  111. }
  112. if (p == NULL)
  113. return;
  115. /*
  116. **  Match on Alias.
  117. ** Deliver to the target list.
  118. */
  120. if (tTd(27, 1))
  121. dprintf("%s (%s, %s) aliased to %sn",
  122. a->q_paddr, a->q_host, a->q_user, p);
  123. if (bitset(EF_VRFYONLY, e->e_flags))
  124. {
  125. a->q_state = QS_VERIFIED;
  126. return;
  127. }
  128. message("aliased to %s", shortenstring(p, MAXSHORTSTR));
  129. if (LogLevel > 10)
  130. sm_syslog(LOG_INFO, e->e_id,
  131. "alias %.100s => %s",
  132. a->q_paddr, shortenstring(p, MAXSHORTSTR));
  133. a->q_flags &= ~QSELFREF;
  134. if (tTd(27, 5))
  135. {
  136. dprintf("alias: QS_EXPANDED ");
  137. printaddr(a, FALSE);
  138. }
  139. a->q_state = QS_EXPANDED;
  141. /*
  142. **  Always deliver aliased items as the default user.
  143. **  Setting q_gid to 0 forces deliver() to use DefUser
  144. **  instead of the alias name for the call to initgroups().
  145. */
  147. a->q_uid = DefUid;
  148. a->q_gid = 0;
  149. a->q_fullname = NULL;
  150. a->q_flags |= QGOODUID;
  152. (void) sendtolist(p, a, sendq, aliaslevel + 1, e);
  153. if (bitset(QSELFREF, a->q_flags) && QS_IS_EXPANDED(a->q_state))
  154. a->q_state = QS_OK;
  156. /*
  157. **  Look for owner of alias
  158. */
  160. (void) strlcpy(obuf, "owner-", sizeof obuf);
  161. if (strncmp(a->q_user, "owner-", 6) == 0 ||
  162.     strlen(a->q_user) > (SIZE_T) sizeof obuf - 7)
  163. (void) strlcat(obuf, "owner", sizeof obuf);
  164. else
  165. (void) strlcat(obuf, a->q_user, sizeof obuf);
  166. owner = aliaslookup(obuf, &status);
  167. if (owner == NULL)
  168. return;
  170. /* reflect owner into envelope sender */
  171. if (strpbrk(owner, ",:/|"") != NULL)
  172. owner = obuf;
  173. a->q_owner = newstr(owner);
  175. /* announce delivery to this alias; NORECEIPT bit set later */
  176. if (e->e_xfp != NULL)
  177. fprintf(e->e_xfp, "Message delivered to mailing list %sn",
  178. a->q_paddr);
  179. e->e_flags |= EF_SENDRECEIPT;
  180. a->q_flags |= QDELIVERED|QEXPANDED;
  181. }
  182. /*
  183. **  ALIASLOOKUP -- look up a name in the alias file.
  184. **
  185. ** Parameters:
  186. ** name -- the name to look up.
  187. ** pstat -- a pointer to a place to put the status.
  188. **
  189. ** Returns:
  190. ** the value of name.
  191. ** NULL if unknown.
  192. **
  193. ** Side Effects:
  194. ** none.
  195. **
  196. ** Warnings:
  197. ** The return value will be trashed across calls.
  198. */
  200. static char *
  201. aliaslookup(name, pstat)
  202. char *name;
  203. int *pstat;
  204. {
  205. static MAP *map = NULL;
  207. if (map == NULL)
  208. {
  209. STAB *s = stab("aliases", ST_MAP, ST_FIND);
  211. if (s == NULL)
  212. return NULL;
  213. map = &s->s_map;
  214. }
  215. DYNOPENMAP(map);
  217. /* special case POstMastER -- always use lower case */
  218. if (strcasecmp(name, "postmaster") == 0)
  219. name = "postmaster";
  221. return (*map->map_class->map_lookup)(map, name, NULL, pstat);
  222. }
  223. /*
  224. **  SETALIAS -- set up an alias map
  225. **
  226. ** Called when reading configuration file.
  227. **
  228. ** Parameters:
  229. ** spec -- the alias specification
  230. **
  231. ** Returns:
  232. ** none.
  233. */
  235. void
  236. setalias(spec)
  237. char *spec;
  238. {
  239. register char *p;
  240. register MAP *map;
  241. char *class;
  242. STAB *s;
  244. if (tTd(27, 8))
  245. dprintf("setalias(%s)n", spec);
  247. for (p = spec; p != NULL; )
  248. {
  249. char buf[50];
  251. while (isascii(*p) && isspace(*p))
  252. p++;
  253. if (*p == '')
  254. break;
  255. spec = p;
  257. if (NAliasFileMaps >= MAXMAPSTACK)
  258. {
  259. syserr("Too many alias databases defined, %d max",
  260. MAXMAPSTACK);
  261. return;
  262. }
  263. if (AliasFileMap == NULL)
  264. {
  265. (void) strlcpy(buf, "aliases.files sequence",
  266.        sizeof buf);
  267. AliasFileMap = makemapentry(buf);
  268. if (AliasFileMap == NULL)
  269. {
  270. syserr("setalias: cannot create aliases.files map");
  271. return;
  272. }
  273. }
  274. (void) snprintf(buf, sizeof buf, "Alias%d", NAliasFileMaps);
  275. s = stab(buf, ST_MAP, ST_ENTER);
  276. map = &s->s_map;
  277. memset(map, '', sizeof *map);
  278. map->map_mname = s->s_name;
  280. p = strpbrk(p, " ,/:");
  281. if (p != NULL && *p == ':')
  282. {
  283. /* map name */
  284. *p++ = '';
  285. class = spec;
  286. spec = p;
  287. }
  288. else
  289. {
  290. class = "implicit";
  291. map->map_mflags = MF_INCLNULL;
  292. }
  294. /* find end of spec */
  295. if (p != NULL)
  296. {
  297. bool quoted = FALSE;
  299. for (; *p != ''; p++)
  300. {
  301. /*
  302. **  Don't break into a quoted string.
  303. **  Needed for ldap maps which use
  304. **  commas in their specifications.
  305. */
  307. if (*p == '"')
  308. quoted = !quoted;
  309. else if (*p == ',' && !quoted)
  310. break;
  311. }
  313. /* No more alias specifications follow */
  314. if (*p == '')
  315. p = NULL;
  316. }
  317. if (p != NULL)
  318. *p++ = '';
  320. if (tTd(27, 20))
  321. dprintf("  map %s:%s %sn", class, s->s_name, spec);
  323. /* look up class */
  324. s = stab(class, ST_MAPCLASS, ST_FIND);
  325. if (s == NULL)
  326. {
  327. syserr("setalias: unknown alias class %s", class);
  328. }
  329. else if (!bitset(MCF_ALIASOK, s->s_mapclass.map_cflags))
  330. {
  331. syserr("setalias: map class %s can't handle aliases",
  332. class);
  333. }
  334. else
  335. {
  336. map->map_class = &s->s_mapclass;
  337. if (map->map_class->map_parse(map, spec))
  338. {
  339. map->map_mflags |= MF_VALID|MF_ALIAS;
  340. AliasFileMap->map_stack[NAliasFileMaps++] = map;
  341. }
  342. }
  343. }
  344. }
  345. /*
  346. **  ALIASWAIT -- wait for distinguished @:@ token to appear.
  347. **
  348. ** This can decide to reopen or rebuild the alias file
  349. **
  350. ** Parameters:
  351. ** map -- a pointer to the map descriptor for this alias file.
  352. ** ext -- the filename extension (e.g., ".db") for the
  353. ** database file.
  354. ** isopen -- if set, the database is already open, and we
  355. ** should check for validity; otherwise, we are
  356. ** just checking to see if it should be created.
  357. **
  358. ** Returns:
  359. ** TRUE -- if the database is open when we return.
  360. ** FALSE -- if the database is closed when we return.
  361. */
  363. bool
  364. aliaswait(map, ext, isopen)
  365. MAP *map;
  366. char *ext;
  367. bool isopen;
  368. {
  369. bool attimeout = FALSE;
  370. time_t mtime;
  371. struct stat stb;
  372. char buf[MAXNAME + 1];
  374. if (tTd(27, 3))
  375. dprintf("aliaswait(%s:%s)n",
  376. map->map_class->map_cname, map->map_file);
  377. if (bitset(MF_ALIASWAIT, map->map_mflags))
  378. return isopen;
  379. map->map_mflags |= MF_ALIASWAIT;
  381. if (SafeAlias > 0)
  382. {
  383. auto int st;
  384. time_t toolong = curtime() + SafeAlias;
  385. unsigned int sleeptime = 2;
  387. while (isopen &&
  388.        map->map_class->map_lookup(map, "@", NULL, &st) == NULL)
  389. {
  390. if (curtime() > toolong)
  391. {
  392. /* we timed out */
  393. attimeout = TRUE;
  394. break;
  395. }
  397. /*
  398. **  Close and re-open the alias database in case
  399. **  the one is mv'ed instead of cp'ed in.
  400. */
  402. if (tTd(27, 2))
  403. dprintf("aliaswait: sleeping for %u secondsn",
  404. sleeptime);
  406. map->map_class->map_close(map);
  407. map->map_mflags &= ~(MF_OPEN|MF_WRITABLE);
  408. (void) sleep(sleeptime);
  409. sleeptime *= 2;
  410. if (sleeptime > 60)
  411. sleeptime = 60;
  412. isopen = map->map_class->map_open(map, O_RDONLY);
  413. }
  414. }
  416. /* see if we need to go into auto-rebuild mode */
  417. if (!bitset(MCF_REBUILDABLE, map->map_class->map_cflags))
  418. {
  419. if (tTd(27, 3))
  420. dprintf("aliaswait: not rebuildablen");
  421. map->map_mflags &= ~MF_ALIASWAIT;
  422. return isopen;
  423. }
  424. if (stat(map->map_file, &stb) < 0)
  425. {
  426. if (tTd(27, 3))
  427. dprintf("aliaswait: no source filen");
  428. map->map_mflags &= ~MF_ALIASWAIT;
  429. return isopen;
  430. }
  431. mtime = stb.st_mtime;
  432. snprintf(buf, sizeof buf, "%s%s",
  433. map->map_file, ext == NULL ? "" : ext);
  434. if (stat(buf, &stb) < 0 || stb.st_mtime < mtime || attimeout)
  435. {
  436. #if !_FFR_REMOVE_AUTOREBUILD
  437. /* database is out of date */
  438. if (AutoRebuild && stb.st_ino != 0 &&
  439.     (stb.st_uid == geteuid() ||
  440.      (geteuid() == 0 && stb.st_uid == TrustedUid)))
  441. {
  442. bool oldSuprErrs;
  444. message("auto-rebuilding alias database %s", buf);
  445. oldSuprErrs = SuprErrs;
  446. SuprErrs = TRUE;
  447. if (isopen)
  448. {
  449. map->map_class->map_close(map);
  450. map->map_mflags &= ~(MF_OPEN|MF_WRITABLE);
  451. }
  452. (void) rebuildaliases(map, TRUE);
  453. isopen = map->map_class->map_open(map, O_RDONLY);
  454. SuprErrs = oldSuprErrs;
  455. }
  456. else
  457. {
  458. if (LogLevel > 3)
  459. sm_syslog(LOG_INFO, NOQID,
  460. "alias database %s out of date",
  461. buf);
  462. message("Warning: alias database %s out of date", buf);
  463. }
  464. #else /* !_FFR_REMOVE_AUTOREBUILD */
  465. if (LogLevel > 3)
  466. sm_syslog(LOG_INFO, NOQID,
  467.   "alias database %s out of date",
  468.   buf);
  469. message("Warning: alias database %s out of date", buf);
  470. #endif /* !_FFR_REMOVE_AUTOREBUILD */
  471. }
  472. map->map_mflags &= ~MF_ALIASWAIT;
  473. return isopen;
  474. }
  475. /*
  476. **  REBUILDALIASES -- rebuild the alias database.
  477. **
  478. ** Parameters:
  479. ** map -- the database to rebuild.
  480. ** automatic -- set if this was automatically generated.
  481. **
  482. ** Returns:
  483. ** TRUE if successful; FALSE otherwise.
  484. **
  485. ** Side Effects:
  486. ** Reads the text version of the database, builds the
  487. ** DBM or DB version.
  488. */
  490. bool
  491. rebuildaliases(map, automatic)
  492. register MAP *map;
  493. bool automatic;
  494. {
  495. FILE *af;
  496. bool nolock = FALSE;
  497. bool success = FALSE;
  498. long sff = SFF_OPENASROOT|SFF_REGONLY|SFF_NOLOCK;
  499. sigfunc_t oldsigint, oldsigquit;
  500. #ifdef SIGTSTP
  501. sigfunc_t oldsigtstp;
  502. #endif /* SIGTSTP */
  504. if (!bitset(MCF_REBUILDABLE, map->map_class->map_cflags))
  505. return FALSE;
  507. if (!bitnset(DBS_LINKEDALIASFILEINWRITABLEDIR, DontBlameSendmail))
  508. sff |= SFF_NOWLINK;
  509. if (!bitnset(DBS_GROUPWRITABLEALIASFILE, DontBlameSendmail))
  510. sff |= SFF_NOGWFILES;
  511. if (!bitnset(DBS_WORLDWRITABLEALIASFILE, DontBlameSendmail))
  512. sff |= SFF_NOWWFILES;
  514. /* try to lock the source file */
  515. if ((af = safefopen(map->map_file, O_RDWR, 0, sff)) == NULL)
  516. {
  517. struct stat stb;
  519. if ((errno != EACCES && errno != EROFS) || automatic ||
  520.     (af = safefopen(map->map_file, O_RDONLY, 0, sff)) == NULL)
  521. {
  522. int saveerr = errno;
  524. if (tTd(27, 1))
  525. dprintf("Can't open %s: %sn",
  526. map->map_file, errstring(saveerr));
  527. if (!automatic && !bitset(MF_OPTIONAL, map->map_mflags))
  528. message("newaliases: cannot open %s: %s",
  529. map->map_file, errstring(saveerr));
  530. errno = 0;
  531. return FALSE;
  532. }
  533. nolock = TRUE;
  534. if (tTd(27, 1) ||
  535.     fstat(fileno(af), &stb) < 0 ||
  536.     bitset(S_IWUSR|S_IWGRP|S_IWOTH, stb.st_mode))
  537. message("warning: cannot lock %s: %s",
  538. map->map_file, errstring(errno));
  539. }
  541. /* see if someone else is rebuilding the alias file */
  542. if (!nolock &&
  543.     !lockfile(fileno(af), map->map_file, NULL, LOCK_EX|LOCK_NB))
  544. {
  545. /* yes, they are -- wait until done */
  546. message("Alias file %s is locked (maybe being rebuilt)",
  547. map->map_file);
  548. if (OpMode != MD_INITALIAS)
  549. {
  550. /* wait for other rebuild to complete */
  551. (void) lockfile(fileno(af), map->map_file, NULL,
  552. LOCK_EX);
  553. }
  554. (void) fclose(af);
  555. errno = 0;
  556. return FALSE;
  557. }
  559. oldsigint = setsignal(SIGINT, SIG_IGN);
  560. oldsigquit = setsignal(SIGQUIT, SIG_IGN);
  561. #ifdef SIGTSTP
  562. oldsigtstp = setsignal(SIGTSTP, SIG_IGN);
  563. #endif /* SIGTSTP */
  565. if (map->map_class->map_open(map, O_RDWR))
  566. {
  567. if (LogLevel > 7)
  568. {
  569. sm_syslog(LOG_NOTICE, NOQID,
  570. "alias database %s %srebuilt by %s",
  571. map->map_file, automatic ? "auto" : "",
  572. username());
  573. }
  574. map->map_mflags |= MF_OPEN|MF_WRITABLE;
  575. map->map_pid = getpid();
  576. readaliases(map, af, !automatic, TRUE);
  577. success = TRUE;
  578. }
  579. else
  580. {
  581. if (tTd(27, 1))
  582. dprintf("Can't create database for %s: %sn",
  583. map->map_file, errstring(errno));
  584. if (!automatic)
  585. syserr("Cannot create database for alias file %s",
  586. map->map_file);
  587. }
  589. /* close the file, thus releasing locks */
  590. (void) fclose(af);
  592. /* add distinguished entries and close the database */
  593. if (bitset(MF_OPEN, map->map_mflags))
  594. {
  595. map->map_class->map_close(map);
  596. map->map_mflags &= ~(MF_OPEN|MF_WRITABLE);
  597. }
  599. /* restore the old signals */
  600. (void) setsignal(SIGINT, oldsigint);
  601. (void) setsignal(SIGQUIT, oldsigquit);
  602. #ifdef SIGTSTP
  603. (void) setsignal(SIGTSTP, oldsigtstp);
  604. #endif /* SIGTSTP */
  605. return success;
  606. }
  607. /*
  608. **  READALIASES -- read and process the alias file.
  609. **
  610. ** This routine implements the part of initaliases that occurs
  611. ** when we are not going to use the DBM stuff.
  612. **
  613. ** Parameters:
  614. ** map -- the alias database descriptor.
  615. ** af -- file to read the aliases from.
  616. ** announcestats -- announce statistics regarding number of
  617. ** aliases, longest alias, etc.
  618. ** logstats -- lot the same info.
  619. **
  620. ** Returns:
  621. ** none.
  622. **
  623. ** Side Effects:
  624. ** Reads aliasfile into the symbol table.
  625. ** Optionally, builds the .dir & .pag files.
  626. */
  628. void
  629. readaliases(map, af, announcestats, logstats)
  630. register MAP *map;
  631. FILE *af;
  632. bool announcestats;
  633. bool logstats;
  634. {
  635. register char *p;
  636. char *rhs;
  637. bool skipping;
  638. long naliases, bytes, longest;
  639. ADDRESS al, bl;
  640. char line[BUFSIZ];
  642. /*
  643. **  Read and interpret lines
  644. */
  646. FileName = map->map_file;
  647. LineNumber = 0;
  648. naliases = bytes = longest = 0;
  649. skipping = FALSE;
  650. while (fgets(line, sizeof line, af) != NULL)
  651. {
  652. int lhssize, rhssize;
  653. int c;
  655. LineNumber++;
  656. p = strchr(line, 'n');
  657. while (p != NULL && p > line && p[-1] == '\')
  658. {
  659. p--;
  660. if (fgets(p, SPACELEFT(line, p), af) == NULL)
  661. break;
  662. LineNumber++;
  663. p = strchr(p, 'n');
  664. }
  665. if (p != NULL)
  666. *p = '';
  667. else if (!feof(af))
  668. {
  669. syserr("554 5.3.0 alias line too long");
  671. /* flush to end of line */
  672. while ((c = getc(af)) != EOF && c != 'n')
  673. continue;
  675. /* skip any continuation lines */
  676. skipping = TRUE;
  677. continue;
  678. }
  679. switch (line[0])
  680. {
  681.   case '#':
  682.   case '':
  683. skipping = FALSE;
  684. continue;
  686.   case ' ':
  687.   case 't':
  688. if (!skipping)
  689. syserr("554 5.3.5 Non-continuation line starts with space");
  690. skipping = TRUE;
  691. continue;
  692. }
  693. skipping = FALSE;
  695. /*
  696. **  Process the LHS
  697. ** Find the colon separator, and parse the address.
  698. ** It should resolve to a local name -- this will
  699. ** be checked later (we want to optionally do
  700. ** parsing of the RHS first to maximize error
  701. ** detection).
  702. */
  704. for (p = line; *p != '' && *p != ':' && *p != 'n'; p++)
  705. continue;
  706. if (*p++ != ':')
  707. {
  708. syserr("554 5.3.5 missing colon");
  709. continue;
  710. }
  711. if (parseaddr(line, &al, RF_COPYALL, ':', NULL, CurEnv) == NULL)
  712. {
  713. syserr("554 5.3.5 %.40s... illegal alias name", line);
  714. continue;
  715. }
  717. /*
  718. **  Process the RHS.
  719. ** 'al' is the internal form of the LHS address.
  720. ** 'p' points to the text of the RHS.
  721. */
  723. while (isascii(*p) && isspace(*p))
  724. p++;
  725. rhs = p;
  726. for (;;)
  727. {
  728. register char *nlp;
  730. nlp = &p[strlen(p)];
  731. if (nlp[-1] == 'n')
  732. *--nlp = '';
  734. if (CheckAliases)
  735. {
  736. /* do parsing & compression of addresses */
  737. while (*p != '')
  738. {
  739. auto char *delimptr;
  741. while ((isascii(*p) && isspace(*p)) ||
  742. *p == ',')
  743. p++;
  744. if (*p == '')
  745. break;
  746. if (parseaddr(p, &bl, RF_COPYNONE, ',',
  747.       &delimptr, CurEnv) == NULL)
  748. usrerr("553 5.3.5 %s... bad address", p);
  749. p = delimptr;
  750. }
  751. }
  752. else
  753. {
  754. p = nlp;
  755. }
  757. /* see if there should be a continuation line */
  758. c = getc(af);
  759. if (!feof(af))
  760. (void) ungetc(c, af);
  761. if (c != ' ' && c != 't')
  762. break;
  764. /* read continuation line */
  765. if (fgets(p, sizeof line - (p - line), af) == NULL)
  766. break;
  767. LineNumber++;
  769. /* check for line overflow */
  770. if (strchr(p, 'n') == NULL && !feof(af))
  771. {
  772. usrerr("554 5.3.5 alias too long");
  773. while ((c = fgetc(af)) != EOF && c != 'n')
  774. continue;
  775. skipping = TRUE;
  776. break;
  777. }
  778. }
  780. if (skipping)
  781. continue;
  783. if (!bitnset(M_ALIASABLE, al.q_mailer->m_flags))
  784. {
  785. syserr("554 5.3.5 %s... cannot alias non-local names",
  786. al.q_paddr);
  787. continue;
  788. }
  790. /*
  791. **  Insert alias into symbol table or database file.
  792. **
  793. ** Special case pOStmaStER -- always make it lower case.
  794. */
  796. if (strcasecmp(al.q_user, "postmaster") == 0)
  797. makelower(al.q_user);
  799. lhssize = strlen(al.q_user);
  800. rhssize = strlen(rhs);
  801. map->map_class->map_store(map, al.q_user, rhs);
  803. if (al.q_paddr != NULL)
  804. free(al.q_paddr);
  805. if (al.q_host != NULL)
  806. free(al.q_host);
  807. if (al.q_user != NULL)
  808. free(al.q_user);
  810. /* statistics */
  811. naliases++;
  812. bytes += lhssize + rhssize;
  813. if (rhssize > longest)
  814. longest = rhssize;
  815. }
  817. CurEnv->e_to = NULL;
  818. FileName = NULL;
  819. if (Verbose || announcestats)
  820. message("%s: %d aliases, longest %d bytes, %d bytes total",
  821. map->map_file, naliases, longest, bytes);
  822. if (LogLevel > 7 && logstats)
  823. sm_syslog(LOG_INFO, NOQID,
  824. "%s: %d aliases, longest %d bytes, %d bytes total",
  825. map->map_file, naliases, longest, bytes);
  826. }
  827. /*
  828. **  FORWARD -- Try to forward mail
  829. **
  830. ** This is similar but not identical to aliasing.
  831. **
  832. ** Parameters:
  833. ** user -- the name of the user who's mail we would like
  834. ** to forward to.  It must have been verified --
  835. ** i.e., the q_home field must have been filled
  836. ** in.
  837. ** sendq -- a pointer to the head of the send queue to
  838. ** put this user's aliases in.
  839. ** aliaslevel -- the current alias nesting depth.
  840. ** e -- the current envelope.
  841. **
  842. ** Returns:
  843. ** none.
  844. **
  845. ** Side Effects:
  846. ** New names are added to send queues.
  847. */
  849. void
  850. forward(user, sendq, aliaslevel, e)
  851. ADDRESS *user;
  852. ADDRESS **sendq;
  853. int aliaslevel;
  854. register ENVELOPE *e;
  855. {
  856. char *pp;
  857. char *ep;
  858. bool got_transient;
  860. if (tTd(27, 1))
  861. dprintf("forward(%s)n", user->q_paddr);
  863. if (!bitnset(M_HASPWENT, user->q_mailer->m_flags) ||
  864.     !QS_IS_OK(user->q_state))
  865. return;
  866. if (user->q_home == NULL)
  867. {
  868. syserr("554 5.3.0 forward: no home");
  869. user->q_home = "/no/such/directory";
  870. }
  872. /* good address -- look for .forward file in home */
  873. define('z', user->q_home, e);
  874. define('u', user->q_user, e);
  875. define('h', user->q_host, e);
  876. if (ForwardPath == NULL)
  877. ForwardPath = newstr("201z/.forward");
  879. got_transient = FALSE;
  880. for (pp = ForwardPath; pp != NULL; pp = ep)
  881. {
  882. int err;
  883. char buf[MAXPATHLEN + 1];
  884. struct stat st;
  886. ep = strchr(pp, ':');
  887. if (ep != NULL)
  888. *ep = '';
  889. expand(pp, buf, sizeof buf, e);
  890. if (ep != NULL)
  891. *ep++ = ':';
  892. if (buf[0] == '')
  893. continue;
  894. if (tTd(27, 3))
  895. dprintf("forward: trying %sn", buf);
  897. err = include(buf, TRUE, user, sendq, aliaslevel, e);
  898. if (err == 0)
  899. break;
  900. else if (transienterror(err))
  901. {
  902. /* we may have to suspend this message */
  903. got_transient = TRUE;
  904. if (tTd(27, 2))
  905. dprintf("forward: transient error on %sn",
  906. buf);
  907. if (LogLevel > 2)
  908. {
  909. char *curhost = CurHostName;
  911. CurHostName = NULL;
  912. sm_syslog(LOG_ERR, e->e_id,
  913.   "forward %s: transient error: %s",
  914.   buf, errstring(err));
  915. CurHostName = curhost;
  916. }
  918. }
  919. else
  920. {
  921. switch (err)
  922. {
  923.   case ENOENT:
  924. break;
  926.   case E_SM_WWDIR:
  927.   case E_SM_GWDIR:
  928. /* check if it even exists */
  929. if (stat(buf, &st) < 0 && errno == ENOENT)
  930. {
  931. if (bitnset(DBS_DONTWARNFORWARDFILEINUNSAFEDIRPATH,
  932.     DontBlameSendmail))
  933. break;
  934. }
  935. /* FALLTHROUGH */
  937. #if _FFR_FORWARD_SYSERR
  938.   case E_SM_NOSLINK:
  939.   case E_SM_NOHLINK:
  940.   case E_SM_REGONLY:
  941.   case E_SM_ISEXEC:
  942.   case E_SM_WWFILE:
  943.   case E_SM_GWFILE:
  944. syserr("forward: %s: %s", buf, errstring(err));
  945. break;
  946. #endif /* _FFR_FORWARD_SYSERR */
  948.   default:
  949. if (LogLevel > (RunAsUid == 0 ? 2 : 10))
  950. sm_syslog(LOG_WARNING, e->e_id,
  951. "forward %s: %s", buf,
  952. errstring(err));
  953. if (Verbose)
  954. message("forward: %s: %s",
  955. buf,
  956. errstring(err));
  957. break;
  958. }
  959. }
  960. }
  961. if (pp == NULL && got_transient)
  962. {
  963. /*
  964. **  There was no successful .forward open and at least one
  965. **  transient open.  We have to defer this address for
  966. **  further delivery.
  967. */
  969. message("transient .forward open error: message queued");
  970. user->q_state = QS_QUEUEUP;
  971. return;
  972. }
  973. }