def log_transferred_value(text: str, aid: int,
characteristic: AbstractCharacteristic, value,
filtered_value):
"""
Logs the transfer of a value between controller and acccessory or vice versa. For characteristics
of type TLV8, a decoder is used if available else a deep decode is done.
:param text: a `str` to express which direction of transfer takes place
:param aid: the accessory id
:param characteristic: the characteristic for which the transfer takes place
:param value: the value that was transferred
"""
iid = int(characteristic.iid)
debug_value = value
filtered_debug_value = filtered_value
characteristic_name = CharacteristicsTypes.get_short(characteristic.type)
if characteristic.format == CharacteristicFormats.tlv8:
bytes_value = base64.b64decode(value)
filtered_bytes_value = base64.b64decode(filtered_value)
decoder = decoder_loader.load(characteristic.type)
if decoder:
try:
debug_value = tlv8.format_string(decoder(bytes_value))
filtered_debug_value = tlv8.format_string(
decoder(filtered_bytes_value))
except Exception as e:
logging.error('problem decoding', e)
else:
debug_value = tlv8.format_string(tlv8.deep_decode(bytes_value))
filtered_debug_value = tlv8.format_string(
tlv8.deep_decode(filtered_bytes_value))
logging.info(
'%s %s.%s (type %s / %s): \n\toriginal value: %s\n\tfiltered value: %s'
% (text, aid, iid, characteristic.type, characteristic_name,
debug_value, filtered_debug_value))
def test_decode_example_2(self):
input_data = b'\x01\x01\x00'
result = tlv8.deep_decode(input_data)
expected = tlv8.EntryList([
tlv8.Entry(1, b'\x00'),
])
self.assertEqual(expected, result)
def test_decode_int4(self):
input_data = b'\x01\x08' + pack('<q', 4611686018427387904)
result = tlv8.deep_decode(input_data)
expected = tlv8.EntryList([
tlv8.Entry(1, b'\x00\x00\x00\x00\x00\x00\x00@'),
])
self.assertEqual(expected, result)
def test_decode_int1(self):
input_data = b'\x01\x01' + pack('<b', -123)
result = tlv8.deep_decode(input_data)
expected = tlv8.EntryList([
tlv8.Entry(1, b'\x85'),
])
self.assertEqual(expected, result)
def test_decode_int2(self):
input_data = b'\x01\x02' + pack('<h', 12345)
result = tlv8.deep_decode(input_data)
expected = tlv8.EntryList([
tlv8.Entry(1, b'90'),
])
self.assertEqual(expected, result)
def test_decode_missing_separator_nonstrict(self):
data = b'\x01\x01\x02\x01\x01\x02'
result = tlv8.deep_decode(data, strict_mode=False)
self.assertEqual(
result,
tlv8.EntryList([tlv8.Entry(1, b'\x02'),
tlv8.Entry(1, b'\x02')]))
def test_decode_float(self):
input_data = b'\x01\x04' + pack('<f', 3.141)
result = tlv8.deep_decode(input_data)
expected = tlv8.EntryList([
tlv8.Entry(1, b'%\x06I@'),
])
self.assertEqual(expected, result)
def test_decode_misinterpretation(self):
"""This show how data may be misinterpreted by deep_decode"""
data = tlv8.encode([tlv8.Entry(1, 16843330), tlv8.Entry(2, b'\x01')])
result = tlv8.deep_decode(data)
expected_data = tlv8.EntryList([
tlv8.Entry(1, tlv8.EntryList([tlv8.Entry(66, b'\x01\x01')])),
tlv8.Entry(2, b'\x01')
])
self.assertEqual(result, expected_data)
def test_decode_4(self):
input_data = b'\x01\x01\x23\x02\x03\x04\x01\x42\x01\x01\x23'
result = tlv8.deep_decode(input_data)
expected = tlv8.EntryList([
tlv8.Entry(1, b'#'),
tlv8.Entry(2, tlv8.EntryList([
tlv8.Entry(4, b'B'),
])),
tlv8.Entry(1, b'#'),
])
self.assertEqual(expected, result)
def test_decode_257bytes(self):
data = b''
for i in range(0, 257):
data += pack('<B', i % 256)
input_data = b'\x17\xff' + data[0:255] + b'\x17\x02' + data[255:]
result = tlv8.deep_decode(input_data)
expected = tlv8.EntryList([tlv8.Entry(23, data)])
self.assertEqual(result, expected)
def write_http(request, expected):
body = tlv8.encode(request)
logging.debug('write message: %s',
tlv8.format_string(tlv8.deep_decode(body)))
connection.putrequest('POST', '/pair-setup', skip_accept_encoding=True)
connection.putheader('Content-Type', 'application/pairing+tlv8')
connection.putheader('Content-Length', len(body))
connection.endheaders(body)
resp = connection.getresponse()
response_tlv = tlv8.decode(resp.read(), expected)
logging.debug('response: %s', tlv8.format_string(response_tlv))
return response_tlv
def test_decode_supported_rtp_configs(self):
data = \
b'\x02\x01\x00' + \
b'\x00\x00' + \
b'\x02\x01\x01'
result = tlv8.deep_decode(data, )
expected_data = tlv8.EntryList([
tlv8.Entry(2, b'\x00'),
tlv8.Entry(0, tlv8.EntryList()),
tlv8.Entry(2, b'\x01')
])
self.assertEqual(result, expected_data)
def test_decode_example_3(self):
input_data = b'\x01\x15\x01\x10e\xad\x8b\xe8\xb3fD\xcb\xbde#\xccc\n\xb8\xef\x02\x01\x01'
result = tlv8.deep_decode(input_data)
expected = tlv8.EntryList([
tlv8.Entry(
1,
tlv8.EntryList([
tlv8.Entry(
1, b'e\xad\x8b\xe8\xb3fD\xcb\xbde#\xccc\n\xb8\xef'),
tlv8.Entry(2, b'\x01'),
])),
])
self.assertEqual(expected, result)
def test_decode_single_entry_bytearry(self):
input_data = bytearray(b'\x02\x01\x23')
result = tlv8.deep_decode(input_data)
self.assertEqual(tlv8.EntryList([tlv8.Entry(2, b'\x23')]), result)
def test_decode_2_entries(self):
input_data = b'\x02\x01\x23\x03\x01\x42'
result = tlv8.deep_decode(input_data)
self.assertEqual(
tlv8.EntryList([tlv8.Entry(2, b'\x23'),
tlv8.Entry(3, b'\x42')]), result)
def test_decode_error_4(self):
data = b'\x01\x02Hi'
result = tlv8.deep_decode(data)
expected_data = tlv8.EntryList([tlv8.Entry(1, b'Hi')])
self.assertEqual(result, expected_data)
def test_zero_input(self):
input_data = b''
result = tlv8.deep_decode(input_data)
self.assertEqual(tlv8.EntryList(), result)
def test_encode_supported_video_stream_configuration(self):
data = \
b'\x01\x30' \
b'\x01\x01\x00' \
b'\x02\x0f' \
b'\x01\x01\x00' \
b'\x02\x01\x00' \
b'\x03\x01\x00' \
b'\x04\x01\x01' \
b'\x05\x01\n' \
b'\x03\x0b' \
b'\x01\x02\x00\x05' \
b'\x02\x02 \x03' \
b'\x03\x01\x1e' \
b'\xff\x00' \
b'\x03\x0b' \
b'\x01\x02\x80\x02' \
b'\x02\x02\xe0\x01' \
b'\x03\x01\x1e' \
b'\xff\x00' \
b'\x01\x2d' \
b'\x01\x01\x00' \
b'\x02\x0c' \
b'\x01\x01\x00' \
b'\x02\x01\x00' \
b'\x03\x01\x00' \
b'\x04\x01\x00' \
b'\x03\x0b' \
b'\x01\x02\x00\x05' \
b'\x02\x02 \x03' \
b'\x03\x01\x1e' \
b'\xff\x00' \
b'\x03\x0b' \
b'\x01\x02\x80\x02' \
b'\x02\x02\xe0\x01' \
b'\x03\x01\x1e'
result = tlv8.deep_decode(data)
expected_data = tlv8.EntryList([
tlv8.Entry(
1,
tlv8.EntryList([ # video codec config
tlv8.Entry(1, b'\x00'), # h.264
tlv8.Entry(
2,
tlv8.EntryList([ # video codec param
tlv8.Entry(
1, b'\x00'), # Constrained Baseline Profile
tlv8.Entry(2, b'\x00'), # Level 3.1
tlv8.Entry(
3, b'\x00'
), # Packetization mode: Non-interleaved mode
tlv8.Entry(4, b'\x01'), # CVO not enabled
tlv8.Entry(5, b'\n'), # CVO ID
])),
tlv8.Entry(
3,
tlv8.EntryList([ # video attributes
tlv8.Entry(1, b'\x00\x05'), # width
tlv8.Entry(2, b' \x03'), # height
tlv8.Entry(3, b'\x1e') # fps
])),
tlv8.Entry(255, tlv8.EntryList()),
tlv8.Entry(
3,
tlv8.EntryList([ # video attributes
tlv8.Entry(1, b'\x80\x02'), # width
tlv8.Entry(2, b'\xe0\x01'), # height
tlv8.Entry(3, b'\x1e') # fps
]))
])),
tlv8.Entry(255, tlv8.EntryList()),
tlv8.Entry(
1,
tlv8.EntryList([
tlv8.Entry(1, b'\x00'), # h.264
tlv8.Entry(
2,
tlv8.EntryList([ # video codec param
tlv8.Entry(
1, b'\x00'), # Constrained Baseline Profile
tlv8.Entry(2, b'\x00'), # Level 3.1
tlv8.Entry(
3, b'\x00'
), # Packetization mode: Non-interleaved mode
tlv8.Entry(4, b'\x00'), # CVO not enabled
])),
tlv8.Entry(
3,
tlv8.EntryList([ # video attributes
tlv8.Entry(1, b'\x00\x05'), # width
tlv8.Entry(2, b' \x03'), # height
tlv8.Entry(3, b'\x1e') # fps
])),
tlv8.Entry(255, tlv8.EntryList()),
tlv8.Entry(
3,
tlv8.EntryList([ # video attributes
tlv8.Entry(1, b'\x80\x02'), # width
tlv8.Entry(2, b'\xe0\x01'), # height
tlv8.Entry(3, b'\x1e') # fps
]))
]))
])
self.assertEqual(result, expected_data)