NeoMutt  2019-12-07-60-g0cfa53
Teaching an old dog new tricks
DOXYGEN
context.c File Reference

The "currently-open" mailbox. More...

#include "config.h"
#include <string.h>
#include "mutt/mutt.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "context.h"
#include "globals.h"
#include "mutt_header.h"
#include "mutt_thread.h"
#include "mx.h"
#include "ncrypt/ncrypt.h"
#include "pattern.h"
#include "score.h"
#include "sort.h"
+ Include dependency graph for context.c:

Go to the source code of this file.

Functions

void ctx_free (struct Context **ptr)
 Free a Context. More...
 
struct Contextctx_new (void)
 Create a new Context. More...
 
static void ctx_cleanup (struct Context *ctx)
 Release memory and initialize a Context object. More...
 
void ctx_update (struct Context *ctx)
 Update the Context's message counts. More...
 
void ctx_update_tables (struct Context *ctx, bool committing)
 Update a Context structure's internal tables. More...
 
int ctx_mailbox_observer (struct NotifyCallback *nc)
 Watch for changes affecting the Context - Implements observer_t. More...
 
bool message_is_visible (struct Context *ctx, struct Email *e)
 Is a message in the index within limit. More...
 
bool message_is_tagged (struct Context *ctx, struct Email *e)
 Is a message in the index tagged (and within limit) More...
 
int el_add_tagged (struct EmailList *el, struct Context *ctx, struct Email *e, bool use_tagged)
 Get a list of the tagged Emails. More...
 
struct Emailmutt_get_virt_email (struct Mailbox *m, int vnum)
 Get a virtual Email. More...
 

Detailed Description

The "currently-open" mailbox.

Authors
  • Richard Russon

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 context.c.

Function Documentation

◆ ctx_free()

void ctx_free ( struct Context **  ptr)

Free a Context.

Parameters
[out]ptrContext to free

Definition at line 49 of file context.c.

50 {
51  if (!ptr || !*ptr)
52  return;
53 
54  struct Context *ctx = *ptr;
55 
56  struct EventContext ev_ctx = { ctx };
58 
59  if (ctx->mailbox)
61 
63  notify_free(&ctx->notify);
64 
65  FREE(ptr);
66 }
The "current" mailbox.
Definition: context.h:36
int ctx_mailbox_observer(struct NotifyCallback *nc)
Watch for changes affecting the Context - Implements observer_t.
Definition: context.c:295
struct Mailbox * mailbox
Definition: context.h:50
struct Notify * notify
Notifications handler.
Definition: context.h:51
struct Hash * thread_hash
Hash table for threading.
Definition: context.h:43
bool notify_observer_remove(struct Notify *notify, observer_t callback, void *global_data)
Remove an observer from an object.
Definition: notify.c:186
The Context is about to be destroyed.
Definition: context.h:68
void notify_free(struct Notify **ptr)
Free a notification handler.
Definition: notify.c:63
bool notify_send(struct Notify *notify, enum NotifyType event_type, int event_subtype, void *event_data)
Send out a notification message.
Definition: notify.c:138
Context has changed.
Definition: notify_type.h:35
#define FREE(x)
Definition: memory.h:40
struct Notify * notify
Notifications handler.
Definition: mailbox.h:138
An Event that happened to an Context.
Definition: context.h:57
void mutt_hash_free(struct Hash **ptr)
Free a hash table.
Definition: hash.c:471
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ctx_new()

struct Context* ctx_new ( void  )

Create a new Context.

Return values
ptrNew Context

Definition at line 72 of file context.c.

73 {
74  struct Context *ctx = mutt_mem_calloc(1, sizeof(struct Context));
75 
76  ctx->notify = notify_new();
78 
79  return ctx;
80 }
The "current" mailbox.
Definition: context.h:36
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
Container for Accounts, Notifications.
Definition: neomutt.h:35
void notify_set_parent(struct Notify *notify, struct Notify *parent)
Set the parent notification handler.
Definition: notify.c:83
struct Notify * notify
Notifications handler.
Definition: context.h:51
struct Notify * notify
Notifications handler.
Definition: neomutt.h:37
struct Notify * notify_new(void)
Create a new notifications handler.
Definition: notify.c:50
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ctx_cleanup()

static void ctx_cleanup ( struct Context ctx)
static

Release memory and initialize a Context object.

Parameters
ctxContext to cleanup

Definition at line 86 of file context.c.

87 {
88  FREE(&ctx->pattern);
90  if (ctx->mailbox)
92 
93  struct Notify *notify = ctx->notify;
94  struct Mailbox *m = ctx->mailbox;
95  memset(ctx, 0, sizeof(struct Context));
96  ctx->notify = notify;
97  ctx->mailbox = m;
98 }
The "current" mailbox.
Definition: context.h:36
int ctx_mailbox_observer(struct NotifyCallback *nc)
Watch for changes affecting the Context - Implements observer_t.
Definition: context.c:295
struct Mailbox * mailbox
Definition: context.h:50
struct Notify * notify
Notifications handler.
Definition: context.h:51
bool notify_observer_remove(struct Notify *notify, observer_t callback, void *global_data)
Remove an observer from an object.
Definition: notify.c:186
A mailbox.
Definition: mailbox.h:80
struct PatternList * limit_pattern
Compiled limit pattern.
Definition: context.h:40
void mutt_pattern_free(struct PatternList **pat)
Free a Pattern.
Definition: pattern.c:1347
Notification API.
Definition: notify.c:40
#define FREE(x)
Definition: memory.h:40
struct Notify * notify
Notifications handler.
Definition: mailbox.h:138
char * pattern
Limit pattern string.
Definition: context.h:39
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ctx_update()

void ctx_update ( struct Context ctx)

Update the Context's message counts.

Parameters
ctxMailbox

this routine is called to update the counts in the context structure

Definition at line 106 of file context.c.

107 {
108  if (!ctx || !ctx->mailbox)
109  return;
110 
111  struct Mailbox *m = ctx->mailbox;
112 
114  mutt_hash_free(&m->id_hash);
115 
116  /* reset counters */
117  m->msg_unread = 0;
118  m->msg_flagged = 0;
119  m->msg_new = 0;
120  m->msg_deleted = 0;
121  m->msg_tagged = 0;
122  m->vcount = 0;
123  m->changed = false;
124 
125  mutt_clear_threads(ctx);
126 
127  struct Email *e = NULL;
128  for (int msgno = 0; msgno < m->msg_count; msgno++)
129  {
130  e = m->emails[msgno];
131  if (!e)
132  continue;
133 
134  if (WithCrypto)
135  {
136  /* NOTE: this _must_ be done before the check for mailcap! */
137  e->security = crypt_query(e->content);
138  }
139 
140  if (ctx->pattern)
141  {
142  e->vnum = -1;
143  }
144  else
145  {
146  m->v2r[m->vcount] = msgno;
147  e->vnum = m->vcount++;
148  }
149  e->msgno = msgno;
150 
151  if (e->env->supersedes)
152  {
153  struct Email *e2 = NULL;
154 
155  if (!m->id_hash)
156  m->id_hash = mutt_make_id_hash(m);
157 
158  e2 = mutt_hash_find(m->id_hash, e->env->supersedes);
159  if (e2)
160  {
161  e2->superseded = true;
162  if (C_Score)
163  mutt_score_message(ctx->mailbox, e2, true);
164  }
165  }
166 
167  /* add this message to the hash tables */
168  if (m->id_hash && e->env->message_id)
170  if (m->subj_hash && e->env->real_subj)
172  mutt_label_hash_add(m, e);
173 
174  if (C_Score)
175  mutt_score_message(ctx->mailbox, e, false);
176 
177  if (e->changed)
178  m->changed = true;
179  if (e->flagged)
180  m->msg_flagged++;
181  if (e->deleted)
182  m->msg_deleted++;
183  if (!e->read)
184  {
185  m->msg_unread++;
186  if (!e->old)
187  m->msg_new++;
188  }
189  }
190 
191  mutt_sort_headers(ctx, true); /* rethread from scratch */
192 }
struct Email ** emails
Array of Emails.
Definition: mailbox.h:98
int msg_count
Total number of messages.
Definition: mailbox.h:90
The envelope/body of an email.
Definition: email.h:37
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:95
int msg_unread
Number of unread messages.
Definition: mailbox.h:91
char * supersedes
Supersedes header.
Definition: envelope.h:70
int msg_flagged
Number of flagged messages.
Definition: mailbox.h:92
struct Body * content
List of MIME parts.
Definition: email.h:90
void * mutt_hash_find(const struct Hash *table, const char *strkey)
Find the HashElem data in a Hash table element using a key.
Definition: hash.c:378
void mutt_score_message(struct Mailbox *m, struct Email *e, bool upd_mbox)
Apply scoring to an email.
Definition: score.c:173
char * real_subj
Offset of the real subject.
Definition: envelope.h:67
bool changed
Email has been edited.
Definition: email.h:48
void mutt_label_hash_add(struct Mailbox *m, struct Email *e)
Add a message&#39;s labels to the Hash Table.
Definition: mutt_header.c:371
int vcount
The number of virtual messages.
Definition: mailbox.h:101
bool read
Email is read.
Definition: email.h:51
char * message_id
Message ID.
Definition: envelope.h:69
struct Mailbox * mailbox
Definition: context.h:50
bool old
Email is seen, but unread.
Definition: email.h:50
struct Envelope * env
Envelope information.
Definition: email.h:89
bool superseded
Got superseded?
Definition: email.h:53
void mutt_sort_headers(struct Context *ctx, bool init)
Sort emails by their headers.
Definition: sort.c:362
A mailbox.
Definition: mailbox.h:80
int msg_tagged
How many messages are tagged?
Definition: mailbox.h:96
int vnum
Virtual message number.
Definition: email.h:87
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/ncrypt.h pgplib.h, smime.h
Definition: email.h:39
struct Hash * mutt_make_id_hash(struct Mailbox *m)
Create a Hash Table for message-ids.
Definition: mutt_thread.c:1456
void mutt_clear_threads(struct Context *ctx)
Clear the threading of message in a mailbox.
Definition: mutt_thread.c:601
int * v2r
Mapping from virtual to real msgno.
Definition: mailbox.h:100
bool flagged
Marked important?
Definition: email.h:43
int msg_new
Number of new messages.
Definition: mailbox.h:94
struct Hash * subj_hash
Hash table by subject.
Definition: mailbox.h:127
bool deleted
Email is deleted.
Definition: email.h:45
WHERE bool C_Score
Config: Use message scoring.
Definition: globals.h:250
bool changed
Mailbox has been modified.
Definition: mailbox.h:113
void mutt_hash_free(struct Hash **ptr)
Free a hash table.
Definition: hash.c:471
struct HashElem * mutt_hash_insert(struct Hash *table, const char *strkey, void *data)
Add a new element to the Hash table (with string keys)
Definition: hash.c:351
char * pattern
Limit pattern string.
Definition: context.h:39
#define WithCrypto
Definition: ncrypt.h:160
SecurityFlags crypt_query(struct Body *m)
Check out the type of encryption used.
Definition: crypt.c:692
struct Hash * id_hash
Hash table by msg id.
Definition: mailbox.h:126
int msgno
Number displayed to the user.
Definition: email.h:86
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ctx_update_tables()

void ctx_update_tables ( struct Context ctx,
bool  committing 
)

Update a Context structure's internal tables.

Parameters
ctxMailbox
committingCommit the changes?

Definition at line 199 of file context.c.

200 {
201  if (!ctx || !ctx->mailbox)
202  return;
203 
204  struct Mailbox *m = ctx->mailbox;
205 
206  int i, j, padding;
207 
208  /* update memory to reflect the new state of the mailbox */
209  m->vcount = 0;
210  ctx->vsize = 0;
211  m->msg_tagged = 0;
212  m->msg_deleted = 0;
213  m->msg_new = 0;
214  m->msg_unread = 0;
215  m->changed = false;
216  m->msg_flagged = 0;
217  padding = mx_msg_padding_size(m);
218  for (i = 0, j = 0; i < m->msg_count; i++)
219  {
220  if (!m->emails[i])
221  break;
222  if (!m->emails[i]->quasi_deleted &&
223  ((committing && (!m->emails[i]->deleted || ((m->magic == MUTT_MAILDIR) && C_MaildirTrash))) ||
224  (!committing && m->emails[i]->active)))
225  {
226  if (i != j)
227  {
228  m->emails[j] = m->emails[i];
229  m->emails[i] = NULL;
230  }
231  m->emails[j]->msgno = j;
232  if (m->emails[j]->vnum != -1)
233  {
234  m->v2r[m->vcount] = j;
235  m->emails[j]->vnum = m->vcount++;
236  struct Body *b = m->emails[j]->content;
237  ctx->vsize += b->length + b->offset - b->hdr_offset + padding;
238  }
239 
240  if (committing)
241  {
242  m->emails[j]->changed = false;
243  m->emails[j]->env->changed = false;
244  }
245  else if (m->emails[j]->changed)
246  m->changed = true;
247 
248  if (!committing || ((m->magic == MUTT_MAILDIR) && C_MaildirTrash))
249  {
250  if (m->emails[j]->deleted)
251  m->msg_deleted++;
252  }
253 
254  if (m->emails[j]->tagged)
255  m->msg_tagged++;
256  if (m->emails[j]->flagged)
257  m->msg_flagged++;
258  if (!m->emails[j]->read)
259  {
260  m->msg_unread++;
261  if (!m->emails[j]->old)
262  m->msg_new++;
263  }
264 
265  j++;
266  }
267  else
268  {
269  if ((m->magic == MUTT_NOTMUCH) || (m->magic == MUTT_MH) ||
270  (m->magic == MUTT_MAILDIR) || (m->magic == MUTT_IMAP))
271  {
272  mailbox_size_sub(m, m->emails[i]);
273  }
274  /* remove message from the hash tables */
275  if (m->subj_hash && m->emails[i]->env->real_subj)
276  mutt_hash_delete(m->subj_hash, m->emails[i]->env->real_subj, m->emails[i]);
277  if (m->id_hash && m->emails[i]->env->message_id)
278  mutt_hash_delete(m->id_hash, m->emails[i]->env->message_id, m->emails[i]);
279  mutt_label_hash_remove(m, m->emails[i]);
280  /* The path mx_mbox_check() -> imap_check_mailbox() ->
281  * imap_expunge_mailbox() -> ctx_update_tables()
282  * can occur before a call to mx_mbox_sync(), resulting in
283  * last_tag being stale if it's not reset here. */
284  if (ctx->last_tag == m->emails[i])
285  ctx->last_tag = NULL;
286  email_free(&m->emails[i]);
287  }
288  }
289  m->msg_count = j;
290 }
struct Email ** emails
Array of Emails.
Definition: mailbox.h:98
void mutt_hash_delete(struct Hash *table, const char *strkey, const void *data)
Remove an element from a Hash table.
Definition: hash.c:443
int msg_count
Total number of messages.
Definition: mailbox.h:90
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:95
int msg_unread
Number of unread messages.
Definition: mailbox.h:91
int msg_flagged
Number of flagged messages.
Definition: mailbox.h:92
struct Body * content
List of MIME parts.
Definition: email.h:90
LOFF_T offset
offset where the actual data begins
Definition: body.h:44
char * real_subj
Offset of the real subject.
Definition: envelope.h:67
bool changed
Email has been edited.
Definition: email.h:48
void mutt_label_hash_remove(struct Mailbox *m, struct Email *e)
Remove a message&#39;s labels from the Hash Table.
Definition: mutt_header.c:384
int vcount
The number of virtual messages.
Definition: mailbox.h:101
The body of an email.
Definition: body.h:34
unsigned char changed
Changed fields, e.g. MUTT_ENV_CHANGED_SUBJECT.
Definition: envelope.h:88
bool tagged
Email is tagged.
Definition: email.h:44
bool read
Email is read.
Definition: email.h:51
char * message_id
Message ID.
Definition: envelope.h:69
struct Mailbox * mailbox
Definition: context.h:50
bool old
Email is seen, but unread.
Definition: email.h:50
enum MailboxType magic
Mailbox type.
Definition: mailbox.h:104
struct Envelope * env
Envelope information.
Definition: email.h:89
&#39;Maildir&#39; Mailbox type
Definition: mailbox.h:50
bool quasi_deleted
Deleted from neomutt, but not modified on disk.
Definition: email.h:47
off_t vsize
Definition: context.h:38
bool active
Message is not to be removed.
Definition: email.h:59
LOFF_T length
length (in bytes) of attachment
Definition: body.h:45
A mailbox.
Definition: mailbox.h:80
WHERE bool C_MaildirTrash
Config: Use the maildir &#39;trashed&#39; flag, rather than deleting.
Definition: globals.h:240
&#39;MH&#39; Mailbox type
Definition: mailbox.h:49
int msg_tagged
How many messages are tagged?
Definition: mailbox.h:96
int vnum
Virtual message number.
Definition: email.h:87
&#39;Notmuch&#39; (virtual) Mailbox type
Definition: mailbox.h:53
int * v2r
Mapping from virtual to real msgno.
Definition: mailbox.h:100
bool flagged
Marked important?
Definition: email.h:43
int msg_new
Number of new messages.
Definition: mailbox.h:94
struct Hash * subj_hash
Hash table by subject.
Definition: mailbox.h:127
bool deleted
Email is deleted.
Definition: email.h:45
bool changed
Mailbox has been modified.
Definition: mailbox.h:113
int mx_msg_padding_size(struct Mailbox *m)
Bytes of padding between messages - Wrapper for MxOps::msg_padding_size()
Definition: mx.c:1517
long hdr_offset
Offset in stream where the headers begin.
Definition: body.h:42
void mailbox_size_sub(struct Mailbox *m, const struct Email *e)
Subtract an email&#39;s size from the total size of a Mailbox.
Definition: mailbox.c:195
void email_free(struct Email **ptr)
Free an Email.
Definition: email.c:41
&#39;IMAP&#39; Mailbox type
Definition: mailbox.h:52
struct Hash * id_hash
Hash table by msg id.
Definition: mailbox.h:126
struct Email * last_tag
Last tagged msg (used to link threads)
Definition: context.h:41
int msgno
Number displayed to the user.
Definition: email.h:86
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ctx_mailbox_observer()

int ctx_mailbox_observer ( struct NotifyCallback nc)

Watch for changes affecting the Context - Implements observer_t.

Definition at line 295 of file context.c.

296 {
297  if (!nc->global_data)
298  return -1;
299  if (nc->event_type != NT_MAILBOX)
300  return 0;
301 
302  struct Context *ctx = nc->global_data;
303 
304  switch (nc->event_subtype)
305  {
306  case NT_MAILBOX_CLOSED:
307  mutt_clear_threads(ctx);
308  ctx_cleanup(ctx);
309  break;
310  case NT_MAILBOX_INVALID:
311  ctx_update(ctx);
312  break;
313  case NT_MAILBOX_UPDATE:
314  ctx_update_tables(ctx, true);
315  break;
316  case NT_MAILBOX_RESORT:
317  mutt_sort_headers(ctx, true);
318  break;
319  case NT_MAILBOX_UNTAG:
320  if (ctx->last_tag && ctx->last_tag->deleted)
321  ctx->last_tag = NULL;
322  break;
323  }
324 
325  return 0;
326 }
void ctx_update_tables(struct Context *ctx, bool committing)
Update a Context structure&#39;s internal tables.
Definition: context.c:199
The "current" mailbox.
Definition: context.h:36
Clear the &#39;last-tagged&#39; pointer.
Definition: mailbox.h:173
Update internal tables.
Definition: mailbox.h:172
Email list was changed.
Definition: mailbox.h:170
Mailbox was closed.
Definition: mailbox.h:169
int event_subtype
Send: Event subtype, e.g. NT_ACCOUNT_ADD.
Definition: observer.h:43
enum NotifyType event_type
Send: Event type, e.g. NT_ACCOUNT.
Definition: observer.h:42
void * global_data
Data from notify_observer_add()
Definition: observer.h:45
Email list needs resorting.
Definition: mailbox.h:171
static void ctx_cleanup(struct Context *ctx)
Release memory and initialize a Context object.
Definition: context.c:86
void mutt_sort_headers(struct Context *ctx, bool init)
Sort emails by their headers.
Definition: sort.c:362
void ctx_update(struct Context *ctx)
Update the Context&#39;s message counts.
Definition: context.c:106
void mutt_clear_threads(struct Context *ctx)
Clear the threading of message in a mailbox.
Definition: mutt_thread.c:601
bool deleted
Email is deleted.
Definition: email.h:45
Mailbox has changed.
Definition: notify_type.h:38
struct Email * last_tag
Last tagged msg (used to link threads)
Definition: context.h:41
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ message_is_visible()

bool message_is_visible ( struct Context ctx,
struct Email e 
)

Is a message in the index within limit.

Parameters
ctxContext
eEmail
Return values
trueThe message is within limit

If no limit is in effect, all the messages are visible.

Definition at line 336 of file context.c.

337 {
338  if (!ctx || !e)
339  return false;
340 
341  return !ctx->pattern || e->limited;
342 }
bool limited
Is this message in a limited view?
Definition: email.h:74
char * pattern
Limit pattern string.
Definition: context.h:39
+ Here is the caller graph for this function:

◆ message_is_tagged()

bool message_is_tagged ( struct Context ctx,
struct Email e 
)

Is a message in the index tagged (and within limit)

Parameters
ctxOpen mailbox
eEmail
Return values
trueThe message is both tagged and within limit

If a limit is in effect, the message must be visible within it.

Definition at line 352 of file context.c.

353 {
354  return message_is_visible(ctx, e) && e->tagged;
355 }
bool tagged
Email is tagged.
Definition: email.h:44
bool message_is_visible(struct Context *ctx, struct Email *e)
Is a message in the index within limit.
Definition: context.c:336
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ el_add_tagged()

int el_add_tagged ( struct EmailList *  el,
struct Context ctx,
struct Email e,
bool  use_tagged 
)

Get a list of the tagged Emails.

Parameters
elEmpty EmailList to populate
ctxCurrent Mailbox
eCurrent Email
use_taggedUse tagged Emails
Return values
numNumber of selected emails
-1Error

Definition at line 366 of file context.c.

367 {
368  int count = 0;
369 
370  if (use_tagged)
371  {
372  if (!ctx || !ctx->mailbox || !ctx->mailbox->emails)
373  return -1;
374 
375  struct Mailbox *m = ctx->mailbox;
376  for (size_t i = 0; i < m->msg_count; i++)
377  {
378  e = m->emails[i];
379  if (!e)
380  break;
381  if (!message_is_tagged(ctx, e))
382  continue;
383 
384  struct EmailNode *en = mutt_mem_calloc(1, sizeof(*en));
385  en->email = e;
386  STAILQ_INSERT_TAIL(el, en, entries);
387  count++;
388  }
389  }
390  else
391  {
392  if (!e)
393  return -1;
394 
395  struct EmailNode *en = mutt_mem_calloc(1, sizeof(*en));
396  en->email = e;
397  STAILQ_INSERT_TAIL(el, en, entries);
398  count = 1;
399  }
400 
401  return count;
402 }
struct Email ** emails
Array of Emails.
Definition: mailbox.h:98
bool message_is_tagged(struct Context *ctx, struct Email *e)
Is a message in the index tagged (and within limit)
Definition: context.c:352
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
int msg_count
Total number of messages.
Definition: mailbox.h:90
#define STAILQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:386
struct Mailbox * mailbox
Definition: context.h:50
A mailbox.
Definition: mailbox.h:80
struct Email * email
Email in the list.
Definition: email.h:116
List of Emails.
Definition: email.h:114
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_get_virt_email()

struct Email* mutt_get_virt_email ( struct Mailbox m,
int  vnum 
)

Get a virtual Email.

Parameters
mMailbox
vnumVirtual index number
Return values
ptrEmail
NULLNo Email selected, or bad index values

This safely gets the result of the following:

  • mailbox->emails[mailbox->v2r[vnum]]

Definition at line 414 of file context.c.

415 {
416  if (!m || !m->emails || !m->v2r)
417  return NULL;
418 
419  if ((vnum < 0) || (vnum >= m->vcount))
420  return NULL;
421 
422  int inum = m->v2r[vnum];
423  if ((inum < 0) || (inum >= m->msg_count))
424  return NULL;
425 
426  return m->emails[inum];
427 }
struct Email ** emails
Array of Emails.
Definition: mailbox.h:98
int msg_count
Total number of messages.
Definition: mailbox.h:90
int vcount
The number of virtual messages.
Definition: mailbox.h:101
int * v2r
Mapping from virtual to real msgno.
Definition: mailbox.h:100
+ Here is the caller graph for this function: