zuuid_t *
zuuid_dup (zuuid_t *self)
{
if (self)
return zuuid_new_from (zuuid_data (self));
else
return NULL;
}
///
// Create UUID object from supplied ZUUID_LEN-octet value.
QZuuid * QZuuid::newFrom (const byte *source)
{
QZuuid *rv = new QZuuid (zuuid_new_from (source));
return rv;
}
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
}
///
// Create UUID object from supplied ZUUID_LEN-octet value.
QZuuid* QZuuid::newFrom (const byte *source, QObject *qObjParent)
{
return new QZuuid (zuuid_new_from (source), qObjParent);
}
int
xrap_traffic_recv (xrap_traffic_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 ("xrap_traffic: 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 ("xrap_traffic: 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 | 9)) {
zsys_warning ("xrap_traffic: 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 XRAP_TRAFFIC_CONNECTION_OPEN:
{
char protocol [256];
GET_STRING (protocol);
if (strneq (protocol, "MALAMUTE")) {
zsys_warning ("xrap_traffic: protocol is invalid");
goto malformed;
}
}
{
uint16_t version;
GET_NUMBER2 (version);
if (version != 1) {
zsys_warning ("xrap_traffic: version is invalid");
goto malformed;
}
}
GET_STRING (self->address);
break;
case XRAP_TRAFFIC_CONNECTION_PING:
break;
case XRAP_TRAFFIC_CONNECTION_PONG:
break;
case XRAP_TRAFFIC_CONNECTION_CLOSE:
break;
case XRAP_TRAFFIC_XRAP_SEND:
GET_NUMBER4 (self->timeout);
// 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 XRAP_TRAFFIC_XRAP_OFFER:
GET_STRING (self->route);
GET_STRING (self->method);
break;
case XRAP_TRAFFIC_XRAP_DELIVER:
if (self->needle + ZUUID_LEN > (self->ceiling)) {
zsys_warning ("xrap_traffic: sender is invalid");
goto malformed;
}
zuuid_destroy (&self->sender);
self->sender = zuuid_new_from (self->needle);
self->needle += ZUUID_LEN;
// 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 XRAP_TRAFFIC_OK:
GET_NUMBER2 (self->status_code);
GET_STRING (self->status_reason);
break;
case XRAP_TRAFFIC_FAIL:
GET_NUMBER2 (self->status_code);
GET_STRING (self->status_reason);
break;
case XRAP_TRAFFIC_ERROR:
GET_NUMBER2 (self->status_code);
GET_STRING (self->status_reason);
break;
default:
zsys_warning ("xrap_traffic: bad message ID");
goto malformed;
}
// Successful return
zmq_msg_close (&frame);
return 0;
// Error returns
malformed:
zsys_warning ("xrap_traffic: xrap_traffic malformed message, fail");
zmq_msg_close (&frame);
return -1; // Invalid message
}
