void
zsocket_set_unsubscribe (void *zocket, char * unsubscribe)
{
# if defined (ZMQ_UNSUBSCRIBE)
if (zsockopt_type (zocket) != ZMQ_SUB) {
printf ("ZMQ_UNSUBSCRIBE is not valid on %s sockets\n", zsocket_type_str (zocket));
assert (false);
}
int rc = zmq_setsockopt (zocket, ZMQ_UNSUBSCRIBE, unsubscribe, strlen (unsubscribe));
assert (rc == 0 || errno == ETERM);
# endif
}
void
zsocket_set_router_raw (void *zocket, int router_raw)
{
# if defined (ZMQ_ROUTER_RAW)
if (zsockopt_type (zocket) != ZMQ_ROUTER) {
printf ("ZMQ_ROUTER_RAW is not valid on %s sockets\n", zsocket_type_str (zocket));
assert (false);
}
int rc = zmq_setsockopt (zocket, ZMQ_ROUTER_RAW, &router_raw, sizeof (int));
assert (rc == 0 || errno == ETERM);
# endif
}
void
zsocket_set_xpub_verbose (void *zocket, int xpub_verbose)
{
# if defined (ZMQ_XPUB_VERBOSE)
if (zsockopt_type (zocket) != ZMQ_XPUB) {
printf ("ZMQ_XPUB_VERBOSE is not valid on %s sockets\n", zsocket_type_str (zocket));
assert (false);
}
int rc = zmq_setsockopt (zocket, ZMQ_XPUB_VERBOSE, &xpub_verbose, sizeof (int));
assert (rc == 0 || errno == ETERM);
# endif
}
void
zsocket_set_router_mandatory (void *zocket, int router_mandatory)
{
# if defined (ZMQ_ROUTER_MANDATORY)
if (zsockopt_type (zocket) != ZMQ_ROUTER) {
printf ("ZMQ_ROUTER_MANDATORY is not valid on %s sockets\n", zsocket_type_str (zocket));
assert (false);
}
int rc = zmq_setsockopt (zocket, ZMQ_ROUTER_MANDATORY, &router_mandatory, sizeof (int));
assert (rc == 0 || errno == ETERM);
# endif
}
char *
zsocket_type_str (void *socket)
{
char *type_name [] = {
"PAIR", "PUB", "SUB", "REQ", "REP",
"DEALER", "ROUTER", "PULL", "PUSH",
"XPUB", "XSUB"
};
int type = zsockopt_type (socket);
if (type < 0 || type > ZMQ_XSUB)
return "UNKNOWN";
else
return type_name [type];
}
int
mdp_worker_send (mdp_worker_t **self_p, void *socket)
{
assert (socket);
assert (self_p);
assert (*self_p);
mdp_worker_t *self = *self_p;
// If we're sending to a ROUTER, we send the address first
zmsg_t *msg = zmsg_new ();
if (zsockopt_type (socket) == ZMQ_ROUTER) {
assert (self->address);
zmsg_add (msg, self->address);
self->address = NULL; // Owned by msg now
}
// Send header fields
zmsg_addstr (msg, "");
zmsg_addstr (msg, "MDPW01");
zmsg_addmem (msg, &self->id, 1);
switch (self->id) {
case MDP_WORKER_READY:
zmsg_addstr (msg, self->service);
break;
case MDP_WORKER_REQUEST:
zmsg_add (msg, self->client);
self->client = NULL;
zmsg_add (msg, self->body);
self->body = NULL;
break;
case MDP_WORKER_REPLY:
zmsg_add (msg, self->client);
self->client = NULL;
zmsg_add (msg, self->body);
self->body = NULL;
break;
case MDP_WORKER_HEARBEAT:
break;
case MDP_WORKER_DISCONNECT:
break;
}
// Send the message and destroy mdp_worker object
int rc = zmsg_send (&msg, socket);
mdp_worker_destroy (self_p);
return rc;
}
mdp_worker_t *
mdp_worker_recv (void *socket)
{
// Read all frames off socket
assert (socket);
zmsg_t *msg = zmsg_recv (socket);
if (!msg)
return NULL; // Interrupted
// Create and populate new mdp_worker instance
mdp_worker_t *self = mdp_worker_new (0);
// If we're reading from a ROUTER socket, get address
if (zsockopt_type (socket) == ZMQ_ROUTER) {
self->address = zmsg_pop (msg);
if (!self->address)
goto empty; // Interrupted
}
// Read and check header
zframe_t *empty_frame = zmsg_pop (msg);
if (!empty_frame || !zframe_streq (empty_frame, ""))
goto malformed;
zframe_destroy (&empty_frame);
zframe_t *protocol_frame = zmsg_pop (msg);
if (!protocol_frame || !zframe_streq (protocol_frame, "MDPW01"))
goto malformed;
zframe_destroy (&protocol_frame);
zframe_t *id_frame = zmsg_pop (msg);
if (!id_frame)
goto malformed;
self->id = zframe_data (id_frame) [0];
zframe_destroy (&id_frame);
// Read and parse fields per-message
switch (self->id) {
case MDP_WORKER_READY:
self->service = zmsg_popstr (msg);
if (!self->service)
goto malformed;
break;
case MDP_WORKER_REQUEST:
self->client = zmsg_pop (msg);
if (!self->client)
goto malformed;
self->body = zmsg_pop (msg);
if (!self->body)
goto malformed;
break;
case MDP_WORKER_REPLY:
self->client = zmsg_pop (msg);
if (!self->client)
goto malformed;
self->body = zmsg_pop (msg);
if (!self->body)
goto malformed;
break;
case MDP_WORKER_HEARBEAT:
break;
case MDP_WORKER_DISCONNECT:
break;
default:
goto malformed;
}
// Successful return
zmsg_destroy (&msg);
return self;
// Error returns
malformed:
printf ("E: malformed message '%d'\n", self->id);
empty:
zmsg_destroy (&msg);
mdp_worker_destroy (&self);
return (NULL);
}
int
zre_log_msg_send (zre_log_msg_t **self_p, void *output)
{
assert (output);
assert (self_p);
assert (*self_p);
// Calculate size of serialized data
zre_log_msg_t *self = *self_p;
size_t frame_size = 2 + 1; // Signature and message ID
switch (self->id) {
case ZRE_LOG_MSG_LOG:
// level is a 1-byte integer
frame_size += 1;
// event is a 1-byte integer
frame_size += 1;
// node is a 2-byte integer
frame_size += 2;
// peer is a 2-byte integer
frame_size += 2;
// time is a 8-byte integer
frame_size += 8;
// data is a string with 1-byte length
frame_size++; // Size is one octet
if (self->data)
frame_size += strlen (self->data);
break;
default:
printf ("E: bad message type '%d', not sent\n", self->id);
// No recovery, this is a fatal application error
assert (false);
}
// Now serialize message into the frame
zframe_t *frame = zframe_new (NULL, frame_size);
self->needle = zframe_data (frame);
size_t string_size;
int frame_flags = 0;
PUT_NUMBER2 (0xAAA0 | 2);
PUT_NUMBER1 (self->id);
switch (self->id) {
case ZRE_LOG_MSG_LOG:
PUT_NUMBER1 (self->level);
PUT_NUMBER1 (self->event);
PUT_NUMBER2 (self->node);
PUT_NUMBER2 (self->peer);
PUT_NUMBER8 (self->time);
if (self->data) {
PUT_STRING (self->data);
}
else
PUT_NUMBER1 (0); // Empty string
break;
}
// If we're sending to a ROUTER, we send the address first
if (zsockopt_type (output) == ZMQ_ROUTER) {
assert (self->address);
if (zframe_send (&self->address, output, ZFRAME_MORE)) {
zframe_destroy (&frame);
zre_log_msg_destroy (self_p);
return -1;
}
}
// Now send the data frame
if (zframe_send (&frame, output, frame_flags)) {
zframe_destroy (&frame);
zre_log_msg_destroy (self_p);
return -1;
}
// Now send any frame fields, in order
switch (self->id) {
}
// Destroy zre_log_msg object
zre_log_msg_destroy (self_p);
return 0;
}
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 (zsockopt_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
zre_msg_send (zre_msg_t **self_p, void *output)
{
assert (output);
assert (self_p);
assert (*self_p);
// Calculate size of serialized data
zre_msg_t *self = *self_p;
size_t frame_size = 2 + 1; // Signature and message ID
switch (self->id) {
case ZRE_MSG_HELLO:
// sequence is a 2-byte integer
frame_size += 2;
// ipaddress is a string with 1-byte length
frame_size++; // Size is one octet
if (self->ipaddress)
frame_size += strlen (self->ipaddress);
// mailbox is a 2-byte integer
frame_size += 2;
// groups is an array of strings
frame_size++; // Size is one octet
if (self->groups) {
// Add up size of list contents
char *groups = (char *) zlist_first (self->groups);
while (groups) {
frame_size += 1 + strlen (groups);
groups = (char *) zlist_next (self->groups);
}
}
// status is a 1-byte integer
frame_size += 1;
// headers is an array of key=value strings
frame_size++; // Size is one octet
if (self->headers) {
self->headers_bytes = 0;
// Add up size of dictionary contents
zhash_foreach (self->headers, s_headers_count, self);
}
frame_size += self->headers_bytes;
break;
case ZRE_MSG_WHISPER:
// sequence is a 2-byte integer
frame_size += 2;
break;
case ZRE_MSG_SHOUT:
// sequence is a 2-byte integer
frame_size += 2;
// group is a string with 1-byte length
frame_size++; // Size is one octet
if (self->group)
frame_size += strlen (self->group);
break;
case ZRE_MSG_JOIN:
// sequence is a 2-byte integer
frame_size += 2;
// group is a string with 1-byte length
frame_size++; // Size is one octet
if (self->group)
frame_size += strlen (self->group);
// status is a 1-byte integer
frame_size += 1;
break;
case ZRE_MSG_LEAVE:
// sequence is a 2-byte integer
frame_size += 2;
// group is a string with 1-byte length
frame_size++; // Size is one octet
if (self->group)
frame_size += strlen (self->group);
// status is a 1-byte integer
frame_size += 1;
break;
case ZRE_MSG_PING:
// sequence is a 2-byte integer
frame_size += 2;
break;
case ZRE_MSG_PING_OK:
// sequence is a 2-byte integer
frame_size += 2;
break;
default:
printf ("E: bad message type '%d', not sent\n", self->id);
// No recovery, this is a fatal application error
assert (false);
}
// Now serialize message into the frame
zframe_t *frame = zframe_new (NULL, frame_size);
self->needle = zframe_data (frame);
size_t string_size;
int frame_flags = 0;
PUT_NUMBER2 (0xAAA0 | 1);
PUT_NUMBER1 (self->id);
switch (self->id) {
case ZRE_MSG_HELLO:
PUT_NUMBER2 (self->sequence);
if (self->ipaddress) {
PUT_STRING (self->ipaddress);
}
else
PUT_NUMBER1 (0); // Empty string
PUT_NUMBER2 (self->mailbox);
if (self->groups != NULL) {
PUT_NUMBER1 (zlist_size (self->groups));
char *groups = (char *) zlist_first (self->groups);
while (groups) {
PUT_STRING (groups);
groups = (char *) zlist_next (self->groups);
}
}
else
PUT_NUMBER1 (0); // Empty string array
PUT_NUMBER1 (self->status);
if (self->headers != NULL) {
PUT_NUMBER1 (zhash_size (self->headers));
zhash_foreach (self->headers, s_headers_write, self);
}
else
PUT_NUMBER1 (0); // Empty dictionary
break;
case ZRE_MSG_WHISPER:
PUT_NUMBER2 (self->sequence);
frame_flags = ZFRAME_MORE;
break;
case ZRE_MSG_SHOUT:
PUT_NUMBER2 (self->sequence);
if (self->group) {
PUT_STRING (self->group);
}
else
PUT_NUMBER1 (0); // Empty string
frame_flags = ZFRAME_MORE;
break;
case ZRE_MSG_JOIN:
PUT_NUMBER2 (self->sequence);
if (self->group) {
PUT_STRING (self->group);
}
else
PUT_NUMBER1 (0); // Empty string
PUT_NUMBER1 (self->status);
break;
case ZRE_MSG_LEAVE:
PUT_NUMBER2 (self->sequence);
if (self->group) {
PUT_STRING (self->group);
}
else
PUT_NUMBER1 (0); // Empty string
PUT_NUMBER1 (self->status);
break;
case ZRE_MSG_PING:
PUT_NUMBER2 (self->sequence);
break;
case ZRE_MSG_PING_OK:
PUT_NUMBER2 (self->sequence);
break;
}
// If we're sending to a ROUTER, we send the address first
if (zsockopt_type (output) == ZMQ_ROUTER) {
assert (self->address);
if (zframe_send (&self->address, output, ZFRAME_MORE)) {
zframe_destroy (&frame);
zre_msg_destroy (self_p);
return -1;
}
}
// Now send the data frame
if (zframe_send (&frame, output, frame_flags)) {
zframe_destroy (&frame);
zre_msg_destroy (self_p);
return -1;
}
// Now send any frame fields, in order
switch (self->id) {
case ZRE_MSG_WHISPER:
// If content isn't set, send an empty frame
if (!self->content)
self->content = zframe_new (NULL, 0);
if (zframe_send (&self->content, output, 0)) {
zframe_destroy (&frame);
zre_msg_destroy (self_p);
return -1;
}
break;
case ZRE_MSG_SHOUT:
// If content isn't set, send an empty frame
if (!self->content)
self->content = zframe_new (NULL, 0);
if (zframe_send (&self->content, output, 0)) {
zframe_destroy (&frame);
zre_msg_destroy (self_p);
return -1;
}
break;
}
// Destroy zre_msg object
zre_msg_destroy (self_p);
return 0;
}
zre_msg_t *
zre_msg_recv (void *input)
{
assert (input);
zre_msg_t *self = zre_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 (zsockopt_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 | 1))
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_MSG_HELLO:
GET_NUMBER2 (self->sequence);
free (self->ipaddress);
GET_STRING (self->ipaddress);
GET_NUMBER2 (self->mailbox);
GET_NUMBER1 (list_size);
self->groups = zlist_new ();
zlist_autofree (self->groups);
while (list_size--) {
char *string;
GET_STRING (string);
zlist_append (self->groups, string);
}
GET_NUMBER1 (self->status);
GET_NUMBER1 (hash_size);
self->headers = zhash_new ();
zhash_autofree (self->headers);
while (hash_size--) {
char *string;
GET_STRING (string);
char *value = strchr (string, '=');
if (value)
*value++ = 0;
zhash_insert (self->headers, string, strdup (value));
free (string);
}
break;
case ZRE_MSG_WHISPER:
GET_NUMBER2 (self->sequence);
// Get next frame, leave current untouched
if (!zsocket_rcvmore (input))
goto malformed;
self->content = zframe_recv (input);
break;
case ZRE_MSG_SHOUT:
GET_NUMBER2 (self->sequence);
free (self->group);
GET_STRING (self->group);
// Get next frame, leave current untouched
if (!zsocket_rcvmore (input))
goto malformed;
self->content = zframe_recv (input);
break;
case ZRE_MSG_JOIN:
GET_NUMBER2 (self->sequence);
free (self->group);
GET_STRING (self->group);
GET_NUMBER1 (self->status);
break;
case ZRE_MSG_LEAVE:
GET_NUMBER2 (self->sequence);
free (self->group);
GET_STRING (self->group);
GET_NUMBER1 (self->status);
break;
case ZRE_MSG_PING:
GET_NUMBER2 (self->sequence);
break;
case ZRE_MSG_PING_OK:
GET_NUMBER2 (self->sequence);
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_msg_destroy (&self);
return (NULL);
}
