PyArchiveFile 0.22.4__py3-none-any.whl → 0.23.0__py3-none-any.whl

pyarchivefile.py

@@ -14,7 +14,7 @@
     Copyright 2018-2024 Game Maker 2k - http://intdb.sourceforge.net/
     Copyright 2018-2024 Kazuki Przyborowski - https://github.com/KazukiPrzyborowski
 
-    $FileInfo: pyarchivefile.py - Last Update: 8/29/2025 Ver. 0.22.4 RC 1 - Author: cooldude2k $
+    $FileInfo: pyarchivefile.py - Last Update: 10/1/2025 Ver. 0.23.0 RC 1 - Author: cooldude2k $
 '''
 
 from __future__ import absolute_import, division, print_function, unicode_literals, generators, with_statement, nested_scopes
@@ -27,8 +27,8 @@ import stat
 import zlib
 import base64
 import shutil
-import struct
 import socket
+import struct
 import hashlib
 import inspect
 import datetime
@@ -79,6 +79,7 @@ try:
 except NameError:
     basestring = str
 
+PY2 = (sys.version_info[0] == 2)
 try:
     unicode  # Py2
 except NameError:  # Py3
@@ -104,11 +105,11 @@ baseint = tuple(baseint)
 # URL Parsing
 try:
     # Python 3
-    from urllib.parse import urlparse, urlunparse, unquote
+    from urllib.parse import urlparse, urlunparse, parse_qs, unquote
     from urllib.request import url2pathname
 except ImportError:
     # Python 2
-    from urlparse import urlparse, urlunparse
+    from urlparse import urlparse, urlunparse, parse_qs
     from urllib import unquote, url2pathname
 
 # Windows-specific setup
@@ -269,8 +270,8 @@ def get_default_threads():
         # os.cpu_count() might not be available in some environments
         return 1
 
-__upload_proto_support__ = "^(ftp|ftps|sftp|scp)://"
-__download_proto_support__ = "^(http|https|ftp|ftps|sftp|scp)://"
+__upload_proto_support__ = "^(ftp|ftps|sftp|scp|tcp|udp)://"
+__download_proto_support__ = "^(http|https|ftp|ftps|sftp|scp|tcp|udp)://"
 __use_pysftp__ = False
 if(not havepysftp):
     __use_pysftp__ = False
@@ -379,12 +380,12 @@ __file_format_extension__ = __file_format_multi_dict__[__file_format_default__][
 __file_format_dict__ = __file_format_multi_dict__[__file_format_default__]
 __project__ = __program_name__
 __project_url__ = "https://github.com/GameMaker2k/PyArchiveFile"
-__version_info__ = (0, 22, 4, "RC 1", 1)
-__version_date_info__ = (2025, 9, 29, "RC 1", 1)
+__version_info__ = (0, 23, 0, "RC 1", 1)
+__version_date_info__ = (2025, 10, 1, "RC 1", 1)
 __version_date__ = str(__version_date_info__[0]) + "." + str(
     __version_date_info__[1]).zfill(2) + "." + str(__version_date_info__[2]).zfill(2)
 __revision__ = __version_info__[3]
-__revision_id__ = "$Id: 2ee1d29a52ba41ea9f964515278af0f8c1b97489 $"
+__revision_id__ = "$Id: 0648f57aa9e81ed48e68f5f42de5c4565b870555 $"
 if(__version_info__[4] is not None):
     __version_date_plusrc__ = __version_date__ + \
         "-" + str(__version_date_info__[4])
@@ -396,15 +397,67 @@ if(__version_info__[3] is not None):
 if(__version_info__[3] is None):
     __version__ = str(__version_info__[0]) + "." + str(__version_info__[1]) + "." + str(__version_info__[2])
 
+# ===== Module-level type code table & helpers (reuse anywhere) =====
+
+FT = {
+    "FILE": 0,
+    "HARDLINK": 1,
+    "SYMLINK": 2,
+    "CHAR": 3,
+    "BLOCK": 4,
+    "DIR": 5,
+    "FIFO": 6,
+    "CONTAGIOUS": 7,   # treated like regular file
+    "SOCK": 8,
+    "DOOR": 9,
+    "PORT": 10,
+    "WHT": 11,
+    "SPARSE": 12,
+    "JUNCTION": 13,
+}
+
+BASE_CATEGORY_BY_CODE = {
+    0:  "files",
+    1:  "hardlinks",
+    2:  "symlinks",
+    3:  "characters",
+    4:  "blocks",
+    5:  "directories",
+    6:  "fifos",
+    7:  "files",         # contagious treated as file
+    8:  "sockets",
+    9:  "doors",
+    10: "ports",
+    11: "whiteouts",
+    12: "sparsefiles",
+    13: "junctions",
+}
+
+# Union categories defined by which base codes should populate them.
+UNION_RULES = [
+    ("links",   set([FT["HARDLINK"], FT["SYMLINK"]])),
+    ("devices", set([FT["CHAR"], FT["BLOCK"]])),
+]
+
+# Deterministic category order (handy for consistent output/printing).
+CATEGORY_ORDER = [
+    "files", "hardlinks", "symlinks", "character", "block",
+    "directories", "fifo", "sockets", "doors", "ports",
+    "whiteouts", "sparsefiles", "junctions", "links", "devices"
+]
+
 # Robust bitness detection
 # Works on Py2 & Py3, all platforms
+
+# Python interpreter bitness
+PyBitness = "64" if struct.calcsize("P") * 8 == 64 else ("64" if sys.maxsize > 2**32 else "32")
+
+# Operating system bitness
 try:
-    import struct
-    PyBitness = "64" if struct.calcsize("P") * 8 == 64 else "32"
+    OSBitness = platform.architecture()[0].replace("bit", "")
 except Exception:
-    # conservative fallback
-    m = platform.machine() or ""
-    PyBitness = "64" if m.endswith("64") else "32"
+    m = platform.machine().lower()
+    OSBitness = "64" if "64" in m else "32"
 
 geturls_ua_pyfile_python = "Mozilla/5.0 (compatible; {proname}/{prover}; +{prourl})".format(
     proname=__project__, prover=__version__, prourl=__project_url__)
@@ -644,6 +697,414 @@ def _resolves_outside(base_rel, target_rel):
         return False
     return True
 
+def _to_bytes(data):
+    if data is None:
+        return b""
+    if isinstance(data, bytes):
+        return data
+    if isinstance(data, unicode):
+        return data.encode("utf-8")
+    try:
+        return bytes(data)
+    except Exception:
+        return (u"%s" % data).encode("utf-8")
+
+def _to_text(b):
+    if isinstance(b, bytes):
+        return b.decode("utf-8", "replace")
+    return b
+
+# ---------- TLS helpers (TCP only) ----------
+def _ssl_available():
+    try:
+        import ssl  # noqa
+        return True
+    except Exception:
+        return False
+
+def _build_ssl_context(server_side=False, verify=True, ca_file=None, certfile=None, keyfile=None):
+    import ssl
+    create_ctx = getattr(ssl, "create_default_context", None)
+    SSLContext = getattr(ssl, "SSLContext", None)
+    Purpose    = getattr(ssl, "Purpose", None)
+    if create_ctx and Purpose:
+        ctx = create_ctx(ssl.Purpose.CLIENT_AUTH if server_side else ssl.Purpose.SERVER_AUTH)
+    elif SSLContext:
+        ctx = SSLContext(getattr(ssl, "PROTOCOL_TLS", getattr(ssl, "PROTOCOL_SSLv23")))
+    else:
+        return None
+
+    if hasattr(ctx, "check_hostname") and not server_side:
+        ctx.check_hostname = bool(verify)
+
+    if verify:
+        if hasattr(ctx, "verify_mode"):
+            ctx.verify_mode = getattr(ssl, "CERT_REQUIRED", 2)
+        if ca_file:
+            try: ctx.load_verify_locations(cafile=ca_file)
+            except Exception: pass
+        else:
+            load_default_certs = getattr(ctx, "load_default_certs", None)
+            if load_default_certs: load_default_certs()
+    else:
+        if hasattr(ctx, "verify_mode"):
+            ctx.verify_mode = getattr(ssl, "CERT_NONE", 0)
+        if hasattr(ctx, "check_hostname"):
+            ctx.check_hostname = False
+
+    if certfile:
+        ctx.load_cert_chain(certfile=certfile, keyfile=keyfile or None)
+
+    try:
+        ctx.set_ciphers("HIGH:!aNULL:!MD5:!RC4")
+    except Exception:
+        pass
+    return ctx
+
+def _ssl_wrap_socket(sock, server_side=False, server_hostname=None,
+                     verify=True, ca_file=None, certfile=None, keyfile=None):
+    import ssl
+    ctx = _build_ssl_context(server_side, verify, ca_file, certfile, keyfile)
+    if ctx is not None:
+        kwargs = {}
+        if not server_side and getattr(ssl, "HAS_SNI", False) and server_hostname:
+            kwargs["server_hostname"] = server_hostname
+        return ctx.wrap_socket(sock, server_side=server_side, **kwargs)
+    # Very old Python fallback
+    kwargs = {
+        "ssl_version": getattr(ssl, "PROTOCOL_TLS", getattr(ssl, "PROTOCOL_SSLv23")),
+        "certfile": certfile or None,
+        "keyfile":  keyfile  or None,
+        "cert_reqs": (getattr(ssl, "CERT_REQUIRED", 2) if (verify and ca_file) else getattr(ssl, "CERT_NONE", 0)),
+    }
+    if verify and ca_file:
+        kwargs["ca_certs"] = ca_file
+    return ssl.wrap_socket(sock, **kwargs)
+
+# ---------- IPv6 / multi-A dialer + keepalive ----------
+def _enable_keepalive(s, idle=60, intvl=15, cnt=4):
+    try:
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+        if hasattr(socket, 'TCP_KEEPIDLE'):
+            s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, idle)
+        if hasattr(socket, 'TCP_KEEPINTVL'):
+            s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, intvl)
+        if hasattr(socket, 'TCP_KEEPCNT'):
+            s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, cnt)
+    except Exception:
+        pass
+
+def _connect_stream(host, port, timeout):
+    err = None
+    for fam, st, proto, _, sa in socket.getaddrinfo(host, int(port), 0, socket.SOCK_STREAM):
+        try:
+            s = socket.socket(fam, st, proto)
+            if timeout is not None:
+                s.settimeout(timeout)
+            try: s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+            except Exception: pass
+            s.connect(sa)
+            _enable_keepalive(s)
+            return s
+        except Exception as e:
+            err = e
+            try: s.close()
+            except Exception: pass
+    if err: raise err
+    raise RuntimeError("no usable address")
+
+# ---------- Auth: AF1 (HMAC) + legacy fallback ----------
+# AF1: single ASCII line ending with '\n':
+#   AF1 ts=<unix> user=<b64url> nonce=<b64url_12B> scope=<b64url> alg=sha256 mac=<hex>\n
+def _b64url_encode(b):
+    s = base64.urlsafe_b64encode(b)
+    return _to_text(s.rstrip(b'='))
+
+def _b64url_decode(s):
+    s = _to_bytes(s)
+    pad = b'=' * ((4 - (len(s) % 4)) % 4)
+    return base64.urlsafe_b64decode(s + pad)
+
+def _auth_msg(ts_int, user_utf8, nonce_bytes, scope_utf8, length_str, sha_hex):
+    # canonical message for MAC: v1|ts|user|nonce_b64|scope|len|sha
+    return _to_bytes("v1|%d|%s|%s|%s|%s|%s" % (
+        ts_int,
+        _to_text(user_utf8),
+        _b64url_encode(nonce_bytes),
+        _to_text(scope_utf8),
+        length_str if length_str is not None else "",
+        sha_hex if sha_hex is not None else "",
+    ))
+
+def build_auth_blob_v1(user, secret, scope=u"", now=None, length=None, sha_hex=None):
+    """
+    user: text; secret: text/bytes (HMAC key)
+    scope: optional text (e.g., path)
+    length: int or None (payload bytes)
+    sha_hex: ascii hex SHA-256 of payload (optional)
+    """
+    ts = int(time.time() if now is None else now)
+    user_b  = _to_bytes(user or u"")
+    scope_b = _to_bytes(scope or u"")
+    key_b   = _to_bytes(secret or u"")
+    nonce   = os.urandom(12)
+
+    length_str = (str(int(length)) if (length is not None and int(length) >= 0) else "")
+    sha_hex = (sha_hex or None)
+    mac = hmac.new(
+        key_b,
+        _auth_msg(ts, user_b, nonce, scope_b, length_str, sha_hex),
+        hashlib.sha256
+    ).hexdigest()
+
+    line = "AF1 ts=%d user=%s nonce=%s scope=%s len=%s sha=%s alg=sha256 mac=%s\n" % (
+        ts,
+        _b64url_encode(user_b),
+        _b64url_encode(nonce),
+        _b64url_encode(scope_b),
+        length_str,
+        (sha_hex or ""),
+        mac,
+    )
+    return _to_bytes(line)
+
+from collections import deque
+class _NonceCache(object):
+    def __init__(self, max_items=10000, ttl_seconds=600):
+        self.max_items = int(max_items); self.ttl = int(ttl_seconds)
+        self.q = deque(); self.s = set()
+    def seen(self, nonce_b64, now_ts):
+        # evict old / over-capacity
+        while self.q and (now_ts - self.q[0][0] > self.ttl or len(self.q) > self.max_items):
+            _, n = self.q.popleft(); self.s.discard(n)
+        if nonce_b64 in self.s: return True
+        self.s.add(nonce_b64); self.q.append((now_ts, nonce_b64))
+        return False
+
+_NONCES = _NonceCache()
+
+def verify_auth_blob_v1(blob_bytes, expected_user=None, secret=None,
+                        max_skew=600, expect_scope=None):
+    """
+    Returns (ok_bool, user_text, scope_text, reason_text, length_or_None, sha_hex_or_None)
+    """
+    try:
+        line = _to_text(blob_bytes).strip()
+        if not line.startswith("AF1 "):
+            return (False, None, None, "bad magic", None, None)
+        kv = {}
+        for tok in line.split()[1:]:
+            if '=' in tok:
+                k, v = tok.split('=', 1); kv[k] = v
+
+        for req in ("ts","user","nonce","mac","alg"):
+            if req not in kv:
+                return (False, None, None, "missing %s" % req, None, None)
+        if kv["alg"].lower() != "sha256":
+            return (False, None, None, "alg", None, None)
+
+        ts    = int(kv["ts"])
+        userb = _b64url_decode(kv["user"])
+        nonce_b64 = kv["nonce"]; nonce = _b64url_decode(nonce_b64)
+        scopeb = _b64url_decode(kv.get("scope","")) if kv.get("scope") else b""
+        length_str = kv.get("len","")
+        sha_hex    = kv.get("sha","") or None
+        mac   = kv["mac"]
+
+        now = int(time.time())
+        if abs(now - ts) > int(max_skew):
+            return (False, None, None, "skew", None, None)
+
+        if _NONCES.seen(nonce_b64, now):
+            return (False, None, None, "replay", None, None)
+
+        if expected_user is not None and _to_bytes(expected_user) != userb:
+            return (False, None, None, "user", None, None)
+
+        calc = hmac.new(
+            _to_bytes(secret or u""),
+            _auth_msg(ts, userb, nonce, scopeb, length_str, sha_hex),
+            hashlib.sha256
+        ).hexdigest()
+        if not hmac.compare_digest(calc, mac):
+            return (False, None, None, "mac", None, None)
+
+        if expect_scope is not None and _to_bytes(expect_scope) != scopeb:
+            return (False, None, None, "scope", None, None)
+
+        length = int(length_str) if (length_str and length_str.isdigit()) else None
+        return (True, _to_text(userb), _to_text(scopeb), "ok", length, sha_hex)
+    except Exception as e:
+        return (False, None, None, "exc:%s" % e, None, None)
+
+# Legacy blob (kept for backward compatibility)
+_MAGIC = b"AUTH\0"; _OK = b"OK"; _NO = b"NO"
+
+def _build_auth_blob_legacy(user, pw):
+    return _MAGIC + _to_bytes(user) + b"\0" + _to_bytes(pw) + b"\0"
+
+def _parse_auth_blob_legacy(data):
+    if not data.startswith(_MAGIC):
+        return (None, None)
+    rest = data[len(_MAGIC):]
+    try:
+        user, rest = rest.split(b"\0", 1)
+        pw, _tail  = rest.split(b"\0", 1)
+        return (user, pw)
+    except Exception:
+        return (None, None)
+
+# ---------- URL helpers ----------
+def _qflag(qs, key, default=False):
+    v = qs.get(key, [None])[0]
+    if v is None: return bool(default)
+    return _to_text(v).lower() in ("1", "true", "yes", "on")
+
+def _qnum(qs, key, default=None, cast=float):
+    v = qs.get(key, [None])[0]
+    if v is None or v == "": return default
+    try: return cast(v)
+    except Exception: return default
+
+def _qstr(qs, key, default=None):
+    v = qs.get(key, [None])[0]
+    if v is None: return default
+    return v
+
+def _parse_net_url(url):
+    """
+    Parse tcp:// / udp:// URL and extract transport options.
+    Returns (parts, opts)
+    """
+    parts = urlparse(url)
+    qs = parse_qs(parts.query or "")
+
+    proto = parts.scheme.lower()
+    if proto not in ("tcp", "udp"):
+        raise ValueError("Only tcp:// or udp:// supported here")
+
+    user = unquote(parts.username) if parts.username else None
+    pw   = unquote(parts.password) if parts.password else None
+
+    use_ssl     = _qflag(qs, "ssl", False) if proto == "tcp" else False
+    ssl_verify  = _qflag(qs, "verify", True)
+    ssl_ca_file = _qstr(qs, "ca", None)
+    ssl_cert    = _qstr(qs, "cert", None)
+    ssl_key     = _qstr(qs, "key", None)
+
+    timeout       = _qnum(qs, "timeout", None, float)
+    total_timeout = _qnum(qs, "total_timeout", None, float)
+    chunk_size    = int(_qnum(qs, "chunk", 65536, float))
+
+    force_auth = _qflag(qs, "auth", False)
+    want_sha   = _qflag(qs, "sha", True)  # <— NEW: default compute sha
+
+    opts = dict(
+        proto=proto,
+        host=parts.hostname or "127.0.0.1",
+        port=int(parts.port or 0),
+
+        user=user, pw=pw, force_auth=force_auth,
+
+        use_ssl=use_ssl, ssl_verify=ssl_verify,
+        ssl_ca_file=ssl_ca_file, ssl_certfile=ssl_cert, ssl_keyfile=ssl_key,
+
+        timeout=timeout, total_timeout=total_timeout, chunk_size=chunk_size,
+
+        server_hostname=parts.hostname or None,
+
+        # new option
+        want_sha=want_sha,
+
+        # convenience (used as scope in AF1)
+        path=(parts.path or u""),
+    )
+    return parts, opts
+
+def _rewrite_url_without_auth(url):
+    u = urlparse(url)
+    netloc = u.hostname or ''
+    if u.port:
+        netloc += ':' + str(u.port)
+    rebuilt = urlunparse((u.scheme, netloc, u.path, u.params, u.query, u.fragment))
+    usr = unquote(u.username) if u.username else ''
+    pwd = unquote(u.password) if u.password else ''
+    return rebuilt, usr, pwd
+
+def _guess_filename(url, filename):
+    if filename:
+        return filename
+    path = urlparse(url).path or ''
+    base = os.path.basename(path)
+    return base or 'OutFile.'+__file_format_extension__
+
+# ---- progress + rate limiting helpers ----
+try:
+    monotonic = time.monotonic  # Py3
+except Exception:
+    # Py2 fallback: time.time() is good enough for coarse throttling
+    monotonic = time.time
+
+def _progress_tick(now_bytes, total_bytes, last_ts, last_bytes, rate_limit_bps, min_interval=0.1):
+    """
+    Returns (sleep_seconds, new_last_ts, new_last_bytes).
+    - If rate_limit_bps is set, computes how long to sleep to keep average <= limit.
+    - Also enforces a minimum interval between progress callbacks (handled by caller).
+    """
+    now = monotonic()
+    elapsed = max(1e-9, now - last_ts)
+    # Desired time to have elapsed for the given rate:
+    desired = (now_bytes - last_bytes) / float(rate_limit_bps) if rate_limit_bps else 0.0
+    extra = desired - elapsed
+    return (max(0.0, extra), now, now_bytes)
+
+def _discover_len_and_reset(fobj):
+    """
+    Try hard to get total length and restore original position.
+    Returns (length_or_None, start_pos_or_None).
+    Works with seekable files and BytesIO; leaves stream position unchanged.
+    """
+    # Generic seek/tell
+    try:
+        pos0 = fobj.tell()
+        fobj.seek(0, os.SEEK_END)
+        end = fobj.tell()
+        fobj.seek(pos0, os.SEEK_SET)
+        if end is not None and pos0 is not None and end >= pos0:
+            return (end - pos0, pos0)
+    except Exception:
+        pass
+
+    # BytesIO fast path
+    try:
+        getvalue = getattr(fobj, "getvalue", None)
+        if callable(getvalue):
+            buf = getvalue()
+            L = len(buf)
+            try:
+                pos0 = fobj.tell()
+            except Exception:
+                pos0 = 0
+            return (max(0, L - pos0), pos0)
+    except Exception:
+        pass
+
+    # Memoryview/getbuffer
+    try:
+        getbuffer = getattr(fobj, "getbuffer", None)
+        if callable(getbuffer):
+            mv = getbuffer()
+            L = len(mv)
+            try:
+                pos0 = fobj.tell()
+            except Exception:
+                pos0 = 0
+            return (max(0, L - pos0), pos0)
+    except Exception:
+        pass
+
+    return (None, None)
+
 
 def DetectTarBombArchiveFileArray(listarrayfiles,
                                  top_file_ratio_threshold=0.6,
@@ -2925,6 +3386,7 @@ def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, list
         outlist['ffilelist'].append(HeaderOut)
         countnum = countnum + 1
         realidnum = realidnum + 1
+    outlist.update({'fp': fp})
     return outlist
 
 
@@ -3278,6 +3740,42 @@ def ReadInMultipleFilesWithContentToArray(infile, fmttype="auto", filestart=0, s
     return ReadInMultipleFileWithContentToArray(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
 
 
+def ReadInStackedFileWithContentToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+    outretval = []
+    outstartfile = filestart
+    outfsize = float('inf')
+    while True:
+        if outstartfile >= outfsize:   # stop when function signals False
+            break
+        outarray = ArchiveFileToArray(infile, fmttype, outstartfile, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, True)
+        outfsize = outarray['fsize']
+        if outarray is False:   # stop when function signals False
+            break
+        infile = outarray['fp']
+        outstartfile = infile.tell()
+        outretval.append(outarray)
+    return outretval
+
+
+def ReadInMultipleStackedFileWithContentToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+    if(isinstance(infile, (list, tuple, ))):
+        pass
+    else:
+        infile = [infile]
+    outretval = {}
+    for curfname in infile:
+        outretval[curfname] = ReadInStackedFileWithContentToArray(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+    return outretval
+
+
+def ReadInStackedFilesWithContentToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+    return ReadInStackedFileWithContentToArray(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+
+
+def ReadInMultipleStackedFilesWithContentToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+    return ReadInMultipleStackedFileWithContentToArray(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+
+
 def ReadInFileWithContentToList(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
     if(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype in formatspecs):
         formatspecs = formatspecs[fmttype]
@@ -3459,7 +3957,7 @@ def ReadInMultipleFileWithContentToList(infile, fmttype="auto", filestart=0, see
         infile = [infile]
     outretval = {}
     for curfname in infile:
-        curretfile[curfname] = ReadInFileWithContentToList(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+        outretval[curfname] = ReadInFileWithContentToList(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
     return outretval
 
 def ReadInMultipleFilesWithContentToList(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
@@ -4028,12 +4526,6 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                       fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, fdev_minor, fdev_major, "+"+str(len(formatspecs['format_delimiter']))]
         AppendFileHeaderWithContent(
             fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[1], checksumtype[2], checksumtype[3]], formatspecs)
-    if(numfiles > 0):
-        try:
-            fp.write(AppendNullBytes(
-                ["0", "0"], formatspecs['format_delimiter']))
-        except OSError:
-            return False
     fp.seek(0, 0)
     return fp
 
@@ -4097,12 +4589,6 @@ def AppendListsWithContent(inlist, fp, dirlistfromtxt=False, filevalues=[], extr
         fcontents.seek(0, 0)
         AppendFileHeaderWithContent(
             fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[1], checksumtype[2], checksumtype[3]], formatspecs)
-    if(numfiles > 0):
-        try:
-            fp.write(AppendNullBytes(
-                ["0", "0"], formatspecs['format_delimiter']))
-        except OSError:
-            return False
     return fp
 
 
@@ -5495,12 +5981,6 @@ def PackArchiveFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", comp
         AppendFileHeaderWithContent(
             fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[1], checksumtype[2], checksumtype[3]], formatspecs)
         fcontents.close()
-    if(numfiles > 0):
-        try:
-            fp.write(AppendNullBytes(
-                ["0", "0"], formatspecs['format_delimiter']))
-        except OSError:
-            return False
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
@@ -5796,12 +6276,6 @@ def PackArchiveFileFromTarFile(infile, outfile, fmttype="auto", compression="aut
         AppendFileHeaderWithContent(
             fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[1], checksumtype[2], checksumtype[3]], formatspecs)
         fcontents.close()
-    if(numfiles > 0):
-        try:
-            fp.write(AppendNullBytes(
-                ["0", "0"], formatspecs['format_delimiter']))
-        except OSError:
-            return False
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
@@ -6090,12 +6564,6 @@ def PackArchiveFileFromZipFile(infile, outfile, fmttype="auto", compression="aut
         AppendFileHeaderWithContent(
             fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[1], checksumtype[2], checksumtype[3]], formatspecs)
         fcontents.close()
-    if(numfiles > 0):
-        try:
-            fp.write(AppendNullBytes(
-                ["0", "0"], formatspecs['format_delimiter']))
-        except OSError:
-            return False
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
@@ -6410,12 +6878,6 @@ if(rarfile_support):
             AppendFileHeaderWithContent(
                 fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[1], checksumtype[2], checksumtype[3]], formatspecs)
             fcontents.close()
-        if(numfiles > 0):
-            try:
-                fp.write(AppendNullBytes(
-                    ["0", "0"], formatspecs['format_delimiter']))
-            except OSError:
-                return False
         if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
             fp = CompressOpenFileAlt(
                 fp, compression, compressionlevel, compressionuselist, formatspecs)
@@ -6664,12 +7126,6 @@ if(py7zr_support):
             AppendFileHeaderWithContent(
                 fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[1], checksumtype[2], checksumtype[3]], formatspecs)
             fcontents.close()
-        if(numfiles > 0):
-            try:
-                fp.write(AppendNullBytes(
-                    ["0", "0"], formatspecs['format_delimiter']))
-            except OSError:
-                return False
         if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
             fp = CompressOpenFileAlt(
                 fp, compression, compressionlevel, compressionuselist, formatspecs)
@@ -7059,24 +7515,75 @@ def ArchiveFileValidate(infile, fmttype="auto", filestart=0, formatspecs=__file_
         return False
 
 
-def ArchiveFileValidateFile(infile, fmttype="auto", formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
-    return ArchiveFileValidate(infile, fmttype, formatspecs, verbose, returnfp)
+def ArchiveFileValidateFile(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
+    return ArchiveFileValidate(infile, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
+
+
+def ArchiveFileValidateMultiple(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
+    if(isinstance(infile, (list, tuple, ))):
+        pass
+    else:
+        infile = [infile]
+    outretval = True
+    for curfname in infile:
+        curretfile = ArchiveFileValidate(curfname, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
+        if(not curretfile):
+            outretval = False
+    return outretval
+
+def ArchiveFileValidateMultipleFiles(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
+    return ArchiveFileValidateMultiple(infile, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
+
 
+def StackedArchiveFileValidate(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
+    outretval = []
+    outstartfile = filestart
+    outfsize = float('inf')
+    while True:
+        if outstartfile >= outfsize:   # stop when function signals False
+            break
+        is_valid_file = ArchiveFileValidate(infile, fmttype, filestart, formatspecs, seektoend, verbose, True)
+        if is_valid_file is False:   # stop when function signals False
+            outretval.append(is_valid_file)
+        else:
+            outretval.append(True)
+        infile = is_valid_file
+        outstartfile = infile.tell()
+        try:
+            infile.seek(0, 2)
+        except OSError:
+            SeekToEndOfFile(infile)
+        except ValueError:
+            SeekToEndOfFile(infile)
+        outfsize = infile.tell()
+        infile.seek(outstartfile, 0)
+    if(returnfp):
+        return infile
+    else:
+        infile.close()
+        return outretval
+    
+
+
+def StackedArchiveFileValidateFile(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
+    return StackedArchiveFileValidate(infile, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
 
-def ArchiveFileValidateMultiple(infile, fmttype="auto", formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+
+def StackedArchiveFileValidateMultiple(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
     if(isinstance(infile, (list, tuple, ))):
         pass
     else:
         infile = [infile]
     outretval = True
     for curfname in infile:
-        curretfile = ArchiveFileValidate(curfname, fmttype, formatspecs, verbose, returnfp)
+        curretfile = StackedArchiveFileValidate(curfname, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
         if(not curretfile):
             outretval = False
     return outretval
 
-def ArchiveFileValidateMultipleFiles(infile, fmttype="auto", formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
-    return ArchiveFileValidateMultiple(infile, fmttype, formatspecs, verbose, returnfp)
+def StackedArchiveFileValidateMultipleFiles(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
+    return StackedArchiveFileValidateMultiple(infile, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
+
 
 def ArchiveFileToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
     if(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype in formatspecs):
@@ -7089,20 +7596,20 @@ def ArchiveFileToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend
         fp = infile
         fp.seek(filestart, 0)
         fp = UncompressFileAlt(fp, formatspecs, filestart)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, True)
-        if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
-            formatspecs = formatspecs[checkcompressfile]
-        if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
+        compresscheck = CheckCompressionSubType(fp, formatspecs, filestart, True)
+        if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
+            formatspecs = formatspecs[compresscheck]
+        if(compresscheck == "tarfile" and TarFileCheck(infile)):
             return TarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
+        elif(compresscheck == "zipfile" and zipfile.is_zipfile(infile)):
             return ZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
+        elif(rarfile_support and compresscheck == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
             return RarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
+        elif(py7zr_support and compresscheck == "7zipfile" and py7zr.is_7zfile(infile)):
             return SevenZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(IsSingleDict(formatspecs) and checkcompressfile != formatspecs['format_magic']):
+        elif(IsSingleDict(formatspecs) and compresscheck != formatspecs['format_magic']):
             return False
-        elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
+        elif(IsNestedDict(formatspecs) and compresscheck not in formatspecs):
             return False
         if(not fp):
             return False
@@ -7115,9 +7622,9 @@ def ArchiveFileToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend
             shutil.copyfileobj(sys.stdin, fp)
         fp.seek(filestart, 0)
         fp = UncompressFileAlt(fp, formatspecs, filestart)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, True)
-        if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
-            formatspecs = formatspecs[checkcompressfile]
+        compresscheck = CheckCompressionSubType(fp, formatspecs, filestart, True)
+        if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
+            formatspecs = formatspecs[compresscheck]
         if(not fp):
             return False
         fp.seek(filestart, 0)
@@ -7144,20 +7651,20 @@ def ArchiveFileToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend
         fp.seek(filestart, 0)
     else:
         infile = RemoveWindowsPath(infile)
-        checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
-        if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
-            formatspecs = formatspecs[checkcompressfile]
-        if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
+        compresscheck = CheckCompressionSubType(infile, formatspecs, filestart, True)
+        if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
+            formatspecs = formatspecs[compresscheck]
+        if(compresscheck == "tarfile" and TarFileCheck(infile)):
             return TarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
+        elif(compresscheck == "zipfile" and zipfile.is_zipfile(infile)):
             return ZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
+        elif(rarfile_support and compresscheck == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
             return RarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
+        elif(py7zr_support and compresscheck == "7zipfile" and py7zr.is_7zfile(infile)):
             return SevenZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(IsSingleDict(formatspecs) and checkcompressfile != formatspecs['format_magic']):
+        elif(IsSingleDict(formatspecs) and compresscheck != formatspecs['format_magic']):
             return False
-        elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
+        elif(IsNestedDict(formatspecs) and compresscheck not in formatspecs):
             return False
         compresscheck = CheckCompressionType(infile, formatspecs, filestart, True)
         if(not compresscheck):
@@ -7536,6 +8043,7 @@ def ArchiveFileToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend
         outlist.update({'fp': fp})
     else:
         fp.close()
+        outlist.update({'fp': None})
     return outlist
 
 
@@ -7546,13 +8054,48 @@ def MultipleArchiveFileToArray(infile, fmttype="auto", filestart=0, seekstart=0,
         infile = [infile]
     outretval = {}
     for curfname in infile:
-        curretfile[curfname] = ArchiveFileToArray(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
+        outretval[curfname] = ArchiveFileToArray(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
     return outretval
 
 def MultipleArchiveFilesToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
     return MultipleArchiveFileToArray(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
 
 
+def StackedArchiveFileToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+    outretval = []
+    outstartfile = filestart
+    outfsize = float('inf')
+    while True:
+        if outstartfile >= outfsize:   # stop when function signals False
+            break
+        outarray = ArchiveFileToArray(infile, fmttype, outstartfile, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, True)
+        outfsize = outarray['fsize']
+        if outarray is False:   # stop when function signals False
+            break
+        infile = outarray['fp']
+        outstartfile = infile.tell()
+        if(not returnfp):
+            outarray.update({"fp": None})
+        outretval.append(outarray)
+    if(not returnfp):
+        infile.close()
+    return outretval
+
+
+def MultipleStackedArchiveFileToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+    if(isinstance(infile, (list, tuple, ))):
+        pass
+    else:
+        infile = [infile]
+    outretval = {}
+    for curfname in infile:
+        outretval[curfname] = StackedArchiveFileToArray(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
+    return outretval
+
+def MultipleStackedArchiveFilesToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+    return MultipleStackedArchiveFileToArray(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
+
+
 def ArchiveFileStringToArray(instr, filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
     checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
@@ -7638,74 +8181,126 @@ def ListDirToArray(infiles, dirlistfromtxt=False, fmttype=__file_format_default_
     outarray = MkTempFile()
     packform = PackArchiveFile(infiles, outarray, dirlistfromtxt, fmttype, compression, compresswholefile,
                               compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, True)
-    listarrayfiles = ArchiveFileToArray(outarray, "auto", filestart, seekstart, seekend, listonly, True, skipchecksum, formatspecs, seektoend, returnfp)
+    listarrayfiles = ArchiveFileToArray(outarray, "auto", filestart, seekstart, seekend, listonly, True, True, skipchecksum, formatspecs, seektoend, returnfp)
     return listarrayfiles
 
 
+# ===== Function (keeps inarray schema; returns entries + indexes) =====
+
 def ArchiveFileArrayToArrayIndex(inarray, returnfp=False):
-    if(isinstance(inarray, dict)):
-        listarrayfiles = inarray
-    else:
+    """
+    Build a bidirectional index over an archive listing while preserving the
+    input 'inarray' as-is. Python 2/3 compatible, no external deps.
+
+    Input (unchanged contract):
+      inarray: dict with at least:
+        - 'ffilelist': list of dicts: {'fname': <str>, 'fid': <any>, 'ftype': <int>}
+        - 'fnumfiles': int (expected count)
+        - optional 'fp': any (passed through if returnfp=True)
+
+    Output structure:
+      {
+        'list': inarray,                 # alias to original input (not copied)
+        'fp':   inarray.get('fp') or None,
+        'entries': { fid: {'name': fname, 'type': ftype} },
+        'indexes': {
+          'by_name': { fname: fid },
+          'by_type': {
+            <category>: {
+              'by_name': { fname: fid },
+              'by_id':   { fid: fname },
+              'count':   <int>
+            }, ...
+          }
+        },
+        'counts': {
+          'total': <int>,
+          'by_type': { <category>: <int>, ... }
+        },
+        'unknown_types': { <ftype_int>: [fname, ...] }
+      }
+    """
+    if not isinstance(inarray, dict):
         return False
-    if(not listarrayfiles):
+    if not inarray:
         return False
-    outarray = {'list': listarrayfiles, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {
-    }, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}}
-    if(returnfp):
-        outarray.update({'fp': listarrayfiles['fp']})
-    lenlist = len(listarrayfiles['ffilelist'])
-    lcfi = 0
-    lcfx = int(listarrayfiles['fnumfiles'])
-    if(lenlist > listarrayfiles['fnumfiles'] or lenlist < listarrayfiles['fnumfiles']):
-        lcfx = int(lenlist)
-    else:
-        lcfx = int(listarrayfiles['fnumfiles'])
-    while(lcfi < lcfx):
-        filetoidarray = {listarrayfiles['ffilelist'][lcfi]
-                         ['fname']: listarrayfiles['ffilelist'][lcfi]['fid']}
-        idtofilearray = {listarrayfiles['ffilelist'][lcfi]
-                         ['fid']: listarrayfiles['ffilelist'][lcfi]['fname']}
-        outarray['filetoid'].update(filetoidarray)
-        outarray['idtofile'].update(idtofilearray)
-        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 0 or listarrayfiles['ffilelist'][lcfi]['ftype'] == 7):
-            outarray['filetypes']['files']['filetoid'].update(filetoidarray)
-            outarray['filetypes']['files']['idtofile'].update(idtofilearray)
-        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 1):
-            outarray['filetypes']['hardlinks']['filetoid'].update(
-                filetoidarray)
-            outarray['filetypes']['hardlinks']['idtofile'].update(
-                idtofilearray)
-            outarray['filetypes']['links']['filetoid'].update(filetoidarray)
-            outarray['filetypes']['links']['idtofile'].update(idtofilearray)
-        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 2):
-            outarray['filetypes']['symlinks']['filetoid'].update(filetoidarray)
-            outarray['filetypes']['symlinks']['idtofile'].update(idtofilearray)
-            outarray['filetypes']['links']['filetoid'].update(filetoidarray)
-            outarray['filetypes']['links']['idtofile'].update(idtofilearray)
-        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 3):
-            outarray['filetypes']['character']['filetoid'].update(
-                filetoidarray)
-            outarray['filetypes']['character']['idtofile'].update(
-                idtofilearray)
-            outarray['filetypes']['devices']['filetoid'].update(filetoidarray)
-            outarray['filetypes']['devices']['idtofile'].update(idtofilearray)
-        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 4):
-            outarray['filetypes']['block']['filetoid'].update(filetoidarray)
-            outarray['filetypes']['block']['idtofile'].update(idtofilearray)
-            outarray['filetypes']['devices']['filetoid'].update(filetoidarray)
-            outarray['filetypes']['devices']['idtofile'].update(idtofilearray)
-        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 5):
-            outarray['filetypes']['directories']['filetoid'].update(
-                filetoidarray)
-            outarray['filetypes']['directories']['idtofile'].update(
-                idtofilearray)
-        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 6):
-            outarray['filetypes']['symlinks']['filetoid'].update(filetoidarray)
-            outarray['filetypes']['symlinks']['idtofile'].update(idtofilearray)
-            outarray['filetypes']['devices']['filetoid'].update(filetoidarray)
-            outarray['filetypes']['devices']['idtofile'].update(idtofilearray)
-        lcfi = lcfi + 1
-    return outarray
+
+    # Buckets for categories
+    def _bucket():
+        return {"by_name": {}, "by_id": {}, "count": 0}
+
+    by_type = {}
+    for cat in CATEGORY_ORDER:
+        by_type[cat] = _bucket()
+
+    out = {
+        "list": inarray,
+        "fp": inarray.get("fp") if returnfp else None,
+        "entries": {},
+        "indexes": {
+            "by_name": {},
+            "by_type": by_type,
+        },
+        "counts": {"total": 0, "by_type": {}},
+        "unknown_types": {},
+    }
+
+    ffilelist = inarray.get("ffilelist") or []
+    try:
+        fnumfiles = int(inarray.get("fnumfiles", len(ffilelist)))
+    except Exception:
+        fnumfiles = len(ffilelist)
+
+    # Process only what's present
+    total = min(len(ffilelist), fnumfiles)
+
+    def _add(cat, name, fid):
+        b = by_type[cat]
+        b["by_name"][name] = fid
+        b["by_id"][fid] = name
+        # Count is number of unique names in this category
+        b["count"] = len(b["by_name"])
+
+    i = 0
+    while i < total:
+        e = ffilelist[i]
+        name = e.get("fname")
+        fid  = e.get("fid")
+        t    = e.get("ftype")
+
+        if name is None or fid is None or t is None:
+            i += 1
+            continue
+
+        # Store canonical entry once, keyed by fid
+        out["entries"][fid] = {"name": name, "type": t}
+
+        # Global reverse index for fast name -> id
+        out["indexes"]["by_name"][name] = fid
+
+        # Base category
+        base_cat = BASE_CATEGORY_BY_CODE.get(t)
+        if base_cat is not None:
+            _add(base_cat, name, fid)
+        else:
+            # Track unknown codes for visibility/forward-compat
+            lst = out["unknown_types"].setdefault(t, [])
+            if name not in lst:
+                lst.append(name)
+
+        # Union categories
+        for union_name, code_set in UNION_RULES:
+            if t in code_set:
+                _add(union_name, name, fid)
+
+        i += 1
+
+    # Counts
+    out["counts"]["total"] = total
+    for cat in CATEGORY_ORDER:
+        out["counts"]["by_type"][cat] = by_type[cat]["count"]
+
+    return out
 
 
 def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, filestart=0, seekstart=0, seekend=0, checksumtype=["crc32", "crc32", "crc32", "crc32"], skipchecksum=False, extradata=[], jsondata={}, formatspecs=__file_format_dict__, seektoend=False, verbose=False, returnfp=False):
@@ -7714,13 +8309,12 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
     else:
         if(infile != "-" and not isinstance(infile, bytes) and not hasattr(infile, "read") and not hasattr(infile, "write")):
             infile = RemoveWindowsPath(infile)
-        listarrayfiles = ArchiveFileToArray(infile, "auto", filestart, seekstart, seekend, False, True, skipchecksum, formatspecs, seektoend, returnfp)
+        listarrayfiles = ArchiveFileToArray(infile, "auto", filestart, seekstart, seekend, False, True, True, skipchecksum, formatspecs, seektoend, returnfp)
     if(IsNestedDict(formatspecs) and fmttype in formatspecs):
         formatspecs = formatspecs[fmttype]
     elif(IsNestedDict(formatspecs) and fmttype not in formatspecs):
         fmttype = __file_format_default__
         formatspecs = formatspecs[fmttype]
-
         if(IsNestedDict(formatspecs) and fmttype in formatspecs):
             formatspecs = formatspecs[fmttype]
         elif(IsNestedDict(formatspecs) and fmttype not in formatspecs):
@@ -7827,11 +8421,11 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
         fdev_major = format(
             int(listarrayfiles['ffilelist'][reallcfi]['fmajor']), 'x').lower()
         fseeknextfile = listarrayfiles['ffilelist'][reallcfi]['fseeknextfile']
-        if(len(listarrayfiles['ffilelist'][reallcfi]['fextralist']) > listarrayfiles['ffilelist'][reallcfi]['fextrafields'] and len(listarrayfiles['ffilelist'][reallcfi]['fextralist']) > 0):
+        if(len(listarrayfiles['ffilelist'][reallcfi]['fextradata']) > listarrayfiles['ffilelist'][reallcfi]['fextrafields'] and len(listarrayfiles['ffilelist'][reallcfi]['fextradata']) > 0):
             listarrayfiles['ffilelist'][reallcfi]['fextrafields'] = len(
-                listarrayfiles['ffilelist'][reallcfi]['fextralist'])
+                listarrayfiles['ffilelist'][reallcfi]['fextradata'])
         if(not followlink and len(extradata) <= 0):
-            extradata = listarrayfiles['ffilelist'][reallcfi]['fextralist']
+            extradata = listarrayfiles['ffilelist'][reallcfi]['fextradata']
         if(not followlink and len(jsondata) <= 0):
             jsondata = listarrayfiles['ffilelist'][reallcfi]['fjsondata']
         fcontents = listarrayfiles['ffilelist'][reallcfi]['fcontents']
@@ -7910,10 +8504,10 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
                 fdev_minor = format(int(flinkinfo['fminor']), 'x').lower()
                 fdev_major = format(int(flinkinfo['fmajor']), 'x').lower()
                 fseeknextfile = flinkinfo['fseeknextfile']
-                if(len(flinkinfo['fextralist']) > flinkinfo['fextrafields'] and len(flinkinfo['fextralist']) > 0):
-                    flinkinfo['fextrafields'] = len(flinkinfo['fextralist'])
+                if(len(flinkinfo['fextradata']) > flinkinfo['fextrafields'] and len(flinkinfo['fextradata']) > 0):
+                    flinkinfo['fextrafields'] = len(flinkinfo['fextradata'])
                 if(len(extradata) < 0):
-                    extradata = flinkinfo['fextralist']
+                    extradata = flinkinfo['fextradata']
                 if(len(jsondata) < 0):
                     extradata = flinkinfo['fjsondata']
                 fcontents = flinkinfo['fcontents']
@@ -7945,12 +8539,6 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
         fcontents.close()
         lcfi = lcfi + 1
         reallcfi = reallcfi + 1
-    if(lcfx > 0):
-        try:
-            fp.write(AppendNullBytes(
-                ["0", "0"], formatspecs['format_delimiter']))
-        except OSError:
-            return False
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
@@ -8014,7 +8602,7 @@ def UnPackArchiveFile(infile, outdir=None, followlink=False, filestart=0, seekst
     else:
         if(infile != "-" and not hasattr(infile, "read") and not hasattr(infile, "write") and not (sys.version_info[0] >= 3 and isinstance(infile, bytes))):
             infile = RemoveWindowsPath(infile)
-        listarrayfiles = ArchiveFileToArray(infile, "auto", filestart, seekstart, seekend, False, True, skipchecksum, formatspecs, seektoend, returnfp)
+        listarrayfiles = ArchiveFileToArray(infile, "auto", filestart, seekstart, seekend, False, True, True, skipchecksum, formatspecs, seektoend, returnfp)
     if(not listarrayfiles):
         return False
     lenlist = len(listarrayfiles['ffilelist'])
@@ -8262,9 +8850,9 @@ def UnPackArchiveFile(infile, outdir=None, followlink=False, filestart=0, seekst
         return True
 
 
-def UnPackArchiveFileString(instr, outdir=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
+def UnPackArchiveFileString(instr, outdir=None, followlink=False, filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
     fp = MkTempFile(instr)
-    listarrayfiles = UnPackArchiveFile(fp, outdir, followlink, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, returnfp)
+    listarrayfiles = UnPackArchiveFile(fp, outdir, followlink, filestart, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, returnfp)
     return listarrayfiles
 
 def ftype_to_str(ftype):
@@ -8335,10 +8923,89 @@ def ArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seeke
         return True
 
 
-def ArchiveFileStringListFiles(instr, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, newstyle=False, returnfp=False):
+def MultipleArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+    if(isinstance(infile, (list, tuple, ))):
+        pass
+    else:
+        infile = [infile]
+    outretval = {}
+    for curfname in infile:
+        outretval[curfname] = ArchiveFileListFiles(infile, fmttype, filestart, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, newstyle, returnfp)
+    return outretval
+
+
+def StackedArchiveFileValidate(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
+    outretval = []
+    outstartfile = filestart
+    outfsize = float('inf')
+    while True:
+        if outstartfile >= outfsize:   # stop when function signals False
+            break
+        is_valid_file = ArchiveFileValidate(infile, fmttype, filestart, formatspecs, seektoend, verbose, True)
+        if is_valid_file is False:   # stop when function signals False
+            outretval.append(is_valid_file)
+        else:
+            outretval.append(True)
+        infile = is_valid_file
+        outstartfile = infile.tell()
+        try:
+            infile.seek(0, 2)
+        except OSError:
+            SeekToEndOfFile(infile)
+        except ValueError:
+            SeekToEndOfFile(infile)
+        outfsize = infile.tell()
+        infile.seek(outstartfile, 0)
+    if(returnfp):
+        return infile
+    else:
+        infile.close()
+        return outretval
+
+
+def StackedArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, newstyle=False, returnfp=False):
+    outretval = []
+    outstartfile = filestart
+    outfsize = float('inf')
+    while True:
+        if outstartfile >= outfsize:   # stop when function signals False
+            break
+        list_file_retu = ArchiveFileListFiles(infile, fmttype, outstartfile, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, newstyle, True)
+        if list_file_retu is False:   # stop when function signals False
+            outretval.append(list_file_retu)
+        else:
+            outretval.append(True)
+        infile = list_file_retu
+        outstartfile = infile.tell()
+        try:
+            infile.seek(0, 2)
+        except OSError:
+            SeekToEndOfFile(infile)
+        except ValueError:
+            SeekToEndOfFile(infile)
+        outfsize = infile.tell()
+        infile.seek(outstartfile, 0)
+    if(returnfp):
+        return infile
+    else:
+        infile.close()
+        return outretval
+
+
+def MultipleStackedArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+    if(isinstance(infile, (list, tuple, ))):
+        pass
+    else:
+        infile = [infile]
+    outretval = {}
+    for curfname in infile:
+        outretval[curfname] = StackedArchiveFileListFiles(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
+    return outretval
+
+
+def ArchiveFileStringListFiles(instr, filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, newstyle=False, returnfp=False):
     fp = MkTempFile(instr)
-    listarrayfiles = ArchiveFileListFiles(
-        instr, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, newstyle, returnfp)
+    listarrayfiles = ArchiveFileListFiles(instr, "auto", filestart, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, newstyle, returnfp)
     return listarrayfiles
 
 
@@ -8930,11 +9597,11 @@ def download_file_from_ftp_file(url):
     file_name = os.path.basename(unquote(urlparts.path))
     file_dir = os.path.dirname(unquote(urlparts.path))
     if(urlparts.username is not None):
-        ftp_username = urlparts.username
+        ftp_username = unquote(urlparts.username)
     else:
         ftp_username = "anonymous"
     if(urlparts.password is not None):
-        ftp_password = urlparts.password
+        ftp_password = unquote(urlparts.password)
     elif(urlparts.password is None and urlparts.username == "anonymous"):
         ftp_password = "anonymous"
     else:
@@ -8945,13 +9612,6 @@ def download_file_from_ftp_file(url):
         ftp = FTP_TLS()
     else:
         return False
-    if(urlparts.scheme == "sftp" or urlparts.scheme == "scp"):
-        if(__use_pysftp__):
-            return download_file_from_pysftp_file(url)
-        else:
-            return download_file_from_sftp_file(url)
-    elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
-        return download_file_from_http_file(url)
     ftp_port = urlparts.port
     if(urlparts.port is None):
         ftp_port = 21
@@ -9028,11 +9688,11 @@ def upload_file_to_ftp_file(ftpfile, url):
     file_name = os.path.basename(unquote(urlparts.path))
     file_dir = os.path.dirname(unquote(urlparts.path))
     if(urlparts.username is not None):
-        ftp_username = urlparts.username
+        ftp_username = unquote(urlparts.username)
     else:
         ftp_username = "anonymous"
     if(urlparts.password is not None):
-        ftp_password = urlparts.password
+        ftp_password = unquote(urlparts.password)
     elif(urlparts.password is None and urlparts.username == "anonymous"):
         ftp_password = "anonymous"
     else:
@@ -9043,13 +9703,6 @@ def upload_file_to_ftp_file(ftpfile, url):
         ftp = FTP_TLS()
     else:
         return False
-    if(urlparts.scheme == "sftp" or urlparts.scheme == "scp"):
-        if(__use_pysftp__):
-            return upload_file_to_pysftp_file(url)
-        else:
-            return upload_file_to_sftp_file(url)
-    elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
-        return False
     ftp_port = urlparts.port
     if(urlparts.port is None):
         ftp_port = 21
@@ -9147,8 +9800,8 @@ def download_file_from_http_file(url, headers=None, usehttp=__use_http_lib__):
     if headers is None:
         headers = {}
     urlparts = urlparse(url)
-    username = urlparts.username
-    password = urlparts.password
+    username = unquote(urlparts.username)
+    password = unquote(urlparts.password)
 
     # Rebuild URL without username and password
     netloc = urlparts.hostname or ''
@@ -9157,15 +9810,6 @@ def download_file_from_http_file(url, headers=None, usehttp=__use_http_lib__):
     rebuilt_url = urlunparse((urlparts.scheme, netloc, urlparts.path,
                               urlparts.params, urlparts.query, urlparts.fragment))
 
-    # Handle SFTP/FTP
-    if urlparts.scheme == "sftp" or urlparts.scheme == "scp":
-        if __use_pysftp__:
-            return download_file_from_pysftp_file(url)
-        else:
-            return download_file_from_sftp_file(url)
-    elif urlparts.scheme == "ftp" or urlparts.scheme == "ftps":
-        return download_file_from_ftp_file(url)
-
     # Create a temporary file object
     httpfile = MkTempFile()
 
@@ -9229,6 +9873,184 @@ def download_file_from_http_file(url, headers=None, usehttp=__use_http_lib__):
     return httpfile
 
 
+def upload_file_to_http_file(
+    fileobj,
+    url,
+    method="POST",                 # "POST" or "PUT"
+    headers=None,
+    form=None,                     # dict of extra form fields → triggers multipart/form-data
+    field_name="file",             # form field name for the file content
+    filename=None,                 # defaults to basename of URL path
+    content_type="application/octet-stream",
+    usehttp=__use_http_lib__,      # 'requests' | 'httpx' | 'mechanize' | anything → urllib fallback
+):
+    """
+    Py2+Py3 compatible HTTP/HTTPS upload.
+
+    - If `form` is provided (dict), uses multipart/form-data:
+        * text fields from `form`
+        * file part named by `field_name` with given `filename` and `content_type`
+    - If `form` is None, uploads raw body as POST/PUT with Content-Type.
+    - Returns True on HTTP 2xx, else False.
+    """
+    if headers is None:
+        headers = {}
+    method = (method or "POST").upper()
+
+    rebuilt_url, username, password = _rewrite_url_without_auth(url)
+    filename = _guess_filename(url, filename)
+
+    # rewind if possible
+    try:
+        fileobj.seek(0)
+    except Exception:
+        pass
+
+    # ========== 1) requests (Py2+Py3) ==========
+    if usehttp == 'requests' and haverequests:
+        import requests
+
+        auth = (username, password) if (username or password) else None
+
+        if form is not None:
+            # multipart/form-data
+            files = {field_name: (filename, fileobj, content_type)}
+            data = form or {}
+            resp = requests.request(method, rebuilt_url, headers=headers, auth=auth,
+                                    files=files, data=data, timeout=(5, 120))
+        else:
+            # raw body
+            hdrs = {'Content-Type': content_type}
+            hdrs.update(headers)
+            # best-effort content-length (helps some servers)
+            if hasattr(fileobj, 'seek') and hasattr(fileobj, 'tell'):
+                try:
+                    cur = fileobj.tell()
+                    fileobj.seek(0, io.SEEK_END if hasattr(io, 'SEEK_END') else 2)
+                    size = fileobj.tell() - cur
+                    fileobj.seek(cur)
+                    hdrs.setdefault('Content-Length', str(size))
+                except Exception:
+                    pass
+            resp = requests.request(method, rebuilt_url, headers=hdrs, auth=auth,
+                                    data=fileobj, timeout=(5, 300))
+
+        return (200 <= resp.status_code < 300)
+
+    # ========== 2) httpx (Py3 only) ==========
+    if usehttp == 'httpx' and havehttpx and not PY2:
+        import httpx
+        auth = (username, password) if (username or password) else None
+
+        with httpx.Client(follow_redirects=True, timeout=60) as client:
+            if form is not None:
+                files = {field_name: (filename, fileobj, content_type)}
+                data  = form or {}
+                resp = client.request(method, rebuilt_url, headers=headers, auth=auth,
+                                      files=files, data=data)
+            else:
+                hdrs = {'Content-Type': content_type}
+                hdrs.update(headers)
+                resp = client.request(method, rebuilt_url, headers=hdrs, auth=auth,
+                                      content=fileobj)
+        return (200 <= resp.status_code < 300)
+
+    # ========== 3) mechanize (forms) → prefer requests if available ==========
+    if usehttp == 'mechanize' and havemechanize:
+        # mechanize is great for HTML forms, but file upload requires form discovery.
+        # For a generic upload helper, prefer requests. If not available, fall through.
+        try:
+            import requests  # noqa
+            # delegate to requests path to ensure robust multipart handling
+            return upload_file_to_http_file(
+                fileobj, url, method=method, headers=headers,
+                form=(form or {}), field_name=field_name,
+                filename=filename, content_type=content_type,
+                usehttp='requests'
+            )
+        except Exception:
+            pass  # fall through to urllib
+
+    # ========== 4) urllib fallback (Py2+Py3) ==========
+    # multipart builder (no f-strings)
+    boundary = ('----pyuploader-%s' % uuid.uuid4().hex)
+
+    if form is not None:
+        # Build multipart body to a temp file-like (your MkTempFile())
+        buf = MkTempFile()
+
+        def _w(s):
+            buf.write(_to_bytes(s))
+
+        # text fields
+        if form:
+            for k, v in form.items():
+                _w('--' + boundary + '\r\n')
+                _w('Content-Disposition: form-data; name="%s"\r\n\r\n' % k)
+                _w('' if v is None else (v if isinstance(v, (str, bytes)) else str(v)))
+                _w('\r\n')
+
+        # file field
+        _w('--' + boundary + '\r\n')
+        _w('Content-Disposition: form-data; name="%s"; filename="%s"\r\n' % (field_name, filename))
+        _w('Content-Type: %s\r\n\r\n' % content_type)
+
+        try:
+            fileobj.seek(0)
+        except Exception:
+            pass
+        shutil.copyfileobj(fileobj, buf)
+
+        _w('\r\n')
+        _w('--' + boundary + '--\r\n')
+
+        buf.seek(0)
+        data = buf.read()
+        hdrs = {'Content-Type': 'multipart/form-data; boundary=%s' % boundary}
+        hdrs.update(headers)
+        req = Request(rebuilt_url, data=data)
+        # method override for Py3; Py2 Request ignores 'method' kw
+        if not PY2:
+            req.method = method  # type: ignore[attr-defined]
+    else:
+        # raw body
+        try:
+            fileobj.seek(0)
+        except Exception:
+            pass
+        data = fileobj.read()
+        hdrs = {'Content-Type': content_type}
+        hdrs.update(headers)
+        req = Request(rebuilt_url, data=data)
+        if not PY2:
+            req.method = method  # type: ignore[attr-defined]
+
+    for k, v in hdrs.items():
+        req.add_header(k, v)
+
+    # Basic auth if present
+    if username or password:
+        pwd_mgr = HTTPPasswordMgrWithDefaultRealm()
+        pwd_mgr.add_password(None, rebuilt_url, username, password)
+        opener = build_opener(HTTPBasicAuthHandler(pwd_mgr))
+    else:
+        opener = build_opener()
+
+    # Py2 OpenerDirector.open takes timeout since 2.6; to be safe, avoid passing if it explodes
+    try:
+        resp = opener.open(req, timeout=60)
+    except TypeError:
+        resp = opener.open(req)
+
+    # Status code compat
+    code = getattr(resp, 'status', None) or getattr(resp, 'code', None) or 0
+    try:
+        resp.close()
+    except Exception:
+        pass
+    return (200 <= int(code) < 300)
+
+
 def download_file_from_http_string(url, headers=geturls_headers_pyfile_python_alt, usehttp=__use_http_lib__):
     httpfile = download_file_from_http_file(url, headers, usehttp)
     httpout = httpfile.read()
@@ -9247,19 +10069,15 @@ if(haveparamiko):
         else:
             sftp_port = urlparts.port
         if(urlparts.username is not None):
-            sftp_username = urlparts.username
+            sftp_username = unquote(urlparts.username)
         else:
             sftp_username = "anonymous"
         if(urlparts.password is not None):
-            sftp_password = urlparts.password
+            sftp_password = unquote(urlparts.password)
         elif(urlparts.password is None and urlparts.username == "anonymous"):
             sftp_password = "anonymous"
         else:
             sftp_password = ""
-        if(urlparts.scheme == "ftp"):
-            return download_file_from_ftp_file(url)
-        elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
-            return download_file_from_http_file(url)
         if(urlparts.scheme != "sftp" and urlparts.scheme != "scp"):
             return False
         ssh = paramiko.SSHClient()
@@ -9267,7 +10085,7 @@ if(haveparamiko):
         ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
         try:
             ssh.connect(urlparts.hostname, port=sftp_port,
-                        username=sftp_username, password=urlparts.password)
+                        username=sftp_username, password=sftp_password)
         except paramiko.ssh_exception.SSHException:
             return False
         except socket.gaierror:
@@ -9308,19 +10126,15 @@ if(haveparamiko):
         else:
             sftp_port = urlparts.port
         if(urlparts.username is not None):
-            sftp_username = urlparts.username
+            sftp_username = unquote(urlparts.username)
         else:
             sftp_username = "anonymous"
         if(urlparts.password is not None):
-            sftp_password = urlparts.password
+            sftp_password = unquote(urlparts.password)
         elif(urlparts.password is None and urlparts.username == "anonymous"):
             sftp_password = "anonymous"
         else:
             sftp_password = ""
-        if(urlparts.scheme == "ftp"):
-            return upload_file_to_ftp_file(sftpfile, url)
-        elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
-            return False
         if(urlparts.scheme != "sftp" and urlparts.scheme != "scp"):
             return False
         ssh = paramiko.SSHClient()
@@ -9369,19 +10183,15 @@ if(havepysftp):
         else:
             sftp_port = urlparts.port
         if(urlparts.username is not None):
-            sftp_username = urlparts.username
+            sftp_username = unquote(urlparts.username)
         else:
             sftp_username = "anonymous"
         if(urlparts.password is not None):
-            sftp_password = urlparts.password
+            sftp_password = unquote(urlparts.password)
         elif(urlparts.password is None and urlparts.username == "anonymous"):
             sftp_password = "anonymous"
         else:
             sftp_password = ""
-        if(urlparts.scheme == "ftp"):
-            return download_file_from_ftp_file(url)
-        elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
-            return download_file_from_http_file(url)
         if(urlparts.scheme != "sftp" and urlparts.scheme != "scp"):
             return False
         try:
@@ -9426,19 +10236,15 @@ if(havepysftp):
         else:
             sftp_port = urlparts.port
         if(urlparts.username is not None):
-            sftp_username = urlparts.username
+            sftp_username = unquote(urlparts.username)
         else:
             sftp_username = "anonymous"
         if(urlparts.password is not None):
-            sftp_password = urlparts.password
+            sftp_password = unquote(urlparts.password)
         elif(urlparts.password is None and urlparts.username == "anonymous"):
             sftp_password = "anonymous"
         else:
             sftp_password = ""
-        if(urlparts.scheme == "ftp"):
-            return upload_file_to_ftp_file(sftpfile, url)
-        elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
-            return False
         if(urlparts.scheme != "sftp" and urlparts.scheme != "scp"):
             return False
         try:
@@ -9484,6 +10290,13 @@ def download_file_from_internet_file(url, headers=geturls_headers_pyfile_python_
             return download_file_from_pysftp_file(url)
         else:
             return download_file_from_sftp_file(url)
+    elif(urlparts.scheme == "tcp" or urlparts.scheme == "udp"):
+        outfile = MkTempFile()
+        returnval = recv_via_url(outfile, url, recv_to_fileobj)
+        if(not returnval):
+            return False
+        outfile.seek(0, 0)
+        return outfile
     else:
         return False
     return False
@@ -9536,6 +10349,12 @@ def upload_file_to_internet_file(ifp, url):
             return upload_file_to_pysftp_file(ifp, url)
         else:
             return upload_file_to_sftp_file(ifp, url)
+    elif(urlparts.scheme == "tcp" or urlparts.scheme == "udp"):
+        ifp.seek(0, 0)
+        returnval = send_via_url(ifp, url, send_from_fileobj)
+        if(not returnval):
+            return False
+        return returnval
     else:
         return False
     return False
@@ -9574,3 +10393,598 @@ def upload_file_to_internet_compress_string(ifp, url, compression="auto", compre
         return False
     fp.seek(0, 0)
     return upload_file_to_internet_file(fp, outfile)
+
+
+# ---------- Core: send / recv ----------
+def send_from_fileobj(fileobj, host, port, proto="tcp", timeout=None,
+                      chunk_size=65536,
+                      use_ssl=False, ssl_verify=True, ssl_ca_file=None,
+                      ssl_certfile=None, ssl_keyfile=None, server_hostname=None,
+                      auth_user=None, auth_pass=None, auth_scope=u"",
+                      on_progress=None, rate_limit_bps=None, want_sha=True):
+    """
+    Send fileobj contents to (host, port) via TCP or UDP.
+
+    UDP behavior:
+      - Computes total length and sha256 when possible.
+      - Sends:  AF1 (if auth)  +  'LEN <n> [<sha>]\\n'  +  payload
+      - If length unknown: stream payload, then 'HASH <sha>\\n' (if enabled), then 'DONE\\n'.
+      - Uses small datagrams (<=1200B) to avoid fragmentation.
+    """
+    proto = (proto or "tcp").lower()
+    total = 0
+    port = int(port)
+    if proto not in ("tcp", "udp"):
+        raise ValueError("proto must be 'tcp' or 'udp'")
+
+    # ---------------- UDP ----------------
+    if proto == "udp":
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            if timeout is not None:
+                sock.settimeout(timeout)
+
+            # connect UDP for convenience
+            try:
+                sock.connect((host, port))
+                connected = True
+            except Exception:
+                connected = False
+
+            # length + optional sha
+            total_bytes, start_pos = _discover_len_and_reset(fileobj)
+
+            sha_hex = None
+            if want_sha and total_bytes is not None:
+                import hashlib
+                h = hashlib.sha256()
+                try:
+                    cur = fileobj.tell()
+                except Exception:
+                    cur = None
+                if start_pos is not None:
+                    try: fileobj.seek(start_pos, os.SEEK_SET)
+                    except Exception: pass
+                _HSZ = 1024 * 1024
+                while True:
+                    blk = fileobj.read(_HSZ)
+                    if not blk: break
+                    h.update(_to_bytes(blk))
+                sha_hex = h.hexdigest()
+                if start_pos is not None:
+                    try: fileobj.seek(start_pos, os.SEEK_SET)
+                    except Exception: pass
+                elif cur is not None:
+                    try: fileobj.seek(cur, os.SEEK_SET)
+                    except Exception: pass
+
+            # optional AF1 (also carries len/sha, but we'll still send LEN for robustness)
+            if auth_user is not None or auth_pass is not None:
+                try:
+                    blob = build_auth_blob_v1(
+                        auth_user or u"", auth_pass or u"",
+                        scope=auth_scope, length=total_bytes, sha_hex=(sha_hex if want_sha else None)
+                    )
+                except Exception:
+                    blob = _build_auth_blob_legacy(auth_user or b"", auth_pass or b"")
+                if connected:
+                    sock.send(blob)
+                    # You may ignore the ack in UDP; keep try/except minimal
+                    try:
+                        resp = sock.recv(16)
+                        if resp != _OK:
+                            raise RuntimeError("UDP auth failed")
+                    except Exception:
+                        pass
+                else:
+                    sock.sendto(blob, (host, port))
+                    try:
+                        resp, _ = sock.recvfrom(16)
+                        if resp != _OK:
+                            raise RuntimeError("UDP auth failed")
+                    except Exception:
+                        pass
+
+            # ALWAYS send LEN when length is known
+            if total_bytes is not None:
+                preface = b"LEN " + str(int(total_bytes)).encode("ascii")
+                if want_sha and sha_hex:
+                    preface += b" " + sha_hex.encode("ascii")
+                preface += b"\n"
+                if connected: sock.send(preface)
+                else: sock.sendto(preface, (host, port))
+
+            # payload stream
+            UDP_PAYLOAD_MAX = 1200
+            effective_chunk = min(int(chunk_size or 65536), UDP_PAYLOAD_MAX)
+
+            sent_so_far = 0
+            last_cb_ts = monotonic()
+            last_rate_ts = last_cb_ts
+            last_rate_bytes = 0
+
+            rolling_h = None
+            if want_sha and total_bytes is None:
+                try:
+                    import hashlib
+                    rolling_h = hashlib.sha256()
+                except Exception:
+                    rolling_h = None
+
+            while True:
+                chunk = fileobj.read(effective_chunk)
+                if not chunk:
+                    break
+                b = _to_bytes(chunk)
+                if rolling_h is not None:
+                    rolling_h.update(b)
+                n = (sock.send(b) if connected else sock.sendto(b, (host, port)))
+                total += n
+                sent_so_far += n
+
+                if rate_limit_bps:
+                    sleep_s, last_rate_ts, last_rate_bytes = _progress_tick(
+                        sent_so_far, total_bytes, last_rate_ts, last_rate_bytes, rate_limit_bps
+                    )
+                    if sleep_s > 0.0:
+                        time.sleep(min(sleep_s, 0.25))
+
+                if on_progress and (monotonic() - last_cb_ts) >= 0.1:
+                    try: on_progress(sent_so_far, total_bytes)
+                    except Exception: pass
+                    last_cb_ts = monotonic()
+
+            # unknown-length trailers
+            if total_bytes is None:
+                if rolling_h is not None:
+                    try:
+                        th = rolling_h.hexdigest().encode("ascii")
+                        (sock.send(b"HASH " + th + b"\n") if connected
+                         else sock.sendto(b"HASH " + th + b"\n", (host, port)))
+                    except Exception:
+                        pass
+                try:
+                    (sock.send(b"DONE\n") if connected else sock.sendto(b"DONE\n", (host, port)))
+                except Exception:
+                    pass
+
+        finally:
+            try: sock.close()
+            except Exception: pass
+        return total
+
+    # ---------------- TCP ----------------
+    sock = _connect_stream(host, port, timeout)
+    try:
+        if use_ssl:
+            if not _ssl_available():
+                raise RuntimeError("SSL requested but 'ssl' module unavailable.")
+            sock = _ssl_wrap_socket(sock, server_side=False,
+                                    server_hostname=(server_hostname or host),
+                                    verify=ssl_verify, ca_file=ssl_ca_file,
+                                    certfile=ssl_certfile, keyfile=ssl_keyfile)
+
+        total_bytes, start_pos = _discover_len_and_reset(fileobj)
+        sha_hex = None
+        if want_sha and total_bytes is not None:
+            try:
+                import hashlib
+                h = hashlib.sha256()
+                cur = fileobj.tell()
+                if start_pos is not None:
+                    fileobj.seek(start_pos, os.SEEK_SET)
+                _HSZ = 1024 * 1024
+                while True:
+                    blk = fileobj.read(_HSZ)
+                    if not blk: break
+                    h.update(_to_bytes(blk))
+                sha_hex = h.hexdigest()
+                fileobj.seek(cur, os.SEEK_SET)
+            except Exception:
+                sha_hex = None
+
+        if auth_user is not None or auth_pass is not None:
+            try:
+                blob = build_auth_blob_v1(
+                    auth_user or u"", auth_pass or u"",
+                    scope=auth_scope, length=total_bytes, sha_hex=(sha_hex if want_sha else None)
+                )
+            except Exception:
+                blob = _build_auth_blob_legacy(auth_user or b"", auth_pass or b"")
+            sock.sendall(blob)
+            try:
+                resp = sock.recv(16)
+                if resp != _OK:
+                    raise RuntimeError("TCP auth failed")
+            except Exception:
+                pass
+
+        sent_so_far = 0
+        last_cb_ts = monotonic()
+        last_rate_ts = last_cb_ts
+        last_rate_bytes = 0
+
+        use_sendfile = hasattr(sock, "sendfile") and hasattr(fileobj, "read")
+        if use_sendfile:
+            try:
+                sent = sock.sendfile(fileobj)
+                if isinstance(sent, int):
+                    total += sent
+                    sent_so_far += sent
+                    if on_progress:
+                        try: on_progress(sent_so_far, total_bytes)
+                        except Exception: pass
+                else:
+                    raise RuntimeError("sendfile returned unexpected type")
+            except Exception:
+                while True:
+                    chunk = fileobj.read(chunk_size)
+                    if not chunk: break
+                    view = memoryview(_to_bytes(chunk))
+                    while view:
+                        n = sock.send(view); total += n; sent_so_far += n; view = view[n:]
+                        if rate_limit_bps:
+                            sleep_s, last_rate_ts, last_rate_bytes = _progress_tick(
+                                sent_so_far, total_bytes, last_rate_ts, last_rate_bytes, rate_limit_bps
+                            )
+                            if sleep_s > 0.0:
+                                time.sleep(min(sleep_s, 0.25))
+                    if on_progress and (monotonic() - last_cb_ts) >= 0.1:
+                        try: on_progress(sent_so_far, total_bytes)
+                        except Exception: pass
+                        last_cb_ts = monotonic()
+        else:
+            while True:
+                chunk = fileobj.read(chunk_size)
+                if not chunk: break
+                view = memoryview(_to_bytes(chunk))
+                while view:
+                    n = sock.send(view); total += n; sent_so_far += n; view = view[n:]
+                    if rate_limit_bps:
+                        sleep_s, last_rate_ts, last_rate_bytes = _progress_tick(
+                            sent_so_far, total_bytes, last_rate_ts, last_rate_bytes, rate_limit_bps
+                        )
+                        if sleep_s > 0.0:
+                            time.sleep(min(sleep_s, 0.25))
+                if on_progress and (monotonic() - last_cb_ts) >= 0.1:
+                    try: on_progress(sent_so_far, total_bytes)
+                    except Exception: pass
+                    last_cb_ts = monotonic()
+    finally:
+        try: sock.shutdown(socket.SHUT_WR)
+        except Exception: pass
+        try: sock.close()
+        except Exception: pass
+    return total
+
+def recv_to_fileobj(fileobj, host="", port=0, proto="tcp", timeout=None,
+                    max_bytes=None, chunk_size=65536, backlog=1,
+                    use_ssl=False, ssl_verify=True, ssl_ca_file=None,
+                    ssl_certfile=None, ssl_keyfile=None,
+                    require_auth=False, expected_user=None, expected_pass=None,
+                    total_timeout=None, expect_scope=None,
+                    on_progress=None, rate_limit_bps=None):
+    """
+    Receive bytes into fileobj over TCP/UDP.
+
+    UDP specifics:
+      * Accepts 'LEN <n> [<sha>]\\n' and 'HASH <sha>\\n' control frames (unauth) or AF1 with len/sha.
+      * If length unknown, accepts final 'DONE\\n' to end cleanly.
+    """
+    proto = (proto or "tcp").lower()
+    port = int(port)
+    total = 0
+
+    start_ts = time.time()
+    def _time_left():
+        if total_timeout is None:
+            return None
+        left = total_timeout - (time.time() - start_ts)
+        return 0.0 if left <= 0 else left
+    def _set_effective_timeout(socklike, base_timeout):
+        left = _time_left()
+        if left == 0.0:
+            return False
+        eff = base_timeout
+        if left is not None:
+            eff = left if eff is None else min(eff, left)
+        if eff is not None:
+            try:
+                socklike.settimeout(eff)
+            except Exception:
+                pass
+        return True
+
+    if proto not in ("tcp", "udp"):
+        raise ValueError("proto must be 'tcp' or 'udp'")
+
+    # ---------------- UDP server ----------------
+    if proto == "udp":
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        authed_addr = None
+        expected_len = None
+        expected_sha = None
+
+        try:
+            sock.bind(("", port))
+            if timeout is None:
+                try: sock.settimeout(10.0)
+                except Exception: pass
+
+            recvd_so_far = 0
+            last_cb_ts = monotonic()
+            last_rate_ts = last_cb_ts
+            last_rate_bytes = 0
+
+            while True:
+                if _time_left() == 0.0:
+                    if expected_len is not None and total < expected_len:
+                        raise RuntimeError("UDP receive aborted by total_timeout before full payload received")
+                    break
+                if (max_bytes is not None) and (total >= max_bytes):
+                    break
+
+                if not _set_effective_timeout(sock, timeout):
+                    if expected_len is not None and total < expected_len:
+                        raise RuntimeError("UDP receive timed out before full payload received")
+                    if expected_len is None and total > 0:
+                        raise RuntimeError("UDP receive timed out with unknown length; partial data")
+                    if expected_len is None and total == 0:
+                        raise RuntimeError("UDP receive: no packets received before timeout (is the sender running?)")
+                    break
+
+                try:
+                    data, addr = sock.recvfrom(chunk_size)
+                except socket.timeout:
+                    if expected_len is not None and total < expected_len:
+                        raise RuntimeError("UDP receive idle-timeout before full payload received")
+                    if expected_len is None and total > 0:
+                        raise RuntimeError("UDP receive idle-timeout with unknown length; partial data")
+                    if expected_len is None and total == 0:
+                        raise RuntimeError("UDP receive: no packets received before timeout (is the sender running?)")
+                    break
+
+                if not data:
+                    continue
+
+                # (0) Control frames FIRST: LEN / HASH / DONE
+                if data.startswith(b"LEN ") and expected_len is None:
+                    try:
+                        parts = data.strip().split()
+                        n = int(parts[1])
+                        expected_len = (None if n < 0 else n)
+                        if len(parts) >= 3:
+                            expected_sha = parts[2].decode("ascii")
+                    except Exception:
+                        expected_len = None
+                        expected_sha = None
+                    continue
+
+                if data.startswith(b"HASH "):
+                    try:
+                        expected_sha = data.strip().split()[1].decode("ascii")
+                    except Exception:
+                        expected_sha = None
+                    continue
+
+                if data == b"DONE\n":
+                    break
+
+                # (1) Auth (AF1 preferred; legacy fallback)
+                if authed_addr is None and require_auth:
+                    ok = False
+                    v_ok, v_user, v_scope, _r, v_len, v_sha = verify_auth_blob_v1(
+                        data, expected_user=expected_user, secret=expected_pass,
+                        max_skew=600, expect_scope=expect_scope
+                    )
+                    if v_ok:
+                        ok = True
+                        if expected_len is None:
+                            expected_len = v_len
+                        if expected_sha is None:
+                            expected_sha = v_sha
+                    else:
+                        user, pw = _parse_auth_blob_legacy(data)
+                        ok = (user is not None and
+                              (expected_user is None or user == _to_bytes(expected_user)) and
+                              (expected_pass is None or pw == _to_bytes(expected_pass)))
+                    try:
+                        sock.sendto((_OK if ok else _NO), addr)
+                    except Exception:
+                        pass
+                    if ok:
+                        authed_addr = addr
+                    continue
+
+                if require_auth and addr != authed_addr:
+                    continue
+
+                # (2) Payload
+                fileobj.write(data)
+                try: fileobj.flush()
+                except Exception: pass
+                total += len(data)
+                recvd_so_far += len(data)
+
+                if rate_limit_bps:
+                    sleep_s, last_rate_ts, last_rate_bytes = _progress_tick(
+                        recvd_so_far, expected_len, last_rate_ts, last_rate_bytes, rate_limit_bps
+                    )
+                    if sleep_s > 0.0:
+                        time.sleep(min(sleep_s, 0.25))
+
+                if on_progress and (monotonic() - last_cb_ts) >= 0.1:
+                    try: on_progress(recvd_so_far, expected_len)
+                    except Exception: pass
+                    last_cb_ts = monotonic()
+
+                if expected_len is not None and total >= expected_len:
+                    break
+
+            # Post-conditions
+            if expected_len is not None and total != expected_len:
+                raise RuntimeError("UDP receive incomplete: got %d of %s bytes" % (total, expected_len))
+
+            if expected_sha:
+                import hashlib
+                try:
+                    cur = fileobj.tell(); fileobj.seek(0)
+                except Exception:
+                    cur = None
+                h = hashlib.sha256(); _HSZ = 1024 * 1024
+                while True:
+                    blk = fileobj.read(_HSZ)
+                    if not blk: break
+                    h.update(_to_bytes(blk))
+                got = h.hexdigest()
+                if cur is not None:
+                    try: fileobj.seek(cur)
+                    except Exception: pass
+                if got != expected_sha:
+                    raise RuntimeError("UDP checksum mismatch: got %s expected %s" % (got, expected_sha))
+
+        finally:
+            try: sock.close()
+            except Exception: pass
+        return total
+
+    # ---------------- TCP server ----------------
+    srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    try:
+        try: srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        except Exception: pass
+        srv.bind((host or "", port))
+        srv.listen(int(backlog) if backlog else 1)
+
+        if not _set_effective_timeout(srv, timeout):
+            return 0
+        try:
+            conn, _peer = srv.accept()
+        except socket.timeout:
+            return 0
+
+        if use_ssl:
+            if not _ssl_available():
+                try: conn.close()
+                except Exception: pass
+                raise RuntimeError("SSL requested but 'ssl' module unavailable.")
+            if not ssl_certfile:
+                try: conn.close()
+                except Exception: pass
+                raise ValueError("TLS server requires ssl_certfile (and usually ssl_keyfile).")
+            conn = _ssl_wrap_socket(conn, server_side=True, server_hostname=None,
+                                    verify=ssl_verify, ca_file=ssl_ca_file,
+                                    certfile=ssl_certfile, keyfile=ssl_keyfile)
+
+        recvd_so_far = 0
+        last_cb_ts = monotonic()
+        last_rate_ts = last_cb_ts
+        last_rate_bytes = 0
+
+        try:
+            if require_auth:
+                if not _set_effective_timeout(conn, timeout):
+                    return 0
+                try:
+                    preface = conn.recv(2048)
+                except socket.timeout:
+                    try: conn.sendall(_NO)
+                    except Exception: pass
+                    return 0
+
+                ok = False
+                v_ok, v_user, v_scope, _r, v_len, v_sha = verify_auth_blob_v1(
+                    preface or b"", expected_user=expected_user, secret=expected_pass,
+                    max_skew=600, expect_scope=expect_scope
+                )
+                if v_ok:
+                    ok = True
+                else:
+                    user, pw = _parse_auth_blob_legacy(preface or b"")
+                    ok = (user is not None and
+                          (expected_user is None or user == _to_bytes(expected_user)) and
+                          (expected_pass is None or pw == _to_bytes(expected_pass)))
+
+                try: conn.sendall(_OK if ok else _NO)
+                except Exception: pass
+                if not ok:
+                    return 0
+
+            while True:
+                if _time_left() == 0.0: break
+                if (max_bytes is not None) and (total >= max_bytes): break
+
+                if not _set_effective_timeout(conn, timeout):
+                    break
+                try:
+                    data = conn.recv(chunk_size)
+                except socket.timeout:
+                    break
+                if not data:
+                    break
+
+                fileobj.write(data)
+                try: fileobj.flush()
+                except Exception: pass
+                total += len(data)
+                recvd_so_far += len(data)
+
+                if rate_limit_bps:
+                    sleep_s, last_rate_ts, last_rate_bytes = _progress_tick(
+                        recvd_so_far, max_bytes, last_rate_ts, last_rate_bytes, rate_limit_bps
+                    )
+                    if sleep_s > 0.0:
+                        time.sleep(min(sleep_s, 0.25))
+
+                if on_progress and (monotonic() - last_cb_ts) >= 0.1:
+                    try: on_progress(recvd_so_far, max_bytes)
+                    except Exception: pass
+                    last_cb_ts = monotonic()
+        finally:
+            try: conn.shutdown(socket.SHUT_RD)
+            except Exception: pass
+            try: conn.close()
+            except Exception: pass
+    finally:
+        try: srv.close()
+        except Exception: pass
+
+    return total
+
+# ---------- URL drivers ----------
+def send_via_url(fileobj, url, send_from_fileobj_func=send_from_fileobj):
+    """
+    Use URL options to drive the sender. Returns bytes sent.
+    """
+    parts, o = _parse_net_url(url)
+    use_auth = (o["user"] is not None and o["pw"] is not None) or o["force_auth"]
+    return send_from_fileobj_func(
+        fileobj,
+        o["host"], o["port"], proto=o["proto"],
+        timeout=o["timeout"], chunk_size=o["chunk_size"],
+        use_ssl=o["use_ssl"], ssl_verify=o["ssl_verify"],
+        ssl_ca_file=o["ssl_ca_file"], ssl_certfile=o["ssl_certfile"], ssl_keyfile=o["ssl_keyfile"],
+        server_hostname=o["server_hostname"],
+        auth_user=(o["user"] if use_auth else None),
+        auth_pass=(o["pw"]   if use_auth else None),
+        auth_scope=o.get("path", u""),
+        want_sha=o["want_sha"],   # <— pass through
+    )
+
+def recv_via_url(fileobj, url, recv_to_fileobj_func=recv_to_fileobj):
+    """
+    Use URL options to drive the receiver. Returns bytes received.
+    """
+    parts, o = _parse_net_url(url)
+    require_auth = (o["user"] is not None and o["pw"] is not None) or o["force_auth"]
+    return recv_to_fileobj_func(
+        fileobj,
+        o["host"], o["port"], proto=o["proto"],
+        timeout=o["timeout"], total_timeout=o["total_timeout"],
+        chunk_size=o["chunk_size"],
+        use_ssl=o["use_ssl"], ssl_verify=o["ssl_verify"],
+        ssl_ca_file=o["ssl_ca_file"], ssl_certfile=o["ssl_certfile"], ssl_keyfile=o["ssl_keyfile"],
+        require_auth=require_auth,
+        expected_user=o["user"], expected_pass=o["pw"],
+        expect_scope=o.get("path", u""),
+    )