PyFoxFile 0.21.2__py3-none-any.whl → 0.22.2__py3-none-any.whl

pyfoxfile.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: pyfoxfile.py - Last Update: 8/24/2025 Ver. 0.21.2 RC 1 - Author: cooldude2k $
+    $FileInfo: pyfoxfile.py - Last Update: 8/29/2025 Ver. 0.22.2 RC 1 - Author: cooldude2k $
 '''
 
 from __future__ import absolute_import, division, print_function, unicode_literals, generators, with_statement, nested_scopes
@@ -32,10 +32,13 @@ import socket
 import hashlib
 import inspect
 import datetime
+import tempfile
 import logging
 import zipfile
 import binascii
 import platform
+from io import StringIO, BytesIO
+import posixpath as pp  # POSIX-safe joins/normpaths
 try:
     from backports import tempfile
 except ImportError:
@@ -43,10 +46,10 @@ except ImportError:
 # FTP Support
 ftpssl = True
 try:
-    from ftplib import FTP, FTP_TLS
+    from ftplib import FTP, FTP_TLS, all_errors
 except ImportError:
     ftpssl = False
-    from ftplib import FTP
+    from ftplib import FTP, all_errors
 
 try:
     import ujson as json
@@ -100,9 +103,13 @@ baseint = tuple(baseint)
 
 # URL Parsing
 try:
-    from urllib.parse import urlparse, urlunparse
+    # Python 3
+    from urllib.parse import urlparse, urlunparse, unquote
+    from urllib.request import url2pathname
 except ImportError:
+    # Python 2
     from urlparse import urlparse, urlunparse
+    from urllib import unquote, url2pathname
 
 # Windows-specific setup
 if os.name == "nt":
@@ -243,17 +250,6 @@ except ImportError:
     from urllib2 import Request, build_opener, HTTPBasicAuthHandler
     from urlparse import urlparse
 
-# StringIO and BytesIO
-try:
-    from io import StringIO, BytesIO
-except ImportError:
-    try:
-        from cStringIO import StringIO
-        from cStringIO import StringIO as BytesIO
-    except ImportError:
-        from StringIO import StringIO
-        from StringIO import StringIO as BytesIO
-
 def get_importing_script_path():
     # Inspect the stack and get the frame of the caller
     stack = inspect.stack()
@@ -275,22 +271,8 @@ def get_default_threads():
 
 
 __use_pysftp__ = False
-__use_alt_format__ = False
-__use_env_file__ = True
-__use_ini_file__ = True
-__use_ini_name__ = "foxfile.ini"
-if('PYARCHIVEFILE_CONFIG_FILE' in os.environ and os.path.exists(os.environ['PYARCHIVEFILE_CONFIG_FILE']) and __use_env_file__):
-    scriptconf = os.environ['PYARCHIVEFILE_CONFIG_FILE']
-else:
-    prescriptpath = get_importing_script_path()
-    if(prescriptpath is not None):
-        scriptconf = os.path.join(os.path.dirname(prescriptpath), __use_ini_name__)
-    else:
-        scriptconf = ""
-if os.path.exists(scriptconf):
-    __config_file__ = scriptconf
-else:
-    __config_file__ = os.path.join(os.path.dirname(os.path.realpath(__file__)), __use_ini_name__)
+__upload_proto_support__ = "^(ftp|ftps|sftp|scp)://"
+__download_proto_support__ = "^(http|https|ftp|ftps|sftp|scp)://"
 if(not havepysftp):
     __use_pysftp__ = False
 __use_http_lib__ = "httpx"
@@ -328,7 +310,25 @@ def is_only_nonprintable(var):
 __file_format_multi_dict__ = {}
 __file_format_default__ = "FoxFile"
 __include_defaults__ = True
+__use_inmemfile__ = False
 __program_name__ = "Py"+__file_format_default__
+__use_env_file__ = True
+__use_ini_file__ = True
+__use_ini_name__ = "foxfile.ini"
+__use_json_file__ = False
+__use_json_name__ = "foxfile.json"
+if('PYARCHIVEFILE_CONFIG_FILE' in os.environ and os.path.exists(os.environ['PYARCHIVEFILE_CONFIG_FILE']) and __use_env_file__):
+    scriptconf = os.environ['PYARCHIVEFILE_CONFIG_FILE']
+else:
+    prescriptpath = get_importing_script_path()
+    if(prescriptpath is not None):
+        scriptconf = os.path.join(os.path.dirname(prescriptpath), __use_ini_name__)
+    else:
+        scriptconf = ""
+if os.path.exists(scriptconf):
+    __config_file__ = scriptconf
+else:
+    __config_file__ = os.path.join(os.path.dirname(os.path.realpath(__file__)), __use_ini_name__)
 if __use_ini_file__ and os.path.exists(__config_file__):
     config = configparser.ConfigParser()
     config.read(__config_file__)
@@ -340,6 +340,7 @@ if __use_ini_file__ and os.path.exists(__config_file__):
     __file_format_default__ = decode_unicode_escape(config.get('config', 'default'))
     __program_name__ = decode_unicode_escape(config.get('config', 'proname'))
     __include_defaults__ = config.getboolean('config', 'includedef')
+    __use_inmemfile__ = config.getboolean('config', 'inmemfile')
     # Loop through all sections
     for section in config.sections():
         required_keys = [
@@ -389,12 +390,13 @@ __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/PyFoxFile"
-__version_info__ = (0, 21, 2, "RC 1", 1)
-__version_date_info__ = (2025, 9, 24, "RC 1", 1)
+__version_info__ = (0, 22, 2, "RC 1", 1)
+__version_info__ = (0, 22, 2, "RC 1", 1)
+__version_date_info__ = (2025, 9, 29, "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: c85d5aa829f172404f285788e6b35f73a35767c2 $"
+__revision_id__ = "$Id: fe60b5bb8a36aa1216d0e100c5dcfd68f8b3459f $"
 if(__version_info__[4] is not None):
     __version_date_plusrc__ = __version_date__ + \
         "-" + str(__version_date_info__[4])
@@ -584,6 +586,281 @@ def VerbosePrintOutReturn(dbgtxt, outtype="log", dbgenable=True, dgblevel=20):
     return dbgtxt
 
 
+# --- Helpers ---
+def _normalize_initial_data(data, isbytes, encoding):
+    """Return data in the correct type for write(): bytes (if isbytes) or text (if not)."""
+    if data is None:
+        return None
+
+    if isbytes:
+        # Want bytes
+        if isinstance(data, bytes):
+            return data
+        # Py2: str is already bytes, unicode needs encode
+        if sys.version_info[0] == 2:
+            try:
+                unicode  # noqa: F821
+            except NameError:
+                pass
+            else:
+                if isinstance(data, unicode):  # noqa: F821
+                    return data.encode(encoding)
+        # Py3 str -> encode
+        return str(data).encode(encoding)
+    else:
+        # Want text (unicode/str)
+        if sys.version_info[0] == 2:
+            try:
+                unicode  # noqa: F821
+                if isinstance(data, unicode):  # noqa: F821
+                    return data
+                # bytes/str -> decode
+                return data.decode(encoding) if isinstance(data, str) else unicode(data)  # noqa: F821
+            except NameError:
+                # Very defensive; shouldn't happen
+                return data
+        else:
+            # Py3: want str
+            if isinstance(data, bytes):
+                return data.decode(encoding)
+            return str(data)
+
+
+def _split_posix(path_text):
+    """Split POSIX paths regardless of OS; return list of components."""
+    # Normalize leading './'
+    if path_text.startswith(u'./'):
+        path_text = path_text[2:]
+    # Strip redundant slashes
+    path_text = re.sub(u'/+', u'/', path_text)
+    # Drop trailing '/' so 'dir/' -> ['dir']
+    if path_text.endswith(u'/'):
+        path_text = path_text[:-1]
+    return path_text.split(u'/') if path_text else []
+
+def _is_abs_like(s):
+    """Absolute targets (POSIX or Windows-drive style)."""
+    return s.startswith(u'/') or s.startswith(u'\\') or re.match(u'^[A-Za-z]:[/\\\\]', s)
+
+def _resolves_outside(base_rel, target_rel):
+    """
+    Given a base directory (relative, POSIX) and a target (relative),
+    return True if base/target resolves outside of base.
+    We anchor under '/' so normpath is root-anchored and portable.
+    """
+    base_clean = u'/'.join(_split_posix(base_rel))
+    target_clean = u'/'.join(_split_posix(target_rel))
+    base_abs = u'/' + base_clean if base_clean else u'/'
+    combined = pp.normpath(pp.join(base_abs, target_clean))
+    if combined == base_abs or combined.startswith(base_abs + u'/'):
+        return False
+    return True
+
+
+def DetectTarBombFoxFileArray(listarrayfiles,
+                                 top_file_ratio_threshold=0.6,
+                                 min_members_for_ratio=4,
+                                 symlink_policy="escape-only",  # 'escape-only' | 'deny' | 'single-folder-only'
+                                 to_text=to_text):
+    """
+    Detect 'tarbomb-like' archives from FoxFileToArray/TarFileToArray dicts.
+
+    Parameters:
+      listarrayfiles: dict with key 'ffilelist' -> list of entries (requires 'fname')
+      top_file_ratio_threshold: float, fraction of root files considered tarbomb
+      min_members_for_ratio: int, minimum members before ratio heuristic applies
+      symlink_policy:
+        - 'escape-only': only symlinks that escape parent/are absolute are unsafe
+        - 'deny': any symlink is unsafe
+        - 'single-folder-only': symlinks allowed only if archive has a single top-level folder
+      to_text: normalization function (your provided to_text)
+
+    Returns dict with:
+      - is_tarbomb, reasons, total_members, top_level_entries, top_level_files_count,
+        has_absolute_paths, has_parent_traversal,
+        symlink_escapes_root (bool), symlink_issues (list[{entry,target,reason}])
+    """
+    files = listarrayfiles or {}
+    members = files.get('ffilelist') or []
+
+    names = []
+    has_abs = False
+    has_parent = False
+
+    # Symlink tracking
+    has_any_symlink = False
+    symlink_issues = []
+    any_symlink_escape = False
+
+    for m in members:
+        m = m or {}
+        name = to_text(m.get('fname', u""))
+
+        if _is_abs_like(name):
+            has_abs = True
+
+        parts = _split_posix(name)
+        if u'..' in parts:
+            has_parent = True
+
+        if not parts:
+            continue
+
+        norm_name = u'/'.join(parts)
+        names.append(norm_name)
+
+        # ---- Symlink detection ----
+        ftype = m.get('ftype')
+        is_symlink = (ftype == 2) or (to_text(ftype).lower() == u'symlink' if ftype is not None else False)
+        if is_symlink:
+            has_any_symlink = True
+            target = to_text(m.get('flinkname', u""))
+            # Absolute symlink target is unsafe
+            if _is_abs_like(target):
+                any_symlink_escape = True
+                symlink_issues.append({'entry': norm_name, 'target': target, 'reason': 'absolute symlink target'})
+            else:
+                parent = u'/'.join(parts[:-1])  # may be ''
+                if _resolves_outside(parent, target):
+                    any_symlink_escape = True
+                    symlink_issues.append({'entry': norm_name, 'target': target, 'reason': 'symlink escapes parent directory'})
+
+    total = len(names)
+    reasons = []
+    if total == 0:
+        return {
+            "is_tarbomb": False,
+            "reasons": ["archive contains no members"],
+            "total_members": 0,
+            "top_level_entries": [],
+            "top_level_files_count": 0,
+            "has_absolute_paths": has_abs,
+            "has_parent_traversal": has_parent,
+            "symlink_escapes_root": any_symlink_escape,
+            "symlink_issues": symlink_issues,
+        }
+
+    # Layout counts
+    top_counts = {}
+    top_level_files_count = 0
+    for name in names:
+        parts = name.split(u'/')
+        first = parts[0]
+        top_counts[first] = top_counts.get(first, 0) + 1
+        if len(parts) == 1:  # directly at archive root
+            top_level_files_count += 1
+
+    top_keys = sorted(top_counts.keys())
+    is_tarbomb = False
+
+    # Path-based dangers
+    if has_abs:
+        is_tarbomb = True
+        reasons.append("contains absolute paths (dangerous)")
+    if has_parent:
+        is_tarbomb = True
+        reasons.append("contains parent-traversal ('..') entries (dangerous)")
+    if any_symlink_escape:
+        is_tarbomb = True
+        reasons.append("contains symlinks that escape their parent directory")
+
+    # Symlink policy enforcement
+    if symlink_policy == "deny" and has_any_symlink:
+        is_tarbomb = True
+        reasons.append("symlinks present and policy is 'deny'")
+    elif symlink_policy == "single-folder-only" and has_any_symlink and len(top_keys) != 1:
+        is_tarbomb = True
+        reasons.append("symlinks present but archive lacks a single top-level folder")
+
+    # Tarbomb layout heuristics
+    if len(top_keys) == 1:
+        reasons.append("single top-level entry '{0}'".format(top_keys[0]))
+    else:
+        ratio = float(top_level_files_count) / float(total)
+        if total >= min_members_for_ratio and ratio > float(top_file_ratio_threshold):
+            is_tarbomb = True
+            reasons.append("high fraction of members ({0:.0%}) at archive root".format(ratio))
+        else:
+            max_bucket = max(top_counts.values()) if top_counts else 0
+            if max_bucket < total * 0.9:
+                is_tarbomb = True
+                reasons.append("multiple top-level entries with no dominant folder: {0}".format(
+                    u", ".join(top_keys[:10])))
+            else:
+                reasons.append("multiple top-level entries but one dominates")
+
+    return {
+        "is_tarbomb": bool(is_tarbomb),
+        "reasons": reasons,
+        "total_members": total,
+        "top_level_entries": top_keys,
+        "top_level_files_count": top_level_files_count,
+        "has_absolute_paths": has_abs,
+        "has_parent_traversal": has_parent,
+        "symlink_escapes_root": any_symlink_escape,
+        "symlink_issues": symlink_issues,
+    }
+
+
+def MkTempFile(data=None, inmem=__use_inmemfile__, isbytes=True, prefix=__project__,
+               delete=True, encoding="utf-8"):
+    """
+    Return a file-like handle.
+      - If inmem=True: returns StringIO (text) or BytesIO (bytes).
+      - If inmem=False: returns a NamedTemporaryFile opened in text or binary mode.
+    Args:
+      data:     optional initial content; if provided, it's written and the handle is seek(0)
+      inmem:    bool — return in-memory handle if True
+      isbytes:  bool — choose bytes (True) or text (False)
+      prefix:   str  — tempfile prefix
+      delete:   bool — whether the tempfile is deleted on close (NamedTemporaryFile)
+      encoding: str  — used for text mode (and for conversions when needed)
+    """
+    init = _normalize_initial_data(data, isbytes, encoding)
+
+    if inmem:
+        buf = BytesIO() if isbytes else StringIO()
+        if init is not None:
+            buf.write(init)
+            buf.seek(0)
+        return buf
+
+    mode = "wb+" if isbytes else "w+"
+    kwargs = {"prefix": prefix or "", "delete": delete, "mode": mode}
+
+    # Only Python 3's text-mode files accept encoding/newline explicitly
+    if not isbytes and sys.version_info[0] >= 3:
+        kwargs["encoding"] = encoding
+        kwargs["newline"] = ""
+
+    f = tempfile.NamedTemporaryFile(**kwargs)
+
+    if init is not None:
+        f.write(init)
+        f.seek(0)
+    return f
+
+
+def MkTempFileSmart(data=None, isbytes=True, prefix=__project__, max_mem=1024*1024, encoding="utf-8"):
+    """
+    Spooled temp file: starts in memory and spills to disk past max_mem.
+    Behaves like BytesIO/StringIO for small data, with the same preload+seek(0) behavior.
+    """
+    mode = "wb+" if isbytes else "w+"
+    kwargs = {"mode": mode, "max_size": max_mem, "prefix": prefix or ""}
+    if not isbytes and sys.version_info[0] >= 3:
+        kwargs["encoding"] = encoding
+        kwargs["newline"] = ""
+
+    f = tempfile.SpooledTemporaryFile(**kwargs)
+
+    init = _normalize_initial_data(data, isbytes, encoding)
+    if init is not None:
+        f.write(init)
+        f.seek(0)
+    return f
+
+
 def RemoveWindowsPath(dpath):
     """
     Normalize a path by converting backslashes to forward slashes
@@ -591,6 +868,13 @@ def RemoveWindowsPath(dpath):
     """
     if not dpath:
         return ""
+    if re.match("^file://", dpath, re.IGNORECASE):
+        # Normalize to file:/// if it's a local path (no host)
+        if dpath.lower().startswith("file://") and not dpath.lower().startswith("file:///"):
+            # insert the extra slash
+            dpath = "file:///" + dpath[7:]
+        dparsed = urlparse(dpath)
+        dpath = url2pathname(dparsed.path)
     # Accept bytes and decode safely
     if isinstance(dpath, (bytes, bytearray)):
         dpath = dpath.decode("utf-8", "ignore")
@@ -606,6 +890,13 @@ def NormalizeRelativePath(inpath):
     """
     Ensures the path is relative unless it is absolute. Prepares consistent relative paths.
     """
+    if re.match("^file://", inpath, re.IGNORECASE):
+        # Normalize to file:/// if it's a local path (no host)
+        if inpath.lower().startswith("file://") and not inpath.lower().startswith("file:///"):
+            # insert the extra slash
+            inpath = "file:///" + inpath[7:]
+        dparsed = urlparse(inpath)
+        inpath = url2pathname(dparsed.path)
     inpath = RemoveWindowsPath(inpath)
     if os.path.isabs(inpath):
         outpath = inpath
@@ -662,6 +953,13 @@ def ListDir(dirpath, followlink=False, duplicates=False, include_regex=None, exc
     include_pattern = re.compile(include_regex) if include_regex else None
     exclude_pattern = re.compile(exclude_regex) if exclude_regex else None
     for mydirfile in dirpath:
+        if re.match("^file://", mydirfile, re.IGNORECASE):
+            # Normalize to file:/// if it's a local path (no host)
+            if mydirfile.lower().startswith("file://") and not mydirfile.lower().startswith("file:///"):
+                # insert the extra slash
+                mydirfile = "file:///" + mydirfile[7:]
+            dparsed = urlparse(mydirfile)
+            mydirfile = url2pathname(dparsed.path)
         if not os.path.exists(mydirfile):
             return False
         mydirfile = NormalizeRelativePath(mydirfile)
@@ -732,6 +1030,13 @@ def ListDirAdvanced(dirpath, followlink=False, duplicates=False, include_regex=N
     include_pattern = re.compile(include_regex) if include_regex else None
     exclude_pattern = re.compile(exclude_regex) if exclude_regex else None
     for mydirfile in dirpath:
+        if re.match("^file://", mydirfile, re.IGNORECASE):
+            # Normalize to file:/// if it's a local path (no host)
+            if mydirfile.lower().startswith("file://") and not mydirfile.lower().startswith("file:///"):
+                # insert the extra slash
+                mydirfile = "file:///" + mydirfile[7:]
+            dparsed = urlparse(mydirfile)
+            mydirfile = url2pathname(dparsed.path)
         if not os.path.exists(mydirfile):
             return False
         mydirfile = NormalizeRelativePath(mydirfile)
@@ -1920,7 +2225,7 @@ def ReadFileHeaderDataBySize(fp, delimiter=__file_format_dict__['format_delimite
     headersize = int(preheaderdata[0], 16)
     if(headersize <= 0):
         return []
-    subfp = BytesIO()
+    subfp = MkTempFile()
     subfp.write(fp.read(headersize))
     fp.seek(len(delimiter), 1)
     subfp.seek(0, 0)
@@ -1941,7 +2246,7 @@ def ReadFileHeaderDataWoSize(fp, delimiter=__file_format_dict__['format_delimite
     if(headersize <= 0 or headernumfields <= 0):
         return []
     headerdata = ReadTillNullByteByNum(fp, delimiter, headernumfields)
-    #headerdata = ReadFileHeaderData(fp, headernumfields, delimiter);
+    #headerdata = ReadFileHeaderData(fp, headernumfields, delimiter)
     HeaderOut = preheaderdata + headerdata
     return HeaderOut
 
@@ -2004,7 +2309,7 @@ def ReadFileHeaderDataWithContent(fp, listonly=False, uncompress=True, skipcheck
         return False
     fhend = fp.tell() - 1
     fcontentstart = fp.tell()
-    fcontents = BytesIO()
+    fcontents = MkTempFile()
     if(fsize > 0 and not listonly):
         if(fcompression == "none" or fcompression == "" or fcompression == "auto"):
             fcontents.write(fp.read(fsize))
@@ -2031,7 +2336,7 @@ def ReadFileHeaderDataWithContent(fp, listonly=False, uncompress=True, skipcheck
         if(uncompress):
             cfcontents = UncompressFileAlt(fcontents, formatspecs)
             cfcontents.seek(0, 0)
-            fcontents = BytesIO()
+            fcontents = MkTempFile()
             shutil.copyfileobj(cfcontents, fcontents)
             cfcontents.close()
             fcontents.seek(0, 0)
@@ -2145,7 +2450,7 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
             fjsoncontent = {}
     elif(fjsontype=="list"):
         fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
-        flisttmp = BytesIO()
+        flisttmp = MkTempFile()
         flisttmp.write(fprejsoncontent.encode())
         flisttmp.seek(0)
         fjsoncontent = ReadFileHeaderData(flisttmp, fjsonlen, delimiter)
@@ -2181,7 +2486,7 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
         return False
     fhend = fp.tell() - 1
     fcontentstart = fp.tell()
-    fcontents = BytesIO()
+    fcontents = MkTempFile()
     pyhascontents = False
     if(fsize > 0 and not listonly):
         if(fcompression == "none" or fcompression == "" or fcompression == "auto"):
@@ -2212,7 +2517,7 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
             cfcontents = UncompressFileAlt(
                 fcontents, formatspecs)
             cfcontents.seek(0, 0)
-            fcontents = BytesIO()
+            fcontents = MkTempFile()
             shutil.copyfileobj(cfcontents, fcontents)
             cfcontents.close()
             fcontents.seek(0, 0)
@@ -2331,7 +2636,7 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
             fjsoncontent = {}
     elif(fjsontype=="list"):
         fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
-        flisttmp = BytesIO()
+        flisttmp = MkTempFile()
         flisttmp.write(fprejsoncontent.encode())
         flisttmp.seek(0)
         fjsoncontent = ReadFileHeaderData(flisttmp, fjsonlen, delimiter)
@@ -2366,7 +2671,7 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
         return False
     fhend = fp.tell() - 1
     fcontentstart = fp.tell()
-    fcontents = BytesIO()
+    fcontents = MkTempFile()
     pyhascontents = False
     if(fsize > 0 and not listonly):
         if(fcompression == "none" or fcompression == "" or fcompression == "auto"):
@@ -2396,7 +2701,7 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
             cfcontents = UncompressFileAlt(
                 fcontents, formatspecs)
             cfcontents.seek(0, 0)
-            fcontents = BytesIO()
+            fcontents = MkTempFile()
             shutil.copyfileobj(cfcontents, fcontents)
             cfcontents.close()
             fcontents.seek(0, 0)
@@ -2428,22 +2733,20 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
     return outlist
 
 
-def ReadFileDataWithContent(fp, listonly=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__):
+def ReadFileDataWithContent(fp, filestart=0, listonly=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__):
     if(not hasattr(fp, "read")):
         return False
     delimiter = formatspecs['format_delimiter']
-    curloc = fp.tell()
+    curloc = filestart
     try:
-        fp.seek(0, 2);
+        fp.seek(0, 2)
     except OSError:
-        SeekToEndOfFile(fp);
+        SeekToEndOfFile(fp)
     except ValueError:
-        SeekToEndOfFile(fp);
-    CatSize = fp.tell();
-    CatSizeEnd = CatSize;
+        SeekToEndOfFile(fp)
+    CatSize = fp.tell()
+    CatSizeEnd = CatSize
     fp.seek(curloc, 0)
-    if(curloc > 0):
-        fp.seek(0, 0)
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelszie = len(formatspecs['format_delimiter'])
@@ -2458,8 +2761,6 @@ def ReadFileDataWithContent(fp, listonly=False, uncompress=True, skipchecksum=Fa
     else:
         inheader = ReadFileHeaderDataWoSize(
             fp, formatspecs['format_delimiter'])
-    if(curloc > 0):
-        fp.seek(curloc, 0)
     fprechecksumtype = inheader[-2]
     fprechecksum = inheader[-1]
     headercheck = ValidateHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, fprechecksum, formatspecs)
@@ -2483,22 +2784,20 @@ def ReadFileDataWithContent(fp, listonly=False, uncompress=True, skipchecksum=Fa
     return flist
 
 
-def ReadFileDataWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False):
+def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False):
     if(not hasattr(fp, "read")):
         return False
     delimiter = formatspecs['format_delimiter']
-    curloc = fp.tell()
+    curloc = filestart
     try:
-        fp.seek(0, 2);
+        fp.seek(0, 2)
     except OSError:
-        SeekToEndOfFile(fp);
+        SeekToEndOfFile(fp)
     except ValueError:
-        SeekToEndOfFile(fp);
-    CatSize = fp.tell();
-    CatSizeEnd = CatSize;
+        SeekToEndOfFile(fp)
+    CatSize = fp.tell()
+    CatSizeEnd = CatSize
     fp.seek(curloc, 0)
-    if(curloc > 0):
-        fp.seek(0, 0)
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelszie = len(formatspecs['format_delimiter'])
@@ -2530,8 +2829,6 @@ def ReadFileDataWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, c
                 fextrafieldslist = json.loads(fextrafieldslist[0])
             except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                 pass
-    if(curloc > 0):
-        fp.seek(curloc, 0)
     formversion = re.findall("([\\d]+)", formstring)
     fheadsize = int(inheader[0], 16)
     fnumfields = int(inheader[1], 16)
@@ -2596,7 +2893,7 @@ def ReadFileDataWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, c
                 invalid_archive = True
             prefhend = fp.tell() - 1
             prefcontentstart = fp.tell()
-            prefcontents = BytesIO()
+            prefcontents = MkTempFile()
             pyhascontents = False
             if(prefsize > 0):
                 prefcontents.write(fp.read(prefsize))
@@ -2643,22 +2940,20 @@ def ReadFileDataWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, c
     return outlist
 
 
-def ReadFileDataWithContentToList(fp, seekstart=0, seekend=0, listonly=False, contentasfile=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False):
+def ReadFileDataWithContentToList(fp, filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False):
     if(not hasattr(fp, "read")):
         return False
     delimiter = formatspecs['format_delimiter']
-    curloc = fp.tell()
+    curloc = filestart
     try:
-        fp.seek(0, 2);
+        fp.seek(0, 2)
     except OSError:
-        SeekToEndOfFile(fp);
+        SeekToEndOfFile(fp)
     except ValueError:
-        SeekToEndOfFile(fp);
-    CatSize = fp.tell();
-    CatSizeEnd = CatSize;
+        SeekToEndOfFile(fp)
+    CatSize = fp.tell()
+    CatSizeEnd = CatSize
     fp.seek(curloc, 0)
-    if(curloc > 0):
-        fp.seek(0, 0)
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelszie = len(formatspecs['format_delimiter'])
@@ -2690,8 +2985,6 @@ def ReadFileDataWithContentToList(fp, seekstart=0, seekend=0, listonly=False, co
                 fextrafieldslist = json.loads(fextrafieldslist[0])
             except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                 pass
-    if(curloc > 0):
-        fp.seek(curloc, 0)
     formversion = re.findall("([\\d]+)", formstring)
     fheadsize = int(inheader[0], 16)
     fnumfields = int(inheader[1], 16)
@@ -2809,25 +3102,25 @@ def ReadFileDataWithContentToList(fp, seekstart=0, seekend=0, listonly=False, co
     return outlist
 
 
-def ReadInFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+def ReadInFileWithContentToArray(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]
     elif(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype not in formatspecs):
         fmttype = "auto"
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         fp = infile
-        fp.seek(0, 0)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         else:
-            fp.seek(0, 0)
-            checkcompressfile = CheckCompressionSubType(fp, formatspecs, False)
+            fp.seek(filestart, 0)
+            checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, False)
             if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
                 formatspecs = formatspecs[checkcompressfile]
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, True)
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
             return TarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
@@ -2862,58 +3155,58 @@ def ReadInFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0,
                 compresscheck = "zlib"
             else:
                 return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     elif(infile == "-"):
-        fp = BytesIO()
+        fp = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, fp)
         else:
             shutil.copyfileobj(sys.stdin, fp)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        fp.seek(0, 0)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        fp.seek(filestart, 0)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         else:
-            fp.seek(0, 0)
-            checkcompressfile = CheckCompressionSubType(fp, formatspecs, False)
+            fp.seek(filestart, 0)
+            checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, False)
             if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
                 formatspecs = formatspecs[checkcompressfile]
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
-        fp = BytesIO()
+        fp = MkTempFile()
         fp.write(infile)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        fp.seek(0, 0)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        fp.seek(filestart, 0)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         else:
-            fp.seek(0, 0)
-            checkcompressfile = CheckCompressionSubType(fp, formatspecs, False)
+            fp.seek(filestart, 0)
+            checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, False)
             if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
                 formatspecs = formatspecs[checkcompressfile]
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
         if(not fp):
             return False
-        fp.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
+        fp.seek(filestart, 0)
+    elif(re.findall(__download_proto_support__, infile)):
         fp = download_file_from_internet_file(infile)
-        fp.seek(0, 0)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         else:
-            fp.seek(0, 0)
-            checkcompressfile = CheckCompressionSubType(fp, formatspecs, False)
+            fp.seek(filestart, 0)
+            checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, False)
             if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
                 formatspecs = formatspecs[checkcompressfile]
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
         if(not compresscheck):
             fextname = os.path.splitext(infile)[1]
             if(fextname == ".gz"):
@@ -2934,14 +3227,14 @@ def ReadInFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0,
                 compresscheck = "zlib"
             else:
                 return False
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     else:
         infile = RemoveWindowsPath(infile)
-        checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+        checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
@@ -2956,7 +3249,7 @@ def ReadInFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0,
             return False
         elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
             return False
-        compresscheck = CheckCompressionType(infile, formatspecs, True)
+        compresscheck = CheckCompressionType(infile, formatspecs, filestart, True)
         if(not compresscheck):
             fextname = os.path.splitext(infile)[1]
             if(fextname == ".gz"):
@@ -2979,43 +3272,43 @@ def ReadInFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0,
                 return False
         if(not compresscheck):
             return False
-        fp = UncompressFile(infile, formatspecs, "rb")
-    return ReadFileDataWithContentToArray(fp, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+        fp = UncompressFile(infile, formatspecs, "rb", filestart)
+    return ReadFileDataWithContentToArray(fp, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
 
 
-def ReadInMultipleFileWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+def ReadInMultipleFileWithContentToArray(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] = ReadInFileWithContentToArray(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+        outretval[curfname] = ReadInFileWithContentToArray(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
     return outretval
 
-def ReadInMultipleFilesWithContentToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
-    return ReadInMultipleFileWithContentToArray(infile, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+def ReadInMultipleFilesWithContentToArray(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 ReadInMultipleFileWithContentToArray(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
 
 
-def ReadInFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+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]
     elif(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype not in formatspecs):
         fmttype = "auto"
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         fp = infile
-        fp.seek(0, 0)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         else:
-            fp.seek(0, 0)
-            checkcompressfile = CheckCompressionSubType(fp, formatspecs, False)
+            fp.seek(filestart, 0)
+            checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, False)
             if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
                 formatspecs = formatspecs[checkcompressfile]
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, True)
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
             return TarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, True)
         elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
@@ -3050,58 +3343,58 @@ def ReadInFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0,
                 compresscheck = "zlib"
             else:
                 return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     elif(infile == "-"):
-        fp = BytesIO()
+        fp = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, fp)
         else:
             shutil.copyfileobj(sys.stdin, fp)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        fp.seek(0, 0)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        fp.seek(filestart, 0)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         else:
-            fp.seek(0, 0)
-            checkcompressfile = CheckCompressionSubType(fp, formatspecs, False)
+            fp.seek(filestart, 0)
+            checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, False)
             if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
                 formatspecs = formatspecs[checkcompressfile]
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
-        fp = BytesIO()
+        fp = MkTempFile()
         fp.write(infile)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        fp.seek(0, 0)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        fp.seek(filestart, 0)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         else:
-            fp.seek(0, 0)
-            checkcompressfile = CheckCompressionSubType(fp, formatspecs, False)
+            fp.seek(filestart, 0)
+            checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, False)
             if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
                 formatspecs = formatspecs[checkcompressfile]
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
         if(not fp):
             return False
-        fp.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
+        fp.seek(filestart, 0)
+    elif(re.findall(__download_proto_support__, infile)):
         fp = download_file_from_internet_file(infile)
-        fp.seek(0, 0)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         else:
-            fp.seek(0, 0)
-            checkcompressfile = CheckCompressionSubType(fp, formatspecs, False)
+            fp.seek(filestart, 0)
+            checkcompressfile = CheckCompressionSubType(fp, formatspecs, filestart, False)
             if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
                 formatspecs = formatspecs[checkcompressfile]
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
         if(not compresscheck):
             fextname = os.path.splitext(infile)[1]
             if(fextname == ".gz"):
@@ -3122,14 +3415,14 @@ def ReadInFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0,
                 compresscheck = "zlib"
             else:
                 return False
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     else:
         infile = RemoveWindowsPath(infile)
-        checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+        checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
@@ -3144,7 +3437,7 @@ def ReadInFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0,
             return False
         elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
             return False
-        compresscheck = CheckCompressionType(infile, formatspecs, True)
+        compresscheck = CheckCompressionType(infile, formatspecs, filestart, True)
         if(not compresscheck):
             fextname = os.path.splitext(infile)[1]
             if(fextname == ".gz"):
@@ -3167,22 +3460,22 @@ def ReadInFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0,
                 return False
         if(not compresscheck):
             return False
-        fp = UncompressFile(infile, formatspecs, "rb")
-    return ReadFileDataWithContentToList(fp, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+        fp = UncompressFile(infile, formatspecs, "rb", filestart)
+    return ReadFileDataWithContentToList(fp, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
 
 
-def ReadInMultipleFileWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+def ReadInMultipleFileWithContentToList(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:
-        curretfile[curfname] = ReadInFileWithContentToList(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+        curretfile[curfname] = ReadInFileWithContentToList(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
     return outretval
 
-def ReadInMultipleFilesWithContentToList(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
-    return ReadInMultipleFileWithContentToList(infile, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+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):
+    return ReadInMultipleFileWithContentToList(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
 
 
 def AppendNullByte(indata, delimiter=__file_format_dict__['format_delimiter']):
@@ -3277,7 +3570,7 @@ def MakeEmptyFilePointer(fp, fmttype=__file_format_default__, checksumtype="crc3
     return fp
 
 
-def MakeEmptyArchiveFilePointer(fp, fmttype=__file_format_default__, checksumtype="crc32", formatspecs=__file_format_multi_dict__):
+def MakeEmptyFoxFilePointer(fp, fmttype=__file_format_default__, checksumtype="crc32", formatspecs=__file_format_multi_dict__):
     return MakeEmptyFilePointer(fp, fmttype, checksumtype, formatspecs)
 
 
@@ -3308,11 +3601,11 @@ def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile
                 pass
     if(outfile == "-" or outfile is None):
         verbose = False
-        fp = BytesIO()
+        fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
-    elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-        fp = BytesIO()
+    elif(re.findall(__upload_proto_support__, outfile)):
+        fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
         fextname = os.path.splitext(outfile)[1]
@@ -3347,7 +3640,7 @@ def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile
         outvar = fp.read()
         fp.close()
         return outvar
-    elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif(re.findall(__upload_proto_support__, outfile)):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
@@ -3360,7 +3653,7 @@ def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile
         return True
 
 
-def MakeEmptyArchiveFile(outfile, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype="crc32", formatspecs=__file_format_dict__, returnfp=False):
+def MakeEmptyFoxFile(outfile, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype="crc32", formatspecs=__file_format_dict__, returnfp=False):
     return MakeEmptyFile(outfile, "auto", compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, formatspecs, returnfp)
 
 
@@ -3644,16 +3937,16 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
             fwinattributes = format(int(0), 'x').lower()
         fcompression = ""
         fcsize = format(int(0), 'x').lower()
-        fcontents = BytesIO()
+        fcontents = MkTempFile()
         chunk_size = 1024
         fcencoding = "UTF-8"
         curcompression = "none"
         if not followlink and ftype in data_types:
             with open(fname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
-                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
-                fcencoding = GetFileEncoding(fcontents, False)
+                fcencoding = GetFileEncoding(fcontents, 0, False)
                 if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
@@ -3663,7 +3956,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                         ilmin = 0
                         ilcsize = []
                         while(ilmin < ilsize):
-                            cfcontents = BytesIO()
+                            cfcontents = MkTempFile()
                             fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             fcontents.seek(0, 0)
@@ -3680,7 +3973,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
                     fcontents.seek(0, 0)
-                    cfcontents = BytesIO()
+                    cfcontents = MkTempFile()
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
@@ -3698,9 +3991,9 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
             flstatinfo = os.stat(flinkname)
             with open(flinkname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
-                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
-                fcencoding = GetFileEncoding(fcontents, False)
+                fcencoding = GetFileEncoding(fcontents, 0, False)
                 if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
@@ -3710,7 +4003,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                         ilmin = 0
                         ilcsize = []
                         while(ilmin < ilsize):
-                            cfcontents = BytesIO()
+                            cfcontents = MkTempFile()
                             fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             fcontents.seek(0, 0)
@@ -3727,7 +4020,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], ext
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
                     fcontents.seek(0, 0)
-                    cfcontents = BytesIO()
+                    cfcontents = MkTempFile()
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
@@ -3810,7 +4103,7 @@ def AppendListsWithContent(inlist, fp, dirlistfromtxt=False, filevalues=[], extr
         fheaderchecksumtype = curfname[26]
         fcontentchecksumtype = curfname[27]
         fcontents = curfname[28]
-        fencoding = GetFileEncoding(fcontents, False)
+        fencoding = GetFileEncoding(fcontents, 0, False)
         tmpoutlist = [ftype, fencoding, fcencoding, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression, fcsize,
                       fuid, funame, fgid, fgname, fid, finode, flinkcount, fdev, fdev_minor, fdev_major, fseeknextfile]
         fcontents.seek(0, 0)
@@ -3857,11 +4150,11 @@ def AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt=False, fmtt
                 pass
     if(outfile == "-" or outfile is None):
         verbose = False
-        fp = BytesIO()
+        fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
-    elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-        fp = BytesIO()
+    elif(re.findall(__upload_proto_support__, outfile)):
+        fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
         fextname = os.path.splitext(outfile)[1]
@@ -3897,7 +4190,7 @@ def AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt=False, fmtt
         outvar = fp.read()
         fp.close()
         return outvar
-    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall(__upload_proto_support__, outfile)):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
@@ -3937,11 +4230,11 @@ def AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt=False, fmtty
                 pass
     if(outfile == "-" or outfile is None):
         verbose = False
-        fp = BytesIO()
+        fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
-    elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-        fp = BytesIO()
+    elif(re.findall(__upload_proto_support__, outfile)):
+        fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
         fextname = os.path.splitext(outfile)[1]
@@ -3977,7 +4270,7 @@ def AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt=False, fmtty
         outvar = fp.read()
         fp.close()
         return outvar
-    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall(__upload_proto_support__, outfile)):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
@@ -4058,10 +4351,11 @@ def GzipCompressData(data, compresslevel=9):
         compressed_data = gzip.compress(data, compresslevel=compresslevel)
     except AttributeError:
         # Fallback to older method for Python 2.x and older 3.x versions
-        out = BytesIO()
+        out = MkTempFile()
         with gzip.GzipFile(fileobj=out, mode="wb", compresslevel=compresslevel) as f:
             f.write(data)
-        compressed_data = out.getvalue()
+        out.seek(0, 0)
+        compressed_data = out.read()
     return compressed_data
 
 
@@ -4071,7 +4365,7 @@ def GzipDecompressData(compressed_data):
         decompressed_data = gzip.decompress(compressed_data)
     except AttributeError:
         # Fallback to older method for Python 2.x and older 3.x versions
-        inp = BytesIO(compressed_data)
+        inp = MkTempFile(compressed_data)
         with gzip.GzipFile(fileobj=inp, mode="rb") as f:
             decompressed_data = f.read()
     return decompressed_data
@@ -4159,7 +4453,7 @@ def IsSingleDict(variable):
     return True
 
 
-def GetFileEncoding(infile, closefp=True):
+def GetFileEncoding(infile, filestart=0, closefp=True):
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         fp = infile
     else:
@@ -4168,19 +4462,19 @@ def GetFileEncoding(infile, closefp=True):
         except FileNotFoundError:
             return False
     file_encoding = "UTF-8"
-    fp.seek(0, 0)
+    fp.seek(filestart, 0)
     prefp = fp.read(2)
     if(prefp == binascii.unhexlify("fffe")):
         file_encoding = "UTF-16LE"
     elif(prefp == binascii.unhexlify("feff")):
         file_encoding = "UTF-16BE"
-    fp.seek(0, 0)
+    fp.seek(filestart, 0)
     prefp = fp.read(3)
     if(prefp == binascii.unhexlify("efbbbf")):
         file_encoding = "UTF-8"
     elif(prefp == binascii.unhexlify("0efeff")):
         file_encoding = "SCSU"
-    fp.seek(0, 0)
+    fp.seek(filestart, 0)
     prefp = fp.read(4)
     if(prefp == binascii.unhexlify("fffe0000")):
         file_encoding = "UTF-32LE"
@@ -4196,21 +4490,21 @@ def GetFileEncoding(infile, closefp=True):
         file_encoding = "UTF-7"
     elif(prefp == binascii.unhexlify("2b2f762f")):
         file_encoding = "UTF-7"
-    fp.seek(0, 0)
+    fp.seek(filestart, 0)
     if(closefp):
         fp.close()
     return file_encoding
 
 
-def GetFileEncodingFromString(instring, closefp=True):
+def GetFileEncodingFromString(instring, filestart=0, closefp=True):
     try:
-        instringsfile = BytesIO(instring)
+        instringsfile = MkTempFile(instring)
     except TypeError:
-        instringsfile = BytesIO(instring.encode("UTF-8"))
-    return GetFileEncoding(instringsfile, closefp)
+        instringsfile = MkTempFile(instring.encode("UTF-8"))
+    return GetFileEncoding(instringsfile, filestart, closefp)
 
 
-def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, closefp=True):
+def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, filestart=0, closefp=True):
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         fp = infile
     else:
@@ -4219,7 +4513,8 @@ def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, closefp
         except FileNotFoundError:
             return False
     filetype = False
-    fp.seek(0, 0)
+    curloc = filestart
+    fp.seek(filestart, 0)
     prefp = fp.read(2)
     if(prefp == binascii.unhexlify("1f8b")):
         filetype = "gzip"
@@ -4235,13 +4530,13 @@ def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, closefp
         filetype = "zlib"
     elif(prefp == binascii.unhexlify("1f9d")):
         filetype = "zcompress"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(3)
     if(prefp == binascii.unhexlify("425a68")):
         filetype = "bzip2"
     elif(prefp == binascii.unhexlify("5d0000")):
         filetype = "lzma"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(4)
     if(prefp == binascii.unhexlify("28b52ffd")):
         filetype = "zstd"
@@ -4253,29 +4548,29 @@ def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, closefp
         filetype = "zipfile"
     elif(prefp == binascii.unhexlify("504b0708")):
         filetype = "zipfile"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(5)
     if(prefp == binascii.unhexlify("7573746172")):
         filetype = "tarfile"
     if(prefp == binascii.unhexlify("7573746172")):
         filetype = "tarfile"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(6)
     if(prefp == binascii.unhexlify("fd377a585a00")):
         filetype = "xz"
     elif(prefp == binascii.unhexlify("377abcaf271c")):
         filetype = "7zipfile"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(7)
     if(prefp == binascii.unhexlify("526172211a0700")):
         filetype = "rarfile"
     elif(prefp == binascii.unhexlify("2a2a4143452a2a")):
         filetype = "ace"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(7)
     if(prefp == binascii.unhexlify("894c5a4f0d0a1a")):
         filetype = "lzo"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(8)
     if(prefp == binascii.unhexlify("7573746172003030")):
         filetype = "tarfile"
@@ -4283,7 +4578,7 @@ def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, closefp
         filetype = "tarfile"
     if(prefp == binascii.unhexlify("526172211a070100")):
         filetype = "rarfile"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     if(IsNestedDict(formatspecs)):
         for key, value in formatspecs.items():
             prefp = fp.read(formatspecs[key]['format_len'])
@@ -4299,7 +4594,7 @@ def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, closefp
                 if(formstring == inheaderver and formdel == formatspecs[key]['format_delimiter']):
                     filetype = formatspecs[key]['format_magic']
                     continue
-            fp.seek(0, 0)
+            fp.seek(curloc, 0)
     elif(IsSingleDict(formatspecs)):
         prefp = fp.read(formatspecs['format_len'])
         if(prefp == binascii.unhexlify(formatspecs['format_hex'])):
@@ -4314,15 +4609,15 @@ def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, closefp
             filetype = formatspecs['format_magic']
     else:
         pass
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(9)
     if(prefp == binascii.unhexlify("894c5a4f000d0a1a0a")):
         filetype = "lzo"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(10)
     if(prefp == binascii.unhexlify("7061785f676c6f62616c")):
         filetype = "tarfile"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     if(filetype == "gzip" or filetype == "bzip2" or filetype == "lzma" or filetype == "zstd" or filetype == "lz4" or filetype == "zlib"):
         if(TarFileCheck(fp)):
             filetype = "tarfile"
@@ -4337,14 +4632,15 @@ def CheckCompressionType(infile, formatspecs=__file_format_multi_dict__, closefp
             return "7zipfile"
         else:
             filetype = False
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     if(closefp):
         fp.close()
     return filetype
 
 
-def CheckCompressionSubType(infile, formatspecs=__file_format_multi_dict__, closefp=True):
-    compresscheck = CheckCompressionType(infile, formatspecs, False)
+def CheckCompressionSubType(infile, formatspecs=__file_format_multi_dict__, filestart=0, closefp=True):
+    compresscheck = CheckCompressionType(infile, formatspecs, filestart, False)
+    curloc = filestart
     if(not compresscheck):
         fextname = os.path.splitext(infile)[1]
         if(fextname == ".gz"):
@@ -4393,7 +4689,7 @@ def CheckCompressionSubType(infile, formatspecs=__file_format_multi_dict__, clos
     elif(py7zr_support and compresscheck == "7zipfile" and py7zr.is_7zfile(infile)):
         return "7zipfile"
     if(hasattr(infile, "read") or hasattr(infile, "write")):
-        fp = UncompressFileAlt(infile, formatspecs)
+        fp = UncompressFileAlt(infile, formatspecs, filestart)
     else:
         try:
             if(compresscheck == "gzip" and compresscheck in compressionsupport):
@@ -4423,10 +4719,11 @@ def CheckCompressionSubType(infile, formatspecs=__file_format_multi_dict__, clos
         except FileNotFoundError:
             return False
     filetype = False
+    fp.seek(filestart, 0)
     prefp = fp.read(5)
     if(prefp == binascii.unhexlify("7573746172")):
         filetype = "tarfile"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     if(IsNestedDict(formatspecs)):
         for key, value in formatspecs.items():
             prefp = fp.read(formatspecs[key]['format_len'])
@@ -4442,7 +4739,7 @@ def CheckCompressionSubType(infile, formatspecs=__file_format_multi_dict__, clos
                 if(formstring == inheaderver and formdel == formatspecs[key]['format_delimiter']):
                     filetype = formatspecs[key]['format_magic']
                     continue
-            fp.seek(0, 0)
+            fp.seek(curloc, 0)
     elif(IsSingleDict(formatspecs)):
         prefp = fp.read(formatspecs['format_len'])
         if(prefp == binascii.unhexlify(formatspecs['format_hex'])):
@@ -4457,36 +4754,36 @@ def CheckCompressionSubType(infile, formatspecs=__file_format_multi_dict__, clos
             filetype = formatspecs['format_magic']
     else:
         pass
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     prefp = fp.read(10)
     if(prefp == binascii.unhexlify("7061785f676c6f62616c")):
         filetype = "tarfile"
-    fp.seek(0, 0)
+    fp.seek(curloc, 0)
     if(closefp):
         fp.close()
     return filetype
 
 
-def CheckCompressionTypeFromString(instring, formatspecs=__file_format_multi_dict__, closefp=True):
+def CheckCompressionTypeFromString(instring, formatspecs=__file_format_multi_dict__, filestart=0, closefp=True):
     try:
-        instringsfile = BytesIO(instring)
+        instringsfile = MkTempFile(instring)
     except TypeError:
-        instringsfile = BytesIO(instring.encode("UTF-8"))
-    return CheckCompressionType(instringsfile, formatspecs, closefp)
+        instringsfile = MkTempFile(instring.encode("UTF-8"))
+    return CheckCompressionType(instringsfile, formatspecs, filestart, closefp)
 
 
-def CheckCompressionTypeFromBytes(instring, formatspecs=__file_format_multi_dict__, closefp=True):
+def CheckCompressionTypeFromBytes(instring, formatspecs=__file_format_multi_dict__, filestart=0, closefp=True):
     try:
-        instringsfile = BytesIO(instring)
+        instringsfile = MkTempFile(instring)
     except TypeError:
-        instringsfile = BytesIO(instring.decode("UTF-8"))
-    return CheckCompressionType(instringsfile, formatspecs, closefp)
+        instringsfile = MkTempFile(instring.decode("UTF-8"))
+    return CheckCompressionType(instringsfile, formatspecs, filestart, closefp)
 
 
-def UncompressFileAlt(fp, formatspecs=__file_format_multi_dict__):
+def UncompressFileAlt(fp, formatspecs=__file_format_multi_dict__, filestart=0):
     if(not hasattr(fp, "read")):
         return False
-    compresscheck = CheckCompressionType(fp, formatspecs, False)
+    compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
     if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
         formatspecs = formatspecs[compresscheck]
     if(compresscheck == "gzip" and compresscheck in compressionsupport):
@@ -4520,8 +4817,8 @@ def UncompressFileAlt(fp, formatspecs=__file_format_multi_dict__):
     return fp
 
 
-def UncompressFile(infile, formatspecs=__file_format_multi_dict__, mode="rb"):
-    compresscheck = CheckCompressionType(infile, formatspecs, False)
+def UncompressFile(infile, formatspecs=__file_format_multi_dict__, mode="rb", filestart=0):
+    compresscheck = CheckCompressionType(infile, formatspecs, filestart, False)
     if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
         formatspecs = formatspecs[compresscheck]
     if(sys.version_info[0] == 2 and compresscheck):
@@ -4567,8 +4864,8 @@ def UncompressFile(infile, formatspecs=__file_format_multi_dict__, mode="rb"):
     return filefp
 
 
-def UncompressString(infile, formatspecs=__file_format_multi_dict__):
-    compresscheck = CheckCompressionTypeFromString(infile, formatspecs, False)
+def UncompressString(infile, formatspecs=__file_format_multi_dict__, filestart=0):
+    compresscheck = CheckCompressionTypeFromString(infile, formatspecs, filestart, False)
     if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
         formatspecs = formatspecs[compresscheck]
     if(compresscheck == "gzip" and compresscheck in compressionsupport):
@@ -4595,32 +4892,32 @@ def UncompressString(infile, formatspecs=__file_format_multi_dict__):
     return fileuz
 
 
-def UncompressStringAlt(instring, formatspecs=__file_format_multi_dict__):
+def UncompressStringAlt(instring, formatspecs=__file_format_multi_dict__, filestart=0):
     filefp = StringIO()
-    outstring = UncompressString(instring, formatspecs)
+    outstring = UncompressString(instring, formatspecs, filestart)
     filefp.write(outstring)
     filefp.seek(0, 0)
     return filefp
 
-def UncompressStringAltFP(fp, formatspecs=__file_format_multi_dict__):
+def UncompressStringAltFP(fp, formatspecs=__file_format_multi_dict__, filestart=0):
     if(not hasattr(fp, "read")):
         return False
-    prechck = CheckCompressionType(fp, formatspecs, False)
+    prechck = CheckCompressionType(fp, formatspecs, filestart, False)
     if(IsNestedDict(formatspecs) and prechck in formatspecs):
         formatspecs = formatspecs[prechck]
-    fp.seek(0, 0)
+    fp.seek(filestart, 0)
     if(prechck!="zstd"):
-        return UncompressFileAlt(fp, formatspecs)
+        return UncompressFileAlt(fp, formatspecs, filestart)
     filefp = StringIO()
-    fp.seek(0, 0)
-    outstring = UncompressString(fp.read(), formatspecs)
+    fp.seek(filestart, 0)
+    outstring = UncompressString(fp.read(), formatspecs, 0)
     filefp.write(outstring)
     filefp.seek(0, 0)
     return filefp
 
 
-def UncompressBytes(infile, formatspecs=__file_format_multi_dict__):
-    compresscheck = CheckCompressionTypeFromBytes(infile, formatspecs, False)
+def UncompressBytes(infile, formatspecs=__file_format_multi_dict__, filestart=0):
+    compresscheck = CheckCompressionTypeFromBytes(infile, formatspecs, filestart, False)
     if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
         formatspecs = formatspecs[compresscheck]
     if(compresscheck == "gzip" and compresscheck in compressionsupport):
@@ -4645,26 +4942,26 @@ def UncompressBytes(infile, formatspecs=__file_format_multi_dict__):
     return fileuz
 
 
-def UncompressBytesAlt(inbytes, formatspecs=__file_format_multi_dict__):
-    filefp = BytesIO()
-    outstring = UncompressBytes(inbytes, formatspecs)
+def UncompressBytesAlt(inbytes, formatspecs=__file_format_multi_dict__, filestart=0):
+    filefp = MkTempFile()
+    outstring = UncompressBytes(inbytes, formatspecs, filestart)
     filefp.write(outstring)
     filefp.seek(0, 0)
     return filefp
 
 
-def UncompressBytesAltFP(fp, formatspecs=__file_format_multi_dict__):
+def UncompressBytesAltFP(fp, formatspecs=__file_format_multi_dict__, filestart=0):
     if(not hasattr(fp, "read")):
         return False
-    prechck = CheckCompressionType(fp, formatspecs, False)
+    prechck = CheckCompressionType(fp, formatspecs, filestart, False)
     if(IsNestedDict(formatspecs) and prechck in formatspecs):
         formatspecs = formatspecs[prechck]
-    fp.seek(0, 0)
+    fp.seek(filestart, 0)
     if(prechck!="zstd"):
-        return UncompressFileAlt(fp, formatspecs)
-    filefp = BytesIO()
-    fp.seek(0, 0)
-    outstring = UncompressBytes(fp.read(), formatspecs)
+        return UncompressFileAlt(fp, formatspecs, filestart)
+    filefp = MkTempFile()
+    fp.seek(filestart, 0)
+    outstring = UncompressBytes(fp.read(), formatspecs, 0)
     filefp.write(outstring)
     filefp.seek(0, 0)
     return filefp
@@ -4679,7 +4976,7 @@ def CompressOpenFileAlt(fp, compression="auto", compressionlevel=None, compressi
     if(compression not in compressionuselist and compression is None):
         compression = "auto"
     if(compression == "gzip" and compression in compressionsupport):
-        bytesfp = BytesIO()
+        bytesfp = MkTempFile()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
@@ -4687,7 +4984,7 @@ def CompressOpenFileAlt(fp, compression="auto", compressionlevel=None, compressi
         bytesfp.write(GzipCompressData(
             fp.read(), compresslevel=compressionlevel))
     elif(compression == "bzip2" and compression in compressionsupport):
-        bytesfp = BytesIO()
+        bytesfp = MkTempFile()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
@@ -4695,7 +4992,7 @@ def CompressOpenFileAlt(fp, compression="auto", compressionlevel=None, compressi
         bytesfp.write(BzipCompressData(
             fp.read(), compresslevel=compressionlevel))
     elif(compression == "lz4" and compression in compressionsupport):
-        bytesfp = BytesIO()
+        bytesfp = MkTempFile()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
@@ -4703,14 +5000,14 @@ def CompressOpenFileAlt(fp, compression="auto", compressionlevel=None, compressi
         bytesfp.write(lz4.frame.compress(
             fp.read(), compression_level=compressionlevel))
     elif((compression == "lzo" or compression == "lzop") and compression in compressionsupport):
-        bytesfp = BytesIO()
+        bytesfp = MkTempFile()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
             compressionlevel = int(compressionlevel)
         bytesfp.write(lzo.compress(fp.read(), compressionlevel))
     elif(compression == "zstd" and compression in compressionsupport):
-        bytesfp = BytesIO()
+        bytesfp = MkTempFile()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
@@ -4718,7 +5015,7 @@ def CompressOpenFileAlt(fp, compression="auto", compressionlevel=None, compressi
         compressor = zstandard.ZstdCompressor(compressionlevel, threads=get_default_threads())
         bytesfp.write(compressor.compress(fp.read()))
     elif(compression == "lzma" and compression in compressionsupport):
-        bytesfp = BytesIO()
+        bytesfp = MkTempFile()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
@@ -4728,7 +5025,7 @@ def CompressOpenFileAlt(fp, compression="auto", compressionlevel=None, compressi
         except (NotImplementedError, lzma.LZMAError):
             bytesfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_ALONE))
     elif(compression == "xz" and compression in compressionsupport):
-        bytesfp = BytesIO()
+        bytesfp = MkTempFile()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
@@ -4738,7 +5035,7 @@ def CompressOpenFileAlt(fp, compression="auto", compressionlevel=None, compressi
         except (NotImplementedError, lzma.LZMAError):
             bytesfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_XZ))
     elif(compression == "zlib" and compression in compressionsupport):
-        bytesfp = BytesIO()
+        bytesfp = MkTempFile()
         if(compressionlevel is None):
             compressionlevel = 9
         else:
@@ -4908,11 +5205,11 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                 pass
     if(outfile == "-" or outfile is None):
         verbose = False
-        fp = BytesIO()
+        fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
-    elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-        fp = BytesIO()
+    elif(re.findall(__upload_proto_support__, outfile)):
+        fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
         fextname = os.path.splitext(outfile)[1]
@@ -5107,15 +5404,15 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
             fwinattributes = format(int(0), 'x').lower()
         fcompression = ""
         fcsize = format(int(0), 'x').lower()
-        fcontents = BytesIO()
+        fcontents = MkTempFile()
         fcencoding = "UTF-8"
         curcompression = "none"
         if not followlink and ftype in data_types:
             with open(fname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
-                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
-                fcencoding = GetFileEncoding(fcontents, False)
+                fcencoding = GetFileEncoding(fcontents, 0, False)
                 if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
@@ -5125,7 +5422,7 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                         ilmin = 0
                         ilcsize = []
                         while(ilmin < ilsize):
-                            cfcontents = BytesIO()
+                            cfcontents = MkTempFile()
                             fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             fcontents.seek(0, 0)
@@ -5142,7 +5439,7 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
                     fcontents.seek(0, 0)
-                    cfcontents = BytesIO()
+                    cfcontents = MkTempFile()
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
@@ -5160,9 +5457,9 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
             flstatinfo = os.stat(flinkname)
             with open(flinkname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents)
-                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
-                fcencoding = GetFileEncoding(fcontents, False)
+                fcencoding = GetFileEncoding(fcontents, 0, False)
                 if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
@@ -5172,7 +5469,7 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                         ilmin = 0
                         ilcsize = []
                         while(ilmin < ilsize):
-                            cfcontents = BytesIO()
+                            cfcontents = MkTempFile()
                             fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             fcontents.seek(0, 0)
@@ -5189,7 +5486,7 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
                     fcontents.seek(0, 0)
-                    cfcontents = BytesIO()
+                    cfcontents = MkTempFile()
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
@@ -5240,7 +5537,7 @@ def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compress
         outvar = fp.read()
         fp.close()
         return outvar
-    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall(__upload_proto_support__, outfile)):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
@@ -5292,11 +5589,11 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
                 pass
     if(outfile == "-" or outfile is None):
         verbose = False
-        fp = BytesIO()
+        fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
-    elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-        fp = BytesIO()
+    elif(re.findall(__upload_proto_support__, outfile)):
+        fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
         fextname = os.path.splitext(outfile)[1]
@@ -5315,7 +5612,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
     filetoinode = {}
     inodetoforminode = {}
     if(infile == "-"):
-        infile = BytesIO()
+        infile = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, infile)
         else:
@@ -5324,7 +5621,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
         if(not infile):
             return False
         infile.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
+    elif(re.findall(__download_proto_support__, infile)):
         infile = download_file_from_internet_file(infile)
         infile.seek(0, 0)
         if(not infile):
@@ -5348,7 +5645,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
                 return False
     try:
         if(hasattr(infile, "read") or hasattr(infile, "write")):
-            compresscheck = CheckCompressionType(infile, formatspecs, False)
+            compresscheck = CheckCompressionType(infile, formatspecs, 0, False)
             if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
                 formatspecs = formatspecs[compresscheck]
             if(compresscheck=="zstd"):
@@ -5360,7 +5657,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
             else:
                 tarfp = tarfile.open(fileobj=infile, mode="r")
         else:
-            compresscheck = CheckCompressionType(infile, formatspecs, True)
+            compresscheck = CheckCompressionType(infile, formatspecs, 0, True)
             if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
                 formatspecs = formatspecs[compresscheck]
             if(compresscheck=="zstd"):
@@ -5454,16 +5751,16 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
         fwinattributes = format(int(0), 'x').lower()
         fcompression = ""
         fcsize = format(int(0), 'x').lower()
-        fcontents = BytesIO()
+        fcontents = MkTempFile()
         fcencoding = "UTF-8"
         curcompression = "none"
         if ftype in data_types:
             fpc = tarfp.extractfile(member)
-            fpc.close()
             shutil.copyfileobj(fpc, fcontents)
-            typechecktest = CheckCompressionType(fcontents, closefp=False)
+            fpc.close()
+            typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
             fcontents.seek(0, 0)
-            fcencoding = GetFileEncoding(fcontents, False)
+            fcencoding = GetFileEncoding(fcontents, 0, False)
             if(typechecktest is False and not compresswholefile):
                 fcontents.seek(0, 2)
                 ucfsize = fcontents.tell()
@@ -5473,7 +5770,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
                     ilmin = 0
                     ilcsize = []
                     while(ilmin < ilsize):
-                        cfcontents = BytesIO()
+                        cfcontents = MkTempFile()
                         fcontents.seek(0, 0)
                         shutil.copyfileobj(fcontents, cfcontents)
                         fcontents.seek(0, 0)
@@ -5490,7 +5787,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
                     ilcmin = ilcsize.index(min(ilcsize))
                     curcompression = compressionuselist[ilcmin]
                 fcontents.seek(0, 0)
-                cfcontents = BytesIO()
+                cfcontents = MkTempFile()
                 shutil.copyfileobj(fcontents, cfcontents)
                 cfcontents.seek(0, 0)
                 cfcontents = CompressOpenFileAlt(
@@ -5541,7 +5838,7 @@ def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto",
         outvar = fp.read()
         fp.close()
         return outvar
-    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall(__upload_proto_support__, outfile)):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
@@ -5589,11 +5886,11 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
                 pass
     if(outfile == "-" or outfile is None):
         verbose = False
-        fp = BytesIO()
+        fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
-    elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-        fp = BytesIO()
+    elif(re.findall(__upload_proto_support__, outfile)):
+        fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
         fextname = os.path.splitext(outfile)[1]
@@ -5612,7 +5909,7 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
     filetoinode = {}
     inodetoforminode = {}
     if(infile == "-"):
-        infile = BytesIO()
+        infile = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, infile)
         else:
@@ -5621,7 +5918,7 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
         if(not infile):
             return False
         infile.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
+    elif(re.findall(__download_proto_support__, infile)):
         infile = download_file_from_internet_file(infile)
         infile.seek(0, 0)
         if(not infile):
@@ -5753,14 +6050,14 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
                 fgname = ""
         except ImportError:
             fgname = ""
-        fcontents = BytesIO()
+        fcontents = MkTempFile()
         fcencoding = "UTF-8"
         curcompression = "none"
         if ftype == 0:
             fcontents.write(zipfp.read(member.filename))
-            typechecktest = CheckCompressionType(fcontents, closefp=False)
+            typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
             fcontents.seek(0, 0)
-            fcencoding = GetFileEncoding(fcontents, False)
+            fcencoding = GetFileEncoding(fcontents, 0, False)
             if(typechecktest is False and not compresswholefile):
                 fcontents.seek(0, 2)
                 ucfsize = fcontents.tell()
@@ -5770,7 +6067,7 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
                     ilmin = 0
                     ilcsize = []
                     while(ilmin < ilsize):
-                        cfcontents = BytesIO()
+                        cfcontents = MkTempFile()
                         fcontents.seek(0, 0)
                         shutil.copyfileobj(fcontents, cfcontents)
                         fcontents.seek(0, 0)
@@ -5784,7 +6081,7 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
                     ilcmin = ilcsize.index(min(ilcsize))
                     curcompression = compressionuselist[ilcmin]
                 fcontents.seek(0, 0)
-                cfcontents = BytesIO()
+                cfcontents = MkTempFile()
                 shutil.copyfileobj(fcontents, cfcontents)
                 cfcontents.seek(0, 0)
                 cfcontents = CompressOpenFileAlt(
@@ -5835,7 +6132,7 @@ def PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto",
         outvar = fp.read()
         fp.close()
         return outvar
-    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall(__upload_proto_support__, outfile)):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
@@ -5888,11 +6185,11 @@ if(rarfile_support):
                     pass
         if(outfile == "-" or outfile is None):
             verbose = False
-            fp = BytesIO()
+            fp = MkTempFile()
         elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
             fp = outfile
-        elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-            fp = BytesIO()
+        elif(re.findall(__upload_proto_support__, outfile)):
+            fp = MkTempFile()
         else:
             fbasename = os.path.splitext(outfile)[0]
             fextname = os.path.splitext(outfile)[1]
@@ -6070,14 +6367,14 @@ if(rarfile_support):
                     fgname = ""
             except ImportError:
                 fgname = ""
-            fcontents = BytesIO()
+            fcontents = MkTempFile()
             fcencoding = "UTF-8"
             curcompression = "none"
             if ftype == 0:
                 fcontents.write(rarfp.read(member.filename))
-                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
-                fcencoding = GetFileEncoding(fcontents, False)
+                fcencoding = GetFileEncoding(fcontents, 0, False)
                 if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
@@ -6087,7 +6384,7 @@ if(rarfile_support):
                         ilmin = 0
                         ilcsize = []
                         while(ilmin < ilsize):
-                            cfcontents = BytesIO()
+                            cfcontents = MkTempFile()
                             fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             fcontents.seek(0, 0)
@@ -6104,7 +6401,7 @@ if(rarfile_support):
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
                     fcontents.seek(0, 0)
-                    cfcontents = BytesIO()
+                    cfcontents = MkTempFile()
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
@@ -6155,7 +6452,7 @@ if(rarfile_support):
             outvar = fp.read()
             fp.close()
             return outvar
-        elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+        elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall(__upload_proto_support__, outfile)):
             fp = CompressOpenFileAlt(
                 fp, compression, compressionlevel, compressionuselist, formatspecs)
             fp.seek(0, 0)
@@ -6208,11 +6505,11 @@ if(py7zr_support):
                     pass
         if(outfile == "-" or outfile is None):
             verbose = False
-            fp = BytesIO()
+            fp = MkTempFile()
         elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
             fp = outfile
-        elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-            fp = BytesIO()
+        elif(re.findall(__upload_proto_support__, outfile)):
+            fp = MkTempFile()
         else:
             fbasename = os.path.splitext(outfile)[0]
             fextname = os.path.splitext(outfile)[1]
@@ -6234,7 +6531,7 @@ if(py7zr_support):
             return False
         szpfp = py7zr.SevenZipFile(infile, mode="r")
         file_content = szpfp.readall()
-        #sztest = szpfp.testzip();
+        #sztest = szpfp.testzip()
         sztestalt = szpfp.test()
         if(sztestalt):
             VerbosePrintOut("Bad file found!")
@@ -6321,16 +6618,16 @@ if(py7zr_support):
                     fgname = ""
             except ImportError:
                 fgname = ""
-            fcontents = BytesIO()
+            fcontents = MkTempFile()
             fcencoding = "UTF-8"
             curcompression = "none"
             if ftype == 0:
                 fcontents.write(file_content[member.filename].read())
                 fsize = format(fcontents.tell(), 'x').lower()
                 fcontents.seek(0, 0)
-                typechecktest = CheckCompressionType(fcontents, closefp=False)
+                typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
-                fcencoding = GetFileEncoding(fcontents, False)
+                fcencoding = GetFileEncoding(fcontents, 0, False)
                 file_content[member.filename].close()
                 if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
@@ -6341,7 +6638,7 @@ if(py7zr_support):
                         ilmin = 0
                         ilcsize = []
                         while(ilmin < ilsize):
-                            cfcontents = BytesIO()
+                            cfcontents = MkTempFile()
                             fcontents.seek(0, 0)
                             shutil.copyfileobj(fcontents, cfcontents)
                             fcontents.seek(0, 0)
@@ -6358,7 +6655,7 @@ if(py7zr_support):
                         ilcmin = ilcsize.index(min(ilcsize))
                         curcompression = compressionuselist[ilcmin]
                     fcontents.seek(0, 0)
-                    cfcontents = BytesIO()
+                    cfcontents = MkTempFile()
                     shutil.copyfileobj(fcontents, cfcontents)
                     cfcontents.seek(0, 0)
                     cfcontents = CompressOpenFileAlt(
@@ -6409,7 +6706,7 @@ if(py7zr_support):
             outvar = fp.read()
             fp.close()
             return outvar
-        elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+        elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall(__upload_proto_support__, outfile)):
             fp = CompressOpenFileAlt(
                 fp, compression, compressionlevel, compressionuselist, formatspecs)
             fp.seek(0, 0)
@@ -6423,7 +6720,7 @@ if(py7zr_support):
 
 
 def PackFoxFileFromInFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["crc32", "crc32", "crc32"], extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
-    checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+    checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
     if(verbose):
@@ -6443,18 +6740,20 @@ def PackFoxFileFromInFile(infile, outfile, fmttype="auto", compression="auto", c
     return False
 
 
-def FoxFileSeekToFileNum(infile, fmttype="auto", seekto=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+def FoxFileValidate(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
+    if(verbose):
+        logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
     if(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype in formatspecs):
         formatspecs = formatspecs[fmttype]
     elif(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype not in formatspecs):
         fmttype = "auto"
-    curloc = 0
+    curloc = filestart
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         curloc = infile.tell()
         fp = infile
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
+        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)):
@@ -6471,45 +6770,45 @@ def FoxFileSeekToFileNum(infile, fmttype="auto", seekto=0, listonly=False, conte
             return False
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     elif(infile == "-"):
-        fp = BytesIO()
+        fp = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, fp)
         else:
             shutil.copyfileobj(sys.stdin, fp)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
+        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(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
-        fp = BytesIO()
+        fp = MkTempFile()
         fp.write(infile)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        compresscheck = CheckCompressionType(fp, formatspecs, 0, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         if(not fp):
             return False
-        fp.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
+        fp.seek(filestart, 0)
+    elif(re.findall(__download_proto_support__, infile)):
         fp = download_file_from_internet_file(infile)
-        fp = UncompressFileAlt(fp, formatspecs)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        compresscheck = CheckCompressionType(fp, formatspecs, 0, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     else:
         infile = RemoveWindowsPath(infile)
-        checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+        checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
@@ -6524,7 +6823,7 @@ def FoxFileSeekToFileNum(infile, fmttype="auto", seekto=0, listonly=False, conte
             return False
         elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
             return False
-        compresscheck = CheckCompressionType(infile, formatspecs, True)
+        compresscheck = CheckCompressionType(infile, formatspecs, filestart, True)
         if(not compresscheck):
             fextname = os.path.splitext(infile)[1]
             if(fextname == ".gz"):
@@ -6547,26 +6846,23 @@ def FoxFileSeekToFileNum(infile, fmttype="auto", seekto=0, listonly=False, conte
                 return False
         if(not compresscheck):
             return False
-        fp = UncompressFile(infile, formatspecs, "rb")
+        fp = UncompressFile(infile, formatspecs, "rb", filestart)
     try:
-        fp.seek(0, 2);
+        fp.seek(0, 2)
     except OSError:
-        SeekToEndOfFile(fp);
+        SeekToEndOfFile(fp)
     except ValueError:
-        SeekToEndOfFile(fp);
-    CatSize = fp.tell();
-    CatSizeEnd = CatSize;
+        SeekToEndOfFile(fp)
+    CatSize = fp.tell()
+    CatSizeEnd = CatSize
     fp.seek(curloc, 0)
-    if(curloc > 0):
-        fp.seek(0, 0)
     if(IsNestedDict(formatspecs)):
-        compresschecking = CheckCompressionType(fp, formatspecs, False)
+        compresschecking = CheckCompressionType(fp, formatspecs, filestart, False)
         if(compresschecking not in formatspecs):
-            fp.seek(0, 0)
             return False
         else:
             formatspecs = formatspecs[compresschecking]
-            fp.seek(0, 0)
+            fp.seek(filestart, 0)
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelszie = len(formatspecs['format_delimiter'])
@@ -6583,23 +6879,8 @@ def FoxFileSeekToFileNum(infile, fmttype="auto", seekto=0, listonly=False, conte
             fp, formatspecs['format_delimiter'])
     fnumextrafieldsize = int(inheader[5], 16)
     fnumextrafields = int(inheader[6], 16)
-    fextrafieldslist = []
     extrastart = 7
     extraend = extrastart + fnumextrafields
-    while(extrastart < extraend):
-        fextrafieldslist.append(inheader[extrastart])
-        extrastart = extrastart + 1
-    if(fnumextrafields==1):
-        try:
-            fextrafieldslist = json.loads(base64.b64decode(fextrafieldslist[0]).decode("UTF-8"))
-            fnumextrafields = len(fextrafieldslist)
-        except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
-            try:
-                fextrafieldslist = json.loads(fextrafieldslist[0])
-            except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
-                pass
-    if(curloc > 0):
-        fp.seek(curloc, 0)
     formversion = re.findall("([\\d]+)", formstring)
     fheadsize = int(inheader[0], 16)
     fnumfields = int(inheader[1], 16)
@@ -6608,629 +6889,7 @@ def FoxFileSeekToFileNum(infile, fmttype="auto", seekto=0, listonly=False, conte
     fnumfiles = int(inheader[4], 16)
     fprechecksumtype = inheader[-2]
     fprechecksum = inheader[-1]
-    headercheck = ValidateHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, fprechecksum, formatspecs)
-    newfcs = GetHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, True, formatspecs)
-    if(not headercheck and not skipchecksum):
-        VerbosePrintOut(
-            "File Header Checksum Error with file at offset " + str(0))
-        VerbosePrintOut("'" + fprechecksum + "' != " +
-                        "'" + newfcs + "'")
-        return False
-    formversions = re.search('(.*?)(\\d+)', formstring).groups()
-    fcompresstype = compresscheck
-    if(fcompresstype==formatspecs['format_magic']):
-        fcompresstype = ""
-    outlist = {'fnumfiles': fnumfiles, 'fformat': formversions[0], 'fcompression': fcompresstype, 'fencoding': fhencoding, 'fversion': formversions[1], 'fostype': fostype, 'fheadersize': fheadsize, 'fsize': CatSizeEnd, 'fnumfields': fnumfields + 2, 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'frawheader': [formstring] + inheader, 'fextrafields': fnumextrafields, 'fextrafieldsize': fnumextrafieldsize, 'fextradata': fextrafieldslist, 'ffilelist': []}
-    if(seekto >= fnumfiles):
-        seekto = fnumfiles - 1
-    if(seekto < 0):
-        seekto = 0
-    if(seekto >= 0):
-        il = -1
-        while (fp.tell() < CatSizeEnd) if seektoend else (il < seekto):
-            prefhstart = fp.tell()
-            if(formatspecs['new_style']):
-                preheaderdata = ReadFileHeaderDataBySize(
-                    fp, formatspecs['format_delimiter'])
-            else:
-                preheaderdata = ReadFileHeaderDataWoSize(
-                    fp, formatspecs['format_delimiter'])
-            if(len(preheaderdata) == 0):
-                break
-            prefheadsize = int(preheaderdata[0], 16)
-            prefnumfields = int(preheaderdata[1], 16)
-            preftype = int(preheaderdata[2], 16)
-            prefencoding = preheaderdata[3]
-            prefcencoding = preheaderdata[4]
-            if(re.findall("^[.|/]", preheaderdata[5])):
-                prefname = preheaderdata[5]
-            else:
-                prefname = "./"+preheaderdata[5]
-            prefbasedir = os.path.dirname(prefname)
-            preflinkname = preheaderdata[6]
-            prefsize = int(preheaderdata[7], 16)
-            prefatime = int(preheaderdata[8], 16)
-            prefmtime = int(preheaderdata[9], 16)
-            prefctime = int(preheaderdata[10], 16)
-            prefbtime = int(preheaderdata[11], 16)
-            prefmode = int(preheaderdata[12], 16)
-            prefchmode = stat.S_IMODE(prefmode)
-            preftypemod = stat.S_IFMT(prefmode)
-            prefwinattributes = int(preheaderdata[13], 16)
-            prefcompression = preheaderdata[14]
-            prefcsize = int(preheaderdata[15], 16)
-            prefuid = int(preheaderdata[16], 16)
-            prefuname = preheaderdata[17]
-            prefgid = int(preheaderdata[18], 16)
-            prefgname = preheaderdata[19]
-            fid = int(preheaderdata[20], 16)
-            finode = int(preheaderdata[21], 16)
-            flinkcount = int(preheaderdata[22], 16)
-            prefdev = int(preheaderdata[23], 16)
-            prefdev_minor = int(preheaderdata[24], 16)
-            prefdev_major = int(preheaderdata[25], 16)
-            prefseeknextfile = preheaderdata[26]
-            prefjsontype = preheaderdata[27]
-            prefjsonlen = int(preheaderdata[28], 16)
-            prefjsonsize = int(preheaderdata[29], 16)
-            prefjsonchecksumtype = preheaderdata[30]
-            prefjsonchecksum = preheaderdata[31]
-            prefhend = fp.tell() - 1
-            prefjstart = fp.tell()
-            prefjoutfprejsoncontent = fp.read(prefjsonsize).decode("UTF-8")
-            prefjend = fp.tell()
-            fp.seek(len(formatspecs['format_delimiter']), 1)
-            prejsonfcs = GetFileChecksum(prefjoutfprejsoncontent, prefjsonchecksumtype, True, formatspecs)
-            prefextrasize = int(preheaderdata[32], 16)
-            prefextrafields = int(preheaderdata[33], 16)
-            extrastart = 34
-            extraend = extrastart + prefextrafields
-            prefcs = preheaderdata[-2].lower()
-            prenewfcs = preheaderdata[-1].lower()
-            prenewfcs = GetHeaderChecksum(
-                preheaderdata[:-2], preheaderdata[-4].lower(), True, formatspecs)
-            if(prefcs != prenewfcs and not skipchecksum):
-                VerbosePrintOut("File Header Checksum Error with file " +
-                                prefname + " at offset " + str(prefhstart))
-                VerbosePrintOut("'" + prefcs + "' != " +
-                                "'" + prenewfcs + "'")
-                return False
-            if(prefjsonsize > 0):
-                if(prejsonfcs != prefjsonchecksum and not skipchecksum):
-                    VerbosePrintOut("File JSON Data Checksum Error with file " +
-                                    prefname + " at offset " + str(prefjstart))
-                    VerbosePrintOut("'" + prefjsonchecksum + "' != " + "'" + prejsonfcs + "'")
-                    return False
-            prefcontentstart = fp.tell()
-            prefcontents = ""
-            pyhascontents = False
-            if(prefsize > 0):
-                if(prefcompression):
-                    prefcontents = fp.read(prefsize)
-                else:
-                    prefcontents = fp.read(prefcsize)
-                prenewfccs = GetFileChecksum(
-                    prefcontents, preheaderdata[-3].lower(), False, formatspecs)
-                pyhascontents = True
-                if(prefccs != prenewfccs and not skipchecksum):
-                    VerbosePrintOut("File Content Checksum Error with file " +
-                                    prefname + " at offset " + str(prefcontentstart))
-                    VerbosePrintOut("'" + prefccs +
-                                    "' != " + "'" + prenewfccs + "'")
-                    return False
-            if(re.findall("^\\+([0-9]+)", prefseeknextfile)):
-                fseeknextasnum = int(prefseeknextfile.replace("+", ""))
-                if(abs(fseeknextasnum) == 0):
-                    pass
-                fp.seek(fseeknextasnum, 1)
-            elif(re.findall("^\\-([0-9]+)", prefseeknextfile)):
-                fseeknextasnum = int(prefseeknextfile)
-                if(abs(fseeknextasnum) == 0):
-                    pass
-                fp.seek(fseeknextasnum, 1)
-            elif(re.findall("^([0-9]+)", prefseeknextfile)):
-                fseeknextasnum = int(prefseeknextfile)
-                if(abs(fseeknextasnum) == 0):
-                    pass
-                fp.seek(fseeknextasnum, 0)
-            else:
-                return False
-            il = il + 1
-    fp.seek(seekstart, 0)
-    fileidnum = il
-    outfheadsize = int(preheaderdata[0], 16)
-    outfnumfields = int(preheaderdata[1], 16)
-    outftype = int(preheaderdata[2], 16)
-    outfencoding = preheaderdata[3]
-    if(re.findall("^[.|/]", preheaderdata[4])):
-        outfname = preheaderdata[4]
-    else:
-        outfname = "./"+preheaderdata[4]
-    outflinkname = preheaderdata[5]
-    outfsize = int(preheaderdata[6], 16)
-    outfbasedir = os.path.dirname(outfname)
-    outlist = {'fid': fileidnum, 'foffset': fp.tell(), 'ftype': outftype, 'fencoding': outfencoding, 'fname': outfname,
-               'fbasedir': outfbasedir, 'flinkname': outflinkname, 'fsize': outfsize}
-    if(returnfp):
-        outlist.update({'fp': fp})
-    else:
-        fp.close()
-    return outlist
-
-
-def FoxFileSeekToFileName(infile, fmttype="auto", seekfile=None, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
-    if(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype in formatspecs):
-        formatspecs = formatspecs[fmttype]
-    elif(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype not in formatspecs):
-        fmttype = "auto"
-    curloc = 0
-    if(hasattr(infile, "read") or hasattr(infile, "write")):
-        curloc = infile.tell()
-        fp = infile
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
-        if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
-            formatspecs = formatspecs[checkcompressfile]
-        if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-            return TarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(checkcompressfile == "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))):
-            return RarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(py7zr_support and checkcompressfile == "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']):
-            return False
-        elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
-            return False
-        if(not fp):
-            return False
-        fp.seek(0, 0)
-    elif(infile == "-"):
-        fp = BytesIO()
-        if(hasattr(sys.stdin, "buffer")):
-            shutil.copyfileobj(sys.stdin.buffer, fp)
-        else:
-            shutil.copyfileobj(sys.stdin, fp)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
-        if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
-            formatspecs = formatspecs[checkcompressfile]
-        if(not fp):
-            return False
-        fp.seek(0, 0)
-    elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
-        fp = BytesIO()
-        fp.write(infile)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
-        if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
-            formatspecs = formatspecs[compresscheck]
-        if(not fp):
-            return False
-        fp.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
-        fp = download_file_from_internet_file(infile)
-        fp = UncompressFileAlt(fp, formatspecs)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
-        if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
-            formatspecs = formatspecs[compresscheck]
-        fp.seek(0, 0)
-        if(not fp):
-            return False
-        fp.seek(0, 0)
-    else:
-        infile = RemoveWindowsPath(infile)
-        checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
-        if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
-            formatspecs = formatspecs[checkcompressfile]
-        if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-            return TarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(checkcompressfile == "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))):
-            return RarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(py7zr_support and checkcompressfile == "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']):
-            return False
-        elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
-            return False
-        compresscheck = CheckCompressionType(infile, formatspecs, True)
-        if(not compresscheck):
-            fextname = os.path.splitext(infile)[1]
-            if(fextname == ".gz"):
-                compresscheck = "gzip"
-            elif(fextname == ".bz2"):
-                compresscheck = "bzip2"
-            elif(fextname == ".zst"):
-                compresscheck = "zstd"
-            elif(fextname == ".lz4" or fextname == ".clz4"):
-                compresscheck = "lz4"
-            elif(fextname == ".lzo" or fextname == ".lzop"):
-                compresscheck = "lzo"
-            elif(fextname == ".lzma"):
-                compresscheck = "lzma"
-            elif(fextname == ".xz"):
-                compresscheck = "xz"
-            elif(fextname == ".zz" or fextname == ".zl" or fextname == ".zlib"):
-                compresscheck = "zlib"
-            else:
-                return False
-        if(not compresscheck):
-            return False
-        fp = UncompressFile(infile, formatspecs, "rb")
-    try:
-        fp.seek(0, 2);
-    except OSError:
-        SeekToEndOfFile(fp);
-    except ValueError:
-        SeekToEndOfFile(fp);
-    CatSize = fp.tell();
-    CatSizeEnd = CatSize;
-    fp.seek(curloc, 0)
-    if(curloc > 0):
-        fp.seek(0, 0)
-    if(IsNestedDict(formatspecs)):
-        compresschecking = CheckCompressionType(fp, formatspecs, False)
-        if(compresschecking not in formatspecs):
-            return False
-        else:
-            formatspecs = formatspecs[compresschecking]
-            fp.seek(0, 0)
-    inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
-    formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
-    formdelszie = len(formatspecs['format_delimiter'])
-    formdel = fp.read(formdelszie).decode("UTF-8")
-    if(formstring != formatspecs['format_magic']+inheaderver):
-        return False
-    if(formdel != formatspecs['format_delimiter']):
-        return False
-    if(formatspecs['new_style']):
-        inheader = ReadFileHeaderDataBySize(
-            fp, formatspecs['format_delimiter'])
-    else:
-        inheader = ReadFileHeaderDataWoSize(
-            fp, formatspecs['format_delimiter'])
-    fnumextrafieldsize = int(inheader[5], 16)
-    fnumextrafields = int(inheader[6], 16)
-    fextrafieldslist = []
-    extrastart = 7
-    extraend = extrastart + fnumextrafields
-    while(extrastart < extraend):
-        fextrafieldslist.append(inheader[extrastart])
-        extrastart = extrastart + 1
-    if(fnumextrafields==1):
-        try:
-            fextrafieldslist = json.loads(base64.b64decode(fextrafieldslist[0]).decode("UTF-8"))
-            fnumextrafields = len(fextrafieldslist)
-        except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
-            try:
-                fextrafieldslist = json.loads(fextrafieldslist[0])
-            except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
-                pass
-    if(curloc > 0):
-        fp.seek(curloc, 0)
-    formversion = re.findall("([\\d]+)", formstring)
-    fheadsize = int(inheader[0], 16)
-    fnumfields = int(inheader[1], 16)
-    fhencoding = inheader[2]
-    fostype = inheader[3]
-    fnumfiles = int(inheader[4], 16)
-    fprechecksumtype = inheader[-2]
-    fprechecksum = inheader[-1]
-    headercheck = ValidateHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, fprechecksum, formatspecs)
-    newfcs = GetHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, True, formatspecs)
-    if(not headercheck and not skipchecksum):
-        VerbosePrintOut(
-            "File Header Checksum Error with file at offset " + str(0))
-        VerbosePrintOut("'" + fprechecksum + "' != " +
-                        "'" + newfcs + "'")
-        return False
-    formversions = re.search('(.*?)(\\d+)', formstring).groups()
-    fcompresstype = compresscheck
-    if(fcompresstype==formatspecs['format_magic']):
-        fcompresstype = ""
-    outlist = {'fnumfiles': fnumfiles, 'fformat': formversions[0], 'fcompression': fcompresstype, 'fencoding': fhencoding, 'fversion': formversions[1], 'fostype': fostype, 'fheadersize': fheadsize, 'fsize': CatSizeEnd, 'fnumfields': fnumfields + 2, 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'frawheader': [formstring] + inheader, 'fextrafields': fnumextrafields, 'fextrafieldsize': fnumextrafieldsize, 'fextradata': fextrafieldslist, 'ffilelist': []}
-    seekto = fnumfiles - 1
-    filefound = False
-    if(seekto >= 0):
-        il = -1
-        while (fp.tell() < CatSizeEnd) if seektoend else (il < seekto):
-            prefhstart = fp.tell()
-            if(formatspecs['new_style']):
-                preheaderdata = ReadFileHeaderDataBySize(
-                    fp, formatspecs['format_delimiter'])
-            else:
-                preheaderdata = ReadFileHeaderDataWoSize(
-                    fp, formatspecs['format_delimiter'])
-            if(len(preheaderdata) == 0):
-                break
-            prefheadsize = int(preheaderdata[0], 16)
-            prefnumfields = int(preheaderdata[1], 16)
-            preftype = int(preheaderdata[2], 16)
-            prefencoding = preheaderdata[3]
-            prefencoding = preheaderdata[4]
-            if(re.findall("^[.|/]", preheaderdata[5])):
-                prefname = preheaderdata[5]
-            else:
-                prefname = "./"+preheaderdata[5]
-            prefbasedir = os.path.dirname(prefname)
-            preflinkname = preheaderdata[6]
-            prefsize = int(preheaderdata[7], 16)
-            prefatime = int(preheaderdata[8], 16)
-            prefmtime = int(preheaderdata[9], 16)
-            prefctime = int(preheaderdata[10], 16)
-            prefbtime = int(preheaderdata[11], 16)
-            prefmode = int(preheaderdata[12], 16)
-            prefchmode = stat.S_IMODE(prefmode)
-            preftypemod = stat.S_IFMT(prefmode)
-            prefwinattributes = int(preheaderdata[13], 16)
-            prefcompression = preheaderdata[14]
-            prefcsize = int(preheaderdata[15], 16)
-            prefuid = int(preheaderdata[16], 16)
-            prefuname = preheaderdata[17]
-            prefgid = int(preheaderdata[18], 16)
-            prefgname = preheaderdata[19]
-            fid = int(preheaderdata[20], 16)
-            finode = int(preheaderdata[21], 16)
-            flinkcount = int(preheaderdata[22], 16)
-            prefdev = int(preheaderdata[23], 16)
-            prefdev_minor = int(preheaderdata[24], 16)
-            prefdev_major = int(preheaderdata[25], 16)
-            prefseeknextfile = preheaderdata[26]
-            prefjsontype = preheaderdata[27]
-            prefjsonlen = int(preheaderdata[28], 16)
-            prefjsonsize = int(preheaderdata[29], 16)
-            prefjsonchecksumtype = preheaderdata[30]
-            prefjsonchecksum = preheaderdata[31]
-            prefhend = fp.tell() - 1
-            prefjstart = fp.tell()
-            prefjoutfprejsoncontent = fp.read(prefjsonsize).decode("UTF-8")
-            prefjend = fp.tell()
-            fp.seek(len(formatspecs['format_delimiter']), 1)
-            prejsonfcs = GetFileChecksum(prefjoutfprejsoncontent, prefjsonchecksumtype, True, formatspecs)
-            prefextrasize = int(preheaderdata[32], 16)
-            prefextrafields = int(preheaderdata[33], 16)
-            extrastart = 34
-            extraend = extrastart + prefextrafields
-            prefcs = preheaderdata[-2].lower()
-            prenewfcs = preheaderdata[-1].lower()
-            prenewfcs = GetHeaderChecksum(
-                preheaderdata[:-2], preheaderdata[-4].lower(), True, formatspecs)
-            if(prefcs != prenewfcs and not skipchecksum):
-                VerbosePrintOut("File Header Checksum Error with file " +
-                                prefname + " at offset " + str(prefhstart))
-                VerbosePrintOut("'" + prefcs + "' != " +
-                                "'" + prenewfcs + "'")
-                return False
-            if(prefjsonsize > 0):
-                if(prejsonfcs != prefjsonchecksum and not skipchecksum):
-                    VerbosePrintOut("File JSON Data Checksum Error with file " +
-                                    prefname + " at offset " + str(prefjstart))
-                    VerbosePrintOut("'" + prefjsonchecksum + "' != " + "'" + prejsonfcs + "'")
-                    return False
-            prefcontentstart = fp.tell()
-            prefcontents = ""
-            pyhascontents = False
-            if(prefsize > 0):
-                if(prefcompression):
-                    prefcontents = fp.read(prefsize)
-                else:
-                    prefcontents = fp.read(prefcsize)
-                prenewfccs = GetFileChecksum(
-                    prefcontents, preheaderdata[-3].lower(), False, formatspecs)
-                pyhascontents = True
-                if(prefccs != prenewfccs and not skipchecksum):
-                    VerbosePrintOut("File Content Checksum Error with file " +
-                                    prefname + " at offset " + str(prefcontentstart))
-                    VerbosePrintOut("'" + prefccs +
-                                    "' != " + "'" + prenewfccs + "'")
-                    return False
-            if(re.findall("^\\+([0-9]+)", prefseeknextfile)):
-                fseeknextasnum = int(prefseeknextfile.replace("+", ""))
-                if(abs(fseeknextasnum) == 0):
-                    pass
-                fp.seek(fseeknextasnum, 1)
-            elif(re.findall("^\\-([0-9]+)", prefseeknextfile)):
-                fseeknextasnum = int(prefseeknextfile)
-                if(abs(fseeknextasnum) == 0):
-                    pass
-                fp.seek(fseeknextasnum, 1)
-            elif(re.findall("^([0-9]+)", prefseeknextfile)):
-                fseeknextasnum = int(prefseeknextfile)
-                if(abs(fseeknextasnum) == 0):
-                    pass
-                fp.seek(fseeknextasnum, 0)
-            else:
-                return False
-            il = il + 1
-            filefound = False
-            if(prefname == seekfile):
-                filefound = True
-                break
-    fp.seek(seekstart, 0)
-    fileidnum = il
-    outfheadsize = int(preheaderdata[0], 16)
-    outfnumfields = int(preheaderdata[1], 16)
-    outftype = int(preheaderdata[2], 16)
-    outfencoding = preheaderdata[3]
-    if(re.findall("^[.|/]", preheaderdata[4])):
-        outfname = preheaderdata[4]
-    else:
-        outfname = "./"+preheaderdata[4]
-    outflinkname = preheaderdata[5]
-    outfsize = int(preheaderdata[6], 16)
-    outfbasedir = os.path.dirname(outfname)
-    if(filefound):
-        outlist = {'fid': fileidnum, 'foffset': fp.tell(), 'ftype': outftype, 'fencoding': outfencoding, 'fname': outfname,
-                   'fbasedir': outfbasedir, 'flinkname': outflinkname, 'fsize': outfsize}
-    else:
-        return False
-    if(returnfp):
-        outlist.update({'fp': fp})
-    else:
-        fp.close()
-    return outlist
-
-
-def FoxFileValidate(infile, fmttype="auto", formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
-    if(verbose):
-        logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
-    if(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype in formatspecs):
-        formatspecs = formatspecs[fmttype]
-    elif(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype not in formatspecs):
-        fmttype = "auto"
-    curloc = 0
-    if(hasattr(infile, "read") or hasattr(infile, "write")):
-        curloc = infile.tell()
-        fp = infile
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
-        if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
-            formatspecs = formatspecs[checkcompressfile]
-        if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-            return TarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(checkcompressfile == "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))):
-            return RarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(py7zr_support and checkcompressfile == "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']):
-            return False
-        elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
-            return False
-        if(not fp):
-            return False
-        fp.seek(0, 0)
-    elif(infile == "-"):
-        fp = BytesIO()
-        if(hasattr(sys.stdin, "buffer")):
-            shutil.copyfileobj(sys.stdin.buffer, fp)
-        else:
-            shutil.copyfileobj(sys.stdin, fp)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
-        if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
-            formatspecs = formatspecs[checkcompressfile]
-        if(not fp):
-            return False
-        fp.seek(0, 0)
-    elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
-        fp = BytesIO()
-        fp.write(infile)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
-        if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
-            formatspecs = formatspecs[compresscheck]
-        if(not fp):
-            return False
-        fp.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
-        fp = download_file_from_internet_file(infile)
-        fp = UncompressFileAlt(fp, formatspecs)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
-        if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
-            formatspecs = formatspecs[compresscheck]
-        fp.seek(0, 0)
-        if(not fp):
-            return False
-        fp.seek(0, 0)
-    else:
-        infile = RemoveWindowsPath(infile)
-        checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
-        if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
-            formatspecs = formatspecs[checkcompressfile]
-        if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-            return TarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(checkcompressfile == "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))):
-            return RarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
-        elif(py7zr_support and checkcompressfile == "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']):
-            return False
-        elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
-            return False
-        compresscheck = CheckCompressionType(infile, formatspecs, True)
-        if(not compresscheck):
-            fextname = os.path.splitext(infile)[1]
-            if(fextname == ".gz"):
-                compresscheck = "gzip"
-            elif(fextname == ".bz2"):
-                compresscheck = "bzip2"
-            elif(fextname == ".zst"):
-                compresscheck = "zstd"
-            elif(fextname == ".lz4" or fextname == ".clz4"):
-                compresscheck = "lz4"
-            elif(fextname == ".lzo" or fextname == ".lzop"):
-                compresscheck = "lzo"
-            elif(fextname == ".lzma"):
-                compresscheck = "lzma"
-            elif(fextname == ".xz"):
-                compresscheck = "xz"
-            elif(fextname == ".zz" or fextname == ".zl" or fextname == ".zlib"):
-                compresscheck = "zlib"
-            else:
-                return False
-        if(not compresscheck):
-            return False
-        fp = UncompressFile(infile, formatspecs, "rb")
-    try:
-        fp.seek(0, 2);
-    except OSError:
-        SeekToEndOfFile(fp);
-    except ValueError:
-        SeekToEndOfFile(fp);
-    CatSize = fp.tell();
-    CatSizeEnd = CatSize;
-    fp.seek(curloc, 0)
-    if(curloc > 0):
-        fp.seek(0, 0)
-    if(IsNestedDict(formatspecs)):
-        compresschecking = CheckCompressionType(fp, formatspecs, False)
-        if(compresschecking not in formatspecs):
-            return False
-        else:
-            formatspecs = formatspecs[compresschecking]
-            fp.seek(0, 0)
-    inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
-    formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
-    formdelszie = len(formatspecs['format_delimiter'])
-    formdel = fp.read(formdelszie).decode("UTF-8")
-    if(formstring != formatspecs['format_magic']+inheaderver):
-        return False
-    if(formdel != formatspecs['format_delimiter']):
-        return False
-    if(formatspecs['new_style']):
-        inheader = ReadFileHeaderDataBySize(
-            fp, formatspecs['format_delimiter'])
-    else:
-        inheader = ReadFileHeaderDataWoSize(
-            fp, formatspecs['format_delimiter'])
-    fnumextrafieldsize = int(inheader[5], 16)
-    fnumextrafields = int(inheader[6], 16)
-    extrastart = 7
-    extraend = extrastart + fnumextrafields
-    if(curloc > 0):
-        fp.seek(curloc, 0)
-    formversion = re.findall("([\\d]+)", formstring)
-    fheadsize = int(inheader[0], 16)
-    fnumfields = int(inheader[1], 16)
-    fhencoding = inheader[2]
-    fostype = inheader[3]
-    fnumfiles = int(inheader[4], 16)
-    fprechecksumtype = inheader[-2]
-    fprechecksum = inheader[-1]
-    il = 0
+    il = 0
     headercheck = ValidateHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, fprechecksum, formatspecs)
     newfcs = GetHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, True, formatspecs)
     valid_archive = True
@@ -7431,18 +7090,18 @@ def FoxFileValidateMultiple(infile, fmttype="auto", formatspecs=__file_format_mu
 def FoxFileValidateMultipleFiles(infile, fmttype="auto", formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
     return FoxFileValidateMultiple(infile, fmttype, formatspecs, verbose, returnfp)
 
-def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+def FoxFileToArray(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):
         formatspecs = formatspecs[fmttype]
     elif(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype not in formatspecs):
         fmttype = "auto"
-    curloc = 0
+    curloc = filestart
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         curloc = infile.tell()
         fp = infile
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
+        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)):
@@ -7459,45 +7118,45 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
             return False
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     elif(infile == "-"):
-        fp = BytesIO()
+        fp = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, fp)
         else:
             shutil.copyfileobj(sys.stdin, fp)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
+        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(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
-        fp = BytesIO()
+        fp = MkTempFile()
         fp.write(infile)
-        fp.seek(0, 0)
-        fp = UncompressFileAlt(fp, formatspecs)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp.seek(filestart, 0)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
         if(not fp):
             return False
-        fp.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
+        fp.seek(filestart, 0)
+    elif(re.findall(__download_proto_support__, infile)):
         fp = download_file_from_internet_file(infile)
-        fp = UncompressFileAlt(fp, formatspecs)
-        compresscheck = CheckCompressionType(fp, formatspecs, False)
+        fp = UncompressFileAlt(fp, formatspecs, filestart)
+        compresscheck = CheckCompressionType(fp, formatspecs, filestart, False)
         if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
             formatspecs = formatspecs[compresscheck]
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
         if(not fp):
             return False
-        fp.seek(0, 0)
+        fp.seek(filestart, 0)
     else:
         infile = RemoveWindowsPath(infile)
-        checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+        checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
@@ -7512,7 +7171,7 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
             return False
         elif(IsNestedDict(formatspecs) and checkcompressfile not in formatspecs):
             return False
-        compresscheck = CheckCompressionType(infile, formatspecs, True)
+        compresscheck = CheckCompressionType(infile, formatspecs, filestart, True)
         if(not compresscheck):
             fextname = os.path.splitext(infile)[1]
             if(fextname == ".gz"):
@@ -7535,25 +7194,23 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
                 return False
         if(not compresscheck):
             return False
-        fp = UncompressFile(infile, formatspecs, "rb")
+        fp = UncompressFile(infile, formatspecs, "rb", filestart)
     try:
-        fp.seek(0, 2);
+        fp.seek(0, 2)
     except OSError:
-        SeekToEndOfFile(fp);
+        SeekToEndOfFile(fp)
     except ValueError:
-        SeekToEndOfFile(fp);
-    CatSize = fp.tell();
+        SeekToEndOfFile(fp)
+    CatSize = fp.tell()
     CatSizeEnd = CatSize;
     fp.seek(curloc, 0)
-    if(curloc > 0):
-        fp.seek(0, 0)
     if(IsNestedDict(formatspecs)):
-        compresschecking = CheckCompressionType(fp, formatspecs, False)
+        compresschecking = CheckCompressionType(fp, formatspecs, filestart, False)
         if(compresschecking not in formatspecs):
             return False
         else:
             formatspecs = formatspecs[compresschecking]
-            fp.seek(0, 0)
+            fp.seek(filestart, 0)
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelszie = len(formatspecs['format_delimiter'])
@@ -7585,8 +7242,6 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
                 fextrafieldslist = json.loads(fextrafieldslist[0])
             except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                 pass
-    if(curloc > 0):
-        fp.seek(curloc, 0)
     formversion = re.findall("([\\d]+)", formstring)
     fheadsize = int(inheader[0], 16)
     fnumfields = int(inheader[1], 16)
@@ -7775,7 +7430,7 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
                 outfjsoncontent = {}
         elif(outfjsontype=="list"):
             outfprejsoncontent = fp.read(outfjsonsize).decode("UTF-8")
-            flisttmp = BytesIO()
+            flisttmp = MkTempFile()
             flisttmp.write(outfprejsoncontent.encode())
             flisttmp.seek(0)
             outfjsoncontent = ReadFileHeaderData(flisttmp, outfjsonlen, formatspecs['format_delimiter'])
@@ -7828,7 +7483,7 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
                 VerbosePrintOut("'" + outfjsonchecksum + "' != " + "'" + injsonfcs + "'")
                 return False
         outfcontentstart = fp.tell()
-        outfcontents = BytesIO()
+        outfcontents = MkTempFile()
         pyhascontents = False
         if(outfsize > 0 and not listonly):
             if(outfcompression == "none" or outfcompression == "" or outfcompression == "auto"):
@@ -7851,9 +7506,9 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
                 outfcontents.seek(0, 0)
                 if(uncompress):
                     cfcontents = UncompressFileAlt(
-                        outfcontents, formatspecs)
+                        outfcontents, formatspecs, 0)
                     cfcontents.seek(0, 0)
-                    outfcontents = BytesIO()
+                    outfcontents = MkTempFile()
                     shutil.copyfileobj(cfcontents, outfcontents)
                     cfcontents.close()
                     outfcontents.seek(0, 0)
@@ -7896,49 +7551,49 @@ def FoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=Fals
     return outlist
 
 
-def MultipleFoxFileToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+def MultipleFoxFileToArray(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:
-        curretfile[curfname] = ArchiveFileToArray(curfname, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
+        curretfile[curfname] = FoxFileToArray(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
     return outretval
 
-def MultipleFoxFilesToArray(infile, fmttype="auto", seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
-    return MultipleFoxFileToArray(infile, fmttype, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
+def MultipleFoxFilesToArray(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 MultipleFoxFileToArray(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
 
 
-def FoxFileStringToArray(instr, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
-    checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+def FoxFileStringToArray(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):
         formatspecs = formatspecs[checkcompressfile]
-    fp = BytesIO(instr)
-    listfoxfiles = FoxFileToArray(fp, "auto", seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
-    return listfoxfiles
+    fp = MkTempFile(instr)
+    listarrayfiles = FoxFileToArray(fp, "auto", filestart, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+    return listarrayfiles
 
 
 def TarFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False, returnfp=False):
-    checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+    checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
-    fp = BytesIO()
+    fp = MkTempFile()
     fp = PackFoxFileFromTarFile(
         infile, fp, "auto", True, None, compressionlistalt, "crc32", [], formatspecs, False, True)
-    listfoxfiles = FoxFileToArray(fp, "auto", seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
-    return listfoxfiles
+    listarrayfiles = FoxFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+    return listarrayfiles
 
 
 def ZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False, returnfp=False):
-    checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+    checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
-    fp = BytesIO()
+    fp = MkTempFile()
     fp = PackFoxFileFromZipFile(
         infile, fp, "auto", True, None, compressionlistalt, "crc32", [], formatspecs, False, True)
-    listfoxfiles = FoxFileToArray(fp, "auto", seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
-    return listfoxfiles
+    listarrayfiles = FoxFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+    return listarrayfiles
 
 
 if(not rarfile_support):
@@ -7947,14 +7602,14 @@ if(not rarfile_support):
 
 if(rarfile_support):
     def RarFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False, returnfp=False):
-        checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+        checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
-        fp = BytesIO()
+        fp = MkTempFile()
         fp = PackFoxFileFromRarFile(
             infile, fp, "auto", True, None, compressionlistalt, "crc32", [], formatspecs, False, True)
-        listfoxfiles = FoxFileToArray(fp, "auto", seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
-        return listfoxfiles
+        listarrayfiles = FoxFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+        return listarrayfiles
 
 if(not py7zr_support):
     def SevenZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False, returnfp=False):
@@ -7962,18 +7617,18 @@ if(not py7zr_support):
 
 if(py7zr_support):
     def SevenZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False, returnfp=False):
-        checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+        checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
-        fp = BytesIO()
+        fp = MkTempFile()
         fp = PackFoxFileFromSevenZipFile(
             infile, fp, "auto", True, None, compressionlistalt, "crc32", [], formatspecs, False, True)
-        listfoxfiles = FoxFileToArray(fp, "auto", seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
-        return listfoxfiles
+        listarrayfiles = FoxFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+        return listarrayfiles
 
 
-def InFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
-    checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+def InFileToArray(infile, 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):
         formatspecs = formatspecs[checkcompressfile]
     if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
@@ -7985,78 +7640,78 @@ def InFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=
     elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
         return SevenZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
     elif(checkcompressfile == formatspecs['format_magic']):
-        return FoxFileToArray(infile, "auto", seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+        return FoxFileToArray(infile, "auto", filestart, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
     else:
         return False
     return False
 
 
-def ListDirToArray(infiles, dirlistfromtxt=False, fmttype=__file_format_default__, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, seekstart=0, seekend=0, listonly=False, skipchecksum=False, checksumtype=["crc32", "crc32", "crc32"], extradata=[], formatspecs=__file_format_dict__, verbose=False, seektoend=False, returnfp=False):
-    outarray = BytesIO()
+def ListDirToArray(infiles, dirlistfromtxt=False, fmttype=__file_format_default__, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, filestart=0, seekstart=0, seekend=0, listonly=False, skipchecksum=False, checksumtype=["crc32", "crc32", "crc32"], extradata=[], formatspecs=__file_format_dict__, verbose=False, seektoend=False, returnfp=False):
+    outarray = MkTempFile()
     packform = PackFoxFile(infiles, outarray, dirlistfromtxt, fmttype, compression, compresswholefile,
                               compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, True)
-    listfoxfiles = FoxFileToArray(outarray, "auto", seekstart, seekend, listonly, True, skipchecksum, formatspecs, seektoend, returnfp)
-    return listfoxfiles
+    listarrayfiles = FoxFileToArray(outarray, "auto", filestart, seekstart, seekend, listonly, True, skipchecksum, formatspecs, seektoend, returnfp)
+    return listarrayfiles
 
 
 def FoxFileArrayToArrayIndex(inarray, returnfp=False):
     if(isinstance(inarray, dict)):
-        listfoxfiles = inarray
+        listarrayfiles = inarray
     else:
         return False
-    if(not listfoxfiles):
+    if(not listarrayfiles):
         return False
-    outarray = {'list': listfoxfiles, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {
+    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': listfoxfiles['fp']})
-    lenlist = len(listfoxfiles['ffilelist'])
+        outarray.update({'fp': listarrayfiles['fp']})
+    lenlist = len(listarrayfiles['ffilelist'])
     lcfi = 0
-    lcfx = int(listfoxfiles['fnumfiles'])
-    if(lenlist > listfoxfiles['fnumfiles'] or lenlist < listfoxfiles['fnumfiles']):
+    lcfx = int(listarrayfiles['fnumfiles'])
+    if(lenlist > listarrayfiles['fnumfiles'] or lenlist < listarrayfiles['fnumfiles']):
         lcfx = int(lenlist)
     else:
-        lcfx = int(listfoxfiles['fnumfiles'])
+        lcfx = int(listarrayfiles['fnumfiles'])
     while(lcfi < lcfx):
-        filetoidarray = {listfoxfiles['ffilelist'][lcfi]
-                         ['fname']: listfoxfiles['ffilelist'][lcfi]['fid']}
-        idtofilearray = {listfoxfiles['ffilelist'][lcfi]
-                         ['fid']: listfoxfiles['ffilelist'][lcfi]['fname']}
+        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(listfoxfiles['ffilelist'][lcfi]['ftype'] == 0 or listfoxfiles['ffilelist'][lcfi]['ftype'] == 7):
+        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(listfoxfiles['ffilelist'][lcfi]['ftype'] == 1):
+        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(listfoxfiles['ffilelist'][lcfi]['ftype'] == 2):
+        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(listfoxfiles['ffilelist'][lcfi]['ftype'] == 3):
+        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(listfoxfiles['ffilelist'][lcfi]['ftype'] == 4):
+        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(listfoxfiles['ffilelist'][lcfi]['ftype'] == 5):
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 5):
             outarray['filetypes']['directories']['filetoid'].update(
                 filetoidarray)
             outarray['filetypes']['directories']['idtofile'].update(
                 idtofilearray)
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 6):
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 6):
             outarray['filetypes']['symlinks']['filetoid'].update(filetoidarray)
             outarray['filetypes']['symlinks']['idtofile'].update(idtofilearray)
             outarray['filetypes']['devices']['filetoid'].update(filetoidarray)
@@ -8065,13 +7720,13 @@ def FoxFileArrayToArrayIndex(inarray, returnfp=False):
     return outarray
 
 
-def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, seekstart=0, seekend=0, checksumtype=["crc32", "crc32", "crc32", "crc32"], skipchecksum=False, extradata=[], jsondata={}, formatspecs=__file_format_dict__, seektoend=False, verbose=False, returnfp=False):
+def RePackFoxFile(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):
     if(isinstance(infile, dict)):
-        listfoxfiles = infile
+        listarrayfiles = infile
     else:
         if(infile != "-" and not isinstance(infile, bytes) and not hasattr(infile, "read") and not hasattr(infile, "write")):
             infile = RemoveWindowsPath(infile)
-        listfoxfiles = FoxFileToArray(infile, "auto", seekstart, seekend, False, True, skipchecksum, formatspecs, seektoend, returnfp)
+        listarrayfiles = FoxFileToArray(infile, "auto", filestart, seekstart, seekend, False, True, skipchecksum, formatspecs, seektoend, returnfp)
     if(IsNestedDict(formatspecs) and fmttype in formatspecs):
         formatspecs = formatspecs[fmttype]
     elif(IsNestedDict(formatspecs) and fmttype not in formatspecs):
@@ -8097,15 +7752,15 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 os.unlink(outfile)
             except OSError:
                 pass
-    if(not listfoxfiles):
+    if(not listarrayfiles):
         return False
     if(outfile == "-" or outfile is None):
         verbose = False
-        fp = BytesIO()
+        fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
-    elif(re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
-        fp = BytesIO()
+    elif(re.findall(__upload_proto_support__, outfile)):
+        fp = MkTempFile()
     else:
         fbasename = os.path.splitext(outfile)[0]
         fextname = os.path.splitext(outfile)[1]
@@ -8117,19 +7772,19 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
             return False
     formver = formatspecs['format_ver']
     fileheaderver = str(int(formver.replace(".", "")))
-    lenlist = len(listfoxfiles['ffilelist'])
-    fnumfiles = int(listfoxfiles['fnumfiles'])
+    lenlist = len(listarrayfiles['ffilelist'])
+    fnumfiles = int(listarrayfiles['fnumfiles'])
     if(lenlist > fnumfiles or lenlist < fnumfiles):
         fnumfiles = lenlist
-    AppendFileHeader(fp, fnumfiles, listfoxfiles['fencoding'], [], checksumtype[0], formatspecs)
-    lenlist = len(listfoxfiles['ffilelist'])
-    fnumfiles = int(listfoxfiles['fnumfiles'])
+    AppendFileHeader(fp, fnumfiles, listarrayfiles['fencoding'], [], checksumtype[0], formatspecs)
+    lenlist = len(listarrayfiles['ffilelist'])
+    fnumfiles = int(listarrayfiles['fnumfiles'])
     lcfi = 0
-    lcfx = int(listfoxfiles['fnumfiles'])
-    if(lenlist > listfoxfiles['fnumfiles'] or lenlist < listfoxfiles['fnumfiles']):
+    lcfx = int(listarrayfiles['fnumfiles'])
+    if(lenlist > listarrayfiles['fnumfiles'] or lenlist < listarrayfiles['fnumfiles']):
         lcfx = int(lenlist)
     else:
-        lcfx = int(listfoxfiles['fnumfiles'])
+        lcfx = int(listarrayfiles['fnumfiles'])
     curinode = 0
     curfid = 0
     inodelist = []
@@ -8137,66 +7792,66 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
     filetoinode = {}
     reallcfi = 0
     while(lcfi < lcfx):
-        fencoding = listfoxfiles['ffilelist'][reallcfi]['fencoding']
-        fcencoding = listfoxfiles['ffilelist'][reallcfi]['fencoding']
-        if(re.findall("^[.|/]", listfoxfiles['ffilelist'][reallcfi]['fname'])):
-            fname = listfoxfiles['ffilelist'][reallcfi]['fname']
+        fencoding = listarrayfiles['ffilelist'][reallcfi]['fencoding']
+        fcencoding = listarrayfiles['ffilelist'][reallcfi]['fencoding']
+        if(re.findall("^[.|/]", listarrayfiles['ffilelist'][reallcfi]['fname'])):
+            fname = listarrayfiles['ffilelist'][reallcfi]['fname']
         else:
-            fname = "./"+listfoxfiles['ffilelist'][reallcfi]['fname']
+            fname = "./"+listarrayfiles['ffilelist'][reallcfi]['fname']
         if(verbose):
             VerbosePrintOut(fname)
         fheadersize = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fheadersize']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fheadersize']), 'x').lower()
         fsize = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fsize']), 'x').lower()
-        flinkname = listfoxfiles['ffilelist'][reallcfi]['flinkname']
+            int(listarrayfiles['ffilelist'][reallcfi]['fsize']), 'x').lower()
+        flinkname = listarrayfiles['ffilelist'][reallcfi]['flinkname']
         fatime = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fatime']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fatime']), 'x').lower()
         fmtime = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fmtime']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fmtime']), 'x').lower()
         fctime = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fctime']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fctime']), 'x').lower()
         fbtime = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fbtime']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fbtime']), 'x').lower()
         fmode = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fmode']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fmode']), 'x').lower()
         fchmode = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fchmode']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fchmode']), 'x').lower()
         fuid = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fuid']), 'x').lower()
-        funame = listfoxfiles['ffilelist'][reallcfi]['funame']
+            int(listarrayfiles['ffilelist'][reallcfi]['fuid']), 'x').lower()
+        funame = listarrayfiles['ffilelist'][reallcfi]['funame']
         fgid = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fgid']), 'x').lower()
-        fgname = listfoxfiles['ffilelist'][reallcfi]['fgname']
+            int(listarrayfiles['ffilelist'][reallcfi]['fgid']), 'x').lower()
+        fgname = listarrayfiles['ffilelist'][reallcfi]['fgname']
         finode = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['finode']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['finode']), 'x').lower()
         flinkcount = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['flinkcount']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['flinkcount']), 'x').lower()
         fwinattributes = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fwinattributes']), 'x').lower()
-        fcompression = listfoxfiles['ffilelist'][reallcfi]['fcompression']
+            int(listarrayfiles['ffilelist'][reallcfi]['fwinattributes']), 'x').lower()
+        fcompression = listarrayfiles['ffilelist'][reallcfi]['fcompression']
         fcsize = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fcsize']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fcsize']), 'x').lower()
         fdev = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fdev']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fdev']), 'x').lower()
         fdev_minor = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fminor']), 'x').lower()
+            int(listarrayfiles['ffilelist'][reallcfi]['fminor']), 'x').lower()
         fdev_major = format(
-            int(listfoxfiles['ffilelist'][reallcfi]['fmajor']), 'x').lower()
-        fseeknextfile = listfoxfiles['ffilelist'][reallcfi]['fseeknextfile']
-        if(len(listfoxfiles['ffilelist'][reallcfi]['fextralist']) > listfoxfiles['ffilelist'][reallcfi]['fextrafields'] and len(listfoxfiles['ffilelist'][reallcfi]['fextralist']) > 0):
-            listfoxfiles['ffilelist'][reallcfi]['fextrafields'] = len(
-                listfoxfiles['ffilelist'][reallcfi]['fextralist'])
+            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):
+            listarrayfiles['ffilelist'][reallcfi]['fextrafields'] = len(
+                listarrayfiles['ffilelist'][reallcfi]['fextralist'])
         if(not followlink and len(extradata) <= 0):
-            extradata = listfoxfiles['ffilelist'][reallcfi]['fextralist']
+            extradata = listarrayfiles['ffilelist'][reallcfi]['fextralist']
         if(not followlink and len(jsondata) <= 0):
-            jsondata = listfoxfiles['ffilelist'][reallcfi]['fjsondata']
-        fcontents = listfoxfiles['ffilelist'][reallcfi]['fcontents']
-        if(not listfoxfiles['ffilelist'][reallcfi]['fcontentasfile']):
-            fcontents = BytesIO(fcontents)
-        typechecktest = CheckCompressionType(fcontents, closefp=False)
+            jsondata = listarrayfiles['ffilelist'][reallcfi]['fjsondata']
+        fcontents = listarrayfiles['ffilelist'][reallcfi]['fcontents']
+        if(not listarrayfiles['ffilelist'][reallcfi]['fcontentasfile']):
+            fcontents = MkTempFile(fcontents)
+        typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
         fcontents.seek(0, 0)
-        fcencoding = GetFileEncoding(fcontents, False)
+        fcencoding = GetFileEncoding(fcontents, 0, False)
         fcompression = ""
         fcsize = format(int(0), 'x').lower()
         curcompression = "none"
@@ -8209,7 +7864,7 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 ilmin = 0
                 ilcsize = []
                 while(ilmin < ilsize):
-                    cfcontents = BytesIO()
+                    cfcontents = MkTempFile()
                     fcontents.seek(0, 0)
                     shutil.copyfileobj(fcontents, cfcontents)
                     fcontents.seek(0, 0)
@@ -8226,7 +7881,7 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 ilcmin = ilcsize.index(min(ilcsize))
                 curcompression = compressionuselist[ilcmin]
             fcontents.seek(0, 0)
-            cfcontents = BytesIO()
+            cfcontents = MkTempFile()
             shutil.copyfileobj(fcontents, cfcontents)
             cfcontents.seek(0, 0)
             cfcontents = CompressOpenFileAlt(
@@ -8239,10 +7894,10 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 fcontents.close()
                 fcontents = cfcontents
         if followlink:
-            if(listarchivefiles['ffilelist'][reallcfi]['ftype'] == 1 or listarchivefiles['ffilelist'][reallcfi]['ftype'] == 2):
-                getflinkpath = listarchivefiles['ffilelist'][reallcfi]['flinkname']
-                flinkid = prelistarchivefiles['filetoid'][getflinkpath]
-                flinkinfo = listarchivefiles['ffilelist'][flinkid]
+            if(listarrayfiles['ffilelist'][reallcfi]['ftype'] == 1 or listarrayfiles['ffilelist'][reallcfi]['ftype'] == 2):
+                getflinkpath = listarrayfiles['ffilelist'][reallcfi]['flinkname']
+                flinkid = prelistarrayfiles['filetoid'][getflinkpath]
+                flinkinfo = listarrayfiles['ffilelist'][flinkid]
                 fheadersize = format(
                     int(flinkinfo['fheadersize']), 'x').lower()
                 fsize = format(int(flinkinfo['fsize']), 'x').lower()
@@ -8275,14 +7930,14 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                     extradata = flinkinfo['fjsondata']
                 fcontents = flinkinfo['fcontents']
                 if(not flinkinfo['fcontentasfile']):
-                    fcontents = BytesIO(fcontents)
+                    fcontents = MkTempFile(fcontents)
                 ftypehex = format(flinkinfo['ftype'], 'x').lower()
         else:
             ftypehex = format(
-                listarchivefiles['ffilelist'][reallcfi]['ftype'], 'x').lower()
+                listarrayfiles['ffilelist'][reallcfi]['ftype'], 'x').lower()
         fcurfid = format(curfid, 'x').lower()
         if(not followlink and finode != 0):
-            if(listfoxfiles['ffilelist'][reallcfi]['ftype'] != 1):
+            if(listarrayfiles['ffilelist'][reallcfi]['ftype'] != 1):
                 fcurinode = format(int(curinode), 'x').lower()
                 inodetofile.update({curinode: fname})
                 filetoinode.update({fname: curinode})
@@ -8332,7 +7987,7 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
         outvar = fp.read()
         fp.close()
         return outvar
-    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall("^(ftp|ftps|sftp):\\/\\/", outfile)):
+    elif((not hasattr(outfile, "read") and not hasattr(outfile, "write")) and re.findall(__upload_proto_support__, outfile)):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
         fp.seek(0, 0)
@@ -8345,50 +8000,50 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
         return True
 
 
-def RePackFoxFileFromString(instr, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["crc32", "crc32", "crc32"], skipchecksum=False, extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
-    fp = BytesIO(instr)
-    listfoxfiles = RePackFoxFile(fp, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist,
-                                     checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp)
-    return listfoxfiles
+def RePackFoxFileFromString(instr, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, filestart=0, seekstart=0, seekend=0, checksumtype=["crc32", "crc32", "crc32"], skipchecksum=False, extradata=[], jsondata={}, formatspecs=__file_format_dict__, seektoend=False, verbose=False, returnfp=False):
+    fp = MkTempFile(instr)
+    listarrayfiles = RePackFoxFile(fp, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, filestart, seekstart, seekend,
+                                     checksumtype, skipchecksum, extradata, jsondata, formatspecs, seektoend, verbose, returnfp)
+    return listarrayfiles
 
 
-def PackFoxFileFromListDir(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, skipchecksum=False, checksumtype=["crc32", "crc32", "crc32"], extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
-    outarray = BytesIO()
+def PackFoxFileFromListDir(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, filestart=0, seekstart=0, seekend=0, checksumtype=["crc32", "crc32", "crc32"], skipchecksum=False, extradata=[], jsondata={}, formatspecs=__file_format_dict__, seektoend=False, verbose=False, returnfp=False):
+    outarray = MkTempFile()
     packform = PackFoxFile(infiles, outarray, dirlistfromtxt, fmttype, compression, compresswholefile,
                               compressionlevel, compressionuselist, followlink, checksumtype, extradata, formatspecs, verbose, True)
-    listfoxfiles = RePackFoxFile(outarray, outfile, fmttype, compression, compresswholefile,
-                                     compressionlevel, checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp)
-    return listfoxfiles
+    listarrayfiles = RePackFoxFile(outarray, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, filestart, seekstart, seekend,
+                                     checksumtype, skipchecksum, extradata, jsondata, formatspecs, seektoend, verbose, returnfp)
+    return listarrayfiles
 
 
-def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, preservepermissions=True, preservetime=True, seektoend=False, verbose=False, returnfp=False):
+def UnPackFoxFile(infile, outdir=None, followlink=False, filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, preservepermissions=True, preservetime=True, seektoend=False, verbose=False, returnfp=False):
     if(outdir is not None):
         outdir = RemoveWindowsPath(outdir)
     if(verbose):
         logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
     if(isinstance(infile, dict)):
-        listfoxfiles = infile
+        listarrayfiles = infile
     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)
-        listfoxfiles = FoxFileToArray(infile, "auto", seekstart, seekend, False, True, skipchecksum, formatspecs, seektoend, returnfp)
-    if(not listfoxfiles):
+        listarrayfiles = FoxFileToArray(infile, "auto", filestart, seekstart, seekend, False, True, skipchecksum, formatspecs, seektoend, returnfp)
+    if(not listarrayfiles):
         return False
-    lenlist = len(listfoxfiles['ffilelist'])
-    fnumfiles = int(listfoxfiles['fnumfiles'])
+    lenlist = len(listarrayfiles['ffilelist'])
+    fnumfiles = int(listarrayfiles['fnumfiles'])
     lcfi = 0
-    lcfx = int(listfoxfiles['fnumfiles'])
-    if(lenlist > listfoxfiles['fnumfiles'] or lenlist < listfoxfiles['fnumfiles']):
+    lcfx = int(listarrayfiles['fnumfiles'])
+    if(lenlist > listarrayfiles['fnumfiles'] or lenlist < listarrayfiles['fnumfiles']):
         lcfx = int(lenlist)
     else:
-        lcfx = int(listfoxfiles['fnumfiles'])
+        lcfx = int(listarrayfiles['fnumfiles'])
     while(lcfi < lcfx):
         funame = ""
         try:
             import pwd
             try:
                 userinfo = pwd.getpwuid(
-                    listfoxfiles['ffilelist'][lcfi]['fuid'])
+                    listarrayfiles['ffilelist'][lcfi]['fuid'])
                 funame = userinfo.pw_name
             except KeyError:
                 funame = ""
@@ -8399,7 +8054,7 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
             import grp
             try:
                 groupinfo = grp.getgrgid(
-                    listfoxfiles['ffilelist'][lcfi]['fgid'])
+                    listarrayfiles['ffilelist'][lcfi]['fgid'])
                 fgname = groupinfo.gr_name
             except KeyError:
                 fgname = ""
@@ -8407,15 +8062,15 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
             fgname = ""
         if(verbose):
             VerbosePrintOut(PrependPath(
-                outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 0 or listfoxfiles['ffilelist'][lcfi]['ftype'] == 7):
-            with open(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
-                if(not listfoxfiles['ffilelist'][lcfi]['fcontentasfile']):
-                    listfoxfiles['ffilelist'][lcfi]['fcontents'] = BytesIO(
-                        listfoxfiles['ffilelist'][lcfi]['fcontents'])
-                listfoxfiles['ffilelist'][lcfi]['fcontents'].seek(0, 0)
+                outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 0 or listarrayfiles['ffilelist'][lcfi]['ftype'] == 7):
+            with open(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
+                if(not listarrayfiles['ffilelist'][lcfi]['fcontentasfile']):
+                    listarrayfiles['ffilelist'][lcfi]['fcontents'] = MkTempFile(
+                        listarrayfiles['ffilelist'][lcfi]['fcontents'])
+                listarrayfiles['ffilelist'][lcfi]['fcontents'].seek(0, 0)
                 shutil.copyfileobj(
-                    listfoxfiles['ffilelist'][lcfi]['fcontents'], fpc)
+                    listarrayfiles['ffilelist'][lcfi]['fcontents'], fpc)
                 try:
                     fpc.flush()
                     if(hasattr(os, "sync")):
@@ -8426,20 +8081,20 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
                     pass
                 except OSError:
                     pass
-            if(hasattr(os, "chown") and funame == listfoxfiles['ffilelist'][lcfi]['funame'] and fgname == listfoxfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
-                os.chown(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']),
-                         listfoxfiles['ffilelist'][lcfi]['fuid'], listfoxfiles['ffilelist'][lcfi]['fgid'])
+            if(hasattr(os, "chown") and funame == listarrayfiles['ffilelist'][lcfi]['funame'] and fgname == listarrayfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
+                os.chown(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']),
+                         listarrayfiles['ffilelist'][lcfi]['fuid'], listarrayfiles['ffilelist'][lcfi]['fgid'])
             if(preservepermissions):
                 os.chmod(PrependPath(
-                    outdir, listfoxfiles['ffilelist'][lcfi]['fname']), listfoxfiles['ffilelist'][lcfi]['fchmode'])
+                    outdir, listarrayfiles['ffilelist'][lcfi]['fname']), listarrayfiles['ffilelist'][lcfi]['fchmode'])
             if(preservetime):
-                os.utime(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), (
-                    listfoxfiles['ffilelist'][lcfi]['fatime'], listfoxfiles['ffilelist'][lcfi]['fmtime']))
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 1):
+                os.utime(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), (
+                    listarrayfiles['ffilelist'][lcfi]['fatime'], listarrayfiles['ffilelist'][lcfi]['fmtime']))
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 1):
             if(followlink):
-                getflinkpath = listfoxfiles['ffilelist'][lcfi]['flinkname']
-                flinkid = prelistfoxfiles['filetoid'][getflinkpath]
-                flinkinfo = listfoxfiles['ffilelist'][flinkid]
+                getflinkpath = listarrayfiles['ffilelist'][lcfi]['flinkname']
+                flinkid = prelistarrayfiles['filetoid'][getflinkpath]
+                flinkinfo = listarrayfiles['ffilelist'][flinkid]
                 funame = ""
                 try:
                     import pwd
@@ -8461,9 +8116,9 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
                 except ImportError:
                     fgname = ""
                 if(flinkinfo['ftype'] == 0 or flinkinfo['ftype'] == 7):
-                    with open(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
+                    with open(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
                         if(not flinkinfo['fcontentasfile']):
-                            flinkinfo['fcontents'] = BytesIO(
+                            flinkinfo['fcontents'] = MkTempFile(
                                 flinkinfo['fcontents'])
                         flinkinfo['fcontents'].seek(0, 0)
                         shutil.copyfileobj(flinkinfo['fcontents'], fpc)
@@ -8479,46 +8134,46 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
                             pass
                     if(hasattr(os, "chown") and funame == flinkinfo['funame'] and fgname == flinkinfo['fgname'] and preservepermissions):
                         os.chown(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
                     if(preservepermissions):
                         os.chmod(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
                     if(preservetime):
-                        os.utime(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), (
+                        os.utime(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), (
                             flinkinfo['fatime'], flinkinfo['fmtime']))
                 if(flinkinfo['ftype'] == 1):
                     os.link(flinkinfo['flinkname'], PrependPath(
-                        outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
+                        outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
                 if(flinkinfo['ftype'] == 2):
                     os.symlink(flinkinfo['flinkname'], PrependPath(
-                        outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
+                        outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
                 if(flinkinfo['ftype'] == 5):
                     if(preservepermissions):
                         os.mkdir(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
                     else:
                         os.mkdir(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
                     if(hasattr(os, "chown") and funame == flinkinfo['funame'] and fgname == flinkinfo['fgname'] and preservepermissions):
                         os.chown(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
                     if(preservepermissions):
                         os.chmod(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
                     if(preservetime):
-                        os.utime(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), (
+                        os.utime(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), (
                             flinkinfo['fatime'], flinkinfo['fmtime']))
                 if(flinkinfo['ftype'] == 6 and hasattr(os, "mkfifo")):
                     os.mkfifo(PrependPath(
-                        outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
+                        outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
             else:
-                os.link(listfoxfiles['ffilelist'][lcfi]['flinkname'], PrependPath(
-                    outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 2):
+                os.link(listarrayfiles['ffilelist'][lcfi]['flinkname'], PrependPath(
+                    outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 2):
             if(followlink):
-                getflinkpath = listfoxfiles['ffilelist'][lcfi]['flinkname']
-                flinkid = prelistfoxfiles['filetoid'][getflinkpath]
-                flinkinfo = listfoxfiles['ffilelist'][flinkid]
+                getflinkpath = listarrayfiles['ffilelist'][lcfi]['flinkname']
+                flinkid = prelistarrayfiles['filetoid'][getflinkpath]
+                flinkinfo = listarrayfiles['ffilelist'][flinkid]
                 funame = ""
                 try:
                     import pwd
@@ -8540,9 +8195,9 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
                 except ImportError:
                     fgname = ""
                 if(flinkinfo['ftype'] == 0 or flinkinfo['ftype'] == 7):
-                    with open(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
+                    with open(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
                         if(not flinkinfo['fcontentasfile']):
-                            flinkinfo['fcontents'] = BytesIO(
+                            flinkinfo['fcontents'] = MkTempFile(
                                 flinkinfo['fcontents'])
                         flinkinfo['fcontents'].seek(0, 0)
                         shutil.copyfileobj(flinkinfo['fcontents'], fpc)
@@ -8558,71 +8213,71 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0,
                             pass
                     if(hasattr(os, "chown") and funame == flinkinfo['funame'] and fgname == flinkinfo['fgname'] and preservepermissions):
                         os.chown(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
                     if(preservepermissions):
                         os.chmod(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
                     if(preservetime):
-                        os.utime(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), (
+                        os.utime(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), (
                             flinkinfo['fatime'], flinkinfo['fmtime']))
                 if(flinkinfo['ftype'] == 1):
                     os.link(flinkinfo['flinkname'], PrependPath(
-                        outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
+                        outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
                 if(flinkinfo['ftype'] == 2):
                     os.symlink(flinkinfo['flinkname'], PrependPath(
-                        outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
+                        outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
                 if(flinkinfo['ftype'] == 5):
                     if(preservepermissions):
                         os.mkdir(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
                     else:
                         os.mkdir(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
                     if(hasattr(os, "chown") and funame == flinkinfo['funame'] and fgname == flinkinfo['fgname'] and preservepermissions):
                         os.chown(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
                     if(preservepermissions):
                         os.chmod(PrependPath(
-                            outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
+                            outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
                     if(preservetime):
-                        os.utime(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), (
+                        os.utime(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), (
                             flinkinfo['fatime'], flinkinfo['fmtime']))
                 if(flinkinfo['ftype'] == 6 and hasattr(os, "mkfifo")):
                     os.mkfifo(PrependPath(
-                        outdir, listfoxfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
+                        outdir, listarrayfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
             else:
-                os.symlink(listfoxfiles['ffilelist'][lcfi]['flinkname'], PrependPath(
-                    outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 5):
+                os.symlink(listarrayfiles['ffilelist'][lcfi]['flinkname'], PrependPath(
+                    outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 5):
             if(preservepermissions):
                 os.mkdir(PrependPath(
-                    outdir, listfoxfiles['ffilelist'][lcfi]['fname']), listfoxfiles['ffilelist'][lcfi]['fchmode'])
+                    outdir, listarrayfiles['ffilelist'][lcfi]['fname']), listarrayfiles['ffilelist'][lcfi]['fchmode'])
             else:
                 os.mkdir(PrependPath(
-                    outdir, listfoxfiles['ffilelist'][lcfi]['fname']))
-            if(hasattr(os, "chown") and funame == listfoxfiles['ffilelist'][lcfi]['funame'] and fgname == listfoxfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
-                os.chown(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']),
-                         listfoxfiles['ffilelist'][lcfi]['fuid'], listfoxfiles['ffilelist'][lcfi]['fgid'])
+                    outdir, listarrayfiles['ffilelist'][lcfi]['fname']))
+            if(hasattr(os, "chown") and funame == listarrayfiles['ffilelist'][lcfi]['funame'] and fgname == listarrayfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
+                os.chown(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']),
+                         listarrayfiles['ffilelist'][lcfi]['fuid'], listarrayfiles['ffilelist'][lcfi]['fgid'])
             if(preservepermissions):
                 os.chmod(PrependPath(
-                    outdir, listfoxfiles['ffilelist'][lcfi]['fname']), listfoxfiles['ffilelist'][lcfi]['fchmode'])
+                    outdir, listarrayfiles['ffilelist'][lcfi]['fname']), listarrayfiles['ffilelist'][lcfi]['fchmode'])
             if(preservetime):
-                os.utime(PrependPath(outdir, listfoxfiles['ffilelist'][lcfi]['fname']), (
-                    listfoxfiles['ffilelist'][lcfi]['fatime'], listfoxfiles['ffilelist'][lcfi]['fmtime']))
-        if(listfoxfiles['ffilelist'][lcfi]['ftype'] == 6 and hasattr(os, "mkfifo")):
+                os.utime(PrependPath(outdir, listarrayfiles['ffilelist'][lcfi]['fname']), (
+                    listarrayfiles['ffilelist'][lcfi]['fatime'], listarrayfiles['ffilelist'][lcfi]['fmtime']))
+        if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 6 and hasattr(os, "mkfifo")):
             os.mkfifo(PrependPath(
-                outdir, listfoxfiles['ffilelist'][lcfi]['fname']), listfoxfiles['ffilelist'][lcfi]['fchmode'])
+                outdir, listarrayfiles['ffilelist'][lcfi]['fname']), listarrayfiles['ffilelist'][lcfi]['fchmode'])
         lcfi = lcfi + 1
     if(returnfp):
-        return listfoxfiles['ffilelist']['fp']
+        return listarrayfiles['ffilelist']['fp']
     else:
         return True
 
 
 def UnPackFoxFileString(instr, outdir=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
-    fp = BytesIO(instr)
-    listfoxfiles = UnPackFoxFile(fp, outdir, followlink, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, returnfp)
-    return listfoxfiles
+    fp = MkTempFile(instr)
+    listarrayfiles = UnPackFoxFile(fp, outdir, followlink, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, returnfp)
+    return listarrayfiles
 
 def ftype_to_str(ftype):
     mapping = {
@@ -8639,71 +8294,71 @@ def ftype_to_str(ftype):
     # Default to "file" if unknown
     return mapping.get(ftype, "file")
 
-def FoxFileListFiles(infile, fmttype="auto", seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, newstyle=False, returnfp=False):
+def FoxFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, newstyle=False, returnfp=False):
     if(verbose):
         logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
     if(isinstance(infile, dict)):
-        listarchivefiles = infile
+        listarrayfiles = infile
     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)
-        listarchivefiles = FoxFileToArray(infile, fmttype, seekstart, seekend, True, False, False, skipchecksum, formatspecs, seektoend, returnfp)
-    if(not listarchivefiles):
+        listarrayfiles = FoxFileToArray(infile, fmttype, filestart, seekstart, seekend, True, False, False, skipchecksum, formatspecs, seektoend, returnfp)
+    if(not listarrayfiles):
         return False
-    lenlist = len(listarchivefiles['ffilelist'])
-    fnumfiles = int(listarchivefiles['fnumfiles'])
+    lenlist = len(listarrayfiles['ffilelist'])
+    fnumfiles = int(listarrayfiles['fnumfiles'])
     lcfi = 0
-    lcfx = int(listarchivefiles['fnumfiles'])
-    if(lenlist > listarchivefiles['fnumfiles'] or lenlist < listarchivefiles['fnumfiles']):
+    lcfx = int(listarrayfiles['fnumfiles'])
+    if(lenlist > listarrayfiles['fnumfiles'] or lenlist < listarrayfiles['fnumfiles']):
         lcfx = int(lenlist)
     else:
-        lcfx = int(listarchivefiles['fnumfiles'])
+        lcfx = int(listarrayfiles['fnumfiles'])
     returnval = {}
     while(lcfi < lcfx):
-        returnval.update({lcfi: listarchivefiles['ffilelist'][lcfi]['fname']})
+        returnval.update({lcfi: listarrayfiles['ffilelist'][lcfi]['fname']})
         if(not verbose):
-            VerbosePrintOut(listarchivefiles['ffilelist'][lcfi]['fname'])
+            VerbosePrintOut(listarrayfiles['ffilelist'][lcfi]['fname'])
         if(verbose):
             permissions = {'access': {'0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': (
                 'r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx')}, 'roles': {0: 'owner', 1: 'group', 2: 'other'}}
-            printfname = listarchivefiles['ffilelist'][lcfi]['fname']
-            if(listarchivefiles['ffilelist'][lcfi]['ftype'] == 1):
-                printfname = listarchivefiles['ffilelist'][lcfi]['fname'] + \
-                    " link to " + listarchivefiles['ffilelist'][lcfi]['flinkname']
-            if(listarchivefiles['ffilelist'][lcfi]['ftype'] == 2):
-                printfname = listarchivefiles['ffilelist'][lcfi]['fname'] + \
-                    " -> " + listarchivefiles['ffilelist'][lcfi]['flinkname']
-            fuprint = listarchivefiles['ffilelist'][lcfi]['funame']
+            printfname = listarrayfiles['ffilelist'][lcfi]['fname']
+            if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 1):
+                printfname = listarrayfiles['ffilelist'][lcfi]['fname'] + \
+                    " link to " + listarrayfiles['ffilelist'][lcfi]['flinkname']
+            if(listarrayfiles['ffilelist'][lcfi]['ftype'] == 2):
+                printfname = listarrayfiles['ffilelist'][lcfi]['fname'] + \
+                    " -> " + listarrayfiles['ffilelist'][lcfi]['flinkname']
+            fuprint = listarrayfiles['ffilelist'][lcfi]['funame']
             if(len(fuprint) <= 0):
-                fuprint = listarchivefiles['ffilelist'][lcfi]['fuid']
-            fgprint = listarchivefiles['ffilelist'][lcfi]['fgname']
+                fuprint = listarrayfiles['ffilelist'][lcfi]['fuid']
+            fgprint = listarrayfiles['ffilelist'][lcfi]['fgname']
             if(len(fgprint) <= 0):
-                fgprint = listarchivefiles['ffilelist'][lcfi]['fgid']
+                fgprint = listarrayfiles['ffilelist'][lcfi]['fgid']
             if(newstyle):
-                VerbosePrintOut(ftype_to_str(listarchivefiles['ffilelist'][lcfi]['ftype']) + "\t" + listarchivefiles['ffilelist'][lcfi]['fcompression'] + "\t" + str(
-                listarchivefiles['ffilelist'][lcfi]['fsize']).rjust(15) + "\t" + printfname)
+                VerbosePrintOut(ftype_to_str(listarrayfiles['ffilelist'][lcfi]['ftype']) + "\t" + listarrayfiles['ffilelist'][lcfi]['fcompression'] + "\t" + str(
+                listarrayfiles['ffilelist'][lcfi]['fsize']).rjust(15) + "\t" + printfname)
             else:
-                VerbosePrintOut(PrintPermissionString(listarchivefiles['ffilelist'][lcfi]['fmode'], listarchivefiles['ffilelist'][lcfi]['ftype']) + " " + str(fuprint) + "/" + str(fgprint) + " " + str(
-                listarchivefiles['ffilelist'][lcfi]['fsize']).rjust(15) + " " + datetime.datetime.utcfromtimestamp(listarchivefiles['ffilelist'][lcfi]['fmtime']).strftime('%Y-%m-%d %H:%M') + " " + printfname)
+                VerbosePrintOut(PrintPermissionString(listarrayfiles['ffilelist'][lcfi]['fmode'], listarrayfiles['ffilelist'][lcfi]['ftype']) + " " + str(fuprint) + "/" + str(fgprint) + " " + str(
+                listarrayfiles['ffilelist'][lcfi]['fsize']).rjust(15) + " " + datetime.datetime.utcfromtimestamp(listarrayfiles['ffilelist'][lcfi]['fmtime']).strftime('%Y-%m-%d %H:%M') + " " + printfname)
         lcfi = lcfi + 1
     if(returnfp):
-        return listarchivefiles['fp']
+        return listarrayfiles['fp']
     else:
         return True
 
 
 def FoxFileStringListFiles(instr, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, newstyle=False, returnfp=False):
-    fp = BytesIO(instr)
-    listfoxfiles = FoxFileListFiles(
+    fp = MkTempFile(instr)
+    listarrayfiles = FoxFileListFiles(
         instr, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, newstyle, returnfp)
-    return listfoxfiles
+    return listarrayfiles
 
 
 def TarFileListFiles(infile, verbose=False, returnfp=False):
     if(verbose):
         logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
     if(infile == "-"):
-        infile = BytesIO()
+        infile = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, infile)
         else:
@@ -8712,7 +8367,7 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
         if(not infile):
             return False
         infile.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
+    elif(re.findall(__download_proto_support__, infile)):
         infile = download_file_from_internet_file(infile)
         infile.seek(0, 0)
         if(not infile):
@@ -8736,7 +8391,7 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
                 return False
     try:
         if(hasattr(infile, "read") or hasattr(infile, "write")):
-            compresscheck = CheckCompressionType(infile, formatspecs, False)
+            compresscheck = CheckCompressionType(infile, formatspecs, 0, False)
             if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
                 formatspecs = formatspecs[compresscheck]
             if(compresscheck=="zstd"):
@@ -8748,7 +8403,7 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
             else:
                 tarfp = tarfile.open(fileobj=infile, mode="r")
         else:
-            compresscheck = CheckCompressionType(infile, formatspecs, True)
+            compresscheck = CheckCompressionType(infile, formatspecs, 0, True)
             if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
                 formatspecs = formatspecs[compresscheck]
             if(compresscheck=="zstd"):
@@ -8819,7 +8474,7 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
                 member.size).rjust(15) + " " + datetime.datetime.utcfromtimestamp(member.mtime).strftime('%Y-%m-%d %H:%M') + " " + printfname)
         lcfi = lcfi + 1
     if(returnfp):
-        return listfoxfiles['fp']
+        return listarrayfiles['fp']
     else:
         return True
 
@@ -8828,7 +8483,7 @@ def ZipFileListFiles(infile, verbose=False, returnfp=False):
     if(verbose):
         logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
     if(infile == "-"):
-        infile = BytesIO()
+        infile = MkTempFile()
         if(hasattr(sys.stdin, "buffer")):
             shutil.copyfileobj(sys.stdin.buffer, infile)
         else:
@@ -8837,7 +8492,7 @@ def ZipFileListFiles(infile, verbose=False, returnfp=False):
         if(not infile):
             return False
         infile.seek(0, 0)
-    elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", infile)):
+    elif(re.findall(__download_proto_support__, infile)):
         infile = download_file_from_internet_file(infile)
         infile.seek(0, 0)
         if(not infile):
@@ -8952,7 +8607,7 @@ def ZipFileListFiles(infile, verbose=False, returnfp=False):
                 15) + " " + datetime.datetime.utcfromtimestamp(int(time.mktime(member.date_time + (0, 0, -1)))).strftime('%Y-%m-%d %H:%M') + " " + printfname)
         lcfi = lcfi + 1
     if(returnfp):
-        return listfoxfiles['fp']
+        return listarrayfiles['fp']
     else:
         return True
 
@@ -9090,7 +8745,7 @@ if(rarfile_support):
                     member.file_size).rjust(15) + " " + member.mtime.strftime('%Y-%m-%d %H:%M') + " " + printfname)
             lcfi = lcfi + 1
         if(returnfp):
-            return listfoxfiles['fp']
+            return listarrayfiles['fp']
         else:
             return True
 
@@ -9108,7 +8763,7 @@ if(py7zr_support):
         returnval = {}
         szpfp = py7zr.SevenZipFile(infile, mode="r")
         file_content = szpfp.readall()
-        #sztest = szpfp.testzip();
+        #sztest = szpfp.testzip()
         sztestalt = szpfp.test()
         if(sztestalt):
             VerbosePrintOut("Bad file found!")
@@ -9197,7 +8852,7 @@ if(py7zr_support):
                     fsize).rjust(15) + " " + member.creationtime.strftime('%Y-%m-%d %H:%M') + " " + printfname)
             lcfi = lcfi + 1
         if(returnfp):
-            return listfoxfiles['fp']
+            return listarrayfiles['fp']
         else:
             return True
 
@@ -9205,7 +8860,7 @@ if(py7zr_support):
 def InFileListFiles(infile, verbose=False, formatspecs=__file_format_multi_dict__, seektoend=False, newstyle=False, returnfp=False):
     if(verbose):
         logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG)
-    checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
+    checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
     if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
@@ -9224,12 +8879,12 @@ def InFileListFiles(infile, verbose=False, formatspecs=__file_format_multi_dict_
 
 
 def ListDirListFiles(infiles, dirlistfromtxt=False, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, checksumtype=["crc32", "crc32", "crc32"], formatspecs=__file_format_dict__, seektoend=False, verbose=False, returnfp=False):
-    outarray = BytesIO()
+    outarray = MkTempFile()
     packform = PackFoxFile(infiles, outarray, dirlistfromtxt, compression, compresswholefile,
                               compressionlevel, followlink, checksumtype, formatspecs, False, True)
-    listfoxfiles = FoxFileListFiles(
+    listarrayfiles = FoxFileListFiles(
         outarray, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, returnfp)
-    return listfoxfiles
+    return listarrayfiles
 
 """
 PyNeoFile compatibility layer
@@ -9242,7 +8897,7 @@ def make_empty_archive_file_pointer_neo(fp, fmttype=None, checksumtype='crc32',
     return make_empty_file_pointer_neo(fp, fmttype, checksumtype, formatspecs, encoding)
 
 def make_empty_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8', returnfp=False):
-    return MakeEmptyFile(outfile, fmttype, "auto", False, None, checksumtype, formatspecs, returnfp)
+    return MakeEmptyFile(outfile, fmttype, "auto", False, None, compressionlistalt, checksumtype, formatspecs, returnfp)
 
 def make_empty_archive_file_neo(outfile=None, fmttype=None, checksumtype='crc32', formatspecs=__file_format_multi_dict__, encoding='UTF-8', returnfp=False):
     return make_empty_file_neo(outfile, fmttype, checksumtype, formatspecs, encoding, returnfp)
@@ -9251,7 +8906,7 @@ def pack_neo(infiles, outfile=None, formatspecs=__file_format_multi_dict__, chec
     return PackFoxFile(infiles, outfile, False, "auto", compression, False, compression_level, compressionlistalt, False, checksumtypes, [], {}, formatspecs, False, returnfp)
 
 def archive_to_array_neo(infile, formatspecs=__file_format_multi_dict__, listonly=False, skipchecksum=False, uncompress=True, returnfp=False):
-    return FoxFileToArray(infile, "auto", 0, 0, listonly, True, uncompress, skipchecksum, formatspecs, False, returnfp)
+    return FoxFileToArray(infile, "auto", 0, 0, 0, listonly, True, uncompress, skipchecksum, formatspecs, False, returnfp)
 
 def unpack_neo(infile, outdir='.', formatspecs=__file_format_multi_dict__, skipchecksum=False, uncompress=True, returnfp=False):
     return UnPackFoxFile(infile, outdir, False, 0, 0, skipchecksum, formatspecs, True, True, False, False, returnfp)
@@ -9266,13 +8921,26 @@ def archivefilelistfiles_neo(infile, formatspecs=__file_format_multi_dict__, adv
     return FoxFileListFiles(infile, "auto", 0, 0, False, formatspecs, False, True, advanced, returnfp)
 
 def convert_foreign_to_neo(infile, outfile=None, formatspecs=__file_format_multi_dict__, checksumtypes=["crc32", "crc32", "crc32", "crc32"], compression="auto", compression_level=None, returnfp=False):
-    intmp = InFileToArray(infile, 0, 0, False, True, False, formatspecs, False, False)
+    intmp = InFileToArray(infile, 0, 0, 0, False, True, False, formatspecs, False, False)
     return RePackFoxFile(intmp, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
 
+def detect_cwd(ftp, file_dir):
+    """
+    Test whether cwd into file_dir works. Returns True if it does,
+    False if not (so absolute paths should be used).
+    """
+    if not file_dir or file_dir in ("/", ""):
+        return False  # nothing to cwd into
+    try:
+        ftp.cwd(file_dir)
+        return True
+    except all_errors:
+        return False
+
 def download_file_from_ftp_file(url):
     urlparts = urlparse(url)
-    file_name = os.path.basename(urlparts.path)
-    file_dir = os.path.dirname(urlparts.path)
+    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
     else:
@@ -9289,7 +8957,7 @@ def download_file_from_ftp_file(url):
         ftp = FTP_TLS()
     else:
         return False
-    if(urlparts.scheme == "sftp"):
+    if(urlparts.scheme == "sftp" or urlparts.scheme == "scp"):
         if(__use_pysftp__):
             return download_file_from_pysftp_file(url)
         else:
@@ -9307,26 +8975,70 @@ def download_file_from_ftp_file(url):
     except socket.timeout:
         log.info("Error With URL "+url)
         return False
-    ftp.login(urlparts.username, urlparts.password)
-    if(urlparts.scheme == "ftps"):
-        ftp.prot_p()
-    ftpfile = BytesIO()
-    ftp.retrbinary("RETR "+urlparts.path, ftpfile.write)
-    #ftp.storbinary("STOR "+urlparts.path, ftpfile.write);
+    if(urlparts.scheme == "ftps" or isinstance(ftp, FTP_TLS)):
+        try:
+            ftp.auth()
+        except all_errors:
+            pass
+    ftp.login(ftp_username, ftp_password)
+    if(urlparts.scheme == "ftps" or isinstance(ftp, FTP_TLS)):
+        try:
+            ftp.prot_p()
+        except all_errors:
+            ftp.prot_c()
+    # UTF-8 filenames if supported
+    try:
+        ftp.sendcmd("OPTS UTF8 ON")
+        ftp.encoding = "utf-8"
+    except all_errors:
+        pass
+    is_cwd_allowed = detect_cwd(ftp, file_dir)
+    ftpfile = MkTempFile()
+    # Try EPSV first, then fall back
+    try:
+        ftp.force_epsv = True
+        ftp.sendcmd("EPSV")   # request extended passive
+        if(is_cwd_allowed):
+            ftp.retrbinary("RETR "+file_name, ftpfile.write)
+        else:
+            ftp.retrbinary("RETR "+unquote(urlparts.path), ftpfile.write)
+    except all_errors:
+        try:
+            ftp.set_pasv(True)
+            if(is_cwd_allowed):
+                ftp.retrbinary("RETR "+file_name, ftpfile.write)
+            else:
+                ftp.retrbinary("RETR "+unquote(urlparts.path), ftpfile.write)
+        except all_errors:
+            ftp.set_pasv(False)
+            if(is_cwd_allowed):
+                ftp.retrbinary("RETR "+file_name, ftpfile.write)
+            else:
+                ftp.retrbinary("RETR "+unquote(urlparts.path), ftpfile.write)
     ftp.close()
     ftpfile.seek(0, 0)
     return ftpfile
 
 
+def download_file_from_ftps_file(url):
+    return download_file_from_ftp_file(url)
+
+
 def download_file_from_ftp_string(url):
     ftpfile = download_file_from_ftp_file(url)
-    return ftpfile.read()
+    ftpout = ftpfile.read()
+    ftpfile.close()
+    return ftpout
+
+
+def download_file_from_ftps_string(url):
+    return download_file_from_ftp_string(url)
 
 
 def upload_file_to_ftp_file(ftpfile, url):
     urlparts = urlparse(url)
-    file_name = os.path.basename(urlparts.path)
-    file_dir = os.path.dirname(urlparts.path)
+    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
     else:
@@ -9343,7 +9055,7 @@ def upload_file_to_ftp_file(ftpfile, url):
         ftp = FTP_TLS()
     else:
         return False
-    if(urlparts.scheme == "sftp"):
+    if(urlparts.scheme == "sftp" or urlparts.scheme == "scp"):
         if(__use_pysftp__):
             return upload_file_to_pysftp_file(url)
         else:
@@ -9361,22 +9073,66 @@ def upload_file_to_ftp_file(ftpfile, url):
     except socket.timeout:
         log.info("Error With URL "+url)
         return False
-    ftp.login(urlparts.username, urlparts.password)
-    if(urlparts.scheme == "ftps"):
-        ftp.prot_p()
-    ftp.storbinary("STOR "+urlparts.path, ftpfile)
+    if(urlparts.scheme == "ftps" or isinstance(ftp, FTP_TLS)):
+        try:
+            ftp.auth()
+        except all_errors:
+            pass
+    ftp.login(ftp_username, ftp_password)
+    if(urlparts.scheme == "ftps" or isinstance(ftp, FTP_TLS)):
+        try:
+            ftp.prot_p()
+        except all_errors:
+            ftp.prot_c()
+    # UTF-8 filenames if supported
+    try:
+        ftp.sendcmd("OPTS UTF8 ON")
+        ftp.encoding = "utf-8"
+    except all_errors:
+        pass
+    is_cwd_allowed = detect_cwd(ftp, file_dir)
+    ftpfile.seek(0, 0)
+    # Try EPSV first, then fall back
+    try:
+        ftp.force_epsv = True
+        ftp.sendcmd("EPSV")   # request extended passive
+        if(is_cwd_allowed):
+            ftp.storbinary("STOR "+file_name, ftpfile)
+        else:
+            ftp.storbinary("STOR "+unquote(urlparts.path), ftpfile)
+    except all_errors:
+        try:
+            ftp.set_pasv(True)
+            if(is_cwd_allowed):
+                ftp.storbinary("STOR "+file_name, ftpfile)
+            else:
+                ftp.storbinary("STOR "+unquote(urlparts.path), ftpfile)
+        except all_errors:
+            ftp.set_pasv(False)
+            if(is_cwd_allowed):
+                ftp.storbinary("STOR "+file_name, ftpfile)
+            else:
+                ftp.storbinary("STOR "+unquote(urlparts.path), ftpfile)
     ftp.close()
     ftpfile.seek(0, 0)
     return ftpfile
 
 
+def upload_file_to_ftps_file(ftpfile, url):
+    return upload_file_to_ftp_file(ftpfile, url)
+
+
 def upload_file_to_ftp_string(ftpstring, url):
-    ftpfileo = BytesIO(ftpstring)
+    ftpfileo = MkTempFile(ftpstring)
     ftpfile = upload_file_to_ftp_file(ftpfileo, url)
     ftpfileo.close()
     return ftpfile
 
 
+def upload_file_to_ftps_string(ftpstring, url):
+    return upload_file_to_ftp_string(ftpstring, url)
+
+
 class RawIteratorWrapper:
     def __init__(self, iterator):
         self.iterator = iterator
@@ -9414,7 +9170,7 @@ def download_file_from_http_file(url, headers=None, usehttp=__use_http_lib__):
                               urlparts.params, urlparts.query, urlparts.fragment))
 
     # Handle SFTP/FTP
-    if urlparts.scheme == "sftp":
+    if urlparts.scheme == "sftp" or urlparts.scheme == "scp":
         if __use_pysftp__:
             return download_file_from_pysftp_file(url)
         else:
@@ -9423,7 +9179,7 @@ def download_file_from_http_file(url, headers=None, usehttp=__use_http_lib__):
         return download_file_from_ftp_file(url)
 
     # Create a temporary file object
-    httpfile = BytesIO()
+    httpfile = MkTempFile()
 
     # 1) Requests branch
     if usehttp == 'requests' and haverequests:
@@ -9487,14 +9243,16 @@ def download_file_from_http_file(url, headers=None, usehttp=__use_http_lib__):
 
 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)
-    return httpfile.read()
+    httpout = httpfile.read()
+    httpfile.close()
+    return httpout
 
 
 if(haveparamiko):
     def download_file_from_sftp_file(url):
         urlparts = urlparse(url)
-        file_name = os.path.basename(urlparts.path)
-        file_dir = os.path.dirname(urlparts.path)
+        file_name = os.path.basename(unquote(urlparts.path))
+        file_dir = os.path.dirname(unquote(urlparts.path))
         sftp_port = urlparts.port
         if(urlparts.port is None):
             sftp_port = 22
@@ -9514,14 +9272,14 @@ if(haveparamiko):
             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"):
+        if(urlparts.scheme != "sftp" and urlparts.scheme != "scp"):
             return False
         ssh = paramiko.SSHClient()
         ssh.load_system_host_keys()
         ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
         try:
             ssh.connect(urlparts.hostname, port=sftp_port,
-                        username=urlparts.username, password=urlparts.password)
+                        username=sftp_username, password=urlparts.password)
         except paramiko.ssh_exception.SSHException:
             return False
         except socket.gaierror:
@@ -9531,8 +9289,8 @@ if(haveparamiko):
             log.info("Error With URL "+url)
             return False
         sftp = ssh.open_sftp()
-        sftpfile = BytesIO()
-        sftp.getfo(urlparts.path, sftpfile)
+        sftpfile = MkTempFile()
+        sftp.getfo(unquote(urlparts.path), sftpfile)
         sftp.close()
         ssh.close()
         sftpfile.seek(0, 0)
@@ -9544,7 +9302,9 @@ else:
 if(haveparamiko):
     def download_file_from_sftp_string(url):
         sftpfile = download_file_from_sftp_file(url)
-        return sftpfile.read()
+        sftpout = sftpfile.read()
+        sftpfile.close()
+        return sftpout
 else:
     def download_file_from_sftp_string(url):
         return False
@@ -9552,8 +9312,8 @@ else:
 if(haveparamiko):
     def upload_file_to_sftp_file(sftpfile, url):
         urlparts = urlparse(url)
-        file_name = os.path.basename(urlparts.path)
-        file_dir = os.path.dirname(urlparts.path)
+        file_name = os.path.basename(unquote(urlparts.path))
+        file_dir = os.path.dirname(unquote(urlparts.path))
         sftp_port = urlparts.port
         if(urlparts.port is None):
             sftp_port = 22
@@ -9570,17 +9330,17 @@ if(haveparamiko):
         else:
             sftp_password = ""
         if(urlparts.scheme == "ftp"):
-            return upload_file_to_ftp_file(url)
+            return upload_file_to_ftp_file(sftpfile, url)
         elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
             return False
-        if(urlparts.scheme != "sftp"):
+        if(urlparts.scheme != "sftp" and urlparts.scheme != "scp"):
             return False
         ssh = paramiko.SSHClient()
         ssh.load_system_host_keys()
         ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
         try:
             ssh.connect(urlparts.hostname, port=sftp_port,
-                        username=urlparts.username, password=urlparts.password)
+                        username=sftp_username, password=sftp_password)
         except paramiko.ssh_exception.SSHException:
             return False
         except socket.gaierror:
@@ -9590,7 +9350,8 @@ if(haveparamiko):
             log.info("Error With URL "+url)
             return False
         sftp = ssh.open_sftp()
-        sftp.putfo(sftpfile, urlparts.path)
+        sftpfile.seek(0, 0)
+        sftp.putfo(sftpfile, unquote(urlparts.path))
         sftp.close()
         ssh.close()
         sftpfile.seek(0, 0)
@@ -9601,7 +9362,7 @@ else:
 
 if(haveparamiko):
     def upload_file_to_sftp_string(sftpstring, url):
-        sftpfileo = BytesIO(sftpstring)
+        sftpfileo = MkTempFile(sftpstring)
         sftpfile = upload_file_to_sftp_files(sftpfileo, url)
         sftpfileo.close()
         return sftpfile
@@ -9612,8 +9373,8 @@ else:
 if(havepysftp):
     def download_file_from_pysftp_file(url):
         urlparts = urlparse(url)
-        file_name = os.path.basename(urlparts.path)
-        file_dir = os.path.dirname(urlparts.path)
+        file_name = os.path.basename(unquote(urlparts.path))
+        file_dir = os.path.dirname(unquote(urlparts.path))
         sftp_port = urlparts.port
         if(urlparts.port is None):
             sftp_port = 22
@@ -9633,11 +9394,11 @@ if(havepysftp):
             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"):
+        if(urlparts.scheme != "sftp" and urlparts.scheme != "scp"):
             return False
         try:
-            pysftp.Connection(urlparts.hostname, port=sftp_port,
-                              username=urlparts.username, password=urlparts.password)
+            sftp = pysftp.Connection(urlparts.hostname, port=sftp_port,
+                              username=sftp_username, password=sftp_password)
         except paramiko.ssh_exception.SSHException:
             return False
         except socket.gaierror:
@@ -9646,9 +9407,8 @@ if(havepysftp):
         except socket.timeout:
             log.info("Error With URL "+url)
             return False
-        sftp = ssh.open_sftp()
-        sftpfile = BytesIO()
-        sftp.getfo(urlparts.path, sftpfile)
+        sftpfile = MkTempFile()
+        sftp.getfo(unquote(urlparts.path), sftpfile)
         sftp.close()
         ssh.close()
         sftpfile.seek(0, 0)
@@ -9660,7 +9420,9 @@ else:
 if(havepysftp):
     def download_file_from_pysftp_string(url):
         sftpfile = download_file_from_pysftp_file(url)
-        return sftpfile.read()
+        sftpout = sftpfile.read()
+        sftpfile.close()
+        return sftpout
 else:
     def download_file_from_pysftp_string(url):
         return False
@@ -9668,8 +9430,8 @@ else:
 if(havepysftp):
     def upload_file_to_pysftp_file(sftpfile, url):
         urlparts = urlparse(url)
-        file_name = os.path.basename(urlparts.path)
-        file_dir = os.path.dirname(urlparts.path)
+        file_name = os.path.basename(unquote(urlparts.path))
+        file_dir = os.path.dirname(unquote(urlparts.path))
         sftp_port = urlparts.port
         if(urlparts.port is None):
             sftp_port = 22
@@ -9686,14 +9448,14 @@ if(havepysftp):
         else:
             sftp_password = ""
         if(urlparts.scheme == "ftp"):
-            return upload_file_to_ftp_file(url)
+            return upload_file_to_ftp_file(sftpfile, url)
         elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
             return False
-        if(urlparts.scheme != "sftp"):
+        if(urlparts.scheme != "sftp" and urlparts.scheme != "scp"):
             return False
         try:
-            pysftp.Connection(urlparts.hostname, port=sftp_port,
-                              username=urlparts.username, password=urlparts.password)
+            sftp = pysftp.Connection(urlparts.hostname, port=sftp_port,
+                              username=sftp_username, password=sftp_password)
         except paramiko.ssh_exception.SSHException:
             return False
         except socket.gaierror:
@@ -9702,8 +9464,8 @@ if(havepysftp):
         except socket.timeout:
             log.info("Error With URL "+url)
             return False
-        sftp = ssh.open_sftp()
-        sftp.putfo(sftpfile, urlparts.path)
+        sftpfile.seek(0, 0)
+        sftp.putfo(sftpfile, unquote(urlparts.path))
         sftp.close()
         ssh.close()
         sftpfile.seek(0, 0)
@@ -9714,7 +9476,7 @@ else:
 
 if(havepysftp):
     def upload_file_to_pysftp_string(sftpstring, url):
-        sftpfileo = BytesIO(sftpstring)
+        sftpfileo = MkTempFile(sftpstring)
         sftpfile = upload_file_to_pysftp_file(ftpfileo, url)
         sftpfileo.close()
         return sftpfile
@@ -9729,7 +9491,7 @@ def download_file_from_internet_file(url, headers=geturls_headers_pyfile_python_
         return download_file_from_http_file(url, headers, usehttp)
     elif(urlparts.scheme == "ftp" or urlparts.scheme == "ftps"):
         return download_file_from_ftp_file(url)
-    elif(urlparts.scheme == "sftp"):
+    elif(urlparts.scheme == "sftp" or urlparts.scheme == "scp"):
         if(__use_pysftp__ and havepysftp):
             return download_file_from_pysftp_file(url)
         else:
@@ -9739,9 +9501,9 @@ def download_file_from_internet_file(url, headers=geturls_headers_pyfile_python_
     return False
 
 
-def download_file_from_internet_uncompress_file(url, headers=geturls_headers_pyfile_python_alt, formatspecs=__file_format_dict__):
+def download_file_from_internet_uncompress_file(url, headers=geturls_headers_pyfile_python_alt, filestart=0, formatspecs=__file_format_dict__):
     fp = download_file_from_internet_file(url)
-    fp = UncompressFileAlt(fp, formatspecs)
+    fp = UncompressFileAlt(fp, formatspecs, filestart)
     fp.seek(0, 0)
     if(not fp):
         return False
@@ -9754,7 +9516,7 @@ def download_file_from_internet_string(url, headers=geturls_headers_pyfile_pytho
         return download_file_from_http_string(url, headers)
     elif(urlparts.scheme == "ftp" or urlparts.scheme == "ftps"):
         return download_file_from_ftp_string(url)
-    elif(urlparts.scheme == "sftp"):
+    elif(urlparts.scheme == "sftp" or urlparts.scheme == "scp"):
         if(__use_pysftp__ and havepysftp):
             return download_file_from_pysftp_string(url)
         else:
@@ -9764,13 +9526,15 @@ def download_file_from_internet_string(url, headers=geturls_headers_pyfile_pytho
     return False
 
 
-def download_file_from_internet_uncompress_string(url, headers=geturls_headers_pyfile_python_alt, formatspecs=__file_format_dict__):
+def download_file_from_internet_uncompress_string(url, headers=geturls_headers_pyfile_python_alt, filestart=0, formatspecs=__file_format_dict__):
     fp = download_file_from_internet_string(url)
-    fp = UncompressFileAlt(fp, formatspecs)
-    fp.seek(0, 0)
+    fp = UncompressFileAlt(fp, formatspecs, filestart)
     if(not fp):
         return False
-    return fp
+    fp.seek(0, 0)
+    fpout = fp.read()
+    fp.close
+    return fpout
 
 
 def upload_file_to_internet_file(ifp, url):
@@ -9779,7 +9543,7 @@ def upload_file_to_internet_file(ifp, url):
         return False
     elif(urlparts.scheme == "ftp" or urlparts.scheme == "ftps"):
         return upload_file_to_ftp_file(ifp, url)
-    elif(urlparts.scheme == "sftp"):
+    elif(urlparts.scheme == "sftp" or urlparts.scheme == "scp"):
         if(__use_pysftp__ and havepysftp):
             return upload_file_to_pysftp_file(ifp, url)
         else:
@@ -9795,8 +9559,7 @@ def upload_file_to_internet_compress_file(ifp, url, compression="auto", compress
     if(not foxfileout):
         return False
     fp.seek(0, 0)
-    upload_file_to_internet_file(fp, outfile)
-    return True
+    return upload_file_to_internet_file(fp, outfile)
 
 
 def upload_file_to_internet_string(ifp, url):
@@ -9805,7 +9568,7 @@ def upload_file_to_internet_string(ifp, url):
         return False
     elif(urlparts.scheme == "ftp" or urlparts.scheme == "ftps"):
         return upload_file_to_ftp_string(ifp, url)
-    elif(urlparts.scheme == "sftp"):
+    elif(urlparts.scheme == "sftp" or urlparts.scheme == "scp"):
         if(__use_pysftp__ and havepysftp):
             return upload_file_to_pysftp_string(ifp, url)
         else:
@@ -9816,10 +9579,10 @@ def upload_file_to_internet_string(ifp, url):
 
 
 def upload_file_to_internet_compress_string(ifp, url, compression="auto", compressionlevel=None, compressionuselist=compressionlistalt, formatspecs=__file_format_dict__):
+    internetfileo = MkTempFile(ifp)
     fp = CompressOpenFileAlt(
-        BytesIO(ifp), compression, compressionlevel, compressionuselist, formatspecs)
+        internetfileo, compression, compressionlevel, compressionuselist, formatspecs)
     if(not foxfileout):
         return False
     fp.seek(0, 0)
-    upload_file_to_internet_file(fp, outfile)
-    return True
+    return upload_file_to_internet_file(fp, outfile)