static void recv_handler(grn_ctx *ctx, void *zmq_recv_sock, msgpack_zone *mempool, grn_obj *cmd_buf) { zmq_msg_t msg; if (zmq_msg_init(&msg)) { print_error("cannot init zmq message."); } else { if (zmq_recv(zmq_recv_sock, &msg, 0)) { print_error("cannot recv zmq message."); } else { msgpack_object obj; msgpack_unpack_return ret; ret = msgpack_unpack(zmq_msg_data(&msg), zmq_msg_size(&msg), NULL, mempool, &obj); if (MSGPACK_UNPACK_SUCCESS == ret) { load_from_learner(&obj, ctx, cmd_buf); } else { print_error("invalid recv data."); } msgpack_zone_clear(mempool); } zmq_msg_close(&msg); } }
int main(void) { msgpack_sbuffer sbuf; msgpack_packer pk; msgpack_zone mempool; msgpack_object deserialized; /* msgpack::sbuffer is a simple buffer implementation. */ msgpack_sbuffer_init(&sbuf); /* serialize values into the buffer using msgpack_sbuffer_write callback function. */ msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); 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); /* deserialize the buffer into msgpack_object instance. */ /* deserialized object is valid during the msgpack_zone instance alive. */ msgpack_zone_init(&mempool, 2048); msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized); /* print the deserialized object. */ msgpack_object_print(stdout, deserialized); puts(""); msgpack_zone_destroy(&mempool); msgpack_sbuffer_destroy(&sbuf); return 0; }
msgpack_object* AReplayPlayer::PacketAtOffset(size_t TmpOffset) { msgpack_unpack_return ret = msgpack_unpack(data, size, &offset, &mempool, &tmp_object); if (ret <= 0) { return NULL; } return &tmp_object; }
msgpack_object* AReplayPlayer::PeekNextPacket() { size_t offset_copy = offset; msgpack_zone_clear(&mempool); msgpack_unpack_return ret = msgpack_unpack(data, size, &offset_copy, &mempool, &tmp_object); if (ret <= 0) { return NULL; } return &tmp_object; }
void load_data(char *filename, load_data_function unpack_function) { char *save_file_name; char *save_data; FILE *save_file; int len; struct stat file_stat; msgpack_zone *mempool; msgpack_object deserialized; if ((save_file_name = get_save_file_path(filename)) == NULL) { red_log(REDD_WARNING, "get_save_file_path returned NULL"); return; } if (stat(save_file_name, &file_stat) != 0) { free(save_file_name); return; } if (!S_ISREG(file_stat.st_mode)) { free(save_file_name); return; } len = file_stat.st_size; if ((save_file = fopen(save_file_name, "r")) != NULL) { size_t bytes_read; save_data = (char *)malloc(len); bytes_read = fread((void *)save_data, 1, len, save_file); fclose(save_file); if (bytes_read != len) { red_log(REDD_WARNING, "Failed to read data from %s", save_file_name); free(save_file_name); free(save_data); return; } } else { red_log(REDD_WARNING, "Failed to open %s", save_file_name); free(save_file_name); return; } mempool = (msgpack_zone *)malloc(sizeof(msgpack_zone)); msgpack_zone_init(mempool, 4096); msgpack_unpack(save_data, len, NULL, mempool, &deserialized); unpack_function(deserialized); free(save_file_name); save_file_name = NULL; free(save_data); save_data = NULL; msgpack_zone_destroy(mempool); free(mempool); mempool = NULL; }
/// output MessagePack sbuffer to stream in text format static void log_text_sbuffer(FILE *stream, msgpack_sbuffer *msg) { // deserialize sbuffer to object msgpack_zone mempool; msgpack_zone_init(&mempool, 1024); msgpack_object deserialized; msgpack_unpack(msg->data, msg->size, NULL, &mempool, &deserialized); // now output the message object log_text(stream, &deserialized); // and free up memory msgpack_zone_destroy(&mempool); }
msgpack_object* AReplayPlayer::NextPacket() { EOffsetHistory* CurrentOffset = (EOffsetHistory*) malloc(sizeof(EOffsetHistory)); CurrentOffset->Offset = offset; CurrentOffset->Previous = OffsetHistory; OffsetHistory = CurrentOffset; msgpack_zone_clear(&mempool); msgpack_unpack_return ret = msgpack_unpack(data, size, &offset, &mempool, &tmp_object); if (ret <= 0) { return NULL; } return &tmp_object; }
value_t unserialize(const zookeeper::value_t& val) { msgpack::object obj; std::unique_ptr<msgpack::zone> z(new msgpack::zone()); msgpack_unpack_return ret = msgpack_unpack( val.c_str(), val.size(), nullptr, z.get(), reinterpret_cast<msgpack_object*>(&obj) ); //Only strict unparse. if(static_cast<msgpack::unpack_return>(ret) != msgpack::UNPACK_SUCCESS) { throw std::system_error(cocaine::error::unicorn_errors::invalid_value); } value_t target; cocaine::io::type_traits<cocaine::dynamic_t>::unpack(obj, target); return target; }
static void on_response(msgxchng_response_t *res, int status) { if (status == RED_ERR) exit(1); msgpack_zone mempool; msgpack_zone_init(&mempool, 4096); msgpack_object deserialized; msgpack_unpack(res->data, res->data_len, NULL, &mempool, &deserialized); int success = 0; if (deserialized.type == MSGPACK_OBJECT_MAP) { msgpack_object_kv* p = deserialized.via.map.ptr; msgpack_object_kv* const pend = deserialized.via.map.ptr + deserialized.via.map.size; for (; p < pend; ++p) { if (p->key.type == MSGPACK_OBJECT_RAW && p->val.type == MSGPACK_OBJECT_RAW) { if (!strncmp(p->key.via.raw.ptr, "return", p->key.via.raw.size)) { if (!strncmp(p->val.via.raw.ptr, "success", p->val.via.raw.size)) success = 1; else success = 0; } else if (!strncmp(p->key.via.raw.ptr, "error", p->key.via.raw.size)) { if (!config.no_output) fprintf(stderr, "red: %s\n", p->val.via.raw.ptr); } } } } clean_msgxchng_response(res); free(res); if (!success) exit(1); }
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); }