tcalmant / python-javaobj / 108

pending completion

Build # 108

Build Type

Pull #38

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/tcalmant/python-javaobj/commit/<a class=hub.com/tcalmant/python-javaobj/commit/54ec57e4f1ab0a0e4e3c2b45b0c8ca7ade1bbeed">54ec57e4f<a href="https://github.com/tcalmant/python-javaobj/commit/54ec57e4f1ab0a0e4e3c2b45b0c8ca7ade1bbeed">">Merge </a><a class="double-link" href="https://github.com/tcalmant/python-javaobj/commit/<a class="double-link" href="https://github.com/tcalmant/python-javaobj/commit/574b076d8c533f454b0f6ab38e386a8ee009180e">574b076d8</a>">574b076d8</a><a href="https://github.com/tcalmant/python-javaobj/commit/54ec57e4f1ab0a0e4e3c2b45b0c8ca7ade1bbeed"> into cd94bff62">cd94bff62</a>

Pull Request Pull Request #38: Adds support for SC_WRITE_METHOD

Run Details

56 of 56 new or added lines in 4 files covered. (100.0%)

1565 of 1972 relevant lines covered (79.36%)

3.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.6

/javaobj/v2/beans.py

#!/usr/bin/env python3
"""
Definition of the beans used to represent the parsed objects

:authors: Thomas Calmant
:license: Apache License 2.0
:version: 0.4.0
:status: Alpha

..

    Copyright 2019 Thomas Calmant

    Licensed 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.
"""

from __future__ import absolute_import

from enum import IntEnum
from typing import Any, Dict, List, Optional, Set
import logging

from ..constants import ClassDescFlags, TypeCode
from ..modifiedutf8 import decode_modified_utf8, byte_to_int
from ..utils import UNICODE_TYPE

# ------------------------------------------------------------------------------

# Module version
__version_info__ = (0, 4, 0)
__version__ = ".".join(str(x) for x in __version_info__)

# Documentation strings format
__docformat__ = "restructuredtext en"

# ------------------------------------------------------------------------------


class ContentType(IntEnum):
    """
    Types of objects
    """

    INSTANCE = 0
    CLASS = 1
    ARRAY = 2
    STRING = 3
    ENUM = 4
    CLASSDESC = 5
    BLOCKDATA = 6
    EXCEPTIONSTATE = 7

class ClassDataType(IntEnum):
    """
    Class data types
    """

    NOWRCLASS = 0
    WRCLASS = 1
    EXTERNAL_CONTENTS = 2
    OBJECT_ANNOTATION = 3


class ClassDescType(IntEnum):
    """
    Types of class descriptions
    """

    NORMALCLASS = 0
    PROXYCLASS = 1


class FieldType(IntEnum):
    """
    Types of class fields
    """

    BYTE = TypeCode.TYPE_BYTE.value
    CHAR = TypeCode.TYPE_CHAR.value
    DOUBLE = TypeCode.TYPE_DOUBLE.value
    FLOAT = TypeCode.TYPE_FLOAT.value
    INTEGER = TypeCode.TYPE_INTEGER.value
    LONG = TypeCode.TYPE_LONG.value
    SHORT = TypeCode.TYPE_SHORT.value
    BOOLEAN = TypeCode.TYPE_BOOLEAN.value
    ARRAY = TypeCode.TYPE_ARRAY.value
    OBJECT = TypeCode.TYPE_OBJECT.value


class ParsedJavaContent(object):
    """
    Generic representation of data parsed from the stream
    """

    def __init__(self, content_type):
        # type: (ContentType) -> None
        self.type = content_type  # type: ContentType
        self.is_exception = False  # type: bool
        self.handle = 0  # type: int

    def __str__(self):
        return "[ParseJavaObject 0x{0:x} - {1}]".format(self.handle, self.type)

    __repr__ = __str__

    def dump(self, indent=0):
        # type: (int) -> str
        """
        Base implementation of a parsed object
        """
        return "\t" * indent + str(self)

    def validate(self):
        """
        Validity check on the object
        """
        pass


class ExceptionState(ParsedJavaContent):
    """
    Representation of a failed parsing
    """

    def __init__(self, exception_object, data):
        # type: (ParsedJavaContent, bytes) -> None
        super(ExceptionState, self).__init__(ContentType.EXCEPTIONSTATE)
        self.exception_object = exception_object
        self.stream_data = data
        self.handle = exception_object.handle

    def dump(self, indent=0):
        # type: (int) -> str
        """
        Returns a dump representation of the exception
        """
        return "\t" * indent + "[ExceptionState {0:x}]".format(self.handle)


class ExceptionRead(Exception):
    """
    Exception used to indicate that an exception object has been parsed
    """

    def __init__(self, content):
        # type: (ParsedJavaContent) -> None
        self.exception_object = content


class JavaString(ParsedJavaContent):
    """
    Represents a Java string
    """

    def __init__(self, handle, data):
        # type: (int, bytes) -> None
        super(JavaString, self).__init__(ContentType.STRING)
        self.handle = handle
        value, length = decode_modified_utf8(data)
        self.value = value  # type: str
        self.length = length  # type: int

    def __repr__(self):
        return repr(self.value)

    def __str__(self):
        return self.value

    def dump(self, indent=0):
        # type: (int) -> str
        """
        Returns a dump representation of the string
        """
        return "\t" * indent + "[String {0:x}: {1}]".format(
            self.handle, repr(self.value)
        )

    def __hash__(self):
        return hash(self.value)

    def __eq__(self, other):
        return self.value == other

class JavaField:
    """
    Represents a field in a Java class description
    """

    def __init__(self, field_type, name, class_name=None):
        # type: (FieldType, str, Optional[JavaString]) -> None
        self.type = field_type
        self.name = name
        self.class_name = class_name  # type: JavaString
        self.is_inner_class_reference = False

        if self.class_name:
            self.validate(self.class_name.value)

    def validate(self, java_type):
        # type: (str) -> None
        """
        Validates the type given as parameter
        """
        if self.type == FieldType.OBJECT:
            if not java_type:
                raise ValueError("Class name can't be empty")

            if java_type[0] != "L" or java_type[-1] != ";":
                raise ValueError(
                    "Invalid object field type: {0}".format(java_type)
                )


class JavaClassDesc(ParsedJavaContent):
    """
    Represents the description of a class
    """

    def __init__(self, class_desc_type):
        # type: (ClassDescType) -> None
        super(JavaClassDesc, self).__init__(ContentType.CLASSDESC)

        # Type of class description
        self.class_type = class_desc_type  # type: ClassDescType

        # Class name
        self.name = None  # type: Optional[str]

        # Serial version UID
        self.serial_version_uid = 0  # type: int

        # Description flags byte
        self.desc_flags = 0  # type: int

        # Fields in the class
        self.fields = []  # type: List[JavaField]

        # Inner classes
        self.inner_classes = []  # type: List[JavaClassDesc]

        # List of annotations objects
        self.annotations = []  # type: List[ParsedJavaContent]

        # The super class of this one, if any
        self.super_class = None  # type: Optional[JavaClassDesc]

        # Indicates if it is a super class
        self.is_super_class = False

        # List of the interfaces of the class
        self.interfaces = []  # type: List[str]

        # Set of enum constants
        self.enum_constants = set()  # type: Set[str]

        # Flag to indicate if this is an inner class
        self.is_inner_class = False  # type: bool

        # Flag to indicate if this is a local inner class
        self.is_local_inner_class = False  # type: bool

        # Flag to indicate if this is a static member class
        self.is_static_member_class = False  # type: bool

    def __str__(self):
        return "[classdesc 0x{0:x}: name {1}, uid {2}]".format(
            self.handle, self.name, self.serial_version_uid
        )

    __repr__ = __str__

    def dump(self, indent=0):
        # type: (int) -> str
        """
        Returns a dump representation of the exception
        """
        return "\t" * indent + "[classdesc 0x{0:x}: name {1}, uid {2}]".format(
            self.handle, self.name, self.serial_version_uid
        )

    @property
    def serialVersionUID(self):
        """
        Mimics the javaobj API
        """
        return self.serial_version_uid

    @property
    def flags(self):
        """
        Mimics the javaobj API
        """
        return self.desc_flags

    @property
    def fields_names(self):
        """
        Mimics the javaobj API
        """
        return [field.name for field in self.fields]

    @property
    def fields_types(self):
        """
        Mimics the javaobj API
        """
        return [field.type for field in self.fields]

    @property
    def data_type(self):
        if (ClassDescFlags.SC_SERIALIZABLE & self.desc_flags):
            return ClassDataType.WRCLASS if (ClassDescFlags.SC_WRITE_METHOD & self.desc_flags) else ClassDataType.NOWRCLASS
        elif (ClassDescFlags.SC_EXTERNALIZABLE & self.desc_flags):
            return ClassDataType.OBJECT_ANNOTATION if (ClassDescFlags.SC_WRITE_METHOD & self.desc_flags) else ClassDataType.EXTERNAL_CONTENTS
        
        raise ValueError("Unhandled Class Data Type")
        

    def is_array_class(self):
        # type: () -> bool
        """
        Determines if this is an array type
        """
        return self.name.startswith("[") if self.name else False

    def get_hierarchy(self, classes):
        # type: (List["JavaClassDesc"]) -> None
        """
        Generates a list of class descriptions in this class's hierarchy, in
        the order described by the Object Stream Serialization Protocol.
        This is the order in which fields are read from the stream.

        :param classes: A list to be filled in with the hierarchy
        """
        if self.super_class is not None:
            if self.super_class.class_type == ClassDescType.PROXYCLASS:
                logging.warning("Hit a proxy class in super class hierarchy")
            else:
                self.super_class.get_hierarchy(classes)

        classes.append(self)

    def validate(self):
        """
        Checks the validity of this class description
        """
        serial_or_extern = (
            ClassDescFlags.SC_SERIALIZABLE | ClassDescFlags.SC_EXTERNALIZABLE
        )
        if (self.desc_flags & serial_or_extern) == 0 and self.fields:
            raise ValueError(
                "Non-serializable, non-externalizable class has fields"
            )

        if self.desc_flags & serial_or_extern == serial_or_extern:
            raise ValueError("Class is both serializable and externalizable")

        if self.desc_flags & ClassDescFlags.SC_ENUM:
            if self.fields or self.interfaces:
                raise ValueError(
                    "Enums shouldn't implement interfaces "
                    "or have non-constant fields"
                )
        else:
            if self.enum_constants:
                raise ValueError(
                    "Non-enum classes shouldn't have enum constants"
                )


class JavaInstance(ParsedJavaContent):
    """
    Represents an instance of Java object
    """

    def __init__(self):
        super(JavaInstance, self).__init__(ContentType.INSTANCE)
        self.classdesc = None  # type: JavaClassDesc
        self.field_data = {}  # type: Dict[JavaClassDesc, Dict[JavaField, Any]]
        self.annotations = (
            {}
        )  # type: Dict[JavaClassDesc, List[ParsedJavaContent]]
        self.is_external_instance = False

    def __str__(self):
        return "[instance 0x{0:x}: type {1}]".format(
            self.handle, self.classdesc.name
        )

    __repr__ = __str__

    def dump(self, indent=0):
        # type: (int) -> str
        """
        Returns a dump representation of the exception
        """
        prefix = "\t" * indent
        sub_prefix = "\t" * (indent + 1)

        dump = [
            prefix
            + "[instance 0x{0:x}: {1:x} / {2}]".format(
                self.handle, self.classdesc.handle, self.classdesc.name
            )
        ]

        for cd, annotations in self.annotations.items():
            dump.append(
                "{0}{1} -- {2} annotations".format(
                    prefix, cd.name, len(annotations)
                )
            )
            for ann in annotations:
                dump.append(sub_prefix + repr(ann))

        for cd, fields in self.field_data.items():
            dump.append(
                "{0}{1} -- {2} fields".format(prefix, cd.name, len(fields))
            )
            for field, value in fields.items():
                if isinstance(value, ParsedJavaContent):
                    if self.handle != 0 and value.handle == self.handle:
                        value_str = "this"
                    else:
                        value_str = "\n" + value.dump(indent + 2)
                else:
                    value_str = repr(value)

                dump.append(
                    "{0}{1} {2}: {3}".format(
                        sub_prefix, field.type.name, field.name, value_str
                    )
                )

        dump.append(prefix + "[/instance 0x{0:x}]".format(self.handle))
        return "\n".join(dump)

    def __getattr__(self, name):
        """
        Returns the field with the given name
        """
        for cd_fields in self.field_data.values():
            for field, value in cd_fields.items():
                if field.name == name:
                    return value

        raise AttributeError(name)

    def get_class(self):
        """
        Returns the class of this instance
        """
        return self.classdesc

    def load_from_blockdata(self, parser, reader, indent=0):
        """
        Reads content stored in a block data.

        This method is called only if the class description has both the
        ``SC_EXTERNALIZABLE`` and ``SC_BLOCK_DATA`` flags set.

        The stream parsing will stop and fail if this method returns False.

        :param parser: The JavaStreamParser in use
        :param reader: The underlying data stream reader
        :param indent: Indentation to use in logs
        :return: True on success, False on error
        """
        return False

    def load_from_instance(self, indent=0):
        # type: (int) -> bool
        """
        Updates the content of this instance from its parsed fields and
        annotations

        :param indent: Indentation to use in logs
        :return: True on success, False on error (currently ignored)
        """
        return False


class JavaClass(ParsedJavaContent):
    """
    Represents a stored Java class
    """

    def __init__(self, handle, class_desc):
        # type: (int, JavaClassDesc) -> None
        super(JavaClass, self).__init__(ContentType.CLASS)
        self.handle = handle
        self.classdesc = class_desc

    def __str__(self):
        return "[class 0x{0:x}: {1}]".format(self.handle, self.classdesc)

    __repr__ = __str__

    @property
    def name(self):
        """
        Mimics the javaobj API
        """
        return self.classdesc.name


class JavaEnum(ParsedJavaContent):
    """
    Represents an enumeration value
    """

    def __init__(self, handle, class_desc, value):
        # type: (int, JavaClassDesc, JavaString) -> None
        super(JavaEnum, self).__init__(ContentType.ENUM)
        self.handle = handle
        self.classdesc = class_desc
        self.value = value

    def __str__(self):
        return "[Enum 0x{0:x}: {1}]".format(self.handle, self.value)

    __repr__ = __str__

    @property
    def constant(self):
        """
        Mimics the javaobj API
        """
        return self.value


class JavaArray(ParsedJavaContent, list):
    """
    Represents a Java array
    """

    def __init__(self, handle, class_desc, field_type, content):
        # type: (int, JavaClassDesc, FieldType, List[Any]) -> None
        list.__init__(self, content)
        ParsedJavaContent.__init__(self, ContentType.ARRAY)
        self.handle = handle
        self.classdesc = class_desc
        self.field_type = field_type
        self.data = content

    def __str__(self):
        return "[{0}]".format(", ".join(repr(x) for x in self))

    __repr__ = __str__

    def dump(self, indent=0):
        # type: (int) -> str
        """
        Returns a dump representation of the array
        """
        prefix = "\t" * indent
        sub_prefix = "\t" * (indent + 1)
        dump = [
            "{0}[array 0x{1:x}: {2} items - stored as {3}]".format(
                prefix, self.handle, len(self), type(self.data).__name__
            )
        ]
        for x in self:
            if isinstance(x, ParsedJavaContent):
                if self.handle != 0 and x.handle == self.handle:
                    dump.append("this,")
                else:
                    dump.append(x.dump(indent + 1) + ",")
            else:
                dump.append(sub_prefix + repr(x) + ",")
        dump.append(prefix + "[/array 0x{0:x}]".format(self.handle))
        return "\n".join(dump)

    @property
    def _data(self):
        """
        Mimics the javaobj API
        """
        return tuple(self)


class BlockData(ParsedJavaContent):
    """
    Represents a data block
    """

    def __init__(self, data):
        # type: (bytes) -> None
        super(BlockData, self).__init__(ContentType.BLOCKDATA)
        self.data = data

    def __str__(self):
        return "[blockdata 0x{0:x}: {1} bytes]".format(
            self.handle, len(self.data)
        )

    def __repr__(self):
        return repr(self.data)

    def __eq__(self, other):
        if isinstance(other, (str, UNICODE_TYPE)):
            other_data = tuple(byte_to_int(x) for x in other)
        elif isinstance(other, bytes):
            other_data = tuple(byte_to_int(x) for x in other)
        else:
            # Can't compare
            return False

        return other_data == tuple(byte_to_int(x) for x in self.data)

1	#!/usr/bin/env python3
2	"""	4✔
3	Definition of the beans used to represent the parsed objects
4
5	:authors: Thomas Calmant
6	:license: Apache License 2.0
7	:version: 0.4.0
8	:status: Alpha
9
10	..
11
12	Copyright 2019 Thomas Calmant
13
14	Licensed under the Apache License, Version 2.0 (the "License");
15	you may not use this file except in compliance with the License.
16	You may obtain a copy of the License at
17
18	http://www.apache.org/licenses/LICENSE-2.0
19
20	Unless required by applicable law or agreed to in writing, software
21	distributed under the License is distributed on an "AS IS" BASIS,
22	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
23	See the License for the specific language governing permissions and
24	limitations under the License.
25	"""
26
27	from __future__ import absolute_import	4✔
28
29	from enum import IntEnum	4✔
30	from typing import Any, Dict, List, Optional, Set	4✔
31	import logging	4✔
32
33	from ..constants import ClassDescFlags, TypeCode	4✔
34	from ..modifiedutf8 import decode_modified_utf8, byte_to_int	4✔
35	from ..utils import UNICODE_TYPE	4✔
36
37	# ------------------------------------------------------------------------------
38
39	# Module version
40	__version_info__ = (0, 4, 0)	4✔
41	__version__ = ".".join(str(x) for x in __version_info__)	4✔
42
43	# Documentation strings format
44	__docformat__ = "restructuredtext en"	4✔
45
46	# ------------------------------------------------------------------------------
47
48
49	class ContentType(IntEnum):	4✔
50	"""
51	Types of objects
52	"""
53
54	INSTANCE = 0	4✔
55	CLASS = 1	4✔
56	ARRAY = 2	4✔
57	STRING = 3	4✔
58	ENUM = 4	4✔
59	CLASSDESC = 5	4✔
60	BLOCKDATA = 6	4✔
61	EXCEPTIONSTATE = 7	4✔
62
63	class ClassDataType(IntEnum):	4✔
64	"""
65	Class data types
66	"""
67
68	NOWRCLASS = 0	4✔
69	WRCLASS = 1	4✔
70	EXTERNAL_CONTENTS = 2	4✔
71	OBJECT_ANNOTATION = 3	4✔
72
73
74	class ClassDescType(IntEnum):	4✔
75	"""
76	Types of class descriptions
77	"""
78
79	NORMALCLASS = 0	4✔
80	PROXYCLASS = 1	4✔
81
82
83	class FieldType(IntEnum):	4✔
84	"""
85	Types of class fields
86	"""
87
88	BYTE = TypeCode.TYPE_BYTE.value	4✔
89	CHAR = TypeCode.TYPE_CHAR.value	4✔
90	DOUBLE = TypeCode.TYPE_DOUBLE.value	4✔
91	FLOAT = TypeCode.TYPE_FLOAT.value	4✔
92	INTEGER = TypeCode.TYPE_INTEGER.value	4✔
93	LONG = TypeCode.TYPE_LONG.value	4✔
94	SHORT = TypeCode.TYPE_SHORT.value	4✔
95	BOOLEAN = TypeCode.TYPE_BOOLEAN.value	4✔
96	ARRAY = TypeCode.TYPE_ARRAY.value	4✔
97	OBJECT = TypeCode.TYPE_OBJECT.value	4✔
98
99
100	class ParsedJavaContent(object):	4✔
101	"""
102	Generic representation of data parsed from the stream
103	"""
104
105	def __init__(self, content_type):	4✔
106	# type: (ContentType) -> None
107	self.type = content_type # type: ContentType	4✔
108	self.is_exception = False # type: bool	4✔
109	self.handle = 0 # type: int	4✔
110
111	def __str__(self):	4✔
112	return "[ParseJavaObject 0x{0:x} - {1}]".format(self.handle, self.type)	×
113
114	__repr__ = __str__	4✔
115
116	def dump(self, indent=0):	4✔
117	# type: (int) -> str
118	"""
119	Base implementation of a parsed object
120	"""
121	return "\t" * indent + str(self)	×
122
123	def validate(self):	4✔
124	"""
125	Validity check on the object
126	"""
127	pass	4✔
128
129
130	class ExceptionState(ParsedJavaContent):	4✔
131	"""
132	Representation of a failed parsing
133	"""
134
135	def __init__(self, exception_object, data):	4✔
136	# type: (ParsedJavaContent, bytes) -> None
137	super(ExceptionState, self).__init__(ContentType.EXCEPTIONSTATE)	×
138	self.exception_object = exception_object	×
139	self.stream_data = data	×
140	self.handle = exception_object.handle	×
141
142	def dump(self, indent=0):	4✔
143	# type: (int) -> str
144	"""
145	Returns a dump representation of the exception
146	"""
147	return "\t" * indent + "[ExceptionState {0:x}]".format(self.handle)	×
148
149
150	class ExceptionRead(Exception):	4✔
151	"""
152	Exception used to indicate that an exception object has been parsed
153	"""
154
155	def __init__(self, content):	4✔
156	# type: (ParsedJavaContent) -> None
157	self.exception_object = content	×
158
159
160	class JavaString(ParsedJavaContent):	4✔
161	"""
162	Represents a Java string
163	"""
164
165	def __init__(self, handle, data):	4✔
166	# type: (int, bytes) -> None
167	super(JavaString, self).__init__(ContentType.STRING)	4✔
168	self.handle = handle	4✔
169	value, length = decode_modified_utf8(data)	4✔
170	self.value = value # type: str	4✔
171	self.length = length # type: int	4✔
172
173	def __repr__(self):	4✔
174	return repr(self.value)	4✔
175
176	def __str__(self):	4✔
177	return self.value	4✔
178
179	def dump(self, indent=0):	4✔
180	# type: (int) -> str
181	"""
182	Returns a dump representation of the string
183	"""
184	return "\t" * indent + "[String {0:x}: {1}]".format(	×
185	self.handle, repr(self.value)
186	)
187
188	def __hash__(self):	4✔
189	return hash(self.value)	4✔
190
191	def __eq__(self, other):	4✔
192	return self.value == other	4✔
193
194	class JavaField:	4✔
195	"""
196	Represents a field in a Java class description
197	"""
198
199	def __init__(self, field_type, name, class_name=None):	4✔
200	# type: (FieldType, str, Optional[JavaString]) -> None
201	self.type = field_type	4✔
202	self.name = name	4✔
203	self.class_name = class_name # type: JavaString	4✔
204	self.is_inner_class_reference = False	4✔
205
206	if self.class_name:	4✔
207	self.validate(self.class_name.value)	4✔
208
209	def validate(self, java_type):	4✔
210	# type: (str) -> None
211	"""
212	Validates the type given as parameter
213	"""
214	if self.type == FieldType.OBJECT:	4✔
215	if not java_type:	4✔
216	raise ValueError("Class name can't be empty")	×
217
218	if java_type[0] != "L" or java_type[-1] != ";":	4✔
219	raise ValueError(	×
220	"Invalid object field type: {0}".format(java_type)
221	)
222
223
224	class JavaClassDesc(ParsedJavaContent):	4✔
225	"""
226	Represents the description of a class
227	"""
228
229	def __init__(self, class_desc_type):	4✔
230	# type: (ClassDescType) -> None
231	super(JavaClassDesc, self).__init__(ContentType.CLASSDESC)	4✔
232
233	# Type of class description
234	self.class_type = class_desc_type # type: ClassDescType	4✔
235
236	# Class name
237	self.name = None # type: Optional[str]	4✔
238
239	# Serial version UID
240	self.serial_version_uid = 0 # type: int	4✔
241
242	# Description flags byte
243	self.desc_flags = 0 # type: int	4✔
244
245	# Fields in the class
246	self.fields = [] # type: List[JavaField]	4✔
247
248	# Inner classes
249	self.inner_classes = [] # type: List[JavaClassDesc]	4✔
250
251	# List of annotations objects
252	self.annotations = [] # type: List[ParsedJavaContent]	4✔
253
254	# The super class of this one, if any
255	self.super_class = None # type: Optional[JavaClassDesc]	4✔
256
257	# Indicates if it is a super class
258	self.is_super_class = False	4✔
259
260	# List of the interfaces of the class
261	self.interfaces = [] # type: List[str]	4✔
262
263	# Set of enum constants
264	self.enum_constants = set() # type: Set[str]	4✔
265
266	# Flag to indicate if this is an inner class
267	self.is_inner_class = False # type: bool	4✔
268
269	# Flag to indicate if this is a local inner class
270	self.is_local_inner_class = False # type: bool	4✔
271
272	# Flag to indicate if this is a static member class
273	self.is_static_member_class = False # type: bool	4✔
274
275	def __str__(self):	4✔
276	return "[classdesc 0x{0:x}: name {1}, uid {2}]".format(	4✔
277	self.handle, self.name, self.serial_version_uid
278	)
279
280	__repr__ = __str__	4✔
281
282	def dump(self, indent=0):	4✔
283	# type: (int) -> str
284	"""
285	Returns a dump representation of the exception
286	"""
287	return "\t" * indent + "[classdesc 0x{0:x}: name {1}, uid {2}]".format(	×
288	self.handle, self.name, self.serial_version_uid
289	)
290
291	@property	4✔
292	def serialVersionUID(self):
293	"""
294	Mimics the javaobj API
295	"""
296	return self.serial_version_uid	4✔
297
298	@property	4✔
299	def flags(self):
300	"""
301	Mimics the javaobj API
302	"""
303	return self.desc_flags	4✔
304
305	@property	4✔
306	def fields_names(self):
307	"""
308	Mimics the javaobj API
309	"""
310	return [field.name for field in self.fields]	4✔
311
312	@property	4✔
313	def fields_types(self):
314	"""
315	Mimics the javaobj API
316	"""
317	return [field.type for field in self.fields]	4✔
318
319	@property	4✔
320	def data_type(self):
321	if (ClassDescFlags.SC_SERIALIZABLE & self.desc_flags):	4✔
322	return ClassDataType.WRCLASS if (ClassDescFlags.SC_WRITE_METHOD & self.desc_flags) else ClassDataType.NOWRCLASS	4✔
323	elif (ClassDescFlags.SC_EXTERNALIZABLE & self.desc_flags):	4✔
324	return ClassDataType.OBJECT_ANNOTATION if (ClassDescFlags.SC_WRITE_METHOD & self.desc_flags) else ClassDataType.EXTERNAL_CONTENTS	4✔
325
326	raise ValueError("Unhandled Class Data Type")	×
327
328
329	def is_array_class(self):	4✔
330	# type: () -> bool
331	"""
332	Determines if this is an array type
333	"""
334	return self.name.startswith("[") if self.name else False	×
335
336	def get_hierarchy(self, classes):	4✔
337	# type: (List["JavaClassDesc"]) -> None
338	"""
339	Generates a list of class descriptions in this class's hierarchy, in
340	the order described by the Object Stream Serialization Protocol.
341	This is the order in which fields are read from the stream.
342
343	:param classes: A list to be filled in with the hierarchy
344	"""
345	if self.super_class is not None:	4✔
346	if self.super_class.class_type == ClassDescType.PROXYCLASS:	4✔
347	logging.warning("Hit a proxy class in super class hierarchy")	×
348	else:
349	self.super_class.get_hierarchy(classes)	4✔
350
351	classes.append(self)	4✔
352
353	def validate(self):	4✔
354	"""
355	Checks the validity of this class description
356	"""
357	serial_or_extern = (	4✔
358	ClassDescFlags.SC_SERIALIZABLE \| ClassDescFlags.SC_EXTERNALIZABLE
359	)
360	if (self.desc_flags & serial_or_extern) == 0 and self.fields:	4✔
361	raise ValueError(	×
362	"Non-serializable, non-externalizable class has fields"
363	)
364
365	if self.desc_flags & serial_or_extern == serial_or_extern:	4✔
366	raise ValueError("Class is both serializable and externalizable")	×
367
368	if self.desc_flags & ClassDescFlags.SC_ENUM:	4✔
369	if self.fields or self.interfaces:	4✔
370	raise ValueError(	×
371	"Enums shouldn't implement interfaces "
372	"or have non-constant fields"
373	)
374	else:
375	if self.enum_constants:	4✔
376	raise ValueError(	×
377	"Non-enum classes shouldn't have enum constants"
378	)
379
380
381	class JavaInstance(ParsedJavaContent):	4✔
382	"""
383	Represents an instance of Java object
384	"""
385
386	def __init__(self):	4✔
387	super(JavaInstance, self).__init__(ContentType.INSTANCE)	4✔
388	self.classdesc = None # type: JavaClassDesc	4✔
389	self.field_data = {} # type: Dict[JavaClassDesc, Dict[JavaField, Any]]	4✔
390	self.annotations = (	4✔
391	{}
392	) # type: Dict[JavaClassDesc, List[ParsedJavaContent]]
393	self.is_external_instance = False	4✔
394
395	def __str__(self):	4✔
396	return "[instance 0x{0:x}: type {1}]".format(	4✔
397	self.handle, self.classdesc.name
398	)
399
400	__repr__ = __str__	4✔
401
402	def dump(self, indent=0):	4✔
403	# type: (int) -> str
404	"""
405	Returns a dump representation of the exception
406	"""
407	prefix = "\t" * indent	×
408	sub_prefix = "\t" * (indent + 1)	×
409
410	dump = [	×
411	prefix
412	+ "[instance 0x{0:x}: {1:x} / {2}]".format(
413	self.handle, self.classdesc.handle, self.classdesc.name
414	)
415	]
416
417	for cd, annotations in self.annotations.items():	×
418	dump.append(	×
419	"{0}{1} -- {2} annotations".format(
420	prefix, cd.name, len(annotations)
421	)
422	)
423	for ann in annotations:	×
424	dump.append(sub_prefix + repr(ann))	×
425
426	for cd, fields in self.field_data.items():	×
427	dump.append(	×
428	"{0}{1} -- {2} fields".format(prefix, cd.name, len(fields))
429	)
430	for field, value in fields.items():	×
431	if isinstance(value, ParsedJavaContent):	×
432	if self.handle != 0 and value.handle == self.handle:	×
433	value_str = "this"	×
434	else:
435	value_str = "\n" + value.dump(indent + 2)	×
436	else:
437	value_str = repr(value)	×
438
439	dump.append(	×
440	"{0}{1} {2}: {3}".format(
441	sub_prefix, field.type.name, field.name, value_str
442	)
443	)
444
445	dump.append(prefix + "[/instance 0x{0:x}]".format(self.handle))	×
446	return "\n".join(dump)	×
447
448	def __getattr__(self, name):	4✔
449	"""
450	Returns the field with the given name
451	"""
452	for cd_fields in self.field_data.values():	4✔
453	for field, value in cd_fields.items():	4✔
454	if field.name == name:	4✔
455	return value	4✔
456
457	raise AttributeError(name)	×
458
459	def get_class(self):	4✔
460	"""
461	Returns the class of this instance
462	"""
463	return self.classdesc	4✔
464
465	def load_from_blockdata(self, parser, reader, indent=0):	4✔
466	"""
467	Reads content stored in a block data.
468
469	This method is called only if the class description has both the
470	``SC_EXTERNALIZABLE`` and ``SC_BLOCK_DATA`` flags set.
471
472	The stream parsing will stop and fail if this method returns False.
473
474	:param parser: The JavaStreamParser in use
475	:param reader: The underlying data stream reader
476	:param indent: Indentation to use in logs
477	:return: True on success, False on error
478	"""
479	return False	×
480
481	def load_from_instance(self, indent=0):	4✔
482	# type: (int) -> bool
483	"""
484	Updates the content of this instance from its parsed fields and
485	annotations
486
487	:param indent: Indentation to use in logs
488	:return: True on success, False on error (currently ignored)
489	"""
490	return False	4✔
491
492
493	class JavaClass(ParsedJavaContent):	4✔
494	"""
495	Represents a stored Java class
496	"""
497
498	def __init__(self, handle, class_desc):	4✔
499	# type: (int, JavaClassDesc) -> None
500	super(JavaClass, self).__init__(ContentType.CLASS)	4✔
501	self.handle = handle	4✔
502	self.classdesc = class_desc	4✔
503
504	def __str__(self):	4✔
505	return "[class 0x{0:x}: {1}]".format(self.handle, self.classdesc)	4✔
506
507	__repr__ = __str__	4✔
508
509	@property	4✔
510	def name(self):
511	"""
512	Mimics the javaobj API
513	"""
514	return self.classdesc.name	4✔
515
516
517	class JavaEnum(ParsedJavaContent):	4✔
518	"""
519	Represents an enumeration value
520	"""
521
522	def __init__(self, handle, class_desc, value):	4✔
523	# type: (int, JavaClassDesc, JavaString) -> None
524	super(JavaEnum, self).__init__(ContentType.ENUM)	4✔
525	self.handle = handle	4✔
526	self.classdesc = class_desc	4✔
527	self.value = value	4✔
528
529	def __str__(self):	4✔
530	return "[Enum 0x{0:x}: {1}]".format(self.handle, self.value)	4✔
531
532	__repr__ = __str__	4✔
533
534	@property	4✔
535	def constant(self):
536	"""
537	Mimics the javaobj API
538	"""
539	return self.value	4✔
540
541
542	class JavaArray(ParsedJavaContent, list):	4✔
543	"""
544	Represents a Java array
545	"""
546
547	def __init__(self, handle, class_desc, field_type, content):	4✔
548	# type: (int, JavaClassDesc, FieldType, List[Any]) -> None
549	list.__init__(self, content)	4✔
550	ParsedJavaContent.__init__(self, ContentType.ARRAY)	4✔
551	self.handle = handle	4✔
552	self.classdesc = class_desc	4✔
553	self.field_type = field_type	4✔
554	self.data = content	4✔
555
556	def __str__(self):	4✔
557	return "[{0}]".format(", ".join(repr(x) for x in self))	4✔
558
559	__repr__ = __str__	4✔
560
561	def dump(self, indent=0):	4✔
562	# type: (int) -> str
563	"""
564	Returns a dump representation of the array
565	"""
566	prefix = "\t" * indent	×
567	sub_prefix = "\t" * (indent + 1)	×
568	dump = [	×
569	"{0}[array 0x{1:x}: {2} items - stored as {3}]".format(
570	prefix, self.handle, len(self), type(self.data).__name__
571	)
572	]
573	for x in self:	×
574	if isinstance(x, ParsedJavaContent):	×
575	if self.handle != 0 and x.handle == self.handle:	×
576	dump.append("this,")	×
577	else:
578	dump.append(x.dump(indent + 1) + ",")	×
579	else:
580	dump.append(sub_prefix + repr(x) + ",")	×
581	dump.append(prefix + "[/array 0x{0:x}]".format(self.handle))	×
582	return "\n".join(dump)	×
583
584	@property	4✔
585	def _data(self):
586	"""
587	Mimics the javaobj API
588	"""
589	return tuple(self)	4✔
590
591
592	class BlockData(ParsedJavaContent):	4✔
593	"""
594	Represents a data block
595	"""
596
597	def __init__(self, data):	4✔
598	# type: (bytes) -> None
599	super(BlockData, self).__init__(ContentType.BLOCKDATA)	4✔
600	self.data = data	4✔
601
602	def __str__(self):	4✔
603	return "[blockdata 0x{0:x}: {1} bytes]".format(	4✔
604	self.handle, len(self.data)
605	)
606
607	def __repr__(self):	4✔
608	return repr(self.data)	4✔
609
610	def __eq__(self, other):	4✔
611	if isinstance(other, (str, UNICODE_TYPE)):	4✔
612	other_data = tuple(byte_to_int(x) for x in other)	1✔
613	elif isinstance(other, bytes):	3✔
614	other_data = tuple(byte_to_int(x) for x in other)	3✔
615	else:
616	# Can't compare
617	return False	×
618
619	return other_data == tuple(byte_to_int(x) for x in self.data)	4✔

tcalmant / python-javaobj / 108

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous