pebble/tools/app_header.py

147 lines
4.9 KiB
Python
Raw Permalink Normal View History

# Copyright 2024 Google LLC
#
# 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.
import struct
import uuid
class PebbleAppHeader(object):
MAGIC = 'PBLAPP\x00\x00'
# 10 bytes
HEADER_STRUCT_DEFINITION = [
'8s', # header
'2B', # struct version
]
HEADER_STRUCT = struct.Struct(''.join(HEADER_STRUCT_DEFINITION))
# 116 bytes
V1_STRUCT_VERSION = (0x08, 0x01)
V1_STRUCT_DEFINTION = [
# format, name, deserialization transform, serialization transform
('B', 'sdk_version_major', None, None),
('B', 'sdk_version_minor', None, None),
('B', 'app_version_major', None, None),
('B', 'app_version_minor', None, None),
('H', 'app_size', None, None),
('I', 'offset', None, None),
('I', 'crc', None, None),
('32s', 'app_name', lambda bytes: bytes.rstrip('\0'), None),
('32s', 'company_name', lambda bytes: bytes.rstrip('\0'), None),
('I', 'icon_resource_id', None, None),
('I', 'symbol_table_addr', None, None),
('I', 'flags', None, None),
('I', 'relocation_list_index', None, None),
('I', 'num_relocation_entries', None, None),
('16s', 'uuid', lambda s: uuid.UUID(bytes=s), lambda u: u.bytes),
]
# 120 bytes
V2_STRUCT_VERSION = (0x10, 0x00)
V2_STRUCT_DEFINTION = list(V1_STRUCT_DEFINTION)
del V2_STRUCT_DEFINTION[12] # relocation list was dropped in v2.x
V2_STRUCT_DEFINTION += [
('I', 'resource_crc', None, None),
('I', 'resource_timestamp', None, None),
('H', 'virtual_size', None, None),
]
V2_HEADER_LENGTH = 10 + 120
DEFINITION_MAP = {
V1_STRUCT_VERSION: V1_STRUCT_DEFINTION,
V2_STRUCT_VERSION: V2_STRUCT_DEFINTION,
}
@classmethod
def get_def_and_struct(cls, struct_version):
definition = cls.DEFINITION_MAP.get(struct_version)
if not definition:
raise Exception("Unsupported "
"struct version %s" % str(struct_version))
fmt = '<' + reduce(lambda s, t: s + t[0], definition, '')
s = struct.Struct(fmt)
return definition, s
@classmethod
def deserialize(cls, app_bin):
header_size = cls.HEADER_STRUCT.size
header = app_bin[0:header_size]
values = cls.HEADER_STRUCT.unpack(header)
struct_version = (values[1], values[2])
info = {
'sentinel': values[0],
'struct_version_major': struct_version[0],
'struct_version_minor': struct_version[1],
}
if info['sentinel'] != cls.MAGIC:
raise Exception('This is not a pebble watchapp')
definition, s = cls.get_def_and_struct(struct_version)
values = s.unpack(app_bin[header_size:header_size + s.size])
for value, elem in zip(values, definition):
field_name = elem[1]
transform = elem[2]
info[field_name] = value if not transform else transform(value)
return info
def serialize(self):
struct_version = (self._info['struct_version_major'],
self._info['struct_version_minor'])
header = PebbleAppHeader.HEADER_STRUCT.pack(PebbleAppHeader.MAGIC,
*struct_version)
definition, s = self.__class__.get_def_and_struct(struct_version)
def map_args(elem):
value = self._info[elem[1]]
transform = elem[3]
return value if not transform else transform(value)
args = map(map_args, definition)
return header + s.pack(*args)
def __init__(self, app_bin_bytes):
self._info = PebbleAppHeader.deserialize(app_bin_bytes)
def __getattr__(self, name):
value = self._info.get(name)
if value is None:
raise Exception("Unknown field %s" % name)
return value
def __setattr__(self, name, value):
if name == '_info':
super(PebbleAppHeader, self).__setattr__(name, value)
self._info[name] = value
def __repr__(self):
return self._info.__repr__()
def __str__(self):
return self.__repr__()
if __name__ == '__main__':
import argparse
import pprint
parser = argparse.ArgumentParser()
parser.add_argument('bin_file')
args = parser.parse_args()
with open(args.bin_file, 'rb') as f:
app_info = PebbleAppHeader.deserialize(f.read())
pprint.pprint(app_info)