NeoMutt  2021-02-05-666-ge300cd
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 "mutt/lib.h"
#include "address/lib.h"
#include "email/lib.h"
#include "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)
 

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)
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)
Log at debug level 1.
Definition: logging.h:40

◆ 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 38 of file email.c.

39 {
40  if (!buf || !al)
41  return;
42  if (TAILQ_EMPTY(al))
43  return;
44 
45  buf[0] = '\0';
46  mutt_addrlist_write(al, buf, buflen, true);
47  mutt_debug(LL_DEBUG1, "\t%s: %s\n", name, buf);
48 }
#define mutt_debug(LEVEL,...)
Definition: logging.h:85
Log at debug level 1.
Definition: logging.h:40
#define TAILQ_EMPTY(head)
Definition: queue.h:721
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
+ 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 50 of file email.c.

51 {
52  if (!list || !name)
53  return;
54  if (STAILQ_EMPTY(list))
55  return;
56 
57  struct Buffer buf = mutt_buffer_make(256);
58 
59  struct ListNode *np = NULL;
60  STAILQ_FOREACH(np, list, entries)
61  {
62  if (!mutt_buffer_is_empty(&buf))
63  mutt_buffer_addch(&buf, ',');
64  mutt_buffer_addstr(&buf, np->data);
65  }
66 
67  mutt_debug(LL_DEBUG1, "\t%s: %s\n", name, mutt_buffer_string(&buf));
68  mutt_buffer_dealloc(&buf);
69 }
struct Buffer mutt_buffer_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:61
String manipulation buffer.
Definition: buffer.h:33
static const char * mutt_buffer_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:77
void mutt_buffer_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:294
size_t mutt_buffer_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:225
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
size_t mutt_buffer_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition: buffer.c:240
#define mutt_debug(LEVEL,...)
Definition: logging.h:85
char * data
String.
Definition: list.h:36
Log at debug level 1.
Definition: logging.h:40
#define STAILQ_EMPTY(head)
Definition: queue.h:348
A List node for strings.
Definition: list.h:34
bool mutt_buffer_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:252
+ 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 71 of file email.c.

72 {
73  struct Buffer buf = mutt_buffer_make(256);
74  char arr[1024];
75 
76  mutt_debug(LL_DEBUG1, "Envelope\n");
77 
78 #define ADD_FLAG(F) add_flag(&buf, (env->changed & F), #F)
83 #undef ADD_FLAG
84  mutt_debug(LL_DEBUG1, "\tchanged: %s\n",
85  mutt_buffer_is_empty(&buf) ? "[NONE]" : mutt_buffer_string(&buf));
86 
87 #define ADDR_LIST(AL) dump_addr_list(arr, sizeof(arr), &env->AL, #AL)
88  ADDR_LIST(return_path);
89  ADDR_LIST(from);
90  ADDR_LIST(to);
91  ADDR_LIST(cc);
92  ADDR_LIST(bcc);
93  ADDR_LIST(sender);
94  ADDR_LIST(reply_to);
95  ADDR_LIST(mail_followup_to);
96  ADDR_LIST(x_original_to);
97 #undef ADDR_LIST
98 
99 #define OPT_STRING(S) \
100  if (env->S) \
101  mutt_debug(LL_DEBUG1, "\t%s: %s\n", #S, env->S)
102  OPT_STRING(list_post);
103  OPT_STRING(subject);
104  OPT_STRING(real_subj);
105  OPT_STRING(disp_subj);
106  OPT_STRING(message_id);
107  OPT_STRING(supersedes);
108  OPT_STRING(date);
109  OPT_STRING(x_label);
110  OPT_STRING(organization);
111 #ifdef USE_NNTP
112  OPT_STRING(newsgroups);
113  OPT_STRING(xref);
114  OPT_STRING(followup_to);
115  OPT_STRING(x_comment_to);
116 #endif
117 #undef OPT_STRING
118 
119  dump_list_head(&env->references, "references");
120  dump_list_head(&env->in_reply_to, "in_reply_to");
121  dump_list_head(&env->userhdrs, "userhdrs");
122 
123  if (!mutt_buffer_is_empty(&env->spam))
124  mutt_debug(LL_DEBUG1, "\tspam: %s\n", mutt_buffer_string(&env->spam));
125 
126 #ifdef USE_AUTOCRYPT
127  if (env->autocrypt)
128  mutt_debug(LL_DEBUG1, "\tautocrypt: %p\n", (void *) env->autocrypt);
129  if (env->autocrypt_gossip)
130  mutt_debug(LL_DEBUG1, "\tautocrypt_gossip: %p\n", (void *) env->autocrypt_gossip);
131 #endif
132 
133  mutt_buffer_dealloc(&buf);
134 }
struct AutocryptHeader * autocrypt_gossip
Definition: envelope.h:86
struct Email * arr[10]
Definition: mailbox.c:256
struct Buffer mutt_buffer_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:61
String manipulation buffer.
Definition: buffer.h:33
struct ListHead userhdrs
user defined headers
Definition: envelope.h:83
#define ADD_FLAG(F)
struct AutocryptHeader * autocrypt
Definition: envelope.h:85
#define ADDR_LIST(AL)
#define MUTT_ENV_CHANGED_SUBJECT
Protected header update.
Definition: envelope.h:35
static const char * mutt_buffer_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:77
struct ListHead in_reply_to
in-reply-to header content
Definition: envelope.h:82
void mutt_buffer_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:294
void dump_list_head(const struct ListHead *list, const char *name)
Definition: email.c:50
#define MUTT_ENV_CHANGED_XLABEL
X-Label edited.
Definition: envelope.h:34
#define mutt_debug(LEVEL,...)
Definition: logging.h:85
#define OPT_STRING(S)
Log at debug level 1.
Definition: logging.h:40
#define MUTT_ENV_CHANGED_REFS
References changed to break thread.
Definition: envelope.h:33
#define MUTT_ENV_CHANGED_IRT
In-Reply-To changed to link/break threads.
Definition: envelope.h:32
struct ListHead references
message references (in reverse order)
Definition: envelope.h:81
bool mutt_buffer_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:252
struct Buffer spam
Spam header.
Definition: envelope.h:80
+ Here is the call graph for this function:

◆ dump_email()

void dump_email ( const struct Email e)

Definition at line 136 of file email.c.

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

◆ dump_param_list()

void dump_param_list ( const struct ParameterList *  pl)

Definition at line 226 of file email.c.

227 {
228  if (!pl || TAILQ_EMPTY(pl))
229  return;
230 
231  mutt_debug(LL_DEBUG1, "\tparameters\n");
232  struct Parameter *np = NULL;
233  TAILQ_FOREACH(np, pl, entries)
234  {
235  mutt_debug(LL_DEBUG1, "\t\t%s = %s\n", NONULL(np->attribute), NONULL(np->value));
236  }
237 }
char * attribute
Parameter name.
Definition: parameter.h:34
#define NONULL(x)
Definition: string2.h:37
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725
#define mutt_debug(LEVEL,...)
Definition: logging.h:85
char * value
Parameter value.
Definition: parameter.h:35
Log at debug level 1.
Definition: logging.h:40
Attribute associated with a MIME part.
Definition: parameter.h:32
#define TAILQ_EMPTY(head)
Definition: queue.h:721
+ Here is the caller graph for this function:

◆ dump_body()

void dump_body ( const struct Body body)

Definition at line 239 of file email.c.

240 {
241  if (!body)
242  return;
243 
244  struct Buffer buf = mutt_buffer_make(256);
245  char arr[256];
246 
247  mutt_debug(LL_DEBUG1, "Body\n");
248 
249 #define ADD_FLAG(F) add_flag(&buf, body->F, #F)
250  ADD_FLAG(attach_qualifies);
251  ADD_FLAG(badsig);
252  ADD_FLAG(collapsed);
253  ADD_FLAG(deleted);
254  ADD_FLAG(force_charset);
255  ADD_FLAG(goodsig);
256 #ifdef USE_AUTOCRYPT
257  ADD_FLAG(is_autocrypt);
258 #endif
259  ADD_FLAG(noconv);
260  ADD_FLAG(tagged);
261  ADD_FLAG(unlink);
262  ADD_FLAG(use_disp);
263  ADD_FLAG(warnsig);
264 #undef ADD_FLAG
265  mutt_debug(LL_DEBUG1, "\tFlags: %s\n",
266  mutt_buffer_is_empty(&buf) ? "[NONE]" : mutt_buffer_string(&buf));
267 
268 #define OPT_STRING(S) \
269  if (body->S) \
270  mutt_debug(LL_DEBUG1, "\t%s: %s\n", #S, body->S)
271  OPT_STRING(charset);
272  OPT_STRING(description);
273  OPT_STRING(d_filename);
274  OPT_STRING(filename);
275  OPT_STRING(form_name);
276  OPT_STRING(language);
277  OPT_STRING(subtype);
278  OPT_STRING(xtype);
279 #undef OPT_STRING
280 
281  mutt_debug(LL_DEBUG1, "\thdr_offset: %ld\n", body->hdr_offset);
282  mutt_debug(LL_DEBUG1, "\toffset: %ld\n", body->offset);
283  mutt_debug(LL_DEBUG1, "\tlength: %ld\n", body->length);
284  mutt_debug(LL_DEBUG1, "\tattach_count: %d\n", body->attach_count);
285 
286  mutt_debug(LL_DEBUG1, "\tcontent type: %s\n", get_content_type(body->type));
287  mutt_debug(LL_DEBUG1, "\tcontent encoding: %s\n", get_content_encoding(body->encoding));
288  mutt_debug(LL_DEBUG1, "\tcontent disposition: %s\n",
290 
291  if (body->stamp != 0)
292  {
293  mutt_date_make_tls(arr, sizeof(arr), body->stamp);
294  mutt_debug(LL_DEBUG1, "\tstamp: %s\n", arr);
295  }
296 
297  dump_param_list(&body->parameter);
298 
299  // struct Content *content; ///< Detailed info about the content of the attachment.
300  // struct Body *next; ///< next attachment in the list
301  // struct Body *parts; ///< parts of a multipart or message/rfc822
302  // struct Email *email; ///< header information for message/rfc822
303  // struct AttachPtr *aptr; ///< Menu information, used in recvattach.c
304  // struct Envelope *mime_headers; ///< Memory hole protected headers
305 
306  if (body->next)
307  {
308  mutt_debug(LL_DEBUG1, "-NEXT-------------------------\n");
309  dump_body(body->next);
310  }
311  if (body->parts)
312  {
313  mutt_debug(LL_DEBUG1, "-PARTS-------------------------\n");
314  dump_body(body->parts);
315  }
316  if (body->next || body->parts)
317  mutt_debug(LL_DEBUG1, "--------------------------\n");
318  mutt_buffer_dealloc(&buf);
319 }
const char * get_content_type(enum ContentType type)
Definition: graphviz.c:75
struct Email * arr[10]
Definition: mailbox.c:256
struct Buffer mutt_buffer_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:61
String manipulation buffer.
Definition: buffer.h:33
LOFF_T offset
offset where the actual data begins
Definition: body.h:44
#define ADD_FLAG(F)
struct Body * next
next attachment in the list
Definition: body.h:53
void dump_param_list(const struct ParameterList *pl)
Definition: email.c:226
unsigned int disposition
content-disposition, ContentDisposition
Definition: body.h:67
static const char * mutt_buffer_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:77
int mutt_date_make_tls(char *buf, size_t buflen, time_t timestamp)
Format date in TLS certificate verification style.
Definition: date.c:583
const char * get_content_encoding(enum ContentEncoding enc)
Definition: graphviz.c:104
void mutt_buffer_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:294
signed short attach_count
Number of attachments.
Definition: body.h:59
unsigned int encoding
content-transfer-encoding, ContentEncoding
Definition: body.h:66
const char * get_content_disposition(enum ContentDisposition disp)
Definition: graphviz.c:127
void dump_body(const struct Body *body)
Definition: email.c:239
LOFF_T length
length (in bytes) of attachment
Definition: body.h:45
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:54
#define mutt_debug(LEVEL,...)
Definition: logging.h:85
unsigned int type
content-type primary type, ContentType
Definition: body.h:65
#define OPT_STRING(S)
Log at debug level 1.
Definition: logging.h:40
time_t stamp
Time stamp of last encoding update.
Definition: body.h:61
long hdr_offset
Offset in stream where the headers begin.
Definition: body.h:42
bool mutt_buffer_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:252
struct ParameterList parameter
parameters of the content-type
Definition: body.h:39
+ 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 321 of file email.c.

322 {
323  if (!att)
324  return;
325 
326  struct Buffer buf = mutt_buffer_make(256);
327 
328  mutt_debug(LL_DEBUG1, "AttachPtr\n");
329 
330 #define ADD_FLAG(F) add_flag(&buf, att->F, #F)
331  ADD_FLAG(unowned);
332  ADD_FLAG(decrypted);
333 #undef ADD_FLAG
334 
335  if (att->fp)
336  mutt_debug(LL_DEBUG1, "\tfp: %p (%d)\n", att->fp, fileno(att->fp));
337  mutt_debug(LL_DEBUG1, "\tparent_type: %d\n", att->parent_type);
338  mutt_debug(LL_DEBUG1, "\tlevel: %d\n", att->level);
339  mutt_debug(LL_DEBUG1, "\tnum: %d\n", att->num);
340 
341  // struct Body *content; ///< Attachment
342  mutt_buffer_dealloc(&buf);
343 }
struct Buffer mutt_buffer_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:61
String manipulation buffer.
Definition: buffer.h:33
#define ADD_FLAG(F)
int parent_type
Type of parent attachment, e.g. TYPE_MULTIPART.
Definition: attach.h:38
void mutt_buffer_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:294
int num
Attachment index number.
Definition: attach.h:41
FILE * fp
Used in the recvattach menu.
Definition: attach.h:37
#define mutt_debug(LEVEL,...)
Definition: logging.h:85
Log at debug level 1.
Definition: logging.h:40
int level
Nesting depth of attachment.
Definition: attach.h:40
+ Here is the call graph for this function: