void prepare(msgpack_sbuffer* sbuf) {
msgpack_packer pk;
msgpack_packer_init(&pk, sbuf, msgpack_sbuffer_write);
/* 1st object */
msgpack_pack_array(&pk, 3);
msgpack_pack_int(&pk, 1);
msgpack_pack_true(&pk);
msgpack_pack_str(&pk, 7);
msgpack_pack_str_body(&pk, "example", 7);
/* 2nd object */
msgpack_pack_str(&pk, 6);
msgpack_pack_str_body(&pk, "second", 6);
/* 3rd object */
msgpack_pack_array(&pk, 2);
msgpack_pack_int(&pk, 42);
msgpack_pack_false(&pk);
}
int UserInfo_to_msgpack(msgpack_packer *pk, UserInfo *arg) {
msgpack_pack_array(pk, 3);
msgpack_pack_int(pk, arg->uid);
if (!arg->name) {
msgpack_pack_nil(pk);
} else {
if (arg->name) {
size_t _l = strlen(arg->name);
msgpack_pack_raw(pk, _l);
msgpack_pack_raw_body(pk, arg->name, _l);
} else {
msgpack_pack_nil(pk);
}
}
msgpack_pack_int(pk, arg->flags);
return 0;
}
int master_finder(zloop_t *loop, zmq_pollitem_t *item, void *arg) {
maneater_client *cli = (maneater_client *)arg;
zframe_t *out;
MSG_DOPACK(
msgpack_pack_int(pk, MID_WANT_MASTER);
MSG_PACK_STR(pk, cli->sessid);
MSG_PACK_STR(pk, cli->myhostid);
out = zframe_new(buf->data, buf->size);
);
void
paxos_header_pack(struct yakyak *yy, struct paxos_header *hdr)
{
msgpack_pack_array(yy->pk, 5);
paxos_uuid_pack(yy, &hdr->ph_session);
msgpack_pack_paxid(yy->pk, hdr->ph_ballot.id);
msgpack_pack_paxid(yy->pk, hdr->ph_ballot.gen);
msgpack_pack_int(yy->pk, hdr->ph_opcode);
msgpack_pack_paxid(yy->pk, hdr->ph_inum);
}
TEST(pack, num)
{
msgpack_sbuffer* sbuf = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write);
EXPECT_EQ(0, msgpack_pack_int(pk, 1));
msgpack_sbuffer_free(sbuf);
msgpack_packer_free(pk);
}
void send_trigger(mdcli_t * client, char * target_worker, char * rule_id, int ival, char * user_id) {
zclock_log("activating trigger\ntarget=%s\nvalue=%d\nuser=%s",
target_worker, ival, user_id);
struct timeval tval;
gettimeofday(&tval, NULL);
// make a messagepack hash
msgpack_sbuffer * buffer = msgpack_sbuffer_new();
msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
// value chunk
msgpack_pack_map(pk, 3);
// key
msgpack_pack_raw(pk, 5);
msgpack_pack_raw_body(pk, "value", 5);
// value
msgpack_pack_int(pk, ival);
//time chunk
// key
msgpack_pack_raw(pk, 5);
msgpack_pack_raw_body(pk, "epoch", 5);
// time
msgpack_pack_int(pk, tval.tv_sec);
msgpack_pack_raw(pk, 6);
msgpack_pack_raw_body(pk, "micros", 6);
// time
msgpack_pack_int(pk, tval.tv_usec);
zmsg_t * msg = zmsg_new();
// really, the user_id should be being added by a
// gatekeeper, not the block itself, or it's a security
// hole. will do for now FIX
zmsg_pushstr(msg, user_id);
// zmsg_pushmem(msg, &trigger.line_id, sizeof(int));
zmsg_pushmem(msg, buffer->data, buffer->size);
zmsg_pushstr(msg, rule_id);
zmsg_pushstr(msg, "DoAction");
mdcli_send(client, target_worker, &msg);
}
void receiver_init(receiver *r) {
msgpack_packer pk;
msgpack_sbuffer_init(&r->sbuf);
msgpack_packer_init(&pk, &r->sbuf, msgpack_sbuffer_write);
/* 1st object */
msgpack_pack_array(&pk, 3);
msgpack_pack_int(&pk, 1);
msgpack_pack_true(&pk);
msgpack_pack_str(&pk, 7);
msgpack_pack_str_body(&pk, "example", 7);
/* 2nd object */
msgpack_pack_str(&pk, 6);
msgpack_pack_str_body(&pk, "second", 6);
/* 3rd object */
msgpack_pack_array(&pk, 2);
msgpack_pack_int(&pk, 42);
msgpack_pack_false(&pk);
r->rest = r->sbuf.size;
}
void report_cert(int err, struct pl*name, struct pl*uri, void*arg)
{
msgpack_packer *pk = arg;
msgpack_pack_array(pk, err ? 2 : 4);
push_cstr("cert.ok");
msgpack_pack_int(pk, err);
if(err==0) {
push_pl((*name));
push_pl((*uri));
}
}
static void pack_hash_event(rbkit_hash_event *event, msgpack_packer *packer) {
VALUE hash;
int size;
msgpack_pack_map(packer, 3);
pack_event_header(packer, event->event_header.event_type);
hash = event->hash;
size = (int)RHASH_SIZE(hash);
msgpack_pack_int(packer, rbkit_message_field_payload);
msgpack_pack_map(packer, size);
rb_hash_foreach(hash, hash_pack_iterator, (VALUE)packer);
}
void monitor_pack_draw_queue(void)
{
unsigned int i;
if(!draw_pk) {
draw_pk = monitor_method_new("DISPLAY_DRAW", draw_sbuf);
}
else {
monitor_method_add("DISPLAY_DRAW", draw_pk);
}
msgpack_pack_array(draw_pk, draw_queue_n);
for(i = 0; i < draw_queue_n; i++) {
msgpack_pack_array(draw_pk, 3);
msgpack_pack_int(draw_pk, draw_queue[i].x);
msgpack_pack_int(draw_pk, draw_queue[i].y);
msgpack_pack_int(draw_pk, draw_queue[i].color);
}
draw_queue_n = 0;
}
/**
* Send [type(2), method, params]
* Returns false if the params could not be serialized
*/
bool MsgpackIODevice::sendNotification(const QByteArray& method, const QVariantList& params)
{
if (!checkVariant(params)) {
return false;
}
msgpack_pack_array(&m_pk, 3);
msgpack_pack_int(&m_pk, 2);
send(method);
send(params);
return true;
}
static FilterReplyResult filter_apply(FilterReplyResultBase * const rb,
const struct sockaddr_storage * const sa_local,
const socklen_t sa_local_len,
struct msghdr *msg, size_t * const nbyte,
int * const flags)
{
msgpack_packer * const msgpack_packer = rb->filter->msgpack_packer;
if (rb->pre != false) {
filter_before_apply(rb, 2U, "recvmsg",
sa_local, sa_local_len, NULL, (socklen_t) 0U);
} else {
filter_before_apply(rb, 2U, "recvmsg",
sa_local, sa_local_len,
msg->msg_name, msg->msg_namelen);
}
msgpack_pack_mstring(msgpack_packer, "flags");
msgpack_pack_int(msgpack_packer, *flags);
if (rb->pre != false) {
msgpack_pack_mstring(msgpack_packer, "nbyte");
msgpack_pack_unsigned_long(msgpack_packer, *nbyte);
} else if (*rb->ret <= 0) {
msgpack_pack_mstring(msgpack_packer, "data");
msgpack_pack_nil(msgpack_packer);
} else {
assert((size_t) *rb->ret <= *nbyte);
msgpack_pack_mstring(msgpack_packer, "data");
msgpack_pack_raw(msgpack_packer, *nbyte);
size_t data_remaining = *nbyte;
size_t read_from_vec;
struct iovec * const vecs = msg->msg_iov;
size_t i_vecs = 0U;
while (i_vecs < (size_t) msg->msg_iovlen &&
data_remaining > (size_t) 0U) {
if (data_remaining < vecs[i_vecs].iov_len) {
read_from_vec = data_remaining;
} else {
read_from_vec = vecs[i_vecs].iov_len;
}
assert(data_remaining >= read_from_vec);
assert(vecs[i_vecs].iov_len >= read_from_vec);
msgpack_pack_raw_body(msgpack_packer, vecs[i_vecs].iov_base,
read_from_vec);
data_remaining -= read_from_vec;
i_vecs++;
}
}
if (filter_send_message(rb->filter) != 0) {
return FILTER_REPLY_RESULT_ERROR;
}
return filter_parse_reply(rb, msg, flags);
}
void report_lp(int err, struct pl*token, void*arg)
{
msgpack_packer *pk = arg;
if(err ==1 ) {
msgpack_pack_array(pk, 3);
} else {
msgpack_pack_array(pk, 2);
}
push_cstr("api.login_phone");
msgpack_pack_int(pk, err);
if(err==1)
push_pl((*token));
}
void report_call(struct tcsipcall* call, void *arg) {
int cdir, cstate, ts;
struct sip_addr *remote;
char *ckey = tcsipcall_ckey(call);
msgpack_packer *pk = arg;
msgpack_pack_array(pk, 7);
push_cstr("sip.call.add");
push_cstr_len(ckey);
tcsipcall_dirs(call, &cdir, &cstate, NULL, &ts);
msgpack_pack_int(pk, cdir);
msgpack_pack_int(pk, cstate);
msgpack_pack_int(pk, ts);
tcop_lr((void*)call, NULL, &remote);
push_pl(remote->dname);
push_pl(remote->uri.user);
}
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);
}
void init_unpack_array(msgpack_object_type type)
{
size_t off = 0;
msgpack_sbuffer sbuf;
msgpack_sbuffer_init(&sbuf);
msgpack_packer pk;
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 3);
if (type == MSGPACK_OBJECT_NIL) {
msgpack_pack_nil(&pk);
} else if (type == MSGPACK_OBJECT_POSITIVE_INTEGER) {
msgpack_pack_int(&pk, 1);
} else if (type == MSGPACK_OBJECT_BOOLEAN) {
msgpack_pack_true(&pk);
} else if (type == MSGPACK_OBJECT_MAP) {
msgpack_pack_map(&pk, 1);
} else if (type == MSGPACK_OBJECT_ARRAY) {
msgpack_pack_array(&pk, 3);
msgpack_pack_int(&pk, 1);
msgpack_pack_int(&pk, 1);
msgpack_pack_int(&pk, 1);
} else if (type == MSGPACK_OBJECT_FLOAT) {
msgpack_pack_double(&pk, 1.2);
}
msgpack_pack_true(&pk);
msgpack_pack_str(&pk, 7);
msgpack_pack_str_body(&pk, "example", 7);
msgpack_unpacked result;
msgpack_unpacked_init(&result);
msgpack_unpack_next(&result, sbuf.data, sbuf.size, &off);
msgpack_sbuffer_destroy(&sbuf);
deserialized = result.data;
}
void report_ctlist(int err, struct list*ctlist, void*arg)
{
int cnt;
msgpack_packer *pk = arg;
msgpack_pack_array(pk, err ? 2 : 3);
push_cstr("contacts.res");
msgpack_pack_int(pk, err);
if(err) return;
cnt = list_count(ctlist);
msgpack_pack_array(pk, cnt);
list_apply(ctlist, true, write_contact_el, arg);
}
void report_hist(int err, char *idx, struct list*hlist, void*arg)
{
int cnt;
msgpack_packer *pk = arg;
msgpack_pack_array(pk, err ? 2 : 4);
push_cstr("hist.res");
msgpack_pack_int(pk, err);
if(err) return;
push_cstr_len(idx);
cnt = list_count(hlist);
msgpack_pack_array(pk, cnt);
list_apply(hlist, true, write_history_el, arg);
}
void publish_output(process_t *process, struct proc_data *procdata,
const char *ioname, const char *data, ssize_t length) {
/* TODO(sissel): move this to a separate file for 'event' streaming */
zmq_msg_t event;
int rc;
size_t msgsize;
program_t *program = pn_proc_program(process);
procnanny_t *pn = program->data;
fprintf(stdout, "%s[%d]: (%d bytes) %.*s\n", pn_proc_program(process)->name,
pn_proc_instance(process), length, length, data);
/* Fields:
* - data (the string read)
* - program name
* - process instance
* - stdout or stderr
*/
msgpack_sbuffer *buffer = msgpack_sbuffer_new();
msgpack_packer *output_msg = msgpack_packer_new(buffer, msgpack_sbuffer_write);
msgpack_pack_map(output_msg, 5);
/* "event" => "data" */
msgpack_pack_string(output_msg, "event", -1);
msgpack_pack_string(output_msg, "data", -1);
msgpack_pack_string(output_msg, "program", -1);
msgpack_pack_string(output_msg, program->name, program->name_len);
msgpack_pack_string(output_msg, "instance", -1);
msgpack_pack_int(output_msg, process->instance);
msgpack_pack_string(output_msg, "source", -1);
msgpack_pack_string(output_msg, ioname, -1);
msgpack_pack_string(output_msg, "data", -1);
msgpack_pack_string(output_msg, data, length);
zmq_msg_init_data(&event, buffer->data, buffer->size, free_msgpack_buffer, buffer);
zmq_send(pn->eventsocket, &event, 0);
zmq_msg_close(&event);
msgpack_packer_free(output_msg);
} /* publish_output */
void report_signup(int err, struct list*elist, void *arg)
{
msgpack_packer *pk = arg;
if(err == 1) {
msgpack_pack_array(pk, 3);
} else {
msgpack_pack_array(pk, 2);
}
push_cstr("api.signup");
msgpack_pack_int(pk, err);
if(err==1) {
msgpack_pack_array(pk, list_count(elist));
list_apply(elist, true, write_field_err, arg);
}
}
static void pack_cpu_sample_event(rbkit_cpu_sample_event *event, msgpack_packer *packer) {
rbkit_cpu_sample *sample;
size_t count;
msgpack_pack_map(packer, 3);
sample = event->sample;
// Keys 1 & 2 - event type and timestamp
pack_event_header(packer, event->event_header.event_type);
// Key 3 : Payload
msgpack_pack_int(packer, rbkit_message_field_payload);
// Value 3: Array of samples
msgpack_pack_array(packer, sample->frame_count);
for(count = 0; count != sample->frame_count; count++){
msgpack_pack_map(packer, 6);
// method_name
msgpack_pack_int(packer, rbkit_message_field_method_name);
pack_string(packer, sample->frames[count].method_name);
// label
msgpack_pack_int(packer, rbkit_message_field_label);
pack_string(packer, sample->frames[count].label);
// file
msgpack_pack_int(packer, rbkit_message_field_file);
pack_string(packer, sample->frames[count].file);
// line
msgpack_pack_int(packer, rbkit_message_field_line);
msgpack_pack_unsigned_long(packer, sample->frames[count].line);
// singleton_method
msgpack_pack_int(packer, rbkit_message_field_singleton_method);
msgpack_pack_int(packer, sample->frames[count].is_singleton_method);
// thread_od
msgpack_pack_int(packer, rbkit_message_field_thread_id);
msgpack_pack_unsigned_long(packer, sample->frames[count].thread_id);
}
}
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);
}
static void pack_object_space_dump_event(rbkit_object_space_dump_event *event, msgpack_packer *packer) {
size_t objects_in_batch;
size_t objects_left;
size_t count = 0;
size_t i = 0;
rbkit_object_dump_page *prev;
rbkit_object_data *data;
rbkit_object_dump_page * page;
msgpack_pack_map(packer, 5);
pack_event_header(packer, event->event_header.event_type);
// Incrementing integer holding the correlation_id
// indicating the event which the message belongs to
msgpack_pack_int(packer, rbkit_message_field_correlation_id);
msgpack_pack_int(packer, event->correlation_id);
// dump total number of messages in batch
msgpack_pack_int(packer, rbkit_message_field_complete_message_count);
msgpack_pack_unsigned_long(packer, event->object_count);
msgpack_pack_int(packer, rbkit_message_field_payload);
// Find the batch size
objects_in_batch = MAX_OBJECT_DUMPS_IN_MESSAGE ;
objects_left = event->object_count - event->packed_objects;
if(objects_left < MAX_OBJECT_DUMPS_IN_MESSAGE)
objects_in_batch = objects_left;
// Set size of array to hold all objects
msgpack_pack_array(packer, objects_in_batch);
// Iterate through all object data
while(count < objects_in_batch) {
if(event->current_page_index == RBKIT_OBJECT_DUMP_PAGE_SIZE) {
event->current_page_index = 0;
prev = event->current_page;
event->current_page = event->current_page->next;
free(prev);
}
page = event->current_page;
i = event->current_page_index;
data = &(page->data[i]);
/* Object dump is a map that looks like this :
* {
* object_id: <OBJECT_ID_IN_HEX>,
* class: <CLASS_NAME>,
* references: [<OBJECT_ID_IN_HEX>, <OBJECT_ID_IN_HEX>, ...],
* file: <FILE_PATH>,
* line: <LINE_NO>,
* size: <SIZE>
* }
*/
msgpack_pack_map(packer, 6);
// Key1 : rbkit_message_field_object_id
msgpack_pack_int(packer, rbkit_message_field_object_id);
// Value1 : pointer address of object
msgpack_pack_unsigned_long_long(packer, data->object_id);
// Key2 : rbkit_message_field_class_name
msgpack_pack_int(packer, rbkit_message_field_class_name);
// Value2 : Class name of object
pack_string(packer, data->class_name);
// Key3 : rbkit_message_field_references
msgpack_pack_int(packer, rbkit_message_field_references);
// Value3 : References held by the object
msgpack_pack_array(packer, data->reference_count);
if(data->reference_count != 0) {
size_t count = 0;
for(; count < data->reference_count; count++ )
msgpack_pack_unsigned_long_long(packer, data->references[count]);
free(data->references);
}
// Key4 : rbkit_message_field_file
msgpack_pack_int(packer, rbkit_message_field_file);
// Value4 : File path where object is defined
pack_string(packer, data->file);
// Key5 : rbkit_message_field_line
msgpack_pack_int(packer, rbkit_message_field_line);
// Value5 : Line no where object is defined
if(data->line == 0)
msgpack_pack_nil(packer);
else
msgpack_pack_unsigned_long(packer, data->line);
// Key6 : rbkit_message_field_size
msgpack_pack_int(packer, rbkit_message_field_size);
// Value6 : Size of the object in memory
if(data->size == 0)
msgpack_pack_nil(packer);
else
msgpack_pack_unsigned_long(packer, data->size);
event->current_page_index++;
event->packed_objects++;
count++;
}
}
void publish_proc_event(process_t *process, const char *name) {
/* TODO(sissel): move this to a separate file for 'event' streaming */
zmq_msg_t event;
int rc;
size_t msgsize;
program_t *program = pn_proc_program(process);
procnanny_t *pn = program->data;
/* Fields:
* - program name
* - process instance
* - exit status
* - duration ?
*/
msgpack_sbuffer *buffer = msgpack_sbuffer_new();
msgpack_packer *output_msg = msgpack_packer_new(buffer, msgpack_sbuffer_write);
msgpack_pack_map(output_msg, 5);
msgpack_pack_string(output_msg, "event", -1);
msgpack_pack_string(output_msg, name, -1);
msgpack_pack_string(output_msg, "program", -1);
msgpack_pack_string(output_msg, program->name, program->name_len);
msgpack_pack_string(output_msg, "instance", -1);
msgpack_pack_int(output_msg, process->instance);
msgpack_pack_string(output_msg, "state", -1);
switch (process->state) {
case PROCESS_STATE_STARTING: msgpack_pack_string(output_msg, "starting", -1); break;
case PROCESS_STATE_RUNNING: msgpack_pack_string(output_msg, "running", -1); break;
case PROCESS_STATE_STOPPING: msgpack_pack_string(output_msg, "stopping", -1); break;
case PROCESS_STATE_EXITED: msgpack_pack_string(output_msg, "exited", -1); break;
case PROCESS_STATE_BACKOFF: msgpack_pack_string(output_msg, "backoff", -1); break;
case PROCESS_STATE_NEW: msgpack_pack_string(output_msg, "new", -1); break;
default: msgpack_pack_string(output_msg, "unknown", -1); break;
}
if (process->state == PROCESS_STATE_EXITED
|| process->state == PROCESS_STATE_BACKOFF) {
msgpack_pack_string(output_msg, "code", -1);
msgpack_pack_nil(output_msg);
} else if (process->exit_signal == 0) {
msgpack_pack_string(output_msg, "code", -1);
msgpack_pack_int(output_msg, process->exit_status);
} else {
msgpack_pack_string(output_msg, "signal", -1);
/* lol. */
switch (process->exit_signal) {
case SIGHUP: msgpack_pack_string(output_msg, "HUP", 3); break;
case SIGINT: msgpack_pack_string(output_msg, "INT", 3); break;
case SIGQUIT: msgpack_pack_string(output_msg, "QUIT", 4); break;
case SIGILL: msgpack_pack_string(output_msg, "ILL", 3); break;
case SIGTRAP: msgpack_pack_string(output_msg, "TRAP", 4); break;
case SIGABRT: msgpack_pack_string(output_msg, "ABRT", 4); break;
case SIGBUS: msgpack_pack_string(output_msg, "BUS", 3); break;
case SIGFPE: msgpack_pack_string(output_msg, "FPE", 3); break;
case SIGKILL: msgpack_pack_string(output_msg, "KILL", 4); break;
case SIGUSR1: msgpack_pack_string(output_msg, "USR1", 4); break;
case SIGSEGV: msgpack_pack_string(output_msg, "SEGV", 4); break;
case SIGUSR2: msgpack_pack_string(output_msg, "USR2", 4); break;
case SIGPIPE: msgpack_pack_string(output_msg, "PIPE", 4); break;
case SIGALRM: msgpack_pack_string(output_msg, "ALRM", 4); break;
case SIGTERM: msgpack_pack_string(output_msg, "TERM", 4); break;
case SIGSTKFLT: msgpack_pack_string(output_msg, "STKFLT", 6); break;
case SIGCHLD: msgpack_pack_string(output_msg, "CHLD", 4); break;
case SIGCONT: msgpack_pack_string(output_msg, "CONT", 4); break;
case SIGSTOP: msgpack_pack_string(output_msg, "STOP", 4); break;
case SIGTSTP: msgpack_pack_string(output_msg, "TSTP", 4); break;
case SIGTTIN: msgpack_pack_string(output_msg, "TTIN", 4); break;
case SIGTTOU: msgpack_pack_string(output_msg, "TTOU", 4); break;
case SIGURG: msgpack_pack_string(output_msg, "URG", 3); break;
case SIGXCPU: msgpack_pack_string(output_msg, "XCPU", 4); break;
case SIGXFSZ: msgpack_pack_string(output_msg, "XFSZ", 4); break;
case SIGVTALRM: msgpack_pack_string(output_msg, "VTALRM", 5); break;
case SIGPROF: msgpack_pack_string(output_msg, "PROF", 4); break;
case SIGWINCH: msgpack_pack_string(output_msg, "WINCH", 5); break;
case SIGPOLL: msgpack_pack_string(output_msg, "POLL", 4); break;
case SIGPWR: msgpack_pack_string(output_msg, "PWR", 3); break;
case SIGSYS: msgpack_pack_string(output_msg, "SYS", 3); break;
default: msgpack_pack_string(output_msg, "unknown", -1); break;
} /* switch process->exit_signal */
} /* if process was killed by a signal */
zmq_msg_init_data(&event, buffer->data, buffer->size, free_msgpack_buffer, buffer);
zmq_send(pn->eventsocket, &event, 0);
zmq_msg_close(&event);
msgpack_packer_free(output_msg);
} /* publish_output */
static char * packStructure(char *serviceName, char *dest, char *trans_id, char *payload, char *contentType, unsigned int payload_len)
{
msgpack_sbuffer sbuf;
msgpack_packer pk;
char* b64buffer = NULL;
size_t encodeSize = 0;
char source[MAX_PARAMETERNAME_LEN/2] = {'\0'};
int msg_type = 4;
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, LMLite %s ENTER\n", __FUNCTION__ ));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, deviceMAC *********:%s\n",deviceMAC));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, serviceName :%s\n",serviceName));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, dest :%s\n",dest));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, transaction_id :%s\n",trans_id));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, contentType :%s\n",contentType));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, payload_len :%d\n",payload_len));
snprintf(source, sizeof(source), "mac:%s/%s", deviceMAC, serviceName);
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Received DeviceMac from Atom side: %s\n",deviceMAC));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Source derived is %s\n", source));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, <======== Start of packStructure ======>\n"));
// Start of msgpack encoding
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, -----------Start of msgpack encoding------------\n"));
msgpack_sbuffer_init(&sbuf);
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_map(&pk, WEBPA_MAP_SIZE);
msgpack_pack_str(&pk, strlen(WEBPA_MSG_TYPE));
msgpack_pack_str_body(&pk, WEBPA_MSG_TYPE,strlen(WEBPA_MSG_TYPE));
msgpack_pack_int(&pk, msg_type);
msgpack_pack_str(&pk, strlen(WEBPA_SOURCE));
msgpack_pack_str_body(&pk, WEBPA_SOURCE,strlen(WEBPA_SOURCE));
msgpack_pack_str(&pk, strlen(source));
msgpack_pack_str_body(&pk, source,strlen(source));
msgpack_pack_str(&pk, strlen(WEBPA_DESTINATION));
msgpack_pack_str_body(&pk, WEBPA_DESTINATION,strlen(WEBPA_DESTINATION));
msgpack_pack_str(&pk, strlen(dest));
msgpack_pack_str_body(&pk, dest,strlen(dest));
msgpack_pack_str(&pk, strlen(WEBPA_TRANSACTION_ID));
msgpack_pack_str_body(&pk, WEBPA_TRANSACTION_ID,strlen(WEBPA_TRANSACTION_ID));
msgpack_pack_str(&pk, strlen(trans_id));
msgpack_pack_str_body(&pk, trans_id,strlen(trans_id));
msgpack_pack_str(&pk, strlen(WEBPA_PAYLOAD));
msgpack_pack_str_body(&pk, WEBPA_PAYLOAD,strlen(WEBPA_PAYLOAD));
if(strcmp(contentType,"avro/binary") == 0)
{
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, msg->payload binary\n"));
msgpack_pack_bin(&pk, payload_len);
msgpack_pack_bin_body(&pk, payload, payload_len);
}
else // string: "contentType :application/json"
{
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, msg->payload string\n"));
msgpack_pack_str(&pk, strlen(payload));
msgpack_pack_str_body(&pk, payload,strlen(payload));
}
msgpack_pack_str(&pk, strlen(CONTENT_TYPE));
msgpack_pack_str_body(&pk, CONTENT_TYPE,strlen(CONTENT_TYPE));
msgpack_pack_str(&pk, strlen(contentType));
msgpack_pack_str_body(&pk, contentType,strlen(contentType));
/*if(consoleDebugEnable)
fprintf(stderr, "RDK_LOG_DEBUG,msgpack encoded data contains %d bytes and data is : %s\n",(int)sbuf.size,sbuf.data);*/
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG,-----------End of msgpack encoding------------\n"));
// End of msgpack encoding
// Start of Base64 Encode
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG,-----------Start of Base64 Encode ------------\n"));
encodeSize = b64_get_encoded_buffer_size( sbuf.size );
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG,encodeSize is %d\n", (int)encodeSize));
b64buffer = malloc(encodeSize + 1); // one byte extra for terminating NULL byte
b64_encode((const uint8_t *)sbuf.data, sbuf.size, (uint8_t *)b64buffer);
b64buffer[encodeSize] = '\0' ;
/*if(consoleDebugEnable)
{
int i;
fprintf(stderr, "RDK_LOG_DEBUG,\n\n b64 encoded data is : ");
for(i = 0; i < encodeSize; i++)
fprintf(stderr,"%c", b64buffer[i]);
fprintf(stderr,"\n\n");
}*/
//CcspLMLiteTrace(("RDK_LOG_DEBUG,\nb64 encoded data length is %d\n",i));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG,---------- End of Base64 Encode -------------\n"));
// End of Base64 Encode
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG,Destroying sbuf.....\n"));
msgpack_sbuffer_destroy(&sbuf);
//CcspLMLiteTrace(("RDK_LOG_DEBUG,Final Encoded data: %s\n",b64buffer));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG,Final Encoded data length: %d\n",(int)strlen(b64buffer)));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG,<======== End of packStructure ======>\n"));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, LMLite %s EXIT\n", __FUNCTION__ ));
return b64buffer;
}
void report_reg(enum reg_state state, void*arg) {
msgpack_packer *pk = arg;
msgpack_pack_array(pk, 2);
push_cstr("sip.reg");
msgpack_pack_int(pk, state);
}
int filter_before_apply(FilterReplyResultBase * const rb,
const unsigned int nongeneric_items,
const char * const function,
const struct sockaddr_storage * const sa_local,
const socklen_t sa_local_len,
const struct sockaddr_storage * const sa_remote,
const socklen_t sa_remote_len)
{
Filter * const filter = filter_get();
const AppContext * const context = sixjack_get_context();
assert(filter->msgpack_packer != NULL);
msgpack_packer * const msgpack_packer = filter->msgpack_packer;
msgpack_packer_init(msgpack_packer, filter->msgpack_sbuffer,
msgpack_sbuffer_write);
unsigned int items_count = nongeneric_items + 5U;
if (rb->pre == false) {
items_count += 2U;
}
if (sa_local != NULL) {
items_count += 2U;
}
if (sa_remote != NULL) {
items_count += 2U;
}
msgpack_pack_map(msgpack_packer, items_count);
msgpack_pack_mstring(msgpack_packer, "version");
msgpack_pack_unsigned_short(msgpack_packer, VERSION_MAJOR);
msgpack_pack_mstring(msgpack_packer, "filter_type");
msgpack_pack_cstring(msgpack_packer, rb->pre ? "PRE" : "POST");
msgpack_pack_mstring(msgpack_packer, "pid");
msgpack_pack_unsigned_int(msgpack_packer, context->pid);
msgpack_pack_mstring(msgpack_packer, "function");
msgpack_pack_cstring(msgpack_packer, function);
msgpack_pack_mstring(msgpack_packer, "fd");
msgpack_pack_int(msgpack_packer, rb->fd);
if (rb->pre == false) {
msgpack_pack_mstring(msgpack_packer, "return_value");
msgpack_pack_int(msgpack_packer, *rb->ret);
msgpack_pack_mstring(msgpack_packer, "errno");
msgpack_pack_int(msgpack_packer, *rb->ret_errno);
}
char host[NI_MAXHOST];
in_port_t port;
if (sa_local != NULL) {
get_name_info(sa_local, sa_local_len, host, &port);
msgpack_pack_mstring(msgpack_packer, "local_host");
msgpack_pack_cstring_or_nil(msgpack_packer, host);
msgpack_pack_mstring(msgpack_packer, "local_port");
msgpack_pack_unsigned_short(msgpack_packer, (unsigned short) port);
}
if (sa_remote != NULL) {
get_name_info(sa_remote, sa_remote_len, host, &port);
msgpack_pack_mstring(msgpack_packer, "remote_host");
msgpack_pack_cstring_or_nil(msgpack_packer, host);
msgpack_pack_mstring(msgpack_packer, "remote_port");
msgpack_pack_unsigned_short(msgpack_packer, (unsigned short) port);
}
return 0;
}
void unit_message_deserialize_response(UNUSED(void **state))
{
struct api_error error = ERROR_INIT;
msgpack_sbuffer sbuf;
msgpack_packer pk;
msgpack_zone mempool;
msgpack_object deserialized;
struct message_response response;
msgpack_sbuffer_init(&sbuf);
msgpack_zone_init(&mempool, 2048);
/* positiv test */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_uint32(&pk, 1234);
msgpack_pack_nil(&pk);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
free_params(response.params);
/* wrong type type */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_nil(&pk);
msgpack_pack_uint32(&pk, 1234);
msgpack_pack_nil(&pk);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* wrong type */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 0);
msgpack_pack_uint32(&pk, 1234);
msgpack_pack_nil(&pk);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* wrong msgid */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_int(&pk, -1234);
msgpack_pack_nil(&pk);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* wrong msgid value*/
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_uint32(&pk, UINT32_MAX);
msgpack_pack_nil(&pk);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* wrong nil */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_uint32(&pk, 1234);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_array(&pk, 1);
msgpack_pack_uint8(&pk, 0);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* wrong params */
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_uint8(&pk, 1);
msgpack_pack_uint32(&pk, 1234);
msgpack_pack_nil(&pk);
msgpack_pack_nil(&pk);
msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
&error));
msgpack_sbuffer_clear(&sbuf);
/* null input params */
assert_int_not_equal(0, message_deserialize_response(&response, &deserialized,
NULL));
assert_int_not_equal(0, message_deserialize_response(&response, NULL,
&error));
assert_int_not_equal(0, message_deserialize_response(NULL, &deserialized,
&error));
msgpack_zone_destroy(&mempool);
msgpack_sbuffer_destroy(&sbuf);
}
static void
msgpack_wrap_redis_reply(const struct cmd *cmd, struct msg_out *out, const redisReply *r) {
unsigned int i;
msgpack_packer* pk = msgpack_packer_new(out, on_msgpack_write);
/* copy verb, as jansson only takes a char* but not its length. */
char *verb = "";
size_t verb_sz = 0;
if(cmd->count) {
verb_sz = cmd->argv_len[0];
verb = cmd->argv[0];
}
/* Create map object */
msgpack_pack_map(pk, 1);
/* The single element is the verb */
msgpack_pack_raw(pk, verb_sz);
msgpack_pack_raw_body(pk, verb, verb_sz);
switch(r->type) {
case REDIS_REPLY_STATUS:
case REDIS_REPLY_ERROR:
msgpack_pack_array(pk, 2);
/* first element: book */
if(r->type == REDIS_REPLY_ERROR)
msgpack_pack_false(pk);
else
msgpack_pack_true(pk);
/* second element: message */
msgpack_pack_raw(pk, r->len);
msgpack_pack_raw_body(pk, r->str, r->len);
break;
case REDIS_REPLY_STRING:
if(verb_sz ==4 && strncasecmp(verb, "INFO", 4) == 0) {
msg_info_reply(pk, r->str, r->len);
} else {
msgpack_pack_raw(pk, r->len);
msgpack_pack_raw_body(pk, r->str, r->len);
}
break;
case REDIS_REPLY_INTEGER:
msgpack_pack_int(pk, r->integer);
break;
case REDIS_REPLY_ARRAY:
if(verb_sz == 7 && strncasecmp(verb, "HGETALL", 7) == 0) {
msg_hgetall_reply(pk, r);
break;
}
msgpack_pack_array(pk, r->elements);
for(i = 0; i < r->elements; ++i) {
redisReply *e = r->element[i];
switch(e->type) {
case REDIS_REPLY_STRING:
msgpack_pack_raw(pk, e->len);
msgpack_pack_raw_body(pk, e->str, e->len);
break;
case REDIS_REPLY_INTEGER:
msgpack_pack_int(pk, e->integer);
break;
default:
msgpack_pack_nil(pk);
break;
}
}
break;
default:
msgpack_pack_nil(pk);
break;
}
msgpack_packer_free(pk);
}
static inline void
rbtrace__send_event(int nargs, const char *name, ...)
{
if (!rbtracer.attached_pid ||
!rbtracer.sbuf ||
!rbtracer.msgpacker ||
rbtracer.mqo_fd == -1)
return;
int n;
msgpack_sbuffer_clear(rbtracer.sbuf);
msgpack_packer *pk = rbtracer.msgpacker;
msgpack_pack_array(pk, nargs+1);
msgpack_pack_raw(pk, strlen(name));
msgpack_pack_raw_body(pk, name, strlen(name));
if (nargs > 0) {
int type;
int sint;
uint32_t uint;
uint64_t uint64;
unsigned long ulong;
char *str;
va_list ap;
va_start(ap, name);
for (n=0; n<nargs; n++) {
type = va_arg(ap, int);
switch (type) {
case 'b': // boolean
if (va_arg(ap, int))
msgpack_pack_true(pk);
else
msgpack_pack_false(pk);
break;
case 'd': // signed int
sint = va_arg(ap, int);
msgpack_pack_int(pk, sint);
break;
case 'u': // unsigned int
uint = va_arg(ap, uint32_t);
msgpack_pack_uint32(pk, uint);
break;
case 'l': // unsigned long (VALUE/ID)
ulong = va_arg(ap, unsigned long);
msgpack_pack_unsigned_long(pk, ulong);
break;
case 't': // uint64 (timestamps)
uint64 = va_arg(ap, uint64_t);
msgpack_pack_uint64(pk, uint64);
break;
case 'n': // current timestamp
msgpack_pack_uint64(pk, timeofday_usec());
break;
case 's': // string
str = va_arg(ap, char *);
if (!str)
str = (char *)"";
msgpack_pack_raw(pk, strlen(str));
msgpack_pack_raw_body(pk, str, strlen(str));
break;
default:
fprintf(stderr, "unknown type (%d) passed to rbtrace__send_event for %s\n", (int)type, name);
}
}
