zre_log_msg_t *
zre_log_msg_decode (zmsg_t **msg_p)
{
assert (msg_p);
zmsg_t *msg = *msg_p;
if (msg == NULL)
return NULL;
zre_log_msg_t *self = zre_log_msg_new (0);
// Read and parse command in frame
zframe_t *frame = zmsg_pop (msg);
if (!frame)
goto empty; // Malformed or empty
// Get and check protocol signature
self->needle = zframe_data (frame);
self->ceiling = self->needle + zframe_size (frame);
uint16_t signature;
GET_NUMBER2 (signature);
if (signature != (0xAAA0 | 2))
goto empty; // Invalid signature
// Get message id and parse per message type
GET_NUMBER1 (self->id);
switch (self->id) {
case ZRE_LOG_MSG_LOG:
GET_NUMBER1 (self->level);
GET_NUMBER1 (self->event);
GET_NUMBER2 (self->node);
GET_NUMBER2 (self->peer);
GET_NUMBER8 (self->time);
GET_STRING (self->data);
break;
default:
goto malformed;
}
// Successful return
zframe_destroy (&frame);
zmsg_destroy (msg_p);
return self;
// Error returns
malformed:
printf ("E: malformed message '%d'\n", self->id);
empty:
zframe_destroy (&frame);
zmsg_destroy (msg_p);
zre_log_msg_destroy (&self);
return (NULL);
}
zre_log_msg_t *
zre_log_msg_recv (void *input)
{
assert (input);
zre_log_msg_t *self = zre_log_msg_new (0);
zframe_t *frame = NULL;
size_t string_size;
size_t list_size;
size_t hash_size;
// Read valid message frame from socket; we loop over any
// garbage data we might receive from badly-connected peers
while (true) {
// If we're reading from a ROUTER socket, get address
if (zsocket_type (input) == ZMQ_ROUTER) {
zframe_destroy (&self->address);
self->address = zframe_recv (input);
if (!self->address)
goto empty; // Interrupted
if (!zsocket_rcvmore (input))
goto malformed;
}
// Read and parse command in frame
frame = zframe_recv (input);
if (!frame)
goto empty; // Interrupted
// Get and check protocol signature
self->needle = zframe_data (frame);
self->ceiling = self->needle + zframe_size (frame);
uint16_t signature;
GET_NUMBER2 (signature);
if (signature == (0xAAA0 | 2))
break; // Valid signature
// Protocol assertion, drop message
while (zsocket_rcvmore (input)) {
zframe_destroy (&frame);
frame = zframe_recv (input);
}
zframe_destroy (&frame);
}
// Get message id and parse per message type
GET_NUMBER1 (self->id);
switch (self->id) {
case ZRE_LOG_MSG_LOG:
GET_NUMBER1 (self->level);
GET_NUMBER1 (self->event);
GET_NUMBER2 (self->node);
GET_NUMBER2 (self->peer);
GET_NUMBER8 (self->time);
free (self->data);
GET_STRING (self->data);
break;
default:
goto malformed;
}
// Successful return
zframe_destroy (&frame);
return self;
// Error returns
malformed:
printf ("E: malformed message '%d'\n", self->id);
empty:
zframe_destroy (&frame);
zre_log_msg_destroy (&self);
return (NULL);
}
int
fmq_msg_recv (fmq_msg_t *self, zsock_t *input)
{
assert (input);
if (zsock_type (input) == ZMQ_ROUTER) {
zframe_destroy (&self->routing_id);
self->routing_id = zframe_recv (input);
if (!self->routing_id || !zsock_rcvmore (input)) {
zsys_warning ("fmq_msg: no routing ID");
return -1; // Interrupted or malformed
}
}
zmq_msg_t frame;
zmq_msg_init (&frame);
int size = zmq_msg_recv (&frame, zsock_resolve (input), 0);
if (size == -1) {
zsys_warning ("fmq_msg: interrupted");
goto malformed; // Interrupted
}
// Get and check protocol signature
self->needle = (byte *) zmq_msg_data (&frame);
self->ceiling = self->needle + zmq_msg_size (&frame);
uint16_t signature;
GET_NUMBER2 (signature);
if (signature != (0xAAA0 | 3)) {
zsys_warning ("fmq_msg: invalid signature");
// TODO: discard invalid messages and loop, and return
// -1 only on interrupt
goto malformed; // Interrupted
}
// Get message id and parse per message type
GET_NUMBER1 (self->id);
switch (self->id) {
case FMQ_MSG_OHAI:
{
char protocol [256];
GET_STRING (protocol);
if (strneq (protocol, "FILEMQ")) {
zsys_warning ("fmq_msg: protocol is invalid");
goto malformed;
}
}
{
uint16_t version;
GET_NUMBER2 (version);
if (version != FMQ_MSG_VERSION) {
zsys_warning ("fmq_msg: version is invalid");
goto malformed;
}
}
break;
case FMQ_MSG_OHAI_OK:
break;
case FMQ_MSG_ICANHAZ:
GET_LONGSTR (self->path);
{
size_t hash_size;
GET_NUMBER4 (hash_size);
self->options = zhash_new ();
zhash_autofree (self->options);
while (hash_size--) {
char key [256];
char *value = NULL;
GET_STRING (key);
GET_LONGSTR (value);
zhash_insert (self->options, key, value);
free (value);
}
}
{
size_t hash_size;
GET_NUMBER4 (hash_size);
self->cache = zhash_new ();
zhash_autofree (self->cache);
while (hash_size--) {
char key [256];
char *value = NULL;
GET_STRING (key);
GET_LONGSTR (value);
zhash_insert (self->cache, key, value);
free (value);
}
}
break;
case FMQ_MSG_ICANHAZ_OK:
break;
case FMQ_MSG_NOM:
GET_NUMBER8 (self->credit);
GET_NUMBER8 (self->sequence);
break;
case FMQ_MSG_CHEEZBURGER:
GET_NUMBER8 (self->sequence);
GET_NUMBER1 (self->operation);
GET_LONGSTR (self->filename);
GET_NUMBER8 (self->offset);
GET_NUMBER1 (self->eof);
{
size_t hash_size;
GET_NUMBER4 (hash_size);
self->headers = zhash_new ();
zhash_autofree (self->headers);
while (hash_size--) {
char key [256];
char *value = NULL;
GET_STRING (key);
GET_LONGSTR (value);
zhash_insert (self->headers, key, value);
free (value);
}
}
{
size_t chunk_size;
GET_NUMBER4 (chunk_size);
if (self->needle + chunk_size > (self->ceiling)) {
zsys_warning ("fmq_msg: chunk is missing data");
goto malformed;
}
zchunk_destroy (&self->chunk);
self->chunk = zchunk_new (self->needle, chunk_size);
self->needle += chunk_size;
}
break;
case FMQ_MSG_HUGZ:
break;
case FMQ_MSG_HUGZ_OK:
break;
case FMQ_MSG_KTHXBAI:
break;
case FMQ_MSG_SRSLY:
GET_STRING (self->reason);
break;
case FMQ_MSG_RTFM:
GET_STRING (self->reason);
break;
default:
zsys_warning ("fmq_msg: bad message ID");
goto malformed;
}
// Successful return
zmq_msg_close (&frame);
return 0;
// Error returns
malformed:
zsys_warning ("fmq_msg: fmq_msg malformed message, fail");
zmq_msg_close (&frame);
return -1; // Invalid message
}
int
zproto_example_recv (zproto_example_t *self, zsock_t *input)
{
assert (input);
if (zsock_type (input) == ZMQ_ROUTER) {
zframe_destroy (&self->routing_id);
self->routing_id = zframe_recv (input);
if (!self->routing_id || !zsock_rcvmore (input)) {
zsys_warning ("zproto_example: no routing ID");
return -1; // Interrupted or malformed
}
}
zmq_msg_t frame;
zmq_msg_init (&frame);
int size = zmq_msg_recv (&frame, zsock_resolve (input), 0);
if (size == -1) {
zsys_warning ("zproto_example: interrupted");
goto malformed; // Interrupted
}
// Get and check protocol signature
self->needle = (byte *) zmq_msg_data (&frame);
self->ceiling = self->needle + zmq_msg_size (&frame);
uint16_t signature;
GET_NUMBER2 (signature);
if (signature != (0xAAA0 | 0)) {
zsys_warning ("zproto_example: invalid signature");
// TODO: discard invalid messages and loop, and return
// -1 only on interrupt
goto malformed; // Interrupted
}
// Get message id and parse per message type
GET_NUMBER1 (self->id);
switch (self->id) {
case ZPROTO_EXAMPLE_LOG:
GET_NUMBER2 (self->sequence);
{
uint16_t version;
GET_NUMBER2 (version);
if (version != 3) {
zsys_warning ("zproto_example: version is invalid");
goto malformed;
}
}
GET_NUMBER1 (self->level);
GET_NUMBER1 (self->event);
GET_NUMBER2 (self->node);
GET_NUMBER2 (self->peer);
GET_NUMBER8 (self->time);
GET_STRING (self->host);
GET_LONGSTR (self->data);
break;
case ZPROTO_EXAMPLE_STRUCTURES:
GET_NUMBER2 (self->sequence);
{
size_t list_size;
GET_NUMBER4 (list_size);
self->aliases = zlist_new ();
zlist_autofree (self->aliases);
while (list_size--) {
char *string = NULL;
GET_LONGSTR (string);
zlist_append (self->aliases, string);
free (string);
}
}
{
size_t hash_size;
GET_NUMBER4 (hash_size);
self->headers = zhash_new ();
zhash_autofree (self->headers);
while (hash_size--) {
char key [256];
char *value = NULL;
GET_STRING (key);
GET_LONGSTR (value);
zhash_insert (self->headers, key, value);
free (value);
}
}
break;
case ZPROTO_EXAMPLE_BINARY:
GET_NUMBER2 (self->sequence);
GET_OCTETS (self->flags, 4);
{
size_t chunk_size;
GET_NUMBER4 (chunk_size);
if (self->needle + chunk_size > (self->ceiling)) {
zsys_warning ("zproto_example: public_key is missing data");
goto malformed;
}
zchunk_destroy (&self->public_key);
self->public_key = zchunk_new (self->needle, chunk_size);
self->needle += chunk_size;
}
if (self->needle + ZUUID_LEN > (self->ceiling)) {
zsys_warning ("zproto_example: identifier is invalid");
goto malformed;
}
zuuid_destroy (&self->identifier);
self->identifier = zuuid_new_from (self->needle);
self->needle += ZUUID_LEN;
// Get next frame off socket
if (!zsock_rcvmore (input)) {
zsys_warning ("zproto_example: address is missing");
goto malformed;
}
zframe_destroy (&self->address);
self->address = zframe_recv (input);
// Get zero or more remaining frames
zmsg_destroy (&self->content);
if (zsock_rcvmore (input))
self->content = zmsg_recv (input);
else
self->content = zmsg_new ();
break;
case ZPROTO_EXAMPLE_TYPES:
GET_NUMBER2 (self->sequence);
GET_STRING (self->client_forename);
GET_STRING (self->client_surname);
GET_STRING (self->client_mobile);
GET_STRING (self->client_email);
GET_STRING (self->supplier_forename);
GET_STRING (self->supplier_surname);
GET_STRING (self->supplier_mobile);
GET_STRING (self->supplier_email);
break;
default:
zsys_warning ("zproto_example: bad message ID");
goto malformed;
}
// Successful return
zmq_msg_close (&frame);
return 0;
// Error returns
malformed:
zsys_warning ("zproto_example: zproto_example malformed message, fail");
zmq_msg_close (&frame);
return -1; // Invalid message
}