diff --git a/CMakeLists.txt b/CMakeLists.txt index 84c401eb0c..c3755dcce0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1030,6 +1030,8 @@ set(NETDISSECT_SOURCE_LIST_C ipproto.c l2vpn.c machdep.c + msgpuck.c + msgpuck_hints.c netdissect.c netdissect-alloc.c nlpid.c @@ -1174,6 +1176,7 @@ set(NETDISSECT_SOURCE_LIST_C print-sunrpc.c print-symantec.c print-syslog.c + print-tarantool.c print-tcp.c print-telnet.c print-tftp.c diff --git a/Makefile.in b/Makefile.in index 0054f05ff3..e349ae8b36 100644 --- a/Makefile.in +++ b/Makefile.in @@ -85,6 +85,8 @@ LIBNETDISSECT_SRC=\ ipproto.c \ l2vpn.c \ machdep.c \ + msgpuck.c \ + msgpuck_hints.c \ netdissect.c \ netdissect-alloc.c \ nlpid.c \ @@ -229,6 +231,7 @@ LIBNETDISSECT_SRC=\ print-sunrpc.c \ print-symantec.c \ print-syslog.c \ + print-tarantool.c \ print-tcp.c \ print-telnet.c \ print-tftp.c \ diff --git a/msgpuck.c b/msgpuck.c new file mode 100644 index 0000000000..79ad8d6adf --- /dev/null +++ b/msgpuck.c @@ -0,0 +1,457 @@ +/* + * Copyright (c) 2021 The TCPDUMP project + * All rights reserved. + * + * 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 THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 THE + * 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. + * + * Initial contribution by Pavel Balaev (balaev@tarantool.org). + */ + +/* + * Copyright (c) 2013-2017 MsgPuck Authors + * All rights reserved. + * + * 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 ``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 + * 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. + */ + +#define MP_LIBRARY 1 +#include "msgpuck.h" + +int +mp_fprint_ext_default(FILE *file, const char **data, int depth) +{ + (void) depth; + int8_t type; + uint32_t len; + mp_decode_ext(data, &type, &len); + return fprintf(file, "(extension: type %d, len %u)", (int)type, + (unsigned)len); +} + +int +mp_snprint_ext_default(char *buf, int size, const char **data, int depth) +{ + (void) depth; + int8_t type; + uint32_t len; + mp_decode_ext(data, &type, &len); + return snprintf(buf, size, "(extension: type %d, len %u)", (int)type, + (unsigned)len); +} + +mp_fprint_ext_f mp_fprint_ext = mp_fprint_ext_default; + +mp_snprint_ext_f mp_snprint_ext = mp_snprint_ext_default; + +int +mp_check_ext_data_default(int8_t type, const char *data, uint32_t len) +{ + (void)data; + (void)type; + (void)len; + return 0; +} + +mp_check_ext_data_f mp_check_ext_data = mp_check_ext_data_default; + +size_t +mp_vformat(char *data, size_t data_size, const char *format, va_list vl) +{ + size_t result = 0; + const char *f = NULL; + + for (f = format; *f; f++) { + if (f[0] == '[') { + uint32_t size = 0; + int level = 1; + const char *e = NULL; + + for (e = f + 1; level && *e; e++) { + if (*e == '[' || *e == '{') { + if (level == 1) + size++; + level++; + } else if (*e == ']' || *e == '}') { + level--; + /* opened '[' must be closed by ']' */ + assert(level || *e == ']'); + } else if (*e == '%') { + if (e[1] == '%') + e++; + else if (level == 1) + size++; + } else if (*e == 'N' && e[1] == 'I' + && e[2] == 'L' && level == 1) { + size++; + } + } + /* opened '[' must be closed */ + assert(level == 0); + result += mp_sizeof_array(size); + if (result <= data_size) + data = mp_encode_array(data, size); + } else if (f[0] == '{') { + uint32_t count = 0; + int level = 1; + const char *e = NULL; + + for (e = f + 1; level && *e; e++) { + if (*e == '[' || *e == '{') { + if (level == 1) + count++; + level++; + } else if (*e == ']' || *e == '}') { + level--; + /* opened '{' must be closed by '}' */ + assert(level || *e == '}'); + } else if (*e == '%') { + if (e[1] == '%') + e++; + else if (level == 1) + count++; + } else if (*e == 'N' && e[1] == 'I' + && e[2] == 'L' && level == 1) { + count++; + } + } + /* opened '{' must be closed */ + assert(level == 0); + /* since map is a pair list, count must be even */ + assert(count % 2 == 0); + uint32_t size = count / 2; + result += mp_sizeof_map(size); + if (result <= data_size) + data = mp_encode_map(data, size); + } else if (f[0] == '%') { + f++; + assert(f[0]); + int64_t int_value = 0; + int int_status = 0; /* 1 - signed, 2 - unsigned */ + + if (f[0] == 'd' || f[0] == 'i') { + int_value = va_arg(vl, int); + int_status = 1; + } else if (f[0] == 'u') { + int_value = va_arg(vl, unsigned int); + int_status = 2; + } else if (f[0] == 's') { + const char *str = va_arg(vl, const char *); + uint32_t len = (uint32_t)strlen(str); + result += mp_sizeof_str(len); + if (result <= data_size) + data = mp_encode_str(data, str, len); + } else if (f[0] == '.' && f[1] == '*' && f[2] == 's') { + uint32_t len = va_arg(vl, uint32_t); + const char *str = va_arg(vl, const char *); + result += mp_sizeof_str(len); + if (result <= data_size) + data = mp_encode_str(data, str, len); + f += 2; + } else if (f[0] == 'p') { + const char *p = va_arg(vl, const char *); + const char *end = p; + mp_next(&end); + uint32_t len = (uint32_t)(end - p); + result += len; + if (result <= data_size) { + memcpy(data, p, len); + data += len; + } + } else if (f[0] == '.' && f[1] == '*' && f[2] == 'p') { + uint32_t len = va_arg(vl, uint32_t); + const char *p = va_arg(vl, const char *); + assert(len > 0); + result += len; + if (result <= data_size) { + memcpy(data, p, len); + data += len; + } + f += 2; + } else if(f[0] == 'f') { + float v = (float)va_arg(vl, double); + result += mp_sizeof_float(v); + if (result <= data_size) + data = mp_encode_float(data, v); + } else if(f[0] == 'l' && f[1] == 'f') { + double v = va_arg(vl, double); + result += mp_sizeof_double(v); + if (result <= data_size) + data = mp_encode_double(data, v); + f++; + } else if(f[0] == 'b') { + bool v = (bool)va_arg(vl, int); + result += mp_sizeof_bool(v); + if (result <= data_size) + data = mp_encode_bool(data, v); + } else if (f[0] == 'l' + && (f[1] == 'd' || f[1] == 'i')) { + int_value = va_arg(vl, long); + int_status = 1; + f++; + } else if (f[0] == 'l' && f[1] == 'u') { + int_value = va_arg(vl, unsigned long); + int_status = 2; + f++; + } else if (f[0] == 'l' && f[1] == 'l' + && (f[2] == 'd' || f[2] == 'i')) { + int_value = va_arg(vl, long long); + int_status = 1; + f += 2; + } else if (f[0] == 'l' && f[1] == 'l' && f[2] == 'u') { + int_value = va_arg(vl, unsigned long long); + int_status = 2; + f += 2; + } else if (f[0] == 'h' + && (f[1] == 'd' || f[1] == 'i')) { + int_value = va_arg(vl, int); + int_status = 1; + f++; + } else if (f[0] == 'h' && f[1] == 'u') { + int_value = va_arg(vl, unsigned int); + int_status = 2; + f++; + } else if (f[0] == 'h' && f[1] == 'h' + && (f[2] == 'd' || f[2] == 'i')) { + int_value = va_arg(vl, int); + int_status = 1; + f += 2; + } else if (f[0] == 'h' && f[1] == 'h' && f[2] == 'u') { + int_value = va_arg(vl, unsigned int); + int_status = 2; + f += 2; + } else if (f[0] != '%') { + /* unexpected format specifier */ + assert(false); + } + + if (int_status == 1 && int_value < 0) { + result += mp_sizeof_int(int_value); + if (result <= data_size) + data = mp_encode_int(data, int_value); + } else if(int_status) { + result += mp_sizeof_uint(int_value); + if (result <= data_size) + data = mp_encode_uint(data, int_value); + } + } else if (f[0] == 'N' && f[1] == 'I' && f[2] == 'L') { + result += mp_sizeof_nil(); + if (result <= data_size) + data = mp_encode_nil(data); + f += 2; + } + } + return result; +} + +size_t +mp_format(char *data, size_t data_size, const char *format, ...) +{ + va_list args; + va_start(args, format); + size_t res = mp_vformat(data, data_size, format, args); + va_end(args); + return res; +} + +#define MP_PRINT(SELF, PRINTF) \ +{ \ + switch (mp_typeof(**data)) { \ + case MP_NIL: \ + mp_decode_nil(data); \ + PRINTF("null"); \ + break; \ + case MP_UINT: \ + PRINTF("%llu", (unsigned long long) mp_decode_uint(data)); \ + break; \ + case MP_INT: \ + PRINTF("%lld", (long long) mp_decode_int(data)); \ + break; \ + case MP_STR: \ + case MP_BIN: \ + { \ + uint32_t len = mp_typeof(**data) == MP_STR ? \ + mp_decode_strl(data) : mp_decode_binl(data); \ + PRINTF("\""); \ + const char *s; \ + const char *end = *data + len; \ + for (s = *data; s < end; s++) { \ + unsigned char c = (unsigned char ) *s; \ + if (c < 128 && mp_char2escape[c] != NULL) { \ + /* Escape character */ \ + PRINTF("%s", mp_char2escape[c]); \ + } else { \ + PRINTF("%c", c); \ + } \ + } \ + PRINTF("\""); \ + *data = end; \ + break; \ + } \ + case MP_ARRAY: \ + { \ + PRINTF("["); \ + if (depth <= 0) { \ + PRINTF("..."); \ + mp_next(data); \ + } else { \ + --depth; \ + uint32_t count = mp_decode_array(data); \ + for (uint32_t i = 0; i < count; i++) { \ + if (i) \ + PRINTF(", "); \ + SELF(data); \ + } \ + ++depth; \ + } \ + PRINTF("]"); \ + break; \ + } \ + case MP_MAP: \ + { \ + PRINTF("{"); \ + if (depth <= 0) { \ + PRINTF("..."); \ + mp_next(data); \ + } else { \ + --depth; \ + uint32_t count = mp_decode_map(data); \ + for (uint32_t i = 0; i < count; i++) { \ + if (i) \ + PRINTF(", "); \ + SELF(data); \ + PRINTF(": "); \ + SELF(data); \ + } \ + ++depth; \ + } \ + PRINTF("}"); \ + break; \ + } \ + case MP_BOOL: \ + PRINTF(mp_decode_bool(data) ? "true" : "false"); \ + break; \ + case MP_FLOAT: \ + PRINTF("%g", mp_decode_float(data)); \ + break; \ + case MP_DOUBLE: \ + PRINTF("%lg", mp_decode_double(data)); \ + break; \ + case MP_EXT: \ + PRINT_EXT(data); \ + break; \ + default: \ + mp_unreachable(); \ + return -1; \ + } \ +} + +int +mp_fprint_recursion(FILE *file, const char **data, int depth) +{ + int total_bytes = 0; +#define HANDLE(FUN, ...) do { \ + int bytes = FUN(file, __VA_ARGS__); \ + if (mp_unlikely(bytes < 0)) \ + return -1; \ + total_bytes += bytes; \ +} while (0) +#define PRINT_EXT(...) HANDLE(mp_fprint_ext, __VA_ARGS__, depth) +#define PRINT(...) HANDLE(fprintf, __VA_ARGS__) +#define SELF(...) HANDLE(mp_fprint_recursion, __VA_ARGS__, depth) +MP_PRINT(SELF, PRINT) +#undef HANDLE +#undef SELF +#undef PRINT +#undef PRINT_EXT + return total_bytes; +} + +int +mp_fprint(FILE *file, const char *data) +{ + if (!file) + file = stdout; + int res = mp_fprint_recursion(file, &data, MP_PRINT_MAX_DEPTH); + return res; +} + +int +mp_snprint_recursion(char *buf, int size, const char **data, int depth) +{ + int total_bytes = 0; +#define HANDLE(FUN, ...) do { \ + int bytes = FUN(buf, size, __VA_ARGS__); \ + if (mp_unlikely(bytes < 0)) \ + return -1; \ + total_bytes += bytes; \ + if (bytes < size) { \ + buf += bytes; \ + size -= bytes; \ + } else { \ + /* Calculate the number of bytes needed */ \ + buf = NULL; \ + size = 0; \ + } \ +} while (0) +#define PRINT_EXT(...) HANDLE(mp_snprint_ext, __VA_ARGS__, depth) +#define PRINT(...) HANDLE(snprintf, __VA_ARGS__) +#define SELF(...) HANDLE(mp_snprint_recursion, __VA_ARGS__, depth) +MP_PRINT(SELF, PRINT) +#undef HANDLE +#undef SELF +#undef PRINT +#undef PRINT_EXT + return total_bytes; +} +#undef MP_PRINT + +int +mp_snprint(char *buf, int size, const char *data) +{ + return mp_snprint_recursion(buf, size, &data, MP_PRINT_MAX_DEPTH); +} diff --git a/msgpuck.h b/msgpuck.h new file mode 100644 index 0000000000..a6fe2492d1 --- /dev/null +++ b/msgpuck.h @@ -0,0 +1,2761 @@ +#ifndef MSGPUCK_H_INCLUDED +#define MSGPUCK_H_INCLUDED + +/* + * Copyright (c) 2021 The TCPDUMP project + * All rights reserved. + * + * 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 THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 THE + * 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. + * + * Initial contribution by Pavel Balaev (balaev@tarantool.org). + */ + +/* + * Copyright (c) 2013-2017 MsgPuck Authors + * All rights reserved. + * + * 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 ``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 + * 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. + */ + +/** + * \file msgpuck.h + * MsgPuck + * \brief MsgPuck is a simple and efficient MsgPack encoder/decoder + * library in a single self-contained file. + * + * Usage example: + * \code + * // Encode + * char buf[1024]; + * char *w = buf; + * w = mp_encode_array(w, 4); + * w = mp_encode_uint(w, 10); + * w = mp_encode_str(w, "hello world", strlen("hello world")); + * w = mp_encode_bool(w, true); + * w = mp_encode_double(w, 3.1415); + * + * // Validate + * const char *b = buf; + * int r = mp_check(&b, w); + * assert(!r); + * assert(b == w); + * + * // Decode + * uint32_t size; + * uint64_t ival; + * const char *sval; + * uint32_t sval_len; + * bool bval; + * double dval; + * + * const char *r = buf; + * + * size = mp_decode_array(&r); + * // size is 4 + * + * ival = mp_decode_uint(&r); + * // ival is 10; + * + * sval = mp_decode_str(&r, &sval_len); + * // sval is "hello world", sval_len is strlen("hello world") + * + * bval = mp_decode_bool(&r); + * // bval is true + * + * dval = mp_decode_double(&r); + * // dval is 3.1415 + * + * assert(r == w); + * \endcode + * + * \note Supported compilers. + * The implementation requires a C99+ or C++03+ compatible compiler. + * + * \note Inline functions. + * The implementation is compatible with both C99 and GNU inline functions. + * Please link libmsgpuck.a static library for non-inlined versions of + * functions and global tables. + */ + +#if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS) +#define __STDC_CONSTANT_MACROS 1 /* make С++ to be happy */ +#endif +#if defined(__cplusplus) && !defined(__STDC_LIMIT_MACROS) +#define __STDC_LIMIT_MACROS 1 /* make С++ to be happy */ +#endif +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(__cplusplus) +extern "C" { +#endif /* defined(__cplusplus) */ + +/* + * {{{ Platform-specific definitions + */ + +/** \cond false **/ + +#if defined(__CC_ARM) /* set the alignment to 1 for armcc compiler */ +#define MP_PACKED __packed +#define MP_PACKED_END +#define MP_CONST __attribute__((const)) +#define MP_PURE __attribute__((pure)) +#elif defined(__GNUC__) +#define MP_PACKED __attribute__((packed)) +#define MP_PACKED_END +#define MP_CONST __attribute__((const)) +#define MP_PURE __attribute__((pure)) +#elif defined(_MSC_VER) +#define MP_CONST +#define MP_PURE +#define MP_PACKED __pragma(pack(push, 1)) +#define MP_PACKED_END __pragma(pack(pop)) +#endif + +#if defined(MP_SOURCE) +#error MP_SOURCE is not supported anymore, please link libmsgpuck.a +#endif + +#if defined(__GNUC__) && !defined(__GNUC_STDC_INLINE__) +#if !defined(MP_LIBRARY) +#define MP_PROTO extern inline +#define MP_IMPL extern inline +#else /* defined(MP_LIBRARY) */ +#define MP_PROTO +#define MP_IMPL +#endif +#define MP_ALWAYSINLINE +#else /* C99 inline */ +#if !defined(MP_LIBRARY) +#define MP_PROTO inline +#define MP_IMPL inline +#else /* defined(MP_LIBRARY) */ +#define MP_PROTO extern inline +#define MP_IMPL inline +#endif +#ifndef _WIN32 +#define MP_ALWAYSINLINE __attribute__((always_inline)) +#else +#define MP_ALWAYSINLINE +#endif +#endif /* GNU inline or C99 inline */ + +#if !defined __GNUC_MINOR__ || defined __INTEL_COMPILER || \ + defined __SUNPRO_C || defined __SUNPRO_CC +#define MP_GCC_VERSION(major, minor) 0 +#else +#define MP_GCC_VERSION(major, minor) (__GNUC__ > (major) || \ + (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor))) +#endif + +#if !defined(__has_builtin) +#define __has_builtin(x) 0 /* clang */ +#endif + +#if MP_GCC_VERSION(2, 9) || __has_builtin(__builtin_expect) +#define mp_likely(x) __builtin_expect((x), 1) +#define mp_unlikely(x) __builtin_expect((x), 0) +#else +#define mp_likely(x) (x) +#define mp_unlikely(x) (x) +#endif + +#if MP_GCC_VERSION(4, 5) || __has_builtin(__builtin_unreachable) +#define mp_unreachable() (assert(0), __builtin_unreachable()) +#else +#ifndef _WIN32 +MP_PROTO void +mp_unreachable(void) __attribute__((noreturn)); +#else +static void __declspec(noreturn) mp_unreachable(void) { + assert(0); +} +#endif +#if 0 +MP_PROTO void +mp_unreachable(void) { assert(0); abort(); } +#define mp_unreachable() (assert(0)) +#endif +#endif + +#define mp_identity(x) (x) /* just to simplify mp_load/mp_store macroses */ + +#if MP_GCC_VERSION(4, 8) || __has_builtin(__builtin_bswap16) +#define mp_bswap_u16(x) __builtin_bswap16(x) +#else /* !MP_GCC_VERSION(4, 8) */ +#define mp_bswap_u16(x) ( \ + (((x) << 8) & 0xff00) | \ + (((x) >> 8) & 0x00ff) ) +#endif + +#if MP_GCC_VERSION(4, 3) || __has_builtin(__builtin_bswap32) +#define mp_bswap_u32(x) __builtin_bswap32(x) +#else /* !MP_GCC_VERSION(4, 3) */ +#define mp_bswap_u32(x) ( \ + (((x) << 24) & UINT32_C(0xff000000)) | \ + (((x) << 8) & UINT32_C(0x00ff0000)) | \ + (((x) >> 8) & UINT32_C(0x0000ff00)) | \ + (((x) >> 24) & UINT32_C(0x000000ff)) ) +#endif + +#if MP_GCC_VERSION(4, 3) || __has_builtin(__builtin_bswap64) +#define mp_bswap_u64(x) __builtin_bswap64(x) +#else /* !MP_GCC_VERSION(4, 3) */ +#define mp_bswap_u64(x) (\ + (((x) << 56) & UINT64_C(0xff00000000000000)) | \ + (((x) << 40) & UINT64_C(0x00ff000000000000)) | \ + (((x) << 24) & UINT64_C(0x0000ff0000000000)) | \ + (((x) << 8) & UINT64_C(0x000000ff00000000)) | \ + (((x) >> 8) & UINT64_C(0x00000000ff000000)) | \ + (((x) >> 24) & UINT64_C(0x0000000000ff0000)) | \ + (((x) >> 40) & UINT64_C(0x000000000000ff00)) | \ + (((x) >> 56) & UINT64_C(0x00000000000000ff)) ) +#endif + +#define MP_LOAD_STORE(name, type, bswap) \ +MP_PROTO type \ +mp_load_##name(const char **data); \ +MP_IMPL type \ +mp_load_##name(const char **data) \ +{ \ + struct MP_PACKED cast { type val; } MP_PACKED_END ; \ + type val = bswap(((const struct cast *) *data)->val); \ + *data += sizeof(type); \ + return val; \ +} \ +MP_PROTO char * \ +mp_store_##name(char *data, type val); \ +MP_IMPL char * \ +mp_store_##name(char *data, type val) \ +{ \ + struct MP_PACKED cast { type val; } MP_PACKED_END ; \ + ((struct cast *) (data))->val = bswap(val); \ + return data + sizeof(type); \ +} + +MP_LOAD_STORE(u8, uint8_t, mp_identity) + +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + +MP_LOAD_STORE(u16, uint16_t, mp_bswap_u16) +MP_LOAD_STORE(u32, uint32_t, mp_bswap_u32) +MP_LOAD_STORE(u64, uint64_t, mp_bswap_u64) + +#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + +MP_LOAD_STORE(u16, uint16_t, mp_identity) +MP_LOAD_STORE(u32, uint32_t, mp_identity) +MP_LOAD_STORE(u64, uint64_t, mp_identity) + +#else +#error Unsupported __BYTE_ORDER__ +#endif + +#if !defined(__FLOAT_WORD_ORDER__) +#define __FLOAT_WORD_ORDER__ __BYTE_ORDER__ +#endif /* defined(__FLOAT_WORD_ORDER__) */ + +#if __FLOAT_WORD_ORDER__ == __ORDER_LITTLE_ENDIAN__ + +/* + * Idiots from msgpack.org byte-swaps even IEEE754 float/double types. + * Some platforms (e.g. arm) cause SIGBUS on attempt to store + * invalid float in registers, so code like flt = mp_bswap_float(flt) + * can't be used here. + */ + +union MP_PACKED mp_float_cast { + uint32_t u32; + float f; +} MP_PACKED_END ; + +union MP_PACKED mp_double_cast { + uint64_t u64; + double d; +} MP_PACKED_END ; + +MP_PROTO float +mp_load_float(const char **data); +MP_PROTO double +mp_load_double(const char **data); +MP_PROTO char * +mp_store_float(char *data, float val); +MP_PROTO char * +mp_store_double(char *data, double val); + +MP_IMPL float +mp_load_float(const char **data) +{ + union mp_float_cast cast = *(const union mp_float_cast *) *data; + *data += sizeof(cast); + cast.u32 = mp_bswap_u32(cast.u32); + return cast.f; +} + +MP_IMPL double +mp_load_double(const char **data) +{ + union mp_double_cast cast = *(const union mp_double_cast *) *data; + *data += sizeof(cast); + cast.u64 = mp_bswap_u64(cast.u64); + return cast.d; +} + +MP_IMPL char * +mp_store_float(char *data, float val) +{ + union mp_float_cast cast; + cast.f = val; + cast.u32 = mp_bswap_u32(cast.u32); + *(union mp_float_cast *) (data) = cast; + return data + sizeof(cast); +} + +MP_IMPL char * +mp_store_double(char *data, double val) +{ + union mp_double_cast cast; + cast.d = val; + cast.u64 = mp_bswap_u64(cast.u64); + *(union mp_double_cast *) (data) = cast; + return data + sizeof(cast); +} + +#elif __FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__ + +MP_LOAD_STORE(float, float, mp_identity) +MP_LOAD_STORE(double, double, mp_identity) + +#else +#error Unsupported __FLOAT_WORD_ORDER__ +#endif + +#undef mp_identity +#undef MP_LOAD_STORE + +/** \endcond */ + +/* + * }}} + */ + +/* + * {{{ API definition + */ + +/** + * \brief MsgPack data types + */ +enum mp_type { + MP_NIL = 0, + MP_UINT, + MP_INT, + MP_STR, + MP_BIN, + MP_ARRAY, + MP_MAP, + MP_BOOL, + MP_FLOAT, + MP_DOUBLE, + MP_EXT +}; + +/** + * \brief Determine MsgPack type by a first byte \a c of encoded data. + * + * Example usage: + * \code + * assert(MP_ARRAY == mp_typeof(0x90)); + * \endcode + * + * \param c - a first byte of encoded data + * \return MsgPack type + */ +MP_PROTO MP_PURE enum mp_type +mp_typeof(const char c); + +/** + * \brief Calculate exact buffer size needed to store an array header of + * \a size elements. Maximum return value is 5. For performance reasons you + * can preallocate buffer for maximum size without calling the function. + * \param size - a number of elements + * \return buffer size in bytes (max is 5) + */ +MP_PROTO MP_CONST uint32_t +mp_sizeof_array(uint32_t size); + +/** + * \brief Encode an array header of \a size elements. + * + * All array members must be encoded after the header. + * + * Example usage: + * \code + * // Encode + * char buf[1024]; + * char *w = buf; + * w = mp_encode_array(w, 2); + * w = mp_encode_uint(w, 10); + * w = mp_encode_uint(w, 15); + * + * // Decode + * const char *r = buf; + * uint32_t size = mp_decode_array(&r); + * for (uint32_t i = 0; i < size; i++) { + * uint64_t val = mp_decode_uint(&r); + * } + * assert (r == w); + * \endcode + * It is your responsibility to ensure that \a data has enough space. + * \param data - a buffer + * \param size - a number of elements + * \return \a data + \link mp_sizeof_array() mp_sizeof_array(size) \endlink + * \sa mp_sizeof_array + */ +MP_PROTO char * +mp_encode_array(char *data, uint32_t size); + +/** + * \brief Check that \a cur buffer has enough bytes to decode an array header + * \param cur buffer + * \param end end of the buffer + * \retval 0 - buffer has enough bytes + * \retval > 0 - the number of remaining bytes to read + * \pre cur < end + * \pre mp_typeof(*cur) == MP_ARRAY + */ +MP_PROTO MP_PURE ptrdiff_t +mp_check_array(const char *cur, const char *end); + +/** + * \brief Decode an array header from MsgPack \a data. + * + * All array members must be decoded after the header. + * \param data - the pointer to a buffer + * \return the number of elements in an array + * \post *data = *data + mp_sizeof_array(retval) + * \sa \link mp_encode_array() An usage example \endlink + */ +MP_PROTO uint32_t +mp_decode_array(const char **data); + +/** + * \brief Calculate exact buffer size needed to store a map header of + * \a size elements. Maximum return value is 5. For performance reasons you + * can preallocate buffer for maximum size without calling the function. + * \param size - a number of elements + * \return buffer size in bytes (max is 5) + */ +MP_PROTO MP_CONST uint32_t +mp_sizeof_map(uint32_t size); + +/** + * \brief Encode a map header of \a size elements. + * + * All map key-value pairs must be encoded after the header. + * + * Example usage: + * \code + * char buf[1024]; + * + * // Encode + * char *w = buf; + * w = mp_encode_map(b, 2); + * w = mp_encode_str(b, "key1", 4); + * w = mp_encode_str(b, "value1", 6); + * w = mp_encode_str(b, "key2", 4); + * w = mp_encode_str(b, "value2", 6); + * + * // Decode + * const char *r = buf; + * uint32_t size = mp_decode_map(&r); + * for (uint32_t i = 0; i < size; i++) { + * // Use switch(mp_typeof(**r)) to support more types + * uint32_t key_len, val_len; + * const char *key = mp_decode_str(&r, key_len); + * const char *val = mp_decode_str(&r, val_len); + * } + * assert (r == w); + * \endcode + * It is your responsibility to ensure that \a data has enough space. + * \param data - a buffer + * \param size - a number of key/value pairs + * \return \a data + \link mp_sizeof_map() mp_sizeof_map(size)\endlink + * \sa mp_sizeof_map + */ +MP_PROTO char * +mp_encode_map(char *data, uint32_t size); + +/** + * \brief Check that \a cur buffer has enough bytes to decode a map header + * \param cur buffer + * \param end end of the buffer + * \retval 0 - buffer has enough bytes + * \retval > 0 - the number of remaining bytes to read + * \pre cur < end + * \pre mp_typeof(*cur) == MP_MAP + */ +MP_PROTO MP_PURE ptrdiff_t +mp_check_map(const char *cur, const char *end); + +/** + * \brief Decode a map header from MsgPack \a data. + * + * All map key-value pairs must be decoded after the header. + * \param data - the pointer to a buffer + * \return the number of key/value pairs in a map + * \post *data = *data + mp_sizeof_array(retval) + * \sa \link mp_encode_map() An usage example \endlink + */ +MP_PROTO uint32_t +mp_decode_map(const char **data); + +/** + * \brief calculate exact buffer size needed to store + * ext header for a value of length \a len. + * \param len value length in bytes. + * \retval buffer size in bytes + */ +MP_PROTO uint32_t +mp_sizeof_extl(uint32_t len); + +/** + * \brief Equivalent to mp_sizeof_extl(\a len) + \a len. + * \param len - a extension data length + * \return size in chars (max is 6 + \a len) + */ +MP_PROTO uint32_t +mp_sizeof_ext(uint32_t len); + +/** + * \brief Encode extension header with \a type and + * value length \a len. + * The value must be encoded after the header. + * \return \a data + \link mp_sizeof_extl() mp_sizeof_extl(size)\endlink + */ +MP_PROTO char * +mp_encode_extl(char *data, int8_t type, uint32_t len); + +/** + * \brief Encode extension data of length \a len. + * The function is equivalent to mp_encode_extl() + memcpy. + * \param data - a buffer + * \param type - extension type to encode + * \param str - a pointer to extension data + * \param len - a extension data length + * \return \a data + mp_sizeof_ext(\a len) == + * data + mp_sizeof_extl(\a len) + \a len + * \sa mp_encode_strl + */ +MP_PROTO char * +mp_encode_ext(char *data, int8_t type, const char *str, uint32_t len); + +/** + * \brief Check that \a cur buffer has enough bytes to decode an ext header. + * \param cur buffer + * \param end end of the buffer + * \retval 0 - buffer has enough bytes + * \retval > 0 - the numbeer of remaining bytes to read + * \pre cur < end + * \pre mp_typeof(*cur) == MP_EXT + */ +MP_PROTO MP_PURE ptrdiff_t +mp_check_extl(const char *cur, const char *end); + +/** + * \brief Decode an extension header from MsgPack \a data. + * + * The extension type value must be decoded after the header. + * \param data - the pointer to a buffer. + * \param type - decoded type of the following value. + * \retval - the length of the following ext value. + * \post *data = *data + mp_sizeof_extl(length) + */ +MP_PROTO uint32_t +mp_decode_extl(const char **data, int8_t *type); + +/** + * \brief Decode an extension from MsgPack \a data + * \param data - the pointer to a buffer + * \param type - the pointer to save extension type + * \param len - the pointer to save extension data length + * \return a pointer to decoded extension data + * \post *data = *data + mp_sizeof_ext(*len) + */ +MP_PROTO const char * +mp_decode_ext(const char **data, int8_t *type, uint32_t *len); + +/** + * \brief Calculate exact buffer size needed to store an integer \a num. + * Maximum return value is 9. For performance reasons you can preallocate + * buffer for maximum size without calling the function. + * Example usage: + * \code + * char **data = ...; + * char *end = *data; + * my_buffer_ensure(mp_sizeof_uint(x), &end); + * // my_buffer_ensure(9, &end); + * mp_encode_uint(buffer, x); + * \endcode + * \param num - a number + * \return buffer size in bytes (max is 9) + */ +MP_PROTO MP_CONST uint32_t +mp_sizeof_uint(uint64_t num); + +/** + * \brief Calculate exact buffer size needed to store an integer \a num. + * Maximum return value is 9. For performance reasons you can preallocate + * buffer for maximum size without calling the function. + * \param num - a number + * \return buffer size in bytes (max is 9) + * \pre \a num < 0 + */ +MP_PROTO MP_CONST uint32_t +mp_sizeof_int(int64_t num); + +/** + * \brief Encode an unsigned integer \a num. + * It is your responsibility to ensure that \a data has enough space. + * \param data - a buffer + * \param num - a number + * \return \a data + mp_sizeof_uint(\a num) + * \sa \link mp_encode_array() An usage example \endlink + * \sa mp_sizeof_uint() + */ +MP_PROTO char * +mp_encode_uint(char *data, uint64_t num); + +/** + * \brief Encode a signed integer \a num. + * It is your responsibility to ensure that \a data has enough space. + * \param data - a buffer + * \param num - a number + * \return \a data + mp_sizeof_int(\a num) + * \sa \link mp_encode_array() An usage example \endlink + * \sa mp_sizeof_int() + * \pre \a num < 0 + */ +MP_PROTO char * +mp_encode_int(char *data, int64_t num); + +/** + * \brief Check that \a cur buffer has enough bytes to decode an uint + * \param cur buffer + * \param end end of the buffer + * \retval 0 - buffer has enough bytes + * \retval > 0 - the number of remaining bytes to read + * \pre cur < end + * \pre mp_typeof(*cur) == MP_UINT + */ +MP_PROTO MP_PURE ptrdiff_t +mp_check_uint(const char *cur, const char *end); + +/** + * \brief Check that \a cur buffer has enough bytes to decode an int + * \param cur buffer + * \param end end of the buffer + * \retval 0 - buffer has enough bytes + * \retval > 0 - the number of remaining bytes to read + * \pre cur < end + * \pre mp_typeof(*cur) == MP_INT + */ +MP_PROTO MP_PURE ptrdiff_t +mp_check_int(const char *cur, const char *end); + +/** + * \brief Decode an unsigned integer from MsgPack \a data + * \param data - the pointer to a buffer + * \return an unsigned number + * \post *data = *data + mp_sizeof_uint(retval) + */ +MP_PROTO uint64_t +mp_decode_uint(const char **data); + +/** + * \brief Decode a signed integer from MsgPack \a data + * \param data - the pointer to a buffer + * \return an unsigned number + * \post *data = *data + mp_sizeof_int(retval) + */ +MP_PROTO int64_t +mp_decode_int(const char **data); + +/** + * \brief Compare two packed unsigned integers. + * + * The function is faster than two mp_decode_uint() calls. + * \param data_a unsigned int a + * \param data_b unsigned int b + * \retval < 0 when \a a < \a b + * \retval 0 when \a a == \a b + * \retval > 0 when \a a > \a b + */ +MP_PROTO MP_PURE int +mp_compare_uint(const char *data_a, const char *data_b); + +/** + * \brief Calculate exact buffer size needed to store a float \a num. + * The return value is always 5. The function was added to provide integrity of + * the library. + * \param num - a float + * \return buffer size in bytes (always 5) + */ +MP_PROTO MP_CONST uint32_t +mp_sizeof_float(float num); + +/** + * \brief Calculate exact buffer size needed to store a double \a num. + * The return value is either 5 or 9. The function was added to provide + * integrity of the library. For performance reasons you can preallocate buffer + * for maximum size without calling the function. + * \param num - a double + * \return buffer size in bytes (5 or 9) + */ +MP_PROTO MP_CONST uint32_t +mp_sizeof_double(double num); + +/** + * \brief Encode a float \a num. + * It is your responsibility to ensure that \a data has enough space. + * \param data - a buffer + * \param num - a float + * \return \a data + mp_sizeof_float(\a num) + * \sa mp_sizeof_float() + * \sa \link mp_encode_array() An usage example \endlink + */ +MP_PROTO char * +mp_encode_float(char *data, float num); + +/** + * \brief Encode a double \a num. + * It is your responsibility to ensure that \a data has enough space. + * \param data - a buffer + * \param num - a float + * \return \a data + mp_sizeof_double(\a num) + * \sa \link mp_encode_array() An usage example \endlink + * \sa mp_sizeof_double() + */ +MP_PROTO char * +mp_encode_double(char *data, double num); + +/** + * \brief Check that \a cur buffer has enough bytes to decode a float + * \param cur buffer + * \param end end of the buffer + * \retval 0 - buffer has enough bytes + * \retval > 0 - the number of remaining bytes to read + * \pre cur < end + * \pre mp_typeof(*cur) == MP_FLOAT + */ +MP_PROTO MP_PURE ptrdiff_t +mp_check_float(const char *cur, const char *end); + +/** + * \brief Check that \a cur buffer has enough bytes to decode a double + * \param cur buffer + * \param end end of the buffer + * \retval 0 - buffer has enough bytes + * \retval > 0 - the number of remaining bytes to read + * \pre cur < end + * \pre mp_typeof(*cur) == MP_DOUBLE + */ +MP_PROTO MP_PURE ptrdiff_t +mp_check_double(const char *cur, const char *end); + +/** + * \brief Decode a float from MsgPack \a data + * \param data - the pointer to a buffer + * \return a float + * \post *data = *data + mp_sizeof_float(retval) + */ +MP_PROTO float +mp_decode_float(const char **data); + +/** + * \brief Decode a double from MsgPack \a data + * \param data - the pointer to a buffer + * \return a double + * \post *data = *data + mp_sizeof_double(retval) + */ +MP_PROTO double +mp_decode_double(const char **data); + +/** + * \brief Calculate exact buffer size needed to store a string header of + * length \a num. Maximum return value is 5. For performance reasons you can + * preallocate buffer for maximum size without calling the function. + * \param len - a string length + * \return size in chars (max is 5) + */ +MP_PROTO MP_CONST uint32_t +mp_sizeof_strl(uint32_t len); + +/** + * \brief Equivalent to mp_sizeof_strl(\a len) + \a len. + * \param len - a string length + * \return size in chars (max is 5 + \a len) + */ +MP_PROTO MP_CONST uint32_t +mp_sizeof_str(uint32_t len); + +/** + * \brief Calculate exact buffer size needed to store a binstring header of + * length \a num. Maximum return value is 5. For performance reasons you can + * preallocate buffer for maximum size without calling the function. + * \param len - a string length + * \return size in chars (max is 5) + */ +MP_PROTO MP_CONST uint32_t +mp_sizeof_binl(uint32_t len); + +/** + * \brief Equivalent to mp_sizeof_binl(\a len) + \a len. + * \param len - a string length + * \return size in chars (max is 5 + \a len) + */ +MP_PROTO MP_CONST uint32_t +mp_sizeof_bin(uint32_t len); + +/** + * \brief Encode a string header of length \a len. + * + * The function encodes MsgPack header (\em only header) for a string of + * length \a len. You should append actual string data to the buffer manually + * after encoding the header (exactly \a len bytes without trailing '\0'). + * + * This approach is very useful for cases when the total length of the string + * is known in advance, but the string data is not stored in a single + * continuous buffer (e.g. network packets). + * + * It is your responsibility to ensure that \a data has enough space. + * Usage example: + * \code + * char buffer[1024]; + * char *b = buffer; + * b = mp_encode_strl(b, hdr.total_len); + * char *s = b; + * memcpy(b, pkt1.data, pkt1.len); + * b += pkt1.len; + * // get next packet + * memcpy(b, pkt2.data, pkt2.len); + * b += pkt2.len; + * // get next packet + * memcpy(b, pkt1.data, pkt3.len); + * b += pkt3.len; + * + * // Check that all data was received + * assert(hdr.total_len == (uint32_t) (b - s)) + * \endcode + * Hint: you can dynamically reallocate the buffer during the process. + * \param data - a buffer + * \param len - a string length + * \return \a data + mp_sizeof_strl(len) + * \sa mp_sizeof_strl() + */ +MP_PROTO char * +mp_encode_strl(char *data, uint32_t len); + +/** + * \brief Encode a string of length \a len. + * The function is equivalent to mp_encode_strl() + memcpy. + * \param data - a buffer + * \param str - a pointer to string data + * \param len - a string length + * \return \a data + mp_sizeof_str(len) == + * data + mp_sizeof_strl(len) + len + * \sa mp_encode_strl + */ +MP_PROTO char * +mp_encode_str(char *data, const char *str, uint32_t len); + +/** + * \brief Encode a null-terminated string + * The function is equivalent to mp_encode_str() with len = strlen(str) + * \param data - a buffer + * \param str - a pointer to string data + * \return mp_encode_str(data, str, strlen(str)) + */ +MP_PROTO char * +mp_encode_str0(char *data, const char *str); + +/** + * \brief Encode a binstring header of length \a len. + * See mp_encode_strl() for more details. + * \param data - a bufer + * \param len - a string length + * \return data + mp_sizeof_binl(\a len) + * \sa mp_encode_strl + */ +MP_PROTO char * +mp_encode_binl(char *data, uint32_t len); + +/** + * \brief Encode a binstring of length \a len. + * The function is equivalent to mp_encode_binl() + memcpy. + * \param data - a buffer + * \param str - a pointer to binstring data + * \param len - a binstring length + * \return \a data + mp_sizeof_bin(\a len) == + * data + mp_sizeof_binl(\a len) + \a len + * \sa mp_encode_strl + */ +MP_PROTO char * +mp_encode_bin(char *data, const char *str, uint32_t len); + +/** + * \brief Encode a sequence of values according to format string. + * Example: mp_format(buf, sz, "[%d {%d%s%d%s}]", 42, 0, "false", 1, "true"); + * to get a msgpack array of two items: number 42 and map (0->"false, 2->"true") + * Does not write items that don't fit to data_size argument. + * + * \param data - a buffer + * \param data_size - a buffer size + * \param format - zero-end string, containing structure of resulting + * msgpack and types of next arguments. + * Format can contain '[' and ']' pairs, defining arrays, + * '{' and '}' pairs, defining maps, and format specifiers, described below: + * %d, %i - int + * %u - unsigned int + * %ld, %li - long + * %lu - unsigned long + * %lld, %lli - long long + * %llu - unsigned long long + * %hd, %hi - short + * %hu - unsigned short + * %hhd, %hhi - char (as number) + * %hhu - unsigned char (as number) + * %f - float + * %lf - double + * %b - bool + * %s - zero-end string + * %.*s - string with specified length + * %p - MsgPack data + * %.*p - MsgPack data with specified length + * %% is ignored + * %smthelse assert and undefined behaviour + * NIL - a nil value + * all other symbols are ignored. + * + * \return the number of requred bytes. + * \retval > data_size means that is not enough space + * and whole msgpack was not encoded. + */ +size_t +mp_format(char *data, size_t data_size, const char *format, ...); + +/** + * \brief mp_format variation, taking variable argument list + * Example: + * va_list args; + * va_start(args, fmt); + * mp_vformat(data, data_size, fmt, args); + * va_end(args); + * \sa \link mp_format() mp_format() \endlink + */ +size_t +mp_vformat(char *data, size_t data_size, const char *format, va_list args); + +/** + * \brief print MsgPack data \a file using JSON-like format. + * MP_EXT is printed as a non-standard JSON 'list': + * + * (extension: type , len ) + * + * For example: + * + * (extension: type 10, len 35) + * + * Type is the MP_EXT type. Length is of the MP_EXT body, not + * counting its header. Since the 'list' and what is in it is not + * a standard JSON, printing a MessagePack buffer, having MP_EXT + * in it, may lead to an invalid JSON. + * + * However MP_EXT may be printed differently in case a proper + * virtual serializer was installed. \sa mp_fprint_ext_f. + * + * \param file - pointer to file (or NULL for stdout) + * \param data - pointer to buffer containing msgpack object + * \retval >=0 - the number of bytes printed + * \retval -1 - error + * \sa fprintf() + */ +int +mp_fprint(FILE *file, const char *data); + +/** + * \brief Print MsgPack data to \a file using JSON-like format. + * Works exactly like \sa mp_fprint(), but allows to specify max + * depth, and changes \a data parameter. Intended to be used for + * MsgPack serialization recursion. + */ +int +mp_fprint_recursion(FILE *file, const char **data, int depth); + +typedef int (*mp_fprint_ext_f)(FILE *file, const char **data, int depth); + +/** + * \brief Function called when need to serialize MP_EXT into a + * file. + */ +extern mp_fprint_ext_f mp_fprint_ext; + +/** + * \brief Default MP_EXT serializer into a file. Skips the object, + * ignores all the other arguments, and writes + * + * (extension: type , len ) + * + * \sa mp_fprint(). + */ +int +mp_fprint_ext_default(FILE *file, const char **data, int depth); + +/** + * \brief format MsgPack data to \a buf using JSON-like format. + * Behaves the same as \sa mp_fprint(), but with snprintf() + * semantics. + * \sa mp_fprint() + * \param buf - buffer to use + * \param size - buffer size. This function write at most size bytes + * (including the terminating null byte ('\0'). + * \param data - pointer to buffer containing msgpack object + * \retval =size - the number of characters (excluding the null byte), + * which would have been written to the final string if + * enough space had been available. + * \retval -1 - error + * \sa snprintf() + */ +int +mp_snprint(char *buf, int size, const char *data); + +/** + * \brief Format MsgPack data to \a buf using JSON-like format. + * Works exactly like \sa mp_snprint(), but allows to specify max + * depth, and changes \a data parameter. Intended to be used for + * MsgPack serialization recursion. + */ +int +mp_snprint_recursion(char *buf, int size, const char **data, int depth); + +typedef int (*mp_snprint_ext_f)(char *buf, int size, const char **data, + int depth); + +/** + * \brief Function called when need to serialize MP_EXT into a + * string. + */ +extern mp_snprint_ext_f mp_snprint_ext; + +/** + * \brief Default MP_EXT serializer into a string. Skips the + * object, ignores all the other arguments, and prints + * + * (extension: type , len ) + * + * \sa mp_snprint(). + */ +int +mp_snprint_ext_default(char *buf, int size, const char **data, int depth); + +typedef int (*mp_check_ext_data_f)(int8_t type, const char *data, uint32_t len); + +/** + * \brief Function called by mp_check() to validate user-defined MP_EXT types. + */ +extern mp_check_ext_data_f mp_check_ext_data; + +/** + * \brief Default MP_EXT checker. Does nothing since knows nothing of + * user-defined extension types. + * \retval 0 + */ +int +mp_check_ext_data_default(int8_t type, const char *data, uint32_t len); + +/** + * \brief Check that \a cur buffer has enough bytes to decode a string header + * \param cur buffer + * \param end end of the buffer + * \retval 0 - buffer has enough bytes + * \retval > 0 - the number of remaining bytes to read + * \pre cur < end + * \pre mp_typeof(*cur) == MP_STR + */ +MP_PROTO MP_PURE ptrdiff_t +mp_check_strl(const char *cur, const char *end); + +/** + * \brief Check that \a cur buffer has enough bytes to decode a binstring header + * \param cur buffer + * \param end end of the buffer + * \retval 0 - buffer has enough bytes + * \retval > 0 - the number of remaining bytes to read + * \pre cur < end + * \pre mp_typeof(*cur) == MP_BIN + */ +MP_PROTO MP_PURE ptrdiff_t +mp_check_binl(const char *cur, const char *end); + +/** + * \brief Decode a length of a string from MsgPack \a data + * \param data - the pointer to a buffer + * \return a length of astring + * \post *data = *data + mp_sizeof_strl(retval) + * \sa mp_encode_strl + */ +MP_PROTO uint32_t +mp_decode_strl(const char **data); + +/** + * \brief Decode a string from MsgPack \a data + * \param data - the pointer to a buffer + * \param len - the pointer to save a string length + * \return a pointer to a decoded string + * \post *data = *data + mp_sizeof_str(*len) + * \sa mp_encode_binl + */ +MP_PROTO const char * +mp_decode_str(const char **data, uint32_t *len); + +/** + * \brief Decode a length of a binstring from MsgPack \a data + * \param data - the pointer to a buffer + * \return a length of a binstring + * \post *data = *data + mp_sizeof_binl(retval) + * \sa mp_encode_binl + */ +MP_PROTO uint32_t +mp_decode_binl(const char **data); + +/** + * \brief Decode a binstring from MsgPack \a data + * \param data - the pointer to a buffer + * \param len - the pointer to save a binstring length + * \return a pointer to a decoded binstring + * \post *data = *data + mp_sizeof_str(*len) + * \sa mp_encode_binl + */ +MP_PROTO const char * +mp_decode_bin(const char **data, uint32_t *len); + +/** + * \brief Decode a length of a string or binstring from MsgPack \a data + * \param data - the pointer to a buffer + * \return a length of a string + * \post *data = *data + mp_sizeof_strbinl(retval) + * \sa mp_encode_binl + */ +MP_PROTO uint32_t +mp_decode_strbinl(const char **data); + +/** + * \brief Decode a string or binstring from MsgPack \a data + * \param data - the pointer to a buffer + * \param len - the pointer to save a binstring length + * \return a pointer to a decoded binstring + * \post *data = *data + mp_sizeof_strbinl(*len) + * \sa mp_encode_binl + */ +MP_PROTO const char * +mp_decode_strbin(const char **data, uint32_t *len); + +/** + * \brief Calculate exact buffer size needed to store the nil value. + * The return value is always 1. The function was added to provide integrity of + * the library. + * \return buffer size in bytes (always 1) + */ +MP_PROTO MP_CONST uint32_t +mp_sizeof_nil(void); + +/** + * \brief Encode the nil value. + * It is your responsibility to ensure that \a data has enough space. + * \param data - a buffer + * \return \a data + mp_sizeof_nil() + * \sa \link mp_encode_array() An usage example \endlink + * \sa mp_sizeof_nil() + */ +MP_PROTO char * +mp_encode_nil(char *data); + +/** + * \brief Check that \a cur buffer has enough bytes to decode nil + * \param cur buffer + * \param end end of the buffer + * \retval 0 - buffer has enough bytes + * \retval > 0 - the number of remaining bytes to read + * \pre cur < end + * \pre mp_typeof(*cur) == MP_NIL + */ +MP_PROTO MP_PURE ptrdiff_t +mp_check_nil(const char *cur, const char *end); + +/** + * \brief Decode the nil value from MsgPack \a data + * \param data - the pointer to a buffer + * \post *data = *data + mp_sizeof_nil() + */ +MP_PROTO void +mp_decode_nil(const char **data); + +/** + * \brief Calculate exact buffer size needed to store a boolean value. + * The return value is always 1. The function was added to provide integrity of + * the library. + * \return buffer size in bytes (always 1) + */ +MP_PROTO MP_CONST uint32_t +mp_sizeof_bool(bool val); + +/** + * \brief Encode a bool value \a val. + * It is your responsibility to ensure that \a data has enough space. + * \param data - a buffer + * \param val - a bool + * \return \a data + mp_sizeof_bool(val) + * \sa \link mp_encode_array() An usage example \endlink + * \sa mp_sizeof_bool() + */ +MP_PROTO char * +mp_encode_bool(char *data, bool val); + +/** + * \brief Check that \a cur buffer has enough bytes to decode a bool value + * \param cur buffer + * \param end end of the buffer + * \retval 0 - buffer has enough bytes + * \retval > 0 - the number of remaining bytes to read + * \pre cur < end + * \pre mp_typeof(*cur) == MP_BOOL + */ +MP_PROTO MP_PURE ptrdiff_t +mp_check_bool(const char *cur, const char *end); + +/** + * \brief Decode a bool value from MsgPack \a data + * \param data - the pointer to a buffer + * \return a decoded bool value + * \post *data = *data + mp_sizeof_bool(retval) + */ +MP_PROTO bool +mp_decode_bool(const char **data); + +/** + * \brief Decode an integer value as int32_t from MsgPack \a data. + * \param data - the pointer to a buffer + * \param[out] ret - the pointer to save a result + * \retval 0 on success + * \retval -1 if underlying mp type is not MP_INT or MP_UINT + * \retval -1 if the result can't be stored in int32_t + */ +MP_PROTO int +mp_read_int32(const char **data, int32_t *ret); + +/** + * \brief Decode an integer value as int64_t from MsgPack \a data. + * \param data - the pointer to a buffer + * \param[out] ret - the pointer to save a result + * \retval 0 on success + * \retval -1 if underlying mp type is not MP_INT or MP_UINT + * \retval -1 if the result can't be stored in int64_t + */ +MP_PROTO int +mp_read_int64(const char **data, int64_t *ret); + +/** + * \brief Decode a floating point value as double from MsgPack \a data. + * \param data - the pointer to a buffer + * \param[out] ret - the pointer to save a result + * \retval 0 on success + * \retval -1 if underlying mp type is not MP_INT, MP_UINT, + * MP_FLOAT, or MP_DOUBLE + * \retval -1 if the result can't be stored in double + */ +MP_PROTO int +mp_read_double(const char **data, double *ret); + +/** + * \brief Skip one element in a packed \a data. + * + * The function is faster than mp_typeof + mp_decode_XXX() combination. + * For arrays and maps the function also skips all members. + * For strings and binstrings the function also skips the string data. + * + * Usage example: + * \code + * char buf[1024]; + * + * char *w = buf; + * // First MsgPack object + * w = mp_encode_uint(w, 10); + * + * // Second MsgPack object + * w = mp_encode_array(w, 4); + * w = mp_encode_array(w, 2); + * // Begin of an inner array + * w = mp_encode_str(w, "second inner 1", 14); + * w = mp_encode_str(w, "second inner 2", 14); + * // End of an inner array + * w = mp_encode_str(w, "second", 6); + * w = mp_encode_uint(w, 20); + * w = mp_encode_bool(w, true); + * + * // Third MsgPack object + * w = mp_encode_str(w, "third", 5); + * // EOF + * + * const char *r = buf; + * + * // First MsgPack object + * assert(mp_typeof(**r) == MP_UINT); + * mp_next(&r); // skip the first object + * + * // Second MsgPack object + * assert(mp_typeof(**r) == MP_ARRAY); + * mp_decode_array(&r); + * assert(mp_typeof(**r) == MP_ARRAY); // inner array + * mp_next(&r); // -->> skip the entire inner array (with all members) + * assert(mp_typeof(**r) == MP_STR); // second + * mp_next(&r); + * assert(mp_typeof(**r) == MP_UINT); // 20 + * mp_next(&r); + * assert(mp_typeof(**r) == MP_BOOL); // true + * mp_next(&r); + * + * // Third MsgPack object + * assert(mp_typeof(**r) == MP_STR); // third + * mp_next(&r); + * + * assert(r == w); // EOF + * + * \endcode + * \param data - the pointer to a buffer + * \post *data = *data + mp_sizeof_TYPE() where TYPE is mp_typeof(**data) + */ +MP_PROTO void +mp_next(const char **data); + +/** + * \brief Equivalent to mp_next() but also validates MsgPack in \a data. + * \param data - the pointer to a buffer + * \param end - the end of a buffer + * \retval 0 when MsgPack in \a data is valid. + * \retval != 0 when MsgPack in \a data is not valid. + * \post *data = *data + mp_sizeof_TYPE() where TYPE is mp_typeof(**data) + * \post *data is not defined if MsgPack is not valid + * \sa mp_next() + */ +MP_PROTO int +mp_check(const char **data, const char *end); + +/** + * The maximum msgpack nesting depth supported by mp_snprint(). + * Everything beyond that will be omitted (replaced with "..."). + */ +#ifndef MP_PRINT_MAX_DEPTH +#define MP_PRINT_MAX_DEPTH 32 +#endif + +/** Message pack MP_MAP or MP_ARRAY container descriptor. */ +struct mp_frame { + /** + * MP frame type calculated with mp_typeof(). + */ + enum mp_type type; + /** + * Total number of items in MP_MAP or MP_ARRAY container + * calculated with mp_decode_map() or mp_decode_array(). + */ + int count; + /** + * Index of currently processing item. Must be less than + * mp_frame::count member. + */ + int idx; +}; + +/** + * Stack of map/array descriptors mp_frame to preserve traversal + * state when parsing nested array/map in a msgpack stream. + * Makes it possible to parse nested MP_ARRAY and MP_MAP msgpack + * containers without recursion and easily determine that + * the container under the parsing cursor is complete. +*/ +struct mp_stack { + /** + * The maximum stack depth. + */ + int size; + /** + * Count of used stack frames. Corresponds to the index + * in the array to perform the push operation. Must be + * less or equal to mp_stack::size member. + */ + int used; + /** + * Array of size mp_stack::size of mp_frames. + */ + struct mp_frame *frames; +}; + +/** + * \brief Initialize mp_stack \a stack with specified size \a size + * and user-allocated array \a frames. + * The \a frames allocation must have at least \a size mp_frame + * items. + * \param stack - the pointer to a mp_stack to initialize. + * \param size - stack size, count of stack::frames to use. + * \param frames - mp_frame preallocated array of size \a size + * of struct mp_frame items + */ +MP_PROTO void +mp_stack_create(struct mp_stack *stack, int size, struct mp_frame *frames); + +/** + * \brief Test if mp_stack \a stack is empty. + * \param stack - the pointer to a mp_stack to a stack to test. + * \retval true if mp_stack is empty, false otherwise. + */ +MP_PROTO bool +mp_stack_is_empty(struct mp_stack *stack); + +/** + * \brief Test if mp_stack \a stack is full. + * \param stack - the pointer to a mp_stack to a stack to test. + * \retval true if mp_stack is full, false otherwise. + */ +MP_PROTO bool +mp_stack_is_full(struct mp_stack *stack); + +/** + * \brief Return the top mp_stack \a stack frame. + * \param stack - the pointer to a mp_stack to operate with. + * \pre mp_stack_is_empty(stack) == false + */ +MP_PROTO struct mp_frame * +mp_stack_top(struct mp_stack *stack); + +/** + * \brief Pop the top mp_stack \a stack frame. + * \param stack - the pointer to a mp_stack to operate with. + * \pre mp_stack_is_empty(stack) == false + */ +MP_PROTO void +mp_stack_pop(struct mp_stack *stack); + +/** + * \brief Construct a new mp_frame and push it on to mp_stack + * \a stack. + * \param stack - the pointer to a stack to operate with. + * \param type - the type of mp_frame to create. + * \param count - the count of itemes of mp_frame to create. + * \pre mp_stack_is_full(stack) == false + */ +MP_PROTO void +mp_stack_push(struct mp_stack *stack, enum mp_type type, int count); + +/** + * \brief Advance idx attribute of the \a frame. + * \param frame - the frame pointer to operate with. + * \retval true when mp_frame::idx is less than mp_frame::count. + * false otherwise. + */ +MP_PROTO bool +mp_frame_advance(struct mp_frame *frame); + +/* + * }}} + */ + +/* + * {{{ Implementation + */ + +/** \cond false */ +extern const enum mp_type mp_type_hint[]; +extern const int8_t mp_parser_hint[]; +extern const char *mp_char2escape[]; +extern const uint8_t mp_ext_hint[]; + +MP_IMPL MP_ALWAYSINLINE enum mp_type +mp_typeof(const char c) +{ + return mp_type_hint[(uint8_t) c]; +} + +MP_IMPL uint32_t +mp_sizeof_array(uint32_t size) +{ + if (size <= 15) { + return 1; + } else if (size <= UINT16_MAX) { + return 1 + sizeof(uint16_t); + } else { + return 1 + sizeof(uint32_t); + } +} + +MP_IMPL char * +mp_encode_array(char *data, uint32_t size) +{ + if (size <= 15) { + return mp_store_u8(data, 0x90 | size); + } else if (size <= UINT16_MAX) { + data = mp_store_u8(data, 0xdc); + data = mp_store_u16(data, size); + return data; + } else { + data = mp_store_u8(data, 0xdd); + return mp_store_u32(data, size); + } +} + +MP_IMPL ptrdiff_t +mp_check_array(const char *cur, const char *end) +{ + assert(cur < end); + assert(mp_typeof(*cur) == MP_ARRAY); + uint8_t c = mp_load_u8(&cur); + if (mp_likely(!(c & 0x40))) + return cur - end; + + assert(c >= 0xdc && c <= 0xdd); /* must be checked above by mp_typeof */ + uint32_t hsize = 2U << (c & 0x1); /* 0xdc->2, 0xdd->4 */ + return hsize - (end - cur); +} + +MP_PROTO uint32_t +mp_decode_array_slowpath(uint8_t c, const char **data); + +MP_IMPL uint32_t +mp_decode_array_slowpath(uint8_t c, const char **data) +{ + uint32_t size; + switch (c & 0x1) { + case 0xdc & 0x1: + size = mp_load_u16(data); + return size; + case 0xdd & 0x1: + size = mp_load_u32(data); + return size; + default: + mp_unreachable(); + } +} + +MP_IMPL MP_ALWAYSINLINE uint32_t +mp_decode_array(const char **data) +{ + uint8_t c = mp_load_u8(data); + + if (mp_likely(!(c & 0x40))) + return (c & 0xf); + + return mp_decode_array_slowpath(c, data); +} + +MP_IMPL uint32_t +mp_sizeof_map(uint32_t size) +{ + if (size <= 15) { + return 1; + } else if (size <= UINT16_MAX) { + return 1 + sizeof(uint16_t); + } else { + return 1 + sizeof(uint32_t); + } +} + +MP_IMPL char * +mp_encode_map(char *data, uint32_t size) +{ + if (size <= 15) { + return mp_store_u8(data, 0x80 | size); + } else if (size <= UINT16_MAX) { + data = mp_store_u8(data, 0xde); + data = mp_store_u16(data, size); + return data; + } else { + data = mp_store_u8(data, 0xdf); + data = mp_store_u32(data, size); + return data; + } +} + +MP_IMPL ptrdiff_t +mp_check_map(const char *cur, const char *end) +{ + assert(cur < end); + assert(mp_typeof(*cur) == MP_MAP); + uint8_t c = mp_load_u8(&cur); + if (mp_likely((c & ~0xfU) == 0x80)) + return cur - end; + + assert(c >= 0xde && c <= 0xdf); /* must be checked above by mp_typeof */ + uint32_t hsize = 2U << (c & 0x1); /* 0xde->2, 0xdf->4 */ + return hsize - (end - cur); +} + +MP_IMPL uint32_t +mp_decode_map(const char **data) +{ + uint8_t c = mp_load_u8(data); + switch (c) { + case 0xde: + return mp_load_u16(data); + case 0xdf: + return mp_load_u32(data); + default: + if (mp_unlikely(c < 0x80 || c > 0x8f)) + mp_unreachable(); + return c & 0xf; + } +} + +MP_IMPL uint32_t +mp_sizeof_extl(uint32_t len) +{ + if (len && len <= 16 && mp_ext_hint[len-1]) return 2; + if (len <= UINT8_MAX) return 3; + if (len <= UINT16_MAX) return 4; + else return 6; +} + +MP_IMPL uint32_t +mp_sizeof_ext(uint32_t len) +{ + return mp_sizeof_extl(len) + len; +} + +MP_IMPL char * +mp_encode_extl(char *data, int8_t type, uint32_t len) +{ + /* + * Only use fixext when length is exactly 1, 2, 4, 8 or 16. + * Otherwise use ext 8 if length <= 255. + */ + if (len && len <= 16 && mp_ext_hint[len-1]) { + data = mp_store_u8(data, mp_ext_hint[len-1]); + } else if (len <= UINT8_MAX) { + data = mp_store_u8(data, 0xc7); + data = mp_store_u8(data, (uint8_t) len); + } else if (len <= UINT16_MAX) { + data = mp_store_u8(data, 0xc8); + data = mp_store_u16(data, (uint16_t) len); + } else { + data = mp_store_u8(data, 0xc9); + data = mp_store_u32(data,len); + } + data = mp_store_u8(data, type); + return data; +} + +MP_IMPL char * +mp_encode_ext(char *data, int8_t type, const char *str, uint32_t len) +{ + data = mp_encode_extl(data, type, len); + memcpy(data, str, len); + return data + len; +} + +MP_IMPL ptrdiff_t +mp_check_extl(const char *cur, const char *end) +{ + assert(cur < end); + assert(mp_typeof(*cur) == MP_EXT); + uint8_t c = mp_load_u8(&cur); + if ((c & 0xf0) == 0xd0) { + return 1 - (end - cur); + } + + assert(c >= 0xc7 && c <= 0xc9); + return (1 << (c - 0xc7)) + 1 - (end - cur); /* 0xc7 -> 2, 0xc8 -> 3, 0xc9 ->5 */ +} + +MP_IMPL uint32_t +mp_decode_extl(const char **data, int8_t *type) { + uint8_t c = mp_load_u8(data); + uint32_t len; + switch (c) { + case 0xd4: + case 0xd5: + case 0xd6: + case 0xd7: + case 0xd8: + len = 1u << (c - 0xd4); + break; + case 0xc7: + len = mp_load_u8(data); + break; + case 0xc8: + len = mp_load_u16(data); + break; + case 0xc9: + len = mp_load_u32(data); + break; + default: + mp_unreachable(); + } + *type = mp_load_u8(data); + return len; +} + +MP_IMPL const char * +mp_decode_ext(const char **data, int8_t *type, uint32_t *len) { + assert(len != NULL); + + *len = mp_decode_extl(data, type); + const char *str = *data; + *data += *len; + return str; +} + +MP_IMPL uint32_t +mp_sizeof_uint(uint64_t num) +{ + if (num <= 0x7f) { + return 1; + } else if (num <= UINT8_MAX) { + return 1 + sizeof(uint8_t); + } else if (num <= UINT16_MAX) { + return 1 + sizeof(uint16_t); + } else if (num <= UINT32_MAX) { + return 1 + sizeof(uint32_t); + } else { + return 1 + sizeof(uint64_t); + } +} + +MP_IMPL uint32_t +mp_sizeof_int(int64_t num) +{ + assert(num < 0); + if (num >= -0x20) { + return 1; + } else if (num >= INT8_MIN && num <= INT8_MAX) { + return 1 + sizeof(int8_t); + } else if (num >= INT16_MIN && num <= UINT16_MAX) { + return 1 + sizeof(int16_t); + } else if (num >= INT32_MIN && num <= UINT32_MAX) { + return 1 + sizeof(int32_t); + } else { + return 1 + sizeof(int64_t); + } +} + +MP_IMPL ptrdiff_t +mp_check_uint(const char *cur, const char *end) +{ + assert(cur < end); + assert(mp_typeof(*cur) == MP_UINT); + uint8_t c = mp_load_u8(&cur); + return mp_parser_hint[c] - (end - cur); +} + +MP_IMPL ptrdiff_t +mp_check_int(const char *cur, const char *end) +{ + assert(cur < end); + assert(mp_typeof(*cur) == MP_INT); + uint8_t c = mp_load_u8(&cur); + return mp_parser_hint[c] - (end - cur); +} + +MP_IMPL char * +mp_encode_uint(char *data, uint64_t num) +{ + if (num <= 0x7f) { + return mp_store_u8(data, (uint8_t)num); + } else if (num <= UINT8_MAX) { + data = mp_store_u8(data, 0xcc); + return mp_store_u8(data, (uint8_t)num); + } else if (num <= UINT16_MAX) { + data = mp_store_u8(data, 0xcd); + return mp_store_u16(data, (uint16_t)num); + } else if (num <= UINT32_MAX) { + data = mp_store_u8(data, 0xce); + return mp_store_u32(data, (uint32_t)num); + } else { + data = mp_store_u8(data, 0xcf); + return mp_store_u64(data, num); + } +} + +MP_IMPL char * +mp_encode_int(char *data, int64_t num) +{ + assert(num < 0); + if (num >= -0x20) { + return mp_store_u8(data, (uint8_t)(0xe0 | num)); + } else if (num >= INT8_MIN) { + data = mp_store_u8(data, 0xd0); + return mp_store_u8(data, (uint8_t)num); + } else if (num >= INT16_MIN) { + data = mp_store_u8(data, 0xd1); + return mp_store_u16(data, (uint16_t)num); + } else if (num >= INT32_MIN) { + data = mp_store_u8(data, 0xd2); + return mp_store_u32(data, (uint32_t)num); + } else { + data = mp_store_u8(data, 0xd3); + return mp_store_u64(data, num); + } +} + +MP_IMPL uint64_t +mp_decode_uint(const char **data) +{ + uint8_t c = mp_load_u8(data); + switch (c) { + case 0xcc: + return mp_load_u8(data); + case 0xcd: + return mp_load_u16(data); + case 0xce: + return mp_load_u32(data); + case 0xcf: + return mp_load_u64(data); + default: + if (mp_unlikely(c > 0x7f)) + mp_unreachable(); + return c; + } +} + +MP_IMPL int +mp_compare_uint(const char *data_a, const char *data_b) +{ + uint8_t ca = mp_load_u8(&data_a); + uint8_t cb = mp_load_u8(&data_b); + + int r = ca - cb; + if (r != 0) + return r; + + if (ca <= 0x7f) + return 0; + + uint64_t a, b; + switch (ca & 0x3) { + case 0xcc & 0x3: + a = mp_load_u8(&data_a); + b = mp_load_u8(&data_b); + break; + case 0xcd & 0x3: + a = mp_load_u16(&data_a); + b = mp_load_u16(&data_b); + break; + case 0xce & 0x3: + a = mp_load_u32(&data_a); + b = mp_load_u32(&data_b); + break; + case 0xcf & 0x3: + a = mp_load_u64(&data_a); + b = mp_load_u64(&data_b); + return a < b ? -1 : a > b; + break; + default: + mp_unreachable(); + } + + int64_t v = (a - b); + return (v > 0) - (v < 0); +} + +MP_IMPL int64_t +mp_decode_int(const char **data) +{ + uint8_t c = mp_load_u8(data); + switch (c) { + case 0xd0: + return (int8_t) mp_load_u8(data); + case 0xd1: + return (int16_t) mp_load_u16(data); + case 0xd2: + return (int32_t) mp_load_u32(data); + case 0xd3: + return (int64_t) mp_load_u64(data); + default: + if (mp_unlikely(c < 0xe0)) + mp_unreachable(); + return (int8_t) (c); + } +} + +MP_IMPL uint32_t +mp_sizeof_float(float num) +{ + (void) num; + return 1 + sizeof(float); +} + +MP_IMPL uint32_t +mp_sizeof_double(double num) +{ + (void) num; + return 1 + sizeof(double); +} + +MP_IMPL ptrdiff_t +mp_check_float(const char *cur, const char *end) +{ + assert(cur < end); + assert(mp_typeof(*cur) == MP_FLOAT); + return 1 + sizeof(float) - (end - cur); +} + +MP_IMPL ptrdiff_t +mp_check_double(const char *cur, const char *end) +{ + assert(cur < end); + assert(mp_typeof(*cur) == MP_DOUBLE); + return 1 + sizeof(double) - (end - cur); +} + +MP_IMPL char * +mp_encode_float(char *data, float num) +{ + data = mp_store_u8(data, 0xca); + return mp_store_float(data, num); +} + +MP_IMPL char * +mp_encode_double(char *data, double num) +{ + data = mp_store_u8(data, 0xcb); + return mp_store_double(data, num); +} + +MP_IMPL float +mp_decode_float(const char **data) +{ + uint8_t c = mp_load_u8(data); + assert(c == 0xca); + (void) c; + return mp_load_float(data); +} + +MP_IMPL double +mp_decode_double(const char **data) +{ + uint8_t c = mp_load_u8(data); + assert(c == 0xcb); + (void) c; + return mp_load_double(data); +} + +MP_IMPL uint32_t +mp_sizeof_strl(uint32_t len) +{ + if (len <= 31) { + return 1; + } else if (len <= UINT8_MAX) { + return 1 + sizeof(uint8_t); + } else if (len <= UINT16_MAX) { + return 1 + sizeof(uint16_t); + } else { + return 1 + sizeof(uint32_t); + } +} + +MP_IMPL uint32_t +mp_sizeof_str(uint32_t len) +{ + return mp_sizeof_strl(len) + len; +} + +MP_IMPL uint32_t +mp_sizeof_binl(uint32_t len) +{ + if (len <= UINT8_MAX) { + return 1 + sizeof(uint8_t); + } else if (len <= UINT16_MAX) { + return 1 + sizeof(uint16_t); + } else { + return 1 + sizeof(uint32_t); + } +} + +MP_IMPL uint32_t +mp_sizeof_bin(uint32_t len) +{ + return mp_sizeof_binl(len) + len; +} + +MP_IMPL char * +mp_encode_strl(char *data, uint32_t len) +{ + if (len <= 31) { + return mp_store_u8(data, 0xa0 | (uint8_t) len); + } else if (len <= UINT8_MAX) { + data = mp_store_u8(data, 0xd9); + return mp_store_u8(data, len); + } else if (len <= UINT16_MAX) { + data = mp_store_u8(data, 0xda); + return mp_store_u16(data, len); + } else { + data = mp_store_u8(data, 0xdb); + return mp_store_u32(data, len); + } +} + +MP_IMPL char * +mp_encode_str(char *data, const char *str, uint32_t len) +{ + data = mp_encode_strl(data, len); + memcpy(data, str, len); + return data + len; +} + +MP_IMPL char * +mp_encode_str0(char *data, const char *str) +{ + return mp_encode_str(data, str, strlen(str)); +} + +MP_IMPL char * +mp_encode_binl(char *data, uint32_t len) +{ + if (len <= UINT8_MAX) { + data = mp_store_u8(data, 0xc4); + return mp_store_u8(data, len); + } else if (len <= UINT16_MAX) { + data = mp_store_u8(data, 0xc5); + return mp_store_u16(data, len); + } else { + data = mp_store_u8(data, 0xc6); + return mp_store_u32(data, len); + } +} + +MP_IMPL char * +mp_encode_bin(char *data, const char *str, uint32_t len) +{ + data = mp_encode_binl(data, len); + memcpy(data, str, len); + return data + len; +} + +MP_IMPL ptrdiff_t +mp_check_strl(const char *cur, const char *end) +{ + assert(cur < end); + assert(mp_typeof(*cur) == MP_STR); + + uint8_t c = mp_load_u8(&cur); + if (mp_likely(c & ~0x1f) == 0xa0) + return cur - end; + + assert(c >= 0xd9 && c <= 0xdb); /* must be checked above by mp_typeof */ + uint32_t hsize = 1U << (c & 0x3) >> 1; /* 0xd9->1, 0xda->2, 0xdb->4 */ + return hsize - (end - cur); +} + +MP_IMPL ptrdiff_t +mp_check_binl(const char *cur, const char *end) +{ + uint8_t c = mp_load_u8(&cur); + assert(cur < end); + assert(mp_typeof(c) == MP_BIN); + + assert(c >= 0xc4 && c <= 0xc6); /* must be checked above by mp_typeof */ + uint32_t hsize = 1U << (c & 0x3); /* 0xc4->1, 0xc5->2, 0xc6->4 */ + return hsize - (end - cur); +} + +MP_IMPL uint32_t +mp_decode_strl(const char **data) +{ + uint8_t c = mp_load_u8(data); + switch (c) { + case 0xd9: + return mp_load_u8(data); + case 0xda: + return mp_load_u16(data); + case 0xdb: + return mp_load_u32(data); + default: + if (mp_unlikely(c < 0xa0 || c > 0xbf)) + mp_unreachable(); + return c & 0x1f; + } +} + +MP_IMPL const char * +mp_decode_str(const char **data, uint32_t *len) +{ + assert(len != NULL); + + *len = mp_decode_strl(data); + const char *str = *data; + *data += *len; + return str; +} + +MP_IMPL uint32_t +mp_decode_binl(const char **data) +{ + uint8_t c = mp_load_u8(data); + + switch (c) { + case 0xc4: + return mp_load_u8(data); + case 0xc5: + return mp_load_u16(data); + case 0xc6: + return mp_load_u32(data); + default: + mp_unreachable(); + } +} + +MP_IMPL const char * +mp_decode_bin(const char **data, uint32_t *len) +{ + assert(len != NULL); + + *len = mp_decode_binl(data); + const char *str = *data; + *data += *len; + return str; +} + +MP_IMPL uint32_t +mp_decode_strbinl(const char **data) +{ + uint8_t c = mp_load_u8(data); + + switch (c) { + case 0xd9: + return mp_load_u8(data); + case 0xda: + return mp_load_u16(data); + case 0xdb: + return mp_load_u32(data); + case 0xc4: + return mp_load_u8(data); + case 0xc5: + return mp_load_u16(data); + case 0xc6: + return mp_load_u32(data); + default: + if (mp_unlikely(c < 0xa0 || c > 0xbf)) + mp_unreachable(); + return c & 0x1f; + } +} + +MP_IMPL const char * +mp_decode_strbin(const char **data, uint32_t *len) +{ + assert(len != NULL); + + *len = mp_decode_strbinl(data); + const char *str = *data; + *data += *len; + return str; +} + +MP_IMPL uint32_t +mp_sizeof_nil(void) +{ + return 1; +} + +MP_IMPL char * +mp_encode_nil(char *data) +{ + return mp_store_u8(data, 0xc0); +} + +MP_IMPL ptrdiff_t +mp_check_nil(const char *cur, const char *end) +{ + assert(cur < end); + assert(mp_typeof(*cur) == MP_NIL); + return 1 - (end - cur); +} + +MP_IMPL void +mp_decode_nil(const char **data) +{ + uint8_t c = mp_load_u8(data); + assert(c == 0xc0); + (void) c; +} + +MP_IMPL uint32_t +mp_sizeof_bool(bool val) +{ + (void) val; + return 1; +} + +MP_IMPL char * +mp_encode_bool(char *data, bool val) +{ + return mp_store_u8(data, 0xc2 | (val & 1)); +} + +MP_IMPL ptrdiff_t +mp_check_bool(const char *cur, const char *end) +{ + assert(cur < end); + assert(mp_typeof(*cur) == MP_BOOL); + return 1 - (end - cur); +} + +MP_IMPL bool +mp_decode_bool(const char **data) +{ + uint8_t c = mp_load_u8(data); + switch (c) { + case 0xc3: + return true; + case 0xc2: + return false; + default: + mp_unreachable(); + } +} + +MP_IMPL int +mp_read_int32(const char **data, int32_t *ret) +{ + uint32_t uval; + const char *p = *data; + uint8_t c = mp_load_u8(&p); + switch (c) { + case 0xd0: + *ret = (int8_t) mp_load_u8(&p); + break; + case 0xd1: + *ret = (int16_t) mp_load_u16(&p); + break; + case 0xd2: + *ret = (int32_t) mp_load_u32(&p); + break; + case 0xcc: + *ret = mp_load_u8(&p); + break; + case 0xcd: + *ret = mp_load_u16(&p); + break; + case 0xce: + uval = mp_load_u32(&p); + if (mp_unlikely(uval > INT32_MAX)) + return -1; + *ret = uval; + break; + default: + if (mp_unlikely(c < 0xe0 && c > 0x7f)) + return -1; + *ret = (int8_t) c; + break; + } + *data = p; + return 0; +} + +MP_IMPL int +mp_read_int64(const char **data, int64_t *ret) +{ + uint64_t uval; + const char *p = *data; + uint8_t c = mp_load_u8(&p); + switch (c) { + case 0xd0: + *ret = (int8_t) mp_load_u8(&p); + break; + case 0xd1: + *ret = (int16_t) mp_load_u16(&p); + break; + case 0xd2: + *ret = (int32_t) mp_load_u32(&p); + break; + case 0xd3: + *ret = (int64_t) mp_load_u64(&p); + break; + case 0xcc: + *ret = mp_load_u8(&p); + break; + case 0xcd: + *ret = mp_load_u16(&p); + break; + case 0xce: + *ret = mp_load_u32(&p); + break; + case 0xcf: + uval = mp_load_u64(&p); + if (uval > INT64_MAX) + return -1; + *ret = uval; + break; + default: + if (mp_unlikely(c < 0xe0 && c > 0x7f)) + return -1; + *ret = (int8_t) c; + break; + } + *data = p; + return 0; +} + +MP_IMPL int +mp_read_double(const char **data, double *ret) +{ + int64_t ival; + uint64_t uval; + double val; + const char *p = *data; + uint8_t c = mp_load_u8(&p); + switch (c) { + case 0xd0: + *ret = (int8_t) mp_load_u8(&p); + break; + case 0xd1: + *ret = (int16_t) mp_load_u16(&p); + break; + case 0xd2: + *ret = (int32_t) mp_load_u32(&p); + break; + case 0xd3: + ival = (int64_t) mp_load_u64(&p); + val = (double) ival; + if ((int64_t)val != ival) + return -1; + *ret = val; + break; + case 0xcc: + *ret = mp_load_u8(&p); + break; + case 0xcd: + *ret = mp_load_u16(&p); + break; + case 0xce: + *ret = mp_load_u32(&p); + break; + case 0xcf: + uval = mp_load_u64(&p); + val = (double)uval; + if ((uint64_t)val != uval) + return -1; + *ret = val; + break; + case 0xca: + *ret = mp_load_float(&p); + break; + case 0xcb: + *ret = mp_load_double(&p); + break; + default: + if (mp_unlikely(c < 0xe0 && c > 0x7f)) + return -1; + *ret = (int8_t) c; + break; + } + *data = p; + return 0; +} + +/** See mp_parser_hint */ +enum { + MP_HINT = -32, + MP_HINT_STR_8 = MP_HINT, + MP_HINT_STR_16 = MP_HINT - 1, + MP_HINT_STR_32 = MP_HINT - 2, + MP_HINT_ARRAY_16 = MP_HINT - 3, + MP_HINT_ARRAY_32 = MP_HINT - 4, + MP_HINT_MAP_16 = MP_HINT - 5, + MP_HINT_MAP_32 = MP_HINT - 6, + MP_HINT_EXT_8 = MP_HINT - 7, + MP_HINT_EXT_16 = MP_HINT - 8, + MP_HINT_EXT_32 = MP_HINT - 9, + MP_HINT_INVALID = MP_HINT - 10 +}; + +MP_PROTO void +mp_next_slowpath(const char **data, int64_t k); + +MP_IMPL void +mp_next_slowpath(const char **data, int64_t k) +{ + for (; k > 0; k--) { + uint8_t c = mp_load_u8(data); + int l = mp_parser_hint[c]; + if (mp_likely(l >= 0)) { + /* + * Same one-byte-encoded-value optimisation. + * Good for skipping tons of NILs, zeros etc. + * Run not more than once per 64 cycles (or about) + * in order to avoid degradation for other cases. + * Note that l == 0 means that the last byte (that is + * in variable `c`) is one-byte-encoded-value. + * The idea of optimization is to read the next 8 bytes + * as one 8byte uint and check if all bytes of that + * word are the same value (`c`). If so - skip 8 bytes + * at once and repeat. + * A small trick is used to create an 8byte uint that + * consists of 8 bytes that equal to one byte (`c`): + * by rules of multiplication if multiply an one-byte + * value (for example 0xab) by 0x0101010101010101 we + * will get 0xabababababababab. That works for any byte. + */ + if (mp_unlikely(l == 0 && k % 64 == 0)) { + /* + * Check k > 8 that there are at least 8 values + * more expected, that are at least 8 bytes of + * total length, that allows us to read 8 bytes. + */ + while (k > 8) { + const char *save = *data; + uint64_t u = mp_load_u64(data); + /* + * Check that `u` is 8 `c` bytes, + * see the trick explanation above. + */ + if (u != c * 0x0101010101010101ull) { + /* Wrong, restore pointer. */ + *data = save; + break; + } + /* Confirm reading of 8 values. */ + k -= 8; + } + continue; + } + *data += l; + continue; + } else if (mp_likely(l > MP_HINT)) { + k -= l; + continue; + } + + uint32_t len; + switch (l) { + case MP_HINT_STR_8: + /* MP_STR (8) */ + len = mp_load_u8(data); + *data += len; + break; + case MP_HINT_STR_16: + /* MP_STR (16) */ + len = mp_load_u16(data); + *data += len; + break; + case MP_HINT_STR_32: + /* MP_STR (32) */ + len = mp_load_u32(data); + *data += len; + break; + case MP_HINT_ARRAY_16: + /* MP_ARRAY (16) */ + k += mp_load_u16(data); + break; + case MP_HINT_ARRAY_32: + /* MP_ARRAY (32) */ + k += mp_load_u32(data); + break; + case MP_HINT_MAP_16: + /* MP_MAP (16) */ + k += 2 * (uint32_t)mp_load_u16(data); + break; + case MP_HINT_MAP_32: + /* MP_MAP (32) */ + k += 2 * (uint64_t)mp_load_u32(data); + break; + case MP_HINT_EXT_8: + /* MP_EXT (8) */ + len = mp_load_u8(data); + mp_load_u8(data); + *data += len; + break; + case MP_HINT_EXT_16: + /* MP_EXT (16) */ + len = mp_load_u16(data); + mp_load_u8(data); + *data += len; + break; + case MP_HINT_EXT_32: + /* MP_EXT (32) */ + len = mp_load_u32(data); + mp_load_u8(data); + *data += len; + break; + default: + mp_unreachable(); + } + } +} + +MP_IMPL void +mp_next(const char **data) +{ + int64_t k = 1; + for (; k > 0; k--) { + uint8_t c = mp_load_u8(data); + int l = mp_parser_hint[c]; + if (mp_likely(l >= 0)) { + *data += l; + continue; + } else if (mp_likely(c == 0xd9)){ + /* MP_STR (8) */ + uint8_t len = mp_load_u8(data); + *data += len; + continue; + } else if (l > MP_HINT) { + k -= l; + continue; + } else { + *data -= sizeof(uint8_t); + mp_next_slowpath(data, k); + return; + } + } +} + +MP_IMPL int +mp_check(const char **data, const char *end) +{ +#define MP_CHECK_LEN(_l) \ + if (mp_unlikely((size_t)(end - *data) < (size_t)(_l))) \ + return 1; + + int64_t k; + for (k = 1; k > 0; k--) { + MP_CHECK_LEN(1); + uint8_t c = mp_load_u8(data); + int l = mp_parser_hint[c]; + uint32_t len; + int8_t type; + if (mp_likely(l >= 0)) { + MP_CHECK_LEN(l); + if (mp_unlikely(c >= 0xd4 && c <= 0xd8)) { + /* + * Check MP_EXT contents. Everything but the + * first byte (which stands for ext type) is the + * payload. + */ + len = l - 1; + type = mp_load_u8(data); + if (mp_check_ext_data(type, *data, len) != 0) + return 1; + *data += len; + } else { + *data += l; + } + continue; + } else if (mp_likely(l > MP_HINT)) { + k -= l; + continue; + } + + switch (l) { + case MP_HINT_STR_8: + /* MP_STR (8) */ + MP_CHECK_LEN(sizeof(uint8_t)); + len = mp_load_u8(data); + MP_CHECK_LEN(len); + *data += len; + break; + case MP_HINT_STR_16: + /* MP_STR (16) */ + MP_CHECK_LEN(sizeof(uint16_t)); + len = mp_load_u16(data); + MP_CHECK_LEN(len); + *data += len; + break; + case MP_HINT_STR_32: + /* MP_STR (32) */ + MP_CHECK_LEN(sizeof(uint32_t)) + len = mp_load_u32(data); + MP_CHECK_LEN(len); + *data += len; + break; + case MP_HINT_ARRAY_16: + /* MP_ARRAY (16) */ + MP_CHECK_LEN(sizeof(uint16_t)); + k += mp_load_u16(data); + break; + case MP_HINT_ARRAY_32: + /* MP_ARRAY (32) */ + MP_CHECK_LEN(sizeof(uint32_t)); + k += mp_load_u32(data); + break; + case MP_HINT_MAP_16: + /* MP_MAP (16) */ + MP_CHECK_LEN(sizeof(uint16_t)); + k += 2 * (uint32_t)mp_load_u16(data); + break; + case MP_HINT_MAP_32: + /* MP_MAP (32) */ + MP_CHECK_LEN(sizeof(uint32_t)); + k += 2 * (uint64_t)mp_load_u32(data); + break; + case MP_HINT_EXT_8: + /* MP_EXT (8) */ + MP_CHECK_LEN(sizeof(uint8_t) + sizeof(uint8_t)); + len = mp_load_u8(data); + type = mp_load_u8(data); + MP_CHECK_LEN(len); + if (mp_check_ext_data(type, *data, len) != 0) + return 1; + *data += len; + break; + case MP_HINT_EXT_16: + /* MP_EXT (16) */ + MP_CHECK_LEN(sizeof(uint16_t) + sizeof(uint8_t)); + len = mp_load_u16(data); + type = mp_load_u8(data); + MP_CHECK_LEN(len); + if (mp_check_ext_data(type, *data, len) != 0) + return 1; + *data += len; + break; + case MP_HINT_EXT_32: + /* MP_EXT (32) */ + MP_CHECK_LEN(sizeof(uint32_t) + sizeof(uint8_t)); + len = mp_load_u32(data); + type = mp_load_u8(data); + MP_CHECK_LEN(len); + if (mp_check_ext_data(type, *data, len) != 0) + return 1; + *data += len; + break; + case MP_HINT_INVALID: + return 1; + default: + mp_unreachable(); + } + } + + assert(*data <= end); +#undef MP_CHECK_LEN + return 0; +} + +MP_IMPL void +mp_stack_create(struct mp_stack *stack, int size, struct mp_frame *frames) +{ + stack->frames = frames; + stack->size = size; + stack->used = 0; +} + +MP_IMPL bool +mp_stack_is_empty(struct mp_stack *stack) +{ + return stack->used == 0; +} + +MP_IMPL bool +mp_stack_is_full(struct mp_stack *stack) +{ + return stack->used >= stack->size; +} + +MP_IMPL struct mp_frame * +mp_stack_top(struct mp_stack *stack) +{ + assert(!mp_stack_is_empty(stack)); + return &stack->frames[stack->used - 1]; +} + +MP_IMPL void +mp_stack_pop(struct mp_stack *stack) +{ + assert(!mp_stack_is_empty(stack)); + --stack->used; +} + +MP_IMPL void +mp_stack_push(struct mp_stack *stack, enum mp_type type, int count) +{ + assert(!mp_stack_is_full(stack)); + int idx = stack->used++; + stack->frames[idx].type = type; + stack->frames[idx].count = count; + stack->frames[idx].idx = -1; +} + +MP_IMPL bool +mp_frame_advance(struct mp_frame *frame) +{ + if (frame->idx >= frame->count - 1) + return false; + ++frame->idx; + return true; +} + +/** \endcond */ + +/* + * }}} + */ + +#if defined(__cplusplus) +} /* extern "C" */ +#endif /* defined(__cplusplus) */ + +#undef MP_LIBRARY +#undef MP_PROTO +#undef MP_IMPL +#undef MP_ALWAYSINLINE +#undef MP_GCC_VERSION + +#endif /* MSGPUCK_H_INCLUDED */ diff --git a/msgpuck_hints.c b/msgpuck_hints.c new file mode 100644 index 0000000000..e7d7c3d2a8 --- /dev/null +++ b/msgpuck_hints.c @@ -0,0 +1,727 @@ +/* + * Copyright (c) 2021 The TCPDUMP project + * All rights reserved. + * + * 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 THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 THE + * 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. + * + * Initial contribution by Pavel Balaev (balaev@tarantool.org). + */ + +/* + * Copyright (c) 2013-2017 MsgPuck Authors + * All rights reserved. + * + * 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 ``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 + * 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 "msgpuck.h" + +/** + * This lookup table used by mp_sizeof() to determine enum mp_type by the first + * byte of MsgPack element. + */ +const enum mp_type mp_type_hint[256]= { + /* {{{ MP_UINT (fixed) */ + /* 0x00 */ MP_UINT, + /* 0x01 */ MP_UINT, + /* 0x02 */ MP_UINT, + /* 0x03 */ MP_UINT, + /* 0x04 */ MP_UINT, + /* 0x05 */ MP_UINT, + /* 0x06 */ MP_UINT, + /* 0x07 */ MP_UINT, + /* 0x08 */ MP_UINT, + /* 0x09 */ MP_UINT, + /* 0x0a */ MP_UINT, + /* 0x0b */ MP_UINT, + /* 0x0c */ MP_UINT, + /* 0x0d */ MP_UINT, + /* 0x0e */ MP_UINT, + /* 0x0f */ MP_UINT, + /* 0x10 */ MP_UINT, + /* 0x11 */ MP_UINT, + /* 0x12 */ MP_UINT, + /* 0x13 */ MP_UINT, + /* 0x14 */ MP_UINT, + /* 0x15 */ MP_UINT, + /* 0x16 */ MP_UINT, + /* 0x17 */ MP_UINT, + /* 0x18 */ MP_UINT, + /* 0x19 */ MP_UINT, + /* 0x1a */ MP_UINT, + /* 0x1b */ MP_UINT, + /* 0x1c */ MP_UINT, + /* 0x1d */ MP_UINT, + /* 0x1e */ MP_UINT, + /* 0x1f */ MP_UINT, + /* 0x20 */ MP_UINT, + /* 0x21 */ MP_UINT, + /* 0x22 */ MP_UINT, + /* 0x23 */ MP_UINT, + /* 0x24 */ MP_UINT, + /* 0x25 */ MP_UINT, + /* 0x26 */ MP_UINT, + /* 0x27 */ MP_UINT, + /* 0x28 */ MP_UINT, + /* 0x29 */ MP_UINT, + /* 0x2a */ MP_UINT, + /* 0x2b */ MP_UINT, + /* 0x2c */ MP_UINT, + /* 0x2d */ MP_UINT, + /* 0x2e */ MP_UINT, + /* 0x2f */ MP_UINT, + /* 0x30 */ MP_UINT, + /* 0x31 */ MP_UINT, + /* 0x32 */ MP_UINT, + /* 0x33 */ MP_UINT, + /* 0x34 */ MP_UINT, + /* 0x35 */ MP_UINT, + /* 0x36 */ MP_UINT, + /* 0x37 */ MP_UINT, + /* 0x38 */ MP_UINT, + /* 0x39 */ MP_UINT, + /* 0x3a */ MP_UINT, + /* 0x3b */ MP_UINT, + /* 0x3c */ MP_UINT, + /* 0x3d */ MP_UINT, + /* 0x3e */ MP_UINT, + /* 0x3f */ MP_UINT, + /* 0x40 */ MP_UINT, + /* 0x41 */ MP_UINT, + /* 0x42 */ MP_UINT, + /* 0x43 */ MP_UINT, + /* 0x44 */ MP_UINT, + /* 0x45 */ MP_UINT, + /* 0x46 */ MP_UINT, + /* 0x47 */ MP_UINT, + /* 0x48 */ MP_UINT, + /* 0x49 */ MP_UINT, + /* 0x4a */ MP_UINT, + /* 0x4b */ MP_UINT, + /* 0x4c */ MP_UINT, + /* 0x4d */ MP_UINT, + /* 0x4e */ MP_UINT, + /* 0x4f */ MP_UINT, + /* 0x50 */ MP_UINT, + /* 0x51 */ MP_UINT, + /* 0x52 */ MP_UINT, + /* 0x53 */ MP_UINT, + /* 0x54 */ MP_UINT, + /* 0x55 */ MP_UINT, + /* 0x56 */ MP_UINT, + /* 0x57 */ MP_UINT, + /* 0x58 */ MP_UINT, + /* 0x59 */ MP_UINT, + /* 0x5a */ MP_UINT, + /* 0x5b */ MP_UINT, + /* 0x5c */ MP_UINT, + /* 0x5d */ MP_UINT, + /* 0x5e */ MP_UINT, + /* 0x5f */ MP_UINT, + /* 0x60 */ MP_UINT, + /* 0x61 */ MP_UINT, + /* 0x62 */ MP_UINT, + /* 0x63 */ MP_UINT, + /* 0x64 */ MP_UINT, + /* 0x65 */ MP_UINT, + /* 0x66 */ MP_UINT, + /* 0x67 */ MP_UINT, + /* 0x68 */ MP_UINT, + /* 0x69 */ MP_UINT, + /* 0x6a */ MP_UINT, + /* 0x6b */ MP_UINT, + /* 0x6c */ MP_UINT, + /* 0x6d */ MP_UINT, + /* 0x6e */ MP_UINT, + /* 0x6f */ MP_UINT, + /* 0x70 */ MP_UINT, + /* 0x71 */ MP_UINT, + /* 0x72 */ MP_UINT, + /* 0x73 */ MP_UINT, + /* 0x74 */ MP_UINT, + /* 0x75 */ MP_UINT, + /* 0x76 */ MP_UINT, + /* 0x77 */ MP_UINT, + /* 0x78 */ MP_UINT, + /* 0x79 */ MP_UINT, + /* 0x7a */ MP_UINT, + /* 0x7b */ MP_UINT, + /* 0x7c */ MP_UINT, + /* 0x7d */ MP_UINT, + /* 0x7e */ MP_UINT, + /* 0x7f */ MP_UINT, + /* }}} */ + + /* {{{ MP_MAP (fixed) */ + /* 0x80 */ MP_MAP, + /* 0x81 */ MP_MAP, + /* 0x82 */ MP_MAP, + /* 0x83 */ MP_MAP, + /* 0x84 */ MP_MAP, + /* 0x85 */ MP_MAP, + /* 0x86 */ MP_MAP, + /* 0x87 */ MP_MAP, + /* 0x88 */ MP_MAP, + /* 0x89 */ MP_MAP, + /* 0x8a */ MP_MAP, + /* 0x8b */ MP_MAP, + /* 0x8c */ MP_MAP, + /* 0x8d */ MP_MAP, + /* 0x8e */ MP_MAP, + /* 0x8f */ MP_MAP, + /* }}} */ + + /* {{{ MP_ARRAY (fixed) */ + /* 0x90 */ MP_ARRAY, + /* 0x91 */ MP_ARRAY, + /* 0x92 */ MP_ARRAY, + /* 0x93 */ MP_ARRAY, + /* 0x94 */ MP_ARRAY, + /* 0x95 */ MP_ARRAY, + /* 0x96 */ MP_ARRAY, + /* 0x97 */ MP_ARRAY, + /* 0x98 */ MP_ARRAY, + /* 0x99 */ MP_ARRAY, + /* 0x9a */ MP_ARRAY, + /* 0x9b */ MP_ARRAY, + /* 0x9c */ MP_ARRAY, + /* 0x9d */ MP_ARRAY, + /* 0x9e */ MP_ARRAY, + /* 0x9f */ MP_ARRAY, + /* }}} */ + + /* {{{ MP_STR (fixed) */ + /* 0xa0 */ MP_STR, + /* 0xa1 */ MP_STR, + /* 0xa2 */ MP_STR, + /* 0xa3 */ MP_STR, + /* 0xa4 */ MP_STR, + /* 0xa5 */ MP_STR, + /* 0xa6 */ MP_STR, + /* 0xa7 */ MP_STR, + /* 0xa8 */ MP_STR, + /* 0xa9 */ MP_STR, + /* 0xaa */ MP_STR, + /* 0xab */ MP_STR, + /* 0xac */ MP_STR, + /* 0xad */ MP_STR, + /* 0xae */ MP_STR, + /* 0xaf */ MP_STR, + /* 0xb0 */ MP_STR, + /* 0xb1 */ MP_STR, + /* 0xb2 */ MP_STR, + /* 0xb3 */ MP_STR, + /* 0xb4 */ MP_STR, + /* 0xb5 */ MP_STR, + /* 0xb6 */ MP_STR, + /* 0xb7 */ MP_STR, + /* 0xb8 */ MP_STR, + /* 0xb9 */ MP_STR, + /* 0xba */ MP_STR, + /* 0xbb */ MP_STR, + /* 0xbc */ MP_STR, + /* 0xbd */ MP_STR, + /* 0xbe */ MP_STR, + /* 0xbf */ MP_STR, + /* }}} */ + + /* {{{ MP_NIL, MP_BOOL */ + /* 0xc0 */ MP_NIL, + /* 0xc1 */ MP_EXT, /* never used */ + /* 0xc2 */ MP_BOOL, + /* 0xc3 */ MP_BOOL, + /* }}} */ + + /* {{{ MP_BIN */ + /* 0xc4 */ MP_BIN, /* MP_BIN(8) */ + /* 0xc5 */ MP_BIN, /* MP_BIN(16) */ + /* 0xc6 */ MP_BIN, /* MP_BIN(32) */ + /* }}} */ + + /* {{{ MP_EXT */ + /* 0xc7 */ MP_EXT, + /* 0xc8 */ MP_EXT, + /* 0xc9 */ MP_EXT, + /* }}} */ + + /* {{{ MP_FLOAT, MP_DOUBLE */ + /* 0xca */ MP_FLOAT, + /* 0xcb */ MP_DOUBLE, + /* }}} */ + + /* {{{ MP_UINT */ + /* 0xcc */ MP_UINT, + /* 0xcd */ MP_UINT, + /* 0xce */ MP_UINT, + /* 0xcf */ MP_UINT, + /* }}} */ + + /* {{{ MP_INT */ + /* 0xd0 */ MP_INT, /* MP_INT (8) */ + /* 0xd1 */ MP_INT, /* MP_INT (16) */ + /* 0xd2 */ MP_INT, /* MP_INT (32) */ + /* 0xd3 */ MP_INT, /* MP_INT (64) */ + /* }}} */ + + /* {{{ MP_EXT */ + /* 0xd4 */ MP_EXT, /* MP_INT (8) */ + /* 0xd5 */ MP_EXT, /* MP_INT (16) */ + /* 0xd6 */ MP_EXT, /* MP_INT (32) */ + /* 0xd7 */ MP_EXT, /* MP_INT (64) */ + /* 0xd8 */ MP_EXT, /* MP_INT (127) */ + /* }}} */ + + /* {{{ MP_STR */ + /* 0xd9 */ MP_STR, /* MP_STR(8) */ + /* 0xda */ MP_STR, /* MP_STR(16) */ + /* 0xdb */ MP_STR, /* MP_STR(32) */ + /* }}} */ + + /* {{{ MP_ARRAY */ + /* 0xdc */ MP_ARRAY, /* MP_ARRAY(16) */ + /* 0xdd */ MP_ARRAY, /* MP_ARRAY(32) */ + /* }}} */ + + /* {{{ MP_MAP */ + /* 0xde */ MP_MAP, /* MP_MAP (16) */ + /* 0xdf */ MP_MAP, /* MP_MAP (32) */ + /* }}} */ + + /* {{{ MP_INT */ + /* 0xe0 */ MP_INT, + /* 0xe1 */ MP_INT, + /* 0xe2 */ MP_INT, + /* 0xe3 */ MP_INT, + /* 0xe4 */ MP_INT, + /* 0xe5 */ MP_INT, + /* 0xe6 */ MP_INT, + /* 0xe7 */ MP_INT, + /* 0xe8 */ MP_INT, + /* 0xe9 */ MP_INT, + /* 0xea */ MP_INT, + /* 0xeb */ MP_INT, + /* 0xec */ MP_INT, + /* 0xed */ MP_INT, + /* 0xee */ MP_INT, + /* 0xef */ MP_INT, + /* 0xf0 */ MP_INT, + /* 0xf1 */ MP_INT, + /* 0xf2 */ MP_INT, + /* 0xf3 */ MP_INT, + /* 0xf4 */ MP_INT, + /* 0xf5 */ MP_INT, + /* 0xf6 */ MP_INT, + /* 0xf7 */ MP_INT, + /* 0xf8 */ MP_INT, + /* 0xf9 */ MP_INT, + /* 0xfa */ MP_INT, + /* 0xfb */ MP_INT, + /* 0xfc */ MP_INT, + /* 0xfd */ MP_INT, + /* 0xfe */ MP_INT, + /* 0xff */ MP_INT + /* }}} */ +}; + +/** + * This lookup table used by mp_next() and mp_check() to determine + * size of MsgPack element by its first byte. + * A positive value contains size of the element (excluding the first byte). + * A negative value means the element is compound (e.g. array or map) + * of size (-n). + * MP_HINT_* values used for special cases handled by switch() statement. + */ +const int8_t mp_parser_hint[256] = { + /* {{{ MP_UINT(fixed) **/ + /* 0x00 */ 0, + /* 0x01 */ 0, + /* 0x02 */ 0, + /* 0x03 */ 0, + /* 0x04 */ 0, + /* 0x05 */ 0, + /* 0x06 */ 0, + /* 0x07 */ 0, + /* 0x08 */ 0, + /* 0x09 */ 0, + /* 0x0a */ 0, + /* 0x0b */ 0, + /* 0x0c */ 0, + /* 0x0d */ 0, + /* 0x0e */ 0, + /* 0x0f */ 0, + /* 0x10 */ 0, + /* 0x11 */ 0, + /* 0x12 */ 0, + /* 0x13 */ 0, + /* 0x14 */ 0, + /* 0x15 */ 0, + /* 0x16 */ 0, + /* 0x17 */ 0, + /* 0x18 */ 0, + /* 0x19 */ 0, + /* 0x1a */ 0, + /* 0x1b */ 0, + /* 0x1c */ 0, + /* 0x1d */ 0, + /* 0x1e */ 0, + /* 0x1f */ 0, + /* 0x20 */ 0, + /* 0x21 */ 0, + /* 0x22 */ 0, + /* 0x23 */ 0, + /* 0x24 */ 0, + /* 0x25 */ 0, + /* 0x26 */ 0, + /* 0x27 */ 0, + /* 0x28 */ 0, + /* 0x29 */ 0, + /* 0x2a */ 0, + /* 0x2b */ 0, + /* 0x2c */ 0, + /* 0x2d */ 0, + /* 0x2e */ 0, + /* 0x2f */ 0, + /* 0x30 */ 0, + /* 0x31 */ 0, + /* 0x32 */ 0, + /* 0x33 */ 0, + /* 0x34 */ 0, + /* 0x35 */ 0, + /* 0x36 */ 0, + /* 0x37 */ 0, + /* 0x38 */ 0, + /* 0x39 */ 0, + /* 0x3a */ 0, + /* 0x3b */ 0, + /* 0x3c */ 0, + /* 0x3d */ 0, + /* 0x3e */ 0, + /* 0x3f */ 0, + /* 0x40 */ 0, + /* 0x41 */ 0, + /* 0x42 */ 0, + /* 0x43 */ 0, + /* 0x44 */ 0, + /* 0x45 */ 0, + /* 0x46 */ 0, + /* 0x47 */ 0, + /* 0x48 */ 0, + /* 0x49 */ 0, + /* 0x4a */ 0, + /* 0x4b */ 0, + /* 0x4c */ 0, + /* 0x4d */ 0, + /* 0x4e */ 0, + /* 0x4f */ 0, + /* 0x50 */ 0, + /* 0x51 */ 0, + /* 0x52 */ 0, + /* 0x53 */ 0, + /* 0x54 */ 0, + /* 0x55 */ 0, + /* 0x56 */ 0, + /* 0x57 */ 0, + /* 0x58 */ 0, + /* 0x59 */ 0, + /* 0x5a */ 0, + /* 0x5b */ 0, + /* 0x5c */ 0, + /* 0x5d */ 0, + /* 0x5e */ 0, + /* 0x5f */ 0, + /* 0x60 */ 0, + /* 0x61 */ 0, + /* 0x62 */ 0, + /* 0x63 */ 0, + /* 0x64 */ 0, + /* 0x65 */ 0, + /* 0x66 */ 0, + /* 0x67 */ 0, + /* 0x68 */ 0, + /* 0x69 */ 0, + /* 0x6a */ 0, + /* 0x6b */ 0, + /* 0x6c */ 0, + /* 0x6d */ 0, + /* 0x6e */ 0, + /* 0x6f */ 0, + /* 0x70 */ 0, + /* 0x71 */ 0, + /* 0x72 */ 0, + /* 0x73 */ 0, + /* 0x74 */ 0, + /* 0x75 */ 0, + /* 0x76 */ 0, + /* 0x77 */ 0, + /* 0x78 */ 0, + /* 0x79 */ 0, + /* 0x7a */ 0, + /* 0x7b */ 0, + /* 0x7c */ 0, + /* 0x7d */ 0, + /* 0x7e */ 0, + /* 0x7f */ 0, + /* }}} */ + + /* {{{ MP_MAP (fixed) */ + /* 0x80 */ 0, /* empty map - just skip one byte */ + /* 0x81 */ -2, /* 2 elements follow */ + /* 0x82 */ -4, + /* 0x83 */ -6, + /* 0x84 */ -8, + /* 0x85 */ -10, + /* 0x86 */ -12, + /* 0x87 */ -14, + /* 0x88 */ -16, + /* 0x89 */ -18, + /* 0x8a */ -20, + /* 0x8b */ -22, + /* 0x8c */ -24, + /* 0x8d */ -26, + /* 0x8e */ -28, + /* 0x8f */ -30, + /* }}} */ + + /* {{{ MP_ARRAY (fixed) */ + /* 0x90 */ 0, /* empty array - just skip one byte */ + /* 0x91 */ -1, /* 1 element follows */ + /* 0x92 */ -2, + /* 0x93 */ -3, + /* 0x94 */ -4, + /* 0x95 */ -5, + /* 0x96 */ -6, + /* 0x97 */ -7, + /* 0x98 */ -8, + /* 0x99 */ -9, + /* 0x9a */ -10, + /* 0x9b */ -11, + /* 0x9c */ -12, + /* 0x9d */ -13, + /* 0x9e */ -14, + /* 0x9f */ -15, + /* }}} */ + + /* {{{ MP_STR (fixed) */ + /* 0xa0 */ 0, + /* 0xa1 */ 1, + /* 0xa2 */ 2, + /* 0xa3 */ 3, + /* 0xa4 */ 4, + /* 0xa5 */ 5, + /* 0xa6 */ 6, + /* 0xa7 */ 7, + /* 0xa8 */ 8, + /* 0xa9 */ 9, + /* 0xaa */ 10, + /* 0xab */ 11, + /* 0xac */ 12, + /* 0xad */ 13, + /* 0xae */ 14, + /* 0xaf */ 15, + /* 0xb0 */ 16, + /* 0xb1 */ 17, + /* 0xb2 */ 18, + /* 0xb3 */ 19, + /* 0xb4 */ 20, + /* 0xb5 */ 21, + /* 0xb6 */ 22, + /* 0xb7 */ 23, + /* 0xb8 */ 24, + /* 0xb9 */ 25, + /* 0xba */ 26, + /* 0xbb */ 27, + /* 0xbc */ 28, + /* 0xbd */ 29, + /* 0xbe */ 30, + /* 0xbf */ 31, + /* }}} */ + + /* {{{ MP_NIL, MP_BOOL */ + /* 0xc0 */ 0, /* MP_NIL */ + /* 0xc1 */ 0, /* never used */ + /* 0xc2 */ 0, /* MP_BOOL*/ + /* 0xc3 */ 0, /* MP_BOOL*/ + /* }}} */ + + /* {{{ MP_BIN */ + /* 0xc4 */ MP_HINT_STR_8, /* MP_BIN (8) */ + /* 0xc5 */ MP_HINT_STR_16, /* MP_BIN (16) */ + /* 0xc6 */ MP_HINT_STR_32, /* MP_BIN (32) */ + /* }}} */ + + /* {{{ MP_EXT */ + /* 0xc7 */ MP_HINT_EXT_8, /* MP_EXT (8) */ + /* 0xc8 */ MP_HINT_EXT_16, /* MP_EXT (16) */ + /* 0xc9 */ MP_HINT_EXT_32, /* MP_EXT (32) */ + /* }}} */ + + /* {{{ MP_FLOAT, MP_DOUBLE */ + /* 0xca */ sizeof(float), /* MP_FLOAT */ + /* 0xcb */ sizeof(double), /* MP_DOUBLE */ + /* }}} */ + + /* {{{ MP_UINT */ + /* 0xcc */ sizeof(uint8_t), /* MP_UINT (8) */ + /* 0xcd */ sizeof(uint16_t), /* MP_UINT (16) */ + /* 0xce */ sizeof(uint32_t), /* MP_UINT (32) */ + /* 0xcf */ sizeof(uint64_t), /* MP_UINT (64) */ + /* }}} */ + + /* {{{ MP_INT */ + /* 0xd0 */ sizeof(uint8_t), /* MP_INT (8) */ + /* 0xd1 */ sizeof(uint16_t), /* MP_INT (8) */ + /* 0xd2 */ sizeof(uint32_t), /* MP_INT (8) */ + /* 0xd3 */ sizeof(uint64_t), /* MP_INT (8) */ + /* }}} */ + + /* {{{ MP_EXT (fixext) */ + /* 0xd4 */ 2, /* MP_EXT (fixext 8) */ + /* 0xd5 */ 3, /* MP_EXT (fixext 16) */ + /* 0xd6 */ 5, /* MP_EXT (fixext 32) */ + /* 0xd7 */ 9, /* MP_EXT (fixext 64) */ + /* 0xd8 */ 17, /* MP_EXT (fixext 128) */ + /* }}} */ + + /* {{{ MP_STR */ + /* 0xd9 */ MP_HINT_STR_8, /* MP_STR (8) */ + /* 0xda */ MP_HINT_STR_16, /* MP_STR (16) */ + /* 0xdb */ MP_HINT_STR_32, /* MP_STR (32) */ + /* }}} */ + + /* {{{ MP_ARRAY */ + /* 0xdc */ MP_HINT_ARRAY_16, /* MP_ARRAY (16) */ + /* 0xdd */ MP_HINT_ARRAY_32, /* MP_ARRAY (32) */ + /* }}} */ + + /* {{{ MP_MAP */ + /* 0xde */ MP_HINT_MAP_16, /* MP_MAP (16) */ + /* 0xdf */ MP_HINT_MAP_32, /* MP_MAP (32) */ + /* }}} */ + + /* {{{ MP_INT (fixed) */ + /* 0xe0 */ 0, + /* 0xe1 */ 0, + /* 0xe2 */ 0, + /* 0xe3 */ 0, + /* 0xe4 */ 0, + /* 0xe5 */ 0, + /* 0xe6 */ 0, + /* 0xe7 */ 0, + /* 0xe8 */ 0, + /* 0xe9 */ 0, + /* 0xea */ 0, + /* 0xeb */ 0, + /* 0xec */ 0, + /* 0xed */ 0, + /* 0xee */ 0, + /* 0xef */ 0, + /* 0xf0 */ 0, + /* 0xf1 */ 0, + /* 0xf2 */ 0, + /* 0xf3 */ 0, + /* 0xf4 */ 0, + /* 0xf5 */ 0, + /* 0xf6 */ 0, + /* 0xf7 */ 0, + /* 0xf8 */ 0, + /* 0xf9 */ 0, + /* 0xfa */ 0, + /* 0xfb */ 0, + /* 0xfc */ 0, + /* 0xfd */ 0, + /* 0xfe */ 0, + /* 0xff */ 0 + /* }}} */ +}; + +const char *mp_char2escape[128] = { + "\\u0000", "\\u0001", "\\u0002", "\\u0003", + "\\u0004", "\\u0005", "\\u0006", "\\u0007", + "\\b", "\\t", "\\n", "\\u000b", + "\\f", "\\r", "\\u000e", "\\u000f", + "\\u0010", "\\u0011", "\\u0012", "\\u0013", + "\\u0014", "\\u0015", "\\u0016", "\\u0017", + "\\u0018", "\\u0019", "\\u001a", "\\u001b", + "\\u001c", "\\u001d", "\\u001e", "\\u001f", + NULL, NULL, "\\\"", NULL, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL, NULL, NULL, NULL, "\\/", + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL, "\\\\", NULL, NULL, NULL, + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL, NULL, NULL, NULL, "\\u007f" +}; + +/* + * This lookup table is used by mp_encode_ext() to + * determine ext code (fixext 1, fixext 2, fixext 4, fixext 8, + * fixext 16) to encode using size. + */ +const uint8_t mp_ext_hint[16] = { + 0xd4, /* 1 */ + 0xd5, /* 2 */ + 0, /* 3 */ + 0xd6, /* 4 */ + 0, /* 5 */ + 0, /* 6 */ + 0, /* 7 */ + 0xd7, /* 8 */ + 0, /* 9 */ + 0, /* 10 */ + 0, /* 11 */ + 0, /* 12 */ + 0, /* 13 */ + 0, /* 14 */ + 0, /* 15 */ + 0xd8 /* 16 */ +}; diff --git a/netdissect.h b/netdissect.h index 24fda9e8aa..311dfe01c9 100644 --- a/netdissect.h +++ b/netdissect.h @@ -304,6 +304,7 @@ nd_trunc_longjmp(netdissect_options *ndo) #define PT_SOMEIP 19 /* Autosar SOME/IP Protocol */ #define PT_DOMAIN 20 /* Domain Name System (DNS) */ #define PT_QUIC 21 /* QUIC */ +#define PT_IPROTO 22 /* Tarantool binary protocol */ #define ND_MIN(a,b) ((a)>(b)?(b):(a)) #define ND_MAX(a,b) ((b)>(a)?(b):(a)) @@ -742,6 +743,7 @@ extern void ssh_print(netdissect_options *, const u_char *, u_int); extern void stp_print(netdissect_options *, const u_char *, u_int); extern void sunrpc_print(netdissect_options *, const u_char *, u_int, const u_char *); extern void syslog_print(netdissect_options *, const u_char *, u_int); +extern void tarantool_print(netdissect_options *, const u_char *, u_int); extern void tcp_print(netdissect_options *, const u_char *, u_int, const u_char *, int); extern void telnet_print(netdissect_options *, const u_char *, u_int); extern void tftp_print(netdissect_options *, const u_char *, u_int); diff --git a/print-tarantool.c b/print-tarantool.c new file mode 100644 index 0000000000..1747820e3e --- /dev/null +++ b/print-tarantool.c @@ -0,0 +1,2086 @@ +/* + * Copyright (c) 2021 The TCPDUMP project + * All rights reserved. + * + * 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 THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 THE + * 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. + * + * Initial contribution by Pavel Balaev (balaev@tarantool.org). + */ + +/* \summary: tarantool binary protocol printer */ + +#include +#include +#ifdef HAVE_CONFIG_H +#include +#endif + +#include "msgpuck.h" +#include "netdissect.h" +#include "netdissect-alloc.h" + +/* + * For information regarding tarantool binary protocol, see: + * https://www.tarantool.io/en/doc/latest/dev_guide/internals/box_protocol/ + */ + +/* IPROTO_FLAGS bitfield constants. */ +enum { + IPROTO_FLAG_COMMIT = 0x01, + IPROTO_FLAG_WAIT_SYNC = 0x02, + IPROTO_FLAG_WAIT_ACK = 0x04, +}; + +/* IPROTO command codes */ +enum request_type { + IPROTO_OK = 0, + IPROTO_SELECT = 1, + IPROTO_INSERT = 2, + IPROTO_REPLACE = 3, + IPROTO_UPDATE = 4, + IPROTO_DELETE = 5, + IPROTO_CALL_16 = 6, + IPROTO_AUTH = 7, + IPROTO_EVAL = 8, + IPROTO_UPSERT = 9, + IPROTO_CALL = 10, + IPROTO_EXECUTE = 11, + IPROTO_NOP = 12, + IPROTO_PREPARE = 13, + IPROTO_BEGIN = 14, + IPROTO_COMMIT = 15, + IPROTO_ROLLBACK = 16, + IPROTO_TYPE_STAT_MAX, + IPROTO_RAFT = 30, + IPROTO_RAFT_PROMOTE = 31, + IPROTO_RAFT_DEMOTE = 32, + IPROTO_RAFT_CONFIRM = 40, + IPROTO_RAFT_ROLLBACK = 41, + IPROTO_PING = 64, + IPROTO_JOIN = 65, + IPROTO_SUBSCRIBE = 66, + IPROTO_VOTE_DEPRECATED = 67, + IPROTO_VOTE = 68, + IPROTO_FETCH_SNAPSHOT = 69, + IPROTO_REGISTER = 70, + IPROTO_JOIN_META = 71, + IPROTO_JOIN_SNAPSHOT = 72, + IPROTO_ID = 73, + IPROTO_WATCH = 74, + IPROTO_UNWATCH = 75, + IPROTO_EVENT = 76, + IPROTO_TYPE_ERROR = 1 << 15 +}; + +enum iproto_key { + IPROTO_REQUEST_TYPE = 0x00, + IPROTO_SYNC = 0x01, + IPROTO_REPLICA_ID = 0x02, + IPROTO_LSN = 0x03, + IPROTO_TIMESTAMP = 0x04, + IPROTO_SCHEMA_VERSION = 0x05, + IPROTO_SERVER_VERSION = 0x06, + IPROTO_GROUP_ID = 0x07, + IPROTO_TSN = 0x08, + IPROTO_FLAGS = 0x09, + IPROTO_STREAM_ID = 0x0a, + IPROTO_SPACE_ID = 0x10, + IPROTO_INDEX_ID = 0x11, + IPROTO_LIMIT = 0x12, + IPROTO_OFFSET = 0x13, + IPROTO_ITERATOR = 0x14, + IPROTO_INDEX_BASE = 0x15, + IPROTO_KEY = 0x20, + IPROTO_TUPLE = 0x21, + IPROTO_FUNCTION_NAME = 0x22, + IPROTO_USER_NAME = 0x23, + IPROTO_INSTANCE_UUID = 0x24, + IPROTO_CLUSTER_UUID = 0x25, + IPROTO_VCLOCK = 0x26, + IPROTO_EXPR = 0x27, + IPROTO_OPS = 0x28, + IPROTO_BALLOT = 0x29, + IPROTO_TUPLE_META = 0x2a, + IPROTO_OPTIONS = 0x2b, + IPROTO_DATA = 0x30, + IPROTO_ERROR_24 = 0x31, + IPROTO_METADATA = 0x32, + IPROTO_BIND_METADATA = 0x33, + IPROTO_BIND_COUNT = 0x34, + IPROTO_SQL_TEXT = 0x40, + IPROTO_SQL_BIND = 0x41, + IPROTO_SQL_INFO = 0x42, + IPROTO_STMT_ID = 0x43, + IPROTO_REPLICA_ANON = 0x50, + IPROTO_ID_FILTER = 0x51, + IPROTO_ERROR = 0x52, + IPROTO_TERM = 0x53, + IPROTO_VERSION = 0x54, + IPROTO_FEATURES = 0x55, + IPROTO_TIMEOUT = 0x56, + IPROTO_EVENT_KEY = 0x57, + IPROTO_EVENT_DATA = 0x58, + IPROTO_KEY_MAX +}; + +enum iproto_metadata_key { + IPROTO_FIELD_NAME = 0, + IPROTO_FIELD_TYPE = 1, + IPROTO_FIELD_COLL = 2, + IPROTO_FIELD_IS_NULLABLE = 3, + IPROTO_FIELD_IS_AUTOINCREMENT = 4, + IPROTO_FIELD_SPAN = 5, +}; + +enum iproto_ballot_key { + IPROTO_BALLOT_IS_RO_CFG = 0x01, + IPROTO_BALLOT_VCLOCK = 0x02, + IPROTO_BALLOT_GC_VCLOCK = 0x03, + IPROTO_BALLOT_IS_RO = 0x04, + IPROTO_BALLOT_IS_ANON = 0x05, + IPROTO_BALLOT_IS_BOOTED = 0x06, + IPROTO_BALLOT_CAN_LEAD = 0x07, +}; + +enum iproto_raft_keys { + IPROTO_RAFT_TERM = 0, + IPROTO_RAFT_VOTE = 1, + IPROTO_RAFT_STATE = 2, + IPROTO_RAFT_VCLOCK = 3, +}; + +enum mp_extension_type { + MP_UNKNOWN_EXTENSION = 0, + MP_DECIMAL = 1, + MP_UUID = 2, + MP_ERROR = 3, + MP_DATETIME = 4, +}; + +static const char *extension_type[] = { + "UNKNOWN_EXTENSION", "DECIMAL", "UUID", "ERROR", "DATETIME" +}; + +static const char *iterator_type[] = { + "EQ", "REQ", "ALL", "LT", "LE", "GE", "GT", + "BITS_ALL_SET", "BITS_ANY_SET", "BITS_ALL_NOT_SET", + "OVERLAPS", "NEIGHBOR" +}; + +static const char *error_codes[] = { + "ER_UNKNOWN", + "ER_ILLEGAL_PARAMS", + "ER_MEMORY_ISSUE", + "ER_TUPLE_FOUND", + "ER_TUPLE_NOT_FOUND", + "ER_UNSUPPORTED", + "ER_NONMASTER", + "ER_READONLY", + "ER_INJECTION", + "ER_CREATE_SPACE", + "ER_SPACE_EXISTS", + "ER_DROP_SPACE", + "ER_ALTER_SPACE", + "ER_INDEX_TYPE", + "ER_MODIFY_INDEX", + "ER_LAST_DROP", + "ER_TUPLE_FORMAT_LIMIT", + "ER_DROP_PRIMARY_KEY", + "ER_KEY_PART_TYPE", + "ER_EXACT_MATCH", + "ER_INVALID_MSGPACK", + "ER_PROC_RET", + "ER_TUPLE_NOT_ARRAY", + "ER_FIELD_TYPE", + "ER_INDEX_PART_TYPE_MISMATCH", + "ER_UPDATE_SPLICE", + "ER_UPDATE_ARG_TYPE", + "ER_FORMAT_MISMATCH_INDEX_PART", + "ER_UNKNOWN_UPDATE_OP", + "ER_UPDATE_FIELD", + "ER_FUNCTION_TX_ACTIVE", + "ER_KEY_PART_COUNT", + "ER_PROC_LUA", + "ER_NO_SUCH_PROC", + "ER_NO_SUCH_TRIGGER", + "ER_NO_SUCH_INDEX_ID", + "ER_NO_SUCH_SPACE", + "ER_NO_SUCH_FIELD_NO", + "ER_EXACT_FIELD_COUNT", + "ER_FIELD_MISSING", + "ER_WAL_IO", + "ER_MORE_THAN_ONE_TUPLE", + "ER_ACCESS_DENIED", + "ER_CREATE_USER", + "ER_DROP_USER", + "ER_NO_SUCH_USER", + "ER_USER_EXISTS", + "ER_PASSWORD_MISMATCH", + "ER_UNKNOWN_REQUEST_TYPE", + "ER_UNKNOWN_SCHEMA_OBJECT", + "ER_CREATE_FUNCTION", + "ER_NO_SUCH_FUNCTION", + "ER_FUNCTION_EXISTS", + "ER_BEFORE_REPLACE_RET", + "ER_MULTISTATEMENT_TRANSACTION", + "ER_TRIGGER_EXISTS", + "ER_USER_MAX", + "ER_NO_SUCH_ENGINE", + "ER_RELOAD_CFG", + "ER_CFG", + "ER_SAVEPOINT_EMPTY_TX", + "ER_NO_SUCH_SAVEPOINT", + "ER_UNKNOWN_REPLICA", + "ER_REPLICASET_UUID_MISMATCH", + "ER_INVALID_UUID", + "ER_REPLICASET_UUID_IS_RO", + "ER_INSTANCE_UUID_MISMATCH", + "ER_REPLICA_ID_IS_RESERVED", + "ER_INVALID_ORDER", + "ER_MISSING_REQUEST_FIELD", + "ER_IDENTIFIER", + "ER_DROP_FUNCTION", + "ER_ITERATOR_TYPE", + "ER_REPLICA_MAX", + "ER_INVALID_XLOG", + "ER_INVALID_XLOG_NAME", + "ER_INVALID_XLOG_ORDER", + "ER_NO_CONNECTION", + "ER_TIMEOUT", + "ER_ACTIVE_TRANSACTION", + "ER_CURSOR_NO_TRANSACTION", + "ER_CROSS_ENGINE_TRANSACTION", + "ER_NO_SUCH_ROLE", + "ER_ROLE_EXISTS", + "ER_CREATE_ROLE", + "ER_INDEX_EXISTS", + "ER_SESSION_CLOSED", + "ER_ROLE_LOOP", + "ER_GRANT", + "ER_PRIV_GRANTED", + "ER_ROLE_GRANTED", + "ER_PRIV_NOT_GRANTED", + "ER_ROLE_NOT_GRANTED", + "ER_MISSING_SNAPSHOT", + "ER_CANT_UPDATE_PRIMARY_KEY", + "ER_UPDATE_INTEGER_OVERFLOW", + "ER_GUEST_USER_PASSWORD", + "ER_TRANSACTION_CONFLICT", + "ER_UNSUPPORTED_PRIV", + "ER_LOAD_FUNCTION", + "ER_FUNCTION_LANGUAGE", + "ER_RTREE_RECT", + "ER_PROC_C", + "ER_UNKNOWN_RTREE_INDEX_DISTANCE_TYPE", + "ER_PROTOCOL", + "ER_UPSERT_UNIQUE_SECONDARY_KEY", + "ER_WRONG_INDEX_RECORD", + "ER_WRONG_INDEX_PARTS", + "ER_WRONG_INDEX_OPTIONS", + "ER_WRONG_SCHEMA_VERSION", + "ER_MEMTX_MAX_TUPLE_SIZE", + "ER_WRONG_SPACE_OPTIONS", + "ER_UNSUPPORTED_INDEX_FEATURE", + "ER_VIEW_IS_RO", + "ER_NO_TRANSACTION", + "ER_SYSTEM", + "ER_LOADING", + "ER_CONNECTION_TO_SELF", + "ER_KEY_PART_IS_TOO_LONG", + "ER_COMPRESSION", + "ER_CHECKPOINT_IN_PROGRESS", + "ER_SUB_STMT_MAX", + "ER_COMMIT_IN_SUB_STMT", + "ER_ROLLBACK_IN_SUB_STMT", + "ER_DECOMPRESSION", + "ER_INVALID_XLOG_TYPE", + "ER_ALREADY_RUNNING", + "ER_INDEX_FIELD_COUNT_LIMIT", + "ER_LOCAL_INSTANCE_ID_IS_READ_ONLY", + "ER_BACKUP_IN_PROGRESS", + "ER_READ_VIEW_ABORTED", + "ER_INVALID_INDEX_FILE", + "ER_INVALID_RUN_FILE", + "ER_INVALID_VYLOG_FILE", + "ER_CASCADE_ROLLBACK", + "ER_VY_QUOTA_TIMEOUT", + "ER_PARTIAL_KEY", + "ER_TRUNCATE_SYSTEM_SPACE", + "ER_LOAD_MODULE", + "ER_VINYL_MAX_TUPLE_SIZE", + "ER_WRONG_DD_VERSION", + "ER_WRONG_SPACE_FORMAT", + "ER_CREATE_SEQUENCE", + "ER_ALTER_SEQUENCE", + "ER_DROP_SEQUENCE", + "ER_NO_SUCH_SEQUENCE", + "ER_SEQUENCE_EXISTS", + "ER_SEQUENCE_OVERFLOW", + "ER_NO_SUCH_INDEX_NAME", + "ER_SPACE_FIELD_IS_DUPLICATE", + "ER_CANT_CREATE_COLLATION", + "ER_WRONG_COLLATION_OPTIONS", + "ER_NULLABLE_PRIMARY", + "ER_NO_SUCH_FIELD_NAME_IN_SPACE", + "ER_TRANSACTION_YIELD", + "ER_NO_SUCH_GROUP", + "ER_SQL_BIND_VALUE", + "ER_SQL_BIND_TYPE", + "ER_SQL_BIND_PARAMETER_MAX", + "ER_SQL_EXECUTE", + "ER_UPDATE_DECIMAL_OVERFLOW", + "ER_SQL_BIND_NOT_FOUND", + "ER_ACTION_MISMATCH", + "ER_VIEW_MISSING_SQL", + "ER_FOREIGN_KEY_CONSTRAINT", + "ER_NO_SUCH_MODULE", + "ER_NO_SUCH_COLLATION", + "ER_CREATE_FK_CONSTRAINT", + "ER_DROP_FK_CONSTRAINT", + "ER_NO_SUCH_CONSTRAINT", + "ER_CONSTRAINT_EXISTS", + "ER_SQL_TYPE_MISMATCH", + "ER_ROWID_OVERFLOW", + "ER_DROP_COLLATION", + "ER_ILLEGAL_COLLATION_MIX", + "ER_SQL_NO_SUCH_PRAGMA", + "ER_SQL_CANT_RESOLVE_FIELD", + "ER_INDEX_EXISTS_IN_SPACE", + "ER_INCONSISTENT_TYPES", + "ER_SQL_SYNTAX_WITH_POS", + "ER_SQL_STACK_OVERFLOW", + "ER_SQL_SELECT_WILDCARD", + "ER_SQL_STATEMENT_EMPTY", + "ER_SQL_KEYWORD_IS_RESERVED", + "ER_SQL_SYNTAX_NEAR_TOKEN", + "ER_SQL_UNKNOWN_TOKEN", + "ER_SQL_PARSER_GENERIC", + "ER_SQL_ANALYZE_ARGUMENT", + "ER_SQL_COLUMN_COUNT_MAX", + "ER_HEX_LITERAL_MAX", + "ER_INT_LITERAL_MAX", + "ER_SQL_PARSER_LIMIT", + "ER_INDEX_DEF_UNSUPPORTED", + "ER_CK_DEF_UNSUPPORTED", + "ER_MULTIKEY_INDEX_MISMATCH", + "ER_CREATE_CK_CONSTRAINT", + "ER_CK_CONSTRAINT_FAILED", + "ER_SQL_COLUMN_COUNT", + "ER_FUNC_INDEX_FUNC", + "ER_FUNC_INDEX_FORMAT", + "ER_FUNC_INDEX_PARTS", + "ER_NO_SUCH_FIELD_NAME", + "ER_FUNC_WRONG_ARG_COUNT", + "ER_BOOTSTRAP_READONLY", + "ER_SQL_FUNC_WRONG_RET_COUNT", + "ER_FUNC_INVALID_RETURN_TYPE", + "ER_SQL_PARSER_GENERIC_WITH_POS", + "ER_REPLICA_NOT_ANON", + "ER_CANNOT_REGISTER", + "ER_SESSION_SETTING_INVALID_VALUE", + "ER_SQL_PREPARE", + "ER_WRONG_QUERY_ID", + "ER_SEQUENCE_NOT_STARTED", + "ER_NO_SUCH_SESSION_SETTING", + "ER_UNCOMMITTED_FOREIGN_SYNC_TXNS", + "ER_SYNC_MASTER_MISMATCH", + "ER_SYNC_QUORUM_TIMEOUT", + "ER_SYNC_ROLLBACK", + "ER_TUPLE_METADATA_IS_TOO_BIG", + "ER_XLOG_GAP", + "ER_TOO_EARLY_SUBSCRIBE", + "ER_SQL_CANT_ADD_AUTOINC", + "ER_QUORUM_WAIT", + "ER_INTERFERING_PROMOTE", + "ER_ELECTION_DISABLED", + "ER_TXN_ROLLBACK", + "ER_NOT_LEADER", + "ER_SYNC_QUEUE_UNCLAIMED", + "ER_SYNC_QUEUE_FOREIGN", + "ER_UNABLE_TO_PROCESS_IN_STREAM", + "ER_UNABLE_TO_PROCESS_OUT_OF_STREAM", + "ER_TRANSACTION_TIMEOUT", + "ER_ACTIVE_TIMER", + "ER_TUPLE_FIELD_COUNT_LIMIT" +}; + +enum error_keys { + MP_ERROR_TYPE = 0x00, + MP_ERROR_FILE = 0x01, + MP_ERROR_LINE = 0x02, + MP_ERROR_MESSAGE = 0x03, + MP_ERROR_ERRNO = 0x04, + MP_ERROR_CODE = 0x05, + MP_ERROR_FIELDS = 0x06, +}; + +enum system_space_id { + BOX_VINYL_DEFERRED_DELETE_ID = 257, + BOX_SCHEMA_ID = 272, + BOX_COLLATION_ID = 276, + BOX_VCOLLATION_ID = 277, + BOX_SPACE_ID = 280, + BOX_VSPACE_ID = 281, + BOX_SEQUENCE_ID = 284, + BOX_SEQUENCE_DATA_ID = 285, + BOX_VSEQUENCE_ID = 286, + BOX_INDEX_ID = 288, + BOX_VINDEX_ID = 289, + BOX_FUNC_ID = 296, + BOX_VFUNC_ID = 297, + BOX_USER_ID = 304, + BOX_VUSER_ID = 305, + BOX_PRIV_ID = 312, + BOX_VPRIV_ID = 313, + BOX_CLUSTER_ID = 320, + BOX_TRIGGER_ID = 328, + BOX_TRUNCATE_ID = 330, + BOX_SPACE_SEQUENCE_ID = 340, + BOX_FK_CONSTRAINT_ID = 356, + BOX_CK_CONSTRAINT_ID = 364, + BOX_FUNC_INDEX_ID = 372, + BOX_SESSION_SETTINGS_ID = 380, + BOX_SYSTEM_ID_MAX = 511, +}; + +/* must be sorted by id */ +static struct space { + enum system_space_id id; + const char *name; +} system_spaces[] = { + { BOX_VINYL_DEFERRED_DELETE_ID, "_vinyl_deferred_delete" }, + { BOX_SCHEMA_ID, "_schema" }, + { BOX_COLLATION_ID, "_collation" }, + { BOX_VCOLLATION_ID, "_vcollation" }, + { BOX_SPACE_ID, "_space" }, + { BOX_VSPACE_ID, "_vspace" }, + { BOX_SEQUENCE_ID, "_sequence" }, + { BOX_SEQUENCE_DATA_ID, "_sequence_data" }, + { BOX_VSEQUENCE_ID, "_vsequence" }, + { BOX_INDEX_ID, "_index" }, + { BOX_VINDEX_ID, "_vindex" }, + { BOX_FUNC_ID, "_func" }, + { BOX_VFUNC_ID, "_vfunc" }, + { BOX_USER_ID, "_user" }, + { BOX_VUSER_ID, "_vuser" }, + { BOX_PRIV_ID, "_priv" }, + { BOX_VPRIV_ID, "_vpriv" }, + { BOX_CLUSTER_ID, "_cluster" }, + { BOX_TRIGGER_ID, "_trigger" }, + { BOX_TRUNCATE_ID, "_truncate" }, + { BOX_SPACE_SEQUENCE_ID, "_space_sequence" }, + { BOX_FK_CONSTRAINT_ID, "_fk_constraint" }, + { BOX_CK_CONSTRAINT_ID, "_ck_constraint" }, + { BOX_FUNC_INDEX_ID, "_func_index" }, + { BOX_SESSION_SETTINGS_ID, "_session_settings" } +}; + +enum { UUID_STR_LEN = 36 }; + +struct uuid { + uint32_t time_low; + uint16_t time_mid; + uint16_t time_hi_and_version; + uint8_t clock_seq_hi_and_reserved; + uint8_t clock_seq_low; + uint8_t node[6]; +}; + +const char *get_time(netdissect_options *ndo, double ts); + +static inline int +uuid_validate(struct uuid *uu) +{ + /* Check variant (NCS, RFC4122, MSFT) */ + uint8_t n = uu->clock_seq_hi_and_reserved; + if ((n & 0x80) != 0x00 && (n & 0xc0) != 0x80 && (n & 0xe0) != 0xc0) { + return 1; + } + + return 0; +} + +static inline void +uuid_to_string(const struct uuid *uu, char *out) +{ + snprintf(out, UUID_STR_LEN + 1, + "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", + uu->time_low, uu->time_mid, uu->time_hi_and_version, + uu->clock_seq_hi_and_reserved, uu->clock_seq_low, uu->node[0], + uu->node[1], uu->node[2], uu->node[3], uu->node[4], uu->node[5]); +} + +static struct uuid * +uuid_unpack(const char **data, struct uuid *uuid) +{ + const char *const svp = *data; + + uuid->time_low = mp_load_u32(data); + uuid->time_mid = mp_load_u16(data); + uuid->time_hi_and_version = mp_load_u16(data); + uuid->clock_seq_hi_and_reserved = mp_load_u8(data); + uuid->clock_seq_low = mp_load_u8(data); + + for (int i = 0; i < 6; i++) { + uuid->node[i] = mp_load_u8(data); + } + + if (uuid_validate(uuid) != 0) { + *data = svp; + return NULL; + } + return uuid; +} + +#define DECIMAL_MAX_DIGITS 38 +#define DECIMAL_MAX_STR_LEN DECIMAL_MAX_DIGITS + 14 + +static int +decimal_unpack(const char **data, uint32_t len, char *res) +{ + int32_t scale, digits = 0; + const char *const svp = *data; + const char last_byte = (*data)[len - 1]; + uint8_t sign = last_byte & 0x0f; + + if (mp_typeof(**data) == MP_UINT) { + scale = mp_decode_uint(data); + } else if (mp_typeof(**data) == MP_INT) { + scale = mp_decode_int(data); + } else { + return 1; + } + + if (scale > DECIMAL_MAX_DIGITS || scale <= -DECIMAL_MAX_DIGITS) { + *data = svp; + return 1; + } + + len -= *data - svp; + + for (uint32_t n = 0; n < len; n++) { + uint8_t high_nibble = (*data)[n]; + uint8_t low_nibble = high_nibble; + + high_nibble >>= 4; + low_nibble &= 0x0f; + + sprintf(res + digits, "%u", high_nibble); + digits++; + + if (!(strlen(res) == 0 && low_nibble == 0) && n != len - 1) { + sprintf(res + digits, "%u", low_nibble); + digits++; + } + } + + /* Add missing zeros when scale is less than current length. */ + if (scale >= digits) { + char zeroes[DECIMAL_MAX_STR_LEN] = {0}; + int32_t z = 0; + + for (; z <= scale - digits; z++) { + sprintf(zeroes + z, "%d", 0); + } + memmove(res + z, res, digits); + memcpy(res, zeroes, z); + } + + /* Add a dot when number is fractional. */ + if (scale != 0) { + size_t res_len = strlen(res); + size_t shift = res_len - scale; + memmove(res + shift + 1, res + shift, scale); + res[shift] = '.'; + } + + /* Add a sign, it is encoded in a low nibble of a last byte */ + if (sign == 0x0d || sign == 0x0b) { + memmove(res + 1, res, strlen(res)); + res[0] = '-'; + } + + return 0; +} + +static int snprint_error(const char **msg, char *buf, int size); + +static int +snprint_ext_custom(char *buf, int size, const char **data, int depth) +{ + (void) depth; + int8_t type; + uint32_t len; + const char *ext = mp_decode_ext(data, &type, &len); + + switch (type) { + case MP_UUID: + { + struct uuid uuid = {0}; + char uuid_out[UUID_STR_LEN + 1] = {0}; + + if (uuid_unpack(&ext, &uuid) == NULL) { + memcpy(uuid_out, "corrupted", 9); + } else { + uuid_to_string(&uuid, uuid_out); + } + + return snprintf(buf, size, "(UUID: %s)", uuid_out); + } + case MP_ERROR: + return snprint_error(&ext, buf, size); + case MP_DECIMAL: + { + char dec_str[DECIMAL_MAX_STR_LEN + 1] = {0}; + + if (decimal_unpack(&ext, len, dec_str) != 0) { + memcpy(dec_str, "Error", 5); + } + return snprintf(buf, size, "(Decimal: %s)", dec_str); + } + case MP_DATETIME: + return snprintf(buf, size, "(Datetime: len %u)", len); + } + + return snprintf(buf, size, "(extension: type %d, len %u)", (int)type, + (unsigned)len); +} + +static int space_compar(const void *s1, const void *s2) +{ + const struct space *sp1 = s1; + const struct space *sp2 = s2; + + if (sp1->id == sp2->id) { + return 0; + } + + return (sp1->id < sp2->id) ? -1 : 1; +} + +#define TIME_BUF_LEN 32 + +/* timestamp returns from libev by ev_now() in double data */ +const char *get_time(netdissect_options *ndo, double ts) +{ + char buf[10] = {0}; + struct tm time; + time_t t = ts; + char *res, *p; + double fract; + size_t len; + + if ((localtime_r(&t, &time)) != &time) { + return NULL; + } + + if ((res = nd_malloc(ndo, TIME_BUF_LEN)) == NULL) { + return NULL; + } + p = res; + memset(res, 0, TIME_BUF_LEN); + + if (!strftime(res, TIME_BUF_LEN, "%Y-%m-%d %H:%M:%S", &time)) { + return NULL; + } + + len = strlen(res); + p += len; + fract = ts - t; + snprintf(buf, sizeof(buf), "%lf", fract); + snprintf(p, TIME_BUF_LEN - len, "%s", buf + 1); + + return res; +} + +#define GR_NAME "Tarantool" +#define GR_MAXLEN 64 +#define ARR_LEN(p) (sizeof(p) / sizeof((p)[0])) +#define ND_PRINT_ERR_MPTYPE() (ndo->ndo_printf)(ndo, " unexpected MsgPack type") + +typedef struct { + uint64_t key; + union { + uint64_t val; + double val_d; + } u; +} kv_t; + +#define GEN_REQ(req) \ + static void parse_ ## req(netdissect_options *ndo, const char *msg, \ + const kv_t *kv, size_t kv_len); + +#define GEN_REQ_FUNC(req, name) \ +static void parse_ ## req(netdissect_options *ndo, const char *msg, \ + const kv_t *kv, size_t kv_len) \ +{ \ + double timestamp = 0; \ + uint64_t sync = 0, lsn = 0, rid = 0, flags = 0; \ + \ + for (size_t n = 0; n < kv_len; n++) { \ + switch (kv[n].key) { \ + case IPROTO_SYNC: \ + sync = kv[n].u.val; \ + break; \ + case IPROTO_LSN: \ + lsn = kv[n].u.val; \ + break; \ + case IPROTO_REPLICA_ID: \ + rid = kv[n].u.val; \ + break; \ + case IPROTO_FLAGS: \ + flags = kv[n].u.val; \ + break; \ + case IPROTO_TIMESTAMP: \ + timestamp = kv[n].u.val_d; \ + break; \ + } \ + } \ + \ + ND_PRINT(" request: %s, SYNC: %" PRIu64, #name, sync); \ + if (rid) { \ + ND_PRINT(", REPLICA_ID: %" PRIu64, rid); \ + } \ + if (lsn) { \ + ND_PRINT(", LSN: %" PRIu64, lsn); \ + } \ + if (timestamp) { \ + const char *time = get_time(ndo, timestamp); \ + ND_PRINT(", TIMESTAMP: %s", (time) ? time : "NULL"); \ + } \ + if (flags) { \ + ND_PRINT(", FLAGS: %" PRIu64, flags); \ + } \ + \ + if (ndo->ndo_vflag == 0) { \ + return; \ + } \ + \ + parse_body(ndo, msg); \ +} + +#define GEN_NOBODY_REQ_FUNC(req, name) \ +static void parse_ ## req(netdissect_options *ndo, const char *msg, \ + const kv_t *kv, size_t kv_len) \ +{ \ + uint64_t sync = 0; \ + (void) msg; \ + \ + for (size_t n = 0; n < kv_len; n++) { \ + switch (kv[n].key) { \ + case IPROTO_SYNC: \ + sync = kv[n].u.val; \ + break; \ + } \ + } \ + \ + ND_PRINT(" request: %s, SYNC: %" PRIu64, #name, sync); \ +} + +#define GEN_TRANS_REQ_FUNC(req, name) \ +static void parse_ ## req(netdissect_options *ndo, const char *msg, \ + const kv_t *kv, size_t kv_len) \ +{ \ + uint64_t sync, id; \ + (void) msg; \ + \ + sync = id = 0; \ + \ + for (size_t n = 0; n < kv_len; n++) { \ + switch (kv[n].key) { \ + case IPROTO_SYNC: \ + sync = kv[n].u.val; \ + break; \ + case IPROTO_STREAM_ID: \ + id = kv[n].u.val; \ + break; \ + default: \ + goto out; \ + } \ + } \ + \ + ND_PRINT(" request: %s, STREAM_ID: %" PRIu64 ", SYNC: %" PRIu64, \ + #name, id, sync); \ + \ + return; \ +out: \ + nd_print_invalid(ndo); \ +} + +typedef void (*request_print_t)(netdissect_options *ndo, const char *msg, + const kv_t *kv, size_t kv_len); + +GEN_REQ(ok) +GEN_REQ(id) +GEN_REQ(eval) +GEN_REQ(ping) +GEN_REQ(select) +GEN_REQ(insert) +GEN_REQ(update) +GEN_REQ(replace) +GEN_REQ(delete) +GEN_REQ(call) +GEN_REQ(call16) +GEN_REQ(auth) +GEN_REQ(upsert) +GEN_REQ(execute) +GEN_REQ(nop) +GEN_REQ(prepare) +GEN_REQ(begin) +GEN_REQ(commit) +GEN_REQ(rollback) +GEN_REQ(vote) +GEN_REQ(join) +GEN_REQ(subscribe) +GEN_REQ(join_meta) +GEN_REQ(join_snapshot) +GEN_REQ(raft) +GEN_REQ(raft_promote) +GEN_REQ(raft_confirm) +GEN_REQ(error) + +#define CASE_IPROTO_STR(param) \ + case IPROTO_ ## param: \ + { \ + const char *func; \ + \ + if (mp_typeof(*msg) != MP_STR) { \ + ND_PRINT_ERR_MPTYPE(); \ + goto out; \ + } \ + \ + func = get_string(ndo, msg); \ + if (func) { \ + ND_PRINT("\n%s: %s", #param, func); \ + } \ + mp_next(&msg); \ + } \ + break; + +#define CASE_IPROTO_UINT(param) \ + case IPROTO_ ## param: \ + if (mp_typeof(*msg) != MP_UINT) { \ + ND_PRINT_ERR_MPTYPE(); \ + goto out; \ + } \ + ND_PRINT("\n%s: %" PRIu64, #param, mp_decode_uint(&msg)); \ + break; + +#define CASE_IPROTO_ARRAY(param) \ + case IPROTO_ ## param: \ + if (mp_typeof(*msg) != MP_ARRAY) { \ + ND_PRINT_ERR_MPTYPE(); \ + goto out; \ + } \ + \ + ND_PRINT("\n%s: %s", #param, get_all_data(ndo, msg)); \ + mp_next(&msg); \ + break; \ + +#define CASE_IPROTO_MAP(param) \ + case IPROTO_ ## param: \ + if (mp_typeof(*msg) != MP_MAP) { \ + ND_PRINT_ERR_MPTYPE(); \ + goto out; \ + } \ + ND_PRINT("\n%s: %s", #param, get_all_data(ndo, msg)); \ + mp_next(&msg); \ + break; + +#define CASE_IPROTO_BOOL(param) \ + case IPROTO_ ## param: \ + if (mp_typeof(*msg) != MP_BOOL) { \ + ND_PRINT_ERR_MPTYPE(); \ + goto out; \ + } \ + ND_PRINT("\n%s: %s", #param, \ + mp_decode_bool(&msg) ? "true" : "false"); \ + break; + +/* must be sorted by type */ +static struct request { + enum request_type type; + request_print_t print; +} request_ops[] = { + { .type = IPROTO_OK, .print = parse_ok }, + { .type = IPROTO_SELECT, .print = parse_select }, + { .type = IPROTO_INSERT, .print = parse_insert }, + { .type = IPROTO_REPLACE, .print = parse_replace }, + { .type = IPROTO_UPDATE, .print = parse_update }, + { .type = IPROTO_DELETE, .print = parse_delete }, + { .type = IPROTO_CALL_16, .print = parse_call16 }, + { .type = IPROTO_AUTH, .print = parse_auth }, + { .type = IPROTO_EVAL, .print = parse_eval }, + { .type = IPROTO_UPSERT, .print = parse_upsert }, + { .type = IPROTO_CALL, .print = parse_call }, + { .type = IPROTO_EXECUTE, .print = parse_execute }, + { .type = IPROTO_NOP, .print = parse_nop }, + { .type = IPROTO_PREPARE, .print = parse_prepare }, + { .type = IPROTO_BEGIN, .print = parse_begin }, + { .type = IPROTO_COMMIT, .print = parse_commit }, + { .type = IPROTO_ROLLBACK, .print = parse_rollback }, + { .type = IPROTO_RAFT, .print = parse_raft }, + { .type = IPROTO_RAFT_PROMOTE, .print = parse_raft_promote }, + { .type = IPROTO_RAFT_CONFIRM, .print = parse_raft_confirm }, + { .type = IPROTO_PING, .print = parse_ping }, + { .type = IPROTO_JOIN, .print = parse_join }, + { .type = IPROTO_SUBSCRIBE, .print = parse_subscribe }, + { .type = IPROTO_VOTE, .print = parse_vote }, + { .type = IPROTO_JOIN_META, .print = parse_join_meta }, + { .type = IPROTO_JOIN_SNAPSHOT, .print = parse_join_snapshot }, + { .type = IPROTO_ID, .print = parse_id }, + { .type = IPROTO_TYPE_ERROR, .print = parse_error } +}; + +static int request_compar(const void *r1, const void *r2) +{ + const struct request *re1 = r1; + const struct request *re2 = r2; + + if (re1->type == re2->type) { + return 0; + } + + return (re1->type < re2->type) ? -1 : 1; +} + +static char *get_all_data(netdissect_options *ndo, const char *msg) +{ + int len = mp_snprint(NULL, 0, msg); + char *data = NULL; + + if (len > 0) { + len++; /* '\0' */ + + data = nd_malloc(ndo, len); + if (!data) { + return NULL; + } + mp_snprint(data, len, msg); + } + + return data; +} + +static char *get_string(netdissect_options *ndo, const char *msg) +{ + const char *str; + uint32_t len; + char *res; + + str = mp_decode_str(&msg, &len); + res = (char *)nd_malloc(ndo, len + 1); + if (!res) { + return NULL; + } + memcpy(res, str, len); + res[len] = '\0'; + + return res; +} + +static int snprint_error(const char **msg, char *buf, int size) +{ + int n = 0; + uint32_t stack_size; + int wlen = 0; + char *tmpbuf = NULL; + const char *err_ext = "(ERROR: "; + size_t err_ext_len = strlen(err_ext); + + if (buf != NULL) { + tmpbuf = calloc(1, size); + } + + if (!tmpbuf && buf) { + return snprintf(buf, size, "(Error: ENOMEM)"); + } + + if (mp_typeof(**msg) != MP_MAP) { + goto err_exit; + } + + if (mp_decode_map(msg) != 1) { + goto err_exit; + } + + if (mp_typeof(**msg) != MP_UINT) { + goto err_exit; + } + + if (mp_decode_uint(msg) != 0) { /* MP_ERROR_STACK */ + goto err_exit; + } + + if (mp_typeof(**msg) != MP_ARRAY) { + goto err_exit; + } + + stack_size = mp_decode_array(msg); + + if (buf != NULL) { + memcpy(tmpbuf + wlen, err_ext, err_ext_len); + } + wlen += err_ext_len; + + for (uint32_t s = 0; s < stack_size; s++) { + uint32_t map_items = mp_decode_map(msg); + + if (buf != NULL) { + memcpy(tmpbuf + wlen, "[", 1); + } + wlen++; + + for (uint32_t i = 0; i < map_items; i++) { + if (mp_typeof(**msg) != MP_UINT) { + goto err_exit; + } + uint64_t err_key = mp_decode_uint(msg); + + switch (err_key) { + case MP_ERROR_TYPE: + { + const char *type; + const char *info = "{ \"type\": \""; + size_t info_len = strlen(info); + uint32_t len; + + if (mp_typeof(**msg) != MP_STR) { + goto err_exit; + } + + type = mp_decode_str(msg, &len); + if (type != NULL) { + if (buf != NULL) { + memcpy(tmpbuf + wlen, info, info_len); + memcpy(tmpbuf + wlen + info_len, type, len); + memcpy(tmpbuf + wlen + info_len + len, "\"", 1); + } + wlen += (len + info_len + 1); + } + } + break; + case MP_ERROR_FILE: + { + const char *type; + const char *info = ", \"file\": \""; + size_t info_len = strlen(info); + uint32_t len; + + if (mp_typeof(**msg) != MP_STR) { + goto err_exit; + } + + type = mp_decode_str(msg, &len); + if (type != NULL) { + if (buf != NULL) { + memcpy(tmpbuf + wlen, info, info_len); + memcpy(tmpbuf + wlen + info_len, type, len); + memcpy(tmpbuf + wlen + info_len + len, "\"", 1); + } + wlen += (len + info_len + 1); + } + } + break; + case MP_ERROR_MESSAGE: + { + const char *type; + const char *info = ", \"message\": \""; + size_t info_len = strlen(info); + uint32_t len; + + if (mp_typeof(**msg) != MP_STR) { + goto err_exit; + } + + type = mp_decode_str(msg, &len); + if (type != NULL) { + if (buf != NULL) { + memcpy(tmpbuf + wlen, info, info_len); + memcpy(tmpbuf + wlen + info_len, type, len); + memcpy(tmpbuf + wlen + info_len + len, "\"", 1); + } + wlen += (len + info_len + 1); + } + } + break; + case MP_ERROR_LINE: + { + uint64_t num; + size_t num_len; + char num_buf[32] = {0}; + + if (mp_typeof(**msg) != MP_UINT) { + goto err_exit; + } + num = mp_decode_uint(msg); + snprintf(num_buf, sizeof(num_buf), + ", \"line\": %" PRIu64, num); + num_len = strlen(num_buf); + if (buf != NULL) { + memcpy(tmpbuf + wlen, num_buf, num_len); + } + wlen += num_len; + } + break; + case MP_ERROR_CODE: + { + uint64_t num; + size_t num_len; + char num_buf[32] = {0}; + + if (mp_typeof(**msg) != MP_UINT) { + goto err_exit; + } + num = mp_decode_uint(msg); + snprintf(num_buf, sizeof(num_buf), + ", \"code\": %" PRIu64 " }", num); + num_len = strlen(num_buf); + if (buf != NULL) { + memcpy(tmpbuf + wlen, num_buf, num_len); + } + wlen += num_len; + } + break; + case MP_ERROR_ERRNO: + { + uint64_t num; + size_t num_len; + char num_buf[32] = {0}; + + if (mp_typeof(**msg) != MP_UINT) { + goto err_exit; + } + num = mp_decode_uint(msg); + snprintf(num_buf, sizeof(num_buf), + ", \"errno\": %" PRIu64, num); + num_len = strlen(num_buf); + if (buf != NULL) { + memcpy(tmpbuf + wlen, num_buf, num_len); + } + wlen += num_len; + } + break; + case MP_ERROR_FIELDS: + { + if (mp_typeof(**msg) != MP_MAP) { + goto err_exit; + } + const char *fields_msg = ", \"fields\": {"; + size_t fields_len = strlen(fields_msg); + uint32_t fields = mp_decode_map(msg); + + if (buf != NULL && fields) { + memcpy(tmpbuf + wlen, fields_msg, fields_len); + } + + if (fields) { + wlen += fields_len; + } + + for (size_t f = 0; f < fields; f++) { + uint32_t len, val_len; + const char *k, *v; + + if (mp_typeof(**msg) != MP_STR) { + goto err_exit; + } + + k = mp_decode_str(msg, &len); + v = *msg; + mp_next(msg); + val_len = *msg - v; + + if (mp_typeof(*v) == MP_STR) { + v++; + val_len--; + } + + if (k && v && buf != NULL) { + memcpy(tmpbuf + wlen, " \"", 2); + memcpy(tmpbuf + wlen + 2, k, len); + memcpy(tmpbuf + wlen + 2 + len, "\": ", 3); + memcpy(tmpbuf + wlen + 5 + len, v, val_len); + memcpy(tmpbuf + wlen + 5 + len + val_len, + (f != fields - 1) ? "," : " ", 1); + } + + if (k && v) { + wlen += len + val_len + 6; + } + } + + if (buf != NULL && fields) { + memcpy(tmpbuf + wlen, "}", 1); + } + if (fields) { + wlen++; + } + } + break; + default: + mp_next(msg); + } + } + + if (buf != NULL) { + memcpy(tmpbuf + wlen, "]", 1); + } + wlen++; + } + + if (buf != NULL) { + memcpy(tmpbuf + wlen, ")", 1); + } + wlen++; + + if (buf != NULL) { + n = snprintf(buf, size, "%s", tmpbuf); + free(tmpbuf); + } else { + n = wlen; + } + return n; + +err_exit: + if (buf != NULL) { + free(tmpbuf); + return snprintf(buf, size, "(Error: incorrect message)"); + } else { + return strlen("(Error: incorrect message)"); + } +} + +/* format: {0: [{}]} */ +static void print_error(netdissect_options *ndo, const char **msg) +{ + uint32_t stack_size; + + if (!msg) { + return; + } + + if (mp_typeof(**msg) != MP_MAP) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + if (mp_decode_map(msg) != 1) { + goto out; + } + + if (mp_typeof(**msg) != MP_UINT) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + if (mp_decode_uint(msg) != 0) { /* MP_ERROR_STACK */ + goto out; + } + + if (mp_typeof(**msg) != MP_ARRAY) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + stack_size = mp_decode_array(msg); + for (uint32_t s = 0; s < stack_size; s++) { + uint32_t map_items = mp_decode_map(msg); + + if (map_items && s != 0) { + ND_PRINT("\n---"); + } + + for (uint32_t i = 0; i < map_items; i++) { + uint64_t err_key; + + if (mp_typeof(**msg) != MP_UINT) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + err_key = mp_decode_uint(msg); + switch (err_key) { + case MP_ERROR_TYPE: + { + const char *type; + + if (mp_typeof(**msg) != MP_STR) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + type = get_string(ndo, *msg); + if (type) { + ND_PRINT("\nTYPE: %s", type); + } + mp_next(msg); + } + break; + case MP_ERROR_FILE: + { + const char *file; + + if (mp_typeof(**msg) != MP_STR) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + file = get_string(ndo, *msg); + if (file) { + ND_PRINT("\nFILE: %s", file); + } + mp_next(msg); + } + break; + case MP_ERROR_LINE: + if (mp_typeof(**msg) != MP_UINT) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + ND_PRINT("\nLINE: %" PRIu64, mp_decode_uint(msg)); + break; + case MP_ERROR_MESSAGE: + { + const char *message; + + if (mp_typeof(**msg) != MP_STR) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + message = get_string(ndo, *msg); + if (message) { + ND_PRINT("\nMESSAGE: %s", message); + } + mp_next(msg); + } + break; + case MP_ERROR_ERRNO: + if (mp_typeof(**msg) != MP_UINT) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + ND_PRINT("\nERRNO: %" PRIu64, mp_decode_uint(msg)); + break; + case MP_ERROR_CODE: + if (mp_typeof(**msg) != MP_UINT) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + ND_PRINT("\nCODE: %" PRIu64, mp_decode_uint(msg)); + break; + case MP_ERROR_FIELDS: + { + uint32_t fields = mp_decode_map(msg); + + if (fields) { + ND_PRINT("\nFIELDS:"); + } + + for (size_t f = 0; f < fields; f++) { + const char *k, *v; + + if (mp_typeof(**msg) != MP_STR) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + k = get_string(ndo, *msg); + mp_next(msg); + v = get_string(ndo, *msg); + mp_next(msg); + + if (k && v) { + ND_PRINT(" %s: %s%s", k, v, + (f != fields - 1) ? "," : ""); + } + } + } + break; + } + } + } + return; +out: + nd_print_invalid(ndo); +} + +static void parse_body(netdissect_options *ndo, const char *msg) +{ + uint32_t body_items; + + if (mp_typeof(*msg) != MP_MAP) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + body_items = mp_decode_map(&msg); + + for (uint32_t n = 0; n < body_items; n++) { + uint64_t key; + + if (mp_typeof(*msg) != MP_UINT) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + key = mp_decode_uint(&msg); + switch (key) { + case IPROTO_SPACE_ID: + { + uint64_t sid; + + if (mp_typeof(*msg) != MP_UINT) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + sid = mp_decode_uint(&msg); + if (sid >= BOX_SYSTEM_ID_MAX) { + ND_PRINT("\nSPACE_ID: %" PRIu64, sid); + } else { + struct space sp = { .id = sid }; + struct space *res; + + res = bsearch(&sp, system_spaces, ARR_LEN(system_spaces), + sizeof(struct space), space_compar); + if (res) { + ND_PRINT("\nSPACE: %s (ID: %" PRIu64 ")", + res->name, sid); + } else { + ND_PRINT("\nSPACE_ID: %" PRIu64, sid); + } + } + } + break; + case IPROTO_ITERATOR: + { + uint64_t it; + + if (mp_typeof(*msg) != MP_UINT) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + it = mp_decode_uint(&msg); + + ND_PRINT("\nITERATOR: %s", (it >= ARR_LEN(iterator_type)) ? + "unknown" : iterator_type[it]); + } + break; + case IPROTO_BALLOT: + { + uint32_t ballot_items; + + if (mp_typeof(*msg) != MP_MAP) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + ballot_items = mp_decode_map(&msg); + if (ballot_items) { + ND_PRINT("\n[BALLOT]"); + } + for (uint32_t b = 0; b < ballot_items; b++) { + uint64_t bkey; + + if (mp_typeof(*msg) != MP_UINT) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + bkey = mp_decode_uint(&msg); + switch (bkey) { + CASE_IPROTO_BOOL(BALLOT_IS_RO_CFG); + CASE_IPROTO_BOOL(BALLOT_IS_RO); + CASE_IPROTO_BOOL(BALLOT_IS_ANON); + CASE_IPROTO_BOOL(BALLOT_IS_BOOTED); + CASE_IPROTO_BOOL(BALLOT_CAN_LEAD); + CASE_IPROTO_MAP(BALLOT_VCLOCK); + CASE_IPROTO_MAP(BALLOT_GC_VCLOCK); + } + } + } + break; + case IPROTO_DATA: + { + uint32_t data_items; + + if (mp_typeof(*msg) != MP_ARRAY) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + data_items = mp_decode_array(&msg); + if (data_items) { + ND_PRINT("\nDATA:"); + } + for (uint32_t d = 0; d < data_items; d++) { + switch (mp_typeof(*msg)) { + case MP_EXT: + { + int8_t type; + uint32_t len; + const char *ext = mp_decode_ext(&msg, &type, &len); + uint8_t idx = type; + ND_PRINT("\nEXTENSION: type %s [%d], len %u", + (idx >= ARR_LEN(extension_type)) ? + "UNKNOWN" : extension_type[idx], + type, len); + switch (type) { + case MP_ERROR: + print_error(ndo, &ext); + break; + } + break; + } + default: + ND_PRINT("\n%s", get_all_data(ndo, msg)); + mp_next(&msg); + break; + } + } + } + break; + CASE_IPROTO_STR(INSTANCE_UUID); + CASE_IPROTO_STR(CLUSTER_UUID); + CASE_IPROTO_STR(FUNCTION_NAME); + CASE_IPROTO_STR(USER_NAME); + CASE_IPROTO_STR(SQL_TEXT); + CASE_IPROTO_STR(EXPR); + CASE_IPROTO_MAP(VCLOCK); + CASE_IPROTO_UINT(SERVER_VERSION); + CASE_IPROTO_UINT(VERSION); + CASE_IPROTO_UINT(BIND_COUNT); + CASE_IPROTO_UINT(INDEX_ID); + CASE_IPROTO_UINT(INDEX_BASE); + CASE_IPROTO_UINT(STMT_ID); + CASE_IPROTO_UINT(OFFSET); + CASE_IPROTO_UINT(LIMIT); + CASE_IPROTO_UINT(REPLICA_ID); + CASE_IPROTO_UINT(LSN); + CASE_IPROTO_UINT(TERM); + CASE_IPROTO_BOOL(REPLICA_ANON); + CASE_IPROTO_ARRAY(FEATURES); + CASE_IPROTO_ARRAY(METADATA); + CASE_IPROTO_ARRAY(BIND_METADATA); + CASE_IPROTO_ARRAY(KEY); + CASE_IPROTO_ARRAY(TUPLE); + CASE_IPROTO_ARRAY(OPS); + CASE_IPROTO_ARRAY(OPTIONS); + CASE_IPROTO_ARRAY(SQL_BIND); + CASE_IPROTO_ARRAY(ID_FILTER); + default: + ND_PRINT("\n_UNKNOWN_"); + mp_next(&msg); + } + } + + return; +out: + nd_print_invalid(ndo); +} + +GEN_REQ_FUNC(prepare, PREPARE) +GEN_REQ_FUNC(call, CALL) +GEN_REQ_FUNC(call16, CALL_16) +GEN_REQ_FUNC(id, ID) +GEN_REQ_FUNC(delete, DELETE) +GEN_REQ_FUNC(replace, REPLACE) +GEN_REQ_FUNC(upsert, UPSERT) +GEN_REQ_FUNC(update, UPDATE) +GEN_REQ_FUNC(auth, AUTH) +GEN_REQ_FUNC(execute, EXECUTE) +GEN_REQ_FUNC(insert, INSERT) +GEN_REQ_FUNC(select, SELECT) +GEN_REQ_FUNC(eval, EVAL) +GEN_REQ_FUNC(join, JOIN) +GEN_REQ_FUNC(subscribe, SUBSCRIBE) +GEN_REQ_FUNC(join_meta, JOIN_META) +GEN_REQ_FUNC(raft_promote, RAFT_PROMOTE) +GEN_REQ_FUNC(raft_confirm, RAFT_CONFIRM) +GEN_NOBODY_REQ_FUNC(ping, PING) +GEN_NOBODY_REQ_FUNC(nop, NOP) +GEN_NOBODY_REQ_FUNC(join_snapshot, JOIN_SNAPSHOT) +GEN_TRANS_REQ_FUNC(begin, BEGIN) +GEN_TRANS_REQ_FUNC(commit, COMMIT) +GEN_TRANS_REQ_FUNC(rollback, ROLLBACK) + +static void parse_heartbeat(netdissect_options *ndo, const char *msg) +{ + uint32_t body_items; + bool heartbeat_resp = false; + + if (mp_typeof(*msg) != MP_MAP) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + body_items = mp_decode_map(&msg); + + for (uint32_t n = 0; n < body_items; n++) { + uint64_t key; + + if (mp_typeof(*msg) != MP_UINT) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + key = mp_decode_uint(&msg); + switch (key) { + case IPROTO_VCLOCK: + if (mp_typeof(*msg) != MP_MAP) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + heartbeat_resp = true; + break; + } + } + + if (heartbeat_resp) { + ND_PRINT(" response: HEARTBEAT\nVCLOCK: %s", get_all_data(ndo, msg)); + } + + return; +out: + nd_print_invalid(ndo); +} + +static void parse_ok(netdissect_options *ndo, const char *msg, + const kv_t *kv, size_t kv_len) +{ + uint64_t sync, version, key, replica_id; + double timestamp = 0; + + sync = version = key = replica_id = 0; + + if (!kv_len) { /* may be a heartbeat response */ + parse_heartbeat(ndo, msg); + return; + } + + for (size_t n = 0; n < kv_len; n++) { + switch (kv[n].key) { + case IPROTO_SYNC: + sync = kv[n].u.val; + break; + case IPROTO_SCHEMA_VERSION: + version = kv[n].u.val; + break; + case IPROTO_REPLICA_ID: + replica_id = kv[n].u.val; + break; + case IPROTO_TIMESTAMP: + timestamp = kv[n].u.val_d; + break; + default: + goto out; + } + } + + if (replica_id && timestamp) { /* heartbeat request */ + const char *time = get_time(ndo, timestamp); + ND_PRINT(" request: HEARTBEAT, REPLICA_ID: %" PRIu64 ", TIMESTAMP: %s", + replica_id, (time) ? time : "NULL"); + return; + } + + ND_PRINT(" response: OK, SYNC: %" PRIu64 ", SCHEMA_VERSION: %" PRIu64, + sync, version); + if (timestamp) { + const char *time = get_time(ndo, timestamp); + ND_PRINT(", TIMESTAMP: %s", (time) ? time : "NULL"); + } + + if (ndo->ndo_vflag == 0) { + return; + } + + parse_body(ndo, msg); + + return; +out: + nd_print_invalid(ndo); +} + +static void parse_error(netdissect_options *ndo, const char *msg, + const kv_t *kv, size_t kv_len) +{ + uint64_t sync, version, errcode; + uint32_t body_items; + + sync = version = errcode = 0; + + if (kv_len != 3) { + goto out; + } + + for (size_t n = 0; n < kv_len; n++) { + switch (kv[n].key) { + case IPROTO_SYNC: + sync = kv[n].u.val; + break; + case IPROTO_SCHEMA_VERSION: + version = kv[n].u.val; + break; + case IPROTO_REQUEST_TYPE: + errcode = kv[n].u.val; + break; + default: + goto out; + } + } + + ND_PRINT(" response: ERR: %s, SYNC: %" PRIu64 ", SCHEMA_VERSION: %" PRIu64, + (errcode >= ARR_LEN(error_codes)) ? "unknown" : + error_codes[errcode], sync, version); + + if (ndo->ndo_vflag == 0) { + return; + } + + /* parse and print body */ + if (mp_typeof(*msg) != MP_MAP) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + body_items = mp_decode_map(&msg); + + if (body_items == 1) { /* versions <= 2.4.0 */ + uint64_t key; + + if (mp_typeof(*msg) != MP_UINT) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + key = mp_decode_uint(&msg); + + if (key == IPROTO_ERROR_24) { + const char *error; + + if (mp_typeof(*msg) != MP_STR) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + error = get_string(ndo, msg); + if (error) { + ND_PRINT("\nERROR: %s", error); + } + } + return; + } + + for (uint32_t n = 0; n < body_items; n++) { + uint64_t key; + + if (mp_typeof(*msg) != MP_UINT) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + key = mp_decode_uint(&msg); + switch (key) { + case IPROTO_ERROR_24: + mp_next(&msg); + break; + case IPROTO_ERROR: + print_error(ndo, &msg); + break; + } + } + + return; +out: + nd_print_invalid(ndo); +} + +static void parse_vote(netdissect_options *ndo, const char *msg, + const kv_t *kv, size_t kv_len) +{ + (void) msg; + (void) kv; + (void) kv_len; + + ND_PRINT(" request: VOTE"); +} + +/* IPROTO_RAFT body does not have unique key in enum iproto_key */ +static void parse_raft(netdissect_options *ndo, const char *msg, + const kv_t *kv, size_t kv_len) +{ + uint32_t body_items; + uint64_t sync, id; + + sync = id = 0; + + for (size_t n = 0; n < kv_len; n++) { + switch (kv[n].key) { + case IPROTO_SYNC: + sync = kv[n].u.val; + break; + case IPROTO_GROUP_ID: + id = kv[n].u.val; + break; + default: + goto out; + } + } + + ND_PRINT(" request: RAFT, GROUP_ID: %" PRIu64 ", SYNC: %" PRIu64, id, sync); + + if (ndo->ndo_vflag == 0) { + return; + } + + if (mp_typeof(*msg) != MP_MAP) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + body_items = mp_decode_map(&msg); + + for (uint32_t n = 0; n < body_items; n++) { + uint64_t key; + + if (mp_typeof(*msg) != MP_UINT) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + key = mp_decode_uint(&msg); + switch (key) { + CASE_IPROTO_UINT(RAFT_TERM); + CASE_IPROTO_UINT(RAFT_VOTE); + CASE_IPROTO_UINT(RAFT_STATE); + CASE_IPROTO_MAP(RAFT_VCLOCK); + } + } + + return; +out: + nd_print_invalid(ndo); +} + +/* Greeting message format: + * _version_:space:_uuid_:space::newline:_salt_:spaces: + */ +static int parse_greeting(netdissect_options *ndo, const char *msg) +{ + char version[GR_MAXLEN] = {0}; + char uuid[GR_MAXLEN] = {0}; + char *nl, *delim; + size_t len, ver_len, uuid_len; + + if (strncmp(msg, "Tarantool", sizeof(GR_NAME) - 1) != 0) { + return 0; + } + + ND_PRINT(": IPROTO: greeting: "); + nl = strchr(msg, '\n'); + + if (!nl) { + ND_PRINT("version: unknown, uuid: unknown"); + nd_print_invalid(ndo); + return 1; + } + + len = nl - msg; + + memcpy(version, msg, len); + version[len] = '\0'; + + delim = strrchr(version, 0x20); + if (!delim) { + ND_PRINT("version: unknown, uuid: unknown"); + nd_print_invalid(ndo); + return 1; + } + + /* cut last space */ + *delim = '\0'; + + delim = strrchr(version, 0x20); + if (!delim) { + ND_PRINT("version: unknown, uuid: unknown"); + nd_print_invalid(ndo); + return 1; + } + + ver_len = delim - version; + + uuid_len = len - ver_len; + memcpy(uuid, delim + 1, uuid_len - 1); + uuid[uuid_len] = '\0'; + version[ver_len] = '\0'; + + ND_PRINT("version: %s, uuid: %s", version, uuid); + + /* print salt if verbose */ + if (ndo->ndo_vflag >= 1) { + char salt[GR_MAXLEN] = {0}; + + delim = strchr(nl, 0x20); + if (!delim) { + return 1; + } + + memcpy(salt, nl + 1, delim - nl - 1); + ND_PRINT(", salt: %s", salt); + } + + return 1; +} + +void +tarantool_print(netdissect_options *ndo, const u_char *bp, u_int length) +{ + request_print_t print_req = NULL; + const char *payload = (const char *) bp; + uint32_t header_items; + size_t kvs_len = 0; + char *body = NULL; + char *hdr = NULL; + uint64_t size; + kv_t *kvs; + + /* override default MP_EXT serialization function */ + mp_snprint_ext = snprint_ext_custom; + + if (!bp || length <= 0) { + return; + } + + /* greeting message is not in MsgPack format */ + if (length >= (sizeof(GR_NAME) - 1)) { + if (parse_greeting(ndo, payload)) { + return; + } + } + + if (mp_typeof(*payload) != MP_UINT) { + return; + } + + size = mp_decode_uint(&payload); + + if (ndo->ndo_vflag == 2) { + hdr = get_all_data(ndo, payload); + } + + /* parse header */ + if (mp_typeof(*payload) != MP_MAP) { + return; + } + + ND_PRINT(": IPROTO size=%" PRIu64, size); + + header_items = mp_decode_map(&payload); + + if (!header_items) { + goto out; + } + + kvs = nd_malloc(ndo, header_items * sizeof(kv_t)); + if (!kvs) { + return; + } + + for (uint32_t n = 0; n < header_items; n++) { + uint64_t key, val = 0; + double val_d = 0; + + if (mp_typeof(*payload) != MP_UINT) { + ND_PRINT_ERR_MPTYPE(); + goto out; + } + key = mp_decode_uint(&payload); + + switch (mp_typeof(*payload)) { + case MP_UINT: + val = mp_decode_uint(&payload); + break; + case MP_DOUBLE: + val_d = mp_decode_double(&payload); + break; + default: + ND_PRINT_ERR_MPTYPE(); + goto out; + } + + if (key == IPROTO_REQUEST_TYPE) { + struct request *res; + struct request rkey = { .type = val }; + + /* error code is 0x8XXX */ + if (val >> 12 == 8) { + uint32_t err = val & 0xfff; + kvs[kvs_len].key = key; + kvs[kvs_len].u.val = err; + kvs_len++; + rkey.type = IPROTO_TYPE_ERROR; + } + + res = bsearch(&rkey, request_ops, ARR_LEN(request_ops), + sizeof(struct request), request_compar); + if (res) { + print_req = res->print; + } + + continue; /* we do not need to store request type */ + } + + kvs[kvs_len].key = key; + if (val_d) { + kvs[kvs_len].u.val_d = val_d; + } else { + kvs[kvs_len].u.val = val; + } + kvs_len++; + } + + if (print_req) { + print_req(ndo, payload, kvs, kvs_len); + } + + if (ndo->ndo_vflag == 2) { + if (mp_typeof(*payload) == MP_MAP) { + body = get_all_data(ndo, payload); + } + if (hdr) { + ND_PRINT("\nheader: %s", hdr); + } + if (body) { + ND_PRINT("\nbody: %s", body); + } + } + + return; +out: + nd_print_invalid(ndo); +} diff --git a/print-tcp.c b/print-tcp.c index d9ca4a34b9..a18ef99864 100644 --- a/print-tcp.c +++ b/print-tcp.c @@ -738,6 +738,9 @@ tcp_print(netdissect_options *ndo, case PT_RESP: resp_print(ndo, bp, length); break; + case PT_IPROTO: + tarantool_print(ndo, bp, length); + break; case PT_DOMAIN: /* over_tcp: TRUE, is_mdns: FALSE */ domain_print(ndo, bp, length, TRUE, FALSE); diff --git a/tcpdump.1.in b/tcpdump.1.in index c387d02c50..c8afb1977e 100644 --- a/tcpdump.1.in +++ b/tcpdump.1.in @@ -748,6 +748,7 @@ Currently known types are \fBrtp\fR (Real-Time Applications protocol), \fBsnmp\fR (Simple Network Management Protocol), \fBsomeip\fR (SOME/IP), +\fBtarantool\fR (Tarantool binary protocol), \fBtftp\fR (Trivial File Transfer Protocol), \fBvat\fR (Visual Audio Tool), \fBvxlan\fR (Virtual eXtensible Local Area Network), diff --git a/tcpdump.c b/tcpdump.c index 515edf5d47..7e04f91de4 100644 --- a/tcpdump.c +++ b/tcpdump.c @@ -1868,6 +1868,8 @@ main(int argc, char **argv) ndo->ndo_packettype = PT_DOMAIN; else if (ascii_strcasecmp(optarg, "quic") == 0) ndo->ndo_packettype = PT_QUIC; + else if (ascii_strcasecmp(optarg, "tarantool") == 0) + ndo->ndo_packettype = PT_IPROTO; else error("unknown packet type `%s'", optarg); break; diff --git a/tests/TESTLIST b/tests/TESTLIST index e066389260..f382a0783d 100644 --- a/tests/TESTLIST +++ b/tests/TESTLIST @@ -519,6 +519,11 @@ resp_1 resp_1_benchmark.pcap resp_1.out resp_2 resp_2_inline.pcap resp_2.out resp_3 resp_3_malicious.pcap resp_3.out +# IPROTO tests +tarantool_base tarantool_base.pcap tarantool_base.out -T tarantool +tarantool_base-v tarantool_base.pcap tarantool_base_v.out -T tarantool -v +tarantool_base-vv tarantool_base.pcap tarantool_base_vv.out -T tarantool -vv + # TFTP tests tftp tftp.pcap tftp.out tftp-T tftp.pcap tftp-T.out -T tftp diff --git a/tests/tarantool_base.out b/tests/tarantool_base.out new file mode 100644 index 0000000000..79c41b2aaf --- /dev/null +++ b/tests/tarantool_base.out @@ -0,0 +1,297 @@ + 1 16:57:31.257128 IP 127.0.0.1.40054 > 127.0.0.1.3309: Flags [S], seq 3784122596, win 65495, options [mss 65495,sackOK,TS val 1977541146 ecr 0,nop,wscale 7], length 0 + 2 16:57:31.257135 IP 127.0.0.1.3309 > 127.0.0.1.40054: Flags [S.], seq 4139244470, ack 3784122597, win 65483, options [mss 65495,sackOK,TS val 1977541146 ecr 1977541146,nop,wscale 7], length 0 + 3 16:57:31.257142 IP 127.0.0.1.40054 > 127.0.0.1.3309: Flags [.], ack 1, win 512, options [nop,nop,TS val 1977541146 ecr 1977541146], length 0 + 4 16:57:31.257310 IP 127.0.0.1.3309 > 127.0.0.1.40054: Flags [P.], seq 1:129, ack 1, win 512, options [nop,nop,TS val 1977541146 ecr 1977541146], length 128: IPROTO: greeting: version: Tarantool 2.10.4 (Binary), uuid: e6bd3069-1336-4934-97d1-61b2dc4392f9 + 5 16:57:31.257314 IP 127.0.0.1.40054 > 127.0.0.1.3309: Flags [.], ack 129, win 511, options [nop,nop,TS val 1977541146 ecr 1977541146], length 0 + 6 16:57:31.257375 IP 127.0.0.1.40054 > 127.0.0.1.3309: Flags [P.], seq 1:9, ack 129, win 512, options [nop,nop,TS val 1977541146 ecr 1977541146], length 8: IPROTO size=3 request: VOTE + 7 16:57:31.257378 IP 127.0.0.1.3309 > 127.0.0.1.40054: Flags [.], ack 9, win 512, options [nop,nop,TS val 1977541146 ecr 1977541146], length 0 + 8 16:57:31.257559 IP 127.0.0.1.3309 > 127.0.0.1.40054: Flags [P.], seq 129:174, ack 9, win 512, options [nop,nop,TS val 1977541146 ecr 1977541146], length 45: IPROTO size=40 response: OK, SYNC: 0, SCHEMA_VERSION: 0 + 9 16:57:31.266905 IP 127.0.0.1.40054 > 127.0.0.1.3309: Flags [F.], seq 9, ack 174, win 512, options [nop,nop,TS val 1977541156 ecr 1977541146], length 0 + 10 16:57:31.267007 IP 127.0.0.1.3309 > 127.0.0.1.40054: Flags [F.], seq 174, ack 10, win 512, options [nop,nop,TS val 1977541156 ecr 1977541156], length 0 + 11 16:57:31.267015 IP 127.0.0.1.40054 > 127.0.0.1.3309: Flags [.], ack 175, win 512, options [nop,nop,TS val 1977541156 ecr 1977541156], length 0 + 12 16:57:31.284958 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [S], seq 1357811807, win 65495, options [mss 65495,sackOK,TS val 1977541174 ecr 0,nop,wscale 7], length 0 + 13 16:57:31.284966 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [S.], seq 4221993135, ack 1357811808, win 65483, options [mss 65495,sackOK,TS val 1977541174 ecr 1977541174,nop,wscale 7], length 0 + 14 16:57:31.284972 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 1, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 0 + 15 16:57:31.285240 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 1:129, ack 1, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 128: IPROTO: greeting: version: Tarantool 2.10.4 (Binary), uuid: e6bd3069-1336-4934-97d1-61b2dc4392f9 + 16 16:57:31.285247 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 129, win 511, options [nop,nop,TS val 1977541174 ecr 1977541174], length 0 + 17 16:57:31.285353 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 1:9, ack 129, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 8: IPROTO size=3 request: VOTE + 18 16:57:31.285357 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], ack 9, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 0 + 19 16:57:31.285461 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 129:176, ack 9, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 47: IPROTO size=42 response: OK, SYNC: 0, SCHEMA_VERSION: 80 + 20 16:57:31.285500 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 9:63, ack 176, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 54: IPROTO size=49 request: AUTH, SYNC: 0 + 21 16:57:31.285673 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 176:205, ack 63, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 29: IPROTO size=24 response: OK, SYNC: 0, SCHEMA_VERSION: 80 + 22 16:57:31.285736 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 63:117, ack 205, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 54: IPROTO size=49 request: JOIN, SYNC: 0 + 23 16:57:31.286004 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 205:218, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541174], length 13: IPROTO size=8 response: HEARTBEAT +VCLOCK: {1: 10} + 24 16:57:31.286011 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 218:226, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541174], length 8: IPROTO size=3 request: JOIN_META, SYNC: 0 + 25 16:57:31.286014 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 226:243, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541174], length 17: IPROTO size=12 request: RAFT_PROMOTE, SYNC: 0, REPLICA_ID: 1 + 26 16:57:31.286016 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 243:251, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541174], length 8: IPROTO size=3 request: JOIN_SNAPSHOT, SYNC: 0 + 27 16:57:31.286048 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 251, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 0 + 28 16:57:31.286105 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 251:314, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 63: IPROTO size=58 request: INSERT, SYNC: 0 + 29 16:57:31.286111 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 314:341, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 27: IPROTO size=22 request: INSERT, SYNC: 0 + 30 16:57:31.286115 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 341:369, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 28: IPROTO size=23 request: INSERT, SYNC: 0 + 31 16:57:31.286118 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 369:402, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 33: IPROTO size=28 request: INSERT, SYNC: 0 + 32 16:57:31.286120 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 402:453, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 51: IPROTO size=46 request: INSERT, SYNC: 0 + 33 16:57:31.286122 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 453:506, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 53: IPROTO size=48 request: INSERT, SYNC: 0 + 34 16:57:31.286124 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 506:541, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 35: IPROTO size=30 request: INSERT, SYNC: 0 + 35 16:57:31.286126 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 541:599, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 + 36 16:57:31.286128 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 599:659, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 + 37 16:57:31.286130 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 659:718, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 + 38 16:57:31.286166 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 718, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 0 + 39 16:57:31.286173 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 718:5866, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 5148: IPROTO size=53 request: INSERT, SYNC: 0 + 40 16:57:31.286176 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 5866:5924, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 + 41 16:57:31.286178 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 5924:5984, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 + 42 16:57:31.286179 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 5984:6043, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 + 43 16:57:31.286181 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 6043:6103, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 + 44 16:57:31.286183 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 6103:6165, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 62: IPROTO size=57 request: INSERT, SYNC: 0 + 45 16:57:31.286185 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 6165:6226, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 61: IPROTO size=56 request: INSERT, SYNC: 0 + 46 16:57:31.286187 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 6226:6284, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 + 47 16:57:31.286189 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 6284:6344, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 + 48 16:57:31.286190 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 6344:6403, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 + 49 16:57:31.286192 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 6403:6461, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 + 50 16:57:31.286194 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 6461:6521, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 + 51 16:57:31.286196 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 6521:6580, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 + 52 16:57:31.286198 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 6580:6638, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 + 53 16:57:31.286200 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 6638:6698, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 + 54 16:57:31.286202 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 6698:6757, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 + 55 16:57:31.286204 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 6757:6815, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 + 56 16:57:31.286206 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 6815:6875, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 + 57 16:57:31.286208 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 6875:6934, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 + 58 16:57:31.286210 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 6934:6992, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 + 59 16:57:31.286312 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 6992, win 463, options [nop,nop,TS val 1977541175 ecr 1977541175], length 0 + 60 16:57:31.286319 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 6992:26160, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 19168: IPROTO size=55 request: INSERT, SYNC: 0 + 61 16:57:31.286320 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26160:26197, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 37: IPROTO size=32 request: INSERT, SYNC: 0 + 62 16:57:31.286322 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26197:26228, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 31: IPROTO size=26 request: INSERT, SYNC: 0 + 63 16:57:31.286325 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26228:26303, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 75: IPROTO size=70 request: INSERT, SYNC: 0 + 64 16:57:31.286328 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26303:26329, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 26: IPROTO size=21 request: INSERT, SYNC: 0 + 65 16:57:31.286330 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26329:26359, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 30: IPROTO size=25 request: INSERT, SYNC: 0 + 66 16:57:31.286332 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26359:26393, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 34: IPROTO size=29 request: INSERT, SYNC: 0 + 67 16:57:31.286334 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26393:26423, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 30: IPROTO size=25 request: INSERT, SYNC: 0 + 68 16:57:31.286336 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26423:26453, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 30: IPROTO size=25 request: INSERT, SYNC: 0 + 69 16:57:31.286338 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26453:26482, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 + 70 16:57:31.286340 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26482:26511, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 + 71 16:57:31.286342 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26511:26540, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 + 72 16:57:31.286344 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26540:26569, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 + 73 16:57:31.286346 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26569:26598, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 + 74 16:57:31.286348 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26598:26627, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 + 75 16:57:31.286350 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26627:26656, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 + 76 16:57:31.286352 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26656:26685, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 + 77 16:57:31.286354 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26685:26714, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 + 78 16:57:31.286357 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26714:26743, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 + 79 16:57:31.286359 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26743:26772, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 + 80 16:57:31.286361 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26772:26802, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 30: IPROTO size=25 request: INSERT, SYNC: 0 + 81 16:57:31.286363 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26802:26836, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 34: IPROTO size=29 request: INSERT, SYNC: 0 + 82 16:57:31.286365 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26836:26862, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 26: IPROTO size=21 request: INSERT, SYNC: 0 + 83 16:57:31.286369 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26862:26888, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 26: IPROTO size=21 request: INSERT, SYNC: 0 + 84 16:57:31.286371 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26888:26918, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 30: IPROTO size=25 request: INSERT, SYNC: 0 + 85 16:57:31.286373 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26918:26945, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 27: IPROTO size=22 request: INSERT, SYNC: 0 + 86 16:57:31.286375 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 26945:27001, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 56: IPROTO size=51 request: INSERT, SYNC: 0 + 87 16:57:31.286582 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27001:27014, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 13: IPROTO size=8 response: HEARTBEAT +VCLOCK: {1: 11} + 88 16:57:31.286719 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27014:27082, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 68: IPROTO size=63 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 11, TIMESTAMP: 2022-12-15 16:57:31.286489 + 89 16:57:31.286800 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27082:27095, ack 117, win 512, options [nop,nop,TS val 1977541176 ecr 1977541175], length 13: IPROTO size=8 response: HEARTBEAT +VCLOCK: {1: 11} + 90 16:57:31.290485 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 27095, win 359, options [nop,nop,TS val 1977541179 ecr 1977541175], length 0 + 91 16:57:31.295019 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 117:219, ack 27095, win 512, options [nop,nop,TS val 1977541184 ecr 1977541175], length 102: IPROTO size=97 request: SUBSCRIBE, SYNC: 0 + 92 16:57:31.295163 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27095:27149, ack 219, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 54: IPROTO size=49 response: OK, SYNC: 0, SCHEMA_VERSION: 0 + 93 16:57:31.295184 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27149:27164, ack 219, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 15: IPROTO size=10 request: RAFT, GROUP_ID: 1, SYNC: 0 + 94 16:57:31.295204 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 27164, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 0 + 95 16:57:31.295333 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 219:232, ack 27164, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 13: IPROTO size=8 response: HEARTBEAT +VCLOCK: {1: 11} + 96 16:57:31.295554 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27164:27184, ack 232, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 20: IPROTO size=15 request: HEARTBEAT, REPLICA_ID: 1, TIMESTAMP: 2022-12-15 16:57:31.295484 + 97 16:57:31.295749 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 232:245, ack 27184, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 13: IPROTO size=8 response: HEARTBEAT +VCLOCK: {1: 11} + 98 16:57:31.336637 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], ack 245, win 512, options [nop,nop,TS val 1977541225 ecr 1977541184], length 0 + 99 16:57:31.368370 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [S], seq 3722433644, win 65495, options [mss 65495,sackOK,TS val 1977541257 ecr 0,nop,wscale 7], length 0 + 100 16:57:31.368378 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [S.], seq 3735401205, ack 3722433645, win 65483, options [mss 65495,sackOK,TS val 1977541257 ecr 1977541257,nop,wscale 7], length 0 + 101 16:57:31.368385 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [.], ack 1, win 512, options [nop,nop,TS val 1977541257 ecr 1977541257], length 0 + 102 16:57:31.368682 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 1:129, ack 1, win 512, options [nop,nop,TS val 1977541257 ecr 1977541257], length 128: IPROTO: greeting: version: Tarantool 2.10.4 (Binary), uuid: e6bd3069-1336-4934-97d1-61b2dc4392f9 + 103 16:57:31.368687 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [.], ack 129, win 511, options [nop,nop,TS val 1977541257 ecr 1977541257], length 0 + 104 16:57:31.368744 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 1:20, ack 129, win 512, options [nop,nop,TS val 1977541257 ecr 1977541257], length 19: IPROTO size=14 request: ID, SYNC: 1 + 105 16:57:31.368748 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [.], ack 20, win 512, options [nop,nop,TS val 1977541257 ecr 1977541257], length 0 + 106 16:57:31.368886 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 129:166, ack 20, win 512, options [nop,nop,TS val 1977541258 ecr 1977541257], length 37: IPROTO size=32 response: OK, SYNC: 1, SCHEMA_VERSION: 80 + 107 16:57:31.368950 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 20:89, ack 166, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 69: IPROTO size=18 request: SELECT, SYNC: 2 + 108 16:57:31.369122 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 166:19926, ack 89, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 19760: IPROTO size=4641 response: OK, SYNC: 2, SCHEMA_VERSION: 80 + 109 16:57:31.369454 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 89:112, ack 19926, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 23: IPROTO size=18 + 110 16:57:31.369464 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 112:122, ack 19926, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 10: IPROTO size=5 request: PING, SYNC: 5 + 111 16:57:31.369561 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [.], ack 122, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 0 + 112 16:57:31.369694 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 19926:19978, ack 122, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 52: IPROTO size=24 response: OK, SYNC: 5, SCHEMA_VERSION: 80 + 113 16:57:31.369766 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 122:164, ack 19978, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 42: IPROTO size=14 request: INSERT, SYNC: 6 + 114 16:57:31.370030 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27184:27217, ack 245, win 512, options [nop,nop,TS val 1977541259 ecr 1977541184], length 33: IPROTO size=28 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 12, TIMESTAMP: 2022-12-15 16:57:31.369981, FLAGS: 6 + 115 16:57:31.370150 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27217:27244, ack 245, win 512, options [nop,nop,TS val 1977541259 ecr 1977541184], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 13, TIMESTAMP: 2022-12-15 16:57:31.370125 + 116 16:57:31.370210 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 27244, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 0 + 117 16:57:31.370210 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 19978:20016, ack 164, win 512, options [nop,nop,TS val 1977541259 ecr 1977541258], length 38: IPROTO size=33 response: OK, SYNC: 6, SCHEMA_VERSION: 80 + 118 16:57:31.370301 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 164:183, ack 20016, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 19: IPROTO size=14 request: INSERT, SYNC: 7 + 119 16:57:31.370368 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 245:268, ack 27244, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.369981 + 120 16:57:31.370446 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], ack 268, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 0 + 121 16:57:31.370452 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 268:291, ack 27244, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.370125 + 122 16:57:31.370460 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], ack 291, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 0 + 123 16:57:31.370481 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27244:27277, ack 291, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 33: IPROTO size=28 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 14, TIMESTAMP: 2022-12-15 16:57:31.370455, FLAGS: 6 + 124 16:57:31.370486 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27277:27304, ack 291, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 15, TIMESTAMP: 2022-12-15 16:57:31.370469 + 125 16:57:31.370566 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20016:20054, ack 183, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 38: IPROTO size=33 response: OK, SYNC: 7, SCHEMA_VERSION: 80 + 126 16:57:31.370566 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 27304, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 0 + 127 16:57:31.370627 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 183:202, ack 20054, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 19: IPROTO size=14 request: INSERT, SYNC: 8 + 128 16:57:31.370804 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 291:314, ack 27304, win 512, options [nop,nop,TS val 1977541260 ecr 1977541259], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.370455 + 129 16:57:31.370845 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27304:27337, ack 314, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 33: IPROTO size=28 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 16, TIMESTAMP: 2022-12-15 16:57:31.370790, FLAGS: 6 + 130 16:57:31.370868 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27337:27364, ack 314, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 17, TIMESTAMP: 2022-12-15 16:57:31.370849 + 131 16:57:31.370898 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 27364, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 132 16:57:31.370907 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 314:337, ack 27364, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.370469 + 133 16:57:31.371014 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20054:20092, ack 202, win 512, options [nop,nop,TS val 1977541260 ecr 1977541259], length 38: IPROTO size=33 response: OK, SYNC: 8, SCHEMA_VERSION: 80 + 134 16:57:31.371066 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 202:238, ack 20092, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 36: IPROTO size=31 request: INSERT, SYNC: 9 + 135 16:57:31.371114 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 337:360, ack 27364, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.370790 + 136 16:57:31.371124 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 360:383, ack 27364, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.370849 + 137 16:57:31.371200 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], ack 383, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 138 16:57:31.371215 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27364:27414, ack 383, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 50: IPROTO size=45 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 18, TIMESTAMP: 2022-12-15 16:57:31.371191, FLAGS: 6 + 139 16:57:31.371222 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27414:27441, ack 383, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 19, TIMESTAMP: 2022-12-15 16:57:31.371215 + 140 16:57:31.371229 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 27441, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 141 16:57:31.371234 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20092:20147, ack 238, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 55: IPROTO size=50 response: OK, SYNC: 9, SCHEMA_VERSION: 80 + 142 16:57:31.371254 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 238:272, ack 20147, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 34: IPROTO size=29 request: INSERT, SYNC: 10 + 143 16:57:31.371308 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 383:406, ack 27441, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371191 + 144 16:57:31.371317 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 406:429, ack 27441, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371215 + 145 16:57:31.371329 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], ack 429, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 146 16:57:31.371341 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20147:20200, ack 272, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 53: IPROTO size=48 response: OK, SYNC: 10, SCHEMA_VERSION: 80 + 147 16:57:31.371343 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27441:27489, ack 429, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 48: IPROTO size=43 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 20, TIMESTAMP: 2022-12-15 16:57:31.371308, FLAGS: 6 + 148 16:57:31.371348 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27489:27516, ack 429, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 21, TIMESTAMP: 2022-12-15 16:57:31.371325 + 149 16:57:31.371352 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 272:311, ack 20200, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 39: IPROTO size=34 request: INSERT, SYNC: 11 + 150 16:57:31.371352 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 27516, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 151 16:57:31.371378 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27516:27569, ack 429, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 53: IPROTO size=48 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 22, TIMESTAMP: 2022-12-15 16:57:31.371363, FLAGS: 6 + 152 16:57:31.371384 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27569:27596, ack 429, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 23, TIMESTAMP: 2022-12-15 16:57:31.371377 + 153 16:57:31.371391 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20200:20258, ack 311, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 58: IPROTO size=53 response: OK, SYNC: 11, SCHEMA_VERSION: 80 + 154 16:57:31.371392 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 27596, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 155 16:57:31.371417 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 429:452, ack 27596, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371308 + 156 16:57:31.371430 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 452:475, ack 27596, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371325 + 157 16:57:31.371435 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], ack 475, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 158 16:57:31.371435 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 475:498, ack 27596, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371363 + 159 16:57:31.371443 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 311:347, ack 20258, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 36: IPROTO size=31 request: INSERT, SYNC: 12 + 160 16:57:31.371451 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 498:521, ack 27596, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371377 + 161 16:57:31.371457 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], ack 521, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 162 16:57:31.371476 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27596:27646, ack 521, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 50: IPROTO size=45 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 24, TIMESTAMP: 2022-12-15 16:57:31.371459, FLAGS: 6 + 163 16:57:31.371479 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20258:20313, ack 347, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 55: IPROTO size=50 response: OK, SYNC: 12, SCHEMA_VERSION: 80 + 164 16:57:31.371480 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27646:27673, ack 521, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 25, TIMESTAMP: 2022-12-15 16:57:31.371464 + 165 16:57:31.371484 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 27673, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 166 16:57:31.371492 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 347:373, ack 20313, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 26: IPROTO size=21 request: SELECT, SYNC: 13 + 167 16:57:31.371509 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20313:20351, ack 373, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 38: IPROTO size=33 response: OK, SYNC: 13, SCHEMA_VERSION: 80 + 168 16:57:31.371522 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 373:402, ack 20351, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 29: IPROTO size=24 request: SELECT, SYNC: 14 + 169 16:57:31.371534 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20351:20476, ack 402, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 125: IPROTO size=120 response: OK, SYNC: 14, SCHEMA_VERSION: 80 + 170 16:57:31.371546 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 402:423, ack 20476, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 21: IPROTO size=16 request: REPLACE, SYNC: 15 + 171 16:57:31.371567 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 521:544, ack 27673, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371459 + 172 16:57:31.371579 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 544:567, ack 27673, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371464 + 173 16:57:31.371612 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], ack 567, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 174 16:57:31.371626 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27673:27708, ack 567, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 35: IPROTO size=30 request: REPLACE, SYNC: 0, REPLICA_ID: 1, LSN: 26, TIMESTAMP: 2022-12-15 16:57:31.371598, FLAGS: 6 + 175 16:57:31.371633 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27708:27735, ack 567, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 27, TIMESTAMP: 2022-12-15 16:57:31.371622 + 176 16:57:31.371635 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20476:20516, ack 423, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 40: IPROTO size=35 response: OK, SYNC: 15, SCHEMA_VERSION: 80 + 177 16:57:31.371639 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 27735, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 178 16:57:31.371650 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 423:452, ack 20516, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 29: IPROTO size=24 request: UPDATE, SYNC: 16 + 179 16:57:31.371705 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 567:590, ack 27735, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371598 + 180 16:57:31.371722 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 590:613, ack 27735, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371622 + 181 16:57:31.371734 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], ack 613, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 182 16:57:31.371751 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27735:27776, ack 613, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 41: IPROTO size=36 request: UPDATE, SYNC: 0, REPLICA_ID: 1, LSN: 28, TIMESTAMP: 2022-12-15 16:57:31.371725, FLAGS: 6 + 183 16:57:31.371759 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27776:27803, ack 613, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 29, TIMESTAMP: 2022-12-15 16:57:31.371747 + 184 16:57:31.371760 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20516:20554, ack 452, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 38: IPROTO size=33 response: OK, SYNC: 16, SCHEMA_VERSION: 80 + 185 16:57:31.371765 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 27803, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 186 16:57:31.371774 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 452:488, ack 20554, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 36: IPROTO size=31 request: UPSERT, SYNC: 17 + 187 16:57:31.371819 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27803:27853, ack 613, win 512, options [nop,nop,TS val 1977541261 ecr 1977541260], length 50: IPROTO size=45 request: UPSERT, SYNC: 0, REPLICA_ID: 1, LSN: 30, TIMESTAMP: 2022-12-15 16:57:31.371804, FLAGS: 6 + 188 16:57:31.371825 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27853:27880, ack 613, win 512, options [nop,nop,TS val 1977541261 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 31, TIMESTAMP: 2022-12-15 16:57:31.371814 + 189 16:57:31.371826 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20554:20589, ack 488, win 512, options [nop,nop,TS val 1977541261 ecr 1977541260], length 35: IPROTO size=30 response: OK, SYNC: 17, SCHEMA_VERSION: 80 + 190 16:57:31.371828 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 613:636, ack 27880, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371725 + 191 16:57:31.371836 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 488:508, ack 20589, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 20: IPROTO size=15 request: DELETE, SYNC: 18 + 192 16:57:31.371841 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 636:659, ack 27880, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371747 + 193 16:57:31.371846 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], ack 659, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 194 16:57:31.371861 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27880:27912, ack 659, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 32: IPROTO size=27 request: DELETE, SYNC: 0, REPLICA_ID: 1, LSN: 32, TIMESTAMP: 2022-12-15 16:57:31.371849, FLAGS: 6 + 195 16:57:31.371868 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27912:27939, ack 659, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 33, TIMESTAMP: 2022-12-15 16:57:31.371856 + 196 16:57:31.371870 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20589:20627, ack 508, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 38: IPROTO size=33 response: OK, SYNC: 18, SCHEMA_VERSION: 80 + 197 16:57:31.371873 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 27939, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 198 16:57:31.371880 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 508:528, ack 20627, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 20: IPROTO size=15 request: DELETE, SYNC: 19 + 199 16:57:31.371930 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 659:682, ack 27939, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371804 + 200 16:57:31.371948 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 682:705, ack 27939, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371814 + 201 16:57:31.371958 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 705:728, ack 27939, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371849 + 202 16:57:31.371960 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], ack 705, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 203 16:57:31.371971 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 728:751, ack 27939, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371856 + 204 16:57:31.371977 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27939:27971, ack 751, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 32: IPROTO size=27 request: DELETE, SYNC: 0, REPLICA_ID: 1, LSN: 34, TIMESTAMP: 2022-12-15 16:57:31.371951, FLAGS: 6 + 205 16:57:31.371984 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20627:20665, ack 528, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 38: IPROTO size=33 response: OK, SYNC: 19, SCHEMA_VERSION: 80 + 206 16:57:31.371984 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27971:27998, ack 751, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 35, TIMESTAMP: 2022-12-15 16:57:31.371971 + 207 16:57:31.371988 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 27998, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 208 16:57:31.371995 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 528:548, ack 20665, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 20: IPROTO size=15 request: DELETE, SYNC: 20 + 209 16:57:31.372021 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 27998:28030, ack 751, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 32: IPROTO size=27 request: DELETE, SYNC: 0, REPLICA_ID: 1, LSN: 36, TIMESTAMP: 2022-12-15 16:57:31.372007, FLAGS: 6 + 210 16:57:31.372031 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], seq 28030:28057, ack 751, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 37, TIMESTAMP: 2022-12-15 16:57:31.372020 + 211 16:57:31.372036 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 28057, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 212 16:57:31.372036 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20665:20703, ack 548, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 38: IPROTO size=33 response: OK, SYNC: 20, SCHEMA_VERSION: 80 + 213 16:57:31.372046 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 548:608, ack 20703, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 60: IPROTO size=55 request: EVAL, SYNC: 21 + 214 16:57:31.372059 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 751:774, ack 28057, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371951 + 215 16:57:31.372070 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20703:20739, ack 608, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 36: IPROTO size=31 response: OK, SYNC: 21, SCHEMA_VERSION: 80 + 216 16:57:31.372079 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 774:797, ack 28057, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371971 + 217 16:57:31.372084 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 797:820, ack 28057, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.372007 + 218 16:57:31.372085 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 608:639, ack 20739, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 31: IPROTO size=26 request: EVAL, SYNC: 22 + 219 16:57:31.372113 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20739:20780, ack 639, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 41: IPROTO size=36 response: OK, SYNC: 22, SCHEMA_VERSION: 80 + 220 16:57:31.372121 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 639:685, ack 20780, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 46: IPROTO size=41 request: EVAL, SYNC: 23 + 221 16:57:31.372127 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], ack 820, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 222 16:57:31.372139 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20780:20815, ack 685, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 35: IPROTO size=30 response: OK, SYNC: 23, SCHEMA_VERSION: 80 + 223 16:57:31.372155 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 685:702, ack 20815, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 17: IPROTO size=12 request: CALL, SYNC: 24 + 224 16:57:31.372170 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20815:20851, ack 702, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 36: IPROTO size=31 response: OK, SYNC: 24, SCHEMA_VERSION: 80 + 225 16:57:31.372180 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 702:752, ack 20851, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 50: IPROTO size=45 request: EVAL, SYNC: 25 + 226 16:57:31.372181 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], seq 820:843, ack 28057, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.372020 + 227 16:57:31.372197 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20851:20886, ack 752, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 35: IPROTO size=30 response: OK, SYNC: 25, SCHEMA_VERSION: 80 + 228 16:57:31.372204 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 752:772, ack 20886, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 20: IPROTO size=15 request: CALL, SYNC: 26 + 229 16:57:31.372216 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20886:20924, ack 772, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 38: IPROTO size=33 response: OK, SYNC: 26, SCHEMA_VERSION: 80 + 230 16:57:31.372224 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 772:799, ack 20924, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 27: IPROTO size=22 request: PREPARE, SYNC: 27 + 231 16:57:31.372270 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 20924:21023, ack 799, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 99: IPROTO size=94 response: OK, SYNC: 27, SCHEMA_VERSION: 80 + 232 16:57:31.372281 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 799:823, ack 21023, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 24: IPROTO size=19 request: EXECUTE, SYNC: 28 + 233 16:57:31.372297 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 21023:21097, ack 823, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 74: IPROTO size=69 response: OK, SYNC: 28, SCHEMA_VERSION: 80 + 234 16:57:31.372309 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 823:835, ack 21097, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 12: IPROTO size=7 request: BEGIN, STREAM_ID: 1, SYNC: 29 + 235 16:57:31.372324 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 21097:21126, ack 835, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 29: IPROTO size=24 response: OK, SYNC: 29, SCHEMA_VERSION: 80 + 236 16:57:31.372331 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 835:847, ack 21126, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 12: IPROTO size=7 request: ROLLBACK, STREAM_ID: 1, SYNC: 30 + 237 16:57:31.372343 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 21126:21155, ack 847, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 29: IPROTO size=24 response: OK, SYNC: 30, SCHEMA_VERSION: 80 + 238 16:57:31.372350 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], seq 847:859, ack 21155, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 12: IPROTO size=7 request: COMMIT, STREAM_ID: 1, SYNC: 31 + 239 16:57:31.372362 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], seq 21155:21184, ack 859, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 29: IPROTO size=24 response: OK, SYNC: 31, SCHEMA_VERSION: 80 + 240 16:57:31.372419 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [F.], seq 859, ack 21184, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 241 16:57:31.372427 IP 127.0.0.1.3309 > 127.0.0.1.40076: Flags [F.], seq 21184, ack 860, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 242 16:57:31.372435 IP 127.0.0.1.40076 > 127.0.0.1.3309: Flags [.], ack 21185, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 243 16:57:31.373225 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [F.], seq 843, ack 28057, win 512, options [nop,nop,TS val 1977541262 ecr 1977541261], length 0 + 244 16:57:31.373454 IP 127.0.0.1.3309 > 127.0.0.1.40070: Flags [F.], seq 28057, ack 844, win 512, options [nop,nop,TS val 1977541262 ecr 1977541261], length 0 + 245 16:57:31.373458 IP 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], ack 28058, win 512, options [nop,nop,TS val 1977541262 ecr 1977541262], length 0 + 246 16:57:32.818697 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [S], seq 725422438, win 65495, options [mss 65495,sackOK,TS val 1977542707 ecr 0,nop,wscale 7], length 0 + 247 16:57:32.818705 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [S.], seq 2701899671, ack 725422439, win 65483, options [mss 65495,sackOK,TS val 1977542707 ecr 1977542707,nop,wscale 7], length 0 + 248 16:57:32.818713 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [.], ack 1, win 512, options [nop,nop,TS val 1977542707 ecr 1977542707], length 0 + 249 16:57:32.818891 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 1:129, ack 1, win 512, options [nop,nop,TS val 1977542708 ecr 1977542707], length 128: IPROTO: greeting: version: Tarantool 2.10.4 (Binary), uuid: 056cb614-461f-4cc2-a26b-8a50f5286086 + 250 16:57:32.818896 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [.], ack 129, win 511, options [nop,nop,TS val 1977542708 ecr 1977542708], length 0 + 251 16:57:32.818950 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 1:20, ack 129, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 19: IPROTO size=14 request: ID, SYNC: 1 + 252 16:57:32.818955 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [.], ack 20, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 0 + 253 16:57:32.819084 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 129:166, ack 20, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 37: IPROTO size=32 response: OK, SYNC: 1, SCHEMA_VERSION: 78 + 254 16:57:32.819150 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 20:89, ack 166, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 69: IPROTO size=18 request: SELECT, SYNC: 2 + 255 16:57:32.819319 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 166:19859, ack 89, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 19693: IPROTO size=4608 response: OK, SYNC: 2, SCHEMA_VERSION: 78 + 256 16:57:32.819674 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 89:112, ack 19859, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 23: IPROTO size=18 + 257 16:57:32.819692 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 112:182, ack 19859, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 70: IPROTO size=65 request: EVAL, SYNC: 5 + 258 16:57:32.819734 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [.], ack 182, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 0 + 259 16:57:32.819884 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 19859:19942, ack 182, win 512, options [nop,nop,TS val 1977542709 ecr 1977542708], length 83: IPROTO size=55 response: OK, SYNC: 5, SCHEMA_VERSION: 78 + 260 16:57:32.819963 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 182:252, ack 19942, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 70: IPROTO size=42 request: CALL, SYNC: 6 + 261 16:57:32.820143 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 19942:20022, ack 252, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 80: IPROTO size=75 response: OK, SYNC: 6, SCHEMA_VERSION: 78 + 262 16:57:32.820243 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 252:301, ack 20022, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 49: IPROTO size=44 request: CALL, SYNC: 7 + 263 16:57:32.820381 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 20022:20118, ack 301, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 96: IPROTO size=91 response: ERR: unknown, SYNC: 7, SCHEMA_VERSION: 78 + 264 16:57:32.820466 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 301:362, ack 20118, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 61: IPROTO size=56 request: CALL, SYNC: 8 + 265 16:57:32.820575 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 20118:20221, ack 362, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 103: IPROTO size=98 response: OK, SYNC: 8, SCHEMA_VERSION: 78 + 266 16:57:32.820661 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 362:425, ack 20221, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 63: IPROTO size=58 request: CALL, SYNC: 9 + 267 16:57:32.820841 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 20221:20341, ack 425, win 512, options [nop,nop,TS val 1977542710 ecr 1977542709], length 120: IPROTO size=115 response: ERR: unknown, SYNC: 9, SCHEMA_VERSION: 78 + 268 16:57:32.820928 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 425:459, ack 20341, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 34: IPROTO size=29 request: CALL, SYNC: 10 + 269 16:57:32.821055 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 20341:20579, ack 459, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 238: IPROTO size=233 response: OK, SYNC: 10, SCHEMA_VERSION: 78 + 270 16:57:32.821152 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 459:499, ack 20579, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 40: IPROTO size=35 request: CALL, SYNC: 11 + 271 16:57:32.821176 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 20579:20886, ack 499, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 307: IPROTO size=302 response: ERR: ER_ACCESS_DENIED, SYNC: 11, SCHEMA_VERSION: 78 + 272 16:57:32.821203 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 499:593, ack 20886, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 94: IPROTO size=89 request: CALL, SYNC: 12 + 273 16:57:32.821225 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 20886:21062, ack 593, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 176: IPROTO size=171 response: OK, SYNC: 12, SCHEMA_VERSION: 78 + 274 16:57:32.821253 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 593:689, ack 21062, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 96: IPROTO size=91 request: CALL, SYNC: 13 + 275 16:57:32.821272 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 21062:21239, ack 689, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 177: IPROTO size=172 response: ERR: unknown, SYNC: 13, SCHEMA_VERSION: 78 + 276 16:57:32.821298 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 689:708, ack 21239, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 14 + 277 16:57:32.821311 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 21239:21342, ack 708, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 103: IPROTO size=98 response: OK, SYNC: 14, SCHEMA_VERSION: 78 + 278 16:57:32.821335 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 708:727, ack 21342, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 15 + 279 16:57:32.821347 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 21342:21447, ack 727, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 105: IPROTO size=100 response: OK, SYNC: 15, SCHEMA_VERSION: 78 + 280 16:57:32.821365 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 727:746, ack 21447, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 16 + 281 16:57:32.821377 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 21447:21552, ack 746, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 105: IPROTO size=100 response: OK, SYNC: 16, SCHEMA_VERSION: 78 + 282 16:57:32.821392 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 746:765, ack 21552, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 17 + 283 16:57:32.821404 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 21552:21655, ack 765, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 103: IPROTO size=98 response: OK, SYNC: 17, SCHEMA_VERSION: 78 + 284 16:57:32.821418 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 765:784, ack 21655, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 18 + 285 16:57:32.821431 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 21655:21759, ack 784, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 104: IPROTO size=99 response: OK, SYNC: 18, SCHEMA_VERSION: 78 + 286 16:57:32.821444 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 784:803, ack 21759, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 19 + 287 16:57:32.821457 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 21759:21864, ack 803, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 105: IPROTO size=100 response: OK, SYNC: 19, SCHEMA_VERSION: 78 + 288 16:57:32.821473 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], seq 803:822, ack 21864, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 20 + 289 16:57:32.821487 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], seq 21864:21969, ack 822, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 105: IPROTO size=100 response: OK, SYNC: 20, SCHEMA_VERSION: 78 + 290 16:57:32.821577 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [F.], seq 822, ack 21969, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 0 + 291 16:57:32.821584 IP 127.0.0.1.3309 > 127.0.0.1.40078: Flags [F.], seq 21969, ack 823, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 0 + 292 16:57:32.821591 IP 127.0.0.1.40078 > 127.0.0.1.3309: Flags [.], ack 21970, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 0 diff --git a/tests/tarantool_base.pcap b/tests/tarantool_base.pcap new file mode 100644 index 0000000000..3259d0105b Binary files /dev/null and b/tests/tarantool_base.pcap differ diff --git a/tests/tarantool_base_v.out b/tests/tarantool_base_v.out new file mode 100644 index 0000000000..af37c2ed9c --- /dev/null +++ b/tests/tarantool_base_v.out @@ -0,0 +1,1130 @@ + 1 16:57:31.257128 IP (tos 0x0, ttl 64, id 10331, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.40054 > 127.0.0.1.3309: Flags [S], cksum 0xfe30 (incorrect -> 0x4c33), seq 3784122596, win 65495, options [mss 65495,sackOK,TS val 1977541146 ecr 0,nop,wscale 7], length 0 + 2 16:57:31.257135 IP (tos 0x0, ttl 64, id 0, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.3309 > 127.0.0.1.40054: Flags [S.], cksum 0xfe30 (incorrect -> 0x21c6), seq 4139244470, ack 3784122597, win 65483, options [mss 65495,sackOK,TS val 1977541146 ecr 1977541146,nop,wscale 7], length 0 + 3 16:57:31.257142 IP (tos 0x0, ttl 64, id 10332, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40054 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x4882), ack 1, win 512, options [nop,nop,TS val 1977541146 ecr 1977541146], length 0 + 4 16:57:31.257310 IP (tos 0x0, ttl 64, id 36974, offset 0, flags [DF], proto TCP (6), length 180) + 127.0.0.1.3309 > 127.0.0.1.40054: Flags [P.], cksum 0xfea8 (incorrect -> 0x9c6b), seq 1:129, ack 1, win 512, options [nop,nop,TS val 1977541146 ecr 1977541146], length 128: IPROTO: greeting: version: Tarantool 2.10.4 (Binary), uuid: e6bd3069-1336-4934-97d1-61b2dc4392f9, salt: JbnlcBzGrEJqDYVKNsxXSle8r3Ya8zMIJFlmT0KrP/A= + 5 16:57:31.257314 IP (tos 0x0, ttl 64, id 10333, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40054 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x4803), ack 129, win 511, options [nop,nop,TS val 1977541146 ecr 1977541146], length 0 + 6 16:57:31.257375 IP (tos 0x0, ttl 64, id 10334, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.40054 > 127.0.0.1.3309: Flags [P.], cksum 0xfe30 (incorrect -> 0x762c), seq 1:9, ack 129, win 512, options [nop,nop,TS val 1977541146 ecr 1977541146], length 8: IPROTO size=3 request: VOTE + 7 16:57:31.257378 IP (tos 0x0, ttl 64, id 36975, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40054: Flags [.], cksum 0xfe28 (incorrect -> 0x47fa), ack 9, win 512, options [nop,nop,TS val 1977541146 ecr 1977541146], length 0 + 8 16:57:31.257559 IP (tos 0x0, ttl 64, id 36976, offset 0, flags [DF], proto TCP (6), length 97) + 127.0.0.1.3309 > 127.0.0.1.40054: Flags [P.], cksum 0xfe55 (incorrect -> 0x758b), seq 129:174, ack 9, win 512, options [nop,nop,TS val 1977541146 ecr 1977541146], length 45: IPROTO size=40 response: OK, SYNC: 0, SCHEMA_VERSION: 0 +[BALLOT] +BALLOT_IS_RO_CFG: false +BALLOT_IS_RO: true +BALLOT_IS_ANON: false +BALLOT_IS_BOOTED: false +BALLOT_VCLOCK: {} +BALLOT_GC_VCLOCK: {} +BALLOT_CAN_LEAD: false + 9 16:57:31.266905 IP (tos 0x0, ttl 64, id 10335, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40054 > 127.0.0.1.3309: Flags [F.], cksum 0xfe28 (incorrect -> 0x47c2), seq 9, ack 174, win 512, options [nop,nop,TS val 1977541156 ecr 1977541146], length 0 + 10 16:57:31.267007 IP (tos 0x0, ttl 64, id 36977, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40054: Flags [F.], cksum 0xfe28 (incorrect -> 0x47b7), seq 174, ack 10, win 512, options [nop,nop,TS val 1977541156 ecr 1977541156], length 0 + 11 16:57:31.267015 IP (tos 0x0, ttl 64, id 10336, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40054 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x47b7), ack 175, win 512, options [nop,nop,TS val 1977541156 ecr 1977541156], length 0 + 12 16:57:31.284958 IP (tos 0x0, ttl 64, id 43340, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [S], cksum 0xfe30 (incorrect -> 0x6d2b), seq 1357811807, win 65495, options [mss 65495,sackOK,TS val 1977541174 ecr 0,nop,wscale 7], length 0 + 13 16:57:31.284966 IP (tos 0x0, ttl 64, id 0, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [S.], cksum 0xfe30 (incorrect -> 0x98ba), seq 4221993135, ack 1357811808, win 65483, options [mss 65495,sackOK,TS val 1977541174 ecr 1977541174,nop,wscale 7], length 0 + 14 16:57:31.284972 IP (tos 0x0, ttl 64, id 43341, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0xbf76), ack 1, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 0 + 15 16:57:31.285240 IP (tos 0x0, ttl 64, id 57315, offset 0, flags [DF], proto TCP (6), length 180) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfea8 (incorrect -> 0x7bad), seq 1:129, ack 1, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 128: IPROTO: greeting: version: Tarantool 2.10.4 (Binary), uuid: e6bd3069-1336-4934-97d1-61b2dc4392f9, salt: 5LkiDWp/a/53A4ggshLxyD5we4CNJmaVQFQmKhl+GPE= + 16 16:57:31.285247 IP (tos 0x0, ttl 64, id 43342, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0xbef7), ack 129, win 511, options [nop,nop,TS val 1977541174 ecr 1977541174], length 0 + 17 16:57:31.285353 IP (tos 0x0, ttl 64, id 43343, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe30 (incorrect -> 0xed20), seq 1:9, ack 129, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 8: IPROTO size=3 request: VOTE + 18 16:57:31.285357 IP (tos 0x0, ttl 64, id 57316, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0xbeee), ack 9, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 0 + 19 16:57:31.285461 IP (tos 0x0, ttl 64, id 57317, offset 0, flags [DF], proto TCP (6), length 99) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe57 (incorrect -> 0xdf2c), seq 129:176, ack 9, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 47: IPROTO size=42 response: OK, SYNC: 0, SCHEMA_VERSION: 80 +[BALLOT] +BALLOT_IS_RO_CFG: false +BALLOT_IS_RO: false +BALLOT_IS_ANON: false +BALLOT_IS_BOOTED: true +BALLOT_VCLOCK: {1: 10} +BALLOT_GC_VCLOCK: {} +BALLOT_CAN_LEAD: false + 20 16:57:31.285500 IP (tos 0x0, ttl 64, id 43344, offset 0, flags [DF], proto TCP (6), length 106) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe5e (incorrect -> 0x3344), seq 9:63, ack 176, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 54: IPROTO size=49 request: AUTH, SYNC: 0 +USER_NAME: replicator +TUPLE: ["chap-sha1", "Ë\u0001\u0001È\"F”ê蔜u\u0011)-}À»\u001bà"] + 21 16:57:31.285673 IP (tos 0x0, ttl 64, id 57318, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x4f25), seq 176:205, ack 63, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 29: IPROTO size=24 response: OK, SYNC: 0, SCHEMA_VERSION: 80 + 22 16:57:31.285736 IP (tos 0x0, ttl 64, id 43345, offset 0, flags [DF], proto TCP (6), length 106) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe5e (incorrect -> 0xf90d), seq 63:117, ack 205, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 54: IPROTO size=49 request: JOIN, SYNC: 0 +INSTANCE_UUID: 144d18f7-75fd-4654-a083-6998c1f10622 +SERVER_VERSION: 133636 + 23 16:57:31.286004 IP (tos 0x0, ttl 64, id 57319, offset 0, flags [DF], proto TCP (6), length 65) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe35 (incorrect -> 0xdb76), seq 205:218, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541174], length 13: IPROTO size=8 response: HEARTBEAT +VCLOCK: {1: 10} + 24 16:57:31.286011 IP (tos 0x0, ttl 64, id 57320, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe30 (incorrect -> 0xec4f), seq 218:226, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541174], length 8: IPROTO size=3 request: JOIN_META, SYNC: 0 +VCLOCK: {1: 10} + 25 16:57:31.286014 IP (tos 0x0, ttl 64, id 57321, offset 0, flags [DF], proto TCP (6), length 69) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe39 (incorrect -> 0x5b0c), seq 226:243, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541174], length 17: IPROTO size=12 request: RAFT_PROMOTE, SYNC: 0, REPLICA_ID: 1 +REPLICA_ID: 1 +LSN: 0 +TERM: 2 + 26 16:57:31.286016 IP (tos 0x0, ttl 64, id 57322, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe30 (incorrect -> 0xec35), seq 243:251, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541174], length 8: IPROTO size=3 request: JOIN_SNAPSHOT, SYNC: 0 + 27 16:57:31.286048 IP (tos 0x0, ttl 64, id 43346, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0xbe06), ack 251, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 0 + 28 16:57:31.286105 IP (tos 0x0, ttl 64, id 57323, offset 0, flags [DF], proto TCP (6), length 115) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe67 (incorrect -> 0xc94f), seq 251:314, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 63: IPROTO size=58 request: INSERT, SYNC: 0 +SPACE: _schema (ID: 272) +TUPLE: ["cluster", "0fa96161-16e5-4cfa-ae7e-c342258abedc"] + 29 16:57:31.286111 IP (tos 0x0, ttl 64, id 57324, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0xca1e), seq 314:341, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 27: IPROTO size=22 request: INSERT, SYNC: 0 +SPACE: _schema (ID: 272) +TUPLE: ["max_id", 512] + 30 16:57:31.286115 IP (tos 0x0, ttl 64, id 57325, offset 0, flags [DF], proto TCP (6), length 80) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe44 (incorrect -> 0x18db), seq 341:369, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 28: IPROTO size=23 request: INSERT, SYNC: 0 +SPACE: _schema (ID: 272) +TUPLE: ["version", 2, 10, 4] + 31 16:57:31.286118 IP (tos 0x0, ttl 64, id 57326, offset 0, flags [DF], proto TCP (6), length 85) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe49 (incorrect -> 0x554d), seq 369:402, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 33: IPROTO size=28 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [0, "none", 1, "BINARY", "", {}] + 32 16:57:31.286120 IP (tos 0x0, ttl 64, id 57327, offset 0, flags [DF], proto TCP (6), length 103) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe5b (incorrect -> 0xa12b), seq 402:453, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 51: IPROTO size=46 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [1, "unicode", 1, "ICU", "", {"strength": "tertiary"}] + 33 16:57:31.286122 IP (tos 0x0, ttl 64, id 57328, offset 0, flags [DF], proto TCP (6), length 105) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe5d (incorrect -> 0x8d49), seq 453:506, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 53: IPROTO size=48 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [2, "unicode_ci", 1, "ICU", "", {"strength": "primary"}] + 34 16:57:31.286124 IP (tos 0x0, ttl 64, id 57329, offset 0, flags [DF], proto TCP (6), length 87) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe4b (incorrect -> 0xe158), seq 506:541, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 35: IPROTO size=30 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [3, "binary", 1, "BINARY", "", {}] + 35 16:57:31.286126 IP (tos 0x0, ttl 64, id 57330, offset 0, flags [DF], proto TCP (6), length 110) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe62 (incorrect -> 0x5c4a), seq 541:599, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [4, "unicode_af_s1", 1, "ICU", "af", {"strength": "primary"}] + 36 16:57:31.286128 IP (tos 0x0, ttl 64, id 57331, offset 0, flags [DF], proto TCP (6), length 112) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe64 (incorrect -> 0xfea0), seq 599:659, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [5, "unicode_af_s2", 1, "ICU", "af", {"strength": "secondary"}] + 37 16:57:31.286130 IP (tos 0x0, ttl 64, id 57332, offset 0, flags [DF], proto TCP (6), length 111) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe63 (incorrect -> 0xf7c0), seq 659:718, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [6, "unicode_af_s3", 1, "ICU", "af", {"strength": "tertiary"}] + 38 16:57:31.286166 IP (tos 0x0, ttl 64, id 43347, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0xbc33), ack 718, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 0 + 39 16:57:31.286173 IP (tos 0x0, ttl 64, id 57333, offset 0, flags [DF], proto TCP (6), length 5200) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0x1245 (incorrect -> 0x0021), seq 718:5866, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 5148: IPROTO size=53 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [7, "unicode_am_s1", 1, "ICU", "am", {"strength": "primary"}] + 40 16:57:31.286176 IP (tos 0x0, ttl 64, id 57334, offset 0, flags [DF], proto TCP (6), length 110) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe62 (incorrect -> 0x4527), seq 5866:5924, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [88, "unicode_ha_s1", 1, "ICU", "ha", {"strength": "primary"}] + 41 16:57:31.286178 IP (tos 0x0, ttl 64, id 57335, offset 0, flags [DF], proto TCP (6), length 112) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe64 (incorrect -> 0xe77d), seq 5924:5984, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [89, "unicode_ha_s2", 1, "ICU", "ha", {"strength": "secondary"}] + 42 16:57:31.286179 IP (tos 0x0, ttl 64, id 57336, offset 0, flags [DF], proto TCP (6), length 111) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe63 (incorrect -> 0xe09d), seq 5984:6043, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [90, "unicode_ha_s3", 1, "ICU", "ha", {"strength": "tertiary"}] + 43 16:57:31.286181 IP (tos 0x0, ttl 64, id 57337, offset 0, flags [DF], proto TCP (6), length 112) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe64 (incorrect -> 0x4181), seq 6043:6103, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [91, "unicode_haw_s1", 1, "ICU", "haw", {"strength": "primary"}] + 44 16:57:31.286183 IP (tos 0x0, ttl 64, id 57338, offset 0, flags [DF], proto TCP (6), length 114) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe66 (incorrect -> 0xe2d6), seq 6103:6165, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 62: IPROTO size=57 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [92, "unicode_haw_s2", 1, "ICU", "haw", {"strength": "secondary"}] + 45 16:57:31.286185 IP (tos 0x0, ttl 64, id 57339, offset 0, flags [DF], proto TCP (6), length 113) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe65 (incorrect -> 0xdaf5), seq 6165:6226, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 61: IPROTO size=56 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [93, "unicode_haw_s3", 1, "ICU", "haw", {"strength": "tertiary"}] + 46 16:57:31.286187 IP (tos 0x0, ttl 64, id 57340, offset 0, flags [DF], proto TCP (6), length 110) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe62 (incorrect -> 0x3fb5), seq 6226:6284, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [94, "unicode_he_s1", 1, "ICU", "he", {"strength": "primary"}] + 47 16:57:31.286189 IP (tos 0x0, ttl 64, id 57341, offset 0, flags [DF], proto TCP (6), length 112) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe64 (incorrect -> 0xe20b), seq 6284:6344, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [95, "unicode_he_s2", 1, "ICU", "he", {"strength": "secondary"}] + 48 16:57:31.286190 IP (tos 0x0, ttl 64, id 57342, offset 0, flags [DF], proto TCP (6), length 111) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe63 (incorrect -> 0xdb2b), seq 6344:6403, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [96, "unicode_he_s3", 1, "ICU", "he", {"strength": "tertiary"}] + 49 16:57:31.286192 IP (tos 0x0, ttl 64, id 57343, offset 0, flags [DF], proto TCP (6), length 110) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe62 (incorrect -> 0x3afd), seq 6403:6461, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [97, "unicode_hi_s1", 1, "ICU", "hi", {"strength": "primary"}] + 50 16:57:31.286194 IP (tos 0x0, ttl 64, id 57344, offset 0, flags [DF], proto TCP (6), length 112) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe64 (incorrect -> 0xdd53), seq 6461:6521, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [98, "unicode_hi_s2", 1, "ICU", "hi", {"strength": "secondary"}] + 51 16:57:31.286196 IP (tos 0x0, ttl 64, id 57345, offset 0, flags [DF], proto TCP (6), length 111) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe63 (incorrect -> 0xd673), seq 6521:6580, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [99, "unicode_hi_s3", 1, "ICU", "hi", {"strength": "tertiary"}] + 52 16:57:31.286198 IP (tos 0x0, ttl 64, id 57346, offset 0, flags [DF], proto TCP (6), length 110) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe62 (incorrect -> 0x3140), seq 6580:6638, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [100, "unicode_hr_s1", 1, "ICU", "hr", {"strength": "primary"}] + 53 16:57:31.286200 IP (tos 0x0, ttl 64, id 57347, offset 0, flags [DF], proto TCP (6), length 112) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe64 (incorrect -> 0xd396), seq 6638:6698, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [101, "unicode_hr_s2", 1, "ICU", "hr", {"strength": "secondary"}] + 54 16:57:31.286202 IP (tos 0x0, ttl 64, id 57348, offset 0, flags [DF], proto TCP (6), length 111) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe63 (incorrect -> 0xccb6), seq 6698:6757, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [102, "unicode_hr_s3", 1, "ICU", "hr", {"strength": "tertiary"}] + 55 16:57:31.286204 IP (tos 0x0, ttl 64, id 57349, offset 0, flags [DF], proto TCP (6), length 110) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe62 (incorrect -> 0x2d89), seq 6757:6815, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [103, "unicode_hu_s1", 1, "ICU", "hu", {"strength": "primary"}] + 56 16:57:31.286206 IP (tos 0x0, ttl 64, id 57350, offset 0, flags [DF], proto TCP (6), length 112) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe64 (incorrect -> 0xcfdf), seq 6815:6875, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [104, "unicode_hu_s2", 1, "ICU", "hu", {"strength": "secondary"}] + 57 16:57:31.286208 IP (tos 0x0, ttl 64, id 57351, offset 0, flags [DF], proto TCP (6), length 111) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe63 (incorrect -> 0xc8ff), seq 6875:6934, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [105, "unicode_hu_s3", 1, "ICU", "hu", {"strength": "tertiary"}] + 58 16:57:31.286210 IP (tos 0x0, ttl 64, id 57352, offset 0, flags [DF], proto TCP (6), length 110) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe62 (incorrect -> 0x28d1), seq 6934:6992, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [106, "unicode_hy_s1", 1, "ICU", "hy", {"strength": "primary"}] + 59 16:57:31.286312 IP (tos 0x0, ttl 64, id 43348, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0xa3e2), ack 6992, win 463, options [nop,nop,TS val 1977541175 ecr 1977541175], length 0 + 60 16:57:31.286319 IP (tos 0x0, ttl 64, id 57353, offset 0, flags [DF], proto TCP (6), length 19220) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0x4909 (incorrect -> 0xaa24), seq 6992:26160, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 19168: IPROTO size=55 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [107, "unicode_hy_s2", 1, "ICU", "hy", {"strength": "secondary"}] + 61 16:57:31.286320 IP (tos 0x0, ttl 64, id 57354, offset 0, flags [DF], proto TCP (6), length 89) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe4d (incorrect -> 0x6eab), seq 26160:26197, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 37: IPROTO size=32 request: INSERT, SYNC: 0 +SPACE: _user (ID: 304) +TUPLE: [3, 1, "replication", "role", {}] + 62 16:57:31.286322 IP (tos 0x0, ttl 64, id 57355, offset 0, flags [DF], proto TCP (6), length 83) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe47 (incorrect -> 0xa3b4), seq 26197:26228, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 31: IPROTO size=26 request: INSERT, SYNC: 0 +SPACE: _user (ID: 304) +TUPLE: [31, 1, "super", "role", {}] + 63 16:57:31.286325 IP (tos 0x0, ttl 64, id 57356, offset 0, flags [DF], proto TCP (6), length 127) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe73 (incorrect -> 0x8eea), seq 26228:26303, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 75: IPROTO size=70 request: INSERT, SYNC: 0 +SPACE: _user (ID: 304) +TUPLE: [32, 1, "replicator", "user", {"chap-sha1": "JHDAwG3uQv0WGLuZAFrcouydHhk="}] + 64 16:57:31.286328 IP (tos 0x0, ttl 64, id 57357, offset 0, flags [DF], proto TCP (6), length 78) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe42 (incorrect -> 0x75ea), seq 26303:26329, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 26: IPROTO size=21 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 0, "role", 2, 4] + 65 16:57:31.286330 IP (tos 0x0, ttl 64, id 57358, offset 0, flags [DF], proto TCP (6), length 82) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe46 (incorrect -> 0x9ac5), seq 26329:26359, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 30: IPROTO size=25 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 0, "universe", 0, 31] + 66 16:57:31.286332 IP (tos 0x0, ttl 64, id 57359, offset 0, flags [DF], proto TCP (6), length 86) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe4a (incorrect -> 0x94f4), seq 26359:26393, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 34: IPROTO size=29 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 1, "universe", 0, 4294967295] + 67 16:57:31.286334 IP (tos 0x0, ttl 64, id 57360, offset 0, flags [DF], proto TCP (6), length 82) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe46 (incorrect -> 0x96ac), seq 26393:26423, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 30: IPROTO size=25 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "function", 1, 4] + 68 16:57:31.286336 IP (tos 0x0, ttl 64, id 57361, offset 0, flags [DF], proto TCP (6), length 82) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe46 (incorrect -> 0x5691), seq 26423:26453, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 30: IPROTO size=25 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "function", 65, 1] + 69 16:57:31.286338 IP (tos 0x0, ttl 64, id 57362, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x1374), seq 26453:26482, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 276, 2] + 70 16:57:31.286340 IP (tos 0x0, ttl 64, id 57363, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x1456), seq 26482:26511, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 277, 1] + 71 16:57:31.286342 IP (tos 0x0, ttl 64, id 57364, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x1435), seq 26511:26540, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 281, 1] + 72 16:57:31.286344 IP (tos 0x0, ttl 64, id 57365, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x1413), seq 26540:26569, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 286, 1] + 73 16:57:31.286346 IP (tos 0x0, ttl 64, id 57366, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x13f3), seq 26569:26598, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 289, 1] + 74 16:57:31.286348 IP (tos 0x0, ttl 64, id 57367, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x13ce), seq 26598:26627, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 297, 1] + 75 16:57:31.286350 IP (tos 0x0, ttl 64, id 57368, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x13a9), seq 26627:26656, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 305, 1] + 76 16:57:31.286352 IP (tos 0x0, ttl 64, id 57369, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x1384), seq 26656:26685, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 313, 1] + 77 16:57:31.286354 IP (tos 0x0, ttl 64, id 57370, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x1256), seq 26685:26714, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 330, 2] + 78 16:57:31.286357 IP (tos 0x0, ttl 64, id 57371, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x1107), seq 26714:26743, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 380, 3] + 79 16:57:31.286359 IP (tos 0x0, ttl 64, id 57372, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x1126), seq 26743:26772, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 3, "space", 320, 2] + 80 16:57:31.286361 IP (tos 0x0, ttl 64, id 57373, offset 0, flags [DF], proto TCP (6), length 82) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe46 (incorrect -> 0x9628), seq 26772:26802, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 30: IPROTO size=25 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 3, "universe", 0, 1] + 81 16:57:31.286363 IP (tos 0x0, ttl 64, id 57374, offset 0, flags [DF], proto TCP (6), length 86) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe4a (incorrect -> 0x7539), seq 26802:26836, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 34: IPROTO size=29 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 31, "universe", 0, 4294967295] + 82 16:57:31.286365 IP (tos 0x0, ttl 64, id 57375, offset 0, flags [DF], proto TCP (6), length 78) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe42 (incorrect -> 0x53d5), seq 26836:26862, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 26: IPROTO size=21 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 32, "role", 2, 4] + 83 16:57:31.286369 IP (tos 0x0, ttl 64, id 57376, offset 0, flags [DF], proto TCP (6), length 78) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe42 (incorrect -> 0x52bb), seq 26862:26888, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 26: IPROTO size=21 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 32, "role", 3, 4] + 84 16:57:31.286371 IP (tos 0x0, ttl 64, id 57377, offset 0, flags [DF], proto TCP (6), length 82) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe46 (incorrect -> 0x789d), seq 26888:26918, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 30: IPROTO size=25 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 32, "universe", 0, 24] + 85 16:57:31.286373 IP (tos 0x0, ttl 64, id 57378, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0xb7a8), seq 26918:26945, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 27: IPROTO size=22 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 32, "user", 32, 128] + 86 16:57:31.286375 IP (tos 0x0, ttl 64, id 57379, offset 0, flags [DF], proto TCP (6), length 108) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe60 (incorrect -> 0xc36e), seq 26945:27001, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 56: IPROTO size=51 request: INSERT, SYNC: 0 +SPACE: _cluster (ID: 320) +TUPLE: [1, "e6bd3069-1336-4934-97d1-61b2dc4392f9"] + 87 16:57:31.286582 IP (tos 0x0, ttl 64, id 57380, offset 0, flags [DF], proto TCP (6), length 65) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe35 (incorrect -> 0x71c9), seq 27001:27014, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 13: IPROTO size=8 response: HEARTBEAT +VCLOCK: {1: 11} + 88 16:57:31.286719 IP (tos 0x0, ttl 64, id 57381, offset 0, flags [DF], proto TCP (6), length 120) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe6c (incorrect -> 0xecdd), seq 27014:27082, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 68: IPROTO size=63 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 11, TIMESTAMP: 2022-12-15 16:57:31.286489 +SPACE: _cluster (ID: 320) +TUPLE: [2, "144d18f7-75fd-4654-a083-6998c1f10622"] + 89 16:57:31.286800 IP (tos 0x0, ttl 64, id 57382, offset 0, flags [DF], proto TCP (6), length 65) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe35 (incorrect -> 0x7177), seq 27082:27095, ack 117, win 512, options [nop,nop,TS val 1977541176 ecr 1977541175], length 13: IPROTO size=8 response: HEARTBEAT +VCLOCK: {1: 11} + 90 16:57:31.290485 IP (tos 0x0, ttl 64, id 43349, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x55bf), ack 27095, win 359, options [nop,nop,TS val 1977541179 ecr 1977541175], length 0 + 91 16:57:31.295019 IP (tos 0x0, ttl 64, id 43350, offset 0, flags [DF], proto TCP (6), length 154) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe8e (incorrect -> 0x9680), seq 117:219, ack 27095, win 512, options [nop,nop,TS val 1977541184 ecr 1977541175], length 102: IPROTO size=97 request: SUBSCRIBE, SYNC: 0 +CLUSTER_UUID: 0fa96161-16e5-4cfa-ae7e-c342258abedc +INSTANCE_UUID: 144d18f7-75fd-4654-a083-6998c1f10622 +VCLOCK: {1: 11} +SERVER_VERSION: 133636 +REPLICA_ANON: false +ID_FILTER: [2] + 92 16:57:31.295163 IP (tos 0x0, ttl 64, id 57383, offset 0, flags [DF], proto TCP (6), length 106) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe5e (incorrect -> 0x7969), seq 27095:27149, ack 219, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 54: IPROTO size=49 response: OK, SYNC: 0, SCHEMA_VERSION: 0 +VCLOCK: {1: 11} +CLUSTER_UUID: 0fa96161-16e5-4cfa-ae7e-c342258abedc + 93 16:57:31.295184 IP (tos 0x0, ttl 64, id 57384, offset 0, flags [DF], proto TCP (6), length 67) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe37 (incorrect -> 0xefc0), seq 27149:27164, ack 219, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 15: IPROTO size=10 request: RAFT, GROUP_ID: 1, SYNC: 0 +RAFT_TERM: 2 +RAFT_STATE: 1 + 94 16:57:31.295204 IP (tos 0x0, ttl 64, id 43351, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x546d), ack 27164, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 0 + 95 16:57:31.295333 IP (tos 0x0, ttl 64, id 43352, offset 0, flags [DF], proto TCP (6), length 65) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe35 (incorrect -> 0x70ae), seq 219:232, ack 27164, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 13: IPROTO size=8 response: HEARTBEAT +VCLOCK: {1: 11} + 96 16:57:31.295554 IP (tos 0x0, ttl 64, id 57385, offset 0, flags [DF], proto TCP (6), length 72) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe3c (incorrect -> 0xdf3f), seq 27164:27184, ack 232, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 20: IPROTO size=15 request: HEARTBEAT, REPLICA_ID: 1, TIMESTAMP: 2022-12-15 16:57:31.295484 + 97 16:57:31.295749 IP (tos 0x0, ttl 64, id 43353, offset 0, flags [DF], proto TCP (6), length 65) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe35 (incorrect -> 0x708d), seq 232:245, ack 27184, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 13: IPROTO size=8 response: HEARTBEAT +VCLOCK: {1: 11} + 98 16:57:31.336637 IP (tos 0x0, ttl 64, id 57386, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x5416), ack 245, win 512, options [nop,nop,TS val 1977541225 ecr 1977541184], length 0 + 99 16:57:31.368370 IP (tos 0x0, ttl 64, id 12066, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [S], cksum 0xfe30 (incorrect -> 0x9bd3), seq 3722433644, win 65495, options [mss 65495,sackOK,TS val 1977541257 ecr 0,nop,wscale 7], length 0 + 100 16:57:31.368378 IP (tos 0x0, ttl 64, id 0, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [S.], cksum 0xfe30 (incorrect -> 0xb1ca), seq 3735401205, ack 3722433645, win 65483, options [mss 65495,sackOK,TS val 1977541257 ecr 1977541257,nop,wscale 7], length 0 + 101 16:57:31.368385 IP (tos 0x0, ttl 64, id 12067, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0xd886), ack 1, win 512, options [nop,nop,TS val 1977541257 ecr 1977541257], length 0 + 102 16:57:31.368682 IP (tos 0x0, ttl 64, id 51474, offset 0, flags [DF], proto TCP (6), length 180) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfea8 (incorrect -> 0x4f67), seq 1:129, ack 1, win 512, options [nop,nop,TS val 1977541257 ecr 1977541257], length 128: IPROTO: greeting: version: Tarantool 2.10.4 (Binary), uuid: e6bd3069-1336-4934-97d1-61b2dc4392f9, salt: IrPp7kzbyxmkm23YKBDponl9diEvxWKter1Z0mpJga8= + 103 16:57:31.368687 IP (tos 0x0, ttl 64, id 12068, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0xd807), ack 129, win 511, options [nop,nop,TS val 1977541257 ecr 1977541257], length 0 + 104 16:57:31.368744 IP (tos 0x0, ttl 64, id 12069, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xdc72), seq 1:20, ack 129, win 512, options [nop,nop,TS val 1977541257 ecr 1977541257], length 19: IPROTO size=14 request: ID, SYNC: 1 +VERSION: 3 +FEATURES: [0, 1, 2, 3] + 105 16:57:31.368748 IP (tos 0x0, ttl 64, id 51475, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [.], cksum 0xfe28 (incorrect -> 0xd7f3), ack 20, win 512, options [nop,nop,TS val 1977541257 ecr 1977541257], length 0 + 106 16:57:31.368886 IP (tos 0x0, ttl 64, id 51476, offset 0, flags [DF], proto TCP (6), length 89) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4d (incorrect -> 0xc2d9), seq 129:166, ack 20, win 512, options [nop,nop,TS val 1977541258 ecr 1977541257], length 37: IPROTO size=32 response: OK, SYNC: 1, SCHEMA_VERSION: 80 +VERSION: 3 +FEATURES: [0, 1, 2, 3] + 107 16:57:31.368950 IP (tos 0x0, ttl 64, id 12070, offset 0, flags [DF], proto TCP (6), length 121) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe6d (incorrect -> 0xbd35), seq 20:89, ack 166, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 69: IPROTO size=18 request: SELECT, SYNC: 2 +SPACE: _vspace (ID: 281) +LIMIT: 4294967295 +KEY: [] + 108 16:57:31.369122 IP (tos 0x0, ttl 64, id 51477, offset 0, flags [DF], proto TCP (6), length 19812) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0x4b59 (incorrect -> 0x3d22), seq 166:19926, ack 89, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 19760: IPROTO size=4641 response: OK, SYNC: 2, SCHEMA_VERSION: 80 +DATA: +[257, 1, "_vinyl_deferred_delete", "blackhole", 0, {"group_id": 1}, [{"name": "space_id", "type": "unsigned"}, {"name": "lsn", "type": "unsigned"}, {"name": "tuple", "type": "array"}]] +[272, 1, "_schema", "memtx", 0, {}, [{"type": "string", "name": "key"}, {"type": "any", "name": "value", "is_nullable": true}]] +[276, 1, "_collation", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "owner", "type": "unsigned"}, {"name": "type", "type": "string"}, {"name": "locale", "type": "string"}, {"name": "opts", "type": "map"}]] +[277, 1, "_vcollation", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "owner", "type": "unsigned"}, {"name": "type", "type": "string"}, {"name": "locale", "type": "string"}, {"name": "opts", "type": "map"}]] +[280, 1, "_space", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "engine", "type": "string"}, {"name": "field_count", "type": "unsigned"}, {"name": "flags", "type": "map"}, {"name": "format", "type": "array"}]] +[281, 1, "_vspace", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "engine", "type": "string"}, {"name": "field_count", "type": "unsigned"}, {"name": "flags", "type": "map"}, {"name": "format", "type": "array"}]] +[284, 1, "_sequence", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "step", "type": "integer"}, {"name": "min", "type": "integer"}, {"name": "max", "type": "integer"}, {"name": "start", "type": "integer"}, {"name": "cache", "type": "integer"}, {"name": "cycle", "type": "boolean"}]] +[285, 1, "_sequence_data", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "value", "type": "integer"}]] +[286, 1, "_vsequence", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "step", "type": "integer"}, {"name": "min", "type": "integer"}, {"name": "max", "type": "integer"}, {"name": "start", "type": "integer"}, {"name": "cache", "type": "integer"}, {"name": "cycle", "type": "boolean"}]] +[288, 1, "_index", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "iid", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "opts", "type": "map"}, {"name": "parts", "type": "array"}]] +[289, 1, "_vindex", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "iid", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "opts", "type": "map"}, {"name": "parts", "type": "array"}]] +[296, 1, "_func", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "setuid", "type": "unsigned"}, {"name": "language", "type": "string"}, {"name": "body", "type": "string"}, {"name": "routine_type", "type": "string"}, {"name": "param_list", "type": "array"}, {"name": "returns", "type": "string"}, {"name": "aggregate", "type": "string"}, {"name": "sql_data_access", "type": "string"}, {"name": "is_deterministic", "type": "boolean"}, {"name": "is_sandboxed", "type": "boolean"}, {"name": "is_null_call", "type": "boolean"}, {"name": "exports", "type": "array"}, {"name": "opts", "type": "map"}, {"name": "comment", "type": "string"}, {"name": "created", "type": "string"}, {"name": "last_altered", "type": "string"}]] +[297, 1, "_vfunc", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "setuid", "type": "unsigned"}, {"name": "language", "type": "string"}, {"name": "body", "type": "string"}, {"name": "routine_type", "type": "string"}, {"name": "param_list", "type": "array"}, {"name": "returns", "type": "string"}, {"name": "aggregate", "type": "string"}, {"name": "sql_data_access", "type": "string"}, {"name": "is_deterministic", "type": "boolean"}, {"name": "is_sandboxed", "type": "boolean"}, {"name": "is_null_call", "type": "boolean"}, {"name": "exports", "type": "array"}, {"name": "opts", "type": "map"}, {"name": "comment", "type": "string"}, {"name": "created", "type": "string"}, {"name": "last_altered", "type": "string"}]] +[304, 1, "_user", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "auth", "type": "map"}]] +[305, 1, "_vuser", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "auth", "type": "map"}]] +[312, 1, "_priv", "memtx", 0, {}, [{"name": "grantor", "type": "unsigned"}, {"name": "grantee", "type": "unsigned"}, {"name": "object_type", "type": "string"}, {"name": "object_id", "type": "scalar"}, {"name": "privilege", "type": "unsigned"}]] +[313, 1, "_vpriv", "sysview", 0, {}, [{"name": "grantor", "type": "unsigned"}, {"name": "grantee", "type": "unsigned"}, {"name": "object_type", "type": "string"}, {"name": "object_id", "type": "scalar"}, {"name": "privilege", "type": "unsigned"}]] +[320, 1, "_cluster", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "uuid", "type": "string"}]] +[328, 1, "_trigger", "memtx", 0, {}, [{"name": "name", "type": "string"}, {"name": "space_id", "type": "unsigned"}, {"name": "opts", "type": "map"}]] +[330, 1, "_truncate", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "count", "type": "unsigned"}]] +[340, 1, "_space_sequence", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "sequence_id", "type": "unsigned"}, {"name": "is_generated", "type": "boolean"}, {"name": "field", "type": "unsigned"}, {"name": "path", "type": "string"}]] +[356, 1, "_fk_constraint", "memtx", 0, {}, [{"name": "name", "type": "string"}, {"name": "child_id", "type": "unsigned"}, {"name": "parent_id", "type": "unsigned"}, {"name": "is_deferred", "type": "boolean"}, {"name": "match", "type": "string"}, {"name": "on_delete", "type": "string"}, {"name": "on_update", "type": "string"}, {"name": "child_cols", "type": "array"}, {"name": "parent_cols", "type": "array"}]] +[364, 1, "_ck_constraint", "memtx", 0, {}, [{"name": "space_id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "is_deferred", "type": "boolean"}, {"name": "language", "type": "str"}, {"name": "code", "type": "str"}, {"name": "is_enabled", "type": "boolean"}]] +[372, 1, "_func_index", "memtx", 0, {}, [{"name": "space_id", "type": "unsigned"}, {"name": "index_id", "type": "unsigned"}, {"name": "func_id", "type": "unsigned"}]] +[380, 1, "_session_settings", "service", 2, {"temporary": true}, [{"name": "name", "type": "string"}, {"name": "value", "type": "any"}]] +[512, 1, "testspace", "memtx", 0, {"is_sync": true}, []] + 109 16:57:31.369454 IP (tos 0x0, ttl 64, id 12071, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0x2375), seq 89:112, ack 19926, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 23: IPROTO size=18 + 110 16:57:31.369464 IP (tos 0x0, ttl 64, id 12072, offset 0, flags [DF], proto TCP (6), length 62) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe32 (incorrect -> 0xb566), seq 112:122, ack 19926, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 10: IPROTO size=5 request: PING, SYNC: 5 + 111 16:57:31.369561 IP (tos 0x0, ttl 64, id 51478, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [.], cksum 0xfe28 (incorrect -> 0x8a36), ack 122, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 0 + 112 16:57:31.369694 IP (tos 0x0, ttl 64, id 51479, offset 0, flags [DF], proto TCP (6), length 104) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe5c (incorrect -> 0x554f), seq 19926:19978, ack 122, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 52: IPROTO size=24 response: OK, SYNC: 5, SCHEMA_VERSION: 80 + 113 16:57:31.369766 IP (tos 0x0, ttl 64, id 12073, offset 0, flags [DF], proto TCP (6), length 94) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe52 (incorrect -> 0xfda8), seq 122:164, ack 19978, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 42: IPROTO size=14 request: INSERT, SYNC: 6 +SPACE_ID: 512 +TUPLE: [1, 10] + 114 16:57:31.370030 IP (tos 0x0, ttl 64, id 57387, offset 0, flags [DF], proto TCP (6), length 85) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe49 (incorrect -> 0x15e7), seq 27184:27217, ack 245, win 512, options [nop,nop,TS val 1977541259 ecr 1977541184], length 33: IPROTO size=28 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 12, TIMESTAMP: 2022-12-15 16:57:31.369981, FLAGS: 6 +SPACE_ID: 512 +TUPLE: [1, 10] + 115 16:57:31.370150 IP (tos 0x0, ttl 64, id 57388, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x7e7f), seq 27217:27244, ack 245, win 512, options [nop,nop,TS val 1977541259 ecr 1977541184], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 13, TIMESTAMP: 2022-12-15 16:57:31.370125 +REPLICA_ID: 1 +LSN: 12 + 116 16:57:31.370210 IP (tos 0x0, ttl 64, id 43354, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x536d), ack 27244, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 0 + 117 16:57:31.370210 IP (tos 0x0, ttl 64, id 51480, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x3097), seq 19978:20016, ack 164, win 512, options [nop,nop,TS val 1977541259 ecr 1977541258], length 38: IPROTO size=33 response: OK, SYNC: 6, SCHEMA_VERSION: 80 +DATA: +[1, 10] + 118 16:57:31.370301 IP (tos 0x0, ttl 64, id 12074, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xb6d2), seq 164:183, ack 20016, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 19: IPROTO size=14 request: INSERT, SYNC: 7 +SPACE_ID: 512 +TUPLE: [2, 20] + 119 16:57:31.370368 IP (tos 0x0, ttl 64, id 43355, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0x0a90), seq 245:268, ack 27244, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.369981 +VCLOCK: {1: 12} + 120 16:57:31.370446 IP (tos 0x0, ttl 64, id 57389, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x5356), ack 268, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 0 + 121 16:57:31.370452 IP (tos 0x0, ttl 64, id 43356, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0x071c), seq 268:291, ack 27244, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.370125 +VCLOCK: {1: 13} + 122 16:57:31.370460 IP (tos 0x0, ttl 64, id 57390, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x533f), ack 291, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 0 + 123 16:57:31.370481 IP (tos 0x0, ttl 64, id 57391, offset 0, flags [DF], proto TCP (6), length 85) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe49 (incorrect -> 0x0368), seq 27244:27277, ack 291, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 33: IPROTO size=28 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 14, TIMESTAMP: 2022-12-15 16:57:31.370455, FLAGS: 6 +SPACE_ID: 512 +TUPLE: [2, 20] + 124 16:57:31.370486 IP (tos 0x0, ttl 64, id 57392, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x7625), seq 27277:27304, ack 291, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 15, TIMESTAMP: 2022-12-15 16:57:31.370469 +REPLICA_ID: 1 +LSN: 14 + 125 16:57:31.370566 IP (tos 0x0, ttl 64, id 51481, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x2f52), seq 20016:20054, ack 183, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 38: IPROTO size=33 response: OK, SYNC: 7, SCHEMA_VERSION: 80 +DATA: +[2, 20] + 126 16:57:31.370566 IP (tos 0x0, ttl 64, id 43357, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x5303), ack 27304, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 0 + 127 16:57:31.370627 IP (tos 0x0, ttl 64, id 12075, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xac97), seq 183:202, ack 20054, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 19: IPROTO size=14 request: INSERT, SYNC: 8 +SPACE_ID: 512 +TUPLE: [3, 30] + 128 16:57:31.370804 IP (tos 0x0, ttl 64, id 43358, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0x005e), seq 291:314, ack 27304, win 512, options [nop,nop,TS val 1977541260 ecr 1977541259], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.370455 +VCLOCK: {1: 14} + 129 16:57:31.370845 IP (tos 0x0, ttl 64, id 57393, offset 0, flags [DF], proto TCP (6), length 85) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe49 (incorrect -> 0xf394), seq 27304:27337, ack 314, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 33: IPROTO size=28 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 16, TIMESTAMP: 2022-12-15 16:57:31.370790, FLAGS: 6 +SPACE_ID: 512 +TUPLE: [3, 30] + 130 16:57:31.370868 IP (tos 0x0, ttl 64, id 57394, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x6d93), seq 27337:27364, ack 314, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 17, TIMESTAMP: 2022-12-15 16:57:31.370849 +REPLICA_ID: 1 +LSN: 16 + 131 16:57:31.370898 IP (tos 0x0, ttl 64, id 43359, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x52ae), ack 27364, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 132 16:57:31.370907 IP (tos 0x0, ttl 64, id 43360, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xfed0), seq 314:337, ack 27364, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.370469 +VCLOCK: {1: 15} + 133 16:57:31.371014 IP (tos 0x0, ttl 64, id 51482, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x2e0d), seq 20054:20092, ack 202, win 512, options [nop,nop,TS val 1977541260 ecr 1977541259], length 38: IPROTO size=33 response: OK, SYNC: 8, SCHEMA_VERSION: 80 +DATA: +[3, 30] + 134 16:57:31.371066 IP (tos 0x0, ttl 64, id 12076, offset 0, flags [DF], proto TCP (6), length 88) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe4c (incorrect -> 0x7165), seq 202:238, ack 20092, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 36: IPROTO size=31 request: INSERT, SYNC: 9 +SPACE_ID: 512 +TUPLE: [4, (UUID: 8ca72637-11b1-4d80-8ac8-8f530a623953)] + 135 16:57:31.371114 IP (tos 0x0, ttl 64, id 43361, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xf877), seq 337:360, ack 27364, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.370790 +VCLOCK: {1: 16} + 136 16:57:31.371124 IP (tos 0x0, ttl 64, id 43362, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xf667), seq 360:383, ack 27364, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.370849 +VCLOCK: {1: 17} + 137 16:57:31.371200 IP (tos 0x0, ttl 64, id 57395, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x5269), ack 383, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 138 16:57:31.371215 IP (tos 0x0, ttl 64, id 57396, offset 0, flags [DF], proto TCP (6), length 102) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe5a (incorrect -> 0xb189), seq 27364:27414, ack 383, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 50: IPROTO size=45 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 18, TIMESTAMP: 2022-12-15 16:57:31.371191, FLAGS: 6 +SPACE_ID: 512 +TUPLE: [4, (UUID: 8ca72637-11b1-4d80-8ac8-8f530a623953)] + 139 16:57:31.371222 IP (tos 0x0, ttl 64, id 57397, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x6501), seq 27414:27441, ack 383, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 19, TIMESTAMP: 2022-12-15 16:57:31.371215 +REPLICA_ID: 1 +LSN: 18 + 140 16:57:31.371229 IP (tos 0x0, ttl 64, id 43363, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x521c), ack 27441, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 141 16:57:31.371234 IP (tos 0x0, ttl 64, id 51483, offset 0, flags [DF], proto TCP (6), length 107) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe5f (incorrect -> 0x3786), seq 20092:20147, ack 238, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 55: IPROTO size=50 response: OK, SYNC: 9, SCHEMA_VERSION: 80 +DATA: +[4, (UUID: 8ca72637-11b1-4d80-8ac8-8f530a623953)] + 142 16:57:31.371254 IP (tos 0x0, ttl 64, id 12077, offset 0, flags [DF], proto TCP (6), length 86) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe4a (incorrect -> 0x50cc), seq 238:272, ack 20147, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 34: IPROTO size=29 request: INSERT, SYNC: 10 +SPACE_ID: 512 +TUPLE: [5, (Decimal: -0987654321.0000000000123)] + 143 16:57:31.371308 IP (tos 0x0, ttl 64, id 43364, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xef6a), seq 383:406, ack 27441, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371191 +VCLOCK: {1: 18} + 144 16:57:31.371317 IP (tos 0x0, ttl 64, id 43365, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xedee), seq 406:429, ack 27441, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371215 +VCLOCK: {1: 19} + 145 16:57:31.371329 IP (tos 0x0, ttl 64, id 57398, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x51ee), ack 429, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 146 16:57:31.371341 IP (tos 0x0, ttl 64, id 51484, offset 0, flags [DF], proto TCP (6), length 105) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe5d (incorrect -> 0xfa0b), seq 20147:20200, ack 272, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 53: IPROTO size=48 response: OK, SYNC: 10, SCHEMA_VERSION: 80 +DATA: +[5, (Decimal: -0987654321.0000000000123)] + 147 16:57:31.371343 IP (tos 0x0, ttl 64, id 57399, offset 0, flags [DF], proto TCP (6), length 100) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe58 (incorrect -> 0x8ee5), seq 27441:27489, ack 429, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 48: IPROTO size=43 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 20, TIMESTAMP: 2022-12-15 16:57:31.371308, FLAGS: 6 +SPACE_ID: 512 +TUPLE: [5, (Decimal: -0987654321.0000000000123)] + 148 16:57:31.371348 IP (tos 0x0, ttl 64, id 57400, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x60b6), seq 27489:27516, ack 429, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 21, TIMESTAMP: 2022-12-15 16:57:31.371325 +REPLICA_ID: 1 +LSN: 20 + 149 16:57:31.371352 IP (tos 0x0, ttl 64, id 12078, offset 0, flags [DF], proto TCP (6), length 91) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe4f (incorrect -> 0x26b1), seq 272:311, ack 20200, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 39: IPROTO size=34 request: INSERT, SYNC: 11 +SPACE_ID: 512 +TUPLE: [6, (Decimal: 0.0123456789876543212345678987654321)] + 150 16:57:31.371352 IP (tos 0x0, ttl 64, id 43366, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x51a3), ack 27516, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 151 16:57:31.371378 IP (tos 0x0, ttl 64, id 57401, offset 0, flags [DF], proto TCP (6), length 105) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe5d (incorrect -> 0x63ec), seq 27516:27569, ack 429, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 53: IPROTO size=48 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 22, TIMESTAMP: 2022-12-15 16:57:31.371363, FLAGS: 6 +SPACE_ID: 512 +TUPLE: [6, (Decimal: 0.0123456789876543212345678987654321)] + 152 16:57:31.371384 IP (tos 0x0, ttl 64, id 57402, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x5d8c), seq 27569:27596, ack 429, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 23, TIMESTAMP: 2022-12-15 16:57:31.371377 +REPLICA_ID: 1 +LSN: 22 + 153 16:57:31.371391 IP (tos 0x0, ttl 64, id 51485, offset 0, flags [DF], proto TCP (6), length 110) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe62 (incorrect -> 0x3685), seq 20200:20258, ack 311, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 58: IPROTO size=53 response: OK, SYNC: 11, SCHEMA_VERSION: 80 +DATA: +[6, (Decimal: 0.0123456789876543212345678987654321)] + 154 16:57:31.371392 IP (tos 0x0, ttl 64, id 43367, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x5153), ack 27596, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 155 16:57:31.371417 IP (tos 0x0, ttl 64, id 43368, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xeab7), seq 429:452, ack 27596, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371308 +VCLOCK: {1: 20} + 156 16:57:31.371430 IP (tos 0x0, ttl 64, id 43369, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xe955), seq 452:475, ack 27596, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371325 +VCLOCK: {1: 21} + 157 16:57:31.371435 IP (tos 0x0, ttl 64, id 57403, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x5125), ack 475, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 158 16:57:31.371435 IP (tos 0x0, ttl 64, id 43370, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xe7a0), seq 475:498, ack 27596, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371363 +VCLOCK: {1: 22} + 159 16:57:31.371443 IP (tos 0x0, ttl 64, id 12079, offset 0, flags [DF], proto TCP (6), length 88) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe4c (incorrect -> 0x14d0), seq 311:347, ack 20258, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 36: IPROTO size=31 request: INSERT, SYNC: 12 +SPACE_ID: 512 +TUPLE: [7, (Datetime: len 16)] + 160 16:57:31.371451 IP (tos 0x0, ttl 64, id 43371, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xe64f), seq 498:521, ack 27596, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371377 +VCLOCK: {1: 23} + 161 16:57:31.371457 IP (tos 0x0, ttl 64, id 57404, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x50f7), ack 521, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 162 16:57:31.371476 IP (tos 0x0, ttl 64, id 57405, offset 0, flags [DF], proto TCP (6), length 102) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe5a (incorrect -> 0x502d), seq 27596:27646, ack 521, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 50: IPROTO size=45 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 24, TIMESTAMP: 2022-12-15 16:57:31.371459, FLAGS: 6 +SPACE_ID: 512 +TUPLE: [7, (Datetime: len 16)] + 163 16:57:31.371479 IP (tos 0x0, ttl 64, id 51486, offset 0, flags [DF], proto TCP (6), length 107) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe5f (incorrect -> 0xb714), seq 20258:20313, ack 347, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 55: IPROTO size=50 response: OK, SYNC: 12, SCHEMA_VERSION: 80 +DATA: +[7, (Datetime: len 16)] + 164 16:57:31.371480 IP (tos 0x0, ttl 64, id 57406, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x5972), seq 27646:27673, ack 521, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 25, TIMESTAMP: 2022-12-15 16:57:31.371464 +REPLICA_ID: 1 +LSN: 24 + 165 16:57:31.371484 IP (tos 0x0, ttl 64, id 43372, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x50aa), ack 27673, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 166 16:57:31.371492 IP (tos 0x0, ttl 64, id 12080, offset 0, flags [DF], proto TCP (6), length 78) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe42 (incorrect -> 0xbc9c), seq 347:373, ack 20313, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 26: IPROTO size=21 request: SELECT, SYNC: 13 +SPACE_ID: 512 +INDEX_ID: 0 +ITERATOR: EQ +OFFSET: 0 +LIMIT: 2 +KEY: [1] + 167 16:57:31.371509 IP (tos 0x0, ttl 64, id 51487, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x2e6d), seq 20313:20351, ack 373, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 38: IPROTO size=33 response: OK, SYNC: 13, SCHEMA_VERSION: 80 +DATA: +[1, 10] + 168 16:57:31.371522 IP (tos 0x0, ttl 64, id 12081, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe45 (incorrect -> 0xec58), seq 373:402, ack 20351, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 29: IPROTO size=24 request: SELECT, SYNC: 14 +SPACE_ID: 512 +INDEX_ID: 0 +ITERATOR: ALL +OFFSET: 0 +LIMIT: 4294967295 +KEY: [] + 169 16:57:31.371534 IP (tos 0x0, ttl 64, id 51488, offset 0, flags [DF], proto TCP (6), length 177) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfea5 (incorrect -> 0xc7f2), seq 20351:20476, ack 402, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 125: IPROTO size=120 response: OK, SYNC: 14, SCHEMA_VERSION: 80 +DATA: +[1, 10] +[2, 20] +[3, 30] +[4, (UUID: 8ca72637-11b1-4d80-8ac8-8f530a623953)] +[5, (Decimal: -0987654321.0000000000123)] +[6, (Decimal: 0.0123456789876543212345678987654321)] +[7, (Datetime: len 16)] + 170 16:57:31.371546 IP (tos 0x0, ttl 64, id 12082, offset 0, flags [DF], proto TCP (6), length 73) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3d (incorrect -> 0xb601), seq 402:423, ack 20476, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 21: IPROTO size=16 request: REPLACE, SYNC: 15 +SPACE_ID: 512 +TUPLE: [5, 6, 7, 8] + 171 16:57:31.371567 IP (tos 0x0, ttl 64, id 43373, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xe393), seq 521:544, ack 27673, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371459 +VCLOCK: {1: 24} + 172 16:57:31.371579 IP (tos 0x0, ttl 64, id 43374, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xe265), seq 544:567, ack 27673, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371464 +VCLOCK: {1: 25} + 173 16:57:31.371612 IP (tos 0x0, ttl 64, id 57407, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x507c), ack 567, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 174 16:57:31.371626 IP (tos 0x0, ttl 64, id 57408, offset 0, flags [DF], proto TCP (6), length 87) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe4b (incorrect -> 0xefd1), seq 27673:27708, ack 567, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 35: IPROTO size=30 request: REPLACE, SYNC: 0, REPLICA_ID: 1, LSN: 26, TIMESTAMP: 2022-12-15 16:57:31.371598, FLAGS: 6 +SPACE_ID: 512 +TUPLE: [5, 6, 7, 8] + 175 16:57:31.371633 IP (tos 0x0, ttl 64, id 57409, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x5470), seq 27708:27735, ack 567, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 27, TIMESTAMP: 2022-12-15 16:57:31.371622 +REPLICA_ID: 1 +LSN: 26 + 176 16:57:31.371635 IP (tos 0x0, ttl 64, id 51489, offset 0, flags [DF], proto TCP (6), length 92) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe50 (incorrect -> 0x208e), seq 20476:20516, ack 423, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 40: IPROTO size=35 response: OK, SYNC: 15, SCHEMA_VERSION: 80 +DATA: +[5, 6, 7, 8] + 177 16:57:31.371639 IP (tos 0x0, ttl 64, id 43375, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x503e), ack 27735, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 178 16:57:31.371650 IP (tos 0x0, ttl 64, id 12083, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe45 (incorrect -> 0xc36b), seq 423:452, ack 20516, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 29: IPROTO size=24 request: UPDATE, SYNC: 16 +SPACE_ID: 512 +INDEX_ID: 0 +INDEX_BASE: 1 +KEY: [1] +TUPLE: [["=", 2, 5]] + 179 16:57:31.371705 IP (tos 0x0, ttl 64, id 43376, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xdedf), seq 567:590, ack 27735, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371598 +VCLOCK: {1: 26} + 180 16:57:31.371722 IP (tos 0x0, ttl 64, id 43377, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xdd65), seq 590:613, ack 27735, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371622 +VCLOCK: {1: 27} + 181 16:57:31.371734 IP (tos 0x0, ttl 64, id 57410, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x5010), ack 613, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 182 16:57:31.371751 IP (tos 0x0, ttl 64, id 57411, offset 0, flags [DF], proto TCP (6), length 93) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe51 (incorrect -> 0xfe0b), seq 27735:27776, ack 613, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 41: IPROTO size=36 request: UPDATE, SYNC: 0, REPLICA_ID: 1, LSN: 28, TIMESTAMP: 2022-12-15 16:57:31.371725, FLAGS: 6 +SPACE_ID: 512 +INDEX_BASE: 1 +KEY: [1] +TUPLE: [["=", 2, 5]] + 183 16:57:31.371759 IP (tos 0x0, ttl 64, id 57412, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x4ff1), seq 27776:27803, ack 613, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 29, TIMESTAMP: 2022-12-15 16:57:31.371747 +REPLICA_ID: 1 +LSN: 28 + 184 16:57:31.371760 IP (tos 0x0, ttl 64, id 51490, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x2d55), seq 20516:20554, ack 452, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 38: IPROTO size=33 response: OK, SYNC: 16, SCHEMA_VERSION: 80 +DATA: +[1, 5] + 185 16:57:31.371765 IP (tos 0x0, ttl 64, id 43378, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x4fcc), ack 27803, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 186 16:57:31.371774 IP (tos 0x0, ttl 64, id 12084, offset 0, flags [DF], proto TCP (6), length 88) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe4c (incorrect -> 0x0551), seq 452:488, ack 20554, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 36: IPROTO size=31 request: UPSERT, SYNC: 17 +SPACE_ID: 512 +INDEX_BASE: 1 +TUPLE: [12, "c"] +OPS: [["=", 3, "a"], ["=", 4, "b"]] + 187 16:57:31.371819 IP (tos 0x0, ttl 64, id 57413, offset 0, flags [DF], proto TCP (6), length 102) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe5a (incorrect -> 0xa723), seq 27803:27853, ack 613, win 512, options [nop,nop,TS val 1977541261 ecr 1977541260], length 50: IPROTO size=45 request: UPSERT, SYNC: 0, REPLICA_ID: 1, LSN: 30, TIMESTAMP: 2022-12-15 16:57:31.371804, FLAGS: 6 +SPACE_ID: 512 +INDEX_BASE: 1 +OPS: [["=", 3, "a"], ["=", 4, "b"]] +TUPLE: [12, "c"] + 188 16:57:31.371825 IP (tos 0x0, ttl 64, id 57414, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x4c86), seq 27853:27880, ack 613, win 512, options [nop,nop,TS val 1977541261 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 31, TIMESTAMP: 2022-12-15 16:57:31.371814 +REPLICA_ID: 1 +LSN: 30 + 189 16:57:31.371826 IP (tos 0x0, ttl 64, id 51491, offset 0, flags [DF], proto TCP (6), length 87) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4b (incorrect -> 0x32a3), seq 20554:20589, ack 488, win 512, options [nop,nop,TS val 1977541261 ecr 1977541260], length 35: IPROTO size=30 response: OK, SYNC: 17, SCHEMA_VERSION: 80 + 190 16:57:31.371828 IP (tos 0x0, ttl 64, id 43379, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xda0b), seq 613:636, ack 27880, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371725 +VCLOCK: {1: 28} + 191 16:57:31.371836 IP (tos 0x0, ttl 64, id 12085, offset 0, flags [DF], proto TCP (6), length 72) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3c (incorrect -> 0xc62f), seq 488:508, ack 20589, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 20: IPROTO size=15 request: DELETE, SYNC: 18 +SPACE_ID: 512 +INDEX_ID: 0 +KEY: [1] + 192 16:57:31.371841 IP (tos 0x0, ttl 64, id 43380, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xd899), seq 636:659, ack 27880, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371747 +VCLOCK: {1: 29} + 193 16:57:31.371846 IP (tos 0x0, ttl 64, id 57415, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x4f4f), ack 659, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 194 16:57:31.371861 IP (tos 0x0, ttl 64, id 57416, offset 0, flags [DF], proto TCP (6), length 84) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe48 (incorrect -> 0xfe91), seq 27880:27912, ack 659, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 32: IPROTO size=27 request: DELETE, SYNC: 0, REPLICA_ID: 1, LSN: 32, TIMESTAMP: 2022-12-15 16:57:31.371849, FLAGS: 6 +SPACE_ID: 512 +KEY: [1] + 195 16:57:31.371868 IP (tos 0x0, ttl 64, id 57417, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x4968), seq 27912:27939, ack 659, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 33, TIMESTAMP: 2022-12-15 16:57:31.371856 +REPLICA_ID: 1 +LSN: 32 + 196 16:57:31.371870 IP (tos 0x0, ttl 64, id 51492, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x2cd0), seq 20589:20627, ack 508, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 38: IPROTO size=33 response: OK, SYNC: 18, SCHEMA_VERSION: 80 +DATA: +[1, 5] + 197 16:57:31.371873 IP (tos 0x0, ttl 64, id 43381, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x4f14), ack 27939, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 198 16:57:31.371880 IP (tos 0x0, ttl 64, id 12086, offset 0, flags [DF], proto TCP (6), length 72) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3c (incorrect -> 0xc5f3), seq 508:528, ack 20627, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 20: IPROTO size=15 request: DELETE, SYNC: 19 +SPACE_ID: 512 +INDEX_ID: 0 +KEY: [2] + 199 16:57:31.371930 IP (tos 0x0, ttl 64, id 43382, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xd656), seq 659:682, ack 27939, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371804 +VCLOCK: {1: 30} + 200 16:57:31.371948 IP (tos 0x0, ttl 64, id 43383, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xd515), seq 682:705, ack 27939, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371814 +VCLOCK: {1: 31} + 201 16:57:31.371958 IP (tos 0x0, ttl 64, id 43384, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xd36d), seq 705:728, ack 27939, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371849 +VCLOCK: {1: 32} + 202 16:57:31.371960 IP (tos 0x0, ttl 64, id 57418, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x4ee6), ack 705, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 203 16:57:31.371971 IP (tos 0x0, ttl 64, id 43385, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xd235), seq 728:751, ack 27939, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371856 +VCLOCK: {1: 33} + 204 16:57:31.371977 IP (tos 0x0, ttl 64, id 57419, offset 0, flags [DF], proto TCP (6), length 84) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe48 (incorrect -> 0xfc48), seq 27939:27971, ack 751, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 32: IPROTO size=27 request: DELETE, SYNC: 0, REPLICA_ID: 1, LSN: 34, TIMESTAMP: 2022-12-15 16:57:31.371951, FLAGS: 6 +SPACE_ID: 512 +KEY: [2] + 205 16:57:31.371984 IP (tos 0x0, ttl 64, id 51493, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x2b86), seq 20627:20665, ack 528, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 38: IPROTO size=33 response: OK, SYNC: 19, SCHEMA_VERSION: 80 +DATA: +[2, 20] + 206 16:57:31.371984 IP (tos 0x0, ttl 64, id 57420, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x44f0), seq 27971:27998, ack 751, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 35, TIMESTAMP: 2022-12-15 16:57:31.371971 +REPLICA_ID: 1 +LSN: 34 + 207 16:57:31.371988 IP (tos 0x0, ttl 64, id 43386, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x4e7d), ack 27998, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 208 16:57:31.371995 IP (tos 0x0, ttl 64, id 12087, offset 0, flags [DF], proto TCP (6), length 72) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3c (incorrect -> 0xc5b7), seq 528:548, ack 20665, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 20: IPROTO size=15 request: DELETE, SYNC: 20 +SPACE_ID: 512 +INDEX_ID: 0 +KEY: [3] + 209 16:57:31.372021 IP (tos 0x0, ttl 64, id 57421, offset 0, flags [DF], proto TCP (6), length 84) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe48 (incorrect -> 0xfb21), seq 27998:28030, ack 751, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 32: IPROTO size=27 request: DELETE, SYNC: 0, REPLICA_ID: 1, LSN: 36, TIMESTAMP: 2022-12-15 16:57:31.372007, FLAGS: 6 +SPACE_ID: 512 +KEY: [3] + 210 16:57:31.372031 IP (tos 0x0, ttl 64, id 57422, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x41e2), seq 28030:28057, ack 751, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 37, TIMESTAMP: 2022-12-15 16:57:31.372020 +REPLICA_ID: 1 +LSN: 36 + 211 16:57:31.372036 IP (tos 0x0, ttl 64, id 43387, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x4e42), ack 28057, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 212 16:57:31.372036 IP (tos 0x0, ttl 64, id 51494, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x2a41), seq 20665:20703, ack 548, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 38: IPROTO size=33 response: OK, SYNC: 20, SCHEMA_VERSION: 80 +DATA: +[3, 30] + 213 16:57:31.372046 IP (tos 0x0, ttl 64, id 12088, offset 0, flags [DF], proto TCP (6), length 112) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe64 (incorrect -> 0x6e7a), seq 548:608, ack 20703, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 60: IPROTO size=55 request: EVAL, SYNC: 21 +EXPR: function f5() return 5 + 5 end; return f5(); +TUPLE: [] + 214 16:57:31.372059 IP (tos 0x0, ttl 64, id 43388, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xcf1a), seq 751:774, ack 28057, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371951 +VCLOCK: {1: 34} + 215 16:57:31.372070 IP (tos 0x0, ttl 64, id 51495, offset 0, flags [DF], proto TCP (6), length 88) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4c (incorrect -> 0x2f86), seq 20703:20739, ack 608, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 36: IPROTO size=31 response: OK, SYNC: 21, SCHEMA_VERSION: 80 +DATA: +10 + 216 16:57:31.372079 IP (tos 0x0, ttl 64, id 43389, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xcdb2), seq 774:797, ack 28057, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371971 +VCLOCK: {1: 35} + 217 16:57:31.372084 IP (tos 0x0, ttl 64, id 43390, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xcc03), seq 797:820, ack 28057, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.372007 +VCLOCK: {1: 36} + 218 16:57:31.372085 IP (tos 0x0, ttl 64, id 12089, offset 0, flags [DF], proto TCP (6), length 83) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe47 (incorrect -> 0xb82f), seq 608:639, ack 20739, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 31: IPROTO size=26 request: EVAL, SYNC: 22 +EXPR: return ... +TUPLE: [1, 2, [3, "x"]] + 219 16:57:31.372113 IP (tos 0x0, ttl 64, id 51496, offset 0, flags [DF], proto TCP (6), length 93) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe51 (incorrect -> 0xaa12), seq 20739:20780, ack 639, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 41: IPROTO size=36 response: OK, SYNC: 22, SCHEMA_VERSION: 80 +DATA: +1 +2 +[3, "x"] + 220 16:57:31.372121 IP (tos 0x0, ttl 64, id 12090, offset 0, flags [DF], proto TCP (6), length 98) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe56 (incorrect -> 0x218e), seq 639:685, ack 20780, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 46: IPROTO size=41 request: EVAL, SYNC: 23 +EXPR: function f1() return 5 + 5 end; +TUPLE: [] + 221 16:57:31.372127 IP (tos 0x0, ttl 64, id 57423, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x4dfd), ack 820, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 222 16:57:31.372139 IP (tos 0x0, ttl 64, id 51497, offset 0, flags [DF], proto TCP (6), length 87) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4b (incorrect -> 0x30f5), seq 20780:20815, ack 685, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 35: IPROTO size=30 response: OK, SYNC: 23, SCHEMA_VERSION: 80 + 223 16:57:31.372155 IP (tos 0x0, ttl 64, id 12091, offset 0, flags [DF], proto TCP (6), length 69) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe39 (incorrect -> 0xc31b), seq 685:702, ack 20815, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 17: IPROTO size=12 request: CALL, SYNC: 24 +FUNCTION_NAME: f1 +TUPLE: [] + 224 16:57:31.372170 IP (tos 0x0, ttl 64, id 51498, offset 0, flags [DF], proto TCP (6), length 88) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4c (incorrect -> 0x2eb5), seq 20815:20851, ack 702, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 36: IPROTO size=31 response: OK, SYNC: 24, SCHEMA_VERSION: 80 +DATA: +10 + 225 16:57:31.372180 IP (tos 0x0, ttl 64, id 12092, offset 0, flags [DF], proto TCP (6), length 102) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe5a (incorrect -> 0x54e6), seq 702:752, ack 20851, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 50: IPROTO size=45 request: EVAL, SYNC: 25 +EXPR: function f2(x, y) return x, y end; +TUPLE: [] + 226 16:57:31.372181 IP (tos 0x0, ttl 64, id 43391, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xcab3), seq 820:843, ack 28057, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.372020 +VCLOCK: {1: 37} + 227 16:57:31.372197 IP (tos 0x0, ttl 64, id 51499, offset 0, flags [DF], proto TCP (6), length 87) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4b (incorrect -> 0x3069), seq 20851:20886, ack 752, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 35: IPROTO size=30 response: OK, SYNC: 25, SCHEMA_VERSION: 80 + 228 16:57:31.372204 IP (tos 0x0, ttl 64, id 12093, offset 0, flags [DF], proto TCP (6), length 72) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3c (incorrect -> 0x1b49), seq 752:772, ack 20886, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 20: IPROTO size=15 request: CALL, SYNC: 26 +FUNCTION_NAME: f2 +TUPLE: [1, "B"] + 229 16:57:31.372216 IP (tos 0x0, ttl 64, id 51500, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x89ea), seq 20886:20924, ack 772, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 38: IPROTO size=33 response: OK, SYNC: 26, SCHEMA_VERSION: 80 +DATA: +1 +"B" + 230 16:57:31.372224 IP (tos 0x0, ttl 64, id 12094, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe43 (incorrect -> 0xb620), seq 772:799, ack 20924, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 27: IPROTO size=22 request: PREPARE, SYNC: 27 +SQL_TEXT: VALUES (?, ?); + 231 16:57:31.372270 IP (tos 0x0, ttl 64, id 51501, offset 0, flags [DF], proto TCP (6), length 151) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe8b (incorrect -> 0x555e), seq 20924:21023, ack 799, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 99: IPROTO size=94 response: OK, SYNC: 27, SCHEMA_VERSION: 80 +STMT_ID: 3618272283 +BIND_COUNT: 2 +BIND_METADATA: [{0: "?", 1: "ANY"}, {0: "?", 1: "ANY"}] +METADATA: [{0: "COLUMN_1", 1: "boolean"}, {0: "COLUMN_2", 1: "boolean"}] + 232 16:57:31.372281 IP (tos 0x0, ttl 64, id 12095, offset 0, flags [DF], proto TCP (6), length 76) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe40 (incorrect -> 0x29b4), seq 799:823, ack 21023, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 24: IPROTO size=19 request: EXECUTE, SYNC: 28 +STMT_ID: 3618272283 +SQL_BIND: [1, "a"] +OPTIONS: [] + 233 16:57:31.372297 IP (tos 0x0, ttl 64, id 51502, offset 0, flags [DF], proto TCP (6), length 126) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe72 (incorrect -> 0xcc59), seq 21023:21097, ack 823, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 74: IPROTO size=69 response: OK, SYNC: 28, SCHEMA_VERSION: 80 +METADATA: [{0: "COLUMN_1", 1: "integer"}, {0: "COLUMN_2", 1: "text"}] +DATA: +[1, "a"] + 234 16:57:31.372309 IP (tos 0x0, ttl 64, id 12096, offset 0, flags [DF], proto TCP (6), length 64) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe34 (incorrect -> 0xa21c), seq 823:835, ack 21097, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 12: IPROTO size=7 request: BEGIN, STREAM_ID: 1, SYNC: 29 + 235 16:57:31.372324 IP (tos 0x0, ttl 64, id 51503, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe45 (incorrect -> 0x1353), seq 21097:21126, ack 835, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 29: IPROTO size=24 response: OK, SYNC: 29, SCHEMA_VERSION: 80 + 236 16:57:31.372331 IP (tos 0x0, ttl 64, id 12097, offset 0, flags [DF], proto TCP (6), length 64) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe34 (incorrect -> 0xa1f0), seq 835:847, ack 21126, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 12: IPROTO size=7 request: ROLLBACK, STREAM_ID: 1, SYNC: 30 + 237 16:57:31.372343 IP (tos 0x0, ttl 64, id 51504, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe45 (incorrect -> 0x1329), seq 21126:21155, ack 847, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 29: IPROTO size=24 response: OK, SYNC: 30, SCHEMA_VERSION: 80 + 238 16:57:31.372350 IP (tos 0x0, ttl 64, id 12098, offset 0, flags [DF], proto TCP (6), length 64) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe34 (incorrect -> 0xa1c7), seq 847:859, ack 21155, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 12: IPROTO size=7 request: COMMIT, STREAM_ID: 1, SYNC: 31 + 239 16:57:31.372362 IP (tos 0x0, ttl 64, id 51505, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe45 (incorrect -> 0x12ff), seq 21155:21184, ack 859, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 29: IPROTO size=24 response: OK, SYNC: 31, SCHEMA_VERSION: 80 + 240 16:57:31.372419 IP (tos 0x0, ttl 64, id 12099, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [F.], cksum 0xfe28 (incorrect -> 0x8264), seq 859, ack 21184, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 241 16:57:31.372427 IP (tos 0x0, ttl 64, id 51506, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [F.], cksum 0xfe28 (incorrect -> 0x8263), seq 21184, ack 860, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 242 16:57:31.372435 IP (tos 0x0, ttl 64, id 12100, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x8263), ack 21185, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 243 16:57:31.373225 IP (tos 0x0, ttl 64, id 43392, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [F.], cksum 0xfe28 (incorrect -> 0x4de4), seq 843, ack 28057, win 512, options [nop,nop,TS val 1977541262 ecr 1977541261], length 0 + 244 16:57:31.373454 IP (tos 0x0, ttl 64, id 57424, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [F.], cksum 0xfe28 (incorrect -> 0x4de3), seq 28057, ack 844, win 512, options [nop,nop,TS val 1977541262 ecr 1977541261], length 0 + 245 16:57:31.373458 IP (tos 0x0, ttl 64, id 43393, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x4de2), ack 28058, win 512, options [nop,nop,TS val 1977541262 ecr 1977541262], length 0 + 246 16:57:32.818697 IP (tos 0x0, ttl 64, id 13000, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [S], cksum 0xfe30 (incorrect -> 0x0bd1), seq 725422438, win 65495, options [mss 65495,sackOK,TS val 1977542707 ecr 0,nop,wscale 7], length 0 + 247 16:57:32.818705 IP (tos 0x0, ttl 64, id 0, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [S.], cksum 0xfe30 (incorrect -> 0x5516), seq 2701899671, ack 725422439, win 65483, options [mss 65495,sackOK,TS val 1977542707 ecr 1977542707,nop,wscale 7], length 0 + 248 16:57:32.818713 IP (tos 0x0, ttl 64, id 13001, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x7bd2), ack 1, win 512, options [nop,nop,TS val 1977542707 ecr 1977542707], length 0 + 249 16:57:32.818891 IP (tos 0x0, ttl 64, id 7475, offset 0, flags [DF], proto TCP (6), length 180) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfea8 (incorrect -> 0x4eef), seq 1:129, ack 1, win 512, options [nop,nop,TS val 1977542708 ecr 1977542707], length 128: IPROTO: greeting: version: Tarantool 2.10.4 (Binary), uuid: 056cb614-461f-4cc2-a26b-8a50f5286086, salt: 5ndApMi9Bm1zp5fR42X/WpfXcUBCabHQX+Na6hRot+0= + 250 16:57:32.818896 IP (tos 0x0, ttl 64, id 13002, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x7b51), ack 129, win 511, options [nop,nop,TS val 1977542708 ecr 1977542708], length 0 + 251 16:57:32.818950 IP (tos 0x0, ttl 64, id 13003, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0x7fbc), seq 1:20, ack 129, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 19: IPROTO size=14 request: ID, SYNC: 1 +VERSION: 3 +FEATURES: [0, 1, 2, 3] + 252 16:57:32.818955 IP (tos 0x0, ttl 64, id 7476, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [.], cksum 0xfe28 (incorrect -> 0x7b3d), ack 20, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 0 + 253 16:57:32.819084 IP (tos 0x0, ttl 64, id 7477, offset 0, flags [DF], proto TCP (6), length 89) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe4d (incorrect -> 0x6626), seq 129:166, ack 20, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 37: IPROTO size=32 response: OK, SYNC: 1, SCHEMA_VERSION: 78 +VERSION: 3 +FEATURES: [0, 1, 2, 3] + 254 16:57:32.819150 IP (tos 0x0, ttl 64, id 13004, offset 0, flags [DF], proto TCP (6), length 121) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe6d (incorrect -> 0x6081), seq 20:89, ack 166, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 69: IPROTO size=18 request: SELECT, SYNC: 2 +SPACE: _vspace (ID: 281) +LIMIT: 4294967295 +KEY: [] + 255 16:57:32.819319 IP (tos 0x0, ttl 64, id 7478, offset 0, flags [DF], proto TCP (6), length 19745) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0x4b16 (incorrect -> 0x1dce), seq 166:19859, ack 89, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 19693: IPROTO size=4608 response: OK, SYNC: 2, SCHEMA_VERSION: 78 +DATA: +[257, 1, "_vinyl_deferred_delete", "blackhole", 0, {"group_id": 1}, [{"name": "space_id", "type": "unsigned"}, {"name": "lsn", "type": "unsigned"}, {"name": "tuple", "type": "array"}]] +[272, 1, "_schema", "memtx", 0, {}, [{"type": "string", "name": "key"}, {"type": "any", "name": "value", "is_nullable": true}]] +[276, 1, "_collation", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "owner", "type": "unsigned"}, {"name": "type", "type": "string"}, {"name": "locale", "type": "string"}, {"name": "opts", "type": "map"}]] +[277, 1, "_vcollation", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "owner", "type": "unsigned"}, {"name": "type", "type": "string"}, {"name": "locale", "type": "string"}, {"name": "opts", "type": "map"}]] +[280, 1, "_space", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "engine", "type": "string"}, {"name": "field_count", "type": "unsigned"}, {"name": "flags", "type": "map"}, {"name": "format", "type": "array"}]] +[281, 1, "_vspace", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "engine", "type": "string"}, {"name": "field_count", "type": "unsigned"}, {"name": "flags", "type": "map"}, {"name": "format", "type": "array"}]] +[284, 1, "_sequence", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "step", "type": "integer"}, {"name": "min", "type": "integer"}, {"name": "max", "type": "integer"}, {"name": "start", "type": "integer"}, {"name": "cache", "type": "integer"}, {"name": "cycle", "type": "boolean"}]] +[285, 1, "_sequence_data", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "value", "type": "integer"}]] +[286, 1, "_vsequence", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "step", "type": "integer"}, {"name": "min", "type": "integer"}, {"name": "max", "type": "integer"}, {"name": "start", "type": "integer"}, {"name": "cache", "type": "integer"}, {"name": "cycle", "type": "boolean"}]] +[288, 1, "_index", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "iid", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "opts", "type": "map"}, {"name": "parts", "type": "array"}]] +[289, 1, "_vindex", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "iid", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "opts", "type": "map"}, {"name": "parts", "type": "array"}]] +[296, 1, "_func", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "setuid", "type": "unsigned"}, {"name": "language", "type": "string"}, {"name": "body", "type": "string"}, {"name": "routine_type", "type": "string"}, {"name": "param_list", "type": "array"}, {"name": "returns", "type": "string"}, {"name": "aggregate", "type": "string"}, {"name": "sql_data_access", "type": "string"}, {"name": "is_deterministic", "type": "boolean"}, {"name": "is_sandboxed", "type": "boolean"}, {"name": "is_null_call", "type": "boolean"}, {"name": "exports", "type": "array"}, {"name": "opts", "type": "map"}, {"name": "comment", "type": "string"}, {"name": "created", "type": "string"}, {"name": "last_altered", "type": "string"}]] +[297, 1, "_vfunc", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "setuid", "type": "unsigned"}, {"name": "language", "type": "string"}, {"name": "body", "type": "string"}, {"name": "routine_type", "type": "string"}, {"name": "param_list", "type": "array"}, {"name": "returns", "type": "string"}, {"name": "aggregate", "type": "string"}, {"name": "sql_data_access", "type": "string"}, {"name": "is_deterministic", "type": "boolean"}, {"name": "is_sandboxed", "type": "boolean"}, {"name": "is_null_call", "type": "boolean"}, {"name": "exports", "type": "array"}, {"name": "opts", "type": "map"}, {"name": "comment", "type": "string"}, {"name": "created", "type": "string"}, {"name": "last_altered", "type": "string"}]] +[304, 1, "_user", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "auth", "type": "map"}]] +[305, 1, "_vuser", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "auth", "type": "map"}]] +[312, 1, "_priv", "memtx", 0, {}, [{"name": "grantor", "type": "unsigned"}, {"name": "grantee", "type": "unsigned"}, {"name": "object_type", "type": "string"}, {"name": "object_id", "type": "scalar"}, {"name": "privilege", "type": "unsigned"}]] +[313, 1, "_vpriv", "sysview", 0, {}, [{"name": "grantor", "type": "unsigned"}, {"name": "grantee", "type": "unsigned"}, {"name": "object_type", "type": "string"}, {"name": "object_id", "type": "scalar"}, {"name": "privilege", "type": "unsigned"}]] +[320, 1, "_cluster", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "uuid", "type": "string"}]] +[328, 1, "_trigger", "memtx", 0, {}, [{"name": "name", "type": "string"}, {"name": "space_id", "type": "unsigned"}, {"name": "opts", "type": "map"}]] +[330, 1, "_truncate", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "count", "type": "unsigned"}]] +[340, 1, "_space_sequence", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "sequence_id", "type": "unsigned"}, {"name": "is_generated", "type": "boolean"}, {"name": "field", "type": "unsigned"}, {"name": "path", "type": "string"}]] +[356, 1, "_fk_constraint", "memtx", 0, {}, [{"name": "name", "type": "string"}, {"name": "child_id", "type": "unsigned"}, {"name": "parent_id", "type": "unsigned"}, {"name": "is_deferred", "type": "boolean"}, {"name": "match", "type": "string"}, {"name": "on_delete", "type": "string"}, {"name": "on_update", "type": "string"}, {"name": "child_cols", "type": "array"}, {"name": "parent_cols", "type": "array"}]] +[364, 1, "_ck_constraint", "memtx", 0, {}, [{"name": "space_id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "is_deferred", "type": "boolean"}, {"name": "language", "type": "str"}, {"name": "code", "type": "str"}, {"name": "is_enabled", "type": "boolean"}]] +[372, 1, "_func_index", "memtx", 0, {}, [{"name": "space_id", "type": "unsigned"}, {"name": "index_id", "type": "unsigned"}, {"name": "func_id", "type": "unsigned"}]] +[380, 1, "_session_settings", "service", 2, {"temporary": true}, [{"name": "name", "type": "string"}, {"name": "value", "type": "any"}]] + 256 16:57:32.819674 IP (tos 0x0, ttl 64, id 13005, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xc703), seq 89:112, ack 19859, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 23: IPROTO size=18 + 257 16:57:32.819692 IP (tos 0x0, ttl 64, id 13006, offset 0, flags [DF], proto TCP (6), length 122) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe6e (incorrect -> 0x0a20), seq 112:182, ack 19859, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 70: IPROTO size=65 request: EVAL, SYNC: 5 +EXPR: return box.error.new(box.error.ILLEGAL_PARAMS, "test") +TUPLE: [] + 258 16:57:32.819734 IP (tos 0x0, ttl 64, id 7479, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [.], cksum 0xfe28 (incorrect -> 0x2d89), ack 182, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 0 + 259 16:57:32.819884 IP (tos 0x0, ttl 64, id 7480, offset 0, flags [DF], proto TCP (6), length 135) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe7b (incorrect -> 0x83ed), seq 19859:19942, ack 182, win 512, options [nop,nop,TS val 1977542709 ecr 1977542708], length 83: IPROTO size=55 response: OK, SYNC: 5, SCHEMA_VERSION: 78 +DATA: +"Illegal parameters, test" + 260 16:57:32.819963 IP (tos 0x0, ttl 64, id 13007, offset 0, flags [DF], proto TCP (6), length 122) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe6e (incorrect -> 0x4b79), seq 182:252, ack 19942, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 70: IPROTO size=42 request: CALL, SYNC: 6 +FUNCTION_NAME: error_new +TUPLE: [{"code": 1000, "reason": "Reason"}] + 261 16:57:32.820143 IP (tos 0x0, ttl 64, id 7481, offset 0, flags [DF], proto TCP (6), length 132) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe78 (incorrect -> 0x3e9e), seq 19942:20022, ack 252, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 80: IPROTO size=75 response: OK, SYNC: 6, SCHEMA_VERSION: 78 +DATA: +EXTENSION: type ERROR [3], len 42 +TYPE: ClientError +LINE: 4294967295 +FILE: [C] +MESSAGE: Reason +ERRNO: 0 +CODE: 1000 + 262 16:57:32.820243 IP (tos 0x0, ttl 64, id 13008, offset 0, flags [DF], proto TCP (6), length 101) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe59 (incorrect -> 0x97e5), seq 252:301, ack 20022, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 49: IPROTO size=44 request: CALL, SYNC: 7 +FUNCTION_NAME: error_throw +TUPLE: [{"code": 1000, "reason": "Reason"}] + 263 16:57:32.820381 IP (tos 0x0, ttl 64, id 7482, offset 0, flags [DF], proto TCP (6), length 148) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe88 (incorrect -> 0x1b6c), seq 20022:20118, ack 301, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 96: IPROTO size=91 response: ERR: unknown, SYNC: 7, SCHEMA_VERSION: 78 +TYPE: ClientError +LINE: 42 +FILE: extended_error.test.lua +MESSAGE: Reason +ERRNO: 0 +CODE: 1000 + 264 16:57:32.820466 IP (tos 0x0, ttl 64, id 13009, offset 0, flags [DF], proto TCP (6), length 113) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe65 (incorrect -> 0x03a4), seq 301:362, ack 20118, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 61: IPROTO size=56 request: CALL, SYNC: 8 +FUNCTION_NAME: error_new +TUPLE: [{"type": "MyError", "reason": "Reason2", "code": 1001}] + 265 16:57:32.820575 IP (tos 0x0, ttl 64, id 7483, offset 0, flags [DF], proto TCP (6), length 155) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe8f (incorrect -> 0xac0a), seq 20118:20221, ack 362, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 103: IPROTO size=98 response: OK, SYNC: 8, SCHEMA_VERSION: 78 +DATA: +EXTENSION: type ERROR [3], len 65 +TYPE: CustomError +LINE: 4294967295 +FILE: [C] +MESSAGE: Reason2 +ERRNO: 0 +CODE: 1001 +FIELDS: custom_type: MyError + 266 16:57:32.820661 IP (tos 0x0, ttl 64, id 13010, offset 0, flags [DF], proto TCP (6), length 115) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe67 (incorrect -> 0x8c84), seq 362:425, ack 20221, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 63: IPROTO size=58 request: CALL, SYNC: 9 +FUNCTION_NAME: error_throw +TUPLE: [{"type": "MyError", "reason": "Reason2", "code": 1001}] + 267 16:57:32.820841 IP (tos 0x0, ttl 64, id 7484, offset 0, flags [DF], proto TCP (6), length 172) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfea0 (incorrect -> 0x78a3), seq 20221:20341, ack 425, win 512, options [nop,nop,TS val 1977542710 ecr 1977542709], length 120: IPROTO size=115 response: ERR: unknown, SYNC: 9, SCHEMA_VERSION: 78 +TYPE: CustomError +LINE: 42 +FILE: extended_error.test.lua +MESSAGE: Reason2 +ERRNO: 0 +CODE: 1001 +FIELDS: custom_type: MyError + 268 16:57:32.820928 IP (tos 0x0, ttl 64, id 13011, offset 0, flags [DF], proto TCP (6), length 86) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe4a (incorrect -> 0x3127), seq 425:459, ack 20341, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 34: IPROTO size=29 request: CALL, SYNC: 10 +FUNCTION_NAME: error_access_denied +TUPLE: [] + 269 16:57:32.821055 IP (tos 0x0, ttl 64, id 7485, offset 0, flags [DF], proto TCP (6), length 290) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xff16 (incorrect -> 0xa534), seq 20341:20579, ack 459, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 238: IPROTO size=233 response: OK, SYNC: 10, SCHEMA_VERSION: 78 +DATA: +EXTENSION: type ERROR [3], len 200 +TYPE: AccessDeniedError +LINE: 533 +FILE: ./src/box/func.c +MESSAGE: Execute access to function 'forbidden_function' is denied for user 'guest' +ERRNO: 0 +CODE: 42 +FIELDS: object_type: function, object_name: forbidden_function, access_type: Execute + 270 16:57:32.821152 IP (tos 0x0, ttl 64, id 13012, offset 0, flags [DF], proto TCP (6), length 92) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe50 (incorrect -> 0xecb1), seq 459:499, ack 20579, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 40: IPROTO size=35 request: CALL, SYNC: 11 +FUNCTION_NAME: error_throw_access_denied +TUPLE: [] + 271 16:57:32.821176 IP (tos 0x0, ttl 64, id 7486, offset 0, flags [DF], proto TCP (6), length 359) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xff5b (incorrect -> 0xe952), seq 20579:20886, ack 499, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 307: IPROTO size=302 response: ERR: ER_ACCESS_DENIED, SYNC: 11, SCHEMA_VERSION: 78 +TYPE: AccessDeniedError +LINE: 533 +FILE: ./src/box/func.c +MESSAGE: Execute access to function 'forbidden_function' is denied for user 'guest' +ERRNO: 0 +CODE: 42 +FIELDS: object_type: function, object_name: forbidden_function, access_type: Execute + 272 16:57:32.821203 IP (tos 0x0, ttl 64, id 13013, offset 0, flags [DF], proto TCP (6), length 146) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe86 (incorrect -> 0xe338), seq 499:593, ack 20886, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 94: IPROTO size=89 request: CALL, SYNC: 12 +FUNCTION_NAME: error_new_stacked +TUPLE: [{"type": "MyError2", "reason": "Reason3", "code": 1003}, {"code": 1004, "reason": "Reason4"}] + 273 16:57:32.821225 IP (tos 0x0, ttl 64, id 7487, offset 0, flags [DF], proto TCP (6), length 228) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfed8 (incorrect -> 0x46d8), seq 20886:21062, ack 593, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 176: IPROTO size=171 response: OK, SYNC: 12, SCHEMA_VERSION: 78 +DATA: +EXTENSION: type ERROR [3], len 138 +TYPE: CustomError +LINE: 46 +FILE: extended_error.test.lua +MESSAGE: Reason3 +ERRNO: 0 +CODE: 1003 +FIELDS: custom_type: MyError2 +--- +TYPE: ClientError +LINE: 47 +FILE: extended_error.test.lua +MESSAGE: Reason4 +ERRNO: 0 +CODE: 1004 + 274 16:57:32.821253 IP (tos 0x0, ttl 64, id 13014, offset 0, flags [DF], proto TCP (6), length 148) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe88 (incorrect -> 0x6baf), seq 593:689, ack 21062, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 96: IPROTO size=91 request: CALL, SYNC: 13 +FUNCTION_NAME: error_throw_stacked +TUPLE: [{"type": "MyError2", "reason": "Reason3", "code": 1003}, {"code": 1004, "reason": "Reason4"}] + 275 16:57:32.821272 IP (tos 0x0, ttl 64, id 7488, offset 0, flags [DF], proto TCP (6), length 229) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfed9 (incorrect -> 0x4aeb), seq 21062:21239, ack 689, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 177: IPROTO size=172 response: ERR: unknown, SYNC: 13, SCHEMA_VERSION: 78 +TYPE: CustomError +LINE: 46 +FILE: extended_error.test.lua +MESSAGE: Reason3 +ERRNO: 0 +CODE: 1003 +FIELDS: custom_type: MyError2 +--- +TYPE: ClientError +LINE: 47 +FILE: extended_error.test.lua +MESSAGE: Reason4 +ERRNO: 0 +CODE: 1004 + 276 16:57:32.821298 IP (tos 0x0, ttl 64, id 13015, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xb95a), seq 689:708, ack 21239, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 14 +FUNCTION_NAME: func +TUPLE: [] + 277 16:57:32.821311 IP (tos 0x0, ttl 64, id 7489, offset 0, flags [DF], proto TCP (6), length 155) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe8f (incorrect -> 0xa75d), seq 21239:21342, ack 708, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 103: IPROTO size=98 response: OK, SYNC: 14, SCHEMA_VERSION: 78 +DATA: +[(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])] + 278 16:57:32.821335 IP (tos 0x0, ttl 64, id 13016, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xb8df), seq 708:727, ack 21342, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 15 +FUNCTION_NAME: func +TUPLE: [] + 279 16:57:32.821347 IP (tos 0x0, ttl 64, id 7490, offset 0, flags [DF], proto TCP (6), length 157) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe91 (incorrect -> 0xa24f), seq 21342:21447, ack 727, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 105: IPROTO size=100 response: OK, SYNC: 15, SCHEMA_VERSION: 78 +DATA: +[1] +[(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])] + 280 16:57:32.821365 IP (tos 0x0, ttl 64, id 13017, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xb862), seq 727:746, ack 21447, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 16 +FUNCTION_NAME: func +TUPLE: [] + 281 16:57:32.821377 IP (tos 0x0, ttl 64, id 7491, offset 0, flags [DF], proto TCP (6), length 157) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe91 (incorrect -> 0xa1d2), seq 21447:21552, ack 746, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 105: IPROTO size=100 response: OK, SYNC: 16, SCHEMA_VERSION: 78 +DATA: +[1] +[(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])] + 282 16:57:32.821392 IP (tos 0x0, ttl 64, id 13018, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xb7e5), seq 746:765, ack 21552, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 17 +FUNCTION_NAME: func +TUPLE: [] + 283 16:57:32.821404 IP (tos 0x0, ttl 64, id 7492, offset 0, flags [DF], proto TCP (6), length 155) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe8f (incorrect -> 0xa5e8), seq 21552:21655, ack 765, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 103: IPROTO size=98 response: OK, SYNC: 17, SCHEMA_VERSION: 78 +DATA: +[(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])] + 284 16:57:32.821418 IP (tos 0x0, ttl 64, id 13019, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xb76a), seq 765:784, ack 21655, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 18 +FUNCTION_NAME: func +TUPLE: [] + 285 16:57:32.821431 IP (tos 0x0, ttl 64, id 7493, offset 0, flags [DF], proto TCP (6), length 156) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe90 (incorrect -> 0x4fbf), seq 21655:21759, ack 784, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 104: IPROTO size=99 response: OK, SYNC: 18, SCHEMA_VERSION: 78 +DATA: +[1, (ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])] + 286 16:57:32.821444 IP (tos 0x0, ttl 64, id 13020, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xb6ee), seq 784:803, ack 21759, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 19 +FUNCTION_NAME: func +TUPLE: [] + 287 16:57:32.821457 IP (tos 0x0, ttl 64, id 7494, offset 0, flags [DF], proto TCP (6), length 157) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe91 (incorrect -> 0xa05e), seq 21759:21864, ack 803, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 105: IPROTO size=100 response: OK, SYNC: 19, SCHEMA_VERSION: 78 +DATA: +[1] +[(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])] + 288 16:57:32.821473 IP (tos 0x0, ttl 64, id 13021, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xb671), seq 803:822, ack 21864, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 20 +FUNCTION_NAME: func +TUPLE: [] + 289 16:57:32.821487 IP (tos 0x0, ttl 64, id 7495, offset 0, flags [DF], proto TCP (6), length 157) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe91 (incorrect -> 0x9fe1), seq 21864:21969, ack 822, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 105: IPROTO size=100 response: OK, SYNC: 20, SCHEMA_VERSION: 78 +DATA: +[1] +[(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])] + 290 16:57:32.821577 IP (tos 0x0, ttl 64, id 13022, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [F.], cksum 0xfe28 (incorrect -> 0x22c6), seq 822, ack 21969, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 0 + 291 16:57:32.821584 IP (tos 0x0, ttl 64, id 7496, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [F.], cksum 0xfe28 (incorrect -> 0x22c5), seq 21969, ack 823, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 0 + 292 16:57:32.821591 IP (tos 0x0, ttl 64, id 13023, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x22c5), ack 21970, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 0 diff --git a/tests/tarantool_base_vv.out b/tests/tarantool_base_vv.out new file mode 100644 index 0000000000..65d9146935 --- /dev/null +++ b/tests/tarantool_base_vv.out @@ -0,0 +1,1572 @@ + 1 16:57:31.257128 IP (tos 0x0, ttl 64, id 10331, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.40054 > 127.0.0.1.3309: Flags [S], cksum 0xfe30 (incorrect -> 0x4c33), seq 3784122596, win 65495, options [mss 65495,sackOK,TS val 1977541146 ecr 0,nop,wscale 7], length 0 + 2 16:57:31.257135 IP (tos 0x0, ttl 64, id 0, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.3309 > 127.0.0.1.40054: Flags [S.], cksum 0xfe30 (incorrect -> 0x21c6), seq 4139244470, ack 3784122597, win 65483, options [mss 65495,sackOK,TS val 1977541146 ecr 1977541146,nop,wscale 7], length 0 + 3 16:57:31.257142 IP (tos 0x0, ttl 64, id 10332, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40054 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x4882), seq 1, ack 1, win 512, options [nop,nop,TS val 1977541146 ecr 1977541146], length 0 + 4 16:57:31.257310 IP (tos 0x0, ttl 64, id 36974, offset 0, flags [DF], proto TCP (6), length 180) + 127.0.0.1.3309 > 127.0.0.1.40054: Flags [P.], cksum 0xfea8 (incorrect -> 0x9c6b), seq 1:129, ack 1, win 512, options [nop,nop,TS val 1977541146 ecr 1977541146], length 128: IPROTO: greeting: version: Tarantool 2.10.4 (Binary), uuid: e6bd3069-1336-4934-97d1-61b2dc4392f9, salt: JbnlcBzGrEJqDYVKNsxXSle8r3Ya8zMIJFlmT0KrP/A= + 5 16:57:31.257314 IP (tos 0x0, ttl 64, id 10333, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40054 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x4803), seq 1, ack 129, win 511, options [nop,nop,TS val 1977541146 ecr 1977541146], length 0 + 6 16:57:31.257375 IP (tos 0x0, ttl 64, id 10334, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.40054 > 127.0.0.1.3309: Flags [P.], cksum 0xfe30 (incorrect -> 0x762c), seq 1:9, ack 129, win 512, options [nop,nop,TS val 1977541146 ecr 1977541146], length 8: IPROTO size=3 request: VOTE +header: {0: 68} + 7 16:57:31.257378 IP (tos 0x0, ttl 64, id 36975, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40054: Flags [.], cksum 0xfe28 (incorrect -> 0x47fa), seq 129, ack 9, win 512, options [nop,nop,TS val 1977541146 ecr 1977541146], length 0 + 8 16:57:31.257559 IP (tos 0x0, ttl 64, id 36976, offset 0, flags [DF], proto TCP (6), length 97) + 127.0.0.1.3309 > 127.0.0.1.40054: Flags [P.], cksum 0xfe55 (incorrect -> 0x758b), seq 129:174, ack 9, win 512, options [nop,nop,TS val 1977541146 ecr 1977541146], length 45: IPROTO size=40 response: OK, SYNC: 0, SCHEMA_VERSION: 0 +[BALLOT] +BALLOT_IS_RO_CFG: false +BALLOT_IS_RO: true +BALLOT_IS_ANON: false +BALLOT_IS_BOOTED: false +BALLOT_VCLOCK: {} +BALLOT_GC_VCLOCK: {} +BALLOT_CAN_LEAD: false +header: {0: 0, 1: 0, 5: 0} +body: {41: {1: false, 4: true, 5: false, 6: false, 2: {}, 3: {}, 7: false}} + 9 16:57:31.266905 IP (tos 0x0, ttl 64, id 10335, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40054 > 127.0.0.1.3309: Flags [F.], cksum 0xfe28 (incorrect -> 0x47c2), seq 9, ack 174, win 512, options [nop,nop,TS val 1977541156 ecr 1977541146], length 0 + 10 16:57:31.267007 IP (tos 0x0, ttl 64, id 36977, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40054: Flags [F.], cksum 0xfe28 (incorrect -> 0x47b7), seq 174, ack 10, win 512, options [nop,nop,TS val 1977541156 ecr 1977541156], length 0 + 11 16:57:31.267015 IP (tos 0x0, ttl 64, id 10336, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40054 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x47b7), seq 10, ack 175, win 512, options [nop,nop,TS val 1977541156 ecr 1977541156], length 0 + 12 16:57:31.284958 IP (tos 0x0, ttl 64, id 43340, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [S], cksum 0xfe30 (incorrect -> 0x6d2b), seq 1357811807, win 65495, options [mss 65495,sackOK,TS val 1977541174 ecr 0,nop,wscale 7], length 0 + 13 16:57:31.284966 IP (tos 0x0, ttl 64, id 0, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [S.], cksum 0xfe30 (incorrect -> 0x98ba), seq 4221993135, ack 1357811808, win 65483, options [mss 65495,sackOK,TS val 1977541174 ecr 1977541174,nop,wscale 7], length 0 + 14 16:57:31.284972 IP (tos 0x0, ttl 64, id 43341, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0xbf76), seq 1, ack 1, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 0 + 15 16:57:31.285240 IP (tos 0x0, ttl 64, id 57315, offset 0, flags [DF], proto TCP (6), length 180) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfea8 (incorrect -> 0x7bad), seq 1:129, ack 1, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 128: IPROTO: greeting: version: Tarantool 2.10.4 (Binary), uuid: e6bd3069-1336-4934-97d1-61b2dc4392f9, salt: 5LkiDWp/a/53A4ggshLxyD5we4CNJmaVQFQmKhl+GPE= + 16 16:57:31.285247 IP (tos 0x0, ttl 64, id 43342, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0xbef7), seq 1, ack 129, win 511, options [nop,nop,TS val 1977541174 ecr 1977541174], length 0 + 17 16:57:31.285353 IP (tos 0x0, ttl 64, id 43343, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe30 (incorrect -> 0xed20), seq 1:9, ack 129, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 8: IPROTO size=3 request: VOTE +header: {0: 68} + 18 16:57:31.285357 IP (tos 0x0, ttl 64, id 57316, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0xbeee), seq 129, ack 9, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 0 + 19 16:57:31.285461 IP (tos 0x0, ttl 64, id 57317, offset 0, flags [DF], proto TCP (6), length 99) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe57 (incorrect -> 0xdf2c), seq 129:176, ack 9, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 47: IPROTO size=42 response: OK, SYNC: 0, SCHEMA_VERSION: 80 +[BALLOT] +BALLOT_IS_RO_CFG: false +BALLOT_IS_RO: false +BALLOT_IS_ANON: false +BALLOT_IS_BOOTED: true +BALLOT_VCLOCK: {1: 10} +BALLOT_GC_VCLOCK: {} +BALLOT_CAN_LEAD: false +header: {0: 0, 1: 0, 5: 80} +body: {41: {1: false, 4: false, 5: false, 6: true, 2: {1: 10}, 3: {}, 7: false}} + 20 16:57:31.285500 IP (tos 0x0, ttl 64, id 43344, offset 0, flags [DF], proto TCP (6), length 106) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe5e (incorrect -> 0x3344), seq 9:63, ack 176, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 54: IPROTO size=49 request: AUTH, SYNC: 0 +USER_NAME: replicator +TUPLE: ["chap-sha1", "Ë\u0001\u0001È\"F”ê蔜u\u0011)-}À»\u001bà"] +header: {0: 7} +body: {35: "replicator", 33: ["chap-sha1", "Ë\u0001\u0001È\"F”ê蔜u\u0011)-}À»\u001bà"]} + 21 16:57:31.285673 IP (tos 0x0, ttl 64, id 57318, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x4f25), seq 176:205, ack 63, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 29: IPROTO size=24 response: OK, SYNC: 0, SCHEMA_VERSION: 80 +header: {0: 0, 1: 0, 5: 80} +body: {} + 22 16:57:31.285736 IP (tos 0x0, ttl 64, id 43345, offset 0, flags [DF], proto TCP (6), length 106) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe5e (incorrect -> 0xf90d), seq 63:117, ack 205, win 512, options [nop,nop,TS val 1977541174 ecr 1977541174], length 54: IPROTO size=49 request: JOIN, SYNC: 0 +INSTANCE_UUID: 144d18f7-75fd-4654-a083-6998c1f10622 +SERVER_VERSION: 133636 +header: {0: 65} +body: {36: "144d18f7-75fd-4654-a083-6998c1f10622", 6: 133636} + 23 16:57:31.286004 IP (tos 0x0, ttl 64, id 57319, offset 0, flags [DF], proto TCP (6), length 65) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe35 (incorrect -> 0xdb76), seq 205:218, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541174], length 13: IPROTO size=8 response: HEARTBEAT +VCLOCK: {1: 10} +header: {0: 0} +body: {38: {1: 10}} + 24 16:57:31.286011 IP (tos 0x0, ttl 64, id 57320, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe30 (incorrect -> 0xec4f), seq 218:226, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541174], length 8: IPROTO size=3 request: JOIN_META, SYNC: 0 +VCLOCK: {1: 10} +header: {0: 71} +body: {38: {1: 10}} + 25 16:57:31.286014 IP (tos 0x0, ttl 64, id 57321, offset 0, flags [DF], proto TCP (6), length 69) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe39 (incorrect -> 0x5b0c), seq 226:243, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541174], length 17: IPROTO size=12 request: RAFT_PROMOTE, SYNC: 0, REPLICA_ID: 1 +REPLICA_ID: 1 +LSN: 0 +TERM: 2 +header: {0: 31, 2: 1} +body: {2: 1, 3: 0, 83: 2} + 26 16:57:31.286016 IP (tos 0x0, ttl 64, id 57322, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe30 (incorrect -> 0xec35), seq 243:251, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541174], length 8: IPROTO size=3 request: JOIN_SNAPSHOT, SYNC: 0 +header: {0: 72} + 27 16:57:31.286048 IP (tos 0x0, ttl 64, id 43346, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0xbe06), seq 117, ack 251, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 0 + 28 16:57:31.286105 IP (tos 0x0, ttl 64, id 57323, offset 0, flags [DF], proto TCP (6), length 115) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe67 (incorrect -> 0xc94f), seq 251:314, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 63: IPROTO size=58 request: INSERT, SYNC: 0 +SPACE: _schema (ID: 272) +TUPLE: ["cluster", "0fa96161-16e5-4cfa-ae7e-c342258abedc"] +header: {0: 2} +body: {16: 272, 33: ["cluster", "0fa96161-16e5-4cfa-ae7e-c342258abedc"]} + 29 16:57:31.286111 IP (tos 0x0, ttl 64, id 57324, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0xca1e), seq 314:341, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 27: IPROTO size=22 request: INSERT, SYNC: 0 +SPACE: _schema (ID: 272) +TUPLE: ["max_id", 512] +header: {0: 2} +body: {16: 272, 33: ["max_id", 512]} + 30 16:57:31.286115 IP (tos 0x0, ttl 64, id 57325, offset 0, flags [DF], proto TCP (6), length 80) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe44 (incorrect -> 0x18db), seq 341:369, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 28: IPROTO size=23 request: INSERT, SYNC: 0 +SPACE: _schema (ID: 272) +TUPLE: ["version", 2, 10, 4] +header: {0: 2} +body: {16: 272, 33: ["version", 2, 10, 4]} + 31 16:57:31.286118 IP (tos 0x0, ttl 64, id 57326, offset 0, flags [DF], proto TCP (6), length 85) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe49 (incorrect -> 0x554d), seq 369:402, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 33: IPROTO size=28 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [0, "none", 1, "BINARY", "", {}] +header: {0: 2} +body: {16: 276, 33: [0, "none", 1, "BINARY", "", {}]} + 32 16:57:31.286120 IP (tos 0x0, ttl 64, id 57327, offset 0, flags [DF], proto TCP (6), length 103) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe5b (incorrect -> 0xa12b), seq 402:453, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 51: IPROTO size=46 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [1, "unicode", 1, "ICU", "", {"strength": "tertiary"}] +header: {0: 2} +body: {16: 276, 33: [1, "unicode", 1, "ICU", "", {"strength": "tertiary"}]} + 33 16:57:31.286122 IP (tos 0x0, ttl 64, id 57328, offset 0, flags [DF], proto TCP (6), length 105) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe5d (incorrect -> 0x8d49), seq 453:506, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 53: IPROTO size=48 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [2, "unicode_ci", 1, "ICU", "", {"strength": "primary"}] +header: {0: 2} +body: {16: 276, 33: [2, "unicode_ci", 1, "ICU", "", {"strength": "primary"}]} + 34 16:57:31.286124 IP (tos 0x0, ttl 64, id 57329, offset 0, flags [DF], proto TCP (6), length 87) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe4b (incorrect -> 0xe158), seq 506:541, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 35: IPROTO size=30 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [3, "binary", 1, "BINARY", "", {}] +header: {0: 2} +body: {16: 276, 33: [3, "binary", 1, "BINARY", "", {}]} + 35 16:57:31.286126 IP (tos 0x0, ttl 64, id 57330, offset 0, flags [DF], proto TCP (6), length 110) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe62 (incorrect -> 0x5c4a), seq 541:599, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [4, "unicode_af_s1", 1, "ICU", "af", {"strength": "primary"}] +header: {0: 2} +body: {16: 276, 33: [4, "unicode_af_s1", 1, "ICU", "af", {"strength": "primary"}]} + 36 16:57:31.286128 IP (tos 0x0, ttl 64, id 57331, offset 0, flags [DF], proto TCP (6), length 112) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe64 (incorrect -> 0xfea0), seq 599:659, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [5, "unicode_af_s2", 1, "ICU", "af", {"strength": "secondary"}] +header: {0: 2} +body: {16: 276, 33: [5, "unicode_af_s2", 1, "ICU", "af", {"strength": "secondary"}]} + 37 16:57:31.286130 IP (tos 0x0, ttl 64, id 57332, offset 0, flags [DF], proto TCP (6), length 111) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe63 (incorrect -> 0xf7c0), seq 659:718, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [6, "unicode_af_s3", 1, "ICU", "af", {"strength": "tertiary"}] +header: {0: 2} +body: {16: 276, 33: [6, "unicode_af_s3", 1, "ICU", "af", {"strength": "tertiary"}]} + 38 16:57:31.286166 IP (tos 0x0, ttl 64, id 43347, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0xbc33), seq 117, ack 718, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 0 + 39 16:57:31.286173 IP (tos 0x0, ttl 64, id 57333, offset 0, flags [DF], proto TCP (6), length 5200) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0x1245 (incorrect -> 0x0021), seq 718:5866, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 5148: IPROTO size=53 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [7, "unicode_am_s1", 1, "ICU", "am", {"strength": "primary"}] +header: {0: 2} +body: {16: 276, 33: [7, "unicode_am_s1", 1, "ICU", "am", {"strength": "primary"}]} + 40 16:57:31.286176 IP (tos 0x0, ttl 64, id 57334, offset 0, flags [DF], proto TCP (6), length 110) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe62 (incorrect -> 0x4527), seq 5866:5924, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [88, "unicode_ha_s1", 1, "ICU", "ha", {"strength": "primary"}] +header: {0: 2} +body: {16: 276, 33: [88, "unicode_ha_s1", 1, "ICU", "ha", {"strength": "primary"}]} + 41 16:57:31.286178 IP (tos 0x0, ttl 64, id 57335, offset 0, flags [DF], proto TCP (6), length 112) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe64 (incorrect -> 0xe77d), seq 5924:5984, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [89, "unicode_ha_s2", 1, "ICU", "ha", {"strength": "secondary"}] +header: {0: 2} +body: {16: 276, 33: [89, "unicode_ha_s2", 1, "ICU", "ha", {"strength": "secondary"}]} + 42 16:57:31.286179 IP (tos 0x0, ttl 64, id 57336, offset 0, flags [DF], proto TCP (6), length 111) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe63 (incorrect -> 0xe09d), seq 5984:6043, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [90, "unicode_ha_s3", 1, "ICU", "ha", {"strength": "tertiary"}] +header: {0: 2} +body: {16: 276, 33: [90, "unicode_ha_s3", 1, "ICU", "ha", {"strength": "tertiary"}]} + 43 16:57:31.286181 IP (tos 0x0, ttl 64, id 57337, offset 0, flags [DF], proto TCP (6), length 112) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe64 (incorrect -> 0x4181), seq 6043:6103, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [91, "unicode_haw_s1", 1, "ICU", "haw", {"strength": "primary"}] +header: {0: 2} +body: {16: 276, 33: [91, "unicode_haw_s1", 1, "ICU", "haw", {"strength": "primary"}]} + 44 16:57:31.286183 IP (tos 0x0, ttl 64, id 57338, offset 0, flags [DF], proto TCP (6), length 114) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe66 (incorrect -> 0xe2d6), seq 6103:6165, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 62: IPROTO size=57 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [92, "unicode_haw_s2", 1, "ICU", "haw", {"strength": "secondary"}] +header: {0: 2} +body: {16: 276, 33: [92, "unicode_haw_s2", 1, "ICU", "haw", {"strength": "secondary"}]} + 45 16:57:31.286185 IP (tos 0x0, ttl 64, id 57339, offset 0, flags [DF], proto TCP (6), length 113) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe65 (incorrect -> 0xdaf5), seq 6165:6226, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 61: IPROTO size=56 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [93, "unicode_haw_s3", 1, "ICU", "haw", {"strength": "tertiary"}] +header: {0: 2} +body: {16: 276, 33: [93, "unicode_haw_s3", 1, "ICU", "haw", {"strength": "tertiary"}]} + 46 16:57:31.286187 IP (tos 0x0, ttl 64, id 57340, offset 0, flags [DF], proto TCP (6), length 110) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe62 (incorrect -> 0x3fb5), seq 6226:6284, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [94, "unicode_he_s1", 1, "ICU", "he", {"strength": "primary"}] +header: {0: 2} +body: {16: 276, 33: [94, "unicode_he_s1", 1, "ICU", "he", {"strength": "primary"}]} + 47 16:57:31.286189 IP (tos 0x0, ttl 64, id 57341, offset 0, flags [DF], proto TCP (6), length 112) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe64 (incorrect -> 0xe20b), seq 6284:6344, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [95, "unicode_he_s2", 1, "ICU", "he", {"strength": "secondary"}] +header: {0: 2} +body: {16: 276, 33: [95, "unicode_he_s2", 1, "ICU", "he", {"strength": "secondary"}]} + 48 16:57:31.286190 IP (tos 0x0, ttl 64, id 57342, offset 0, flags [DF], proto TCP (6), length 111) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe63 (incorrect -> 0xdb2b), seq 6344:6403, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [96, "unicode_he_s3", 1, "ICU", "he", {"strength": "tertiary"}] +header: {0: 2} +body: {16: 276, 33: [96, "unicode_he_s3", 1, "ICU", "he", {"strength": "tertiary"}]} + 49 16:57:31.286192 IP (tos 0x0, ttl 64, id 57343, offset 0, flags [DF], proto TCP (6), length 110) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe62 (incorrect -> 0x3afd), seq 6403:6461, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [97, "unicode_hi_s1", 1, "ICU", "hi", {"strength": "primary"}] +header: {0: 2} +body: {16: 276, 33: [97, "unicode_hi_s1", 1, "ICU", "hi", {"strength": "primary"}]} + 50 16:57:31.286194 IP (tos 0x0, ttl 64, id 57344, offset 0, flags [DF], proto TCP (6), length 112) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe64 (incorrect -> 0xdd53), seq 6461:6521, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [98, "unicode_hi_s2", 1, "ICU", "hi", {"strength": "secondary"}] +header: {0: 2} +body: {16: 276, 33: [98, "unicode_hi_s2", 1, "ICU", "hi", {"strength": "secondary"}]} + 51 16:57:31.286196 IP (tos 0x0, ttl 64, id 57345, offset 0, flags [DF], proto TCP (6), length 111) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe63 (incorrect -> 0xd673), seq 6521:6580, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [99, "unicode_hi_s3", 1, "ICU", "hi", {"strength": "tertiary"}] +header: {0: 2} +body: {16: 276, 33: [99, "unicode_hi_s3", 1, "ICU", "hi", {"strength": "tertiary"}]} + 52 16:57:31.286198 IP (tos 0x0, ttl 64, id 57346, offset 0, flags [DF], proto TCP (6), length 110) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe62 (incorrect -> 0x3140), seq 6580:6638, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [100, "unicode_hr_s1", 1, "ICU", "hr", {"strength": "primary"}] +header: {0: 2} +body: {16: 276, 33: [100, "unicode_hr_s1", 1, "ICU", "hr", {"strength": "primary"}]} + 53 16:57:31.286200 IP (tos 0x0, ttl 64, id 57347, offset 0, flags [DF], proto TCP (6), length 112) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe64 (incorrect -> 0xd396), seq 6638:6698, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [101, "unicode_hr_s2", 1, "ICU", "hr", {"strength": "secondary"}] +header: {0: 2} +body: {16: 276, 33: [101, "unicode_hr_s2", 1, "ICU", "hr", {"strength": "secondary"}]} + 54 16:57:31.286202 IP (tos 0x0, ttl 64, id 57348, offset 0, flags [DF], proto TCP (6), length 111) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe63 (incorrect -> 0xccb6), seq 6698:6757, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [102, "unicode_hr_s3", 1, "ICU", "hr", {"strength": "tertiary"}] +header: {0: 2} +body: {16: 276, 33: [102, "unicode_hr_s3", 1, "ICU", "hr", {"strength": "tertiary"}]} + 55 16:57:31.286204 IP (tos 0x0, ttl 64, id 57349, offset 0, flags [DF], proto TCP (6), length 110) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe62 (incorrect -> 0x2d89), seq 6757:6815, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [103, "unicode_hu_s1", 1, "ICU", "hu", {"strength": "primary"}] +header: {0: 2} +body: {16: 276, 33: [103, "unicode_hu_s1", 1, "ICU", "hu", {"strength": "primary"}]} + 56 16:57:31.286206 IP (tos 0x0, ttl 64, id 57350, offset 0, flags [DF], proto TCP (6), length 112) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe64 (incorrect -> 0xcfdf), seq 6815:6875, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 60: IPROTO size=55 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [104, "unicode_hu_s2", 1, "ICU", "hu", {"strength": "secondary"}] +header: {0: 2} +body: {16: 276, 33: [104, "unicode_hu_s2", 1, "ICU", "hu", {"strength": "secondary"}]} + 57 16:57:31.286208 IP (tos 0x0, ttl 64, id 57351, offset 0, flags [DF], proto TCP (6), length 111) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe63 (incorrect -> 0xc8ff), seq 6875:6934, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 59: IPROTO size=54 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [105, "unicode_hu_s3", 1, "ICU", "hu", {"strength": "tertiary"}] +header: {0: 2} +body: {16: 276, 33: [105, "unicode_hu_s3", 1, "ICU", "hu", {"strength": "tertiary"}]} + 58 16:57:31.286210 IP (tos 0x0, ttl 64, id 57352, offset 0, flags [DF], proto TCP (6), length 110) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe62 (incorrect -> 0x28d1), seq 6934:6992, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 58: IPROTO size=53 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [106, "unicode_hy_s1", 1, "ICU", "hy", {"strength": "primary"}] +header: {0: 2} +body: {16: 276, 33: [106, "unicode_hy_s1", 1, "ICU", "hy", {"strength": "primary"}]} + 59 16:57:31.286312 IP (tos 0x0, ttl 64, id 43348, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0xa3e2), seq 117, ack 6992, win 463, options [nop,nop,TS val 1977541175 ecr 1977541175], length 0 + 60 16:57:31.286319 IP (tos 0x0, ttl 64, id 57353, offset 0, flags [DF], proto TCP (6), length 19220) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0x4909 (incorrect -> 0xaa24), seq 6992:26160, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 19168: IPROTO size=55 request: INSERT, SYNC: 0 +SPACE: _collation (ID: 276) +TUPLE: [107, "unicode_hy_s2", 1, "ICU", "hy", {"strength": "secondary"}] +header: {0: 2} +body: {16: 276, 33: [107, "unicode_hy_s2", 1, "ICU", "hy", {"strength": "secondary"}]} + 61 16:57:31.286320 IP (tos 0x0, ttl 64, id 57354, offset 0, flags [DF], proto TCP (6), length 89) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe4d (incorrect -> 0x6eab), seq 26160:26197, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 37: IPROTO size=32 request: INSERT, SYNC: 0 +SPACE: _user (ID: 304) +TUPLE: [3, 1, "replication", "role", {}] +header: {0: 2} +body: {16: 304, 33: [3, 1, "replication", "role", {}]} + 62 16:57:31.286322 IP (tos 0x0, ttl 64, id 57355, offset 0, flags [DF], proto TCP (6), length 83) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe47 (incorrect -> 0xa3b4), seq 26197:26228, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 31: IPROTO size=26 request: INSERT, SYNC: 0 +SPACE: _user (ID: 304) +TUPLE: [31, 1, "super", "role", {}] +header: {0: 2} +body: {16: 304, 33: [31, 1, "super", "role", {}]} + 63 16:57:31.286325 IP (tos 0x0, ttl 64, id 57356, offset 0, flags [DF], proto TCP (6), length 127) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe73 (incorrect -> 0x8eea), seq 26228:26303, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 75: IPROTO size=70 request: INSERT, SYNC: 0 +SPACE: _user (ID: 304) +TUPLE: [32, 1, "replicator", "user", {"chap-sha1": "JHDAwG3uQv0WGLuZAFrcouydHhk="}] +header: {0: 2} +body: {16: 304, 33: [32, 1, "replicator", "user", {"chap-sha1": "JHDAwG3uQv0WGLuZAFrcouydHhk="}]} + 64 16:57:31.286328 IP (tos 0x0, ttl 64, id 57357, offset 0, flags [DF], proto TCP (6), length 78) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe42 (incorrect -> 0x75ea), seq 26303:26329, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 26: IPROTO size=21 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 0, "role", 2, 4] +header: {0: 2} +body: {16: 312, 33: [1, 0, "role", 2, 4]} + 65 16:57:31.286330 IP (tos 0x0, ttl 64, id 57358, offset 0, flags [DF], proto TCP (6), length 82) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe46 (incorrect -> 0x9ac5), seq 26329:26359, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 30: IPROTO size=25 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 0, "universe", 0, 31] +header: {0: 2} +body: {16: 312, 33: [1, 0, "universe", 0, 31]} + 66 16:57:31.286332 IP (tos 0x0, ttl 64, id 57359, offset 0, flags [DF], proto TCP (6), length 86) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe4a (incorrect -> 0x94f4), seq 26359:26393, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 34: IPROTO size=29 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 1, "universe", 0, 4294967295] +header: {0: 2} +body: {16: 312, 33: [1, 1, "universe", 0, 4294967295]} + 67 16:57:31.286334 IP (tos 0x0, ttl 64, id 57360, offset 0, flags [DF], proto TCP (6), length 82) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe46 (incorrect -> 0x96ac), seq 26393:26423, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 30: IPROTO size=25 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "function", 1, 4] +header: {0: 2} +body: {16: 312, 33: [1, 2, "function", 1, 4]} + 68 16:57:31.286336 IP (tos 0x0, ttl 64, id 57361, offset 0, flags [DF], proto TCP (6), length 82) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe46 (incorrect -> 0x5691), seq 26423:26453, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 30: IPROTO size=25 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "function", 65, 1] +header: {0: 2} +body: {16: 312, 33: [1, 2, "function", 65, 1]} + 69 16:57:31.286338 IP (tos 0x0, ttl 64, id 57362, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x1374), seq 26453:26482, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 276, 2] +header: {0: 2} +body: {16: 312, 33: [1, 2, "space", 276, 2]} + 70 16:57:31.286340 IP (tos 0x0, ttl 64, id 57363, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x1456), seq 26482:26511, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 277, 1] +header: {0: 2} +body: {16: 312, 33: [1, 2, "space", 277, 1]} + 71 16:57:31.286342 IP (tos 0x0, ttl 64, id 57364, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x1435), seq 26511:26540, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 281, 1] +header: {0: 2} +body: {16: 312, 33: [1, 2, "space", 281, 1]} + 72 16:57:31.286344 IP (tos 0x0, ttl 64, id 57365, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x1413), seq 26540:26569, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 286, 1] +header: {0: 2} +body: {16: 312, 33: [1, 2, "space", 286, 1]} + 73 16:57:31.286346 IP (tos 0x0, ttl 64, id 57366, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x13f3), seq 26569:26598, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 289, 1] +header: {0: 2} +body: {16: 312, 33: [1, 2, "space", 289, 1]} + 74 16:57:31.286348 IP (tos 0x0, ttl 64, id 57367, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x13ce), seq 26598:26627, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 297, 1] +header: {0: 2} +body: {16: 312, 33: [1, 2, "space", 297, 1]} + 75 16:57:31.286350 IP (tos 0x0, ttl 64, id 57368, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x13a9), seq 26627:26656, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 305, 1] +header: {0: 2} +body: {16: 312, 33: [1, 2, "space", 305, 1]} + 76 16:57:31.286352 IP (tos 0x0, ttl 64, id 57369, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x1384), seq 26656:26685, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 313, 1] +header: {0: 2} +body: {16: 312, 33: [1, 2, "space", 313, 1]} + 77 16:57:31.286354 IP (tos 0x0, ttl 64, id 57370, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x1256), seq 26685:26714, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 330, 2] +header: {0: 2} +body: {16: 312, 33: [1, 2, "space", 330, 2]} + 78 16:57:31.286357 IP (tos 0x0, ttl 64, id 57371, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x1107), seq 26714:26743, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 2, "space", 380, 3] +header: {0: 2} +body: {16: 312, 33: [1, 2, "space", 380, 3]} + 79 16:57:31.286359 IP (tos 0x0, ttl 64, id 57372, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe45 (incorrect -> 0x1126), seq 26743:26772, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 29: IPROTO size=24 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 3, "space", 320, 2] +header: {0: 2} +body: {16: 312, 33: [1, 3, "space", 320, 2]} + 80 16:57:31.286361 IP (tos 0x0, ttl 64, id 57373, offset 0, flags [DF], proto TCP (6), length 82) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe46 (incorrect -> 0x9628), seq 26772:26802, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 30: IPROTO size=25 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 3, "universe", 0, 1] +header: {0: 2} +body: {16: 312, 33: [1, 3, "universe", 0, 1]} + 81 16:57:31.286363 IP (tos 0x0, ttl 64, id 57374, offset 0, flags [DF], proto TCP (6), length 86) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe4a (incorrect -> 0x7539), seq 26802:26836, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 34: IPROTO size=29 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 31, "universe", 0, 4294967295] +header: {0: 2} +body: {16: 312, 33: [1, 31, "universe", 0, 4294967295]} + 82 16:57:31.286365 IP (tos 0x0, ttl 64, id 57375, offset 0, flags [DF], proto TCP (6), length 78) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe42 (incorrect -> 0x53d5), seq 26836:26862, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 26: IPROTO size=21 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 32, "role", 2, 4] +header: {0: 2} +body: {16: 312, 33: [1, 32, "role", 2, 4]} + 83 16:57:31.286369 IP (tos 0x0, ttl 64, id 57376, offset 0, flags [DF], proto TCP (6), length 78) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe42 (incorrect -> 0x52bb), seq 26862:26888, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 26: IPROTO size=21 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 32, "role", 3, 4] +header: {0: 2} +body: {16: 312, 33: [1, 32, "role", 3, 4]} + 84 16:57:31.286371 IP (tos 0x0, ttl 64, id 57377, offset 0, flags [DF], proto TCP (6), length 82) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe46 (incorrect -> 0x789d), seq 26888:26918, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 30: IPROTO size=25 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 32, "universe", 0, 24] +header: {0: 2} +body: {16: 312, 33: [1, 32, "universe", 0, 24]} + 85 16:57:31.286373 IP (tos 0x0, ttl 64, id 57378, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0xb7a8), seq 26918:26945, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 27: IPROTO size=22 request: INSERT, SYNC: 0 +SPACE: _priv (ID: 312) +TUPLE: [1, 32, "user", 32, 128] +header: {0: 2} +body: {16: 312, 33: [1, 32, "user", 32, 128]} + 86 16:57:31.286375 IP (tos 0x0, ttl 64, id 57379, offset 0, flags [DF], proto TCP (6), length 108) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe60 (incorrect -> 0xc36e), seq 26945:27001, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 56: IPROTO size=51 request: INSERT, SYNC: 0 +SPACE: _cluster (ID: 320) +TUPLE: [1, "e6bd3069-1336-4934-97d1-61b2dc4392f9"] +header: {0: 2} +body: {16: 320, 33: [1, "e6bd3069-1336-4934-97d1-61b2dc4392f9"]} + 87 16:57:31.286582 IP (tos 0x0, ttl 64, id 57380, offset 0, flags [DF], proto TCP (6), length 65) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe35 (incorrect -> 0x71c9), seq 27001:27014, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 13: IPROTO size=8 response: HEARTBEAT +VCLOCK: {1: 11} +header: {0: 0} +body: {38: {1: 11}} + 88 16:57:31.286719 IP (tos 0x0, ttl 64, id 57381, offset 0, flags [DF], proto TCP (6), length 120) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe6c (incorrect -> 0xecdd), seq 27014:27082, ack 117, win 512, options [nop,nop,TS val 1977541175 ecr 1977541175], length 68: IPROTO size=63 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 11, TIMESTAMP: 2022-12-15 16:57:31.286489 +SPACE: _cluster (ID: 320) +TUPLE: [2, "144d18f7-75fd-4654-a083-6998c1f10622"] +header: {0: 2, 2: 1, 3: 11, 4: 1.67112e+09} +body: {16: 320, 33: [2, "144d18f7-75fd-4654-a083-6998c1f10622"]} + 89 16:57:31.286800 IP (tos 0x0, ttl 64, id 57382, offset 0, flags [DF], proto TCP (6), length 65) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe35 (incorrect -> 0x7177), seq 27082:27095, ack 117, win 512, options [nop,nop,TS val 1977541176 ecr 1977541175], length 13: IPROTO size=8 response: HEARTBEAT +VCLOCK: {1: 11} +header: {0: 0} +body: {38: {1: 11}} + 90 16:57:31.290485 IP (tos 0x0, ttl 64, id 43349, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x55bf), seq 117, ack 27095, win 359, options [nop,nop,TS val 1977541179 ecr 1977541175], length 0 + 91 16:57:31.295019 IP (tos 0x0, ttl 64, id 43350, offset 0, flags [DF], proto TCP (6), length 154) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe8e (incorrect -> 0x9680), seq 117:219, ack 27095, win 512, options [nop,nop,TS val 1977541184 ecr 1977541175], length 102: IPROTO size=97 request: SUBSCRIBE, SYNC: 0 +CLUSTER_UUID: 0fa96161-16e5-4cfa-ae7e-c342258abedc +INSTANCE_UUID: 144d18f7-75fd-4654-a083-6998c1f10622 +VCLOCK: {1: 11} +SERVER_VERSION: 133636 +REPLICA_ANON: false +ID_FILTER: [2] +header: {0: 66} +body: {37: "0fa96161-16e5-4cfa-ae7e-c342258abedc", 36: "144d18f7-75fd-4654-a083-6998c1f10622", 38: {1: 11}, 6: 133636, 80: false, 81: [2]} + 92 16:57:31.295163 IP (tos 0x0, ttl 64, id 57383, offset 0, flags [DF], proto TCP (6), length 106) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe5e (incorrect -> 0x7969), seq 27095:27149, ack 219, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 54: IPROTO size=49 response: OK, SYNC: 0, SCHEMA_VERSION: 0 +VCLOCK: {1: 11} +CLUSTER_UUID: 0fa96161-16e5-4cfa-ae7e-c342258abedc +header: {0: 0, 2: 1} +body: {38: {1: 11}, 37: "0fa96161-16e5-4cfa-ae7e-c342258abedc"} + 93 16:57:31.295184 IP (tos 0x0, ttl 64, id 57384, offset 0, flags [DF], proto TCP (6), length 67) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe37 (incorrect -> 0xefc0), seq 27149:27164, ack 219, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 15: IPROTO size=10 request: RAFT, GROUP_ID: 1, SYNC: 0 +RAFT_TERM: 2 +RAFT_STATE: 1 +header: {0: 30, 7: 1} +body: {0: 2, 2: 1} + 94 16:57:31.295204 IP (tos 0x0, ttl 64, id 43351, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x546d), seq 219, ack 27164, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 0 + 95 16:57:31.295333 IP (tos 0x0, ttl 64, id 43352, offset 0, flags [DF], proto TCP (6), length 65) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe35 (incorrect -> 0x70ae), seq 219:232, ack 27164, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 13: IPROTO size=8 response: HEARTBEAT +VCLOCK: {1: 11} +header: {0: 0} +body: {38: {1: 11}} + 96 16:57:31.295554 IP (tos 0x0, ttl 64, id 57385, offset 0, flags [DF], proto TCP (6), length 72) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe3c (incorrect -> 0xdf3f), seq 27164:27184, ack 232, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 20: IPROTO size=15 request: HEARTBEAT, REPLICA_ID: 1, TIMESTAMP: 2022-12-15 16:57:31.295484 +header: {0: 0, 2: 1, 4: 1.67112e+09} + 97 16:57:31.295749 IP (tos 0x0, ttl 64, id 43353, offset 0, flags [DF], proto TCP (6), length 65) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe35 (incorrect -> 0x708d), seq 232:245, ack 27184, win 512, options [nop,nop,TS val 1977541184 ecr 1977541184], length 13: IPROTO size=8 response: HEARTBEAT +VCLOCK: {1: 11} +header: {0: 0} +body: {38: {1: 11}} + 98 16:57:31.336637 IP (tos 0x0, ttl 64, id 57386, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x5416), seq 27184, ack 245, win 512, options [nop,nop,TS val 1977541225 ecr 1977541184], length 0 + 99 16:57:31.368370 IP (tos 0x0, ttl 64, id 12066, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [S], cksum 0xfe30 (incorrect -> 0x9bd3), seq 3722433644, win 65495, options [mss 65495,sackOK,TS val 1977541257 ecr 0,nop,wscale 7], length 0 + 100 16:57:31.368378 IP (tos 0x0, ttl 64, id 0, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [S.], cksum 0xfe30 (incorrect -> 0xb1ca), seq 3735401205, ack 3722433645, win 65483, options [mss 65495,sackOK,TS val 1977541257 ecr 1977541257,nop,wscale 7], length 0 + 101 16:57:31.368385 IP (tos 0x0, ttl 64, id 12067, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0xd886), seq 1, ack 1, win 512, options [nop,nop,TS val 1977541257 ecr 1977541257], length 0 + 102 16:57:31.368682 IP (tos 0x0, ttl 64, id 51474, offset 0, flags [DF], proto TCP (6), length 180) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfea8 (incorrect -> 0x4f67), seq 1:129, ack 1, win 512, options [nop,nop,TS val 1977541257 ecr 1977541257], length 128: IPROTO: greeting: version: Tarantool 2.10.4 (Binary), uuid: e6bd3069-1336-4934-97d1-61b2dc4392f9, salt: IrPp7kzbyxmkm23YKBDponl9diEvxWKter1Z0mpJga8= + 103 16:57:31.368687 IP (tos 0x0, ttl 64, id 12068, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0xd807), seq 1, ack 129, win 511, options [nop,nop,TS val 1977541257 ecr 1977541257], length 0 + 104 16:57:31.368744 IP (tos 0x0, ttl 64, id 12069, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xdc72), seq 1:20, ack 129, win 512, options [nop,nop,TS val 1977541257 ecr 1977541257], length 19: IPROTO size=14 request: ID, SYNC: 1 +VERSION: 3 +FEATURES: [0, 1, 2, 3] +header: {1: 1, 0: 73} +body: {84: 3, 85: [0, 1, 2, 3]} + 105 16:57:31.368748 IP (tos 0x0, ttl 64, id 51475, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [.], cksum 0xfe28 (incorrect -> 0xd7f3), seq 129, ack 20, win 512, options [nop,nop,TS val 1977541257 ecr 1977541257], length 0 + 106 16:57:31.368886 IP (tos 0x0, ttl 64, id 51476, offset 0, flags [DF], proto TCP (6), length 89) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4d (incorrect -> 0xc2d9), seq 129:166, ack 20, win 512, options [nop,nop,TS val 1977541258 ecr 1977541257], length 37: IPROTO size=32 response: OK, SYNC: 1, SCHEMA_VERSION: 80 +VERSION: 3 +FEATURES: [0, 1, 2, 3] +header: {0: 0, 1: 1, 5: 80} +body: {84: 3, 85: [0, 1, 2, 3]} + 107 16:57:31.368950 IP (tos 0x0, ttl 64, id 12070, offset 0, flags [DF], proto TCP (6), length 121) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe6d (incorrect -> 0xbd35), seq 20:89, ack 166, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 69: IPROTO size=18 request: SELECT, SYNC: 2 +SPACE: _vspace (ID: 281) +LIMIT: 4294967295 +KEY: [] +header: {1: 2, 0: 1} +body: {16: 281, 18: 4294967295, 32: []} + 108 16:57:31.369122 IP (tos 0x0, ttl 64, id 51477, offset 0, flags [DF], proto TCP (6), length 19812) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0x4b59 (incorrect -> 0x3d22), seq 166:19926, ack 89, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 19760: IPROTO size=4641 response: OK, SYNC: 2, SCHEMA_VERSION: 80 +DATA: +[257, 1, "_vinyl_deferred_delete", "blackhole", 0, {"group_id": 1}, [{"name": "space_id", "type": "unsigned"}, {"name": "lsn", "type": "unsigned"}, {"name": "tuple", "type": "array"}]] +[272, 1, "_schema", "memtx", 0, {}, [{"type": "string", "name": "key"}, {"type": "any", "name": "value", "is_nullable": true}]] +[276, 1, "_collation", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "owner", "type": "unsigned"}, {"name": "type", "type": "string"}, {"name": "locale", "type": "string"}, {"name": "opts", "type": "map"}]] +[277, 1, "_vcollation", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "owner", "type": "unsigned"}, {"name": "type", "type": "string"}, {"name": "locale", "type": "string"}, {"name": "opts", "type": "map"}]] +[280, 1, "_space", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "engine", "type": "string"}, {"name": "field_count", "type": "unsigned"}, {"name": "flags", "type": "map"}, {"name": "format", "type": "array"}]] +[281, 1, "_vspace", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "engine", "type": "string"}, {"name": "field_count", "type": "unsigned"}, {"name": "flags", "type": "map"}, {"name": "format", "type": "array"}]] +[284, 1, "_sequence", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "step", "type": "integer"}, {"name": "min", "type": "integer"}, {"name": "max", "type": "integer"}, {"name": "start", "type": "integer"}, {"name": "cache", "type": "integer"}, {"name": "cycle", "type": "boolean"}]] +[285, 1, "_sequence_data", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "value", "type": "integer"}]] +[286, 1, "_vsequence", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "step", "type": "integer"}, {"name": "min", "type": "integer"}, {"name": "max", "type": "integer"}, {"name": "start", "type": "integer"}, {"name": "cache", "type": "integer"}, {"name": "cycle", "type": "boolean"}]] +[288, 1, "_index", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "iid", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "opts", "type": "map"}, {"name": "parts", "type": "array"}]] +[289, 1, "_vindex", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "iid", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "opts", "type": "map"}, {"name": "parts", "type": "array"}]] +[296, 1, "_func", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "setuid", "type": "unsigned"}, {"name": "language", "type": "string"}, {"name": "body", "type": "string"}, {"name": "routine_type", "type": "string"}, {"name": "param_list", "type": "array"}, {"name": "returns", "type": "string"}, {"name": "aggregate", "type": "string"}, {"name": "sql_data_access", "type": "string"}, {"name": "is_deterministic", "type": "boolean"}, {"name": "is_sandboxed", "type": "boolean"}, {"name": "is_null_call", "type": "boolean"}, {"name": "exports", "type": "array"}, {"name": "opts", "type": "map"}, {"name": "comment", "type": "string"}, {"name": "created", "type": "string"}, {"name": "last_altered", "type": "string"}]] +[297, 1, "_vfunc", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "setuid", "type": "unsigned"}, {"name": "language", "type": "string"}, {"name": "body", "type": "string"}, {"name": "routine_type", "type": "string"}, {"name": "param_list", "type": "array"}, {"name": "returns", "type": "string"}, {"name": "aggregate", "type": "string"}, {"name": "sql_data_access", "type": "string"}, {"name": "is_deterministic", "type": "boolean"}, {"name": "is_sandboxed", "type": "boolean"}, {"name": "is_null_call", "type": "boolean"}, {"name": "exports", "type": "array"}, {"name": "opts", "type": "map"}, {"name": "comment", "type": "string"}, {"name": "created", "type": "string"}, {"name": "last_altered", "type": "string"}]] +[304, 1, "_user", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "auth", "type": "map"}]] +[305, 1, "_vuser", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "auth", "type": "map"}]] +[312, 1, "_priv", "memtx", 0, {}, [{"name": "grantor", "type": "unsigned"}, {"name": "grantee", "type": "unsigned"}, {"name": "object_type", "type": "string"}, {"name": "object_id", "type": "scalar"}, {"name": "privilege", "type": "unsigned"}]] +[313, 1, "_vpriv", "sysview", 0, {}, [{"name": "grantor", "type": "unsigned"}, {"name": "grantee", "type": "unsigned"}, {"name": "object_type", "type": "string"}, {"name": "object_id", "type": "scalar"}, {"name": "privilege", "type": "unsigned"}]] +[320, 1, "_cluster", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "uuid", "type": "string"}]] +[328, 1, "_trigger", "memtx", 0, {}, [{"name": "name", "type": "string"}, {"name": "space_id", "type": "unsigned"}, {"name": "opts", "type": "map"}]] +[330, 1, "_truncate", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "count", "type": "unsigned"}]] +[340, 1, "_space_sequence", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "sequence_id", "type": "unsigned"}, {"name": "is_generated", "type": "boolean"}, {"name": "field", "type": "unsigned"}, {"name": "path", "type": "string"}]] +[356, 1, "_fk_constraint", "memtx", 0, {}, [{"name": "name", "type": "string"}, {"name": "child_id", "type": "unsigned"}, {"name": "parent_id", "type": "unsigned"}, {"name": "is_deferred", "type": "boolean"}, {"name": "match", "type": "string"}, {"name": "on_delete", "type": "string"}, {"name": "on_update", "type": "string"}, {"name": "child_cols", "type": "array"}, {"name": "parent_cols", "type": "array"}]] +[364, 1, "_ck_constraint", "memtx", 0, {}, [{"name": "space_id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "is_deferred", "type": "boolean"}, {"name": "language", "type": "str"}, {"name": "code", "type": "str"}, {"name": "is_enabled", "type": "boolean"}]] +[372, 1, "_func_index", "memtx", 0, {}, [{"name": "space_id", "type": "unsigned"}, {"name": "index_id", "type": "unsigned"}, {"name": "func_id", "type": "unsigned"}]] +[380, 1, "_session_settings", "service", 2, {"temporary": true}, [{"name": "name", "type": "string"}, {"name": "value", "type": "any"}]] +[512, 1, "testspace", "memtx", 0, {"is_sync": true}, []] +header: {0: 0, 1: 2, 5: 80} +body: {48: [[257, 1, "_vinyl_deferred_delete", "blackhole", 0, {"group_id": 1}, [{"name": "space_id", "type": "unsigned"}, {"name": "lsn", "type": "unsigned"}, {"name": "tuple", "type": "array"}]], [272, 1, "_schema", "memtx", 0, {}, [{"type": "string", "name": "key"}, {"type": "any", "name": "value", "is_nullable": true}]], [276, 1, "_collation", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "owner", "type": "unsigned"}, {"name": "type", "type": "string"}, {"name": "locale", "type": "string"}, {"name": "opts", "type": "map"}]], [277, 1, "_vcollation", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "owner", "type": "unsigned"}, {"name": "type", "type": "string"}, {"name": "locale", "type": "string"}, {"name": "opts", "type": "map"}]], [280, 1, "_space", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "engine", "type": "string"}, {"name": "field_count", "type": "unsigned"}, {"name": "flags", "type": "map"}, {"name": "format", "type": "array"}]], [281, 1, "_vspace", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "engine", "type": "string"}, {"name": "field_count", "type": "unsigned"}, {"name": "flags", "type": "map"}, {"name": "format", "type": "array"}]], [284, 1, "_sequence", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "step", "type": "integer"}, {"name": "min", "type": "integer"}, {"name": "max", "type": "integer"}, {"name": "start", "type": "integer"}, {"name": "cache", "type": "integer"}, {"name": "cycle", "type": "boolean"}]], [285, 1, "_sequence_data", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "value", "type": "integer"}]], [286, 1, "_vsequence", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "step", "type": "integer"}, {"name": "min", "type": "integer"}, {"name": "max", "type": "integer"}, {"name": "start", "type": "integer"}, {"name": "cache", "type": "integer"}, {"name": "cycle", "type": "boolean"}]], [288, 1, "_index", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "iid", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "opts", "type": "map"}, {"name": "parts", "type": "array"}]], [289, 1, "_vindex", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "iid", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "opts", "type": "map"}, {"name": "parts", "type": "array"}]], [296, 1, "_func", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "setuid", "type": "unsigned"}, {"name": "language", "type": "string"}, {"name": "body", "type": "string"}, {"name": "routine_type", "type": "string"}, {"name": "param_list", "type": "array"}, {"name": "returns", "type": "string"}, {"name": "aggregate", "type": "string"}, {"name": "sql_data_access", "type": "string"}, {"name": "is_deterministic", "type": "boolean"}, {"name": "is_sandboxed", "type": "boolean"}, {"name": "is_null_call", "type": "boolean"}, {"name": "exports", "type": "array"}, {"name": "opts", "type": "map"}, {"name": "comment", "type": "string"}, {"name": "created", "type": "string"}, {"name": "last_altered", "type": "string"}]], [297, 1, "_vfunc", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "setuid", "type": "unsigned"}, {"name": "language", "type": "string"}, {"name": "body", "type": "string"}, {"name": "routine_type", "type": "string"}, {"name": "param_list", "type": "array"}, {"name": "returns", "type": "string"}, {"name": "aggregate", "type": "string"}, {"name": "sql_data_access", "type": "string"}, {"name": "is_deterministic", "type": "boolean"}, {"name": "is_sandboxed", "type": "boolean"}, {"name": "is_null_call", "type": "boolean"}, {"name": "exports", "type": "array"}, {"name": "opts", "type": "map"}, {"name": "comment", "type": "string"}, {"name": "created", "type": "string"}, {"name": "last_altered", "type": "string"}]], [304, 1, "_user", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "auth", "type": "map"}]], [305, 1, "_vuser", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "auth", "type": "map"}]], [312, 1, "_priv", "memtx", 0, {}, [{"name": "grantor", "type": "unsigned"}, {"name": "grantee", "type": "unsigned"}, {"name": "object_type", "type": "string"}, {"name": "object_id", "type": "scalar"}, {"name": "privilege", "type": "unsigned"}]], [313, 1, "_vpriv", "sysview", 0, {}, [{"name": "grantor", "type": "unsigned"}, {"name": "grantee", "type": "unsigned"}, {"name": "object_type", "type": "string"}, {"name": "object_id", "type": "scalar"}, {"name": "privilege", "type": "unsigned"}]], [320, 1, "_cluster", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "uuid", "type": "string"}]], [328, 1, "_trigger", "memtx", 0, {}, [{"name": "name", "type": "string"}, {"name": "space_id", "type": "unsigned"}, {"name": "opts", "type": "map"}]], [330, 1, "_truncate", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "count", "type": "unsigned"}]], [340, 1, "_space_sequence", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "sequence_id", "type": "unsigned"}, {"name": "is_generated", "type": "boolean"}, {"name": "field", "type": "unsigned"}, {"name": "path", "type": "string"}]], [356, 1, "_fk_constraint", "memtx", 0, {}, [{"name": "name", "type": "string"}, {"name": "child_id", "type": "unsigned"}, {"name": "parent_id", "type": "unsigned"}, {"name": "is_deferred", "type": "boolean"}, {"name": "match", "type": "string"}, {"name": "on_delete", "type": "string"}, {"name": "on_update", "type": "string"}, {"name": "child_cols", "type": "array"}, {"name": "parent_cols", "type": "array"}]], [364, 1, "_ck_constraint", "memtx", 0, {}, [{"name": "space_id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "is_deferred", "type": "boolean"}, {"name": "language", "type": "str"}, {"name": "code", "type": "str"}, {"name": "is_enabled", "type": "boolean"}]], [372, 1, "_func_index", "memtx", 0, {}, [{"name": "space_id", "type": "unsigned"}, {"name": "index_id", "type": "unsigned"}, {"name": "func_id", "type": "unsigned"}]], [380, 1, "_session_settings", "service", 2, {"temporary": true}, [{"name": "name", "type": "string"}, {"name": "value", "type": "any"}]], [512, 1, "testspace", "memtx", 0, {"is_sync": true}, []]]} + 109 16:57:31.369454 IP (tos 0x0, ttl 64, id 12071, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0x2375), seq 89:112, ack 19926, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 23: IPROTO size=18 +header: {0: 74} +body: {87: "box.shutdown"} + 110 16:57:31.369464 IP (tos 0x0, ttl 64, id 12072, offset 0, flags [DF], proto TCP (6), length 62) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe32 (incorrect -> 0xb566), seq 112:122, ack 19926, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 10: IPROTO size=5 request: PING, SYNC: 5 +header: {1: 5, 0: 64} + 111 16:57:31.369561 IP (tos 0x0, ttl 64, id 51478, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [.], cksum 0xfe28 (incorrect -> 0x8a36), seq 19926, ack 122, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 0 + 112 16:57:31.369694 IP (tos 0x0, ttl 64, id 51479, offset 0, flags [DF], proto TCP (6), length 104) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe5c (incorrect -> 0x554f), seq 19926:19978, ack 122, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 52: IPROTO size=24 response: OK, SYNC: 5, SCHEMA_VERSION: 80 +header: {0: 0, 1: 5, 5: 80} +body: {} + 113 16:57:31.369766 IP (tos 0x0, ttl 64, id 12073, offset 0, flags [DF], proto TCP (6), length 94) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe52 (incorrect -> 0xfda8), seq 122:164, ack 19978, win 512, options [nop,nop,TS val 1977541258 ecr 1977541258], length 42: IPROTO size=14 request: INSERT, SYNC: 6 +SPACE_ID: 512 +TUPLE: [1, 10] +header: {1: 6, 0: 2} +body: {16: 512, 33: [1, 10]} + 114 16:57:31.370030 IP (tos 0x0, ttl 64, id 57387, offset 0, flags [DF], proto TCP (6), length 85) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe49 (incorrect -> 0x15e7), seq 27184:27217, ack 245, win 512, options [nop,nop,TS val 1977541259 ecr 1977541184], length 33: IPROTO size=28 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 12, TIMESTAMP: 2022-12-15 16:57:31.369981, FLAGS: 6 +SPACE_ID: 512 +TUPLE: [1, 10] +header: {0: 2, 2: 1, 3: 12, 4: 1.67112e+09, 9: 6} +body: {16: 512, 33: [1, 10]} + 115 16:57:31.370150 IP (tos 0x0, ttl 64, id 57388, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x7e7f), seq 27217:27244, ack 245, win 512, options [nop,nop,TS val 1977541259 ecr 1977541184], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 13, TIMESTAMP: 2022-12-15 16:57:31.370125 +REPLICA_ID: 1 +LSN: 12 +header: {0: 40, 2: 1, 3: 13, 4: 1.67112e+09} +body: {2: 1, 3: 12} + 116 16:57:31.370210 IP (tos 0x0, ttl 64, id 43354, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x536d), seq 245, ack 27244, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 0 + 117 16:57:31.370210 IP (tos 0x0, ttl 64, id 51480, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x3097), seq 19978:20016, ack 164, win 512, options [nop,nop,TS val 1977541259 ecr 1977541258], length 38: IPROTO size=33 response: OK, SYNC: 6, SCHEMA_VERSION: 80 +DATA: +[1, 10] +header: {0: 0, 1: 6, 5: 80} +body: {48: [[1, 10]]} + 118 16:57:31.370301 IP (tos 0x0, ttl 64, id 12074, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xb6d2), seq 164:183, ack 20016, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 19: IPROTO size=14 request: INSERT, SYNC: 7 +SPACE_ID: 512 +TUPLE: [2, 20] +header: {1: 7, 0: 2} +body: {16: 512, 33: [2, 20]} + 119 16:57:31.370368 IP (tos 0x0, ttl 64, id 43355, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0x0a90), seq 245:268, ack 27244, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.369981 +VCLOCK: {1: 12} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 12}} + 120 16:57:31.370446 IP (tos 0x0, ttl 64, id 57389, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x5356), seq 27244, ack 268, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 0 + 121 16:57:31.370452 IP (tos 0x0, ttl 64, id 43356, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0x071c), seq 268:291, ack 27244, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.370125 +VCLOCK: {1: 13} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 13}} + 122 16:57:31.370460 IP (tos 0x0, ttl 64, id 57390, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x533f), seq 27244, ack 291, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 0 + 123 16:57:31.370481 IP (tos 0x0, ttl 64, id 57391, offset 0, flags [DF], proto TCP (6), length 85) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe49 (incorrect -> 0x0368), seq 27244:27277, ack 291, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 33: IPROTO size=28 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 14, TIMESTAMP: 2022-12-15 16:57:31.370455, FLAGS: 6 +SPACE_ID: 512 +TUPLE: [2, 20] +header: {0: 2, 2: 1, 3: 14, 4: 1.67112e+09, 9: 6} +body: {16: 512, 33: [2, 20]} + 124 16:57:31.370486 IP (tos 0x0, ttl 64, id 57392, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x7625), seq 27277:27304, ack 291, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 15, TIMESTAMP: 2022-12-15 16:57:31.370469 +REPLICA_ID: 1 +LSN: 14 +header: {0: 40, 2: 1, 3: 15, 4: 1.67112e+09} +body: {2: 1, 3: 14} + 125 16:57:31.370566 IP (tos 0x0, ttl 64, id 51481, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x2f52), seq 20016:20054, ack 183, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 38: IPROTO size=33 response: OK, SYNC: 7, SCHEMA_VERSION: 80 +DATA: +[2, 20] +header: {0: 0, 1: 7, 5: 80} +body: {48: [[2, 20]]} + 126 16:57:31.370566 IP (tos 0x0, ttl 64, id 43357, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x5303), seq 291, ack 27304, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 0 + 127 16:57:31.370627 IP (tos 0x0, ttl 64, id 12075, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xac97), seq 183:202, ack 20054, win 512, options [nop,nop,TS val 1977541259 ecr 1977541259], length 19: IPROTO size=14 request: INSERT, SYNC: 8 +SPACE_ID: 512 +TUPLE: [3, 30] +header: {1: 8, 0: 2} +body: {16: 512, 33: [3, 30]} + 128 16:57:31.370804 IP (tos 0x0, ttl 64, id 43358, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0x005e), seq 291:314, ack 27304, win 512, options [nop,nop,TS val 1977541260 ecr 1977541259], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.370455 +VCLOCK: {1: 14} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 14}} + 129 16:57:31.370845 IP (tos 0x0, ttl 64, id 57393, offset 0, flags [DF], proto TCP (6), length 85) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe49 (incorrect -> 0xf394), seq 27304:27337, ack 314, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 33: IPROTO size=28 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 16, TIMESTAMP: 2022-12-15 16:57:31.370790, FLAGS: 6 +SPACE_ID: 512 +TUPLE: [3, 30] +header: {0: 2, 2: 1, 3: 16, 4: 1.67112e+09, 9: 6} +body: {16: 512, 33: [3, 30]} + 130 16:57:31.370868 IP (tos 0x0, ttl 64, id 57394, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x6d93), seq 27337:27364, ack 314, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 17, TIMESTAMP: 2022-12-15 16:57:31.370849 +REPLICA_ID: 1 +LSN: 16 +header: {0: 40, 2: 1, 3: 17, 4: 1.67112e+09} +body: {2: 1, 3: 16} + 131 16:57:31.370898 IP (tos 0x0, ttl 64, id 43359, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x52ae), seq 314, ack 27364, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 132 16:57:31.370907 IP (tos 0x0, ttl 64, id 43360, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xfed0), seq 314:337, ack 27364, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.370469 +VCLOCK: {1: 15} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 15}} + 133 16:57:31.371014 IP (tos 0x0, ttl 64, id 51482, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x2e0d), seq 20054:20092, ack 202, win 512, options [nop,nop,TS val 1977541260 ecr 1977541259], length 38: IPROTO size=33 response: OK, SYNC: 8, SCHEMA_VERSION: 80 +DATA: +[3, 30] +header: {0: 0, 1: 8, 5: 80} +body: {48: [[3, 30]]} + 134 16:57:31.371066 IP (tos 0x0, ttl 64, id 12076, offset 0, flags [DF], proto TCP (6), length 88) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe4c (incorrect -> 0x7165), seq 202:238, ack 20092, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 36: IPROTO size=31 request: INSERT, SYNC: 9 +SPACE_ID: 512 +TUPLE: [4, (UUID: 8ca72637-11b1-4d80-8ac8-8f530a623953)] +header: {1: 9, 0: 2} +body: {16: 512, 33: [4, (UUID: 8ca72637-11b1-4d80-8ac8-8f530a623953)]} + 135 16:57:31.371114 IP (tos 0x0, ttl 64, id 43361, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xf877), seq 337:360, ack 27364, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.370790 +VCLOCK: {1: 16} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 16}} + 136 16:57:31.371124 IP (tos 0x0, ttl 64, id 43362, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xf667), seq 360:383, ack 27364, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.370849 +VCLOCK: {1: 17} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 17}} + 137 16:57:31.371200 IP (tos 0x0, ttl 64, id 57395, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x5269), seq 27364, ack 383, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 138 16:57:31.371215 IP (tos 0x0, ttl 64, id 57396, offset 0, flags [DF], proto TCP (6), length 102) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe5a (incorrect -> 0xb189), seq 27364:27414, ack 383, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 50: IPROTO size=45 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 18, TIMESTAMP: 2022-12-15 16:57:31.371191, FLAGS: 6 +SPACE_ID: 512 +TUPLE: [4, (UUID: 8ca72637-11b1-4d80-8ac8-8f530a623953)] +header: {0: 2, 2: 1, 3: 18, 4: 1.67112e+09, 9: 6} +body: {16: 512, 33: [4, (UUID: 8ca72637-11b1-4d80-8ac8-8f530a623953)]} + 139 16:57:31.371222 IP (tos 0x0, ttl 64, id 57397, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x6501), seq 27414:27441, ack 383, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 19, TIMESTAMP: 2022-12-15 16:57:31.371215 +REPLICA_ID: 1 +LSN: 18 +header: {0: 40, 2: 1, 3: 19, 4: 1.67112e+09} +body: {2: 1, 3: 18} + 140 16:57:31.371229 IP (tos 0x0, ttl 64, id 43363, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x521c), seq 383, ack 27441, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 141 16:57:31.371234 IP (tos 0x0, ttl 64, id 51483, offset 0, flags [DF], proto TCP (6), length 107) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe5f (incorrect -> 0x3786), seq 20092:20147, ack 238, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 55: IPROTO size=50 response: OK, SYNC: 9, SCHEMA_VERSION: 80 +DATA: +[4, (UUID: 8ca72637-11b1-4d80-8ac8-8f530a623953)] +header: {0: 0, 1: 9, 5: 80} +body: {48: [[4, (UUID: 8ca72637-11b1-4d80-8ac8-8f530a623953)]]} + 142 16:57:31.371254 IP (tos 0x0, ttl 64, id 12077, offset 0, flags [DF], proto TCP (6), length 86) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe4a (incorrect -> 0x50cc), seq 238:272, ack 20147, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 34: IPROTO size=29 request: INSERT, SYNC: 10 +SPACE_ID: 512 +TUPLE: [5, (Decimal: -0987654321.0000000000123)] +header: {1: 10, 0: 2} +body: {16: 512, 33: [5, (Decimal: -0987654321.0000000000123)]} + 143 16:57:31.371308 IP (tos 0x0, ttl 64, id 43364, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xef6a), seq 383:406, ack 27441, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371191 +VCLOCK: {1: 18} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 18}} + 144 16:57:31.371317 IP (tos 0x0, ttl 64, id 43365, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xedee), seq 406:429, ack 27441, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371215 +VCLOCK: {1: 19} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 19}} + 145 16:57:31.371329 IP (tos 0x0, ttl 64, id 57398, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x51ee), seq 27441, ack 429, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 146 16:57:31.371341 IP (tos 0x0, ttl 64, id 51484, offset 0, flags [DF], proto TCP (6), length 105) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe5d (incorrect -> 0xfa0b), seq 20147:20200, ack 272, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 53: IPROTO size=48 response: OK, SYNC: 10, SCHEMA_VERSION: 80 +DATA: +[5, (Decimal: -0987654321.0000000000123)] +header: {0: 0, 1: 10, 5: 80} +body: {48: [[5, (Decimal: -0987654321.0000000000123)]]} + 147 16:57:31.371343 IP (tos 0x0, ttl 64, id 57399, offset 0, flags [DF], proto TCP (6), length 100) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe58 (incorrect -> 0x8ee5), seq 27441:27489, ack 429, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 48: IPROTO size=43 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 20, TIMESTAMP: 2022-12-15 16:57:31.371308, FLAGS: 6 +SPACE_ID: 512 +TUPLE: [5, (Decimal: -0987654321.0000000000123)] +header: {0: 2, 2: 1, 3: 20, 4: 1.67112e+09, 9: 6} +body: {16: 512, 33: [5, (Decimal: -0987654321.0000000000123)]} + 148 16:57:31.371348 IP (tos 0x0, ttl 64, id 57400, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x60b6), seq 27489:27516, ack 429, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 21, TIMESTAMP: 2022-12-15 16:57:31.371325 +REPLICA_ID: 1 +LSN: 20 +header: {0: 40, 2: 1, 3: 21, 4: 1.67112e+09} +body: {2: 1, 3: 20} + 149 16:57:31.371352 IP (tos 0x0, ttl 64, id 12078, offset 0, flags [DF], proto TCP (6), length 91) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe4f (incorrect -> 0x26b1), seq 272:311, ack 20200, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 39: IPROTO size=34 request: INSERT, SYNC: 11 +SPACE_ID: 512 +TUPLE: [6, (Decimal: 0.0123456789876543212345678987654321)] +header: {1: 11, 0: 2} +body: {16: 512, 33: [6, (Decimal: 0.0123456789876543212345678987654321)]} + 150 16:57:31.371352 IP (tos 0x0, ttl 64, id 43366, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x51a3), seq 429, ack 27516, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 151 16:57:31.371378 IP (tos 0x0, ttl 64, id 57401, offset 0, flags [DF], proto TCP (6), length 105) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe5d (incorrect -> 0x63ec), seq 27516:27569, ack 429, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 53: IPROTO size=48 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 22, TIMESTAMP: 2022-12-15 16:57:31.371363, FLAGS: 6 +SPACE_ID: 512 +TUPLE: [6, (Decimal: 0.0123456789876543212345678987654321)] +header: {0: 2, 2: 1, 3: 22, 4: 1.67112e+09, 9: 6} +body: {16: 512, 33: [6, (Decimal: 0.0123456789876543212345678987654321)]} + 152 16:57:31.371384 IP (tos 0x0, ttl 64, id 57402, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x5d8c), seq 27569:27596, ack 429, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 23, TIMESTAMP: 2022-12-15 16:57:31.371377 +REPLICA_ID: 1 +LSN: 22 +header: {0: 40, 2: 1, 3: 23, 4: 1.67112e+09} +body: {2: 1, 3: 22} + 153 16:57:31.371391 IP (tos 0x0, ttl 64, id 51485, offset 0, flags [DF], proto TCP (6), length 110) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe62 (incorrect -> 0x3685), seq 20200:20258, ack 311, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 58: IPROTO size=53 response: OK, SYNC: 11, SCHEMA_VERSION: 80 +DATA: +[6, (Decimal: 0.0123456789876543212345678987654321)] +header: {0: 0, 1: 11, 5: 80} +body: {48: [[6, (Decimal: 0.0123456789876543212345678987654321)]]} + 154 16:57:31.371392 IP (tos 0x0, ttl 64, id 43367, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x5153), seq 429, ack 27596, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 155 16:57:31.371417 IP (tos 0x0, ttl 64, id 43368, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xeab7), seq 429:452, ack 27596, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371308 +VCLOCK: {1: 20} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 20}} + 156 16:57:31.371430 IP (tos 0x0, ttl 64, id 43369, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xe955), seq 452:475, ack 27596, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371325 +VCLOCK: {1: 21} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 21}} + 157 16:57:31.371435 IP (tos 0x0, ttl 64, id 57403, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x5125), seq 27596, ack 475, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 158 16:57:31.371435 IP (tos 0x0, ttl 64, id 43370, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xe7a0), seq 475:498, ack 27596, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371363 +VCLOCK: {1: 22} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 22}} + 159 16:57:31.371443 IP (tos 0x0, ttl 64, id 12079, offset 0, flags [DF], proto TCP (6), length 88) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe4c (incorrect -> 0x14d0), seq 311:347, ack 20258, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 36: IPROTO size=31 request: INSERT, SYNC: 12 +SPACE_ID: 512 +TUPLE: [7, (Datetime: len 16)] +header: {1: 12, 0: 2} +body: {16: 512, 33: [7, (Datetime: len 16)]} + 160 16:57:31.371451 IP (tos 0x0, ttl 64, id 43371, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xe64f), seq 498:521, ack 27596, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371377 +VCLOCK: {1: 23} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 23}} + 161 16:57:31.371457 IP (tos 0x0, ttl 64, id 57404, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x50f7), seq 27596, ack 521, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 162 16:57:31.371476 IP (tos 0x0, ttl 64, id 57405, offset 0, flags [DF], proto TCP (6), length 102) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe5a (incorrect -> 0x502d), seq 27596:27646, ack 521, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 50: IPROTO size=45 request: INSERT, SYNC: 0, REPLICA_ID: 1, LSN: 24, TIMESTAMP: 2022-12-15 16:57:31.371459, FLAGS: 6 +SPACE_ID: 512 +TUPLE: [7, (Datetime: len 16)] +header: {0: 2, 2: 1, 3: 24, 4: 1.67112e+09, 9: 6} +body: {16: 512, 33: [7, (Datetime: len 16)]} + 163 16:57:31.371479 IP (tos 0x0, ttl 64, id 51486, offset 0, flags [DF], proto TCP (6), length 107) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe5f (incorrect -> 0xb714), seq 20258:20313, ack 347, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 55: IPROTO size=50 response: OK, SYNC: 12, SCHEMA_VERSION: 80 +DATA: +[7, (Datetime: len 16)] +header: {0: 0, 1: 12, 5: 80} +body: {48: [[7, (Datetime: len 16)]]} + 164 16:57:31.371480 IP (tos 0x0, ttl 64, id 57406, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x5972), seq 27646:27673, ack 521, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 25, TIMESTAMP: 2022-12-15 16:57:31.371464 +REPLICA_ID: 1 +LSN: 24 +header: {0: 40, 2: 1, 3: 25, 4: 1.67112e+09} +body: {2: 1, 3: 24} + 165 16:57:31.371484 IP (tos 0x0, ttl 64, id 43372, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x50aa), seq 521, ack 27673, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 166 16:57:31.371492 IP (tos 0x0, ttl 64, id 12080, offset 0, flags [DF], proto TCP (6), length 78) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe42 (incorrect -> 0xbc9c), seq 347:373, ack 20313, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 26: IPROTO size=21 request: SELECT, SYNC: 13 +SPACE_ID: 512 +INDEX_ID: 0 +ITERATOR: EQ +OFFSET: 0 +LIMIT: 2 +KEY: [1] +header: {1: 13, 0: 1} +body: {16: 512, 17: 0, 20: 0, 19: 0, 18: 2, 32: [1]} + 167 16:57:31.371509 IP (tos 0x0, ttl 64, id 51487, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x2e6d), seq 20313:20351, ack 373, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 38: IPROTO size=33 response: OK, SYNC: 13, SCHEMA_VERSION: 80 +DATA: +[1, 10] +header: {0: 0, 1: 13, 5: 80} +body: {48: [[1, 10]]} + 168 16:57:31.371522 IP (tos 0x0, ttl 64, id 12081, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe45 (incorrect -> 0xec58), seq 373:402, ack 20351, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 29: IPROTO size=24 request: SELECT, SYNC: 14 +SPACE_ID: 512 +INDEX_ID: 0 +ITERATOR: ALL +OFFSET: 0 +LIMIT: 4294967295 +KEY: [] +header: {1: 14, 0: 1} +body: {16: 512, 17: 0, 20: 2, 19: 0, 18: 4294967295, 32: []} + 169 16:57:31.371534 IP (tos 0x0, ttl 64, id 51488, offset 0, flags [DF], proto TCP (6), length 177) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfea5 (incorrect -> 0xc7f2), seq 20351:20476, ack 402, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 125: IPROTO size=120 response: OK, SYNC: 14, SCHEMA_VERSION: 80 +DATA: +[1, 10] +[2, 20] +[3, 30] +[4, (UUID: 8ca72637-11b1-4d80-8ac8-8f530a623953)] +[5, (Decimal: -0987654321.0000000000123)] +[6, (Decimal: 0.0123456789876543212345678987654321)] +[7, (Datetime: len 16)] +header: {0: 0, 1: 14, 5: 80} +body: {48: [[1, 10], [2, 20], [3, 30], [4, (UUID: 8ca72637-11b1-4d80-8ac8-8f530a623953)], [5, (Decimal: -0987654321.0000000000123)], [6, (Decimal: 0.0123456789876543212345678987654321)], [7, (Datetime: len 16)]]} + 170 16:57:31.371546 IP (tos 0x0, ttl 64, id 12082, offset 0, flags [DF], proto TCP (6), length 73) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3d (incorrect -> 0xb601), seq 402:423, ack 20476, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 21: IPROTO size=16 request: REPLACE, SYNC: 15 +SPACE_ID: 512 +TUPLE: [5, 6, 7, 8] +header: {1: 15, 0: 3} +body: {16: 512, 33: [5, 6, 7, 8]} + 171 16:57:31.371567 IP (tos 0x0, ttl 64, id 43373, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xe393), seq 521:544, ack 27673, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371459 +VCLOCK: {1: 24} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 24}} + 172 16:57:31.371579 IP (tos 0x0, ttl 64, id 43374, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xe265), seq 544:567, ack 27673, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371464 +VCLOCK: {1: 25} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 25}} + 173 16:57:31.371612 IP (tos 0x0, ttl 64, id 57407, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x507c), seq 27673, ack 567, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 174 16:57:31.371626 IP (tos 0x0, ttl 64, id 57408, offset 0, flags [DF], proto TCP (6), length 87) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe4b (incorrect -> 0xefd1), seq 27673:27708, ack 567, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 35: IPROTO size=30 request: REPLACE, SYNC: 0, REPLICA_ID: 1, LSN: 26, TIMESTAMP: 2022-12-15 16:57:31.371598, FLAGS: 6 +SPACE_ID: 512 +TUPLE: [5, 6, 7, 8] +header: {0: 3, 2: 1, 3: 26, 4: 1.67112e+09, 9: 6} +body: {16: 512, 33: [5, 6, 7, 8]} + 175 16:57:31.371633 IP (tos 0x0, ttl 64, id 57409, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x5470), seq 27708:27735, ack 567, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 27, TIMESTAMP: 2022-12-15 16:57:31.371622 +REPLICA_ID: 1 +LSN: 26 +header: {0: 40, 2: 1, 3: 27, 4: 1.67112e+09} +body: {2: 1, 3: 26} + 176 16:57:31.371635 IP (tos 0x0, ttl 64, id 51489, offset 0, flags [DF], proto TCP (6), length 92) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe50 (incorrect -> 0x208e), seq 20476:20516, ack 423, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 40: IPROTO size=35 response: OK, SYNC: 15, SCHEMA_VERSION: 80 +DATA: +[5, 6, 7, 8] +header: {0: 0, 1: 15, 5: 80} +body: {48: [[5, 6, 7, 8]]} + 177 16:57:31.371639 IP (tos 0x0, ttl 64, id 43375, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x503e), seq 567, ack 27735, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 178 16:57:31.371650 IP (tos 0x0, ttl 64, id 12083, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe45 (incorrect -> 0xc36b), seq 423:452, ack 20516, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 29: IPROTO size=24 request: UPDATE, SYNC: 16 +SPACE_ID: 512 +INDEX_ID: 0 +INDEX_BASE: 1 +KEY: [1] +TUPLE: [["=", 2, 5]] +header: {1: 16, 0: 4} +body: {16: 512, 17: 0, 21: 1, 32: [1], 33: [["=", 2, 5]]} + 179 16:57:31.371705 IP (tos 0x0, ttl 64, id 43376, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xdedf), seq 567:590, ack 27735, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371598 +VCLOCK: {1: 26} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 26}} + 180 16:57:31.371722 IP (tos 0x0, ttl 64, id 43377, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xdd65), seq 590:613, ack 27735, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371622 +VCLOCK: {1: 27} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 27}} + 181 16:57:31.371734 IP (tos 0x0, ttl 64, id 57410, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x5010), seq 27735, ack 613, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 182 16:57:31.371751 IP (tos 0x0, ttl 64, id 57411, offset 0, flags [DF], proto TCP (6), length 93) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe51 (incorrect -> 0xfe0b), seq 27735:27776, ack 613, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 41: IPROTO size=36 request: UPDATE, SYNC: 0, REPLICA_ID: 1, LSN: 28, TIMESTAMP: 2022-12-15 16:57:31.371725, FLAGS: 6 +SPACE_ID: 512 +INDEX_BASE: 1 +KEY: [1] +TUPLE: [["=", 2, 5]] +header: {0: 4, 2: 1, 3: 28, 4: 1.67112e+09, 9: 6} +body: {16: 512, 21: 1, 32: [1], 33: [["=", 2, 5]]} + 183 16:57:31.371759 IP (tos 0x0, ttl 64, id 57412, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x4ff1), seq 27776:27803, ack 613, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 29, TIMESTAMP: 2022-12-15 16:57:31.371747 +REPLICA_ID: 1 +LSN: 28 +header: {0: 40, 2: 1, 3: 29, 4: 1.67112e+09} +body: {2: 1, 3: 28} + 184 16:57:31.371760 IP (tos 0x0, ttl 64, id 51490, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x2d55), seq 20516:20554, ack 452, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 38: IPROTO size=33 response: OK, SYNC: 16, SCHEMA_VERSION: 80 +DATA: +[1, 5] +header: {0: 0, 1: 16, 5: 80} +body: {48: [[1, 5]]} + 185 16:57:31.371765 IP (tos 0x0, ttl 64, id 43378, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x4fcc), seq 613, ack 27803, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 0 + 186 16:57:31.371774 IP (tos 0x0, ttl 64, id 12084, offset 0, flags [DF], proto TCP (6), length 88) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe4c (incorrect -> 0x0551), seq 452:488, ack 20554, win 512, options [nop,nop,TS val 1977541260 ecr 1977541260], length 36: IPROTO size=31 request: UPSERT, SYNC: 17 +SPACE_ID: 512 +INDEX_BASE: 1 +TUPLE: [12, "c"] +OPS: [["=", 3, "a"], ["=", 4, "b"]] +header: {1: 17, 0: 9} +body: {16: 512, 21: 1, 33: [12, "c"], 40: [["=", 3, "a"], ["=", 4, "b"]]} + 187 16:57:31.371819 IP (tos 0x0, ttl 64, id 57413, offset 0, flags [DF], proto TCP (6), length 102) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe5a (incorrect -> 0xa723), seq 27803:27853, ack 613, win 512, options [nop,nop,TS val 1977541261 ecr 1977541260], length 50: IPROTO size=45 request: UPSERT, SYNC: 0, REPLICA_ID: 1, LSN: 30, TIMESTAMP: 2022-12-15 16:57:31.371804, FLAGS: 6 +SPACE_ID: 512 +INDEX_BASE: 1 +OPS: [["=", 3, "a"], ["=", 4, "b"]] +TUPLE: [12, "c"] +header: {0: 9, 2: 1, 3: 30, 4: 1.67112e+09, 9: 6} +body: {16: 512, 21: 1, 40: [["=", 3, "a"], ["=", 4, "b"]], 33: [12, "c"]} + 188 16:57:31.371825 IP (tos 0x0, ttl 64, id 57414, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x4c86), seq 27853:27880, ack 613, win 512, options [nop,nop,TS val 1977541261 ecr 1977541260], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 31, TIMESTAMP: 2022-12-15 16:57:31.371814 +REPLICA_ID: 1 +LSN: 30 +header: {0: 40, 2: 1, 3: 31, 4: 1.67112e+09} +body: {2: 1, 3: 30} + 189 16:57:31.371826 IP (tos 0x0, ttl 64, id 51491, offset 0, flags [DF], proto TCP (6), length 87) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4b (incorrect -> 0x32a3), seq 20554:20589, ack 488, win 512, options [nop,nop,TS val 1977541261 ecr 1977541260], length 35: IPROTO size=30 response: OK, SYNC: 17, SCHEMA_VERSION: 80 +header: {0: 0, 1: 17, 5: 80} +body: {48: []} + 190 16:57:31.371828 IP (tos 0x0, ttl 64, id 43379, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xda0b), seq 613:636, ack 27880, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371725 +VCLOCK: {1: 28} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 28}} + 191 16:57:31.371836 IP (tos 0x0, ttl 64, id 12085, offset 0, flags [DF], proto TCP (6), length 72) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3c (incorrect -> 0xc62f), seq 488:508, ack 20589, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 20: IPROTO size=15 request: DELETE, SYNC: 18 +SPACE_ID: 512 +INDEX_ID: 0 +KEY: [1] +header: {1: 18, 0: 5} +body: {16: 512, 17: 0, 32: [1]} + 192 16:57:31.371841 IP (tos 0x0, ttl 64, id 43380, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xd899), seq 636:659, ack 27880, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371747 +VCLOCK: {1: 29} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 29}} + 193 16:57:31.371846 IP (tos 0x0, ttl 64, id 57415, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x4f4f), seq 27880, ack 659, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 194 16:57:31.371861 IP (tos 0x0, ttl 64, id 57416, offset 0, flags [DF], proto TCP (6), length 84) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe48 (incorrect -> 0xfe91), seq 27880:27912, ack 659, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 32: IPROTO size=27 request: DELETE, SYNC: 0, REPLICA_ID: 1, LSN: 32, TIMESTAMP: 2022-12-15 16:57:31.371849, FLAGS: 6 +SPACE_ID: 512 +KEY: [1] +header: {0: 5, 2: 1, 3: 32, 4: 1.67112e+09, 9: 6} +body: {16: 512, 32: [1]} + 195 16:57:31.371868 IP (tos 0x0, ttl 64, id 57417, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x4968), seq 27912:27939, ack 659, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 33, TIMESTAMP: 2022-12-15 16:57:31.371856 +REPLICA_ID: 1 +LSN: 32 +header: {0: 40, 2: 1, 3: 33, 4: 1.67112e+09} +body: {2: 1, 3: 32} + 196 16:57:31.371870 IP (tos 0x0, ttl 64, id 51492, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x2cd0), seq 20589:20627, ack 508, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 38: IPROTO size=33 response: OK, SYNC: 18, SCHEMA_VERSION: 80 +DATA: +[1, 5] +header: {0: 0, 1: 18, 5: 80} +body: {48: [[1, 5]]} + 197 16:57:31.371873 IP (tos 0x0, ttl 64, id 43381, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x4f14), seq 659, ack 27939, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 198 16:57:31.371880 IP (tos 0x0, ttl 64, id 12086, offset 0, flags [DF], proto TCP (6), length 72) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3c (incorrect -> 0xc5f3), seq 508:528, ack 20627, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 20: IPROTO size=15 request: DELETE, SYNC: 19 +SPACE_ID: 512 +INDEX_ID: 0 +KEY: [2] +header: {1: 19, 0: 5} +body: {16: 512, 17: 0, 32: [2]} + 199 16:57:31.371930 IP (tos 0x0, ttl 64, id 43382, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xd656), seq 659:682, ack 27939, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371804 +VCLOCK: {1: 30} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 30}} + 200 16:57:31.371948 IP (tos 0x0, ttl 64, id 43383, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xd515), seq 682:705, ack 27939, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371814 +VCLOCK: {1: 31} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 31}} + 201 16:57:31.371958 IP (tos 0x0, ttl 64, id 43384, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xd36d), seq 705:728, ack 27939, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371849 +VCLOCK: {1: 32} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 32}} + 202 16:57:31.371960 IP (tos 0x0, ttl 64, id 57418, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x4ee6), seq 27939, ack 705, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 203 16:57:31.371971 IP (tos 0x0, ttl 64, id 43385, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xd235), seq 728:751, ack 27939, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371856 +VCLOCK: {1: 33} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 33}} + 204 16:57:31.371977 IP (tos 0x0, ttl 64, id 57419, offset 0, flags [DF], proto TCP (6), length 84) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe48 (incorrect -> 0xfc48), seq 27939:27971, ack 751, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 32: IPROTO size=27 request: DELETE, SYNC: 0, REPLICA_ID: 1, LSN: 34, TIMESTAMP: 2022-12-15 16:57:31.371951, FLAGS: 6 +SPACE_ID: 512 +KEY: [2] +header: {0: 5, 2: 1, 3: 34, 4: 1.67112e+09, 9: 6} +body: {16: 512, 32: [2]} + 205 16:57:31.371984 IP (tos 0x0, ttl 64, id 51493, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x2b86), seq 20627:20665, ack 528, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 38: IPROTO size=33 response: OK, SYNC: 19, SCHEMA_VERSION: 80 +DATA: +[2, 20] +header: {0: 0, 1: 19, 5: 80} +body: {48: [[2, 20]]} + 206 16:57:31.371984 IP (tos 0x0, ttl 64, id 57420, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x44f0), seq 27971:27998, ack 751, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 35, TIMESTAMP: 2022-12-15 16:57:31.371971 +REPLICA_ID: 1 +LSN: 34 +header: {0: 40, 2: 1, 3: 35, 4: 1.67112e+09} +body: {2: 1, 3: 34} + 207 16:57:31.371988 IP (tos 0x0, ttl 64, id 43386, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x4e7d), seq 751, ack 27998, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 208 16:57:31.371995 IP (tos 0x0, ttl 64, id 12087, offset 0, flags [DF], proto TCP (6), length 72) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3c (incorrect -> 0xc5b7), seq 528:548, ack 20665, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 20: IPROTO size=15 request: DELETE, SYNC: 20 +SPACE_ID: 512 +INDEX_ID: 0 +KEY: [3] +header: {1: 20, 0: 5} +body: {16: 512, 17: 0, 32: [3]} + 209 16:57:31.372021 IP (tos 0x0, ttl 64, id 57421, offset 0, flags [DF], proto TCP (6), length 84) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe48 (incorrect -> 0xfb21), seq 27998:28030, ack 751, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 32: IPROTO size=27 request: DELETE, SYNC: 0, REPLICA_ID: 1, LSN: 36, TIMESTAMP: 2022-12-15 16:57:31.372007, FLAGS: 6 +SPACE_ID: 512 +KEY: [3] +header: {0: 5, 2: 1, 3: 36, 4: 1.67112e+09, 9: 6} +body: {16: 512, 32: [3]} + 210 16:57:31.372031 IP (tos 0x0, ttl 64, id 57422, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [P.], cksum 0xfe43 (incorrect -> 0x41e2), seq 28030:28057, ack 751, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 27: IPROTO size=22 request: RAFT_CONFIRM, SYNC: 0, REPLICA_ID: 1, LSN: 37, TIMESTAMP: 2022-12-15 16:57:31.372020 +REPLICA_ID: 1 +LSN: 36 +header: {0: 40, 2: 1, 3: 37, 4: 1.67112e+09} +body: {2: 1, 3: 36} + 211 16:57:31.372036 IP (tos 0x0, ttl 64, id 43387, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x4e42), seq 751, ack 28057, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 212 16:57:31.372036 IP (tos 0x0, ttl 64, id 51494, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x2a41), seq 20665:20703, ack 548, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 38: IPROTO size=33 response: OK, SYNC: 20, SCHEMA_VERSION: 80 +DATA: +[3, 30] +header: {0: 0, 1: 20, 5: 80} +body: {48: [[3, 30]]} + 213 16:57:31.372046 IP (tos 0x0, ttl 64, id 12088, offset 0, flags [DF], proto TCP (6), length 112) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe64 (incorrect -> 0x6e7a), seq 548:608, ack 20703, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 60: IPROTO size=55 request: EVAL, SYNC: 21 +EXPR: function f5() return 5 + 5 end; return f5(); +TUPLE: [] +header: {1: 21, 0: 8} +body: {39: "function f5() return 5 + 5 end; return f5();", 33: []} + 214 16:57:31.372059 IP (tos 0x0, ttl 64, id 43388, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xcf1a), seq 751:774, ack 28057, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371951 +VCLOCK: {1: 34} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 34}} + 215 16:57:31.372070 IP (tos 0x0, ttl 64, id 51495, offset 0, flags [DF], proto TCP (6), length 88) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4c (incorrect -> 0x2f86), seq 20703:20739, ack 608, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 36: IPROTO size=31 response: OK, SYNC: 21, SCHEMA_VERSION: 80 +DATA: +10 +header: {0: 0, 1: 21, 5: 80} +body: {48: [10]} + 216 16:57:31.372079 IP (tos 0x0, ttl 64, id 43389, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xcdb2), seq 774:797, ack 28057, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.371971 +VCLOCK: {1: 35} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 35}} + 217 16:57:31.372084 IP (tos 0x0, ttl 64, id 43390, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xcc03), seq 797:820, ack 28057, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.372007 +VCLOCK: {1: 36} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 36}} + 218 16:57:31.372085 IP (tos 0x0, ttl 64, id 12089, offset 0, flags [DF], proto TCP (6), length 83) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe47 (incorrect -> 0xb82f), seq 608:639, ack 20739, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 31: IPROTO size=26 request: EVAL, SYNC: 22 +EXPR: return ... +TUPLE: [1, 2, [3, "x"]] +header: {1: 22, 0: 8} +body: {39: "return ...", 33: [1, 2, [3, "x"]]} + 219 16:57:31.372113 IP (tos 0x0, ttl 64, id 51496, offset 0, flags [DF], proto TCP (6), length 93) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe51 (incorrect -> 0xaa12), seq 20739:20780, ack 639, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 41: IPROTO size=36 response: OK, SYNC: 22, SCHEMA_VERSION: 80 +DATA: +1 +2 +[3, "x"] +header: {0: 0, 1: 22, 5: 80} +body: {48: [1, 2, [3, "x"]]} + 220 16:57:31.372121 IP (tos 0x0, ttl 64, id 12090, offset 0, flags [DF], proto TCP (6), length 98) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe56 (incorrect -> 0x218e), seq 639:685, ack 20780, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 46: IPROTO size=41 request: EVAL, SYNC: 23 +EXPR: function f1() return 5 + 5 end; +TUPLE: [] +header: {1: 23, 0: 8} +body: {39: "function f1() return 5 + 5 end;", 33: []} + 221 16:57:31.372127 IP (tos 0x0, ttl 64, id 57423, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [.], cksum 0xfe28 (incorrect -> 0x4dfd), seq 28057, ack 820, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 222 16:57:31.372139 IP (tos 0x0, ttl 64, id 51497, offset 0, flags [DF], proto TCP (6), length 87) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4b (incorrect -> 0x30f5), seq 20780:20815, ack 685, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 35: IPROTO size=30 response: OK, SYNC: 23, SCHEMA_VERSION: 80 +header: {0: 0, 1: 23, 5: 80} +body: {48: []} + 223 16:57:31.372155 IP (tos 0x0, ttl 64, id 12091, offset 0, flags [DF], proto TCP (6), length 69) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe39 (incorrect -> 0xc31b), seq 685:702, ack 20815, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 17: IPROTO size=12 request: CALL, SYNC: 24 +FUNCTION_NAME: f1 +TUPLE: [] +header: {1: 24, 0: 10} +body: {34: "f1", 33: []} + 224 16:57:31.372170 IP (tos 0x0, ttl 64, id 51498, offset 0, flags [DF], proto TCP (6), length 88) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4c (incorrect -> 0x2eb5), seq 20815:20851, ack 702, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 36: IPROTO size=31 response: OK, SYNC: 24, SCHEMA_VERSION: 80 +DATA: +10 +header: {0: 0, 1: 24, 5: 80} +body: {48: [10]} + 225 16:57:31.372180 IP (tos 0x0, ttl 64, id 12092, offset 0, flags [DF], proto TCP (6), length 102) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe5a (incorrect -> 0x54e6), seq 702:752, ack 20851, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 50: IPROTO size=45 request: EVAL, SYNC: 25 +EXPR: function f2(x, y) return x, y end; +TUPLE: [] +header: {1: 25, 0: 8} +body: {39: "function f2(x, y) return x, y end;", 33: []} + 226 16:57:31.372181 IP (tos 0x0, ttl 64, id 43391, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xcab3), seq 820:843, ack 28057, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 23: IPROTO size=18 response: OK, SYNC: 0, SCHEMA_VERSION: 0, TIMESTAMP: 2022-12-15 16:57:31.372020 +VCLOCK: {1: 37} +header: {0: 0, 4: 1.67112e+09} +body: {38: {1: 37}} + 227 16:57:31.372197 IP (tos 0x0, ttl 64, id 51499, offset 0, flags [DF], proto TCP (6), length 87) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4b (incorrect -> 0x3069), seq 20851:20886, ack 752, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 35: IPROTO size=30 response: OK, SYNC: 25, SCHEMA_VERSION: 80 +header: {0: 0, 1: 25, 5: 80} +body: {48: []} + 228 16:57:31.372204 IP (tos 0x0, ttl 64, id 12093, offset 0, flags [DF], proto TCP (6), length 72) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3c (incorrect -> 0x1b49), seq 752:772, ack 20886, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 20: IPROTO size=15 request: CALL, SYNC: 26 +FUNCTION_NAME: f2 +TUPLE: [1, "B"] +header: {1: 26, 0: 10} +body: {34: "f2", 33: [1, "B"]} + 229 16:57:31.372216 IP (tos 0x0, ttl 64, id 51500, offset 0, flags [DF], proto TCP (6), length 90) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe4e (incorrect -> 0x89ea), seq 20886:20924, ack 772, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 38: IPROTO size=33 response: OK, SYNC: 26, SCHEMA_VERSION: 80 +DATA: +1 +"B" +header: {0: 0, 1: 26, 5: 80} +body: {48: [1, "B"]} + 230 16:57:31.372224 IP (tos 0x0, ttl 64, id 12094, offset 0, flags [DF], proto TCP (6), length 79) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe43 (incorrect -> 0xb620), seq 772:799, ack 20924, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 27: IPROTO size=22 request: PREPARE, SYNC: 27 +SQL_TEXT: VALUES (?, ?); +header: {1: 27, 0: 13} +body: {64: "VALUES (?, ?);"} + 231 16:57:31.372270 IP (tos 0x0, ttl 64, id 51501, offset 0, flags [DF], proto TCP (6), length 151) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe8b (incorrect -> 0x555e), seq 20924:21023, ack 799, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 99: IPROTO size=94 response: OK, SYNC: 27, SCHEMA_VERSION: 80 +STMT_ID: 3618272283 +BIND_COUNT: 2 +BIND_METADATA: [{0: "?", 1: "ANY"}, {0: "?", 1: "ANY"}] +METADATA: [{0: "COLUMN_1", 1: "boolean"}, {0: "COLUMN_2", 1: "boolean"}] +header: {0: 0, 1: 27, 5: 80} +body: {67: 3618272283, 52: 2, 51: [{0: "?", 1: "ANY"}, {0: "?", 1: "ANY"}], 50: [{0: "COLUMN_1", 1: "boolean"}, {0: "COLUMN_2", 1: "boolean"}]} + 232 16:57:31.372281 IP (tos 0x0, ttl 64, id 12095, offset 0, flags [DF], proto TCP (6), length 76) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe40 (incorrect -> 0x29b4), seq 799:823, ack 21023, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 24: IPROTO size=19 request: EXECUTE, SYNC: 28 +STMT_ID: 3618272283 +SQL_BIND: [1, "a"] +OPTIONS: [] +header: {1: 28, 0: 11} +body: {67: 3618272283, 65: [1, "a"], 43: []} + 233 16:57:31.372297 IP (tos 0x0, ttl 64, id 51502, offset 0, flags [DF], proto TCP (6), length 126) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe72 (incorrect -> 0xcc59), seq 21023:21097, ack 823, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 74: IPROTO size=69 response: OK, SYNC: 28, SCHEMA_VERSION: 80 +METADATA: [{0: "COLUMN_1", 1: "integer"}, {0: "COLUMN_2", 1: "text"}] +DATA: +[1, "a"] +header: {0: 0, 1: 28, 5: 80} +body: {50: [{0: "COLUMN_1", 1: "integer"}, {0: "COLUMN_2", 1: "text"}], 48: [[1, "a"]]} + 234 16:57:31.372309 IP (tos 0x0, ttl 64, id 12096, offset 0, flags [DF], proto TCP (6), length 64) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe34 (incorrect -> 0xa21c), seq 823:835, ack 21097, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 12: IPROTO size=7 request: BEGIN, STREAM_ID: 1, SYNC: 29 +header: {1: 29, 0: 14, 10: 1} + 235 16:57:31.372324 IP (tos 0x0, ttl 64, id 51503, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe45 (incorrect -> 0x1353), seq 21097:21126, ack 835, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 29: IPROTO size=24 response: OK, SYNC: 29, SCHEMA_VERSION: 80 +header: {0: 0, 1: 29, 5: 80} +body: {} + 236 16:57:31.372331 IP (tos 0x0, ttl 64, id 12097, offset 0, flags [DF], proto TCP (6), length 64) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe34 (incorrect -> 0xa1f0), seq 835:847, ack 21126, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 12: IPROTO size=7 request: ROLLBACK, STREAM_ID: 1, SYNC: 30 +header: {1: 30, 0: 16, 10: 1} + 237 16:57:31.372343 IP (tos 0x0, ttl 64, id 51504, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe45 (incorrect -> 0x1329), seq 21126:21155, ack 847, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 29: IPROTO size=24 response: OK, SYNC: 30, SCHEMA_VERSION: 80 +header: {0: 0, 1: 30, 5: 80} +body: {} + 238 16:57:31.372350 IP (tos 0x0, ttl 64, id 12098, offset 0, flags [DF], proto TCP (6), length 64) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [P.], cksum 0xfe34 (incorrect -> 0xa1c7), seq 847:859, ack 21155, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 12: IPROTO size=7 request: COMMIT, STREAM_ID: 1, SYNC: 31 +header: {1: 31, 0: 15, 10: 1} + 239 16:57:31.372362 IP (tos 0x0, ttl 64, id 51505, offset 0, flags [DF], proto TCP (6), length 81) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [P.], cksum 0xfe45 (incorrect -> 0x12ff), seq 21155:21184, ack 859, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 29: IPROTO size=24 response: OK, SYNC: 31, SCHEMA_VERSION: 80 +header: {0: 0, 1: 31, 5: 80} +body: {} + 240 16:57:31.372419 IP (tos 0x0, ttl 64, id 12099, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [F.], cksum 0xfe28 (incorrect -> 0x8264), seq 859, ack 21184, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 241 16:57:31.372427 IP (tos 0x0, ttl 64, id 51506, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40076: Flags [F.], cksum 0xfe28 (incorrect -> 0x8263), seq 21184, ack 860, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 242 16:57:31.372435 IP (tos 0x0, ttl 64, id 12100, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40076 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x8263), seq 860, ack 21185, win 512, options [nop,nop,TS val 1977541261 ecr 1977541261], length 0 + 243 16:57:31.373225 IP (tos 0x0, ttl 64, id 43392, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [F.], cksum 0xfe28 (incorrect -> 0x4de4), seq 843, ack 28057, win 512, options [nop,nop,TS val 1977541262 ecr 1977541261], length 0 + 244 16:57:31.373454 IP (tos 0x0, ttl 64, id 57424, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40070: Flags [F.], cksum 0xfe28 (incorrect -> 0x4de3), seq 28057, ack 844, win 512, options [nop,nop,TS val 1977541262 ecr 1977541261], length 0 + 245 16:57:31.373458 IP (tos 0x0, ttl 64, id 43393, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40070 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x4de2), seq 844, ack 28058, win 512, options [nop,nop,TS val 1977541262 ecr 1977541262], length 0 + 246 16:57:32.818697 IP (tos 0x0, ttl 64, id 13000, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [S], cksum 0xfe30 (incorrect -> 0x0bd1), seq 725422438, win 65495, options [mss 65495,sackOK,TS val 1977542707 ecr 0,nop,wscale 7], length 0 + 247 16:57:32.818705 IP (tos 0x0, ttl 64, id 0, offset 0, flags [DF], proto TCP (6), length 60) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [S.], cksum 0xfe30 (incorrect -> 0x5516), seq 2701899671, ack 725422439, win 65483, options [mss 65495,sackOK,TS val 1977542707 ecr 1977542707,nop,wscale 7], length 0 + 248 16:57:32.818713 IP (tos 0x0, ttl 64, id 13001, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x7bd2), seq 1, ack 1, win 512, options [nop,nop,TS val 1977542707 ecr 1977542707], length 0 + 249 16:57:32.818891 IP (tos 0x0, ttl 64, id 7475, offset 0, flags [DF], proto TCP (6), length 180) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfea8 (incorrect -> 0x4eef), seq 1:129, ack 1, win 512, options [nop,nop,TS val 1977542708 ecr 1977542707], length 128: IPROTO: greeting: version: Tarantool 2.10.4 (Binary), uuid: 056cb614-461f-4cc2-a26b-8a50f5286086, salt: 5ndApMi9Bm1zp5fR42X/WpfXcUBCabHQX+Na6hRot+0= + 250 16:57:32.818896 IP (tos 0x0, ttl 64, id 13002, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x7b51), seq 1, ack 129, win 511, options [nop,nop,TS val 1977542708 ecr 1977542708], length 0 + 251 16:57:32.818950 IP (tos 0x0, ttl 64, id 13003, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0x7fbc), seq 1:20, ack 129, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 19: IPROTO size=14 request: ID, SYNC: 1 +VERSION: 3 +FEATURES: [0, 1, 2, 3] +header: {1: 1, 0: 73} +body: {84: 3, 85: [0, 1, 2, 3]} + 252 16:57:32.818955 IP (tos 0x0, ttl 64, id 7476, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [.], cksum 0xfe28 (incorrect -> 0x7b3d), seq 129, ack 20, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 0 + 253 16:57:32.819084 IP (tos 0x0, ttl 64, id 7477, offset 0, flags [DF], proto TCP (6), length 89) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe4d (incorrect -> 0x6626), seq 129:166, ack 20, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 37: IPROTO size=32 response: OK, SYNC: 1, SCHEMA_VERSION: 78 +VERSION: 3 +FEATURES: [0, 1, 2, 3] +header: {0: 0, 1: 1, 5: 78} +body: {84: 3, 85: [0, 1, 2, 3]} + 254 16:57:32.819150 IP (tos 0x0, ttl 64, id 13004, offset 0, flags [DF], proto TCP (6), length 121) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe6d (incorrect -> 0x6081), seq 20:89, ack 166, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 69: IPROTO size=18 request: SELECT, SYNC: 2 +SPACE: _vspace (ID: 281) +LIMIT: 4294967295 +KEY: [] +header: {1: 2, 0: 1} +body: {16: 281, 18: 4294967295, 32: []} + 255 16:57:32.819319 IP (tos 0x0, ttl 64, id 7478, offset 0, flags [DF], proto TCP (6), length 19745) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0x4b16 (incorrect -> 0x1dce), seq 166:19859, ack 89, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 19693: IPROTO size=4608 response: OK, SYNC: 2, SCHEMA_VERSION: 78 +DATA: +[257, 1, "_vinyl_deferred_delete", "blackhole", 0, {"group_id": 1}, [{"name": "space_id", "type": "unsigned"}, {"name": "lsn", "type": "unsigned"}, {"name": "tuple", "type": "array"}]] +[272, 1, "_schema", "memtx", 0, {}, [{"type": "string", "name": "key"}, {"type": "any", "name": "value", "is_nullable": true}]] +[276, 1, "_collation", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "owner", "type": "unsigned"}, {"name": "type", "type": "string"}, {"name": "locale", "type": "string"}, {"name": "opts", "type": "map"}]] +[277, 1, "_vcollation", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "owner", "type": "unsigned"}, {"name": "type", "type": "string"}, {"name": "locale", "type": "string"}, {"name": "opts", "type": "map"}]] +[280, 1, "_space", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "engine", "type": "string"}, {"name": "field_count", "type": "unsigned"}, {"name": "flags", "type": "map"}, {"name": "format", "type": "array"}]] +[281, 1, "_vspace", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "engine", "type": "string"}, {"name": "field_count", "type": "unsigned"}, {"name": "flags", "type": "map"}, {"name": "format", "type": "array"}]] +[284, 1, "_sequence", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "step", "type": "integer"}, {"name": "min", "type": "integer"}, {"name": "max", "type": "integer"}, {"name": "start", "type": "integer"}, {"name": "cache", "type": "integer"}, {"name": "cycle", "type": "boolean"}]] +[285, 1, "_sequence_data", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "value", "type": "integer"}]] +[286, 1, "_vsequence", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "step", "type": "integer"}, {"name": "min", "type": "integer"}, {"name": "max", "type": "integer"}, {"name": "start", "type": "integer"}, {"name": "cache", "type": "integer"}, {"name": "cycle", "type": "boolean"}]] +[288, 1, "_index", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "iid", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "opts", "type": "map"}, {"name": "parts", "type": "array"}]] +[289, 1, "_vindex", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "iid", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "opts", "type": "map"}, {"name": "parts", "type": "array"}]] +[296, 1, "_func", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "setuid", "type": "unsigned"}, {"name": "language", "type": "string"}, {"name": "body", "type": "string"}, {"name": "routine_type", "type": "string"}, {"name": "param_list", "type": "array"}, {"name": "returns", "type": "string"}, {"name": "aggregate", "type": "string"}, {"name": "sql_data_access", "type": "string"}, {"name": "is_deterministic", "type": "boolean"}, {"name": "is_sandboxed", "type": "boolean"}, {"name": "is_null_call", "type": "boolean"}, {"name": "exports", "type": "array"}, {"name": "opts", "type": "map"}, {"name": "comment", "type": "string"}, {"name": "created", "type": "string"}, {"name": "last_altered", "type": "string"}]] +[297, 1, "_vfunc", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "setuid", "type": "unsigned"}, {"name": "language", "type": "string"}, {"name": "body", "type": "string"}, {"name": "routine_type", "type": "string"}, {"name": "param_list", "type": "array"}, {"name": "returns", "type": "string"}, {"name": "aggregate", "type": "string"}, {"name": "sql_data_access", "type": "string"}, {"name": "is_deterministic", "type": "boolean"}, {"name": "is_sandboxed", "type": "boolean"}, {"name": "is_null_call", "type": "boolean"}, {"name": "exports", "type": "array"}, {"name": "opts", "type": "map"}, {"name": "comment", "type": "string"}, {"name": "created", "type": "string"}, {"name": "last_altered", "type": "string"}]] +[304, 1, "_user", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "auth", "type": "map"}]] +[305, 1, "_vuser", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "auth", "type": "map"}]] +[312, 1, "_priv", "memtx", 0, {}, [{"name": "grantor", "type": "unsigned"}, {"name": "grantee", "type": "unsigned"}, {"name": "object_type", "type": "string"}, {"name": "object_id", "type": "scalar"}, {"name": "privilege", "type": "unsigned"}]] +[313, 1, "_vpriv", "sysview", 0, {}, [{"name": "grantor", "type": "unsigned"}, {"name": "grantee", "type": "unsigned"}, {"name": "object_type", "type": "string"}, {"name": "object_id", "type": "scalar"}, {"name": "privilege", "type": "unsigned"}]] +[320, 1, "_cluster", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "uuid", "type": "string"}]] +[328, 1, "_trigger", "memtx", 0, {}, [{"name": "name", "type": "string"}, {"name": "space_id", "type": "unsigned"}, {"name": "opts", "type": "map"}]] +[330, 1, "_truncate", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "count", "type": "unsigned"}]] +[340, 1, "_space_sequence", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "sequence_id", "type": "unsigned"}, {"name": "is_generated", "type": "boolean"}, {"name": "field", "type": "unsigned"}, {"name": "path", "type": "string"}]] +[356, 1, "_fk_constraint", "memtx", 0, {}, [{"name": "name", "type": "string"}, {"name": "child_id", "type": "unsigned"}, {"name": "parent_id", "type": "unsigned"}, {"name": "is_deferred", "type": "boolean"}, {"name": "match", "type": "string"}, {"name": "on_delete", "type": "string"}, {"name": "on_update", "type": "string"}, {"name": "child_cols", "type": "array"}, {"name": "parent_cols", "type": "array"}]] +[364, 1, "_ck_constraint", "memtx", 0, {}, [{"name": "space_id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "is_deferred", "type": "boolean"}, {"name": "language", "type": "str"}, {"name": "code", "type": "str"}, {"name": "is_enabled", "type": "boolean"}]] +[372, 1, "_func_index", "memtx", 0, {}, [{"name": "space_id", "type": "unsigned"}, {"name": "index_id", "type": "unsigned"}, {"name": "func_id", "type": "unsigned"}]] +[380, 1, "_session_settings", "service", 2, {"temporary": true}, [{"name": "name", "type": "string"}, {"name": "value", "type": "any"}]] +header: {0: 0, 1: 2, 5: 78} +body: {48: [[257, 1, "_vinyl_deferred_delete", "blackhole", 0, {"group_id": 1}, [{"name": "space_id", "type": "unsigned"}, {"name": "lsn", "type": "unsigned"}, {"name": "tuple", "type": "array"}]], [272, 1, "_schema", "memtx", 0, {}, [{"type": "string", "name": "key"}, {"type": "any", "name": "value", "is_nullable": true}]], [276, 1, "_collation", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "owner", "type": "unsigned"}, {"name": "type", "type": "string"}, {"name": "locale", "type": "string"}, {"name": "opts", "type": "map"}]], [277, 1, "_vcollation", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "owner", "type": "unsigned"}, {"name": "type", "type": "string"}, {"name": "locale", "type": "string"}, {"name": "opts", "type": "map"}]], [280, 1, "_space", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "engine", "type": "string"}, {"name": "field_count", "type": "unsigned"}, {"name": "flags", "type": "map"}, {"name": "format", "type": "array"}]], [281, 1, "_vspace", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "engine", "type": "string"}, {"name": "field_count", "type": "unsigned"}, {"name": "flags", "type": "map"}, {"name": "format", "type": "array"}]], [284, 1, "_sequence", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "step", "type": "integer"}, {"name": "min", "type": "integer"}, {"name": "max", "type": "integer"}, {"name": "start", "type": "integer"}, {"name": "cache", "type": "integer"}, {"name": "cycle", "type": "boolean"}]], [285, 1, "_sequence_data", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "value", "type": "integer"}]], [286, 1, "_vsequence", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "step", "type": "integer"}, {"name": "min", "type": "integer"}, {"name": "max", "type": "integer"}, {"name": "start", "type": "integer"}, {"name": "cache", "type": "integer"}, {"name": "cycle", "type": "boolean"}]], [288, 1, "_index", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "iid", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "opts", "type": "map"}, {"name": "parts", "type": "array"}]], [289, 1, "_vindex", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "iid", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "opts", "type": "map"}, {"name": "parts", "type": "array"}]], [296, 1, "_func", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "setuid", "type": "unsigned"}, {"name": "language", "type": "string"}, {"name": "body", "type": "string"}, {"name": "routine_type", "type": "string"}, {"name": "param_list", "type": "array"}, {"name": "returns", "type": "string"}, {"name": "aggregate", "type": "string"}, {"name": "sql_data_access", "type": "string"}, {"name": "is_deterministic", "type": "boolean"}, {"name": "is_sandboxed", "type": "boolean"}, {"name": "is_null_call", "type": "boolean"}, {"name": "exports", "type": "array"}, {"name": "opts", "type": "map"}, {"name": "comment", "type": "string"}, {"name": "created", "type": "string"}, {"name": "last_altered", "type": "string"}]], [297, 1, "_vfunc", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "setuid", "type": "unsigned"}, {"name": "language", "type": "string"}, {"name": "body", "type": "string"}, {"name": "routine_type", "type": "string"}, {"name": "param_list", "type": "array"}, {"name": "returns", "type": "string"}, {"name": "aggregate", "type": "string"}, {"name": "sql_data_access", "type": "string"}, {"name": "is_deterministic", "type": "boolean"}, {"name": "is_sandboxed", "type": "boolean"}, {"name": "is_null_call", "type": "boolean"}, {"name": "exports", "type": "array"}, {"name": "opts", "type": "map"}, {"name": "comment", "type": "string"}, {"name": "created", "type": "string"}, {"name": "last_altered", "type": "string"}]], [304, 1, "_user", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "auth", "type": "map"}]], [305, 1, "_vuser", "sysview", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "owner", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "type", "type": "string"}, {"name": "auth", "type": "map"}]], [312, 1, "_priv", "memtx", 0, {}, [{"name": "grantor", "type": "unsigned"}, {"name": "grantee", "type": "unsigned"}, {"name": "object_type", "type": "string"}, {"name": "object_id", "type": "scalar"}, {"name": "privilege", "type": "unsigned"}]], [313, 1, "_vpriv", "sysview", 0, {}, [{"name": "grantor", "type": "unsigned"}, {"name": "grantee", "type": "unsigned"}, {"name": "object_type", "type": "string"}, {"name": "object_id", "type": "scalar"}, {"name": "privilege", "type": "unsigned"}]], [320, 1, "_cluster", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "uuid", "type": "string"}]], [328, 1, "_trigger", "memtx", 0, {}, [{"name": "name", "type": "string"}, {"name": "space_id", "type": "unsigned"}, {"name": "opts", "type": "map"}]], [330, 1, "_truncate", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "count", "type": "unsigned"}]], [340, 1, "_space_sequence", "memtx", 0, {}, [{"name": "id", "type": "unsigned"}, {"name": "sequence_id", "type": "unsigned"}, {"name": "is_generated", "type": "boolean"}, {"name": "field", "type": "unsigned"}, {"name": "path", "type": "string"}]], [356, 1, "_fk_constraint", "memtx", 0, {}, [{"name": "name", "type": "string"}, {"name": "child_id", "type": "unsigned"}, {"name": "parent_id", "type": "unsigned"}, {"name": "is_deferred", "type": "boolean"}, {"name": "match", "type": "string"}, {"name": "on_delete", "type": "string"}, {"name": "on_update", "type": "string"}, {"name": "child_cols", "type": "array"}, {"name": "parent_cols", "type": "array"}]], [364, 1, "_ck_constraint", "memtx", 0, {}, [{"name": "space_id", "type": "unsigned"}, {"name": "name", "type": "string"}, {"name": "is_deferred", "type": "boolean"}, {"name": "language", "type": "str"}, {"name": "code", "type": "str"}, {"name": "is_enabled", "type": "boolean"}]], [372, 1, "_func_index", "memtx", 0, {}, [{"name": "space_id", "type": "unsigned"}, {"name": "index_id", "type": "unsigned"}, {"name": "func_id", "type": "unsigned"}]], [380, 1, "_session_settings", "service", 2, {"temporary": true}, [{"name": "name", "type": "string"}, {"name": "value", "type": "any"}]]]} + 256 16:57:32.819674 IP (tos 0x0, ttl 64, id 13005, offset 0, flags [DF], proto TCP (6), length 75) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3f (incorrect -> 0xc703), seq 89:112, ack 19859, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 23: IPROTO size=18 +header: {0: 74} +body: {87: "box.shutdown"} + 257 16:57:32.819692 IP (tos 0x0, ttl 64, id 13006, offset 0, flags [DF], proto TCP (6), length 122) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe6e (incorrect -> 0x0a20), seq 112:182, ack 19859, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 70: IPROTO size=65 request: EVAL, SYNC: 5 +EXPR: return box.error.new(box.error.ILLEGAL_PARAMS, "test") +TUPLE: [] +header: {1: 5, 0: 8} +body: {39: "return box.error.new(box.error.ILLEGAL_PARAMS, \"test\")", 33: []} + 258 16:57:32.819734 IP (tos 0x0, ttl 64, id 7479, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [.], cksum 0xfe28 (incorrect -> 0x2d89), seq 19859, ack 182, win 512, options [nop,nop,TS val 1977542708 ecr 1977542708], length 0 + 259 16:57:32.819884 IP (tos 0x0, ttl 64, id 7480, offset 0, flags [DF], proto TCP (6), length 135) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe7b (incorrect -> 0x83ed), seq 19859:19942, ack 182, win 512, options [nop,nop,TS val 1977542709 ecr 1977542708], length 83: IPROTO size=55 response: OK, SYNC: 5, SCHEMA_VERSION: 78 +DATA: +"Illegal parameters, test" +header: {0: 0, 1: 5, 5: 78} +body: {48: ["Illegal parameters, test"]} + 260 16:57:32.819963 IP (tos 0x0, ttl 64, id 13007, offset 0, flags [DF], proto TCP (6), length 122) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe6e (incorrect -> 0x4b79), seq 182:252, ack 19942, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 70: IPROTO size=42 request: CALL, SYNC: 6 +FUNCTION_NAME: error_new +TUPLE: [{"code": 1000, "reason": "Reason"}] +header: {1: 6, 0: 10} +body: {34: "error_new", 33: [{"code": 1000, "reason": "Reason"}]} + 261 16:57:32.820143 IP (tos 0x0, ttl 64, id 7481, offset 0, flags [DF], proto TCP (6), length 132) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe78 (incorrect -> 0x3e9e), seq 19942:20022, ack 252, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 80: IPROTO size=75 response: OK, SYNC: 6, SCHEMA_VERSION: 78 +DATA: +EXTENSION: type ERROR [3], len 42 +TYPE: ClientError +LINE: 4294967295 +FILE: [C] +MESSAGE: Reason +ERRNO: 0 +CODE: 1000 +header: {0: 0, 1: 6, 5: 78} +body: {48: [(ERROR: [{ "type": "ClientError", "line": 4294967295, "file": "[C]", "message": "Reason", "errno": 0, "code": 1000 }])]} + 262 16:57:32.820243 IP (tos 0x0, ttl 64, id 13008, offset 0, flags [DF], proto TCP (6), length 101) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe59 (incorrect -> 0x97e5), seq 252:301, ack 20022, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 49: IPROTO size=44 request: CALL, SYNC: 7 +FUNCTION_NAME: error_throw +TUPLE: [{"code": 1000, "reason": "Reason"}] +header: {1: 7, 0: 10} +body: {34: "error_throw", 33: [{"code": 1000, "reason": "Reason"}]} + 263 16:57:32.820381 IP (tos 0x0, ttl 64, id 7482, offset 0, flags [DF], proto TCP (6), length 148) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe88 (incorrect -> 0x1b6c), seq 20022:20118, ack 301, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 96: IPROTO size=91 response: ERR: unknown, SYNC: 7, SCHEMA_VERSION: 78 +TYPE: ClientError +LINE: 42 +FILE: extended_error.test.lua +MESSAGE: Reason +ERRNO: 0 +CODE: 1000 +header: {0: 33768, 1: 7, 5: 78} +body: {49: "Reason", 82: {0: [{0: "ClientError", 2: 42, 1: "extended_error.test.lua", 3: "Reason", 4: 0, 5: 1000}]}} + 264 16:57:32.820466 IP (tos 0x0, ttl 64, id 13009, offset 0, flags [DF], proto TCP (6), length 113) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe65 (incorrect -> 0x03a4), seq 301:362, ack 20118, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 61: IPROTO size=56 request: CALL, SYNC: 8 +FUNCTION_NAME: error_new +TUPLE: [{"type": "MyError", "reason": "Reason2", "code": 1001}] +header: {1: 8, 0: 10} +body: {34: "error_new", 33: [{"type": "MyError", "reason": "Reason2", "code": 1001}]} + 265 16:57:32.820575 IP (tos 0x0, ttl 64, id 7483, offset 0, flags [DF], proto TCP (6), length 155) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe8f (incorrect -> 0xac0a), seq 20118:20221, ack 362, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 103: IPROTO size=98 response: OK, SYNC: 8, SCHEMA_VERSION: 78 +DATA: +EXTENSION: type ERROR [3], len 65 +TYPE: CustomError +LINE: 4294967295 +FILE: [C] +MESSAGE: Reason2 +ERRNO: 0 +CODE: 1001 +FIELDS: custom_type: MyError +header: {0: 0, 1: 8, 5: 78} +body: {48: [(ERROR: [{ "type": "CustomError", "line": 4294967295, "file": "[C]", "message": "Reason2", "errno": 0, "code": 1001 }, "fields": { "custom_type": MyError }])]} + 266 16:57:32.820661 IP (tos 0x0, ttl 64, id 13010, offset 0, flags [DF], proto TCP (6), length 115) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe67 (incorrect -> 0x8c84), seq 362:425, ack 20221, win 512, options [nop,nop,TS val 1977542709 ecr 1977542709], length 63: IPROTO size=58 request: CALL, SYNC: 9 +FUNCTION_NAME: error_throw +TUPLE: [{"type": "MyError", "reason": "Reason2", "code": 1001}] +header: {1: 9, 0: 10} +body: {34: "error_throw", 33: [{"type": "MyError", "reason": "Reason2", "code": 1001}]} + 267 16:57:32.820841 IP (tos 0x0, ttl 64, id 7484, offset 0, flags [DF], proto TCP (6), length 172) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfea0 (incorrect -> 0x78a3), seq 20221:20341, ack 425, win 512, options [nop,nop,TS val 1977542710 ecr 1977542709], length 120: IPROTO size=115 response: ERR: unknown, SYNC: 9, SCHEMA_VERSION: 78 +TYPE: CustomError +LINE: 42 +FILE: extended_error.test.lua +MESSAGE: Reason2 +ERRNO: 0 +CODE: 1001 +FIELDS: custom_type: MyError +header: {0: 33769, 1: 9, 5: 78} +body: {49: "Reason2", 82: {0: [{0: "CustomError", 2: 42, 1: "extended_error.test.lua", 3: "Reason2", 4: 0, 5: 1001, 6: {"custom_type": "MyError"}}]}} + 268 16:57:32.820928 IP (tos 0x0, ttl 64, id 13011, offset 0, flags [DF], proto TCP (6), length 86) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe4a (incorrect -> 0x3127), seq 425:459, ack 20341, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 34: IPROTO size=29 request: CALL, SYNC: 10 +FUNCTION_NAME: error_access_denied +TUPLE: [] +header: {1: 10, 0: 10} +body: {34: "error_access_denied", 33: []} + 269 16:57:32.821055 IP (tos 0x0, ttl 64, id 7485, offset 0, flags [DF], proto TCP (6), length 290) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xff16 (incorrect -> 0xa534), seq 20341:20579, ack 459, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 238: IPROTO size=233 response: OK, SYNC: 10, SCHEMA_VERSION: 78 +DATA: +EXTENSION: type ERROR [3], len 200 +TYPE: AccessDeniedError +LINE: 533 +FILE: ./src/box/func.c +MESSAGE: Execute access to function 'forbidden_function' is denied for user 'guest' +ERRNO: 0 +CODE: 42 +FIELDS: object_type: function, object_name: forbidden_function, access_type: Execute +header: {0: 0, 1: 10, 5: 78} +body: {48: [(ERROR: [{ "type": "AccessDeniedError", "line": 533, "file": "./src/box/func.c", "message": "Execute access to function 'forbidden_function' is denied for user 'guest'", "errno": 0, "code": 42 }, "fields": { "object_type": function, "object_name": forbidden_function, "access_type": Execute }])]} + 270 16:57:32.821152 IP (tos 0x0, ttl 64, id 13012, offset 0, flags [DF], proto TCP (6), length 92) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe50 (incorrect -> 0xecb1), seq 459:499, ack 20579, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 40: IPROTO size=35 request: CALL, SYNC: 11 +FUNCTION_NAME: error_throw_access_denied +TUPLE: [] +header: {1: 11, 0: 10} +body: {34: "error_throw_access_denied", 33: []} + 271 16:57:32.821176 IP (tos 0x0, ttl 64, id 7486, offset 0, flags [DF], proto TCP (6), length 359) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xff5b (incorrect -> 0xe952), seq 20579:20886, ack 499, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 307: IPROTO size=302 response: ERR: ER_ACCESS_DENIED, SYNC: 11, SCHEMA_VERSION: 78 +TYPE: AccessDeniedError +LINE: 533 +FILE: ./src/box/func.c +MESSAGE: Execute access to function 'forbidden_function' is denied for user 'guest' +ERRNO: 0 +CODE: 42 +FIELDS: object_type: function, object_name: forbidden_function, access_type: Execute +header: {0: 32810, 1: 11, 5: 78} +body: {49: "Execute access to function 'forbidden_function' is denied for user 'guest'", 82: {0: [{0: "AccessDeniedError", 2: 533, 1: ".\/src\/box\/func.c", 3: "Execute access to function 'forbidden_function' is denied for user 'guest'", 4: 0, 5: 42, 6: {"object_type": "function", "object_name": "forbidden_function", "access_type": "Execute"}}]}} + 272 16:57:32.821203 IP (tos 0x0, ttl 64, id 13013, offset 0, flags [DF], proto TCP (6), length 146) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe86 (incorrect -> 0xe338), seq 499:593, ack 20886, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 94: IPROTO size=89 request: CALL, SYNC: 12 +FUNCTION_NAME: error_new_stacked +TUPLE: [{"type": "MyError2", "reason": "Reason3", "code": 1003}, {"code": 1004, "reason": "Reason4"}] +header: {1: 12, 0: 10} +body: {34: "error_new_stacked", 33: [{"type": "MyError2", "reason": "Reason3", "code": 1003}, {"code": 1004, "reason": "Reason4"}]} + 273 16:57:32.821225 IP (tos 0x0, ttl 64, id 7487, offset 0, flags [DF], proto TCP (6), length 228) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfed8 (incorrect -> 0x46d8), seq 20886:21062, ack 593, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 176: IPROTO size=171 response: OK, SYNC: 12, SCHEMA_VERSION: 78 +DATA: +EXTENSION: type ERROR [3], len 138 +TYPE: CustomError +LINE: 46 +FILE: extended_error.test.lua +MESSAGE: Reason3 +ERRNO: 0 +CODE: 1003 +FIELDS: custom_type: MyError2 +--- +TYPE: ClientError +LINE: 47 +FILE: extended_error.test.lua +MESSAGE: Reason4 +ERRNO: 0 +CODE: 1004 +header: {0: 0, 1: 12, 5: 78} +body: {48: [(ERROR: [{ "type": "CustomError", "line": 46, "file": "extended_error.test.lua", "message": "Reason3", "errno": 0, "code": 1003 }, "fields": { "custom_type": MyError2 }][{ "type": "ClientError", "line": 47, "file": "extended_error.test.lua", "message": "Reason4", "errno": 0, "code": 1004 }])]} + 274 16:57:32.821253 IP (tos 0x0, ttl 64, id 13014, offset 0, flags [DF], proto TCP (6), length 148) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe88 (incorrect -> 0x6baf), seq 593:689, ack 21062, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 96: IPROTO size=91 request: CALL, SYNC: 13 +FUNCTION_NAME: error_throw_stacked +TUPLE: [{"type": "MyError2", "reason": "Reason3", "code": 1003}, {"code": 1004, "reason": "Reason4"}] +header: {1: 13, 0: 10} +body: {34: "error_throw_stacked", 33: [{"type": "MyError2", "reason": "Reason3", "code": 1003}, {"code": 1004, "reason": "Reason4"}]} + 275 16:57:32.821272 IP (tos 0x0, ttl 64, id 7488, offset 0, flags [DF], proto TCP (6), length 229) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfed9 (incorrect -> 0x4aeb), seq 21062:21239, ack 689, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 177: IPROTO size=172 response: ERR: unknown, SYNC: 13, SCHEMA_VERSION: 78 +TYPE: CustomError +LINE: 46 +FILE: extended_error.test.lua +MESSAGE: Reason3 +ERRNO: 0 +CODE: 1003 +FIELDS: custom_type: MyError2 +--- +TYPE: ClientError +LINE: 47 +FILE: extended_error.test.lua +MESSAGE: Reason4 +ERRNO: 0 +CODE: 1004 +header: {0: 33771, 1: 13, 5: 78} +body: {49: "Reason3", 82: {0: [{0: "CustomError", 2: 46, 1: "extended_error.test.lua", 3: "Reason3", 4: 0, 5: 1003, 6: {"custom_type": "MyError2"}}, {0: "ClientError", 2: 47, 1: "extended_error.test.lua", 3: "Reason4", 4: 0, 5: 1004}]}} + 276 16:57:32.821298 IP (tos 0x0, ttl 64, id 13015, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xb95a), seq 689:708, ack 21239, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 14 +FUNCTION_NAME: func +TUPLE: [] +header: {1: 14, 0: 6} +body: {34: "func", 33: []} + 277 16:57:32.821311 IP (tos 0x0, ttl 64, id 7489, offset 0, flags [DF], proto TCP (6), length 155) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe8f (incorrect -> 0xa75d), seq 21239:21342, ack 708, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 103: IPROTO size=98 response: OK, SYNC: 14, SCHEMA_VERSION: 78 +DATA: +[(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])] +header: {0: 0, 1: 14, 5: 78} +body: {48: [[(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])]]} + 278 16:57:32.821335 IP (tos 0x0, ttl 64, id 13016, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xb8df), seq 708:727, ack 21342, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 15 +FUNCTION_NAME: func +TUPLE: [] +header: {1: 15, 0: 6} +body: {34: "func", 33: []} + 279 16:57:32.821347 IP (tos 0x0, ttl 64, id 7490, offset 0, flags [DF], proto TCP (6), length 157) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe91 (incorrect -> 0xa24f), seq 21342:21447, ack 727, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 105: IPROTO size=100 response: OK, SYNC: 15, SCHEMA_VERSION: 78 +DATA: +[1] +[(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])] +header: {0: 0, 1: 15, 5: 78} +body: {48: [[1], [(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])]]} + 280 16:57:32.821365 IP (tos 0x0, ttl 64, id 13017, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xb862), seq 727:746, ack 21447, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 16 +FUNCTION_NAME: func +TUPLE: [] +header: {1: 16, 0: 6} +body: {34: "func", 33: []} + 281 16:57:32.821377 IP (tos 0x0, ttl 64, id 7491, offset 0, flags [DF], proto TCP (6), length 157) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe91 (incorrect -> 0xa1d2), seq 21447:21552, ack 746, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 105: IPROTO size=100 response: OK, SYNC: 16, SCHEMA_VERSION: 78 +DATA: +[1] +[(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])] +header: {0: 0, 1: 16, 5: 78} +body: {48: [[1], [(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])]]} + 282 16:57:32.821392 IP (tos 0x0, ttl 64, id 13018, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xb7e5), seq 746:765, ack 21552, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 17 +FUNCTION_NAME: func +TUPLE: [] +header: {1: 17, 0: 6} +body: {34: "func", 33: []} + 283 16:57:32.821404 IP (tos 0x0, ttl 64, id 7492, offset 0, flags [DF], proto TCP (6), length 155) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe8f (incorrect -> 0xa5e8), seq 21552:21655, ack 765, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 103: IPROTO size=98 response: OK, SYNC: 17, SCHEMA_VERSION: 78 +DATA: +[(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])] +header: {0: 0, 1: 17, 5: 78} +body: {48: [[(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])]]} + 284 16:57:32.821418 IP (tos 0x0, ttl 64, id 13019, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xb76a), seq 765:784, ack 21655, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 18 +FUNCTION_NAME: func +TUPLE: [] +header: {1: 18, 0: 6} +body: {34: "func", 33: []} + 285 16:57:32.821431 IP (tos 0x0, ttl 64, id 7493, offset 0, flags [DF], proto TCP (6), length 156) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe90 (incorrect -> 0x4fbf), seq 21655:21759, ack 784, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 104: IPROTO size=99 response: OK, SYNC: 18, SCHEMA_VERSION: 78 +DATA: +[1, (ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])] +header: {0: 0, 1: 18, 5: 78} +body: {48: [[1, (ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])]]} + 286 16:57:32.821444 IP (tos 0x0, ttl 64, id 13020, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xb6ee), seq 784:803, ack 21759, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 19 +FUNCTION_NAME: func +TUPLE: [] +header: {1: 19, 0: 6} +body: {34: "func", 33: []} + 287 16:57:32.821457 IP (tos 0x0, ttl 64, id 7494, offset 0, flags [DF], proto TCP (6), length 157) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe91 (incorrect -> 0xa05e), seq 21759:21864, ack 803, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 105: IPROTO size=100 response: OK, SYNC: 19, SCHEMA_VERSION: 78 +DATA: +[1] +[(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])] +header: {0: 0, 1: 19, 5: 78} +body: {48: [[1], [(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])]]} + 288 16:57:32.821473 IP (tos 0x0, ttl 64, id 13021, offset 0, flags [DF], proto TCP (6), length 71) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [P.], cksum 0xfe3b (incorrect -> 0xb671), seq 803:822, ack 21864, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 19: IPROTO size=14 request: CALL_16, SYNC: 20 +FUNCTION_NAME: func +TUPLE: [] +header: {1: 20, 0: 6} +body: {34: "func", 33: []} + 289 16:57:32.821487 IP (tos 0x0, ttl 64, id 7495, offset 0, flags [DF], proto TCP (6), length 157) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [P.], cksum 0xfe91 (incorrect -> 0x9fe1), seq 21864:21969, ack 822, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 105: IPROTO size=100 response: OK, SYNC: 20, SCHEMA_VERSION: 78 +DATA: +[1] +[(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])] +header: {0: 0, 1: 20, 5: 78} +body: {48: [[1], [(ERROR: [{ "type": "ClientError", "line": 158, "file": "extended_error.test.lua", "message": "Unknown error", "errno": 0, "code": 0 }])]]} + 290 16:57:32.821577 IP (tos 0x0, ttl 64, id 13022, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [F.], cksum 0xfe28 (incorrect -> 0x22c6), seq 822, ack 21969, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 0 + 291 16:57:32.821584 IP (tos 0x0, ttl 64, id 7496, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.3309 > 127.0.0.1.40078: Flags [F.], cksum 0xfe28 (incorrect -> 0x22c5), seq 21969, ack 823, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 0 + 292 16:57:32.821591 IP (tos 0x0, ttl 64, id 13023, offset 0, flags [DF], proto TCP (6), length 52) + 127.0.0.1.40078 > 127.0.0.1.3309: Flags [.], cksum 0xfe28 (incorrect -> 0x22c5), seq 823, ack 21970, win 512, options [nop,nop,TS val 1977542710 ecr 1977542710], length 0