Battam's picture
regenerate the index pages only (generator 46a2db14, templates 908e82ff) [run publish-20261028T213235Z]
ec5da4b verified
Raw History Blame Contribute Delete
21.8 kB
"""Make a delivered file out of an upstream file: take a member out of a zip or tar archive, decompress, turn a hex
dump or a uuencoded file back into bytes, recompress.
Standard library only, so it can sit next to fetch.py and to_pool.py and be imported by both.
A transform is a list of steps, applied in order:
unzip:<member> the member with exactly this name inside a zip archive (a directory entry is refused)
bunzip2 decompress bzip2 (several concatenated streams are read as one)
gunzip decompress gzip (several concatenated members are read as one)
unxz decompress xz (several concatenated streams are read as one)
untar:<member> the member with exactly this name inside an uncompressed tar archive (put unxz, gunzip or
bunzip2 before it for a compressed one); it must be a regular file, read at its full size
when it is stored sparse; a member that is a link, a directory or a device is refused, and
so is a name that is absolute, has a .. part, or is found more than once in the archive
unxxd turn a hex dump written by xxd (or xxd -a) back into bytes, without running xxd; see below
uudecode turn a uuencoded file back into bytes, without running uudecode; see below
uncompress decompress a .Z file written by Unix compress (LZW), without running uncompress; see below
gzip compress with gzip at level 9, modification time 0 and no file name in the header;
allowed once, as the last step
validate(steps) checks a list of steps and raises ValueError for anything else.
apply(src_path, steps, out_path) writes the result to out_path (atomically: a temporary file in the same
directory, renamed at the end) and returns {"sha256", "bytes", "content_sha256"}: the sha256 and size of the
written file, and the sha256 of the bytes before a final gzip step (equal to sha256 when the last step is not
gzip). The gzip bytes depend on the zlib build, so compare content_sha256 to check a transform made elsewhere.
Only the named member is read out of an archive, and the result is written only to out_path: no name found
inside an archive is ever used as a path.
The output of unxz, untar, unxxd, uudecode and uncompress may be at most max_bytes (a keyword of apply; default
MAX_BYTES, 256,000,000 bytes; None for no limit): apply stops as soon as it passes and raises TooLarge, a ValueError.
A tar member whose size, counted at its expanded size when it is stored sparse, is more than the limit is refused
before it is read. The other steps have no limit.
unxxd reads only the default layout of xxd: each line is an offset of 8 lowercase hex digits, a colon and a
space, 16 bytes in groups of two bytes (4 lowercase hex digits) parted by one space, two spaces and the text
column. The text column is not compared with the bytes; it must hold one character per byte. The first line has
offset 0 and each line starts where the one before it ended. Only the last line may hold fewer than 16 bytes;
its hex part is padded with spaces to the full width. A line holding only * (written by xxd -a) means that the
bytes from the end of the line before it up to the offset of the line after it are all zero: the line before it
must hold 16 zero bytes, the line after it must be a line of bytes, and the zero bytes it stands for must be a
whole number of 16-byte lines, at least one. Every line ends with a newline (a carriage return is refused), and
an empty file gives an empty output. Anything else is refused: nothing is guessed. The whole dump is read and
checked, and the length of the output counted, before anything is written, so a dump that is bad anywhere or
whose output would pass max_bytes writes nothing.
uudecode decodes the lines between the first line of the form "begin <mode> <name>" (mode in octal digits) and
the first line "end" after it, each with binascii.a2b_uu; lines before the begin line and after the end line are
skipped. The name on the begin line is never used: the output goes only to out_path. A file with no begin line,
with a second begin line, with no end line after the begin line, or with a line between them that does not decode
is refused. A line may end with a carriage return before its newline.
uncompress reads the .Z format of Unix compress: the magic bytes 1f 9d, a flags byte whose low five bits are the
maximum code width (9 to 16 bits) and whose high bit is block mode (code 256 then clears the table), and then LZW
codes of 9 bits up to that width, packed from the low bit up. Codes are read in groups of eight, as the original
compress writes them: when the width grows, or after a clear code, the remaining codes of the current group are
skipped and the next group starts at the new width. As in the original compress (and in gzip -d), with a maximum
width of 9 the codes still grow to 10 bits once the table is full, so a file written by ncompress -b 9 does not
decode here, as it does not with ncompress or gzip either. Bits at the end too few for one more code are ignored.
A wrong magic, a maximum width outside 9 to 16, a first code that is not a byte, and a code that is not yet in the
table (other than the next one to be added, the KwKwK case) are refused. The output is written as it is decoded.
Bad archives, a missing member and corrupt compressed data raise ValueError; reading or writing errors (a
missing source file, a full disk) raise OSError.
Deletes: the step outputs .transform-*.part that apply made with tempfile.mkstemp next to the output (listed one by
one in its temps list), once the last one is renamed to the output or a step fails: temporary files.
"""
from __future__ import annotations
import binascii
import bz2
import gzip
import hashlib
import lzma
import os
import re
import tarfile
import tempfile
import unicodedata
import zipfile
import zlib
UNZIP = "unzip:"
UNTAR = "untar:"
SIMPLE = ("bunzip2", "gunzip", "unxz", "unxxd", "uudecode", "uncompress", "gzip")
MAX_BYTES = 256_000_000
GZIP_LEVEL = 9
CHUNK = 1 << 20
XXD_WIDTH = 16
_XXD_LINE = re.compile(r"([0-9a-f]{8}): ([0-9a-f ]{39}) ([ -~]*)")
_XXD_HEX = re.compile(r"(?:[0-9a-f]{4} ){0,7}(?:[0-9a-f]{4}|[0-9a-f]{2})")
_XXD_LINE_MAX = 128
_UU_BEGIN = re.compile(rb"begin [0-7]{1,6} +\S.*")
_UU_LINE_MAX = 1024
_Z_MAGIC = b"\x1f\x9d"
_Z_BLOCK_MODE = 0x80
_Z_BITS_MASK = 0x1f
_Z_INIT_BITS = 9
_Z_MAX_BITS = 16
_Z_CLEAR = 256
_Z_KEEP = 256
_ZEROS = bytes(CHUNK)
_DATA_ERRORS = (OSError, EOFError, zlib.error, zipfile.BadZipFile, RuntimeError, NotImplementedError,
lzma.LZMAError, tarfile.TarError)
class TooLarge(ValueError):
"""The output of a step passed max_bytes."""
def _tar_name_problem(member: str):
if re.match(r"[/\\]|[A-Za-z]:", member):
return "is an absolute path"
if ".." in re.split(r"[/\\]", member):
return "has a .. part"
return None
def validate(steps) -> list:
"""-> the steps as a new list; ValueError unless steps is a non-empty list of known steps with gzip only last."""
if not isinstance(steps, (list, tuple)) or not steps:
raise ValueError(f"transform must be a non-empty list of steps, got {steps!r}")
out = []
for i, s in enumerate(steps):
if not isinstance(s, str):
raise ValueError(f"step {i + 1} must be a string, got {s!r}")
if s.startswith(UNZIP):
member = s[len(UNZIP):]
if not member or member.endswith("/"):
raise ValueError(f"step {i + 1}: unzip needs a file member name: {s!r}")
if any(unicodedata.category(c) == "Cc" for c in member):
raise ValueError(f"step {i + 1}: member name has a control character: {s!r}")
elif s.startswith(UNTAR):
member = s[len(UNTAR):]
if not member or member.endswith("/"):
raise ValueError(f"step {i + 1}: untar needs a file member name: {s!r}")
if any(unicodedata.category(c) == "Cc" for c in member):
raise ValueError(f"step {i + 1}: member name has a control character: {s!r}")
why = _tar_name_problem(member)
if why:
raise ValueError(f"step {i + 1}: member name {why}: {s!r}")
elif s not in SIMPLE:
raise ValueError(f"step {i + 1}: unknown step {s!r} "
"(use unzip:<member>, untar:<member>, bunzip2, gunzip, unxz, unxxd, uudecode, uncompress "
"or gzip)")
if s == "gzip" and i != len(steps) - 1:
raise ValueError(f"step {i + 1}: gzip is allowed only as the last step")
out.append(s)
return out
def _copy(fin, fout, h=None, limit=None) -> None:
n = 0
while True:
b = fin.read(CHUNK)
if not b:
return
n += len(b)
if limit is not None and n > limit:
raise TooLarge(f"output passes the limit of {limit} bytes")
if h is not None:
h.update(b)
fout.write(b)
def _unzip(src: str, member: str, fout) -> None:
with zipfile.ZipFile(src) as zf:
try:
info = zf.getinfo(member)
except KeyError:
raise ValueError(f"no member {member!r} in the zip archive") from None
if info.is_dir():
raise ValueError(f"member {member!r} is a directory")
with zf.open(info) as fin:
_copy(fin, fout)
def _untar(src: str, member: str, fout, limit) -> None:
with tarfile.open(src, "r:") as tf:
found = [m for m in tf.getmembers() if m.name == member]
if not found:
raise ValueError(f"no member {member!r} in the tar archive")
if len(found) > 1:
raise ValueError(f"member {member!r} is in the tar archive {len(found)} times")
info = found[0]
if info.issym() or info.islnk():
raise ValueError(f"member {member!r} is a link")
if not info.isfile():
raise ValueError(f"member {member!r} is not a regular file")
if limit is not None and info.size > limit:
raise TooLarge(f"member {member!r} is {info.size} bytes"
f"{' when expanded' if info.sparse else ''}, more than the limit of {limit} bytes")
fin = tf.extractfile(info)
_copy(fin, fout, limit=limit)
def _xxd_parts(fin):
"""Yield the bytes a hex dump stands for, in order: a bytes object per line, an int (that many zero bytes) per *
line. Raises ValueError at the first thing that does not fit the layout."""
pos = 0
last = None
n = 0
while True:
raw = fin.readline(_XXD_LINE_MAX)
if not raw:
break
n += 1
if not raw.endswith(b"\n"):
raise ValueError(f"line {n}: " + ("too long" if len(raw) >= _XXD_LINE_MAX else "no newline at the end"))
try:
line = raw[:-1].decode("ascii")
except UnicodeDecodeError:
raise ValueError(f"line {n}: not ASCII") from None
if line == "*":
if last is None:
raise ValueError(f"line {n}: a * line cannot come first")
if last == "*":
raise ValueError(f"line {n}: two * lines in a row")
if len(last) != XXD_WIDTH or any(last):
raise ValueError(f"line {n}: the line before a * line must hold {XXD_WIDTH} zero bytes")
last = "*"
continue
m = _XXD_LINE.fullmatch(line)
hexpart = m.group(2).rstrip(" ") if m else ""
if not m or not _XXD_HEX.fullmatch(hexpart):
raise ValueError(f"line {n}: not a line of xxd output: {line[:80]!r}")
data = bytes.fromhex(hexpart)
if len(m.group(3)) != len(data):
raise ValueError(f"line {n}: the text column has {len(m.group(3))} characters for {len(data)} bytes")
if isinstance(last, bytes) and len(last) < XXD_WIDTH:
raise ValueError(f"line {n - 1}: only the last line may hold fewer than {XXD_WIDTH} bytes")
off = int(m.group(1), 16)
if last == "*":
gap = off - pos
if gap <= 0:
raise ValueError(f"line {n}: offset {off:08x} after a * line does not pass {pos:08x}")
if gap % XXD_WIDTH:
raise ValueError(f"line {n}: the * line before it stands for {gap} bytes, "
f"not a whole number of {XXD_WIDTH}-byte lines")
yield gap
pos = off
elif off != pos:
raise ValueError(f"line {n}: offset {off:08x}, expected {pos:08x}")
yield data
pos += len(data)
last = data
if last == "*":
raise ValueError("the dump ends with a * line")
def _unxxd(src: str, fout, limit) -> None:
with open(src, "rb") as fin:
total = 0
for part in _xxd_parts(fin):
total += part if isinstance(part, int) else len(part)
if limit is not None and total > limit:
raise TooLarge(f"output would pass the limit of {limit} bytes")
fin.seek(0)
for part in _xxd_parts(fin):
if isinstance(part, int):
while part:
k = min(part, CHUNK)
fout.write(_ZEROS[:k] if k < CHUNK else _ZEROS)
part -= k
else:
fout.write(part)
def _uu_lines(fin):
"""Yield (line number, line without its line end) for each line of fin; a line of _UU_LINE_MAX bytes or more
is read to its end and yielded as None, so it never matches a begin or end line and never decodes."""
n = 0
while True:
raw = fin.readline(_UU_LINE_MAX)
if not raw:
return
n += 1
if len(raw) >= _UU_LINE_MAX and not raw.endswith(b"\n"):
while raw and not raw.endswith(b"\n"):
raw = fin.readline(CHUNK)
yield n, None
continue
line = raw[:-1] if raw.endswith(b"\n") else raw
if line.endswith(b"\r"):
line = line[:-1]
yield n, line
def _uudecode(src: str, fout, limit) -> None:
with open(src, "rb") as fin:
state = "before"
total = 0
for n, line in _uu_lines(fin):
is_begin = line is not None and _UU_BEGIN.fullmatch(line) is not None
if state == "before":
if is_begin:
state = "body"
continue
if is_begin:
raise ValueError(f"line {n}: a second begin line")
if state == "after":
continue
if line == b"end":
state = "after"
continue
if line is None:
raise ValueError(f"line {n}: too long for a uuencoded line")
try:
data = binascii.a2b_uu(line)
except binascii.Error as e:
raise ValueError(f"line {n}: does not decode: {e}") from None
total += len(data)
if limit is not None and total > limit:
raise TooLarge(f"output passes the limit of {limit} bytes")
fout.write(data)
if state == "before":
raise ValueError("no begin line")
if state == "body":
raise ValueError("no end line after the begin line")
def _uncompress(src: str, fout, limit) -> None:
with open(src, "rb") as fin:
head = fin.read(3)
if len(head) < 3 or head[:2] != _Z_MAGIC:
raise ValueError("not a .Z file (no 1f 9d magic)")
maxbits = head[2] & _Z_BITS_MASK
block = bool(head[2] & _Z_BLOCK_MODE)
if not _Z_INIT_BITS <= maxbits <= _Z_MAX_BITS:
raise ValueError(f"maximum code width {maxbits} is outside {_Z_INIT_BITS} to {_Z_MAX_BITS}")
maxmaxcode = 1 << maxbits
# an entry is kept as bytes when it is at most _Z_KEEP bytes long, else as its prefix code and last byte
strs = [bytes([i]) for i in range(256)] + [None] * (maxmaxcode - 256)
pre = [0] * maxmaxcode
suf = [0] * maxmaxcode
n_bits = _Z_INIT_BITS
maxcode = (1 << n_bits) - 1
free_ent = 257 if block else 256
oldcode = -1
prev = b""
total = 0
buf = bytearray()
while True:
group = fin.read(n_bits)
if not group:
break
v = int.from_bytes(group, "little")
mask = (1 << n_bits) - 1
for k in range(len(group) * 8 // n_bits):
code = (v >> (k * n_bits)) & mask
if oldcode == -1:
if code >= 256:
raise ValueError(f"first code {code} is not a byte")
oldcode = code
prev = strs[code]
out = prev
elif code == _Z_CLEAR and block:
free_ent = 256
n_bits = _Z_INIT_BITS
maxcode = (1 << n_bits) - 1
break
else:
if code > free_ent:
raise ValueError(f"code {code} is not in the table (next entry is {free_ent})")
if code == free_ent:
out = prev + prev[:1]
else:
out = strs[code]
if out is None:
tail = []
c = code
while out is None:
tail.append(suf[c])
c = pre[c]
out = strs[c]
tail.reverse()
out = out + bytes(tail)
if free_ent < maxmaxcode:
if len(prev) < _Z_KEEP:
strs[free_ent] = prev + out[:1]
else:
strs[free_ent] = None
pre[free_ent] = oldcode
suf[free_ent] = out[0]
free_ent += 1
oldcode = code
prev = out
total += len(out)
if limit is not None and total > limit:
raise TooLarge(f"output passes the limit of {limit} bytes")
buf += out
if len(buf) >= CHUNK:
fout.write(buf)
buf.clear()
if free_ent > maxcode:
n_bits += 1
maxcode = maxmaxcode if n_bits == maxbits else (1 << n_bits) - 1
break
fout.write(buf)
def _step(src: str, step: str, fout, content, limit=None) -> None:
if step.startswith(UNZIP):
_unzip(src, step[len(UNZIP):], fout)
elif step.startswith(UNTAR):
_untar(src, step[len(UNTAR):], fout, limit)
elif step == "unxz":
with lzma.open(src, "rb", format=lzma.FORMAT_XZ) as fin:
_copy(fin, fout, limit=limit)
elif step == "unxxd":
_unxxd(src, fout, limit)
elif step == "uudecode":
_uudecode(src, fout, limit)
elif step == "uncompress":
_uncompress(src, fout, limit)
elif step == "bunzip2":
with bz2.open(src, "rb") as fin:
_copy(fin, fout)
elif step == "gunzip":
with gzip.open(src, "rb") as fin:
_copy(fin, fout)
else:
with open(src, "rb") as fin, gzip.GzipFile(filename="", mode="wb", fileobj=fout,
compresslevel=GZIP_LEVEL, mtime=0) as gz:
_copy(fin, gz, content)
def _sha256_file(path: str) -> tuple:
h = hashlib.sha256()
n = 0
with open(path, "rb") as f:
while True:
b = f.read(CHUNK)
if not b:
return h.hexdigest(), n
h.update(b)
n += len(b)
def apply(src_path, steps, out_path, *, max_bytes: int | None = MAX_BYTES) -> dict:
"""Apply steps to src_path, write out_path -> {"sha256", "bytes", "content_sha256"}. max_bytes limits the
output of unxz, untar, unxxd, uudecode and uncompress (TooLarge when it passes)."""
steps = validate(steps)
src = os.fspath(src_path)
out = os.path.abspath(os.fspath(out_path))
if not os.path.isfile(src):
raise FileNotFoundError(src)
d = os.path.dirname(out)
os.makedirs(d, exist_ok=True)
temps = []
cur = src
content = None
try:
for i, step in enumerate(steps):
fd, tmp = tempfile.mkstemp(dir=d, prefix=".transform-", suffix=".part")
temps.append(tmp)
if step == "gzip":
content = hashlib.sha256()
with os.fdopen(fd, "wb") as fout:
limited = step in ("unxz", "unxxd", "uudecode", "uncompress") or step.startswith(UNTAR)
try:
_step(cur, step, fout, content, max_bytes if limited else None)
except ValueError as e:
kind = TooLarge if isinstance(e, TooLarge) else ValueError
raise kind(f"step {i + 1} ({step}): {e}") from None
except _DATA_ERRORS as e:
if isinstance(e, OSError) and e.errno is not None:
raise
raise ValueError(f"step {i + 1} ({step}): {type(e).__name__}: {e}") from e
cur = tmp
sha, n = _sha256_file(cur)
os.chmod(cur, 0o644)
os.replace(cur, out)
temps.remove(cur)
finally:
for t in temps:
try:
os.unlink(t)
except OSError:
pass
return {"sha256": sha, "bytes": n, "content_sha256": content.hexdigest() if content is not None else sha}