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

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

WEB邮件程序

开发平台：

C/C++

maildirshared.c：源码内容
  1. /*
  2. ** Copyright 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. #include <sys/stat.h>
  29. #include <string.h>
  30. #include <stdlib.h>
  31. #include <time.h>
  32. #if HAVE_UNISTD_H
  33. #include <unistd.h>
  34. #endif
  35. #include <stdio.h>
  36. #include <ctype.h>
  37. #include <errno.h>
  38. #include <fcntl.h>
  40. #include "maildirmisc.h"
  41. #include "maildircreate.h"
  42. #include "maildirsharedrc.h"
  44. static const char rcsid[]="$Id: maildirshared.c,v 1.12 2000/05/07 17:14:24 mrsam Exp $";
  46. /* Prerequisited for shared folder support */
  48. #if HAVE_READLINK
  49. #if HAVE_SYMLINK
  50. #if HAVE_DBOBJ
  52. #define YES_WE_CAN_DO_SHARED 1
  54. #endif
  55. #endif
  56. #endif
  58. #if YES_WE_CAN_DO_SHARED
  60. #include "dbobj.h"
  62. static void list_sharable(const char *, const char *,
  63. void (*)(const char *, void *),
  64. void *);
  66. extern FILE *maildir_shared_fopen(const char *, const char *);
  67. extern void maildir_shared_fparse(char *, char **, char **);
  69. void maildir_list_sharable(const char *maildir,
  70. void (*func)(const char *, void *),
  71. void *voidp)
  72. {
  73. char buf[BUFSIZ];
  74. FILE *fp;
  75. char *p;
  76. int pass;
  78. if (!maildir) maildir=".";
  80. for (pass=0; pass<2; pass++)
  81. {
  82. fp=pass ? maildir_shared_fopen(maildir, "r")
  83. : fopen (MAILDIRSHAREDRC, "r");
  85. if (!fp) continue;
  87. while ((p=fgets(buf, sizeof(buf), fp)) != 0)
  88. {
  89. char *name, *dir;
  91. maildir_shared_fparse(p, &name, &dir);
  92. if (name)
  93. list_sharable(name, dir, func, voidp);
  94. }
  95. fclose(fp);
  96. }
  97. }
  99. static void list_sharable(const char *pfix, const char *path,
  100. void (*func)(const char *, void *),
  101. void *voidp)
  102. {
  103. DIR *dirp;
  104. struct dirent *de;
  105. struct stat stat_buf;
  107. dirp=opendir(path);
  108. while (dirp && (de=readdir(dirp)) != 0)
  109. {
  110. char *z;
  112. if (de->d_name[0] != '.') continue;
  113. if (strcmp(de->d_name, ".") == 0 ||
  114. strcmp(de->d_name, "..") == 0) continue;
  116. z=malloc(strlen(path)+strlen(de->d_name)+12);
  117. if (!z) continue;
  119. strcat(strcat(strcat(strcpy(z, path),
  120. "/"), de->d_name), "/cur/.");
  122. if (stat(z, &stat_buf))
  123. {
  124. free(z);
  125. continue;
  126. }
  127. free(z);
  128. z=malloc(strlen(pfix)+strlen(de->d_name)+1);
  129. if (!z) continue;
  130. strcat(strcpy(z, pfix), de->d_name);
  131. (*func)(z, voidp);
  132. free(z);
  133. }
  134. if (dirp) closedir(dirp);
  135. }
  137. int maildir_shared_subscribe(const char *maildir, const char *folder)
  138. {
  139. char linebuf[BUFSIZ];
  140. FILE *fp;
  141. char *p;
  142. char *name=strchr(folder, '.');
  143. char *s, *n, *dir;
  144. char *buf, *link;
  145. unsigned l;
  146. int pass;
  148. if (!name)
  149. {
  150. errno=EINVAL;
  151. return (-1);
  152. }
  154. if (!maildir) maildir=".";
  155. p=maildir_shareddir(maildir, folder); /* valid folder name? */
  156. if (!p)
  157. {
  158. errno=EINVAL;
  159. return (-1);
  160. }
  161. free(p);
  163. p=0;
  165. for (pass=0; pass<2; pass++)
  166. {
  167. fp=pass ? maildir_shared_fopen(maildir, "r")
  168. : fopen (MAILDIRSHAREDRC, "r");
  170. if (!fp) continue;
  172. while ((p=fgets(linebuf, sizeof(linebuf), fp)) != 0)
  173. {
  174. maildir_shared_fparse(p, &n, &dir);
  176. if (!n) continue;
  178. if (strlen(n) == name - folder ||
  179. memcmp(n, folder, name-folder) == 0) break;
  180. }
  181. fclose(fp);
  183. if (p) break;
  184. }
  186. if (p)
  187. {
  188. /*
  189. ** We will create:
  190. **
  191. **  maildir/shared-folders/ (name-folder) /(name)
  192. **
  193. **  there we'll have subdirs cur/new/tmp  and shared link
  194. */
  196. l=sizeof("/" SHAREDSUBDIR "//shared") +
  197. strlen(maildir) + strlen(folder);
  198. buf=malloc(l);
  199. if (!buf) return (-1);
  200. strcat(strcpy(buf, maildir), "/" SHAREDSUBDIR);
  201. mkdir(buf, 0700);
  202. strcat(buf, "/");
  203. strncat(buf, folder, name-folder);
  204. mkdir(buf, 0700);
  205. strcat(buf, "/");
  206. strcat(buf, name+1);
  207. if ( mkdir(buf, 0700)) return (-1);
  208. s=buf+strlen(buf);
  209. *s++='/';
  210. strcpy(s, "tmp");
  211. if ( mkdir(buf, 0700))
  212. {
  213. s[-1]=0;
  214. rmdir(buf);
  215. free(buf);
  216. return (-1);
  217. }
  218. strcpy(s, "cur");
  219. if ( mkdir(buf, 0700))
  220. {
  221. strcpy(s, "tmp");
  222. rmdir(buf);
  223. s[-1]=0;
  224. rmdir(buf);
  225. free(buf);
  226. return (-1);
  227. }
  228. strcpy(s, "new");
  229. if ( mkdir(buf, 0700))
  230. {
  231. strcpy(s, "cur");
  232. rmdir(buf);
  233. strcpy(s, "tmp");
  234. rmdir(buf);
  235. s[-1]=0;
  236. rmdir(buf);
  237. free(buf);
  238. return (-1);
  239. }
  241. strcpy(s, "shared");
  242. if ((link=malloc(strlen(dir)+strlen(name)+2)) == 0 ||
  243. symlink( strcat(strcat(strcpy(link, dir), "/"), name),
  244. buf))
  245. {
  246. if (link) free(link);
  247. strcpy(s, "new");
  248. rmdir(buf);
  249. strcpy(s, "cur");
  250. rmdir(buf);
  251. strcpy(s, "tmp");
  252. rmdir(buf);
  253. s[-1]=0;
  254. rmdir(buf);
  255. free(buf);
  256. return (-1);
  257. }
  258. free(link);
  259. free(buf);
  260. return (0);
  261. }
  262. errno=ENOENT;
  263. return (-1);
  264. }
  266. void maildir_list_shared(const char *maildir,
  267. void (*func)(const char *, void *),
  268. void *voidp)
  269. {
  270. char *sh;
  271. DIR *dirp;
  272. struct dirent *de;
  274. if (!maildir) maildir=".";
  275. sh=malloc(strlen(maildir)+sizeof("/" SHAREDSUBDIR));
  276. if (!sh) return;
  278. strcat(strcpy(sh, maildir), "/" SHAREDSUBDIR);
  280. dirp=opendir(sh);
  281. while (dirp && (de=readdir(dirp)) != 0)
  282. {
  283. DIR *dirp2;
  284. struct dirent *de2;
  285. char *z;
  287. if (de->d_name[0] == '.') continue;
  289. z=malloc(strlen(sh)+strlen(de->d_name)+2);
  290. if (!z) continue;
  291. strcat(strcat(strcpy(z, sh), "/"), de->d_name);
  292. dirp2=opendir(z);
  293. free(z);
  295. while (dirp2 && (de2=readdir(dirp2)) != 0)
  296. {
  297. char *s;
  299. if (de2->d_name[0] == '.') continue;
  300. s=malloc(strlen(de->d_name)+strlen(de2->d_name)+2);
  301. if (!s) continue;
  302. strcat(strcat(strcpy(s, de->d_name), "."), de2->d_name);
  303. (*func)(s, voidp);
  304. free(s);
  305. }
  306. if (dirp2) closedir(dirp2);
  307. }
  308. free(sh);
  309. if (dirp) closedir(dirp);
  310. }
  312. int maildir_shared_unsubscribe(const char *maildir, const char *folder)
  313. {
  314. char *s;
  316. s=maildir_shareddir(maildir, folder);
  317. if (!s) return (-1);
  319. if (maildir_mddelete(s))
  320. {
  321. free(s);
  322. return (-1);
  323. }
  324. *strrchr(s, '/')=0; /* Try to remove the whole folder dir */
  325. rmdir(s);
  326. free(s);
  327. return (0);
  328. }
  330. char *maildir_shareddir(const char *maildir, const char *sharedname)
  331. {
  332. char    *p, *q;
  333. const char *r;
  334. size_t  l;
  336. if (!maildir)   maildir=".";
  337.         l=strlen(maildir);
  339. if (strchr(sharedname, '.') == 0 || *sharedname == '.' ||
  340. strchr(sharedname, '/'))
  341. {
  342. errno=EINVAL;
  343. return (0);
  344. }
  346. for (r=sharedname; *r; r++)
  347. {
  348. if (*r == '.' && (r[1] == '.' || r[1] == ''))
  349. {
  350. errno=EINVAL;
  351. return (0);
  352. }
  353. }
  355. p=malloc(strlen(maildir)+sizeof("/" SHAREDSUBDIR "/")+strlen(sharedname));
  356. if (!p) return (0);
  358.         *p=0;
  359.         if (strcmp(maildir, "."))
  360. strcat(strcpy(p, maildir), "/");
  361. strcat(p, SHAREDSUBDIR "/");
  362. q=p+strlen(p);
  363. strcpy(q, sharedname);
  364. *strchr(q, '.')='/';
  365. return (p);
  366. }
  368. /*                    LET'S SYNC IT                  */
  370. static void do_maildir_shared_sync(const char *, const char *);
  372. void maildir_shared_sync(const char *dir)
  373. {
  374. char *shareddir;
  375. char *buf;
  377. shareddir=malloc(strlen(dir)+sizeof("/shared"));
  378. if (!shareddir)
  379. {
  380. perror("malloc");
  381. return;
  382. }
  383. strcat(strcpy(shareddir, dir),"/shared");
  385. buf=maildir_getlink(shareddir);
  386. free(shareddir);
  387. if (buf)
  388. {
  389. do_maildir_shared_sync(dir, buf);
  390. free(buf);
  391. }
  392. }
  394. /* Step 1 - safely create a temporary database */
  396. static int create_db(struct dbobj *obj,
  397. const char *dir,
  398. char **dbname)
  399. {
  400. int rc;
  401. char *tmpname, *dummy;
  403. for (;;)
  404. {
  405. int fd;
  407. rc=maildir_try_create(dir, "sync", 0, &tmpname, &dummy);
  408. if (rc < 0)
  409. {
  410. perror(dir);
  411. return (-1);
  412. }
  414. if (rc == 0)
  415. {
  416. fd=maildir_safeopen(tmpname, O_RDWR|O_CREAT|O_EXCL,
  417. 0600);
  418. if (fd >= 0)
  419. {
  420. dbobj_init(obj);
  421. if (dbobj_open(obj, tmpname, "N") < 0)
  422. {
  423. perror(tmpname);
  424. close(fd);
  425. unlink(tmpname);
  426. free(tmpname);
  427. free(dummy);
  428. return (-1);
  429. }
  430. close(fd);
  431. free(dummy);
  432. break;
  433. }
  434. perror(tmpname);
  435. free(tmpname);
  436. free(dummy);
  437. }
  438. sleep(3);
  439. }
  441. *dbname=tmpname;
  442. return (0);
  443. }
  445. /*
  446. ** Populate the DB by building the db with the messages in the sharable
  447. ** folder's cur.  The key is the stripped message filename, the value is
  448. ** the complete message filename.
  449. */
  451. static int build_db(const char *shared, struct dbobj *obj)
  452. {
  453. char *dummy=malloc(strlen(shared)+sizeof("/cur"));
  454. DIR *dirp;
  455. struct dirent *de;
  457. if (!dummy)
  458. {
  459. perror("malloc");
  460. return (-1);
  461. }
  463. strcat(strcpy(dummy, shared), "/cur");
  465. dirp=opendir(dummy);
  466. while (dirp && (de=readdir(dirp)) != 0)
  467. {
  468. char *a, *b;
  469. char *c;
  471. if (de->d_name[0] == '.')
  472. continue;
  473. if ((a=malloc(strlen(de->d_name)+1)) == 0)
  474. {
  475. perror("malloc");
  476. closedir(dirp);
  477. free(dummy);
  478. return (-1);
  479. }
  480. if ((b=malloc(strlen(de->d_name)+1)) == 0)
  481. {
  482. perror("malloc");
  483. closedir(dirp);
  484. free(dummy);
  485. free(a);
  486. return (-1);
  487. }
  488. strcpy(a, de->d_name);
  489. strcpy(b, de->d_name);
  490. c=strrchr(a, ':');
  491. if (c) *c=0;
  493. if (dbobj_store(obj, a, strlen(a), b, strlen(b), "R"))
  494. {
  495. perror("dbobj_store");
  496. free(a);
  497. free(b);
  498. closedir(dirp);
  499. free(dummy);
  500. return (-1);
  501. }
  502. free(a);
  503. free(b);
  504. }
  505. if (dirp) closedir(dirp);
  506. free(dummy);
  507. return (0);
  508. }
  510. static int update_link(const char *,
  511. const char *, const char *,
  512. const char *,
  513. const char *,
  514. size_t);
  516. /*
  517. ** Now, read our synced cur directory, and make sure that the soft
  518. ** links are up to date.  Remove messages that have been deleted from
  519. ** the sharable maildir, and make sure that the remaining links are
  520. ** valid.
  521. */
  523. static int update_cur(const char *cur, const char *shared, struct dbobj *obj)
  524. {
  525. DIR *dirp;
  526. struct dirent *de;
  527. char *p;
  529. dirp=opendir(cur);
  530. while (dirp && (de=readdir(dirp)) != 0)
  531. {
  532. char *cur_base;
  534. char *cur_name_ptr;
  535. size_t cur_name_len;
  537. char *linked_name_buf;
  538. size_t linked_name_len;
  539. int n;
  541. if (de->d_name[0] == '.') continue;
  543. /*
  544. ** Strip the maildir flags, and look up the message in the
  545. ** db.
  546. */
  548. cur_base=malloc(strlen(de->d_name)+1);
  549. if (!cur_base)
  550. {
  551. perror("malloc");
  552. closedir(dirp);
  553. return (-1);
  554. }
  555. strcpy(cur_base, de->d_name);
  556. p=strrchr(cur_base, ':');
  557. if (p) *p=0;
  559. cur_name_ptr=dbobj_fetch(obj, cur_base, strlen(cur_base),
  560. &cur_name_len, "");
  562. /* If it's there, delete the db entry. */
  564. if (cur_name_ptr)
  565. dbobj_delete(obj, cur_base, strlen(cur_base));
  567. /*
  568. ** We'll either delete this soft link, or check its
  569. ** contents, so we better build its complete pathname in
  570. ** any case.
  571. */
  573. free(cur_base);
  574. cur_base=malloc(strlen(de->d_name)+strlen(cur)+2);
  575. if (!cur_base)
  576. {
  577. perror("malloc");
  578. if (cur_name_ptr) free(cur_name_ptr);
  579. closedir(dirp);
  580. return (-1);
  581. }
  582. strcat(strcat(strcpy(cur_base, cur), "/"), de->d_name);
  584. if (!cur_name_ptr) /* Removed from sharable dir */
  585. {
  586. unlink(cur_base);
  587. free(cur_base);
  588. continue;
  589. }
  591. linked_name_len=strlen(shared)+strlen(de->d_name)+100;
  592. /* should be enough */
  594. if ((linked_name_buf=malloc(linked_name_len)) == 0)
  595. {
  596. perror("malloc");
  597. free(cur_base);
  598. free(cur_name_ptr);
  599. closedir(dirp);
  600. return (-1);
  601. }
  603. if ((n=readlink(cur_base, linked_name_buf, linked_name_len))< 0)
  604. {
  605. /* This is stupid, let's just unlink this nonsense */
  607. n=0;
  608. }
  610. if (n == 0 || n >= linked_name_len ||
  611. (linked_name_buf[n]=0,
  612. update_link(cur,
  613. cur_base, linked_name_buf, shared, cur_name_ptr,
  614. cur_name_len)))
  615. {
  616. unlink(cur_base);
  617. free(linked_name_buf);
  618. free(cur_base);
  619. free(cur_name_ptr);
  620. closedir(dirp);
  621. return (-1);
  622. }
  623. free(cur_base);
  624. free(linked_name_buf);
  625. free(cur_name_ptr);
  626. }
  627. if (dirp) closedir(dirp);
  628. return (0);
  629. }
  631. /* Update the link pointer */
  633. static int update_link(const char *curdir,
  634. const char *linkname, const char *linkvalue,
  635. const char *shareddir,
  636. const char *msgfilename,
  637. size_t msgfilenamelen)
  638. {
  639. char *p=malloc(strlen(shareddir)+sizeof("/cur/")+msgfilenamelen);
  640. char *q;
  641. int rc;
  642. char *tmpname, *dummy;
  644. if (!p)
  645. {
  646. perror("malloc");
  647. return (-1);
  648. }
  650. strcat(strcpy(p, shareddir), "/cur/");
  651. q=p+strlen(p);
  652. memcpy(q, msgfilename, msgfilenamelen);
  653. q[msgfilenamelen]=0;
  655. if (linkvalue && strcmp(p, linkvalue) == 0)
  656. {
  657. /* the link is good */
  659. free(p);
  660. return (0);
  661. }
  663. /* Ok, we want this to be an atomic operation. */
  665. for (;;)
  666. {
  667. rc=maildir_try_create(curdir, "relink", 0, &tmpname, &dummy);
  668. if (rc < 0)
  669. {
  670. perror(curdir);
  671. return (-1);
  672. }
  674. if (rc == 0)
  675. {
  676. free(dummy);
  678. if (symlink(p, tmpname))
  679. {
  680. perror(tmpname);
  681. free(tmpname);
  682. free(p);
  683. return (-1);
  684. }
  685. break;
  686. }
  687. sleep(3);
  688. }
  689. free(p);
  691. if (rename(tmpname, linkname))
  692. {
  693. perror(linkname);
  694. unlink(tmpname);
  695. free(tmpname);
  696. return (-1);
  697. }
  698. free(tmpname);
  699. return (0);
  700. }
  702. /* and now, anything that's left in the temporary db must be new messages */
  704. static int newmsgs(const char *cur, const char *shared, struct dbobj *obj)
  705. {
  706. char *key, *val;
  707. size_t keylen, vallen;
  708. int rc;
  709. char *tmpname, *dummy;
  711. for (key=dbobj_firstkey(obj, &keylen, &val, &vallen); key;
  712. key=dbobj_nextkey(obj, &keylen, &val, &vallen))
  713. {
  714. char *slink=malloc(strlen(shared)+sizeof("/cur/")+vallen);
  715. char *q;
  717. if (!slink)
  718. {
  719. free(val);
  720. return (-1);
  721. }
  723. strcat(strcpy(slink, shared), "/cur/");
  724. q=slink+strlen(slink);
  725. memcpy(q, val, vallen);
  726. q[vallen]=0;
  727. free(val);
  729. for (;;)
  730. {
  731. rc=maildir_try_create(cur, "newlink",
  732. 0, &tmpname, &dummy);
  733. if (rc < 0)
  734. {
  735. perror(cur);
  736. free(slink);
  737. return (-1);
  738. }
  740. if (rc == 0)
  741. {
  742. free(dummy);
  744. if (symlink(slink, tmpname))
  745. {
  746. perror(tmpname);
  747. free(tmpname);
  748. free(slink);
  749. return (-1);
  750. }
  751. break;
  752. }
  753. sleep(3);
  754. }
  756. free(slink);
  757. slink=malloc(strlen(cur)+sizeof("/new/:2,")+keylen);
  758. if (!slink)
  759. {
  760. perror("malloc");
  761. unlink(tmpname);
  762. free(tmpname);
  763. }
  764. strcat(strcpy(slink, cur), "/new/");
  765. q=slink+strlen(slink);
  766. memcpy(q, key, keylen);
  767. strcpy(q+keylen, ":2,");
  769. if (rename(tmpname, slink))
  770. {
  771. perror(slink);
  772. unlink(tmpname);
  773. free(tmpname);
  774. }
  775. }
  776. return (0);
  777. }
  779. static void do_maildir_shared_sync(const char *dir, const char *shared)
  780. {
  781. struct dbobj obj;
  782. char *dbname;
  783. char *cur;
  784. char *shared_update_name;
  786. struct stat stat1, stat2;
  787. int fd;
  789. maildir_purgetmp(dir); /* clean up after myself */
  790. maildir_getnew(dir, 0);
  792. maildir_purgetmp(shared);
  793. maildir_getnew(shared, 0);
  795. /* Figure out if we REALLY need to sync something */
  797. shared_update_name=malloc(strlen(dir)+sizeof("/shared-timestamp"));
  798. if (!shared_update_name) return;
  799. strcat(strcpy(shared_update_name, dir), "/shared-timestamp");
  800. cur=malloc(strlen(shared)+sizeof("/new"));
  801. if (!cur)
  802. {
  803. free(shared_update_name);
  804. return;
  805. }
  807. if (stat(shared_update_name, &stat1) == 0)
  808. {
  809. if ( stat( strcat(strcpy(cur, shared), "/new"), &stat2) == 0 &&
  810. stat2.st_mtime < stat1.st_mtime &&
  811. stat( strcat(strcpy(cur, shared), "/cur"), &stat2)
  812. == 0 && stat2.st_mtime < stat1.st_mtime)
  813. {
  814. free(shared_update_name);
  815. free(cur);
  816. return;
  817. }
  818. }
  819. if ((fd=maildir_safeopen(shared_update_name, O_RDWR|O_CREAT, 0600))>= 0)
  820. {
  821. write(fd, "", 1);
  822. close(fd);
  823. }
  825. if (create_db(&obj, dir, &dbname)) return;
  827. if (build_db(shared, &obj))
  828. {
  829. dbobj_close(&obj);
  830. unlink(dbname);
  831. free(dbname);
  832. return;
  833. }
  835. if ((cur=malloc(strlen(dir)+sizeof("/cur"))) == 0)
  836. {
  837. perror("malloc");
  838. dbobj_close(&obj);
  839. unlink(dbname);
  840. free(dbname);
  841. return;
  842. }
  843. strcat(strcpy(cur, dir), "/cur");
  844. if (update_cur(cur, shared, &obj) == 0)
  845. {
  846. strcat(strcpy(cur, dir), "/new");
  847. if (update_cur(cur, shared, &obj) == 0)
  848. {
  849. *strrchr(cur, '/')=0; /* Chop off the /new */
  850. newmsgs(cur, shared, &obj);
  851. }
  852. }
  854. free(cur);
  855. dbobj_close(&obj);
  856. unlink(dbname);
  857. free(dbname);
  858. }
  860. int maildir_sharedisro(const char *maildir)
  861. {
  862. char *p=malloc(strlen(maildir)+sizeof("/shared/cur"));
  864. if (!p)
  865. {
  866. perror("malloc");
  867. return (-1);
  868. }
  869. strcat(strcpy(p, maildir), "/shared/cur");
  871. if (access(p, W_OK) == 0)
  872. {
  873. free(p);
  874. return (0);
  875. }
  876. free(p);
  877. return (1);
  878. }
  880. int maildir_unlinksharedmsg(const char *filename)
  881. {
  882. char *buf=maildir_getlink(filename);
  884. if (buf)
  885. {
  886. if (access(buf, 0) == 0)
  887. {
  888. if (unlink(buf))
  889. {
  890. free(buf);
  891. return (-1);
  892. }
  893. }
  894. free(buf);
  895. }
  896. unlink(filename);
  897. return (0);
  898. }
  901. #else
  903. /* We cannot implement sharing */
  905. void maildir_list_sharable(const char *maildir,
  906. void (*func)(const char *, void *),
  907. void *voidp)
  908. {
  909. }
  911. int maildir_shared_subscribe(const char *maildir, const char *folder)
  912. {
  913. errno=EINVAL;
  914. return (-1);
  915. }
  917. void maildir_list_shared(const char *maildir,
  918. void (*func)(const char *, void *),
  919. void *voidp)
  920. {
  921. }
  923. int maildir_shared_unsubscribe(const char *maildir, const char *folder)
  924. {
  925. errno=EINVAL;
  926. return (-1);
  927. }
  929. char *maildir_shareddir(const char *maildir, const char *sharedname)
  930. {
  931. errno=EINVAL;
  932. return (0);
  933. }
  935. void maildir_shared_sync(const char *maildir)
  936. {
  937. }
  939. int maildir_sharedisro(const char *maildir)
  940. {
  941. return (-1);
  942. }
  944. int maildir_unlinksharedmsg(const char *filename)
  945. {
  946. return (-1);
  947. }
  948. #endif