NeoMutt  2020-08-21-74-g346364
Teaching an old dog new tricks
DOXYGEN
context.h File Reference

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

#include <stdbool.h>
#include <sys/types.h>
+ Include dependency graph for context.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  Context
 The "current" mailbox. More...
 
struct  EventContext
 An Event that happened to an Context. More...
 

Enumerations

enum  NotifyContext { NT_CONTEXT_OPEN = 1, NT_CONTEXT_CLOSE }
 Types of Context Event. More...
 

Functions

void ctx_free (struct Context **ptr)
 Free a Context. More...
 
int ctx_mailbox_observer (struct NotifyCallback *nc)
 Watch for changes affecting the Context - Implements observer_t. More...
 
struct Contextctx_new (struct Mailbox *m)
 Create a new Context. 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...
 
bool ctx_has_limit (const struct Context *ctx)
 Is a limit active? More...
 
bool message_is_tagged (struct Context *ctx, struct Email *e)
 Is a message in the index tagged (and within limit) More...
 
struct Emailmutt_get_virt_email (struct Mailbox *m, int vnum)
 Get a virtual Email. 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...
 

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.h.

Enumeration Type Documentation

◆ NotifyContext

Types of Context Event.

Observers of NT_CONTEXT will be passed an EventContext.

Enumerator
NT_CONTEXT_OPEN 

The Context has been opened.

NT_CONTEXT_CLOSE 

The Context is about to be destroyed.

Definition at line 59 of file context.h.

60 {
61  NT_CONTEXT_OPEN = 1,
63 };
The Context has been opened.
Definition: context.h:61
The Context is about to be destroyed.
Definition: context.h:62

Function Documentation

◆ ctx_free()

void ctx_free ( struct Context **  ptr)

Free a Context.

Parameters
[out]ptrContext to free

Definition at line 50 of file context.c.

51 {
52  if (!ptr || !*ptr)
53  return;
54 
55  struct Context *ctx = *ptr;
56 
57  struct EventContext ev_ctx = { ctx };
59 
60  if (ctx->mailbox)
62 
64  notify_free(&ctx->notify);
65 
66  FREE(ptr);
67 }
The "current" mailbox.
Definition: context.h:38
int ctx_mailbox_observer(struct NotifyCallback *nc)
Watch for changes affecting the Context - Implements observer_t.
Definition: context.c:302
void notify_free(struct Notify **ptr)
Free a notification handler.
Definition: notify.c:62
struct ThreadsContext * threads
Threads context.
Definition: context.h:43
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:38
#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:207
void mutt_thread_ctx_free(struct ThreadsContext **tctx)
Finalize a threading context.
Definition: mutt_thread.c:301
struct Notify * notify
Notifications handler.
Definition: mailbox.h:144
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:152
+ 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 302 of file context.c.

303 {
304  if (!nc->global_data)
305  return -1;
306  if (nc->event_type != NT_MAILBOX)
307  return 0;
308 
309  struct Context *ctx = nc->global_data;
310 
311  switch (nc->event_subtype)
312  {
313  case NT_MAILBOX_CLOSED:
315  ctx_cleanup(ctx);
316  break;
317  case NT_MAILBOX_INVALID:
318  ctx_update(ctx);
319  break;
320  case NT_MAILBOX_UPDATE:
321  ctx_update_tables(ctx, true);
322  break;
323  case NT_MAILBOX_RESORT:
324  mutt_sort_headers(ctx->mailbox, ctx->threads, true, &ctx->vsize);
325  break;
326  }
327 
328  return 0;
329 }
void ctx_update_tables(struct Context *ctx, bool committing)
Update a Context structure&#39;s internal tables.
Definition: context.c:206
The "current" mailbox.
Definition: context.h:38
Update internal tables.
Definition: mailbox.h:174
void mutt_sort_headers(struct Mailbox *m, struct ThreadsContext *threads, bool init, off_t *vsize)
Sort emails by their headers.
Definition: sort.c:366
struct ThreadsContext * threads
Threads context.
Definition: context.h:43
Email list was changed.
Definition: mailbox.h:171
Mailbox was closed.
Definition: mailbox.h:170
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
struct Mailbox * mailbox
Definition: context.h:50
void mutt_clear_threads(struct ThreadsContext *tctx)
Clear the threading of message in a mailbox.
Definition: mutt_thread.c:637
void * global_data
Data from notify_observer_add()
Definition: observer.h:45
off_t vsize
Size (in bytes) of the messages shown.
Definition: context.h:40
Email list needs resorting.
Definition: mailbox.h:172
static void ctx_cleanup(struct Context *ctx)
Release memory and initialize a Context object.
Definition: context.c:90
void ctx_update(struct Context *ctx)
Update the Context&#39;s message counts.
Definition: context.c:110
Mailbox has changed, NotifyMailbox, EventMailbox.
Definition: notify_type.h:41
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ctx_new()

struct Context* ctx_new ( struct Mailbox m)

Create a new Context.

Parameters
mMailbox
Return values
ptrNew Context

Definition at line 74 of file context.c.

75 {
76  struct Context *ctx = mutt_mem_calloc(1, sizeof(struct Context));
77 
78  ctx->notify = notify_new();
80  ctx->mailbox = m;
81  ctx->threads = mutt_thread_ctx_init(m);
82 
83  return ctx;
84 }
The "current" mailbox.
Definition: context.h:38
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
struct ThreadsContext * threads
Threads context.
Definition: context.h:43
Container for Accounts, Notifications.
Definition: neomutt.h:36
struct Mailbox * mailbox
Definition: context.h:50
struct Notify * notify
Notifications handler.
Definition: context.h:51
struct Notify * notify_new(void)
Create a new notifications handler.
Definition: notify.c:49
struct ThreadsContext * mutt_thread_ctx_init(struct Mailbox *m)
Initialize a threading context.
Definition: mutt_thread.c:288
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_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 110 of file context.c.

111 {
112  if (!ctx || !ctx->mailbox)
113  return;
114 
115  struct Mailbox *m = ctx->mailbox;
116 
118  mutt_hash_free(&m->id_hash);
119 
120  /* reset counters */
121  m->msg_unread = 0;
122  m->msg_flagged = 0;
123  m->msg_new = 0;
124  m->msg_deleted = 0;
125  m->msg_tagged = 0;
126  m->vcount = 0;
127  m->changed = false;
128 
130 
131  struct Email *e = NULL;
132  for (int msgno = 0; msgno < m->msg_count; msgno++)
133  {
134  e = m->emails[msgno];
135  if (!e)
136  continue;
137 
138  if (WithCrypto)
139  {
140  /* NOTE: this _must_ be done before the check for mailcap! */
141  e->security = crypt_query(e->body);
142  }
143 
144  if (ctx_has_limit(ctx))
145  {
146  e->vnum = -1;
147  }
148  else
149  {
150  m->v2r[m->vcount] = msgno;
151  e->vnum = m->vcount++;
152  }
153  e->msgno = msgno;
154 
155  if (e->env->supersedes)
156  {
157  struct Email *e2 = NULL;
158 
159  if (!m->id_hash)
160  m->id_hash = mutt_make_id_hash(m);
161 
162  e2 = mutt_hash_find(m->id_hash, e->env->supersedes);
163  if (e2)
164  {
165  e2->superseded = true;
166  if (C_Score)
167  mutt_score_message(ctx->mailbox, e2, true);
168  }
169  }
170 
171  /* add this message to the hash tables */
172  if (m->id_hash && e->env->message_id)
174  if (m->subj_hash && e->env->real_subj)
176  mutt_label_hash_add(m, e);
177 
178  if (C_Score)
179  mutt_score_message(ctx->mailbox, e, false);
180 
181  if (e->changed)
182  m->changed = true;
183  if (e->flagged)
184  m->msg_flagged++;
185  if (e->deleted)
186  m->msg_deleted++;
187  if (e->tagged)
188  m->msg_tagged++;
189  if (!e->read)
190  {
191  m->msg_unread++;
192  if (!e->old)
193  m->msg_new++;
194  }
195  }
196 
197  /* rethread from scratch */
198  mutt_sort_headers(ctx->mailbox, ctx->threads, true, &ctx->vsize);
199 }
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:123
The envelope/body of an email.
Definition: email.h:37
struct Body * body
List of MIME parts.
Definition: email.h:91
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
void mutt_sort_headers(struct Mailbox *m, struct ThreadsContext *threads, bool init, off_t *vsize)
Sort emails by their headers.
Definition: sort.c:366
struct HashTable * mutt_make_id_hash(struct Mailbox *m)
Create a Hash Table for message-ids.
Definition: mutt_thread.c:1521
struct ThreadsContext * threads
Threads context.
Definition: context.h:43
WHERE bool C_Score
Config: Use message scoring.
Definition: mutt_globals.h:158
void mutt_score_message(struct Mailbox *m, struct Email *e, bool upd_mbox)
Apply scoring to an email.
Definition: score.c:173
bool ctx_has_limit(const struct Context *ctx)
Is a limit active?
Definition: context.c:422
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:377
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:90
bool superseded
Got superseded?
Definition: email.h:53
void mutt_clear_threads(struct ThreadsContext *tctx)
Clear the threading of message in a mailbox.
Definition: mutt_thread.c:637
struct HashTable * subj_hash
Hash Table by subject.
Definition: mailbox.h:128
off_t vsize
Size (in bytes) of the messages shown.
Definition: context.h:40
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:88
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib...
Definition: email.h:39
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
SecurityFlags crypt_query(struct Body *m)
Check out the type of encryption used.
Definition: crypt.c:685
int msgno
Number displayed to the user.
Definition: email.h:87
+ 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 206 of file context.c.

207 {
208  if (!ctx || !ctx->mailbox)
209  return;
210 
211  struct Mailbox *m = ctx->mailbox;
212 
213  int i, j, padding;
214 
215  /* update memory to reflect the new state of the mailbox */
216  m->vcount = 0;
217  ctx->vsize = 0;
218  m->msg_tagged = 0;
219  m->msg_deleted = 0;
220  m->msg_new = 0;
221  m->msg_unread = 0;
222  m->changed = false;
223  m->msg_flagged = 0;
224  padding = mx_msg_padding_size(m);
225  for (i = 0, j = 0; i < m->msg_count; i++)
226  {
227  if (!m->emails[i])
228  break;
229  if (!m->emails[i]->quasi_deleted &&
230  ((committing && (!m->emails[i]->deleted || ((m->type == MUTT_MAILDIR) && C_MaildirTrash))) ||
231  (!committing && m->emails[i]->active)))
232  {
233  if (i != j)
234  {
235  m->emails[j] = m->emails[i];
236  m->emails[i] = NULL;
237  }
238  m->emails[j]->msgno = j;
239  if (m->emails[j]->vnum != -1)
240  {
241  m->v2r[m->vcount] = j;
242  m->emails[j]->vnum = m->vcount++;
243  struct Body *b = m->emails[j]->body;
244  ctx->vsize += b->length + b->offset - b->hdr_offset + padding;
245  }
246 
247  if (committing)
248  {
249  m->emails[j]->changed = false;
250  m->emails[j]->env->changed = false;
251  }
252  else if (m->emails[j]->changed)
253  m->changed = true;
254 
255  if (!committing || ((m->type == MUTT_MAILDIR) && C_MaildirTrash))
256  {
257  if (m->emails[j]->deleted)
258  m->msg_deleted++;
259  }
260 
261  if (m->emails[j]->tagged)
262  m->msg_tagged++;
263  if (m->emails[j]->flagged)
264  m->msg_flagged++;
265  if (!m->emails[j]->read)
266  {
267  m->msg_unread++;
268  if (!m->emails[j]->old)
269  m->msg_new++;
270  }
271 
272  j++;
273  }
274  else
275  {
276  if ((m->type == MUTT_NOTMUCH) || (m->type == MUTT_MH) ||
277  (m->type == MUTT_MAILDIR) || (m->type == MUTT_IMAP))
278  {
279  mailbox_size_sub(m, m->emails[i]);
280  }
281  /* remove message from the hash tables */
282  if (m->subj_hash && m->emails[i]->env->real_subj)
283  mutt_hash_delete(m->subj_hash, m->emails[i]->env->real_subj, m->emails[i]);
284  if (m->id_hash && m->emails[i]->env->message_id)
285  mutt_hash_delete(m->id_hash, m->emails[i]->env->message_id, m->emails[i]);
286  mutt_label_hash_remove(m, m->emails[i]);
287 
288 #ifdef USE_IMAP
289  if (m->type == MUTT_IMAP)
291 #endif
292 
293  email_free(&m->emails[i]);
294  }
295  }
296  m->msg_count = j;
297 }
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
struct Body * body
List of MIME parts.
Definition: email.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
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:390
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:90
void imap_notify_delete_email(struct Mailbox *m, struct Email *e)
Inform IMAP that an Email has been deleted.
Definition: imap.c:629
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
Size (in bytes) of the messages shown.
Definition: context.h:40
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:88
&#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:39
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:1569
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:43
&#39;IMAP&#39; Mailbox type
Definition: mailbox.h:53
int msgno
Number displayed to the user.
Definition: email.h:87
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ctx_has_limit()

bool ctx_has_limit ( const struct Context ctx)

Is a limit active?

Parameters
ctxContext
Return values
trueA limit is active
falseNo limit is active

Definition at line 422 of file context.c.

423 {
424  return ctx && ctx->pattern;
425 }
char * pattern
Limit pattern string.
Definition: context.h:41
+ 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 339 of file context.c.

340 {
341  return e->visible && e->tagged;
342 }
bool tagged
Email is tagged.
Definition: email.h:44
bool visible
Is this message part of the view?
Definition: email.h:74
+ 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 401 of file context.c.

402 {
403  if (!m || !m->emails || !m->v2r)
404  return NULL;
405 
406  if ((vnum < 0) || (vnum >= m->vcount))
407  return NULL;
408 
409  int inum = m->v2r[vnum];
410  if ((inum < 0) || (inum >= m->msg_count))
411  return NULL;
412 
413  return m->emails[inum];
414 }
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:

◆ 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 353 of file context.c.

354 {
355  int count = 0;
356 
357  if (use_tagged)
358  {
359  if (!ctx || !ctx->mailbox || !ctx->mailbox->emails)
360  return -1;
361 
362  struct Mailbox *m = ctx->mailbox;
363  for (size_t i = 0; i < m->msg_count; i++)
364  {
365  e = m->emails[i];
366  if (!e)
367  break;
368  if (!message_is_tagged(ctx, e))
369  continue;
370 
371  struct EmailNode *en = mutt_mem_calloc(1, sizeof(*en));
372  en->email = e;
373  STAILQ_INSERT_TAIL(el, en, entries);
374  count++;
375  }
376  }
377  else
378  {
379  if (!e)
380  return -1;
381 
382  struct EmailNode *en = mutt_mem_calloc(1, sizeof(*en));
383  en->email = e;
384  STAILQ_INSERT_TAIL(el, en, entries);
385  count = 1;
386  }
387 
388  return count;
389 }
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:339
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:127
List of Emails.
Definition: email.h:125
+ Here is the call graph for this function:
+ Here is the caller graph for this function: