sequence.h File Reference

MH Mailbox Sequences. More...

#include <stdbool.h>
#include <stdint.h>

Include dependency graph for sequence.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	MhSequences
	Set of MH sequence numbers. More...

Macros
#define	MH_SEQ_NO_FLAGS   0
	No flags are set.
#define	MH_SEQ_UNSEEN   (1 << 0)
	Email hasn't been read.
#define	MH_SEQ_REPLIED   (1 << 1)
	Email has been replied to.
#define	MH_SEQ_FLAGGED   (1 << 2)
	Email is flagged.

Typedefs
typedef uint8_t	MhSeqFlags
	Flags, e.g. MH_SEQ_UNSEEN.

Functions
void	mh_seq_add_one (struct Mailbox *m, int n, bool unseen, bool flagged, bool replied)
	Update the flags for one sequence.
int	mh_seq_changed (struct Mailbox *m)
	Has the mailbox changed.
MhSeqFlags	mh_seq_check (struct MhSequences *mhs, int i)
	Get the flags for a given sequence.
void	mh_seq_free (struct MhSequences *mhs)
	Free some sequences.
int	mh_seq_read (struct MhSequences *mhs, const char *path)
	Read a set of MH sequences.
void	mh_seq_update (struct Mailbox *m)
	Update sequence numbers.

Detailed Description

MH Mailbox Sequences.

Authors

• Richard Russon

Copyright

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, see http://www.gnu.org/licenses/.

Definition in file sequence.h.

Macro Definition Documentation

MH_SEQ_NO_FLAGS

#define MH_SEQ_NO_FLAGS   0

No flags are set.

Definition at line 32 of file sequence.h.

MH_SEQ_UNSEEN

#define MH_SEQ_UNSEEN   (1 << 0)

Email hasn't been read.

Definition at line 33 of file sequence.h.

MH_SEQ_REPLIED

#define MH_SEQ_REPLIED   (1 << 1)

Email has been replied to.

Definition at line 34 of file sequence.h.

MH_SEQ_FLAGGED

#define MH_SEQ_FLAGGED   (1 << 2)

Email is flagged.

Definition at line 35 of file sequence.h.

Typedef Documentation

MhSeqFlags

typedef uint8_t MhSeqFlags

Flags, e.g. MH_SEQ_UNSEEN.

Definition at line 31 of file sequence.h.

Function Documentation

mh_seq_add_one()

void mh_seq_add_one	(	struct Mailbox *	m,
		int	n,
		bool	unseen,
		bool	flagged,
		bool	replied
	)

Update the flags for one sequence.

Parameters

m	Mailbox
n	Sequence number to update
unseen	Update the unseen sequence
flagged	Update the flagged sequence
replied	Update the replied sequence

Definition at line 108 of file sequence.c.

{
  bool unseen_done = false;
  bool flagged_done = false;
  bool replied_done = false;
 
  char *tmpfname = NULL;
  char sequences[PATH_MAX] = { 0 };
 
  char seq_unseen[256] = { 0 };
  char seq_replied[256] = { 0 };
  char seq_flagged[256] = { 0 };
 
  char *buf = NULL;
  size_t sz;
 
  FILE *fp_new = NULL;
  if (!mh_mkstemp(m, &fp_new, &tmpfname))
    return;
 
  const char *const c_mh_seq_unseen = cs_subset_string(NeoMutt->sub, "mh_seq_unseen");
  const char *const c_mh_seq_replied = cs_subset_string(NeoMutt->sub, "mh_seq_replied");
  const char *const c_mh_seq_flagged = cs_subset_string(NeoMutt->sub, "mh_seq_flagged");
  snprintf(seq_unseen, sizeof(seq_unseen), "%s:", NONULL(c_mh_seq_unseen));
  snprintf(seq_replied, sizeof(seq_replied), "%s:", NONULL(c_mh_seq_replied));
  snprintf(seq_flagged, sizeof(seq_flagged), "%s:", NONULL(c_mh_seq_flagged));
 
  snprintf(sequences, sizeof(sequences), "%s/.mh_sequences", mailbox_path(m));
  FILE *fp_old = mutt_file_fopen(sequences, "r");
  if (fp_old)
  {
    while ((buf = mutt_file_read_line(buf, &sz, fp_old, NULL, MUTT_RL_NO_FLAGS)))
    {
      if (unseen && mutt_strn_equal(buf, seq_unseen, mutt_str_len(seq_unseen)))
      {
        fprintf(fp_new, "%s %d\n", buf, n);
        unseen_done = true;
      }
      else if (flagged && mutt_strn_equal(buf, seq_flagged, mutt_str_len(seq_flagged)))
      {
        fprintf(fp_new, "%s %d\n", buf, n);
        flagged_done = true;
      }
      else if (replied && mutt_strn_equal(buf, seq_replied, mutt_str_len(seq_replied)))
      {
        fprintf(fp_new, "%s %d\n", buf, n);
        replied_done = true;
      }
      else
      {
        fprintf(fp_new, "%s\n", buf);
      }
    }
  }
  mutt_file_fclose(&fp_old);
  FREE(&buf);
 
  if (!unseen_done && unseen)
    fprintf(fp_new, "%s: %d\n", NONULL(c_mh_seq_unseen), n);
  if (!flagged_done && flagged)
    fprintf(fp_new, "%s: %d\n", NONULL(c_mh_seq_flagged), n);
  if (!replied_done && replied)
    fprintf(fp_new, "%s: %d\n", NONULL(c_mh_seq_replied), n);
 
  mutt_file_fclose(&fp_new);
 
  unlink(sequences);
  if (mutt_file_safe_rename(tmpfname, sequences) != 0)
    unlink(tmpfname);
 
  FREE(&tmpfname);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_seq_changed()

int mh_seq_changed

(

struct Mailbox *

m

)

Has the mailbox changed.

Parameters

m

Mailbox

Return values

1	mh_sequences last modification time is more recent than the last visit to this mailbox
0	modification time is older
-1	Error

Definition at line 439 of file sequence.c.

{
  char path[PATH_MAX] = { 0 };
  struct stat st = { 0 };
 
  if ((snprintf(path, sizeof(path), "%s/.mh_sequences", mailbox_path(m)) < sizeof(path)) &&
      (stat(path, &st) == 0))
  {
    return (mutt_file_stat_timespec_compare(&st, MUTT_STAT_MTIME, &m->last_visited) > 0);
  }
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_seq_check()

MhSeqFlags mh_seq_check	(	struct MhSequences *	mhs,
		int	i
	)

Get the flags for a given sequence.

Parameters

mhs	Sequences
i	Index number required

Return values

num	Flags, see MhSeqFlags

Definition at line 79 of file sequence.c.

{
  if (!mhs->flags || (i > mhs->max))
    return 0;
  return mhs->flags[i];
}

Here is the caller graph for this function:

mh_seq_free()

void mh_seq_free

(

struct MhSequences *

mhs

)

Free some sequences.

Parameters

mhs	Sequences to free

Definition at line 68 of file sequence.c.

{
  FREE(&mhs->flags);
}

Here is the caller graph for this function:

mh_seq_read()

int mh_seq_read	(	struct MhSequences *	mhs,
		const char *	path
	)

Read a set of MH sequences.

Parameters

mhs	Existing sequences
path	File to read from

Return values

0	Success
-1	Error

Definition at line 378 of file sequence.c.

{
  char *buf = NULL;
  size_t sz = 0;
 
  MhSeqFlags flags;
  int first, last, rc = 0;
 
  char pathname[PATH_MAX] = { 0 };
  snprintf(pathname, sizeof(pathname), "%s/.mh_sequences", path);
 
  FILE *fp = mutt_file_fopen(pathname, "r");
  if (!fp)
    return 0; /* yes, ask callers to silently ignore the error */
 
  const char *const c_mh_seq_unseen = cs_subset_string(NeoMutt->sub, "mh_seq_unseen");
  const char *const c_mh_seq_flagged = cs_subset_string(NeoMutt->sub, "mh_seq_flagged");
  const char *const c_mh_seq_replied = cs_subset_string(NeoMutt->sub, "mh_seq_replied");
  while ((buf = mutt_file_read_line(buf, &sz, fp, NULL, MUTT_RL_NO_FLAGS)))
  {
    char *t = strtok(buf, " \t:");
    if (!t)
      continue;
 
    if (mutt_str_equal(t, c_mh_seq_unseen))
      flags = MH_SEQ_UNSEEN;
    else if (mutt_str_equal(t, c_mh_seq_flagged))
      flags = MH_SEQ_FLAGGED;
    else if (mutt_str_equal(t, c_mh_seq_replied))
      flags = MH_SEQ_REPLIED;
    else /* unknown sequence */
      continue;
 
    while ((t = strtok(NULL, " \t:")))
    {
      if (mh_seq_read_token(t, &first, &last) < 0)
      {
        mh_seq_free(mhs);
        rc = -1;
        goto out;
      }
      for (; first <= last; first++)
        mh_seq_set(mhs, first, flags);
    }
  }
 
  rc = 0;
 
out:
  FREE(&buf);
  mutt_file_fclose(&fp);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_seq_update()

void mh_seq_update

(

struct Mailbox *

m

)

Update sequence numbers.

Parameters

m

Mailbox

XXX we don't currently remove deleted messages from sequences we don't know. Should we?

Definition at line 234 of file sequence.c.

{
  char sequences[PATH_MAX] = { 0 };
  char *tmpfname = NULL;
  char *buf = NULL;
  char *p = NULL;
  size_t s;
  int seq_num = 0;
 
  int unseen = 0;
  int flagged = 0;
  int replied = 0;
 
  char seq_unseen[256] = { 0 };
  char seq_replied[256] = { 0 };
  char seq_flagged[256] = { 0 };
 
  struct MhSequences mhs = { 0 };
 
  const char *const c_mh_seq_unseen = cs_subset_string(NeoMutt->sub, "mh_seq_unseen");
  const char *const c_mh_seq_replied = cs_subset_string(NeoMutt->sub, "mh_seq_replied");
  const char *const c_mh_seq_flagged = cs_subset_string(NeoMutt->sub, "mh_seq_flagged");
  snprintf(seq_unseen, sizeof(seq_unseen), "%s:", NONULL(c_mh_seq_unseen));
  snprintf(seq_replied, sizeof(seq_replied), "%s:", NONULL(c_mh_seq_replied));
  snprintf(seq_flagged, sizeof(seq_flagged), "%s:", NONULL(c_mh_seq_flagged));
 
  FILE *fp_new = NULL;
  if (!mh_mkstemp(m, &fp_new, &tmpfname))
  {
    /* error message? */
    return;
  }
 
  snprintf(sequences, sizeof(sequences), "%s/.mh_sequences", mailbox_path(m));
 
  /* first, copy unknown sequences */
  FILE *fp_old = mutt_file_fopen(sequences, "r");
  if (fp_old)
  {
    while ((buf = mutt_file_read_line(buf, &s, fp_old, NULL, MUTT_RL_NO_FLAGS)))
    {
      if (mutt_str_startswith(buf, seq_unseen) || mutt_str_startswith(buf, seq_flagged) ||
          mutt_str_startswith(buf, seq_replied))
      {
        continue;
      }
 
      fprintf(fp_new, "%s\n", buf);
    }
  }
  mutt_file_fclose(&fp_old);
 
  /* now, update our unseen, flagged, and replied sequences */
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
 
    if (e->deleted)
      continue;
 
    p = strrchr(e->path, '/');
    if (p)
      p++;
    else
      p = e->path;
 
    if (!mutt_str_atoi_full(p, &seq_num))
      continue;
 
    if (!e->read)
    {
      mh_seq_set(&mhs, seq_num, MH_SEQ_UNSEEN);
      unseen++;
    }
    if (e->flagged)
    {
      mh_seq_set(&mhs, seq_num, MH_SEQ_FLAGGED);
      flagged++;
    }
    if (e->replied)
    {
      mh_seq_set(&mhs, seq_num, MH_SEQ_REPLIED);
      replied++;
    }
  }
 
  /* write out the new sequences */
  if (unseen)
    mh_seq_write_one(fp_new, &mhs, MH_SEQ_UNSEEN, NONULL(c_mh_seq_unseen));
  if (flagged)
    mh_seq_write_one(fp_new, &mhs, MH_SEQ_FLAGGED, NONULL(c_mh_seq_flagged));
  if (replied)
    mh_seq_write_one(fp_new, &mhs, MH_SEQ_REPLIED, NONULL(c_mh_seq_replied));
 
  mh_seq_free(&mhs);
 
  /* try to commit the changes - no guarantee here */
  mutt_file_fclose(&fp_new);
 
  unlink(sequences);
  if (mutt_file_safe_rename(tmpfname, sequences) != 0)
  {
    /* report an error? */
    unlink(tmpfname);
  }
 
  FREE(&tmpfname);
}

Here is the call graph for this function:

Here is the caller graph for this function: