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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > WEB邮件程序 > 查看源码
maildirquota.c
资源名称：sqwebmail-0.37a.38pre2.tar.gz　[点击查看]
上传用户：s81996212
上传日期：2007-01-04
资源大小：722k
文件大小：12k
源码类别：

WEB邮件程序

开发平台：

C/C++

maildirquota.c：源码内容
  1. /*
  2. ** Copyright 1998 - 2000 Double Precision, Inc.
  3. ** See COPYING for distribution information.
  4. */
  6. #if HAVE_CONFIG_H
  7. #include "config.h"
  8. #endif
  10. #include <sys/types.h>
  11. #if HAVE_DIRENT_H
  12. #include <dirent.h>
  13. #define NAMLEN(dirent) strlen((dirent)->d_name)
  14. #else
  15. #define dirent direct
  16. #define NAMLEN(dirent) (dirent)->d_namlen
  17. #if HAVE_SYS_NDIR_H
  18. #include <sys/ndir.h>
  19. #endif
  20. #if HAVE_SYS_DIR_H
  21. #include <sys/dir.h>
  22. #endif
  23. #if HAVE_NDIR_H
  24. #include <ndir.h>
  25. #endif
  26. #endif
  27. #include <sys/types.h>
  28. #if HAVE_SYS_STAT_H
  29. #include <sys/stat.h>
  30. #endif
  31. #include <sys/uio.h>
  33. #include "maildirquota.h"
  34. #include "maildirmisc.h"
  35. #include <stdio.h>
  36. #include <stdlib.h>
  37. #include <string.h>
  38. #include <errno.h>
  39. #if HAVE_FCNTL_H
  40. #include <fcntl.h>
  41. #endif
  42. #if HAVE_UNISTD_H
  43. #include <unistd.h>
  44. #endif
  45. #include <time.h>
  46. #include <numlib/numlib.h>
  48. static const char rcsid[]="$Id: maildirquota.c,v 1.3 2000/05/24 03:42:00 mrsam Exp $";
  50. /* Read the maildirsize file */
  52. static int maildirsize_read(const char *filename, /* The filename */
  53. int *fdptr, /* Keep the file descriptor open */
  54. off_t *sizeptr, /* Grand total of maildir size */
  55. unsigned *cntptr, /* Grand total of message count */
  56. unsigned *nlines, /* # of lines in maildirsize */
  57. struct stat *statptr) /* The stats on maildirsize */
  58. {
  59. char buf[5120];
  60. int f;
  61. char *p;
  62. unsigned l;
  63. int n;
  64. int first;
  66. if ((f=maildir_safeopen(filename, O_RDWR|O_APPEND, 0)) < 0)
  67. return (-1);
  68. p=buf;
  69. l=sizeof(buf);
  71. while (l)
  72. {
  73. n=read(f, p, l);
  74. if (n < 0)
  75. {
  76. close(f);
  77. return (-1);
  78. }
  79. if (n == 0) break;
  80. p += n;
  81. l -= n;
  82. }
  83. if (l == 0 || fstat(f, statptr)) /* maildir too big */
  84. {
  85. close(f);
  86. return (-1);
  87. }
  89. *sizeptr=0;
  90. *cntptr=0;
  91. *nlines=0;
  92. *p=0;
  93. p=buf;
  94. first=1;
  95. while (*p)
  96. {
  97. long n=0;
  98. int c=0;
  99. char *q=p;
  101. while (*p)
  102. if (*p++ == 'n')
  103. {
  104. p[-1]=0;
  105. break;
  106. }
  108. if (first)
  109. {
  110. first=0;
  111. continue;
  112. }
  113. sscanf(q, "%ld %d", &n, &c);
  114. *sizeptr += n;
  115. *cntptr += c;
  116. ++ *nlines;
  117. }
  118. *fdptr=f;
  119. return (0);
  120. }
  122. static char *makenewmaildirsizename(const char *, int *);
  123. static int countcurnew(const char *, time_t *, off_t *, unsigned *);
  124. static int countsubdir(const char *, const char *,
  125. time_t *, off_t *, unsigned *);
  126. static int statcurnew(const char *, time_t *);
  127. static int statsubdir(const char *, const char *, time_t *);
  129. #define MDQUOTA_SIZE 'S' /* Total size of all messages in maildir */
  130. #define MDQUOTA_BLOCKS 'B' /* Total # of blocks for all messages in
  131. maildir -- NOT IMPLEMENTED */
  132. #define MDQUOTA_COUNT 'C' /* Total number of messages in maildir */
  134. static int qcalc(off_t s, unsigned n, const char *quota)
  135. {
  136. unsigned long i;
  138. errno=ENOSPC;
  139. while (quota && *quota)
  140. {
  141. if (*quota < '0' || *quota > '9')
  142. {
  143. ++quota;
  144. continue;
  145. }
  146. i=0;
  147. while (*quota >= '0' && *quota <= '9')
  148. i=i*10 + (*quota++ - '0');
  149. switch (*quota) {
  150. default:
  151. if (i < s) return (-1);
  152. break;
  153. case 'C':
  154. if (i < n) return (-1);
  155. break;
  156. }
  157. }
  158. return (0);
  159. }
  161. static int doaddquota(const char *, int, const char *, long, int, int);
  163. int maildir_checkquota(const char *dir,
  164. int *maildirsize_fdptr,
  165. const char *quota_type,
  166. long xtra_size,
  167. int xtra_cnt)
  168. {
  169. char *checkfolder=(char *)malloc(strlen(dir)+sizeof("/maildirfolder"));
  170. char *newmaildirsizename;
  171. struct stat stat_buf;
  172. int maildirsize_fd;
  173. off_t maildirsize_size;
  174. unsigned maildirsize_cnt;
  175. unsigned maildirsize_nlines;
  176. int n;
  177. time_t tm;
  178. time_t maxtime;
  179. DIR *dirp;
  180. struct dirent *de;
  182. if (checkfolder == 0) return (-1);
  183. *maildirsize_fdptr= -1;
  184. strcat(strcpy(checkfolder, dir), "/maildirfolder");
  185. if (stat(checkfolder, &stat_buf) == 0) /* Go to parent */
  186. {
  187. strcat(strcpy(checkfolder, dir), "/..");
  188. n=maildir_checkquota(checkfolder, maildirsize_fdptr,
  189. quota_type, xtra_size, xtra_cnt);
  190. free(checkfolder);
  191. return (n);
  192. }
  193. if (!quota_type || !*quota_type) return (0);
  195. strcat(strcpy(checkfolder, dir), "/maildirsize");
  196. time(&tm);
  197. if (maildirsize_read(checkfolder, &maildirsize_fd,
  198. &maildirsize_size, &maildirsize_cnt,
  199. &maildirsize_nlines, &stat_buf) == 0)
  200. {
  201. n=qcalc(maildirsize_size+xtra_size, maildirsize_cnt+xtra_cnt,
  202. quota_type);
  204. if (n == 0)
  205. {
  206. free(checkfolder);
  207. *maildirsize_fdptr=maildirsize_fd;
  208. return (0);
  209. }
  210. close(maildirsize_fd);
  212. if (maildirsize_nlines == 1 && tm < stat_buf.st_mtime + 15*60)
  213. return (n);
  214. }
  216. maxtime=0;
  217. maildirsize_size=0;
  218. maildirsize_cnt=0;
  220. if (countcurnew(dir, &maxtime, &maildirsize_size, &maildirsize_cnt))
  221. {
  222. free(checkfolder);
  223. return (-1);
  224. }
  226. dirp=opendir(dir);
  227. while (dirp && (de=readdir(dirp)) != 0)
  228. {
  229. if (countsubdir(dir, de->d_name, &maxtime, &maildirsize_size,
  230. &maildirsize_cnt))
  231. {
  232. free(checkfolder);
  233. closedir(dirp);
  234. return (-1);
  235. }
  236. }
  237. if (dirp)
  238. {
  239. #if CLOSEDIR_VOID
  240. closedir(dirp);
  241. #else
  242. if (closedir(dirp))
  243. {
  244. free(checkfolder);
  245. return (-1);
  246. }
  247. #endif
  248. }
  250. newmaildirsizename=makenewmaildirsizename(dir, &maildirsize_fd);
  251. if (!newmaildirsizename)
  252. {
  253. free(checkfolder);
  254. return (-1);
  255. }
  257. *maildirsize_fdptr=maildirsize_fd;
  259. if (doaddquota(dir, maildirsize_fd, quota_type, maildirsize_size,
  260. maildirsize_cnt, 1))
  261. {
  262. free(newmaildirsizename);
  263. unlink(newmaildirsizename);
  264. close(maildirsize_fd);
  265. *maildirsize_fdptr= -1;
  266. free(checkfolder);
  267. return (-1);
  268. }
  270. strcat(strcpy(checkfolder, dir), "/maildirsize");
  272. if (rename(newmaildirsizename, checkfolder))
  273. {
  274. free(checkfolder);
  275. unlink(newmaildirsizename);
  276. close(maildirsize_fd);
  277. *maildirsize_fdptr= -1;
  278. }
  279. free(checkfolder);
  280. free(newmaildirsizename);
  282. tm=0;
  284. if (statcurnew(dir, &tm))
  285. {
  286. close(maildirsize_fd);
  287. *maildirsize_fdptr= -1;
  288. return (-1);
  289. }
  291. dirp=opendir(dir);
  292. while (dirp && (de=readdir(dirp)) != 0)
  293. {
  294. if (statsubdir(dir, de->d_name, &tm))
  295. {
  296. close(maildirsize_fd);
  297. *maildirsize_fdptr= -1;
  298. closedir(dirp);
  299. return (-1);
  300. }
  301. }
  302. if (dirp)
  303. {
  304. #if CLOSEDIR_VOID
  305. closedir(dirp);
  306. #else
  307. if (closedir(dirp))
  308. {
  309. close(maildirsize_fd);
  310. *maildirsize_fdptr= -1;
  311. return (-1);
  312. }
  313. #endif
  314. }
  316. if (tm != maxtime) /* Race condition, someone changed something */
  317. {
  318. errno=EAGAIN;
  319. return (-1);
  320. }
  322. return (qcalc(maildirsize_size+xtra_size, maildirsize_cnt+xtra_cnt,
  323. quota_type));
  324. }
  326. int maildir_addquota(const char *dir, int maildirsize_fd,
  327. const char *quota_type, long maildirsize_size, int maildirsize_cnt)
  328. {
  329. if (!quota_type || !*quota_type) return (0);
  330. return (doaddquota(dir, maildirsize_fd, quota_type, maildirsize_size,
  331. maildirsize_cnt, 0));
  332. }
  334. static int doaddquota(const char *dir, int maildirsize_fd,
  335. const char *quota_type, long maildirsize_size, int maildirsize_cnt,
  336. int isnew)
  337. {
  338. union {
  339. char buf[100];
  340. struct stat stat_buf;
  341. } u; /* Scrooge */
  342. char *newname2=0;
  343. char *newmaildirsizename=0;
  344. struct iovec iov[3];
  345. int niov;
  346. struct iovec *p;
  347. int n;
  349. niov=0;
  350. if ( maildirsize_fd < 0)
  351. {
  352. newname2=(char *)malloc(strlen(dir)+sizeof("/maildirfolder"));
  353. if (!newname2) return (-1);
  354. strcat(strcpy(newname2, dir), "/maildirfolder");
  355. if (stat(newname2, &u.stat_buf) == 0)
  356. {
  357. strcat(strcpy(newname2, dir), "/..");
  358. n=doaddquota(newname2, maildirsize_fd, quota_type,
  359. maildirsize_size, maildirsize_cnt,
  360. isnew);
  361. free(newname2);
  362. return (n);
  363. }
  365. strcat(strcpy(newname2, dir), "/maildirsize");
  367. if ((maildirsize_fd=maildir_safeopen(newname2,
  368. O_RDWR|O_APPEND, 0644)) < 0)
  369. {
  370. newmaildirsizename=makenewmaildirsizename(dir, &maildirsize_fd);
  371. if (!newmaildirsizename)
  372. {
  373. free(newname2);
  374. return (-1);
  375. }
  377. maildirsize_fd=maildir_safeopen(newmaildirsizename,
  378. O_CREAT|O_RDWR|O_APPEND, 0644);
  380. if (maildirsize_fd < 0)
  381. {
  382. free(newname2);
  383. return (-1);
  384. }
  385. isnew=1;
  386. }
  387. }
  389. if (isnew)
  390. {
  391. iov[0].iov_base=(caddr_t)quota_type;
  392. iov[0].iov_len=strlen(quota_type);
  393. iov[1].iov_base=(caddr_t)"n";
  394. iov[1].iov_len=1;
  395. niov=2;
  396. }
  399. sprintf(u.buf, "%ld %dn", maildirsize_size, maildirsize_cnt);
  400. iov[niov].iov_base=(caddr_t)u.buf;
  401. iov[niov].iov_len=strlen(u.buf);
  403. p=iov;
  404. ++niov;
  405. n=0;
  406. while (niov)
  407. {
  408. if (n)
  409. {
  410. if (n < p->iov_len)
  411. {
  412. p->iov_base=
  413. (caddr_t)((char *)p->iov_base + n);
  414. p->iov_len -= n;
  415. }
  416. else
  417. {
  418. n -= p->iov_len;
  419. ++p;
  420. --niov;
  421. continue;
  422. }
  423. }
  425. n=writev( maildirsize_fd, p, niov);
  427. if (n <= 0)
  428. {
  429. if (newname2)
  430. {
  431. close(maildirsize_fd);
  432. free(newname2);
  433. }
  434. return (-1);
  435. }
  436. }
  437. if (newname2)
  438. {
  439. close(maildirsize_fd);
  441. if (newmaildirsizename)
  442. {
  443. rename(newmaildirsizename, newname2);
  444. free(newmaildirsizename);
  445. }
  446. free(newname2);
  447. }
  448. return (0);
  449. }
  451. /* New maildirsize is built in the tmp subdirectory */
  453. static char *makenewmaildirsizename(const char *dir, int *fd)
  454. {
  455. char hostname[256];
  456. struct stat stat_buf;
  457. time_t t;
  458. char *p;
  460. hostname[0]=0;
  461. hostname[sizeof(hostname)-1]=0;
  462. gethostname(hostname, sizeof(hostname)-1);
  463. p=(char *)malloc(strlen(dir)+strlen(hostname)+130);
  464. if (!p) return (0);
  466. for (;;)
  467. {
  468. char tbuf[NUMBUFSIZE];
  469. char pbuf[NUMBUFSIZE];
  471. time(&t);
  472. strcat(strcpy(p, dir), "/tmp/");
  473. sprintf(p+strlen(p), "%s.%s_NeWmAiLdIrSiZe.%s",
  474. str_time_t(t, tbuf),
  475. str_pid_t(getpid(), pbuf), hostname);
  477. if (stat( (const char *)p, &stat_buf) < 0 &&
  478. (*fd=maildir_safeopen(p,
  479. O_CREAT|O_RDWR|O_APPEND, 0644)) >= 0)
  480. break;
  481. sleep(3);
  482. }
  483. return (p);
  484. }
  486. static int statcurnew(const char *dir, time_t *maxtimestamp)
  487. {
  488. char *p=(char *)malloc(strlen(dir)+5);
  489. struct stat stat_buf;
  491. if (!p) return (-1);
  492. strcat(strcpy(p, dir), "/cur");
  493. if ( stat(p, &stat_buf) == 0 && stat_buf.st_mtime > *maxtimestamp)
  494. *maxtimestamp=stat_buf.st_mtime;
  495. strcat(strcpy(p, dir), "/new");
  496. if ( stat(p, &stat_buf) == 0 && stat_buf.st_mtime > *maxtimestamp)
  497. *maxtimestamp=stat_buf.st_mtime;
  498. free(p);
  499. return (0);
  500. }
  502. static int statsubdir(const char *dir, const char *subdir, time_t *maxtime)
  503. {
  504. char *p;
  505. int n;
  507. if ( *subdir != '.' || strcmp(subdir, ".") == 0 ||
  508. strcmp(subdir, "..") == 0 || strcmp(subdir, ".Trash") == 0)
  509. return (0);
  511. p=(char *)malloc(strlen(dir)+strlen(subdir)+2);
  512. if (!p) return (-1);
  513. strcat(strcat(strcpy(p, dir), "/"), subdir);
  514. n=statcurnew(p, maxtime);
  515. free(p);
  516. return (n);
  517. }
  519. static int docount(const char *, time_t *, off_t *, unsigned *);
  521. static int countcurnew(const char *dir, time_t *maxtime,
  522. off_t *sizep, unsigned *cntp)
  523. {
  524. char *p=(char *)malloc(strlen(dir)+5);
  525. int n;
  527. if (!p) return (-1);
  528. strcat(strcpy(p, dir), "/new");
  529. n=docount(p, maxtime, sizep, cntp);
  530. if (n == 0)
  531. {
  532. strcat(strcpy(p, dir), "/cur");
  533. n=docount(p, maxtime, sizep, cntp);
  534. }
  535. free(p);
  536. return (n);
  537. }
  539. static int countsubdir(const char *dir, const char *subdir, time_t *maxtime,
  540. off_t *sizep, unsigned *cntp)
  541. {
  542. char *p;
  543. int n;
  545. if ( *subdir != '.' || strcmp(subdir, ".") == 0 ||
  546. strcmp(subdir, "..") == 0 || strcmp(subdir, ".Trash") == 0)
  547. return (0);
  549. p=(char *)malloc(strlen(dir)+strlen(subdir)+2);
  550. if (!p) return (2);
  551. strcat(strcat(strcpy(p, dir), "/"), subdir);
  552. n=countcurnew(p, maxtime, sizep, cntp);
  553. free(p);
  554. return (n);
  555. }
  557. static int docount(const char *dir, time_t *dirstamp,
  558. off_t *sizep, unsigned *cntp)
  559. {
  560. struct stat stat_buf;
  561. char *p;
  562. DIR *dirp;
  563. struct dirent *de;
  564. unsigned long s;
  566. if (stat(dir, &stat_buf)) return (0); /* Ignore */
  567. if (stat_buf.st_mtime > *dirstamp) *dirstamp=stat_buf.st_mtime;
  568. if ((dirp=opendir(dir)) == 0) return (0);
  569. while ((de=readdir(dirp)) != 0)
  570. {
  571. const char *n=de->d_name;
  573. if (*n == '.') continue;
  575. /* PATCH - do not count msgs marked as deleted */
  577. for ( ; *n; n++)
  578. {
  579. if (n[0] != ':' || n[1] != '2' ||
  580. n[2] != ',') continue;
  581. n += 3;
  582. while (*n >= 'A' && *n <= 'Z')
  583. {
  584. if (*n == 'T') break;
  585. ++n;
  586. }
  587. break;
  588. }
  589. if (*n == 'T') continue;
  590. n=de->d_name;
  593. if (maildir_parsequota(n, &s) == 0)
  594. stat_buf.st_size=s;
  595. else
  596. {
  597. p=(char *)malloc(strlen(dir)+strlen(n)+2);
  598. if (!p)
  599. {
  600. closedir(dirp);
  601. return (-1);
  602. }
  603. strcat(strcat(strcpy(p, dir), "/"), n);
  604. if (stat(p, &stat_buf))
  605. {
  606. free(p);
  607. continue;
  608. }
  609. free(p);
  610. }
  611. *sizep += stat_buf.st_size;
  612. ++*cntp;
  613. }
  615. #if CLOSEDIR_VOID
  616. closedir(dirp);
  617. #else
  618. if (closedir(dirp))
  619. return (-1);
  620. #endif
  621. return (0);
  622. }