/** * msgpack_conn_destroy - Free up a conn. */ void msgpack_conn_destroy(struct msgpack_conn *conn) { GIOStatus status; GError *error = NULL; if (conn == NULL) { return; } // Clean up the msgpack unpacker/read buffer. msgpack_unpacker_destroy(&conn->mc_unpacker); // Get rid of our event listeners. while (g_source_remove_by_user_data(conn)); // Flush and destroy the GIOChannel. status = g_io_channel_shutdown(conn->mc_channel, TRUE, &error); if (status != G_IO_STATUS_NORMAL) { g_warning("msgpack_conn_destroy: Trouble destroying conn."); } // Free the conn structure itself. g_free(conn); }
/** * paxos_peer_destroy - Free up a peer. */ void paxos_peer_destroy(struct paxos_peer *peer) { GIOStatus status; GError *error = NULL; if (peer == NULL) { return; } // Clean up the msgpack read buffer / unpacker. msgpack_unpacker_destroy(&peer->pp_unpacker); // Get rid of our event listeners. while (g_source_remove_by_user_data(peer)); // Flush and destroy the GIOChannel. status = g_io_channel_shutdown(peer->pp_channel, TRUE, &error); if (status != G_IO_STATUS_NORMAL) { g_warning("paxos_peer_destroy: Trouble destroying peer."); } // Free the peer structure itself. g_free(peer); }
msgpack_unpacked *filter_receive_message(Filter * const filter) { msgpack_unpacker * const msgpack_unpacker = &filter->msgpack_unpacker; msgpack_unpacker_destroy(msgpack_unpacker); msgpack_unpacker_init(msgpack_unpacker, FILTER_UNPACK_BUFFER_SIZE); msgpack_unpacker_reserve_buffer(msgpack_unpacker, FILTER_READ_BUFFER_SIZE); msgpack_unpacked * const message = &filter->message; ssize_t readnb; while (msgpack_unpacker_next(msgpack_unpacker, message) == false) { assert(msgpack_unpacker_buffer_capacity(msgpack_unpacker) > 0U); readnb = safe_read_partial (filter->upipe_stdout.fd_read, msgpack_unpacker_buffer(msgpack_unpacker), msgpack_unpacker_buffer_capacity(msgpack_unpacker)); if (readnb <= (ssize_t) 0) { assert(0); return NULL; } msgpack_unpacker_buffer_consumed(msgpack_unpacker, readnb); } assert(message->data.type == MSGPACK_OBJECT_MAP); return message; }
static void Unpacker_free(msgpack_unpacker_t* uk) { if(uk == NULL) { return; } msgpack_unpacker_destroy(uk); free(uk); }
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; }
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); }
void msgpack_unpacker_free(msgpack_unpacker* mpac) { msgpack_unpacker_destroy(mpac); free(mpac); }
MsgpackIODevice::~MsgpackIODevice() { //msgpack_packer_destroy(&m_pk); msgpack_unpacker_destroy(&m_uk); }
TEST(streaming, basic) { msgpack_sbuffer* buffer = msgpack_sbuffer_new(); msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write); // 1, 2, 3, "str", ["str_data"], "bin", ["bin_data"], {0.3: 0.4} EXPECT_EQ(0, msgpack_pack_int(pk, 1)); EXPECT_EQ(0, msgpack_pack_int(pk, 2)); EXPECT_EQ(0, msgpack_pack_int(pk, 3)); EXPECT_EQ(0, msgpack_pack_str(pk, 3)); EXPECT_EQ(0, msgpack_pack_str_body(pk, "str", 3)); EXPECT_EQ(0, msgpack_pack_array(pk, 1)); EXPECT_EQ(0, msgpack_pack_str(pk, 8)); EXPECT_EQ(0, msgpack_pack_str_body(pk, "str_data", 8)); EXPECT_EQ(0, msgpack_pack_bin(pk, 3)); EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin", 3)); EXPECT_EQ(0, msgpack_pack_array(pk, 1)); EXPECT_EQ(0, msgpack_pack_bin(pk, 8)); EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin_data", 8)); EXPECT_EQ(0, msgpack_pack_map(pk, 1)); EXPECT_EQ(0, msgpack_pack_float(pk, 0.4f)); EXPECT_EQ(0, msgpack_pack_double(pk, 0.8)); int max_count = 6; msgpack_packer_free(pk); const char* input = buffer->data; const char* const eof = input + buffer->size; msgpack_unpacker pac; msgpack_unpacker_init(&pac, MSGPACK_UNPACKER_INIT_BUFFER_SIZE); msgpack_unpacked result; msgpack_unpacked_init(&result); int count = 0; while(count < max_count) { bool unpacked = false; msgpack_unpacker_reserve_buffer(&pac, 32*1024); while(!unpacked) { /* read buffer into msgpack_unapcker_buffer(&pac) upto * msgpack_unpacker_buffer_capacity(&pac) bytes. */ memcpy(msgpack_unpacker_buffer(&pac), input, 1); input += 1; EXPECT_TRUE(input <= eof); msgpack_unpacker_buffer_consumed(&pac, 1); while(msgpack_unpacker_next(&pac, &result) == MSGPACK_UNPACK_SUCCESS) { unpacked = 1; msgpack_object obj = result.data; msgpack_object e; switch(count++) { case 0: EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); EXPECT_EQ(1, obj.via.u64); break; case 1: EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); EXPECT_EQ(2, obj.via.u64); break; case 2: EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); EXPECT_EQ(3, obj.via.u64); break; case 3: EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); EXPECT_EQ(std::string("str",3), std::string(obj.via.str.ptr, obj.via.str.size)); break; case 4: EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); EXPECT_EQ(1, obj.via.array.size); e = obj.via.array.ptr[0]; EXPECT_EQ(MSGPACK_OBJECT_STR, e.type); EXPECT_EQ(std::string("str_data",8), std::string(e.via.str.ptr, e.via.str.size)); break; case 5: EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); EXPECT_EQ(std::string("bin",3), std::string(obj.via.bin.ptr, obj.via.bin.size)); break; case 6: EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); EXPECT_EQ(1, obj.via.array.size); e = obj.via.array.ptr[0]; EXPECT_EQ(MSGPACK_OBJECT_BIN, e.type); EXPECT_EQ(std::string("bin_data",8), std::string(e.via.bin.ptr, e.via.bin.size)); break; case 7: EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type); EXPECT_EQ(1, obj.via.map.size); e = obj.via.map.ptr[0].key; EXPECT_EQ(MSGPACK_OBJECT_FLOAT, e.type); ASSERT_FLOAT_EQ(0.4f, static_cast<float>(e.via.f64)); #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type); ASSERT_FLOAT_EQ(0.4f, static_cast<float>(e.via.dec)); #endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT e = obj.via.map.ptr[0].val; EXPECT_EQ(MSGPACK_OBJECT_FLOAT, e.type); ASSERT_DOUBLE_EQ(0.8, e.via.f64); #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type); ASSERT_DOUBLE_EQ(0.8, e.via.dec); #endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT break; } } } } msgpack_unpacker_destroy(&pac); msgpack_unpacked_destroy(&result); msgpack_sbuffer_free(buffer); }
void tmate_decoder_destroy(struct tmate_decoder *decoder) { msgpack_unpacker_destroy(&decoder->unpacker); memset(decoder, 0, sizeof(*decoder)); }