static int event(zloop_t *loop, zmq_pollitem_t *item, void *arg)
{
if (interrupt)
return -1;
zmsg_t *msg = zmsg_recv(dealer);
zframe_t *payload = zmsg_pop(msg);
zmsg_destroy(&msg);
msgpack_unpacked object;
msgpack_unpacked_init(&object);
if (msgpack_unpack_next(&object, (char*)zframe_data(payload), zframe_size(payload) , NULL))
{
//zclock_log("message");
//msgpack_object_print(stdout, object.data);
char *command = (char*)m_lookup(object.data, "command");
if (command) {
//zclock_log("command: %s", command);
if (streq(command, "exception")) {
failed++;
}
if (streq(command, "result")) {
success++;
}
free(command);
}
}
msgpack_unpacked_destroy(&object);
zframe_destroy(&payload);
return 0;
}
bool msgpack_unpack_next(msgpack_unpacked* result,
const char* data, size_t len, size_t* off)
{
msgpack_unpacked_destroy(result);
size_t noff = 0;
if(off != NULL) { noff = *off; }
if(len <= noff) {
return false;
}
msgpack_zone* z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
template_context ctx;
template_init(&ctx);
ctx.user.z = z;
ctx.user.referenced = false;
int e = template_execute(&ctx, data, len, &noff);
if(e <= 0) {
msgpack_zone_free(z);
return false;
}
if(off != NULL) { *off = noff; }
result->zone = z;
result->data = template_data(&ctx);
return true;
}
void
add_input_bytes(msgpack_unpacker *unpacker, char *buf, int sz)
{
msgpack_unpacked result;
int got = 0;
printf("reading %d bytes\n", sz);
//getchar();
printf("ENT u(%u) f(%u) o(%u) p(%u)\n", (unsigned)unpacker->used, (unsigned)unpacker->free, (unsigned)unpacker->off, (unsigned)unpacker->parsed);
msgpack_unpacker_reserve_buffer(unpacker, sz);
printf("EXP u(%u) f(%u) o(%u) p(%u)\n", (unsigned)unpacker->used, (unsigned)unpacker->free, (unsigned)unpacker->off, (unsigned)unpacker->parsed);
memcpy(msgpack_unpacker_buffer(unpacker), buf, sz);
msgpack_unpacker_buffer_consumed(unpacker, sz);
printf("CON u(%u) f(%u) o(%u) p(%u)\n", (unsigned)unpacker->used, (unsigned)unpacker->free, (unsigned)unpacker->off, (unsigned)unpacker->parsed);
msgpack_unpacked_init(&result);
while (msgpack_unpacker_next(unpacker, &result)) {
got = 1;
msgpack_object_print(stdout, result.data);
printf("\n");
}
if (got) {
msgpack_unpacker_expand_buffer(unpacker, 0);
printf("XXX u(%u) f(%u) o(%u) p(%u)\n", (unsigned)unpacker->used, (unsigned)unpacker->free, (unsigned)unpacker->off, (unsigned)unpacker->parsed);
}
msgpack_unpacked_destroy(&result);
}
static inline int process_pack(struct tcp_conn *conn,
char *pack, size_t size)
{
size_t off = 0;
msgpack_unpacked result;
msgpack_object entry;
struct flb_in_tcp_config *ctx;
ctx = conn->ctx;
/* First pack the results, iterate concatenated messages */
msgpack_unpacked_init(&result);
while (msgpack_unpack_next(&result, pack, size, &off)) {
entry = result.data;
msgpack_pack_array(&ctx->mp_pck, 2);
msgpack_pack_uint64(&ctx->mp_pck, time(NULL));
msgpack_pack_map(&ctx->mp_pck, 1);
msgpack_pack_bin(&ctx->mp_pck, 3);
msgpack_pack_bin_body(&ctx->mp_pck, "msg", 3);
msgpack_pack_object(&ctx->mp_pck, entry);
ctx->buffer_id++;
}
msgpack_unpacked_destroy(&result);
return 0;
}
void unpack(char const* buf, size_t len) {
/* buf is allocated by client. */
msgpack_unpacked result;
size_t off = 0;
msgpack_unpack_return ret;
int i = 0;
msgpack_unpacked_init(&result);
ret = msgpack_unpack_next(&result, buf, len, &off);
while (ret == MSGPACK_UNPACK_SUCCESS) {
msgpack_object obj = result.data;
/* Use obj. */
printf("Object no %d:\n", ++i);
msgpack_object_print(stdout, obj);
printf("\n");
/* If you want to allocate something on the zone, you can use zone. */
/* msgpack_zone* zone = result.zone; */
/* The lifetime of the obj and the zone, */
ret = msgpack_unpack_next(&result, buf, len, &off);
}
msgpack_unpacked_destroy(&result);
if (ret == MSGPACK_UNPACK_CONTINUE) {
printf("All msgpack_object in the buffer is consumed.\n");
}
else if (ret == MSGPACK_UNPACK_PARSE_ERROR) {
printf("The data in the buf is invalid format.\n");
}
}
void start_echo(char *arg)
{
struct timeval tv;
gettimeofday(&tv,NULL);
start = (uint64_t)tv.tv_sec;
//while(!interrupt)
//{
char *actionid = getActionid();
zmsg_t *msg = create_call(actionid, "worker", "sleep", arg);
if (msg)
{
zmsg_send(&msg, dealer);
counter ++;
zmsg_destroy(&msg);
zmsg_t *msg = zmsg_recv(dealer);
zframe_t *payload = zmsg_pop(msg);
zmsg_destroy(&msg);
msgpack_unpacked object;
msgpack_unpacked_init(&object);
if (msgpack_unpack_next(&object, (char*)zframe_data(payload), zframe_size(payload) , NULL))
{
//zclock_log("message");
//msgpack_object_print(stdout, object.data);
char *command = (char*)m_lookup(object.data, "command");
if (command) {
//zclock_log("command: %s", command);
if (streq(command, "exception")) {
failed++;
zclock_log("exception");
}
if (streq(command, "result")) {
success++;
zclock_log("result ok");
}
free(command);
}
}
msgpack_unpacked_destroy(&object);
zframe_destroy(&payload);
}
gettimeofday(&tv,NULL);
uint64_t end = (uint64_t)tv.tv_sec;
if ((end - start) == 1)
{
float speed = counter/(end-start);
zclock_log("speed %f m/s, failed %ld, success %ld", speed, failed, success);
counter = 0;
failed = 0;
success = 0;
start = end;
}
//} //end while
}
/**
* msgpack_conn_read - Buffer data from a socket read and deserialize.
*/
int
msgpack_conn_read(GIOChannel *channel, GIOCondition condition, void *data)
{
struct msgpack_conn *conn;
msgpack_unpacked result;
size_t bytes_read;
int r = TRUE;
GIOStatus status;
GError *error = NULL;
conn = (struct msgpack_conn *)data;
msgpack_unpacked_init(&result);
// Keep reading until we've flushed the channel's read buffer completely.
do {
// Reserve enough space in the msgpack_unpacker buffer for a read.
msgpack_unpacker_reserve_buffer(&conn->mc_unpacker, BUFSIZE);
// Read up to BUFSIZE bytes into the stream.
status = g_io_channel_read_chars(channel,
msgpack_unpacker_buffer(&conn->mc_unpacker), BUFSIZE, &bytes_read,
&error);
if (status == G_IO_STATUS_ERROR) {
g_warning("msgpack_conn_read: Read from socket failed.");
}
// Inform the msgpack_unpacker how much of the buffer we actually consumed.
msgpack_unpacker_buffer_consumed(&conn->mc_unpacker, bytes_read);
// Pop as many msgpack objects as we can get our hands on.
while (msgpack_unpacker_next(&conn->mc_unpacker, &result)) {
if (conn->mc_recv(conn, &result.data)) {
g_warning("paxos_read_conn: Dispatch failed.");
r = FALSE;
break;
}
}
// Drop the connection if we're at the end.
if (status == G_IO_STATUS_EOF) {
conn->mc_drop(conn);
r = FALSE;
break;
}
} while (g_io_channel_get_buffer_condition(channel) & G_IO_IN);
msgpack_unpacked_destroy(&result);
return r;
}
int handle_rep(zmq_msg_t * msg)
{
msgpack_object obj;
msgpack_unpacked pack;
char *errmsg;
msgpack_unpacked_init(&pack);
if (!msgpack_unpack_next
(&pack, zmq_msg_data(msg), zmq_msg_size(msg), NULL)) {
LOG_ERROR("handle_rep: msgpack_unpack_next failed\n");
return (-1);
}
obj = pack.data;
if (obj.type != MSGPACK_OBJECT_ARRAY) {
LOG_ERROR("handle_rep: not an array\n");
return (-2);
}
if (obj.via.array.size < 1) {
LOG_ERROR("handle_rep: empty array\n");
return (-3);
}
if (obj.via.array.ptr[0].type != MSGPACK_OBJECT_BOOLEAN) {
LOG_ERROR("handle_rep: first entry is nota boolean\n");
return (-4);
}
if (obj.via.array.ptr[0].via.boolean == false) {
if (obj.via.array.size > 1
&& obj.via.array.ptr[1].type == MSGPACK_OBJECT_RAW) {
errmsg = raw_to_string(&(obj.via.array.ptr[1].via.raw));
if (errmsg) {
LOG_SERV("%s\n", errmsg);
free(errmsg);
}
}
msgpack_unpacked_destroy(&pack);
return (1);
}
if (obj.via.array.size > 1) {
/* Technically speaking unspecified, but I feel lazy */
msgpack_object_print(stdout, obj.via.array.ptr[1]);
printf("\n");
}
return (0);
}
void tmate_decoder_commit(struct tmate_decoder *decoder, size_t len)
{
struct tmate_unpacker _uk, *uk = &_uk;
msgpack_unpacked result;
msgpack_unpacker_buffer_consumed(&decoder->unpacker, len);
msgpack_unpacked_init(&result);
while (msgpack_unpacker_next(&decoder->unpacker, &result)) {
init_unpacker(uk, result.data);
decoder->reader(decoder->userdata, uk);
}
msgpack_unpacked_destroy(&result);
}
void flb_pack_print(char *data, size_t bytes)
{
msgpack_unpacked result;
size_t off = 0, cnt = 0;
msgpack_unpacked_init(&result);
while (msgpack_unpack_next(&result, data, bytes, &off)) {
/* FIXME: lazy output */
printf("[%zd] ", cnt++);
msgpack_object_print(stdout, result.data);
printf("\n");
}
msgpack_unpacked_destroy(&result);
}
void unpack(receiver* r) {
/* buf is allocated by unpacker. */
msgpack_unpacker* unp = msgpack_unpacker_new(100);
msgpack_unpacked result;
msgpack_unpack_return ret;
size_t recv_len;
int recv_count = 0;
int i = 0;
msgpack_unpacked_init(&result);
while (true) {
recv_len = receiver_to_unpacker(r, EACH_RECV_SIZE, unp);
if (recv_len == 0) break; // (reached end of input)
printf("receive count: %d %zd bytes received.\n", recv_count++, recv_len);
ret = msgpack_unpacker_next(unp, &result);
while (ret == MSGPACK_UNPACK_SUCCESS) {
msgpack_object obj = result.data;
/* Use obj. */
printf("Object no %d:\n", ++i);
msgpack_object_print(stdout, obj);
printf("\n");
/* If you want to allocate something on the zone, you can use zone. */
/* msgpack_zone* zone = result.zone; */
/* The lifetime of the obj and the zone, */
ret = msgpack_unpacker_next(unp, &result);
}
if (ret == MSGPACK_UNPACK_PARSE_ERROR) {
printf("The data in the buf is invalid format.\n");
msgpack_unpacked_destroy(&result);
return;
}
}
msgpack_unpacked_destroy(&result);
msgpack_unpacker_free(unp);
}
static ktype_t msgpack_unpackTo(CTX ctx, const char *buf, size_t size, ksfp_t *sfp)
{
ktype_t type;
msgpack_unpacker upk;
msgpack_unpacked result;
msgpack_unpacker_init(&upk, MSGPACK_UNPACKER_INIT_BUFFER_SIZE);
msgpack_unpacker_reserve_buffer(&upk, size);
memcpy(msgpack_unpacker_buffer(&upk), buf, size);
msgpack_unpacker_buffer_consumed(&upk, size);
msgpack_unpacked_init(&result);
msgpack_unpacker_next(&upk, &result);
type = msgpack_read(ctx, result.data, sfp);
msgpack_unpacker_destroy(&upk);
msgpack_unpacked_destroy(&result);
return type;
}
msgpack_unpack_return
msgpack_unpack_next(msgpack_unpacked* result,
const char* data, size_t len, size_t* off)
{
size_t noff = 0;
msgpack_unpacked_destroy(result);
if(off != NULL) { noff = *off; }
if(len <= noff) {
return MSGPACK_UNPACK_CONTINUE;
}
if (!result->zone) {
result->zone = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
}
if (!result->zone) {
return MSGPACK_UNPACK_NOMEM_ERROR;
}
else {
int e;
template_context ctx;
template_init(&ctx);
ctx.user.z = result->zone;
ctx.user.referenced = false;
e = template_execute(&ctx, data, len, &noff);
if(e < 0) {
msgpack_zone_free(result->zone);
result->zone = NULL;
return MSGPACK_UNPACK_PARSE_ERROR;
}
if(e == 0) {
return MSGPACK_UNPACK_CONTINUE;
}
if(off != NULL) { *off = noff; }
result->data = template_data(&ctx);
return MSGPACK_UNPACK_SUCCESS;
}
}
void tmate_decoder_commit(struct tmate_decoder *decoder, size_t len)
{
msgpack_unpacked result;
msgpack_unpacker_buffer_consumed(&decoder->unpacker, len);
msgpack_unpacked_init(&result);
while (msgpack_unpacker_next(&decoder->unpacker, &result)) {
handle_message(decoder, result.data);
}
msgpack_unpacked_destroy(&result);
if (msgpack_unpacker_message_size(&decoder->unpacker) >
TMATE_MAX_MESSAGE_SIZE) {
tmate_fatal("Message too big");
}
}
static gboolean
receive_message(Session *session)
{
session->message_size =
read(session->socket_fd, session->message, MESSAGE_SIZE);
if (session->message_size == -1) {
perror("failed to read()");
return FALSE;
}
if (session->message_size == 0) {
return stop_session(session);
}
if (parse_data) {
if (session->message[0] == '{') {
JsonParser *parser;
parser = json_parser_new();
json_parser_load_from_data(parser,
session->message, session->message_size,
NULL);
g_object_unref(parser);
} else {
msgpack_unpacked unpacked;
size_t offset;
msgpack_unpacked_init(&unpacked);
msgpack_unpack_next(&unpacked,
session->message, session->message_size,
&offset);
msgpack_unpacked_destroy(&unpacked);
}
}
{
int epoll_fd = session->context->epoll_fd;
struct epoll_event event;
event.events = EPOLLOUT;
event.data.ptr = session;
if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, session->socket_fd, &event) == -1) {
perror("failed to epoll_ctl(EPOLL_CTL_MOD, client_socket_fd)");
return FALSE;
}
}
return TRUE;
}
static void
client_gone(struct socket_info *si)
{
struct client_connection *c = si->udata;
PS.active_client_connections--;
si->udata = NULL;
free_all_client_request_info_for_fd(si->fd);
delete_socket_info(si);
if (c) {
msgpack_unpacked_destroy(&c->input);
msgpack_unpacker_destroy(&c->unpacker);
free(c);
}
if (!opt_quiet)
fprintf(stderr, "client disconnect\n");
}
int main(int argc, char **argv) {
g_cmd = argv[0];
if (argc > 2) usage();
if (argc == 2) g_path = argv[1];
char buf[CHK_SIZE];
int fd;
ssize_t rsize;
msgpack_unpacker u;
msgpack_unpacked obj;
if (!strcmp(g_path, "-"))
fd = 0;
else if (strlen(g_path) > 0)
fd = open(g_path, O_RDONLY);
else
fd = 0;
if (fd < 0) goto readerr;
msgpack_unpacker_init(&u, BUF_SIZE);
msgpack_unpacked_init(&obj);
while ((rsize = read(fd, buf, CHK_SIZE)) > 0) {
msgpack_unpacker_reserve_buffer(&u, rsize);
memcpy(msgpack_unpacker_buffer(&u), buf, rsize);
msgpack_unpacker_buffer_consumed(&u, rsize);
while (msgpack_unpacker_next(&u, &obj)) {
msgpack_object_print(stdout, obj.data);
putchar('\n');
}
}
msgpack_unpacker_destroy(&u);
msgpack_unpacked_destroy(&obj);
if (fd > 0) close(fd);
return 0;
readerr:
fprintf(stderr, "file read error\n");
exit(1);
}
msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* result)
{
msgpack_unpacked_destroy(result);
int ret = msgpack_unpacker_execute(mpac);
if(ret < 0) {
result->zone = NULL;
memset(&result->data, 0, sizeof(msgpack_object));
return MSGPACK_UNPACK_PARSE_ERROR;
}
if(ret == 0) {
return MSGPACK_UNPACK_CONTINUE;
}
result->zone = msgpack_unpacker_release_zone(mpac);
result->data = msgpack_unpacker_data(mpac);
msgpack_unpacker_reset(mpac);
return MSGPACK_UNPACK_SUCCESS;
}
TEST(pack, insufficient)
{
msgpack_sbuffer* sbuf = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write);
EXPECT_EQ(0, msgpack_pack_int(pk, 255)); // uint8 (2bytes)
msgpack_unpack_return success;
size_t offset = 0;
msgpack_unpacked msg;
msgpack_unpacked_init(&msg);
success = msgpack_unpack_next(&msg, sbuf->data, 1, &offset);
EXPECT_EQ(MSGPACK_UNPACK_CONTINUE, success);
EXPECT_EQ(0u, offset);
msgpack_unpacked_destroy(&msg);
msgpack_sbuffer_free(sbuf);
msgpack_packer_free(pk);
}
TEST(unpack, sequence)
{
msgpack_sbuffer* sbuf = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write);
EXPECT_EQ(0, msgpack_pack_int(pk, 1));
EXPECT_EQ(0, msgpack_pack_int(pk, 2));
EXPECT_EQ(0, msgpack_pack_int(pk, 3));
msgpack_packer_free(pk);
msgpack_unpack_return success;
size_t offset = 0;
msgpack_unpacked msg;
msgpack_unpacked_init(&msg);
success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset);
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, success);
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type);
EXPECT_EQ(1u, msg.data.via.u64);
success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset);
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, success);
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type);
EXPECT_EQ(2u, msg.data.via.u64);
success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset);
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, success);
EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type);
EXPECT_EQ(3u, msg.data.via.u64);
success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset);
EXPECT_EQ(MSGPACK_UNPACK_CONTINUE, success);
msgpack_sbuffer_free(sbuf);
msgpack_unpacked_destroy(&msg);
}
static void scl_read_power(float *_voltage, float *_current)
{
char buffer[128];
int ret = scl_recv_static(scl_socket, buffer, sizeof(buffer));
if (ret > 0)
{
msgpack_unpacked msg;
msgpack_unpacked_init(&msg);
if (msgpack_unpack_next(&msg, buffer, ret, NULL))
{
msgpack_object root = msg.data;
assert (root.type == MSGPACK_OBJECT_ARRAY);
assert(root.via.array.size == 2);
*_voltage = root.via.array.ptr[0].via.dec;
*_current = root.via.array.ptr[1].via.dec;
}
msgpack_unpacked_destroy(&msg);
}
else
{
sleep(1);
LOG(LL_ERROR, "could not read voltage");
}
}
static void *client_thread(void *arg) {
ssize_t nwritten;
pthread_detach(pthread_self());
int client_fd = (int) (long) arg;
int yes = 1, tcp_keepalive_probes = 3, tcp_keepalive_time = 5, tcp_keepalive_intvl = 2;
int nodelay = 1;
if (setsockopt(client_fd, SOL_SOCKET, SO_KEEPALIVE, &yes, sizeof(yes)) == -1) {
log_error("setsockopt failed: %s", strerror(errno));
close(client_fd);
return NULL;
}
if (setsockopt(client_fd, SOL_TCP, TCP_KEEPCNT, &tcp_keepalive_probes, sizeof(tcp_keepalive_probes)) == -1) {
log_error("setsockopt failed: %s", strerror(errno));
close(client_fd);
return NULL;
}
if (setsockopt(client_fd, SOL_TCP, TCP_KEEPIDLE, &tcp_keepalive_time, sizeof(tcp_keepalive_time)) == -1) {
log_error("setsockopt failed: %s", strerror(errno));
close(client_fd);
return NULL;
}
if (setsockopt(client_fd, SOL_TCP, TCP_KEEPINTVL, &tcp_keepalive_intvl, sizeof(tcp_keepalive_intvl)) == -1) {
log_error("setsockopt failed: %s", strerror(errno));
close(client_fd);
return NULL;
}
if (setsockopt(client_fd, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay)) == -1) {
log_error("setsockopt failed: %s", strerror(errno));
close(client_fd);
return NULL;
}
size_t request_size = 8192;
struct request *request_back = NULL;
struct request *request = (struct request *) malloc(request_size);
if (!request) {
log_error("malloc failed: %s", strerror(errno));
close(client_fd);
return NULL;
}
msgpack_unpacked msg;
msgpack_unpacked_init(&msg);
bool enable_gzip = false;
while (1) {
struct response_header response_header;
ssize_t recvsize = readn(client_fd, request, sizeof(struct request));
if (!recvsize) {
log_warn("peer closed connection");
break;
}
if (recvsize < (ssize_t) sizeof(struct request)) {
log_warn("error while receiving header, received %zd", recvsize);
break;
}
if (request->payload_size > 256 * 1024 * 1024) {
log_warn("payload size %"PRIu32" too large", request->payload_size);
break;
}
if (sizeof(struct request) + request->payload_size > request_size) {
request_size = sizeof(struct request) + request->payload_size;
request_back = request;
request = realloc(request, request_size);
if (!request) {
log_error("realloc failed: %s", strerror(errno));
free(request_back);
break;
}
}
recvsize = readn(client_fd, request->payload, request->payload_size);
if (!recvsize) {
log_warn("peer closed connection");
break;
}
if (recvsize < request->payload_size) {
log_warn("error while receiving payload, received %zd (should be %"PRIu32")", recvsize, request->payload_size);
break;
}
if (request->flags & REQUEST_FLAG_GZIP) {
enable_gzip = true;
uLongf destLen = 16;
Bytef *dest = malloc(destLen);
if (!dest) {
log_error("malloc failed: %s", strerror(errno));
break;
}
int ret;
keep_malloc:
ret = uncompress(dest, &destLen, (Bytef *) request->payload, request->payload_size);
if (ret == Z_BUF_ERROR) {
destLen = destLen * 2;
free(dest);
dest = malloc(destLen);
if (!dest) {
log_error("malloc failed: %s", strerror(errno));
break;
}
goto keep_malloc;
}
if (ret != Z_OK) {
free(dest);
break;
}
request->flags &= ~REQUEST_FLAG_GZIP;
if (sizeof(struct request) + destLen > request_size) {
request_size = sizeof(struct request) + destLen;
request_back = request;
request = realloc(request, request_size);
if (!request) {
log_error("realloc failed: %s", strerror(errno));
free(request_back);
free(dest);
break;
}
}
memcpy(request->payload, dest, destLen);
request->payload_size = destLen;
free(dest);
}
bool success = msgpack_unpack_next(&msg, request->payload, request->payload_size, NULL);
if (!success) {
log_warn("error while parsing payload");
break;
}
msgpack_sbuffer* buffer = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
response_header.seq = request->seq;
__sync_add_and_fetch(&pending_commands, 1);
if (server->terminated) {
__sync_add_and_fetch(&pending_commands, -1);
break;
}
if (server->redirection) {
response_header.status = RESPONSE_STATUS_REDIRECTION;
msgpack_pack_map(pk, 2);
mp_pack_string(pk, "host");
mp_pack_string(pk, server->redirection->host);
mp_pack_string(pk, "port");
msgpack_pack_uint16(pk, server->redirection->port);
}
else {
response_header.status = execute_command(request, request->command, msg.data, pk);
}
__sync_add_and_fetch(&pending_commands, -1);
msgpack_packer_free(pk);
if (!(request->flags & REQUEST_FLAG_NO_REPLY)) {
if (!(buffer->size > 0)) {
response_header.payload_size = 0;
nwritten = writen(client_fd, &response_header, sizeof(response_header));
if (!nwritten) {
log_error("writen failed: %s", strerror(errno));
msgpack_sbuffer_free(buffer);
break;
}
}
else {
if (!enable_gzip) {
response_header.payload_size = buffer->size;
nwritten = writen(client_fd, &response_header, sizeof(response_header));
if (!nwritten) {
log_error("writen failed: %s", strerror(errno));
msgpack_sbuffer_free(buffer);
break;
}
nwritten = writen(client_fd, buffer->data, buffer->size);
if (!nwritten) {
log_error("writen failed: %s", strerror(errno));
msgpack_sbuffer_free(buffer);
break;
}
}
else {
uLongf destLen = buffer->size * 1.00101 + 13;
Bytef *dest = malloc(destLen);
if (!dest) {
log_error("malloc failed: %s", strerror(errno));
msgpack_sbuffer_free(buffer);
break;
}
int ret = compress(dest, &destLen, (Bytef *) buffer->data, buffer->size);
while (ret == Z_BUF_ERROR) {
destLen = destLen * 2 + 16;
free(dest);
dest = malloc(destLen);
if (!dest) {
log_error("malloc failed: %s", strerror(errno));
msgpack_sbuffer_free(buffer);
break;
}
ret = compress(dest, &destLen, (Bytef *) buffer->data, buffer->size);
}
if (ret != Z_OK) {
log_error("error while compressing response: %d", ret);
if (dest)
free(dest);
break;
}
response_header.payload_size = destLen;
nwritten = writen(client_fd, &response_header, sizeof(response_header));
if (!nwritten) {
log_warn("peer closed connection");
msgpack_sbuffer_free(buffer);
free(dest);
break;
}
if (nwritten < 0) {
log_error("send response header failed: %s", strerror(errno));
msgpack_sbuffer_free(buffer);
free(dest);
break;
}
if (nwritten < (ssize_t)sizeof(response_header)) {
log_warn("error while sending response header, sent %zd (should be %"PRIu64")", nwritten, sizeof(response_header));
msgpack_sbuffer_free(buffer);
free(dest);
break;
}
nwritten = writen(client_fd, dest, destLen);
if (!nwritten) {
log_warn("peer closed connection");
msgpack_sbuffer_free(buffer);
free(dest);
break;
}
if (nwritten < 0) {
log_error("send response failed: %s", strerror(errno));
msgpack_sbuffer_free(buffer);
free(dest);
break;
}
if (nwritten < (ssize_t)destLen) {
log_warn("error while sending response, sent %zd (should be %"PRIu64")", nwritten, destLen);
msgpack_sbuffer_free(buffer);
free(dest);
break;
}
free(dest);
}
}
}
msgpack_sbuffer_free(buffer);
if (request_size > 65536) {
request_size = 8192;
request_back = request;
request = realloc(request, request_size);
if (!request) {
log_error("realloc failed: %s", strerror(errno));
free(request_back);
break;
}
}
}
close(client_fd);
free(request);
msgpack_unpacked_destroy(&msg);
return NULL;
}
int handle_req(void *socket, zmq_msg_t * msg)
{
int command_id;
char *query;
char *path = NULL;
msgpack_object obj;
msgpack_unpacked pack;
msgpack_unpacked_init(&pack);
if (!msgpack_unpack_next
(&pack, zmq_msg_data(msg), zmq_msg_size(msg), NULL)) {
LOG_ERROR("handle_req: msgpack_unpack_next failed\n");
return (-1);
}
obj = pack.data;
if (obj.type != MSGPACK_OBJECT_ARRAY) {
LOG_ERROR("handle_req: not an array\n");
pcma_send(socket, failed_packfn, "not an array");
return (-2);
}
const char *command = (const char *) obj.via.array.ptr[0].via.raw.ptr;
int command_size = obj.via.array.ptr[0].via.raw.size;
if (!command) {
LOG_ERROR("handle_req: no command\n");
pcma_send(socket, failed_packfn, "no command");
return (-3);
}
if (command_size == PING_COMMAND_SIZE &&
!bcmp(PING_COMMAND, command, PING_COMMAND_SIZE)) {
command_id = PING_COMMAND_ID;
} else if (command_size == LIST_COMMAND_SIZE &&
!bcmp(LIST_COMMAND, command, LIST_COMMAND_SIZE)) {
command_id = LIST_COMMAND_ID;
} else if (command_size == LOCK_COMMAND_SIZE &&
!bcmp(LOCK_COMMAND, command, LOCK_COMMAND_SIZE)) {
command_id = LOCK_COMMAND_ID;
} else if (command_size == UNLOCK_COMMAND_SIZE &&
!bcmp(UNLOCK_COMMAND, command, UNLOCK_COMMAND_SIZE)) {
command_id = UNLOCK_COMMAND_ID;
} else {
LOG_ERROR("handle_req: unknown command\n");
pcma_send(socket, failed_packfn, "unknown command");
return (-4);
}
switch (command_id) {
case PING_COMMAND_ID:
case LIST_COMMAND_ID:
if (obj.via.array.size != 1) {
LOG_ERROR("handle_req: no parameter expected\n");
pcma_send(socket, failed_packfn, "no parameter expected");
return (-5);
}
break;
case LOCK_COMMAND_ID:
case UNLOCK_COMMAND_ID:
if (obj.via.array.size != 2) {
LOG_ERROR("handle_req: 1 parameter expected\n");
pcma_send(socket, failed_packfn, "1 parameter expected");
return (-6);
}
if (obj.via.array.ptr[1].type != MSGPACK_OBJECT_RAW) {
LOG_ERROR("handle_req: RAW parameter expected\n");
pcma_send(socket, failed_packfn, "RAW parameter expected");
return (-7);
}
path = raw_to_string(&obj.via.array.ptr[1].via.raw);
if (!path) {
perror("raw_to_string");
pcma_send(socket, failed_packfn, "raw_to_string failure");
}
}
switch (command_id) {
case PING_COMMAND_ID:
handle_ping_request(socket);
break;
case LIST_COMMAND_ID:
handle_list_request(socket);
break;
case LOCK_COMMAND_ID:
handle_lock_request(socket, path);
break;
case UNLOCK_COMMAND_ID:
handle_unlock_request(socket, path);
break;
}
msgpack_unpacked_destroy(&pack);
if (path)
free(path);
return 0;
}
void ANetworkController::TryReceiveData() {
if (!TcpSocket) {
return;
}
uint32 Size;
if (TcpSocket->HasPendingData(Size)) {
uint8 buffer[4096];
int32 read;
TcpSocket->Recv(buffer, 4096, read);
msgpack_unpacker_reserve_buffer(&unpacker, read);
memcpy(msgpack_unpacker_buffer(&unpacker), buffer, read);
msgpack_unpacker_buffer_consumed(&unpacker, read);
msgpack_unpacked result;
msgpack_unpacked_init(&result);
while (msgpack_unpacker_next(&unpacker, &result)) {
msgpack_object* packet = &result.data;
TMap<FName, msgpack_object*> Received = Unpack<TMap<FName, msgpack_object*>>(packet);
uint8 PacketTypeId = Received[TYPE]->via.i64;
EPacketType PacketType = (EPacketType)PacketTypeId;
msgpack_object* Data = Received[DATA];
switch (PacketType) {
case EPacketType::PT_SetPaused: {
bool Paused = Received[DATA]->via.boolean;
ReceivedSetPaused(Paused);
break;
}
case EPacketType::PT_GetBehaviors: {
ReceivedGetBehaviors();
break;
}
case EPacketType::PT_ConfigureSpawner: {
TMap<FName, msgpack_object*> DataMap = Unpack<TMap<FName, msgpack_object*>>(Data);
ReceivedConfigureSpawner(DataMap);
break;
}
case EPacketType::PT_DisableAllSpawners: {
ReceivedDisableAllSpawners();
break;
}
case EPacketType::PT_ExecuteCommand: {
ReceivedExecuteCommand(Data);
break;
}
case EPacketType::PT_RemoveAllVehicles: {
ReceivedRemoveAllVehicles();
break;
}
case EPacketType::PT_ResetStats: {
ReceivedResetStats();
break;
}
case EPacketType::PT_RecreateLogEntry: {
ReceivedRecreateLogEntry(Data);
break;
}
case EPacketType::PT_AddArrow: {
ReceivedAddArrow(Data);
break;
}
case EPacketType::PT_StartRecording: {
ReceivedStartRecording(Data);
break;
}
case EPacketType::PT_StopRecording: {
ReceivedStopRecording(Data);
break;
}
case EPacketType::PT_StartPlayback: {
ReceivedStartPlayback(Data);
break;
}
case EPacketType::PT_StopPlayback: {
ReceivedStopPlayback(Data);
break;
}
case EPacketType::PT_GetGitHash: {
ReceivedGetGitHash();
break;
}
case EPacketType::PT_StartMatinee: {
ReceivedStartMatinee(Data);
break;
}
case EPacketType::PT_SetArrowsVisible:
ReceivedSetArrowsVisible(Data);
break;
case EPacketType::PT_SeekAndPauseReplay:
ReceivedSeekAndPauseReplay(Data);
break;
case EPacketType::PT_SetReplaySpeed:
ReceivedSetReplaySpeed(Data);
break;
case EPacketType::PT_SetReplayPaused:
ReceivedSetReplayPaused(Data);
break;
case EPacketType::PT_SelectCamera:
ReceivedSelectCamera(Data);
break;
case EPacketType::PT_CameraLookAtVehicle:
ReceivedCameraLookAtVehicle(Data);
break;
case EPacketType::PT_SelectVehicleCamera:
ReceivedSelectVehicleCamera(Data);
break;
case EPacketType::PT_FollowCam:
ReceivedFollowCam(Data);
break;
}
}
msgpack_unpacked_destroy(&result);
}
}
void rpc_service_handle(rpc_service_t *service, zmq_msg_t *request) {
/* Parse the msgpack */
zmq_msg_t response;
int rc;
msgpack_unpacked request_msg;
msgpack_unpacked_init(&request_msg);
rc = msgpack_unpack_next(&request_msg, zmq_msg_data(request),
zmq_msg_size(request), NULL);
insist_return(rc, (void)(0), "Failed to unpack message '%.*s'",
(int)zmq_msg_size(request), (char *)zmq_msg_data(request));
msgpack_object request_obj = request_msg.data;
/* Find the method name */
char *method = NULL;
size_t method_len = -1;
rc = obj_get(&request_obj, "method", MSGPACK_OBJECT_RAW, &method, &method_len);
msgpack_sbuffer *response_buffer = msgpack_sbuffer_new();
msgpack_sbuffer *result_buffer = msgpack_sbuffer_new();
msgpack_sbuffer *error_buffer = msgpack_sbuffer_new();
msgpack_packer *response_msg = msgpack_packer_new(response_buffer, msgpack_sbuffer_write);
msgpack_packer *result = msgpack_packer_new(result_buffer, msgpack_sbuffer_write);
msgpack_packer *error = msgpack_packer_new(error_buffer, msgpack_sbuffer_write);
//printf("Method: %.*s\n", method_len, method);
void *clock = zmq_stopwatch_start();
double duration;
if (rc != 0) { /* method not found */
msgpack_pack_nil(result); /* result is nil on error */
msgpack_pack_map(error, 2);
msgpack_pack_string(error, "error", -1);
msgpack_pack_string(error, "Message had no 'method' field", -1);
msgpack_pack_string(error, "request", -1);
msgpack_pack_object(error, request_obj);
} else { /* valid method, keep going */
//printf("The method is: '%.*s'\n", (int)method_len, method);
rpc_name name;
name.name = method;
name.len = method_len;
rpc_method *rpcmethod = g_tree_lookup(service->methods, &name);
/* if we found a valid rpc method and the args check passed ... */
if (rpcmethod != NULL) {
/* the callback is responsible for filling in the 'result' and 'error'
* objects. */
rpcmethod->callback(NULL, &request_obj, result, error, rpcmethod->data);
} else {
msgpack_pack_nil(result); /* result is nil on error */
/* TODO(sissel): allow methods to register themselves */
//fprintf(stderr, "Invalid request '%.*s' (unknown method): ",
//method_len, method);
//msgpack_object_print(stderr, request_obj);
//fprintf(stderr, "\n");
msgpack_pack_map(error, 2);
msgpack_pack_string(error, "error", -1);
msgpack_pack_string(error, "No such method requested", -1);
msgpack_pack_string(error, "request", -1);
msgpack_pack_object(error, request_obj);
}
} /* valid/invalid method handling */
duration = zmq_stopwatch_stop(clock) / 1000000.;
//printf("method '%.*s' took %lf seconds\n", (int)method_len, method);
msgpack_unpacked result_unpacked;
msgpack_unpacked error_unpacked;
msgpack_unpacked response_unpacked;
msgpack_unpacked_init(&result_unpacked);
msgpack_unpacked_init(&error_unpacked);
msgpack_unpacked_init(&response_unpacked);
/* TODO(sissel): If this unpack test fails, we should return an error to the calling
* client indicating that some internal error has occurred */
//fprintf(stderr, "Result payload: '%.*s'\n", result_buffer->size,
//result_buffer->data);
rc = msgpack_unpack_next(&result_unpacked, result_buffer->data,
result_buffer->size, NULL);
insist(rc == true, "msgpack_unpack_next failed on 'result' buffer"
" of request '%.*s'", (int)method_len, method);
rc = msgpack_unpack_next(&error_unpacked, error_buffer->data,
error_buffer->size, NULL);
insist(rc == true, "msgpack_unpack_next failed on 'error' buffer"
" of request '%.*s'", (int)method_len, method);
msgpack_pack_map(response_msg, 3); /* result, error, duration */
msgpack_pack_string(response_msg, "result", 6);
msgpack_pack_object(response_msg, result_unpacked.data);
msgpack_pack_string(response_msg, "error", 5);
msgpack_pack_object(response_msg, error_unpacked.data);
msgpack_pack_string(response_msg, "duration", 8);
msgpack_pack_double(response_msg, duration);
rc = msgpack_unpack_next(&response_unpacked, response_buffer->data,
response_buffer->size, NULL);
insist(rc == true, "msgpack_unpack_next failed on full response buffer"
" of request '%.*s'", (int)method_len, method);
//printf("request: ");
//msgpack_object_print(stdout, request_obj);
//printf("\n");
//printf("response: ");
//msgpack_object_print(stdout, response_unpacked.data);
//printf("\n");
zmq_msg_init_data(&response, response_buffer->data, response_buffer->size,
free_msgpack_buffer, response_buffer);
zmq_send(service->socket, &response, 0);
zmq_msg_close(&response);
msgpack_packer_free(error);
msgpack_packer_free(result);
msgpack_sbuffer_free(error_buffer);
msgpack_sbuffer_free(result_buffer);
msgpack_packer_free(response_msg);
msgpack_unpacked_destroy(&request_msg);
} /* rpc_service_handle */
void yar_unpack_free(yar_unpackager *unpk) /* {{{ */ {
msgpack_unpacked_destroy(&unpk->msg);
free(unpk);
}
void cb_forward_flush(void *data, size_t bytes,
char *tag, int tag_len,
struct flb_input_instance *i_ins, void *out_context,
struct flb_config *config)
{
int ret = -1;
int entries = 0;
size_t off = 0;
size_t total;
size_t bytes_sent;
msgpack_packer mp_pck;
msgpack_sbuffer mp_sbuf;
msgpack_unpacked result;
struct flb_out_forward_config *ctx = out_context;
struct flb_upstream_conn *u_conn;
(void) i_ins;
(void) config;
flb_debug("[out_forward] request %lu bytes to flush", bytes);
/* Initialize packager */
msgpack_sbuffer_init(&mp_sbuf);
msgpack_packer_init(&mp_pck, &mp_sbuf, msgpack_sbuffer_write);
/* Count number of entries, is there a better way to do this ? */
msgpack_unpacked_init(&result);
while (msgpack_unpack_next(&result, data, bytes, &off)) {
entries++;
}
flb_debug("[out_fw] %i entries tag='%s' tag_len=%i",
entries, tag, tag_len);
msgpack_unpacked_destroy(&result);
/* Output: root array */
msgpack_pack_array(&mp_pck, 2);
msgpack_pack_str(&mp_pck, tag_len);
msgpack_pack_str_body(&mp_pck, tag, tag_len);
msgpack_pack_array(&mp_pck, entries);
/* Get a TCP connection instance */
u_conn = flb_upstream_conn_get(ctx->u);
if (!u_conn) {
flb_error("[out_forward] no upstream connections available");
msgpack_sbuffer_destroy(&mp_sbuf);
FLB_OUTPUT_RETURN(FLB_RETRY);
}
/* Write message header */
ret = flb_io_net_write(u_conn, mp_sbuf.data, mp_sbuf.size, &bytes_sent);
if (ret == -1) {
flb_error("[out_forward] could not write chunk header");
msgpack_sbuffer_destroy(&mp_sbuf);
flb_upstream_conn_release(u_conn);
FLB_OUTPUT_RETURN(FLB_RETRY);
}
msgpack_sbuffer_destroy(&mp_sbuf);
total = ret;
/* Write body */
ret = flb_io_net_write(u_conn, data, bytes, &bytes_sent);
if (ret == -1) {
flb_error("[out_forward] error writing content body");
flb_upstream_conn_release(u_conn);
FLB_OUTPUT_RETURN(FLB_RETRY);
}
total += bytes_sent;
flb_upstream_conn_release(u_conn);
flb_trace("[out_forward] ended write()=%d bytes", total);
FLB_OUTPUT_RETURN(FLB_OK);
}
/**
* plume_recv_dispatch - Dispatch routine for Plume server messages.
*/
int
plume_recv_dispatch(struct plume_client *client, int status, void *data)
{
ssize_t len;
msgpack_unpacked result;
msgpack_object *o, *p;
int opcode;
(void)status;
(void)data;
msgpack_unpacked_init(&result);
// Reserve enough space in the msgpack buffer for a read.
msgpack_unpacker_reserve_buffer(&client->pc_unpac, BUFSIZE);
// Read up to BUFSIZE bytes into the stream.
len = plume_recv(client, msgpack_unpacker_buffer(&client->pc_unpac), BUFSIZE);
msgpack_unpacker_buffer_consumed(&client->pc_unpac, len);
// Dispatch on as many msgpack objects as possible.
while (msgpack_unpacker_next(&client->pc_unpac, &result)) {
o = &result.data;
// Discard malformed responses.
if (o->type != MSGPACK_OBJECT_ARRAY ||
o->via.array.size < 2 || o->via.array.size > 3) {
log_error("Discarding malformed Plume server payload");
continue;
}
p = o->via.array.ptr;
// Pull out the opcode.
if (p->type != MSGPACK_OBJECT_POSITIVE_INTEGER) {
log_error("Discarding malformed Plume server payload");
continue;
}
opcode = (p++)->via.u64;
// Dispatch.
switch (opcode) {
case PLUME_OP_IDENTIFY:
plume_recv_identify(client, p->via.raw.ptr, p->via.raw.size, p + 1);
break;
case PLUME_OP_CERT:
plume_recv_cert(client, p->via.raw.ptr, p->via.raw.size, p + 1);
break;
case PLUME_OP_CONNECT:
plume_recv_connect(client, p->via.raw.ptr, p->via.raw.size, p + 1);
break;
case PLUME_OP_UDP_ACK:
plume_recv_udp_ack(client, p);
case PLUME_OP_UDP_ECHO:
plume_recv_udp_echo(client, p);
break;
default:
log_error("Discarding malformed Plume server payload");
break;
}
}
msgpack_unpacked_destroy(&result);
return 0;
}
void rpc_handle(rpc_io *rpcio, zmq_msg_t *request) {
/* Parse the msgpack */
zmq_msg_t response;
int rc;
msgpack_unpacked request_msg;
msgpack_unpacked_init(&request_msg);
rc = msgpack_unpack_next(&request_msg, zmq_msg_data(request),
zmq_msg_size(request), NULL);
insist_return(rc, (void)(0), "Failed to unpack message '%.*s'",
zmq_msg_size(request), zmq_msg_data(request));
msgpack_object request_obj = request_msg.data;
printf("Object: ");
msgpack_object_print(stdout, request_obj); /*=> ["Hello", "MessagePack"] */
printf("\n");
/* Find the method name */
char *method = NULL;
size_t method_len = -1;
rc = obj_get(&request_obj, "request", MSGPACK_OBJECT_RAW, &method, &method_len);
msgpack_sbuffer *buffer = msgpack_sbuffer_new();
msgpack_packer *response_msg = msgpack_packer_new(buffer, msgpack_sbuffer_write);
printf("Method: %.*s\n", method_len, method);
if (rc != 0) {
fprintf(stderr, "Message had no 'request' field. Ignoring: ");
msgpack_object_print(stderr, request_obj);
msgpack_pack_map(response_msg, 2);
msgpack_pack_string(response_msg, "error", -1);
msgpack_pack_string(response_msg, "Message had no 'request' field", -1);
msgpack_pack_string(response_msg, "request", -1);
msgpack_pack_object(response_msg, request_obj);
} else {
/* Found request */
printf("The method is: '%.*s'\n", (int)method_len, method);
//msgpack_pack_map(response_msg, 2);
//msgpack_pack_string(response_msg, "results", 7);
void *clock = zmq_stopwatch_start();
/* TODO(sissel): Use gperf here or allow methods to register themselves */
if (!strncmp("dance", method, method_len)) {
api_request_dance(rpcio, &request_obj, response_msg);
} else if (!strncmp("restart", method, method_len)) {
api_request_restart(rpcio, &request_obj, response_msg);
} else if (!strncmp("status", method, method_len)) {
api_request_status(rpcio, &request_obj, response_msg);
} else if (!strncmp("create", method, method_len)) {
api_request_create(rpcio, &request_obj, response_msg);
} else {
fprintf(stderr, "Invalid request '%.*s' (unknown method): ", method_len, method);
msgpack_object_print(stderr, request_obj);
msgpack_pack_map(response_msg, 2);
msgpack_pack_string(response_msg, "error", -1);
msgpack_pack_string(response_msg, "No such method requested", -1);
msgpack_pack_string(response_msg, "request", -1);
msgpack_pack_object(response_msg, request_obj);
}
double duration = zmq_stopwatch_stop(clock) / 1000000.;
printf("method '%.*s' took %lf seconds\n", (int)method_len, method);
//msgpack_pack_string(response_msg, "stats", 5);
//msgpack_pack_map(response_msg, 1),
//msgpack_pack_string(response_msg, "duration", 8);
//msgpack_pack_double(response_msg, duration);
}
zmq_msg_init_data(&response, buffer->data, buffer->size, free_msgpack_buffer, buffer);
zmq_send(rpcio->socket, &response, 0);
zmq_msg_close(&response);
//msgpack_sbuffer_free(buffer);
msgpack_packer_free(response_msg);
msgpack_unpacked_destroy(&request_msg);
} /* rpc_handle */
/* EXPECTED ARGUMENTS:
* <endpoint> <identity>
*/
int main(int argc, char *argv[]) {
if (argc < 3) {
fprintf(stderr, "Usage: testdriver <endpoint> <identity>\n");
return 1;
}
void *context = zmq_ctx_new();
void *socket = zmq_socket(context, ZMQ_DEALER);
char *address = argv[1];
char *identity = argv[2];
fprintf(stdout, "Connecting worker %s to socket at %s\n", identity, address);
zmq_setsockopt(socket, ZMQ_IDENTITY, identity, strlen(identity));
zmq_connect(socket, address);
zmq_send_const(socket, "RDY", 3, 0);
char *outbuffer = NULL;
msgpack_unpacked unpacked;
for (;;) {
zmq_msg_t msg;
zmq_msg_init(&msg);
zmq_msg_recv(&msg, socket, 0);
size_t size = zmq_msg_size(&msg);
char *inbuffer = (char *) malloc(size + 1);
if (NULL == inbuffer) {
fprintf(stderr, "Out of Memory!\n");
return 1;
}
memcpy(inbuffer, zmq_msg_data(&msg), size);
zmq_msg_close(&msg);
inbuffer[size] = 0;
msgpack_unpacked_init(&unpacked);
size_t off = 0;
bool res = msgpack_unpack_next(&unpacked, inbuffer, size, &off);
if (!res) {
fprintf(stderr,"res == %d\n", res);
fprintf(stderr,"off == %zu\n", off);
return 1;
}
msgpack_object obj = unpacked.data;
uint32_t id = (uint32_t) obj.via.u64;
msgpack_unpacked_destroy(&unpacked);
res = msgpack_unpack_next(&unpacked, inbuffer, size, &off);
if (!res) {
fprintf(stderr, "res == %d\n", res);
fprintf(stderr, "off == %zu\n", off);
return 1;
}
obj = unpacked.data;
const char* path = obj.via.str.ptr;
PIN_SCORE_START(outbuffer);
// TODO call sut here with path
msgpack_unpacked_destroy(&unpacked);
free(inbuffer);
outbuffer = PIN_SCORE_END(id, socket);
}
}
