示例#1
0
  /**
   * Creates recordset page from Input object
   *
   * @param input Input object to use as source for data that has to be deserialized
   */
  @SuppressWarnings({"unchecked", "rawtypes"})
  public RecordSetPage(Input input) {
    Deserializer deserizalizer = new Deserializer();
    Map mapResult = deserizalizer.deserialize(input, Map.class);

    cursor = (Integer) mapResult.get("Cursor");
    data = (List<List<Object>>) mapResult.get("Page");
  }
示例#2
0
 // TODO need to fix
 public MetaData<?, ?> readMetaData(IoBuffer buffer) {
   MetaData<?, ?> retMeta = new MetaData<String, Object>();
   Input input = new Input(buffer);
   String metaType = Deserializer.deserialize(input, String.class);
   log.debug("Metadata type: {}", metaType);
   Map<String, ?> m = Deserializer.deserialize(input, Map.class);
   retMeta.putAll(m);
   return retMeta;
 }
 /**
  * Read remoting headers.
  *
  * @param in Input data as byte buffer
  * @return header map
  */
 @SuppressWarnings("unchecked")
 protected Map<String, Object> readHeaders(IoBuffer in) {
   int version = in.getUnsignedShort(); // skip the version
   int count = in.getUnsignedShort();
   log.debug("Read headers - version: {} count: {}", version, count);
   if (count == 0) {
     // No headers present
     return Collections.EMPTY_MAP;
   }
   Input input;
   if (version == 3) {
     input = new org.red5.io.amf3.Input(in);
   } else {
     input = new org.red5.io.amf.Input(in);
   }
   Map<String, Object> result = new HashMap<String, Object>();
   for (int i = 0; i < count; i++) {
     String name = input.getString();
     boolean required = in.get() == 0x01;
     int size = in.getInt();
     Object value = Deserializer.deserialize(input, Object.class);
     log.debug(
         "Header: {} Required: {} Size: {} Value: {}", new Object[] {name, required, size, value});
     result.put(name, value);
   }
   return result;
 }
  /**
   * Decode calls.
   *
   * @param in Input data as byte buffer
   * @return List of pending calls
   */
  protected List<RemotingCall> decodeCalls(IoBuffer in) {
    log.debug("Decode calls");
    // in.getInt();
    List<RemotingCall> calls = new LinkedList<RemotingCall>();
    org.red5.io.amf.Input input;
    int count = in.getUnsignedShort();
    log.debug("Calls: {}", count);
    int limit = in.limit();
    // Loop over all the body elements
    for (int i = 0; i < count; i++) {
      in.limit(limit);

      String serviceString = org.red5.io.amf.Input.getString(in);
      String clientCallback = org.red5.io.amf.Input.getString(in);
      log.debug("callback: {}", clientCallback);

      Object[] args = null;
      boolean isAMF3 = false;

      @SuppressWarnings("unused")
      int length = in.getInt();
      // Set the limit and deserialize
      // NOTE: disabled because the FP sends wrong values here
      /*
       * if (length != -1) in.limit(in.position()+length);
       */
      byte type = in.get();
      if (type == AMF.TYPE_ARRAY) {
        int elements = in.getInt();
        List<Object> values = new ArrayList<Object>();
        RefStorage refStorage = null;
        for (int j = 0; j < elements; j++) {
          byte amf3Check = in.get();
          in.position(in.position() - 1);
          isAMF3 = (amf3Check == AMF.TYPE_AMF3_OBJECT);
          if (isAMF3) {
            if (refStorage == null) {
              input = new org.red5.io.amf3.Input(in);
            } else {
              input = new org.red5.io.amf3.Input(in, refStorage);
            }
          } else {
            input = new org.red5.io.amf.Input(in);
          }
          // prepare remoting mode
          input.reset();
          // add deserialized object to the value list
          values.add(Deserializer.deserialize(input, Object.class));
          if (isAMF3) {
            refStorage = ((org.red5.io.amf3.Input) input).getRefStorage();
          }
        }
        args = values.toArray(new Object[values.size()]);
        if (log.isDebugEnabled()) {
          for (Object element : args) {
            log.debug("> " + element);
          }
        }

      } else if (type == AMF.TYPE_NULL) {
        log.debug("Got null amf type");

      } else if (type != AMF.TYPE_ARRAY) {
        throw new RuntimeException("AMF0 array type expected but found " + type);
      }

      String serviceName;
      String serviceMethod;
      int dotPos = serviceString.lastIndexOf('.');
      if (dotPos != -1) {
        serviceName = serviceString.substring(0, dotPos);
        serviceMethod = serviceString.substring(dotPos + 1, serviceString.length());
      } else {
        serviceName = "";
        serviceMethod = serviceString;
      }

      boolean isMessaging = false;
      if ("".equals(serviceName) && "null".equals(serviceMethod)) {
        // Use fixed service and method name for Flex messaging requests,
        // this probably will change in the future.
        serviceName = FlexMessagingService.SERVICE_NAME;
        serviceMethod = "handleRequest";
        isMessaging = true;
      }
      log.debug("Service: {} Method: {}", serviceName, serviceMethod);

      // Add the call to the list
      calls.add(
          new RemotingCall(serviceName, serviceMethod, args, clientCallback, isAMF3, isMessaging));
    }
    return calls;
  }
 @SuppressWarnings({"unchecked", "rawtypes", "serial"})
 public Object readObject(Deserializer deserializer, Type target) {
   int type = readAMF3Integer();
   log.debug("Type: {} and {} ref {}", new Object[] {type, (type & 1), (type >> 1)});
   if ((type & 1) == 0) {
     // Reference
     Object ref = getReference(type >> 1);
     if (ref != null) {
       return ref;
     }
     byte b = buf.get();
     if (b == 7) {
       log.debug("BEL: {}", b); // 7	
     } else {
       log.debug("Non-BEL byte: {}", b);
       log.debug("Extra byte: {}", buf.get());
     }
   }
   type >>= 1;
   List<String> attributes = null;
   String className;
   Object result = null;
   boolean inlineClass = (type & 1) == 1;
   log.debug("Class is in-line? {}", inlineClass);
   if (!inlineClass) {
     ClassReference info = refStorage.classReferences.get(type >> 1);
     className = info.className;
     attributes = info.attributeNames;
     type = info.type;
     if (attributes != null) {
       type |= attributes.size() << 2;
     }
   } else {
     type >>= 1;
     className = readString(String.class);
     log.debug("Type: {} classname: {}", type, className);
     // check for flex class alias since these wont be detected as externalizable
     if (classAliases.containsKey(className)) {
       // make sure type is externalizable
       type = 1;
     } else if (className.startsWith("flex")) {
       // set the attributes for messaging classes
       if (className.endsWith("CommandMessage")) {
         attributes =
             new LinkedList<String>() {
               {
                 add("timestamp");
                 add("headers");
                 add("operation");
                 add("body");
                 add("correlationId");
                 add("messageId");
                 add("timeToLive");
                 add("clientId");
                 add("destination");
               }
             };
       } else {
         log.debug("Attributes for {} were not set", className);
       }
     }
   }
   amf3_mode += 1;
   Object instance = newInstance(className);
   Map<String, Object> properties = null;
   PendingObject pending = new PendingObject();
   int tempRefId = storeReference(pending);
   log.debug("Object type: {}", (type & 0x03));
   switch (type & 0x03) {
     case AMF3.TYPE_OBJECT_PROPERTY:
       log.debug("Detected: Object property type");
       // Load object properties into map
       int count = type >> 2;
       log.debug("Count: {}", count);
       if (attributes == null) {
         attributes = new ArrayList<String>(count);
         for (int i = 0; i < count; i++) {
           attributes.add(readString(String.class));
         }
         refStorage.classReferences.add(
             new ClassReference(className, AMF3.TYPE_OBJECT_PROPERTY, attributes));
       }
       properties = new ObjectMap<String, Object>();
       for (int i = 0; i < count; i++) {
         String name = attributes.get(i);
         properties.put(name, deserializer.deserialize(this, getPropertyType(instance, name)));
       }
       break;
     case AMF3.TYPE_OBJECT_EXTERNALIZABLE:
       log.debug("Detected: Externalizable type");
       // Use custom class to deserialize the object
       if ("".equals(className)) {
         throw new RuntimeException("Classname is required to load an Externalizable object");
       }
       log.debug("Externalizable class: {}", className);
       if (className.length() == 3) {
         // check for special DS class aliases
         className = classAliases.get(className);
       }
       result = newInstance(className);
       if (result == null) {
         throw new RuntimeException(String.format("Could not instantiate class: %s", className));
       }
       if (!(result instanceof IExternalizable)) {
         throw new RuntimeException(
             String.format("Class must implement the IExternalizable interface: %s", className));
       }
       refStorage.classReferences.add(
           new ClassReference(className, AMF3.TYPE_OBJECT_EXTERNALIZABLE, null));
       storeReference(tempRefId, result);
       ((IExternalizable) result).readExternal(new DataInput(this, deserializer));
       break;
     case AMF3.TYPE_OBJECT_VALUE:
       log.debug("Detected: Object value type");
       // First, we should read typed (non-dynamic) properties ("sealed traits" according to AMF3
       // specification).
       // Property names are stored in the beginning, then values are stored.
       count = type >> 2;
       log.debug("Count: {}", count);
       if (attributes == null) {
         attributes = new ArrayList<String>(count);
         for (int i = 0; i < count; i++) {
           attributes.add(readString(String.class));
         }
         refStorage.classReferences.add(
             new ClassReference(className, AMF3.TYPE_OBJECT_VALUE, attributes));
       }
       // use the size of the attributes if we have no count
       if (count == 0 && attributes != null) {
         count = attributes.size();
         log.debug("Using class attribute size for property count: {}", count);
         // read the attributes from the stream and log if count doesnt match
         List<String> tmpAttributes = new ArrayList<String>(count);
         for (int i = 0; i < count; i++) {
           tmpAttributes.add(readString(String.class));
         }
         if (count != tmpAttributes.size()) {
           log.debug("Count and attributes length does not match!");
         }
         refStorage.classReferences.add(
             new ClassReference(className, AMF3.TYPE_OBJECT_VALUE, attributes));
       }
       properties = new ObjectMap<String, Object>();
       for (String key : attributes) {
         log.debug("Looking for property: {}", key);
         Object value = deserializer.deserialize(this, getPropertyType(instance, key));
         log.debug("Key: {} Value: {}", key, value);
         properties.put(key, value);
       }
       log.trace("Buffer - position: {} limit: {}", buf.position(), buf.limit());
       // no more items to read if we are at the end of the buffer
       if (buf.position() < buf.limit()) {
         // Now we should read dynamic properties which are stored as name-value pairs.
         // Dynamic properties are NOT remembered in 'classReferences'.
         String key = readString(String.class);
         while (!"".equals(key)) {
           Object value = deserializer.deserialize(this, getPropertyType(instance, key));
           properties.put(key, value);
           key = readString(String.class);
         }
       }
       break;
     default:
     case AMF3.TYPE_OBJECT_PROXY:
       log.debug("Detected: Object proxy type");
       if ("".equals(className)) {
         throw new RuntimeException("Classname is required to load an Externalizable object");
       }
       log.debug("Externalizable class: {}", className);
       result = newInstance(className);
       if (result == null) {
         throw new RuntimeException(String.format("Could not instantiate class: %s", className));
       }
       if (!(result instanceof IExternalizable)) {
         throw new RuntimeException(
             String.format("Class must implement the IExternalizable interface: %s", className));
       }
       refStorage.classReferences.add(new ClassReference(className, AMF3.TYPE_OBJECT_PROXY, null));
       storeReference(tempRefId, result);
       ((IExternalizable) result).readExternal(new DataInput(this, deserializer));
   }
   amf3_mode -= 1;
   if (result == null) {
     // Create result object based on classname
     if ("".equals(className)) {
       // "anonymous" object, load as Map
       // Resolve circular references
       for (Map.Entry<String, Object> entry : properties.entrySet()) {
         if (entry.getValue() == pending) {
           entry.setValue(properties);
         }
       }
       storeReference(tempRefId, properties);
       result = properties;
     } else if ("RecordSet".equals(className)) {
       // TODO: how are RecordSet objects encoded?
       throw new RuntimeException("Objects of type RecordSet not supported yet.");
     } else if ("RecordSetPage".equals(className)) {
       // TODO: how are RecordSetPage objects encoded?
       throw new RuntimeException("Objects of type RecordSetPage not supported yet.");
     } else {
       // Apply properties to object
       result = newInstance(className);
       if (result != null) {
         storeReference(tempRefId, result);
         Class resultClass = result.getClass();
         pending.resolveProperties(result);
         for (Map.Entry<String, Object> entry : properties.entrySet()) {
           // Resolve circular references
           final String key = entry.getKey();
           Object value = entry.getValue();
           if (value == pending) {
             value = result;
           }
           if (value instanceof PendingObject) {
             // Defer setting of value until real object is created
             ((PendingObject) value).addPendingProperty(result, resultClass, key);
             continue;
           }
           if (value != null) {
             try {
               final Field field = resultClass.getField(key);
               final Class fieldType = field.getType();
               if (!fieldType.isAssignableFrom(value.getClass())) {
                 value = ConversionUtils.convert(value, fieldType);
               } else if (value instanceof Enum) {
                 value = Enum.valueOf(fieldType, value.toString());
               }
               field.set(result, value);
             } catch (Exception e) {
               try {
                 BeanUtils.setProperty(result, key, value);
               } catch (IllegalAccessException ex) {
                 log.warn("Error mapping key: {} value: {}", key, value);
               } catch (InvocationTargetException ex) {
                 log.warn("Error mapping key: {} value: {}", key, value);
               }
             }
           } else {
             log.debug("Skipping null property: {}", key);
           }
         }
       } // else fall through
     }
   }
   return result;
 }
 /**
  * Returns an array
  *
  * @return int Length of array
  */
 @SuppressWarnings({"unchecked", "rawtypes"})
 public Object readArray(Deserializer deserializer, Type target) {
   int count = readAMF3Integer();
   log.debug("Count: {} and {} ref {}", new Object[] {count, (count & 1), (count >> 1)});
   if ((count & 1) == 0) {
     // Reference
     Object ref = getReference(count >> 1);
     if (ref != null) {
       return ref;
     }
   }
   count = (count >> 1);
   String key = readString(String.class);
   amf3_mode += 1;
   Object result;
   if (key.equals("")) {
     Class<?> nested = Object.class;
     Class<?> collection = Collection.class;
     Collection resultCollection;
     if (target instanceof ParameterizedType) {
       ParameterizedType t = (ParameterizedType) target;
       Type[] actualTypeArguments = t.getActualTypeArguments();
       if (actualTypeArguments.length == 1) {
         nested = (Class<?>) actualTypeArguments[0];
       }
       target = t.getRawType();
     }
     if (target instanceof Class) {
       collection = (Class) target;
     }
     if (collection.isArray()) {
       nested = ArrayUtils.getGenericType(collection.getComponentType());
       result = Array.newInstance(nested, count);
       storeReference(result);
       for (int i = 0; i < count; i++) {
         final Object value = deserializer.deserialize(this, nested);
         Array.set(result, i, value);
       }
     } else {
       if (SortedSet.class.isAssignableFrom(collection)) {
         resultCollection = new TreeSet();
       } else if (Set.class.isAssignableFrom(collection)) {
         resultCollection = new HashSet(count);
       } else {
         resultCollection = new ArrayList(count);
       }
       result = resultCollection;
       storeReference(result);
       for (int i = 0; i < count; i++) {
         final Object value = deserializer.deserialize(this, nested);
         resultCollection.add(value);
       }
     }
   } else {
     Class<?> k = Object.class;
     Class<?> v = Object.class;
     Class<?> collection = Collection.class;
     if (target instanceof ParameterizedType) {
       ParameterizedType t = (ParameterizedType) target;
       Type[] actualTypeArguments = t.getActualTypeArguments();
       if (actualTypeArguments.length == 2) {
         k = (Class<?>) actualTypeArguments[0];
         v = (Class<?>) actualTypeArguments[1];
       }
       target = t.getRawType();
     }
     if (target instanceof Class) {
       collection = (Class) target;
     }
     if (SortedMap.class.isAssignableFrom(collection)) {
       collection = TreeMap.class;
     } else {
       collection = HashMap.class;
     }
     Map resultMap;
     try {
       resultMap = (Map) collection.newInstance();
     } catch (Exception e) {
       resultMap = new HashMap(count);
     }
     // associative array
     storeReference(resultMap);
     while (!key.equals("")) {
       final Object value = deserializer.deserialize(this, v);
       resultMap.put(key, value);
       key = readString(k);
     }
     for (int i = 0; i < count; i++) {
       final Object value = deserializer.deserialize(this, v);
       resultMap.put(i, value);
     }
     result = resultMap;
   }
   amf3_mode -= 1;
   return result;
 }