Estructura inicial funcional con documentación en el README.md de la FastAPI
This commit is contained in:
898
env/lib/python3.12/site-packages/smbprotocol/structure.py
vendored
Normal file
898
env/lib/python3.12/site-packages/smbprotocol/structure.py
vendored
Normal file
@@ -0,0 +1,898 @@
|
||||
# Copyright: (c) 2019, Jordan Borean (@jborean93) <jborean93@gmail.com>
|
||||
# MIT License (see LICENSE or https://opensource.org/licenses/MIT)
|
||||
|
||||
import copy
|
||||
import datetime
|
||||
import inspect
|
||||
import math
|
||||
import struct
|
||||
import textwrap
|
||||
import types
|
||||
import uuid
|
||||
import weakref
|
||||
from abc import ABCMeta, abstractmethod
|
||||
from binascii import hexlify
|
||||
|
||||
from smbprotocol._text import to_bytes, to_text
|
||||
|
||||
TAB = " " # Instead of displaying a tab on the print, use 4 spaces
|
||||
|
||||
|
||||
class InvalidFieldDefinition(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def _bytes_to_hex(bytes, pretty=False, hex_per_line=8):
|
||||
hex = to_text(hexlify(bytes))
|
||||
|
||||
if pretty:
|
||||
if hex_per_line == 0: # show hex on 1 line
|
||||
hex_list = [hex]
|
||||
else:
|
||||
idx = hex_per_line * 2
|
||||
hex_list = list(hex[i : i + idx] for i in range(0, len(hex), idx))
|
||||
|
||||
hexes = []
|
||||
for h in hex_list:
|
||||
hexes.append(" ".join(h[i : i + 2] for i in range(0, len(h), 2)).upper())
|
||||
hex = "\n".join(hexes)
|
||||
|
||||
return hex
|
||||
|
||||
|
||||
def _indent_lines(string, prefix):
|
||||
# Would use textwrap.indent for this but it is not available for Python 2
|
||||
def predicate(line):
|
||||
return line.strip()
|
||||
|
||||
lines = []
|
||||
for line in string.splitlines(True):
|
||||
lines.append(prefix + line if predicate(line) else line)
|
||||
return "".join(lines)
|
||||
|
||||
|
||||
class Structure:
|
||||
def __init__(self):
|
||||
# Now that self.fields is set, loop through it again and set the
|
||||
# metadata around the fields and set the value based on default.
|
||||
# This must be done outside of the OrderedDict definition as set_value
|
||||
# relies on the full structure (self) being available and error
|
||||
# messages use the field name to be helpful
|
||||
for name, field in self.fields.items():
|
||||
field.structure = weakref.proxy(self)
|
||||
field.name = name
|
||||
field.set_value(field.default)
|
||||
|
||||
def __str__(self):
|
||||
struct_name = self.__class__.__name__
|
||||
raw_hex = _bytes_to_hex(self.pack(), True, hex_per_line=0)
|
||||
field_strings = []
|
||||
|
||||
for name, field in self.fields.items():
|
||||
# the field header is slightly different for a StructureField
|
||||
# remove the leading space and put the value on the next line
|
||||
if isinstance(field, StructureField):
|
||||
field_string = f"{field.name} =\n{field}"
|
||||
else:
|
||||
field_string = f"{field.name} = {field}"
|
||||
|
||||
field_strings.append(_indent_lines(field_string, TAB))
|
||||
|
||||
field_strings.append("")
|
||||
field_strings.append(_indent_lines("Raw Hex:", TAB))
|
||||
hex_wrapper = textwrap.TextWrapper(
|
||||
width=33, # set to show 8 hex values per line, 33 for 8, 56 for 16
|
||||
initial_indent=TAB + TAB,
|
||||
subsequent_indent=TAB + TAB,
|
||||
)
|
||||
field_strings.append(hex_wrapper.fill(raw_hex))
|
||||
|
||||
struct_name = to_text(struct_name)
|
||||
field_names = "\n".join([to_text(s) for s in field_strings])
|
||||
string = f"{struct_name}:\n{field_names}"
|
||||
return string
|
||||
|
||||
def __setitem__(self, key, value):
|
||||
field = self._get_field(key)
|
||||
field.set_value(value)
|
||||
|
||||
def __getitem__(self, key):
|
||||
return self._get_field(key)
|
||||
|
||||
def __delitem__(self, key):
|
||||
self._get_field(key)
|
||||
del self.fields[key]
|
||||
|
||||
def __len__(self):
|
||||
length = 0
|
||||
for field in self.fields.values():
|
||||
length += len(field)
|
||||
return length
|
||||
|
||||
def pack(self):
|
||||
data = b""
|
||||
for field in self.fields.values():
|
||||
field_data = field.pack()
|
||||
data += field_data
|
||||
|
||||
return data
|
||||
|
||||
def unpack(self, data):
|
||||
mem = memoryview(data)
|
||||
for key, field in self.fields.items():
|
||||
mem = field.unpack(mem)
|
||||
return bytes(mem) # remaining data
|
||||
|
||||
def _get_field(self, key):
|
||||
field = self.fields.get(key, None)
|
||||
if field is None:
|
||||
raise ValueError(f"Structure does not contain field {key}")
|
||||
return field
|
||||
|
||||
|
||||
class Field(metaclass=ABCMeta):
|
||||
def __init__(self, little_endian=True, default=None, size=None):
|
||||
"""
|
||||
The base class of a Field object. This contains the framework that a
|
||||
field SHOULD implement in regards to packing and unpacking a value.
|
||||
There should be little need to call this particular object as it is
|
||||
designed to be a base class for *Type classes.
|
||||
|
||||
:param little_endian: When converting an int/uuid to bytes, the byte
|
||||
order to pack as, False means it will be big endian
|
||||
:param default: The default value of the field, this can be any
|
||||
supported value such as as well as a lambda function or None
|
||||
(default).
|
||||
:param size: The size of the field, this can be an int, lambda function
|
||||
or None (for variable length end field) unless overridden in Class
|
||||
definition.
|
||||
"""
|
||||
field_type = self.__class__.__name__
|
||||
self.little_endian = little_endian
|
||||
|
||||
if not (size is None or isinstance(size, int) or callable(size)):
|
||||
raise InvalidFieldDefinition(f"{field_type} size for field must be an int or None for a variable length")
|
||||
self.size = size
|
||||
self.default = default
|
||||
self.value = None
|
||||
|
||||
def __str__(self):
|
||||
return self._to_string()
|
||||
|
||||
def __len__(self):
|
||||
return self._get_packed_size()
|
||||
|
||||
@property
|
||||
def _endian_prefix(self):
|
||||
return "<" if self.little_endian else ">"
|
||||
|
||||
def pack(self):
|
||||
"""
|
||||
Packs the field value into a byte string so it can be sent to the
|
||||
server.
|
||||
|
||||
:param structure: The message structure class object
|
||||
:return: A byte string of the packed field's value
|
||||
"""
|
||||
value = self._get_calculated_value(self.value)
|
||||
packed_value = self._pack_value(value)
|
||||
size = self._get_calculated_size(self.size, packed_value)
|
||||
packed_value_len = len(packed_value)
|
||||
if packed_value_len != size:
|
||||
raise ValueError(
|
||||
f"Invalid packed data length for field {self.name} of {packed_value_len} "
|
||||
f"does not fit field size of {size}"
|
||||
)
|
||||
|
||||
return packed_value
|
||||
|
||||
def get_value(self):
|
||||
"""
|
||||
Returns the value set for the field, will run any lambda functions
|
||||
that is set under the value attribute and return the final value.
|
||||
|
||||
:return: The value attribute with lambda functions run if value is a
|
||||
lambda function
|
||||
"""
|
||||
return self._get_calculated_value(self.value)
|
||||
|
||||
def set_value(self, value):
|
||||
"""
|
||||
Parses, and sets the value attribute for the field.
|
||||
|
||||
:param value: The value to be parsed and set, the allowed input types
|
||||
vary depending on the Field used
|
||||
"""
|
||||
if isinstance(value, memoryview):
|
||||
value = bytes(value)
|
||||
parsed_value = self._parse_value(value)
|
||||
self.value = parsed_value
|
||||
|
||||
def unpack(self, data):
|
||||
"""
|
||||
Takes in a byte string and set's the field value based on field
|
||||
definition.
|
||||
|
||||
:param structure: The message structure class object
|
||||
:param data: The byte string of the data to unpack
|
||||
:return: The remaining data for subsequent fields
|
||||
"""
|
||||
size = self._get_calculated_size(self.size, data)
|
||||
self.set_value(data[0:size])
|
||||
return data[len(self) :]
|
||||
|
||||
@abstractmethod
|
||||
def _pack_value(self, value):
|
||||
"""
|
||||
Packs the value passed in according to the rules of the FieldType.
|
||||
|
||||
:param value: The value to be packed, this is derived by
|
||||
_get_calculated_value(self.value)
|
||||
:return: A byte string of the data once packed
|
||||
"""
|
||||
pass # pragma: no cover
|
||||
|
||||
@abstractmethod
|
||||
def _parse_value(self, value):
|
||||
"""
|
||||
Parses the value into the FieldType type, this also validates that
|
||||
the value is allowable by the FieldType.
|
||||
|
||||
:param value: The value to parse
|
||||
:return: The value that has been parsed/casted to the correct value
|
||||
"""
|
||||
pass # pragma: no cover
|
||||
|
||||
@abstractmethod
|
||||
def _get_packed_size(self):
|
||||
"""
|
||||
Get's the size of the data once it has been packed. Depending on the
|
||||
FieldType, this can either be pre-set or calculated when called.
|
||||
|
||||
:return: The size of the field once it is packed
|
||||
"""
|
||||
pass # pragma: no cover
|
||||
|
||||
@abstractmethod
|
||||
def _to_string(self):
|
||||
"""
|
||||
Creates a string which is a human readable representation of the value.
|
||||
The output is dependent on the field implementation.
|
||||
|
||||
:return: string of the field value
|
||||
"""
|
||||
# creates a string which is a friendly representation of the value
|
||||
pass # pragma: no cover
|
||||
|
||||
def _get_calculated_value(self, value):
|
||||
"""
|
||||
Get's the final value of the field and runs the lambda functions
|
||||
recursively until a final value is derived.
|
||||
|
||||
:param value: The value to calculate/expand
|
||||
:return: The final value
|
||||
"""
|
||||
if callable(value):
|
||||
expanded_value = value(self.structure)
|
||||
return self._get_calculated_value(expanded_value)
|
||||
else:
|
||||
# perform one final parsing of the value in case lambda value
|
||||
# returned a different type
|
||||
return self._parse_value(value)
|
||||
|
||||
def _get_calculated_size(self, size, data):
|
||||
"""
|
||||
Get's the final size of the field and runs the lambda functions
|
||||
recursively until a final size is derived. If size is None then it
|
||||
will just return the length of the data as it is assumed it is the
|
||||
final field (None should only be set on size for the final field).
|
||||
|
||||
:param size: The size to calculate/expand
|
||||
:param data: The data that the size is being calculated for
|
||||
:return: The final size
|
||||
"""
|
||||
# if the size is derived from a lambda function, run it now; otherwise
|
||||
# return the value we passed in or the length of the data if the size
|
||||
# is None (last field value)
|
||||
if size is None:
|
||||
return len(data)
|
||||
elif callable(size):
|
||||
expanded_size = size(self.structure)
|
||||
return self._get_calculated_size(expanded_size, data)
|
||||
else:
|
||||
return size
|
||||
|
||||
def _get_struct_format(self, size, unsigned=True):
|
||||
"""
|
||||
Get's the format specified for use in struct. This is only designed
|
||||
for 1, 2, 4, or 8 byte values and will throw an exception if it is
|
||||
anything else.
|
||||
|
||||
:param size: The size as an int
|
||||
:return: The struct format specifier for the size specified
|
||||
"""
|
||||
if callable(size):
|
||||
size = size(self.structure)
|
||||
|
||||
struct_format = {1: "B", 2: "H", 4: "L", 8: "Q"}
|
||||
if size not in struct_format.keys():
|
||||
raise InvalidFieldDefinition(f"Cannot struct format of size {size}")
|
||||
format_char = struct_format[size]
|
||||
if not unsigned:
|
||||
format_char = format_char.lower()
|
||||
|
||||
return format_char
|
||||
|
||||
|
||||
class IntField(Field):
|
||||
def __init__(self, size, unsigned=True, **kwargs):
|
||||
"""
|
||||
Used to store an int value for a field. The size for these values MUST
|
||||
be 1, 2, 4, or 8 and if another size is required use the BytesField
|
||||
instead and store the values as bytes.
|
||||
|
||||
:param size: The size of the integer when packed
|
||||
:param kwargs: Any other kwarg to be sent to Field()
|
||||
"""
|
||||
if size not in [1, 2, 4, 8]:
|
||||
raise InvalidFieldDefinition(f"IntField size must have a value of 1, 2, 4, or 8 not {size}")
|
||||
self.unsigned = unsigned
|
||||
super().__init__(size=size, **kwargs)
|
||||
|
||||
def _pack_value(self, value):
|
||||
struct_string = self._endian_prefix + self._get_struct_format(self.size, self.unsigned)
|
||||
packed_int = struct.pack(struct_string, value)
|
||||
return packed_int
|
||||
|
||||
def _parse_value(self, value):
|
||||
if value is None:
|
||||
int_value = 0
|
||||
elif callable(value):
|
||||
int_value = value
|
||||
elif isinstance(value, bytes):
|
||||
struct_string = self._endian_prefix + self._get_struct_format(self.size, self.unsigned)
|
||||
int_value = struct.unpack(struct_string, value)[0]
|
||||
elif isinstance(value, int):
|
||||
int_value = value
|
||||
else:
|
||||
raise TypeError(f"Cannot parse value for field {self.name} of type {type(value).__name__} to an int")
|
||||
return int_value
|
||||
|
||||
def _get_packed_size(self):
|
||||
return self.size
|
||||
|
||||
def _to_string(self):
|
||||
return str(self._get_calculated_value(self.value))
|
||||
|
||||
|
||||
class BytesField(Field):
|
||||
"""
|
||||
Used to store a raw bytes value as a field. Is the most universal and can
|
||||
convert from most objects to a bytes string. Use this is the field can
|
||||
contain multiple values and parsing will be done outside of the class.
|
||||
"""
|
||||
|
||||
def _pack_value(self, value):
|
||||
return value
|
||||
|
||||
def _parse_value(self, value):
|
||||
if value is None:
|
||||
bytes_value = b""
|
||||
elif callable(value):
|
||||
bytes_value = value
|
||||
elif isinstance(value, int):
|
||||
struct_string = self._endian_prefix + self._get_struct_format(self.size)
|
||||
bytes_value = struct.pack(struct_string, value)
|
||||
elif isinstance(value, Structure):
|
||||
bytes_value = value.pack()
|
||||
elif isinstance(value, bytes):
|
||||
bytes_value = value
|
||||
else:
|
||||
raise TypeError(f"Cannot parse value for field {self.name} of type {type(value).__name__} to a byte string")
|
||||
return bytes_value
|
||||
|
||||
def _get_packed_size(self):
|
||||
bytes_value = self._get_calculated_value(self.value)
|
||||
return len(bytes_value)
|
||||
|
||||
def _to_string(self):
|
||||
bytes_value = self._get_calculated_value(self.value)
|
||||
return _bytes_to_hex(bytes_value, pretty=True, hex_per_line=0)
|
||||
|
||||
|
||||
class ListField(Field):
|
||||
def __init__(self, list_count=None, list_type=BytesField(), unpack_func=None, **kwargs):
|
||||
"""
|
||||
Used to store a list of values that are the same time, the list can
|
||||
contain both fixed length values or variable length values but the
|
||||
former is easier to use as it does not require lambda functions to
|
||||
unpack the values. If the list values are different types, then the
|
||||
BytesField list_type should be used and the data will automatically
|
||||
will be converted to a bytes object. If appending a value to the list,
|
||||
ensure the value it added as an actual *Field() object and not just
|
||||
the raw value.
|
||||
|
||||
:param list_count: The number of entries in the list, the value can be
|
||||
an int, lambda function or None (for variable length). The lambda
|
||||
function is only evaluated in the pack and unpack methods. This
|
||||
must be set if unpack_func is not set so it can unpack the data
|
||||
receved from the server.
|
||||
:param list_type: The *Field() definition for each list entry, defaults
|
||||
to a variable length BytesField. If unpack_func is not set, the
|
||||
size attribute must be set.
|
||||
:param unpack_func: A lambda function used during the unpack method to
|
||||
unpack the data received from the server to a list. It takes in the
|
||||
(structure, data) arguments which is the structure of the whole
|
||||
packet and the remaining data left to be unpacked. This MUST be
|
||||
used when the list contains variable length values.
|
||||
:param kwargs: Any other kwarg to be sent to Field()
|
||||
"""
|
||||
if list_count is not None and not (isinstance(list_count, int) or callable(list_count)):
|
||||
raise InvalidFieldDefinition(
|
||||
"ListField list_count must be an int, lambda, or None for a variable list length"
|
||||
)
|
||||
self.list_count = list_count
|
||||
|
||||
if not isinstance(list_type, Field):
|
||||
raise InvalidFieldDefinition("ListField list_type must be a Field definition")
|
||||
self.list_type = list_type
|
||||
|
||||
if unpack_func is not None and not callable(unpack_func):
|
||||
raise InvalidFieldDefinition("ListField unpack_func must be a lambda function or None")
|
||||
elif unpack_func is None and (list_count is None or list_type.size is None):
|
||||
raise InvalidFieldDefinition(
|
||||
"ListField must either define "
|
||||
"unpack_func as a lambda or set "
|
||||
"list_count and list_size with a "
|
||||
"size"
|
||||
)
|
||||
self.unpack_func = unpack_func
|
||||
|
||||
super().__init__(**kwargs)
|
||||
|
||||
def __getitem__(self, item):
|
||||
# TODO: Make this more efficient
|
||||
return self.get_value()[item]
|
||||
|
||||
def get_value(self):
|
||||
# Override default get_value() so we return a list with the actual
|
||||
# value, not the Field definition
|
||||
list_value = []
|
||||
if callable(self.value):
|
||||
value = self._get_calculated_value(self.value)
|
||||
else:
|
||||
value = self.value
|
||||
|
||||
for entry in value:
|
||||
list_value.append(entry.get_value())
|
||||
return list_value
|
||||
|
||||
def _pack_value(self, value):
|
||||
data = b""
|
||||
for value in list(value):
|
||||
data += value.pack()
|
||||
return data
|
||||
|
||||
def _parse_value(self, value):
|
||||
if value is None:
|
||||
list_value = []
|
||||
elif callable(value):
|
||||
return value
|
||||
elif isinstance(value, bytes) and callable(self.unpack_func):
|
||||
# use the lambda function to parse the bytes to a list
|
||||
list_value = self.unpack_func(self.structure, value)
|
||||
elif isinstance(value, bytes):
|
||||
# we have a fixed length array with a specified count
|
||||
list_value = self._create_list_from_bytes(self.list_count, self.list_type, value)
|
||||
elif isinstance(value, list):
|
||||
# manually parse each list entry to the field type specified
|
||||
list_value = value
|
||||
else:
|
||||
raise TypeError(f"Cannot parse value for field {self.name} of type {type(value).__name__} to a list")
|
||||
list_value = [self._parse_sub_value(v) for v in list_value]
|
||||
return list_value
|
||||
|
||||
def _parse_sub_value(self, value):
|
||||
if isinstance(value, Field):
|
||||
new_field = value
|
||||
elif isinstance(value, Structure):
|
||||
new_field = StructureField(
|
||||
size=len(value),
|
||||
structure_type=type(value),
|
||||
default=value,
|
||||
)
|
||||
new_field.name = f"{self.name} list entry"
|
||||
new_field.structure = value
|
||||
new_field.set_value(new_field.default)
|
||||
else:
|
||||
new_field = copy.deepcopy(self.list_type)
|
||||
new_field.name = f"{self.name} list entry"
|
||||
new_field.set_value(value)
|
||||
return new_field
|
||||
|
||||
def _get_packed_size(self):
|
||||
list_value = self._get_calculated_value(self.value)
|
||||
size = 0
|
||||
for field in list(list_value):
|
||||
size += len(field)
|
||||
return size
|
||||
|
||||
def _to_string(self):
|
||||
list_value = self._get_calculated_value(self.value)
|
||||
list_string = [_indent_lines(str(v), TAB) for v in list(list_value)]
|
||||
if len(list_string) == 0:
|
||||
string = "[]"
|
||||
else:
|
||||
list_str = ",\n".join(list_string)
|
||||
string = f"[\n{list_str}\n]"
|
||||
return string
|
||||
|
||||
def _create_list_from_bytes(self, list_count, list_type, value):
|
||||
# calculate the list_count and rerun method if a lambda
|
||||
if callable(list_count):
|
||||
list_count = list_count(self.structure)
|
||||
return self._create_list_from_bytes(list_count, list_type, value)
|
||||
|
||||
list_value = []
|
||||
for idx in range(0, list_count):
|
||||
new_field = copy.deepcopy(list_type)
|
||||
value = new_field.unpack(value)
|
||||
list_value.append(new_field)
|
||||
return list_value
|
||||
|
||||
|
||||
class StructureField(Field):
|
||||
def __init__(self, structure_type, **kwargs):
|
||||
"""
|
||||
Used to store a message packet Structure object as a field. Can store
|
||||
both an actual Structure value or a byte string.
|
||||
|
||||
:param structure_type: The message structure type, e.g.
|
||||
SMB2NegotiateRequest. Used to marshal a byte string to a structure
|
||||
object when unpacking or setting a value
|
||||
:param kwargs: Any other kwarg to be sent to Field()
|
||||
"""
|
||||
self.structure_type = structure_type
|
||||
super().__init__(**kwargs)
|
||||
|
||||
def __setitem__(self, key, value):
|
||||
field = self._get_field(key)
|
||||
field.set_value(value)
|
||||
|
||||
def __getitem__(self, key):
|
||||
return self._get_field(key)
|
||||
|
||||
def set_structure_type(self, structure_type):
|
||||
# Set's the structure type and convert a byte string to the actual
|
||||
# structure specified
|
||||
self.structure_type = structure_type
|
||||
self.set_value(self.value)
|
||||
|
||||
def _pack_value(self, value):
|
||||
# Can either be a Structure or just plain bytes, just pack the
|
||||
# structure if needed
|
||||
if isinstance(value, Structure):
|
||||
value = value.pack()
|
||||
return value
|
||||
|
||||
def _parse_value(self, value):
|
||||
if value is None:
|
||||
structure_value = b""
|
||||
elif callable(value):
|
||||
structure_value = value
|
||||
elif isinstance(value, bytes):
|
||||
structure_value = value
|
||||
elif isinstance(value, Structure):
|
||||
structure_value = value
|
||||
else:
|
||||
raise TypeError(f"Cannot parse value for field {self.name} of type {type(value).__name__} to a structure")
|
||||
|
||||
if isinstance(structure_value, bytes) and self.structure_type and structure_value != b"":
|
||||
if callable(self.structure_type) and not inspect.isclass(self.structure_type):
|
||||
structure_type = self.structure_type(self.structure)
|
||||
else:
|
||||
structure_type = self.structure_type
|
||||
structure = structure_type()
|
||||
structure.unpack(structure_value)
|
||||
structure_value = structure
|
||||
return structure_value
|
||||
|
||||
def _get_packed_size(self):
|
||||
structure_value = self._get_calculated_value(self.value)
|
||||
return len(structure_value)
|
||||
|
||||
def _to_string(self):
|
||||
structure_value = self._get_calculated_value(self.value)
|
||||
return str(structure_value)
|
||||
|
||||
def _get_field(self, key):
|
||||
structure_value = self._get_calculated_value(self.value)
|
||||
if isinstance(structure_value, bytes):
|
||||
raise ValueError(f"Cannot get field {key} when structure is defined as a byte string")
|
||||
field = structure_value._get_field(key)
|
||||
return field
|
||||
|
||||
|
||||
class DateTimeField(Field):
|
||||
EPOCH_FILETIME = 116444736000000000 # epoch as a MS FILETIME int
|
||||
|
||||
def __init__(self, size=None, **kwargs):
|
||||
"""
|
||||
[MS-DTYP] 0.0 2017-09-15
|
||||
|
||||
2.3.3 FILETIME
|
||||
The FILETIME structure is a 64-it value that represents the number of
|
||||
100 nanoseconds intervals that have elapsed since January 1, 1601 UTC.
|
||||
This is used to convert the FILETIME int value to a native Python
|
||||
datetime object.
|
||||
|
||||
While the format FILETIME is used when communicating with the server,
|
||||
this type allows Python code to interact with datetime objects natively
|
||||
with all the conversions handled at pack/unpack time.
|
||||
|
||||
:param size: Must be set to None or 8, this is so we can check/override
|
||||
:param kwargs: Any other kwarg to be sent to Field()
|
||||
"""
|
||||
if not (size is None or size == 8):
|
||||
raise InvalidFieldDefinition(f"DateTimeField type must have a size of 8 not {size}")
|
||||
super().__init__(size=8, **kwargs)
|
||||
|
||||
def _pack_value(self, value):
|
||||
utc_tz = datetime.timezone.utc
|
||||
utc_dt = value.replace(tzinfo=value.tzinfo if value.tzinfo else utc_tz)
|
||||
td = utc_dt.astimezone(utc_tz) - datetime.datetime(1970, 1, 1, 0, 0, 0, tzinfo=utc_tz)
|
||||
epoch_time_ms = td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6
|
||||
ns100 = self.EPOCH_FILETIME + (epoch_time_ms * 10)
|
||||
|
||||
struct_string = self._endian_prefix + self._get_struct_format(8)
|
||||
bytes_value = struct.pack(struct_string, ns100)
|
||||
|
||||
return bytes_value
|
||||
|
||||
def _parse_value(self, value):
|
||||
if value is None:
|
||||
datetime_value = datetime.datetime.today()
|
||||
elif callable(value):
|
||||
datetime_value = value
|
||||
elif isinstance(value, bytes):
|
||||
struct_string = self._endian_prefix + self._get_struct_format(8)
|
||||
int_value = struct.unpack(struct_string, value)[0]
|
||||
return self._parse_value(int_value) # just parse the value again
|
||||
elif isinstance(value, int):
|
||||
time_microseconds = (value - self.EPOCH_FILETIME) // 10
|
||||
try:
|
||||
datetime_value = datetime.datetime(
|
||||
year=1970,
|
||||
month=1,
|
||||
day=1,
|
||||
tzinfo=datetime.timezone.utc,
|
||||
) + datetime.timedelta(microseconds=time_microseconds)
|
||||
except OverflowError:
|
||||
# This is unfortunately but 9999 is the max value a datetime can be so we just default to that
|
||||
datetime_value = datetime.datetime.max
|
||||
|
||||
elif isinstance(value, datetime.datetime):
|
||||
datetime_value = value
|
||||
else:
|
||||
raise TypeError(f"Cannot parse value for field {self.name} of type {type(value).__name__} to a datetime")
|
||||
return datetime_value
|
||||
|
||||
def _get_packed_size(self):
|
||||
return self.size
|
||||
|
||||
def _to_string(self):
|
||||
datetime_value = self._get_calculated_value(self.value)
|
||||
return datetime_value.isoformat(" ")
|
||||
|
||||
|
||||
class UuidField(Field):
|
||||
def __init__(self, size=None, **kwargs):
|
||||
"""
|
||||
Used to store a UUID (GUID) as a Python UUID object.
|
||||
|
||||
:param size: Must be set to None or 16, this is so we can
|
||||
check/override
|
||||
:param kwargs: Any other kwarg to be sent to Field()
|
||||
"""
|
||||
if not (size is None or size == 16):
|
||||
raise InvalidFieldDefinition(f"UuidField type must have a size of 16 not {size}")
|
||||
super().__init__(size=16, **kwargs)
|
||||
|
||||
def _pack_value(self, value):
|
||||
if self.little_endian:
|
||||
return value.bytes
|
||||
else:
|
||||
return value.bytes_le
|
||||
|
||||
def _parse_value(self, value):
|
||||
if value is None:
|
||||
uuid_value = uuid.UUID(bytes=b"\x00" * 16)
|
||||
elif isinstance(value, bytes) and self.little_endian:
|
||||
uuid_value = uuid.UUID(bytes=value)
|
||||
elif isinstance(value, bytes) and not self.little_endian:
|
||||
uuid_value = uuid.UUID(bytes_le=value)
|
||||
elif isinstance(value, int):
|
||||
uuid_value = uuid.UUID(int=value)
|
||||
elif isinstance(value, uuid.UUID):
|
||||
uuid_value = value
|
||||
elif callable(value):
|
||||
uuid_value = value
|
||||
else:
|
||||
raise TypeError(f"Cannot parse value for field {self.name} of type {type(value).__name__} to a uuid")
|
||||
return uuid_value
|
||||
|
||||
def _get_packed_size(self):
|
||||
return self.size
|
||||
|
||||
def _to_string(self):
|
||||
uuid_value = self._get_calculated_value(self.value)
|
||||
return str(uuid_value)
|
||||
|
||||
|
||||
class EnumField(IntField):
|
||||
def __init__(self, enum_type, enum_strict=True, **kwargs):
|
||||
self.enum_type = enum_type
|
||||
self.enum_strict = enum_strict
|
||||
super().__init__(**kwargs)
|
||||
|
||||
def _parse_value(self, value):
|
||||
int_value = super()._parse_value(value)
|
||||
valid = False
|
||||
for flag_value in vars(self.enum_type).values():
|
||||
if int_value == flag_value:
|
||||
valid = True
|
||||
break
|
||||
|
||||
if not valid and int_value != 0 and self.enum_strict:
|
||||
raise ValueError(f"Enum value {int_value} does not exist in enum type {self.enum_type}")
|
||||
return int_value
|
||||
|
||||
def _to_string(self):
|
||||
enum_name = None
|
||||
value = self._get_calculated_value(self.value)
|
||||
for enum, enum_value in vars(self.enum_type).items():
|
||||
if value == enum_value:
|
||||
enum_name = enum
|
||||
break
|
||||
if enum_name is None:
|
||||
return f"({value}) UNKNOWN_ENUM"
|
||||
else:
|
||||
return f"({value}) {enum_name}"
|
||||
|
||||
|
||||
class FlagField(IntField):
|
||||
def __init__(self, flag_type, flag_strict=True, **kwargs):
|
||||
self.flag_type = flag_type
|
||||
self.flag_strict = flag_strict
|
||||
super().__init__(**kwargs)
|
||||
|
||||
def set_flag(self, flag):
|
||||
valid = False
|
||||
for value in vars(self.flag_type).values():
|
||||
if flag == value:
|
||||
valid = True
|
||||
break
|
||||
|
||||
if not valid and self.flag_strict:
|
||||
raise ValueError(f"Flag value does not exist in flag type {self.flag_type}")
|
||||
self.set_value(self.value | flag)
|
||||
|
||||
def has_flag(self, flag):
|
||||
return self.value & flag == flag
|
||||
|
||||
def _parse_value(self, value):
|
||||
int_value = super()._parse_value(value)
|
||||
current_val = int_value
|
||||
for value in vars(self.flag_type).values():
|
||||
if isinstance(value, int):
|
||||
current_val &= ~value
|
||||
if current_val != 0 and self.flag_strict:
|
||||
raise ValueError(f"Invalid flag for field {self.name} value set {current_val}")
|
||||
|
||||
return int_value
|
||||
|
||||
def _to_string(self):
|
||||
field_value = self._get_calculated_value(self.value)
|
||||
if field_value == 0:
|
||||
return "0"
|
||||
flags = []
|
||||
for flag, value in vars(self.flag_type).items():
|
||||
# ignore and dunder __foo__ attributes.
|
||||
if not flag.startswith("__") and isinstance(value, int) and self.has_flag(value):
|
||||
flags.append(flag)
|
||||
flags.sort()
|
||||
return f"({field_value}) " + (", ".join(flags))
|
||||
|
||||
|
||||
class BoolField(Field):
|
||||
def __init__(self, size=1, **kwargs):
|
||||
"""
|
||||
Used to store a boolean value in 1 byte. b"\x00" is False while b"\x01"
|
||||
is True.
|
||||
|
||||
:param kwargs: Any other kwargs to be sent to Field()
|
||||
"""
|
||||
if size != 1:
|
||||
raise InvalidFieldDefinition(f"BoolField size must have a value of 1, not {size}")
|
||||
super().__init__(size=size, **kwargs)
|
||||
|
||||
def _pack_value(self, value):
|
||||
return b"\x01" if value else b"\x00"
|
||||
|
||||
def _parse_value(self, value):
|
||||
if value is None:
|
||||
bool_value = False
|
||||
elif isinstance(value, bool):
|
||||
bool_value = value
|
||||
elif isinstance(value, bytes):
|
||||
bool_value = value == b"\x01"
|
||||
elif callable(value):
|
||||
bool_value = value
|
||||
else:
|
||||
raise TypeError(f"Cannot parse value for field {self.name} of type {type(value).__name__} to a bool")
|
||||
return bool_value
|
||||
|
||||
def _get_packed_size(self):
|
||||
return 1
|
||||
|
||||
def _to_string(self):
|
||||
return str(self._get_calculated_value(self.value))
|
||||
|
||||
|
||||
class TextField(BytesField):
|
||||
def __init__(self, encoding="utf-16-le", null_terminated=False, **kwargs):
|
||||
self.encoding = encoding
|
||||
self.null_terminated = null_terminated
|
||||
super().__init__(**kwargs)
|
||||
|
||||
def _pack_value(self, value):
|
||||
if self.null_terminated:
|
||||
value += "\x00"
|
||||
return to_bytes(value, encoding=self.encoding)
|
||||
|
||||
def _parse_value(self, value):
|
||||
if value is None:
|
||||
text_value = ""
|
||||
elif isinstance(value, bytes):
|
||||
text_value = to_text(value, encoding=self.encoding)
|
||||
elif isinstance(value, str):
|
||||
text_value = value
|
||||
elif callable(value):
|
||||
text_value = value
|
||||
else:
|
||||
raise TypeError(f"Cannot parse value for field {self.name} of type {type(value).__name__} to a text string")
|
||||
|
||||
return text_value
|
||||
|
||||
def _get_packed_size(self):
|
||||
text_value = self._get_calculated_value(self.value)
|
||||
size = len(to_bytes(text_value, encoding=self.encoding))
|
||||
if self.null_terminated:
|
||||
char_len = len("\x00".encode(self.encoding))
|
||||
size += char_len
|
||||
return size
|
||||
|
||||
def _to_string(self):
|
||||
return self.value
|
||||
|
||||
def unpack(self, data):
|
||||
null_byte = "\x00".encode(self.encoding)
|
||||
|
||||
if self.null_terminated and self.size is None:
|
||||
# If the size wasn't specified and the string contains a null terminator, cut off the bytes there.
|
||||
null_index = bytes(data).find(null_byte)
|
||||
if null_index != -1:
|
||||
# In the case of UTF-16 we might be the index in the middle of a char, make sure we round up and get
|
||||
# the boundary of each char.
|
||||
actual_index = int(math.ceil(null_index / len(null_byte)) * len(null_byte))
|
||||
|
||||
self.set_value(data[0:actual_index])
|
||||
return data[actual_index + len(null_byte) :]
|
||||
|
||||
size = self._get_calculated_size(self.size, data)
|
||||
raw_value = data[0:size]
|
||||
if self.null_terminated and bytes(raw_value).endswith(null_byte):
|
||||
raw_value = raw_value[: len(null_byte) * -1]
|
||||
|
||||
self.set_value(raw_value)
|
||||
return data[size:]
|
||||
Reference in New Issue
Block a user