def _process_buffer(self):
while self.buffer:
length, raw = variant.read_variant(self.buffer)
if len(raw) < length:
break
data = raw[:length]
self.buffer = raw[length:]
if self.chacha:
log_binary(_LOGGER, "ENC Phone->ATV", Encrypted=data)
data = self.chacha.decrypt(data)
message = protobuf.ProtocolMessage()
message.ParseFromString(data)
_LOGGER.info("(DEC Phone->ATV): %s", message)
try:
if message.type == protobuf.DEVICE_INFO_MESSAGE:
self.handle_device_info(message, message.inner())
elif message.type == protobuf.CRYPTO_PAIRING_MESSAGE:
self.handle_crypto_pairing(message, message.inner())
else:
self.connection.send_raw(data)
except Exception: # pylint: disable=broad-except
_LOGGER.exception("Error while dispatching message")
def data_received(self, data):
self.buffer += data
while self.buffer:
length, raw = variant.read_variant(self.buffer)
if len(raw) < length:
return
data = raw[:length]
self.buffer = raw[length:]
if self.chacha:
data = self.chacha.decrypt(data)
parsed = protobuf.ProtocolMessage()
parsed.ParseFromString(data)
log_protobuf(_LOGGER, "<< Receive: Protobuf", parsed)
try:
name = parsed.Type.Name(parsed.type).lower().replace("_message", "")
_LOGGER.debug("Received %s message", name)
getattr(self, "handle_" + name)(parsed, parsed.inner())
except AttributeError:
_LOGGER.exception("No message handler for " + str(parsed))
except Exception:
_LOGGER.exception("Error while dispatching message")
def data_received(self, data):
self.buffer += data
while self.buffer:
length, raw = variant.read_variant(self.buffer)
if len(raw) < length:
return
data = raw[:length]
self.buffer = raw[length:]
if self.chacha:
data = self.chacha.decrypt(data)
parsed = protobuf.ProtocolMessage()
parsed.ParseFromString(data)
_LOGGER.info('Incoming message: %s', parsed)
try:
name = parsed.Type.Name(
parsed.type).lower().replace('_message', '')
_LOGGER.debug('Received %s message', name)
getattr(self, 'handle_' + name)(parsed, parsed.inner())
except AttributeError:
_LOGGER.exception('No message handler for ' + str(parsed))
except Exception:
_LOGGER.exception('Error while dispatching message')
def data_received(self, data):
"""Message received from iOS app/client."""
self.buffer += data
while self.buffer:
length, raw = variant.read_variant(self.buffer)
if len(raw) < length:
break
data = raw[:length]
self.buffer = raw[length:]
if self.chacha:
log_binary(_LOGGER, 'ENC Phone->ATV', Encrypted=data)
data = self.chacha.decrypt(data)
parsed = protobuf.ProtocolMessage()
parsed.ParseFromString(data)
_LOGGER.info('(DEC Phone->ATV): %s', parsed)
try:
def unhandled_message(_, raw):
self.connection.send_raw(raw)
self.mapping.get(parsed.type, unhandled_message)(parsed, data)
except Exception: # pylint: disable=broad-except
_LOGGER.exception('Error while dispatching message')
def create(message_type, priority=0, identifier=None):
"""Create a ProtocolMessage."""
message = protobuf.ProtocolMessage()
message.type = message_type
message.priority = priority
if identifier:
message.identifier = identifier
return message
def create(message_type, error_code=0, identifier=None):
"""Create a ProtocolMessage."""
message = protobuf.ProtocolMessage()
message.type = message_type
message.errorCode = error_code
if identifier:
message.identifier = identifier
return message
def _handle_message(self, data):
if self._chacha:
data = self._chacha.decrypt(data)
log_binary(_LOGGER, self._log_str + "<< Receive", Decrypted=data)
parsed = protobuf.ProtocolMessage()
parsed.ParseFromString(data)
log_protobuf(_LOGGER, self._log_str + "<< Receive: Protobuf", parsed)
self.listener.message_received(parsed, data)
def _handle_message(self, data):
if self._chacha:
data = self._chacha.decrypt(data)
log_binary(_LOGGER, '<< Receive', Decrypted=data)
parsed = protobuf.ProtocolMessage()
parsed.ParseFromString(data)
_LOGGER.debug('<< Receive: Protobuf=%s', parsed)
if self.listener:
self.listener.message_received(parsed)
def _send_raw(self, raw):
parsed = protobuf.ProtocolMessage()
parsed.ParseFromString(raw)
log_binary(_LOGGER, 'ATV->APP', Raw=raw)
_LOGGER.info('ATV->APP Parsed: %s', parsed)
if self.chacha:
raw = self.chacha.encrypt(raw)
log_binary(_LOGGER, 'ATV->APP', Encrypted=raw)
length = variant.write_variant(len(raw))
try:
self.transport.write(length + raw)
except Exception: # pylint: disable=broad-except
_LOGGER.exception('Failed to send to app')
def send_raw(self, raw):
"""Send raw data to client."""
parsed = protobuf.ProtocolMessage()
parsed.ParseFromString(raw)
log_binary(_LOGGER, "ATV->APP", Raw=raw)
_LOGGER.info("ATV->APP Parsed: %s", parsed)
if self.chacha:
raw = self.chacha.encrypt(raw)
log_binary(_LOGGER, "ATV->APP", Encrypted=raw)
length = variant.write_variant(len(raw))
try:
self.transport.write(length + raw)
except Exception: # pylint: disable=broad-except
_LOGGER.exception("Failed to send to app")
def data_received(self, data):
self.buffer += data
length, raw = variant.read_variant(self.buffer)
if len(raw) < length:
return
data = raw[:length]
self.buffer = raw[length:]
parsed = protobuf.ProtocolMessage()
parsed.ParseFromString(data)
_LOGGER.info('Incoming message: %s', parsed)
try:
def unhandled_message(message):
_LOGGER.warning('No message handler for %s', message)
self.mapping.get(parsed.type, unhandled_message)(parsed)
except Exception:
_LOGGER.exception('Error while dispatching message')
def create(message_type, priority=0):
"""Create a ProtocolMessage."""
message = protobuf.ProtocolMessage()
message.type = message_type
message.priority = priority
return message
