serialize.h File Reference

Email-object serialiser. More...

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <sys/types.h>

Include dependency graph for serialize.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
unsigned char *	serial_dump_address (const struct AddressList *al, unsigned char *d, int *off, bool convert)
	Pack an Address into a binary blob.
unsigned char *	serial_dump_body (const struct Body *b, unsigned char *d, int *off, bool convert)
	Pack an Body into a binary blob.
unsigned char *	serial_dump_tags (const struct TagList *tl, unsigned char *d, int *off)
	Pack a TagList into 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.
unsigned char *	serial_dump_char (const char *c, unsigned char *d, int *off, bool convert)
	Pack a variable-length string into 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_envelope (const struct Envelope *env, unsigned char *d, int *off, bool convert)
	Pack an Envelope into a binary blob.
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.
unsigned char *	serial_dump_parameter (const struct ParameterList *pl, unsigned char *d, int *off, bool convert)
	Pack a Parameter into 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_address (struct AddressList *al, const unsigned char *d, int *off, size_t dlen, bool convert)
	Unpack an Address from 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.
bool	serial_restore_tags (struct TagList *tl, const unsigned char *d, int *off, size_t dlen)
	Unpack a TagList from 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.
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.
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.
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.
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.
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.
void	lazy_realloc (void *ptr, size_t size)
	Reallocate some memory.

Detailed Description

Email-object serialiser.

Authors

• Richard Russon
• Pietro Cerutti

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

Function Documentation

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_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_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_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_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_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_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_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_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_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_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_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_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:

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_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_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_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_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:

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:

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: