LPM Masking: Fix masking for fields with bitwidth non divisable by 8.

When prefix and/or bitwidth are not aligend to size of a byte, we must make sure the mask is applied correctly to all bits in field.
Until now, the logic expected to find maximum of one byte that needs special masking, and that masking is relative to the "beginning" (MSB bits) of the bytes.
This caused issues with fields that are smaller than a byte.
Another issue, some fields and prefixed might need some bits of a the "first" and "last" byte in the prefix to be masked, for example:
Field bitwidth = 20
Prefix length = 16
Mask should be = 0b11111111111111110000
Since we are representing in byte arrays, in bytes we get -> 00001111 11111111 11110000  (24 bits, 3 bytes)

Old implmentation disregarded the first 2 bytes and only masked the last byte (0b11110000).

Both issues are fixed in this commit, by this flow:
1. Utilizing prefix byte array, which is aligned to number of bytes needed to represent bitwidth in bytes.
2. Creating a mask for entire field, according to prefix length.
3. Applying it to all bits in prefix length.

Issue: #146

Author: dorakerman

p4runtime_sh/shell.py

@@ -428,7 +428,7 @@ def _sanitize_and_convert_mf_lpm(self, prefix, length, field_info):
         if length == 0:
             raise UserError(
                 "Ignoring LPM don't care match (prefix length of 0) as per P4Runtime spec")
-
+        
         mf = p4runtime_pb2.FieldMatch()
         mf.field_id = field_info.id
         mf.lpm.prefix_len = length
@@ -440,19 +440,30 @@ def _sanitize_and_convert_mf_lpm(self, prefix, length, field_info):
 
         barray = bytearray(prefix)
         transformed = False
-        r = length % 8
-        byte_mask = 0xff & ((0xff << (8 - r)))
-        if barray[first_byte_masked] & byte_mask != barray[first_byte_masked]:
-            transformed = True
-            barray[first_byte_masked] = barray[first_byte_masked] & byte_mask
-
-        for i in range(first_byte_masked + 1, len(prefix)):
-            if barray[i] != 0:
+        # When prefix mask and field bithwidth are not aligned to the size of a 
+        # byte, we need to make sure mask is applied to the all bytes in prefix
+        # that should be masked.
+        # Therefore, we will create a byte array mask for all the bits in the
+        # field and apply it to entire prefix, zeroing out the bits that should
+        # not be part of the prefix.
+        mask = ((1 << length) - 1) << (field_info.bitwidth - length)
+        nbytes = (field_info.bitwidth + 7) // 8
+        bytes_mask = bytearray(mask.to_bytes(nbytes, byteorder='big'))
+
+        # Prefix len is aligned to num of byte needed to represent bitwidth in parsing stage.
+        if len(bytes_mask) != len(prefix):  # Should not happen, safety check.
+            raise UserError("Invalid prefix length")
+
+        transformed = False
+        for i in range(len(bytes_mask)):
+            if barray[i] & bytes_mask[i] != barray[i]:
                 transformed = True
-                barray[i] = 0
+                barray[i] = barray[i] & bytes_mask[i]
+        
         if transformed:
             _print("LPM value was transformed to conform to the P4Runtime spec "
                    "(trailing bits must be unset)")
+
         mf.lpm.value = bytes(bytes_utils.make_canonical_if_option_set(barray))
         return mf