# include "config.h"
#endif
+#include <lib-lib/mem.h>
+#include <lib-lib/ascii.h>
+#include <lib-lib/str.h>
+#include <lib-lib/macros.h>
+#include <lib-lib/file.h>
+
+#include <lib-mime/mime.h>
+
#include "mutt.h"
+#include "buffy.h"
#include "mx.h"
#include "mbox.h"
#include "mh.h"
-#include "rfc2047.h"
#include "sort.h"
+#include "thread.h"
#include "copy.h"
#include "keymap.h"
#include "url.h"
#include "nntp/mx_nntp.h"
#endif
-#ifdef BUFFY_SIZE
-#include "buffy.h"
-#endif
-
#ifdef USE_DOTLOCK
#include "dotlock.h"
#endif
#include "mutt_crypt.h"
-#include "lib/mem.h"
-#include "lib/intl.h"
-#include "lib/str.h"
#include "lib/list.h"
#include "lib/debug.h"
#define MX_COMMAND(idx,cmd) ((mx_t*) MailboxFormats->data[idx])->cmd
#define MX_IDX(idx) (idx >= 0 && idx < MailboxFormats->length)
-#define mutt_is_spool(s) (str_cmp (Spoolfile, s) == 0)
+#define mutt_is_spool(s) (m_strcmp(Spoolfile, s) == 0)
#ifdef USE_DOTLOCK
/* parameters:
* retry - should retry if unable to lock?
*/
-#ifdef DL_STANDALONE
-
static int invoke_dotlock (const char *path, int dummy, int flags, int retry)
{
char cmd[LONG_STRING + _POSIX_PATH_MAX];
return mutt_system (cmd);
}
-#else
-
-#define invoke_dotlock dotlock_invoke
-
-#endif
-
static int dotlock_file (const char *path, int fd, int retry)
{
int r;
struct flock lck;
- memset (&lck, 0, sizeof (struct flock));
+ p_clear(&lck, 1);
lck.l_type = excl ? F_WRLCK : F_RDLCK;
lck.l_whence = SEEK_SET;
count = 0;
attempt = 0;
+ prev_sb.st_size = 0;
while (fcntl (fd, F_SETLK, &lck) == -1) {
struct stat sb;
int mx_unlock_file (const char *path, int fd, int dot)
{
#ifdef USE_FCNTL
- struct flock unlockit = { F_UNLCK, 0, 0, 0 };
+ struct flock unlockit;
- memset (&unlockit, 0, sizeof (struct flock));
+ p_clear(&unlockit, 1);
unlockit.l_type = F_UNLCK;
unlockit.l_whence = SEEK_SET;
fcntl (fd, F_SETLK, &unlockit);
int mx_get_magic (const char *path) {
int i = 0;
- if (str_len (path) == 0)
+ if (m_strlen(path) == 0)
return (-1);
if ((i = mx_get_idx (path)) >= 0)
return (MX_COMMAND(i,type));
}
return (-1);
}
- fseek (ctx->fp, 0, 2);
+ fseeko (ctx->fp, 0, 2);
break;
case M_MH:
int rc;
if (!ctx)
- ctx = safe_malloc (sizeof (CONTEXT));
- memset (ctx, 0, sizeof (CONTEXT));
- ctx->path = str_dup (path);
+ ctx = p_new(CONTEXT, 1);
+ p_clear(ctx, 1);
+ ctx->path = m_strdup(path);
ctx->msgnotreadyet = -1;
ctx->collapsed = 0;
if (mx_open_mailbox_append (ctx, flags) != 0) {
mx_fastclose_mailbox (ctx);
if (!pctx)
- FREE (&ctx);
+ p_delete(&ctx);
return NULL;
}
return ctx;
if (ctx->magic <= 0) {
mx_fastclose_mailbox (ctx);
if (!pctx)
- FREE (&ctx);
+ p_delete(&ctx);
return (NULL);
}
else {
mx_fastclose_mailbox (ctx);
if (!pctx)
- FREE (&ctx);
+ p_delete(&ctx);
}
unset_option (OPTFORCEREFRESH);
mutt_clear_threads (ctx);
for (i = 0; i < ctx->msgcount; i++)
mutt_free_header (&ctx->hdrs[i]);
- FREE (&ctx->hdrs);
- FREE (&ctx->v2r);
+ p_delete(&ctx->hdrs);
+ p_delete(&ctx->v2r);
#ifdef USE_COMPRESSED
if (ctx->compressinfo)
mutt_fast_close_compressed (ctx);
#endif
- FREE (&ctx->path);
- FREE (&ctx->pattern);
+ p_delete(&ctx->path);
+ p_delete(&ctx->pattern);
if (ctx->limit_pattern)
mutt_pattern_free (&ctx->limit_pattern);
safe_fclose (&ctx->fp);
- memset (ctx, 0, sizeof (CONTEXT));
+ p_clear(ctx, 1);
}
/* save changes to disk */
}
/* save changes and close mailbox */
-int mx_close_mailbox (CONTEXT * ctx, int *index_hint)
+static int _mx_close_mailbox (CONTEXT * ctx, int *index_hint)
{
int i, move_messages = 0, purge = 1, read_msgs = 0;
int check;
if ((p = mutt_find_hook (M_MBOXHOOK, ctx->path))) {
isSpool = 1;
- strfcpy (mbox, p, sizeof (mbox));
+ m_strcpy(mbox, sizeof(mbox), p);
}
else {
- strfcpy (mbox, NONULL (Inbox), sizeof (mbox));
+ m_strcpy(mbox, sizeof(mbox), NONULL(Inbox));
isSpool = mutt_is_spool (ctx->path) && !mutt_is_spool (mbox);
}
mutt_expand_path (mbox, sizeof (mbox));
return 0;
}
+int mx_close_mailbox (CONTEXT * ctx, int *index_hint) {
+ int ret = 0;
+ if (!ctx)
+ return (0);
+ ret = _mx_close_mailbox (ctx, index_hint);
+ sidebar_set_buffystats (ctx);
+ return (ret);
+}
/* update a Context structure's internal tables. */
* 0 success
* -1 error
*/
-int mx_sync_mailbox (CONTEXT * ctx, int *index_hint)
+static int _mx_sync_mailbox (CONTEXT * ctx, int *index_hint)
{
int rc, i;
int purge = 1;
km_find_func (MENU_MAIN, OP_TOGGLE_WRITE)))
snprintf (tmp, sizeof (tmp), _(" Press '%s' to toggle write"), buf);
else
- strfcpy (tmp, _("Use 'toggle-write' to re-enable write!"),
- sizeof (tmp));
+ m_strcpy(tmp, sizeof(tmp), _("Use 'toggle-write' to re-enable write!"));
mutt_error (_("Mailbox is marked unwritable. %s"), tmp);
return -1;
return 0;
}
- /* update sidebar counts */
- sidebar_set_buffystats (ctx);
-
/* if we haven't deleted any messages, we don't need to resort */
/* ... except for certain folder formats which need "unsorted"
* sort order in order to synchronize folders.
return (rc);
}
+int mx_sync_mailbox (CONTEXT* ctx, int* index_hint) {
+ int ret = _mx_sync_mailbox (ctx, index_hint);
+ sidebar_set_buffystats (ctx);
+ return (ret);
+}
+
/* args:
* dest destintation mailbox
* hdr message being copied (required for maildir support, because
MESSAGE *mx_open_new_message (CONTEXT * dest, HEADER * hdr, int flags)
{
MESSAGE *msg;
- ADDRESS *p = NULL;
+ address_t *p = NULL;
if (!MX_IDX(dest->magic-1)) {
debug_print (1, ("function unimplemented for mailbox type %d.\n", dest->magic));
return (NULL);
}
- msg = safe_calloc (1, sizeof (MESSAGE));
+ msg = p_new(MESSAGE, 1);
msg->magic = dest->magic;
msg->write = 1;
}
}
else
- FREE (&msg);
+ p_delete(&msg);
return msg;
}
{
MESSAGE *msg;
- msg = safe_calloc (1, sizeof (MESSAGE));
+ msg = p_new(MESSAGE, 1);
switch (msg->magic = ctx->magic) {
case M_MBOX:
case M_MMDF:
if (msg->fp == NULL) {
mutt_perror (path);
debug_print (1, ("fopen: %s: %s (errno %d).\n", path, strerror (errno), errno));
- FREE (&msg);
+ p_delete(&msg);
}
}
break;
case M_IMAP:
{
if (imap_fetch_message (msg, ctx, msgno) != 0)
- FREE (&msg);
+ p_delete(&msg);
break;
}
#endif /* USE_IMAP */
case M_POP:
{
if (pop_fetch_message (msg, ctx, msgno) != 0)
- FREE (&msg);
+ p_delete(&msg);
break;
}
#endif /* USE_POP */
case M_NNTP:
{
if (nntp_fetch_message (msg, ctx, msgno) != 0)
- FREE (&msg);
+ p_delete(&msg);
break;
}
#endif /* USE_NNTP */
default:
debug_print (1, ("function not implemented for mailbox type %d.\n", ctx->magic));
- FREE (&msg);
+ p_delete(&msg);
break;
}
return (msg);
if ((*msg)->path) {
debug_print (1, ("unlinking %s\n", (*msg)->path));
unlink ((*msg)->path);
- FREE (&(*msg)->path);
+ p_delete(&(*msg)->path);
}
- FREE (msg);
+ p_delete(msg);
return (r);
}
}
if (ctx->hdrs) {
- safe_realloc (&ctx->hdrs, sizeof (HEADER *) * (ctx->hdrmax += 25));
- safe_realloc (&ctx->v2r, sizeof (int) * ctx->hdrmax);
+ p_realloc(&ctx->hdrs, ctx->hdrmax += 25);
+ p_realloc(&ctx->v2r, ctx->hdrmax);
}
else {
- ctx->hdrs = safe_calloc ((ctx->hdrmax += 25), sizeof (HEADER *));
- ctx->v2r = safe_calloc (ctx->hdrmax, sizeof (int));
+ ctx->hdrs = p_new(HEADER *, (ctx->hdrmax += 25));
+ ctx->v2r = p_new(int, ctx->hdrmax);
}
for (i = ctx->msgcount; i < ctx->hdrmax; i++) {
ctx->hdrs[i] = NULL;
h2 = hash_find (ctx->id_hash, h->env->supersedes);
- /* FREE (&h->env->supersedes); should I ? */
+ /* p_delete(&h->env->supersedes); should I ? */
if (h2) {
h2->superseded = 1;
if (!ctx->counting && option (OPTSCORE))
#undef EXITWITHERR
#endif /* DEBUG */
}
+
+int mx_rebuild_cache (void) {
+#ifndef USE_HCACHE
+ mutt_error (_("Support for header caching was not build in."));
+ return (1);
+#else
+ int i = 0, magic = 0;
+ CONTEXT* ctx = NULL;
+ BUFFY* b = NULL;
+
+ if (list_empty(Incoming)) {
+ mutt_error (_("No mailboxes defined."));
+ return (1);
+ }
+
+ for (i = 0; i < Incoming->length; i++) {
+ b = (BUFFY*) Incoming->data[i];
+ magic = mx_get_magic (b->path);
+ if (magic != M_MAILDIR && magic != M_MH
+#ifdef USE_IMAP
+ && magic != M_IMAP
+#endif
+ )
+ continue;
+ sidebar_set_current (b->path);
+ sidebar_draw (CurrentMenu);
+ if ((ctx = mx_open_mailbox (b->path,
+ M_READONLY | M_NOSORT | M_COUNT,
+ NULL)) != NULL)
+ mx_close_mailbox (ctx, 0);
+ }
+ mutt_clear_error ();
+
+ if (Context && Context->path)
+ sidebar_set_current (Context->path);
+ sidebar_draw (CurrentMenu);
+
+ return (0);
+#endif
+}