lwtarantool 0.0.2

data/ext/lwtarantool/vendor/tarantool-c/tnt/tnt_assoc.h

@@ -0,0 +1,172 @@
+#if defined(__cplusplus)
+extern "C" {
+#endif /* defined(__cplusplus) */
+
+struct assoc_key {
+	const char *id;
+	uint32_t id_len;
+};
+
+struct assoc_val {
+	struct assoc_key key;
+	void *data;
+};
+
+static inline int
+mh_cmp_eq(
+		const struct assoc_val **lval,
+		const struct assoc_val **rval,
+		void *arg) {
+	(void )arg;
+	if ((*lval)->key.id_len != (*rval)->key.id_len) return 0;
+	return !memcmp((*lval)->key.id, (*rval)->key.id, (*rval)->key.id_len);
+}
+
+static inline int
+mh_cmp_key_eq(
+		const struct assoc_key *key,
+		const struct assoc_val **val,
+		void *arg) {
+	(void )arg;
+	if (key->id_len != (*val)->key.id_len) return 0;
+	return !memcmp(key->id, (*val)->key.id, key->id_len);
+}
+
+static inline void *
+tnt_mem_calloc(size_t count, size_t size) {
+	size_t sz = count * size;
+	void *alloc = tnt_mem_alloc(sz);
+	if (!alloc) return 0;
+	memset(alloc, 0, sz);
+	return alloc;
+
+}
+
+#define mh_arg_t void *
+
+#define mh_eq(a, b, arg)      mh_cmp_eq(a, b, arg)
+#define mh_eq_key(a, b, arg)  mh_cmp_key_eq(a, b, arg)
+#define mh_hash(x, arg)       PMurHash32(MUR_SEED, (*x)->key.id, (*x)->key.id_len)
+#define mh_hash_key(x, arg)   PMurHash32(MUR_SEED, (x)->id, (x)->id_len);
+
+/* type for hash value */
+#define mh_node_t struct assoc_val *
+/* type for hash key */
+#define mh_key_t  const struct assoc_key *
+
+#define MH_CALLOC(x, y) tnt_mem_calloc((x), (y))
+#define MH_FREE(x)      tnt_mem_free((x))
+
+#define mh_name               _assoc
+#define MUR_SEED 13
+#include		      <PMurHash.h>
+#include                      <mhash.h>
+
+/*!
+ * \file tnt_assoc.h
+ */
+
+/*! \struct mh_assoc_t */
+
+/*! \fn void mh_assoc_clear(struct mh_assoc_t *h)
+ * \brief Clear an associate array
+ * \param h associate array
+ */
+
+/*! \fn void mh_assoc_delete(struct mh_assoc_t *h)
+ * \brief Free an associate array
+ * \param h associate array
+ */
+
+/*! \fn void mh_assoc_reserve(struct mh_assoc_t *h, uint32_t size, void *arg)
+ * \brief Reserve place for elements
+ * \param h associate array
+ * \param size count of elements
+ * \param arg  context for (eq/hash functions) (must be NULL)
+ */
+
+/*! \fn mh_node_t *mh_assoc_node(struct mh_assoc_t *h, uint32_t x)
+ * \brief  Access value in specified slot
+ * \param  h associate array
+ * \param  x slot number
+ * \retval value in slot
+ */
+
+/*! \fn uint32_t mh_assoc_find(struct mh_assoc_t *h, mh_key_t key, void *arg)
+ * \brief  Search for element by key
+ * \param  h    associate array
+ * \param  key  key to search for
+ * \param  arg  context for (eq/hash functions) (must be NULL)
+ *
+ * \retval != mh_end()   slot number, where element is contained
+ * \retval    mh_end()   not found
+ *
+ * See also: \see mh_assoc_get or \see mh_assoc_find
+ */
+
+/*! \fn uint32_t mh_assoc_get(struct mh_assoc_t *h, mh_node_t *node, void *arg)
+ * \brief Search for element by value
+ * \param  h    associate array
+ * \param  node node to search for
+ * \param  arg  context for (eq/hash functions) (must be NULL)
+ *
+ * \retval != mh_end()   slot number, where element is contained
+ * \retval    mh_end()   not found
+ *
+ * See also: \see mh_assoc_get or \see mh_assoc_find
+ */
+
+/*! \fn uint32_t mh_assoc_random(struct mh_assoc_t *h, uint32_t rnd)
+ * \brief get random slot with existing element
+ * \param h   associate array
+ * \param rnd random number
+ *
+ * \retval != mh_end()   pos of the random node
+ * \retval    mh_end()   last one
+ */
+
+/*! \fn uint32_t mh_assoc_put(struct mh_assoc_t *h, const mh_node_t *node,
+ * 			      mh_node_t **ret, void *arg)
+ * \brief put element into hash
+ * \param h[in]    associate array
+ * \param node[in] node to insert
+ * \param ret[out] node, that's replaced
+ * \param arg[in]  context for (eq/hash functions) (must be NULL)
+ *
+ * Find a node in the hash and replace it with a new value.
+ * Save the old node in ret pointer, if it is provided.
+ * If the old node didn't exist, just insert the new node.
+ *
+ * \retval != mh_end()   pos of the new node, ret is either NULL
+ *                       or copy of the old node
+ * \retval    mh_end()   out of memory, ret is unchanged.
+ */
+
+/*! \fn void mh_assoc_del(struct mh_assoc_t *h, uint32_t x, void *arg)
+ * \brief delete element from specified slot
+ * \param  h    associate array
+ * \param  x    slot to delete element from
+ * \param  arg  context for (eq/hash functions) (must be NULL)
+ */
+
+/*! \fn void mh_assoc_remove(struct mh_assoc_t *h, mh_node_t node, void *arg)
+ * \brief delete specified element from assoc hash
+ * \param  h    associate array
+ * \param  node node to delete
+ * \param  arg  context for (eq/hash functions) (must be NULL)
+ */
+
+/*! \fn struct mh_assoc_t *mh_assoc_new()
+ * \brief allocate and initialize new associate array
+ * \retval !NULL new associate array
+ * \retval NULL  memory allocation error
+ */
+
+/*! \def mh_first(hash) */
+/*! \def mh_next(hash) */
+/*! \def mh_end(hash) */
+/*! \def mh_foreach(hash, iter) */
+
+#if defined(__cplusplus)
+}
+#endif /* defined(__cplusplus) */

data/ext/lwtarantool/vendor/tarantool-c/tnt/tnt_auth.c

@@ -0,0 +1,118 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <limits.h>
+#include <string.h>
+#include <stdbool.h>
+
+#include <sys/types.h>
+
+#include <tarantool/tnt_reply.h>
+#include <tarantool/tnt_stream.h>
+#include <tarantool/tnt_ping.h>
+
+#include <tarantool/tnt_net.h>
+
+#include <sha1.h>
+#include <base64.h>
+
+#include "tnt_proto_internal.h"
+
+static inline void
+tnt_xor(unsigned char *to, const unsigned char *left,
+	const unsigned char *right, uint32_t len)
+{
+	const uint8_t *end = to + len;
+	while (to < end)
+		*to++= *left++ ^ *right++;
+}
+static inline void
+tnt_scramble_prepare(void *out, const void *salt, const void *pass, int plen)
+{
+	unsigned char hash1[TNT_SCRAMBLE_SIZE];
+	unsigned char hash2[TNT_SCRAMBLE_SIZE];
+	SHA1_CTX ctx;
+
+	SHA1Init(&ctx);
+	SHA1Update(&ctx, (const unsigned char *) pass, plen);
+	SHA1Final(hash1, &ctx);
+
+	SHA1Init(&ctx);
+	SHA1Update(&ctx, hash1, TNT_SCRAMBLE_SIZE);
+	SHA1Final(hash2, &ctx);
+
+	SHA1Init(&ctx);
+	SHA1Update(&ctx, (const unsigned char *) salt, TNT_SCRAMBLE_SIZE);
+	SHA1Update(&ctx, hash2, TNT_SCRAMBLE_SIZE);
+	SHA1Final((unsigned char *) out, &ctx);
+
+	tnt_xor((unsigned char *) out, hash1, (const unsigned char *) out,
+	       TNT_SCRAMBLE_SIZE);
+}
+
+
+ssize_t
+tnt_auth_raw(struct tnt_stream *s, const char *user, int ulen,
+	     const char *pass, int plen, const char *base64_salt)
+{
+	struct tnt_iheader hdr;
+	struct iovec v[6]; int v_sz = 5;
+	char *data = NULL, *body_start = NULL;
+	int guest = !user || (ulen == 5 && !strncmp(user, "guest", 5));
+	if (guest) {
+		user = "guest";
+		ulen = 5;
+	}
+	encode_header(&hdr, TNT_OP_AUTH, s->reqid++);
+	v[1].iov_base = (void *)hdr.header;
+	v[1].iov_len  = hdr.end - hdr.header;
+	char body[64]; data = body; body_start = data;
+
+	data = mp_encode_map(data, 2);
+	data = mp_encode_uint(data, TNT_USERNAME);
+	data = mp_encode_strl(data, ulen);
+	v[2].iov_base = body_start;
+	v[2].iov_len  = data - body_start;
+	v[3].iov_base = (void *)user;
+	v[3].iov_len  = ulen;
+	body_start = data;
+	data = mp_encode_uint(data, TNT_TUPLE);
+	char salt[64], scramble[TNT_SCRAMBLE_SIZE];
+	if (!guest) {
+		data = mp_encode_array(data, 2);
+		data = mp_encode_str(data, "chap-sha1", strlen("chap-sha1"));
+		data = mp_encode_strl(data, TNT_SCRAMBLE_SIZE);
+		base64_decode(base64_salt, TNT_SALT_SIZE, salt, 64);
+		tnt_scramble_prepare(scramble, salt, pass, plen);
+		v[5].iov_base = scramble;
+		v[5].iov_len  = TNT_SCRAMBLE_SIZE;
+		v_sz++;
+	} else {
+		data = mp_encode_array(data, 0);
+	}
+	v[4].iov_base = body_start;
+	v[4].iov_len  = data - body_start;
+
+	size_t package_len = 0;
+	for (int i = 1; i < v_sz; ++i) {
+		package_len += v[i].iov_len;
+	}
+	char len_prefix[9];
+	char *len_end = mp_encode_luint32(len_prefix, package_len);
+	v[0].iov_base = len_prefix;
+	v[0].iov_len = len_end - len_prefix;
+	return s->writev(s, v, v_sz);
+}
+
+ssize_t
+tnt_auth(struct tnt_stream *s, const char *user, int ulen,
+	 const char *pass, int plen)
+{
+	return tnt_auth_raw(s, user, ulen, pass, plen,
+			    TNT_SNET_CAST(s)->greeting + TNT_VERSION_SIZE);
+}
+
+ssize_t
+tnt_deauth(struct tnt_stream *s)
+{
+	return tnt_auth(s, NULL, 0, NULL, 0);
+}

data/ext/lwtarantool/vendor/tarantool-c/tnt/tnt_buf.c

@@ -0,0 +1,171 @@
+
+/*
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above
+ *    copyright notice, this list of conditions and the
+ *    following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/types.h>
+#include <tarantool/tnt_mem.h>
+#include <tarantool/tnt_proto.h>
+#include <tarantool/tnt_reply.h>
+#include <tarantool/tnt_stream.h>
+#include <tarantool/tnt_buf.h>
+
+static void tnt_buf_free(struct tnt_stream *s) {
+	struct tnt_stream_buf *sb = TNT_SBUF_CAST(s);
+	if (!sb->as && sb->data)
+		tnt_mem_free(sb->data);
+	if (sb->free)
+		sb->free(s);
+	tnt_mem_free(s->data);
+	s->data = NULL;
+}
+
+static ssize_t
+tnt_buf_read(struct tnt_stream *s, char *buf, size_t size) {
+	struct tnt_stream_buf *sb = TNT_SBUF_CAST(s);
+	if (sb->data == NULL)
+		return 0;
+	if (sb->size == sb->rdoff)
+		return 0;
+	size_t avail = sb->size - sb->rdoff;
+	if (size > avail)
+		size = avail;
+	memcpy(sb->data + sb->rdoff, buf, size);
+	sb->rdoff += size;
+	return size;
+}
+
+static char* tnt_buf_resize(struct tnt_stream *s, size_t size) {
+	struct tnt_stream_buf *sb = TNT_SBUF_CAST(s);
+	size_t off = sb->size;
+	size_t nsize = off + size;
+	char *nd = tnt_mem_realloc(sb->data, nsize);
+	if (nd == NULL) {
+		tnt_mem_free(sb->data);
+		return NULL;
+	}
+	sb->data = nd;
+	sb->alloc = nsize;
+	return sb->data + off;
+}
+
+static ssize_t
+tnt_buf_write(struct tnt_stream *s, const char *buf, size_t size) {
+	if (TNT_SBUF_CAST(s)->as == 1) return -1;
+	char *p = TNT_SBUF_CAST(s)->resize(s, size);
+	if (p == NULL)
+		return -1;
+	memcpy(p, buf, size);
+	TNT_SBUF_CAST(s)->size += size;
+	s->wrcnt++;
+	return size;
+}
+
+static ssize_t
+tnt_buf_writev(struct tnt_stream *s, struct iovec *iov, int count) {
+	if (TNT_SBUF_CAST(s)->as == 1) return -1;
+	size_t size = 0;
+	int i;
+	for (i = 0 ; i < count ; i++)
+		size += iov[i].iov_len;
+	char *p = TNT_SBUF_CAST(s)->resize(s, size);
+	if (p == NULL)
+		return -1;
+	for (i = 0 ; i < count ; i++) {
+		memcpy(p, iov[i].iov_base, iov[i].iov_len);
+		p += iov[i].iov_len;
+	}
+	TNT_SBUF_CAST(s)->size += size;
+	s->wrcnt++;
+	return size;
+}
+
+static int
+tnt_buf_reply(struct tnt_stream *s, struct tnt_reply *r) {
+	struct tnt_stream_buf *sb = TNT_SBUF_CAST(s);
+	if (sb->data == NULL)
+		return -1;
+	if (sb->size == sb->rdoff)
+		return 1;
+	size_t off = 0;
+	int rc = tnt_reply(r, sb->data + sb->rdoff, sb->size - sb->rdoff, &off);
+	if (rc == 0)
+		sb->rdoff += off;
+	return rc;
+}
+
+struct tnt_stream *tnt_buf(struct tnt_stream *s) {
+	int allocated = s == NULL;
+	s = tnt_stream_init(s);
+	if (s == NULL)
+		return NULL;
+	/* allocating stream data */
+	s->data = tnt_mem_alloc(sizeof(struct tnt_stream_buf));
+	if (s->data == NULL) {
+		if (allocated)
+			tnt_stream_free(s);
+		return NULL;
+	}
+	/* initializing interfaces */
+	s->read       = tnt_buf_read;
+	s->read_reply = tnt_buf_reply;
+	s->write      = tnt_buf_write;
+	s->writev     = tnt_buf_writev;
+	s->free       = tnt_buf_free;
+	/* initializing internal data */
+	struct tnt_stream_buf *sb = TNT_SBUF_CAST(s);
+	sb->rdoff   = 0;
+	sb->size    = 0;
+	sb->alloc   = 0;
+	sb->data    = NULL;
+	sb->resize  = tnt_buf_resize;
+	sb->free    = NULL;
+	sb->subdata = NULL;
+	sb->as      = 0;
+	return s;
+}
+
+struct tnt_stream *tnt_buf_as(struct tnt_stream *s, char *buf, size_t buf_len)
+{
+	if (s == NULL) {
+		s = tnt_buf(s);
+		if (s == NULL)
+			return NULL;
+	}
+	struct tnt_stream_buf *sb = TNT_SBUF_CAST(s);
+
+	sb->data = buf;
+	sb->size = buf_len;
+	sb->alloc = buf_len;
+	sb->as = 1;
+
+	return s;
+}

data/ext/lwtarantool/vendor/tarantool-c/tnt/tnt_call.c

@@ -0,0 +1,79 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <limits.h>
+#include <string.h>
+#include <stdbool.h>
+#include <sys/types.h>
+
+#include <msgpuck.h>
+
+#include <tarantool/tnt_reply.h>
+#include <tarantool/tnt_stream.h>
+#include <tarantool/tnt_buf.h>
+#include <tarantool/tnt_object.h>
+#include <tarantool/tnt_call.h>
+
+#include "tnt_proto_internal.h"
+
+static ssize_t
+tnt_rpc_base(struct tnt_stream *s, const char *proc, size_t proc_len,
+	     struct tnt_stream *args, enum tnt_request_t op)
+{
+	if (!proc || proc_len == 0)
+		return -1;
+	if (tnt_object_verify(args, MP_ARRAY))
+		return -1;
+	uint32_t fld = (is_call(op) ? TNT_FUNCTION : TNT_EXPRESSION);
+	struct tnt_iheader hdr;
+	struct iovec v[6]; int v_sz = 6;
+	char *data = NULL, *body_start = NULL;
+	encode_header(&hdr, op, s->reqid++);
+	v[1].iov_base = (void *)hdr.header;
+	v[1].iov_len  = hdr.end - hdr.header;
+	char body[64]; body_start = body; data = body;
+
+	data = mp_encode_map(data, 2);
+	data = mp_encode_uint(data, fld);
+	data = mp_encode_strl(data, proc_len);
+	v[2].iov_base = body_start;
+	v[2].iov_len  = data - body_start;
+	v[3].iov_base = (void *)proc;
+	v[3].iov_len  = proc_len;
+	body_start = data;
+	data = mp_encode_uint(data, TNT_TUPLE);
+	v[4].iov_base = body_start;
+	v[4].iov_len  = data - body_start;
+	v[5].iov_base = TNT_SBUF_DATA(args);
+	v[5].iov_len  = TNT_SBUF_SIZE(args);
+
+	size_t package_len = 0;
+	for (int i = 1; i < v_sz; ++i)
+		package_len += v[i].iov_len;
+	char len_prefix[9];
+	char *len_end = mp_encode_luint32(len_prefix, package_len);
+	v[0].iov_base = len_prefix;
+	v[0].iov_len = len_end - len_prefix;
+	return s->writev(s, v, v_sz);
+}
+
+ssize_t
+tnt_call(struct tnt_stream *s, const char *proc, size_t proc_len,
+	 struct tnt_stream *args)
+{
+	return tnt_rpc_base(s, proc, proc_len, args, TNT_OP_CALL);
+}
+
+ssize_t
+tnt_call_16(struct tnt_stream *s, const char *proc, size_t proc_len,
+	    struct tnt_stream *args)
+{
+	return tnt_rpc_base(s, proc, proc_len, args, TNT_OP_CALL_16);
+}
+
+ssize_t
+tnt_eval(struct tnt_stream *s, const char *proc, size_t proc_len,
+	 struct tnt_stream *args)
+{
+	return tnt_rpc_base(s, proc, proc_len, args, TNT_OP_EVAL);
+}

data/ext/lwtarantool/vendor/tarantool-c/tnt/tnt_delete.c

@@ -0,0 +1,52 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <limits.h>
+#include <string.h>
+#include <stdbool.h>
+
+#include <msgpuck.h>
+#include <sys/types.h>
+
+#include <tarantool/tnt_reply.h>
+#include <tarantool/tnt_stream.h>
+#include <tarantool/tnt_buf.h>
+#include <tarantool/tnt_object.h>
+#include <tarantool/tnt_delete.h>
+
+#include "tnt_proto_internal.h"
+
+ssize_t
+tnt_delete(struct tnt_stream *s, uint32_t space, uint32_t index,
+	   struct tnt_stream *key)
+{
+	if (tnt_object_verify(key, MP_ARRAY))
+		return -1;
+	struct tnt_iheader hdr;
+	struct iovec v[4]; int v_sz = 4;
+	char *data = NULL;
+	encode_header(&hdr, TNT_OP_DELETE, s->reqid++);
+	v[1].iov_base = (void *)hdr.header;
+	v[1].iov_len  = hdr.end - hdr.header;
+	char body[64]; data = body;
+
+	data = mp_encode_map(data, 3);
+	data = mp_encode_uint(data, TNT_SPACE);
+	data = mp_encode_uint(data, space);
+	data = mp_encode_uint(data, TNT_INDEX);
+	data = mp_encode_uint(data, index);
+	data = mp_encode_uint(data, TNT_KEY);
+	v[2].iov_base = body;
+	v[2].iov_len  = data - body;
+	v[3].iov_base = TNT_SBUF_DATA(key);
+	v[3].iov_len  = TNT_SBUF_SIZE(key);
+
+	size_t package_len = 0;
+	for (int i = 1; i < v_sz; ++i)
+		package_len += v[i].iov_len;
+	char len_prefix[9];
+	char *len_end = mp_encode_luint32(len_prefix, package_len);
+	v[0].iov_base = len_prefix;
+	v[0].iov_len = len_end - len_prefix;
+	return s->writev(s, v, v_sz);
+}

data/ext/lwtarantool/vendor/tarantool-c/tnt/tnt_execute.c

@@ -0,0 +1,60 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <limits.h>
+#include <string.h>
+#include <stdbool.h>
+#include <sys/types.h>
+
+#include <msgpuck.h>
+
+#include <tarantool/tnt_reply.h>
+#include <tarantool/tnt_stream.h>
+#include <tarantool/tnt_buf.h>
+#include <tarantool/tnt_object.h>
+#include <tarantool/tnt_execute.h>
+
+#include "tnt_proto_internal.h"
+
+ssize_t
+tnt_execute(struct tnt_stream *s, const char *expr, size_t elen,
+	    struct tnt_stream *params)
+{
+	if (!expr || elen == 0)
+		return -1;
+	if (tnt_object_verify(params, MP_ARRAY))
+		return -1;
+	struct tnt_iheader hdr;
+	struct iovec v[6];
+	int v_sz = 6;
+	char *data = NULL, *body_start = NULL;
+	encode_header(&hdr, TNT_OP_EXECUTE, s->reqid++);
+	v[1].iov_base = (void *) hdr.header;
+	v[1].iov_len = hdr.end - hdr.header;
+	char body[64];
+	body_start = body;
+	data = body;
+
+	data = mp_encode_map(data, 2);
+	data = mp_encode_uint(data, TNT_SQL_TEXT);
+	data = mp_encode_strl(data, elen);
+	v[2].iov_base = body_start;
+	v[2].iov_len = data - body_start;
+	v[3].iov_base = (void *) expr;
+	v[3].iov_len = elen;
+	body_start = data;
+	data = mp_encode_uint(data, TNT_SQL_BIND);
+	v[4].iov_base = body_start;
+	v[4].iov_len = data - body_start;
+	v[5].iov_base = TNT_SBUF_DATA(params);
+	v[5].iov_len = TNT_SBUF_SIZE(params);
+
+	size_t package_len = 0;
+	for (int i = 1; i < v_sz; ++i)
+		package_len += v[i].iov_len;
+	char len_prefix[9];
+	char *len_end = mp_encode_luint32(len_prefix, package_len);
+	v[0].iov_base = len_prefix;
+	v[0].iov_len = len_end - len_prefix;
+	return s->writev(s, v, v_sz);
+}

data/ext/lwtarantool/vendor/tarantool-c/tnt/tnt_insert.c

@@ -0,0 +1,60 @@
+#include <stddef.h>
+#include <stdint.h>
+#include <limits.h>
+#include <string.h>
+#include <stdbool.h>
+
+#include <msgpuck.h>
+
+#include <tarantool/tnt_reply.h>
+#include <tarantool/tnt_stream.h>
+#include <tarantool/tnt_buf.h>
+#include <tarantool/tnt_object.h>
+#include <tarantool/tnt_insert.h>
+
+#include "tnt_proto_internal.h"
+
+static ssize_t
+tnt_store_base(struct tnt_stream *s, uint32_t space, struct tnt_stream *tuple,
+	       enum tnt_request_t op)
+{
+	if (tnt_object_verify(tuple, MP_ARRAY))
+		return -1;
+	struct tnt_iheader hdr;
+	struct iovec v[4]; int v_sz = 4;
+	char *data = NULL;
+	encode_header(&hdr, op, s->reqid++);
+	v[1].iov_base = (void *)hdr.header;
+	v[1].iov_len  = hdr.end - hdr.header;
+	char body[64]; data = body;
+
+	data = mp_encode_map(data, 2);
+	data = mp_encode_uint(data, TNT_SPACE);
+	data = mp_encode_uint(data, space);
+	data = mp_encode_uint(data, TNT_TUPLE);
+	v[2].iov_base = body;
+	v[2].iov_len  = data - body;
+	v[3].iov_base = TNT_SBUF_DATA(tuple);
+	v[3].iov_len  = TNT_SBUF_SIZE(tuple);
+
+	size_t package_len = 0;
+	for (int i = 1; i < v_sz; ++i)
+		package_len += v[i].iov_len;
+	char len_prefix[9];
+	char *len_end = mp_encode_luint32(len_prefix, package_len);
+	v[0].iov_base = len_prefix;
+	v[0].iov_len = len_end - len_prefix;
+	return s->writev(s, v, v_sz);
+}
+
+ssize_t
+tnt_insert(struct tnt_stream *s, uint32_t space, struct tnt_stream *tuple)
+{
+	return tnt_store_base(s, space, tuple, TNT_OP_INSERT);
+}
+
+ssize_t
+tnt_replace(struct tnt_stream *s, uint32_t space, struct tnt_stream *tuple)
+{
+	return tnt_store_base(s, space, tuple, TNT_OP_REPLACE);
+}