Make FlagValue bound to a Packet (#4705)

- `FlagValue.pkt` attribute added.
- `list_field.ensure_bound()` generalized as
  `Packet._ensure_bound_field_value()` and completed for `FlagValue`s.
- `Packet.clear_cache()` automatically in `FlagValue.__setattr__()`.

Author: alxroyer-thales

scapy/fields.py

@@ -2973,7 +2973,7 @@ def __next__(self):
 
 
 class FlagValue(object):
-    __slots__ = ["value", "names", "multi"]
+    __slots__ = ["pkt", "value", "names", "multi"]
 
     def _fixvalue(self, value):
         # type: (Any) -> int
@@ -2990,6 +2990,12 @@ def _fixvalue(self, value):
 
     def __init__(self, value, names):
         # type: (Union[List[str], int, str], Union[List[str], str]) -> None
+
+        #: Packet bound with this flag value.
+        #:
+        #: Ensures ``Packet.clear_cache()`` is called when the flags are modified.
+        self.pkt = None  # type: Optional[Packet]
+
         self.multi = isinstance(names, list)
         self.names = names
         self.value = self._fixvalue(value)
@@ -3125,6 +3131,10 @@ def __setattr__(self, attr, value):
                 self.value |= (2 ** self.names.index(attr))
             else:
                 self.value &= ~(2 ** self.names.index(attr))
+
+            # Automatically call `Packet.clear_cache()` when the flags are modified.
+            if self.pkt is not None:
+                self.pkt.clear_cache(upwards=True, downwards=True)
         else:
             return super(FlagValue, self).__setattr__(attr, value)
 

scapy/packet.py

@@ -205,11 +205,7 @@ def __init__(self,
                 continue
             if not isinstance(value, RawVal):
                 value = self.get_field(fname).any2i(self, value)
-
-            # In case of a list, ensure we store a `list_field` instance, not a simple `list`.
-            if isinstance(value, list):
-                value = list_field.ensure_bound(self, value)
-
+            value = self._ensure_bound_field_value(value)
             self.fields[fname] = value
         # The remaining fields are unknown
         for fname in fields:
@@ -219,11 +215,7 @@ def __init__(self,
                 fname = self._resolve_alias(fname)
                 if not isinstance(value, RawVal):
                     value = self.get_field(fname).any2i(self, value)
-
-                # In case of a list, ensure we store a `list_field` instance, not a simple `list`.
-                if isinstance(value, list):
-                    value = list_field.ensure_bound(self, value)
-
+                value = self._ensure_bound_field_value(value)
                 self.fields[fname] = value
                 continue
             raise AttributeError(fname)
@@ -332,10 +324,7 @@ def do_init_cached_fields(self, for_dissect_only=False, init_fields=None):
 
                 # Fix: Use `copy_field_value()` instead of just `value.copy()`, in order to duplicate list items as well in case of a list.
                 self.fields[fname] = self.copy_field_value(fname, self.default_fields[fname])
-
-                # In case of a list, ensure we store a `list_field` instance, not a simple `list`.
-                if isinstance(self.fields[fname], list):
-                    self.fields[fname] = list_field.ensure_bound(self, self.fields[fname])
+                self.fields[fname] = self._ensure_bound_field_value(self.fields[fname])
 
                 self._ensure_parent_of(self.fields[fname])
 
@@ -682,11 +671,7 @@ def setfieldval(self, attr, val):
                 any2i = fld.any2i
             if not isinstance(val, RawVal):
                 val = any2i(self, val)
-
-            # In case of a list, ensure we store a `list_field` instance, not a simple `list`.
-            if isinstance(val, list):
-                val = list_field.ensure_bound(self, val)
-
+            val = self._ensure_bound_field_value(val)
             self.fields[attr] = val
             self.explicit = 0
             # Invalidate cache when the packet has changed.
@@ -708,6 +693,31 @@ def __setattr__(self, attr, val):
             pass
         return object.__setattr__(self, attr, val)
 
+    def _ensure_bound_field_value(
+            self,
+            value,  # type: Any
+    ):  # type: (...) -> Any
+        """
+        Ensures a field instance bound with ``self`` when applicable.
+        """
+        if isinstance(value, list):
+            # If `value` is a simple `list`, create a new `list_field` instance.
+            # If `value` is already a `list_field` instance, we never know where this instance comes from, and what it's being used for.
+            # Let's create a new `list_field` instance in any case.
+            return list_field(self, value)
+
+        if isinstance(value, FlagValue):
+            # We never know where the `FlagValue` instance comes from, and what it's being used for.
+            # Let's create a new instance.
+            value = value.copy()
+            value.pkt = self
+            return value
+
+        # Non-specific bound field.
+        # Maybe a packet? rely on parentship in that case.
+        # Return `value` as is.
+        return value
+
     def delfieldval(self, attr):
         # type: (str) -> None
         if attr in self.fields:
@@ -1233,11 +1243,7 @@ def do_dissect(self, s):
             # Skip unused ConditionalField
             if isinstance(f, ConditionalField) and fval is None:
                 continue
-
-            # In case of a list, ensure we store a `list_field` instance, not a simple `list`.
-            if isinstance(fval, list):
-                fval = list_field.ensure_bound(self, fval)
-
+            fval = self._ensure_bound_field_value(fval)
             self.fields[f.name] = fval
             # Nothing left to dissect
             if not s and (isinstance(f, MayEnd) or
@@ -2231,19 +2237,6 @@ def __init__(
         #: Packet bound with this list field.
         self.pkt = pkt
 
-    @staticmethod
-    def ensure_bound(
-            pkt,  # type: Packet
-            lst,  # type: List[Any]
-    ):  # type: (...) -> list_field
-        """
-        Ensures a :class:`list_field` instance bound with ``pkt``.
-        """
-        # If `lst` is a simple `list`, this method intends to create a new `list_field` instance.
-        # If `lst` is already a `list_field` instance, we never know where this instance comes from, and what it's being used for.
-        # Let's create a new `list_field` instance in any case.
-        return list_field(pkt, lst)
-
 
 ####################
 #  packet classes  #