THRIFT-1313 implement compact protocol for c_glib library
Client: C_glib
Chandler May <cjmay4754@gmail.com>
This closes #795
diff --git a/.gitignore b/.gitignore
index 922ac4d..632bd80 100644
--- a/.gitignore
+++ b/.gitignore
@@ -127,6 +127,7 @@
/lib/c_glib/test/testwrapper-test*
/lib/c_glib/test/testapplicationexception
/lib/c_glib/test/testbinaryprotocol
+/lib/c_glib/test/testcompactprotocol
/lib/c_glib/test/testbufferedtransport
/lib/c_glib/test/testcontainertest
/lib/c_glib/test/testdebugproto
diff --git a/lib/c_glib/CMakeLists.txt b/lib/c_glib/CMakeLists.txt
index 2c0ce76..b409fbe 100644
--- a/lib/c_glib/CMakeLists.txt
+++ b/lib/c_glib/CMakeLists.txt
@@ -37,6 +37,8 @@
src/thrift/c_glib/protocol/thrift_protocol_factory.c
src/thrift/c_glib/protocol/thrift_binary_protocol.c
src/thrift/c_glib/protocol/thrift_binary_protocol_factory.c
+ src/thrift/c_glib/protocol/thrift_compact_protocol.c
+ src/thrift/c_glib/protocol/thrift_compact_protocol_factory.c
src/thrift/c_glib/transport/thrift_transport.c
src/thrift/c_glib/transport/thrift_transport_factory.c
src/thrift/c_glib/transport/thrift_buffered_transport_factory.c
diff --git a/lib/c_glib/Makefile.am b/lib/c_glib/Makefile.am
index 153d14b..71cb283 100755
--- a/lib/c_glib/Makefile.am
+++ b/lib/c_glib/Makefile.am
@@ -38,6 +38,8 @@
src/thrift/c_glib/protocol/thrift_protocol_factory.c \
src/thrift/c_glib/protocol/thrift_binary_protocol.c \
src/thrift/c_glib/protocol/thrift_binary_protocol_factory.c \
+ src/thrift/c_glib/protocol/thrift_compact_protocol.c \
+ src/thrift/c_glib/protocol/thrift_compact_protocol_factory.c \
src/thrift/c_glib/transport/thrift_transport.c \
src/thrift/c_glib/transport/thrift_transport_factory.c \
src/thrift/c_glib/transport/thrift_buffered_transport_factory.c \
@@ -64,7 +66,9 @@
include_protocol_HEADERS = src/thrift/c_glib/protocol/thrift_protocol.h \
src/thrift/c_glib/protocol/thrift_protocol_factory.h \
src/thrift/c_glib/protocol/thrift_binary_protocol.h \
- src/thrift/c_glib/protocol/thrift_binary_protocol_factory.h
+ src/thrift/c_glib/protocol/thrift_binary_protocol_factory.h \
+ src/thrift/c_glib/protocol/thrift_compact_protocol.h \
+ src/thrift/c_glib/protocol/thrift_compact_protocol_factory.h
include_transportdir = $(include_thriftdir)/transport
include_transport_HEADERS = src/thrift/c_glib/transport/thrift_buffered_transport.h \
diff --git a/lib/c_glib/src/thrift/c_glib/protocol/thrift_compact_protocol.c b/lib/c_glib/src/thrift/c_glib/protocol/thrift_compact_protocol.c
new file mode 100644
index 0000000..1b36904
--- /dev/null
+++ b/lib/c_glib/src/thrift/c_glib/protocol/thrift_compact_protocol.c
@@ -0,0 +1,1605 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <string.h>
+#include <stdio.h>
+
+#include <thrift/c_glib/thrift.h>
+#include <thrift/c_glib/protocol/thrift_protocol.h>
+#include <thrift/c_glib/protocol/thrift_compact_protocol.h>
+
+/*
+ * *_to_zigzag depend on the fact that the right shift
+ * operator on a signed integer is an arithmetic (sign-extending) shift.
+ * If this is not the case, the current implementation will not work.
+ */
+#if !defined(SIGNED_RIGHT_SHIFT_IS) || !defined(ARITHMETIC_RIGHT_SHIFT)
+# error "Unable to determine the behavior of a signed right shift"
+#endif
+#if SIGNED_RIGHT_SHIFT_IS != ARITHMETIC_RIGHT_SHIFT
+# error "thrift_compact_protocol only works if signed right shift is arithmetic"
+#endif
+
+/* object properties */
+enum _ThriftCompactProtocolProperties
+{
+ PROP_0,
+ PROP_THRIFT_COMPACT_PROTOCOL_STRING_LIMIT,
+ PROP_THRIFT_COMPACT_PROTOCOL_CONTAINER_LIMIT
+};
+
+G_DEFINE_TYPE (ThriftCompactProtocol, thrift_compact_protocol,
+ THRIFT_TYPE_PROTOCOL)
+
+static const gint8 PROTOCOL_ID = (gint8)0x82u;
+static const gint8 VERSION_N = 1;
+static const gint8 VERSION_MASK = 0x1f; /* 0001 1111 */
+static const gint8 TYPE_MASK = (gint8)0xe0u; /* 1110 0000 */
+static const gint8 TYPE_BITS = 0x07; /* 0000 0111 */
+static const gint32 TYPE_SHIFT_AMOUNT = 5;
+
+enum Types {
+ CT_STOP = 0x00,
+ CT_BOOLEAN_TRUE = 0x01,
+ CT_BOOLEAN_FALSE = 0x02,
+ CT_BYTE = 0x03,
+ CT_I16 = 0x04,
+ CT_I32 = 0x05,
+ CT_I64 = 0x06,
+ CT_DOUBLE = 0x07,
+ CT_BINARY = 0x08,
+ CT_LIST = 0x09,
+ CT_SET = 0x0A,
+ CT_MAP = 0x0B,
+ CT_STRUCT = 0x0C
+};
+
+static const gint8 TTypeToCType[16] = {
+ CT_STOP, /* T_STOP */
+ 0, /* unused */
+ CT_BOOLEAN_TRUE, /* T_BOOL */
+ CT_BYTE, /* T_BYTE */
+ CT_DOUBLE, /* T_DOUBLE */
+ 0, /* unused */
+ CT_I16, /* T_I16 */
+ 0, /* unused */
+ CT_I32, /* T_I32 */
+ 0, /* unused */
+ CT_I64, /* T_I64 */
+ CT_BINARY, /* T_STRING */
+ CT_STRUCT, /* T_STRUCT */
+ CT_MAP, /* T_MAP */
+ CT_SET, /* T_SET */
+ CT_LIST, /* T_LIST */
+};
+
+static guint64
+thrift_bitwise_cast_guint64 (const gdouble v)
+{
+ union {
+ gdouble from;
+ guint64 to;
+ } u;
+ u.from = v;
+ return u.to;
+}
+
+static gdouble
+thrift_bitwise_cast_gdouble (const guint64 v)
+{
+ union {
+ guint64 from;
+ gdouble to;
+ } u;
+ u.from = v;
+ return u.to;
+}
+
+/**
+ * Convert l into a zigzag long. This allows negative numbers to be
+ * represented compactly as a varint.
+ */
+static guint64
+i64_to_zigzag (const gint64 l)
+{
+ return (l << 1) ^ (l >> 63);
+}
+
+/**
+ * Convert n into a zigzag int. This allows negative numbers to be
+ * represented compactly as a varint.
+ */
+static guint32
+i32_to_zigzag (const gint32 n)
+{
+ return (n << 1) ^ (n >> 31);
+}
+
+/**
+ * Convert from zigzag int to int.
+ */
+static gint32
+zigzag_to_i32 (guint32 n)
+{
+ return (n >> 1) ^ (guint32) (-(gint32) (n & 1));
+}
+
+/**
+ * Convert from zigzag long to long.
+ */
+static gint64
+zigzag_to_i64 (guint64 n)
+{
+ return (n >> 1) ^ (guint64) (-(gint64) (n & 1));
+}
+
+ThriftType thrift_compact_protocol_get_ttype (ThriftCompactProtocol *protocol,
+ const gint8 type, GError **error)
+{
+ THRIFT_UNUSED_VAR (protocol);
+
+ switch (type) {
+ case T_STOP:
+ return T_STOP;
+ case CT_BOOLEAN_FALSE:
+ case CT_BOOLEAN_TRUE:
+ return T_BOOL;
+ case CT_BYTE:
+ return T_BYTE;
+ case CT_I16:
+ return T_I16;
+ case CT_I32:
+ return T_I32;
+ case CT_I64:
+ return T_I64;
+ case CT_DOUBLE:
+ return T_DOUBLE;
+ case CT_BINARY:
+ return T_STRING;
+ case CT_LIST:
+ return T_LIST;
+ case CT_SET:
+ return T_SET;
+ case CT_MAP:
+ return T_MAP;
+ case CT_STRUCT:
+ return T_STRUCT;
+ default:
+ g_set_error (error, THRIFT_PROTOCOL_ERROR,
+ THRIFT_PROTOCOL_ERROR_INVALID_DATA,
+ "unrecognized type");
+ return -1;
+ }
+}
+
+/**
+ * Write an i32 as a varint. Results in 1-5 bytes on the wire.
+ */
+gint32
+thrift_compact_protocol_write_varint32 (ThriftCompactProtocol *protocol,
+ const guint32 n,
+ GError **error)
+{
+ guint8 buf[5];
+ gint32 xfer;
+ guint32 m;
+
+ THRIFT_UNUSED_VAR (error);
+
+ xfer = 0;
+ m = n;
+
+ while (TRUE) {
+ if ((m & ~0x7F) == 0) {
+ buf[xfer++] = (gint8)m;
+ break;
+ } else {
+ buf[xfer++] = (gint8)((m & 0x7F) | 0x80);
+ m >>= 7;
+ }
+ }
+
+ if (thrift_transport_write (THRIFT_PROTOCOL (protocol)->transport,
+ (const gpointer) buf, xfer, error)) {
+ return xfer;
+ } else {
+ return -1;
+ }
+}
+
+/**
+ * Write an i64 as a varint. Results in 1-10 bytes on the wire.
+ */
+gint32
+thrift_compact_protocol_write_varint64 (ThriftCompactProtocol *protocol,
+ const guint64 n,
+ GError **error)
+{
+ guint8 buf[10];
+ gint32 xfer;
+ guint64 m;
+
+ THRIFT_UNUSED_VAR (error);
+
+ xfer = 0;
+ m = n;
+
+ while (TRUE) {
+ if ((m & ~0x7FL) == 0) {
+ buf[xfer++] = (gint8)m;
+ break;
+ } else {
+ buf[xfer++] = (gint8)((m & 0x7F) | 0x80);
+ m >>= 7;
+ }
+ }
+
+ if (thrift_transport_write (THRIFT_PROTOCOL (protocol)->transport,
+ (const gpointer) buf, xfer, error)) {
+ return xfer;
+ } else {
+ return -1;
+ }
+}
+
+/**
+ * Read an i64 from the wire as a proper varint. The MSB of each byte is set
+ * if there is another byte to follow. This can read up to 10 bytes.
+ */
+gint32
+thrift_compact_protocol_read_varint64 (ThriftCompactProtocol *protocol,
+ gint64 *i64,
+ GError **error)
+{
+ gint32 ret;
+ gint32 xfer;
+ guint64 val;
+ gint shift;
+ guint8 byte;
+
+ xfer = 0;
+ val = 0;
+ shift = 0;
+ byte = 0;
+
+ while (TRUE) {
+ if ((ret = thrift_transport_read (THRIFT_PROTOCOL (protocol)->transport,
+ (gpointer) &byte, 1, error)) < 0) {
+ return -1;
+ }
+ ++xfer;
+ val |= (guint64)(byte & 0x7f) << shift;
+ shift += 7;
+ if (!(byte & 0x80)) {
+ *i64 = (gint64) val;
+ return xfer;
+ }
+ if (G_UNLIKELY (xfer == 10)) { /* 7 * 9 < 64 < 7 * 10 */
+ g_set_error (error, THRIFT_PROTOCOL_ERROR,
+ THRIFT_PROTOCOL_ERROR_INVALID_DATA,
+ "variable-length int over 10 bytes");
+ return -1;
+ }
+ }
+}
+
+/**
+ * Read an i32 from the wire as a varint. The MSB of each byte is set
+ * if there is another byte to follow. This can read up to 5 bytes.
+ */
+gint32
+thrift_compact_protocol_read_varint32 (ThriftCompactProtocol *protocol,
+ gint32 *i32,
+ GError **error)
+{
+ gint64 val;
+ gint32 ret;
+ gint32 xfer;
+
+ xfer = 0;
+
+ if ((ret = thrift_compact_protocol_read_varint64 (protocol, &val,
+ error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ *i32 = (gint32)val;
+
+ return xfer;
+}
+
+gint32
+thrift_compact_protocol_write_field_begin_internal (ThriftCompactProtocol
+ *protocol,
+ const gchar *name,
+ const ThriftType field_type,
+ const gint16 field_id,
+ const gint8 type_override,
+ GError **error)
+{
+ gint32 ret;
+ gint32 xfer;
+ gint8 type_to_write;
+
+ THRIFT_UNUSED_VAR (name);
+
+ xfer = 0;
+
+ /* if there's a type override, use that. */
+ type_to_write
+ = (type_override == -1 ? TTypeToCType[field_type] : type_override);
+
+ /* check if we can use delta encoding for the field id */
+ if (field_id > protocol->_last_field_id
+ && field_id - protocol->_last_field_id <= 15) {
+ /* write them together */
+ if ((ret = thrift_protocol_write_byte (THRIFT_PROTOCOL (protocol),
+ (gint8) ((field_id
+ - protocol->_last_field_id)
+ << 4 | type_to_write),
+ error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+ } else {
+ /* write them separate */
+ if ((ret = thrift_protocol_write_byte (THRIFT_PROTOCOL (protocol),
+ type_to_write, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ if ((ret = thrift_protocol_write_i16 (THRIFT_PROTOCOL (protocol), field_id,
+ error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+ }
+
+ protocol->_last_field_id = field_id;
+ return xfer;
+}
+
+/**
+ * Method for writing the start of lists and sets. List and sets on
+ * the wire differ only by the type indicator.
+ */
+gint32
+thrift_compact_protocol_write_collection_begin (ThriftCompactProtocol *protocol,
+ const ThriftType elem_type,
+ guint32 size, GError **error)
+{
+ gint32 ret;
+ gint32 xfer;
+
+ xfer = 0;
+
+ if (size <= 14) {
+ if ((ret = thrift_protocol_write_byte (THRIFT_PROTOCOL (protocol),
+ (gint8) (size << 4
+ | TTypeToCType[elem_type]),
+ error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+ } else {
+ if ((ret = thrift_protocol_write_byte (THRIFT_PROTOCOL (protocol),
+ (gint8) (0xf0
+ | TTypeToCType[elem_type]),
+ error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ if ((ret = thrift_compact_protocol_write_varint32 (protocol,
+ (guint32) size,
+ error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+ }
+
+ return xfer;
+}
+
+/*
+ * public methods
+ */
+
+gint32
+thrift_compact_protocol_write_message_begin (ThriftProtocol *protocol,
+ const gchar *name,
+ const ThriftMessageType
+ message_type,
+ const gint32 seqid, GError **error)
+{
+ gint8 version;
+ gint32 ret;
+ gint32 xfer;
+
+ ThriftCompactProtocol *cp;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ version = (VERSION_N & VERSION_MASK)
+ | (((gint32) message_type << TYPE_SHIFT_AMOUNT) & TYPE_MASK);
+ xfer = 0;
+
+ if ((ret = thrift_protocol_write_byte (protocol, PROTOCOL_ID, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ if ((ret = thrift_protocol_write_byte (protocol, version, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ if ((ret = thrift_compact_protocol_write_varint32 (cp,
+ (guint32) seqid,
+ error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ if ((ret = thrift_protocol_write_string (protocol, name, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ return xfer;
+}
+
+gint32
+thrift_compact_protocol_write_message_end (ThriftProtocol *protocol,
+ GError **error)
+{
+ /* satisfy -Wall */
+ THRIFT_UNUSED_VAR (protocol);
+ THRIFT_UNUSED_VAR (error);
+ return 0;
+}
+
+gint32
+thrift_compact_protocol_write_struct_begin (ThriftProtocol *protocol,
+ const gchar *name,
+ GError **error)
+{
+ ThriftCompactProtocol *cp;
+ GQueue *q;
+
+ /* satisfy -Wall */
+ THRIFT_UNUSED_VAR (name);
+ THRIFT_UNUSED_VAR (error);
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+ q = &(cp->_last_field);
+
+ g_queue_push_tail (q, GINT_TO_POINTER ((gint) cp->_last_field_id));
+ cp->_last_field_id = 0;
+ return 0;
+}
+
+gint32
+thrift_compact_protocol_write_struct_end (ThriftProtocol *protocol,
+ GError **error)
+{
+ ThriftCompactProtocol *cp;
+ GQueue *q;
+
+ /* satisfy -Wall */
+ THRIFT_UNUSED_VAR (error);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+ q = &(cp->_last_field);
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp->_last_field_id = (gint16) GPOINTER_TO_INT (g_queue_pop_tail (q));
+ return 0;
+}
+
+gint32
+thrift_compact_protocol_write_field_begin (ThriftProtocol *protocol,
+ const gchar *name,
+ const ThriftType field_type,
+ const gint16 field_id,
+ GError **error)
+{
+ ThriftCompactProtocol *cp;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ if (field_type == T_BOOL) {
+ cp->_bool_field_name = name;
+ cp->_bool_field_type = field_type;
+ cp->_bool_field_id = field_id;
+ return 0;
+ } else {
+ return thrift_compact_protocol_write_field_begin_internal (cp, name,
+ field_type,
+ field_id, -1,
+ error);
+ }
+}
+
+gint32
+thrift_compact_protocol_write_field_end (ThriftProtocol *protocol,
+ GError **error)
+{
+ /* satisfy -Wall */
+ THRIFT_UNUSED_VAR (protocol);
+ THRIFT_UNUSED_VAR (error);
+ return 0;
+}
+
+gint32
+thrift_compact_protocol_write_field_stop (ThriftProtocol *protocol,
+ GError **error)
+{
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+ return thrift_protocol_write_byte (protocol, (gint8) T_STOP, error);
+}
+
+gint32
+thrift_compact_protocol_write_map_begin (ThriftProtocol *protocol,
+ const ThriftType key_type,
+ const ThriftType value_type,
+ const guint32 size,
+ GError **error)
+{
+ gint32 ret;
+ gint32 xfer;
+
+ ThriftCompactProtocol *cp;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ xfer = 0;
+
+ if ((ret = thrift_compact_protocol_write_varint32 (cp, (guint32) size,
+ error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ if (size > 0) {
+ if ((ret = thrift_protocol_write_byte (protocol,
+ (gint8) (TTypeToCType[key_type] << 4
+ | TTypeToCType[value_type]),
+ error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+ }
+
+ return xfer;
+}
+
+gint32
+thrift_compact_protocol_write_map_end (ThriftProtocol *protocol,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (protocol);
+ THRIFT_UNUSED_VAR (error);
+ return 0;
+}
+
+gint32
+thrift_compact_protocol_write_list_begin (ThriftProtocol *protocol,
+ const ThriftType element_type,
+ const guint32 size,
+ GError **error)
+{
+ ThriftCompactProtocol *cp;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ return thrift_compact_protocol_write_collection_begin (cp, element_type,
+ size, error);
+}
+
+gint32
+thrift_compact_protocol_write_list_end (ThriftProtocol *protocol,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (protocol);
+ THRIFT_UNUSED_VAR (error);
+ return 0;
+}
+
+gint32
+thrift_compact_protocol_write_set_begin (ThriftProtocol *protocol,
+ const ThriftType element_type,
+ const guint32 size,
+ GError **error)
+{
+ ThriftCompactProtocol *cp;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ return thrift_compact_protocol_write_collection_begin (cp, element_type,
+ size, error);
+}
+
+gint32
+thrift_compact_protocol_write_set_end (ThriftProtocol *protocol, GError **error)
+{
+ THRIFT_UNUSED_VAR (protocol);
+ THRIFT_UNUSED_VAR (error);
+ return 0;
+}
+
+gint32
+thrift_compact_protocol_write_bool (ThriftProtocol *protocol,
+ const gboolean value, GError **error)
+{
+ ThriftCompactProtocol *cp;
+
+ gint32 ret;
+ gint32 xfer;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ xfer = 0;
+
+ if (cp->_bool_field_name != NULL) {
+ /* we haven't written the field header yet */
+ if ((ret = thrift_compact_protocol_write_field_begin_internal (cp,
+ cp->_bool_field_name,
+ cp->_bool_field_type,
+ cp->_bool_field_id,
+ (gint8) (value
+ ? CT_BOOLEAN_TRUE : CT_BOOLEAN_FALSE),
+ error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ cp->_bool_field_name = NULL;
+ } else {
+ /* we're not part of a field, so just write the value */
+ if ((ret = thrift_protocol_write_byte (protocol,
+ (gint8) (value ? CT_BOOLEAN_TRUE
+ : CT_BOOLEAN_FALSE),
+ error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+ }
+ return xfer;
+}
+
+gint32
+thrift_compact_protocol_write_byte (ThriftProtocol *protocol, const gint8 value,
+ GError **error)
+{
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ if (thrift_transport_write (protocol->transport,
+ (const gpointer) &value, 1, error)) {
+ return 1;
+ } else {
+ return -1;
+ }
+}
+
+gint32
+thrift_compact_protocol_write_i16 (ThriftProtocol *protocol, const gint16 value,
+ GError **error)
+{
+ ThriftCompactProtocol *cp;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ return thrift_compact_protocol_write_varint32 (cp,
+ i32_to_zigzag ((gint32) value),
+ error);
+}
+
+gint32
+thrift_compact_protocol_write_i32 (ThriftProtocol *protocol, const gint32 value,
+ GError **error)
+{
+ ThriftCompactProtocol *cp;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ return thrift_compact_protocol_write_varint32 (cp,
+ i32_to_zigzag (value),
+ error);
+}
+
+gint32
+thrift_compact_protocol_write_i64 (ThriftProtocol *protocol, const gint64 value,
+ GError **error)
+{
+ ThriftCompactProtocol *cp;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ return thrift_compact_protocol_write_varint64 (cp,
+ i64_to_zigzag (value),
+ error);
+}
+
+gint32
+thrift_compact_protocol_write_double (ThriftProtocol *protocol,
+ const gdouble value, GError **error)
+{
+ guint64 bits;
+
+ g_assert (sizeof (gdouble) == sizeof (guint64));
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ bits = GUINT64_TO_LE (thrift_bitwise_cast_guint64 (value));
+ if (thrift_transport_write (protocol->transport,
+ (const gpointer) &bits, 8, error)) {
+ return 8;
+ } else {
+ return -1;
+ }
+}
+
+gint32
+thrift_compact_protocol_write_string (ThriftProtocol *protocol,
+ const gchar *str, GError **error)
+{
+ size_t len;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ len = str != NULL ? strlen (str) : 0;
+ if (len > G_MAXINT32) {
+ g_set_error (error, THRIFT_PROTOCOL_ERROR,
+ THRIFT_PROTOCOL_ERROR_SIZE_LIMIT,
+ "string size (guess: %lu) is too large", (unsigned long) len);
+ return -1;
+ }
+
+ /* write the string length + 1 which includes the null terminator */
+ return thrift_protocol_write_binary (protocol, (const gpointer) str,
+ (const guint32) len, error);
+}
+
+gint32
+thrift_compact_protocol_write_binary (ThriftProtocol *protocol,
+ const gpointer buf,
+ const guint32 len, GError **error)
+{
+ ThriftCompactProtocol *cp;
+
+ gint32 ret;
+ gint32 xfer;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ xfer = 0;
+
+ if ((ret = thrift_compact_protocol_write_varint32 (cp, len, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ if (len > 0) {
+ /* checking len + xfer > uint_max, but we don't want to overflow while
+ * checking for overflows. transforming to len > uint_max - xfer.
+ */
+ if (len > (guint32) (G_MAXINT32 - xfer)) {
+ g_set_error (error, THRIFT_PROTOCOL_ERROR,
+ THRIFT_PROTOCOL_ERROR_SIZE_LIMIT,
+ "size %d + %d is too large", len, xfer);
+ return -1;
+ }
+
+ if (thrift_transport_write (protocol->transport,
+ (const gpointer) buf, len, error) == FALSE) {
+ return -1;
+ }
+ xfer += len;
+ }
+
+ return xfer;
+}
+
+gint32
+thrift_compact_protocol_read_message_begin (ThriftProtocol *protocol,
+ gchar **name,
+ ThriftMessageType *message_type,
+ gint32 *seqid, GError **error)
+{
+ ThriftCompactProtocol *cp;
+
+ gint32 ret;
+ gint32 xfer;
+
+ gint8 protocol_id, version_and_type, version;
+
+ xfer = 0;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ if ((ret = thrift_protocol_read_byte (protocol, &protocol_id, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ if (protocol_id != PROTOCOL_ID) {
+ g_set_error (error, THRIFT_PROTOCOL_ERROR,
+ THRIFT_PROTOCOL_ERROR_BAD_VERSION,
+ "bad protocol id");
+ return -1;
+ }
+
+ if ((ret = thrift_protocol_read_byte (protocol, &version_and_type,
+ error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ version = (gint8)(version_and_type & VERSION_MASK);
+ if (version != VERSION_N) {
+ g_set_error (error, THRIFT_PROTOCOL_ERROR,
+ THRIFT_PROTOCOL_ERROR_BAD_VERSION,
+ "bad version and/or type");
+ return -1;
+ }
+
+ *message_type
+ = (ThriftMessageType)((version_and_type >> TYPE_SHIFT_AMOUNT) & TYPE_BITS);
+
+ if ((ret = thrift_compact_protocol_read_varint32 (cp, seqid, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ if ((ret = thrift_protocol_read_string (protocol, name, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ return xfer;
+}
+
+gint32
+thrift_compact_protocol_read_message_end (ThriftProtocol *protocol,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (protocol);
+ THRIFT_UNUSED_VAR (error);
+ return 0;
+}
+
+gint32
+thrift_compact_protocol_read_struct_begin (ThriftProtocol *protocol,
+ gchar **name,
+ GError **error)
+{
+ ThriftCompactProtocol *cp;
+ GQueue *q;
+
+ THRIFT_UNUSED_VAR (error);
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+ q = &(cp->_last_field);
+
+ *name = NULL;
+
+ g_queue_push_tail (q, GINT_TO_POINTER ((gint) cp->_last_field_id));
+ cp->_last_field_id = 0;
+
+ return 0;
+}
+
+gint32
+thrift_compact_protocol_read_struct_end (ThriftProtocol *protocol,
+ GError **error)
+{
+ ThriftCompactProtocol *cp;
+ GQueue *q;
+
+ THRIFT_UNUSED_VAR (error);
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+ q = &(cp->_last_field);
+
+ cp->_last_field_id = (gint16) GPOINTER_TO_INT (g_queue_pop_tail (q));
+
+ return 0;
+}
+
+gint32
+thrift_compact_protocol_read_field_begin (ThriftProtocol *protocol,
+ gchar **name,
+ ThriftType *field_type,
+ gint16 *field_id,
+ GError **error)
+{
+ ThriftCompactProtocol *cp;
+
+ gint32 ret;
+ gint32 xfer;
+
+ gint16 modifier;
+ gint8 byte;
+ gint8 type;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ THRIFT_UNUSED_VAR (name);
+
+ xfer = 0;
+
+ if ((ret = thrift_protocol_read_byte (protocol, &byte, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ type = (byte & 0x0f);
+
+ /* if it's a stop, then we can return immediately, as the struct is over. */
+ if (type == T_STOP) {
+ *field_type = T_STOP;
+ *field_id = 0;
+ return xfer;
+ }
+
+ /* mask off the 4 MSB of the type header.
+ * it could contain a field id delta.
+ */
+ modifier = (gint16)(((guint8)byte & 0xf0) >> 4);
+ if (modifier == 0) {
+ /* not a delta, look ahead for the zigzag varint field id. */
+ if ((ret = thrift_protocol_read_i16 (protocol, field_id, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+ } else {
+ *field_id = (gint16)(cp->_last_field_id + modifier);
+ }
+ if ((ret = thrift_compact_protocol_get_ttype (cp, type, error)) < 0) {
+ return -1;
+ }
+ *field_type = ret;
+
+ /* if this happens to be a boolean field, the value is encoded in the type */
+ if (type == CT_BOOLEAN_TRUE || type == CT_BOOLEAN_FALSE) {
+ /* save the boolean value in a special instance variable. */
+ cp->_has_bool_value = TRUE;
+ cp->_bool_value =
+ (type == CT_BOOLEAN_TRUE ? TRUE : FALSE);
+ }
+
+ /* push the new field onto the field stack so we can keep the deltas going. */
+ cp->_last_field_id = *field_id;
+
+ return xfer;
+}
+
+gint32
+thrift_compact_protocol_read_field_end (ThriftProtocol *protocol,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (protocol);
+ THRIFT_UNUSED_VAR (error);
+ return 0;
+}
+
+gint32
+thrift_compact_protocol_read_map_begin (ThriftProtocol *protocol,
+ ThriftType *key_type,
+ ThriftType *value_type,
+ guint32 *size,
+ GError **error)
+{
+ gint32 ret;
+ gint32 xfer;
+
+ gint8 kv_type;
+ gint32 msize;
+
+ ThriftCompactProtocol *cp;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ kv_type = 0;
+ msize = 0;
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ xfer = 0;
+
+ if ((ret = thrift_compact_protocol_read_varint32 (cp, &msize, error)) <0) {
+ return -1;
+ }
+ xfer += ret;
+
+ /* still read the kv byte if negative size */
+ if (msize != 0) {
+ if ((ret = thrift_protocol_read_byte (protocol, &kv_type, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+ }
+
+ if (cp->container_limit > 0 && msize > cp->container_limit) {
+ g_set_error (error, THRIFT_PROTOCOL_ERROR,
+ THRIFT_PROTOCOL_ERROR_SIZE_LIMIT,
+ "got size over limit (%d > %d)", msize, cp->container_limit);
+ return -1;
+ } else if (msize > 0) {
+ if ((ret = thrift_compact_protocol_get_ttype (cp,
+ (gint8)((guint8)kv_type
+ >> 4),
+ error)) < 0) {
+ return -1;
+ }
+ *key_type = ret;
+ if ((ret = thrift_compact_protocol_get_ttype (cp,
+ (gint8)((guint8)kv_type
+ & 0xf),
+ error)) < 0) {
+ return -1;
+ }
+ *value_type = ret;
+ *size = (guint32) msize;
+ } else if (msize == 0) {
+ *key_type = 0;
+ *value_type = 0;
+ *size = 0;
+ } else {
+ g_set_error (error, THRIFT_PROTOCOL_ERROR,
+ THRIFT_PROTOCOL_ERROR_NEGATIVE_SIZE,
+ "got negative size of %d", msize);
+ return -1;
+ }
+
+ return xfer;
+}
+
+gint32
+thrift_compact_protocol_read_map_end (ThriftProtocol *protocol,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (protocol);
+ THRIFT_UNUSED_VAR (error);
+ return 0;
+}
+
+gint32
+thrift_compact_protocol_read_list_begin (ThriftProtocol *protocol,
+ ThriftType *element_type,
+ guint32 *size, GError **error)
+{
+ ThriftCompactProtocol *cp;
+
+ gint32 ret;
+ gint32 xfer;
+
+ gint8 size_and_type;
+ gint32 lsize;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ size_and_type = 0;
+
+ xfer = 0;
+
+ if ((ret = thrift_protocol_read_byte (protocol, &size_and_type, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ lsize = ((guint8)size_and_type >> 4) & 0x0f;
+ if (lsize == 15) {
+ if ((ret = thrift_compact_protocol_read_varint32 (cp, &lsize, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+ }
+
+ if (lsize < 0) {
+ g_set_error (error, THRIFT_PROTOCOL_ERROR,
+ THRIFT_PROTOCOL_ERROR_NEGATIVE_SIZE,
+ "got negative size of %d", lsize);
+ return -1;
+ } else if (cp->container_limit > 0 && lsize > cp->container_limit) {
+ g_set_error (error, THRIFT_PROTOCOL_ERROR,
+ THRIFT_PROTOCOL_ERROR_SIZE_LIMIT,
+ "got size over limit (%d > %d)", lsize, cp->container_limit);
+ return -1;
+ }
+
+ if ((ret = thrift_compact_protocol_get_ttype (cp,
+ (gint8)(size_and_type & 0x0f),
+ error)) < 0) {
+ return -1;
+ }
+ *element_type = ret;
+ *size = (guint32) lsize;
+
+ return xfer;
+}
+
+gint32
+thrift_compact_protocol_read_list_end (ThriftProtocol *protocol,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (protocol);
+ THRIFT_UNUSED_VAR (error);
+ return 0;
+}
+
+gint32
+thrift_compact_protocol_read_set_begin (ThriftProtocol *protocol,
+ ThriftType *element_type,
+ guint32 *size, GError **error)
+{
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ return thrift_protocol_read_list_begin (protocol, element_type, size, error);
+}
+
+gint32
+thrift_compact_protocol_read_set_end (ThriftProtocol *protocol,
+ GError **error)
+{
+ THRIFT_UNUSED_VAR (protocol);
+ THRIFT_UNUSED_VAR (error);
+ return 0;
+}
+
+gint32
+thrift_compact_protocol_read_bool (ThriftProtocol *protocol, gboolean *value,
+ GError **error)
+{
+ ThriftCompactProtocol *cp;
+
+ gint32 ret;
+ gint32 xfer;
+
+ gint8 val;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ xfer = 0;
+
+ if (cp->_has_bool_value == TRUE) {
+ *value = cp->_bool_value;
+ cp->_has_bool_value = FALSE;
+ return 0;
+ } else {
+ if ((ret = thrift_protocol_read_byte (protocol, &val, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ *value = (val == CT_BOOLEAN_TRUE);
+ return xfer;
+ }
+}
+
+gint32
+thrift_compact_protocol_read_byte (ThriftProtocol *protocol, gint8 *value,
+ GError **error)
+{
+ gint32 ret;
+ gpointer b[1];
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ if ((ret =
+ thrift_transport_read (protocol->transport,
+ b, 1, error)) < 0) {
+ return -1;
+ }
+ *value = *(gint8 *) b;
+ return ret;
+}
+
+gint32
+thrift_compact_protocol_read_i16 (ThriftProtocol *protocol, gint16 *value,
+ GError **error)
+{
+ ThriftCompactProtocol *cp;
+
+ gint32 ret;
+ gint32 val;
+ gint32 xfer;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ xfer = 0;
+
+ if ((ret = thrift_compact_protocol_read_varint32 (cp, &val, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ *value = (gint16) zigzag_to_i32 ((guint32) val);
+
+ return xfer;
+}
+
+gint32
+thrift_compact_protocol_read_i32 (ThriftProtocol *protocol, gint32 *value,
+ GError **error)
+{
+ ThriftCompactProtocol *cp;
+
+ gint32 ret;
+ gint32 val;
+ gint32 xfer;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ xfer = 0;
+
+ if ((ret = thrift_compact_protocol_read_varint32 (cp, &val, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ *value = zigzag_to_i32 ((guint32) val);
+
+ return xfer;
+}
+
+gint32
+thrift_compact_protocol_read_i64 (ThriftProtocol *protocol, gint64 *value,
+ GError **error)
+{
+ ThriftCompactProtocol *cp;
+
+ gint32 ret;
+ gint64 val;
+ gint32 xfer;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ xfer = 0;
+
+ if ((ret = thrift_compact_protocol_read_varint64 (cp, &val, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ *value = zigzag_to_i64 ((guint64) val);
+
+ return xfer;
+}
+
+gint32
+thrift_compact_protocol_read_double (ThriftProtocol *protocol,
+ gdouble *value, GError **error)
+{
+ gint32 ret;
+ union {
+ guint64 bits;
+ guint8 b[8];
+ } u;
+
+ g_assert (sizeof (gdouble) == sizeof (guint64));
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ if ((ret =
+ thrift_transport_read (protocol->transport,
+ u.b, 8, error)) < 0) {
+ return -1;
+ }
+ u.bits = GUINT64_FROM_LE (u.bits);
+ *value = thrift_bitwise_cast_gdouble (u.bits);
+ return ret;
+}
+
+gint32
+thrift_compact_protocol_read_string (ThriftProtocol *protocol,
+ gchar **str, GError **error)
+{
+ ThriftCompactProtocol *cp;
+
+ gint32 ret;
+ gint32 xfer;
+
+ gint32 read_len;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ xfer = 0;
+ read_len = 0;
+
+ /* read the length into read_len */
+ if ((ret =
+ thrift_compact_protocol_read_varint32 (cp, &read_len, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ if (cp->string_limit > 0 && read_len > cp->string_limit) {
+ g_set_error (error, THRIFT_PROTOCOL_ERROR,
+ THRIFT_PROTOCOL_ERROR_SIZE_LIMIT,
+ "got size over limit (%d > %d)", read_len, cp->string_limit);
+ *str = NULL;
+ return -1;
+ }
+
+ if (read_len > 0) {
+ /* allocate the memory as an array of unsigned char for binary data */
+ *str = g_new0 (gchar, read_len + 1);
+ if ((ret =
+ thrift_transport_read (protocol->transport,
+ *str, read_len, error)) < 0) {
+ g_free (*str);
+ *str = NULL;
+ return -1;
+ }
+ xfer += ret;
+
+ } else if (read_len == 0) {
+ *str = NULL;
+
+ } else {
+ g_set_error (error, THRIFT_PROTOCOL_ERROR,
+ THRIFT_PROTOCOL_ERROR_NEGATIVE_SIZE,
+ "got negative size of %d", read_len);
+ *str = NULL;
+ return -1;
+ }
+
+ return xfer;
+}
+
+gint32
+thrift_compact_protocol_read_binary (ThriftProtocol *protocol,
+ gpointer *buf, guint32 *len,
+ GError **error)
+{
+ ThriftCompactProtocol *cp;
+
+ gint32 ret;
+ gint32 xfer;
+
+ gint32 read_len;
+
+ g_return_val_if_fail (THRIFT_IS_COMPACT_PROTOCOL (protocol), -1);
+
+ cp = THRIFT_COMPACT_PROTOCOL (protocol);
+
+ xfer = 0;
+ read_len = 0;
+
+ /* read the length into read_len */
+ if ((ret =
+ thrift_compact_protocol_read_varint32 (cp, &read_len, error)) < 0) {
+ return -1;
+ }
+ xfer += ret;
+
+ if (cp->string_limit > 0 && read_len > cp->string_limit) {
+ g_set_error (error, THRIFT_PROTOCOL_ERROR,
+ THRIFT_PROTOCOL_ERROR_SIZE_LIMIT,
+ "got size over limit (%d > %d)", read_len, cp->string_limit);
+ *buf = NULL;
+ *len = 0;
+ return -1;
+ }
+
+ if (read_len > 0) {
+ /* allocate the memory as an array of unsigned char for binary data */
+ *len = (guint32) read_len;
+ *buf = g_new (guchar, *len);
+ if ((ret =
+ thrift_transport_read (protocol->transport,
+ *buf, *len, error)) < 0) {
+ g_free (*buf);
+ *buf = NULL;
+ *len = 0;
+ return -1;
+ }
+ xfer += ret;
+
+ } else if (read_len == 0) {
+ *len = (guint32) read_len;
+ *buf = NULL;
+
+ } else {
+ g_set_error (error, THRIFT_PROTOCOL_ERROR,
+ THRIFT_PROTOCOL_ERROR_NEGATIVE_SIZE,
+ "got negative size of %d", read_len);
+ *buf = NULL;
+ *len = 0;
+ return -1;
+ }
+
+ return xfer;
+}
+
+/* property accessor */
+void
+thrift_compact_protocol_get_property (GObject *object, guint property_id,
+ GValue *value, GParamSpec *pspec)
+{
+ ThriftCompactProtocol *tc;
+
+ THRIFT_UNUSED_VAR (pspec);
+
+ tc = THRIFT_COMPACT_PROTOCOL (object);
+
+ switch (property_id) {
+ case PROP_THRIFT_COMPACT_PROTOCOL_STRING_LIMIT:
+ g_value_set_int (value, tc->string_limit);
+ break;
+ case PROP_THRIFT_COMPACT_PROTOCOL_CONTAINER_LIMIT:
+ g_value_set_int (value, tc->container_limit);
+ break;
+ }
+}
+
+/* property mutator */
+void
+thrift_compact_protocol_set_property (GObject *object, guint property_id,
+ const GValue *value, GParamSpec *pspec)
+{
+ ThriftCompactProtocol *tc;
+
+ THRIFT_UNUSED_VAR (pspec);
+
+ tc = THRIFT_COMPACT_PROTOCOL (object);
+
+ switch (property_id) {
+ case PROP_THRIFT_COMPACT_PROTOCOL_STRING_LIMIT:
+ tc->string_limit = g_value_get_int (value);
+ break;
+ case PROP_THRIFT_COMPACT_PROTOCOL_CONTAINER_LIMIT:
+ tc->container_limit = g_value_get_int (value);
+ break;
+ }
+}
+
+/* initialize the class */
+static void
+thrift_compact_protocol_class_init (ThriftCompactProtocolClass *klass)
+{
+ ThriftProtocolClass *cls;
+ GObjectClass *gobject_class;
+ GParamSpec *param_spec;
+
+ cls = THRIFT_PROTOCOL_CLASS (klass);
+ gobject_class = G_OBJECT_CLASS (klass);
+ param_spec = NULL;
+
+ /* setup accessors and mutators */
+ gobject_class->get_property = thrift_compact_protocol_get_property;
+ gobject_class->set_property = thrift_compact_protocol_set_property;
+
+ param_spec = g_param_spec_int ("string_limit",
+ "Max allowed string size",
+ "Set the max string limit",
+ 0, /* min */
+ G_MAXINT32, /* max */
+ 0, /* default value */
+ G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
+ g_object_class_install_property (gobject_class,
+ PROP_THRIFT_COMPACT_PROTOCOL_STRING_LIMIT,
+ param_spec);
+
+ param_spec = g_param_spec_int ("container_limit",
+ "Max allowed container size",
+ "Set the max container limit",
+ 0, /* min */
+ G_MAXINT32, /* max */
+ 0, /* default value */
+ G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
+ g_object_class_install_property (gobject_class,
+ PROP_THRIFT_COMPACT_PROTOCOL_CONTAINER_LIMIT,
+ param_spec);
+
+ cls->write_message_begin = thrift_compact_protocol_write_message_begin;
+ cls->write_message_end = thrift_compact_protocol_write_message_end;
+ cls->write_struct_begin = thrift_compact_protocol_write_struct_begin;
+ cls->write_struct_end = thrift_compact_protocol_write_struct_end;
+ cls->write_field_begin = thrift_compact_protocol_write_field_begin;
+ cls->write_field_end = thrift_compact_protocol_write_field_end;
+ cls->write_field_stop = thrift_compact_protocol_write_field_stop;
+ cls->write_map_begin = thrift_compact_protocol_write_map_begin;
+ cls->write_map_end = thrift_compact_protocol_write_map_end;
+ cls->write_list_begin = thrift_compact_protocol_write_list_begin;
+ cls->write_list_end = thrift_compact_protocol_write_list_end;
+ cls->write_set_begin = thrift_compact_protocol_write_set_begin;
+ cls->write_set_end = thrift_compact_protocol_write_set_end;
+ cls->write_bool = thrift_compact_protocol_write_bool;
+ cls->write_byte = thrift_compact_protocol_write_byte;
+ cls->write_i16 = thrift_compact_protocol_write_i16;
+ cls->write_i32 = thrift_compact_protocol_write_i32;
+ cls->write_i64 = thrift_compact_protocol_write_i64;
+ cls->write_double = thrift_compact_protocol_write_double;
+ cls->write_string = thrift_compact_protocol_write_string;
+ cls->write_binary = thrift_compact_protocol_write_binary;
+ cls->read_message_begin = thrift_compact_protocol_read_message_begin;
+ cls->read_message_end = thrift_compact_protocol_read_message_end;
+ cls->read_struct_begin = thrift_compact_protocol_read_struct_begin;
+ cls->read_struct_end = thrift_compact_protocol_read_struct_end;
+ cls->read_field_begin = thrift_compact_protocol_read_field_begin;
+ cls->read_field_end = thrift_compact_protocol_read_field_end;
+ cls->read_map_begin = thrift_compact_protocol_read_map_begin;
+ cls->read_map_end = thrift_compact_protocol_read_map_end;
+ cls->read_list_begin = thrift_compact_protocol_read_list_begin;
+ cls->read_list_end = thrift_compact_protocol_read_list_end;
+ cls->read_set_begin = thrift_compact_protocol_read_set_begin;
+ cls->read_set_end = thrift_compact_protocol_read_set_end;
+ cls->read_bool = thrift_compact_protocol_read_bool;
+ cls->read_byte = thrift_compact_protocol_read_byte;
+ cls->read_i16 = thrift_compact_protocol_read_i16;
+ cls->read_i32 = thrift_compact_protocol_read_i32;
+ cls->read_i64 = thrift_compact_protocol_read_i64;
+ cls->read_double = thrift_compact_protocol_read_double;
+ cls->read_string = thrift_compact_protocol_read_string;
+ cls->read_binary = thrift_compact_protocol_read_binary;
+}
+
+static void
+thrift_compact_protocol_init (ThriftCompactProtocol *self)
+{
+ g_queue_init (&(self->_last_field));
+}
diff --git a/lib/c_glib/src/thrift/c_glib/protocol/thrift_compact_protocol.h b/lib/c_glib/src/thrift/c_glib/protocol/thrift_compact_protocol.h
new file mode 100644
index 0000000..effcaad
--- /dev/null
+++ b/lib/c_glib/src/thrift/c_glib/protocol/thrift_compact_protocol.h
@@ -0,0 +1,107 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef _THRIFT_COMPACT_PROTOCOL_H
+#define _THRIFT_COMPACT_PROTOCOL_H
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include <thrift/c_glib/protocol/thrift_protocol.h>
+#include <thrift/c_glib/transport/thrift_transport.h>
+
+G_BEGIN_DECLS
+
+/*! \file thrift_compact_protocol.h
+ * \brief Compact protocol implementation of a Thrift protocol. Implements the
+ * ThriftProtocol interface.
+ */
+
+/* type macros */
+#define THRIFT_TYPE_COMPACT_PROTOCOL (thrift_compact_protocol_get_type ())
+#define THRIFT_COMPACT_PROTOCOL(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST ((obj), THRIFT_TYPE_COMPACT_PROTOCOL, \
+ ThriftCompactProtocol))
+#define THRIFT_IS_COMPACT_PROTOCOL(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), THRIFT_TYPE_COMPACT_PROTOCOL))
+#define THRIFT_COMPACT_PROTOCOL_CLASS(c) \
+ (G_TYPE_CHECK_CLASS_CAST ((c), THRIFT_TYPE_COMPACT_PROTOCOL, \
+ ThriftCompactProtocolClass))
+#define THRIFT_IS_COMPACT_PROTOCOL_CLASS(c) \
+ (G_TYPE_CHECK_CLASS_TYPE ((c), THRIFT_TYPE_COMPACT_PROTOCOL))
+#define THRIFT_COMPACT_PROTOCOL_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), THRIFT_TYPE_COMPACT_PROTOCOL, \
+ ThriftCompactProtocolClass))
+
+
+typedef struct _ThriftCompactProtocol ThriftCompactProtocol;
+
+/*!
+ * Thrift Compact Protocol instance.
+ */
+struct _ThriftCompactProtocol
+{
+ ThriftProtocol parent;
+
+ /* protected */
+ gint32 string_limit;
+ gint32 container_limit;
+
+ /* private */
+
+ /**
+ * (Writing) If we encounter a boolean field begin, save the TField here
+ * so it can have the value incorporated.
+ */
+ const gchar* _bool_field_name;
+ ThriftType _bool_field_type;
+ gint16 _bool_field_id;
+
+ /**
+ * (Reading) If we read a field header, and it's a boolean field, save
+ * the boolean value here so that read_bool can use it.
+ */
+ gboolean _has_bool_value;
+ gboolean _bool_value;
+
+ /**
+ * Used to keep track of the last field for the current and previous structs,
+ * so we can do the delta stuff.
+ */
+
+ GQueue _last_field;
+ gint16 _last_field_id;
+};
+
+typedef struct _ThriftCompactProtocolClass ThriftCompactProtocolClass;
+
+/*!
+ * Thrift Compact Protocol class.
+ */
+struct _ThriftCompactProtocolClass
+{
+ ThriftProtocolClass parent;
+};
+
+/* used by THRIFT_TYPE_COMPACT_PROTOCOL */
+GType thrift_compact_protocol_get_type (void);
+
+G_END_DECLS
+
+#endif /* _THRIFT_COMPACT_PROTOCOL_H */
diff --git a/lib/c_glib/src/thrift/c_glib/protocol/thrift_compact_protocol_factory.c b/lib/c_glib/src/thrift/c_glib/protocol/thrift_compact_protocol_factory.c
new file mode 100644
index 0000000..e725e1f
--- /dev/null
+++ b/lib/c_glib/src/thrift/c_glib/protocol/thrift_compact_protocol_factory.c
@@ -0,0 +1,140 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <thrift/c_glib/thrift.h>
+#include <thrift/c_glib/protocol/thrift_compact_protocol.h>
+#include <thrift/c_glib/protocol/thrift_compact_protocol_factory.h>
+
+/* object properties */
+enum _ThriftCompactProtocolFactoryProperties
+{
+ PROP_0,
+ PROP_THRIFT_COMPACT_PROTOCOL_FACTORY_STRING_LIMIT,
+ PROP_THRIFT_COMPACT_PROTOCOL_FACTORY_CONTAINER_LIMIT
+};
+
+G_DEFINE_TYPE (ThriftCompactProtocolFactory, thrift_compact_protocol_factory,
+ THRIFT_TYPE_PROTOCOL_FACTORY)
+
+ThriftProtocol *
+thrift_compact_protocol_factory_get_protocol (ThriftProtocolFactory *factory,
+ ThriftTransport *transport)
+{
+ ThriftCompactProtocolFactory *tcf;
+ ThriftCompactProtocol *tc;
+
+ tcf = THRIFT_COMPACT_PROTOCOL_FACTORY (factory);
+
+ tc = g_object_new (THRIFT_TYPE_COMPACT_PROTOCOL,
+ "transport", transport,
+ "string_limit", tcf->string_limit,
+ "container_limit", tcf->container_limit,
+ NULL);
+
+ return THRIFT_PROTOCOL (tc);
+}
+
+/* property accessor */
+void
+thrift_compact_protocol_factory_get_property (GObject *object, guint property_id,
+ GValue *value, GParamSpec *pspec)
+{
+ ThriftCompactProtocolFactory *tcf;
+
+ THRIFT_UNUSED_VAR (pspec);
+
+ tcf = THRIFT_COMPACT_PROTOCOL_FACTORY (object);
+
+ switch (property_id) {
+ case PROP_THRIFT_COMPACT_PROTOCOL_FACTORY_STRING_LIMIT:
+ g_value_set_int (value, tcf->string_limit);
+ break;
+ case PROP_THRIFT_COMPACT_PROTOCOL_FACTORY_CONTAINER_LIMIT:
+ g_value_set_int (value, tcf->container_limit);
+ break;
+ }
+}
+
+/* property mutator */
+void
+thrift_compact_protocol_factory_set_property (GObject *object, guint property_id,
+ const GValue *value, GParamSpec
+ *pspec)
+{
+ ThriftCompactProtocolFactory *tcf;
+
+ THRIFT_UNUSED_VAR (pspec);
+
+ tcf = THRIFT_COMPACT_PROTOCOL_FACTORY (object);
+
+ switch (property_id) {
+ case PROP_THRIFT_COMPACT_PROTOCOL_FACTORY_STRING_LIMIT:
+ tcf->string_limit = g_value_get_int (value);
+ break;
+ case PROP_THRIFT_COMPACT_PROTOCOL_FACTORY_CONTAINER_LIMIT:
+ tcf->container_limit = g_value_get_int (value);
+ break;
+ }
+}
+
+static void
+thrift_compact_protocol_factory_class_init (ThriftCompactProtocolFactoryClass
+ *klass)
+{
+ ThriftProtocolFactoryClass *cls;
+ GObjectClass *gobject_class;
+ GParamSpec *param_spec;
+
+ cls = THRIFT_PROTOCOL_FACTORY_CLASS (klass);
+ gobject_class = G_OBJECT_CLASS (klass);
+ param_spec = NULL;
+
+ /* setup accessors and mutators */
+ gobject_class->get_property = thrift_compact_protocol_factory_get_property;
+ gobject_class->set_property = thrift_compact_protocol_factory_set_property;
+
+ param_spec = g_param_spec_int ("string_limit",
+ "Max allowed string size",
+ "Set the max string limit",
+ 0, /* min */
+ G_MAXINT32, /* max */
+ 0, /* default value */
+ G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
+ g_object_class_install_property (gobject_class,
+ PROP_THRIFT_COMPACT_PROTOCOL_FACTORY_STRING_LIMIT,
+ param_spec);
+
+ param_spec = g_param_spec_int ("container_limit",
+ "Max allowed container size",
+ "Set the max container limit",
+ 0, /* min */
+ G_MAXINT32, /* max */
+ 0, /* default value */
+ G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
+ g_object_class_install_property (gobject_class,
+ PROP_THRIFT_COMPACT_PROTOCOL_FACTORY_CONTAINER_LIMIT, param_spec);
+
+ cls->get_protocol = thrift_compact_protocol_factory_get_protocol;
+}
+
+static void
+thrift_compact_protocol_factory_init (ThriftCompactProtocolFactory *factory)
+{
+ THRIFT_UNUSED_VAR (factory);
+}
diff --git a/lib/c_glib/src/thrift/c_glib/protocol/thrift_compact_protocol_factory.h b/lib/c_glib/src/thrift/c_glib/protocol/thrift_compact_protocol_factory.h
new file mode 100644
index 0000000..3bf953b
--- /dev/null
+++ b/lib/c_glib/src/thrift/c_glib/protocol/thrift_compact_protocol_factory.h
@@ -0,0 +1,70 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef _THRIFT_COMPACT_PROTOCOL_FACTORY_H
+#define _THRIFT_COMPACT_PROTOCOL_FACTORY_H
+
+#include <glib-object.h>
+
+#include <thrift/c_glib/protocol/thrift_protocol_factory.h>
+
+G_BEGIN_DECLS
+
+/* type macros */
+#define THRIFT_TYPE_COMPACT_PROTOCOL_FACTORY \
+ (thrift_compact_protocol_factory_get_type ())
+#define THRIFT_COMPACT_PROTOCOL_FACTORY(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST ((obj), THRIFT_TYPE_COMPACT_PROTOCOL_FACTORY, \
+ ThriftCompactProtocolFactory))
+#define THRIFT_IS_COMPACT_PROTOCOL_FACTORY(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), THRIFT_TYPE_COMPACT_PROTOCOL_FACTORY))
+#define THRIFT_COMPACT_PROTOCOL_FACTORY_CLASS(c) \
+ (G_TYPE_CHECK_CLASS_CAST ((c), THRIFT_TYPE_COMPACT_PROTOCOL_FACTORY, \
+ ThriftCompactProtocolFactoryClass))
+#define THRIFT_IS_COMPACT_PROTOCOL_FACTORY_CLASS(c) \
+ (G_TYPE_CHECK_CLASS_TYPE ((c), THRIFT_TYPE_COMPACT_PROTOCOL_FACTORY))
+#define THRIFT_COMPACT_PROTOCOL_FACTORY_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), THRIFT_TYPE_COMPACT_PROTOCOL_FACTORY, \
+ ThriftCompactProtocolFactoryClass))
+
+typedef struct _ThriftCompactProtocolFactory ThriftCompactProtocolFactory;
+
+struct _ThriftCompactProtocolFactory
+{
+ ThriftProtocolFactory parent;
+
+ /* protected */
+ gint32 string_limit;
+ gint32 container_limit;
+};
+
+typedef struct _ThriftCompactProtocolFactoryClass
+ ThriftCompactProtocolFactoryClass;
+
+struct _ThriftCompactProtocolFactoryClass
+{
+ ThriftProtocolFactoryClass parent;
+};
+
+/* used by THRIFT_TYPE_COMPACT_PROTOCOL_FACTORY */
+GType thrift_compact_protocol_factory_get_type (void);
+
+G_END_DECLS
+
+#endif /* _THRIFT_COMPACT_PROTOCOL_FACTORY_H */
diff --git a/lib/c_glib/test/CMakeLists.txt b/lib/c_glib/test/CMakeLists.txt
index 48a30d0..14454ed 100644
--- a/lib/c_glib/test/CMakeLists.txt
+++ b/lib/c_glib/test/CMakeLists.txt
@@ -73,6 +73,10 @@
target_link_libraries(testbinaryprotocol thrift_c_glib)
add_test(NAME testbinaryprotocol COMMAND testbinaryprotocol)
+add_executable(testcompactprotocol testcompactprotocol.c)
+target_link_libraries(testcompactprotocol thrift_c_glib)
+add_test(NAME testcompactprotocol COMMAND testcompactprotocol)
+
add_executable(testbufferedtransport testbufferedtransport.c)
target_link_libraries(testbufferedtransport thrift_c_glib)
add_test(NAME testbufferedtransport COMMAND testbufferedtransport)
diff --git a/lib/c_glib/test/Makefile.am b/lib/c_glib/test/Makefile.am
index 4d35f2a..43f3b4b 100755
--- a/lib/c_glib/test/Makefile.am
+++ b/lib/c_glib/test/Makefile.am
@@ -48,6 +48,7 @@
testcontainertest \
testtransportsocket \
testbinaryprotocol \
+ testcompactprotocol \
testbufferedtransport \
testframedtransport \
testmemorybuffer \
@@ -106,6 +107,14 @@
$(top_builddir)/lib/c_glib/src/thrift/c_glib/transport/libthrift_c_glib_la-thrift_server_transport.o \
$(top_builddir)/lib/c_glib/src/thrift/c_glib/transport/libthrift_c_glib_la-thrift_server_socket.o
+testcompactprotocol_SOURCES = testcompactprotocol.c
+testcompactprotocol_LDADD = \
+ $(top_builddir)/lib/c_glib/src/thrift/c_glib/protocol/libthrift_c_glib_la-thrift_protocol.o \
+ $(top_builddir)/lib/c_glib/src/thrift/c_glib/transport/libthrift_c_glib_la-thrift_transport.o \
+ $(top_builddir)/lib/c_glib/src/thrift/c_glib/transport/libthrift_c_glib_la-thrift_socket.o \
+ $(top_builddir)/lib/c_glib/src/thrift/c_glib/transport/libthrift_c_glib_la-thrift_server_transport.o \
+ $(top_builddir)/lib/c_glib/src/thrift/c_glib/transport/libthrift_c_glib_la-thrift_server_socket.o
+
testbufferedtransport_SOURCES = testbufferedtransport.c
testbufferedtransport_LDADD = \
$(top_builddir)/lib/c_glib/src/thrift/c_glib/transport/libthrift_c_glib_la-thrift_transport.o \
diff --git a/lib/c_glib/test/testcompactprotocol.c b/lib/c_glib/test/testcompactprotocol.c
new file mode 100755
index 0000000..3d16dc0
--- /dev/null
+++ b/lib/c_glib/test/testcompactprotocol.c
@@ -0,0 +1,1074 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/* Disable string-function optimizations when glibc is used, as these produce
+ compiler warnings about string length when a string function is used inside
+ a call to assert () */
+#if !defined(__APPLE__) && !defined(__FreeBSD__) && \
+ !defined(__OpenBSD__) && !defined(__NetBSD__)
+#include <features.h>
+#endif
+
+#ifdef __GLIBC__
+#define __NO_STRING_INLINES 1
+#endif
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <netdb.h>
+#include <string.h>
+#include <sys/wait.h>
+
+#include <thrift/c_glib/protocol/thrift_protocol.h>
+#include <thrift/c_glib/transport/thrift_socket.h>
+#include <thrift/c_glib/transport/thrift_server_socket.h>
+
+#define TEST_BOOL TRUE
+#define TEST_BYTE 123
+#define TEST_I16 12345
+#define TEST_I32 1234567890
+#define TEST_I64 123456789012345
+#define TEST_NI16 (-12345)
+#define TEST_NI32 (-1234567890)
+#define TEST_NI64 (-123456789012345)
+#define TEST_DOUBLE 1234567890.123
+#define TEST_STRING "this is a test string 1234567890!@#$%^&*()"
+#define TEST_PORT 51199
+
+static int transport_read_count = 0;
+static int transport_read_error = 0;
+static int transport_read_error_at = -1;
+gint32
+my_thrift_transport_read (ThriftTransport *transport, gpointer buf,
+ guint32 len, GError **error)
+{
+ if (transport_read_count != transport_read_error_at
+ && transport_read_error == 0)
+ {
+ transport_read_count++;
+ return thrift_transport_read (transport, buf, len, error);
+ }
+ return -1;
+}
+
+static int transport_write_count = 0;
+static int transport_write_error = 0;
+static int transport_write_error_at = -1;
+gboolean
+my_thrift_transport_write (ThriftTransport *transport, const gpointer buf,
+ const guint32 len, GError **error)
+{
+ if (transport_write_count != transport_write_error_at
+ && transport_write_error == 0)
+ {
+ transport_write_count++;
+ return thrift_transport_write (transport, buf, len, error);
+ }
+ return FALSE;
+}
+
+#define thrift_transport_read my_thrift_transport_read
+#define thrift_transport_write my_thrift_transport_write
+#include "../src/thrift/c_glib/protocol/thrift_compact_protocol.c"
+#undef thrift_transport_read
+#undef thrift_transport_write
+
+static void thrift_server_primitives (const int port);
+static void thrift_server_complex_types (const int port);
+
+static void
+test_create_and_destroy (void)
+{
+ GObject *object = NULL;
+
+ /* create an object and then destroy it */
+ object = g_object_new (THRIFT_TYPE_COMPACT_PROTOCOL, NULL);
+ assert (object != NULL);
+ g_object_unref (object);
+}
+
+static void
+test_initialize (void)
+{
+ ThriftSocket *tsocket = NULL;
+ ThriftCompactProtocol *protocol = NULL;
+ ThriftSocket *temp = NULL;
+
+ /* create a ThriftTransport */
+ tsocket = g_object_new (THRIFT_TYPE_SOCKET, "hostname", "localhost",
+ "port", 51188, NULL);
+ assert (tsocket != NULL);
+ /* create a ThriftCompactProtocol using the Transport */
+ protocol = g_object_new (THRIFT_TYPE_COMPACT_PROTOCOL, "transport",
+ tsocket, NULL);
+ assert (protocol != NULL);
+ /* fetch the properties */
+ g_object_get (G_OBJECT (protocol), "transport", &temp, NULL);
+ g_object_unref (temp);
+
+ /* clean up memory */
+ g_object_unref (protocol);
+ g_object_unref (tsocket);
+}
+
+static void
+test_read_and_write_primitives (void)
+{
+ int status;
+ pid_t pid;
+ ThriftSocket *tsocket = NULL;
+ ThriftTransport *transport = NULL;
+ ThriftCompactProtocol *tc = NULL;
+ ThriftProtocol *protocol = NULL;
+ gpointer binary = (gpointer *) TEST_STRING;
+ guint32 len = strlen (TEST_STRING);
+ int port = TEST_PORT;
+
+ /* fork a server from the client */
+ pid = fork ();
+ assert (pid >= 0);
+
+ if (pid == 0)
+ {
+ /* child listens */
+ thrift_server_primitives (port);
+ exit (0);
+ } else {
+ /* parent. wait a bit for the socket to be created. */
+ sleep (1);
+
+ /* create a ThriftSocket */
+ tsocket = g_object_new (THRIFT_TYPE_SOCKET, "hostname", "localhost",
+ "port", port, NULL);
+ transport = THRIFT_TRANSPORT (tsocket);
+ thrift_transport_open (transport, NULL);
+ assert (thrift_transport_is_open (transport));
+
+ /* create a ThriftCompactTransport */
+ tc = g_object_new (THRIFT_TYPE_COMPACT_PROTOCOL, "transport",
+ tsocket, NULL);
+ protocol = THRIFT_PROTOCOL (tc);
+ assert (protocol != NULL);
+
+ /* write a bunch of primitives */
+ assert (thrift_compact_protocol_write_bool (protocol, TEST_BOOL, NULL) > 0);
+ assert (thrift_compact_protocol_write_byte (protocol, TEST_BYTE, NULL) > 0);
+ assert (thrift_compact_protocol_write_i16 (protocol, TEST_I16, NULL) > 0);
+ assert (thrift_compact_protocol_write_i32 (protocol, TEST_I32, NULL) > 0);
+ assert (thrift_compact_protocol_write_i64 (protocol, TEST_I64, NULL) > 0);
+ assert (thrift_compact_protocol_write_i16 (protocol, TEST_NI16, NULL) > 0);
+ assert (thrift_compact_protocol_write_i32 (protocol, TEST_NI32, NULL) > 0);
+ assert (thrift_compact_protocol_write_i64 (protocol, TEST_NI64, NULL) > 0);
+ assert (thrift_compact_protocol_write_i16 (protocol, 2, NULL) > 0);
+ assert (thrift_compact_protocol_write_i32 (protocol, 2, NULL) > 0);
+ assert (thrift_compact_protocol_write_i64 (protocol, 2, NULL) > 0);
+ assert (thrift_compact_protocol_write_i16 (protocol, -2, NULL) > 0);
+ assert (thrift_compact_protocol_write_i32 (protocol, -2, NULL) > 0);
+ assert (thrift_compact_protocol_write_i64 (protocol, -2, NULL) > 0);
+ assert (thrift_compact_protocol_write_double (protocol,
+ TEST_DOUBLE, NULL) > 0);
+ assert (thrift_compact_protocol_write_string (protocol,
+ TEST_STRING, NULL) > 0);
+ assert (thrift_compact_protocol_write_binary (protocol, binary,
+ len, NULL) > 0);
+ assert (thrift_compact_protocol_write_binary (protocol, NULL, 0, NULL) > 0);
+ assert (thrift_compact_protocol_write_binary (protocol, binary,
+ len, NULL) > 0);
+
+ /* test write errors */
+ transport_write_error = 1;
+ assert (thrift_compact_protocol_write_byte (protocol, TEST_BYTE,
+ NULL) == -1);
+ assert (thrift_compact_protocol_write_i16 (protocol, TEST_I16, NULL) == -1);
+ assert (thrift_compact_protocol_write_i32 (protocol, TEST_I32, NULL) == -1);
+ assert (thrift_compact_protocol_write_i64 (protocol, TEST_I64, NULL) == -1);
+ assert (thrift_compact_protocol_write_i16 (protocol, TEST_NI16,
+ NULL) == -1);
+ assert (thrift_compact_protocol_write_i32 (protocol, TEST_NI32,
+ NULL) == -1);
+ assert (thrift_compact_protocol_write_i64 (protocol, TEST_NI64,
+ NULL) == -1);
+ assert (thrift_compact_protocol_write_double (protocol, TEST_DOUBLE,
+ NULL) == -1);
+ assert (thrift_compact_protocol_write_binary (protocol, binary, len,
+ NULL) == -1);
+ transport_write_error = 0;
+
+ /* test binary partial failure */
+ transport_write_count = 0;
+ transport_write_error_at = 1;
+ assert (thrift_compact_protocol_write_binary (protocol, binary,
+ len, NULL) == -1);
+ transport_write_error_at = -1;
+
+ /* clean up */
+ thrift_transport_close (transport, NULL);
+ g_object_unref (tsocket);
+ g_object_unref (protocol);
+ assert (wait (&status) == pid);
+ assert (status == 0);
+ }
+}
+
+static void
+test_read_and_write_complex_types (void)
+{
+ int status;
+ pid_t pid;
+ ThriftSocket *tsocket = NULL;
+ ThriftTransport *transport = NULL;
+ ThriftCompactProtocol *tc = NULL;
+ ThriftProtocol *protocol = NULL;
+ int port = TEST_PORT;
+
+ /* fork a server from the client */
+ pid = fork ();
+ assert (pid >= 0);
+
+ if (pid == 0)
+ {
+ /* child listens */
+ thrift_server_complex_types (port);
+ exit (0);
+ } else {
+ /* parent. wait a bit for the socket to be created. */
+ sleep (1);
+
+ /* create a ThriftSocket */
+ tsocket = g_object_new (THRIFT_TYPE_SOCKET, "hostname", "localhost",
+ "port", port, NULL);
+ transport = THRIFT_TRANSPORT (tsocket);
+ thrift_transport_open (transport, NULL);
+ assert (thrift_transport_is_open (transport));
+
+ /* create a ThriftCompactTransport */
+ tc = g_object_new (THRIFT_TYPE_COMPACT_PROTOCOL, "transport",
+ tsocket, NULL);
+ protocol = THRIFT_PROTOCOL (tc);
+ assert (protocol != NULL);
+
+ /* test structures */
+ assert (thrift_compact_protocol_write_struct_begin (protocol,
+ NULL, NULL) == 0);
+ assert (thrift_compact_protocol_write_struct_end (protocol, NULL) == 0);
+
+ /* test field state w.r.t. deltas */
+
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE, 1, NULL) == 1);
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 16, NULL) == 1);
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 17, NULL) == 1);
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 15, NULL) > 1);
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 30, NULL) == 1);
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 46, NULL) > 1);
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 47, NULL) == 1);
+
+ /* test fields */
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 1, NULL) > 1);
+ assert (thrift_compact_protocol_write_field_end (protocol, NULL) == 0);
+
+ /* test field state w.r.t. structs */
+
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 1, NULL) > 1);
+ assert (thrift_compact_protocol_write_field_end (protocol, NULL) == 0);
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 16, NULL) == 1);
+ assert (thrift_compact_protocol_write_field_end (protocol, NULL) == 0);
+
+ assert (thrift_compact_protocol_write_struct_begin (protocol,
+ NULL, NULL) == 0);
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 17, NULL) > 1);
+ assert (thrift_compact_protocol_write_field_end (protocol, NULL) == 0);
+
+ assert (thrift_compact_protocol_write_struct_begin (protocol,
+ NULL, NULL) == 0);
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 18, NULL) > 1);
+ assert (thrift_compact_protocol_write_field_end (protocol, NULL) == 0);
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 19, NULL) == 1);
+ assert (thrift_compact_protocol_write_field_end (protocol, NULL) == 0);
+ assert (thrift_compact_protocol_write_struct_end (protocol, NULL) == 0);
+
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 18, NULL) == 1);
+ assert (thrift_compact_protocol_write_field_end (protocol, NULL) == 0);
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 25, NULL) == 1);
+ assert (thrift_compact_protocol_write_field_end (protocol, NULL) == 0);
+ assert (thrift_compact_protocol_write_struct_end (protocol, NULL) == 0);
+
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 17, NULL) == 1);
+ assert (thrift_compact_protocol_write_field_end (protocol, NULL) == 0);
+
+ /* test field state w.r.t. bools */
+
+ /* deltas */
+ /* non-bool field -> bool field -> non-bool field */
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 18, NULL) == 1);
+ assert (thrift_compact_protocol_write_field_end (protocol, NULL) == 0);
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test", T_BOOL,
+ 19, NULL) == 0);
+ assert (thrift_compact_protocol_write_bool (protocol, TEST_BOOL,
+ NULL) == 1);
+ assert (thrift_compact_protocol_write_field_end (protocol, NULL) == 0);
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 20, NULL) == 1);
+ assert (thrift_compact_protocol_write_field_end (protocol, NULL) == 0);
+ /* bool -> bool field -> bool */
+ assert (thrift_compact_protocol_write_bool (protocol, TEST_BOOL, NULL) > 0);
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test", T_BOOL,
+ 21, NULL) == 0);
+ assert (thrift_compact_protocol_write_bool (protocol, TEST_BOOL,
+ NULL) == 1);
+ assert (thrift_compact_protocol_write_field_end (protocol, NULL) == 0);
+ assert (thrift_compact_protocol_write_bool (protocol, TEST_BOOL, NULL) > 0);
+
+ /* no deltas */
+ /* non-bool field -> bool field -> non-bool field */
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 1, NULL) > 1);
+ assert (thrift_compact_protocol_write_field_end (protocol, NULL) == 0);
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test", T_BOOL,
+ 1, NULL) == 0);
+ assert (thrift_compact_protocol_write_bool (protocol, TEST_BOOL, NULL) > 1);
+ assert (thrift_compact_protocol_write_field_end (protocol, NULL) == 0);
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 1, NULL) > 1);
+ assert (thrift_compact_protocol_write_field_end (protocol, NULL) == 0);
+ /* bool -> bool field -> bool */
+ assert (thrift_compact_protocol_write_bool (protocol, TEST_BOOL, NULL) > 0);
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test", T_BOOL,
+ 1, NULL) == 0);
+ assert (thrift_compact_protocol_write_bool (protocol, TEST_BOOL, NULL) > 1);
+ assert (thrift_compact_protocol_write_field_end (protocol, NULL) == 0);
+ assert (thrift_compact_protocol_write_bool (protocol, TEST_BOOL, NULL) > 0);
+
+ /* test write error */
+ transport_write_error = 1;
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 1, NULL) == -1);
+ transport_write_error = 0;
+
+ /* test 2nd write error */
+ transport_write_count = 0;
+ transport_write_error_at = 1;
+ assert (thrift_compact_protocol_write_field_begin (protocol, "test",
+ T_DOUBLE,
+ 1, NULL) == -1);
+ transport_write_error_at = -1;
+
+ /* test 2nd read failure on a field */
+ thrift_compact_protocol_write_byte (protocol, T_DOUBLE, NULL);
+
+ /* test write_field_stop */
+ assert (thrift_compact_protocol_write_field_stop (protocol, NULL) > 0);
+
+ /* write a map */
+ assert (thrift_compact_protocol_write_map_begin (protocol, T_DOUBLE,
+ T_DOUBLE,
+ 1, NULL) > 0);
+ assert (thrift_compact_protocol_write_map_end (protocol, NULL) == 0);
+
+ /* test 1st read failure on map---nothing to do on our side */
+
+ /* test 2nd read failure on a map */
+ thrift_compact_protocol_write_byte (protocol, T_DOUBLE, NULL);
+
+ /* test 1st write failure on a map */
+ transport_write_error = 1;
+ assert (thrift_compact_protocol_write_map_begin (protocol, T_DOUBLE,
+ T_DOUBLE,
+ 1, NULL) == -1);
+ transport_write_error = 0;
+
+ /* test 2nd write failure on a map */
+ transport_write_count = 0;
+ transport_write_error_at = 1;
+ assert (thrift_compact_protocol_write_map_begin (protocol, T_DOUBLE,
+ T_DOUBLE,
+ 1, NULL) == -1);
+ transport_write_error_at = -1;
+
+ /* test negative map size */
+ thrift_compact_protocol_write_varint32 (tc, -10, NULL);
+ thrift_compact_protocol_write_byte (protocol, T_DOUBLE, NULL);
+
+ /* test list operations */
+ assert (thrift_compact_protocol_write_list_begin (protocol, T_DOUBLE,
+ 15, NULL) > 0);
+ assert (thrift_compact_protocol_write_list_end (protocol, NULL) == 0);
+
+ /* test 1st read failure on a small list---nothing to do on our end */
+
+ /* test 1st read failure on a big list---nothing to do on our end */
+
+ /* test 2nd read failure on a big list */
+ thrift_compact_protocol_write_byte (protocol, (gint8) 0xf0, NULL);
+
+ /* test negative list size */
+ thrift_compact_protocol_write_byte (protocol, (gint8) 0xf0, NULL);
+ thrift_compact_protocol_write_varint32 (tc, -10, NULL);
+
+ /* test first write error on a small list */
+ transport_write_error = 1;
+ assert (thrift_compact_protocol_write_list_begin (protocol, T_DOUBLE,
+ 14, NULL) == -1);
+ transport_write_error = 0;
+
+ /* test first write error on a big list */
+ transport_write_error = 1;
+ assert (thrift_compact_protocol_write_list_begin (protocol, T_DOUBLE,
+ 15, NULL) == -1);
+ transport_write_error = 0;
+
+ /* test 2nd write error on a big list */
+ transport_write_count = 0;
+ transport_write_error_at = 1;
+ assert (thrift_compact_protocol_write_list_begin (protocol, T_DOUBLE,
+ 15, NULL) == -1);
+ transport_write_error_at = -1;
+
+ /* test set operation s*/
+ assert (thrift_compact_protocol_write_set_begin (protocol, T_DOUBLE,
+ 1, NULL) > 0);
+ assert (thrift_compact_protocol_write_set_end (protocol, NULL) == 0);
+
+ /* invalid protocol */
+ assert (thrift_compact_protocol_write_byte (protocol, 0, NULL) > 0);
+
+ /* invalid version */
+ assert (thrift_compact_protocol_write_byte (protocol, (gint8) 0x82u,
+ NULL) > 0);
+ assert (thrift_compact_protocol_write_byte (protocol, 0, NULL) > 0);
+
+ /* send a valid message */
+ assert (thrift_compact_protocol_write_byte (protocol, (gint8) 0x82u,
+ NULL) > 0);
+ assert (thrift_compact_protocol_write_byte (protocol, 0x01u, NULL) > 0);
+ thrift_compact_protocol_write_varint32 (tc, 1, NULL);
+ thrift_compact_protocol_write_string (protocol, "test", NULL);
+
+ /* broken 2nd read */
+ thrift_compact_protocol_write_byte (protocol, (gint8) 0x82u, NULL);
+
+ /* send a broken 3rd read */
+ thrift_compact_protocol_write_byte (protocol, (gint8) 0x82u, NULL);
+ thrift_compact_protocol_write_byte (protocol, 0x01u, NULL);
+
+ /* send a broken 4th read */
+ thrift_compact_protocol_write_byte (protocol, (gint8) 0x82u, NULL);
+ thrift_compact_protocol_write_byte (protocol, 0x01u, NULL);
+ thrift_compact_protocol_write_varint32 (tc, 1, NULL);
+
+ /* send a valid message */
+ assert (thrift_compact_protocol_write_message_begin (protocol, "test",
+ T_CALL, 1, NULL) > 0);
+
+ assert (thrift_compact_protocol_write_message_end (protocol, NULL) == 0);
+
+ /* send broken writes */
+ transport_write_error = 1;
+ assert (thrift_compact_protocol_write_message_begin (protocol, "test",
+ T_CALL, 1, NULL) == -1);
+ transport_write_error = 0;
+
+ transport_write_count = 0;
+ transport_write_error_at = 1;
+ assert (thrift_compact_protocol_write_message_begin (protocol, "test",
+ T_CALL, 1, NULL) == -1);
+ transport_write_error_at = -1;
+
+ transport_write_count = 0;
+ transport_write_error_at = 2;
+ assert (thrift_compact_protocol_write_message_begin (protocol, "test",
+ T_CALL, 1, NULL) == -1);
+ transport_write_error_at = -1;
+
+ transport_write_count = 0;
+ transport_write_error_at = 3;
+ assert (thrift_compact_protocol_write_message_begin (protocol, "test",
+ T_CALL, 1, NULL) == -1);
+ transport_write_error_at = -1;
+
+ /* clean up */
+ thrift_transport_close (transport, NULL);
+ g_object_unref (tsocket);
+ g_object_unref (protocol);
+ assert (wait (&status) == pid);
+ assert (status == 0);
+ }
+}
+
+
+static void
+thrift_server_primitives (const int port)
+{
+ ThriftServerTransport *transport = NULL;
+ ThriftTransport *client = NULL;
+ ThriftCompactProtocol *tc = NULL;
+ ThriftProtocol *protocol = NULL;
+ gboolean value_boolean = FALSE;
+ gint8 value_byte = 0,
+ zigzag_p16 = 0, zigzag_p32 = 0, zigzag_p64 = 0,
+ zigzag_n16 = 0, zigzag_n32 = 0, zigzag_n64 = 0;
+ gint16 value_16 = 0;
+ gint32 value_32 = 0;
+ gint64 value_64 = 0;
+ gint16 value_n16 = 0;
+ gint32 value_n32 = 0;
+ gint64 value_n64 = 0;
+ gdouble value_double = 0;
+ gchar *string = NULL;
+ gpointer binary = NULL;
+ guint32 len = 0;
+ void *comparator = (void *) TEST_STRING;
+
+ ThriftServerSocket *tsocket = g_object_new (THRIFT_TYPE_SERVER_SOCKET,
+ "port", port, NULL);
+ transport = THRIFT_SERVER_TRANSPORT (tsocket);
+ thrift_server_transport_listen (transport, NULL);
+ client = thrift_server_transport_accept (transport, NULL);
+ assert (client != NULL);
+
+ tc = g_object_new (THRIFT_TYPE_COMPACT_PROTOCOL, "transport",
+ client, NULL);
+ protocol = THRIFT_PROTOCOL (tc);
+
+ assert (thrift_compact_protocol_read_bool (protocol,
+ &value_boolean, NULL) > 0);
+ assert (thrift_compact_protocol_read_byte (protocol, &value_byte, NULL) > 0);
+ assert (thrift_compact_protocol_read_i16 (protocol, &value_16, NULL) > 0);
+ assert (thrift_compact_protocol_read_i32 (protocol, &value_32, NULL) > 0);
+ assert (thrift_compact_protocol_read_i64 (protocol, &value_64, NULL) > 0);
+ assert (thrift_compact_protocol_read_i16 (protocol, &value_n16, NULL) > 0);
+ assert (thrift_compact_protocol_read_i32 (protocol, &value_n32, NULL) > 0);
+ assert (thrift_compact_protocol_read_i64 (protocol, &value_n64, NULL) > 0);
+ assert (thrift_compact_protocol_read_byte (protocol, &zigzag_p16, NULL) > 0);
+ assert (thrift_compact_protocol_read_byte (protocol, &zigzag_p32, NULL) > 0);
+ assert (thrift_compact_protocol_read_byte (protocol, &zigzag_p64, NULL) > 0);
+ assert (thrift_compact_protocol_read_byte (protocol, &zigzag_n16, NULL) > 0);
+ assert (thrift_compact_protocol_read_byte (protocol, &zigzag_n32, NULL) > 0);
+ assert (thrift_compact_protocol_read_byte (protocol, &zigzag_n64, NULL) > 0);
+ assert (thrift_compact_protocol_read_double (protocol,
+ &value_double, NULL) > 0);
+ assert (thrift_compact_protocol_read_string (protocol, &string, NULL) > 0);
+ assert (thrift_compact_protocol_read_binary (protocol, &binary,
+ &len, NULL) > 0);
+
+ assert (value_boolean == TEST_BOOL);
+ assert (value_byte == TEST_BYTE);
+ assert (value_16 == TEST_I16);
+ assert (value_32 == TEST_I32);
+ assert (value_64 == TEST_I64);
+ assert (value_n16 == TEST_NI16);
+ assert (value_n32 == TEST_NI32);
+ assert (value_n64 == TEST_NI64);
+ assert (zigzag_p16 == 4);
+ assert (zigzag_p32 == 4);
+ assert (zigzag_p64 == 4);
+ assert (zigzag_n16 == 3);
+ assert (zigzag_n32 == 3);
+ assert (zigzag_n64 == 3);
+ assert (value_double == TEST_DOUBLE);
+ assert (strcmp (TEST_STRING, string) == 0);
+ assert (memcmp (comparator, binary, len) == 0);
+
+ g_free (string);
+ g_free (binary);
+
+ thrift_compact_protocol_read_binary (protocol, &binary, &len, NULL);
+ g_free (binary);
+
+ transport_read_count = 0;
+ transport_read_error_at = 0;
+ assert (thrift_compact_protocol_read_binary (protocol, &binary,
+ &len, NULL) == -1);
+ transport_read_error_at = -1;
+
+ transport_read_count = 0;
+ transport_read_error_at = 1;
+ assert (thrift_compact_protocol_read_binary (protocol, &binary,
+ &len, NULL) == -1);
+ transport_read_error_at = -1;
+
+ transport_read_error = 1;
+ assert (thrift_compact_protocol_read_bool (protocol,
+ &value_boolean, NULL) == -1);
+ assert (thrift_compact_protocol_read_byte (protocol,
+ &value_byte, NULL) == -1);
+ assert (thrift_compact_protocol_read_i16 (protocol,
+ &value_16, NULL) == -1);
+ assert (thrift_compact_protocol_read_i32 (protocol, &value_32, NULL) == -1);
+ assert (thrift_compact_protocol_read_i64 (protocol, &value_64, NULL) == -1);
+ assert (thrift_compact_protocol_read_i16 (protocol,
+ &value_n16, NULL) == -1);
+ assert (thrift_compact_protocol_read_i32 (protocol, &value_n32, NULL) == -1);
+ assert (thrift_compact_protocol_read_i64 (protocol, &value_n64, NULL) == -1);
+ assert (thrift_compact_protocol_read_double (protocol,
+ &value_double, NULL) == -1);
+ transport_read_error = 0;
+
+ /* test partial write failure */
+ thrift_protocol_read_i32 (protocol, &value_32, NULL);
+
+ thrift_transport_read_end (client, NULL);
+ thrift_transport_close (client, NULL);
+
+ g_object_unref (tc);
+ g_object_unref (client);
+ g_object_unref (tsocket);
+}
+
+static void
+thrift_server_complex_types (const int port)
+{
+ ThriftServerTransport *transport = NULL;
+ ThriftTransport *client = NULL;
+ ThriftCompactProtocol *tc = NULL;
+ ThriftProtocol *protocol = NULL;
+ gchar *struct_name = NULL;
+ gchar *field_name = NULL;
+ gchar *message_name = NULL;
+ ThriftType element_type, key_type, value_type, field_type;
+ ThriftMessageType message_type;
+ gboolean value_boolean = ! TEST_BOOL;
+ gint8 value = 0;
+ gint16 field_id = 0;
+ guint32 size = 0;
+ gint32 seqid = 0;
+ gint8 version_and_type = 0;
+ gint8 protocol_id = 0;
+
+ ThriftServerSocket *tsocket = g_object_new (THRIFT_TYPE_SERVER_SOCKET,
+ "port", port, NULL);
+ transport = THRIFT_SERVER_TRANSPORT (tsocket);
+ thrift_server_transport_listen (transport, NULL);
+ client = thrift_server_transport_accept (transport, NULL);
+ assert (client != NULL);
+
+ tc = g_object_new (THRIFT_TYPE_COMPACT_PROTOCOL, "transport",
+ client, NULL);
+ protocol = THRIFT_PROTOCOL (tc);
+
+ /* test struct operations */
+
+ thrift_compact_protocol_read_struct_begin (protocol, &struct_name, NULL);
+ thrift_compact_protocol_read_struct_end (protocol, NULL);
+
+ /* test field state w.r.t. deltas */
+
+ field_id = 0;
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) == 1);
+ assert (field_id == 1);
+ field_id = 0;
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) == 1);
+ assert (field_id == 16);
+ field_id = 0;
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) == 1);
+ assert (field_id == 17);
+ field_id = 0;
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) > 1);
+ assert (field_id == 15);
+ field_id = 0;
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) == 1);
+ assert (field_id == 30);
+ field_id = 0;
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) > 1);
+ assert (field_id == 46);
+ field_id = 0;
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) == 1);
+ assert (field_id == 47);
+ field_id = 0;
+
+ /* test field operations */
+
+ thrift_compact_protocol_read_field_begin (protocol, &field_name, &field_type,
+ &field_id, NULL);
+ thrift_compact_protocol_read_field_end (protocol, NULL);
+
+ /* test field state w.r.t. structs */
+
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) > 1);
+ assert (field_id == 1);
+ field_id = 0;
+ thrift_compact_protocol_read_field_end (protocol, NULL);
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) == 1);
+ assert (field_id == 16);
+ field_id = 0;
+ thrift_compact_protocol_read_field_end (protocol, NULL);
+
+ assert (thrift_compact_protocol_read_struct_begin (protocol,
+ &struct_name, NULL) == 0);
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) > 1);
+ assert (field_id == 17);
+ field_id = 0;
+ thrift_compact_protocol_read_field_end (protocol, NULL);
+
+ assert (thrift_compact_protocol_read_struct_begin (protocol,
+ &struct_name, NULL) == 0);
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) > 1);
+ assert (field_id == 18);
+ field_id = 0;
+ thrift_compact_protocol_read_field_end (protocol, NULL);
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) == 1);
+ assert (field_id == 19);
+ field_id = 0;
+ thrift_compact_protocol_read_field_end (protocol, NULL);
+ assert (thrift_compact_protocol_read_struct_end (protocol, NULL) == 0);
+
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) == 1);
+ assert (field_id == 18);
+ field_id = 0;
+ thrift_compact_protocol_read_field_end (protocol, NULL);
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) == 1);
+ assert (field_id == 25);
+ field_id = 0;
+ thrift_compact_protocol_read_field_end (protocol, NULL);
+ assert (thrift_compact_protocol_read_struct_end (protocol, NULL) == 0);
+
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) == 1);
+ assert (field_id == 17);
+ field_id = 0;
+ thrift_compact_protocol_read_field_end (protocol, NULL);
+
+ /* test field state w.r.t. bools */
+
+ /* deltas */
+ /* non-bool field -> bool field -> non-bool field */
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) == 1);
+ thrift_compact_protocol_read_field_end (protocol, NULL);
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) == 1);
+ assert (field_type == T_BOOL);
+ assert (thrift_compact_protocol_read_bool (protocol,
+ &value_boolean, NULL) == 0);
+ assert (value_boolean == TEST_BOOL);
+ value_boolean = ! TEST_BOOL;
+ thrift_compact_protocol_read_field_end (protocol, NULL);
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) == 1);
+ thrift_compact_protocol_read_field_end (protocol, NULL);
+ /* bool -> bool field -> bool */
+ assert (thrift_compact_protocol_read_bool (protocol,
+ &value_boolean, NULL) > 0);
+ assert (value_boolean == TEST_BOOL);
+ value_boolean = ! TEST_BOOL;
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) == 1);
+ assert (field_type == T_BOOL);
+ assert (thrift_compact_protocol_read_bool (protocol,
+ &value_boolean, NULL) == 0);
+ assert (value_boolean == TEST_BOOL);
+ value_boolean = ! TEST_BOOL;
+ thrift_compact_protocol_read_field_end (protocol, NULL);
+ assert (thrift_compact_protocol_read_bool (protocol,
+ &value_boolean, NULL) > 0);
+ assert (value_boolean == TEST_BOOL);
+ value_boolean = ! TEST_BOOL;
+
+ /* no deltas */
+ /* non-bool field -> bool field -> non-bool field */
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) > 1);
+ thrift_compact_protocol_read_field_end (protocol, NULL);
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) > 1);
+ assert (field_type == T_BOOL);
+ assert (thrift_compact_protocol_read_bool (protocol,
+ &value_boolean, NULL) == 0);
+ assert (value_boolean == TEST_BOOL);
+ value_boolean = ! TEST_BOOL;
+ thrift_compact_protocol_read_field_end (protocol, NULL);
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) > 1);
+ thrift_compact_protocol_read_field_end (protocol, NULL);
+ /* bool -> bool field -> bool */
+ assert (thrift_compact_protocol_read_bool (protocol,
+ &value_boolean, NULL) > 0);
+ assert (value_boolean == TEST_BOOL);
+ value_boolean = ! TEST_BOOL;
+ assert (thrift_compact_protocol_read_field_begin (protocol, &field_name,
+ &field_type,
+ &field_id, NULL) > 1);
+ assert (field_type == T_BOOL);
+ assert (thrift_compact_protocol_read_bool (protocol,
+ &value_boolean, NULL) == 0);
+ assert (value_boolean == TEST_BOOL);
+ value_boolean = ! TEST_BOOL;
+ thrift_compact_protocol_read_field_end (protocol, NULL);
+ assert (thrift_compact_protocol_read_bool (protocol,
+ &value_boolean, NULL) > 0);
+ assert (value_boolean == TEST_BOOL);
+ value_boolean = ! TEST_BOOL;
+
+ /* test first read error on a field */
+ transport_read_error = 1;
+ assert (thrift_compact_protocol_read_field_begin (protocol,
+ &field_name, &field_type,
+ &field_id, NULL) == -1);
+ transport_read_error = 0;
+
+ /* test 2nd write failure */
+ thrift_compact_protocol_read_byte (protocol, &value, NULL);
+
+ /* test 2nd read failure on a field */
+ transport_read_count = 0;
+ transport_read_error_at = 1;
+ assert (thrift_compact_protocol_read_field_begin (protocol,
+ &field_name, &field_type,
+ &field_id, NULL) == -1);
+ transport_read_error_at = -1;
+
+ /* test field stop */
+ thrift_compact_protocol_read_field_begin (protocol, &field_name, &field_type,
+ &field_id, NULL);
+
+ /* test map operations */
+
+ thrift_compact_protocol_read_map_begin (protocol, &key_type, &value_type,
+ &size, NULL);
+ thrift_compact_protocol_read_map_end (protocol, NULL);
+
+ /* test 1st read failure on a map */
+ transport_read_count = 0;
+ transport_read_error_at = 0;
+ assert (thrift_compact_protocol_read_map_begin (protocol,
+ &key_type, &value_type,
+ &size, NULL) == -1);
+ transport_read_error_at = -1;
+
+ /* test 2nd read failure on a map */
+ transport_read_count = 0;
+ transport_read_error_at = 1;
+ assert (thrift_compact_protocol_read_map_begin (protocol,
+ &key_type, &value_type,
+ &size, NULL) == -1);
+ transport_read_error_at = -1;
+
+ /* test 1st write failure on map---nothing to do on our side */
+
+ /* test 2nd write failure */
+ thrift_compact_protocol_read_byte (protocol, &value, NULL);
+
+ /* test negative map size */
+ assert (thrift_compact_protocol_read_map_begin (protocol,
+ &key_type, &value_type,
+ &size, NULL) == -1);
+
+ /* test list operations */
+ thrift_compact_protocol_read_list_begin (protocol, &element_type, &size,
+ NULL);
+ thrift_compact_protocol_read_list_end (protocol, NULL);
+
+ /* test small list 1st read failure */
+ transport_read_error = 1;
+ assert (thrift_compact_protocol_read_list_begin (protocol, &element_type,
+ &size, NULL) == -1);
+ transport_read_error = 0;
+
+ /* test big list 1st read failure */
+ transport_read_error = 1;
+ assert (thrift_compact_protocol_read_list_begin (protocol, &element_type,
+ &size, NULL) == -1);
+ transport_read_error = 0;
+
+ /* test big list 2nd read failure */
+ transport_read_count = 0;
+ transport_read_error_at = 1;
+ thrift_compact_protocol_read_list_begin (protocol, &element_type, &size,
+ NULL);
+ transport_read_error_at = -1;
+
+ /* test negative list size failure */
+ thrift_compact_protocol_read_list_begin (protocol, &element_type, &size,
+ NULL);
+
+ /* test small list 1st write failure---nothing to do on our end */
+
+ /* test big list 1st write failure---nothing to do on our end */
+
+ /* test big list 2nd write failure */
+ thrift_compact_protocol_read_byte (protocol, &value, NULL);
+
+ /* test set operations */
+ thrift_compact_protocol_read_set_begin (protocol, &element_type, &size, NULL);
+ thrift_compact_protocol_read_set_end (protocol, NULL);
+
+ /* broken read */
+ transport_read_error = 1;
+ assert (thrift_compact_protocol_read_message_begin (protocol, &message_name,
+ &message_type, &seqid,
+ NULL) == -1);
+ transport_read_error = 0;
+
+ /* invalid protocol */
+ assert (thrift_compact_protocol_read_message_begin (protocol, &message_name,
+ &message_type, &seqid,
+ NULL) == -1);
+
+ /* invalid version */
+ assert (thrift_compact_protocol_read_message_begin (protocol, &message_name,
+ &message_type, &seqid,
+ NULL) == -1);
+
+ /* read a valid message */
+ assert (thrift_compact_protocol_read_message_begin (protocol, &message_name,
+ &message_type, &seqid,
+ NULL) > 0);
+ g_free (message_name);
+
+ /* broken 2nd read on a message */
+ transport_read_count = 0;
+ transport_read_error_at = 1;
+ assert (thrift_compact_protocol_read_message_begin (protocol, &message_name,
+ &message_type, &seqid,
+ NULL) == -1);
+ transport_read_error_at = -1;
+
+ /* broken 3rd read on a message */
+ transport_read_count = 0;
+ transport_read_error_at = 2;
+ assert (thrift_compact_protocol_read_message_begin (protocol, &message_name,
+ &message_type, &seqid,
+ NULL) == -1);
+ transport_read_error_at = -1;
+
+ /* broken 4th read on a message */
+ transport_read_count = 0;
+ transport_read_error_at = 3;
+ assert (thrift_compact_protocol_read_message_begin (protocol, &message_name,
+ &message_type, &seqid,
+ NULL) == -1);
+ transport_read_error_at = -1;
+
+ /* read a valid message */
+ assert (thrift_compact_protocol_read_message_begin (protocol, &message_name,
+ &message_type, &seqid,
+ NULL) > 0);
+ g_free (message_name);
+
+ assert (thrift_compact_protocol_read_message_end (protocol, NULL) == 0);
+
+ /* handle 2nd write failure on a message */
+ thrift_compact_protocol_read_byte (protocol, &protocol_id, NULL);
+
+ /* handle 3rd write failure on a message */
+ thrift_compact_protocol_read_byte (protocol, &protocol_id, NULL);
+ thrift_compact_protocol_read_byte (protocol, &version_and_type, NULL);
+
+ /* handle 4th write failure on a message */
+ thrift_compact_protocol_read_byte (protocol, &protocol_id, NULL);
+ thrift_compact_protocol_read_byte (protocol, &version_and_type, NULL);
+ thrift_compact_protocol_read_varint32 (tc, &seqid, NULL);
+
+ g_object_unref (client);
+ g_object_unref (tsocket);
+}
+
+int
+main (int argc, char *argv[])
+{
+#if (!GLIB_CHECK_VERSION (2, 36, 0))
+ g_type_init ();
+#endif
+
+ g_test_init (&argc, &argv, NULL);
+
+ g_test_add_func ("/testcompactprotocol/CreateAndDestroy",
+ test_create_and_destroy);
+ g_test_add_func ("/testcompactprotocol/Initialize", test_initialize);
+ g_test_add_func ("/testcompactprotocol/ReadAndWritePrimitives",
+ test_read_and_write_primitives);
+ g_test_add_func ("/testcompactprotocol/ReadAndWriteComplexTypes",
+ test_read_and_write_complex_types);
+
+ return g_test_run ();
+}
diff --git a/test/c_glib/src/test_client.c b/test/c_glib/src/test_client.c
index 0f8a713..3ae9325 100644
--- a/test/c_glib/src/test_client.c
+++ b/test/c_glib/src/test_client.c
@@ -27,6 +27,7 @@
#include <thrift/c_glib/thrift.h>
#include <thrift/c_glib/protocol/thrift_binary_protocol.h>
+#include <thrift/c_glib/protocol/thrift_compact_protocol.h>
#include <thrift/c_glib/transport/thrift_buffered_transport.h>
#include <thrift/c_glib/transport/thrift_framed_transport.h>
#include <thrift/c_glib/transport/thrift_socket.h>
@@ -89,7 +90,7 @@
{ "transport", 0, 0, G_OPTION_ARG_STRING, &transport_option,
"Transport: buffered, framed (=buffered)", NULL },
{ "protocol", 0, 0, G_OPTION_ARG_STRING, &protocol_option,
- "Protocol: binary (=binary)", NULL },
+ "Protocol: binary, compact (=binary)", NULL },
{ "testloops", 'n', 0, G_OPTION_ARG_INT, &num_tests,
"Number of tests (=1)", NULL },
{ NULL }
@@ -141,10 +142,15 @@
host = g_strdup ("localhost");
/* Validate the parsed options */
- if (protocol_option != NULL &&
- strncmp (protocol_option, "binary", 7) != 0) {
- fprintf (stderr, "Unknown protocol type %s\n", protocol_option);
- options_valid = FALSE;
+ if (protocol_option != NULL) {
+ if (strncmp (protocol_option, "compact", 8) == 0) {
+ protocol_type = THRIFT_TYPE_COMPACT_PROTOCOL;
+ protocol_name = "compact";
+ }
+ else if (strncmp (protocol_option, "binary", 7) != 0) {
+ fprintf (stderr, "Unknown protocol type %s\n", protocol_option);
+ options_valid = FALSE;
+ }
}
if (transport_option != NULL) {
diff --git a/test/c_glib/src/test_server.c b/test/c_glib/src/test_server.c
index 13eec27..7f41d3f 100644
--- a/test/c_glib/src/test_server.c
+++ b/test/c_glib/src/test_server.c
@@ -24,6 +24,7 @@
#include <thrift/c_glib/thrift.h>
#include <thrift/c_glib/protocol/thrift_binary_protocol_factory.h>
+#include <thrift/c_glib/protocol/thrift_compact_protocol_factory.h>
#include <thrift/c_glib/server/thrift_server.h>
#include <thrift/c_glib/server/thrift_simple_server.h>
#include <thrift/c_glib/transport/thrift_buffered_transport.h>
@@ -68,6 +69,8 @@
static gchar *server_type_option = NULL;
static gchar *transport_option = NULL;
static gchar *protocol_option = NULL;
+ static gint string_limit = 0;
+ static gint container_limit = 0;
static
GOptionEntry option_entries[] = {
@@ -78,7 +81,11 @@
{ "transport", 0, 0, G_OPTION_ARG_STRING, &transport_option,
"Transport: buffered, framed (=buffered)", NULL },
{ "protocol", 0, 0, G_OPTION_ARG_STRING, &protocol_option,
- "Protocol: binary (=binary)", NULL },
+ "Protocol: binary, compact (=binary)", NULL },
+ { "string-limit", 0, 0, G_OPTION_ARG_INT, &string_limit,
+ "Max string length (=none)", NULL },
+ { "container-limit", 0, 0, G_OPTION_ARG_INT, &container_limit,
+ "Max container length (=none)", NULL },
{ NULL }
};
@@ -126,10 +133,15 @@
options_valid = FALSE;
}
- if (protocol_option != NULL &&
- strncmp (protocol_option, "binary", 7) != 0) {
- fprintf (stderr, "Unknown protocol type %s\n", protocol_option);
- options_valid = FALSE;
+ if (protocol_option != NULL) {
+ if (strncmp (protocol_option, "compact", 8) == 0) {
+ protocol_factory_type = THRIFT_TYPE_COMPACT_PROTOCOL_FACTORY;
+ protocol_name = "compact";
+ }
+ else if (strncmp (protocol_option, "binary", 7) != 0) {
+ fprintf (stderr, "Unknown protocol type %s\n", protocol_option);
+ options_valid = FALSE;
+ }
}
if (transport_option != NULL) {
@@ -157,8 +169,16 @@
NULL);
transport_factory = g_object_new (transport_factory_type,
NULL);
- protocol_factory = g_object_new (protocol_factory_type,
- NULL);
+
+ if (strncmp (protocol_name, "compact", 8) == 0) {
+ protocol_factory = g_object_new (protocol_factory_type,
+ "string_limit", string_limit,
+ "container_limit", container_limit,
+ NULL);
+ } else {
+ protocol_factory = g_object_new (protocol_factory_type,
+ NULL);
+ }
server = g_object_new (THRIFT_TYPE_SIMPLE_SERVER,
"processor", processor,
diff --git a/test/tests.json b/test/tests.json
index c816d6e..8ba6186 100644
--- a/test/tests.json
+++ b/test/tests.json
@@ -23,7 +23,8 @@
"ip"
],
"protocols": [
- "binary"
+ "binary",
+ "compact"
],
"workdir": "c_glib"
},