Upgraded JavaObjectMarshaller according to the original repository

Author: tcalmant

javaobj.py

@@ -1046,7 +1046,7 @@ def _oops_dump_state(self, ignore_remaining_data=False):
 
 class JavaObjectMarshaller(JavaObjectConstants):
     """
-    UNUSABLE: Serializes objects into Java serialization format
+    Serializes objects into Java serialization format
     """
     def __init__(self, stream=None):
         """
@@ -1090,9 +1090,21 @@ def writeObject(self, obj):
         :raise RuntimeError: Unsupported type
         """
         log_debug("Writing object of type {0}".format(type(obj).__name__))
-        if type(obj) is JavaObject:
+        if isinstance(obj, JavaArray):
+            # Deserialized Java array
+            self.write_array(obj)
+        elif isinstance(obj, JavaEnum):
+            # Deserialized Java Enum
+            self.write_enum(obj)
+        elif isinstance(obj, JavaObject):
             # Deserialized Java object
             self.write_object(obj)
+        elif isinstance(obj, JavaClass):
+            # Java class
+            self.write_class(obj)
+        elif obj is None:
+            # Null
+            self.write_null()
         elif type(obj) is str:
             # String value
             self.write_blockdata(obj)
@@ -1121,21 +1133,54 @@ def _writeString(self, string):
         self._writeStruct(">H", 2, (len(string),))
         self.object_stream.write(string)
 
+    def write_string(self, obj):
+        """
+        Writes a Java string with the TC_STRING type marker
+
+        :param obj: The string to print
+        """
+        self._writeStruct(">B", 1, (self.TC_STRING,))
+        self._writeString(obj)
+
+    def write_enum(self, obj):
+        """
+        Writes an Enum value
+
+        :param obj: A JavaEnum object
+        """
+        self._writeStruct(">B", 1, (self.TC_ENUM,))
+        self.write_classdesc(obj.get_class())
+        self.write_string(obj.constant)
+
     def write_blockdata(self, obj, parent=None):
         """
         Appends a block of data to the serialization stream
 
         :param obj: String form of the data block
         """
-        # TC_BLOCKDATA (unsigned byte)<size> (byte)[size]
-        self._writeStruct(">B", 1, (self.TC_BLOCKDATA,))
         if type(obj) is str:
             # Latin-1: keep bytes as is
             obj = to_bytes(obj, "latin-1")
-            self._writeStruct(">B", 1, (len(obj),))
-            self.object_stream.write(obj)
+
+        length = len(obj)
+        if length <= 256:
+            # Small block data
+            # TC_BLOCKDATA (unsigned byte)<size> (byte)[size]
+            self._writeStruct(">B", 1, (self.TC_BLOCKDATA,))
+            self._writeStruct(">B", 1, (length,))
         else:
-            log_error("Not a str blockdata: {0:r}".format(obj))
+            # Large block data
+            # TC_BLOCKDATALONG (unsigned int)<size> (byte)[size]
+            self._writeStruct(">B", 1, (self.TC_BLOCKDATALONG,))
+            self._writeStruct(">I", 1, (length,))
+
+        self.object_stream.write(obj)
+
+    def write_null(self):
+        """
+        Writes a "null" value
+        """
+        self._writeStruct(">B", 1, (self.TC_NULL,))
 
     def write_object(self, obj, parent=None):
         """
@@ -1152,7 +1197,161 @@ def write_object(self, obj, parent=None):
                 break
 
         self._writeStruct(">B", 1, (self.TC_OBJECT,))
+        cls = obj.get_class()
+        self.write_classdesc(cls)
+
+        all_names = []
+        all_types = []
+        tmpcls = cls
+        while tmpcls:
+            all_names.extend(tmpcls.fields_names)
+            all_types.extend(tmpcls.fields_types)
+            tmpcls = tmpcls.superclass
+        del tmpcls
+
+        for field_name, field_type in zip(all_names, all_types):
+            try:
+                self._write_value(field_type, getattr(obj, field_name))
+            except AttributeError as ex:
+                log_error("No attribute {0} for object {1}\nDir: {2}"
+                          .format(ex, repr(obj), dir(obj)))
+                raise
+        del all_names, all_types
+
+        if cls.flags & self.SC_SERIALIZABLE \
+                and cls.flags & self.SC_WRITE_METHOD \
+                or cls.flags & self.SC_EXTERNALIZABLE \
+                and cls.flags & self.SC_BLOCK_DATA:
+            for annotation in obj.annotations:
+                log_debug("Write annotation {0} for {1}"
+                          .format(repr(annotation), repr(obj)))
+                if annotation is None:
+                    self.write_null()
+                else:
+                    self.writeObject(annotation)
+            self._writeStruct('>B', 1, (self.TC_ENDBLOCKDATA,))
+
+    def write_class(self, obj, parent=None):
+        """
+        Writes a class to the stream
+
+        :param obj: A JavaClass object
+        :param parent:
+        """
+        self._writeStruct(">B", 1, (self.TC_CLASS,))
+        self.write_classdesc(obj)
+
+    def write_classdesc(self, obj, parent=None):
+        """
+        Writes a class description
+
+        :param obj: Class description to write
+        :param parent:
+        """
         self._writeStruct(">B", 1, (self.TC_CLASSDESC,))
+        self._writeString(obj.name)
+        self._writeStruct(">qB", 1, (obj.serialVersionUID, obj.flags))
+        self._writeStruct(">H", 1, (len(obj.fields_names),))
+
+        for field_name, field_type in zip(obj.fields_names, obj.fields_types):
+            self._writeStruct(
+                ">B", 1, (self._convert_type_to_char(field_type),))
+            self._writeString(field_name)
+            if field_type[0] in (self.TYPE_OBJECT, self.TYPE_ARRAY):
+                self.write_string(field_type)
+
+        self._writeStruct(">B", 1, (self.TC_ENDBLOCKDATA,))
+        if obj.superclass:
+            self.write_classdesc(obj.superclass)
+        else:
+            self.write_null()
+
+    def write_array(self, obj):
+        """
+        Writes a JavaArray
+
+        :param obj: A JavaArray object
+        """
+        self._writeStruct(">B", 1, (self.TC_ARRAY,))
+        self.write_classdesc(obj.get_class())
+        self._writeStruct(">i", 1, (len(obj),))
+
+        classdesc = obj.get_class()
+
+        type_char = classdesc.name[0]
+        assert type_char == self.TYPE_ARRAY
+        type_char = classdesc.name[1]
+
+        if type_char == self.TYPE_OBJECT:
+            for o in obj:
+                self.write_object(o)
+        elif type_char == self.TYPE_ARRAY:
+            for a in obj:
+                self.write_array(a)
+        else:
+            log_debug("Write array of type %s" % type_char)
+            for v in obj:
+                self._write_value(type_char, v)
+
+    def _write_value(self, field_type, value):
+        """
+        Writes an item of an array
+
+        :param field_type: Value type
+        :param value: The value itself
+        """
+        if len(field_type) > 1:
+            # We don't need details for arrays and objects
+            field_type = field_type[0]
+
+        if field_type == self.TYPE_BOOLEAN:
+            self._writeStruct(">B", 1, (1 if value else 0,))
+        elif field_type == self.TYPE_BYTE:
+            self._writeStruct(">B", 1, (value,))
+        elif field_type == self.TYPE_SHORT:
+            self._writeStruct(">h", 1, (value,))
+        elif field_type == self.TYPE_INTEGER:
+            self._writeStruct(">i", 1, (value,))
+        elif field_type == self.TYPE_LONG:
+            self._writeStruct(">q", 1, (value,))
+        elif field_type == self.TYPE_FLOAT:
+            self._writeStruct(">f", 1, (value,))
+        elif field_type == self.TYPE_DOUBLE:
+            self._writeStruct(">d", 1, (value,))
+        elif field_type == self.TYPE_OBJECT or field_type == self.TYPE_ARRAY:
+            if value is None:
+                self.write_null()
+            elif isinstance(value, JavaEnum):
+                self.write_enum(value)
+            elif isinstance(value, JavaObject):
+                self.write_object(value)
+            elif isinstance(value, str):
+                self.write_blockdata(value)
+            else:
+                raise RuntimeError("Unknown typecode: {0}".format(field_type))
+        else:
+            raise RuntimeError("Unknown typecode: {0}".format(field_type))
+
+    def _convert_type_to_char(self, type_char):
+        """
+        Converts the given type code to an int
+
+        :param type_char: A type code character
+        """
+        typecode = type_char
+        if type(type_char) is int:
+            typecode = chr(type_char)
+
+        if typecode in self.TYPECODES_LIST:
+            return ord(typecode)
+        elif len(typecode) > 1:
+            if typecode[0] == 'L':
+                return ord(self.TYPE_OBJECT)
+            elif typecode[0] == '[':
+                return ord(self.TYPE_ARRAY)
+
+        raise RuntimeError("Typecode {0} ({1}) isn't supported."
+                           .format(type_char, typecode))
 
 # ------------------------------------------------------------------------------