commit 2db5cfb525cf6215c58f3da784f9092f50ed59bb
author Harald Welte <laforge@osmocom.org> Sat Apr 10 19:05:37 2021 +0200
committer Harald Welte <laforge@osmocom.org> Sun Apr 11 12:20:29 2021 +0200
tree 4db0fb7539d162febdee79ac1509550fde246710
parent 703f933b40610ab30eb53368609b42ace4def200

filesystem: Introduce 'construct' support

This allows for pure declarative encoders/decoders for linear fixed
and transparent EFs.

Change-Id: Id0765ec3ddb8c044838ce47d0ff8740720a32b15

pySim/filesystem.py

diff --git a/pySim/filesystem.py b/pySim/filesystem.py
index e771f3c..49520c3 100644
--- a/pySim/filesystem.py
+++ b/pySim/filesystem.py
@@ -35,6 +35,7 @@
 from typing import cast, Optional, Iterable, List, Any, Dict, Tuple
 
 from pySim.utils import sw_match, h2b, b2h, is_hex
+from pySim.construct import filter_dict
 from pySim.exceptions import *
 from pySim.jsonpath import js_path_find, js_path_modify
 
@@ -466,6 +467,7 @@
             size : tuple of (minimum_size, recommended_size)
         """
         super().__init__(fid=fid, sfid=sfid, name=name, desc=desc, parent=parent)
+        self._construct = None
         self.size = size
         self.shell_commands = [self.ShellCommands()]
 
@@ -487,6 +489,8 @@
         method = getattr(self, '_decode_hex', None)
         if callable(method):
             return method(b2h(raw_bin_data))
+        if self._construct:
+            return filter_dict(self._construct.parse(raw_bin_data, total_len=len(raw_bin_data)))
         return {'raw': raw_bin_data.hex()}
 
     def decode_hex(self, raw_hex_data:str) -> dict:
@@ -508,6 +512,8 @@
         method = getattr(self, '_decode_bin', None)
         if callable(method):
             return method(raw_bin_data)
+        if self._construct:
+            return filter_dict(self._construct.parse(raw_bin_data, total_len=len(raw_bin_data)))
         return {'raw': raw_bin_data.hex()}
 
     def encode_bin(self, abstract_data:dict) -> bytearray:
@@ -528,6 +534,8 @@
         method = getattr(self, '_encode_hex', None)
         if callable(method):
             return h2b(method(abstract_data))
+        if self._construct:
+            return self._construct.build(abstract_data)
         raise NotImplementedError
 
     def encode_hex(self, abstract_data:dict) -> str:
@@ -549,6 +557,8 @@
         if callable(method):
             raw_bin_data = method(abstract_data)
             return b2h(raw_bin_data)
+        if self._construct:
+            return b2h(self._construct.build(abstract_data))
         raise NotImplementedError
 
 
@@ -683,6 +693,7 @@
         super().__init__(fid=fid, sfid=sfid, name=name, desc=desc, parent=parent)
         self.rec_len = rec_len
         self.shell_commands = [self.ShellCommands()]
+        self._construct = None
 
     def decode_record_hex(self, raw_hex_data:str) -> dict:
         """Decode raw (hex string) data into abstract representation.
@@ -703,6 +714,8 @@
         method = getattr(self, '_decode_record_bin', None)
         if callable(method):
             return method(raw_bin_data)
+        if self._construct:
+            return filter_dict(self._construct.parse(raw_bin_data, total_len=len(raw_bin_data)))
         return {'raw': raw_bin_data.hex()}
 
     def decode_record_bin(self, raw_bin_data:bytearray) -> dict:
@@ -724,6 +737,8 @@
         method = getattr(self, '_decode_record_hex', None)
         if callable(method):
             return method(raw_hex_data)
+        if self._construct:
+            return filter_dict(self._construct.parse(raw_bin_data, total_len=len(raw_bin_data)))
         return {'raw': raw_hex_data}
 
     def encode_record_hex(self, abstract_data:dict) -> str:
@@ -745,6 +760,8 @@
         if callable(method):
             raw_bin_data = method(abstract_data)
             return b2h(raw_bin_data)
+        if self._construct:
+            return b2h(self._construct.build(abstract_data))
         raise NotImplementedError
 
     def encode_record_bin(self, abstract_data:dict) -> bytearray:
@@ -765,6 +782,8 @@
         method = getattr(self, '_encode_record_hex', None)
         if callable(method):
             return h2b(method(abstract_data))
+        if self._construct:
+            return self._construct.build(abstract_data)
         raise NotImplementedError
 
 class CyclicEF(LinFixedEF):
@@ -813,10 +832,12 @@
         method = getattr(self, '_decode_record_hex', None)
         if callable(method):
             return method(raw_hex_data)
+        raw_bin_data = h2b(raw_hex_data)
         method = getattr(self, '_decode_record_bin', None)
         if callable(method):
-            raw_bin_data = h2b(raw_hex_data)
             return method(raw_bin_data)
+        if self._construct:
+            return filter_dict(self._construct.parse(raw_bin_data, total_len=len(raw_bin_data)))
         return {'raw': raw_hex_data}
 
     def decode_record_bin(self, raw_bin_data:bytearray) -> dict:
@@ -838,6 +859,8 @@
         method = getattr(self, '_decode_record_hex', None)
         if callable(method):
             return method(raw_hex_data)
+        if self._construct:
+            return filter_dict(self._construct.parse(raw_bin_data, total_len=len(raw_bin_data)))
         return {'raw': raw_hex_data}
 
     def encode_record_hex(self, abstract_data:dict) -> str:
@@ -858,6 +881,8 @@
         method = getattr(self, '_encode_record_bin', None)
         if callable(method):
             return b2h(method(abstract_data))
+        if self._construct:
+            return b2h(filter_dict(self._construct.build(abstract_data)))
         raise NotImplementedError
 
     def encode_record_bin(self, abstract_data:dict) -> bytearray:
@@ -878,6 +903,8 @@
         method = getattr(self, '_encode_record_hex', None)
         if callable(method):
             return h2b(method(abstract_data))
+        if self._construct:
+            return filter_dict(self._construct.build(abstract_data))
         raise NotImplementedError
 
     def _decode_bin(self, raw_bin_data:bytearray):