bsdiff4 1.4.1__tar.gz → 1.4.2__tar.gz

{bsdiff4-1.4.1/bsdiff4.egg-info → bsdiff4-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bsdiff4
-Version: 1.4.1
+Version: 1.4.2
 Summary: binary diff and patch using the BSDIFF4-format
 Home-page: https://github.com/ilanschnell/bsdiff4
 Author: Ilan Schnell
@@ -47,9 +47,11 @@ Key features of this package include:
 
 * high-level ``diff`` and ``patch`` functions
 * an interface to the BSDIFF4 format
-* improved error handling for malformed patches
+* stricter validation and improved error handling of malformed patches than
+  the standard ``bspatch`` tool; in particular overlong blocks are rejected
 * functions for creating patches from files and applying them to files
-* command-line interfaces: ``bsdiff4`` and ``bspatch4``
+* command-line interfaces: ``bsdiff4`` and ``bspatch4`` (the latter can also
+  inspect patches using ``bspatch4 PATCH``)
 * support for free-threaded Python
 * type hints
 * extensive tests
@@ -65,15 +67,15 @@ The bsdiff4 package defines the following high level functions:
    Apply the BSDIFF4-format ``patch_bytes`` to ``src_bytes`` and return
    the bytes.
 
-``file_diff(src_path, dst_path, patch_path)``
+``file_diff(src_path, dst_path, patch_path)`` -> None
    Write a BSDIFF4-format patch (from the file ``src_path`` to the
    file ``dst_path``) to the file ``patch_path``.
 
-``file_patch(src_path, dst_path, patch_path)``
+``file_patch(src_path, dst_path, patch_path)`` -> None
    Apply the BSDIFF4-format file ``patch_path`` to the file ``src_path``
    and write the result to the file ``dst_path``.
 
-``file_patch_inplace(path, patch_path)``
+``file_patch_inplace(path, patch_path)`` -> None
    Apply the BSDIFF4-format file ``patch_path`` to the file ``path``
    in place.
 

{bsdiff4-1.4.1 → bsdiff4-1.4.2}/README.rst

@@ -11,9 +11,11 @@ Key features of this package include:
 
 * high-level ``diff`` and ``patch`` functions
 * an interface to the BSDIFF4 format
-* improved error handling for malformed patches
+* stricter validation and improved error handling of malformed patches than
+  the standard ``bspatch`` tool; in particular overlong blocks are rejected
 * functions for creating patches from files and applying them to files
-* command-line interfaces: ``bsdiff4`` and ``bspatch4``
+* command-line interfaces: ``bsdiff4`` and ``bspatch4`` (the latter can also
+  inspect patches using ``bspatch4 PATCH``)
 * support for free-threaded Python
 * type hints
 * extensive tests
@@ -29,15 +31,15 @@ The bsdiff4 package defines the following high level functions:
    Apply the BSDIFF4-format ``patch_bytes`` to ``src_bytes`` and return
    the bytes.
 
-``file_diff(src_path, dst_path, patch_path)``
+``file_diff(src_path, dst_path, patch_path)`` -> None
    Write a BSDIFF4-format patch (from the file ``src_path`` to the
    file ``dst_path``) to the file ``patch_path``.
 
-``file_patch(src_path, dst_path, patch_path)``
+``file_patch(src_path, dst_path, patch_path)`` -> None
    Apply the BSDIFF4-format file ``patch_path`` to the file ``src_path``
    and write the result to the file ``dst_path``.
 
-``file_patch_inplace(path, patch_path)``
+``file_patch_inplace(path, patch_path)`` -> None
    Apply the BSDIFF4-format file ``patch_path`` to the file ``path``
    in place.
 

{bsdiff4-1.4.1 → bsdiff4-1.4.2}/bsdiff4/__init__.py

@@ -1,11 +1,15 @@
 from bsdiff4.format import (diff, patch, file_diff, file_patch,
                             file_patch_inplace)
 
-__version__ = "1.4.1"
+__version__ = "1.4.2"
 
 __all__ = ["diff", "patch", "file_diff", "file_patch", "file_patch_inplace"]
 
 
 def test(verbosity=1):
-    from .test_all import run
+    """test(verbosity=1) -> TextTestResult
+
+    Run self-test, and return `unittest.runner.TextTestResult` object.
+    """
+    from bsdiff4.tests import run
     return run(verbosity=verbosity)

bsdiff4-1.4.2/bsdiff4/cli.py

@@ -0,0 +1,145 @@
+import sys
+from argparse import ArgumentParser
+from os.path import getsize
+
+import bsdiff4.core as core  # type: ignore
+from bsdiff4 import __version__
+from bsdiff4.format import (file_diff, file_patch, read_patch,
+                            unpack_header, unpack_control_block)
+
+
+def human_bytes(n):
+    """
+    return the number of bytes 'n' in more human readable form
+    """
+    if n < 1024:
+        return '%d B' % n
+    k = n / 1024
+    if k < 1024:
+        return '%.1f K' % k
+    m = k / 1024
+    if m < 1024:
+        return '%.1f M' % m
+    g = m / 1024
+    return '%.2f G' % g
+
+
+def show_filesizes(*args):
+    for i, name in enumerate(['src', 'dst', 'patch']):
+        size = getsize(args[i])
+        print('%s: %s (%s)' % (name, args[i], human_bytes(size)))
+
+
+def show_header(fi):
+    total_len = fi.seek(0, 2)  # go to EOF and return position
+    fi.seek(0)
+    control_len, diff_len, dst_len = unpack_header(fi.read(32))
+    print("sizes:")
+    for name, size in [
+        ('total', total_len),
+        ('control', control_len),
+        ('diff', diff_len),
+        ('extra', total_len - 32 - control_len - diff_len),
+        ('dst', dst_len),
+    ]:
+        print('%10s: %10d (%s)' % (name, size, human_bytes(size)))
+
+
+def show_control(control_block, verbose=False):
+    print('\nnumber of control tuples: %d' % (len(control_block) // 24))
+    print('%10s %10s %10s %10s' % ('x', 'y', 'z', 'src pos'))
+    omitted = False
+    src_pos = 0
+    totals = (0, 0)  # x, y totals
+    for i, (x, y, z) in enumerate(unpack_control_block(control_block)):
+        if i < 5 or verbose:
+            print('%10d %10d %10d %10d' % (x, y, z, src_pos))
+        else:
+            omitted = True
+        totals = (totals[0] + x, totals[1] + y)
+        src_pos += x + z
+
+    if omitted:
+        print('%10s %10s %10s' % (3 * ('...',)))
+    print('%10s %10s' % (2 * ('------',)))
+    print('%10d %10d' % totals)
+
+
+def show_patch(fi, verbose=False):
+    show_header(fi)
+    fi.seek(0)
+    control_block, diff_block, extra_block = read_patch(fi)
+    print("\nuncompressed block sizes:")
+    for name, size in [
+        ('control', len(control_block)),
+        ('diff', len(diff_block)),
+        ('extra', len(extra_block)),
+    ]:
+        note = ""
+        if name == 'diff' and diff_block:
+            nonzero = len(diff_block) - diff_block.count(b'\x00')
+            note = '  (non-zero bytes: %d)' % nonzero
+        print('%10s: %10d (%s)%s' % (name, size, human_bytes(size), note))
+
+    show_control(control_block, verbose)
+    # validate patch by applying it to empty source
+    core.patch(b'', control_block, diff_block, extra_block)
+
+
+def main_bsdiff4():
+    """
+    Generate a BSDIFF4-format PATCH from SRC to DST and write it to PATCH.
+    """
+    p = ArgumentParser(description=main_bsdiff4.__doc__)
+    p.add_argument('-v', '--verbose', action='store_true',
+                   help="show file sizes")
+    p.add_argument('--version', action='version',
+                   version="bsdiff4 %s" % __version__)
+    p.add_argument('src', metavar='SRC')
+    p.add_argument('dst', metavar='DST')
+    p.add_argument('patch', metavar='PATCH')
+    args = p.parse_args()
+
+    paths = args.src, args.dst, args.patch
+    try:
+        file_diff(*paths)
+    except (OSError, MemoryError) as e:
+        sys.exit("%s: %s" % (p.prog, str(e) or type(e).__name__))
+    if args.verbose:
+        show_filesizes(*paths)
+
+
+def main_bspatch4():
+    """
+    Generate DST by applying the BSDIFF4-format PATCH file to SRC;
+    with only PATCH, display information about and verify the patch.
+    """
+    p = ArgumentParser(
+        usage="%(prog)s [options] SRC DST PATCH\n"
+              "       %(prog)s [options] PATCH",
+        description=main_bspatch4.__doc__,
+    )
+    p.add_argument('-v', '--verbose', action='store_true',
+                   help="show file sizes or all control tuples")
+    p.add_argument('--version', action='version',
+                   version="bsdiff4 %s" % __version__)
+    p.add_argument('paths', nargs='+', metavar='PATH')
+    args = p.parse_args()
+
+    if len(args.paths) == 1:
+        try:
+            with open(args.paths[0], 'rb') as fi:
+                show_patch(fi, args.verbose)
+        except (ValueError, OSError, MemoryError) as e:
+            sys.exit("%s: %s" % (p.prog, str(e) or type(e).__name__))
+        return
+
+    if len(args.paths) != 3:
+        p.error("requires either PATCH or SRC DST PATCH")
+
+    try:
+        file_patch(*args.paths)
+    except (ValueError, OSError, MemoryError) as e:
+        sys.exit("%s: %s" % (p.prog, str(e) or type(e).__name__))
+    if args.verbose:
+        show_filesizes(*args.paths)

{bsdiff4-1.4.1 → bsdiff4-1.4.2}/bsdiff4/core.c

@@ -7,6 +7,7 @@
 
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
+#include <assert.h>
 #include <stdint.h>
 
 
@@ -109,6 +110,9 @@ split(Py_ssize_t *sa, Py_ssize_t *rank, Py_ssize_t start,
     }
 
     partition_group(sa, rank, start, len, h, &lower, &upper);
+    assert(start <= lower);
+    assert(lower < upper);
+    assert(upper <= start + len);
 
     if (lower > start)
         split(sa, rank, start, lower - start, h);
@@ -214,7 +218,7 @@ matchlen(const char *a, Py_ssize_t a_len,
     return i;
 }
 
-/* return the longest prefix-match length and store its position in *pos */
+/* find a prefix match using the suffix array */
 static Py_ssize_t
 search(const Py_ssize_t *sa,
        const char *a, Py_ssize_t a_len,
@@ -446,6 +450,11 @@ compute_diff(const char *src, Py_ssize_t src_len,
             adjust_overlap(src, dst, lastscan, lastpos, scan, pos,
                            &lenf, &lenb);
 
+            assert(lenf >= 0 && lenb >= 0);
+            assert(lastpos >= 0 && lenf <= src_len - lastpos);
+            assert(lastscan >= 0 && lenf <= dst_len - lastscan);
+            assert(lastscan + lenf <= scan - lenb);
+
             for (i = 0; i < lenf; i++)
                 result->diff[result->diff_len + i] =
                     dst[lastscan + i] - src[lastpos + i];
@@ -468,6 +477,9 @@ compute_diff(const char *src, Py_ssize_t src_len,
     }
 
     PyMem_Free(sa);
+    assert(result->diff_len <= dst_len);
+    assert(result->extra_len == dst_len - result->diff_len);
+    assert(PyByteArray_GET_SIZE(result->control) % 24 == 0);
     return 0;
 
 error:
@@ -514,7 +526,9 @@ mod_diff(PyObject *module, PyObject *args)
     char *src, *dst;
     PyObject *result;
 
-    if (!PyArg_ParseTuple(args, "s#s#", &src, &src_len, &dst, &dst_len))
+    if (!PyArg_ParseTuple(args, "s#s#",
+                          &src, &src_len,
+                          &dst, &dst_len))
         return NULL;
 
     if (compute_diff(src, src_len, dst, dst_len, &diff) < 0)
@@ -576,17 +590,19 @@ mod_patch(PyObject *module, PyObject *args)
     Py_ssize_t dst_pos = 0, i;
     int64_t src_pos = 0;
 
-    if (!PyArg_ParseTuple(args, "s#ns#s#s#",
-                          &src, &src_len, &dst_len,
+    if (!PyArg_ParseTuple(args, "s#s#s#s#",
+                          &src, &src_len,
                           &control_block, &control_len,
                           &diff_block, &diff_remaining,
                           &extra_block, &extra_remaining))
         return NULL;
 
-    if (dst_len < 0) {
-        CORRUPT("negative destination length");
+    if (diff_remaining > PY_SSIZE_T_MAX - extra_remaining) {
+        PyErr_NoMemory();
         return NULL;
     }
+    dst_len = diff_remaining + extra_remaining;
+
     if (control_len % 24) {
         CORRUPT("invalid control block");
         return NULL;
@@ -608,10 +624,11 @@ mod_patch(PyObject *module, PyObject *args)
         memcpy(dst + dst_pos, diff_block, x);
         diff_block += x;
         diff_remaining -= x;
-        /* Check bounds without overflowing src_pos + j. */
-        for (j = 0; j < x; j++)
+        for (j = 0; j < x; j++) {
+            /* Check bounds without overflowing src_pos + j. */
             if (src_pos >= -j && src_pos < src_len - j)
                 dst[dst_pos + j] += src[src_pos + j];
+        }
         dst_pos += x;
         if (y < 0 || y > dst_len - dst_pos || y > extra_remaining) {
             CORRUPT("y out of range");
@@ -630,10 +647,7 @@ mod_patch(PyObject *module, PyObject *args)
         CORRUPT("incomplete output");
         goto error;
     }
-    if (diff_remaining != 0 || extra_remaining != 0) {
-        CORRUPT("unused block data");
-        goto error;
-    }
+    assert(diff_remaining == 0 && extra_remaining == 0);
 
     return result;
 

{bsdiff4-1.4.1 → bsdiff4-1.4.2}/bsdiff4/format.py

@@ -9,17 +9,15 @@ MAGIC = b'BSDIFF40'
 
 
 def pack_header(control_len, diff_len, dst_len):
-    return (MAGIC +
-            core.encode_int64(control_len) +
-            core.encode_int64(diff_len) +
-            core.encode_int64(dst_len))
+    lengths = control_len, diff_len, dst_len
+    return MAGIC + b''.join(core.encode_int64(n) for n in lengths)
 
 
 def unpack_header(header):
     if len(header) != 32:
         raise ValueError("invalid header size")
-    if header[:7] != MAGIC[:7]:
-        raise ValueError("invalid magic bsdiff4 header")
+    if header[:8] != MAGIC:
+        raise ValueError("invalid BSDIFF40 magic header, got %r" % header[:8])
     return tuple(core.decode_int64(header[i:i + 8]) for i in range(8, 32, 8))
 
 
@@ -34,7 +32,6 @@ def unpack_control_block(control_block):
     "unpack the binary control block and generate control tuples"
     if len(control_block) % 24:
         raise ValueError("invalid control block")
-
     for i in range(0, len(control_block), 24):
         yield tuple(core.decode_int64(control_block[j:j + 8])
                     for j in range(i, i + 24, 8))
@@ -62,14 +59,19 @@ def read_patch(fi):
         check_size(size)
     control_len, diff_len, dst_len = sizes
     control_block = bz2.decompress(read_exact(fi, control_len))
+    if len(control_block) % 24:
+        raise ValueError("invalid control block")
     diff_block = bz2.decompress(read_exact(fi, diff_len))
     extra_block = bz2.decompress(fi.read())
-    return dst_len, control_block, diff_block, extra_block
+    if dst_len != len(diff_block) + len(extra_block):
+        raise ValueError("invalid destination length")
+    return control_block, diff_block, extra_block
 
 
-def write_patch(fo, dst_len, control_block, diff_block, extra_block):
+def write_patch(fo, control_block, diff_block, extra_block):
     "write a BSDIFF4-format patch to stream 'fo'"
     # compress each block
+    dst_len = len(diff_block) + len(extra_block)
     control_block = bz2.compress(control_block)
     diff_block = bz2.compress(diff_block)
     extra_block = bz2.compress(extra_block)
@@ -90,21 +92,9 @@ def diff(src_bytes: bytes, dst_bytes: bytes) -> bytes:
 
     Return a BSDIFF4-format patch (from src_bytes to dst_bytes) as bytes.
     """
-    faux = BytesIO()
-    write_patch(faux, len(dst_bytes), *core.diff(src_bytes, dst_bytes))
-    return faux.getvalue()
-
-
-def file_diff(src_path: str, dst_path: str, patch_path: str) -> None:
-    """file_diff(src_path, dst_path, patch_path)
-
-    Write a BSDIFF4-format patch (from the file src_path to the file dst_path)
-    to the file patch_path.
-    """
-    src = read_data(src_path)
-    dst = read_data(dst_path)
-    with open(patch_path, 'wb') as fo:
-        write_patch(fo, len(dst), *core.diff(src, dst))
+    fo = BytesIO()
+    write_patch(fo, *core.diff(src_bytes, dst_bytes))
+    return fo.getvalue()
 
 
 def patch(src_bytes: bytes, patch_bytes: bytes) -> bytes:
@@ -115,31 +105,38 @@ def patch(src_bytes: bytes, patch_bytes: bytes) -> bytes:
     return core.patch(src_bytes, *read_patch(BytesIO(patch_bytes)))
 
 
+def file_diff(src_path: str, dst_path: str, patch_path: str) -> None:
+    """file_diff(src_path, dst_path, patch_path) -> None
+
+    Write a BSDIFF4-format patch (from the file src_path to the file dst_path)
+    to the file patch_path.
+    """
+    blocks = core.diff(read_data(src_path), read_data(dst_path))
+    with open(patch_path, 'wb') as fo:
+        write_patch(fo, *blocks)
+
+
 def file_patch_inplace(path: str, patch_path: str) -> None:
-    """file_patch_inplace(path, patch_path)
+    """file_patch_inplace(path, patch_path) -> None
 
     Apply the BSDIFF4-format file patch_path to the file 'path' in place.
     """
     with open(patch_path, 'rb') as fi:
-        with open(path, 'r+b') as fo:
-            data = fo.read()
-            fo.seek(0)
-            fo.write(core.patch(data, *read_patch(fi)))
-            fo.truncate()
+        blocks = read_patch(fi)
+    with open(path, 'r+b') as f:
+        dst = core.patch(f.read(), *blocks)
+        f.seek(0)
+        f.write(dst)
+        f.truncate()
 
 
 def file_patch(src_path: str, dst_path: str, patch_path: str) -> None:
-    """file_patch(src_path, dst_path, patch_path)
+    """file_patch(src_path, dst_path, patch_path) -> None
 
     Apply the BSDIFF4-format file patch_path to the file src_path and
     write the result to the file dst_path.
     """
-    from os.path import abspath
-
-    if abspath(dst_path) == abspath(src_path):
-        file_patch_inplace(src_path, patch_path)
-        return
-
     with open(patch_path, 'rb') as fi:
-        with open(dst_path, 'wb') as fo:
-            fo.write(core.patch(read_data(src_path), *read_patch(fi)))
+        dst = core.patch(read_data(src_path), *read_patch(fi))
+    with open(dst_path, 'wb') as fo:
+        fo.write(dst)

bsdiff4-1.4.1/bsdiff4/test_all.py → bsdiff4-1.4.2/bsdiff4/tests.py

@@ -6,14 +6,15 @@ import shutil
 import unittest
 import tempfile
 from io import BytesIO
+from os.path import exists, samefile
 from sysconfig import get_config_var
 from concurrent.futures import ThreadPoolExecutor
 from threading import Barrier
 
 import bsdiff4.core as core  # type: ignore
-from bsdiff4.format import (MAGIC, pack_header, unpack_header,
+from bsdiff4.format import (pack_header, unpack_header,
                             pack_control_block, unpack_control_block,
-                            write_patch, read_patch, read_data)
+                            write_patch, read_patch)
 from bsdiff4 import diff, patch, file_diff, file_patch, file_patch_inplace
 
 
@@ -49,12 +50,12 @@ class TestCoreInt64(unittest.TestCase):
             core.decode_int64(bytes.fromhex('00 00 00 00 00 00 00 80')), 0)
 
     def test_errors(self):
-        self.assertRaises(TypeError, core.encode_int64, 'x')
+        self.assertRaises(TypeError, core.encode_int64, 8 * b'\x00')
         M = 1 << 63
         for n in -M -1, -M, M, M + 1:
             self.assertRaises(OverflowError, core.encode_int64, n)
 
-        self.assertRaises(TypeError, core.decode_int64, 12345)
+        self.assertRaises(TypeError, core.decode_int64, 0)
         for n in 0, 1, 7, 9, 16:
             self.assertRaisesRegex(ValueError, "8 bytes expected",
                                    core.decode_int64, n * b'\x00')
@@ -98,6 +99,8 @@ class TestSuffixArray(unittest.TestCase):
         self.check_data(os.urandom(1000))
 
 
+RND_200 = os.urandom(200)
+
 ROUND_TRIP_CASES = [
     (b'', b''),
     (b'', b'x'),
@@ -107,19 +110,22 @@ ROUND_TRIP_CASES = [
     (b'abc', b'xbc'),
     (b'abc', b'xybc'),
     (b'123456789 987654321', b'123456789000987654321'),  # issue #14
-    (b'', os.urandom(200)),
-    (os.urandom(200), os.urandom(200)),
+    (b'', RND_200),
+    (RND_200, RND_200),
+    (RND_200, os.urandom(20) + RND_200),
+    (RND_200, RND_200 + os.urandom(20)),
 ]
 
+BYTES_CASES = [b'', b'a', b'abc', 100 * b'a', RND_200]
+
 
 class TestCoreDiffPatch(unittest.TestCase):
 
     def round_trip(self, src, dst):
-        control_block, diff_block, extra_block = core.diff(src, dst)
-        for b in control_block, diff_block, extra_block:
-            self.assertIs(type(b), bytes)
-        dst2 = core.patch(src, len(dst),
-                          control_block, diff_block, extra_block)
+        blocks = core.diff(src, dst)
+        for block in blocks:
+            self.assertIs(type(block), bytes)
+        dst2 = core.patch(src, *blocks)
         self.assertIs(type(dst2), bytes)
         self.assertEqual(dst2, dst)
 
@@ -128,117 +134,167 @@ class TestCoreDiffPatch(unittest.TestCase):
             self.round_trip(a, b)
             self.round_trip(b, a)
 
-    def test_diff_blocks(self):
+    def check_diff_blocks(self, src, dst, controls, diff, extra):
         # Check construction of control, diff and extra blocks.
-        self.assertEqual(core.diff(b'banana', b'bandana'),
-                         (pack_control_block((3, 4, 2)),
-                          3 * b'\x00', b'dana'))
-
+        blocks = core.diff(src, dst)
+        self.assertEqual(list(unpack_control_block(blocks[0])), controls)
+        self.assertEqual(blocks[1], diff)
+        self.assertEqual(blocks[2], extra)
+        self.assertEqual(core.patch(src, *blocks), dst)
+
+    def test_diff_simple_example(self):
+        self.check_diff_blocks(b'banana', b'bandana',
+                               [(3, 4, 2)], 3 * b'\x00', b'dana')
+
+    def test_nonzero_diff(self):
+        src = b"The quick brown fox jumps over the lazy dog."
+        dst = b"The quick brown fox jumps over the hazy dog."
+        n = len(src)
+        diff = bytearray(n)
+        diff[35] = (ord(b'h') - ord(b'l')) & 0xff
+        self.check_diff_blocks(src, dst, [(n, 0, -8)], bytes(diff), b'')
+
+    def test_diff_insert_byte(self):
         src = 32 * b'a'
-        dst = 16 * b'a' + b'b' + 16 * b'a'
-        self.assertEqual(core.diff(src, dst),
-                         (pack_control_block((32, 1, -1)),
-                          16 * b'\x00' + b'\x01' + 15 * b'\x00', b'a'))
-
-        src = 100 * b'a' + 100 * b'b'
-        dst = 100 * b'b' + 100 * b'a'
-        self.assertEqual(core.diff(src, dst),
-                         (pack_control_block((0, 100, 0), (100, 0, -100)),
-                          100 * b'\x00', 100 * b'b'))
+        dst = src[:16] + b'b' + src[16:]
+        self.check_diff_blocks(src, dst, [(32, 1, -1)],
+                               diff=16 * b'\x00' + b'\x01' + 15 * b'\x00',
+                               extra=b'a')
+
+    def test_diff_swap_repeated_blocks(self):
+        A, B = 100 * b'A', 100 * b'B'
+        self.check_diff_blocks(A + B, B + A,
+                               [(0, 100, 0), (100, 0, -100)],
+                               diff=100 * b'\x00', extra=B)
+
+    def test_diff_swap_blocks(self):
+        src = bytes(range(200))
+        dst = src[100:] + src[:100]
+        self.check_diff_blocks(src, dst,
+                               [(0, 0, 100), (100, 0, -200), (100, 0, -100)],
+                               diff=200 * b'\x00', extra=b'')
 
     def test_diff_adjust_overlap(self):
         # Ensure that an overlapping byte is assigned to the better
         # matching block.
-        self.assertEqual(core.diff(b'ccccdabcadcb', b'ccccdcdabcadcb'),
-                         (pack_control_block((5, 0, -2), (9, 0, -9)),
-                          14 * b'\x00', b''))
+        self.check_diff_blocks(b'ccccdabcadcb',
+                               b'ccccdcdabcadcb',
+                               [(5, 0, -2), (9, 0, -9)],
+                               14 * b'\x00', b'')
+
+    def test_empty_dst(self):
+        for src in BYTES_CASES:
+            self.check_diff_blocks(src, b'', [], b'', b'')
+
+    def test_empty_src(self):
+        for dst in BYTES_CASES:
+            self.check_diff_blocks(b'', dst,
+                                   [(0, len(dst), 0)] if dst else [],
+                                   diff=b'', extra=dst)
+
+    def test_identical_src_dst(self):
+        for src in BYTES_CASES:
+            control, diff, extra = core.diff(src, src)
+            controls = list(unpack_control_block(control))
+
+            if src:
+                self.assertEqual(len(controls), 1)
+                x, y, z = controls[0]
+                self.assertEqual(x, len(src))
+                self.assertEqual(y, 0)
+                # final source-position adjustment z does not affect output
+            else:
+                self.assertEqual(controls, [])
+
+            self.assertEqual(diff, len(src) * b'\x00')
+            self.assertEqual(extra, b'')
+            self.assertEqual(core.patch(src, control, diff, extra), src)
+
+    def test_patch_addition(self):
+        src = bytes(range(256))
+        dst = bytes((value + 1) % 256 for value in src)
+        bcontrol = pack_control_block((len(src), 0, 0))
+        blocks = bcontrol, len(src) * b'\x01', b''
+        self.assertEqual(core.patch(src, *blocks), dst)
 
     def test_patch(self):
-        for controls in [
-            [(3, 4, 2)],
-            [(3, 4, 2), (0, 0, 0)],  # (0, 0, 0) is a no-op control tuple
-            [(0, 0, 0), (3, 4, 2)],
+        noop = pack_control_block((0, 0, 0))  # no-op control tuple
+        noop2 = 3 * (7 * b'\x00' + b'\x80')   # negative zero no-op
+        operation = pack_control_block((3, 4, 2))
+        for bcontrol in [
+            operation,
+            noop + operation + noop,
+            noop2 + operation + noop + noop2,
         ]:
-            dst = core.patch(b'banana', 7, pack_control_block(*controls),
-                             3 * b'\x00', b'dana')
+            dst = core.patch(b'banana', bcontrol, 3 * b'\x00', b'dana')
             self.assertEqual(dst, b'bandana')
 
         # The control block must be binary data, not a list of tuples.
-        self.assertRaises(TypeError, core.patch, b'', 0, [], b'', b'')
+        self.assertRaises(TypeError, core.patch, b'', [], b'', b'')
 
     # ----- Patch edge cases and error handling -----
 
+    def assert_corrupt(self, reason, control=b'', diff=b'', extra=b''):
+        msg = r"corrupt patch \(%s\)" % reason
+        with self.assertRaisesRegex(ValueError, msg):
+            core.patch(b'', control, diff, extra)
+
     def test_x_y_out_of_range(self):
+        # regression test for PR #29
         for control, var_name in [((-1, 0, 0), 'x'),
                                   ((0, -1, 0), 'y'),
                                   ((5, 0, 0), 'x'),
                                   ((0, 5, 0), 'y')]:
             bcontrol = pack_control_block(control)
-            msg = r"corrupt patch \(%s out of range\)" % var_name
-            self.assertRaisesRegex(ValueError, msg,
-                                   core.patch, b'abcd', 4,
-                                   bcontrol, 4 * b'\x00', b'')
-
-    def test_negative_destination_length(self):
-        msg = r"corrupt patch \(negative destination length\)"
-        self.assertRaisesRegex(ValueError, msg,
-                               core.patch, b'', -1, b'', b'', b'')
+            self.assert_corrupt("%s out of range" % var_name,
+                                bcontrol, diff=4 * b'\x00', extra=b'abcd')
 
     def test_invalid_control_block(self):
-        msg = r"corrupt patch \(invalid control block\)"
         for n in 1, 23, 25, 47, 49:
-            self.assertRaisesRegex(ValueError, msg,
-                                   core.patch, b'', 0, n * b'\x00', b'', b'')
+            self.assert_corrupt("invalid control block", control=n * b'\x00')
 
     def test_final_state(self):
-        for args, msg in [
-            ((1, b'', b'', b''),  "incomplete output"),
-            ((0, b'', b'x', b''), "unused block data"),
-            ((0, b'', b'', b'x'), "unused block data"),
-        ]:
-            self.assertRaisesRegex(ValueError, r"corrupt patch \(%s\)" % msg,
-                                   core.patch, b'', *args)
+        self.assert_corrupt("incomplete output", diff=b'x')
+        self.assert_corrupt("incomplete output", extra=b'y')
+        self.assert_corrupt("incomplete output", diff=b'x', extra=b'y')
 
     def test_src_pos_outside_source(self):
-        bcontrol = pack_control_block((0, 0, -1), (2, 0, 0))
-        self.assertEqual(
-            core.patch(b'ab', 2, bcontrol, b'\x01\x01', b''), b'\x01b')
-
-        bcontrol = pack_control_block((0, 0, 2), (2, 0, 0))
-        self.assertEqual(
-            core.patch(b'ab', 2, bcontrol, b'\x01\x02', b''), b'\x01\x02')
+        src = b'ab'
+        for controls, bdiff, dst in [
+            ([(0, 0, -1), (2, 0, 0)], b'\x01\x01', b'\x01b'),
+            ([(0, 0,  2), (2, 0, 0)], b'\x01\x02', b'\x01\x02'),
+        ]:
+            bcontrol = pack_control_block(*controls)
+            self.assertEqual(core.patch(src, bcontrol, bdiff, b''), dst)
 
     def test_src_pos_overflow(self):
         M = 1 << 63
         for z in -M + 1, M - 1:
             bcontrol = pack_control_block((0, 0, z))
-            self.assertEqual(core.patch(b'', 0, bcontrol, b'', b''), b'')
+            self.assertEqual(core.patch(b'', bcontrol, b'', b''), b'')
 
-        for dst_len, controls, diff_block in [
-            (0, [(0, 0, M - 1), (0, 0, 1)],               b''),
-            (0, [(0, 0, -M + 1), (0, 0, -1), (0, 0, -1)], b''),
-            (2, [(0, 0, M - 1), (2, 0, 0)],               b'\x00\x00'),
+        for controls, diff_len in [
+            ([(0, 0, M - 1), (0, 0, 1)], 0),
+            ([(0, 0, -M + 1), (0, 0, -1), (0, 0, -1)], 0),
+            ([(0, 0, M - 1), (2, 0, 0)], 2),
         ]:
             bcontrol = pack_control_block(*controls)
-            self.assertRaisesRegex(ValueError,
-                                   r"corrupt patch \(offset overflow\)",
-                                   core.patch, b'', dst_len,
-                                   bcontrol, diff_block, b'')
+            self.assert_corrupt("offset overflow",
+                                bcontrol, diff=diff_len * b'\x00')
 
 # ----------------------- BSDIFF4 format layer ---------------------------
 
 class TestHelpers(unittest.TestCase):
 
     def test_header(self):
-        bheader = b'BSDIFF40' + bytes.fromhex("""
-        c9 02 00 00 00 00 00 00
-        a2 07 00 00 00 00 00 00
-        c0 0f 02 00 00 00 00 00 """)
+        bheader = bytes.fromhex("""
+        42 53 44 49 46 46 34 30   c9 02 00 00 00 00 00 00
+        a2 07 00 00 00 00 00 00   c0 0f 02 00 00 00 00 00 """)
         sizes = (0x2c9, 0x7a2, 0x20fc0)
 
         self.assertEqual(pack_header(*sizes), bheader)
         self.assertEqual(unpack_header(bheader), sizes)
-        self.assertRaisesRegex(ValueError, "invalid magic bsdiff4 header",
+        self.assertRaisesRegex(ValueError, "invalid BSDIFF40 magic header",
                                unpack_header, 32 * b'\x00')
         for n in 0, 1, 31, 33:
             self.assertRaisesRegex(ValueError, "invalid header size",
@@ -247,8 +303,7 @@ class TestHelpers(unittest.TestCase):
     def test_control_block(self):
         bcontrol = bytes.fromhex("""
         1f00000000000000 a007000000000000 0100000000000080
-        0200000000000000 3000000000000080 0000000000000000
-        """)
+        0200000000000000 3000000000000080 0000000000000000 """)
         controls = [(0x1f, 0x7a0, -1), (2, -0x30, 0)]
 
         self.assertEqual(pack_control_block(*controls), bcontrol)
@@ -267,44 +322,36 @@ class Example:
     dst = b'abd!'
     # BSDIFF40 patch from b'abc' to b'abd!', verified with bspatch.
     # 42 5a 68 39 = BZh9
-    data = bytes.fromhex("""
+    patch = bytes.fromhex("""
     42534449 46463430 2a000000 00000000 25000000 00000000 04000000 00000000
     425a6839 31415926 5359d014 9a290000 04c00068 08200030 cd34193f 5209593c
     5dc914e1 42434052 68a4425a 68393141 59265359 4c5a9f48 00000040 00600020
     00210082 8c5dc914 e1424131 6a7d2042 5a683931 41592653 592d15eb 1c000000
-    10002000 20002118 4682ee48 a70a1205 a2bd6380
-    """)
+    10002000 20002118 4682ee48 a70a1205 a2bd6380 """)
     header_sizes = (0x2a, 0x25, 0x04)  # control_len, diff_len, dst_len
     control_tuples = [(3, 1, 0)]
     diff_block = b'\x00\x00\x01'
     extra_block = b'!'
+    blocks = (pack_control_block(*control_tuples), diff_block, extra_block)
 
 
 class TestExample(unittest.TestCase):
 
     def test_compatibility(self):
-        self.assertEqual(patch(Example.src, Example.data), Example.dst)
+        self.assertEqual(patch(Example.src, Example.patch), Example.dst)
 
     def test_header(self):
-        self.assertEqual(unpack_header(Example.data[:32]),
+        self.assertEqual(unpack_header(Example.patch[:32]),
                          Example.header_sizes)
 
-    def test_read_patch(self):
-        f = BytesIO(Example.data)
-        dst_len, control_block, diff_block, extra_block = read_patch(f)
-        self.assertEqual(dst_len, len(Example.dst))
-        self.assertEqual(list(unpack_control_block(control_block)),
-                         Example.control_tuples)
-        self.assertEqual(diff_block, Example.diff_block)
-        self.assertEqual(extra_block, Example.extra_block)
-
-    def test_write_patch(self):
+    def test_read_write_roundtrip(self):
+        blocks = read_patch(BytesIO(Example.patch))
+        self.assertEqual(blocks, Example.blocks)
         f = BytesIO()
-        write_patch(f, len(Example.dst),
-                    pack_control_block(*Example.control_tuples),
-                    Example.diff_block,
-                    Example.extra_block)
-        self.assertEqual(f.getvalue(), Example.data)
+        write_patch(f, *blocks)
+        self.assertEqual(f.getvalue(), Example.patch)
+        f.seek(0)
+        self.assertEqual(read_patch(f), blocks)
 
 
 class TestFormat(unittest.TestCase):
@@ -329,12 +376,6 @@ class TestFormat(unittest.TestCase):
             self.round_trip(a, b)
             self.round_trip(b, a)
 
-    def test_extra(self):
-        src = os.urandom(1000)
-        dst = src + os.urandom(10)
-        self.round_trip(src, dst)
-        self.round_trip(dst, src)
-
     def test_random(self):
         for _ in range(100):
             n1 = random.randint(0, 1000)
@@ -354,14 +395,16 @@ EMPTY = bz2.compress(b'')  # compressed empty block
 class TestFormatErrors(unittest.TestCase):
 
     def test_invalid_header(self):
-        p = b"BSDIFF30" + 24 * b'\x00'
-        self.assertRaisesRegex(ValueError, "invalid magic bsdiff4 header",
+        p = b"BSDIFF41" + 24 * b'\x00'
+        self.assertRaisesRegex(ValueError, "invalid BSDIFF40 magic header",
                                read_patch, BytesIO(p))
 
     def test_truncated_patch(self):
         for data in [
-            MAGIC,
-            MAGIC + 23 * b'\x00',
+            b'',
+            b'ABC',
+            b'BSDIFF40',
+            b'BSDIFF40' + 23 * b'\x00',
             pack_header(len(EMPTY) + 1, 0, 0) + EMPTY,
             pack_header(len(EMPTY), len(EMPTY) + 1, 0) + 2 * EMPTY,
         ]:
@@ -375,6 +418,14 @@ class TestFormatErrors(unittest.TestCase):
                                    "negative size in bsdiff4 patch",
                                    read_patch, BytesIO(data))
 
+    def test_invalid_control_block(self):
+        for n in 1, 23, 25, 47, 49:
+            f = BytesIO()
+            write_patch(f, n * b'\x00', b'', b'')
+            f.seek(0)
+            self.assertRaisesRegex(ValueError, "invalid control block",
+                                   read_patch, f)
+
     def test_invalid_blocks(self):
         for data in [
             pack_header(1, len(EMPTY), 0) + b'x' + EMPTY + EMPTY,
@@ -383,11 +434,17 @@ class TestFormatErrors(unittest.TestCase):
         ]:
             self.assertRaises(OSError, read_patch, BytesIO(data))
 
+    def test_dst_length(self):
+        dst_len = 1  # Conflicts with the empty diff and extra block.
+        data = pack_header(len(EMPTY), len(EMPTY), dst_len) + 3 * EMPTY
+        self.assertRaisesRegex(ValueError, "invalid destination length",
+                               read_patch, BytesIO(data))
+
     @unittest.skipUnless(sys.maxsize < (1 << 31), "requires 32-bit Python")
     def test_header_overflow(self):
         M = 1 << 31
         for lengths in [(M, 0, 0), (0, M, 0), (0, 0, M)]:
-            data = pack_header(*lengths) + 3 * bz2.compress(b'')
+            data = pack_header(*lengths) + 3 * EMPTY
             self.assertRaisesRegex(ValueError,
                                    "size too large in bsdiff4 patch",
                                    read_patch, BytesIO(data))
@@ -396,14 +453,14 @@ class TestFormatErrors(unittest.TestCase):
 class TestMutate(unittest.TestCase):
 
     def test_truncated_patch(self):
-        for i in range(len(Example.data)):
+        for i in range(len(Example.patch)):
             # truncating patch
             self.assertRaises(ValueError, patch,
-                              Example.src, Example.data[:i])
+                              Example.src, Example.patch[:i])
 
     @unittest.skipIf(UNDER_QEMU, "slow under QEMU")
     def test_mutated_patch(self):
-        data = Example.data
+        data = Example.patch
         for i in range(len(data)):
             mut = bytearray(data)
             for j in range(8):
@@ -429,9 +486,17 @@ class TestFile(unittest.TestCase):
     def path(self, fn):
         return os.path.join(self.tmpdir, fn)
 
+    def read_data(self, fn):
+        with open(self.path(fn), 'rb') as fi:
+            return fi.read()
+
+    def write_data(self, fn, data):
+        with open(self.path(fn), 'wb') as fo:
+            fo.write(data)
+
     def assert_same_file_content(self, fn1, fn2):
-        data1 = read_data(self.path(fn1))
-        data2 = read_data(self.path(fn2))
+        data1 = self.read_data(fn1)
+        data2 = self.read_data(fn2)
         self.assertEqual(data1, data2)
 
     def round_trip(self):
@@ -445,25 +510,94 @@ class TestFile(unittest.TestCase):
         file_patch(self.path('src'), self.path('src'), self.path('patch'))
         self.assert_same_file_content('src', 'dst')
 
-    def write_data(self, fn, data):
-        with open(self.path(fn), 'wb') as fo:
-            fo.write(data)
-
     def test_cases(self):
         for a, b in ROUND_TRIP_CASES:
             self.write_data('src', a)
             self.write_data('dst', b)
             self.round_trip()
 
-    def test_inplace(self):
-        a = 1000 * b'ABCDE'
-        b = 1000 * b'XYZ'
-        self.write_data('src', a + os.urandom(100) + b)
-        self.write_data('dst', a + os.urandom(100) + b)
-        file_diff(self.path('src'), self.path('dst'), self.path('patch'))
+    def test_example(self):
+        self.write_data('src', Example.src)
+        self.write_data('patch', Example.patch)
+        file_patch(self.path('src'), self.path('dst'), self.path('patch'))
+        self.assertEqual(self.read_data('dst'), Example.dst)
+
+    def test_example_inplace(self):
+        self.write_data('src', Example.src)
+        self.write_data('patch', Example.patch)
         file_patch_inplace(self.path('src'), self.path('patch'))
+        self.assertEqual(self.read_data('src'), Example.dst)
+
+    def check_preserves_file(self, mode):
+        # Verify that patching preserves the inode and its hard-link
+        # relationship.
+        self.write_data('src', b'source data will be patched with new data')
+        self.write_data('dst', b'destination data')
+        patch_path = self.path('patch')
+        file_diff(self.path('src'), self.path('dst'), patch_path)
+
+        src = self.path('src')
+        link = self.path('link')
+
+        os.link(src, link)
+        stat_before = os.stat(src)
+
+        if mode == 'inplace':
+            file_patch_inplace(src, patch_path)
+        elif mode == 'samepath':
+            file_patch(src, src, patch_path)
+        elif mode == 'samefile':
+            file_patch(src, link, patch_path)
+        else:
+            raise ValueError(mode)
+
+        # Ensure that `src` still refers to the same file.
+        stat_after = os.stat(src)
+        self.assertEqual((stat_after.st_dev, stat_after.st_ino),
+                         (stat_before.st_dev, stat_before.st_ino))
+        # Ensure that the hard link was not broken.
+        self.assertTrue(samefile(src, link))
         self.assert_same_file_content('src', 'dst')
 
+    def test_preserves_file_inplace(self):
+        self.check_preserves_file('inplace')
+
+    def test_preserves_file_samepath(self):
+        self.check_preserves_file('samepath')
+
+    def test_preserves_file_samefile(self):
+        self.check_preserves_file('samefile')
+
+    def test_patch_error_preserves_files(self):
+        # Verify that an invalid patch leaves the target file unchanged.
+        self.write_data('src', b'source data')
+        self.write_data('dst', b'destination data')
+        self.write_data('patch', b'invalid patch')
+
+        self.assertRaises(ValueError, file_patch,
+                          self.path('src'), self.path('dst'),
+                          self.path('patch'))
+        self.assertEqual(self.read_data('dst'), b'destination data')
+
+        self.assertRaises(ValueError, file_patch_inplace,
+                          self.path('src'), self.path('patch'))
+        self.assertEqual(self.read_data('src'), b'source data')
+
+        self.assertRaises(ValueError, file_patch,
+                          self.path('src'), self.path('src'),
+                          self.path('patch'))
+        self.assertEqual(self.read_data('src'), b'source data')
+
+    def test_patch_error_does_not_create_dst(self):
+        # Verify that an invalid patch does not create the target file.
+        self.write_data('src', b'source data')
+        self.write_data('patch', b'invalid patch')
+
+        self.assertRaises(ValueError, file_patch,
+                          self.path('src'), self.path('dst'),
+                          self.path('patch'))
+        self.assertFalse(exists(self.path('dst')))
+
 # -------------------------- free threading ------------------------------
 
 NTHREADS = 4
@@ -500,7 +634,7 @@ class TestFreeThreading(unittest.TestCase):
                 blocks = core.diff(src, dst)
                 if blocks != expected_blocks:
                     return False
-                if core.patch(src, len(dst), *blocks) != dst:
+                if core.patch(src, *blocks) != dst:
                     return False
                 if core.suffix_array(src) != expected_sa:
                     return False

{bsdiff4-1.4.1 → bsdiff4-1.4.2/bsdiff4.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bsdiff4
-Version: 1.4.1
+Version: 1.4.2
 Summary: binary diff and patch using the BSDIFF4-format
 Home-page: https://github.com/ilanschnell/bsdiff4
 Author: Ilan Schnell
@@ -47,9 +47,11 @@ Key features of this package include:
 
 * high-level ``diff`` and ``patch`` functions
 * an interface to the BSDIFF4 format
-* improved error handling for malformed patches
+* stricter validation and improved error handling of malformed patches than
+  the standard ``bspatch`` tool; in particular overlong blocks are rejected
 * functions for creating patches from files and applying them to files
-* command-line interfaces: ``bsdiff4`` and ``bspatch4``
+* command-line interfaces: ``bsdiff4`` and ``bspatch4`` (the latter can also
+  inspect patches using ``bspatch4 PATCH``)
 * support for free-threaded Python
 * type hints
 * extensive tests
@@ -65,15 +67,15 @@ The bsdiff4 package defines the following high level functions:
    Apply the BSDIFF4-format ``patch_bytes`` to ``src_bytes`` and return
    the bytes.
 
-``file_diff(src_path, dst_path, patch_path)``
+``file_diff(src_path, dst_path, patch_path)`` -> None
    Write a BSDIFF4-format patch (from the file ``src_path`` to the
    file ``dst_path``) to the file ``patch_path``.
 
-``file_patch(src_path, dst_path, patch_path)``
+``file_patch(src_path, dst_path, patch_path)`` -> None
    Apply the BSDIFF4-format file ``patch_path`` to the file ``src_path``
    and write the result to the file ``dst_path``.
 
-``file_patch_inplace(path, patch_path)``
+``file_patch_inplace(path, patch_path)`` -> None
    Apply the BSDIFF4-format file ``patch_path`` to the file ``path``
    in place.
 

{bsdiff4-1.4.1 → bsdiff4-1.4.2}/bsdiff4.egg-info/SOURCES.txt

@@ -7,7 +7,7 @@ bsdiff4/cli.py
 bsdiff4/core.c
 bsdiff4/format.py
 bsdiff4/py.typed
-bsdiff4/test_all.py
+bsdiff4/tests.py
 bsdiff4.egg-info/PKG-INFO
 bsdiff4.egg-info/SOURCES.txt
 bsdiff4.egg-info/dependency_links.txt

{bsdiff4-1.4.1 → bsdiff4-1.4.2}/setup.py

@@ -9,7 +9,7 @@ except ImportError:
 kwds = {}
 kwds['long_description'] = open('README.rst').read()
 
-# Read version from bsdiff/__init__.py
+# Read version from bsdiff4/__init__.py
 pat = re.compile(r'__version__\s*=\s*"(\S+)"', re.M)
 data = open('bsdiff4/__init__.py').read()
 kwds['version'] = pat.search(data).group(1)

bsdiff4-1.4.1/bsdiff4/cli.py

@@ -1,103 +0,0 @@
-from argparse import ArgumentParser
-from os.path import getsize
-
-from bsdiff4 import __version__
-from bsdiff4.format import (file_diff, file_patch, read_patch,
-                            unpack_header, unpack_control_block)
-
-
-def human_bytes(n):
-    """
-    return the number of bytes 'n' in more human readable form
-    """
-    if n < 1024:
-        return '%d B' % n
-    k = n / 1024
-    if k < 1024:
-        return '%.1f K' % k
-    m = k / 1024
-    if m < 1024:
-        return '%.1f M' % m
-    g = m / 1024
-    return '%.2f G' % g
-
-
-def show_filesizes(*args):
-    for i, name in enumerate(['src', 'dst', 'patch']):
-        size = getsize(args[i])
-        print('%s: %s (%s)' % (name, args[i], human_bytes(size)))
-
-
-def main_bsdiff4():
-    p = ArgumentParser(
-        description=("generate a BSDIFF4-format PATCH from SRC to DST "
-                     "and write it to PATCH"))
-    p.add_argument('-v', '--verbose', action='store_true',
-                   help="show file sizes")
-    p.add_argument('--version', action='version',
-                   version="bsdiff4 %s" % __version__)
-    p.add_argument('src', metavar='SRC')
-    p.add_argument('dst', metavar='DST')
-    p.add_argument('patch', metavar='PATCH')
-    args = p.parse_args()
-
-    paths = args.src, args.dst, args.patch
-    file_diff(*paths)
-    if args.verbose:
-        show_filesizes(*paths)
-
-
-def show_patch(patch_path, verbose=False):
-    total_len = getsize(patch_path)
-    with open(patch_path, 'rb') as fi:
-        control_len, diff_len, dst_len = unpack_header(fi.read(32))
-        print("sizes:")
-        for name, size in [
-            ('total', total_len),
-            ('control', control_len),
-            ('diff', diff_len),
-            ('extra', total_len - 32 - control_len - diff_len),
-            ('dst', dst_len),
-        ]:
-            print('%10s: %10d (%s)' % (name, size, human_bytes(size)))
-
-        fi.seek(0)
-        _, control_block, diff_block, extra_block = read_patch(fi)
-        print("\nuncompressed block sizes:")
-        for name, size in [
-            ('control', len(control_block)),
-            ('diff', len(diff_block)),
-            ('extra', len(extra_block)),
-        ]:
-            print('%10s: %10d (%s)' % (name, size, human_bytes(size)))
-
-        print('\nnumber of control tuples: %d' % (len(control_block) // 24))
-        if verbose:
-            print('%10s %10s %10s' % ('x', 'y', 'z'))
-            for ct in unpack_control_block(control_block):
-                print('%10d %10d %10d' % ct)
-
-
-def main_bspatch4():
-    p = ArgumentParser(
-        usage="%(prog)s [options] SRC DST PATCH\n"
-              "       %(prog)s [options] PATCH",
-        description=("generate DST by applying the BSDIFF4-format PATCH "
-                     "file to SRC, or display information about PATCH"))
-    p.add_argument('-v', '--verbose', action='store_true',
-                   help="show file sizes or control tuples")
-    p.add_argument('--version', action='version',
-                   version="bsdiff4 %s" % __version__)
-    p.add_argument('paths', nargs='+', metavar='PATH')
-    args = p.parse_args()
-
-    if len(args.paths) == 1:
-        show_patch(args.paths[0], args.verbose)
-        return
-
-    if len(args.paths) != 3:
-        p.error("requires either PATCH or SRC DST PATCH")
-
-    file_patch(*args.paths)
-    if args.verbose:
-        show_filesizes(*args.paths)