prelude_msg_read ()

int
prelude_msg_read (prelude_msg_t **msg,
                  prelude_io_t *pio);

Read a message on pio into msg . If msg is NULL, it is allocated. This function will never block.

prelude_msg_forward ()

int
prelude_msg_forward (prelude_msg_t *msg,
                     prelude_io_t *dst,
                     prelude_io_t *src);

prelude_msg_forward() read the message corresponding to the msg object containing the message header previously gathered using prelude_msg_read_header() from the src object, and transfer it to dst . The header is also transfered.

prelude_msg_get ()

int
prelude_msg_get (prelude_msg_t *msg,
                 uint8_t *tag,
                 uint32_t *len,
                 void **buf);

prelude_msg_get() read the next data chunk contained in the message. tag is updated to contain the kind of data the chunk contain. len is updated to contain the len of the data chunk. buf is updated to point on the data chunk.

prelude_msg_recycle ()

void
prelude_msg_recycle (prelude_msg_t *msg);

Recycle msg so you can write at it again, even thought it was written.

prelude_msg_mark_end ()

void
prelude_msg_mark_end (prelude_msg_t *msg);

Mark end of message in the msg buffer, so you can continue adding different message in the same buffer.

prelude_msg_dynamic_new ()

int
prelude_msg_dynamic_new (prelude_msg_t **ret,
                         int (*flush_msg_cb) (prelude_msg_t **msg, void *data),
                         void *data);

Allocate a new prelude_msg_t object. prelude_msg_set() can then be used to add chunk of data to the message, and prelude_msg_mark_start() to separate different message in the same buffer.

This function use memory chunk of static size to store the message in. If the size of the data you want to store is bigger than the actual chunk size, flush_msg_cb callback will be called for the current message to be flushed, and the returned message will be used in order to store remaining data.

prelude_msg_new ()

int
prelude_msg_new (prelude_msg_t **ret,
                 size_t msgcount,
                 size_t msglen,
                 uint8_t tag,
                 prelude_msg_priority_t priority);

Allocate a new prelude_msg_t object and store it into ret . prelude_msg_set() can then be used to add chunk of data to the message, and prelude_msg_write() to send it.

prelude_msg_set ()

int
prelude_msg_set (prelude_msg_t *msg,
                 uint8_t tag,
                 uint32_t len,
                 const void *data);

prelude_msg_set() append len bytes of data from the data buffer to the msg object representing a message. The data is tagged with tag .

prelude_msg_write ()

int
prelude_msg_write (prelude_msg_t *msg,
                   prelude_io_t *dst);

prelude_msg_write() write the message corresponding to the msg object to dst . The message should have been created using the prelude_msg_new() and prelude_msg_set() functions.

prelude_msg_set_tag ()

void
prelude_msg_set_tag (prelude_msg_t *msg,
                     uint8_t tag);

Tag msg .

prelude_msg_set_priority ()

void
prelude_msg_set_priority (prelude_msg_t *msg,
                          prelude_msg_priority_t priority);

Associate priority with msg .

prelude_msg_get_tag ()

uint8_t
prelude_msg_get_tag (prelude_msg_t *msg);

prelude_msg_get_tag() return the tag contained in the msg header.

prelude_msg_get_priority ()

prelude_msg_priority_t
prelude_msg_get_priority (prelude_msg_t *msg);

prelude_msg_get_priority() return the priority contained in the msg header.

prelude_msg_get_len ()

uint32_t
prelude_msg_get_len (prelude_msg_t *msg);

prelude_msg_get_len() return the currently used len for the msg message.

prelude_msg_get_datalen ()

uint32_t
prelude_msg_get_datalen (prelude_msg_t *msg);

prelude_msg_get_datalen() return the len of the whole message contained in the msg header.

prelude_msg_destroy ()

void
prelude_msg_destroy (prelude_msg_t *msg);

prelude_msg_destroy() destroy the prelude_msg_t object pointed to by msg . All the ressources for this message are freed.

prelude_msg_get_time ()

struct timeval *
prelude_msg_get_time (prelude_msg_t *msg,
                      struct timeval *tv);

prelude_msg_is_empty ()

int
prelude_msg_is_empty (prelude_msg_t *msg);

prelude_msg_is_fragment ()

int
prelude_msg_is_fragment (prelude_msg_t *msg);

prelude_msg_ref ()

prelude_msg_t *
prelude_msg_ref (prelude_msg_t *msg);

prelude_msg_set_callback ()

void
prelude_msg_set_callback (prelude_msg_t *msg,
                          int (*flush_msg_cb) (prelude_msg_t **msg, void *data));

prelude_msg_set_callback() allow to change the callback used to flush a message created with prelude_msg_dynamic_new().

prelude_msg_set_data ()

void
prelude_msg_set_data (prelude_msg_t *msg,
                      void *data);

prelude_msg_set_data() allow to change the data passed to the message sending callback.

prelude_msg_get_message_data ()

const unsigned char *
prelude_msg_get_message_data (prelude_msg_t *msg);

prelude_msg_t

typedef struct prelude_msg prelude_msg_t;

enum prelude_msg_priority_t