NeoMutt  2020-06-26-89-g172cd3
Teaching an old dog new tricks
DOXYGEN
context.c File Reference

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

#include "config.h"
#include <string.h>
#include "mutt/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "context.h"
#include "mutt_globals.h"
#include "mutt_header.h"
#include "mutt_thread.h"
#include "mx.h"
#include "pattern.h"
#include "score.h"
#include "sort.h"
#include "maildir/lib.h"
#include "ncrypt/lib.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:37
int ctx_mailbox_observer(struct NotifyCallback *nc)
Watch for changes affecting the Context - Implements observer_t.
Definition: context.c:291
struct HashTable * thread_hash
Hash Table for threading.
Definition: context.h:43
void mutt_hash_free(struct HashTable **ptr)
Free a hash table.
Definition: hash.c:447
void notify_free(struct Notify **ptr)
Free a notification handler.
Definition: notify.c:62
struct Mailbox * mailbox
Definition: context.h:50
struct Notify * notify
Notifications handler.
Definition: context.h:51
The Context is about to be destroyed.
Definition: context.h:62
Context has changed, NotifyContext, EventContext.
Definition: notify_type.h:37
#define FREE(x)
Definition: memory.h:40
bool notify_observer_remove(struct Notify *notify, observer_t callback, void *global_data)
Remove an observer from an object.
Definition: notify.c:185
struct Notify * notify
Notifications handler.
Definition: mailbox.h:139
An Event that happened to an Context.
Definition: context.h:68
bool notify_send(struct Notify *notify, enum NotifyType event_type, int event_subtype, void *event_data)
Send out a notification message.
Definition: notify.c:137
+ 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:37
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:36
struct Notify * notify
Notifications handler.
Definition: context.h:51
struct Notify * notify_new(void)
Create a new notifications handler.
Definition: notify.c:49
struct Notify * notify
Notifications handler.
Definition: neomutt.h:38
void notify_set_parent(struct Notify *notify, struct Notify *parent)
Set the parent notification handler.
Definition: notify.c:82
+ 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:37
int ctx_mailbox_observer(struct NotifyCallback *nc)
Watch for changes affecting the Context - Implements observer_t.
Definition: context.c:291
struct Mailbox * mailbox
Definition: context.h:50
struct Notify * notify
Notifications handler.
Definition: context.h:51
A mailbox.
Definition: mailbox.h:81
struct PatternList * limit_pattern
Compiled limit pattern.
Definition: context.h:41
void mutt_pattern_free(struct PatternList **pat)
Free a Pattern.
Definition: pattern.c:1385
Notification API.
Definition: notify.c:39
#define FREE(x)
Definition: memory.h:40
bool notify_observer_remove(struct Notify *notify, observer_t callback, void *global_data)
Remove an observer from an object.
Definition: notify.c:185
struct Notify * notify
Notifications handler.
Definition: mailbox.h:139
char * pattern
Limit pattern string.
Definition: context.h:40
+ 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->tagged)
184  m->msg_tagged++;
185  if (!e->read)
186  {
187  m->msg_unread++;
188  if (!e->old)
189  m->msg_new++;
190  }
191  }
192 
193  mutt_sort_headers(ctx, true); /* rethread from scratch */
194 }
void * mutt_hash_find(const struct HashTable *table, const char *strkey)
Find the HashElem data in a Hash Table element using a key.
Definition: hash.c:354
struct Email ** emails
Array of Emails.
Definition: mailbox.h:99
struct HashElem * mutt_hash_insert(struct HashTable *table, const char *strkey, void *data)
Add a new element to the Hash Table (with string keys)
Definition: hash.c:327
int msg_count
Total number of messages.
Definition: mailbox.h:91
#define WithCrypto
Definition: lib.h:118
The envelope/body of an email.
Definition: email.h:37
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:96
int msg_unread
Number of unread messages.
Definition: mailbox.h:92
char * supersedes
Supersedes header.
Definition: envelope.h:70
void mutt_hash_free(struct HashTable **ptr)
Free a hash table.
Definition: hash.c:447
int msg_flagged
Number of flagged messages.
Definition: mailbox.h:93
struct HashTable * mutt_make_id_hash(struct Mailbox *m)
Create a Hash Table for message-ids.
Definition: mutt_thread.c:1455
struct Body * content
List of MIME parts.
Definition: email.h:90
WHERE bool C_Score
Config: Use message scoring.
Definition: mutt_globals.h:161
void mutt_score_message(struct Mailbox *m, struct Email *e, bool upd_mbox)
Apply scoring to an email.
Definition: score.c:174
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:372
int vcount
The number of virtual messages.
Definition: mailbox.h:102
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
struct HashTable * id_hash
Hash Table by msg id.
Definition: mailbox.h:127
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
struct HashTable * subj_hash
Hash Table by subject.
Definition: mailbox.h:128
void mutt_sort_headers(struct Context *ctx, bool init)
Sort emails by their headers.
Definition: sort.c:364
A mailbox.
Definition: mailbox.h:81
int msg_tagged
How many messages are tagged?
Definition: mailbox.h:97
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/lib.h pgplib...
Definition: email.h:39
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:101
bool flagged
Marked important?
Definition: email.h:43
int msg_new
Number of new messages.
Definition: mailbox.h:95
bool deleted
Email is deleted.
Definition: email.h:45
bool changed
Mailbox has been modified.
Definition: mailbox.h:114
char * pattern
Limit pattern string.
Definition: context.h:40
SecurityFlags crypt_query(struct Body *m)
Check out the type of encryption used.
Definition: crypt.c:683
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 201 of file context.c.

202 {
203  if (!ctx || !ctx->mailbox)
204  return;
205 
206  struct Mailbox *m = ctx->mailbox;
207 
208  int i, j, padding;
209 
210  /* update memory to reflect the new state of the mailbox */
211  m->vcount = 0;
212  ctx->vsize = 0;
213  m->msg_tagged = 0;
214  m->msg_deleted = 0;
215  m->msg_new = 0;
216  m->msg_unread = 0;
217  m->changed = false;
218  m->msg_flagged = 0;
219  padding = mx_msg_padding_size(m);
220  for (i = 0, j = 0; i < m->msg_count; i++)
221  {
222  if (!m->emails[i])
223  break;
224  if (!m->emails[i]->quasi_deleted &&
225  ((committing && (!m->emails[i]->deleted || ((m->type == MUTT_MAILDIR) && C_MaildirTrash))) ||
226  (!committing && m->emails[i]->active)))
227  {
228  if (i != j)
229  {
230  m->emails[j] = m->emails[i];
231  m->emails[i] = NULL;
232  }
233  m->emails[j]->msgno = j;
234  if (m->emails[j]->vnum != -1)
235  {
236  m->v2r[m->vcount] = j;
237  m->emails[j]->vnum = m->vcount++;
238  struct Body *b = m->emails[j]->content;
239  ctx->vsize += b->length + b->offset - b->hdr_offset + padding;
240  }
241 
242  if (committing)
243  {
244  m->emails[j]->changed = false;
245  m->emails[j]->env->changed = false;
246  }
247  else if (m->emails[j]->changed)
248  m->changed = true;
249 
250  if (!committing || ((m->type == MUTT_MAILDIR) && C_MaildirTrash))
251  {
252  if (m->emails[j]->deleted)
253  m->msg_deleted++;
254  }
255 
256  if (m->emails[j]->tagged)
257  m->msg_tagged++;
258  if (m->emails[j]->flagged)
259  m->msg_flagged++;
260  if (!m->emails[j]->read)
261  {
262  m->msg_unread++;
263  if (!m->emails[j]->old)
264  m->msg_new++;
265  }
266 
267  j++;
268  }
269  else
270  {
271  if ((m->type == MUTT_NOTMUCH) || (m->type == MUTT_MH) ||
272  (m->type == MUTT_MAILDIR) || (m->type == MUTT_IMAP))
273  {
274  mailbox_size_sub(m, m->emails[i]);
275  }
276  /* remove message from the hash tables */
277  if (m->subj_hash && m->emails[i]->env->real_subj)
278  mutt_hash_delete(m->subj_hash, m->emails[i]->env->real_subj, m->emails[i]);
279  if (m->id_hash && m->emails[i]->env->message_id)
280  mutt_hash_delete(m->id_hash, m->emails[i]->env->message_id, m->emails[i]);
281  mutt_label_hash_remove(m, m->emails[i]);
282  email_free(&m->emails[i]);
283  }
284  }
285  m->msg_count = j;
286 }
struct Email ** emails
Array of Emails.
Definition: mailbox.h:99
enum MailboxType type
Mailbox type.
Definition: mailbox.h:105
int msg_count
Total number of messages.
Definition: mailbox.h:91
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:96
int msg_unread
Number of unread messages.
Definition: mailbox.h:92
int msg_flagged
Number of flagged messages.
Definition: mailbox.h:93
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:385
int vcount
The number of virtual messages.
Definition: mailbox.h:102
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
struct HashTable * id_hash
Hash Table by msg id.
Definition: mailbox.h:127
bool old
Email is seen, but unread.
Definition: email.h:50
struct Envelope * env
Envelope information.
Definition: email.h:89
struct HashTable * subj_hash
Hash Table by subject.
Definition: mailbox.h:128
&#39;Maildir&#39; Mailbox type
Definition: mailbox.h:51
bool quasi_deleted
Deleted from neomutt, but not modified on disk.
Definition: email.h:47
off_t vsize
Definition: context.h:39
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:81
&#39;MH&#39; Mailbox type
Definition: mailbox.h:50
int msg_tagged
How many messages are tagged?
Definition: mailbox.h:97
int vnum
Virtual message number.
Definition: email.h:87
&#39;Notmuch&#39; (virtual) Mailbox type
Definition: mailbox.h:54
int * v2r
Mapping from virtual to real msgno.
Definition: mailbox.h:101
bool flagged
Marked important?
Definition: email.h:43
int msg_new
Number of new messages.
Definition: mailbox.h:95
bool deleted
Email is deleted.
Definition: email.h:45
bool C_MaildirTrash
Config: Use the maildir &#39;trashed&#39; flag, rather than deleting.
Definition: config.c:38
void mutt_hash_delete(struct HashTable *table, const char *strkey, const void *data)
Remove an element from a Hash Table.
Definition: hash.c:419
bool changed
Mailbox has been modified.
Definition: mailbox.h:114
int mx_msg_padding_size(struct Mailbox *m)
Bytes of padding between messages - Wrapper for MxOps::msg_padding_size()
Definition: mx.c:1543
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:198
void email_free(struct Email **ptr)
Free an Email.
Definition: email.c:41
&#39;IMAP&#39; Mailbox type
Definition: mailbox.h:53
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 291 of file context.c.

292 {
293  if (!nc->global_data)
294  return -1;
295  if (nc->event_type != NT_MAILBOX)
296  return 0;
297 
298  struct Context *ctx = nc->global_data;
299 
300  switch (nc->event_subtype)
301  {
302  case NT_MAILBOX_CLOSED:
303  mutt_clear_threads(ctx);
304  ctx_cleanup(ctx);
305  break;
306  case NT_MAILBOX_INVALID:
307  ctx_update(ctx);
308  break;
309  case NT_MAILBOX_UPDATE:
310  ctx_update_tables(ctx, true);
311  break;
312  case NT_MAILBOX_RESORT:
313  mutt_sort_headers(ctx, true);
314  break;
315  }
316 
317  return 0;
318 }
void ctx_update_tables(struct Context *ctx, bool committing)
Update a Context structure&#39;s internal tables.
Definition: context.c:201
The "current" mailbox.
Definition: context.h:37
Update internal tables.
Definition: mailbox.h:169
Email list was changed.
Definition: mailbox.h:166
Mailbox was closed.
Definition: mailbox.h:165
int event_subtype
Send: Event subtype, e.g. NT_ACCOUNT_ADD.
Definition: observer.h:42
enum NotifyType event_type
Send: Event type, e.g. NT_ACCOUNT.
Definition: observer.h:41
void * global_data
Data from notify_observer_add()
Definition: observer.h:44
Email list needs resorting.
Definition: mailbox.h:167
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:364
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
Mailbox has changed, NotifyMailbox, EventMailbox.
Definition: notify_type.h:40
+ 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 328 of file context.c.

329 {
330  if (!ctx || !e)
331  return false;
332 
333  return !ctx->pattern || e->limited;
334 }
bool limited
Is this message in a limited view?
Definition: email.h:74
char * pattern
Limit pattern string.
Definition: context.h:40
+ 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 344 of file context.c.

345 {
346  return message_is_visible(ctx, e) && e->tagged;
347 }
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:328
+ 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 358 of file context.c.

359 {
360  int count = 0;
361 
362  if (use_tagged)
363  {
364  if (!ctx || !ctx->mailbox || !ctx->mailbox->emails)
365  return -1;
366 
367  struct Mailbox *m = ctx->mailbox;
368  for (size_t i = 0; i < m->msg_count; i++)
369  {
370  e = m->emails[i];
371  if (!e)
372  break;
373  if (!message_is_tagged(ctx, e))
374  continue;
375 
376  struct EmailNode *en = mutt_mem_calloc(1, sizeof(*en));
377  en->email = e;
378  STAILQ_INSERT_TAIL(el, en, entries);
379  count++;
380  }
381  }
382  else
383  {
384  if (!e)
385  return -1;
386 
387  struct EmailNode *en = mutt_mem_calloc(1, sizeof(*en));
388  en->email = e;
389  STAILQ_INSERT_TAIL(el, en, entries);
390  count = 1;
391  }
392 
393  return count;
394 }
struct Email ** emails
Array of Emails.
Definition: mailbox.h:99
bool message_is_tagged(struct Context *ctx, struct Email *e)
Is a message in the index tagged (and within limit)
Definition: context.c:344
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:91
#define STAILQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:386
struct Mailbox * mailbox
Definition: context.h:50
A mailbox.
Definition: mailbox.h:81
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 406 of file context.c.

407 {
408  if (!m || !m->emails || !m->v2r)
409  return NULL;
410 
411  if ((vnum < 0) || (vnum >= m->vcount))
412  return NULL;
413 
414  int inum = m->v2r[vnum];
415  if ((inum < 0) || (inum >= m->msg_count))
416  return NULL;
417 
418  return m->emails[inum];
419 }
struct Email ** emails
Array of Emails.
Definition: mailbox.h:99
int msg_count
Total number of messages.
Definition: mailbox.h:91
int vcount
The number of virtual messages.
Definition: mailbox.h:102
int * v2r
Mapping from virtual to real msgno.
Definition: mailbox.h:101
+ Here is the caller graph for this function: