440 lines
15 KiB
Python
440 lines
15 KiB
Python
"""
|
|
Copyright 2009, Linden Research, Inc.
|
|
See NOTICE.md for previous contributors
|
|
Copyright 2021, Salad Dais
|
|
All Rights Reserved.
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 3 of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with this program; if not, write to the Free Software Foundation,
|
|
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import copy
|
|
import enum
|
|
import importlib
|
|
import itertools
|
|
import logging
|
|
import os
|
|
import uuid
|
|
from typing import *
|
|
|
|
from hippolyzer.lib.base.datatypes import *
|
|
import hippolyzer.lib.base.serialization as se
|
|
import hippolyzer.lib.base.templates as templates
|
|
from hippolyzer.lib.base.datatypes import Pretty
|
|
from hippolyzer.lib.base.message.msgtypes import PacketFlags
|
|
from hippolyzer.lib.base.network.transport import Direction, ADDR_TUPLE
|
|
|
|
BLOCK_DICT = Dict[str, "MsgBlockList"]
|
|
VAR_TYPE = Union[TupleCoord, bytes, str, float, int, Tuple, UUID]
|
|
|
|
_TEMPLATES_MTIME = os.stat(templates.__file__).st_mtime
|
|
|
|
|
|
def maybe_reload_templates():
|
|
# Templates may be modified at runtime during development, check
|
|
# if they've changed since startup and reload if they have.
|
|
global _TEMPLATES_MTIME
|
|
templates_mtime = os.stat(templates.__file__).st_mtime
|
|
|
|
if _TEMPLATES_MTIME is None or _TEMPLATES_MTIME < templates_mtime:
|
|
print("Reloading templates")
|
|
try:
|
|
importlib.reload(templates) # type: ignore
|
|
_TEMPLATES_MTIME = templates_mtime
|
|
except:
|
|
logging.exception("Failed to reload templates!")
|
|
|
|
|
|
class Block:
|
|
"""
|
|
base representation of a block
|
|
Block expects a name, and kwargs for variables (var_name = value)
|
|
"""
|
|
__slots__ = ('name', 'size', 'vars', 'message_name', '_ser_cache', 'fill_missing',)
|
|
PARENT_MESSAGE_NAME: ClassVar[Optional[str]] = None
|
|
|
|
def __init__(self, name, /, *, fill_missing=False, **kwargs):
|
|
self.name = name
|
|
self.size = 0
|
|
self.message_name: Optional[str] = self.PARENT_MESSAGE_NAME
|
|
self.vars: Dict[str, VAR_TYPE] = {}
|
|
self._ser_cache: Dict[str, Any] = {}
|
|
self.fill_missing = fill_missing
|
|
for var_name, val in kwargs.items():
|
|
self[var_name] = val
|
|
|
|
def get(self, var_name, default: Optional[VAR_TYPE] = None) -> Optional[VAR_TYPE]:
|
|
return self.vars.get(var_name, default)
|
|
|
|
def __contains__(self, item):
|
|
return item in self.vars
|
|
|
|
def __getitem__(self, name):
|
|
return self.vars[name]
|
|
|
|
def __setitem__(self, key, value):
|
|
if isinstance(value, Pretty):
|
|
return self.serialize_var(key, value.value)
|
|
|
|
# These don't pickle well since they're likely to get hot-reloaded
|
|
if isinstance(value, (enum.IntEnum, enum.IntFlag)):
|
|
value = int(value)
|
|
|
|
self.vars[key] = value
|
|
# Invalidate the serialization cache if we manually changed the value
|
|
if key in self._ser_cache:
|
|
self._ser_cache.pop(key)
|
|
|
|
def get_serializer(self, var_name) -> se.BaseSubfieldSerializer:
|
|
serializer_key = (self.message_name, self.name, var_name)
|
|
serializer = se.SUBFIELD_SERIALIZERS.get(serializer_key)
|
|
if not serializer:
|
|
raise KeyError(f"No serializer for {serializer_key!r}")
|
|
return serializer
|
|
|
|
def deserialize_var(self, var_name, make_copy=True):
|
|
"""
|
|
Deserialize a var, using a cached version if available
|
|
|
|
Does a deepcopy() of the value from the cache by default, so
|
|
callers don't accidentally mutate the cached version. Allows
|
|
opting out as otherwise deepcopy() can dominate runtime if
|
|
you don't expect mutations.
|
|
"""
|
|
if var_name in self._ser_cache:
|
|
val = self._ser_cache[var_name]
|
|
return copy.deepcopy(val) if make_copy else val
|
|
serializer = self.get_serializer(var_name)
|
|
deser = serializer.deserialize(self, self[var_name], pod=False)
|
|
self._ser_cache[var_name] = deser
|
|
return copy.deepcopy(deser) if make_copy else deser
|
|
|
|
def serialize_var(self, var_name, val):
|
|
serializer = self.get_serializer(var_name)
|
|
serialized = serializer.serialize(self, val)
|
|
self[var_name] = serialized
|
|
self._ser_cache[var_name] = val
|
|
|
|
def invalidate_caches(self):
|
|
self._ser_cache.clear()
|
|
|
|
def items(self):
|
|
return self.vars.items()
|
|
|
|
def finalize(self):
|
|
# Stupid hack around the fact that blocks don't know how to
|
|
# invoke field-specific serializers until they're added to a message.
|
|
# Can do `Block("FooBlock", Baz_={"someserializedval": 1})` to set
|
|
# "Baz" to a serialized val without having to first construct a message.
|
|
for name in tuple(self.vars.keys()):
|
|
if not name.endswith("_"):
|
|
continue
|
|
val = self.vars.pop(name)
|
|
self.serialize_var(name.rstrip("_"), val)
|
|
|
|
def repr(self, pretty=False):
|
|
block_vars = {}
|
|
if pretty:
|
|
if not self.message_name:
|
|
raise ValueError("Can't give pretty representation of block outside a message")
|
|
for key in tuple(self.vars.keys()):
|
|
try:
|
|
self.get_serializer(key)
|
|
except KeyError:
|
|
block_vars[key] = repr(self.vars[key])
|
|
continue
|
|
# We have a serializer, include the pretty output in the repr,
|
|
# using the _ suffix so the builder knows it needs to be serialized.
|
|
block_vars[f"{key}_"] = repr(self.deserialize_var(key))
|
|
else:
|
|
block_vars = self.vars
|
|
|
|
kws = ", ".join((f"{k}={v if pretty else repr(v)}" for k, v in block_vars.items()))
|
|
if kws:
|
|
kws = ", " + kws
|
|
return f"{self.__class__.__name__}({self.name!r}{kws})"
|
|
|
|
def __repr__(self):
|
|
return self.repr()
|
|
|
|
|
|
class MsgBlockList(List["Block"]):
|
|
__slots__ = ()
|
|
|
|
def __getitem__(self, item) -> Union["Block", VAR_TYPE]:
|
|
if isinstance(item, str):
|
|
return super().__getitem__(0)[item]
|
|
return super().__getitem__(item)
|
|
|
|
def __setitem__(self, item: Union[str, int, slice], val):
|
|
if isinstance(item, str):
|
|
self[0][item] = val
|
|
else:
|
|
super().__setitem__(item, val)
|
|
|
|
|
|
class Message:
|
|
__slots__ = ("name", "send_flags", "packet_id", "acks", "body_boundaries", "queued",
|
|
"offset", "raw_extra", "raw_body", "deserializer", "_blocks", "finalized",
|
|
"direction", "meta", "synthetic", "dropped", "sender", "unknown_message")
|
|
|
|
def __init__(self, name, *args, packet_id=None, flags=0, acks=None, direction=None):
|
|
# TODO: Do this on a timer or something.
|
|
maybe_reload_templates()
|
|
|
|
self.name = name
|
|
self.send_flags = flags
|
|
self.packet_id: Optional[int] = packet_id # aka, sequence number
|
|
|
|
self.acks = acks if acks is not None else tuple()
|
|
self.body_boundaries = (-1, -1)
|
|
self.unknown_message = False
|
|
self.offset = 0
|
|
self.raw_extra = b""
|
|
self.direction: Direction = direction if direction is not None else Direction.OUT
|
|
# For lazy deserialization
|
|
self.raw_body = None
|
|
self.deserializer = None
|
|
# should be set once a packet is sent / dropped to prevent accidental
|
|
# re-sending or re-dropping
|
|
self.finalized = False
|
|
# Whether message is owned by the queue or should be sent immediately
|
|
self.queued: bool = False
|
|
self._blocks: BLOCK_DICT = {}
|
|
self.meta = {}
|
|
self.synthetic = packet_id is None
|
|
self.dropped = False
|
|
self.sender: Optional[ADDR_TUPLE] = None
|
|
|
|
self.add_blocks(args)
|
|
|
|
def add_blocks(self, block_list):
|
|
# can have a list of blocks if it is multiple or variable
|
|
for block in block_list:
|
|
if type(block) is list:
|
|
for bl in block:
|
|
self.add_block(bl)
|
|
else:
|
|
self.add_block(block)
|
|
|
|
@property
|
|
def extra(self) -> bytes:
|
|
return self.raw_extra
|
|
|
|
@extra.setter
|
|
def extra(self, val: bytes):
|
|
# Make sure this message is fully parsed if it wasn't already,
|
|
# changing `.extra` requires re-serializing the message body.
|
|
self.ensure_parsed()
|
|
self.raw_extra = val
|
|
self.offset = len(val)
|
|
|
|
@property
|
|
def blocks(self) -> BLOCK_DICT:
|
|
self.ensure_parsed()
|
|
return self._blocks
|
|
|
|
@blocks.setter
|
|
def blocks(self, val: BLOCK_DICT):
|
|
self._blocks = val
|
|
|
|
# block list was clobbered, so we don't care about any unparsed data
|
|
self.raw_body = None
|
|
self.deserializer = None
|
|
|
|
def create_block_list(self, block_name: str):
|
|
# There's a slight semantic difference between a missing block list
|
|
# and a present block list with 0 length. This helps us distinguish.
|
|
if block_name not in self.blocks:
|
|
self.blocks[block_name] = MsgBlockList()
|
|
|
|
def add_block(self, block: Block):
|
|
self.create_block_list(block.name)
|
|
|
|
self.blocks[block.name].append(block)
|
|
block.message_name = self.name
|
|
block.finalize()
|
|
|
|
def get_blocks(self, block_name: str, default=None, /) -> Optional[MsgBlockList]:
|
|
return self.blocks.get(block_name, default)
|
|
|
|
@property
|
|
def reliable(self):
|
|
# int() because otherwise this causes an alloc
|
|
return self.send_flags & int(PacketFlags.RELIABLE)
|
|
|
|
@property
|
|
def has_acks(self):
|
|
return self.send_flags & int(PacketFlags.ACK)
|
|
|
|
@property
|
|
def zerocoded(self):
|
|
return self.send_flags & int(PacketFlags.ZEROCODED)
|
|
|
|
@property
|
|
def resent(self):
|
|
return self.send_flags & int(PacketFlags.RESENT)
|
|
|
|
def ensure_parsed(self):
|
|
# This is a little magic, think about whether we want this.
|
|
if self.raw_body and self.deserializer and self.deserializer():
|
|
self.deserializer().parse_message_body(self)
|
|
|
|
def to_dict(self, extended=False):
|
|
""" A dict representation of a message.
|
|
|
|
This is the form used for templated messages sent via EQ.
|
|
"""
|
|
self.ensure_parsed()
|
|
base_repr = {'message': self.name, 'body': {}}
|
|
|
|
for block_type in self.blocks:
|
|
dict_blocks = base_repr['body'].setdefault(block_type, [])
|
|
for block in self.blocks[block_type]:
|
|
new_vars = {}
|
|
for var_name, val in block.items():
|
|
new_vars[var_name] = val
|
|
dict_blocks.append(new_vars)
|
|
|
|
if extended:
|
|
base_repr.update({
|
|
"packet_id": self.packet_id,
|
|
"meta": self.meta.copy(),
|
|
"dropped": self.dropped,
|
|
"synthetic": self.synthetic,
|
|
"direction": self.direction.name,
|
|
"send_flags": int(self.send_flags),
|
|
"extra": self.extra,
|
|
"acks": self.acks,
|
|
})
|
|
|
|
return base_repr
|
|
|
|
@classmethod
|
|
def from_dict(cls, dict_val):
|
|
msg = cls(dict_val['message'])
|
|
for block_type, blocks in dict_val['body'].items():
|
|
msg.create_block_list(block_type)
|
|
for block in blocks:
|
|
msg.add_block(Block(block_type, **block))
|
|
|
|
if 'packet_id' in dict_val:
|
|
# extended format
|
|
msg.packet_id = dict_val['packet_id']
|
|
msg.meta = dict_val['meta']
|
|
msg.dropped = dict_val['dropped']
|
|
msg.synthetic = dict_val['synthetic']
|
|
msg.direction = Direction[dict_val['direction']]
|
|
msg.send_flags = dict_val['send_flags']
|
|
msg.extra = dict_val['extra']
|
|
msg.acks = dict_val['acks']
|
|
return msg
|
|
|
|
@classmethod
|
|
def from_eq_event(cls, event) -> Message:
|
|
# If this isn't a templated message (like some EQ-only events are),
|
|
# then we wrap it in a synthetic `Message` so that the API for handling
|
|
# both EQ-only and templated message events can be the same. Ick.
|
|
msg = cls(event["message"])
|
|
if isinstance(event["body"], dict):
|
|
msg.add_block(Block("EventData", **event["body"]))
|
|
else:
|
|
# Shouldn't be any events that have anything other than a dict
|
|
# as a body, but just to be sure...
|
|
msg.add_block(Block("EventData", Data=event["body"]))
|
|
msg.synthetic = True
|
|
return msg
|
|
|
|
def invalidate_caches(self):
|
|
# Don't have any caches if we haven't even parsed
|
|
if self.raw_body:
|
|
return
|
|
for blocks in self.blocks.values():
|
|
for block in blocks:
|
|
block.invalidate_caches()
|
|
|
|
def __getitem__(self, item):
|
|
return self.blocks[item]
|
|
|
|
def __setitem__(self, key: str, value):
|
|
if not isinstance(value, (list, tuple)):
|
|
value = (value,)
|
|
if not isinstance(value, MsgBlockList):
|
|
value = MsgBlockList(value)
|
|
self.blocks[key] = value
|
|
|
|
def __contains__(self, item):
|
|
return item in self.blocks
|
|
|
|
def _args_repr(self, pretty=False):
|
|
sep = ",\n "
|
|
block_reprs = sep.join(x.repr(pretty=pretty) for x in itertools.chain(*self.blocks.values()))
|
|
if block_reprs:
|
|
block_reprs = sep + block_reprs
|
|
return f"{self.name!r}{block_reprs}, direction=Direction.{self.direction.name}"
|
|
|
|
def repr(self, pretty=False):
|
|
self.ensure_parsed()
|
|
return f"{self.__class__.__name__}({self._args_repr(pretty=pretty)})"
|
|
|
|
def take(self):
|
|
message_copy = copy.deepcopy(self)
|
|
|
|
# Set the queued flag so the original will be dropped and acks will be sent
|
|
if not self.finalized:
|
|
self.queued = True
|
|
|
|
# Original was dropped so let's make sure we have clean acks and packet id
|
|
message_copy.acks = tuple()
|
|
message_copy.send_flags &= ~PacketFlags.ACK
|
|
message_copy.packet_id = None
|
|
message_copy.dropped = False
|
|
message_copy.finalized = False
|
|
message_copy.queued = False
|
|
return message_copy
|
|
|
|
def to_summary(self):
|
|
string = ""
|
|
for block_name, block_list in self.blocks.items():
|
|
for block in block_list:
|
|
for var_name, val in block.items():
|
|
if block.name == "AgentData" and var_name in ("AgentID", "SessionID"):
|
|
continue
|
|
if string:
|
|
string += ", "
|
|
string += f"{var_name}={_trunc_repr(val, 10)}"
|
|
return string
|
|
|
|
def __repr__(self):
|
|
return self.repr()
|
|
|
|
def __eq__(self, other):
|
|
if not isinstance(other, self.__class__):
|
|
return NotImplemented
|
|
return self.to_dict() == other.to_dict()
|
|
|
|
|
|
def _trunc_repr(val, max_len):
|
|
if isinstance(val, (uuid.UUID, TupleCoord)):
|
|
val = str(val)
|
|
repr_val = repr(val)
|
|
if isinstance(val, str):
|
|
repr_val = repr_val[1:-1]
|
|
if isinstance(val, bytes):
|
|
repr_val = repr_val[2:-1]
|
|
if len(repr_val) > max_len:
|
|
return repr_val[:max_len] + "…"
|
|
return repr_val
|