--- /dev/null
+/*
+ * 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.
+ */
+
+package org.apache.thrift.protocol;
+
+import org.apache.thrift.TException;
+
+/**
+ * Utility class with static methods for interacting with protocol data
+ * streams.
+ *
+ */
+public class TProtocolUtil {
+
+ /**
+ * The maximum recursive depth the skip() function will traverse before
+ * throwing a TException.
+ */
+ private static int maxSkipDepth = Integer.MAX_VALUE;
+
+ /**
+ * Specifies the maximum recursive depth that the skip function will
+ * traverse before throwing a TException. This is a global setting, so
+ * any call to skip in this JVM will enforce this value.
+ *
+ * @param depth the maximum recursive depth. A value of 2 would allow
+ * the skip function to skip a structure or collection with basic children,
+ * but it would not permit skipping a struct that had a field containing
+ * a child struct. A value of 1 would only allow skipping of simple
+ * types and empty structs/collections.
+ */
+ public static void setMaxSkipDepth(int depth) {
+ maxSkipDepth = depth;
+ }
+
+ /**
+ * Skips over the next data element from the provided input TProtocol object.
+ *
+ * @param prot the protocol object to read from
+ * @param type the next value will be interpreted as this TType value.
+ */
+ public static void skip(TProtocol prot, byte type)
+ throws TException {
+ skip(prot, type, maxSkipDepth);
+ }
+
+ /**
+ * Skips over the next data element from the provided input TProtocol object.
+ *
+ * @param prot the protocol object to read from
+ * @param type the next value will be interpreted as this TType value.
+ * @param maxDepth this function will only skip complex objects to this
+ * recursive depth, to prevent Java stack overflow.
+ */
+ public static void skip(TProtocol prot, byte type, int maxDepth)
+ throws TException {
+ if (maxDepth <= 0) {
+ throw new TException("Maximum skip depth exceeded");
+ }
+ switch (type) {
+ case TType.BOOL:
+ prot.readBool();
+ break;
+
+ case TType.BYTE:
+ prot.readByte();
+ break;
+
+ case TType.I16:
+ prot.readI16();
+ break;
+
+ case TType.I32:
+ prot.readI32();
+ break;
+
+ case TType.I64:
+ prot.readI64();
+ break;
+
+ case TType.DOUBLE:
+ prot.readDouble();
+ break;
+
+ case TType.STRING:
+ prot.readBinary();
+ break;
+
+ case TType.STRUCT:
+ prot.readStructBegin();
+ while (true) {
+ TField field = prot.readFieldBegin();
+ if (field.type == TType.STOP) {
+ break;
+ }
+ skip(prot, field.type, maxDepth - 1);
+ prot.readFieldEnd();
+ }
+ prot.readStructEnd();
+ break;
+
+ case TType.MAP:
+ TMap map = prot.readMapBegin();
+ for (int i = 0; i < map.size; i++) {
+ skip(prot, map.keyType, maxDepth - 1);
+ skip(prot, map.valueType, maxDepth - 1);
+ }
+ prot.readMapEnd();
+ break;
+
+ case TType.SET:
+ TSet set = prot.readSetBegin();
+ for (int i = 0; i < set.size; i++) {
+ skip(prot, set.elemType, maxDepth - 1);
+ }
+ prot.readSetEnd();
+ break;
+
+ case TType.LIST:
+ TList list = prot.readListBegin();
+ for (int i = 0; i < list.size; i++) {
+ skip(prot, list.elemType, maxDepth - 1);
+ }
+ prot.readListEnd();
+ break;
+
+ default:
+ throw new TProtocolException(TProtocolException.INVALID_DATA,
+ "Unrecognized type " + type);
+ }
+ }
+
+ /**
+ * Attempt to determine the protocol used to serialize some data.
+ *
+ * The guess is based on known specificities of supported protocols.
+ * In some cases, no guess can be done, in that case we return the
+ * fallback TProtocolFactory.
+ * To be certain to correctly detect the protocol, the first encoded
+ * field should have a field id < 256
+ *
+ * @param data The serialized data to guess the protocol for.
+ * @param fallback The TProtocol to return if no guess can be made.
+ * @return a Class implementing TProtocolFactory which can be used to create a deserializer.
+ */
+ public static TProtocolFactory guessProtocolFactory(byte[] data, TProtocolFactory fallback) {
+ //
+ // If the first and last bytes are opening/closing curly braces we guess the protocol as
+ // being TJSONProtocol.
+ // It could not be a TCompactBinary encoding for a field of type 0xb (Map)
+ // with delta id 7 as the last byte for TCompactBinary is always 0.
+ //
+
+ if ('{' == data[0] && '}' == data[data.length - 1]) {
+ return new TJSONProtocol.Factory();
+ }
+
+ //
+ // If the last byte is not 0, then it cannot be TCompactProtocol, it must be
+ // TBinaryProtocol.
+ //
+
+ if (data[data.length - 1] != 0) {
+ return new TBinaryProtocol.Factory();
+ }
+
+ //
+ // A first byte of value > 16 indicates TCompactProtocol was used, and the first byte
+ // encodes a delta field id (id <= 15) and a field type.
+ //
+
+ if (data[0] > 0x10) {
+ return new TCompactProtocol.Factory();
+ }
+
+ //
+ // If the second byte is 0 then it is a field id < 256 encoded by TBinaryProtocol.
+ // It cannot possibly be TCompactProtocol since a value of 0 would imply a field id
+ // of 0 as the zig zag varint encoding would end.
+ //
+
+ if (data.length > 1 && 0 == data[1]) {
+ return new TBinaryProtocol.Factory();
+ }
+
+ //
+ // If bit 7 of the first byte of the field id is set then we have two choices:
+ // 1. A field id > 63 was encoded with TCompactProtocol.
+ // 2. A field id > 0x7fff (32767) was encoded with TBinaryProtocol and the last byte of the
+ // serialized data is 0.
+ // Option 2 is impossible since field ids are short and thus limited to 32767.
+ //
+
+ if (data.length > 1 && (data[1] & 0x80) != 0) {
+ return new TCompactProtocol.Factory();
+ }
+
+ //
+ // The remaining case is either a field id <= 63 encoded as TCompactProtocol,
+ // one >= 256 encoded with TBinaryProtocol with a last byte at 0, or an empty structure.
+ // As we cannot really decide, we return the fallback protocol.
+ //
+ return fallback;
+ }
+}
projects / ceph.git / blobdiff