# include "config.h"
#endif
-#include "mutt.h"
-#include "mx.h"
-#include "mh.h"
-#include "mbox.h"
-#include "copy.h"
-#include "buffy.h"
-#include "sort.h"
-
-#include "lib/mem.h"
-#include "lib/intl.h"
-#include "lib/str.h"
-
#include <sys/stat.h>
#include <sys/types.h>
#include <dirent.h>
#include <sys/time.h>
#endif
+#include <lib-lib/mem.h>
+#include <lib-lib/str.h>
+#include <lib-lib/macros.h>
+#include <lib-lib/file.h>
+#include <lib-lib/debug.h>
+
+#include "mutt.h"
+#include "mx.h"
+#include "mh.h"
+#include "mbox.h"
+#include "copy.h"
+#include "buffy.h"
+#include "sort.h"
+#include "thread.h"
+#include "hcache.h"
+
struct maildir {
HEADER *h;
char *canon_fname;
unsigned header_parsed:1;
-#ifdef USE_INODESORT
- ino_t inode;
-#endif /* USE_INODESORT */
struct maildir *next;
};
#define MH_SEQ_REPLIED (1 << 1)
#define MH_SEQ_FLAGGED (1 << 2)
+/* prototypes */
+static int maildir_check_empty (const char*);
+static int maildir_check_mailbox (CONTEXT*, int*, int);
+static int mh_check_mailbox (CONTEXT*, int*, int);
+
static void mhs_alloc (struct mh_sequences *mhs, int i)
{
int j;
if (i > mhs->max || !mhs->flags) {
newmax = i + 128;
- safe_realloc (&mhs->flags, sizeof (mhs->flags[0]) * (newmax + 1));
+ p_realloc(&mhs->flags, newmax + 1);
for (j = mhs->max + 1; j <= newmax; j++)
mhs->flags[j] = 0;
static void mhs_free_sequences (struct mh_sequences *mhs)
{
- FREE (&mhs->flags);
+ p_delete(&mhs->flags);
}
static short mhs_check (struct mh_sequences *mhs, int i)
int line = 1;
char *buff = NULL;
char *t;
- size_t sz = 0;
+ ssize_t sz = 0;
short f;
int first, last;
if (!(t = strtok (buff, " \t:")))
continue;
- if (!safe_strcmp (t, MhUnseen))
+ if (!m_strcmp(t, MhUnseen))
f = MH_SEQ_UNSEEN;
- else if (!safe_strcmp (t, MhFlagged))
+ else if (!m_strcmp(t, MhFlagged))
f = MH_SEQ_FLAGGED;
- else if (!safe_strcmp (t, MhReplied))
+ else if (!m_strcmp(t, MhReplied))
f = MH_SEQ_REPLIED;
else /* unknown sequence */
continue;
}
}
- FREE (&buff);
+ p_delete(&buff);
safe_fclose (&fp);
}
int i, r = 0;
struct mh_sequences mhs;
- memset (&mhs, 0, sizeof (mhs));
+ p_clear(&mhs, 1);
mh_read_sequences (&mhs, path);
for (i = 0; !r && i <= mhs.max; i++)
int fd;
char path[_POSIX_PATH_MAX];
- FOREVER {
+ for (;;) {
snprintf (path, _POSIX_PATH_MAX, "%s/.mutt-%s-%d-%d",
dest->path, NONULL (Hostname), (int) getpid (), Counter++);
umask (Umask);
}
}
else {
- *tgt = safe_strdup (path);
+ *tgt = m_strdup(path);
break;
}
}
if ((*fp = fdopen (fd, "w")) == NULL) {
- FREE (tgt);
+ p_delete(tgt);
close (fd);
unlink (path);
return (-1);
char *tmpfname;
char *buff = NULL;
char *p;
- size_t s;
+ ssize_t s;
int l = 0;
int i;
struct mh_sequences mhs;
- memset (&mhs, 0, sizeof (mhs));
+ p_clear(&mhs, 1);
snprintf (seq_unseen, sizeof (seq_unseen), "%s:", NONULL (MhUnseen));
snprintf (seq_replied, sizeof (seq_replied), "%s:", NONULL (MhReplied));
/* first, copy unknown sequences */
if ((ofp = fopen (sequences, "r"))) {
while ((buff = mutt_read_line (buff, &s, ofp, &l))) {
- if (!safe_strncmp (buff, seq_unseen, safe_strlen (seq_unseen)))
+ if (!m_strncmp(buff, seq_unseen, m_strlen(seq_unseen)))
continue;
- if (!safe_strncmp (buff, seq_flagged, safe_strlen (seq_flagged)))
+ if (!m_strncmp(buff, seq_flagged, m_strlen(seq_flagged)))
continue;
- if (!safe_strncmp (buff, seq_replied, safe_strlen (seq_replied)))
+ if (!m_strncmp(buff, seq_replied, m_strlen(seq_replied)))
continue;
fprintf (nfp, "%s\n", buff);
unlink (tmpfname);
}
- FREE (&tmpfname);
+ p_delete(&tmpfname);
}
static void mh_sequences_add_one (CONTEXT * ctx, int n, short unseen,
char *buff = NULL;
int line;
- size_t sz;
+ ssize_t sz;
if (mh_mkstemp (ctx, &nfp, &tmpfname) == -1)
return;
snprintf (sequences, sizeof (sequences), "%s/.mh_sequences", ctx->path);
if ((ofp = fopen (sequences, "r"))) {
while ((buff = mutt_read_line (buff, &sz, ofp, &line))) {
- if (unseen && !strncmp (buff, seq_unseen, safe_strlen (seq_unseen))) {
+ if (unseen && !strncmp (buff, seq_unseen, m_strlen(seq_unseen))) {
fprintf (nfp, "%s %d\n", buff, n);
unseen_done = 1;
}
else if (flagged
- && !strncmp (buff, seq_flagged, safe_strlen (seq_flagged))) {
+ && !strncmp (buff, seq_flagged, m_strlen(seq_flagged))) {
fprintf (nfp, "%s %d\n", buff, n);
flagged_done = 1;
}
else if (replied
- && !strncmp (buff, seq_replied, safe_strlen (seq_replied))) {
+ && !strncmp (buff, seq_replied, m_strlen(seq_replied))) {
fprintf (nfp, "%s %d\n", buff, n);
replied_done = 1;
}
}
}
safe_fclose (&ofp);
- FREE (&buff);
+ p_delete(&buff);
if (!unseen_done && unseen)
fprintf (nfp, "%s: %d\n", NONULL (MhUnseen), n);
if (safe_rename (tmpfname, sequences) != 0)
unlink (tmpfname);
- FREE (&tmpfname);
+ p_delete(&tmpfname);
}
static void mh_update_maildir (struct maildir *md, struct mh_sequences *mhs)
if (!md || !*md)
return;
- FREE (&(*md)->canon_fname);
+ p_delete(&(*md)->canon_fname);
if ((*md)->h)
- mutt_free_header (&(*md)->h);
+ header_delete(&(*md)->h);
- FREE (md);
+ p_delete(md);
}
static void maildir_free_maildir (struct maildir **md)
h->read = 0;
h->replied = 0;
- if ((p = strrchr (path, ':')) != NULL && safe_strncmp (p + 1, "2,", 2) == 0) {
+ if ((p = strrchr (path, ':')) != NULL && m_strncmp(p + 1, "2,", 2) == 0) {
p += 3;
- str_replace (&h->maildir_flags, p);
+ m_strreplace(&h->maildir_flags, p);
q = h->maildir_flags;
while (*p) {
}
if (q == h->maildir_flags)
- FREE (&h->maildir_flags);
+ p_delete(&h->maildir_flags);
else if (q)
*q = '\0';
}
if (stat (buf, &st) == 0)
ctx->mtime_cur = st.st_mtime;
- strfcpy (buf, ctx->path, sizeof (buf));
+ m_strcpy(buf, sizeof(buf), ctx->path);
}
if (stat (buf, &st) == 0)
if ((f = fopen (fname, "r")) != NULL) {
if (!h)
- h = mutt_new_header ();
+ h = header_new();
h->env = mutt_read_rfc822_header (f, h, 0, 0);
fstat (fileno (f), &st);
static int maildir_parse_entry (CONTEXT * ctx, struct maildir ***last,
const char *subdir, const char *fname,
- int *count, int is_old, ino_t inode)
+ int *count, int is_old, ino_t inode __attribute__ ((unused)))
{
struct maildir *entry;
HEADER *h = NULL;
if (ctx->magic == M_MH)
h = maildir_parse_message (ctx->magic, buf, is_old, NULL);
else {
- h = mutt_new_header ();
+ h = header_new();
h->old = is_old;
maildir_parse_flags (h, buf);
}
if (subdir) {
snprintf (buf, sizeof (buf), "%s/%s", subdir, fname);
- h->path = safe_strdup (buf);
+ h->path = m_strdup(buf);
}
else
- h->path = safe_strdup (fname);
+ h->path = m_strdup(fname);
- entry = safe_calloc (sizeof (struct maildir), 1);
+ entry = p_new(struct maildir, 1);
entry->h = h;
entry->header_parsed = (ctx->magic == M_MH);
-#ifdef USE_INODESORT
- entry->inode = inode;
-#endif /* USE_INODESORT */
**last = entry;
*last = &entry->next;
if (subdir) {
snprintf (buf, sizeof (buf), "%s/%s", ctx->path, subdir);
- is_old = (safe_strcmp ("cur", subdir) == 0);
+ is_old = (m_strcmp("cur", subdir) == 0);
}
else
- strfcpy (buf, ctx->path, sizeof (buf));
+ m_strcpy(buf, sizeof(buf), ctx->path);
if ((dirp = opendir (buf)) == NULL)
return -1;
/* FOO - really ignore the return value? */
- dprint (2,
- (debugfile, "%s:%d: parsing %s\n", __FILE__, __LINE__,
- de->d_name));
+ debug_print (2, ("parsing %s\n", de->d_name));
maildir_parse_entry (ctx, last, subdir, de->d_name, count, is_old,
- de->d_ino);
+#if HAVE_DIRENT_D_INO
+ de->d_ino
+#else
+ 0
+#endif
+ );
}
closedir (dirp);
while (md) {
- dprint (2, (debugfile, "%s:%d maildir_add_to_context(): Considering %s\n",
- __FILE__, __LINE__, NONULL (md->canon_fname)));
+ debug_print (2, ("considering %s\n", NONULL (md->canon_fname)));
if (md->h) {
- dprint (2,
- (debugfile,
- "%s:%d Adding header structure. Flags: %s%s%s%s%s\n", __FILE__,
- __LINE__, md->h->flagged ? "f" : "", md->h->deleted ? "D" : "",
- md->h->replied ? "r" : "", md->h->old ? "O" : "",
- md->h->read ? "R" : ""));
+ debug_print (2, ("flags: %s%s%s%s%s\n", md->h->flagged ? "f" : "",
+ md->h->deleted ? "D" : "", md->h->replied ? "r" : "",
+ md->h->old ? "O" : "", md->h->read ? "R" : ""));
if (ctx->msgcount == ctx->hdrmax)
mx_alloc_memory (ctx);
return r;
}
-#ifdef USE_INODESORT
-/*
- * Merge two maildir lists according to the inode numbers.
- */
-static struct maildir *maildir_merge_inode (struct maildir *left,
- struct maildir *right)
+#ifdef USE_HCACHE
+static ssize_t maildir_hcache_keylen (const char *fn)
{
- struct maildir *head;
- struct maildir *tail;
-
- if (left && right) {
- if (left->inode < right->inode) {
- head = left;
- left = left->next;
- }
- else {
- head = right;
- right = right->next;
- }
- }
- else {
- if (left)
- return left;
- else
- return right;
- }
-
- tail = head;
-
- while (left && right) {
- if (left->inode < right->inode) {
- tail->next = left;
- left = left->next;
- }
- else {
- tail->next = right;
- right = right->next;
- }
- tail = tail->next;
- }
-
- if (left) {
- tail->next = left;
- }
- else {
- tail->next = right;
- }
-
- return head;
-}
-
-/*
- * Sort maildir list according to inode.
- */
-static struct maildir *maildir_sort_inode (struct maildir *list)
-{
- struct maildir *left = list;
- struct maildir *right = list;
-
- if (!list || !list->next) {
- return list;
- }
-
- list = list->next;
- while (list && list->next) {
- right = right->next;
- list = list->next->next;
- }
-
- list = right;
- right = right->next;
- list->next = 0;
-
- left = maildir_sort_inode (left);
- right = maildir_sort_inode (right);
- return maildir_merge_inode (left, right);
-}
-#endif /* USE_INODESORT */
-
-#if USE_HCACHE
-static size_t maildir_hcache_keylen (const char *fn)
-{
- const char *p = strchr (fn, ':');
-
- return p ? (size_t) (p - fn) : safe_strlen (fn);
+ return m_strchrnul(fn, ':') - fn;
}
#endif
char fn[_POSIX_PATH_MAX];
int count;
-#if USE_HCACHE
+#ifdef USE_HCACHE
void *hc = NULL;
void *data;
struct timeval *when = NULL;
if (!(p && p->h && !p->header_parsed))
continue;
-#if USE_HCACHE
+#ifdef USE_HCACHE
data = mutt_hcache_fetch (hc, p->h->path + 3, &maildir_hcache_keylen);
when = (struct timeval *) data;
#endif
mutt_message (_("Reading %s... %d"), ctx->path, count);
snprintf (fn, sizeof (fn), "%s/%s", ctx->path, p->h->path);
-#if USE_HCACHE
+#ifdef USE_HCACHE
if (option (OPTHCACHEVERIFY)) {
ret = stat (fn, &lastchanged);
}
if (maildir_parse_message (ctx->magic, fn, p->h->old, p->h)) {
p->header_parsed = 1;
maildir_parse_flags (p->h, fn);
-#if USE_HCACHE
+#ifdef USE_HCACHE
mutt_hcache_store (hc, p->h->path + 3, p->h, 0, &maildir_hcache_keylen);
#endif
}
else
- mutt_free_header (&p->h);
-#if USE_HCACHE
- FREE (&data);
+ header_delete(&p->h);
+#ifdef USE_HCACHE
+ p_delete(&data);
#endif
}
-#if USE_HCACHE
+#ifdef USE_HCACHE
mutt_hcache_close (hc);
#endif
}
int count;
- memset (&mhs, 0, sizeof (mhs));
+ p_clear(&mhs, 1);
maildir_update_mtime (ctx);
mhs_free_sequences (&mhs);
}
-#ifdef USE_INODESORT
- md = maildir_sort_inode (md);
-#endif /* USE_INODESORT */
-
if (ctx->magic == M_MAILDIR)
maildir_delayed_parsing (ctx, md);
return 0;
}
-int mh_read_dir (CONTEXT* ctx) {
+static int mh_read_dir (CONTEXT* ctx) {
return (_mh_read_dir (ctx, NULL));
}
/* read a maildir style mailbox */
-int maildir_read_dir (CONTEXT * ctx)
+static int maildir_read_dir (CONTEXT * ctx)
{
/* maildir looks sort of like MH, except that there are two subdirectories
* of the main folder path from which to read messages
* Open a new (temporary) message in an MH folder.
*/
-int mh_open_new_message (MESSAGE * msg, CONTEXT * dest, HEADER * hdr)
+static int mh_open_new_message (MESSAGE * msg, CONTEXT * dest, HEADER * hdr __attribute__ ((unused)))
{
return mh_mkstemp (dest, &msg->fp, &msg->path);
}
return (int) (*((const char *) a) - *((const char *) b));
}
-static void maildir_flags (char *dest, size_t destlen, HEADER * hdr)
+static void maildir_flags (char *dest, ssize_t destlen, HEADER * hdr)
{
*dest = '\0';
hdr->read ? "S" : "", hdr->deleted ? "T" : "",
NONULL (hdr->maildir_flags));
if (hdr->maildir_flags)
- qsort (tmp, safe_strlen (tmp), 1, ch_compar);
+ qsort (tmp, m_strlen(tmp), 1, ch_compar);
snprintf (dest, destlen, ":2,%s", tmp);
}
}
*
*/
-int maildir_open_new_message (MESSAGE * msg, CONTEXT * dest, HEADER * hdr)
+static int maildir_open_new_message (MESSAGE * msg, CONTEXT * dest, HEADER * hdr)
{
int fd;
char path[_POSIX_PATH_MAX];
*suffix = '\0';
if (hdr && (hdr->read || hdr->old))
- strfcpy (subdir, "cur", sizeof (subdir));
+ m_strcpy(subdir, sizeof(subdir), "cur");
else
- strfcpy (subdir, "new", sizeof (subdir));
+ m_strcpy(subdir, sizeof(subdir), "new");
- FOREVER {
+ for (;;) {
snprintf (path, _POSIX_PATH_MAX, "%s/tmp/%s.%ld.%u_%d.%s%s",
dest->path, subdir, (long) time (NULL),
(unsigned int) getpid (), Counter++, NONULL (Hostname), suffix);
- dprint (2, (debugfile, "maildir_open_new_message (): Trying %s.\n",
- path));
+ debug_print (2, ("trying %s.\n", path));
umask (Umask);
if ((fd = open (path, O_WRONLY | O_EXCL | O_CREAT, 0666)) == -1) {
}
}
else {
- dprint (2, (debugfile, "maildir_open_new_message (): Success.\n"));
- msg->path = safe_strdup (path);
+ debug_print (2, ("success.\n"));
+ msg->path = m_strdup(path);
break;
}
}
if ((msg->fp = fdopen (fd, "w")) == NULL) {
- FREE (&msg->path);
+ p_delete(&msg->path);
close (fd);
unlink (path);
return (-1);
*
*/
-int maildir_commit_message (CONTEXT * ctx, MESSAGE * msg, HEADER * hdr)
+static int maildir_commit_message (MESSAGE * msg, CONTEXT * ctx, HEADER * hdr)
{
char subdir[4];
char suffix[16];
/* extract the subdir */
s = strrchr (msg->path, '/') + 1;
- strfcpy (subdir, s, 4);
+ m_strcpy(subdir, sizeof(subdir), s);
/* extract the flags */
if ((s = strchr (s, ':')))
- strfcpy (suffix, s, sizeof (suffix));
+ m_strcpy(suffix, sizeof(suffix), s);
else
suffix[0] = '\0';
/* construct a new file name. */
- FOREVER {
+ for (;;) {
snprintf (path, _POSIX_PATH_MAX, "%s/%ld.%u_%d.%s%s", subdir,
(long) time (NULL), (unsigned int) getpid (), Counter++,
NONULL (Hostname), suffix);
snprintf (full, _POSIX_PATH_MAX, "%s/%s", ctx->path, path);
- dprint (2, (debugfile, "maildir_commit_message (): renaming %s to %s.\n",
- msg->path, full));
+ debug_print (2, ("renaming %s to %s.\n", msg->path, full));
if (safe_rename (msg->path, full) == 0) {
if (hdr)
- str_replace (&hdr->path, path);
- FREE (&msg->path);
+ m_strreplace(&hdr->path, path);
+ p_delete(&msg->path);
/*
* Adjust the mtime on the file to match the time at which this
*/
-static int _mh_commit_message (CONTEXT * ctx, MESSAGE * msg, HEADER * hdr,
+static int _mh_commit_message (MESSAGE * msg, CONTEXT * ctx, HEADER * hdr,
short updseq)
{
DIR *dirp;
* slot.
*/
- FOREVER {
+ for (;;) {
hi++;
snprintf (tmp, sizeof (tmp), "%d", hi);
snprintf (path, sizeof (path), "%s/%s", ctx->path, tmp);
if (safe_rename (msg->path, path) == 0) {
if (hdr)
- str_replace (&hdr->path, tmp);
- FREE (&msg->path);
+ m_strreplace(&hdr->path, tmp);
+ p_delete(&msg->path);
break;
}
else if (errno != EEXIST) {
return 0;
}
-int mh_commit_message (CONTEXT * ctx, MESSAGE * msg, HEADER * hdr)
-{
- return _mh_commit_message (ctx, msg, hdr, 1);
+static int mh_commit_message (MESSAGE * msg, CONTEXT * ctx, HEADER * hdr) {
+ return _mh_commit_message (msg, ctx, hdr, 1);
}
-
/* Sync a message in an MH folder.
*
* This code is also used for attachment deletion in maildir
if ((rc = mutt_copy_message (dest->fp, ctx, h,
M_CM_UPDATE, CH_UPDATE | CH_UPDATE_LEN)) == 0)
{
- snprintf (oldpath, _POSIX_PATH_MAX, "%s/%s", ctx->path, h->path);
- strfcpy (partpath, h->path, _POSIX_PATH_MAX);
+ snprintf (oldpath, sizeof(oldpath), "%s/%s", ctx->path, h->path);
+ m_strcpy(partpath, sizeof(partpath), h->path);
if (ctx->magic == M_MAILDIR)
- rc = maildir_commit_message (ctx, dest, h);
+ rc = maildir_commit_message (dest, ctx, h);
else
- rc = _mh_commit_message (ctx, dest, h, 0);
+ rc = _mh_commit_message (dest, ctx, h, 0);
mx_close_message (&dest);
if (ctx->magic == M_MH && rc == 0) {
snprintf (newpath, _POSIX_PATH_MAX, "%s/%s", ctx->path, h->path);
if ((rc = safe_rename (newpath, oldpath)) == 0)
- str_replace (&h->path, partpath);
+ m_strreplace(&h->path, partpath);
}
}
else
{
HEADER *h = ctx->hdrs[msgno];
- if (h->attach_del || h->refs_changed || h->irt_changed)
+ if (h->attach_del ||
+ (h->env && (h->env->refs_changed || h->env->irt_changed)))
if (mh_rewrite_message (ctx, msgno) != 0)
return -1;
{
HEADER *h = ctx->hdrs[msgno];
- if (h->attach_del || h->refs_changed || h->irt_changed) {
+ if (h->attach_del ||
+ (h->env && (h->env->refs_changed || h->env->irt_changed))) {
/* when doing attachment deletion/rethreading, fall back to the MH case. */
if (mh_rewrite_message (ctx, msgno) != 0)
return (-1);
char *p;
if ((p = strrchr (h->path, '/')) == NULL) {
- dprint (1,
- (debugfile,
- "maildir_sync_message: %s: unable to find subdir!\n",
- h->path));
+ debug_print (1, ("%s: unable to find subdir!\n", h->path));
return (-1);
}
p++;
- strfcpy (newpath, p, sizeof (newpath));
+ m_strcpy(newpath, sizeof(newpath), p);
/* kill the previous flags */
if ((p = strchr (newpath, ':')) != NULL)
snprintf (fullpath, sizeof (fullpath), "%s/%s", ctx->path, partpath);
snprintf (oldpath, sizeof (oldpath), "%s/%s", ctx->path, h->path);
- if (safe_strcmp (fullpath, oldpath) == 0) {
+ if (m_strcmp(fullpath, oldpath) == 0) {
/* message hasn't really changed */
return 0;
}
mutt_perror ("rename");
return (-1);
}
- str_replace (&h->path, partpath);
+ m_strreplace(&h->path, partpath);
}
return (0);
}
-int mh_sync_mailbox (CONTEXT * ctx, int *index_hint)
+static int mh_sync_mailbox (CONTEXT * ctx, int unused __attribute__ ((unused)), int *index_hint)
{
char path[_POSIX_PATH_MAX], tmp[_POSIX_PATH_MAX];
int i, j;
-#if USE_HCACHE
+#ifdef USE_HCACHE
void *hc = NULL;
#endif /* USE_HCACHE */
if (ctx->magic == M_MH)
- i = mh_check_mailbox (ctx, index_hint);
+ i = mh_check_mailbox (ctx, index_hint, 0);
else
- i = maildir_check_mailbox (ctx, index_hint);
+ i = maildir_check_mailbox (ctx, index_hint, 0);
if (i != 0)
return i;
-#if USE_HCACHE
+#ifdef USE_HCACHE
if (ctx->magic == M_MAILDIR)
hc = mutt_hcache_open (HeaderCache, ctx->path);
#endif /* USE_HCACHE */
snprintf (path, sizeof (path), "%s/%s", ctx->path, ctx->hdrs[i]->path);
if (ctx->magic == M_MAILDIR
|| (option (OPTMHPURGE) && ctx->magic == M_MH)) {
-#if USE_HCACHE
+#ifdef USE_HCACHE
if (ctx->magic == M_MAILDIR)
mutt_hcache_delete (hc, ctx->hdrs[i]->path + 3,
&maildir_hcache_keylen);
}
}
-#if USE_HCACHE
+#ifdef USE_HCACHE
if (ctx->magic == M_MAILDIR)
mutt_hcache_close (hc);
#endif /* USE_HCACHE */
return 0;
err:
-#if USE_HCACHE
+#ifdef USE_HCACHE
if (ctx->magic == M_MAILDIR)
mutt_hcache_close (hc);
#endif /* USE_HCACHE */
return -1;
}
-static char *maildir_canon_filename (char *dest, const char *src, size_t l)
+static char *maildir_canon_filename (char *dest, const char *src, ssize_t l)
{
char *t, *u;
if ((t = strrchr (src, '/')))
src = t + 1;
- strfcpy (dest, src, l);
+ m_strcpy(dest, l, src);
if ((u = strrchr (dest, ':')))
*u = '\0';
* either subdirectory differently, as mail could be copied directly into
* the cur directory from another agent.
*/
-int maildir_check_mailbox (CONTEXT * ctx, int *index_hint)
+static int maildir_check_mailbox (CONTEXT * ctx, int *index_hint, int unused __attribute__ ((unused)))
{
struct stat st_new; /* status of the "new" subdirectory */
struct stat st_cur; /* status of the "cur" subdirectory */
HASH *fnames; /* hash table for quickly looking up the base filename
for a maildir message */
- /* XXX seems like this check belongs in mx_check_mailbox()
- * rather than here.
- */
if (!option (OPTCHECKNEW))
return 0;
for (p = md; p; p = p->next) {
maildir_canon_filename (buf, p->h->path, sizeof (buf));
- p->canon_fname = safe_strdup (buf);
+ p->canon_fname = m_strdup(buf);
hash_insert (fnames, p->canon_fname, p, 0);
}
/* check to see if the message has moved to a different
* subdirectory. If so, update the associated filename.
*/
- if (safe_strcmp (ctx->hdrs[i]->path, p->h->path))
- str_replace (&ctx->hdrs[i]->path, p->h->path);
+ if (m_strcmp(ctx->hdrs[i]->path, p->h->path))
+ m_strreplace(&ctx->hdrs[i]->path, p->h->path);
/* if the user hasn't modified the flags on this message, update
* the flags we just detected.
ctx->hdrs[i]->trash = p->h->trash;
/* this is a duplicate of an existing header, so remove it */
- mutt_free_header (&p->h);
+ header_delete(&p->h);
}
/* This message was not in the list of messages we just scanned.
* Check to see if we have enough information to know if the
*
*/
-int mh_check_mailbox (CONTEXT * ctx, int *index_hint)
+static int mh_check_mailbox (CONTEXT * ctx, int *index_hint, int unused __attribute__ ((unused)))
{
char buf[_POSIX_PATH_MAX];
struct stat st, st_cur;
if (!option (OPTCHECKNEW))
return 0;
- strfcpy (buf, ctx->path, sizeof (buf));
+ m_strcpy(buf, sizeof(buf), ctx->path);
if (stat (buf, &st) == -1)
return -1;
safe_fclose (&fp);
if (safe_rename (tmp, buf) == -1)
unlink (tmp);
- FREE (&tmp);
+ p_delete(&tmp);
}
}
ctx->mtime_cur = st_cur.st_mtime;
ctx->mtime = st.st_mtime;
- memset (&mhs, 0, sizeof (mhs));
+ p_clear(&mhs, 1);
md = NULL;
last = &md;
ctx->hdrs[i]->active = 0;
if ((p = hash_find (fnames, ctx->hdrs[i]->path)) && p->h &&
- (mbox_strict_cmp_headers (ctx->hdrs[i], p->h))) {
+ (mutt_cmp_header (ctx->hdrs[i], p->h))) {
ctx->hdrs[i]->active = 1;
/* found the right message */
if (!ctx->hdrs[i]->changed)
maildir_update_flags (ctx, ctx->hdrs[i], p->h);
- mutt_free_header (&p->h);
+ header_delete(&p->h);
}
else /* message has disappeared */
occult = 1;
while ((de = readdir (dp))) {
maildir_canon_filename (tunique, de->d_name, sizeof (tunique));
- if (!safe_strcmp (tunique, unique)) {
+ if (!m_strcmp(tunique, unique)) {
snprintf (fname, sizeof (fname), "%s/%s/%s", folder, subfolder,
de->d_name);
fp = fopen (fname, "r"); /* __FOPEN_CHECKED__ */
* 0 if there are messages in the mailbox
* -1 on error
*/
-int maildir_check_empty (const char *path)
+static int maildir_check_empty (const char *path)
{
DIR *dp;
struct dirent *de;
int r = 1; /* assume empty until we find a message */
- char realpath[_POSIX_PATH_MAX];
+ char frealpath[_POSIX_PATH_MAX];
int iter = 0;
/* Strategy here is to look for any file not beginning with a period */
/* we do "cur" on the first iteration since its more likely that we'll
* find old messages without having to scan both subdirs
*/
- snprintf (realpath, sizeof (realpath), "%s/%s", path,
+ snprintf (frealpath, sizeof (frealpath), "%s/%s", path,
iter == 0 ? "cur" : "new");
- if ((dp = opendir (realpath)) == NULL)
+ if ((dp = opendir (frealpath)) == NULL)
return -1;
while ((de = readdir (dp))) {
if (*de->d_name != '.') {
return r;
}
-int mh_is_magic (const char* path) {
- struct stat st;
+static int mh_is_magic (const char* path, struct stat* st) {
char tmp[_POSIX_PATH_MAX];
- if (stat (path, &st) == -1)
- return (-1);
-
- if (S_ISDIR (st.st_mode)) {
+ if (S_ISDIR (st->st_mode)) {
snprintf (tmp, sizeof (tmp), "%s/.mh_sequences", path);
if (access (tmp, F_OK) == 0)
return (M_MH);
return (-1);
}
-int maildir_is_magic (const char* path) {
- struct stat st;
+static int maildir_is_magic (const char* path, struct stat* st) {
+ struct stat sb;
char tmp[_POSIX_PATH_MAX];
- if (stat (path, &st) == -1)
- return (-1);
- if (S_ISDIR (st.st_mode)) {
+ if (S_ISDIR (st->st_mode)) {
snprintf (tmp, sizeof (tmp), "%s/cur", path);
- if (stat (tmp, &st) == 0 && S_ISDIR (st.st_mode))
+ if (stat (tmp, &sb) == 0 && S_ISDIR (sb.st_mode))
return (M_MAILDIR);
}
return (-1);
/* routines common to maildir and mh */
static mx_t* reg_mx (void) {
- mx_t* fmt = safe_calloc (1, sizeof (mx_t));
+ mx_t* fmt = p_new(mx_t, 1);
fmt->local = 1;
fmt->mx_access = access;
+ fmt->mx_sync_mailbox = mh_sync_mailbox;
return (fmt);
}
+static int mh_commit (MESSAGE* msg, CONTEXT* ctx) {
+ return (mh_commit_message (msg, ctx, NULL));
+}
+
+static int maildir_commit (MESSAGE* msg, CONTEXT* ctx) {
+ return (maildir_commit_message (msg, ctx, NULL));
+}
+
mx_t* mh_reg_mx (void) {
mx_t* fmt = reg_mx ();
fmt->type = M_MH;
fmt->mx_check_empty = mh_check_empty;
fmt->mx_is_magic = mh_is_magic;
fmt->mx_open_mailbox = mh_read_dir;
+ fmt->mx_open_new_message = mh_open_new_message;
+ fmt->mx_check_mailbox = mh_check_mailbox;
+ fmt->mx_commit_message = mh_commit;
return (fmt);
}
fmt->mx_check_empty = maildir_check_empty;
fmt->mx_is_magic = maildir_is_magic;
fmt->mx_open_mailbox = maildir_read_dir;
+ fmt->mx_open_new_message = maildir_open_new_message;
+ fmt->mx_check_mailbox = maildir_check_mailbox;
+ fmt->mx_commit_message = maildir_commit;
return (fmt);
}
projects / apps / madmutt.git / blobdiff