static void
connect_to_server (client_t *self)
{
if (zsock_connect(self->dealer, "%s", self->args->endpoint)) {
engine_set_exception(self, connect_error_event);
zsys_warning("could not connect to %s", self->args->endpoint);
zsock_send (self->cmdpipe, "si", "FAILURE", 0);
}
else
{
zsys_debug("connected to %s", self->args->endpoint);
zsock_send (self->cmdpipe, "si", "SUCCESS", 0);
}
}
static void s_restart_boca_serial(ticket_printer_t *self, const char *port) {
boca_serial_destroy(&self->serial_printer);
self->serial_printer = boca_serial_new(port);
if (self->serial_printer == NULL) {
zsys_warning("ticket printer: restart serial printer failed");
self->event = EVENT_BOCA_ERROR_STATUS;
s_state_machine(self);
} else {
zsys_info("ticket printer: restart serial printer ok.");
self->event = EVENT_BOCA_RESTARTED;
s_state_machine(self);
self->boca_serial_restart_count = 0;
}
}
static void
store_stream_reader (client_t *self)
{
stream_t *stream = s_stream_require (self, mlm_proto_stream (self->message));
if (stream) {
zlistx_add_end (self->readers, stream);
zsock_send (stream->actor, "sps", "COMPILE", self, mlm_proto_pattern (self->message));
mlm_proto_set_status_code (self->message, MLM_PROTO_SUCCESS);
}
else {
engine_set_exception (self, exception_event);
zsys_warning ("reader trying to talk to multiple streams");
}
}
server_connect (server_t *self, const char *endpoint)
#endif
{
zsock_t *remote = zsock_new (ZMQ_DEALER);
assert (remote); // No recovery if exhausted
#ifdef CZMQ_BUILD_DRAFT_API
// DRAFT-API: Security
if (public_key){
zcert_t *cert = zcert_new_from_txt (self->public_key, self->secret_key);
zcert_apply(cert, remote);
zsock_set_curve_serverkey (remote, public_key);
#ifndef ZMQ_CURVE
// legacy ZMQ support
// inline incase the underlying assert is removed
bool ZMQ_CURVE = false;
#endif
assert (zsock_mechanism (remote) == ZMQ_CURVE);
zcert_destroy(&cert);
}
#endif
// Never block on sending; we use an infinite HWM and buffer as many
// messages as needed in outgoing pipes. Note that the maximum number
// is the overall tuple set size.
zsock_set_unbounded (remote);
if (zsock_connect (remote, "%s", endpoint)) {
zsys_warning ("bad zgossip endpoint '%s'", endpoint);
zsock_destroy (&remote);
return;
}
// Send HELLO and then PUBLISH for each tuple we have
zgossip_msg_t *gossip = zgossip_msg_new ();
zgossip_msg_set_id (gossip, ZGOSSIP_MSG_HELLO);
zgossip_msg_send (gossip, remote);
tuple_t *tuple = (tuple_t *) zhashx_first (self->tuples);
while (tuple) {
zgossip_msg_set_id (gossip, ZGOSSIP_MSG_PUBLISH);
zgossip_msg_set_key (gossip, tuple->key);
zgossip_msg_set_value (gossip, tuple->value);
zgossip_msg_send (gossip, remote);
tuple = (tuple_t *) zhashx_next (self->tuples);
}
// Now monitor this remote for incoming messages
zgossip_msg_destroy (&gossip);
engine_handle_socket (self, remote, remote_handler);
zlistx_add_end (self->remotes, remote);
}
static int
s_expect_reply (zsock_t *dealer, int message_id)
{
zpipes_msg_t *reply = zpipes_msg_recv (dealer);
if (!reply) {
puts ("- interrupted");
return -1;
}
int rc = zpipes_msg_id (reply) == message_id? 0: -1;
if (rc)
zsys_warning ("expected %d, got %d/%s\n", message_id,
zpipes_msg_id (reply), zpipes_msg_command (reply));
zpipes_msg_destroy (&reply);
return rc;
}
static void
s_self_listen (self_t *self, const char *event)
{
#if defined (ZMQ_EVENT_ALL)
if (streq (event, "CONNECTED"))
self->events |= ZMQ_EVENT_CONNECTED;
else
if (streq (event, "CONNECT_DELAYED"))
self->events |= ZMQ_EVENT_CONNECT_DELAYED;
else
if (streq (event, "CONNECT_RETRIED"))
self->events |= ZMQ_EVENT_CONNECT_RETRIED;
else
if (streq (event, "LISTENING"))
self->events |= ZMQ_EVENT_LISTENING;
else
if (streq (event, "BIND_FAILED"))
self->events |= ZMQ_EVENT_BIND_FAILED;
else
if (streq (event, "ACCEPTED"))
self->events |= ZMQ_EVENT_ACCEPTED;
else
if (streq (event, "ACCEPT_FAILED"))
self->events |= ZMQ_EVENT_ACCEPT_FAILED;
else
if (streq (event, "CLOSED"))
self->events |= ZMQ_EVENT_CLOSED;
else
if (streq (event, "CLOSE_FAILED"))
self->events |= ZMQ_EVENT_CLOSE_FAILED;
else
if (streq (event, "DISCONNECTED"))
self->events |= ZMQ_EVENT_DISCONNECTED;
else
#if (ZMQ_VERSION_MAJOR == 4)
if (streq (event, "MONITOR_STOPPED"))
self->events |= ZMQ_EVENT_MONITOR_STOPPED;
else
#endif
if (streq (event, "ALL"))
self->events |= ZMQ_EVENT_ALL;
else
zsys_warning ("zmonitor: - invalid listen event=%s", event);
#endif
}
static void
write_message_to_stream (client_t *self)
{
if (self->writer) {
mlm_msg_t *msg = mlm_msg_new (
self->address,
self->writer->name,
mlm_proto_subject (self->message),
NULL,
mlm_proto_timeout (self->message),
mlm_proto_get_content (self->message));
zsock_bsend (self->writer->msgpipe, "pp", self, msg);
}
else {
engine_set_exception (self, exception_event);
zsys_warning ("client attempted to send without writer");
}
}
static void
write_message_to_stream (client_t *self)
{
if (self->writer) {
mlm_msg_t *msg = mlm_msg_new (
self->address,
self->writer->name,
mlm_proto_subject (self->message),
NULL,
mlm_proto_timeout (self->message),
mlm_proto_get_content (self->message));
zsock_bsend (self->writer->msgpipe, "pp", self, msg);
}
else {
// TODO: we can't properly reply to a STREAM_SEND
mlm_proto_set_status_code (self->message, MLM_PROTO_COMMAND_INVALID);
engine_set_exception (self, exception_event);
zsys_warning ("client attempted to send without writer");
}
}
static int twps_create_ticket_printer(twps_server_t *self, zmsg_t *msg) {
char *type = zmsg_popstr(msg);
char *id = zmsg_popstr(msg);
zstr_free(&id);
char *path = zmsg_popstr(msg);
char *model = zmsg_popstr(msg);
wchar_t *manufacture = (wchar_t *) zmsg_popstr(msg);
wchar_t *product = (wchar_t *) zmsg_popstr(msg);
zactor_t *printer = NULL;
if (streq(type, "HID")) {
printer = zactor_new(ticket_hid_printer, path);
}
#ifdef __WIN32__
else if (streq(type, "SERIAL")) {
printer = zactor_new(ticket_serial_printer, path);
}
#endif
if (printer != NULL) {
if (self->verbose) {
zstr_send(printer, "VERBOSE");
}
if (self->diagnostic)
zstr_sendx(printer, "SETDIAGNOSTIC", NULL);
zstr_sendx(printer, "START", TICKET_STORE_REP_ENDPOINT, NULL);
zsock_wait(printer);
zstr_sendx(printer, "SETPRINTERSTORE", PRINTER_STORE_REP_ENDPOINT, PRINTER_STORE_PUB_ENDPOINT, NULL);
zsock_wait(printer);
zsys_info("twps server: started ticket printer %s manufacturer|product|model %ls|%ls|%s", type, manufacture,
product, model);
zlistx_add_end(self->ticket_printers, printer);
} else {
zsys_warning("twps server: printer not added %s, %s", type, path);
zmsg_print(msg);
}
zstr_free(&type);
zstr_free(&path);
zstr_free(&model);
zstr_free((char **) &manufacture);
zstr_free((char **) &product);
return 0;
}
enum BOCA_FEATURE_REPORT_STATUS boca_hid_status_feature(boca_hid_printer_t *self) {
enum BOCA_FEATURE_REPORT_STATUS ret = BOCA_REPORT_UNKNOWN;
if (!self->device)
return ret;
unsigned char *buf = (unsigned char *) calloc(PACKET_SIZE, sizeof(byte));
buf[0] = 0x0;
int byte_read = hid_get_feature_report(self->device, buf, sizeof(byte) * PACKET_SIZE);
if(self->verbose)
zsys_debug("hid printer: read %d bytes from feature port", byte_read);
if (byte_read > 0) {
if (byte_read == 2)
ret = (enum BOCA_FEATURE_REPORT_STATUS) (int) buf[1];
else
ret = (enum BOCA_FEATURE_REPORT_STATUS) (int) buf[0];
if (self->verbose) {
zsys_debug("hid printer: BOCA status %s", boca_feature_report_display(ret));
}
} else {
zsys_warning("hid printer: could not read from BOCA %ls", hid_error(self->device));
}
return ret;
}
int
main (int argc, char **argv)
{
if (argc < 2) {
zsys_warning ("Need argument");
zsys_info ("usage: %s <regex>", argv [0]);
return EXIT_FAILURE;
}
zrex_t *regex = zrex_new (argv [1]);
if (!regex) {
zsys_error ("zrex_new () failed.");
return EXIT_FAILURE;
}
if (!zrex_valid (regex)) {
zsys_error ("regex not valid: %s", zrex_strerror (regex));
return EXIT_FAILURE;
}
zsys_info ("zrex valid");
return EXIT_SUCCESS;
}
///
// Log warning condition - high priority
void QmlZsysAttached::warning (const QString &format) {
zsys_warning (format.toUtf8().data());
};
int
zloop_start (zloop_t *self)
{
assert (self);
int rc = 0;
// Main reactor loop
while (!zsys_interrupted) {
if (self->need_rebuild) {
// If s_rebuild_pollset() fails, break out of the loop and
// return its error
rc = s_rebuild_pollset (self);
if (rc)
break;
}
rc = zmq_poll (self->pollset, (int) self->poll_size, s_tickless (self));
if (rc == -1 || zsys_interrupted) {
if (self->verbose)
zsys_debug ("zloop: interrupted");
rc = 0;
break; // Context has been shut down
}
// Handle any timers that have now expired
int64_t time_now = zclock_mono ();
s_timer_t *timer = (s_timer_t *) zlistx_first (self->timers);
while (timer) {
if (time_now >= timer->when) {
if (self->verbose)
zsys_debug ("zloop: call timer handler id=%d", timer->timer_id);
rc = timer->handler (self, timer->timer_id, timer->arg);
if (rc == -1)
break; // Timer handler signaled break
if (timer->times && --timer->times == 0)
zlistx_delete (self->timers, timer->list_handle);
else
timer->when += timer->delay;
}
timer = (s_timer_t *) zlistx_next (self->timers);
}
// Handle any tickets that have now expired
s_ticket_t *ticket = (s_ticket_t *) zlistx_first (self->tickets);
while (ticket && time_now >= ticket->when) {
if (self->verbose)
zsys_debug ("zloop: call ticket handler");
rc = ticket->handler (self, 0, ticket->arg);
if (rc == -1)
break; // Timer handler signaled break
zlistx_delete (self->tickets, ticket->list_handle);
ticket = (s_ticket_t *) zlistx_next (self->tickets);
}
// Handle any readers and pollers that are ready
size_t item_nbr;
for (item_nbr = 0; item_nbr < self->poll_size && rc >= 0; item_nbr++) {
s_reader_t *reader = &self->readact [item_nbr];
if (reader->handler) {
if ((self->pollset [item_nbr].revents & ZMQ_POLLERR)
&& !reader->tolerant) {
if (self->verbose)
zsys_warning ("zloop: can't read %s socket: %s",
zsock_type_str (reader->sock),
zmq_strerror (zmq_errno ()));
// Give handler one chance to handle error, then kill
// reader because it'll disrupt the reactor otherwise.
if (reader->errors++) {
zloop_reader_end (self, reader->sock);
self->pollset [item_nbr].revents = 0;
}
}
else
reader->errors = 0; // A non-error happened
if (self->pollset [item_nbr].revents) {
if (self->verbose)
zsys_debug ("zloop: call %s socket handler",
zsock_type_str (reader->sock));
rc = reader->handler (self, reader->sock, reader->arg);
if (rc == -1 || self->need_rebuild)
break;
}
}
else {
s_poller_t *poller = &self->pollact [item_nbr];
assert (self->pollset [item_nbr].socket == poller->item.socket);
if ((self->pollset [item_nbr].revents & ZMQ_POLLERR)
&& !poller->tolerant) {
if (self->verbose)
zsys_warning ("zloop: can't poll %s socket (%p, %d): %s",
poller->item.socket ?
zsys_sockname (zsock_type (poller->item.socket)) : "FD",
poller->item.socket, poller->item.fd,
zmq_strerror (zmq_errno ()));
// Give handler one chance to handle error, then kill
// poller because it'll disrupt the reactor otherwise.
if (poller->errors++) {
zloop_poller_end (self, &poller->item);
self->pollset [item_nbr].revents = 0;
}
}
else
poller->errors = 0; // A non-error happened
if (self->pollset [item_nbr].revents) {
if (self->verbose)
zsys_debug ("zloop: call %s socket handler (%p, %d)",
poller->item.socket ?
zsys_sockname (zsock_type (poller->item.socket)) : "FD",
poller->item.socket, poller->item.fd);
rc = poller->handler (self, &self->pollset [item_nbr], poller->arg);
if (rc == -1 || self->need_rebuild)
break;
}
}
}
// Now handle any timer zombies
// This is going to be slow if we have many timers; we might use
// a faster lookup on the timer list.
while (zlistx_first (self->zombies)) {
// Get timer_id back from pointer
int timer_id = (byte *) zlistx_detach (self->zombies, NULL) - (byte *) NULL;
s_timer_remove (self, timer_id);
}
if (rc == -1)
break;
}
self->terminated = true;
return rc;
}
static void
zyre_node_recv_peer (zyre_node_t *self)
{
// Router socket tells us the identity of this peer
zre_msg_t *msg = zre_msg_recv (self->inbox);
if (!msg)
return; // Interrupted
// First frame is sender identity
byte *peerid_data = zframe_data (zre_msg_routing_id (msg));
size_t peerid_size = zframe_size (zre_msg_routing_id (msg));
// Identity must be [1] followed by 16-byte UUID
if (peerid_size != ZUUID_LEN + 1) {
zre_msg_destroy (&msg);
return;
}
zuuid_t *uuid = zuuid_new ();
zuuid_set (uuid, peerid_data + 1);
// On HELLO we may create the peer if it's unknown
// On other commands the peer must already exist
zyre_peer_t *peer = (zyre_peer_t *) zhash_lookup (self->peers, zuuid_str (uuid));
if (zre_msg_id (msg) == ZRE_MSG_HELLO) {
if (peer) {
// Remove fake peers
if (zyre_peer_ready (peer)) {
zyre_node_remove_peer (self, peer);
assert (!(zyre_peer_t *) zhash_lookup (self->peers, zuuid_str (uuid)));
}
else
if (streq (zyre_peer_endpoint (peer), self->endpoint)) {
// We ignore HELLO, if peer has same endpoint as current node
zre_msg_destroy (&msg);
zuuid_destroy (&uuid);
return;
}
}
peer = zyre_node_require_peer (self, uuid, zre_msg_endpoint (msg));
assert (peer);
zyre_peer_set_ready (peer, true);
}
// Ignore command if peer isn't ready
if (peer == NULL || !zyre_peer_ready (peer)) {
zre_msg_destroy (&msg);
zuuid_destroy (&uuid);
return;
}
if (zyre_peer_messages_lost (peer, msg)) {
zsys_warning ("(%s) messages lost from %s", self->name, zyre_peer_name (peer));
zyre_node_remove_peer (self, peer);
zre_msg_destroy (&msg);
zuuid_destroy (&uuid);
return;
}
// Now process each command
if (zre_msg_id (msg) == ZRE_MSG_HELLO) {
// Store properties from HELLO command into peer
zyre_peer_set_name (peer, zre_msg_name (msg));
zyre_peer_set_headers (peer, zre_msg_headers (msg));
// Tell the caller about the peer
zstr_sendm (self->outbox, "ENTER");
zstr_sendm (self->outbox, zyre_peer_identity (peer));
zstr_sendm (self->outbox, zyre_peer_name (peer));
zframe_t *headers = zhash_pack (zyre_peer_headers (peer));
zframe_send (&headers, self->outbox, ZFRAME_MORE);
zstr_send (self->outbox, zre_msg_endpoint (msg));
if (self->verbose)
zsys_info ("(%s) ENTER name=%s endpoint=%s",
self->name, zyre_peer_name (peer), zyre_peer_endpoint (peer));
// Join peer to listed groups
const char *name = zre_msg_groups_first (msg);
while (name) {
zyre_node_join_peer_group (self, peer, name);
name = zre_msg_groups_next (msg);
}
// Now take peer's status from HELLO, after joining groups
zyre_peer_set_status (peer, zre_msg_status (msg));
}
else
if (zre_msg_id (msg) == ZRE_MSG_WHISPER) {
// Pass up to caller API as WHISPER event
zstr_sendm (self->outbox, "WHISPER");
zstr_sendm (self->outbox, zuuid_str (uuid));
zstr_sendm (self->outbox, zyre_peer_name (peer));
zmsg_t *content = zmsg_dup (zre_msg_content (msg));
zmsg_send (&content, self->outbox);
}
else
if (zre_msg_id (msg) == ZRE_MSG_SHOUT) {
// Pass up to caller as SHOUT event
zstr_sendm (self->outbox, "SHOUT");
zstr_sendm (self->outbox, zuuid_str (uuid));
zstr_sendm (self->outbox, zyre_peer_name (peer));
zstr_sendm (self->outbox, zre_msg_group (msg));
zmsg_t *content = zmsg_dup (zre_msg_content (msg));
zmsg_send (&content, self->outbox);
}
else
if (zre_msg_id (msg) == ZRE_MSG_PING) {
zre_msg_t *msg = zre_msg_new (ZRE_MSG_PING_OK);
zyre_peer_send (peer, &msg);
}
else
if (zre_msg_id (msg) == ZRE_MSG_JOIN) {
zyre_node_join_peer_group (self, peer, zre_msg_group (msg));
assert (zre_msg_status (msg) == zyre_peer_status (peer));
}
else
if (zre_msg_id (msg) == ZRE_MSG_LEAVE) {
zyre_node_leave_peer_group (self, peer, zre_msg_group (msg));
assert (zre_msg_status (msg) == zyre_peer_status (peer));
}
zuuid_destroy (&uuid);
zre_msg_destroy (&msg);
// Activity from peer resets peer timers
zyre_peer_refresh (peer, self->evasive_timeout, self->expired_timeout);
}
int
zmailer_msg_recv (zmailer_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 ("zmailer_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 ("zmailer_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 | 0)) {
zsys_warning ("zmailer_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 ZMAILER_MSG_MAIL:
{
uint16_t version;
GET_NUMBER2 (version);
if (version != 1) {
zsys_warning ("zmailer_msg: version is invalid");
goto malformed;
}
}
GET_STRING (self->from);
GET_LONGSTR (self->to);
GET_LONGSTR (self->subject);
GET_LONGSTR (self->request);
break;
default:
zsys_warning ("zmailer_msg: bad message ID");
goto malformed;
}
// Successful return
zmq_msg_close (&frame);
return 0;
// Error returns
malformed:
zsys_warning ("zmailer_msg: zmailer_msg malformed message, fail");
zmq_msg_close (&frame);
return -1; // Invalid message
}
int
zpubsub_filter_recv (zpubsub_filter_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 ("zpubsub_filter: 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 ("zpubsub_filter: 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 | 7)) {
zsys_warning ("zpubsub_filter: 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 ZPUBSUB_FILTER_FILTER:
{
uint16_t magic;
GET_NUMBER2 (magic);
if (magic != ZPUBSUB_FILTER_MAGIC_NUMBER) {
zsys_warning ("zpubsub_filter: magic is invalid");
goto malformed;
}
}
{
uint16_t version;
GET_NUMBER2 (version);
if (version != ZPUBSUB_FILTER_VERSION) {
zsys_warning ("zpubsub_filter: version is invalid");
goto malformed;
}
}
GET_STRING (self->partition);
GET_STRING (self->topic);
break;
default:
zsys_warning ("zpubsub_filter: bad message ID");
goto malformed;
}
// Successful return
zmq_msg_close (&frame);
return 0;
// Error returns
malformed:
zsys_warning ("zpubsub_filter: zpubsub_filter malformed message, fail");
zmq_msg_close (&frame);
return -1; // Invalid message
}
void
zsys_test (bool verbose)
{
printf (" * zsys: ");
if (verbose)
printf ("\n");
// @selftest
zsys_catch_interrupts ();
// Check capabilities without using the return value
int rc = zsys_has_curve ();
if (verbose) {
char *hostname = zsys_hostname ();
zsys_info ("host name is %s", hostname);
free (hostname);
zsys_info ("system limit is %zd ZeroMQ sockets", zsys_socket_limit ());
}
zsys_set_io_threads (1);
zsys_set_max_sockets (0);
zsys_set_linger (0);
zsys_set_sndhwm (1000);
zsys_set_rcvhwm (1000);
zsys_set_pipehwm (2500);
assert (zsys_pipehwm () == 2500);
zsys_set_ipv6 (0);
rc = zsys_file_delete ("nosuchfile");
assert (rc == -1);
bool rc_bool = zsys_file_exists ("nosuchfile");
assert (rc_bool != true);
rc = (int) zsys_file_size ("nosuchfile");
assert (rc == -1);
time_t when = zsys_file_modified (".");
assert (when > 0);
mode_t mode = zsys_file_mode (".");
assert (S_ISDIR (mode));
assert (mode & S_IRUSR);
assert (mode & S_IWUSR);
zsys_file_mode_private ();
rc = zsys_dir_create ("%s/%s", ".", ".testsys/subdir");
assert (rc == 0);
when = zsys_file_modified ("./.testsys/subdir");
assert (when > 0);
assert (!zsys_file_stable ("./.testsys/subdir"));
rc = zsys_dir_delete ("%s/%s", ".", ".testsys/subdir");
assert (rc == 0);
rc = zsys_dir_delete ("%s/%s", ".", ".testsys");
assert (rc == 0);
zsys_file_mode_default ();
int major, minor, patch;
zsys_version (&major, &minor, &patch);
assert (major == CZMQ_VERSION_MAJOR);
assert (minor == CZMQ_VERSION_MINOR);
assert (patch == CZMQ_VERSION_PATCH);
char *string = zsys_sprintf ("%s %02x", "Hello", 16);
assert (streq (string, "Hello 10"));
free (string);
char *str64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890,.";
int num10 = 1234567890;
string = zsys_sprintf ("%s%s%s%s%d", str64, str64, str64, str64, num10);
assert (strlen (string) == (4 * 64 + 10));
free (string);
// Test logging system
zsys_set_logident ("czmq_selftest");
zsys_set_logsender ("inproc://logging");
void *logger = zsys_socket (ZMQ_SUB, NULL, 0);
assert (logger);
rc = zsocket_connect (logger, "inproc://logging");
assert (rc == 0);
rc = zmq_setsockopt (logger, ZMQ_SUBSCRIBE, "", 0);
assert (rc == 0);
if (verbose) {
zsys_error ("This is an %s message", "error");
zsys_warning ("This is a %s message", "warning");
zsys_notice ("This is a %s message", "notice");
zsys_info ("This is a %s message", "info");
zsys_debug ("This is a %s message", "debug");
zsys_set_logident ("hello, world");
zsys_info ("This is a %s message", "info");
zsys_debug ("This is a %s message", "debug");
// Check that logsender functionality is working
char *received = zstr_recv (logger);
assert (received);
zstr_free (&received);
}
zsys_close (logger, NULL, 0);
// @end
printf ("OK\n");
}
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
}
static void
s_self_listen (self_t *self, const char *event)
{
#if defined (ZMQ_EVENT_ALL)
if (streq (event, "CONNECTED"))
self->events |= ZMQ_EVENT_CONNECTED;
else
if (streq (event, "CONNECT_DELAYED"))
self->events |= ZMQ_EVENT_CONNECT_DELAYED;
else
if (streq (event, "CONNECT_RETRIED"))
self->events |= ZMQ_EVENT_CONNECT_RETRIED;
else
if (streq (event, "LISTENING"))
self->events |= ZMQ_EVENT_LISTENING;
else
if (streq (event, "BIND_FAILED"))
self->events |= ZMQ_EVENT_BIND_FAILED;
else
if (streq (event, "ACCEPTED"))
self->events |= ZMQ_EVENT_ACCEPTED;
else
if (streq (event, "ACCEPT_FAILED"))
self->events |= ZMQ_EVENT_ACCEPT_FAILED;
else
if (streq (event, "CLOSED"))
self->events |= ZMQ_EVENT_CLOSED;
else
if (streq (event, "CLOSE_FAILED"))
self->events |= ZMQ_EVENT_CLOSE_FAILED;
else
if (streq (event, "DISCONNECTED"))
self->events |= ZMQ_EVENT_DISCONNECTED;
else
#if defined (ZMQ_EVENT_MONITOR_STOPPED)
if (streq (event, "MONITOR_STOPPED"))
self->events |= ZMQ_EVENT_MONITOR_STOPPED;
else
#endif
#if defined (ZMQ_EVENT_HANDSHAKE_FAILED)
if (streq (event, "HANDSHAKE_FAILED"))
self->events |= ZMQ_EVENT_HANDSHAKE_FAILED;
else
#endif
#if defined (ZMQ_EVENT_HANDSHAKE_SUCCEED)
if (streq (event, "HANDSHAKE_SUCCEED"))
self->events |= ZMQ_EVENT_HANDSHAKE_SUCCEED;
else
#endif
#if defined (ZMQ_EVENT_HANDSHAKE_SUCCEEDED)
if (streq (event, "HANDSHAKE_SUCCEEDED"))
self->events |= ZMQ_EVENT_HANDSHAKE_SUCCEEDED;
else
#endif
#if defined (ZMQ_EVENT_HANDSHAKE_FAILED_NO_DETAIL)
if (streq (event, "HANDSHAKE_FAILED_NO_DETAIL"))
self->events |= ZMQ_EVENT_HANDSHAKE_FAILED_NO_DETAIL;
else
#endif
#if defined (ZMQ_EVENT_HANDSHAKE_FAILED_PROTOCOL)
if (streq (event, "HANDSHAKE_FAILED_PROTOCOL"))
self->events |= ZMQ_EVENT_HANDSHAKE_FAILED_PROTOCOL;
else
#endif
#if defined (ZMQ_EVENT_HANDSHAKE_FAILED_AUTH)
if (streq (event, "HANDSHAKE_FAILED_AUTH"))
self->events |= ZMQ_EVENT_HANDSHAKE_FAILED_AUTH;
else
#endif
if (streq (event, "ALL"))
self->events |= ZMQ_EVENT_ALL;
else
zsys_warning ("zmonitor: - invalid listen event=%s", event);
#endif
}
Z K1(zsyswarning){zsys_warning(xs); RZ;}
static void s_handle_boca_status(ticket_printer_t *self, enum BOCA_STATUS *status, bool is_hid) {
switch ((*status)) {
case BOCA_TICKET_ACK:
zstr_send(self->ticket_store_req, "TICKETPRINTED");
char *code = zstr_recv(self->ticket_store_req);
if (code != NULL && streq(code, "OK")) {
self->tix_counter--;
}
if (code != NULL) zstr_free(&code);
self->event = EVENT_BOCA_ACK;
s_state_machine(self);
break;
case BOCA_INVALID_CHECKSUM:
self->event = EVENT_BOCA_ERROR_STATUS;
s_state_machine(self);
break;
case BOCA_OUT_OF_PAPER:
self->event = EVENT_BOCA_OOP;
s_state_machine(self);
break;
case BOCA_X_ON:
self->event = EVENT_BOCA_READY;
s_state_machine(self);
break;
case BOCA_POWER_ON:
self->state = STATE_IDLE;
break;
case BOCA_X_OFF:
self->event = EVENT_BOCA_BUSY;
s_state_machine(self);
break;
case BOCA_NAK:
self->event = EVENT_BOCA_ERROR_STATUS;
s_state_machine(self);
break;
case BOCA_PAPER_JAM:
self->event = EVENT_BOCA_ERROR_STATUS;
s_state_machine(self);
break;
case BOCA_ILLEGAL_DATA:
self->event = EVENT_BOCA_ERROR_STATUS;
s_state_machine(self);
break;
case BOCA_POWERUP_PROBLEM:
self->event = EVENT_BOCA_ERROR_STATUS;
s_state_machine(self);
break;
case BOCA_DOWNLOADING_ERROR:
self->event = EVENT_BOCA_ERROR_STATUS;
s_state_machine(self);
break;
case BOCA_CUTTER_JAM:
self->event = EVENT_BOCA_ERROR_STATUS;
s_state_machine(self);
break;
case BOCA_STUCK_TICKET:
self->event = EVENT_BOCA_ERROR_STATUS;
s_state_machine(self);
break;
case BOCA_UNKNOWN:
break;
case BOCA_OFFLINE:
self->event = EVENT_BOCA_ERROR_STATUS;
s_state_machine(self);
break;
case BOCA_GENERAL_ERROR:
self->event = EVENT_BOCA_ERROR_STATUS;
s_state_machine(self);
break;
}
if (self->printer_store_req != NULL && (*status) != BOCA_UNKNOWN) {
char str_status[5];
sprintf(str_status, "%d", boca_status_to_int((*status)));
if (is_hid) {
zstr_sendx(self->printer_store_req, "SETHIDPRINTERSTATUS", self->boca_hid_device_path, str_status,
NULL);
zmsg_t *resp = zmsg_recv(self->printer_store_req);
char *result = zmsg_popstr(resp);
if (streq(result, "FAIL")) {
zsys_warning("ticket printer: could not update hid printer %s status %s",
self->boca_hid_device_path,
boca_status_display((*status)));
} else {
self->hid_status_at = zclock_time();
}
zmsg_destroy(&resp);
}
#ifdef __WIN32__
else {
zstr_sendx(self->printer_store_req, "SETSERIALPRINTERSTATUS", self->serial_printer->port, str_status, NULL);
zmsg_t *resp = zmsg_recv(self->printer_store_req);
char *result = zmsg_popstr(resp);
if (streq(result, "FAIL")) {
zsys_warning("ticket printer: could not update serial printer %s status %s", self->serial_printer->port,
boca_status_display((*status)));
} else {
if (self->verbose)
zsys_debug("ticket printer: update serial printer %s status %s", self->serial_printer->port,
boca_status_display((*status)));
self->serial_status_at = zclock_time();
}
zmsg_destroy(&resp);
}
#endif
}
}
zyre_event_t *
zyre_event_new (zyre_t *node)
{
zmsg_t *msg = zyre_recv (node);
if (!msg)
return NULL; // Interrupted
zyre_event_t *self = (zyre_event_t *) zmalloc (sizeof (zyre_event_t));
assert (self);
char *type = zmsg_popstr (msg);
self->sender = zmsg_popstr (msg);
self->name = zmsg_popstr (msg);
if (streq (type, "ENTER")) {
self->type = ZYRE_EVENT_ENTER;
zframe_t *headers = zmsg_pop (msg);
if (headers) {
self->headers = zhash_unpack (headers);
zframe_destroy (&headers);
}
self->address = zmsg_popstr (msg);
}
else
if (streq (type, "EXIT"))
self->type = ZYRE_EVENT_EXIT;
else
if (streq (type, "JOIN")) {
self->type = ZYRE_EVENT_JOIN;
self->group = zmsg_popstr (msg);
}
else
if (streq (type, "LEAVE")) {
self->type = ZYRE_EVENT_LEAVE;
self->group = zmsg_popstr (msg);
}
else
if (streq (type, "WHISPER")) {
self->type = ZYRE_EVENT_WHISPER;
self->msg = msg;
msg = NULL;
}
else
if (streq (type, "SHOUT")) {
self->type = ZYRE_EVENT_SHOUT;
self->group = zmsg_popstr (msg);
self->msg = msg;
msg = NULL;
}
else
if (streq (type, "STOP")) {
self->type = ZYRE_EVENT_STOP;
}
else
if (streq (type, "EVASIVE")) {
self->type = ZYRE_EVENT_EVASIVE;
}
else
zsys_warning ("bad message received from node: %s\n", type);
free (type);
zmsg_destroy (&msg);
return self;
}
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
}
int
mdp_client_msg_recv (mdp_client_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 ("mdp_client_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 ("mdp_client_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 | 4)) {
zsys_warning ("mdp_client_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 MDP_CLIENT_MSG_CLIENT_REQUEST:
{
char version [256];
GET_STRING (version);
if (strneq (version, "MDPC02")) {
zsys_warning ("mdp_client_msg: version is invalid");
goto malformed;
}
}
{
byte messageid;
GET_NUMBER1 (messageid);
if (messageid != 1) {
zsys_warning ("mdp_client_msg: messageid is invalid");
goto malformed;
}
}
GET_STRING (self->service);
// Get zero or more remaining frames
zmsg_destroy (&self->body);
if (zsock_rcvmore (input))
self->body = zmsg_recv (input);
else
self->body = zmsg_new ();
break;
case MDP_CLIENT_MSG_CLIENT_PARTIAL:
{
char version [256];
GET_STRING (version);
if (strneq (version, "MDPC02")) {
zsys_warning ("mdp_client_msg: version is invalid");
goto malformed;
}
}
{
byte messageid;
GET_NUMBER1 (messageid);
if (messageid != 2) {
zsys_warning ("mdp_client_msg: messageid is invalid");
goto malformed;
}
}
GET_STRING (self->service);
// Get zero or more remaining frames
zmsg_destroy (&self->body);
if (zsock_rcvmore (input))
self->body = zmsg_recv (input);
else
self->body = zmsg_new ();
break;
case MDP_CLIENT_MSG_CLIENT_FINAL:
{
char version [256];
GET_STRING (version);
if (strneq (version, "MDPC02")) {
zsys_warning ("mdp_client_msg: version is invalid");
goto malformed;
}
}
{
byte messageid;
GET_NUMBER1 (messageid);
if (messageid != 3) {
zsys_warning ("mdp_client_msg: messageid is invalid");
goto malformed;
}
}
GET_STRING (self->service);
// Get zero or more remaining frames
zmsg_destroy (&self->body);
if (zsock_rcvmore (input))
self->body = zmsg_recv (input);
else
self->body = zmsg_new ();
break;
default:
zsys_warning ("mdp_client_msg: bad message ID");
goto malformed;
}
// Successful return
zmq_msg_close (&frame);
return 0;
// Error returns
malformed:
zsys_warning ("mdp_client_msg: mdp_client_msg malformed message, fail");
zmq_msg_close (&frame);
return -1; // Invalid message
}
static void s_print_tix(ticket_printer_t *self, bool serial) {
#ifdef __WIN32__
if (serial && self->serial_printer == NULL) return;
#endif
if (!serial && self->hid_printer == NULL) return;
bool is_stop = false;
int queue_size = serial ? TICKET_PRINTING_SIZE_SERIAL : TICKET_PRINTING_SIZE;
while (self->tix_counter < queue_size && !is_stop) {
int bytes_written = 0;
char count_str[15];
sprintf(count_str, "%d", queue_size - self->tix_counter);
zstr_sendx(self->ticket_store_req, "GETNEXTTICKETS", self->last_token, count_str, NULL);
zpoller_t *poller = zpoller_new(self->ticket_store_req, NULL);
zsock_t *reader = zpoller_wait(poller, 800);
if (reader == NULL) {
is_stop = true;
} else {
zmsg_t *msg = zmsg_recv(self->ticket_store_req);
char *result = zmsg_popstr(msg);
if (streq(result, "OK")) {
char *count_str_resp = zmsg_popstr(msg);
int tix_count = atoi(count_str_resp);
zsys_info("ticket printer: read %d tix back", tix_count);
while (tix_count > 0) {
char *group = zmsg_popstr(msg);
char *token = zmsg_popstr(msg);
char *data = zmsg_popstr(msg);
char *seq = zmsg_popstr(msg);
zsys_info("ticket printer: sending tix %s to BOCA", seq);
if (self->diagnostic) {
char diagnostic_fgl[100] = {'\0'};
sprintf(diagnostic_fgl, "<RR><RC25,1050><F2>S_%s", seq);
#ifdef __WIN32__
serial ? boca_serial_write(self->serial_printer, diagnostic_fgl) : boca_hid_write(
self->hid_printer,
diagnostic_fgl,
strlen(diagnostic_fgl));
#else
boca_hid_write(
self->hid_printer,
diagnostic_fgl,
strlen(diagnostic_fgl));
#endif
}
#ifdef __WIN32__
bytes_written = serial ? boca_serial_write(self->serial_printer, data) : boca_hid_write(
self->hid_printer,
data, strlen(data));
#else
bytes_written = boca_hid_write(
self->hid_printer,
data, strlen(data));
#endif
if (bytes_written > 0) {
self->tix_counter++;
self->event = EVENT_BOCA_WRITE_OK;
s_state_machine(self);
} else {
zsys_warning("ticket printer: can not write fgl to hid printer");
self->event = EVENT_BOCA_WRITE_ERROR;
s_state_machine(self);
is_stop = true;
}
free(self->last_token);
self->last_token = strdup(token);
zstr_free(&group);
zstr_free(&token);
zstr_free(&data);
zstr_free(&seq);
tix_count--;
}
zstr_free(&count_str_resp);
} else {
is_stop = true;
}
zstr_free(&result);
zmsg_destroy(&msg);
}
zpoller_destroy(&poller);
}
}
static int
server_join_cluster (server_t *self)
{
self->zyre = zyre_new (zconfig_resolve (self->config, "zyre/name", NULL));
// Get Zyre configuration properties
char *value = zconfig_resolve (self->config, "zyre/discovery", "beacon");
if (streq (value, "beacon")) {
// Set-up UDP beacon discovery
zsys_info ("using UDP beacon discovery service");
value = zconfig_resolve (self->config, "zyre/beacon/interface", "auto");
if (strneq (value, "auto")) {
zsys_info ("forcing cluster interface to %s", value);
zyre_set_interface (self->zyre, value);
}
value = zconfig_resolve (self->config, "zyre/beacon/interval", NULL);
if (value)
zyre_set_interval (self->zyre, atoi (value));
value = zconfig_resolve (self->config, "zyre/beacon/port", NULL);
if (value) {
zsys_info ("UDP beaconing on port %s", value);
zyre_set_port (self->zyre, atoi (value));
}
}
else
if (streq (value, "gossip")) {
// Set-up TCP gossip discovery
zsys_info ("using TCP gossip discovery service");
zconfig_t *section = zconfig_locate (self->config, "zyre/gossip");
if (!section) {
zsys_warning ("please configure zyre/gossip section");
return -1;
}
zconfig_t *entry = zconfig_child (section);
while (entry) {
char *name = zconfig_name (entry);
char *value = zconfig_value (entry);
if (streq (name, "endpoint")) {
zsys_info ("Zyre node endpoint=%s", value);
zyre_set_endpoint (self->zyre, "%s", value);
}
else
if (streq (name, "bind")) {
zsys_info ("gossip service bind to %s", value);
zyre_gossip_bind (self->zyre, "%s", value);
}
else
if (streq (name, "connect")) {
zsys_info ("gossip service connect to %s", value);
zyre_gossip_connect (self->zyre, "%s", value);
}
else
zsys_warning ("unknown zyre/gossip entry '%s' ignored", name);
entry = zconfig_next (entry);
}
}
else {
zsys_error ("bad zyre/discovery=%s (use beacon|gossip)", value);
assert (0);
}
if (zyre_start (self->zyre)) {
zsys_warning ("clustering not working");
return -1; // Can't join cluster
}
zyre_join (self->zyre, "ZPIPES");
// Get Zyre public name for logging
self->name = strdup (zyre_name (self->zyre));
zsys_info ("joining cluster as %s", self->name);
// Set-up reader for Zyre events
engine_handle_socket (self, zyre_socket (self->zyre), zyre_handler);
return 0;
}
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
}
static void
have_message_confirmation (client_t *self)
{
engine_set_exception (self, exception_event);
zsys_warning ("message confirmations are not implemented");
}
static int
s_on_command (zloop_t *loop, zsock_t *reader, void *arg)
{
zdir_watch_t *watch = (zdir_watch_t *) arg;
zmsg_t *msg = zmsg_recv (watch->pipe);
assert (msg);
char *command = zmsg_popstr (msg);
assert (command);
if (watch->verbose)
zsys_info ("zdir_watch: Command received: %s", command);
if (streq (command, "$TERM")) {
zstr_free (&command);
zmsg_destroy (&msg);
return -1;
}
else
if (streq (command, "VERBOSE")) {
watch->verbose = true;
zsock_signal (watch->pipe, 0);
}
else
if (streq (command, "SUBSCRIBE")) {
char *path = zmsg_popstr (msg);
if (path) {
s_zdir_watch_subscribe (watch, path);
freen (path);
}
else {
if (watch->verbose)
zsys_error ("zdir_watch: Unable to extract path from SUBSCRIBE message");
zsock_signal (watch->pipe, 1);
}
}
else
if (streq (command, "UNSUBSCRIBE")) {
char *path = zmsg_popstr (msg);
if (path) {
assert (path);
s_zdir_watch_unsubscribe (watch, path);
freen (path);
}
else {
if (watch->verbose)
zsys_error ("zdir_watch: Unable to extract path from UNSUBSCRIBE message");
zsock_signal (watch->pipe, 1);
}
}
else
if (streq (command, "TIMEOUT")) {
char *timeout_string = zmsg_popstr (msg);
if (timeout_string) {
int timeout = atoi (timeout_string);
zsock_signal (watch->pipe, s_zdir_watch_timeout (watch, timeout));
freen (timeout_string);
}
else {
if (watch->verbose)
zsys_error ("zdir_watch: Unable to extract time from TIMEOUT message");
zsock_signal (watch->pipe, 1);
}
}
else {
if (watch->verbose)
zsys_warning ("zdir_watch: Unknown command '%s'", command);
zsock_signal (watch->pipe, 1);
}
freen (command);
zmsg_destroy (&msg);
return 0;
}
