bsdiff4 1.4.1__tar.gz → 1.4.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bsdiff4
-Version: 1.4.1
+Version: 1.4.3
 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.
 
@@ -88,6 +90,6 @@ Example:
    >>> b[100:106] = b' diff '
    >>> p = bsdiff4.diff(a, bytes(b))
    >>> len(p)
-   154
+   153
    >>> bsdiff4.patch(a, p) == b
    True

{bsdiff4-1.4.1 → bsdiff4-1.4.3}/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.
 
@@ -52,6 +54,6 @@ Example:
    >>> b[100:106] = b' diff '
    >>> p = bsdiff4.diff(a, bytes(b))
    >>> len(p)
-   154
+   153
    >>> bsdiff4.patch(a, p) == b
    True

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

@@ -1,11 +1,17 @@
+import bsdiff4.core as core  # type: ignore
 from bsdiff4.format import (diff, patch, file_diff, file_patch,
                             file_patch_inplace)
 
-__version__ = "1.4.1"
+
+__version__: str = core.BSDIFF4_VERSION
 
 __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.3/bsdiff4/cli.py

@@ -0,0 +1,151 @@
+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,
+                            NonCanonicalError, validate_canonical,
+                            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)
+    try:
+        validate_canonical(control_block)
+        print("Valid patch has canonical control structure.")
+    except NonCanonicalError as e:
+        print("Valid patch is non-canonical: %s" % e)
+
+
+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.3}/bsdiff4/core.c

@@ -7,8 +7,10 @@
 
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
+#include <assert.h>
 #include <stdint.h>
 
+#define BSDIFF4_VERSION  "1.4.3"
 
 /* swap two values */
 static inline void
@@ -109,6 +111,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 +219,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,
@@ -309,6 +314,69 @@ append_control(PyObject *control, Py_ssize_t x, Py_ssize_t y, Py_ssize_t z)
     return 0;
 }
 
+typedef struct {
+    Py_ssize_t x, y, z;
+    int initialized;  /* whether we received any control tuple yet */
+} PendingControl;
+
+/* Retain one control tuple so it can be merged with the next. */
+static int
+queue_add(PyObject *control, PendingControl *pending,
+          Py_ssize_t x, Py_ssize_t y, Py_ssize_t z)
+{
+    if (pending->initialized == 0) {
+        pending->x = x;
+        pending->y = y;
+        pending->z = z;
+        pending->initialized = 1;
+        return 0;
+    }
+
+    /* A tuple with no diff range does not access the source; any data it
+       emits is extra data.  Merge it into the preceding tuple:
+       (px, py, pz), (0, y, z) -> (px, py + y, pz + z). */
+    if (x == 0) {
+        assert(y <= PY_SSIZE_T_MAX - pending->y);
+        assert((z >= 0 && pending->z <= PY_SSIZE_T_MAX - z) ||
+               (z < 0 && pending->z >= -PY_SSIZE_T_MAX - 1 - z));
+        pending->y += y;
+        pending->z += z;
+        return 0;
+    }
+
+    /* The preceding rule may cancel intervening source seeks, leaving
+       (px, 0, 0), (x, y, z).  Merge these into (px + x, y, z), since
+       both diff ranges access consecutive source data. */
+    if (pending->y == 0 && pending->z == 0) {
+        assert(x <= PY_SSIZE_T_MAX - pending->x);
+        pending->x += x;
+        pending->y = y;
+        pending->z = z;
+        return 0;
+    }
+
+    if (append_control(control, pending->x, pending->y, pending->z) < 0)
+        return -1;
+    pending->x = x;
+    pending->y = y;
+    pending->z = z;
+    return 0;
+}
+
+/* Append the final pending tuple, unless it produces no output. */
+static int
+queue_flush(PyObject *control, const PendingControl *pending)
+{
+    if (pending->initialized == 0)
+        return 0;
+
+    /* The final source seek is irrelevant. */
+    if (pending->x == 0 && pending->y == 0)
+        return 0;
+
+    return append_control(control, pending->x, pending->y, 0);
+}
+
 /* find the best forward match length */
 static Py_ssize_t
 forward_match_length(const char *src, Py_ssize_t src_len,
@@ -384,6 +452,7 @@ compute_diff(const char *src, Py_ssize_t src_len,
     Py_ssize_t lastscan, lastpos, lastoffset;
     Py_ssize_t scan, pos, len;
     Py_ssize_t *sa;
+    PendingControl pending = {0, 0, 0, 0};
 
     result->control = PyByteArray_FromStringAndSize(NULL, 0);
     if (result->control == NULL)
@@ -446,6 +515,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];
@@ -458,7 +532,7 @@ compute_diff(const char *src, Py_ssize_t src_len,
             result->extra_len += extra_len;
 
             z = (pos - lenb) - (lastpos + lenf);
-            if (append_control(result->control, lenf, extra_len, z) < 0)
+            if (queue_add(result->control, &pending, lenf, extra_len, z) < 0)
                 goto error;
 
             lastscan = scan - lenb;
@@ -467,7 +541,13 @@ compute_diff(const char *src, Py_ssize_t src_len,
         }
     }
 
+    if (queue_flush(result->control, &pending) < 0)
+        goto error;
+
     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 +594,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 +658,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 +692,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");
@@ -624,16 +709,15 @@ mod_patch(PyObject *module, PyObject *args)
         if (update_src_pos(&src_pos, x) < 0 ||
             update_src_pos(&src_pos, z) < 0)
             goto error;
+        assert(dst_pos + diff_remaining + extra_remaining == dst_len);
     }
 
     if (dst_pos != dst_len) {
         CORRUPT("incomplete output");
         goto error;
     }
-    if (diff_remaining != 0 || extra_remaining != 0) {
-        CORRUPT("unused block data");
-        goto error;
-    }
+    /* Complete output implies that both input blocks were fully consumed. */
+    assert(diff_remaining == 0 && extra_remaining == 0);
 
     return result;
 
@@ -734,9 +818,21 @@ PyInit_core(void)
     if (m == NULL)
         return NULL;
 
+    if (PyModule_AddStringMacro(m, BSDIFF4_VERSION) < 0)
+        goto error;
+
 #ifdef Py_GIL_DISABLED
-    PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
+    if (PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED) < 0)
+        goto error;
+#endif
+
+#ifndef NDEBUG
+    if (PyModule_AddIntConstant(m, "DEBUG", 1) < 0)
+        goto error;
 #endif
 
     return m;
+ error:
+    Py_DECREF(m);
+    return NULL;
 }

{bsdiff4-1.4.1 → bsdiff4-1.4.3}/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,12 +32,52 @@ 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))
 
 
+class NonCanonicalError(ValueError):
+    "Raised when a valid control block is not canonical."
+
+
+def validate_canonical(control_block, src_len=None):
+    "Raise NonCanonicalError unless a valid control block is canonical."
+    controls = list(unpack_control_block(control_block))
+
+    negative_zero = 7 * b'\x00' + b'\x80'
+    for j in range(0, len(control_block), 8):
+        if control_block[j:j + 8] == negative_zero:
+            raise NonCanonicalError("negative zero found")
+
+    src_pos = 0
+    for i, (x, y, z) in enumerate(controls):
+        if src_pos < 0:
+            raise NonCanonicalError("negative source position")
+
+        if src_len is not None:
+            if src_pos > src_len:
+                raise NonCanonicalError("source position not in source range")
+
+            if src_pos + x > src_len:
+                raise NonCanonicalError("diff range not in source range")
+
+        if x == y == z == 0:
+            raise NonCanonicalError("no-op tuple found")
+
+        if i and x == 0:
+            raise NonCanonicalError("empty diff range")
+
+        if i == len(controls) - 1:
+            if z:
+                raise NonCanonicalError("final z not zero")
+        else:
+            if y == z == 0:
+                raise NonCanonicalError("adjacent diff ranges not merged")
+
+        src_pos += x + z
+
+
 def check_size(size):
     if size < 0:
         raise ValueError("negative size in bsdiff4 patch")
@@ -62,14 +100,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 +133,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 +146,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)