NeoMutt  2024-04-25-100-gcb3684
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
serialize.c
Go to the documentation of this file.
1
31#include "config.h"
32#include <stdbool.h>
33#include <stddef.h>
34#include <string.h>
35#include <sys/types.h>
36#include "mutt/lib.h"
37#include "address/lib.h"
38#include "config/lib.h"
39#include "email/lib.h"
40#include "core/lib.h"
41#include "serialize.h"
42
50void lazy_realloc(void *ptr, size_t size)
51{
52 void **p = (void **) ptr;
53
54 if (p && (size < 4096))
55 return;
56
57 mutt_mem_realloc(ptr, size);
58}
59
67unsigned char *serial_dump_int(const unsigned int i, unsigned char *d, int *off)
68{
69 lazy_realloc(&d, *off + sizeof(int));
70 memcpy(d + *off, &i, sizeof(int));
71 (*off) += sizeof(int);
72
73 return d;
74}
75
83unsigned char *serial_dump_uint32_t(const uint32_t s, unsigned char *d, int *off)
84{
85 lazy_realloc(&d, *off + sizeof(uint32_t));
86 memcpy(d + *off, &s, sizeof(uint32_t));
87 (*off) += sizeof(uint32_t);
88
89 return d;
90}
91
99unsigned char *serial_dump_uint64_t(const uint64_t s, unsigned char *d, int *off)
100{
101 lazy_realloc(&d, *off + sizeof(uint64_t));
102 memcpy(d + *off, &s, sizeof(uint64_t));
103 (*off) += sizeof(uint64_t);
104
105 return d;
106}
107
114void serial_restore_int(unsigned int *i, const unsigned char *d, int *off)
115{
116 memcpy(i, d + *off, sizeof(int));
117 (*off) += sizeof(int);
118}
119
126void serial_restore_uint32_t(uint32_t *s, const unsigned char *d, int *off)
127{
128 memcpy(s, d + *off, sizeof(uint32_t));
129 (*off) += sizeof(uint32_t);
130}
131
138void serial_restore_uint64_t(uint64_t *s, const unsigned char *d, int *off)
139{
140 memcpy(s, d + *off, sizeof(uint64_t));
141 (*off) += sizeof(uint64_t);
142}
143
153unsigned char *serial_dump_char_size(const char *c, ssize_t size,
154 unsigned char *d, int *off, bool convert)
155{
156 char *p = NULL;
157
158 if (!c || (*c == '\0') || (size == 0))
159 {
160 return serial_dump_int(0, d, off);
161 }
162
163 if (convert && !mutt_str_is_ascii(c, size))
164 {
165 p = mutt_strn_dup(c, size);
166 if (mutt_ch_convert_string(&p, cc_charset(), "utf-8", MUTT_ICONV_NO_FLAGS) == 0)
167 {
168 size = mutt_str_len(p) + 1;
169 }
170 }
171
172 d = serial_dump_int(size, d, off);
173 lazy_realloc(&d, *off + size);
174 memcpy(d + *off, p ? p : c, size);
175 *off += size;
176
177 FREE(&p);
178
179 return d;
180}
181
190unsigned char *serial_dump_char(const char *c, unsigned char *d, int *off, bool convert)
191{
192 return serial_dump_char_size(c, mutt_str_len(c) + 1, d, off, convert);
193}
194
202void serial_restore_char(char **c, const unsigned char *d, int *off, bool convert)
203{
204 unsigned int size = 0;
205 serial_restore_int(&size, d, off);
206
207 if (size == 0)
208 {
209 *c = NULL;
210 return;
211 }
212
213 *c = mutt_mem_malloc(size);
214 memcpy(*c, d + *off, size);
215 if (convert && !mutt_str_is_ascii(*c, size))
216 {
217 char *tmp = mutt_str_dup(*c);
218 if (mutt_ch_convert_string(&tmp, "utf-8", cc_charset(), MUTT_ICONV_NO_FLAGS) == 0)
219 {
220 FREE(c);
221 *c = tmp;
222 }
223 else
224 {
225 FREE(&tmp);
226 }
227 }
228 *off += size;
229}
230
239unsigned char *serial_dump_address(const struct AddressList *al,
240 unsigned char *d, int *off, bool convert)
241{
242 unsigned int counter = 0;
243 unsigned int start_off = *off;
244
245 d = serial_dump_int(0xdeadbeef, d, off);
246
247 struct Address *a = NULL;
248 TAILQ_FOREACH(a, al, entries)
249 {
250 d = serial_dump_buffer(a->personal, d, off, convert);
251 d = serial_dump_buffer(a->mailbox, d, off, convert);
252 d = serial_dump_int(a->group, d, off);
253 counter++;
254 }
255
256 memcpy(d + start_off, &counter, sizeof(int));
257
258 return d;
259}
260
268void serial_restore_address(struct AddressList *al, const unsigned char *d,
269 int *off, bool convert)
270{
271 unsigned int counter = 0;
272 unsigned int g = 0;
273
274 serial_restore_int(&counter, d, off);
275
276 while (counter)
277 {
278 struct Address *a = mutt_addr_new();
279
280 a->personal = buf_new(NULL);
281 serial_restore_buffer(a->personal, d, off, convert);
282 if (buf_is_empty(a->personal))
283 {
284 buf_free(&a->personal);
285 }
286
287 a->mailbox = buf_new(NULL);
288 serial_restore_buffer(a->mailbox, d, off, false);
289 if (buf_is_empty(a->mailbox))
290 {
291 buf_free(&a->mailbox);
292 }
293
294 serial_restore_int(&g, d, off);
295 a->group = !!g;
297 counter--;
298 }
299}
300
309unsigned char *serial_dump_stailq(const struct ListHead *l, unsigned char *d,
310 int *off, bool convert)
311{
312 unsigned int counter = 0;
313 unsigned int start_off = *off;
314
315 d = serial_dump_int(0xdeadbeef, d, off);
316
317 struct ListNode *np = NULL;
318 STAILQ_FOREACH(np, l, entries)
319 {
320 d = serial_dump_char(np->data, d, off, convert);
321 counter++;
322 }
323
324 memcpy(d + start_off, &counter, sizeof(int));
325
326 return d;
327}
328
336void serial_restore_stailq(struct ListHead *l, const unsigned char *d, int *off, bool convert)
337{
338 unsigned int counter = 0;
339
340 serial_restore_int(&counter, d, off);
341
342 struct ListNode *np = NULL;
343 while (counter)
344 {
345 np = mutt_list_insert_tail(l, NULL);
346 serial_restore_char(&np->data, d, off, convert);
347 counter--;
348 }
349}
350
359unsigned char *serial_dump_buffer(const struct Buffer *buf, unsigned char *d,
360 int *off, bool convert)
361{
362 if (buf_is_empty(buf))
363 {
364 d = serial_dump_int(0, d, off);
365 return d;
366 }
367
368 d = serial_dump_int(1, d, off);
369
370 d = serial_dump_char(buf->data, d, off, convert);
371
372 return d;
373}
374
382void serial_restore_buffer(struct Buffer *buf, const unsigned char *d, int *off, bool convert)
383{
384 buf_alloc(buf, 1);
385
386 unsigned int used = 0;
387 serial_restore_int(&used, d, off);
388 if (used == 0)
389 return;
390
391 char *str = NULL;
392 serial_restore_char(&str, d, off, convert);
393
394 buf_addstr(buf, str);
395 FREE(&str);
396}
397
406unsigned char *serial_dump_parameter(const struct ParameterList *pl,
407 unsigned char *d, int *off, bool convert)
408{
409 unsigned int counter = 0;
410 unsigned int start_off = *off;
411
412 d = serial_dump_int(0xdeadbeef, d, off);
413
414 struct Parameter *np = NULL;
415 TAILQ_FOREACH(np, pl, entries)
416 {
417 d = serial_dump_char(np->attribute, d, off, false);
418 d = serial_dump_char(np->value, d, off, convert);
419 counter++;
420 }
421
422 memcpy(d + start_off, &counter, sizeof(int));
423
424 return d;
425}
426
434void serial_restore_parameter(struct ParameterList *pl, const unsigned char *d,
435 int *off, bool convert)
436{
437 unsigned int counter = 0;
438
439 serial_restore_int(&counter, d, off);
440
441 struct Parameter *np = NULL;
442 while (counter)
443 {
444 np = mutt_param_new();
445 serial_restore_char(&np->attribute, d, off, false);
446 serial_restore_char(&np->value, d, off, convert);
447 TAILQ_INSERT_TAIL(pl, np, entries);
448 counter--;
449 }
450}
451
459static inline uint32_t body_pack_flags(const struct Body *b)
460{
461 if (!b)
462 return 0;
463
464 // clang-format off
465 uint32_t packed = b->type +
466 (b->encoding << 4) +
467 (b->disposition << 7) +
468 (b->badsig << 9) +
469 (b->force_charset << 10) +
470 (b->goodsig << 11) +
471 (b->noconv << 12) +
472 (b->use_disp << 13) +
473 (b->warnsig << 14);
474 // clang-format on
475#ifdef USE_AUTOCRYPT
476 packed += (b->is_autocrypt << 15);
477#endif
478
479 return packed;
480}
481
489static inline void body_unpack_flags(struct Body *b, uint32_t packed)
490{
491 if (!b)
492 return;
493
494 // clang-format off
495 b->type = (packed & ((1 << 4) - 1)); // bits 0-3 (4)
496 b->encoding = ((packed >> 4) & ((1 << 3) - 1)); // bits 4-6 (3)
497 b->disposition = ((packed >> 7) & ((1 << 2) - 1)); // bits 7-8 (2)
498
499 b->badsig = (packed & (1 << 9));
500 b->force_charset = (packed & (1 << 10));
501 b->goodsig = (packed & (1 << 11));
502 b->noconv = (packed & (1 << 12));
503 b->use_disp = (packed & (1 << 13));
504 b->warnsig = (packed & (1 << 14));
505#ifdef USE_AUTOCRYPT
506 b->is_autocrypt = (packed & (1 << 15));
507#endif
508 // clang-format on
509}
510
519unsigned char *serial_dump_body(const struct Body *b, unsigned char *d, int *off, bool convert)
520{
521 uint32_t packed = body_pack_flags(b);
522 d = serial_dump_uint32_t(packed, d, off);
523
524 uint64_t big = b->offset;
525 d = serial_dump_uint64_t(big, d, off);
526
527 big = b->length;
528 d = serial_dump_uint64_t(big, d, off);
529
530 d = serial_dump_char(b->xtype, d, off, false);
531 d = serial_dump_char(b->subtype, d, off, false);
532
533 d = serial_dump_parameter(&b->parameter, d, off, convert);
534
535 d = serial_dump_char(b->description, d, off, convert);
536 d = serial_dump_char(b->form_name, d, off, convert);
537 d = serial_dump_char(b->filename, d, off, convert);
538 d = serial_dump_char(b->d_filename, d, off, convert);
539
540 return d;
541}
542
550void serial_restore_body(struct Body *b, const unsigned char *d, int *off, bool convert)
551{
552 uint32_t packed = 0;
553 serial_restore_uint32_t(&packed, d, off);
554 body_unpack_flags(b, packed);
555
556 uint64_t big = 0;
557 serial_restore_uint64_t(&big, d, off);
558 b->offset = big;
559
560 big = 0;
561 serial_restore_uint64_t(&big, d, off);
562 b->length = big;
563
564 serial_restore_char(&b->xtype, d, off, false);
565 serial_restore_char(&b->subtype, d, off, false);
566
568 serial_restore_parameter(&b->parameter, d, off, convert);
569
570 serial_restore_char(&b->description, d, off, convert);
571 serial_restore_char(&b->form_name, d, off, convert);
572 serial_restore_char(&b->filename, d, off, convert);
573 serial_restore_char(&b->d_filename, d, off, convert);
574}
575
584unsigned char *serial_dump_envelope(const struct Envelope *env,
585 unsigned char *d, int *off, bool convert)
586{
587 d = serial_dump_address(&env->return_path, d, off, convert);
588 d = serial_dump_address(&env->from, d, off, convert);
589 d = serial_dump_address(&env->to, d, off, convert);
590 d = serial_dump_address(&env->cc, d, off, convert);
591 d = serial_dump_address(&env->bcc, d, off, convert);
592 d = serial_dump_address(&env->sender, d, off, convert);
593 d = serial_dump_address(&env->reply_to, d, off, convert);
594 d = serial_dump_address(&env->mail_followup_to, d, off, convert);
595
596 d = serial_dump_char(env->list_post, d, off, convert);
597 d = serial_dump_char(env->list_subscribe, d, off, convert);
598 d = serial_dump_char(env->list_unsubscribe, d, off, convert);
599 d = serial_dump_char(env->subject, d, off, convert);
600
601 if (env->real_subj)
602 d = serial_dump_int(env->real_subj - env->subject, d, off);
603 else
604 d = serial_dump_int(-1, d, off);
605
606 d = serial_dump_char(env->message_id, d, off, false);
607 d = serial_dump_char(env->supersedes, d, off, false);
608 d = serial_dump_char(env->date, d, off, false);
609 d = serial_dump_char(env->x_label, d, off, convert);
610 d = serial_dump_char(env->organization, d, off, convert);
611
612 d = serial_dump_buffer(&env->spam, d, off, convert);
613
614 d = serial_dump_stailq(&env->references, d, off, false);
615 d = serial_dump_stailq(&env->in_reply_to, d, off, false);
616 d = serial_dump_stailq(&env->userhdrs, d, off, convert);
617
618 d = serial_dump_char(env->xref, d, off, false);
619 d = serial_dump_char(env->followup_to, d, off, false);
620 d = serial_dump_char(env->x_comment_to, d, off, convert);
621
622 return d;
623}
624
632void serial_restore_envelope(struct Envelope *env, const unsigned char *d, int *off, bool convert)
633{
634 int real_subj_off = 0;
635
636 serial_restore_address(&env->return_path, d, off, convert);
637 serial_restore_address(&env->from, d, off, convert);
638 serial_restore_address(&env->to, d, off, convert);
639 serial_restore_address(&env->cc, d, off, convert);
640 serial_restore_address(&env->bcc, d, off, convert);
641 serial_restore_address(&env->sender, d, off, convert);
642 serial_restore_address(&env->reply_to, d, off, convert);
643 serial_restore_address(&env->mail_followup_to, d, off, convert);
644
645 serial_restore_char(&env->list_post, d, off, convert);
646 serial_restore_char(&env->list_subscribe, d, off, convert);
647 serial_restore_char(&env->list_unsubscribe, d, off, convert);
648
649 const bool c_auto_subscribe = cs_subset_bool(NeoMutt->sub, "auto_subscribe");
650 if (c_auto_subscribe)
652
653 serial_restore_char((char **) &env->subject, d, off, convert);
654 serial_restore_int((unsigned int *) (&real_subj_off), d, off);
655
656 size_t len = mutt_str_len(env->subject);
657 if ((real_subj_off < 0) || (real_subj_off >= len))
658 *(char **) &env->real_subj = NULL;
659 else
660 *(char **) &env->real_subj = env->subject + real_subj_off;
661
662 serial_restore_char(&env->message_id, d, off, false);
663 serial_restore_char(&env->supersedes, d, off, false);
664 serial_restore_char(&env->date, d, off, false);
665 serial_restore_char(&env->x_label, d, off, convert);
666 serial_restore_char(&env->organization, d, off, convert);
667
668 serial_restore_buffer(&env->spam, d, off, convert);
669
670 serial_restore_stailq(&env->references, d, off, false);
671 serial_restore_stailq(&env->in_reply_to, d, off, false);
672 serial_restore_stailq(&env->userhdrs, d, off, convert);
673
674 serial_restore_char(&env->xref, d, off, false);
675 serial_restore_char(&env->followup_to, d, off, false);
676 serial_restore_char(&env->x_comment_to, d, off, convert);
677}
678
686unsigned char *serial_dump_tags(const struct TagList *tl, unsigned char *d, int *off)
687{
688 unsigned int counter = 0;
689 unsigned int start_off = *off;
690
691 d = serial_dump_int(0xdeadbeef, d, off);
692
693 struct Tag *tag = NULL;
694 STAILQ_FOREACH(tag, tl, entries)
695 {
696 d = serial_dump_char(tag->name, d, off, false);
697 counter++;
698 }
699
700 memcpy(d + start_off, &counter, sizeof(int));
701
702 return d;
703}
704
711void serial_restore_tags(struct TagList *tl, const unsigned char *d, int *off)
712{
713 unsigned int counter = 0;
714
715 serial_restore_int(&counter, d, off);
716
717 while (counter)
718 {
719 char *name = NULL;
720 serial_restore_char(&name, d, off, false);
722 counter--;
723 }
724}
void mutt_addrlist_append(struct AddressList *al, struct Address *a)
Append an Address to an AddressList.
Definition: address.c:1480
struct Address * mutt_addr_new(void)
Create a new Address.
Definition: address.c:401
Email Address Handling.
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:291
void buf_free(struct Buffer **ptr)
Deallocates a buffer.
Definition: buffer.c:319
struct Buffer * buf_new(const char *str)
Allocate a new Buffer.
Definition: buffer.c:304
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:226
void buf_alloc(struct Buffer *buf, size_t new_size)
Make sure a buffer can store at least new_size bytes.
Definition: buffer.c:337
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
Convenience wrapper for the config headers.
const char * cc_charset(void)
Get the cached value of $charset.
Definition: config_cache.c:116
Convenience wrapper for the core headers.
Structs that make up an email.
void mutt_auto_subscribe(const char *mailto)
Check if user is subscribed to mailing list.
Definition: parse.c:109
struct ListNode * mutt_list_insert_tail(struct ListHead *h, char *s)
Append a string to the end of a List.
Definition: list.c:65
void * mutt_mem_malloc(size_t size)
Allocate memory on the heap.
Definition: memory.c:91
void mutt_mem_realloc(void *ptr, size_t size)
Resize a block of memory on the heap.
Definition: memory.c:115
#define FREE(x)
Definition: memory.h:45
int mutt_ch_convert_string(char **ps, const char *from, const char *to, uint8_t flags)
Convert a string between encodings.
Definition: charset.c:831
#define MUTT_ICONV_NO_FLAGS
No flags are set.
Definition: charset.h:73
Convenience wrapper for the library headers.
char * mutt_strn_dup(const char *begin, size_t len)
Duplicate a sub-string.
Definition: string.c:380
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
bool mutt_str_is_ascii(const char *str, size_t len)
Is a string ASCII (7-bit)?
Definition: string.c:683
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:496
struct Parameter * mutt_param_new(void)
Create a new Parameter.
Definition: parameter.c:40
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725
#define TAILQ_INIT(head)
Definition: queue.h:765
#define TAILQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:809
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
unsigned char * serial_dump_body(const struct Body *b, unsigned char *d, int *off, bool convert)
Pack an Body into a binary blob.
Definition: serialize.c:519
unsigned char * serial_dump_tags(const struct TagList *tl, unsigned char *d, int *off)
Pack a TagList into a binary blob.
Definition: serialize.c:686
void serial_restore_tags(struct TagList *tl, const unsigned char *d, int *off)
Unpack a TagList from a binary blob.
Definition: serialize.c:711
unsigned char * serial_dump_uint64_t(const uint64_t s, unsigned char *d, int *off)
Pack a uint64_t into a binary blob.
Definition: serialize.c:99
void serial_restore_char(char **c, const unsigned char *d, int *off, bool convert)
Unpack a variable-length string from a binary blob.
Definition: serialize.c:202
unsigned char * serial_dump_int(const unsigned int i, unsigned char *d, int *off)
Pack an integer into a binary blob.
Definition: serialize.c:67
void serial_restore_buffer(struct Buffer *buf, const unsigned char *d, int *off, bool convert)
Unpack a Buffer from a binary blob.
Definition: serialize.c:382
void serial_restore_envelope(struct Envelope *env, const unsigned char *d, int *off, bool convert)
Unpack an Envelope from a binary blob.
Definition: serialize.c:632
unsigned char * serial_dump_envelope(const struct Envelope *env, unsigned char *d, int *off, bool convert)
Pack an Envelope into a binary blob.
Definition: serialize.c:584
static uint32_t body_pack_flags(const struct Body *b)
Pack the Body flags into a uint32_t.
Definition: serialize.c:459
unsigned char * serial_dump_buffer(const struct Buffer *buf, unsigned char *d, int *off, bool convert)
Pack a Buffer into a binary blob.
Definition: serialize.c:359
void serial_restore_stailq(struct ListHead *l, const unsigned char *d, int *off, bool convert)
Unpack a STAILQ from a binary blob.
Definition: serialize.c:336
unsigned char * serial_dump_address(const struct AddressList *al, unsigned char *d, int *off, bool convert)
Pack an Address into a binary blob.
Definition: serialize.c:239
void serial_restore_uint64_t(uint64_t *s, const unsigned char *d, int *off)
Unpack an uint64_t from a binary blob.
Definition: serialize.c:138
void lazy_realloc(void *ptr, size_t size)
Reallocate some memory.
Definition: serialize.c:50
unsigned char * serial_dump_parameter(const struct ParameterList *pl, unsigned char *d, int *off, bool convert)
Pack a Parameter into a binary blob.
Definition: serialize.c:406
void serial_restore_body(struct Body *b, const unsigned char *d, int *off, bool convert)
Unpack a Body from a binary blob.
Definition: serialize.c:550
unsigned char * serial_dump_uint32_t(const uint32_t s, unsigned char *d, int *off)
Pack a uint32_t into a binary blob.
Definition: serialize.c:83
unsigned char * serial_dump_stailq(const struct ListHead *l, unsigned char *d, int *off, bool convert)
Pack a STAILQ into a binary blob.
Definition: serialize.c:309
void serial_restore_parameter(struct ParameterList *pl, const unsigned char *d, int *off, bool convert)
Unpack a Parameter from a binary blob.
Definition: serialize.c:434
unsigned char * serial_dump_char_size(const char *c, ssize_t size, unsigned char *d, int *off, bool convert)
Pack a fixed-length string into a binary blob.
Definition: serialize.c:153
static void body_unpack_flags(struct Body *b, uint32_t packed)
Unpack the Body flags from a uint32_t.
Definition: serialize.c:489
void serial_restore_address(struct AddressList *al, const unsigned char *d, int *off, bool convert)
Unpack an Address from a binary blob.
Definition: serialize.c:268
void serial_restore_int(unsigned int *i, const unsigned char *d, int *off)
Unpack an integer from a binary blob.
Definition: serialize.c:114
void serial_restore_uint32_t(uint32_t *s, const unsigned char *d, int *off)
Unpack an uint32_t from a binary blob.
Definition: serialize.c:126
unsigned char * serial_dump_char(const char *c, unsigned char *d, int *off, bool convert)
Pack a variable-length string into a binary blob.
Definition: serialize.c:190
Email-object serialiser.
An email address.
Definition: address.h:36
struct Buffer * personal
Real name of address.
Definition: address.h:37
bool group
Group mailbox?
Definition: address.h:39
struct Buffer * mailbox
Mailbox and host address.
Definition: address.h:38
The body of an email.
Definition: body.h:36
char * d_filename
filename to be used for the content-disposition header If NULL, filename is used instead.
Definition: body.h:56
LOFF_T offset
offset where the actual data begins
Definition: body.h:52
char * xtype
content-type if x-unknown
Definition: body.h:62
bool noconv
Don't do character set conversion.
Definition: body.h:46
bool badsig
Bad cryptographic signature (needed to check encrypted s/mime-signatures)
Definition: body.h:43
bool is_autocrypt
Flag autocrypt-decrypted messages for replying.
Definition: body.h:50
LOFF_T length
length (in bytes) of attachment
Definition: body.h:53
struct ParameterList parameter
Parameters of the content-type.
Definition: body.h:63
bool use_disp
Content-Disposition uses filename= ?
Definition: body.h:47
char * description
content-description
Definition: body.h:55
unsigned int disposition
content-disposition, ContentDisposition
Definition: body.h:42
bool force_charset
Send mode: don't adjust the character set when in send-mode.
Definition: body.h:44
char * subtype
content-type subtype
Definition: body.h:61
unsigned int encoding
content-transfer-encoding, ContentEncoding
Definition: body.h:41
bool goodsig
Good cryptographic signature.
Definition: body.h:45
char * form_name
Content-Disposition form-data name param.
Definition: body.h:60
bool warnsig
Maybe good signature.
Definition: body.h:48
unsigned int type
content-type primary type, ContentType
Definition: body.h:40
char * filename
When sending a message, this is the file to which this structure refers.
Definition: body.h:59
String manipulation buffer.
Definition: buffer.h:36
char * data
Pointer to data.
Definition: buffer.h:37
The header of an Email.
Definition: envelope.h:57
struct ListHead userhdrs
user defined headers
Definition: envelope.h:85
char * supersedes
Supersedes header.
Definition: envelope.h:74
char * list_subscribe
This stores a mailto URL, or nothing.
Definition: envelope.h:68
struct AddressList return_path
Return path for the Email.
Definition: envelope.h:58
char *const subject
Email's subject.
Definition: envelope.h:70
struct AddressList to
Email's 'To' list.
Definition: envelope.h:60
char * followup_to
List of 'followup-to' fields.
Definition: envelope.h:80
struct AddressList reply_to
Email's 'reply-to'.
Definition: envelope.h:64
char * message_id
Message ID.
Definition: envelope.h:73
char * x_comment_to
List of 'X-comment-to' fields.
Definition: envelope.h:81
struct AddressList mail_followup_to
Email's 'mail-followup-to'.
Definition: envelope.h:65
struct AddressList cc
Email's 'Cc' list.
Definition: envelope.h:61
struct AddressList sender
Email's sender.
Definition: envelope.h:63
struct ListHead references
message references (in reverse order)
Definition: envelope.h:83
struct Buffer spam
Spam header.
Definition: envelope.h:82
struct ListHead in_reply_to
in-reply-to header content
Definition: envelope.h:84
struct AddressList bcc
Email's 'Bcc' list.
Definition: envelope.h:62
char * xref
List of cross-references.
Definition: envelope.h:79
char * organization
Organisation header.
Definition: envelope.h:77
char * x_label
X-Label.
Definition: envelope.h:76
char * list_post
This stores a mailto URL, or nothing.
Definition: envelope.h:67
char *const real_subj
Offset of the real subject.
Definition: envelope.h:71
char * date
Sent date.
Definition: envelope.h:75
char * list_unsubscribe
This stores a mailto URL, or nothing.
Definition: envelope.h:69
struct AddressList from
Email's 'From' list.
Definition: envelope.h:59
A List node for strings.
Definition: list.h:37
char * data
String.
Definition: list.h:38
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
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
LinkedList Tag Element.
Definition: tags.h:42
char * name
Tag name.
Definition: tags.h:43
void driver_tags_add(struct TagList *tl, char *new_tag)
Add a tag to header.
Definition: tags.c:107