NeoMutt  2022-04-29-178-g3b62e6
Teaching an old dog new tricks
DOXYGEN
email.c File Reference

Dump an Email. More...

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "email/lib.h"
#include "lib.h"
#include "attach/lib.h"
#include "ncrypt/lib.h"
+ Include dependency graph for email.c:

Go to the source code of this file.

Macros

#define ADD_FLAG(F)   add_flag(&buf, (env->changed & F), #F)
 
#define ADDR_LIST(AL)   dump_addr_list(arr, sizeof(arr), &env->AL, #AL)
 
#define OPT_STRING(S)
 
#define ADD_FLAG(F)   add_flag(&buf, e->F, #F)
 
#define ADD_FLAG(F)   add_flag(&buf, (e->security & F), #F)
 
#define ADD_FLAG(F)   add_flag(&buf, body->F, #F)
 
#define OPT_STRING(S)
 
#define ADD_FLAG(F)   add_flag(&buf, att->F, #F)
 

Functions

void dump_addr_list (char *buf, size_t buflen, const struct AddressList *al, const char *name)
 
void dump_list_head (const struct ListHead *list, const char *name)
 
void dump_envelope (const struct Envelope *env)
 
void dump_email (const struct Email *e)
 
void dump_param_list (const struct ParameterList *pl)
 
void dump_body (const struct Body *body)
 
void dump_attach (const struct AttachPtr *att)
 
char body_name (const struct Body *b)
 
void dump_body_next (struct Buffer *buf, const struct Body *b)
 
void dump_body_one_line (const struct Body *b)
 

Detailed Description

Dump an Email.

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

Macro Definition Documentation

◆ ADD_FLAG [1/5]

#define ADD_FLAG (   F)    add_flag(&buf, (env->changed & F), #F)

◆ ADDR_LIST

#define ADDR_LIST (   AL)    dump_addr_list(arr, sizeof(arr), &env->AL, #AL)

◆ OPT_STRING [1/2]

#define OPT_STRING (   S)
Value:
if (env->S) \
mutt_debug(LL_DEBUG1, "\t%s: %s\n", #S, env->S)
@ LL_DEBUG1
Log at debug level 1.
Definition: logging.h:40

◆ ADD_FLAG [2/5]

#define ADD_FLAG (   F)    add_flag(&buf, e->F, #F)

◆ ADD_FLAG [3/5]

#define ADD_FLAG (   F)    add_flag(&buf, (e->security & F), #F)

◆ ADD_FLAG [4/5]

#define ADD_FLAG (   F)    add_flag(&buf, body->F, #F)

◆ OPT_STRING [2/2]

#define OPT_STRING (   S)
Value:
if (body->S) \
mutt_debug(LL_DEBUG1, "\t%s: %s\n", #S, body->S)

◆ ADD_FLAG [5/5]

#define ADD_FLAG (   F)    add_flag(&buf, att->F, #F)

Function Documentation

◆ dump_addr_list()

void dump_addr_list ( char *  buf,
size_t  buflen,
const struct AddressList *  al,
const char *  name 
)

Definition at line 40 of file email.c.

41{
42 if (!buf || !al)
43 return;
44 if (TAILQ_EMPTY(al))
45 return;
46
47 buf[0] = '\0';
48 mutt_addrlist_write(al, buf, buflen, true);
49 mutt_debug(LL_DEBUG1, "\t%s: %s\n", name, buf);
50}
size_t mutt_addrlist_write(const struct AddressList *al, char *buf, size_t buflen, bool display)
Write an Address to a buffer.
Definition: address.c:1150
#define mutt_debug(LEVEL,...)
Definition: logging.h:84
#define TAILQ_EMPTY(head)
Definition: queue.h:721
+ Here is the call graph for this function:

◆ dump_list_head()

void dump_list_head ( const struct ListHead *  list,
const char *  name 
)

Definition at line 52 of file email.c.

53{
54 if (!list || !name)
55 return;
56 if (STAILQ_EMPTY(list))
57 return;
58
59 struct Buffer buf = mutt_buffer_make(256);
60
61 struct ListNode *np = NULL;
62 STAILQ_FOREACH(np, list, entries)
63 {
64 if (!mutt_buffer_is_empty(&buf))
65 mutt_buffer_addch(&buf, ',');
66 mutt_buffer_addstr(&buf, np->data);
67 }
68
69 mutt_debug(LL_DEBUG1, "\t%s: %s\n", name, mutt_buffer_string(&buf));
71}
struct Buffer mutt_buffer_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:63
bool mutt_buffer_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:250
void mutt_buffer_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:292
size_t mutt_buffer_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition: buffer.c:238
size_t mutt_buffer_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:223
static const char * mutt_buffer_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:77
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
#define STAILQ_EMPTY(head)
Definition: queue.h:348
String manipulation buffer.
Definition: buffer.h:34
A List node for strings.
Definition: list.h:35
char * data
String.
Definition: list.h:36
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dump_envelope()

void dump_envelope ( const struct Envelope env)

Definition at line 73 of file email.c.

74{
75 struct Buffer buf = mutt_buffer_make(256);
76 char arr[1024];
77
78 mutt_debug(LL_DEBUG1, "Envelope\n");
79
80#define ADD_FLAG(F) add_flag(&buf, (env->changed & F), #F)
85#undef ADD_FLAG
86 mutt_debug(LL_DEBUG1, "\tchanged: %s\n",
87 mutt_buffer_is_empty(&buf) ? "[NONE]" : mutt_buffer_string(&buf));
88
89#define ADDR_LIST(AL) dump_addr_list(arr, sizeof(arr), &env->AL, #AL)
90 ADDR_LIST(return_path);
91 ADDR_LIST(from);
92 ADDR_LIST(to);
93 ADDR_LIST(cc);
94 ADDR_LIST(bcc);
95 ADDR_LIST(sender);
96 ADDR_LIST(reply_to);
97 ADDR_LIST(mail_followup_to);
98 ADDR_LIST(x_original_to);
99#undef ADDR_LIST
100
101#define OPT_STRING(S) \
102 if (env->S) \
103 mutt_debug(LL_DEBUG1, "\t%s: %s\n", #S, env->S)
104 OPT_STRING(list_post);
105 OPT_STRING(list_subscribe);
106 OPT_STRING(list_unsubscribe);
107 OPT_STRING(subject);
108 OPT_STRING(real_subj);
109 OPT_STRING(disp_subj);
110 OPT_STRING(message_id);
111 OPT_STRING(supersedes);
112 OPT_STRING(date);
113 OPT_STRING(x_label);
114 OPT_STRING(organization);
115#ifdef USE_NNTP
116 OPT_STRING(newsgroups);
117 OPT_STRING(xref);
118 OPT_STRING(followup_to);
119 OPT_STRING(x_comment_to);
120#endif
121#undef OPT_STRING
122
123 dump_list_head(&env->references, "references");
124 dump_list_head(&env->in_reply_to, "in_reply_to");
125 dump_list_head(&env->userhdrs, "userhdrs");
126
127 if (!mutt_buffer_is_empty(&env->spam))
128 mutt_debug(LL_DEBUG1, "\tspam: %s\n", mutt_buffer_string(&env->spam));
129
130#ifdef USE_AUTOCRYPT
131 if (env->autocrypt)
132 mutt_debug(LL_DEBUG1, "\tautocrypt: %p\n", (void *) env->autocrypt);
133 if (env->autocrypt_gossip)
134 mutt_debug(LL_DEBUG1, "\tautocrypt_gossip: %p\n", (void *) env->autocrypt_gossip);
135#endif
136
138}
void dump_list_head(const struct ListHead *list, const char *name)
Definition: email.c:52
#define OPT_STRING(S)
#define ADDR_LIST(AL)
#define ADD_FLAG(F)
#define MUTT_ENV_CHANGED_SUBJECT
Protected header update.
Definition: envelope.h:37
#define MUTT_ENV_CHANGED_XLABEL
X-Label edited.
Definition: envelope.h:36
#define MUTT_ENV_CHANGED_IRT
In-Reply-To changed to link/break threads.
Definition: envelope.h:34
#define MUTT_ENV_CHANGED_REFS
References changed to break thread.
Definition: envelope.h:35
struct ListHead userhdrs
user defined headers
Definition: envelope.h:87
struct AutocryptHeader * autocrypt_gossip
Autocrypt Gossip header.
Definition: envelope.h:90
struct ListHead references
message references (in reverse order)
Definition: envelope.h:85
struct AutocryptHeader * autocrypt
Autocrypt header.
Definition: envelope.h:89
struct Buffer spam
Spam header.
Definition: envelope.h:84
struct ListHead in_reply_to
in-reply-to header content
Definition: envelope.h:86
+ Here is the call graph for this function:

◆ dump_email()

void dump_email ( const struct Email e)

Definition at line 140 of file email.c.

141{
142 if (!e)
143 return;
144
145 struct Buffer buf = mutt_buffer_make(256);
146 char arr[256];
147
148 mutt_debug(LL_DEBUG1, "Email\n");
149 mutt_debug(LL_DEBUG1, "\tpath: %s\n", e->path);
150
151#define ADD_FLAG(F) add_flag(&buf, e->F, #F)
152 ADD_FLAG(active);
153 ADD_FLAG(attach_del);
154 ADD_FLAG(attach_valid);
155 ADD_FLAG(changed);
156 ADD_FLAG(collapsed);
157 ADD_FLAG(deleted);
158 ADD_FLAG(display_subject);
159 ADD_FLAG(expired);
160 ADD_FLAG(flagged);
161 ADD_FLAG(matched);
162 ADD_FLAG(mime);
163 ADD_FLAG(old);
164 ADD_FLAG(purge);
165 ADD_FLAG(quasi_deleted);
166 ADD_FLAG(read);
167 ADD_FLAG(recip_valid);
168 ADD_FLAG(replied);
169 ADD_FLAG(searched);
170 ADD_FLAG(subject_changed);
171 ADD_FLAG(superseded);
172 ADD_FLAG(tagged);
173 ADD_FLAG(threaded);
174 ADD_FLAG(trash);
175 ADD_FLAG(visible);
176#undef ADD_FLAG
177 mutt_debug(LL_DEBUG1, "\tFlags: %s\n",
178 mutt_buffer_is_empty(&buf) ? "[NONE]" : mutt_buffer_string(&buf));
179
180#define ADD_FLAG(F) add_flag(&buf, (e->security & F), #F)
181 mutt_buffer_reset(&buf);
196#undef ADD_FLAG
197 mutt_debug(LL_DEBUG1, "\tSecurity: %s\n",
198 mutt_buffer_is_empty(&buf) ? "[NONE]" : mutt_buffer_string(&buf));
199
200 mutt_date_make_tls(arr, sizeof(arr), e->date_sent);
201 mutt_debug(LL_DEBUG1, "\tSent: %s (%c%02u%02u)\n", arr,
202 e->zoccident ? '-' : '+', e->zhours, e->zminutes);
203
204 mutt_date_make_tls(arr, sizeof(arr), e->received);
205 mutt_debug(LL_DEBUG1, "\tRecv: %s\n", arr);
206
208
209 mutt_debug(LL_DEBUG1, "\tnum_hidden: %ld\n", e->num_hidden);
210 mutt_debug(LL_DEBUG1, "\trecipient: %d\n", e->recipient);
211 mutt_debug(LL_DEBUG1, "\toffset: %ld\n", e->offset);
212 mutt_debug(LL_DEBUG1, "\tlines: %d\n", e->lines);
213 mutt_debug(LL_DEBUG1, "\tindex: %d\n", e->index);
214 mutt_debug(LL_DEBUG1, "\tmsgno: %d\n", e->msgno);
215 mutt_debug(LL_DEBUG1, "\tvnum: %d\n", e->vnum);
216 mutt_debug(LL_DEBUG1, "\tscore: %d\n", e->score);
217 mutt_debug(LL_DEBUG1, "\tattach_total: %d\n", e->attach_total);
218 // if (e->maildir_flags)
219 // mutt_debug(LL_DEBUG1, "\tmaildir_flags: %s\n", e->maildir_flags);
220
221 // struct MuttThread *thread
222 // struct Envelope *env
223 // struct Body *content
224 // struct TagList tags
225
226 // void *edata
228}
void mutt_buffer_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:81
int mutt_date_make_tls(char *buf, size_t buflen, time_t timestamp)
Format date in TLS certificate verification style.
Definition: date.c:583
#define SEC_INLINE
Email has an inline signature.
Definition: lib.h:85
#define SEC_AUTOCRYPT
(Autocrypt) Message will be, or was Autocrypt encrypt+signed
Definition: lib.h:87
#define SEC_OPPENCRYPT
Opportunistic encrypt mode.
Definition: lib.h:86
#define PGP_TRADITIONAL_CHECKED
Email has a traditional (inline) signature.
Definition: lib.h:92
#define SEC_GOODSIGN
Email has a valid signature.
Definition: lib.h:80
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:90
#define SEC_SIGNOPAQUE
Email has an opaque signature (encrypted)
Definition: lib.h:83
#define SEC_BADSIGN
Email has a bad signature.
Definition: lib.h:81
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:91
#define SEC_PARTSIGN
Not all parts of the email is signed.
Definition: lib.h:82
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:78
#define SEC_AUTOCRYPT_OVERRIDE
(Autocrypt) Indicates manual set/unset of encryption
Definition: lib.h:88
#define SEC_SIGN
Email is signed.
Definition: lib.h:79
#define SEC_KEYBLOCK
Email has a key attached.
Definition: lib.h:84
unsigned int zminutes
Minutes away from UTC.
Definition: email.h:55
int lines
How many lines in the body of this message?
Definition: email.h:60
size_t num_hidden
Number of hidden messages in this view (only valid when collapsed is set)
Definition: email.h:122
bool zoccident
True, if west of UTC, False if east.
Definition: email.h:56
LOFF_T offset
Where in the stream does this message begin?
Definition: email.h:69
short attach_total
Number of qualifying attachments in message, if attach_valid.
Definition: email.h:115
unsigned int zhours
Hours away from UTC.
Definition: email.h:54
time_t date_sent
Time when the message was sent (UTC)
Definition: email.h:58
int vnum
Virtual message number.
Definition: email.h:114
int score
Message score.
Definition: email.h:113
int msgno
Number displayed to the user.
Definition: email.h:111
char * path
Path of Email (for local Mailboxes)
Definition: email.h:68
int index
The absolute (unsorted) message number.
Definition: email.h:110
short recipient
User_is_recipient()'s return value, cached.
Definition: email.h:116
time_t received
Time when the message was placed in the mailbox.
Definition: email.h:59
+ Here is the call graph for this function:

◆ dump_param_list()

void dump_param_list ( const struct ParameterList *  pl)

Definition at line 230 of file email.c.

231{
232 if (!pl || TAILQ_EMPTY(pl))
233 return;
234
235 mutt_debug(LL_DEBUG1, "\tparameters\n");
236 struct Parameter *np = NULL;
237 TAILQ_FOREACH(np, pl, entries)
238 {
239 mutt_debug(LL_DEBUG1, "\t\t%s = %s\n", NONULL(np->attribute), NONULL(np->value));
240 }
241}
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725
#define NONULL(x)
Definition: string2.h:37
Attribute associated with a MIME part.
Definition: parameter.h:33
char * attribute
Parameter name.
Definition: parameter.h:34
char * value
Parameter value.
Definition: parameter.h:35
+ Here is the caller graph for this function:

◆ dump_body()

void dump_body ( const struct Body body)

Definition at line 243 of file email.c.

244{
245 if (!body)
246 return;
247
248 struct Buffer buf = mutt_buffer_make(256);
249 char arr[256];
250
251 mutt_debug(LL_DEBUG1, "Body\n");
252
253#define ADD_FLAG(F) add_flag(&buf, body->F, #F)
254 ADD_FLAG(attach_qualifies);
255 ADD_FLAG(badsig);
256 ADD_FLAG(deleted);
257 ADD_FLAG(force_charset);
258 ADD_FLAG(goodsig);
259#ifdef USE_AUTOCRYPT
260 ADD_FLAG(is_autocrypt);
261#endif
262 ADD_FLAG(noconv);
263 ADD_FLAG(tagged);
264 ADD_FLAG(unlink);
265 ADD_FLAG(use_disp);
266 ADD_FLAG(warnsig);
267#undef ADD_FLAG
268 mutt_debug(LL_DEBUG1, "\tFlags: %s\n",
269 mutt_buffer_is_empty(&buf) ? "[NONE]" : mutt_buffer_string(&buf));
270
271#define OPT_STRING(S) \
272 if (body->S) \
273 mutt_debug(LL_DEBUG1, "\t%s: %s\n", #S, body->S)
274 OPT_STRING(charset);
275 OPT_STRING(description);
276 OPT_STRING(d_filename);
277 OPT_STRING(filename);
278 OPT_STRING(form_name);
279 OPT_STRING(language);
280 OPT_STRING(subtype);
281 OPT_STRING(xtype);
282#undef OPT_STRING
283
284 mutt_debug(LL_DEBUG1, "\thdr_offset: %ld\n", body->hdr_offset);
285 mutt_debug(LL_DEBUG1, "\toffset: %ld\n", body->offset);
286 mutt_debug(LL_DEBUG1, "\tlength: %ld\n", body->length);
287 mutt_debug(LL_DEBUG1, "\tattach_count: %d\n", body->attach_count);
288
289 mutt_debug(LL_DEBUG1, "\tcontent type: %s\n", get_content_type(body->type));
290 mutt_debug(LL_DEBUG1, "\tcontent encoding: %s\n", get_content_encoding(body->encoding));
291 mutt_debug(LL_DEBUG1, "\tcontent disposition: %s\n",
293
294 if (body->stamp != 0)
295 {
296 mutt_date_make_tls(arr, sizeof(arr), body->stamp);
297 mutt_debug(LL_DEBUG1, "\tstamp: %s\n", arr);
298 }
299
301
302 // struct Content *content; ///< Detailed info about the content of the attachment.
303 // struct Body *next; ///< next attachment in the list
304 // struct Body *parts; ///< parts of a multipart or message/rfc822
305 // struct Email *email; ///< header information for message/rfc822
306 // struct AttachPtr *aptr; ///< Menu information, used in recvattach.c
307 // struct Envelope *mime_headers; ///< Memory hole protected headers
308
309 if (body->next)
310 {
311 mutt_debug(LL_DEBUG1, "-NEXT-------------------------\n");
312 dump_body(body->next);
313 }
314 if (body->parts)
315 {
316 mutt_debug(LL_DEBUG1, "-PARTS-------------------------\n");
317 dump_body(body->parts);
318 }
319 if (body->next || body->parts)
320 mutt_debug(LL_DEBUG1, "--------------------------\n");
322}
void dump_param_list(const struct ParameterList *pl)
Definition: email.c:230
void dump_body(const struct Body *body)
Definition: email.c:243
const char * get_content_type(enum ContentType type)
Definition: graphviz.c:81
const char * get_content_encoding(enum ContentEncoding enc)
Definition: graphviz.c:110
const char * get_content_disposition(enum ContentDisposition disp)
Definition: graphviz.c:133
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:72
LOFF_T offset
offset where the actual data begins
Definition: body.h:52
signed short attach_count
Number of attachments.
Definition: body.h:90
time_t stamp
Time stamp of last encoding update.
Definition: body.h:76
LOFF_T length
length (in bytes) of attachment
Definition: body.h:53
struct ParameterList parameter
Parameters of the content-type.
Definition: body.h:62
unsigned int disposition
content-disposition, ContentDisposition
Definition: body.h:42
struct Body * next
next attachment in the list
Definition: body.h:71
unsigned int encoding
content-transfer-encoding, ContentEncoding
Definition: body.h:41
long hdr_offset
Offset in stream where the headers begin.
Definition: body.h:80
unsigned int type
content-type primary type, ContentType
Definition: body.h:40
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dump_attach()

void dump_attach ( const struct AttachPtr att)

Definition at line 324 of file email.c.

325{
326 if (!att)
327 return;
328
329 struct Buffer buf = mutt_buffer_make(256);
330
331 mutt_debug(LL_DEBUG1, "AttachPtr\n");
332
333#define ADD_FLAG(F) add_flag(&buf, att->F, #F)
334 ADD_FLAG(unowned);
335 ADD_FLAG(decrypted);
336 ADD_FLAG(collapsed);
337#undef ADD_FLAG
338
339 if (att->fp)
340 mutt_debug(LL_DEBUG1, "\tfp: %p (%d)\n", att->fp, fileno(att->fp));
341 mutt_debug(LL_DEBUG1, "\tparent_type: %d\n", att->parent_type);
342 mutt_debug(LL_DEBUG1, "\tlevel: %d\n", att->level);
343 mutt_debug(LL_DEBUG1, "\tnum: %d\n", att->num);
344
345 // struct Body *content; ///< Attachment
347}
int num
Attachment index number.
Definition: attach.h:41
int level
Nesting depth of attachment.
Definition: attach.h:40
FILE * fp
Used in the recvattach menu.
Definition: attach.h:37
int parent_type
Type of parent attachment, e.g. TYPE_MULTIPART.
Definition: attach.h:38
+ Here is the call graph for this function:

◆ body_name()

char body_name ( const struct Body b)

Definition at line 349 of file email.c.

350{
351 if (!b)
352 return '!';
353
354 if (b->type == TYPE_MULTIPART)
355 return '&';
356
357 if (b->description)
358 return b->description[0];
359
360 if (b->filename)
361 {
362 const char *base = basename(b->filename);
363 if (mutt_str_startswith(base, "neomutt-"))
364 return '0';
365
366 return base[0];
367 }
368
369 return '!';
370}
@ TYPE_MULTIPART
Type: 'multipart/*'.
Definition: mime.h:37
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
Definition: string.c:227
char * description
content-description
Definition: body.h:55
char * filename
When sending a message, this is the file to which this structure refers.
Definition: body.h:58
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dump_body_next()

void dump_body_next ( struct Buffer buf,
const struct Body b 
)

Definition at line 372 of file email.c.

373{
374 if (!b)
375 return;
376
377 mutt_buffer_addstr(buf, "<");
378 for (; b; b = b->next)
379 {
380 mutt_buffer_add_printf(buf, "%c", body_name(b));
381 dump_body_next(buf, b->parts);
382 if (b->next)
383 mutt_buffer_addch(buf, ',');
384 }
385 mutt_buffer_addstr(buf, ">");
386}
int mutt_buffer_add_printf(struct Buffer *buf, const char *fmt,...)
Format a string appending a Buffer.
Definition: buffer.c:201
void dump_body_next(struct Buffer *buf, const struct Body *b)
Definition: email.c:372
char body_name(const struct Body *b)
Definition: email.c:349
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dump_body_one_line()

void dump_body_one_line ( const struct Body b)

Definition at line 388 of file email.c.

389{
390 if (!b)
391 return;
392
393 struct Buffer *buf = mutt_buffer_pool_get();
394 mutt_buffer_addstr(buf, "Body layout: ");
395 dump_body_next(buf, b);
396
399}
#define mutt_message(...)
Definition: logging.h:86
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
+ Here is the call graph for this function: