WHERE char *ImapHeadercache INITVAL (NULL);

#include "imap_headercache.h"

  if (idata->hcache)

  {

    imap_headercache_close(idata->hcache);

    idata->hcache = NULL;

  }

  idata->uidvalidity = 0;

    /* save UIDVALIDITY for the header cache */

    else if (ascii_strncasecmp("OK [UIDVALIDITY", pc, 14) == 0)

    {

      dprint(2, (debugfile, "Getting mailbox UIDVALIDITY\n"));

      pc += 3;

      pc = imap_next_word(pc);

      sscanf(pc, "%u", &(idata->uidvalidity));

    }

  idata->hcache = imap_headercache_open(idata);

  IMAP_HEADER h;

      if (idata->hcache)

      {

        h.data = HEADER_DATA(ctx->hdrs[n]);

        h.read     = ctx->hdrs[n]->read;

        h.old      = ctx->hdrs[n]->old;

        h.deleted  = ctx->hdrs[n]->deleted;

        h.flagged  = ctx->hdrs[n]->flagged;

        h.replied  = ctx->hdrs[n]->replied;

        h.changed  = ctx->hdrs[n]->changed;

        h.sid      = ctx->hdrs[n]->index + 1;

        h.received = ctx->hdrs[n]->received;

        h.content_length = ctx->hdrs[n]->content->length;

        imap_headercache_update(idata->hcache, &h);

      }

    if (idata->hcache)

    {

      imap_headercache_close(idata->hcache);

      idata->hcache = NULL;

    }

/*

 * Copyright (C) 2002 Tudor Bosman <tudorb-mutt@dwyn.net>

 * 

 *     This program is free software; you can redistribute it and/or modify

 *     it under the terms of the GNU General Public License as published by

 *     the Free Software Foundation; either version 2 of the License, or

 *     (at your option) any later version.

 * 

 *     This program is distributed in the hope that it will be useful,

 *     but WITHOUT ANY WARRANTY; without even the implied warranty of

 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *     GNU General Public License for more details.

 * 

 *     You should have received a copy of the GNU General Public License

 *     along with this program; if not, write to the Free Software

 *     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.

 */ 

#include "mutt.h"

#include "imap.h"

#include "imap_private.h"

#include "imap_headercache.h"

#include "mx.h"

#include <stdio.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <errno.h>

#include <unistd.h>

#include <dirent.h>

#include <assert.h>

/* Delete all messages from headercache */

static int imap_headercache_purge(IMAP_HEADERCACHE *hc)

{

  int rc = -1;

  DIR *dir;

  struct dirent *ent;

  dir = opendir(hc->name);

  if (!dir)

  {

    mutt_error(_("IMAP headercache: can't purge directory %s: %s"), hc->name,

               strerror(errno));

    mutt_sleep(2);

    return -1;

  }

  while ((ent = readdir(dir)) != NULL)

  {

    if (!strcmp(ent->d_name, ".") || !strcmp(ent->d_name, ".."))

      continue;

    sprintf(hc->tmpname, "%s/%s", hc->name, ent->d_name);

    if (unlink(hc->tmpname) == -1)

    {

      mutt_error(_("IMAP headercache: can't unlink file %s: %s"), hc->tmpname,

                 strerror(errno));

      mutt_sleep(2);

      goto bail;

    }

  }

  rc = 0;

bail:

  closedir(dir);

  return rc;

}

/* Open headercache */

IMAP_HEADERCACHE *imap_headercache_open(IMAP_DATA *idata)

{

  IMAP_HEADERCACHE *hc;

  char hcdir[_POSIX_PATH_MAX + 1];

  FILE *f;

  size_t len;

  char *p;

  if (!ImapHeadercache || ImapHeadercache[0] == '\0')

    return NULL;

  strfcpy(hcdir, ImapHeadercache, _POSIX_PATH_MAX);

  mutt_expand_path(hcdir, _POSIX_PATH_MAX);

  hc = safe_malloc(sizeof(IMAP_HEADERCACHE));

  len = strlen(hcdir) + strlen(idata->conn->account.host) +

        strlen(idata->mailbox) + 5;

  hc->name = safe_malloc(len);

  hc->tmpname = safe_malloc(len + NAME_MAX + 2);

  sprintf(hc->name, "%s/%s", hcdir, idata->conn->account.host);

  if (mkdir(hcdir, 0777) == -1 && errno != EEXIST)

  {

    mutt_error(_("Can't create IMAP headercache root directory %s: %s"), 

                 hcdir, strerror(errno));

    mutt_sleep(2);

    goto bail;

  }

  if (mkdir(hc->name, 0700) == -1 && errno != EEXIST)

  {

    mutt_error(_("Can't create IMAP headercache server directory %s: %s"),

                 hc->name, strerror(errno));

    mutt_sleep(2);

    goto bail;

  }

  p = idata->mailbox;

  while ((p = strchr(p, '/')) != NULL)

  {

    *p = '\0';

    sprintf(hc->name, "%s/%s/%s", hcdir, 

            idata->conn->account.host, idata->mailbox);

    if (mkdir(hc->name, 0700) == -1 && errno != EEXIST)

    {

      mutt_error(_("Can't create IMAP headercache mailbox directory %s: %s"),

                   hc->name, strerror(errno));

      mutt_sleep(2);

      goto bail;

    }

    *p = '/';

    p++;

  }

  sprintf(hc->name, "%s/%s/%s", hcdir, 

          idata->conn->account.host, idata->mailbox);

  if (mkdir(hc->name, 0700) == -1 && errno != EEXIST)

  {

    mutt_error(_("Can't create IMAP headercache mailbox directory %s: %s"),

                 hc->name, strerror(errno));

    mutt_sleep(2);

    goto bail;

  }

  sprintf(hc->tmpname, "%s/uidvalidity", hc->name);

  f = fopen(hc->tmpname, "r");

  if (f)

  {

    fscanf(f, "%u", &hc->uidvalidity);

    if (idata->uidvalidity != hc->uidvalidity)

    {

      fclose(f);

      f = NULL;

    }

  }

  if (!f)

  {

    if (imap_headercache_purge(hc) == -1)

      goto bail;

    sprintf(hc->tmpname, "%s/uidvalidity", hc->name);

    f = fopen(hc->tmpname, "w");

    if (!f)

    {

      mutt_error(_("Can't create IMAP headercache uidvalidity file %s: %s"),

                   hc->tmpname, strerror(errno));

      mutt_sleep(2);

      goto bail;

    }

    hc->uidvalidity = idata->uidvalidity;

    fprintf(f, "%u\n", hc->uidvalidity);

    fclose(f);

  }

  return hc;

bail:

  safe_free((void **)&hc->tmpname);

  safe_free((void **)&hc->name);

  safe_free((void **)&hc);

  return NULL;

}

/* Close headercache */

void imap_headercache_close(IMAP_HEADERCACHE *hc)

{

  safe_free((void **)&hc->tmpname);

  safe_free((void **)&hc->name);

  safe_free((void **)&hc);

}

static void imap_headercache_writehdr(FILE *f, IMAP_HEADER *h)

{

  /* Write the stuff in the header.  This must have a fixed length, as it is

   * overwritten in case of imap_headercache_update

   */

  fprintf(f, "%1x %1x %1x %1x %1x %1x %8x %16lx %16lx %8x\n",

          h->read, h->old, h->deleted, h->flagged, h->replied, h->changed,

          h->sid, h->received, h->content_length, HEADER_DATA(h)->uid);

}

/* Add message to headercache */

int imap_headercache_add(IMAP_HEADERCACHE *hc, IMAP_HEADER *h, FILE *from,

                         size_t hdrsz)

{

  FILE *f;

#define BUFSIZE 4096

  char buf[BUFSIZE];

  size_t sz;

  int rc = -1;

  sprintf(hc->tmpname, "%s/%u", hc->name, HEADER_DATA(h)->uid);

  f = fopen(hc->tmpname, "w");

  if (!f)

  {

    mutt_error(_("Can't create IMAP headercache message file %s: %s"),

                 hc->tmpname, strerror(errno));

    mutt_sleep(2);

    goto bail;

  }

  imap_headercache_writehdr(f, h);

  while ((sz = fread(buf, 1, (hdrsz < BUFSIZE ? hdrsz : BUFSIZE), from)) != 0)

  {

    hdrsz -= sz;

    fwrite(buf, 1, sz, f);

  }

  fclose(f);

  rc = 0;

bail:

  return rc;

}

/* Update flags in headercache message */

int imap_headercache_update(IMAP_HEADERCACHE *hc, IMAP_HEADER *h)

{

  FILE *f;

  int rc = -1;

  sprintf(hc->tmpname, "%s/%u", hc->name, HEADER_DATA(h)->uid);

  f = fopen(hc->tmpname, "r+");

  if (!f)

    goto bail;

  imap_headercache_writehdr(f, h);

  fclose(f);

  rc = 0;

bail:

  return rc;

}

/* Delete message from headercache */

int imap_headercache_delete(IMAP_HEADERCACHE *hc, IMAP_HEADER *h)

{

  int rc = -1;

  sprintf(hc->tmpname, "%s/%u", hc->name, HEADER_DATA(h)->uid);

  if (unlink(hc->tmpname) == -1)

  {

    mutt_error(_("Can't delete IMAP headercache message %s: %s"),

               hc->tmpname, strerror(errno));

    mutt_sleep(2);

    goto bail;

  }

  rc = 0;

bail:

  return rc;

}

/* Find message in headercache */

FILE *imap_headercache_find(IMAP_HEADERCACHE *hc, IMAP_HEADER *h)

{

  FILE *f = NULL;

  unsigned int flag_read, flag_old, flag_deleted, flag_flagged, flag_replied;

  unsigned int flag_changed;

  unsigned int uid;

  unsigned long received;

  unsigned long content_length;

  sprintf(hc->tmpname, "%s/%u", hc->name, HEADER_DATA(h)->uid);

  f = fopen(hc->tmpname, "r");

  if (!f)

    goto bail;

  fscanf(f, "%x %x %x %x %x %x %x %lx %lx %x\n",

         &flag_read, &flag_old, &flag_deleted, &flag_flagged, &flag_replied,

         &flag_changed, &h->sid, &received, &content_length, &uid);

  if (uid != HEADER_DATA(h)->uid)

  {

    fclose(f);

    f = NULL;

    goto bail;

  }

  h->received = received;

  h->read = flag_read;

  h->old = flag_old;

  h->deleted = flag_deleted;

  h->flagged = flag_flagged;

  h->replied = flag_replied;

  h->changed = flag_changed;

  h->content_length = (long)content_length;

bail:

  return f;

}

/* Close file returned by imap_headercache_find */

void imap_headercache_done(IMAP_HEADERCACHE *hc, FILE *f)

{

  fclose(f);

}

/*

 * Copyright (C) 2002 Tudor Bosman <tudorb-mutt@dwyn.net>

 * 

 *     This program is free software; you can redistribute it and/or modify

 *     it under the terms of the GNU General Public License as published by

 *     the Free Software Foundation; either version 2 of the License, or

 *     (at your option) any later version.

 * 

 *     This program is distributed in the hope that it will be useful,

 *     but WITHOUT ANY WARRANTY; without even the implied warranty of

 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *     GNU General Public License for more details.

 * 

 *     You should have received a copy of the GNU General Public License

 *     along with this program; if not, write to the Free Software

 *     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.

 */ 

#ifndef _IMAP_HEADERCACHE_H

#define _IMAP_HEADERCACHE_H

#include "imap_private.h"

#include "message.h"

typedef struct IMAP_HEADERCACHE

{

  char *name;

  char *tmpname;

  unsigned int uidvalidity;

  int exists;

} IMAP_HEADERCACHE;

struct IMAP_DATA;

IMAP_HEADERCACHE *imap_headercache_open(struct IMAP_DATA *idata);

void imap_headercache_close(IMAP_HEADERCACHE *hc);

int imap_headercache_add(IMAP_HEADERCACHE *hc, IMAP_HEADER *h, FILE *from,

                         size_t hdrsz);

int imap_headercache_update(IMAP_HEADERCACHE *hc, IMAP_HEADER *h);

int imap_headercache_delete(IMAP_HEADERCACHE *hc, IMAP_HEADER *h);

FILE *imap_headercache_find(IMAP_HEADERCACHE *hc, IMAP_HEADER *h);

void imap_headercache_done(IMAP_HEADERCACHE *hc, FILE *f);

#endif

#include "imap_headercache.h"

  unsigned int uidvalidity;

  IMAP_HEADERCACHE *hcache;

#include "imap_headercache.h"

  IMAP_HEADERCACHE *hc = NULL;

  int msgbegin_hc;

  msgno = msgbegin;

  oldmsgcount = ctx->msgcount;

  msgbegin_hc = msgbegin;

  hc = idata->hcache;

restart:

  if (hc)

  {

    snprintf(buf, sizeof(buf), "FETCH %d:%d (UID)", msgbegin_hc + 1, 

             msgend + 1);

    imap_cmd_start(idata, buf);

    for (msgno = msgbegin_hc; msgno <= msgend; msgno++)

    {

      if (ReadInc && (!msgno || ((msgno+1) % ReadInc == 0)))

        mutt_message (_("Fetching message UIDs... [%d/%d]"), msgno + 1,

                      msgend + 1);

      /* XXX */

      ctx->hdrs[msgno] = NULL;

      /* XXX leaking h.data on successful exit */

      memset (&h, 0, sizeof (h));

      h.data = safe_calloc (1, sizeof (IMAP_HEADER_DATA));

      do

      {

        FILE *cache_fp;

        mfhrc = 0;

        rc = imap_cmd_step (idata);

        if (rc != IMAP_CMD_CONTINUE)

          break;

        if ((mfhrc = msg_fetch_header (idata->ctx, &h, idata->cmd.buf, NULL)) == -1)

          continue;

        else if (mfhrc < 0)

          break;

        cache_fp = imap_headercache_find(hc, &h);

        if (cache_fp)

        {

          /* update context with message header */

          ctx->hdrs[msgno] = mutt_new_header ();

          ctx->hdrs[msgno]->index = h.sid - 1;

          /* messages which have not been expunged are ACTIVE (borrowed from mh 

           * folders) */

          ctx->hdrs[msgno]->active = 1;

          ctx->hdrs[msgno]->read = h.read;

          ctx->hdrs[msgno]->old = h.old;

          ctx->hdrs[msgno]->deleted = h.deleted;

          ctx->hdrs[msgno]->flagged = h.flagged;

          ctx->hdrs[msgno]->replied = h.replied;

          ctx->hdrs[msgno]->changed = h.changed;

          ctx->hdrs[msgno]->received = h.received;

          ctx->hdrs[msgno]->data = (void *) (h.data);

          /* NOTE: if Date: header is missing, mutt_read_rfc822_header depends

           *   on h.received being set */

          ctx->hdrs[msgno]->env = mutt_read_rfc822_header (cache_fp, ctx->hdrs[msgno],

            0, 0);

          /* content built as a side-effect of mutt_read_rfc822_header */

          ctx->hdrs[msgno]->content->length = h.content_length;

          imap_headercache_done(hc, cache_fp);

        }

      }

      while (mfhrc == -1);

      /* in case we get new mail while fetching the headers */

      if (idata->reopen & IMAP_NEWMAIL_PENDING)

      {

        msgbegin_hc = msgno + 1;

        msgend = idata->newMailCount - 1;

        goto restart;

      }

      /* XXX freshen... etc */

    }

  }

  /* Remember where we left if we get new mail while fetching actual headers */

  msgbegin_hc = msgno;

  /* Now, either one of the following is true:

   * 1. We don't have a headercache (hc == 0)

   * 2. All messages found in the cache have ctx->hdrs[msgno] != NULL, and

   * filled up.

   */

  /*

   * Make one request for everything. This makes fetching headers an

   * order of magnitude faster if you have a large mailbox.

   *

   * If we get more messages while doing this, we make another

   * request for all the new messages.

   */

  if (!hc)

  {

    snprintf (buf, sizeof (buf),

      "FETCH %d:%d (UID FLAGS INTERNALDATE RFC822.SIZE %s)", msgbegin + 1,

      msgend + 1, hdrreq);

    imap_cmd_start (idata, buf);

  }

      size_t hdrsz;

      hdrsz = (size_t)ftell(fp);

#if 0

#endif

      if (hc)

      {

        imap_headercache_add(hc, &h, fp, hdrsz);

        rewind(fp);

      }

      msgbegin = msgno + 1;

  int fetch_rc;

  FREE (&(*idata)->hcache);

  { "imap_headercache", DT_STR, R_NONE, UL &ImapHeadercache, UL 0 },

  /*

  ** .pp

  ** The location of the IMAP headercache directory.

  */