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

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

Email客户端

开发平台：

Unix_Linux

safefile.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: safefile.c,v 8.79 1999/12/03 03:40:27 gshapiro Exp $";
  16. #endif /* ! lint */
  18. #include <sendmail.h>
  19. /*
  20. **  SAFEFILE -- return true if a file exists and is safe for a user.
  21. **
  22. ** Parameters:
  23. ** fn -- filename to check.
  24. ** uid -- user id to compare against.
  25. ** gid -- group id to compare against.
  26. ** user -- user name to compare against (used for group
  27. ** sets).
  28. ** flags -- modifiers:
  29. ** SFF_MUSTOWN -- "uid" must own this file.
  30. ** SFF_NOSLINK -- file cannot be a symbolic link.
  31. ** mode -- mode bits that must match.
  32. ** st -- if set, points to a stat structure that will
  33. ** get the stat info for the file.
  34. **
  35. ** Returns:
  36. ** 0 if fn exists, is owned by uid, and matches mode.
  37. ** An errno otherwise.  The actual errno is cleared.
  38. **
  39. ** Side Effects:
  40. ** none.
  41. */
  43. int
  44. safefile(fn, uid, gid, user, flags, mode, st)
  45. char *fn;
  46. UID_T uid;
  47. GID_T gid;
  48. char *user;
  49. long flags;
  50. int mode;
  51. struct stat *st;
  52. {
  53. register char *p;
  54. register struct group *gr = NULL;
  55. int file_errno = 0;
  56. bool checkpath;
  57. struct stat stbuf;
  58. struct stat fstbuf;
  59. char fbuf[MAXPATHLEN + 1];
  61. if (tTd(44, 4))
  62. dprintf("safefile(%s, uid=%d, gid=%d, flags=%lx, mode=%o):n",
  63. fn, (int) uid, (int) gid, flags, mode);
  64. errno = 0;
  65. if (st == NULL)
  66. st = &fstbuf;
  67. if (strlcpy(fbuf, fn, sizeof fbuf) >= sizeof fbuf)
  68. {
  69. if (tTd(44, 4))
  70. dprintf("tpathname too longn");
  71. return ENAMETOOLONG;
  72. }
  73. fn = fbuf;
  75. /* ignore SFF_SAFEDIRPATH if we are debugging */
  76. if (RealUid != 0 && RunAsUid == RealUid)
  77. flags &= ~SFF_SAFEDIRPATH;
  79. /* first check to see if the file exists at all */
  80. #if HASLSTAT
  81. if ((bitset(SFF_NOSLINK, flags) ? lstat(fn, st)
  82. : stat(fn, st)) < 0)
  83. #else /* HASLSTAT */
  84. if (stat(fn, st) < 0)
  85. #endif /* HASLSTAT */
  86. {
  87. file_errno = errno;
  88. }
  89. else if (bitset(SFF_SETUIDOK, flags) &&
  90.  !bitset(S_IXUSR|S_IXGRP|S_IXOTH, st->st_mode) &&
  91.  S_ISREG(st->st_mode))
  92. {
  93. /*
  94. **  If final file is setuid, run as the owner of that
  95. **  file.  Gotta be careful not to reveal anything too
  96. **  soon here!
  97. */
  99. #ifdef SUID_ROOT_FILES_OK
  100. if (bitset(S_ISUID, st->st_mode))
  101. #else /* SUID_ROOT_FILES_OK */
  102. if (bitset(S_ISUID, st->st_mode) && st->st_uid != 0 &&
  103.     st->st_uid != TrustedUid)
  104. #endif /* SUID_ROOT_FILES_OK */
  105. {
  106. uid = st->st_uid;
  107. user = NULL;
  108. }
  109. #ifdef SUID_ROOT_FILES_OK
  110. if (bitset(S_ISGID, st->st_mode))
  111. #else /* SUID_ROOT_FILES_OK */
  112. if (bitset(S_ISGID, st->st_mode) && st->st_gid != 0)
  113. #endif /* SUID_ROOT_FILES_OK */
  114. gid = st->st_gid;
  115. }
  117. checkpath = !bitset(SFF_NOPATHCHECK, flags) ||
  118.     (uid == 0 && !bitset(SFF_ROOTOK|SFF_OPENASROOT, flags));
  119. if (bitset(SFF_NOWLINK, flags) && !bitset(SFF_SAFEDIRPATH, flags))
  120. {
  121. int ret;
  123. /* check the directory */
  124. p = strrchr(fn, '/');
  125. if (p == NULL)
  126. {
  127. ret = safedirpath(".", uid, gid, user,
  128.   flags|SFF_SAFEDIRPATH, 0, 0);
  129. }
  130. else
  131. {
  132. *p = '';
  133. ret = safedirpath(fn, uid, gid, user,
  134.   flags|SFF_SAFEDIRPATH, 0, 0);
  135. *p = '/';
  136. }
  137. if (ret == 0)
  138. {
  139. /* directory is safe */
  140. checkpath = FALSE;
  141. }
  142. else
  143. {
  144. #if HASLSTAT
  145. /* Need lstat() information if called stat() before */
  146. if (!bitset(SFF_NOSLINK, flags) && lstat(fn, st) < 0)
  147. {
  148. ret = errno;
  149. if (tTd(44, 4))
  150. dprintf("t%sn", errstring(ret));
  151. return ret;
  152. }
  153. #endif /* HASLSTAT */
  154. /* directory is writable: disallow links */
  155. flags |= SFF_NOLINK;
  156. }
  157. }
  159. if (checkpath)
  160. {
  161. int ret;
  163. p = strrchr(fn, '/');
  164. if (p == NULL)
  165. {
  166. ret = safedirpath(".", uid, gid, user, flags, 0, 0);
  167. }
  168. else
  169. {
  170. *p = '';
  171. ret = safedirpath(fn, uid, gid, user, flags, 0, 0);
  172. *p = '/';
  173. }
  174. if (ret != 0)
  175. return ret;
  176. }
  178. /*
  179. **  If the target file doesn't exist, check the directory to
  180. **  ensure that it is writable by this user.
  181. */
  183. if (file_errno != 0)
  184. {
  185. int ret = file_errno;
  186. char *dir = fn;
  188. if (tTd(44, 4))
  189. dprintf("t%sn", errstring(ret));
  191. errno = 0;
  192. if (!bitset(SFF_CREAT, flags) || file_errno != ENOENT)
  193. return ret;
  195. /* check to see if legal to create the file */
  196. p = strrchr(dir, '/');
  197. if (p == NULL)
  198. dir = ".";
  199. else if (p == dir)
  200. dir = "/";
  201. else
  202. *p = '';
  203. if (stat(dir, &stbuf) >= 0)
  204. {
  205. int md = S_IWRITE|S_IEXEC;
  207. if (stbuf.st_uid == uid)
  208. /* EMPTY */
  209. ;
  210. else if (uid == 0 && stbuf.st_uid == TrustedUid)
  211. /* EMPTY */
  212. ;
  213. else
  214. {
  215. md >>= 3;
  216. if (stbuf.st_gid == gid)
  217. /* EMPTY */
  218. ;
  219. #ifndef NO_GROUP_SET
  220. else if (user != NULL && !DontInitGroups &&
  221.  ((gr != NULL &&
  222.    gr->gr_gid == stbuf.st_gid) ||
  223.   (gr = getgrgid(stbuf.st_gid)) != NULL))
  224. {
  225. register char **gp;
  227. for (gp = gr->gr_mem; *gp != NULL; gp++)
  228. if (strcmp(*gp, user) == 0)
  229. break;
  230. if (*gp == NULL)
  231. md >>= 3;
  232. }
  233. #endif /* ! NO_GROUP_SET */
  234. else
  235. md >>= 3;
  236. }
  237. if ((stbuf.st_mode & md) != md)
  238. errno = EACCES;
  239. }
  240. ret = errno;
  241. if (tTd(44, 4))
  242. dprintf("t[final dir %s uid %d mode %lo] %sn",
  243. dir, (int) stbuf.st_uid, (u_long) stbuf.st_mode,
  244. errstring(ret));
  245. if (p != NULL)
  246. *p = '/';
  247. st->st_mode = ST_MODE_NOFILE;
  248. return ret;
  249. }
  251. #ifdef S_ISLNK
  252. if (bitset(SFF_NOSLINK, flags) && S_ISLNK(st->st_mode))
  253. {
  254. if (tTd(44, 4))
  255. dprintf("t[slink mode %lo]tE_SM_NOSLINKn",
  256. (u_long) st->st_mode);
  257. return E_SM_NOSLINK;
  258. }
  259. #endif /* S_ISLNK */
  260. if (bitset(SFF_REGONLY, flags) && !S_ISREG(st->st_mode))
  261. {
  262. if (tTd(44, 4))
  263. dprintf("t[non-reg mode %lo]tE_SM_REGONLYn",
  264. (u_long) st->st_mode);
  265. return E_SM_REGONLY;
  266. }
  267. if (bitset(SFF_NOGWFILES, flags) &&
  268.     bitset(S_IWGRP, st->st_mode))
  269. {
  270. if (tTd(44, 4))
  271. dprintf("t[write bits %lo]tE_SM_GWFILEn",
  272. (u_long) st->st_mode);
  273. return E_SM_GWFILE;
  274. }
  275. if (bitset(SFF_NOWWFILES, flags) &&
  276.     bitset(S_IWOTH, st->st_mode))
  277. {
  278. if (tTd(44, 4))
  279. dprintf("t[write bits %lo]tE_SM_WWFILEn",
  280. (u_long) st->st_mode);
  281. return E_SM_WWFILE;
  282. }
  283. if (bitset(SFF_NORFILES, flags) &&
  284.     (bitset(S_IRGRP, st->st_mode) || bitset(S_IROTH, st->st_mode)))
  285. {
  286. if (tTd(44, 4))
  287. dprintf("t[read bits %lo]tE_SM_RFILEn",
  288. (u_long) st->st_mode);
  289. return E_SM_RFILE;
  290. }
  291. if (!bitset(SFF_EXECOK, flags) &&
  292.     bitset(S_IWUSR|S_IWGRP|S_IWOTH, mode) &&
  293.     bitset(S_IXUSR|S_IXGRP|S_IXOTH, st->st_mode))
  294. {
  295. if (tTd(44, 4))
  296. dprintf("t[exec bits %lo]tE_SM_ISEXEC]n",
  297. (u_long) st->st_mode);
  298. return E_SM_ISEXEC;
  299. }
  300. if (bitset(SFF_NOHLINK, flags) && st->st_nlink != 1)
  301. {
  302. if (tTd(44, 4))
  303. dprintf("t[link count %d]tE_SM_NOHLINKn",
  304. (int) st->st_nlink);
  305. return E_SM_NOHLINK;
  306. }
  308. if (uid == 0 && bitset(SFF_OPENASROOT, flags))
  309. /* EMPTY */
  310. ;
  311. else if (uid == 0 && !bitset(SFF_ROOTOK, flags))
  312. mode >>= 6;
  313. else if (st->st_uid == uid)
  314. /* EMPTY */
  315. ;
  316. else if (uid == 0 && st->st_uid == TrustedUid)
  317. /* EMPTY */
  318. ;
  319. else
  320. {
  321. mode >>= 3;
  322. if (st->st_gid == gid)
  323. /* EMPTY */
  324. ;
  325. #ifndef NO_GROUP_SET
  326. else if (user != NULL && !DontInitGroups &&
  327.  ((gr != NULL && gr->gr_gid == st->st_gid) ||
  328.   (gr = getgrgid(st->st_gid)) != NULL))
  329. {
  330. register char **gp;
  332. for (gp = gr->gr_mem; *gp != NULL; gp++)
  333. if (strcmp(*gp, user) == 0)
  334. break;
  335. if (*gp == NULL)
  336. mode >>= 3;
  337. }
  338. #endif /* ! NO_GROUP_SET */
  339. else
  340. mode >>= 3;
  341. }
  342. if (tTd(44, 4))
  343. dprintf("t[uid %d, nlink %d, stat %lo, mode %lo] ",
  344. (int) st->st_uid, (int) st->st_nlink,
  345. (u_long) st->st_mode, (u_long) mode);
  346. if ((st->st_uid == uid || st->st_uid == 0 ||
  347.      st->st_uid == TrustedUid ||
  348.      !bitset(SFF_MUSTOWN, flags)) &&
  349.     (st->st_mode & mode) == mode)
  350. {
  351. if (tTd(44, 4))
  352. dprintf("tOKn");
  353. return 0;
  354. }
  355. if (tTd(44, 4))
  356. dprintf("tEACCESn");
  357. return EACCES;
  358. }
  359. /*
  360. **  SAFEDIRPATH -- check to make sure a path to a directory is safe
  361. **
  362. ** Safe means not writable and owned by the right folks.
  363. **
  364. ** Parameters:
  365. ** fn -- filename to check.
  366. ** uid -- user id to compare against.
  367. ** gid -- group id to compare against.
  368. ** user -- user name to compare against (used for group
  369. ** sets).
  370. ** flags -- modifiers:
  371. ** SFF_ROOTOK -- ok to use root permissions to open.
  372. ** SFF_SAFEDIRPATH -- writable directories are considered
  373. ** to be fatal errors.
  374. ** level -- symlink recursive level.
  375. ** offset -- offset into fn to start checking from.
  376. **
  377. ** Returns:
  378. ** 0 -- if the directory path is "safe".
  379. ** else -- an error number associated with the path.
  380. */
  382. int
  383. safedirpath(fn, uid, gid, user, flags, level, offset)
  384. char *fn;
  385. UID_T uid;
  386. GID_T gid;
  387. char *user;
  388. long flags;
  389. int level;
  390. int offset;
  391. {
  392. int ret = 0;
  393. int mode = S_IWOTH;
  394. char save = '';
  395. char *saveptr = NULL;
  396. char *p, *enddir;
  397. register struct group *gr = NULL;
  398. char s[MAXLINKPATHLEN + 1];
  399. struct stat stbuf;
  401. /* make sure we aren't in a symlink loop */
  402. if (level > MAXSYMLINKS)
  403. return ELOOP;
  405. /* special case root directory */
  406. if (*fn == '')
  407. fn = "/";
  409. if (tTd(44, 4))
  410. dprintf("safedirpath(%s, uid=%ld, gid=%ld, flags=%lx, level=%d, offset=%d):n",
  411. fn, (long) uid, (long) gid, flags, level, offset);
  413. if (!bitnset(DBS_GROUPWRITABLEDIRPATHSAFE, DontBlameSendmail))
  414. mode |= S_IWGRP;
  416. /* Make a modifiable copy of the filename */
  417. if (strlcpy(s, fn, sizeof s) >= sizeof s)
  418. return EINVAL;
  420. p = s + offset;
  421. while (p != NULL)
  422. {
  423. /* put back character */
  424. if (saveptr != NULL)
  425. {
  426. *saveptr = save;
  427. saveptr = NULL;
  428. p++;
  429. }
  431. if (*p == '')
  432. break;
  434. p = strchr(p, '/');
  436. /* Special case for root directory */
  437. if (p == s)
  438. {
  439. save = *(p + 1);
  440. saveptr = p + 1;
  441. *(p + 1) = '';
  442. }
  443. else if (p != NULL)
  444. {
  445. save = *p;
  446. saveptr = p;
  447. *p = '';
  448. }
  450. /* Heuristic: . and .. have already been checked */
  451. enddir = strrchr(s, '/');
  452. if (enddir != NULL &&
  453.     (strcmp(enddir, "/..") == 0 ||
  454.      strcmp(enddir, "/.") == 0))
  455. continue;
  457. if (tTd(44, 20))
  458. dprintf("t[dir %s]n", s);
  460. #if HASLSTAT
  461. ret = lstat(s, &stbuf);
  462. #else /* HASLSTAT */
  463. ret = stat(s, &stbuf);
  464. #endif /* HASLSTAT */
  465. if (ret < 0)
  466. {
  467. ret = errno;
  468. break;
  469. }
  471. #ifdef S_ISLNK
  472. /* Follow symlinks */
  473. if (S_ISLNK(stbuf.st_mode))
  474. {
  475. char *target;
  476. char buf[MAXPATHLEN + 1];
  478. memset(buf, '', sizeof buf);
  479. if (readlink(s, buf, sizeof buf) < 0)
  480. {
  481. ret = errno;
  482. break;
  483. }
  485. offset = 0;
  486. if (*buf == '/')
  487. {
  488. target = buf;
  490. /* If path is the same, avoid rechecks */
  491. while (s[offset] == buf[offset] &&
  492.        s[offset] != '')
  493. offset++;
  495. if (s[offset] == '' && buf[offset] == '')
  496. {
  497. /* strings match, symlink loop */
  498. return ELOOP;
  499. }
  501. /* back off from the mismatch */
  502. if (offset > 0)
  503. offset--;
  505. /* Make sure we are at a directory break */
  506. if (offset > 0 &&
  507.     s[offset] != '/' &&
  508.     s[offset] != '')
  509. {
  510. while (buf[offset] != '/' &&
  511.        offset > 0)
  512. offset--;
  513. }
  514. if (offset > 0 &&
  515.     s[offset] == '/' &&
  516.     buf[offset] == '/')
  517. {
  518. /* Include the trailing slash */
  519. offset++;
  520. }
  521. }
  522. else
  523. {
  524. char *sptr;
  525. char fullbuf[MAXLINKPATHLEN + 1];
  527. sptr = strrchr(s, '/');
  528. if (sptr != NULL)
  529. {
  530. *sptr = '';
  531. offset = sptr + 1 - s;
  532. if ((strlen(s) + 1 +
  533.      strlen(buf) + 1) > sizeof fullbuf)
  534. {
  535. ret = EINVAL;
  536. break;
  537. }
  538. snprintf(fullbuf, sizeof fullbuf,
  539.  "%s/%s", s, buf);
  540. *sptr = '/';
  541. }
  542. else
  543. {
  544. if (strlen(buf) + 1 > sizeof fullbuf)
  545. {
  546. ret = EINVAL;
  547. break;
  548. }
  549. (void) strlcpy(fullbuf, buf,
  550.        sizeof fullbuf);
  551. }
  552. target = fullbuf;
  553. }
  554. ret = safedirpath(target, uid, gid, user, flags,
  555.   level + 1, offset);
  556. if (ret != 0)
  557. break;
  559. /* Don't check permissions on the link file itself */
  560. continue;
  561. }
  562. #endif /* S_ISLNK */
  564. if ((uid == 0 || bitset(SFF_SAFEDIRPATH, flags)) &&
  565. #ifdef S_ISVTX
  566.     !(bitnset(DBS_TRUSTSTICKYBIT, DontBlameSendmail) &&
  567.       bitset(S_ISVTX, stbuf.st_mode)) &&
  568. #endif /* S_ISVTX */
  569.     bitset(mode, stbuf.st_mode))
  570. {
  571. if (tTd(44, 4))
  572. dprintf("t[dir %s] mode %lo ",
  573. s, (u_long) stbuf.st_mode);
  574. if (bitset(SFF_SAFEDIRPATH, flags))
  575. {
  576. if (bitset(S_IWOTH, stbuf.st_mode))
  577. ret = E_SM_WWDIR;
  578. else
  579. ret = E_SM_GWDIR;
  580. if (tTd(44, 4))
  581. dprintf("FATALn");
  582. break;
  583. }
  584. if (tTd(44, 4))
  585. dprintf("WARNINGn");
  586. if (Verbose > 1)
  587. message("051 WARNING: %s writable directory %s",
  588. bitset(S_IWOTH, stbuf.st_mode)
  589.    ? "World"
  590.    : "Group",
  591. s);
  592. }
  593. if (uid == 0 && !bitset(SFF_ROOTOK|SFF_OPENASROOT, flags))
  594. {
  595. if (bitset(S_IXOTH, stbuf.st_mode))
  596. continue;
  597. ret = EACCES;
  598. break;
  599. }
  601. /*
  602. **  Let OS determine access to file if we are not
  603. **  running as a privileged user.  This allows ACLs
  604. **  to work.  Also, if opening as root, assume we can
  605. **  scan the directory.
  606. */
  607. if (geteuid() != 0 || bitset(SFF_OPENASROOT, flags))
  608. continue;
  610. if (stbuf.st_uid == uid &&
  611.     bitset(S_IXUSR, stbuf.st_mode))
  612. continue;
  613. if (stbuf.st_gid == gid &&
  614.     bitset(S_IXGRP, stbuf.st_mode))
  615. continue;
  616. #ifndef NO_GROUP_SET
  617. if (user != NULL && !DontInitGroups &&
  618.     ((gr != NULL && gr->gr_gid == stbuf.st_gid) ||
  619.      (gr = getgrgid(stbuf.st_gid)) != NULL))
  620. {
  621. register char **gp;
  623. for (gp = gr->gr_mem; gp != NULL && *gp != NULL; gp++)
  624. if (strcmp(*gp, user) == 0)
  625. break;
  626. if (gp != NULL && *gp != NULL &&
  627.     bitset(S_IXGRP, stbuf.st_mode))
  628. continue;
  629. }
  630. #endif /* ! NO_GROUP_SET */
  631. if (!bitset(S_IXOTH, stbuf.st_mode))
  632. {
  633. ret = EACCES;
  634. break;
  635. }
  636. }
  637. if (tTd(44, 4))
  638. dprintf("t[dir %s] %sn", fn,
  639. ret == 0 ? "OK" : errstring(ret));
  640. return ret;
  641. }
  642. /*
  643. **  SAFEOPEN -- do a file open with extra checking
  644. **
  645. ** Parameters:
  646. ** fn -- the file name to open.
  647. ** omode -- the open-style mode flags.
  648. ** cmode -- the create-style mode flags.
  649. ** sff -- safefile flags.
  650. **
  651. ** Returns:
  652. ** Same as open.
  653. */
  655. #ifndef O_ACCMODE
  656. # define O_ACCMODE (O_RDONLY|O_WRONLY|O_RDWR)
  657. #endif /* ! O_ACCMODE */
  659. int
  660. safeopen(fn, omode, cmode, sff)
  661. char *fn;
  662. int omode;
  663. int cmode;
  664. long sff;
  665. {
  666. int rval;
  667. int fd;
  668. int smode;
  669. struct stat stb;
  671. if (tTd(44, 10))
  672. printf("safeopen: fn=%s, omode=%x, cmode=%x, sff=%lxn",
  673.        fn, omode, cmode, sff);
  675. if (bitset(O_CREAT, omode))
  676. sff |= SFF_CREAT;
  677. omode &= ~O_CREAT;
  678. smode = 0;
  679. switch (omode & O_ACCMODE)
  680. {
  681.   case O_RDONLY:
  682. smode = S_IREAD;
  683. break;
  685.   case O_WRONLY:
  686. smode = S_IWRITE;
  687. break;
  689.   case O_RDWR:
  690. smode = S_IREAD|S_IWRITE;
  691. break;
  693.   default:
  694. smode = 0;
  695. break;
  696. }
  697. if (bitset(SFF_OPENASROOT, sff))
  698. rval = safefile(fn, RunAsUid, RunAsGid, RunAsUserName,
  699. sff, smode, &stb);
  700. else
  701. rval = safefile(fn, RealUid, RealGid, RealUserName,
  702. sff, smode, &stb);
  703. if (rval != 0)
  704. {
  705. errno = rval;
  706. return -1;
  707. }
  708. if (stb.st_mode == ST_MODE_NOFILE && bitset(SFF_CREAT, sff))
  709. omode |= O_CREAT | (bitset(SFF_NOTEXCL, sff) ? 0 : O_EXCL);
  710. else if (bitset(SFF_CREAT, sff) && bitset(O_EXCL, omode))
  711. {
  712. /* The file exists so an exclusive create would fail */
  713. errno = EEXIST;
  714. return -1;
  715. }
  717. fd = dfopen(fn, omode, cmode, sff);
  718. if (fd < 0)
  719. return fd;
  720. if (filechanged(fn, fd, &stb))
  721. {
  722. syserr("554 5.3.0 cannot open: file %s changed after open", fn);
  723. (void) close(fd);
  724. errno = E_SM_FILECHANGE;
  725. return -1;
  726. }
  727. return fd;
  728. }
  729. /*
  730. **  SAFEFOPEN -- do a file open with extra checking
  731. **
  732. ** Parameters:
  733. ** fn -- the file name to open.
  734. ** omode -- the open-style mode flags.
  735. ** cmode -- the create-style mode flags.
  736. ** sff -- safefile flags.
  737. **
  738. ** Returns:
  739. ** Same as fopen.
  740. */
  742. FILE *
  743. safefopen(fn, omode, cmode, sff)
  744. char *fn;
  745. int omode;
  746. int cmode;
  747. long sff;
  748. {
  749. int fd;
  750. int save_errno;
  751. FILE *fp;
  752. char *fmode;
  754. switch (omode & O_ACCMODE)
  755. {
  756.   case O_RDONLY:
  757. fmode = "r";
  758. break;
  760.   case O_WRONLY:
  761. if (bitset(O_APPEND, omode))
  762. fmode = "a";
  763. else
  764. fmode = "w";
  765. break;
  767.   case O_RDWR:
  768. if (bitset(O_TRUNC, omode))
  769. fmode = "w+";
  770. else if (bitset(O_APPEND, omode))
  771. fmode = "a+";
  772. else
  773. fmode = "r+";
  774. break;
  776.   default:
  777. syserr("554 5.3.5 safefopen: unknown omode %o", omode);
  778. fmode = "x";
  779. }
  780. fd = safeopen(fn, omode, cmode, sff);
  781. if (fd < 0)
  782. {
  783. save_errno = errno;
  784. if (tTd(44, 10))
  785. dprintf("safefopen: safeopen failed: %sn",
  786. errstring(errno));
  787. errno = save_errno;
  788. return NULL;
  789. }
  790. fp = fdopen(fd, fmode);
  791. if (fp != NULL)
  792. return fp;
  794. save_errno = errno;
  795. if (tTd(44, 10))
  796. {
  797. dprintf("safefopen: fdopen(%s, %s) failed: omode=%x, sff=%lx, err=%sn",
  798. fn, fmode, omode, sff, errstring(errno));
  799. }
  800. (void) close(fd);
  801. errno = save_errno;
  802. return NULL;
  803. }
  804. /*
  805. **  FILECHANGED -- check to see if file changed after being opened
  806. **
  807. ** Parameters:
  808. ** fn -- pathname of file to check.
  809. ** fd -- file descriptor to check.
  810. ** stb -- stat structure from before open.
  811. **
  812. ** Returns:
  813. ** TRUE -- if a problem was detected.
  814. ** FALSE -- if this file is still the same.
  815. */
  817. bool
  818. filechanged(fn, fd, stb)
  819. char *fn;
  820. int fd;
  821. struct stat *stb;
  822. {
  823. struct stat sta;
  825. if (stb->st_mode == ST_MODE_NOFILE)
  826. {
  827. #if HASLSTAT && BOGUS_O_EXCL
  828. /* only necessary if exclusive open follows symbolic links */
  829. if (lstat(fn, stb) < 0 || stb->st_nlink != 1)
  830. return TRUE;
  831. #else /* HASLSTAT && BOGUS_O_EXCL */
  832. return FALSE;
  833. #endif /* HASLSTAT && BOGUS_O_EXCL */
  834. }
  835. if (fstat(fd, &sta) < 0)
  836. return TRUE;
  838. if (sta.st_nlink != stb->st_nlink ||
  839.     sta.st_dev != stb->st_dev ||
  840.     sta.st_ino != stb->st_ino ||
  841. #if HAS_ST_GEN && 0 /* AFS returns garbage in st_gen */
  842.     sta.st_gen != stb->st_gen ||
  843. #endif /* HAS_ST_GEN && 0 */
  844.     sta.st_uid != stb->st_uid ||
  845.     sta.st_gid != stb->st_gid)
  846. {
  847. if (tTd(44, 8))
  848. {
  849. dprintf("File changed after opening:n");
  850. dprintf(" nlink = %ld/%ldn",
  851. (long) stb->st_nlink, (long) sta.st_nlink);
  852. dprintf(" dev = %ld/%ldn",
  853. (long) stb->st_dev, (long) sta.st_dev);
  854. if (sizeof sta.st_ino > sizeof (long))
  855. {
  856. dprintf(" ino = %s/",
  857. quad_to_string(stb->st_ino));
  858. dprintf("%sn",
  859. quad_to_string(sta.st_ino));
  860. }
  861. else
  862. dprintf(" ino = %lu/%lun",
  863. (unsigned long) stb->st_ino,
  864. (unsigned long) sta.st_ino);
  865. #if HAS_ST_GEN
  866. dprintf(" gen = %ld/%ldn",
  867. (long) stb->st_gen, (long) sta.st_gen);
  868. #endif /* HAS_ST_GEN */
  869. dprintf(" uid = %ld/%ldn",
  870. (long) stb->st_uid, (long) sta.st_uid);
  871. dprintf(" gid = %ld/%ldn",
  872. (long) stb->st_gid, (long) sta.st_gid);
  873. }
  874. return TRUE;
  875. }
  877. return FALSE;
  878. }
  879. /*
  880. **  DFOPEN -- determined file open
  881. **
  882. ** This routine has the semantics of open, except that it will
  883. ** keep trying a few times to make this happen.  The idea is that
  884. ** on very loaded systems, we may run out of resources (inodes,
  885. ** whatever), so this tries to get around it.
  886. */
  888. int
  889. dfopen(filename, omode, cmode, sff)
  890. char *filename;
  891. int omode;
  892. int cmode;
  893. long sff;
  894. {
  895. register int tries;
  896. int fd = -1;
  897. struct stat st;
  899. for (tries = 0; tries < 10; tries++)
  900. {
  901. (void) sleep((unsigned) (10 * tries));
  902. errno = 0;
  903. fd = open(filename, omode, cmode);
  904. if (fd >= 0)
  905. break;
  906. switch (errno)
  907. {
  908.   case ENFILE: /* system file table full */
  909.   case EINTR: /* interrupted syscall */
  910. #ifdef ETXTBSY
  911.   case ETXTBSY: /* Apollo: net file locked */
  912. #endif /* ETXTBSY */
  913. continue;
  914. }
  915. break;
  916. }
  917. if (!bitset(SFF_NOLOCK, sff) &&
  918.     fd >= 0 &&
  919.     fstat(fd, &st) >= 0 &&
  920.     S_ISREG(st.st_mode))
  921. {
  922. int locktype;
  924. /* lock the file to avoid accidental conflicts */
  925. if ((omode & O_ACCMODE) != O_RDONLY)
  926. locktype = LOCK_EX;
  927. else
  928. locktype = LOCK_SH;
  929. if (!lockfile(fd, filename, NULL, locktype))
  930. {
  931. int save_errno = errno;
  933. (void) close(fd);
  934. fd = -1;
  935. errno = save_errno;
  936. }
  937. else
  938. errno = 0;
  939. }
  940. return fd;
  941. }