gboolean bucket_store_mapping_client_recv_get_mapping (BucketStoreMappingIf * iface, GHashTable ** _return, BucketStoreMappingException ** e, GError ** error)
{

    gint32 rseqid;
    gchar * fname;
    ThriftMessageType mtype;
    ThriftProtocol * protocol = BUCKET_STORE_MAPPING_CLIENT (iface)->input_protocol;

    if (thrift_protocol_read_message_begin (protocol, &fname, &mtype, &rseqid, error) < 0)
    {
        if (fname) g_free (fname);
        return FALSE;
    }

    if (mtype == T_EXCEPTION) {
        if (fname) g_free (fname);
        ThriftApplicationException *xception = g_object_new (THRIFT_TYPE_APPLICATION_EXCEPTION, NULL);
        thrift_struct_read (THRIFT_STRUCT (xception), protocol, NULL);
        thrift_protocol_read_message_end (protocol, NULL);
        thrift_transport_read_end (protocol->transport, NULL);
        g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, xception->type, "application error: %s", xception->message);
        g_object_unref (xception);
        return FALSE;
    } else if (mtype != T_REPLY) {
        if (fname) g_free (fname);
        thrift_protocol_skip (protocol, T_STRUCT, NULL);
        thrift_protocol_read_message_end (protocol, NULL);
        thrift_transport_read_end (protocol->transport, NULL);
        g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, THRIFT_APPLICATION_EXCEPTION_ERROR_INVALID_MESSAGE_TYPE, "invalid message type %d, expected T_REPLY", mtype);
        return FALSE;
    } else if (strncmp (fname, "getMapping", 10) != 0) {
        thrift_protocol_skip (protocol, T_STRUCT, NULL);
        thrift_protocol_read_message_end (protocol, error);
        thrift_transport_read_end (protocol->transport, error);
        g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, THRIFT_APPLICATION_EXCEPTION_ERROR_WRONG_METHOD_NAME, "wrong method name %s, expected getMapping", fname);
        if (fname) g_free (fname);
        return FALSE;
    }
    if (fname) g_free (fname);

    {
        gint32 ret;
        gint32 xfer = 0;
        gchar *name = NULL;
        ThriftType ftype;
        gint16 fid;
        guint32 len = 0;
        gpointer data = NULL;


        /* satisfy -Wall in case these aren't used */
        THRIFT_UNUSED_VAR (len);
        THRIFT_UNUSED_VAR (data);

        /* read the struct begin marker */
        if ((ret = thrift_protocol_read_struct_begin (protocol, &name, error)) < 0)
        {
            if (name) g_free (name);
            return 0;
        }
        xfer += ret;
        if (name) g_free (name);
        name = NULL;

        /* read the struct fields */
        while (1)
        {
            /* read the beginning of a field */
            if ((ret = thrift_protocol_read_field_begin (protocol, &name, &ftype, &fid, error)) < 0)
            {
                if (name) g_free (name);
                return 0;
            }
            xfer += ret;
            if (name) g_free (name);
            name = NULL;

            /* break if we get a STOP field */
            if (ftype == T_STOP)
            {
                break;
            }

            switch (fid)
            {
            case 0:
                if (ftype == T_MAP)
                {
                    {
                        guint32 size;
                        ThriftType key_type;
                        ThriftType value_type;

                        /* read the map begin marker */
                        if ((ret = thrift_protocol_read_map_begin (protocol, &key_type, &value_type, &size, error)) < 0)
                            return 0;
                        xfer += ret;

                        /* iterate through each of the map's fields */
                        guint32 i;
                        for (i = 0; i < size; i++)
                        {
                            gint32* key0 = g_new (gint32, 1);
                            HostPort * val1 = NULL;
                            if ((ret = thrift_protocol_read_i32 (protocol, &*key0, error)) < 0)
                                return 0;
                            xfer += ret;
                            if ( val1 != NULL)
                            {
                                g_object_unref (val1);
                            }
                            val1 = g_object_new (TYPE_HOST_PORT, NULL);
                            if ((ret = thrift_struct_read (THRIFT_STRUCT (val1), protocol, error)) < 0)
                            {
                                g_object_unref (val1);
                                return 0;
                            }
                            xfer += ret;
                            g_hash_table_insert ((GHashTable *)*_return, (gpointer) key0, (gpointer) val1);
                        }

                        /* read the map end marker */
                        if ((ret = thrift_protocol_read_map_end (protocol, error)) < 0)
                            return 0;
                        xfer += ret;
                    }
                } else {
                    if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
                        return 0;
                    xfer += ret;
                }
                break;
            case 1:
                if (ftype == T_STRUCT)
                {
                    /* This struct is an exception */
                    if ( *e != NULL)
                    {
                        g_object_unref (*e);
                    }
                    *e = g_object_new (TYPE_BUCKET_STORE_MAPPING_EXCEPTION, NULL);
                    if ((ret = thrift_struct_read (THRIFT_STRUCT (*e), protocol, error)) < 0)
                    {
                        g_object_unref (*e);
                        return 0;
                    }
                    xfer += ret;
                } else {
                    if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
                        return 0;
                    xfer += ret;
                }
                break;
            default:
                if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
                    return 0;
                xfer += ret;
                break;
            }
            if ((ret = thrift_protocol_read_field_end (protocol, error)) < 0)
                return 0;
            xfer += ret;
        }

        if ((ret = thrift_protocol_read_struct_end (protocol, error)) < 0)
            return 0;
        xfer += ret;

    }

    if (thrift_protocol_read_message_end (protocol, error) < 0)
        return FALSE;

    if (!thrift_transport_read_end (protocol->transport, error))
        return FALSE;

    if (*e != NULL)
    {
        g_set_error (error, BUCKET_STORE_MAPPING_EXCEPTION_ERROR, BUCKET_STORE_MAPPING_EXCEPTION_ERROR_CODE, "BucketStoreMappingException");
        return FALSE;
    }
    return TRUE;
}
int32_t
thrift_protocol_skip (ThriftProtocol *protocol, ThriftType type, int *error)
{
  switch (type)
  {
    case T_BOOL:
      {
        u_int8_t boolv;
        return thrift_protocol_read_bool (protocol, &boolv, error);
      }
    case T_BYTE:
      {
        int8_t bytev;
        return thrift_protocol_read_byte (protocol, &bytev, error);
      }

    case T_I16:
      {
        int16_t i16;
        return thrift_protocol_read_i16 (protocol, &i16, error);
      }
    case T_I32:
      {
        int32_t i32;
        return thrift_protocol_read_i32 (protocol, &i32, error);
      }
    case T_I64:
      {
        int64_t i64;
        return thrift_protocol_read_i64 (protocol, &i64, error);
      }
    case T_U16:
      {
        u_int16_t u16;
        return thrift_protocol_read_u16 (protocol, &u16, error);
      }
    case T_U32:
      {
        u_int32_t u32;
        return thrift_protocol_read_u32 (protocol, &u32, error);
      }
    case T_U64:
      {
        u_int64_t u64;
        return thrift_protocol_read_u64 (protocol, &u64, error);
      }
    case T_DOUBLE:
      {
        double dub;
        return thrift_protocol_read_double (protocol, &dub, error);
      }
    case T_STRING:
    case T_XML:
      {
        void *data;
        u_int32_t len;
        u_int32_t ret = thrift_protocol_read_binary (protocol, &data, &len, error);
        os_free (data);
        return ret;
      }
    case T_STRUCT:
      {
        u_int32_t result = 0;
        char *name;
        int16_t fid;
        ThriftType ftype;
        result += thrift_protocol_read_struct_begin (protocol, &name, error);

        while (1)
        {
          result += thrift_protocol_read_field_begin (protocol, &name, &ftype,
                                                      &fid, error);
          if (ftype == T_STOP)
          {
            break;
          }
          result += thrift_protocol_skip (protocol, ftype, error);
          result += thrift_protocol_read_field_end (protocol, error);
        }
        result += thrift_protocol_read_struct_end (protocol, error);
        return result;
      }
    case T_MAP:
      {
        u_int32_t result = 0;
        ThriftType elem_type;
        u_int32_t i, size;
        result += thrift_protocol_read_set_begin (protocol, &elem_type, &size,
                                                  error);
        for (i = 0; i < size; i++)
        {
          result += thrift_protocol_skip (protocol, elem_type, error);
        }
        result += thrift_protocol_read_set_end (protocol, error);
        return result;
      }
    case T_LIST:
      {
        u_int32_t result = 0;
        ThriftType elem_type;
        u_int32_t i, size;
        result += thrift_protocol_read_list_begin (protocol, &elem_type, &size,
                                                   error);
        for (i = 0; i < size; i++)
        {
          result += thrift_protocol_skip (protocol, elem_type, error);
        }
        result += thrift_protocol_read_list_end (protocol, error);
        return result;
      }
    default:
      return 0;
  }
}
예제 #3
0
gboolean t_test_second_service_client_recv_secondtest_string (TTestSecondServiceIf * iface, gchar ** _return, GError ** error)
{

    gint32 rseqid;
    gchar * fname = NULL;
    ThriftMessageType mtype;
    ThriftProtocol * protocol = T_TEST_SECOND_SERVICE_CLIENT (iface)->input_protocol;

    if (thrift_protocol_read_message_begin (protocol, &fname, &mtype, &rseqid, error) < 0)
    {
        if (fname) g_free (fname);
        return FALSE;
    }

    if (mtype == T_EXCEPTION) {
        if (fname) g_free (fname);
        ThriftApplicationException *xception = g_object_new (THRIFT_TYPE_APPLICATION_EXCEPTION, NULL);
        thrift_struct_read (THRIFT_STRUCT (xception), protocol, NULL);
        thrift_protocol_read_message_end (protocol, NULL);
        thrift_transport_read_end (protocol->transport, NULL);
        g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, xception->type, "application error: %s", xception->message);
        g_object_unref (xception);
        return FALSE;
    } else if (mtype != T_REPLY) {
        if (fname) g_free (fname);
        thrift_protocol_skip (protocol, T_STRUCT, NULL);
        thrift_protocol_read_message_end (protocol, NULL);
        thrift_transport_read_end (protocol->transport, NULL);
        g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, THRIFT_APPLICATION_EXCEPTION_ERROR_INVALID_MESSAGE_TYPE, "invalid message type %d, expected T_REPLY", mtype);
        return FALSE;
    } else if (strncmp (fname, "secondtestString", 16) != 0) {
        thrift_protocol_skip (protocol, T_STRUCT, NULL);
        thrift_protocol_read_message_end (protocol, error);
        thrift_transport_read_end (protocol->transport, error);
        g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, THRIFT_APPLICATION_EXCEPTION_ERROR_WRONG_METHOD_NAME, "wrong method name %s, expected secondtestString", fname);
        if (fname) g_free (fname);
        return FALSE;
    }
    if (fname) g_free (fname);

    {
        gint32 ret;
        gint32 xfer = 0;
        gchar *name = NULL;
        ThriftType ftype;
        gint16 fid;
        guint32 len = 0;
        gpointer data = NULL;


        /* satisfy -Wall in case these aren't used */
        THRIFT_UNUSED_VAR (len);
        THRIFT_UNUSED_VAR (data);

        /* read the struct begin marker */
        if ((ret = thrift_protocol_read_struct_begin (protocol, &name, error)) < 0)
        {
            if (name) g_free (name);
            return 0;
        }
        xfer += ret;
        if (name) g_free (name);
        name = NULL;

        /* read the struct fields */
        while (1)
        {
            /* read the beginning of a field */
            if ((ret = thrift_protocol_read_field_begin (protocol, &name, &ftype, &fid, error)) < 0)
            {
                if (name) g_free (name);
                return 0;
            }
            xfer += ret;
            if (name) g_free (name);
            name = NULL;

            /* break if we get a STOP field */
            if (ftype == T_STOP)
            {
                break;
            }

            switch (fid)
            {
            case 0:
                if (ftype == T_STRING)
                {
                    if (*_return != NULL)
                    {
                        g_free(*_return);
                        *_return = NULL;
                    }

                    if ((ret = thrift_protocol_read_string (protocol, &*_return, error)) < 0)
                        return 0;
                    xfer += ret;
                } else {
                    if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
                        return 0;
                    xfer += ret;
                }
                break;
            default:
                if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
                    return 0;
                xfer += ret;
                break;
            }
            if ((ret = thrift_protocol_read_field_end (protocol, error)) < 0)
                return 0;
            xfer += ret;
        }

        if ((ret = thrift_protocol_read_struct_end (protocol, error)) < 0)
            return 0;
        xfer += ret;

    }

    if (thrift_protocol_read_message_end (protocol, error) < 0)
        return FALSE;

    if (!thrift_transport_read_end (protocol->transport, error))
        return FALSE;

    return TRUE;
}
예제 #4
0
/* reads a log_entry object */
gint32
log_entry_read (ThriftStruct *object, ThriftProtocol *protocol, GError **error)
{
  gint32 ret;
  gint32 xfer = 0;
  gchar *name = NULL;
  ThriftType ftype;
  gint16 fid;
  guint32 len = 0;
  gpointer data = NULL;
  LogEntry * this_object = LOG_ENTRY(object);

  /* satisfy -Wall in case these aren't used */
  THRIFT_UNUSED_VAR (len);
  THRIFT_UNUSED_VAR (data);
  THRIFT_UNUSED_VAR (this_object);

  /* read the struct begin marker */
  if ((ret = thrift_protocol_read_struct_begin (protocol, &name, error)) < 0)
  {
    if (name) g_free (name);
    return -1;
  }
  xfer += ret;
  if (name) g_free (name);
  name = NULL;

  /* read the struct fields */
  while (1)
  {
    /* read the beginning of a field */
    if ((ret = thrift_protocol_read_field_begin (protocol, &name, &ftype, &fid, error)) < 0)
    {
      if (name) g_free (name);
      return -1;
    }
    xfer += ret;
    if (name) g_free (name);
    name = NULL;

    /* break if we get a STOP field */
    if (ftype == T_STOP)
    {
      break;
    }

    switch (fid)
    {
      case 1:
        if (ftype == T_STRING)
        {
          if (this_object->category != NULL)
          {
            g_free(this_object->category);
            this_object->category = NULL;
          }

          if ((ret = thrift_protocol_read_string (protocol, &this_object->category, error)) < 0)
            return -1;
          xfer += ret;
          this_object->__isset_category = TRUE;
        } else {
          if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
            return -1;
          xfer += ret;
        }
        break;
      case 2:
        if (ftype == T_STRING)
        {
          if (this_object->message != NULL)
          {
            g_free(this_object->message);
            this_object->message = NULL;
          }

          if ((ret = thrift_protocol_read_string (protocol, &this_object->message, error)) < 0)
            return -1;
          xfer += ret;
          this_object->__isset_message = TRUE;
        } else {
          if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
            return -1;
          xfer += ret;
        }
        break;
      default:
        if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
          return -1;
        xfer += ret;
        break;
    }
    if ((ret = thrift_protocol_read_field_end (protocol, error)) < 0)
      return -1;
    xfer += ret;
  }

  if ((ret = thrift_protocol_read_struct_end (protocol, error)) < 0)
    return -1;
  xfer += ret;

  return xfer;
}
예제 #5
0
gboolean calculator_client_recv_calculate (CalculatorIf * iface, gint32* _return, InvalidOperation ** ouch, GError ** error)
{
  gint32 rseqid;
  gchar * fname = NULL;
  ThriftMessageType mtype;
  ThriftProtocol * protocol = SHARED_SERVICE_CLIENT (iface)->input_protocol;
  ThriftApplicationException *xception;

  if (thrift_protocol_read_message_begin (protocol, &fname, &mtype, &rseqid, error) < 0) {
    if (fname) g_free (fname);
    return FALSE;
  }

  if (mtype == T_EXCEPTION) {
    if (fname) g_free (fname);
    xception = g_object_new (THRIFT_TYPE_APPLICATION_EXCEPTION, NULL);
    thrift_struct_read (THRIFT_STRUCT (xception), protocol, NULL);
    thrift_protocol_read_message_end (protocol, NULL);
    thrift_transport_read_end (protocol->transport, NULL);
    g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR,xception->type, "application error: %s", xception->message);
    g_object_unref (xception);
    return FALSE;
  } else if (mtype != T_REPLY) {
    if (fname) g_free (fname);
    thrift_protocol_skip (protocol, T_STRUCT, NULL);
    thrift_protocol_read_message_end (protocol, NULL);
    thrift_transport_read_end (protocol->transport, NULL);
    g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, THRIFT_APPLICATION_EXCEPTION_ERROR_INVALID_MESSAGE_TYPE, "invalid message type %d, expected T_REPLY", mtype);
    return FALSE;
  } else if (strncmp (fname, "calculate", 9) != 0) {
    thrift_protocol_skip (protocol, T_STRUCT, NULL);
    thrift_protocol_read_message_end (protocol,error);
    thrift_transport_read_end (protocol->transport, error);
    g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, THRIFT_APPLICATION_EXCEPTION_ERROR_WRONG_METHOD_NAME, "wrong method name %s, expected calculate", fname);
    if (fname) g_free (fname);
    return FALSE;
  }
  if (fname) g_free (fname);

  {
    gint32 ret;
    gint32 xfer = 0;
    gchar *name = NULL;
    ThriftType ftype;
    gint16 fid;
    guint32 len = 0;
    gpointer data = NULL;
    

    /* satisfy -Wall in case these aren't used */
    THRIFT_UNUSED_VAR (len);
    THRIFT_UNUSED_VAR (data);

    /* read the struct begin marker */
    if ((ret = thrift_protocol_read_struct_begin (protocol, &name, error)) < 0)
    {
      if (name) g_free (name);
      return 0;
    }
    xfer += ret;
    if (name) g_free (name);
    name = NULL;

    /* read the struct fields */
    while (1)
    {
      /* read the beginning of a field */
      if ((ret = thrift_protocol_read_field_begin (protocol, &name, &ftype, &fid, error)) < 0)
      {
        if (name) g_free (name);
        return 0;
      }
      xfer += ret;
      if (name) g_free (name);
      name = NULL;

      /* break if we get a STOP field */
      if (ftype == T_STOP)
      {
        break;
      }

      switch (fid)
      {
        case 0:
          if (ftype == T_I32)
          {
            if ((ret = thrift_protocol_read_i32 (protocol, &*_return, error)) < 0)
              return 0;
            xfer += ret;
          } else {
            if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
              return 0;
            xfer += ret;
          }
          break;
        case 1:
          if (ftype == T_STRUCT)
          {
            /* This struct is an exception */
            if ( *ouch != NULL)
            {
              g_object_unref (*ouch);
            }
            *ouch = g_object_new (TYPE_INVALID_OPERATION, NULL);
            if ((ret = thrift_struct_read (THRIFT_STRUCT (*ouch), protocol, error)) < 0)
            {
              g_object_unref (*ouch);
              *ouch = NULL;
              return 0;
            }
            xfer += ret;
          } else {
            if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
              return 0;
            xfer += ret;
          }
          break;
        default:
          if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
            return 0;
          xfer += ret;
          break;
      }
      if ((ret = thrift_protocol_read_field_end (protocol, error)) < 0)
        return 0;
      xfer += ret;
    }

    if ((ret = thrift_protocol_read_struct_end (protocol, error)) < 0)
      return 0;
    xfer += ret;

  }

  if (thrift_protocol_read_message_end (protocol, error) < 0)
    return FALSE;

  if (!thrift_transport_read_end (protocol->transport, error))
    return FALSE;

  if (*ouch != NULL)
  {
      g_set_error (error, INVALID_OPERATION_ERROR, INVALID_OPERATION_ERROR_CODE, "InvalidOperation");
      return FALSE;
  }
  return TRUE;
}
예제 #6
0
gint32
thrift_protocol_skip (ThriftProtocol *protocol, ThriftType type, GError **error)
{
  switch (type)
  {
    case T_BOOL:
      {
        gboolean boolv;
        return thrift_protocol_read_bool (protocol, &boolv, error);
      }
    case T_BYTE:
      {
        gint8 bytev;
        return thrift_protocol_read_byte (protocol, &bytev, error);
      }

    case T_I16:
      {
        gint16 i16;
        return thrift_protocol_read_i16 (protocol, &i16, error);
      }
    case T_I32:
      {
        gint32 i32;
        return thrift_protocol_read_i32 (protocol, &i32, error);
      }
    case T_I64:
      {
        gint64 i64;
        return thrift_protocol_read_i64 (protocol, &i64, error);
      }
    case T_DOUBLE:
      {
        gdouble dub;
        return thrift_protocol_read_double (protocol, &dub, error);
      }
    case T_STRING:
      {
        gpointer data;
        guint32 len;
        gint32 ret = thrift_protocol_read_binary (protocol, &data, &len, error);
        g_free (data);
        return ret;
      }
    case T_STRUCT:
      {
        guint32 result = 0;
        gchar *name;
        gint16 fid;
        ThriftType ftype;
        result += thrift_protocol_read_struct_begin (protocol, &name, error);

        while (1)
        {
          result += thrift_protocol_read_field_begin (protocol, &name, &ftype,
                                                      &fid, error);
          if (ftype == T_STOP)
          {
            break;
          }
          result += thrift_protocol_skip (protocol, ftype, error);
          result += thrift_protocol_read_field_end (protocol, error);
        }
        result += thrift_protocol_read_struct_end (protocol, error);
        return result;
      }
    case T_SET:
      {
        guint32 result = 0;
        ThriftType elem_type;
        guint32 i, size;
        result += thrift_protocol_read_set_begin (protocol, &elem_type, &size,
                                                  error);
        for (i = 0; i < size; i++)
        {
          result += thrift_protocol_skip (protocol, elem_type, error);
        }
        result += thrift_protocol_read_set_end (protocol, error);
        return result;
      }
    case T_MAP:
      {
        guint32 result = 0;
        ThriftType elem_type;
        ThriftType key_type;
        guint32 i, size;
        result += thrift_protocol_read_map_begin (protocol, &key_type, &elem_type, &size,
                                                  error);
        for (i = 0; i < size; i++)
        {
          result += thrift_protocol_skip (protocol, key_type, error);
          result += thrift_protocol_skip (protocol, elem_type, error);
        }
        result += thrift_protocol_read_map_end (protocol, error);
        return result;
      }
    case T_LIST:
      {
        guint32 result = 0;
        ThriftType elem_type;
        guint32 i, size;
        result += thrift_protocol_read_list_begin (protocol, &elem_type, &size,
                                                   error);
        for (i = 0; i < size; i++)
        {
          result += thrift_protocol_skip (protocol, elem_type, error);
        }
        result += thrift_protocol_read_list_end (protocol, error);
        return result;
      }
    default:
      return 0;
  }
}