more rewording and refactoring

Author: Changaco

libarchive/entry.py

@@ -4,6 +4,7 @@
 import math
 
 from . import ffi
+from .exception import ArchiveError
 
 
 class FileType(IntEnum):
@@ -86,12 +87,12 @@ def modify(self, header_codec=None, **attributes):
             rdev (int | Tuple[int, int]): device number, if the file is a device
             rdevmajor (int): major part of the device number
             rdevminor (int): minor part of the device number
-            md5digest (bytes): MD5 digest
-            rmd160digest (bytes): RMD160 digest
-            sha1digest (bytes): SHA1 digest
-            sha256digest (bytes): SHA256 digest
-            sha384digest (bytes): SHA384 digest
-            sha512digest (bytes): SHA512 digest
+            md5 (bytes): MD5 digest
+            rmd160 (bytes): RMD160 digest
+            sha1 (bytes): SHA1 digest
+            sha256 (bytes): SHA256 digest
+            sha384 (bytes): SHA384 digest
+            sha512 (bytes): SHA512 digest
         """
         if header_codec:
             self.header_codec = header_codec
@@ -440,79 +441,93 @@ def rdevminor(self, value):
         ffi.entry_set_rdevminor(self._entry_p, value)
 
     @property
-    def md5digest(self):
-        return self._digest(ffi.ARCHIVE_ENTRY_DIGEST_MD5)
+    def md5(self):
+        return self.get_stored_digest('md5')
 
-    @md5digest.setter
-    def md5digest(self, value):
-        self._set_digest(ffi.ARCHIVE_ENTRY_DIGEST_MD5, value)
+    @md5.setter
+    def md5(self, value):
+        self.set_stored_digest('md5', value)
 
     @property
-    def rmd160digest(self):
-        return self._digest(ffi.ARCHIVE_ENTRY_DIGEST_RMD160)
+    def rmd160(self):
+        return self.get_stored_digest('rmd160')
 
-    @rmd160digest.setter
-    def rmd160digest(self, value):
-        self._set_digest(ffi.ARCHIVE_ENTRY_DIGEST_RMD160, value)
+    @rmd160.setter
+    def rmd160(self, value):
+        self.set_stored_digest('rmd160', value)
 
     @property
-    def sha1digest(self):
-        return self._digest(ffi.ARCHIVE_ENTRY_DIGEST_SHA1)
+    def sha1(self):
+        return self.get_stored_digest('sha1')
 
-    @sha1digest.setter
-    def sha1digest(self, value):
-        self._set_digest(ffi.ARCHIVE_ENTRY_DIGEST_SHA1, value)
+    @sha1.setter
+    def sha1(self, value):
+        self.set_stored_digest('sha1', value)
 
     @property
-    def sha256digest(self):
-        return self._digest(ffi.ARCHIVE_ENTRY_DIGEST_SHA256)
+    def sha256(self):
+        return self.get_stored_digest('sha256')
 
-    @sha256digest.setter
-    def sha256digest(self, value):
-        self._set_digest(ffi.ARCHIVE_ENTRY_DIGEST_SHA256, value)
+    @sha256.setter
+    def sha256(self, value):
+        self.set_stored_digest('sha256', value)
 
     @property
-    def sha384digest(self):
-        return self._digest(ffi.ARCHIVE_ENTRY_DIGEST_SHA384)
+    def sha384(self):
+        return self.get_stored_digest('sha384')
 
-    @sha384digest.setter
-    def sha384digest(self, value):
-        self._set_digest(ffi.ARCHIVE_ENTRY_DIGEST_SHA384, value)
+    @sha384.setter
+    def sha384(self, value):
+        self.set_stored_digest('sha384', value)
 
     @property
-    def sha512digest(self):
-        return self._digest(ffi.ARCHIVE_ENTRY_DIGEST_SHA512)
+    def sha512(self):
+        return self.get_stored_digest('sha512')
 
-    @sha512digest.setter
-    def sha512digest(self, value):
-        self._set_digest(ffi.ARCHIVE_ENTRY_DIGEST_SHA512, value)
+    @sha512.setter
+    def sha512(self, value):
+        self.set_stored_digest('sha512', value)
 
-    def _digest(self, digest_type):
+    def get_stored_digest(self, algorithm_name):
+        algorithm = ffi.DIGEST_ALGORITHMS[algorithm_name]
         try:
-            ptr = ffi.entry_digest(self._entry_p, digest_type)
-            if ptr:
-                return bytes(ptr[:ffi._DIGEST_LENGTHS[digest_type - 1]])
+            ptr = ffi.entry_digest(self._entry_p, algorithm.libarchive_id)
         except AttributeError:
-            raise NotImplementedError(f"the libarchive being used (version "
-                                      f"{ffi.version_number()} path "
-                                      f"{ffi.libarchive_path}) doesn't "
-                                      f"support read-only digest APIs")
-        return None
-
-    def _set_digest(self, digest_type, value):
+            raise NotImplementedError(
+                f"the libarchive being used (version {ffi.version_number()}, path "
+                f"{ffi.libarchive_path}) doesn't support reading entry digests"
+            ) from None
+        except ArchiveError:
+            raise NotImplementedError(
+                f"the libarchive being used (version {ffi.version_number()}, path "
+                f"{ffi.libarchive_path}) doesn't support {algorithm_name} digests"
+            ) from None
+        return bytes(ptr[:algorithm.bytes_length])
+
+    def set_stored_digest(self, algorithm_name, value):
+        algorithm = ffi.DIGEST_ALGORITHMS[algorithm_name]
+        expected_length = algorithm.bytes_length
+        if len(value) != expected_length:
+            raise ValueError(
+                f"invalid input digest: expected {expected_length} bytes, "
+                f"got {len(value)}"
+            )
         try:
-            digest_length = ffi._DIGEST_LENGTHS[digest_type - 1]
-            if len(value) != digest_length:
-                raise ValueError(f"Invalid input digest Expected {digest_length} "
-                                 f"bytes. Got {len(value)}.")
-            buffer = (digest_length * ffi.c_ubyte)(*value)
-            ffi.entry_set_digest(self._entry_p, digest_type, buffer)
+            retcode = ffi.entry_set_digest(
+                self._entry_p,
+                algorithm.libarchive_id,
+                (expected_length * ffi.c_ubyte)(*value)
+            )
         except AttributeError:
-            raise NotImplementedError(f"the libarchive being used (version "
-                                      f"{ffi.version_number()} path "
-                                      f"{ffi.libarchive_path}) doesn't support "
-                                      f"writable digest APIs")
-        return None
+            raise NotImplementedError(
+                f"the libarchive being used (version {ffi.version_number()}, path "
+                f"{ffi.libarchive_path}) doesn't support writing entry digests"
+            ) from None
+        if retcode < 0:
+            raise NotImplementedError(
+                f"the libarchive being used (version {ffi.version_number()}, path "
+                f"{ffi.libarchive_path}) doesn't support {algorithm_name} digests"
+            ) from None
 
 
 class ConsumedArchiveEntry(ArchiveEntry):

libarchive/ffi.py

@@ -366,38 +366,41 @@ def get_write_filter_function(filter_name):
         f"path {libarchive_path}) doesn't support encryption"
     )
 
-# archive digest API
-try:
-    ffi('entry_digest', [c_archive_entry_p, c_int], POINTER(c_ubyte))
-
-    ARCHIVE_ENTRY_DIGEST_MD5 = 1
-    ARCHIVE_ENTRY_DIGEST_RMD160 = 2
-    ARCHIVE_ENTRY_DIGEST_SHA1 = 3
-    ARCHIVE_ENTRY_DIGEST_SHA256 = 4
-    ARCHIVE_ENTRY_DIGEST_SHA384 = 5
-    ARCHIVE_ENTRY_DIGEST_SHA512 = 6
-
-    _DIGEST_LENGTHS = [
-        16,  # MD5
-        20,  # RMD160
-        20,  # SHA1
-        32,  # SHA256
-        48,  # SHA384
-        64,  # SHA512
-    ]
 
+# archive entry digests (a.k.a. hashes)
+
+class DigestAlgorithm:
+    __slots__ = ('name', 'libarchive_id', 'bytes_length')
+
+    def __init__(self, name, libarchive_id, bytes_length):
+        self.name = name
+        self.libarchive_id = libarchive_id
+        self.bytes_length = bytes_length
+
+
+DIGEST_ALGORITHMS = {
+    'md5': DigestAlgorithm('md5', libarchive_id=1, bytes_length=16),
+    'rmd160': DigestAlgorithm('rmd160', libarchive_id=2, bytes_length=20),
+    'sha1': DigestAlgorithm('sha1', libarchive_id=3, bytes_length=20),
+    'sha256': DigestAlgorithm('sha256', libarchive_id=4, bytes_length=32),
+    'sha384': DigestAlgorithm('sha384', libarchive_id=5, bytes_length=48),
+    'sha512': DigestAlgorithm('sha512', libarchive_id=6, bytes_length=64),
+}
+
+try:
+    ffi('entry_digest', [c_archive_entry_p, c_int], POINTER(c_ubyte), check_null)
 except AttributeError:
     logger.info(
         f"the libarchive being used (version {version_number()}, "
-        f"path {libarchive_path}) doesn't support read-only message digest API"
+        f"path {libarchive_path}) doesn't support reading entry digests"
     )
 
 try:
     ffi('entry_set_digest',
-        [ctypes.c_void_p, ctypes.c_int, ctypes.POINTER(ctypes.c_ubyte)],
-        ctypes.c_int)
+        [c_archive_entry_p, c_int, POINTER(c_ubyte)],
+        c_int, check_int)
 except AttributeError:
     logger.info(
         f"the libarchive being used (version {version_number()}, "
-        f"path {libarchive_path}) doesn't support mutable message digest API"
+        f"path {libarchive_path}) doesn't support modifying entry digests"
     )