serialize.c File Reference

Email-object serialiser. More...

#include "config.h"
#include <stdbool.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "alias/lib.h"
#include "serialize.h"

Include dependency graph for serialize.c:

Go to the source code of this file.

Macros
#define	SERIAL_MAX_CHAR_SIZE   (256 * 1024)
	Max size for a single serialized string field (256 KiB).
#define	SERIAL_MAX_LIST_COUNT   1024
	Max entries in a serialized list (addresses, headers, parameters, tags).

Functions
static bool	serial_in_bounds (int off, size_t need, size_t dlen)
	Does a read stay within the serialized blob?
void	lazy_realloc (void *ptr, size_t size)
	Reallocate some memory.
unsigned char *	serial_dump_int (const unsigned int i, unsigned char *d, int *off)
	Pack an integer into a binary blob.
unsigned char *	serial_dump_uint32_t (const uint32_t s, unsigned char *d, int *off)
	Pack a uint32_t into a binary blob.
unsigned char *	serial_dump_uint64_t (const uint64_t s, unsigned char *d, int *off)
	Pack a uint64_t into a binary blob.
bool	serial_restore_int (unsigned int *i, const unsigned char *d, int *off, size_t dlen)
	Unpack an integer from a binary blob.
bool	serial_restore_uint32_t (uint32_t *s, const unsigned char *d, int *off, size_t dlen)
	Unpack an uint32_t from a binary blob.
bool	serial_restore_uint64_t (uint64_t *s, const unsigned char *d, int *off, size_t dlen)
	Unpack an uint64_t from a binary blob.
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.
unsigned char *	serial_dump_char (const char *c, unsigned char *d, int *off, bool convert)
	Pack a variable-length string into a binary blob.
bool	serial_restore_char (char **c, const unsigned char *d, int *off, size_t dlen, bool convert)
	Unpack a variable-length string from a binary blob.
unsigned char *	serial_dump_address (const struct AddressList *al, unsigned char *d, int *off, bool convert)
	Pack an Address into a binary blob.
bool	serial_restore_address (struct AddressList *al, const unsigned char *d, int *off, size_t dlen, bool convert)
	Unpack an Address from a binary blob.
unsigned char *	serial_dump_stailq (const struct ListHead *l, unsigned char *d, int *off, bool convert)
	Pack a STAILQ into a binary blob.
bool	serial_restore_stailq (struct ListHead *l, const unsigned char *d, int *off, size_t dlen, bool convert)
	Unpack a STAILQ from a binary blob.
unsigned char *	serial_dump_buffer (const struct Buffer *buf, unsigned char *d, int *off, bool convert)
	Pack a Buffer into a binary blob.
bool	serial_restore_buffer (struct Buffer *buf, const unsigned char *d, int *off, size_t dlen, bool convert)
	Unpack a Buffer from a binary blob.
unsigned char *	serial_dump_parameter (const struct ParameterList *pl, unsigned char *d, int *off, bool convert)
	Pack a Parameter into a binary blob.
bool	serial_restore_parameter (struct ParameterList *pl, const unsigned char *d, int *off, size_t dlen, bool convert)
	Unpack a Parameter from a binary blob.
static uint32_t	body_pack_flags (const struct Body *b)
	Pack the Body flags into a uint32_t.
static void	body_unpack_flags (struct Body *b, uint32_t packed)
	Unpack the Body flags from a uint32_t.
unsigned char *	serial_dump_body (const struct Body *b, unsigned char *d, int *off, bool convert)
	Pack an Body into a binary blob.
bool	serial_restore_body (struct Body *b, const unsigned char *d, int *off, size_t dlen, bool convert)
	Unpack a Body from a binary blob.
unsigned char *	serial_dump_envelope (const struct Envelope *env, unsigned char *d, int *off, bool convert)
	Pack an Envelope into a binary blob.
bool	serial_restore_envelope (struct Envelope *env, const unsigned char *d, int *off, size_t dlen, bool convert)
	Unpack an Envelope from a binary blob.
unsigned char *	serial_dump_tags (const struct TagList *tl, unsigned char *d, int *off)
	Pack a TagList into a binary blob.
bool	serial_restore_tags (struct TagList *tl, const unsigned char *d, int *off, size_t dlen)
	Unpack a TagList from a binary blob.

Detailed Description

Email-object serialiser.

Authors

• Richard Russon
• Pietro Cerutti
• Anna Figueiredo Gomes

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

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

Macro Definition Documentation

SERIAL_MAX_CHAR_SIZE

#define SERIAL_MAX_CHAR_SIZE   (256 * 1024)

Max size for a single serialized string field (256 KiB).

Definition at line 45 of file serialize.c.

SERIAL_MAX_LIST_COUNT

#define SERIAL_MAX_LIST_COUNT   1024

Max entries in a serialized list (addresses, headers, parameters, tags).

Definition at line 48 of file serialize.c.

Function Documentation

serial_in_bounds()

bool serial_in_bounds ( int off, size_t need, size_t dlen )

static

Does a read stay within the serialized blob?

Parameters

off	Current offset into the blob
need	Number of bytes about to be read
dlen	Total length of the blob

Return values

true	The read is fully contained in the blob

The restore helpers walk a blob whose length is only known to the caller. A truncated or crafted cache entry can claim fields that extend past the end of the fetched data, so every read is checked against dlen first.

Definition at line 61 of file serialize.c.

{
  return (off >= 0) && (need <= dlen) && ((size_t) off <= (dlen - need));
}

Here is the caller graph for this function:

lazy_realloc()

void lazy_realloc	(	void *	ptr,
		size_t	size )

Reallocate some memory.

Parameters

[in]	ptr	Pointer to resize
[in]	size	Minimum size

The minimum size is 4KiB to avoid repeated resizing.

Definition at line 73 of file serialize.c.

{
  void **p = (void **) ptr;
 
  if (p && (size < 4096))
    return;
 
  mutt_mem_realloc(ptr, size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_dump_int()

unsigned char * serial_dump_int	(	const unsigned int	i,
		unsigned char *	d,
		int *	off )

Pack an integer into a binary blob.

Parameters

[in]	i	Integer to save
[in]	d	Binary blob to add to
[in,out]	off	Offset into the blob

Return values

ptr	End of the newly packed binary

Definition at line 90 of file serialize.c.

{
  lazy_realloc(&d, *off + sizeof(int));
  memcpy(d + *off, &i, sizeof(int));
  (*off) += sizeof(int);
 
  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_dump_uint32_t()

unsigned char * serial_dump_uint32_t	(	const uint32_t	s,
		unsigned char *	d,
		int *	off )

Pack a uint32_t into a binary blob.

Parameters

[in]	s	uint32_t to save
[in]	d	Binary blob to add to
[in,out]	off	Offset into the blob

Return values

ptr	End of the newly packed binary

Definition at line 106 of file serialize.c.

{
  lazy_realloc(&d, *off + sizeof(uint32_t));
  memcpy(d + *off, &s, sizeof(uint32_t));
  (*off) += sizeof(uint32_t);
 
  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_dump_uint64_t()

unsigned char * serial_dump_uint64_t	(	const uint64_t	s,
		unsigned char *	d,
		int *	off )

Pack a uint64_t into a binary blob.

Parameters

[in]	s	uint64_t to save
[in]	d	Binary blob to add to
[in,out]	off	Offset into the blob

Return values

ptr	End of the newly packed binary

Definition at line 122 of file serialize.c.

{
  lazy_realloc(&d, *off + sizeof(uint64_t));
  memcpy(d + *off, &s, sizeof(uint64_t));
  (*off) += sizeof(uint64_t);
 
  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_restore_int()

bool serial_restore_int	(	unsigned int *	i,
		const unsigned char *	d,
		int *	off,
		size_t	dlen )

Unpack an integer from a binary blob.

Parameters

[in]	i	Integer to write to
[in]	d	Binary blob to read from
[in,out]	off	Offset into the blob
[in]	dlen	Length of the binary blob

Return values

true	The integer was read
false	The read would leave the blob

Definition at line 140 of file serialize.c.

{
  if (!serial_in_bounds(*off, sizeof(int), dlen))
    return false;
 
  memcpy(i, d + *off, sizeof(int));
  (*off) += sizeof(int);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_restore_uint32_t()

bool serial_restore_uint32_t	(	uint32_t *	s,
		const unsigned char *	d,
		int *	off,
		size_t	dlen )

Unpack an uint32_t from a binary blob.

Parameters

[in]	s	uint32_t to write to
[in]	d	Binary blob to read from
[in,out]	off	Offset into the blob
[in]	dlen	Length of the binary blob

Return values

true	The uint32_t was read
false	The read would leave the blob

Definition at line 159 of file serialize.c.

{
  if (!serial_in_bounds(*off, sizeof(uint32_t), dlen))
    return false;
 
  memcpy(s, d + *off, sizeof(uint32_t));
  (*off) += sizeof(uint32_t);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_restore_uint64_t()

bool serial_restore_uint64_t	(	uint64_t *	s,
		const unsigned char *	d,
		int *	off,
		size_t	dlen )

Unpack an uint64_t from a binary blob.

Parameters

[in]	s	uint64_t to write to
[in]	d	Binary blob to read from
[in,out]	off	Offset into the blob
[in]	dlen	Length of the binary blob

Return values

true	The uint64_t was read
false	The read would leave the blob

Definition at line 178 of file serialize.c.

{
  if (!serial_in_bounds(*off, sizeof(uint64_t), dlen))
    return false;
 
  memcpy(s, d + *off, sizeof(uint64_t));
  (*off) += sizeof(uint64_t);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_dump_char_size()

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.

Parameters

[in]	c	String to pack
[in]	d	Binary blob to add to
[in]	size	Size of the string
[in,out]	off	Offset into the blob
[in]	convert	If true, the strings will be converted to utf-8

Return values

ptr	End of the newly packed binary

Definition at line 197 of file serialize.c.

{
  char *p = NULL;
 
  if (!c || (*c == '\0') || (size == 0))
  {
    return serial_dump_int(0, d, off);
  }
 
  if (convert && !mutt_str_is_ascii(c, size))
  {
    p = mutt_strn_dup(c, size);
    if (mutt_ch_convert_string(&p, cc_charset(), "utf-8", MUTT_ICONV_NONE) == 0)
    {
      size = mutt_str_len(p) + 1;
    }
  }
 
  d = serial_dump_int(size, d, off);
  lazy_realloc(&d, *off + size);
  memcpy(d + *off, p ? p : c, size);
  *off += size;
 
  FREE(&p);
 
  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_dump_char()

unsigned char * serial_dump_char	(	const char *	c,
		unsigned char *	d,
		int *	off,
		bool	convert )

Pack a variable-length string into a binary blob.

Parameters

[in]	c	String to pack
[in]	d	Binary blob to add to
[in,out]	off	Offset into the blob
[in]	convert	If true, the strings will be converted to utf-8

Return values

ptr	End of the newly packed binary

Definition at line 234 of file serialize.c.

{
  return serial_dump_char_size(c, mutt_str_len(c) + 1, d, off, convert);
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_restore_char()

bool serial_restore_char	(	char **	c,
		const unsigned char *	d,
		int *	off,
		size_t	dlen,
		bool	convert )

Unpack a variable-length string from a binary blob.

Parameters

[out]	c	Store the unpacked string here
[in]	d	Binary blob to read from
[in,out]	off	Offset into the blob
[in]	dlen	Length of the binary blob
[in]	convert	If true, the strings will be converted to utf-8

Return values

true	The string was read (an empty string yields a NULL c)
false	The read would leave the blob

Definition at line 249 of file serialize.c.

{
  *c = NULL;
 
  unsigned int size = 0;
  if (!serial_restore_int(&size, d, off, dlen))
    return false;
 
  if (size == 0)
    return true;
 
  if ((size > SERIAL_MAX_CHAR_SIZE) || !serial_in_bounds(*off, size, dlen))
    return false;
 
  *c = MUTT_MEM_MALLOC(size, char);
  memcpy(*c, d + *off, size);
  if (convert && !mutt_str_is_ascii(*c, size))
  {
    char *tmp = mutt_str_dup(*c);
    if (mutt_ch_convert_string(&tmp, "utf-8", cc_charset(), MUTT_ICONV_NONE) == 0)
    {
      FREE(c);
      *c = tmp;
    }
    else
    {
      FREE(&tmp);
    }
  }
  *off += size;
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_dump_address()

unsigned char * serial_dump_address	(	const struct AddressList *	al,
		unsigned char *	d,
		int *	off,
		bool	convert )

Pack an Address into a binary blob.

Parameters

[in]	al	AddressList to pack
[in]	d	Binary blob to add to
[in,out]	off	Offset into the blob
[in]	convert	If true, the strings will be converted to utf-8

Return values

ptr	End of the newly packed binary

Definition at line 290 of file serialize.c.

{
  unsigned int counter = 0;
  unsigned int start_off = *off;
 
  d = serial_dump_int(0xdeadbeef, d, off);
 
  struct Address *a = NULL;
  TAILQ_FOREACH(a, al, entries)
  {
    d = serial_dump_buffer(a->personal, d, off, convert);
    d = serial_dump_buffer(a->mailbox, d, off, convert);
    d = serial_dump_int(a->group, d, off);
    counter++;
  }
 
  memcpy(d + start_off, &counter, sizeof(int));
 
  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_restore_address()

bool serial_restore_address	(	struct AddressList *	al,
		const unsigned char *	d,
		int *	off,
		size_t	dlen,
		bool	convert )

Unpack an Address from a binary blob.

Parameters

[out]	al	Store the unpacked AddressList here
[in]	d	Binary blob to read from
[in,out]	off	Offset into the blob
[in]	dlen	Length of the binary blob
[in]	convert	If true, the strings will be converted from utf-8

Return values

true	The AddressList was read
false	A read would leave the blob, or the count is out of range

Definition at line 322 of file serialize.c.

{
  unsigned int counter = 0;
  unsigned int g = 0;
 
  if (!serial_restore_int(&counter, d, off, dlen))
    return false;
 
  if (counter > SERIAL_MAX_LIST_COUNT)
    return false;
 
  while (counter > 0)
  {
    struct Address *a = mutt_addr_new();
    mutt_addrlist_append(al, a);
 
    a->personal = buf_new(NULL);
    if (!serial_restore_buffer(a->personal, d, off, dlen, convert))
      return false;
    if (buf_is_empty(a->personal))
    {
      buf_free(&a->personal);
    }
 
    a->mailbox = buf_new(NULL);
    if (!serial_restore_buffer(a->mailbox, d, off, dlen, false))
      return false;
    if (buf_is_empty(a->mailbox))
    {
      buf_free(&a->mailbox);
    }
 
    if (!serial_restore_int(&g, d, off, dlen))
      return false;
    a->group = !!g;
    counter--;
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_dump_stailq()

unsigned char * serial_dump_stailq	(	const struct ListHead *	l,
		unsigned char *	d,
		int *	off,
		bool	convert )

Pack a STAILQ into a binary blob.

Parameters

[in]	l	List to read from
[in]	d	Binary blob to add to
[in,out]	off	Offset into the blob
[in]	convert	If true, the strings will be converted to utf-8

Return values

ptr	End of the newly packed binary

Definition at line 372 of file serialize.c.

{
  unsigned int counter = 0;
  unsigned int start_off = *off;
 
  d = serial_dump_int(0xdeadbeef, d, off);
 
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, l, entries)
  {
    d = serial_dump_char(np->data, d, off, convert);
    counter++;
  }
 
  memcpy(d + start_off, &counter, sizeof(int));
 
  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_restore_stailq()

bool serial_restore_stailq	(	struct ListHead *	l,
		const unsigned char *	d,
		int *	off,
		size_t	dlen,
		bool	convert )

Unpack a STAILQ from a binary blob.

Parameters

[in]	l	List to add to
[in]	d	Binary blob to read from
[in,out]	off	Offset into the blob
[in]	dlen	Length of the binary blob
[in]	convert	If true, the strings will be converted from utf-8

Return values

true	The list was read
false	A read would leave the blob, or the count is out of range

Definition at line 402 of file serialize.c.

{
  unsigned int counter = 0;
 
  if (!serial_restore_int(&counter, d, off, dlen))
    return false;
 
  if (counter > SERIAL_MAX_LIST_COUNT)
    return false;
 
  struct ListNode *np = NULL;
  while (counter > 0)
  {
    np = mutt_list_insert_tail(l, NULL);
    if (!serial_restore_char(&np->data, d, off, dlen, convert))
      return false;
    counter--;
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_dump_buffer()

unsigned char * serial_dump_buffer	(	const struct Buffer *	buf,
		unsigned char *	d,
		int *	off,
		bool	convert )

Pack a Buffer into a binary blob.

Parameters

[in]	buf	Buffer to pack
[in]	d	Binary blob to add to
[in,out]	off	Offset into the blob
[in]	convert	If true, the strings will be converted to utf-8

Return values

ptr	End of the newly packed binary

Definition at line 433 of file serialize.c.

{
  if (buf_is_empty(buf))
  {
    d = serial_dump_int(0, d, off);
    return d;
  }
 
  d = serial_dump_int(1, d, off);
 
  d = serial_dump_char(buf->data, d, off, convert);
 
  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_restore_buffer()

bool serial_restore_buffer	(	struct Buffer *	buf,
		const unsigned char *	d,
		int *	off,
		size_t	dlen,
		bool	convert )

Unpack a Buffer from a binary blob.

Parameters

[out]	buf	Store the unpacked Buffer here
[in]	d	Binary blob to read from
[in,out]	off	Offset into the blob
[in]	dlen	Length of the binary blob
[in]	convert	If true, the strings will be converted from utf-8

Return values

true	The Buffer was read
false	A read would leave the blob

Definition at line 459 of file serialize.c.

{
  buf_alloc(buf, 1);
 
  unsigned int used = 0;
  if (!serial_restore_int(&used, d, off, dlen))
    return false;
  if (used == 0)
    return true;
 
  char *str = NULL;
  if (!serial_restore_char(&str, d, off, dlen, convert))
    return false;
 
  buf_addstr(buf, str);
  FREE(&str);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_dump_parameter()

unsigned char * serial_dump_parameter	(	const struct ParameterList *	pl,
		unsigned char *	d,
		int *	off,
		bool	convert )

Pack a Parameter into a binary blob.

Parameters

[in]	pl	Parameter to pack
[in]	d	Binary blob to add to
[in,out]	off	Offset into the blob
[in]	convert	If true, the strings will be converted to utf-8

Return values

ptr	End of the newly packed binary

Definition at line 487 of file serialize.c.

{
  unsigned int counter = 0;
  unsigned int start_off = *off;
 
  d = serial_dump_int(0xdeadbeef, d, off);
 
  struct Parameter *np = NULL;
  TAILQ_FOREACH(np, pl, entries)
  {
    d = serial_dump_char(np->attribute, d, off, false);
    d = serial_dump_char(np->value, d, off, convert);
    counter++;
  }
 
  memcpy(d + start_off, &counter, sizeof(int));
 
  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_restore_parameter()

bool serial_restore_parameter	(	struct ParameterList *	pl,
		const unsigned char *	d,
		int *	off,
		size_t	dlen,
		bool	convert )

Unpack a Parameter from a binary blob.

Parameters

[in]	pl	Store the unpacked Parameter here
[in]	d	Binary blob to read from
[in,out]	off	Offset into the blob
[in]	dlen	Length of the binary blob
[in]	convert	If true, the strings will be converted from utf-8

Return values

true	The Parameter was read
false	A read would leave the blob, or the count is out of range

Definition at line 518 of file serialize.c.

{
  unsigned int counter = 0;
 
  if (!serial_restore_int(&counter, d, off, dlen))
    return false;
 
  if (counter > SERIAL_MAX_LIST_COUNT)
    return false;
 
  struct Parameter *np = NULL;
  while (counter > 0)
  {
    np = mutt_param_new();
    TAILQ_INSERT_TAIL(pl, np, entries);
    if (!serial_restore_char(&np->attribute, d, off, dlen, false))
      return false;
    if (!serial_restore_char(&np->value, d, off, dlen, convert))
      return false;
    counter--;
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

body_pack_flags()

uint32_t body_pack_flags ( const struct Body * b )

inlinestatic

Pack the Body flags into a uint32_t.

Parameters

b	Body to pack

Return values

num	uint32_t of packed flags

Note

Order of packing must match body_unpack_flags()

Definition at line 551 of file serialize.c.

{
  if (!b)
    return 0;
 
  // clang-format off
  uint32_t packed = b->type +
                   (b->encoding      <<  4) +
                   (b->disposition   <<  7) +
                   (b->badsig        <<  9) +
                   (b->force_charset << 10) +
                   (b->goodsig       << 11) +
                   (b->noconv        << 12) +
                   (b->use_disp      << 13) +
                   (b->warnsig       << 14);
  // clang-format on
#ifdef USE_AUTOCRYPT
  packed += (b->is_autocrypt << 15);
#endif
 
  return packed;
}

Here is the caller graph for this function:

body_unpack_flags()

void body_unpack_flags ( struct Body * b, uint32_t packed )

inlinestatic

Unpack the Body flags from a uint32_t.

Parameters

b	Body to unpack into
packed	Packed flags

Note

Order of packing must match body_pack_flags()

Definition at line 581 of file serialize.c.

{
  if (!b)
    return;
 
  // clang-format off
  b->type         =  (packed       & ((1 << 4) - 1)); // bits 0-3 (4)
  b->encoding     = ((packed >> 4) & ((1 << 3) - 1)); // bits 4-6 (3)
  b->disposition  = ((packed >> 7) & ((1 << 2) - 1)); // bits 7-8 (2)
 
  b->badsig        = (packed & (1 <<  9));
  b->force_charset = (packed & (1 << 10));
  b->goodsig       = (packed & (1 << 11));
  b->noconv        = (packed & (1 << 12));
  b->use_disp      = (packed & (1 << 13));
  b->warnsig       = (packed & (1 << 14));
#ifdef USE_AUTOCRYPT
  b->is_autocrypt  = (packed & (1 << 15));
#endif
  // clang-format on
}

Here is the caller graph for this function:

serial_dump_body()

unsigned char * serial_dump_body	(	const struct Body *	b,
		unsigned char *	d,
		int *	off,
		bool	convert )

Pack an Body into a binary blob.

Parameters

[in]	b	Body to pack
[in]	d	Binary blob to add to
[in,out]	off	Offset into the blob
[in]	convert	If true, the strings will be converted to utf-8

Return values

ptr	End of the newly packed binary

Definition at line 611 of file serialize.c.

{
  uint32_t packed = body_pack_flags(b);
  d = serial_dump_uint32_t(packed, d, off);
 
  uint64_t big = b->offset;
  d = serial_dump_uint64_t(big, d, off);
 
  big = b->length;
  d = serial_dump_uint64_t(big, d, off);
 
  d = serial_dump_char(b->xtype, d, off, false);
  d = serial_dump_char(b->subtype, d, off, false);
 
  d = serial_dump_parameter(&b->parameter, d, off, convert);
 
  d = serial_dump_char(b->description, d, off, convert);
  d = serial_dump_char(b->content_id, d, off, convert);
  d = serial_dump_char(b->form_name, d, off, convert);
  d = serial_dump_char(b->filename, d, off, convert);
  d = serial_dump_char(b->d_filename, d, off, convert);
 
  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_restore_body()

bool serial_restore_body	(	struct Body *	b,
		const unsigned char *	d,
		int *	off,
		size_t	dlen,
		bool	convert )

Unpack a Body from a binary blob.

Parameters

[in]	b	Store the unpacked Body here
[in]	d	Binary blob to read from
[in,out]	off	Offset into the blob
[in]	dlen	Length of the binary blob
[in]	convert	If true, the strings will be converted from utf-8

Return values

true	The Body was read
false	A read would leave the blob

Definition at line 646 of file serialize.c.

{
  uint32_t packed = 0;
  if (!serial_restore_uint32_t(&packed, d, off, dlen))
    return false;
  body_unpack_flags(b, packed);
 
  uint64_t big = 0;
  if (!serial_restore_uint64_t(&big, d, off, dlen))
    return false;
  b->offset = big;
 
  big = 0;
  if (!serial_restore_uint64_t(&big, d, off, dlen))
    return false;
  b->length = big;
 
  if (!serial_restore_char(&b->xtype, d, off, dlen, false))
    return false;
  if (!serial_restore_char(&b->subtype, d, off, dlen, false))
    return false;
 
  TAILQ_INIT(&b->parameter);
  if (!serial_restore_parameter(&b->parameter, d, off, dlen, convert))
    return false;
 
  if (!serial_restore_char(&b->description, d, off, dlen, convert))
    return false;
  if (!serial_restore_char(&b->content_id, d, off, dlen, convert))
    return false;
  if (!serial_restore_char(&b->form_name, d, off, dlen, convert))
    return false;
  if (!serial_restore_char(&b->filename, d, off, dlen, convert))
    return false;
  if (!serial_restore_char(&b->d_filename, d, off, dlen, convert))
    return false;
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_dump_envelope()

unsigned char * serial_dump_envelope	(	const struct Envelope *	env,
		unsigned char *	d,
		int *	off,
		bool	convert )

Pack an Envelope into a binary blob.

Parameters

[in]	env	Envelope to pack
[in]	d	Binary blob to add to
[in,out]	off	Offset into the blob
[in]	convert	If true, the strings will be converted to utf-8

Return values

ptr	End of the newly packed binary

Definition at line 695 of file serialize.c.

{
  d = serial_dump_address(&env->return_path, d, off, convert);
  d = serial_dump_address(&env->from, d, off, convert);
  d = serial_dump_address(&env->to, d, off, convert);
  d = serial_dump_address(&env->cc, d, off, convert);
  d = serial_dump_address(&env->bcc, d, off, convert);
  d = serial_dump_address(&env->sender, d, off, convert);
  d = serial_dump_address(&env->reply_to, d, off, convert);
  d = serial_dump_address(&env->mail_followup_to, d, off, convert);
 
  d = serial_dump_char(env->list_post, d, off, convert);
  d = serial_dump_char(env->list_subscribe, d, off, convert);
  d = serial_dump_char(env->list_unsubscribe, d, off, convert);
  d = serial_dump_char(env->subject, d, off, convert);
 
  if (env->real_subj)
    d = serial_dump_int(env->real_subj - env->subject, d, off);
  else
    d = serial_dump_int(-1, d, off);
 
  d = serial_dump_char(env->message_id, d, off, false);
  d = serial_dump_char(env->supersedes, d, off, false);
  d = serial_dump_char(env->date, d, off, false);
  d = serial_dump_char(env->x_label, d, off, convert);
  d = serial_dump_char(env->organization, d, off, convert);
 
  d = serial_dump_buffer(&env->spam, d, off, convert);
 
  d = serial_dump_stailq(&env->references, d, off, false);
  d = serial_dump_stailq(&env->in_reply_to, d, off, false);
  d = serial_dump_stailq(&env->userhdrs, d, off, convert);
 
  d = serial_dump_char(env->xref, d, off, false);
  d = serial_dump_char(env->followup_to, d, off, false);
  d = serial_dump_char(env->x_comment_to, d, off, convert);
 
  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_restore_envelope()

bool serial_restore_envelope	(	struct Envelope *	env,
		const unsigned char *	d,
		int *	off,
		size_t	dlen,
		bool	convert )

Unpack an Envelope from a binary blob.

Parameters

[in]	env	Store the unpacked Envelope here
[in]	d	Binary blob to read from
[in,out]	off	Offset into the blob
[in]	dlen	Length of the binary blob
[in]	convert	If true, the strings will be converted from utf-8

Return values

true	The Envelope was read
false	A read would leave the blob

Definition at line 746 of file serialize.c.

{
  int real_subj_off = 0;
 
  if (!serial_restore_address(&env->return_path, d, off, dlen, convert) ||
      !serial_restore_address(&env->from, d, off, dlen, convert) ||
      !serial_restore_address(&env->to, d, off, dlen, convert) ||
      !serial_restore_address(&env->cc, d, off, dlen, convert) ||
      !serial_restore_address(&env->bcc, d, off, dlen, convert) ||
      !serial_restore_address(&env->sender, d, off, dlen, convert) ||
      !serial_restore_address(&env->reply_to, d, off, dlen, convert) ||
      !serial_restore_address(&env->mail_followup_to, d, off, dlen, convert))
  {
    return false;
  }
 
  if (!serial_restore_char(&env->list_post, d, off, dlen, convert) ||
      !serial_restore_char(&env->list_subscribe, d, off, dlen, convert) ||
      !serial_restore_char(&env->list_unsubscribe, d, off, dlen, convert))
  {
    return false;
  }
 
  const bool c_auto_subscribe = cs_subset_bool(NeoMutt->sub, "auto_subscribe");
  if (c_auto_subscribe)
    mutt_auto_subscribe(env->list_post);
 
  if (!serial_restore_char((char **) &env->subject, d, off, dlen, convert))
    return false;
  if (!serial_restore_int((unsigned int *) (&real_subj_off), d, off, dlen))
    return false;
 
  size_t len = mutt_str_len(env->subject);
  if ((real_subj_off < 0) || (real_subj_off >= len))
    *(char **) &env->real_subj = NULL;
  else
    *(char **) &env->real_subj = env->subject + real_subj_off;
 
  if (!serial_restore_char(&env->message_id, d, off, dlen, false) ||
      !serial_restore_char(&env->supersedes, d, off, dlen, false) ||
      !serial_restore_char(&env->date, d, off, dlen, false) ||
      !serial_restore_char(&env->x_label, d, off, dlen, convert) ||
      !serial_restore_char(&env->organization, d, off, dlen, convert))
  {
    return false;
  }
 
  if (!serial_restore_buffer(&env->spam, d, off, dlen, convert))
    return false;
 
  if (!serial_restore_stailq(&env->references, d, off, dlen, false) ||
      !serial_restore_stailq(&env->in_reply_to, d, off, dlen, false) ||
      !serial_restore_stailq(&env->userhdrs, d, off, dlen, convert))
  {
    return false;
  }
 
  if (!serial_restore_char(&env->xref, d, off, dlen, false) ||
      !serial_restore_char(&env->followup_to, d, off, dlen, false) ||
      !serial_restore_char(&env->x_comment_to, d, off, dlen, convert))
  {
    return false;
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_dump_tags()

unsigned char * serial_dump_tags	(	const struct TagList *	tl,
		unsigned char *	d,
		int *	off )

Pack a TagList into a binary blob.

Parameters

[in]	tl	TagList to pack
[in]	d	Binary blob to add to
[in,out]	off	Offset into the blob

Return values

ptr	End of the newly packed binary

Definition at line 821 of file serialize.c.

{
  unsigned int counter = 0;
  unsigned int start_off = *off;
 
  d = serial_dump_int(0xdeadbeef, d, off);
 
  struct Tag *tag = NULL;
  STAILQ_FOREACH(tag, tl, entries)
  {
    d = serial_dump_char(tag->name, d, off, false);
    counter++;
  }
 
  memcpy(d + start_off, &counter, sizeof(int));
 
  return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

serial_restore_tags()

bool serial_restore_tags	(	struct TagList *	tl,
		const unsigned char *	d,
		int *	off,
		size_t	dlen )

Unpack a TagList from a binary blob.

Parameters

[in]	tl	TagList to unpack
[in]	d	Binary blob to add to
[in,out]	off	Offset into the blob
[in]	dlen	Length of the binary blob

Return values

true	The TagList was read
false	A read would leave the blob, or the count is out of range

Definition at line 849 of file serialize.c.

{
  unsigned int counter = 0;
 
  if (!serial_restore_int(&counter, d, off, dlen))
    return false;
 
  if (counter > SERIAL_MAX_LIST_COUNT)
    return false;
 
  while (counter > 0)
  {
    char *name = NULL;
    if (!serial_restore_char(&name, d, off, dlen, false))
      return false;
    driver_tags_add(tl, name);
    counter--;
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function: