NeoMutt  2021-02-05-89-gabe350
Teaching an old dog new tricks
DOXYGEN
lib.h File Reference
#include <stddef.h>
#include <stdbool.h>
#include "email/lib.h"
+ Include dependency graph for lib.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

void show_backtrace (void)
 Log the program's call stack. More...
 
const char * win_name (const struct MuttWindow *win)
 
void add_flag (struct Buffer *buf, bool is_set, const char *name)
 
void dump_addr_list (char *buf, size_t buflen, const struct AddressList *al, const char *name)
 
void dump_attach (const struct AttachPtr *att)
 
void dump_body (const struct Body *body)
 
void dump_email (const struct Email *e)
 
void dump_envelope (const struct Envelope *env)
 
void dump_list_head (const struct ListHead *list, const char *name)
 
void dump_param_list (const struct ParameterList *pl)
 
const char * get_content_disposition (enum ContentDisposition disp)
 
const char * get_content_encoding (enum ContentEncoding enc)
 
const char * get_content_type (enum ContentType type)
 
void dump_graphviz (const char *title, struct Context *ctx)
 
void dump_graphviz_attach_ctx (struct AttachCtx *actx)
 
void dump_graphviz_email (struct Email *e)
 
int debug_notify_observer (struct NotifyCallback *nc)
 
void test_parse_set (void)
 Test the config parsing. More...
 
void debug_win_dump (void)
 

Detailed Description

Convenience wrapper for the debug headers

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

Function Documentation

◆ show_backtrace()

void show_backtrace ( void  )

Log the program's call stack.

Definition at line 39 of file backtrace.c.

40 {
41  unw_cursor_t cursor;
42  unw_context_t uc;
43  unw_word_t ip, sp;
44  char buf[256];
45 
46  printf("\n%s\n", mutt_make_version());
47  printf("Backtrace\n");
48  mutt_debug(LL_DEBUG1, "\nBacktrace\n");
49  unw_getcontext(&uc);
50  unw_init_local(&cursor, &uc);
51  while (unw_step(&cursor) > 0)
52  {
53  unw_get_reg(&cursor, UNW_REG_IP, &ip);
54  unw_get_reg(&cursor, UNW_REG_SP, &sp);
55  unw_get_proc_name(&cursor, buf, sizeof(buf), &ip);
56  if (buf[0] == '_')
57  break;
58  printf(" %s() ip = %lx, sp = %lx\n", buf, (long) ip, (long) sp);
59  mutt_debug(LL_DEBUG1, " %s() ip = %lx, sp = %lx\n", buf, (long) ip, (long) sp);
60  }
61  printf("\n");
62 }
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ win_name()

const char* win_name ( const struct MuttWindow win)

Definition at line 34 of file common.c.

35 {
36  if (!win)
37  return "UNKNOWN";
38 
39  switch (win->type)
40  {
41  case WT_ALL_DIALOGS:
42  return "All Dialogs";
43  case WT_CONTAINER:
44  return "Container";
45  case WT_CUSTOM:
46  return "Custom";
47  case WT_DLG_ALIAS:
48  return "Alias Dialog";
49  case WT_DLG_ATTACH:
50  return "Attach Dialog";
51  case WT_DLG_AUTOCRYPT:
52  return "Autocrypt Dialog";
53  case WT_DLG_BROWSER:
54  return "Browser Dialog";
55  case WT_DLG_CERTIFICATE:
56  return "Certificate Dialog";
57  case WT_DLG_COMPOSE:
58  return "Compose Dialog";
59  case WT_DLG_CRYPT_GPGME:
60  return "Crypt-GPGME Dialog";
61  case WT_DLG_DO_PAGER:
62  return "Pager Dialog";
63  case WT_DLG_HISTORY:
64  return "History Dialog";
65  case WT_DLG_INDEX:
66  return "Index Dialog";
67  case WT_DLG_PGP:
68  return "Pgp Dialog";
69  case WT_DLG_POSTPONE:
70  return "Postpone Dialog";
71  case WT_DLG_QUERY:
72  return "Query Dialog";
73  case WT_DLG_REMAILER:
74  return "Remailer Dialog";
75  case WT_DLG_SMIME:
76  return "Smime Dialog";
77  case WT_HELP_BAR:
78  return "Help Bar";
79  case WT_INDEX:
80  return "Index";
81  case WT_INDEX_BAR:
82  return "Index Bar";
83  case WT_MESSAGE:
84  return "Message";
85  case WT_PAGER:
86  return "Pager";
87  case WT_PAGER_BAR:
88  return "Pager Bar";
89  case WT_ROOT:
90  return "Root Dialog";
91  case WT_SIDEBAR:
92  return "Sidebar";
93  default:
94  return "UNKNOWN";
95  }
96 }
+ Here is the caller graph for this function:

◆ add_flag()

void add_flag ( struct Buffer buf,
bool  is_set,
const char *  name 
)

Definition at line 136 of file graphviz.c.

137 {
138  if (!buf || !name)
139  return;
140 
141  if (is_set)
142  {
143  if (!mutt_buffer_is_empty(buf))
144  mutt_buffer_addch(buf, ',');
145  mutt_buffer_addstr(buf, name);
146  }
147 }
+ Here is the call graph for this function:

◆ dump_addr_list()

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

Definition at line 34 of file email.c.

35 {
36  if (!buf || !al)
37  return;
38  if (TAILQ_EMPTY(al))
39  return;
40 
41  buf[0] = '\0';
42  mutt_addrlist_write(al, buf, buflen, true);
43  mutt_debug(LL_DEBUG1, "\t%s: %s\n", name, buf);
44 }
+ Here is the call graph for this function:

◆ dump_attach()

void dump_attach ( const struct AttachPtr att)

Definition at line 317 of file email.c.

318 {
319  if (!att)
320  return;
321 
322  struct Buffer buf = mutt_buffer_make(256);
323 
324  mutt_debug(LL_DEBUG1, "AttachPtr\n");
325 
326 #define ADD_FLAG(F) add_flag(&buf, att->F, #F)
327  ADD_FLAG(unowned);
328  ADD_FLAG(decrypted);
329 #undef ADD_FLAG
330 
331  if (att->fp)
332  mutt_debug(LL_DEBUG1, "\tfp: %p (%d)\n", att->fp, fileno(att->fp));
333  mutt_debug(LL_DEBUG1, "\tparent_type: %d\n", att->parent_type);
334  mutt_debug(LL_DEBUG1, "\tlevel: %d\n", att->level);
335  mutt_debug(LL_DEBUG1, "\tnum: %d\n", att->num);
336 
337  // struct Body *content; ///< Attachment
338  mutt_buffer_dealloc(&buf);
339 }
+ Here is the call graph for this function:

◆ dump_body()

void dump_body ( const struct Body body)

Definition at line 235 of file email.c.

236 {
237  if (!body)
238  return;
239 
240  struct Buffer buf = mutt_buffer_make(256);
241  char arr[256];
242 
243  mutt_debug(LL_DEBUG1, "Body\n");
244 
245 #define ADD_FLAG(F) add_flag(&buf, body->F, #F)
246  ADD_FLAG(attach_qualifies);
247  ADD_FLAG(badsig);
248  ADD_FLAG(collapsed);
249  ADD_FLAG(deleted);
250  ADD_FLAG(force_charset);
251  ADD_FLAG(goodsig);
252 #ifdef USE_AUTOCRYPT
253  ADD_FLAG(is_autocrypt);
254 #endif
255  ADD_FLAG(noconv);
256  ADD_FLAG(tagged);
257  ADD_FLAG(unlink);
258  ADD_FLAG(use_disp);
259  ADD_FLAG(warnsig);
260 #undef ADD_FLAG
261  mutt_debug(LL_DEBUG1, "\tFlags: %s\n",
262  mutt_buffer_is_empty(&buf) ? "[NONE]" : mutt_buffer_string(&buf));
263 
264 #define OPT_STRING(S) \
265  if (body->S) \
266  mutt_debug(LL_DEBUG1, "\t%s: %s\n", #S, body->S)
267  OPT_STRING(charset);
268  OPT_STRING(description);
269  OPT_STRING(d_filename);
270  OPT_STRING(filename);
271  OPT_STRING(form_name);
272  OPT_STRING(language);
273  OPT_STRING(subtype);
274  OPT_STRING(xtype);
275 #undef OPT_STRING
276 
277  mutt_debug(LL_DEBUG1, "\thdr_offset: %ld\n", body->hdr_offset);
278  mutt_debug(LL_DEBUG1, "\toffset: %ld\n", body->offset);
279  mutt_debug(LL_DEBUG1, "\tlength: %ld\n", body->length);
280  mutt_debug(LL_DEBUG1, "\tattach_count: %d\n", body->attach_count);
281 
282  mutt_debug(LL_DEBUG1, "\tcontent type: %s\n", get_content_type(body->type));
283  mutt_debug(LL_DEBUG1, "\tcontent encoding: %s\n", get_content_encoding(body->encoding));
284  mutt_debug(LL_DEBUG1, "\tcontent disposition: %s\n",
286 
287  if (body->stamp != 0)
288  {
289  mutt_date_make_tls(arr, sizeof(arr), body->stamp);
290  mutt_debug(LL_DEBUG1, "\tstamp: %s\n", arr);
291  }
292 
293  dump_param_list(&body->parameter);
294 
295  // struct Content *content; ///< Detailed info about the content of the attachment.
296  // struct Body *next; ///< next attachment in the list
297  // struct Body *parts; ///< parts of a multipart or message/rfc822
298  // struct Email *email; ///< header information for message/rfc822
299  // struct AttachPtr *aptr; ///< Menu information, used in recvattach.c
300  // struct Envelope *mime_headers; ///< Memory hole protected headers
301 
302  if (body->next)
303  {
304  mutt_debug(LL_DEBUG1, "-NEXT-------------------------\n");
305  dump_body(body->next);
306  }
307  if (body->parts)
308  {
309  mutt_debug(LL_DEBUG1, "-PARTS-------------------------\n");
310  dump_body(body->parts);
311  }
312  if (body->next || body->parts)
313  mutt_debug(LL_DEBUG1, "--------------------------\n");
314  mutt_buffer_dealloc(&buf);
315 }
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dump_email()

void dump_email ( const struct Email e)

Definition at line 132 of file email.c.

133 {
134  if (!e)
135  return;
136 
137  struct Buffer buf = mutt_buffer_make(256);
138  char arr[256];
139 
140  mutt_debug(LL_DEBUG1, "Email\n");
141  mutt_debug(LL_DEBUG1, "\tpath: %s\n", e->path);
142 
143 #define ADD_FLAG(F) add_flag(&buf, e->F, #F)
144  ADD_FLAG(active);
145  ADD_FLAG(attach_del);
146  ADD_FLAG(attach_valid);
147  ADD_FLAG(changed);
148  ADD_FLAG(collapsed);
149  ADD_FLAG(deleted);
150  ADD_FLAG(display_subject);
151  ADD_FLAG(expired);
152  ADD_FLAG(flagged);
153  ADD_FLAG(matched);
154  ADD_FLAG(mime);
155  ADD_FLAG(old);
156  ADD_FLAG(purge);
157  ADD_FLAG(quasi_deleted);
158  ADD_FLAG(read);
159  ADD_FLAG(recip_valid);
160  ADD_FLAG(replied);
161  ADD_FLAG(searched);
162  ADD_FLAG(subject_changed);
163  ADD_FLAG(superseded);
164  ADD_FLAG(tagged);
165  ADD_FLAG(threaded);
166  ADD_FLAG(trash);
167  ADD_FLAG(visible);
168 #undef ADD_FLAG
169  mutt_debug(LL_DEBUG1, "\tFlags: %s\n",
170  mutt_buffer_is_empty(&buf) ? "[NONE]" : mutt_buffer_string(&buf));
171 
172 #define ADD_FLAG(F) add_flag(&buf, (e->security & F), #F)
173  mutt_buffer_reset(&buf);
188 #undef ADD_FLAG
189  mutt_debug(LL_DEBUG1, "\tSecurity: %s\n",
190  mutt_buffer_is_empty(&buf) ? "[NONE]" : mutt_buffer_string(&buf));
191 
192  mutt_date_make_tls(arr, sizeof(arr), e->date_sent);
193  mutt_debug(LL_DEBUG1, "\tSent: %s (%c%02u%02u)\n", arr,
194  e->zoccident ? '-' : '+', e->zhours, e->zminutes);
195 
196  mutt_date_make_tls(arr, sizeof(arr), e->received);
197  mutt_debug(LL_DEBUG1, "\tRecv: %s\n", arr);
198 
199  mutt_buffer_dealloc(&buf);
200 
201  mutt_debug(LL_DEBUG1, "\tnum_hidden: %ld\n", e->num_hidden);
202  mutt_debug(LL_DEBUG1, "\trecipient: %d\n", e->recipient);
203  mutt_debug(LL_DEBUG1, "\toffset: %ld\n", e->offset);
204  mutt_debug(LL_DEBUG1, "\tlines: %d\n", e->lines);
205  mutt_debug(LL_DEBUG1, "\tindex: %d\n", e->index);
206  mutt_debug(LL_DEBUG1, "\tmsgno: %d\n", e->msgno);
207  mutt_debug(LL_DEBUG1, "\tvnum: %d\n", e->vnum);
208  mutt_debug(LL_DEBUG1, "\tscore: %d\n", e->score);
209  mutt_debug(LL_DEBUG1, "\tattach_total: %d\n", e->attach_total);
210  // if (e->maildir_flags)
211  // mutt_debug(LL_DEBUG1, "\tmaildir_flags: %s\n", e->maildir_flags);
212 
213  // struct MuttThread *thread
214  // struct Envelope *env
215  // struct Body *content
216  // struct TagList tags
217 
218  // void *edata
219  mutt_buffer_dealloc(&buf);
220 }
+ Here is the call graph for this function:

◆ dump_envelope()

void dump_envelope ( const struct Envelope env)

Definition at line 67 of file email.c.

68 {
69  struct Buffer buf = mutt_buffer_make(256);
70  char arr[1024];
71 
72  mutt_debug(LL_DEBUG1, "Envelope\n");
73 
74 #define ADD_FLAG(F) add_flag(&buf, (env->changed & F), #F)
79 #undef ADD_FLAG
80  mutt_debug(LL_DEBUG1, "\tchanged: %s\n",
81  mutt_buffer_is_empty(&buf) ? "[NONE]" : mutt_buffer_string(&buf));
82 
83 #define ADDR_LIST(AL) dump_addr_list(arr, sizeof(arr), &env->AL, #AL)
84  ADDR_LIST(return_path);
85  ADDR_LIST(from);
86  ADDR_LIST(to);
87  ADDR_LIST(cc);
88  ADDR_LIST(bcc);
89  ADDR_LIST(sender);
90  ADDR_LIST(reply_to);
91  ADDR_LIST(mail_followup_to);
92  ADDR_LIST(x_original_to);
93 #undef ADDR_LIST
94 
95 #define OPT_STRING(S) \
96  if (env->S) \
97  mutt_debug(LL_DEBUG1, "\t%s: %s\n", #S, env->S)
98  OPT_STRING(list_post);
99  OPT_STRING(subject);
100  OPT_STRING(real_subj);
101  OPT_STRING(disp_subj);
102  OPT_STRING(message_id);
103  OPT_STRING(supersedes);
104  OPT_STRING(date);
105  OPT_STRING(x_label);
106  OPT_STRING(organization);
107 #ifdef USE_NNTP
108  OPT_STRING(newsgroups);
109  OPT_STRING(xref);
110  OPT_STRING(followup_to);
111  OPT_STRING(x_comment_to);
112 #endif
113 #undef OPT_STRING
114 
115  dump_list_head(&env->references, "references");
116  dump_list_head(&env->in_reply_to, "in_reply_to");
117  dump_list_head(&env->userhdrs, "userhdrs");
118 
119  if (!mutt_buffer_is_empty(&env->spam))
120  mutt_debug(LL_DEBUG1, "\tspam: %s\n", mutt_buffer_string(&env->spam));
121 
122 #ifdef USE_AUTOCRYPT
123  if (env->autocrypt)
124  mutt_debug(LL_DEBUG1, "\tautocrypt: %p\n", (void *) env->autocrypt);
125  if (env->autocrypt_gossip)
126  mutt_debug(LL_DEBUG1, "\tautocrypt_gossip: %p\n", (void *) env->autocrypt_gossip);
127 #endif
128 
129  mutt_buffer_dealloc(&buf);
130 }
+ 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 46 of file email.c.

47 {
48  if (!list || !name)
49  return;
50  if (STAILQ_EMPTY(list))
51  return;
52 
53  struct Buffer buf = mutt_buffer_make(256);
54 
55  struct ListNode *np = NULL;
56  STAILQ_FOREACH(np, list, entries)
57  {
58  if (!mutt_buffer_is_empty(&buf))
59  mutt_buffer_addch(&buf, ',');
60  mutt_buffer_addstr(&buf, np->data);
61  }
62 
63  mutt_debug(LL_DEBUG1, "\t%s: %s\n", name, mutt_buffer_string(&buf));
64  mutt_buffer_dealloc(&buf);
65 }
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dump_param_list()

void dump_param_list ( const struct ParameterList *  pl)

Definition at line 222 of file email.c.

223 {
224  if (!pl || TAILQ_EMPTY(pl))
225  return;
226 
227  mutt_debug(LL_DEBUG1, "\tparameters\n");
228  struct Parameter *np = NULL;
229  TAILQ_FOREACH(np, pl, entries)
230  {
231  mutt_debug(LL_DEBUG1, "\t\t%s = %s\n", NONULL(np->attribute), NONULL(np->value));
232  }
233 }
+ Here is the caller graph for this function:

◆ get_content_disposition()

const char* get_content_disposition ( enum ContentDisposition  disp)

Definition at line 119 of file graphviz.c.

120 {
121  switch (disp)
122  {
123  case DISP_INLINE:
124  return "DISP_INLINE";
125  case DISP_ATTACH:
126  return "DISP_ATTACH";
127  case DISP_FORM_DATA:
128  return "DISP_FORM_DATA";
129  case DISP_NONE:
130  return "DISP_NONE";
131  default:
132  return "UNKNOWN";
133  }
134 }
+ Here is the caller graph for this function:

◆ get_content_encoding()

const char* get_content_encoding ( enum ContentEncoding  enc)

Definition at line 96 of file graphviz.c.

97 {
98  switch (enc)
99  {
100  case ENC_OTHER:
101  return "ENC_OTHER";
102  case ENC_7BIT:
103  return "ENC_7BIT";
104  case ENC_8BIT:
105  return "ENC_8BIT";
107  return "ENC_QUOTED_PRINTABLE";
108  case ENC_BASE64:
109  return "ENC_BASE64";
110  case ENC_BINARY:
111  return "ENC_BINARY";
112  case ENC_UUENCODED:
113  return "ENC_UUENCODED";
114  default:
115  return "UNKNOWN";
116  }
117 }
+ Here is the caller graph for this function:

◆ get_content_type()

const char* get_content_type ( enum ContentType  type)

Definition at line 67 of file graphviz.c.

68 {
69  switch (type)
70  {
71  case TYPE_OTHER:
72  return "TYPE_OTHER";
73  case TYPE_AUDIO:
74  return "TYPE_AUDIO";
75  case TYPE_APPLICATION:
76  return "TYPE_APPLICATION";
77  case TYPE_IMAGE:
78  return "TYPE_IMAGE";
79  case TYPE_MESSAGE:
80  return "TYPE_MESSAGE";
81  case TYPE_MODEL:
82  return "TYPE_MODEL";
83  case TYPE_MULTIPART:
84  return "TYPE_MULTIPART";
85  case TYPE_TEXT:
86  return "TYPE_TEXT";
87  case TYPE_VIDEO:
88  return "TYPE_VIDEO";
89  case TYPE_ANY:
90  return "TYPE_ANY";
91  default:
92  return "UNKNOWN";
93  }
94 }
+ Here is the caller graph for this function:

◆ dump_graphviz()

void dump_graphviz ( const char *  title,
struct Context ctx 
)

Definition at line 937 of file graphviz.c.

938 {
939  char name[256] = { 0 };
940  struct ListHead links = STAILQ_HEAD_INITIALIZER(links);
941 
942  time_t now = time(NULL);
943  if (title)
944  {
945  char date[128];
946  mutt_date_localtime_format(date, sizeof(date), "%R", now);
947  snprintf(name, sizeof(name), "%s-%s.gv", date, title);
948  }
949  else
950  {
951  mutt_date_localtime_format(name, sizeof(name), "%R.gv", now);
952  }
953 
954  umask(022);
955  FILE *fp = fopen(name, "w");
956  if (!fp)
957  return;
958 
959  dot_graph_header(fp);
960 
961 #ifndef GV_HIDE_NEOMUTT
962  dot_node(fp, NeoMutt, "NeoMutt", "#ffa500");
964  "NeoMutt->accounts", false, NULL);
965 #ifndef GV_HIDE_CONFIG
966  dot_config(fp, (const char *) NeoMutt->sub, 0, NeoMutt->sub, &links);
967  dot_add_link(&links, NeoMutt, NeoMutt->sub, "NeoMutt Config", false, NULL);
968  struct Buffer buf = mutt_buffer_make(256);
969  char obj1[16] = { 0 };
970  char obj2[16] = { 0 };
971  dot_ptr_name(obj1, sizeof(obj1), NeoMutt);
972  dot_ptr_name(obj2, sizeof(obj2), NeoMutt->sub);
973  mutt_buffer_printf(&buf, "{ rank=same %s %s }", obj1, obj2);
975  mutt_buffer_dealloc(&buf);
976 #endif
977 #endif
978 
979  dot_account_list(fp, &NeoMutt->accounts, &links);
980 
981 #ifndef GV_HIDE_CONTEXT
982  if (ctx)
983  dot_context(fp, ctx, &links);
984 
985 #ifndef GV_HIDE_NEOMUTT
986  /* Globals */
987  fprintf(fp, "\t{ rank=same ");
988  if (ctx)
989  {
990  dot_ptr_name(name, sizeof(name), ctx);
991  fprintf(fp, "%s ", name);
992  }
993  dot_ptr_name(name, sizeof(name), NeoMutt);
994  fprintf(fp, "%s ", name);
995  fprintf(fp, "}\n");
996 #endif
997 #endif
998 
999  fprintf(fp, "\t{ rank=same ");
1000  struct Account *np = NULL;
1001  TAILQ_FOREACH(np, &NeoMutt->accounts, entries)
1002  {
1003 #ifdef GV_HIDE_MBOX
1004  if (np->type == MUTT_MBOX)
1005  continue;
1006 #endif
1007  dot_ptr_name(name, sizeof(name), np);
1008  fprintf(fp, "%s ", name);
1009  }
1010  fprintf(fp, "}\n");
1011 
1012  dot_graph_footer(fp, &links);
1013  fclose(fp);
1014  mutt_list_free(&links);
1015 }
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dump_graphviz_attach_ctx()

void dump_graphviz_attach_ctx ( struct AttachCtx actx)

Definition at line 1582 of file graphviz.c.

1583 {
1584  char name[256] = { 0 };
1585  struct ListHead links = STAILQ_HEAD_INITIALIZER(links);
1586 
1587  time_t now = time(NULL);
1588  mutt_date_localtime_format(name, sizeof(name), "%R-actx.gv", now);
1589 
1590  umask(022);
1591  FILE *fp = fopen(name, "w");
1592  if (!fp)
1593  return;
1594 
1595  dot_graph_header(fp);
1596 
1597  dot_attach_ctx(fp, actx, &links);
1598 
1599  dot_graph_footer(fp, &links);
1600  fclose(fp);
1601  mutt_list_free(&links);
1602 }
+ Here is the call graph for this function:

◆ dump_graphviz_email()

void dump_graphviz_email ( struct Email e)

Definition at line 1420 of file graphviz.c.

1421 {
1422  char name[256] = { 0 };
1423  struct ListHead links = STAILQ_HEAD_INITIALIZER(links);
1424 
1425  time_t now = time(NULL);
1426  mutt_date_localtime_format(name, sizeof(name), "%R-email.gv", now);
1427 
1428  umask(022);
1429  FILE *fp = fopen(name, "w");
1430  if (!fp)
1431  return;
1432 
1433  dot_graph_header(fp);
1434 
1435  dot_email(fp, e, &links);
1436 
1437  dot_graph_footer(fp, &links);
1438  fclose(fp);
1439  mutt_list_free(&links);
1440 }
+ Here is the call graph for this function:

◆ debug_notify_observer()

int debug_notify_observer ( struct NotifyCallback nc)

Definition at line 321 of file notify.c.

322 {
323  mutt_debug(LL_DEBUG1, "\033[1;31mNotification:\033[0m %s\n", get_event_type(nc->event_type));
324 
325  switch (nc->event_type)
326  {
327  case NT_ACCOUNT:
329  break;
330  case NT_COLOR:
331  notify_dump_color(nc);
332  break;
333  case NT_COMMAND:
335  break;
336  case NT_CONFIG:
337  notify_dump_config(nc);
338  break;
339  case NT_CONTEXT:
341  break;
342  case NT_EMAIL:
343  notify_dump_email(nc);
344  break;
345  case NT_GLOBAL:
346  notify_dump_global(nc);
347  break;
348  case NT_MAILBOX:
350  break;
351  case NT_WINDOW:
352  if (nc->event_subtype == NT_WINDOW_STATE)
354  else if (nc->event_subtype == NT_WINDOW_FOCUS)
356  break;
357  default:
358  mutt_debug(LL_DEBUG1, " Event Type: %d\n", nc->event_type);
359  mutt_debug(LL_DEBUG1, " Event Sub-type: %d\n", nc->event_subtype);
360  mutt_debug(LL_DEBUG1, " Event Data: %p\n", nc->event_data);
361  break;
362  }
363 
364  mutt_debug(LL_DEBUG1, " Global Data: %p\n", nc->global_data);
365 
366  return 0;
367 }
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ test_parse_set()

void test_parse_set ( void  )

Test the config parsing.

Definition at line 39 of file parse_test.c.

40 {
41  const char *vars[] = {
42  "from", // ADDRESS
43  "beep", // BOOL
44  "ispell", // COMMAND
45  "mbox_type", // ENUM
46  "to_chars", // MBTABLE
47  "net_inc", // NUMBER
48  "signature", // PATH
49  "print", // QUAD
50  "mask", // REGEX
51  "sort", // SORT
52  "attribution", // STRING
53  "zzz", // UNKNOWN
54  "my_var", // MY_VAR
55  };
56 
57  const char *commands[] = {
58  "set",
59  "toggle",
60  "reset",
61  "unset",
62  };
63 
64  const char *tests[] = {
65  "%s %s", "%s %s=42", "%s %s?", "%s ?%s", "%s ?%s=42",
66  "%s ?%s?", "%s no%s", "%s no%s=42", "%s no%s?", "%s inv%s",
67  "%s inv%s=42", "%s inv%s?", "%s &%s", "%s &%s=42", "%s &%s?",
68  };
69 
70  struct Buffer err = mutt_buffer_make(256);
71  char line[64];
72 
73  for (size_t v = 0; v < mutt_array_size(vars); v++)
74  {
75  // printf("--------------------------------------------------------------------------------\n");
76  // printf("VARIABLE %s\n", vars[v]);
77  for (size_t c = 0; c < mutt_array_size(commands); c++)
78  {
79  // printf("----------------------------------------\n");
80  // printf("COMMAND %s\n", commands[c]);
81  for (size_t t = 0; t < mutt_array_size(tests); t++)
82  {
83  mutt_buffer_reset(&err);
84 
85  snprintf(line, sizeof(line), tests[t], commands[c], vars[v]);
86  printf("%-26s", line);
87  enum CommandResult rc = mutt_parse_rc_line(line, &err);
88  printf("%2d %s\n", rc, err.data);
89  }
90  printf("\n");
91  }
92  // printf("\n");
93  }
94 
95  mutt_buffer_dealloc(&err);
96 }
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ debug_win_dump()

void debug_win_dump ( void  )

Definition at line 88 of file window.c.

89 {
91  mutt_debug(LL_DEBUG1, "\n");
92  win_dump(RootWindow, 0);
93  mutt_debug(LL_DEBUG1, "\n");
94  struct Buffer buf = mutt_buffer_make(1024);
96  mutt_debug(LL_DEBUG1, "%s\n", mutt_buffer_string(&buf));
97  mutt_buffer_dealloc(&buf);
98  win_focus = NULL;
99 }
+ Here is the call graph for this function:
+ Here is the caller graph for this function:
Body::hdr_offset
long hdr_offset
Offset in stream where the headers begin.
Definition: body.h:42
Email::date_sent
time_t date_sent
Time when the message was sent (UTC)
Definition: email.h:82
Email::msgno
int msgno
Number displayed to the user.
Definition: email.h:87
dot_account_list
static void dot_account_list(FILE *fp, struct AccountList *al, struct ListHead *links)
Definition: graphviz.c:907
WT_DLG_POSTPONE
@ WT_DLG_POSTPONE
Postpone Dialog, dlg_select_postponed_email()
Definition: mutt_window.h:86
ENC_BINARY
@ ENC_BINARY
Binary.
Definition: mime.h:53
WT_CUSTOM
@ WT_CUSTOM
Window with a custom drawing function.
Definition: mutt_window.h:92
ENC_QUOTED_PRINTABLE
@ ENC_QUOTED_PRINTABLE
Quoted-printable text.
Definition: mime.h:51
WT_PAGER
@ WT_PAGER
Window containing paged free-form text.
Definition: mutt_window.h:97
mutt_parse_rc_line
enum CommandResult mutt_parse_rc_line(const char *line, struct Buffer *err)
Parse a line of user config.
Definition: init.c:1044
NT_WINDOW_STATE
@ NT_WINDOW_STATE
Window state has changed, e.g. WN_VISIBLE.
Definition: mutt_window.h:183
get_event_type
static const char * get_event_type(enum NotifyType type)
Definition: notify.c:42
WT_DLG_ATTACH
@ WT_DLG_ATTACH
Attach Dialog, dlg_select_attachment()
Definition: mutt_window.h:75
win_dump
static void win_dump(struct MuttWindow *win, int indent)
Definition: window.c:54
WT_PAGER_BAR
@ WT_PAGER_BAR
Pager Bar containing status info about the Pager.
Definition: mutt_window.h:98
WT_ROOT
@ WT_ROOT
Parent of All Windows.
Definition: mutt_window.h:69
MUTT_ENV_CHANGED_IRT
#define MUTT_ENV_CHANGED_IRT
In-Reply-To changed to link/break threads.
Definition: envelope.h:32
NeoMutt::accounts
struct AccountList accounts
List of all Accounts.
Definition: neomutt.h:40
NONULL
#define NONULL(x)
Definition: string2.h:37
Email::lines
int lines
How many lines in the body of this message?
Definition: email.h:85
Envelope::in_reply_to
struct ListHead in_reply_to
in-reply-to header content
Definition: envelope.h:82
ENC_UUENCODED
@ ENC_UUENCODED
UUEncoded text.
Definition: mime.h:54
APPLICATION_SMIME
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:98
AttachPtr::num
int num
Attachment index number.
Definition: attach.h:41
DISP_FORM_DATA
@ DISP_FORM_DATA
Content is form-data.
Definition: mime.h:64
NT_CONFIG
@ NT_CONFIG
Config has changed, NotifyConfig, EventConfig.
Definition: notify_type.h:37
ListNode
A List node for strings.
Definition: list.h:34
Buffer
String manipulation buffer.
Definition: buffer.h:33
WT_DLG_CERTIFICATE
@ WT_DLG_CERTIFICATE
Certificate Dialog, dlg_verify_certificate()
Definition: mutt_window.h:78
Account::type
enum MailboxType type
Type of Mailboxes this Account contains.
Definition: account.h:38
Body::offset
LOFF_T offset
offset where the actual data begins
Definition: body.h:44
dump_body
void dump_body(const struct Body *body)
Definition: email.c:235
SEC_OPPENCRYPT
#define SEC_OPPENCRYPT
Opportunistic encrypt mode.
Definition: lib.h:93
SEC_AUTOCRYPT_OVERRIDE
#define SEC_AUTOCRYPT_OVERRIDE
(Autocrypt) Indicates manual set/unset of encryption
Definition: lib.h:95
notify_dump_window_focus
static void notify_dump_window_focus(struct NotifyCallback *nc)
Definition: notify.c:291
Body::next
struct Body * next
next attachment in the list
Definition: body.h:53
mutt_buffer_is_empty
bool mutt_buffer_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:252
mutt_buffer_dealloc
void mutt_buffer_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:294
ADDR_LIST
#define ADDR_LIST(AL)
SEC_ENCRYPT
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:85
WT_DLG_AUTOCRYPT
@ WT_DLG_AUTOCRYPT
Autocrypt Dialog, dlg_select_autocrypt_account()
Definition: mutt_window.h:76
notify_dump_config
static void notify_dump_config(struct NotifyCallback *nc)
Definition: notify.c:208
AttachPtr::fp
FILE * fp
Used in the recvattach menu.
Definition: attach.h:37
SEC_SIGN
#define SEC_SIGN
Email is signed.
Definition: lib.h:86
NT_GLOBAL
@ NT_GLOBAL
Not object-related, NotifyGlobal.
Definition: notify_type.h:40
mutt_addrlist_write
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
Parameter::value
char * value
Parameter value.
Definition: parameter.h:35
mutt_date_make_tls
int mutt_date_make_tls(char *buf, size_t buflen, time_t timestamp)
Format date in TLS certificate verification style.
Definition: date.c:572
dot_context
static void dot_context(FILE *fp, struct Context *ctx, struct ListHead *links)
Definition: graphviz.c:925
Account::name
char * name
Name of Account.
Definition: account.h:39
Email::num_hidden
size_t num_hidden
Number of hidden messages in this view (only valid when collapsed is set)
Definition: email.h:75
TAILQ_EMPTY
#define TAILQ_EMPTY(head)
Definition: queue.h:714
Email::offset
LOFF_T offset
Where in the stream does this message begin?
Definition: email.h:84
arr
struct Email * arr[10]
Definition: mailbox.c:233
TAILQ_FOREACH
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:718
Envelope::autocrypt
struct AutocryptHeader * autocrypt
Definition: envelope.h:85
notify_dump_context
static void notify_dump_context(struct NotifyCallback *nc)
Definition: notify.c:219
TYPE_VIDEO
@ TYPE_VIDEO
Type: 'video/*'.
Definition: mime.h:39
mutt_str_dup
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:370
LL_DEBUG1
@ LL_DEBUG1
Log at debug level 1.
Definition: logging.h:40
Body::disposition
unsigned int disposition
content-disposition, ContentDisposition
Definition: body.h:67
WT_DLG_CRYPT_GPGME
@ WT_DLG_CRYPT_GPGME
Crypt-GPGME Dialog, dlg_select_gpgme_key()
Definition: mutt_window.h:80
RootWindow
struct MuttWindow * RootWindow
Parent of all Windows.
Definition: mutt_window.c:45
Email::path
char * path
Path of Email (for local Mailboxes)
Definition: email.h:92
Body::encoding
unsigned int encoding
content-transfer-encoding, ContentEncoding
Definition: body.h:66
DISP_ATTACH
@ DISP_ATTACH
Content is attached.
Definition: mime.h:63
mutt_buffer_reset
void mutt_buffer_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:79
STAILQ_EMPTY
#define STAILQ_EMPTY(head)
Definition: queue.h:345
Email::recipient
short recipient
User_is_recipient()'s return value, cached.
Definition: email.h:78
Parameter
Attribute associated with a MIME part.
Definition: parameter.h:32
mutt_list_insert_tail
struct ListNode * mutt_list_insert_tail(struct ListHead *h, char *s)
Append a string to the end of a List.
Definition: list.c:64
WT_DLG_COMPOSE
@ WT_DLG_COMPOSE
Compose Dialog, mutt_compose_menu()
Definition: mutt_window.h:79
mutt_array_size
#define mutt_array_size(x)
Definition: memory.h:33
STAILQ_FOREACH
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:349
WT_DLG_PGP
@ WT_DLG_PGP
Pgp Dialog, dlg_select_pgp_key()
Definition: mutt_window.h:85
Email::zoccident
bool zoccident
True, if west of UTC, False if east.
Definition: email.h:65
window_get_focus
struct MuttWindow * window_get_focus(void)
Get the currently focussed Window.
Definition: mutt_window.c:790
WT_SIDEBAR
@ WT_SIDEBAR
Side panel containing Accounts or groups of data.
Definition: mutt_window.h:99
NT_WINDOW
@ NT_WINDOW
MuttWindow has changed, NotifyWindow, EventWindow.
Definition: notify_type.h:43
TYPE_AUDIO
@ TYPE_AUDIO
Type: 'audio/*'.
Definition: mime.h:32
Body::attach_count
signed short attach_count
Number of attachments.
Definition: body.h:59
win_serialise
static void win_serialise(struct MuttWindow *win, struct Buffer *buf)
Definition: window.c:72
PGP_TRADITIONAL_CHECKED
#define PGP_TRADITIONAL_CHECKED
Email has a traditional (inline) signature.
Definition: lib.h:99
dump_param_list
void dump_param_list(const struct ParameterList *pl)
Definition: email.c:222
Email::received
time_t received
Time when the message was placed in the mailbox.
Definition: email.h:83
TAILQ_FIRST
#define TAILQ_FIRST(head)
Definition: queue.h:716
NT_MAILBOX
@ NT_MAILBOX
Mailbox has changed, NotifyMailbox, EventMailbox.
Definition: notify_type.h:42
mutt_buffer_addch
size_t mutt_buffer_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition: buffer.c:240
mutt_date_localtime_format
size_t mutt_date_localtime_format(char *buf, size_t buflen, const char *format, time_t t)
Format localtime.
Definition: date.c:680
NT_COMMAND
@ NT_COMMAND
A Command has been executed, Command.
Definition: notify_type.h:36
WT_MESSAGE
@ WT_MESSAGE
Window for messages/errors and command entry.
Definition: mutt_window.h:96
Parameter::attribute
char * attribute
Parameter name.
Definition: parameter.h:34
Account
A group of associated Mailboxes.
Definition: account.h:36
notify_dump_color
static void notify_dump_color(struct NotifyCallback *nc)
Definition: notify.c:171
AttachPtr::level
int level
Nesting depth of attachment.
Definition: attach.h:40
Email::zminutes
unsigned int zminutes
Minutes away from UTC.
Definition: email.h:64
WT_DLG_QUERY
@ WT_DLG_QUERY
Query Dialog, dlg_select_query()
Definition: mutt_window.h:87
NT_COLOR
@ NT_COLOR
Colour has changed, ColorId, EventColor.
Definition: notify_type.h:35
Body::length
LOFF_T length
length (in bytes) of attachment
Definition: body.h:45
ENC_8BIT
@ ENC_8BIT
8-bit text
Definition: mime.h:50
APPLICATION_PGP
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
DISP_NONE
@ DISP_NONE
No preferred disposition.
Definition: mime.h:65
MUTT_ENV_CHANGED_SUBJECT
#define MUTT_ENV_CHANGED_SUBJECT
Protected header update.
Definition: envelope.h:35
NotifyCallback::global_data
void * global_data
Data from notify_observer_add()
Definition: observer.h:45
TYPE_ANY
@ TYPE_ANY
Type: '*' or '.*'.
Definition: mime.h:40
TYPE_MODEL
@ TYPE_MODEL
Type: 'model/*'.
Definition: mime.h:36
Body::parts
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:54
TYPE_MESSAGE
@ TYPE_MESSAGE
Type: 'message/*'.
Definition: mime.h:35
WT_DLG_INDEX
@ WT_DLG_INDEX
Index Dialog, index_pager_init()
Definition: mutt_window.h:83
mutt_debug
#define mutt_debug(LEVEL,...)
Definition: logging.h:81
OPT_STRING
#define OPT_STRING(S)
TYPE_IMAGE
@ TYPE_IMAGE
Type: 'image/*'.
Definition: mime.h:34
Email::attach_total
short attach_total
Number of qualifying attachments in message, if attach_valid.
Definition: email.h:97
notify_dump_command
static void notify_dump_command(struct NotifyCallback *nc)
Definition: notify.c:198
WT_DLG_DO_PAGER
@ WT_DLG_DO_PAGER
Pager Dialog, mutt_do_pager()
Definition: mutt_window.h:81
Email::zhours
unsigned int zhours
Hours away from UTC.
Definition: email.h:63
mutt_buffer_string
static const char * mutt_buffer_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:77
WT_DLG_BROWSER
@ WT_DLG_BROWSER
Browser Dialog, mutt_buffer_select_file()
Definition: mutt_window.h:77
dot_add_link
static void dot_add_link(struct ListHead *links, void *src, void *dst, const char *label, bool back, const char *colour)
Definition: graphviz.c:264
win_focus
static struct MuttWindow * win_focus
Definition: window.c:34
Email::score
int score
Message score.
Definition: email.h:89
NotifyCallback::event_data
void * event_data
Data from notify_send()
Definition: observer.h:44
NT_WINDOW_FOCUS
@ NT_WINDOW_FOCUS
Window focus has changed.
Definition: mutt_window.h:185
CommandResult
CommandResult
Error codes for command_t parse functions.
Definition: mutt_commands.h:34
SEC_BADSIGN
#define SEC_BADSIGN
Email has a bad signature.
Definition: lib.h:88
WT_INDEX
@ WT_INDEX
An Index Window containing a selection list.
Definition: mutt_window.h:94
WT_DLG_ALIAS
@ WT_DLG_ALIAS
Alias Dialog, dlg_select_alias()
Definition: mutt_window.h:74
STAILQ_HEAD_INITIALIZER
#define STAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:321
WT_DLG_SMIME
@ WT_DLG_SMIME
Smime Dialog, dlg_select_smime_key()
Definition: mutt_window.h:89
dot_node
static void dot_node(FILE *fp, void *ptr, const char *name, const char *colour)
Definition: graphviz.c:346
Envelope::userhdrs
struct ListHead userhdrs
user defined headers
Definition: envelope.h:83
TYPE_APPLICATION
@ TYPE_APPLICATION
Type: 'application/*'.
Definition: mime.h:33
WT_ALL_DIALOGS
@ WT_ALL_DIALOGS
Container for All Dialogs (nested Windows)
Definition: mutt_window.h:71
WT_CONTAINER
@ WT_CONTAINER
Invisible shaping container Window.
Definition: mutt_window.h:70
MUTT_ENV_CHANGED_REFS
#define MUTT_ENV_CHANGED_REFS
References changed to break thread.
Definition: envelope.h:33
Body::stamp
time_t stamp
Time stamp of last encoding update.
Definition: body.h:61
ENC_BASE64
@ ENC_BASE64
Base-64 encoded text.
Definition: mime.h:52
WT_INDEX_BAR
@ WT_INDEX_BAR
Index Bar containing status info about the Index.
Definition: mutt_window.h:95
NT_EMAIL
@ NT_EMAIL
Email has changed, NotifyEmail, EventEmail.
Definition: notify_type.h:39
TYPE_TEXT
@ TYPE_TEXT
Type: 'text/*'.
Definition: mime.h:38
WT_HELP_BAR
@ WT_HELP_BAR
Help Bar containing list of useful key bindings.
Definition: mutt_window.h:93
dot_graph_header
static void dot_graph_header(FILE *fp)
Definition: graphviz.c:288
NeoMutt
Container for Accounts, Notifications.
Definition: neomutt.h:36
DISP_INLINE
@ DISP_INLINE
Content is inline.
Definition: mime.h:62
SEC_INLINE
#define SEC_INLINE
Email has an inline signature.
Definition: lib.h:92
notify_dump_global
static void notify_dump_global(struct NotifyCallback *nc)
Definition: notify.c:241
Body::type
unsigned int type
content-type primary type, ContentType
Definition: body.h:65
ENC_OTHER
@ ENC_OTHER
Encoding unknown.
Definition: mime.h:48
NT_CONTEXT
@ NT_CONTEXT
Context has changed, NotifyContext, EventContext.
Definition: notify_type.h:38
TYPE_OTHER
@ TYPE_OTHER
Unknown Content-Type.
Definition: mime.h:31
MuttWindow::type
enum WindowType type
Window type, e.g. WT_SIDEBAR.
Definition: mutt_window.h:137
Envelope::spam
struct Buffer spam
Spam header.
Definition: envelope.h:80
dot_graph_footer
static void dot_graph_footer(FILE *fp, struct ListHead *links)
Definition: graphviz.c:311
Email::vnum
int vnum
Virtual message number.
Definition: email.h:88
dot_ptr_name
static void dot_ptr_name(char *buf, size_t buflen, const void *ptr)
Definition: graphviz.c:242
ListNode::data
char * data
String.
Definition: list.h:36
get_content_type
const char * get_content_type(enum ContentType type)
Definition: graphviz.c:67
dot_config
static void dot_config(FILE *fp, const char *name, int type, struct ConfigSubset *sub, struct ListHead *links)
Definition: graphviz.c:413
Email::index
int index
The absolute (unsorted) message number.
Definition: email.h:86
NeoMutt::sub
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
SEC_SIGNOPAQUE
#define SEC_SIGNOPAQUE
Email has an opaque signature (encrypted)
Definition: lib.h:90
mutt_buffer_addstr
size_t mutt_buffer_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:225
notify_dump_mailbox
static void notify_dump_mailbox(struct NotifyCallback *nc)
Definition: notify.c:246
notify_dump_account
static void notify_dump_account(struct NotifyCallback *nc)
Definition: notify.c:162
notify_dump_window_state
static void notify_dump_window_state(struct NotifyCallback *nc)
Definition: notify.c:255
AttachPtr::parent_type
int parent_type
Type of parent attachment, e.g. TYPE_MULTIPART.
Definition: attach.h:38
NotifyCallback::event_subtype
int event_subtype
Send: Event subtype, e.g. NT_ACCOUNT_ADD.
Definition: observer.h:43
NotifyCallback::event_type
enum NotifyType event_type
Send: Event type, e.g. NT_ACCOUNT.
Definition: observer.h:42
dump_list_head
void dump_list_head(const struct ListHead *list, const char *name)
Definition: email.c:46
Body::parameter
struct ParameterList parameter
parameters of the content-type
Definition: body.h:39
WT_DLG_HISTORY
@ WT_DLG_HISTORY
History Dialog, dlg_select_history()
Definition: mutt_window.h:82
SEC_KEYBLOCK
#define SEC_KEYBLOCK
Email has a key attached.
Definition: lib.h:91
Buffer::data
char * data
Pointer to data.
Definition: buffer.h:35
TYPE_MULTIPART
@ TYPE_MULTIPART
Type: 'multipart/*'.
Definition: mime.h:37
mutt_buffer_printf
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
mutt_make_version
const char * mutt_make_version(void)
Generate the NeoMutt version string.
Definition: muttlib.c:1462
Envelope::references
struct ListHead references
message references (in reverse order)
Definition: envelope.h:81
dot_email
static void dot_email(FILE *fp, struct Email *e, struct ListHead *links)
Definition: graphviz.c:1301
mutt_buffer_make
struct Buffer mutt_buffer_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:61
mutt_list_free
void mutt_list_free(struct ListHead *h)
Free a List AND its strings.
Definition: list.c:122
WT_DLG_REMAILER
@ WT_DLG_REMAILER
Remailer Dialog, dlg_select_mixmaster_chain()
Definition: mutt_window.h:88
MUTT_MBOX
@ MUTT_MBOX
'mbox' Mailbox type
Definition: mailbox.h:48
get_content_encoding
const char * get_content_encoding(enum ContentEncoding enc)
Definition: graphviz.c:96
SEC_GOODSIGN
#define SEC_GOODSIGN
Email has a valid signature.
Definition: lib.h:87
ENC_7BIT
@ ENC_7BIT
7-bit text
Definition: mime.h:49
NT_ACCOUNT
@ NT_ACCOUNT
Account has changed, NotifyAccount, EventAccount.
Definition: notify_type.h:34
SEC_AUTOCRYPT
#define SEC_AUTOCRYPT
(Autocrypt) Message will be, or was Autocrypt encrypt+signed
Definition: lib.h:94
ADD_FLAG
#define ADD_FLAG(F)
get_content_disposition
const char * get_content_disposition(enum ContentDisposition disp)
Definition: graphviz.c:119
SEC_PARTSIGN
#define SEC_PARTSIGN
Not all parts of the email is signed.
Definition: lib.h:89
dot_attach_ctx
static void dot_attach_ctx(FILE *fp, struct AttachCtx *actx, struct ListHead *links)
Definition: graphviz.c:1543
notify_dump_email
static void notify_dump_email(struct NotifyCallback *nc)
Definition: notify.c:230
MUTT_ENV_CHANGED_XLABEL
#define MUTT_ENV_CHANGED_XLABEL
X-Label edited.
Definition: envelope.h:34
Envelope::autocrypt_gossip
struct AutocryptHeader * autocrypt_gossip
Definition: envelope.h:86