pycatfile.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 '''
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the Revised BSD License.
   7
   8     This program is distributed in the hope that it will be useful,
   9     but WITHOUT ANY WARRANTY; without even the implied warranty of
  10     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11     Revised BSD License for more details.
  12
  13     Copyright 2018-2024 Cool Dude 2k - http://idb.berlios.de/
  14     Copyright 2018-2024 Game Maker 2k - http://intdb.sourceforge.net/
  15     Copyright 2018-2024 Kazuki Przyborowski - https://github.com/KazukiPrzyborowski
  16
  17     $FileInfo: pycatfile.py - Last Update: 11/17/2024 Ver. 0.14.4 RC 1 - Author: cooldude2k $
  18 '''
  19
  20 from __future__ import absolute_import, division, print_function, unicode_literals, generators, with_statement, nested_scopes
  21 import io
  22 import os
  23 import re
  24 import sys
  25 import time
  26 import stat
  27 import zlib
  28 import base64
  29 import shutil
  30 import socket
  31 import hashlib
  32 import datetime
  33 import logging
  34 import binascii
  35 import zipfile
  36 import platform
  37 try:
  38     from backports import tempfile
  39 except ImportError:
  40     import tempfile
  41 # FTP Support
  42 ftpssl = True
  43 try:
  44     from ftplib import FTP, FTP_TLS
  45 except ImportError:
  46     ftpssl = False
  47     from ftplib import FTP
  48
  49 try:
  50     import ujson as json
  51 except ImportError:
  52     try:
  53         import simplejson as json
  54     except ImportError:
  55         import json
  56
  57 try:
  58     import configparser
  59 except ImportError:
  60     try:
  61         import SafeConfigParser as configparser
  62     except ImportError:
  63         import ConfigParser as configparser
  64
  65 try:
  66     basestring
  67 except NameError:
  68     basestring = str
  69
  70 baseint = []
  71 try:
  72     baseint.append(long)
  73     baseint.insert(0, int)
  74 except NameError:
  75     baseint.append(int)
  76 baseint = tuple(baseint)
  77
  78 # URL Parsing
  79 try:
  80     from urllib.parse import urlparse, urlunparse
  81 except ImportError:
  82     from urlparse import urlparse, urlunparse
  83
  84 # Windows-specific setup
  85 if os.name == 'nt':
  86     if sys.version_info[0] == 2:
  87         import codecs
  88         sys.stdout = codecs.getwriter('utf-8')(sys.stdout)
  89         sys.stderr = codecs.getwriter('utf-8')(sys.stderr)
  90     else:
  91         sys.stdout = io.TextIOWrapper(
  92             sys.stdout.buffer, encoding='utf-8', errors='replace', line_buffering=True)
  93         sys.stderr = io.TextIOWrapper(
  94             sys.stderr.buffer, encoding='utf-8', errors='replace', line_buffering=True)
  95
  96 hashlib_guaranteed = False
  97 # Environment setup
  98 os.environ["PYTHONIOENCODING"] = "UTF-8"
  99 os.environ["LC_CTYPE"] = "UTF-8"
 100
 101 # Reload sys to set default encoding to UTF-8 (Python 2 only)
 102 if sys.version_info[0] == 2:
 103     try:
 104         reload(sys)
 105         sys.setdefaultencoding('UTF-8')
 106     except (NameError, AttributeError):
 107         pass
 108
 109 # CRC32 import
 110 try:
 111     from zlib import crc32
 112 except ImportError:
 113     from binascii import crc32
 114
 115 # Define FileNotFoundError for Python 2
 116 try:
 117     FileNotFoundError
 118 except NameError:
 119     FileNotFoundError = IOError
 120
 121 # RAR file support
 122 rarfile_support = False
 123 try:
 124     import rarfile
 125     rarfile_support = True
 126 except ImportError:
 127     pass
 128
 129 # 7z file support
 130 py7zr_support = False
 131 try:
 132     import py7zr
 133     py7zr_support = True
 134 except ImportError:
 135     pass
 136
 137 # TAR file checking
 138 try:
 139     from xtarfile import is_tarfile
 140 except ImportError:
 141     try:
 142         from safetar import is_tarfile
 143     except ImportError:
 144         from tarfile import is_tarfile
 145
 146 # TAR file module
 147 try:
 148     import xtarfile as tarfile
 149 except ImportError:
 150     try:
 151         import safetar as tarfile
 152     except ImportError:
 153         import tarfile
 154
 155 # Paramiko support
 156 haveparamiko = False
 157 try:
 158     import paramiko
 159     haveparamiko = True
 160 except ImportError:
 161     pass
 162
 163 # PySFTP support
 164 havepysftp = False
 165 try:
 166     import pysftp
 167     havepysftp = True
 168 except ImportError:
 169     pass
 170
 171 # Requests support
 172 haverequests = False
 173 try:
 174     import requests
 175     haverequests = True
 176     import urllib3
 177     logging.getLogger("urllib3").setLevel(logging.WARNING)
 178 except ImportError:
 179     pass
 180
 181 # HTTPX support
 182 havehttpx = False
 183 try:
 184     import httpx
 185     havehttpx = True
 186     logging.getLogger("httpx").setLevel(logging.WARNING)
 187     logging.getLogger("httpcore").setLevel(logging.WARNING)
 188 except ImportError:
 189     pass
 190
 191 # HTTP and URL parsing
 192 try:
 193     from urllib.request import Request, build_opener, HTTPBasicAuthHandler
 194     from urllib.parse import urlparse
 195 except ImportError:
 196     from urllib2 import Request, build_opener, HTTPBasicAuthHandler
 197     from urlparse import urlparse
 198
 199 # StringIO and BytesIO
 200 try:
 201     from io import StringIO, BytesIO
 202 except ImportError:
 203     try:
 204         from cStringIO import StringIO
 205         from cStringIO import StringIO as BytesIO
 206     except ImportError:
 207         from StringIO import StringIO
 208         from StringIO import StringIO as BytesIO
 209
 210 __use_pysftp__ = False
 211 __use_alt_format__ = False
 212 scriptconf = os.path.join(os.path.dirname(get_importing_script_path()), "catfile.ini")
 213 if os.path.exists(scriptconf):
 214     __config_file__ = scriptconf
 215 else:
 216     __config_file__ = os.path.join(os.path.dirname(os.path.realpath(__file__)), "catfile.ini")
 217 __use_ini_file__ = True
 218 if(not havepysftp):
 219     __use_pysftp__ = False
 220 __use_http_lib__ = "httpx"
 221 if(__use_http_lib__ == "httpx" and haverequests and not havehttpx):
 222     __use_http_lib__ = "requests"
 223 if(__use_http_lib__ == "requests" and havehttpx and not haverequests):
 224     __use_http_lib__ = "httpx"
 225 if((__use_http_lib__ == "httpx" or __use_http_lib__ == "requests") and not havehttpx and not haverequests):
 226     __use_http_lib__ = "urllib"
 227 if os.path.exists(__config_file__) and __use_ini_file__:
 228     # Create a ConfigParser object
 229     config = configparser.ConfigParser()
 230     # Read the configuration file
 231     config.read(__config_file__)
 232     # Accessing values from the config file
 233     __file_format_name__ = config['main']['name']
 234     __program_name__ = config['main']['proname']
 235     __file_format_lower__ = config['main']['lower']
 236     __file_format_magic__ = config['main']['magic'].encode("UTF-8").decode('unicode_escape')
 237     __file_format_len__ = int(config['main']['len'])
 238     __file_format_hex__ = config['main']['hex']
 239     __file_format_delimiter__ = config['main']['delimiter'].encode("UTF-8").decode('unicode_escape')
 240     __file_format_ver__ = config['main']['ver']
 241     __use_new_style__ = config.getboolean('main', 'newstyle')
 242     __use_advanced_list__ = config.getboolean('main', 'advancedlist')
 243     __use_alt_inode__ = config.getboolean('main', 'altinode')
 244     __file_format_extension__ = config['main']['extension']
 245 else:
 246     if not __use_alt_format__:
 247         # Format Info by Kazuki Przyborowski
 248         __file_format_name__ = "CatFile"
 249         __program_name__ = "Py" + __file_format_name__
 250         __file_format_lower__ = __file_format_name__.lower()
 251         __file_format_magic__ = __file_format_name__
 252         __file_format_len__ = len(__file_format_magic__)
 253         __file_format_hex__ = binascii.hexlify(
 254             __file_format_magic__.encode("UTF-8")).decode("UTF-8")
 255         __file_format_delimiter__ = "\x00"
 256         __file_format_ver__ = "001"
 257         __use_new_style__ = True
 258         __use_advanced_list__ = True
 259         __use_alt_inode__ = False
 260         __file_format_extension__ = ".cat"
 261     else:
 262         # Format Info Generated by ChatGPT
 263         __file_format_name__ = "FastArchive"
 264         __program_name__ = "Py" + __file_format_name__
 265         __file_format_lower__ = __file_format_name__.lower()
 266         __file_format_magic__ = "FstArch"
 267         __file_format_len__ = len(__file_format_magic__)
 268         __file_format_hex__ = binascii.hexlify(
 269             __file_format_magic__.encode("UTF-8")).decode("UTF-8")
 270         # Using a non-printable ASCII character as delimiter
 271         __file_format_delimiter__ = "\x1F"
 272         __file_format_ver__ = "001"
 273         __use_new_style__ = True
 274         __use_advanced_list__ = False
 275         __use_alt_inode__ = False
 276         __file_format_extension__ = ".fast"
 277 __file_format_list__ = [__file_format_name__, __file_format_magic__, __file_format_lower__, __file_format_len__,
 278                         __file_format_hex__, __file_format_delimiter__, __file_format_ver__, __use_new_style__, __use_advanced_list__, __use_alt_inode__]
 279 __file_format_dict__ = {'format_name': __file_format_name__, 'format_magic': __file_format_magic__, 'format_lower': __file_format_lower__, 'format_len': __file_format_len__, 'format_hex': __file_format_hex__,
 280                         'format_delimiter': __file_format_delimiter__, 'format_ver': __file_format_ver__, 'new_style': __use_new_style__, 'use_advanced_list': __use_advanced_list__, 'use_alt_inode': __use_alt_inode__}
 281 __project__ = __program_name__
 282 __project_url__ = "https://github.com/GameMaker2k/PyCatFile"
 283 __version_info__ = (0, 14, 4, "RC 1", 1)
 284 __version_date_info__ = (2024, 11, 17, "RC 1", 1)
 285 __version_date__ = str(__version_date_info__[0]) + "." + str(
 286     __version_date_info__[1]).zfill(2) + "." + str(__version_date_info__[2]).zfill(2)
 287 __revision__ = __version_info__[3]
 288 __revision_id__ = "$Id$"
 289 if(__version_info__[4] is not None):
 290     __version_date_plusrc__ = __version_date__ + \
 291         "-" + str(__version_date_info__[4])
 292 if(__version_info__[4] is None):
 293     __version_date_plusrc__ = __version_date__
 294 if(__version_info__[3] is not None):
 295     __version__ = str(__version_info__[0]) + "." + str(__version_info__[
 296         1]) + "." + str(__version_info__[2]) + " " + str(__version_info__[3])
 297 if(__version_info__[3] is None):
 298     __version__ = str(__version_info__[
 299                       0]) + "." + str(__version_info__[1]) + "." + str(__version_info__[2])
 300
 301 PyBitness = platform.architecture()
 302 if(PyBitness == "32bit" or PyBitness == "32"):
 303     PyBitness = "32"
 304 elif(PyBitness == "64bit" or PyBitness == "64"):
 305     PyBitness = "64"
 306 else:
 307     PyBitness = "32"
 308
 309 geturls_ua_pycatfile_python = "Mozilla/5.0 (compatible; {proname}/{prover}; +{prourl})".format(
 310     proname=__project__, prover=__version__, prourl=__project_url__)
 311 if(platform.python_implementation() != ""):
 312     py_implementation = platform.python_implementation()
 313 if(platform.python_implementation() == ""):
 314     py_implementation = "Python"
 315 geturls_ua_pycatfile_python_alt = "Mozilla/5.0 ({osver}; {archtype}; +{prourl}) {pyimp}/{pyver} (KHTML, like Gecko) {proname}/{prover}".format(osver=platform.system(
 316 )+" "+platform.release(), archtype=platform.machine(), prourl=__project_url__, pyimp=py_implementation, pyver=platform.python_version(), proname=__project__, prover=__version__)
 317 geturls_ua_googlebot_google = "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"
 318 geturls_ua_googlebot_google_old = "Googlebot/2.1 (+http://www.google.com/bot.html)"
 319 geturls_headers_pycatfile_python = {'Referer': "http://google.com/", 'User-Agent': geturls_ua_pycatfile_python, 'Accept-Encoding': "none", 'Accept-Language': "en-US,en;q=0.8,en-CA,en-GB;q=0.6", 'Accept-Charset': "ISO-8859-1,ISO-8859-15,utf-8;q=0.7,*;q=0.7", 'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 'Connection': "close",
 320                                     'SEC-CH-UA': "\""+__project__+"\";v=\""+str(__version__)+"\", \"Not;A=Brand\";v=\"8\", \""+py_implementation+"\";v=\""+str(platform.release())+"\"", 'SEC-CH-UA-FULL-VERSION': str(__version__), 'SEC-CH-UA-PLATFORM': ""+py_implementation+"", 'SEC-CH-UA-ARCH': ""+platform.machine()+"", 'SEC-CH-UA-PLATFORM': str(__version__), 'SEC-CH-UA-BITNESS': str(PyBitness)}
 321 geturls_headers_pycatfile_python_alt = {'Referer': "http://google.com/", 'User-Agent': geturls_ua_pycatfile_python_alt, 'Accept-Encoding': "none", 'Accept-Language': "en-US,en;q=0.8,en-CA,en-GB;q=0.6", 'Accept-Charset': "ISO-8859-1,ISO-8859-15,utf-8;q=0.7,*;q=0.7", 'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 'Connection': "close",
 322                                         'SEC-CH-UA': "\""+__project__+"\";v=\""+str(__version__)+"\", \"Not;A=Brand\";v=\"8\", \""+py_implementation+"\";v=\""+str(platform.release())+"\"", 'SEC-CH-UA-FULL-VERSION': str(__version__), 'SEC-CH-UA-PLATFORM': ""+py_implementation+"", 'SEC-CH-UA-ARCH': ""+platform.machine()+"", 'SEC-CH-UA-PLATFORM': str(__version__), 'SEC-CH-UA-BITNESS': str(PyBitness)}
 323 geturls_headers_googlebot_google = {'Referer': "http://google.com/", 'User-Agent': geturls_ua_googlebot_google, 'Accept-Encoding': "none", 'Accept-Language': "en-US,en;q=0.8,en-CA,en-GB;q=0.6",
 324                                     'Accept-Charset': "ISO-8859-1,ISO-8859-15,utf-8;q=0.7,*;q=0.7", 'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 'Connection': "close"}
 325 geturls_headers_googlebot_google_old = {'Referer': "http://google.com/", 'User-Agent': geturls_ua_googlebot_google_old, 'Accept-Encoding': "none", 'Accept-Language': "en-US,en;q=0.8,en-CA,en-GB;q=0.6",
 326                                         'Accept-Charset': "ISO-8859-1,ISO-8859-15,utf-8;q=0.7,*;q=0.7", 'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 'Connection': "close"}
 327
 328 compressionsupport = []
 329 try:
 330     import gzip
 331     compressionsupport.append("gz")
 332     compressionsupport.append("gzip")
 333 except ImportError:
 334     pass
 335 try:
 336     import bz2
 337     compressionsupport.append("bz2")
 338     compressionsupport.append("bzip2")
 339 except ImportError:
 340     pass
 341 try:
 342     import lz4
 343     import lz4.frame
 344     compressionsupport.append("lz4")
 345 except ImportError:
 346     pass
 347 try:
 348     import lzo
 349     compressionsupport.append("lzo")
 350     compressionsupport.append("lzop")
 351 except ImportError:
 352     pass
 353 try:
 354     import zstandard
 355     compressionsupport.append("zstd")
 356     compressionsupport.append("zstandard")
 357 except ImportError:
 358     pass
 359 try:
 360     import lzma
 361     compressionsupport.append("lzma")
 362     compressionsupport.append("xz")
 363 except ImportError:
 364     try:
 365         from backports import lzma
 366         compressionsupport.append("lzma")
 367         compressionsupport.append("xz")
 368     except ImportError:
 369         pass
 370 compressionsupport.append("zlib")
 371
 372 compressionlist = ['auto']
 373 compressionlistalt = []
 374 outextlist = []
 375 outextlistwd = []
 376 if('gzip' in compressionsupport):
 377     compressionlist.append('gzip')
 378     compressionlistalt.append('gzip')
 379     outextlist.append('gz')
 380     outextlistwd.append('.gz')
 381 if('bzip2' in compressionsupport):
 382     compressionlist.append('bzip2')
 383     compressionlistalt.append('bzip2')
 384     outextlist.append('bz2')
 385     outextlistwd.append('.bz2')
 386 if('zstd' in compressionsupport):
 387     compressionlist.append('zstd')
 388     compressionlistalt.append('zstd')
 389     outextlist.append('zst')
 390     outextlistwd.append('.zst')
 391 if('lz4' in compressionsupport):
 392     compressionlist.append('lz4')
 393     compressionlistalt.append('lz4')
 394     outextlist.append('lz4')
 395     outextlistwd.append('.lz4')
 396 if('lzo' in compressionsupport):
 397     compressionlist.append('lzo')
 398     compressionlistalt.append('lzo')
 399     outextlist.append('lzo')
 400     outextlistwd.append('.lzo')
 401 if('lzop' in compressionsupport):
 402     compressionlist.append('lzop')
 403     compressionlistalt.append('lzop')
 404     outextlist.append('lzop')
 405     outextlistwd.append('.lzop')
 406 if('lzma' in compressionsupport):
 407     compressionlist.append('lzma')
 408     compressionlistalt.append('lzma')
 409     outextlist.append('lzma')
 410     outextlistwd.append('.lzma')
 411 if('xz' in compressionsupport):
 412     compressionlist.append('xz')
 413     compressionlistalt.append('xz')
 414     outextlist.append('xz')
 415     outextlistwd.append('.xz')
 416 if('zlib' in compressionsupport):
 417     compressionlist.append('zlib')
 418     compressionlistalt.append('zlib')
 419     outextlist.append('zz')
 420     outextlistwd.append('.zz')
 421     outextlist.append('zl')
 422     outextlistwd.append('.zl')
 423     outextlist.append('zlib')
 424     outextlistwd.append('.zlib')
 425
 426 tarfile_mimetype = "application/tar"
 427 tarfile_tar_mimetype = tarfile_mimetype
 428 zipfile_mimetype = "application/zip"
 429 zipfile_zip_mimetype = zipfile_mimetype
 430 rarfile_mimetype = "application/rar"
 431 rarfile_rar_mimetype = rarfile_mimetype
 432 archivefile_mimetype = "application/x-"+__file_format_dict__['format_lower']+""
 433 archivefile_cat_mimetype = archivefile_mimetype
 434 archivefile_gzip_mimetype = "application/x-" + \
 435     __file_format_dict__['format_lower']+"+gzip"
 436 archivefile_gz_mimetype = archivefile_gzip_mimetype
 437 archivefile_bzip2_mimetype = "application/x-" + \
 438     __file_format_dict__['format_lower']+"+bzip2"
 439 archivefile_bz2_mimetype = archivefile_bzip2_mimetype
 440 archivefile_lz4_mimetype = "application/x-" + \
 441     __file_format_dict__['format_lower']+"+lz4"
 442 archivefile_lzop_mimetype = "application/x-" + \
 443     __file_format_dict__['format_lower']+"+lzop"
 444 archivefile_lzo_mimetype = archivefile_lzop_mimetype
 445 archivefile_zstandard_mimetype = "application/x-" + \
 446     __file_format_dict__['format_lower']+"+zstandard"
 447 archivefile_zstd_mimetype = archivefile_zstandard_mimetype
 448 archivefile_lzma_mimetype = "application/x-" + \
 449     __file_format_dict__['format_lower']+"+lzma"
 450 archivefile_xz_mimetype = "application/x-" + \
 451     __file_format_dict__['format_lower']+"+xz"
 452 archivefile_zlib_mimetype = "application/x-" + \
 453     __file_format_dict__['format_lower']+"+zlib"
 454 archivefile_zz_mimetype = archivefile_zlib_mimetype
 455 archivefile_zl_mimetype = archivefile_zlib_mimetype
 456 archivefile_extensions = [__file_format_extension__, __file_format_extension__+".gz", __file_format_extension__+".bz2", __file_format_extension__+".zst", __file_format_extension__+".lz4", __file_format_extension__ +
 457                           ".lzo", __file_format_extension__+".lzop", __file_format_extension__+".lzma", __file_format_extension__+".xz", __file_format_extension__+".zz", __file_format_extension__+".zl", __file_format_extension__+".zlib"]
 458
 459 if __name__ == "__main__":
 460     import subprocess
 461     curscrpath = os.path.dirname(sys.argv[0])
 462     if(curscrpath == ""):
 463         curscrpath = "."
 464     if(os.sep == "\\"):
 465         curscrpath = curscrpath.replace(os.sep, "/")
 466     curscrpath = curscrpath + "/"
 467     scrfile = curscrpath + "catfile.py"
 468     if(os.path.exists(scrfile) and os.path.isfile(scrfile)):
 469         scrcmd = subprocess.Popen([sys.executable, scrfile] + sys.argv[1:])
 470         scrcmd.wait()
 471
 472
 473 def VerbosePrintOut(dbgtxt, outtype="log", dbgenable=True, dgblevel=20):
 474     if(not dbgenable):
 475         return True
 476     log_functions = {
 477         "print": print,
 478         "log": logging.info,
 479         "warning": logging.warning,
 480         "error": logging.error,
 481         "critical": logging.critical,
 482         "exception": logging.exception,
 483         "logalt": lambda x: logging.log(dgblevel, x),
 484         "debug": logging.debug
 485     }
 486     log_function = log_functions.get(outtype)
 487     if(log_function):
 488         log_function(dbgtxt)
 489         return True
 490     return False
 491
 492
 493 def VerbosePrintOutReturn(dbgtxt, outtype="log", dbgenable=True, dgblevel=20):
 494     VerbosePrintOut(dbgtxt, outtype, dbgenable, dgblevel)
 495     return dbgtxt
 496
 497
 498 def RemoveWindowsPath(dpath):
 499     if(dpath is None):
 500         dpath = ""
 501     if(os.sep != "/"):
 502         dpath = dpath.replace(os.path.sep, "/")
 503     dpath = dpath.rstrip("/")
 504     if(dpath == "." or dpath == ".."):
 505         dpath = dpath + "/"
 506     return dpath
 507
 508
 509 def NormalizeRelativePath(inpath):
 510     inpath = RemoveWindowsPath(inpath)
 511     if(os.path.isabs(inpath)):
 512         outpath = inpath
 513     else:
 514         if(inpath.startswith("./") or inpath.startswith("../")):
 515             outpath = inpath
 516         else:
 517             outpath = "./" + inpath
 518     return outpath
 519
 520
 521 def PrependPath(base_dir, child_path):
 522     # Check if base_dir is None or empty, if so, return child_path as is
 523     if not base_dir:
 524         return child_path
 525     # Ensure base_dir ends with exactly one slash
 526     if not base_dir.endswith('/'):
 527         base_dir += '/'
 528     # Check if child_path starts with ./ or ../ (indicating a relative path)
 529     if child_path.startswith('./') or child_path.startswith('../'):
 530         # For relative paths, we don't alter the child_path
 531         return base_dir + child_path
 532     else:
 533         # For non-relative paths, ensure there's no starting slash on child_path to avoid double slashes
 534         return base_dir + child_path.lstrip('/')
 535
 536
 537 def ListDir(dirpath, followlink=False, duplicates=False):
 538     if isinstance(dirpath, (list, tuple, )):
 539         dirpath = list(filter(None, dirpath))
 540     elif isinstance(dirpath, str):
 541         dirpath = list(filter(None, [dirpath]))
 542     retlist = []
 543     fs_encoding = sys.getfilesystemencoding()
 544     for mydirfile in dirpath:
 545         if not os.path.exists(mydirfile):
 546             return False
 547         mydirfile = NormalizeRelativePath(mydirfile)
 548         if os.path.exists(mydirfile) and os.path.islink(mydirfile):
 549             mydirfile = RemoveWindowsPath(os.path.realpath(mydirfile))
 550         if os.path.exists(mydirfile) and os.path.isdir(mydirfile):
 551             for root, dirs, filenames in os.walk(mydirfile):
 552                 dpath = root
 553                 dpath = RemoveWindowsPath(dpath)
 554                 if fs_encoding != 'utf-8':
 555                     dpath = dpath.encode(fs_encoding).decode('utf-8')
 556                 if dpath not in retlist and not duplicates:
 557                     retlist.append(dpath)
 558                 if duplicates:
 559                     retlist.append(dpath)
 560                 for file in filenames:
 561                     fpath = os.path.join(root, file)
 562                     fpath = RemoveWindowsPath(fpath)
 563                     if fs_encoding != 'utf-8':
 564                         fpath = fpath.encode(fs_encoding).decode('utf-8')
 565                     if fpath not in retlist and not duplicates:
 566                         retlist.append(fpath)
 567                     if duplicates:
 568                         retlist.append(fpath)
 569         else:
 570             path = RemoveWindowsPath(mydirfile)
 571             if fs_encoding != 'utf-8':
 572                 path = path.encode(fs_encoding).decode('utf-8')
 573             retlist.append(path)
 574     return retlist
 575
 576
 577 def ListDirAdvanced(dirpath, followlink=False, duplicates=False):
 578     if isinstance(dirpath, (list, tuple, )):
 579         dirpath = list(filter(None, dirpath))
 580     elif isinstance(dirpath, str):
 581         dirpath = list(filter(None, [dirpath]))
 582     retlist = []
 583     fs_encoding = sys.getfilesystemencoding()
 584     for mydirfile in dirpath:
 585         if not os.path.exists(mydirfile):
 586             return False
 587         mydirfile = NormalizeRelativePath(mydirfile)
 588         if os.path.exists(mydirfile) and os.path.islink(mydirfile) and followlink:
 589             mydirfile = RemoveWindowsPath(os.path.realpath(mydirfile))
 590         if os.path.exists(mydirfile) and os.path.isdir(mydirfile):
 591             for root, dirs, filenames in os.walk(mydirfile):
 592                 # Sort dirs and filenames alphabetically in place
 593                 dirs.sort(key=lambda x: x.lower())
 594                 filenames.sort(key=lambda x: x.lower())
 595                 dpath = RemoveWindowsPath(root)
 596                 if fs_encoding != 'utf-8':
 597                     dpath = dpath.encode(fs_encoding).decode('utf-8')
 598                 if not duplicates and dpath not in retlist:
 599                     retlist.append(dpath)
 600                 elif duplicates:
 601                     retlist.append(dpath)
 602                 for file in filenames:
 603                     fpath = os.path.join(root, file)
 604                     fpath = RemoveWindowsPath(fpath)
 605                     if fs_encoding != 'utf-8':
 606                         fpath = fpath.encode(fs_encoding).decode('utf-8')
 607                     if not duplicates and fpath not in retlist:
 608                         retlist.append(fpath)
 609                     elif duplicates:
 610                         retlist.append(fpath)
 611         else:
 612             path = RemoveWindowsPath(mydirfile)
 613             if fs_encoding != 'utf-8':
 614                 path = path.encode(fs_encoding).decode('utf-8')
 615             retlist.append(path)
 616     return retlist
 617
 618
 619 def create_alias_function(prefix, base_name, suffix, target_function):
 620     # Define a new function that wraps the target function
 621     def alias_function(*args, **kwargs):
 622         return target_function(*args, **kwargs)
 623     # Create the function name by combining the prefix, base name, and the suffix
 624     function_name = "{}{}{}".format(prefix, base_name, suffix)
 625     # Add the new function to the global namespace
 626     globals()[function_name] = alias_function
 627
 628
 629 def create_alias_function_alt(prefix, base_name, suffix, target_function):
 630     # Create the function name by combining the prefix, base name, and the suffix
 631     # Use the format method for string formatting, compatible with Python 2 and 3
 632     function_name = "{}{}{}".format(prefix, base_name, suffix)
 633     # Add the new function (alias of the target_function) to the global namespace
 634     # This line is compatible as-is with both Python 2 and 3
 635     globals()[function_name] = target_function
 636
 637
 638 def FormatSpecsListToDict(formatspecs=__file_format_list__):
 639     if(isinstance(formatspecs, (list, tuple, ))):
 640         return {'format_name': formatspecs[0], 'format_magic': formatspecs[1], 'format_lower': formatspecs[2], 'format_len': formatspecs[3], 'format_hex': formatspecs[4], 'format_delimiter': formatspecs[5], 'format_ver': formatspecs[6], 'new_style': formatspecs[7], 'use_advanced_list': formatspecs[8], 'use_alt_inode': formatspecs[9]}
 641     elif(isinstance(formatspecs, (dict, ))):
 642         return formatspecs
 643     else:
 644         return __file_format_dict__
 645     return __file_format_dict__
 646
 647
 648 class ZlibFile:
 649     def __init__(self, file_path=None, fileobj=None, mode='rb', level=9, wbits=15, encoding=None, errors=None, newline=None):
 650         if file_path is None and fileobj is None:
 651             raise ValueError("Either file_path or fileobj must be provided")
 652         if file_path is not None and fileobj is not None:
 653             raise ValueError(
 654                 "Only one of file_path or fileobj should be provided")
 655
 656         self.file_path = file_path
 657         self.fileobj = fileobj
 658         self.mode = mode
 659         self.level = level
 660         self.wbits = wbits
 661         self.encoding = encoding
 662         self.errors = errors
 663         self.newline = newline
 664         self._compressed_data = b''
 665         self._decompressed_data = b''
 666         self._position = 0
 667         self._text_mode = 't' in mode
 668
 669         # Force binary mode for internal handling
 670         internal_mode = mode.replace('t', 'b')
 671
 672         if 'w' in mode or 'a' in mode or 'x' in mode:
 673             self.file = open(
 674                 file_path, internal_mode) if file_path else fileobj
 675             self._compressor = zlib.compressobj(level, zlib.DEFLATED, wbits)
 676         elif 'r' in mode:
 677             if file_path:
 678                 if os.path.exists(file_path):
 679                     self.file = open(file_path, internal_mode)
 680                     self._load_file()
 681                 else:
 682                     raise FileNotFoundError(
 683                         "No such file: '{}'".format(file_path))
 684             elif fileobj:
 685                 self.file = fileobj
 686                 self._load_file()
 687         else:
 688             raise ValueError("Mode should be 'rb' or 'wb'")
 689
 690     def _load_file(self):
 691         self.file.seek(0)
 692         self._compressed_data = self.file.read()
 693         if not self._compressed_data.startswith((b'\x78\x01', b'\x78\x5E', b'\x78\x9C', b'\x78\xDA')):
 694             raise ValueError("Invalid zlib file header")
 695         self._decompressed_data = zlib.decompress(
 696             self._compressed_data, self.wbits)
 697         if self._text_mode:
 698             self._decompressed_data = self._decompressed_data.decode(
 699                 self.encoding or 'utf-8', self.errors or 'strict')
 700
 701     def write(self, data):
 702         if self._text_mode:
 703             data = data.encode(self.encoding or 'utf-8',
 704                                self.errors or 'strict')
 705         compressed_data = self._compressor.compress(
 706             data) + self._compressor.flush(zlib.Z_SYNC_FLUSH)
 707         self.file.write(compressed_data)
 708
 709     def read(self, size=-1):
 710         if size == -1:
 711             size = len(self._decompressed_data) - self._position
 712         data = self._decompressed_data[self._position:self._position + size]
 713         self._position += size
 714         return data
 715
 716     def seek(self, offset, whence=0):
 717         if whence == 0:  # absolute file positioning
 718             self._position = offset
 719         elif whence == 1:  # seek relative to the current position
 720             self._position += offset
 721         elif whence == 2:  # seek relative to the file's end
 722             self._position = len(self._decompressed_data) + offset
 723         else:
 724             raise ValueError("Invalid value for whence")
 725
 726         # Ensure the position is within bounds
 727         self._position = max(
 728             0, min(self._position, len(self._decompressed_data)))
 729
 730     def tell(self):
 731         return self._position
 732
 733     def flush(self):
 734         self.file.flush()
 735
 736     def fileno(self):
 737         if hasattr(self.file, 'fileno'):
 738             return self.file.fileno()
 739         raise OSError("The underlying file object does not support fileno()")
 740
 741     def isatty(self):
 742         if hasattr(self.file, 'isatty'):
 743             return self.file.isatty()
 744         return False
 745
 746     def truncate(self, size=None):
 747         if hasattr(self.file, 'truncate'):
 748             return self.file.truncate(size)
 749         raise OSError("The underlying file object does not support truncate()")
 750
 751     def close(self):
 752         if 'w' in self.mode or 'a' in self.mode or 'x' in self.mode:
 753             self.file.write(self._compressor.flush(zlib.Z_FINISH))
 754         if self.file_path:
 755             self.file.close()
 756
 757     def __enter__(self):
 758         return self
 759
 760     def __exit__(self, exc_type, exc_value, traceback):
 761         self.close()
 762
 763
 764 class GzipFile:
 765     def __init__(self, file_path=None, fileobj=None, mode='rb', compresslevel=9, encoding=None, errors=None, newline=None):
 766         if file_path is None and fileobj is None:
 767             raise ValueError("Either file_path or fileobj must be provided")
 768         if file_path is not None and fileobj is not None:
 769             raise ValueError(
 770                 "Only one of file_path or fileobj should be provided")
 771
 772         self.file_path = file_path
 773         self.fileobj = fileobj
 774         self.mode = mode
 775         self.compresslevel = compresslevel
 776         self.encoding = encoding
 777         self.errors = errors
 778         self.newline = newline
 779         self._compressed_data = b''
 780         self._decompressed_data = b''
 781         self._position = 0
 782         self._text_mode = 't' in mode
 783
 784         # Force binary mode for internal handling
 785         internal_mode = mode.replace('t', 'b')
 786
 787         if 'w' in mode or 'a' in mode or 'x' in mode:
 788             self.file = gzip.open(file_path, internal_mode, compresslevel=compresslevel) if file_path else gzip.GzipFile(
 789                 fileobj=fileobj, mode=internal_mode, compresslevel=compresslevel)
 790             self._compressor = gzip.GzipFile(
 791                 fileobj=self.file, mode=internal_mode, compresslevel=compresslevel)
 792         elif 'r' in mode:
 793             if file_path:
 794                 if os.path.exists(file_path):
 795                     self.file = gzip.open(file_path, internal_mode)
 796                     self._load_file()
 797                 else:
 798                     raise FileNotFoundError(
 799                         "No such file: '{}'".format(file_path))
 800             elif fileobj:
 801                 self.file = gzip.GzipFile(fileobj=fileobj, mode=internal_mode)
 802                 self._load_file()
 803         else:
 804             raise ValueError("Mode should be 'rb' or 'wb'")
 805
 806     def _load_file(self):
 807         self.file.seek(0)
 808         self._compressed_data = self.file.read()
 809         if not self._compressed_data.startswith(b'\x1f\x8b'):
 810             raise ValueError("Invalid gzip file header")
 811         self._decompressed_data = gzip.decompress(self._compressed_data)
 812         if self._text_mode:
 813             self._decompressed_data = self._decompressed_data.decode(
 814                 self.encoding or 'utf-8', self.errors or 'strict')
 815
 816     def write(self, data):
 817         if self._text_mode:
 818             data = data.encode(self.encoding or 'utf-8',
 819                                self.errors or 'strict')
 820         compressed_data = self._compressor.compress(data)
 821         self.file.write(compressed_data)
 822         self.file.flush()
 823
 824     def read(self, size=-1):
 825         if size == -1:
 826             size = len(self._decompressed_data) - self._position
 827         data = self._decompressed_data[self._position:self._position + size]
 828         self._position += size
 829         return data
 830
 831     def seek(self, offset, whence=0):
 832         if whence == 0:  # absolute file positioning
 833             self._position = offset
 834         elif whence == 1:  # seek relative to the current position
 835             self._position += offset
 836         elif whence == 2:  # seek relative to the file's end
 837             self._position = len(self._decompressed_data) + offset
 838         else:
 839             raise ValueError("Invalid value for whence")
 840
 841         # Ensure the position is within bounds
 842         self._position = max(
 843             0, min(self._position, len(self._decompressed_data)))
 844
 845     def tell(self):
 846         return self._position
 847
 848     def flush(self):
 849         self.file.flush()
 850
 851     def fileno(self):
 852         if hasattr(self.file, 'fileno'):
 853             return self.file.fileno()
 854         raise OSError("The underlying file object does not support fileno()")
 855
 856     def isatty(self):
 857         if hasattr(self.file, 'isatty'):
 858             return self.file.isatty()
 859         return False
 860
 861     def truncate(self, size=None):
 862         if hasattr(self.file, 'truncate'):
 863             return self.file.truncate(size)
 864         raise OSError("The underlying file object does not support truncate()")
 865
 866     def close(self):
 867         if 'w' in self.mode or 'a' in self.mode or 'x' in self.mode:
 868             self.file.write(self._compressor.flush())
 869         if self.file_path:
 870             self.file.close()
 871
 872     def __enter__(self):
 873         return self
 874
 875     def __exit__(self, exc_type, exc_value, traceback):
 876         self.close()
 877
 878
 879 '''
 880 class BloscFile:
 881  def __init__(self, file_path=None, fileobj=None, mode='rb', level=9, encoding=None, errors=None, newline=None):
 882   if file_path is None and fileobj is None:
 883    raise ValueError("Either file_path or fileobj must be provided");
 884   if file_path is not None and fileobj is not None:
 885    raise ValueError("Only one of file_path or fileobj should be provided");
 886
 887   self.file_path = file_path;
 888   self.fileobj = fileobj;
 889   self.mode = mode;
 890   self.level = level;
 891   self.encoding = encoding;
 892   self.errors = errors;
 893   self.newline = newline;
 894   self._compressed_data = b'';
 895   self._decompressed_data = b'';
 896   self._position = 0;
 897   self._text_mode = 't' in mode;
 898
 899   # Force binary mode for internal handling
 900   internal_mode = mode.replace('t', 'b');
 901
 902   if 'w' in mode or 'a' in mode or 'x' in mode:
 903    self.file = open(file_path, internal_mode) if file_path else fileobj;
 904    self._compressor = blosc.Blosc(level);
 905   elif 'r' in mode:
 906    if file_path:
 907     if os.path.exists(file_path):
 908      self.file = open(file_path, internal_mode);
 909      self._load_file();
 910     else:
 911      raise FileNotFoundError("No such file: '{}'".format(file_path));
 912    elif fileobj:
 913     self.file = fileobj;
 914     self._load_file();
 915   else:
 916    raise ValueError("Mode should be 'rb' or 'wb'");
 917
 918  def _load_file(self):
 919   self.file.seek(0);
 920   self._compressed_data = self.file.read();
 921   if not self._compressed_data:
 922    raise ValueError("Invalid blosc file header");
 923   self._decompressed_data = blosc.decompress(self._compressed_data);
 924   if self._text_mode:
 925    self._decompressed_data = self._decompressed_data.decode(self.encoding or 'utf-8', self.errors or 'strict');
 926
 927  def write(self, data):
 928   if self._text_mode:
 929    data = data.encode(self.encoding or 'utf-8', self.errors or 'strict');
 930   compressed_data = blosc.compress(data, cname='blosclz', clevel=self.level);
 931   self.file.write(compressed_data);
 932   self.file.flush();
 933
 934  def read(self, size=-1):
 935   if size == -1:
 936    size = len(self._decompressed_data) - self._position;
 937   data = self._decompressed_data[self._position:self._position + size];
 938   self._position += size;
 939   return data;
 940
 941  def seek(self, offset, whence=0):
 942   if whence == 0:  # absolute file positioning
 943    self._position = offset;
 944   elif whence == 1:  # seek relative to the current position
 945    self._position += offset;
 946   elif whence == 2:  # seek relative to the file's end
 947    self._position = len(self._decompressed_data) + offset;
 948   else:
 949    raise ValueError("Invalid value for whence");
 950
 951   # Ensure the position is within bounds
 952   self._position = max(0, min(self._position, len(self._decompressed_data)));
 953
 954  def tell(self):
 955   return self._position;
 956
 957  def flush(self):
 958   self.file.flush();
 959
 960  def fileno(self):
 961   if hasattr(self.file, 'fileno'):
 962    return self.file.fileno();
 963   raise OSError("The underlying file object does not support fileno()");
 964
 965  def isatty(self):
 966   if hasattr(self.file, 'isatty'):
 967    return self.file.isatty();
 968   return False;
 969
 970  def truncate(self, size=None):
 971   if hasattr(self.file, 'truncate'):
 972    return self.file.truncate(size);
 973   raise OSError("The underlying file object does not support truncate()");
 974
 975  def close(self):
 976   if 'w' in self.mode or 'a' in self.mode or 'x' in self.mode:
 977    self.file.write(blosc.compress(self._compressor.flush(), cname='blosclz', clevel=self.level));
 978   if self.file_path:
 979    self.file.close();
 980
 981  def __enter__(self):
 982   return self;
 983
 984  def __exit__(self, exc_type, exc_value, traceback):
 985   self.close();
 986
 987 class BrotliFile:
 988  def __init__(self, file_path=None, fileobj=None, mode='rb', level=11, encoding=None, errors=None, newline=None):
 989   if file_path is None and fileobj is None:
 990    raise ValueError("Either file_path or fileobj must be provided");
 991   if file_path is not None and fileobj is not None:
 992    raise ValueError("Only one of file_path or fileobj should be provided");
 993
 994   self.file_path = file_path;
 995   self.fileobj = fileobj;
 996   self.mode = mode;
 997   self.level = level;
 998   self.encoding = encoding;
 999   self.errors = errors;
1000   self.newline = newline;
1001   self._compressed_data = b'';
1002   self._decompressed_data = b'';
1003   self._position = 0;
1004   self._text_mode = 't' in mode;
1005
1006   # Force binary mode for internal handling
1007   internal_mode = mode.replace('t', 'b');
1008
1009   if 'w' in mode or 'a' in mode or 'x' in mode:
1010    self.file = open(file_path, internal_mode) if file_path else fileobj;
1011    self._compressor = brotli.Compressor(quality=self.level);
1012   elif 'r' in mode:
1013    if file_path:
1014     if os.path.exists(file_path):
1015      self.file = open(file_path, internal_mode);
1016      self._load_file();
1017     else:
1018      raise FileNotFoundError("No such file: '{}'".format(file_path));
1019    elif fileobj:
1020     self.file = fileobj;
1021     self._load_file();
1022   else:
1023    raise ValueError("Mode should be 'rb' or 'wb'");
1024
1025  def _load_file(self):
1026   self.file.seek(0);
1027   self._compressed_data = self.file.read();
1028   if not self._compressed_data:
1029    raise ValueError("Invalid brotli file header");
1030   self._decompressed_data = brotli.decompress(self._compressed_data);
1031   if self._text_mode:
1032    self._decompressed_data = self._decompressed_data.decode(self.encoding or 'utf-8', self.errors or 'strict');
1033
1034  def write(self, data):
1035   if self._text_mode:
1036    data = data.encode(self.encoding or 'utf-8', self.errors or 'strict');
1037   compressed_data = self._compressor.process(data);
1038   self.file.write(compressed_data);
1039   self.file.flush();
1040
1041  def read(self, size=-1):
1042   if size == -1:
1043    size = len(self._decompressed_data) - self._position;
1044   data = self._decompressed_data[self._position:self._position + size];
1045   self._position += size;
1046   return data;
1047
1048  def seek(self, offset, whence=0):
1049   if whence == 0:  # absolute file positioning
1050    self._position = offset;
1051   elif whence == 1:  # seek relative to the current position
1052    self._position += offset;
1053   elif whence == 2:  # seek relative to the file's end
1054    self._position = len(self._decompressed_data) + offset;
1055   else:
1056    raise ValueError("Invalid value for whence");
1057
1058   # Ensure the position is within bounds
1059   self._position = max(0, min(self._position, len(self._decompressed_data)));
1060
1061  def tell(self):
1062   return self._position;
1063
1064  def flush(self):
1065   self.file.flush();
1066
1067  def fileno(self):
1068   if hasattr(self.file, 'fileno'):
1069    return self.file.fileno();
1070   raise OSError("The underlying file object does not support fileno()");
1071
1072  def isatty(self):
1073   if hasattr(self.file, 'isatty'):
1074    return self.file.isatty();
1075   return False;
1076
1077  def truncate(self, size=None):
1078   if hasattr(self.file, 'truncate'):
1079    return self.file.truncate(size);
1080   raise OSError("The underlying file object does not support truncate()");
1081
1082  def close(self):
1083   if 'w' in self.mode or 'a' in self.mode or 'x' in self.mode:
1084    self.file.write(self._compressor.finish());
1085   if self.file_path:
1086    self.file.close();
1087
1088  def __enter__(self):
1089   return self;
1090
1091  def __exit__(self, exc_type, exc_value, traceback):
1092   self.close();
1093 '''
1094
1095
1096 def TarFileCheck(infile):
1097     try:
1098         if is_tarfile(infile):
1099             return True
1100         else:
1101             return False
1102     except TypeError:
1103         try:
1104             # Check if the input is a file object
1105             if hasattr(infile, 'read'):
1106                 # Save the current file position
1107                 current_position = infile.tell()
1108                 # Attempt to open the file object as a tar file
1109                 tar = tarfile.open(fileobj=infile)
1110                 tar.close()
1111                 # Restore the file position
1112                 infile.seek(current_position)
1113                 return True
1114             else:
1115                 # Assume it's a filename
1116                 tar = tarfile.open(name=infile)
1117                 tar.close()
1118                 return True
1119         except tarfile.TarError:
1120             return False
1121
1122
1123 def TarFileCheckAlt(infile):
1124     try:
1125         if is_tarfile(infile):
1126             return True
1127     except TypeError:
1128         pass
1129     try:
1130         # Check if the input is a file-like object
1131         if hasattr(infile, 'read'):
1132             # Save the current file position
1133             current_position = infile.tell()
1134             # Attempt to open the file object as a tar file
1135             with tarfile.open(fileobj=infile) as tar:
1136                 pass
1137             # Restore the file position
1138             infile.seek(current_position)
1139         else:
1140             # Assume it's a filename and attempt to open it as a tar file
1141             with tarfile.open(name=infile) as tar:
1142                 pass
1143         return True
1144     except (tarfile.TarError, AttributeError, IOError):
1145         return False
1146
1147
1148 def ZipFileCheck(infile):
1149     try:
1150         if zipfile.is_zipfile(infile):
1151             return True
1152     except TypeError:
1153         pass
1154     try:
1155         # Check if the input is a file-like object
1156         if hasattr(infile, 'read'):
1157             # Save the current file position
1158             current_position = infile.tell()
1159             # Attempt to open the file object as a zip file
1160             with zipfile.ZipFile(infile) as zipf:
1161                 pass
1162             # Restore the file position
1163             infile.seek(current_position)
1164         else:
1165             # Assume it's a filename and attempt to open it as a zip file
1166             with zipfile.ZipFile(infile) as zipf:
1167                 pass
1168         return True
1169     except (zipfile.BadZipFile, AttributeError, IOError):
1170         return False
1171
1172
1173 def RarFileCheck(infile):
1174     try:
1175         if rarfile.is_rarfile(infile):
1176             return True
1177     except TypeError:
1178         pass
1179     try:
1180         # Check if the input is a file-like object
1181         if hasattr(infile, 'read'):
1182             # Save the current file position
1183             current_position = infile.tell()
1184             # Attempt to open the file object as a rar file
1185             with rarfile.RarFile(infile) as rarf:
1186                 pass
1187             # Restore the file position
1188             infile.seek(current_position)
1189         else:
1190             # Assume it's a filename and attempt to open it as a rar file
1191             with rarfile.RarFile(infile) as rarf:
1192                 pass
1193         return True
1194     except (rarfile.Error, AttributeError, IOError):
1195         return False
1196
1197
1198 def SevenZipFileCheck(infile):
1199     try:
1200         # Check if the input is a file-like object
1201         if hasattr(infile, 'read'):
1202             # Save the current file position
1203             current_position = infile.tell()
1204             # Attempt to open the file object as a 7z file
1205             with py7zr.SevenZipFile(infile, 'r') as archive:
1206                 pass
1207             # Restore the file position
1208             infile.seek(current_position)
1209         else:
1210             # Assume it's a filename and attempt to open it as a 7z file
1211             with py7zr.SevenZipFile(infile, 'r') as archive:
1212                 pass
1213         return True
1214     except (py7zr.Bad7zFile, AttributeError, IOError):
1215         return False
1216
1217 # initial_value can be 0xFFFF or 0x0000
1218
1219
1220 def crc16_ansi(msg, initial_value=0xFFFF):
1221     # CRC-16-IBM / CRC-16-ANSI polynomial and initial value
1222     poly = 0x8005  # Polynomial for CRC-16-IBM / CRC-16-ANSI
1223     crc = initial_value  # Initial value
1224     for b in msg:
1225         crc ^= b << 8  # XOR byte into CRC top byte
1226         for _ in range(8):  # Process each bit
1227             if crc & 0x8000:  # If the top bit is set
1228                 # Shift left and XOR with the polynomial
1229                 crc = (crc << 1) ^ poly
1230             else:
1231                 crc = crc << 1  # Just shift left
1232             crc &= 0xFFFF  # Ensure CRC remains 16-bit
1233     return crc
1234
1235 # initial_value can be 0xFFFF or 0x0000
1236
1237
1238 def crc16_ibm(msg, initial_value=0xFFFF):
1239     return crc16_ansi(msg, initial_value)
1240
1241 # initial_value is 0xFFFF
1242
1243
1244 def crc16(msg):
1245     return crc16_ansi(msg, 0xFFFF)
1246
1247 # initial_value can be 0xFFFF, 0x1D0F or 0x0000
1248
1249
1250 def crc16_ccitt(msg, initial_value=0xFFFF):
1251     # CRC-16-CCITT polynomial
1252     poly = 0x1021  # Polynomial for CRC-16-CCITT
1253     # Use the specified initial value
1254     crc = initial_value
1255     for b in msg:
1256         crc ^= b << 8  # XOR byte into CRC top byte
1257         for _ in range(8):  # Process each bit
1258             if crc & 0x8000:  # If the top bit is set
1259                 # Shift left and XOR with the polynomial
1260                 crc = (crc << 1) ^ poly
1261             else:
1262                 crc = crc << 1  # Just shift left
1263             crc &= 0xFFFF  # Ensure CRC remains 16-bit
1264     return crc
1265
1266 # initial_value can be 0x42F0E1EBA9EA3693 or 0x0000000000000000
1267
1268
1269 def crc64_ecma(msg, initial_value=0x0000000000000000):
1270     # CRC-64-ECMA polynomial and initial value
1271     poly = 0x42F0E1EBA9EA3693
1272     crc = initial_value  # Initial value for CRC-64-ECMA
1273     for b in msg:
1274         crc ^= b << 56  # XOR byte into the most significant byte of the CRC
1275         for _ in range(8):  # Process each bit
1276             if crc & (1 << 63):  # Check if the leftmost (most significant) bit is set
1277                 # Shift left and XOR with poly if the MSB is 1
1278                 crc = (crc << 1) ^ poly
1279             else:
1280                 crc <<= 1  # Just shift left if the MSB is 0
1281             crc &= 0xFFFFFFFFFFFFFFFF  # Ensure CRC remains 64-bit
1282     return crc
1283
1284 # initial_value can be 0x000000000000001B or 0xFFFFFFFFFFFFFFFF
1285
1286
1287 def crc64_iso(msg, initial_value=0xFFFFFFFFFFFFFFFF):
1288     # CRC-64-ISO polynomial and initial value
1289     poly = 0x000000000000001B
1290     crc = initial_value  # Common initial value for CRC-64-ISO
1291     for b in msg:
1292         crc ^= b << 56  # XOR byte into the most significant byte of the CRC
1293         for _ in range(8):  # Process each bit
1294             if crc & (1 << 63):  # Check if the leftmost (most significant) bit is set
1295                 # Shift left and XOR with poly if the MSB is 1
1296                 crc = (crc << 1) ^ poly
1297             else:
1298                 crc <<= 1  # Just shift left if the MSB is 0
1299             crc &= 0xFFFFFFFFFFFFFFFF  # Ensure CRC remains 64-bit
1300     return crc
1301
1302
1303 def GetDataFromArray(data, path, default=None):
1304     element = data
1305     try:
1306         for key in path:
1307             element = element[key]
1308         return element
1309     except (KeyError, TypeError, IndexError):
1310         return default
1311
1312
1313 def GetDataFromArrayAlt(structure, path, default=None):
1314     element = structure
1315     for key in path:
1316         if isinstance(element, dict) and key in element:
1317             element = element[key]
1318         elif isinstance(element, list) and isinstance(key, int) and -len(element) <= key < len(element):
1319             element = element[key]
1320         else:
1321             return default
1322     return element
1323
1324
1325 def GetHeaderChecksum(inlist=[], checksumtype="crc32", encodedata=True, formatspecs=__file_format_dict__):
1326     formatspecs = FormatSpecsListToDict(formatspecs)
1327     fileheader = AppendNullBytes(inlist, formatspecs['format_delimiter']) if isinstance(
1328         inlist, list) else AppendNullByte(inlist, formatspecs['format_delimiter'])
1329     if encodedata:
1330         fileheader = fileheader.encode('UTF-8')
1331     checksum_methods = {
1332         "crc16": lambda data: format(crc16(data) & 0xffff, '04x').lower(),
1333         "crc16_ansi": lambda data: format(crc16(data) & 0xffff, '04x').lower(),
1334         "crc16_ibm": lambda data: format(crc16(data) & 0xffff, '04x').lower(),
1335         "crc16_ccitt": lambda data: format(crc16_ccitt(data) & 0xffff, '04x').lower(),
1336         "adler32": lambda data: format(zlib.adler32(data) & 0xffffffff, '08x').lower(),
1337         "crc32": lambda data: format(crc32(data) & 0xffffffff, '08x').lower(),
1338         "crc64_ecma": lambda data: format(crc64_ecma(data) & 0xffffffffffffffff, '016x').lower(),
1339         "crc64": lambda data: format(crc64_iso(data) & 0xffffffffffffffff, '016x').lower(),
1340         "crc64_iso": lambda data: format(crc64_iso(data) & 0xffffffffffffffff, '016x').lower(),
1341     }
1342     if checksumtype in checksum_methods:
1343         return checksum_methods[checksumtype](fileheader)
1344     elif CheckSumSupportAlt(checksumtype, hashlib_guaranteed):
1345         checksumoutstr = hashlib.new(checksumtype)
1346         checksumoutstr.update(fileheader)
1347         return checksumoutstr.hexdigest().lower()
1348     return format(0, 'x').lower()
1349
1350
1351 def GetFileChecksum(instr, checksumtype="crc32", encodedata=True, formatspecs=__file_format_dict__):
1352     formatspecs = FormatSpecsListToDict(formatspecs)
1353     if encodedata:
1354         instr = instr.encode('UTF-8')
1355     checksum_methods = {
1356         "crc16": lambda data: format(crc16(data) & 0xffff, '04x').lower(),
1357         "crc16_ansi": lambda data: format(crc16(data) & 0xffff, '04x').lower(),
1358         "crc16_ibm": lambda data: format(crc16(data) & 0xffff, '04x').lower(),
1359         "crc16_ccitt": lambda data: format(crc16_ccitt(data) & 0xffff, '04x').lower(),
1360         "adler32": lambda data: format(zlib.adler32(data) & 0xffffffff, '08x').lower(),
1361         "crc32": lambda data: format(crc32(data) & 0xffffffff, '08x').lower(),
1362         "crc64_ecma": lambda data: format(crc64_ecma(data) & 0xffffffffffffffff, '016x').lower(),
1363         "crc64": lambda data: format(crc64_iso(data) & 0xffffffffffffffff, '016x').lower(),
1364         "crc64_iso": lambda data: format(crc64_iso(data) & 0xffffffffffffffff, '016x').lower(),
1365     }
1366     if checksumtype in checksum_methods:
1367         return checksum_methods[checksumtype](instr)
1368     elif CheckSumSupportAlt(checksumtype, hashlib_guaranteed):
1369         checksumoutstr = hashlib.new(checksumtype)
1370         checksumoutstr.update(instr)
1371         return checksumoutstr.hexdigest().lower()
1372     return format(0, 'x').lower()
1373
1374
1375 def ValidateHeaderChecksum(inlist=[], checksumtype="crc32", inchecksum="0", formatspecs=__file_format_dict__):
1376     formatspecs = FormatSpecsListToDict(formatspecs)
1377     catfileheadercshex = GetHeaderChecksum(
1378         inlist, checksumtype, True, formatspecs).lower()
1379     return inchecksum.lower() == catfileheadercshex
1380
1381
1382 def ValidateFileChecksum(infile, checksumtype="crc32", inchecksum="0", formatspecs=__file_format_dict__):
1383     formatspecs = FormatSpecsListToDict(formatspecs)
1384     catinfilecshex = GetFileChecksum(
1385         infile, checksumtype, True, formatspecs).lower()
1386     return inchecksum.lower() == catinfilecshex
1387
1388
1389 def ReadTillNullByteOld(fp, delimiter=__file_format_dict__['format_delimiter']):
1390     curbyte = b""
1391     curfullbyte = b""
1392     nullbyte = delimiter.encode("UTF-8")
1393     while(True):
1394         curbyte = fp.read(1)
1395         if(curbyte == nullbyte or not curbyte):
1396             break
1397         curfullbyte = curfullbyte + curbyte
1398     return curfullbyte.decode('UTF-8')
1399
1400
1401 def ReadUntilNullByteOld(fp, delimiter=__file_format_dict__['format_delimiter']):
1402     return ReadTillNullByteOld(fp, delimiter)
1403
1404
1405 def ReadTillNullByteAlt(fp, delimiter=__file_format_dict__['format_delimiter'], chunk_size=1024, max_read=1024000):
1406     delimiter = delimiter.encode('UTF-8')  # Ensure the delimiter is in bytes
1407     buffer = bytearray()
1408     total_read = 0
1409     delimiter_length = len(delimiter)
1410     while True:
1411         chunk = fp.read(chunk_size)
1412         if not chunk:
1413             # End of file reached without finding the delimiter
1414             break
1415         buffer.extend(chunk)
1416         total_read += len(chunk)
1417         if delimiter in buffer:
1418             # Delimiter found, calculate where to reset the file pointer
1419             index = buffer.find(delimiter)
1420             # Calculate how many extra bytes were read after the delimiter
1421             extra_bytes_read = len(buffer) - (index + delimiter_length)
1422             # Move the file pointer back to just after the delimiter
1423             fp.seek(-extra_bytes_read, 1)
1424             buffer = buffer[:index]
1425             break
1426         if total_read >= max_read:
1427             # Stop reading if max limit is reached to prevent excessive memory usage
1428             raise MemoryError(
1429                 "Maximum read limit reached without finding the delimiter.")
1430         # Check for incomplete UTF-8 sequences at the end of the buffer
1431         if len(buffer) > 1 and 128 <= buffer[-1] < 192:
1432             # This suggests that the last byte might be the start of a multi-byte character
1433             # Try to read one more byte to complete the character
1434             extra_byte = fp.read(1)
1435             if extra_byte:
1436                 buffer.extend(extra_byte)
1437             else:
1438                 # No more data available
1439                 break
1440     try:
1441         return buffer.decode('UTF-8', errors='replace')
1442     except UnicodeDecodeError:
1443         return buffer.decode('UTF-8', errors='replace')
1444
1445
1446 def ReadUntilNullByteAlt(fp, delimiter=__file_format_dict__['format_delimiter'], chunk_size=1024, max_read=1024000):
1447     return ReadTillNullByteAlt(fp, delimiter, chunk_size, max_read)
1448
1449
1450 def ReadTillNullByte(fp, delimiter=__file_format_dict__['format_delimiter'], max_read=1024000):
1451     curfullbyte = bytearray()
1452     nullbyte = delimiter.encode("UTF-8")
1453     total_read = 0  # Track the total number of bytes read
1454     while True:
1455         curbyte = fp.read(1)
1456         if curbyte == nullbyte or not curbyte:
1457             break
1458         curfullbyte.extend(curbyte)
1459         total_read += 1
1460         if total_read >= max_read:
1461             raise MemoryError(
1462                 "Maximum read limit reached without finding the delimiter.")
1463     # Decode the full byte array to string once out of the loop
1464     try:
1465         return curfullbyte.decode('UTF-8')
1466     except UnicodeDecodeError:
1467         # Handle potential partial UTF-8 characters
1468         for i in range(1, 4):
1469             try:
1470                 return curfullbyte[:-i].decode('UTF-8')
1471             except UnicodeDecodeError:
1472                 continue
1473         raise  # Re-raise if decoding fails even after trimming
1474
1475
1476 def ReadUntilNullByte(fp, delimiter=__file_format_dict__['format_delimiter'], max_read=1024000):
1477     return ReadTillNullByte(fp, delimiter, max_read)
1478
1479
1480 def ReadTillNullByteByNum(fp, delimiter=__file_format_dict__['format_delimiter'], num_delimiters=1, chunk_size=1024, max_read=1024000):
1481     delimiter = delimiter.encode('UTF-8')  # Ensure the delimiter is in bytes
1482     buffer = bytearray()
1483     total_read = 0
1484     delimiter_length = len(delimiter)
1485     results = []
1486     while len(results) < num_delimiters:
1487         chunk = fp.read(chunk_size)
1488         if not chunk:
1489             # End of file reached; decode whatever is collected if it's the last needed part
1490             if len(buffer) > 0:
1491                 results.append(buffer.decode('UTF-8', errors='replace'))
1492             break
1493         buffer.extend(chunk)
1494         total_read += len(chunk)
1495         # Check if we have found the delimiter
1496         while delimiter in buffer:
1497             index = buffer.find(delimiter)
1498             # Decode the section before the delimiter
1499             results.append(buffer[:index].decode('UTF-8', errors='replace'))
1500             # Remove the processed part from the buffer
1501             buffer = buffer[index + delimiter_length:]
1502             if len(results) == num_delimiters:
1503                 # If reached the required number of delimiters, adjust the file pointer and stop
1504                 fp.seek(-len(buffer), 1)
1505                 return results
1506         if total_read >= max_read:
1507             # Stop reading if max limit is reached to prevent excessive memory usage
1508             raise MemoryError(
1509                 "Maximum read limit reached without finding the delimiter.")
1510         # Check for incomplete UTF-8 sequences at the end of the buffer
1511         if len(buffer) > 1 and 128 <= buffer[-1] < 192:
1512             # This suggests that the last byte might be the start of a multi-byte character
1513             # Try to read one more byte to complete the character
1514             extra_byte = fp.read(1)
1515             if extra_byte:
1516                 buffer.extend(extra_byte)
1517             else:
1518                 # No more data available
1519                 break
1520     # Process remaining buffer if less than the required number of delimiters were found
1521     if len(buffer) > 0 and len(results) < num_delimiters:
1522         results.append(buffer.decode('UTF-8', errors='replace'))
1523     return results
1524
1525
1526 def ReadUntilNullByteByNum(fp, delimiter=__file_format_dict__['format_delimiter'], num_delimiters=1, chunk_size=1024, max_read=1024000):
1527     return ReadTillNullByteByNum(fp, delimiter, num_delimiters, chunk_size, max_read)
1528
1529
1530 def SeekToEndOfFile(fp):
1531     lasttell = 0
1532     while(True):
1533         fp.seek(1, 1)
1534         if(lasttell == fp.tell()):
1535             break
1536         lasttell = fp.tell()
1537     return True
1538
1539
1540 def ReadFileHeaderData(fp, rounds=0, delimiter=__file_format_dict__['format_delimiter']):
1541     rocount = 0
1542     roend = int(rounds)
1543     HeaderOut = []
1544     while(rocount < roend):
1545         HeaderOut.append(ReadTillNullByte(fp, delimiter))
1546         rocount = rocount + 1
1547     return HeaderOut
1548
1549
1550 def ReadFileHeaderDataBySize(fp, delimiter=__file_format_dict__['format_delimiter']):
1551     headerpresize = ReadTillNullByte(fp, delimiter)
1552     headersize = int(headerpresize, 16)
1553     if(headersize <= 0):
1554         return []
1555     headercontent = str(fp.read(headersize).decode('UTF-8')).split(delimiter)
1556     fp.seek(1, 1)
1557     rocount = 0
1558     roend = int(len(headercontent))
1559     HeaderOut = [headerpresize]
1560     while(rocount < roend):
1561         HeaderOut.append(headercontent[rocount])
1562         rocount = rocount + 1
1563     return HeaderOut
1564
1565
1566 def ReadFileHeaderDataWoSize(fp, delimiter=__file_format_dict__['format_delimiter']):
1567     preheaderdata = ReadFileHeaderData(fp, 2, delimiter)
1568     headersize = int(preheaderdata[0], 16)
1569     headernumfields = int(preheaderdata[1], 16)
1570     if(headersize <= 0 or headernumfields <= 0):
1571         return []
1572     headerdata = ReadTillNullByteByNum(fp, delimiter, headernumfields)
1573     #headerdata = ReadFileHeaderData(fp, headernumfields, delimiter);
1574     HeaderOut = preheaderdata + headerdata
1575     return HeaderOut
1576
1577
1578 def ReadFileHeaderDataBySizeWithContent(fp, listonly=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__):
1579     formatspecs = FormatSpecsListToDict(formatspecs)
1580     delimiter = formatspecs['format_delimiter']
1581     fheaderstart = fp.tell()
1582     HeaderOut = ReadFileHeaderDataBySize(fp, delimiter)
1583     if(len(HeaderOut) == 0):
1584         return False
1585     if(re.findall("^[.|/]", HeaderOut[3])):
1586         fname = HeaderOut[3]
1587     else:
1588         fname = "./"+HeaderOut[3]
1589     fcs = HeaderOut[-2].lower()
1590     fccs = HeaderOut[-1].lower()
1591     fsize = int(HeaderOut[5], 16)
1592     fcompression = HeaderOut[12]
1593     fcsize = int(HeaderOut[13], 16)
1594     fseeknextfile = HeaderOut[25]
1595     newfcs = GetHeaderChecksum(
1596         HeaderOut[:-2], HeaderOut[-4].lower(), True, formatspecs)
1597     if(fcs != newfcs and not skipchecksum):
1598         VerbosePrintOut("File Header Checksum Error with file " +
1599                         fname + " at offset " + str(fheaderstart))
1600         VerbosePrintOut("'" + str(fcs) + "' != " + "'" + str(newfcs) + "'")
1601         return False
1602     fhend = fp.tell() - 1
1603     fcontentstart = fp.tell()
1604     fcontents = BytesIO()
1605     if(fsize > 0 and not listonly):
1606         if(fcompression == "none" or fcompression == "" or fcompression == "auto"):
1607             fcontents.write(fp.read(fsize))
1608         else:
1609             fcontents.write(fp.read(fcsize))
1610     elif(fsize > 0 and listonly):
1611         if(fcompression == "none" or fcompression == "" or fcompression == "auto"):
1612             fp.seek(fsize, 1)
1613         else:
1614             fp.seek(fcsize, 1)
1615     fcontents.seek(0, 0)
1616     newfccs = GetFileChecksum(
1617         fcontents.read(), HeaderOut[-3].lower(), False, formatspecs)
1618     if(fccs != newfccs and not skipchecksum and not listonly):
1619         VerbosePrintOut("File Content Checksum Error with file " +
1620                         fname + " at offset " + str(fcontentstart))
1621         VerbosePrintOut("'" + str(fccs) + "' != " + "'" + str(newfccs) + "'")
1622         return False
1623     if(fcompression == "none" or fcompression == "" or fcompression == "auto"):
1624         pass
1625     else:
1626         fcontents.seek(0, 0)
1627         if(uncompress):
1628             fcontents = UncompressArchiveFile(fcontents, formatspecs)
1629     fcontentend = fp.tell()
1630     if(re.findall("^\\+([0-9]+)", fseeknextfile)):
1631         fseeknextasnum = int(fseeknextfile.replace("+", ""))
1632         if(abs(fseeknextasnum) == 0):
1633             pass
1634         fp.seek(fseeknextasnum, 1)
1635     elif(re.findall("^\\-([0-9]+)", fseeknextfile)):
1636         fseeknextasnum = int(fseeknextfile)
1637         if(abs(fseeknextasnum) == 0):
1638             pass
1639         fp.seek(fseeknextasnum, 1)
1640     elif(re.findall("^([0-9]+)", fseeknextfile)):
1641         fseeknextasnum = int(fseeknextfile)
1642         if(abs(fseeknextasnum) == 0):
1643             pass
1644         fp.seek(fseeknextasnum, 0)
1645     else:
1646         return False
1647     HeaderOut.append(fcontents)
1648     return HeaderOut
1649
1650
1651 def ReadFileHeaderDataBySizeWithContentToArray(fp, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__):
1652     formatspecs = FormatSpecsListToDict(formatspecs)
1653     delimiter = formatspecs['format_delimiter']
1654     fheaderstart = fp.tell()
1655     if(formatspecs['new_style']):
1656         HeaderOut = ReadFileHeaderDataBySize(fp, delimiter)
1657     else:
1658         HeaderOut = ReadFileHeaderDataWoSize(fp, delimiter)
1659     if(len(HeaderOut) == 0):
1660         return False
1661     fheadsize = int(HeaderOut[0], 16)
1662     fnumfields = int(HeaderOut[1], 16)
1663     ftype = int(HeaderOut[2], 16)
1664     if(re.findall("^[.|/]", HeaderOut[3])):
1665         fname = HeaderOut[3]
1666     else:
1667         fname = "./"+HeaderOut[3]
1668     fbasedir = os.path.dirname(fname)
1669     flinkname = HeaderOut[4]
1670     fsize = int(HeaderOut[5], 16)
1671     fatime = int(HeaderOut[6], 16)
1672     fmtime = int(HeaderOut[7], 16)
1673     fctime = int(HeaderOut[8], 16)
1674     fbtime = int(HeaderOut[9], 16)
1675     fmode = int(HeaderOut[10], 16)
1676     fchmode = stat.S_IMODE(fmode)
1677     ftypemod = stat.S_IFMT(fmode)
1678     fwinattributes = int(HeaderOut[11], 16)
1679     fcompression = HeaderOut[12]
1680     fcsize = int(HeaderOut[13], 16)
1681     fuid = int(HeaderOut[14], 16)
1682     funame = HeaderOut[15]
1683     fgid = int(HeaderOut[16], 16)
1684     fgname = HeaderOut[17]
1685     fid = int(HeaderOut[18], 16)
1686     finode = int(HeaderOut[19], 16)
1687     flinkcount = int(HeaderOut[20], 16)
1688     fdev_minor = int(HeaderOut[21], 16)
1689     fdev_major = int(HeaderOut[22], 16)
1690     frdev_minor = int(HeaderOut[23], 16)
1691     frdev_major = int(HeaderOut[24], 16)
1692     fseeknextfile = HeaderOut[25]
1693     fextrasize = int(HeaderOut[26], 16)
1694     fextrafields = int(HeaderOut[27], 16)
1695     extrafieldslist = []
1696     extrastart = 28
1697     extraend = extrastart + fextrafields
1698     extrafieldslist = []
1699     if(extrastart < extraend):
1700         extrafieldslist.append(HeaderOut[extrastart])
1701         extrastart = extrastart + 1
1702     fcs = HeaderOut[-2].lower()
1703     fccs = HeaderOut[-1].lower()
1704     newfcs = GetHeaderChecksum(
1705         HeaderOut[:-2], HeaderOut[-4].lower(), True, formatspecs)
1706     if(fcs != newfcs and not skipchecksum):
1707         VerbosePrintOut("File Header Checksum Error with file " +
1708                         fname + " at offset " + str(fheaderstart))
1709         VerbosePrintOut("'" + str(fcs) + "' != " + "'" + str(newfcs) + "'")
1710         return False
1711     fhend = fp.tell() - 1
1712     fcontentstart = fp.tell()
1713     fcontents = BytesIO()
1714     pyhascontents = False
1715     if(fsize > 0 and not listonly):
1716         if(fcompression == "none" or fcompression == "" or fcompression == "auto"):
1717             fcontents.write(fp.read(fsize))
1718         else:
1719             fcontents.write(fp.read(fcsize))
1720         pyhascontents = True
1721     elif(fsize > 0 and listonly):
1722         if(fcompression == "none" or fcompression == "" or fcompression == "auto"):
1723             fp.seek(fsize, 1)
1724         else:
1725             fp.seek(fcsize, 1)
1726         pyhascontents = False
1727     fcontents.seek(0, 0)
1728     newfccs = GetFileChecksum(
1729         fcontents.read(), HeaderOut[-3].lower(), False, formatspecs)
1730     if(fccs != newfccs and not skipchecksum and not listonly):
1731         VerbosePrintOut("File Content Checksum Error with file " +
1732                         fname + " at offset " + str(fcontentstart))
1733         VerbosePrintOut("'" + str(fccs) + "' != " + "'" + str(newfccs) + "'")
1734         return False
1735     if(fcompression == "none" or fcompression == "" or fcompression == "auto"):
1736         pass
1737     else:
1738         fcontents.seek(0, 0)
1739         if(uncompress):
1740             fcontents = UncompressArchiveFile(fcontents, formatspecs)
1741             fcontents.seek(0, 0)
1742             fccs = GetFileChecksum(
1743                 fcontents.read(), HeaderOut[-3].lower(), False, formatspecs)
1744     fcontentend = fp.tell() - 1
1745     if(re.findall("^\\+([0-9]+)", fseeknextfile)):
1746         fseeknextasnum = int(fseeknextfile.replace("+", ""))
1747         if(abs(fseeknextasnum) == 0):
1748             pass
1749         fp.seek(fseeknextasnum, 1)
1750     elif(re.findall("^\\-([0-9]+)", fseeknextfile)):
1751         fseeknextasnum = int(fseeknextfile)
1752         if(abs(fseeknextasnum) == 0):
1753             pass
1754         fp.seek(fseeknextasnum, 1)
1755     elif(re.findall("^([0-9]+)", fseeknextfile)):
1756         fseeknextasnum = int(fseeknextfile)
1757         if(abs(fseeknextasnum) == 0):
1758             pass
1759         fp.seek(fseeknextasnum, 0)
1760     else:
1761         return False
1762     fcontents.seek(0, 0)
1763     if(not contentasfile):
1764         fcontents = fcontents.read()
1765     catlist = {'fheadersize': fheadsize, 'fhstart': fheaderstart, 'fhend': fhend, 'ftype': ftype, 'fname': fname, 'fbasedir': fbasedir, 'flinkname': flinkname, 'fsize': fsize, 'fatime': fatime, 'fmtime': fmtime, 'fctime': fctime, 'fbtime': fbtime, 'fmode': fmode, 'fchmode': fchmode, 'ftypemod': ftypemod, 'fwinattributes': fwinattributes, 'fcompression': fcompression, 'fcsize': fcsize, 'fuid': fuid, 'funame': funame, 'fgid': fgid, 'fgname': fgname, 'finode': finode, 'flinkcount': flinkcount, 'fminor': fdev_minor,
1766                'fmajor': fdev_major, 'frminor': frdev_minor, 'frmajor': frdev_major, 'fseeknextfile': fseeknextfile, 'fheaderchecksumtype': HeaderOut[-4], 'fcontentchecksumtype': HeaderOut[-3], 'fnumfields': fnumfields + 2, 'frawheader': HeaderOut, 'fextrafields': fextrafields, 'fextrafieldsize': fextrasize, 'fextralist': extrafieldslist, 'fheaderchecksum': fcs, 'fcontentchecksum': fccs, 'fhascontents': pyhascontents, 'fcontentstart': fcontentstart, 'fcontentend': fcontentend, 'fcontentasfile': contentasfile, 'fcontents': fcontents}
1767     return catlist
1768
1769
1770 def ReadFileHeaderDataBySizeWithContentToList(fp, listonly=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__):
1771     formatspecs = FormatSpecsListToDict(formatspecs)
1772     delimiter = formatspecs['format_delimiter']
1773     fheaderstart = fp.tell()
1774     if(formatspecs['new_style']):
1775         HeaderOut = ReadFileHeaderDataBySize(fp, delimiter)
1776     else:
1777         HeaderOut = ReadFileHeaderDataWoSize(fp, delimiter)
1778     if(len(HeaderOut) == 0):
1779         return False
1780     fheadsize = int(HeaderOut[0], 16)
1781     fnumfields = int(HeaderOut[1], 16)
1782     ftype = int(HeaderOut[2], 16)
1783     if(re.findall("^[.|/]", HeaderOut[3])):
1784         fname = HeaderOut[3]
1785     else:
1786         fname = "./"+HeaderOut[3]
1787     fbasedir = os.path.dirname(fname)
1788     flinkname = HeaderOut[4]
1789     fsize = int(HeaderOut[5], 16)
1790     fatime = int(HeaderOut[6], 16)
1791     fmtime = int(HeaderOut[7], 16)
1792     fctime = int(HeaderOut[8], 16)
1793     fbtime = int(HeaderOut[9], 16)
1794     fmode = int(HeaderOut[10], 16)
1795     fchmode = stat.S_IMODE(fmode)
1796     ftypemod = stat.S_IFMT(fmode)
1797     fwinattributes = int(HeaderOut[11], 16)
1798     fcompression = HeaderOut[12]
1799     fcsize = int(HeaderOut[13], 16)
1800     fuid = int(HeaderOut[14], 16)
1801     funame = HeaderOut[15]
1802     fgid = int(HeaderOut[16], 16)
1803     fgname = HeaderOut[17]
1804     fid = int(HeaderOut[18], 16)
1805     finode = int(HeaderOut[19], 16)
1806     flinkcount = int(HeaderOut[20], 16)
1807     fdev_minor = int(HeaderOut[21], 16)
1808     fdev_major = int(HeaderOut[22], 16)
1809     frdev_minor = int(HeaderOut[23], 16)
1810     frdev_major = int(HeaderOut[24], 16)
1811     fseeknextfile = HeaderOut[25]
1812     fextrasize = int(HeaderOut[26], 16)
1813     fextrafields = int(HeaderOut[27], 16)
1814     extrafieldslist = []
1815     extrastart = 28
1816     extraend = extrastart + fextrafields
1817     extrafieldslist = []
1818     if(extrastart < extraend):
1819         extrafieldslist.append(HeaderOut[extrastart])
1820         extrastart = extrastart + 1
1821     fheaderchecksumtype = HeaderOut[extrastart].lower()
1822     fcontentchecksumtype = HeaderOut[extrastart + 1].lower()
1823     fcs = HeaderOut[-2].lower()
1824     fccs = HeaderOut[-1].lower()
1825     newfcs = GetHeaderChecksum(
1826         HeaderOut[:-2], HeaderOut[-4].lower(), True, formatspecs)
1827     if(fcs != newfcs and not skipchecksum):
1828         VerbosePrintOut("File Header Checksum Error with file " +
1829                         fname + " at offset " + str(fheaderstart))
1830         VerbosePrintOut("'" + str(fcs) + "' != " + "'" + str(newfcs) + "'")
1831         return False
1832     fhend = fp.tell() - 1
1833     fcontentstart = fp.tell()
1834     fcontents = BytesIO()
1835     pyhascontents = False
1836     if(fsize > 0 and not listonly):
1837         if(fcompression == "none" or fcompression == "" or fcompression == "auto"):
1838             fcontents.write(fp.read(fsize))
1839         else:
1840             fcontents.write(fp.read(fcsize))
1841         pyhascontents = True
1842     elif(fsize > 0 and listonly):
1843         if(fcompression == "none" or fcompression == "" or fcompression == "atuo"):
1844             fp.seek(fsize, 1)
1845         else:
1846             fp.seek(fcsize, 1)
1847         pyhascontents = False
1848     fcontents.seek(0, 0)
1849     newfccs = GetFileChecksum(
1850         fcontents.read(), HeaderOut[-3].lower(), False, formatspecs)
1851     if(fccs != newfccs and not skipchecksum and not listonly):
1852         VerbosePrintOut("File Content Checksum Error with file " +
1853                         fname + " at offset " + str(fcontentstart))
1854         VerbosePrintOut("'" + str(fccs) + "' != " + "'" + str(newfccs) + "'")
1855         return False
1856     if(fcompression == "none" or fcompression == "" or fcompression == "auto"):
1857         pass
1858     else:
1859         fcontents.seek(0, 0)
1860         if(uncompress):
1861             fcontents = UncompressArchiveFile(fcontents, formatspecs)
1862             fcontents.seek(0, 0)
1863     fcontentend = fp.tell() - 1
1864     if(re.findall("^\\+([0-9]+)", fseeknextfile)):
1865         fseeknextasnum = int(fseeknextfile.replace("+", ""))
1866         if(abs(fseeknextasnum) == 0):
1867             pass
1868         fp.seek(fseeknextasnum, 1)
1869     elif(re.findall("^\\-([0-9]+)", fseeknextfile)):
1870         fseeknextasnum = int(fseeknextfile)
1871         if(abs(fseeknextasnum) == 0):
1872             pass
1873         fp.seek(fseeknextasnum, 1)
1874     elif(re.findall("^([0-9]+)", fseeknextfile)):
1875         fseeknextasnum = int(fseeknextfile)
1876         if(abs(fseeknextasnum) == 0):
1877             pass
1878         fp.seek(fseeknextasnum, 0)
1879     else:
1880         return False
1881     catlist = [ftype, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression, fcsize, fuid, funame, fgid, fgname, fid,
1882                finode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, fseeknextfile, extrafieldslist, fheaderchecksumtype, fcontentchecksumtype, fcontents]
1883     return catlist
1884
1885
1886 def ReadFileDataBySizeWithContent(fp, listonly=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__):
1887     formatspecs = FormatSpecsListToDict(formatspecs)
1888     delimiter = formatspecs['format_delimiter']
1889     curloc = fp.tell()
1890     if(curloc > 0):
1891         fp.seek(0, 0)
1892     catheader = ReadFileHeaderData(fp, 4, delimiter)
1893     if(curloc > 0):
1894         fp.seek(curloc, 0)
1895     headercheck = ValidateHeaderChecksum(
1896         catheader[:-1], catheader[2], catheader[3], formatspecs)
1897     newfcs = GetHeaderChecksum(catheader[:-2], catheader[2], True, formatspecs)
1898     if(not headercheck and not skipchecksum):
1899         VerbosePrintOut(
1900             "File Header Checksum Error with file at offset " + str(0))
1901         VerbosePrintOut("'" + str(newfcs) + "' != " +
1902                         "'" + str(catheader[3]) + "'")
1903         return False
1904     fnumfiles = int(catheader[1], 16)
1905     countnum = 0
1906     flist = []
1907     while(countnum < fnumfiles):
1908         HeaderOut = ReadFileHeaderDataBySizeWithContent(
1909             fp, listonly, uncompress, skipchecksum, formatspecs)
1910         if(len(HeaderOut) == 0):
1911             break
1912         flist.append(HeaderOut)
1913         countnum = countnum + 1
1914     return flist
1915
1916
1917 def ReadFileDataBySizeWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__):
1918     formatspecs = FormatSpecsListToDict(formatspecs)
1919     delimiter = formatspecs['format_delimiter']
1920     curloc = fp.tell()
1921     if(curloc > 0):
1922         fp.seek(0, 0)
1923     catheader = ReadFileHeaderData(fp, 4, delimiter)
1924     if(curloc > 0):
1925         fp.seek(curloc, 0)
1926     headercheck = ValidateHeaderChecksum(
1927         catheader[:-1], catheader[2], catheader[3], formatspecs)
1928     newfcs = GetHeaderChecksum(catheader[:-2], catheader[2], True, formatspecs)
1929     if(not headercheck and not skipchecksum):
1930         VerbosePrintOut(
1931             "File Header Checksum Error with file at offset " + str(0))
1932         VerbosePrintOut("'" + str(newfcs) + "' != " +
1933                         "'" + str(catheader[3]) + "'")
1934         return False
1935     catstring = catheader[0]
1936     catversion = re.findall("([\\d]+)", catstring)
1937     catversions = re.search('(.*?)(\\d+)', catstring).groups()
1938     fprenumfiles = catheader[1]
1939     fnumfiles = int(fprenumfiles, 16)
1940     fprechecksumtype = catheader[2]
1941     fprechecksum = catheader[3]
1942     catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1],
1943                'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': []}
1944     if(seekstart < 0 and seekstart > fnumfiles):
1945         seekstart = 0
1946     if(seekend == 0 or seekend > fnumfiles and seekend < seekstart):
1947         seekend = fnumfiles
1948     elif(seekend < 0 and abs(seekend) <= fnumfiles and abs(seekend) >= seekstart):
1949         seekend = fnumfiles - abs(seekend)
1950     if(seekstart > 0):
1951         il = 0
1952         while(il < seekstart):
1953             prefhstart = fp.tell()
1954             preheaderdata = ReadFileHeaderDataBySize(
1955                 fp, formatspecs['format_delimiter'])
1956             if(len(preheaderdata) == 0):
1957                 break
1958             prefsize = int(preheaderdata[5], 16)
1959             prefseeknextfile = preheaderdata[25]
1960             prenewfcs = GetHeaderChecksum(
1961                 preheaderdata[:-2], preheaderdata[-4].lower(), True, formatspecs)
1962             prefcs = preheaderdata[-2]
1963             if(prefcs != prenewfcs and not skipchecksum):
1964                 VVerbosePrintOut("File Header Checksum Error with file " +
1965                                  prefname + " at offset " + str(prefhstart))
1966                 VerbosePrintOut("'" + str(prefcs) + "' != " +
1967                                 "'" + str(prenewfcs) + "'")
1968                 return False
1969                 valid_archive = False
1970                 invalid_archive = True
1971             prefhend = fp.tell() - 1
1972             prefcontentstart = fp.tell()
1973             prefcontents = BytesIO()
1974             pyhascontents = False
1975             if(prefsize > 0):
1976                 prefcontents.write(fp.read(prefsize))
1977                 prefcontents.seek(0, 0)
1978                 prenewfccs = GetFileChecksum(
1979                     prefcontents.read(), preheaderdata[-3].lower(), False, formatspecs)
1980                 prefccs = preheaderdata[-1]
1981                 pyhascontents = True
1982                 if(prefccs != prenewfccs and not skipchecksum):
1983                     VerbosePrintOut("File Content Checksum Error with file " +
1984                                     prefname + " at offset " + str(prefcontentstart))
1985                     VerbosePrintOut("'" + str(prefccs) +
1986                                     "' != " + "'" + str(prenewfccs) + "'")
1987                     return False
1988             if(re.findall("^\\+([0-9]+)", prefseeknextfile)):
1989                 fseeknextasnum = int(prefseeknextfile.replace("+", ""))
1990                 if(abs(fseeknextasnum) == 0):
1991                     pass
1992                 fp.seek(fseeknextasnum, 1)
1993             elif(re.findall("^\\-([0-9]+)", prefseeknextfile)):
1994                 fseeknextasnum = int(prefseeknextfile)
1995                 if(abs(fseeknextasnum) == 0):
1996                     pass
1997                 fp.seek(fseeknextasnum, 1)
1998             elif(re.findall("^([0-9]+)", prefseeknextfile)):
1999                 fseeknextasnum = int(prefseeknextfile)
2000                 if(abs(fseeknextasnum) == 0):
2001                     pass
2002                 fp.seek(fseeknextasnum, 0)
2003             else:
2004                 return False
2005             il = il + 1
2006     realidnum = 0
2007     countnum = seekstart
2008     while(countnum < seekend):
2009         HeaderOut = ReadFileHeaderDataBySizeWithContentToArray(
2010             fp, listonly, contentasfile, uncompress, skipchecksum, formatspecs)
2011         if(len(HeaderOut) == 0):
2012             break
2013         HeaderOut.update({'fid': realidnum, 'fidalt': realidnum})
2014         catlist['ffilelist'].append(HeaderOut)
2015         countnum = countnum + 1
2016         realidnum = realidnum + 1
2017     return catlist
2018
2019
2020 def ReadFileDataBySizeWithContentToList(fp, seekstart=0, seekend=0, listonly=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__):
2021     formatspecs = FormatSpecsListToDict(formatspecs)
2022     delimiter = formatspecs['format_delimiter']
2023     curloc = fp.tell()
2024     if(curloc > 0):
2025         fp.seek(0, 0)
2026     catheader = ReadFileHeaderData(fp, 4, delimiter)
2027     if(curloc > 0):
2028         fp.seek(curloc, 0)
2029     headercheck = ValidateHeaderChecksum(
2030         catheader[:-1], catheader[2], catheader[3], formatspecs)
2031     newfcs = GetHeaderChecksum(catheader[:-2], catheader[2], True, formatspecs)
2032     if(not headercheck and not skipchecksum):
2033         VerbosePrintOut(
2034             "File Header Checksum Error with file at offset " + str(0))
2035         VerbosePrintOut("'" + str(newfcs) + "' != " +
2036                         "'" + str(catheader[3]) + "'")
2037         return False
2038     catstring = catheader[0]
2039     catversion = re.findall("([\\d]+)", catstring)
2040     catversions = re.search('(.*?)(\\d+)', catstring).groups()
2041     fprenumfiles = catheader[1]
2042     fnumfiles = int(fprenumfiles, 16)
2043     fprechecksumtype = catheader[2]
2044     fprechecksum = catheader[3]
2045     catlist = []
2046     if(seekstart < 0 and seekstart > fnumfiles):
2047         seekstart = 0
2048     if(seekend == 0 or seekend > fnumfiles and seekend < seekstart):
2049         seekend = fnumfiles
2050     elif(seekend < 0 and abs(seekend) <= fnumfiles and abs(seekend) >= seekstart):
2051         seekend = fnumfiles - abs(seekend)
2052     if(seekstart > 0):
2053         il = 0
2054         while(il < seekstart):
2055             prefhstart = fp.tell()
2056             preheaderdata = ReadFileHeaderDataBySize(
2057                 fp, formatspecs['format_delimiter'])
2058             if(len(preheaderdata) == 0):
2059                 break
2060             prefsize = int(preheaderdata[5], 16)
2061             prefcompression = preheaderdata[12]
2062             prefcsize = int(preheaderdata[13], 16)
2063             prefseeknextfile = HeaderOut[25]
2064             prenewfcs = GetHeaderChecksum(
2065                 preheaderdata[:-2], preheaderdata[-4].lower(), True, formatspecs)
2066             prefcs = preheaderdata[-2]
2067             if(prefcs != prenewfcs and not skipchecksum):
2068                 VerbosePrintOut("File Header Checksum Error with file " +
2069                                 prefname + " at offset " + str(prefhstart))
2070                 VerbosePrintOut("'" + str(prefcs) + "' != " +
2071                                 "'" + str(prenewfcs) + "'")
2072                 return False
2073                 valid_archive = False
2074                 invalid_archive = True
2075             prefhend = fp.tell() - 1
2076             prefcontentstart = fp.tell()
2077             prefcontents = ""
2078             pyhascontents = False
2079             if(prefsize > 0):
2080                 if(prefcompression == "none" or prefcompression == "" or prefcompression == "auto"):
2081                     prefcontents = catfp.read(prefsize)
2082                 else:
2083                     prefcontents = catfp.read(prefcsize)
2084                 prenewfccs = GetFileChecksum(
2085                     prefcontents, preheaderdata[-3].lower(), False, formatspecs)
2086                 prefccs = preheaderdata[-1]
2087                 pyhascontents = True
2088                 if(prefccs != prenewfccs and not skipchecksum):
2089                     VerbosePrintOut("File Content Checksum Error with file " +
2090                                     prefname + " at offset " + str(prefcontentstart))
2091                     VerbosePrintOut("'" + str(prefccs) +
2092                                     "' != " + "'" + str(prenewfccs) + "'")
2093                     return False
2094             if(re.findall("^\\+([0-9]+)", prefseeknextfile)):
2095                 fseeknextasnum = int(prefseeknextfile.replace("+", ""))
2096                 if(abs(fseeknextasnum) == 0):
2097                     pass
2098                 catfp.seek(fseeknextasnum, 1)
2099             elif(re.findall("^\\-([0-9]+)", prefseeknextfile)):
2100                 fseeknextasnum = int(prefseeknextfile)
2101                 if(abs(fseeknextasnum) == 0):
2102                     pass
2103                 catfp.seek(fseeknextasnum, 1)
2104             elif(re.findall("^([0-9]+)", prefseeknextfile)):
2105                 fseeknextasnum = int(prefseeknextfile)
2106                 if(abs(fseeknextasnum) == 0):
2107                     pass
2108                 catfp.seek(fseeknextasnum, 0)
2109             else:
2110                 return False
2111             il = il + 1
2112     realidnum = 0
2113     countnum = seekstart
2114     while(countnum < seekend):
2115         HeaderOut = ReadFileHeaderDataBySizeWithContentToList(
2116             fp, listonly, uncompress, skipchecksum, formatspecs)
2117         if(len(HeaderOut) == 0):
2118             break
2119         catlist.append(HeaderOut)
2120         countnum = countnum + 1
2121         realidnum = realidnum + 1
2122     return catlist
2123
2124
2125 def ReadInFileBySizeWithContentToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__):
2126     formatspecs = FormatSpecsListToDict(formatspecs)
2127     delimiter = formatspecs['format_delimiter']
2128     if(hasattr(infile, "read") or hasattr(infile, "write")):
2129         fp = infile
2130         fp.seek(0, 0)
2131         fp = UncompressArchiveFile(fp, formatspecs)
2132         checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
2133         if(checkcompressfile != "catfile" and checkcompressfile != formatspecs['format_lower']):
2134             return False
2135         if(not fp):
2136             return False
2137         fp.seek(0, 0)
2138     elif(infile == "-"):
2139         fp = BytesIO()
2140         if(hasattr(sys.stdin, "buffer")):
2141             shutil.copyfileobj(sys.stdin.buffer, fp)
2142         else:
2143             shutil.copyfileobj(sys.stdin, fp)
2144         fp.seek(0, 0)
2145         fp = UncompressArchiveFile(fp, formatspecs)
2146         if(not fp):
2147             return False
2148         fp.seek(0, 0)
2149     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
2150         fp = download_file_from_internet_file(infile)
2151         fp = UncompressArchiveFile(fp, formatspecs)
2152         fp.seek(0, 0)
2153         if(not fp):
2154             return False
2155         fp.seek(0, 0)
2156     else:
2157         infile = RemoveWindowsPath(infile)
2158         checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
2159         if(checkcompressfile != "catfile" and checkcompressfile != formatspecs['format_lower']):
2160             return False
2161         compresscheck = CheckCompressionType(infile, formatspecs, True)
2162         if(not compresscheck):
2163             fextname = os.path.splitext(infile)[1]
2164             if(fextname == ".gz"):
2165                 compresscheck = "gzip"
2166             elif(fextname == ".bz2"):
2167                 compresscheck = "bzip2"
2168             elif(fextname == ".zst"):
2169                 compresscheck = "zstd"
2170             elif(fextname == ".lz4" or fextname == ".clz4"):
2171                 compresscheck = "lz4"
2172             elif(fextname == ".lzo" or fextname == ".lzop"):
2173                 compresscheck = "lzo"
2174             elif(fextname == ".lzma"):
2175                 compresscheck = "lzma"
2176             elif(fextname == ".xz"):
2177                 compresscheck = "xz"
2178             elif(fextname == ".zz" or fextname == ".zl" or fextname == ".zlib"):
2179                 compresscheck = "zlib"
2180             else:
2181                 return False
2182         if(not compresscheck):
2183             return False
2184         fp = UncompressFile(infile, formatspecs, "rb")
2185     return ReadFileDataBySizeWithContentToArray(fp, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs)
2186
2187
2188 def ReadInFileBySizeWithContentToList(infile, seekstart=0, seekend=0, listonly=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__):
2189     formatspecs = FormatSpecsListToDict(formatspecs)
2190     delimiter = formatspecs['format_delimiter']
2191     if(hasattr(infile, "read") or hasattr(infile, "write")):
2192         fp = infile
2193         fp.seek(0, 0)
2194         fp = UncompressArchiveFile(fp, formatspecs)
2195         checkcompressfile = CheckCompressionSubType(fp, formatspecs, True)
2196         if(checkcompressfile != "catfile" and checkcompressfile != formatspecs['format_lower']):
2197             return False
2198         if(not fp):
2199             return False
2200         fp.seek(0, 0)
2201     elif(infile == "-"):
2202         fp = BytesIO()
2203         if(hasattr(sys.stdin, "buffer")):
2204             shutil.copyfileobj(sys.stdin.buffer, fp)
2205         else:
2206             shutil.copyfileobj(sys.stdin, fp)
2207         fp.seek(0, 0)
2208         fp = UncompressArchiveFile(fp, formatspecs)
2209         if(not fp):
2210             return False
2211         fp.seek(0, 0)
2212     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
2213         fp = download_file_from_internet_file(infile)
2214         fp = UncompressArchiveFile(fp, formatspecs)
2215         fp.seek(0, 0)
2216         if(not fp):
2217             return False
2218         fp.seek(0, 0)
2219     else:
2220         infile = RemoveWindowsPath(infile)
2221         checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
2222         if(checkcompressfile != "catfile" and checkcompressfile != formatspecs['format_lower']):
2223             return False
2224         compresscheck = CheckCompressionType(infile, formatspecs, True)
2225         if(not compresscheck):
2226             fextname = os.path.splitext(infile)[1]
2227             if(fextname == ".gz"):
2228                 compresscheck = "gzip"
2229             elif(fextname == ".bz2"):
2230                 compresscheck = "bzip2"
2231             elif(fextname == ".zst"):
2232                 compresscheck = "zstd"
2233             elif(fextname == ".lz4" or fextname == ".clz4"):
2234                 compresscheck = "lz4"
2235             elif(fextname == ".lzo" or fextname == ".lzop"):
2236                 compresscheck = "lzo"
2237             elif(fextname == ".lzma"):
2238                 compresscheck = "lzma"
2239             elif(fextname == ".xz"):
2240                 compresscheck = "xz"
2241             elif(fextname == ".zz" or fextname == ".zl" or fextname == ".zlib"):
2242                 compresscheck = "zlib"
2243             else:
2244                 return False
2245         if(not compresscheck):
2246             return False
2247         fp = UncompressFile(infile, formatspecs, "rb")
2248     return ReadFileDataBySizeWithContentToList(fp, seekstart, seekend, listonly, uncompress, skipchecksum, formatspecs)
2249
2250
2251 def AppendNullByte(indata, delimiter=__file_format_dict__['format_delimiter']):
2252     outdata = str(indata) + delimiter
2253     return outdata
2254
2255
2256 def AppendNullBytes(indata=[], delimiter=__file_format_dict__['format_delimiter']):
2257     outdata = ""
2258     inum = 0
2259     il = len(indata)
2260     while(inum < il):
2261         outdata = outdata + AppendNullByte(indata[inum], delimiter)
2262         inum = inum + 1
2263     return outdata
2264
2265
2266 def AppendFileHeader(fp, numfiles, checksumtype="crc32", formatspecs=__file_format_dict__):
2267     formatspecs = FormatSpecsListToDict(formatspecs)
2268     delimiter = formatspecs['format_delimiter']
2269     catver = formatspecs['format_ver']
2270     fileheaderver = str(int(catver.replace(".", "")))
2271     fileheader = AppendNullByte(
2272         formatspecs['format_magic'] + fileheaderver, formatspecs['format_delimiter'])
2273     fp.write(fileheader.encode('UTF-8'))
2274     fnumfiles = format(int(numfiles), 'x').lower()
2275     fnumfilesa = AppendNullBytes(
2276         [fnumfiles, checksumtype], formatspecs['format_delimiter'])
2277     catfileheadercshex = GetFileChecksum(
2278         fileheader + fnumfilesa, checksumtype, True, formatspecs)
2279     fnumfilesa = fnumfilesa + \
2280         AppendNullByte(catfileheadercshex, formatspecs['format_delimiter'])
2281     fp.write(fnumfilesa.encode('UTF-8'))
2282     try:
2283         fp.flush()
2284         os.fsync(fp.fileno())
2285     except io.UnsupportedOperation:
2286         pass
2287     except AttributeError:
2288         pass
2289     except OSError as e:
2290         pass
2291     return fp
2292
2293
2294 def MakeEmptyFilePointer(fp, checksumtype="crc32", formatspecs=__file_format_dict__):
2295     formatspecs = FormatSpecsListToDict(formatspecs)
2296     AppendFileHeader(fp, 0, checksumtype, formatspecs)
2297     return fp
2298
2299
2300 def MakeEmptyFile(outfile, compression="auto", compressionlevel=None, checksumtype="crc32", formatspecs=__file_format_dict__, returnfp=False):
2301     formatspecs = FormatSpecsListToDict(formatspecs)
2302     if(outfile != "-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2303         if(os.path.exists(outfile)):
2304             try:
2305                 os.unlink(outfile)
2306             except OSError as e:
2307                 pass
2308     if(outfile == "-"):
2309         verbose = False
2310         catfpfp = BytesIO()
2311     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
2312         catfp = outfile
2313     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
2314         catfp = BytesIO()
2315     else:
2316         fbasename = os.path.splitext(outfile)[0]
2317         fextname = os.path.splitext(outfile)[1]
2318         if(not compresswholefile and fextname in outextlistwd):
2319             compresswholefile = True
2320         catfp = CompressOpenFile(outfile, True, compressionlevel)
2321     catfp = AppendFileHeader(catfp, 0, checksumtype, formatspecs)
2322     if(outfile == "-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
2323         catfp = CompressArchiveFile(
2324             catfp, compression, compressionlevel, formatspecs)
2325         try:
2326             catfp.flush()
2327             os.fsync(catfp.fileno())
2328         except io.UnsupportedOperation:
2329             pass
2330         except AttributeError:
2331             pass
2332         except OSError as e:
2333             pass
2334     if(outfile == "-"):
2335         catfp.seek(0, 0)
2336         if(hasattr(sys.stdout, "buffer")):
2337             shutil.copyfileobj(catfp, sys.stdout.buffer)
2338         else:
2339             shutil.copyfileobj(catfp, sys.stdout)
2340     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
2341         catfp = CompressArchiveFile(
2342             catfp, compression, compressionlevel, formatspecs)
2343         catfp.seek(0, 0)
2344         upload_file_to_internet_file(catfp, outfile)
2345     if(returnfp):
2346         catfp.seek(0, 0)
2347         return catfp
2348     else:
2349         catfp.close()
2350         return True
2351
2352
2353 def AppendFileHeaderWithContent(fp, filevalues=[], extradata=[], filecontent="", checksumtype="crc32", formatspecs=__file_format_dict__):
2354     formatspecs = FormatSpecsListToDict(formatspecs)
2355     extrafields = format(len(extradata), 'x').lower()
2356     extrasizestr = AppendNullByte(extrafields, formatspecs['format_delimiter'])
2357     if(len(extradata) > 0):
2358         extrasizestr = extrasizestr + \
2359             AppendNullBytes(extradata, formatspecs['format_delimiter'])
2360     extrasizelen = format(len(extrasizestr), 'x').lower()
2361     catoutlen = len(filevalues) + len(extradata) + 5
2362     catoutlenhex = format(catoutlen, 'x').lower()
2363     catoutlist = filevalues
2364     catoutlist.insert(0, catoutlenhex)
2365     catoutlist.append(extrasizelen)
2366     catoutlist.append(extrafields)
2367     catfileoutstr = AppendNullBytes(
2368         catoutlist, formatspecs['format_delimiter'])
2369     if(len(extradata) > 0):
2370         catfileoutstr = catfileoutstr + \
2371             AppendNullBytes(extradata, formatspecs['format_delimiter'])
2372     if(len(filecontent) == 0):
2373         checksumlist = [checksumtype, "none"]
2374     else:
2375         checksumlist = [checksumtype, checksumtype]
2376     catfileoutstr = catfileoutstr + \
2377         AppendNullBytes(checksumlist, formatspecs['format_delimiter'])
2378     catfileheadercshex = GetFileChecksum(
2379         catfileoutstr, checksumtype, True, formatspecs)
2380     if(len(filecontent) == 0):
2381         catfilecontentcshex = GetFileChecksum(
2382             filecontent, "none", False, formatspecs)
2383     else:
2384         catfilecontentcshex = GetFileChecksum(
2385             filecontent, checksumtype, False, formatspecs)
2386     tmpfileoutstr = catfileoutstr + \
2387         AppendNullBytes([catfileheadercshex, catfilecontentcshex],
2388                         formatspecs['format_delimiter'])
2389     catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
2390     catfileoutstr = AppendNullByte(
2391         catheaersize, formatspecs['format_delimiter']) + catfileoutstr
2392     catfileheadercshex = GetFileChecksum(
2393         catfileoutstr, checksumtype, True, formatspecs)
2394     catfileoutstr = catfileoutstr + \
2395         AppendNullBytes([catfileheadercshex, catfilecontentcshex],
2396                         formatspecs['format_delimiter'])
2397     catfileoutstrecd = catfileoutstr.encode('UTF-8')
2398     nullstrecd = formatspecs['format_delimiter'].encode('UTF-8')
2399     catfileout = catfileoutstrecd + filecontent + nullstrecd
2400     fp.write(catfileout)
2401     try:
2402         fp.flush()
2403         os.fsync(fp.fileno())
2404     except io.UnsupportedOperation:
2405         pass
2406     except AttributeError:
2407         pass
2408     except OSError as e:
2409         pass
2410     return fp
2411
2412
2413 def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], extradata=[], compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, checksumtype="crc32", formatspecs=__file_format_dict__, verbose=False):
2414     formatspecs = FormatSpecsListToDict(formatspecs)
2415     advancedlist = formatspecs['use_advanced_list']
2416     altinode = formatspecs['use_alt_inode']
2417     if(verbose):
2418         logging.basicConfig(format="%(message)s",
2419                             stream=sys.stdout, level=logging.DEBUG)
2420     if(infiles == "-"):
2421         for line in sys.stdin:
2422             infilelist.append(line.strip())
2423         infilelist = list(filter(None, infilelist))
2424     elif(infiles != "-" and dirlistfromtxt and os.path.exists(infiles) and (os.path.isfile(infiles) or infiles == "/dev/null" or infiles == "NUL")):
2425         if(not os.path.exists(infiles) or not os.path.isfile(infiles)):
2426             return False
2427         with UncompressFile(infiles, formatspecs, "r") as finfile:
2428             for line in finfile:
2429                 infilelist.append(line.strip())
2430         infilelist = list(filter(None, infilelist))
2431     else:
2432         if(isinstance(infiles, (list, tuple, ))):
2433             infilelist = list(filter(None, infiles))
2434         elif(isinstance(infiles, (str, ))):
2435             infilelist = list(filter(None, [infiles]))
2436     if(advancedlist):
2437         GetDirList = ListDirAdvanced(infilelist, followlink, False)
2438     else:
2439         GetDirList = ListDir(infilelist, followlink, False)
2440     if(not GetDirList):
2441         return False
2442     curinode = 0
2443     curfid = 0
2444     inodelist = []
2445     inodetofile = {}
2446     filetoinode = {}
2447     inodetocatinode = {}
2448     numfiles = int(len(GetDirList))
2449     fnumfiles = format(numfiles, 'x').lower()
2450     AppendFileHeader(fp, fnumfiles, checksumtype, formatspecs)
2451     for curfname in GetDirList:
2452         if(re.findall("^[.|/]", curfname)):
2453             fname = curfname
2454         else:
2455             fname = "./"+curfname
2456         if(verbose):
2457             VerbosePrintOut(fname)
2458         if(not followlink or followlink is None):
2459             fstatinfo = os.lstat(fname)
2460         else:
2461             fstatinfo = os.stat(fname)
2462         fpremode = fstatinfo.st_mode
2463         finode = fstatinfo.st_ino
2464         flinkcount = fstatinfo.st_nlink
2465         ftype = 0
2466         if(stat.S_ISREG(fpremode)):
2467             ftype = 0
2468         elif(stat.S_ISLNK(fpremode)):
2469             ftype = 2
2470         elif(stat.S_ISCHR(fpremode)):
2471             ftype = 3
2472         elif(stat.S_ISBLK(fpremode)):
2473             ftype = 4
2474         elif(stat.S_ISDIR(fpremode)):
2475             ftype = 5
2476         elif(stat.S_ISFIFO(fpremode)):
2477             ftype = 6
2478         elif(stat.S_ISSOCK(fpremode)):
2479             ftype = 8
2480         elif(hasattr(stat, "S_ISDOOR") and stat.S_ISDOOR(fpremode)):
2481             ftype = 9
2482         elif(hasattr(stat, "S_ISPORT") and stat.S_ISPORT(fpremode)):
2483             ftype = 10
2484         elif(hasattr(stat, "S_ISWHT") and stat.S_ISWHT(fpremode)):
2485             ftype = 11
2486         else:
2487             ftype = 0
2488         flinkname = ""
2489         fcurfid = format(int(curfid), 'x').lower()
2490         if(not followlink and finode != 0):
2491             if(ftype != 1):
2492                 if(finode in inodelist):
2493                     ftype = 1
2494                     flinkname = inodetofile[finode]
2495                     if(altinode):
2496                         fcurinode = format(int(finode), 'x').lower()
2497                     else:
2498                         fcurinode = format(
2499                             int(inodetocatinode[finode]), 'x').lower()
2500                 if(finode not in inodelist):
2501                     inodelist.append(finode)
2502                     inodetofile.update({finode: fname})
2503                     inodetocatinode.update({finode: curinode})
2504                     if(altinode):
2505                         fcurinode = format(int(finode), 'x').lower()
2506                     else:
2507                         fcurinode = format(int(curinode), 'x').lower()
2508                     curinode = curinode + 1
2509         else:
2510             fcurinode = format(int(curinode), 'x').lower()
2511             curinode = curinode + 1
2512         curfid = curfid + 1
2513         if(ftype == 2):
2514             flinkname = os.readlink(fname)
2515         fdev = fstatinfo.st_dev
2516         getfdev = GetDevMajorMinor(fdev)
2517         fdev_minor = getfdev[0]
2518         fdev_major = getfdev[1]
2519         frdev = fstatinfo.st_dev
2520         if(hasattr(fstatinfo, "st_rdev")):
2521             frdev = fstatinfo.st_rdev
2522         else:
2523             frdev = fstatinfo.st_dev
2524         getfrdev = GetDevMajorMinor(frdev)
2525         frdev_minor = getfrdev[0]
2526         frdev_major = getfrdev[1]
2527         if(ftype == 1 or ftype == 2 or ftype == 3 or ftype == 4 or ftype == 5 or ftype == 6):
2528             fsize = format(int("0"), 'x').lower()
2529         elif(ftype == 0 or ftype == 7):
2530             fsize = format(int(fstatinfo.st_size), 'x').lower()
2531         else:
2532             fsize = format(int(fstatinfo.st_size)).lower()
2533         fatime = format(int(fstatinfo.st_atime), 'x').lower()
2534         fmtime = format(int(fstatinfo.st_mtime), 'x').lower()
2535         fctime = format(int(fstatinfo.st_ctime), 'x').lower()
2536         if(hasattr(fstatinfo, "st_birthtime")):
2537             fbtime = format(int(fstatinfo.st_birthtime), 'x').lower()
2538         else:
2539             fbtime = format(int(fstatinfo.st_ctime), 'x').lower()
2540         fmode = format(int(fstatinfo.st_mode), 'x').lower()
2541         fchmode = format(int(stat.S_IMODE(fstatinfo.st_mode)), 'x').lower()
2542         ftypemod = format(int(stat.S_IFMT(fstatinfo.st_mode)), 'x').lower()
2543         fuid = format(int(fstatinfo.st_uid), 'x').lower()
2544         fgid = format(int(fstatinfo.st_gid), 'x').lower()
2545         funame = ""
2546         try:
2547             import pwd
2548             try:
2549                 userinfo = pwd.getpwuid(fstatinfo.st_uid)
2550                 funame = userinfo.pw_name
2551             except KeyError:
2552                 funame = ""
2553         except ImportError:
2554             funame = ""
2555         fgname = ""
2556         try:
2557             import grp
2558             try:
2559                 groupinfo = grp.getgrgid(fstatinfo.st_gid)
2560                 fgname = groupinfo.gr_name
2561             except KeyError:
2562                 fgname = ""
2563         except ImportError:
2564             fgname = ""
2565         fdev_minor = format(int(fdev_minor), 'x').lower()
2566         fdev_major = format(int(fdev_major), 'x').lower()
2567         frdev_minor = format(int(frdev_minor), 'x').lower()
2568         frdev_major = format(int(frdev_major), 'x').lower()
2569         finode = format(int(finode), 'x').lower()
2570         flinkcount = format(int(flinkcount), 'x').lower()
2571         if(hasattr(fstatinfo, "st_file_attributes")):
2572             fwinattributes = format(
2573                 int(fstatinfo.st_file_attributes), 'x').lower()
2574         else:
2575             fwinattributes = format(int(0), 'x').lower()
2576         fcompression = ""
2577         fcsize = format(int(0), 'x').lower()
2578         fcontents = BytesIO()
2579         chunk_size = 1024
2580         if(ftype == 0 or ftype == 7):
2581             with open(fname, "rb") as fpc:
2582                 shutil.copyfileobj(fpc, fcontents)
2583                 if(not compresswholefile):
2584                     fcontents.seek(0, 2)
2585                     ucfsize = fcontents.tell()
2586                     fcontents.seek(0, 0)
2587                     if(compression == "auto"):
2588                         ilsize = len(compressionlistalt)
2589                         ilmin = 0
2590                         ilcsize = []
2591                         while(ilmin < ilsize):
2592                             cfcontents = BytesIO()
2593                             shutil.copyfileobj(fcontents, cfcontents)
2594                             fcontents.seek(0, 0)
2595                             cfcontents.seek(0, 0)
2596                             cfcontents = CompressArchiveFile(
2597                                 cfcontents, compressionlistalt[ilmin], compressionlevel, formatspecs)
2598                             if(cfcontents):
2599                                 cfcontents.seek(0, 2)
2600                                 ilcsize.append(cfcontents.tell())
2601                                 cfcontents.close()
2602                             else:
2603                                 try:
2604                                     ilcsize.append(sys.maxint)
2605                                 except AttributeError:
2606                                     ilcsize.append(sys.maxsize)
2607                             ilmin = ilmin + 1
2608                         ilcmin = ilcsize.index(min(ilcsize))
2609                         compression = compressionlistalt[ilcmin]
2610                     fcontents.seek(0, 0)
2611                     cfcontents = BytesIO()
2612                     shutil.copyfileobj(fcontents, cfcontents)
2613                     cfcontents.seek(0, 0)
2614                     cfcontents = CompressArchiveFile(
2615                         cfcontents, compression, compressionlevel, formatspecs)
2616                     cfcontents.seek(0, 2)
2617                     cfsize = cfcontents.tell()
2618                     if(ucfsize > cfsize):
2619                         fcsize = format(int(cfsize), 'x').lower()
2620                         fcompression = compression
2621                         fcontents.close()
2622                         fcontents = cfcontents
2623         if(followlink and (ftype == 1 or ftype == 2)):
2624             flstatinfo = os.stat(flinkname)
2625             with open(flinkname, "rb") as fpc:
2626                 shutil.copyfileobj(fpc, fcontents)
2627                 if(not compresswholefile):
2628                     fcontents.seek(0, 2)
2629                     ucfsize = fcontents.tell()
2630                     fcontents.seek(0, 0)
2631                     if(compression == "auto"):
2632                         ilsize = len(compressionlistalt)
2633                         ilmin = 0
2634                         ilcsize = []
2635                         while(ilmin < ilsize):
2636                             cfcontents = BytesIO()
2637                             shutil.copyfileobj(fcontents, cfcontents)
2638                             fcontents.seek(0, 0)
2639                             cfcontents.seek(0, 0)
2640                             cfcontents = CompressArchiveFile(
2641                                 cfcontents, compressionlistalt[ilmin], compressionlevel, formatspecs)
2642                             if(cfcontents):
2643                                 cfcontents.seek(0, 2)
2644                                 ilcsize.append(cfcontents.tell())
2645                                 cfcontents.close()
2646                             else:
2647                                 try:
2648                                     ilcsize.append(sys.maxint)
2649                                 except AttributeError:
2650                                     ilcsize.append(sys.maxsize)
2651                             ilmin = ilmin + 1
2652                         ilcmin = ilcsize.index(min(ilcsize))
2653                         compression = compressionlistalt[ilcmin]
2654                     fcontents.seek(0, 0)
2655                     cfcontents = BytesIO()
2656                     shutil.copyfileobj(fcontents, cfcontents)
2657                     cfcontents.seek(0, 0)
2658                     cfcontents = CompressArchiveFile(
2659                         cfcontents, compression, compressionlevel, formatspecs)
2660                     cfcontents.seek(0, 2)
2661                     cfsize = cfcontents.tell()
2662                     if(ucfsize > cfsize):
2663                         fcsize = format(int(cfsize), 'x').lower()
2664                         fcompression = compression
2665                         fcontents.close()
2666                         fcontents = cfcontents
2667         if(fcompression == "none"):
2668             fcompression = ""
2669         fcontents.seek(0, 0)
2670         ftypehex = format(ftype, 'x').lower()
2671         catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
2672                       fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, "+1"]
2673         fp = AppendFileHeaderWithContent(
2674             fp, catoutlist, extradata, fcontents.read(), checksumtype, formatspecs)
2675     if(numfiles > 0):
2676         catfp.write(AppendNullBytes(
2677             [0, 0], formatspecs['format_delimiter']).encode("UTF-8"))
2678     fp.seek(0, 0)
2679     return fp
2680
2681
2682 def AppendListsWithContent(inlist, fp, dirlistfromtxt=False, filevalues=[], extradata=[], compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, checksumtype="crc32", formatspecs=__file_format_dict__, verbose=False):
2683     formatspecs = FormatSpecsListToDict(formatspecs)
2684     if(verbose):
2685         logging.basicConfig(format="%(message)s",
2686                             stream=sys.stdout, level=logging.DEBUG)
2687     GetDirList = inlist
2688     if(not GetDirList):
2689         return False
2690     curinode = 0
2691     curfid = 0
2692     inodelist = []
2693     inodetofile = {}
2694     filetoinode = {}
2695     inodetocatinode = {}
2696     numfiles = int(len(GetDirList))
2697     fnumfiles = format(numfiles, 'x').lower()
2698     AppendFileHeader(fp, fnumfiles, checksumtype, formatspecs)
2699     for curfname in GetDirList:
2700         ftype = format(curfname[0], 'x').lower()
2701         if(re.findall("^[.|/]", curfname[1])):
2702             fname = curfname[1]
2703         else:
2704             fname = "./"+curfname[1]
2705         fbasedir = os.path.dirname(fname)
2706         flinkname = curfname[2]
2707         fsize = format(curfname[3], 'x').lower()
2708         fatime = format(curfname[4], 'x').lower()
2709         fmtime = format(curfname[5], 'x').lower()
2710         fctime = format(curfname[6], 'x').lower()
2711         fbtime = format(curfname[7], 'x').lower()
2712         fmode = format(curfname[8], 'x').lower()
2713         fwinattributes = format(curfname[9], 'x').lower()
2714         fcompression = curfname[10]
2715         fcsize = format(curfname[11], 'x').lower()
2716         fuid = format(curfname[12], 'x').lower()
2717         funame = curfname[13]
2718         fgid = format(curfname[14], 'x').lower()
2719         fgname = curfname[15]
2720         fid = format(curfname[16], 'x').lower()
2721         finode = format(curfname[17], 'x').lower()
2722         flinkcount = format(curfname[18], 'x').lower()
2723         fdev_minor = format(curfname[19], 'x').lower()
2724         fdev_major = format(curfname[20], 'x').lower()
2725         frdev_minor = format(curfname[21], 'x').lower()
2726         frdev_major = format(curfname[22], 'x').lower()
2727         fseeknextfile = curfname[23]
2728         extradata = curfname[24]
2729         fheaderchecksumtype = curfname[25]
2730         fcontentchecksumtype = curfname[26]
2731         fcontents = curfname[27]
2732         catoutlist = [ftype, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression, fcsize,
2733                       fuid, funame, fgid, fgname, fid, finode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, fseeknextfile]
2734         fcontents.seek(0, 0)
2735         fp = AppendFileHeaderWithContent(
2736             fp, catoutlist, extradata, fcontents.read(), checksumtype, formatspecs)
2737     if(numfiles > 0):
2738         fp.write(AppendNullBytes(
2739             [0, 0], formatspecs['format_delimiter']).encode("UTF-8"))
2740     return fp
2741
2742
2743 def AppendInFileWithContent(infile, fp, dirlistfromtxt=False, filevalues=[], extradata=[], followlink=False, checksumtype="crc32", formatspecs=__file_format_dict__, verbose=False):
2744     formatspecs = FormatSpecsListToDict(formatspecs)
2745     inlist = ReadInFileBySizeWithContentToList(
2746         infile, 0, 0, False, True, False, formatspecs)
2747     return AppendListsWithContent(inlist, fp, dirlistfromtxt, filevalues, extradata, followlink, checksumtype, formatspecs, verbose)
2748
2749
2750 def AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt=False, compression="auto", compresswholefile=True, compressionlevel=None, filevalues=[], extradata=[], followlink=False, checksumtype="crc32", formatspecs=__file_format_dict__, verbose=False, returnfp=False):
2751     formatspecs = FormatSpecsListToDict(formatspecs)
2752     if(outfile != "-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2753         if(os.path.exists(outfile)):
2754             try:
2755                 os.unlink(outfile)
2756             except OSError as e:
2757                 pass
2758     if(outfile == "-"):
2759         verbose = False
2760         catfpfp = BytesIO()
2761     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
2762         catfp = outfile
2763     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
2764         catfp = BytesIO()
2765     else:
2766         fbasename = os.path.splitext(outfile)[0]
2767         fextname = os.path.splitext(outfile)[1]
2768         if(not compresswholefile and fextname in outextlistwd):
2769             compresswholefile = True
2770         catfp = CompressOpenFile(outfile, compresswholefile, compressionlevel)
2771     catfp = AppendFilesWithContent(infiles, catfp, dirlistfromtxt, filevalues, extradata, compression,
2772                                    compresswholefile, compressionlevel, followlink, checksumtype, formatspecs, verbose)
2773     if(outfile == "-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
2774         catfp = CompressArchiveFile(
2775             catfp, compression, compressionlevel, formatspecs)
2776         try:
2777             catfp.flush()
2778             os.fsync(catfp.fileno())
2779         except io.UnsupportedOperation:
2780             pass
2781         except AttributeError:
2782             pass
2783         except OSError as e:
2784             pass
2785     if(outfile == "-"):
2786         catfp.seek(0, 0)
2787         if(hasattr(sys.stdout, "buffer")):
2788             shutil.copyfileobj(catfp, sys.stdout.buffer)
2789         else:
2790             shutil.copyfileobj(catfp, sys.stdout)
2791     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
2792         catfp = CompressArchiveFile(
2793             catfp, compression, compressionlevel, formatspecs)
2794         catfp.seek(0, 0)
2795         upload_file_to_internet_file(catfp, outfile)
2796     if(returnfp):
2797         catfp.seek(0, 0)
2798         return catfp
2799     else:
2800         catfp.close()
2801         return True
2802
2803
2804 def AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt=False, compression="auto", compresswholefile=True, compressionlevel=None, filevalues=[], extradata=[], followlink=False, checksumtype="crc32", formatspecs=__file_format_dict__, verbose=False, returnfp=False):
2805     formatspecs = FormatSpecsListToDict(formatspecs)
2806     if(outfile != "-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2807         if(os.path.exists(outfile)):
2808             try:
2809                 os.unlink(outfile)
2810             except OSError as e:
2811                 pass
2812     if(outfile == "-"):
2813         verbose = False
2814         catfpfp = BytesIO()
2815     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
2816         catfp = outfile
2817     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
2818         catfp = BytesIO()
2819     else:
2820         fbasename = os.path.splitext(outfile)[0]
2821         fextname = os.path.splitext(outfile)[1]
2822         if(not compresswholefile and fextname in outextlistwd):
2823             compresswholefile = True
2824         catfp = CompressOpenFile(outfile, compresswholefile, compressionlevel)
2825     catfp = AppendListsWithContent(inlist, catfp, dirlistfromtxt, filevalues, extradata, compression,
2826                                    compresswholefile, compressionlevel, followlink, checksumtype, formatspecs, verbose)
2827     if(outfile == "-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
2828         catfp = CompressArchiveFile(
2829             catfp, compression, compressionlevel, formatspecs)
2830         try:
2831             catfp.flush()
2832             os.fsync(catfp.fileno())
2833         except io.UnsupportedOperation:
2834             pass
2835         except AttributeError:
2836             pass
2837         except OSError as e:
2838             pass
2839     if(outfile == "-"):
2840         catfp.seek(0, 0)
2841         if(hasattr(sys.stdout, "buffer")):
2842             shutil.copyfileobj(catfp, sys.stdout.buffer)
2843         else:
2844             shutil.copyfileobj(catfp, sys.stdout)
2845     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
2846         catfp = CompressArchiveFile(
2847             catfp, compression, compressionlevel, formatspecs)
2848         catfp.seek(0, 0)
2849         upload_file_to_internet_file(catfp, outfile)
2850     if(returnfp):
2851         catfp.seek(0, 0)
2852         return catfp
2853     else:
2854         catfp.close()
2855         return True
2856
2857
2858 def AppendInFileWithContentToOutFile(infile, outfile, dirlistfromtxt=False, compression="auto", compresswholefile=True, compressionlevel=None, filevalues=[], extradata=[], followlink=False, checksumtype="crc32", formatspecs=__file_format_dict__, verbose=False, returnfp=False):
2859     formatspecs = FormatSpecsListToDict(formatspecs)
2860     inlist = ReadInFileBySizeWithContentToList(
2861         infile, 0, 0, False, True, False, formatspecs)
2862     return AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt, compression, compresswholefile, compressionlevel, filevalues, extradata, followlink, checksumtype, formatspecs, verbose, returnfp)
2863
2864
2865 def PrintPermissionString(fchmode, ftype):
2866     permissions = {'access': {'0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': (
2867         'r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx')}, 'roles': {0: 'owner', 1: 'group', 2: 'other'}}
2868     permissionstr = ""
2869     for fmodval in str(oct(fchmode))[-3:]:
2870         permissionstr = permissionstr + \
2871             permissions['access'].get(fmodval, '---')
2872     if(ftype == 0 or ftype == 7):
2873         permissionstr = "-" + permissionstr
2874     if(ftype == 1):
2875         permissionstr = "h" + permissionstr
2876     if(ftype == 2):
2877         permissionstr = "l" + permissionstr
2878     if(ftype == 3):
2879         permissionstr = "c" + permissionstr
2880     if(ftype == 4):
2881         permissionstr = "b" + permissionstr
2882     if(ftype == 5):
2883         permissionstr = "d" + permissionstr
2884     if(ftype == 6):
2885         permissionstr = "f" + permissionstr
2886     if(ftype == 8):
2887         permissionstr = "D" + permissionstr
2888     if(ftype == 9):
2889         permissionstr = "p" + permissionstr
2890     if(ftype == 10):
2891         permissionstr = "w" + permissionstr
2892     try:
2893         permissionoutstr = stat.filemode(fchmode)
2894     except AttributeError:
2895         permissionoutstr = permissionstr
2896     except KeyError:
2897         permissionoutstr = permissionstr
2898     return permissionoutstr
2899
2900
2901 def PrintPermissionStringAlt(fchmode, ftype):
2902     permissions = {
2903         '0': '---', '1': '--x', '2': '-w-', '3': '-wx',
2904         '4': 'r--', '5': 'r-x', '6': 'rw-', '7': 'rwx'
2905     }
2906     # Translate file mode into permission string
2907     permissionstr = ''.join([permissions[i] for i in str(oct(fchmode))[-3:]])
2908     # Append file type indicator
2909     type_indicators = {
2910         0: '-', 1: 'h', 2: 'l', 3: 'c', 4: 'b',
2911         5: 'd', 6: 'f', 8: 'D', 9: 'p', 10: 'w'
2912     }
2913     file_type = type_indicators.get(ftype, '-')
2914     permissionstr = file_type + permissionstr
2915     try:
2916         permissionoutstr = stat.filemode(fchmode)
2917     except AttributeError:
2918         permissionoutstr = permissionstr
2919     return permissionoutstr
2920
2921
2922 def GzipCompressData(data, compresslevel=9):
2923     try:
2924         # Try using modern gzip.compress if available
2925         compressed_data = gzip.compress(data, compresslevel=compresslevel)
2926     except AttributeError:
2927         # Fallback to older method for Python 2.x and older 3.x versions
2928         out = BytesIO()
2929         with gzip.GzipFile(fileobj=out, mode="wb", compresslevel=compresslevel) as f:
2930             f.write(data)
2931         compressed_data = out.getvalue()
2932     return compressed_data
2933
2934
2935 def GzipDecompressData(compressed_data):
2936     try:
2937         # Try using modern gzip.decompress if available
2938         decompressed_data = gzip.decompress(compressed_data)
2939     except AttributeError:
2940         # Fallback to older method for Python 2.x and older 3.x versions
2941         inp = BytesIO(compressed_data)
2942         with gzip.GzipFile(fileobj=inp, mode="rb") as f:
2943             decompressed_data = f.read()
2944     return decompressed_data
2945
2946
2947 def BzipCompressData(data, compresslevel=9):
2948     try:
2949         # Try using modern bz2.compress if available
2950         compressed_data = bz2.compress(data, compresslevel=compresslevel)
2951     except AttributeError:
2952         # Fallback to older method for Python 2.x and older 3.x versions
2953         compressor = bz2.BZ2Compressor(compresslevel)
2954         compressed_data = compressor.compress(data)
2955         compressed_data += compressor.flush()
2956     return compressed_data
2957
2958
2959 def BzipDecompressData(compressed_data):
2960     try:
2961         # Try using modern bz2.decompress if available
2962         decompressed_data = bz2.decompress(compressed_data)
2963     except AttributeError:
2964         # Fallback to older method for Python 2.x and older 3.x versions
2965         decompressor = bz2.BZ2Decompressor()
2966         decompressed_data = decompressor.decompress(compressed_data)
2967     return decompressed_data
2968
2969
2970 def CheckCompressionType(infile, formatspecs=__file_format_dict__, closefp=True):
2971     formatspecs = FormatSpecsListToDict(formatspecs)
2972     if(hasattr(infile, "read") or hasattr(infile, "write")):
2973         catfp = infile
2974     else:
2975         try:
2976             catfp = open(infile, "rb")
2977         except FileNotFoundError:
2978             return False
2979     filetype = False
2980     catfp.seek(0, 0)
2981     prefp = catfp.read(2)
2982     if(prefp == binascii.unhexlify("1f8b")):
2983         filetype = "gzip"
2984     if(prefp == binascii.unhexlify("7801")):
2985         filetype = "zlib"
2986     if(prefp == binascii.unhexlify("785e")):
2987         filetype = "zlib"
2988     if(prefp == binascii.unhexlify("789c")):
2989         filetype = "zlib"
2990     if(prefp == binascii.unhexlify("78da")):
2991         filetype = "zlib"
2992     catfp.seek(0, 0)
2993     prefp = catfp.read(3)
2994     if(prefp == binascii.unhexlify("425a68")):
2995         filetype = "bzip2"
2996     if(prefp == binascii.unhexlify("5d0000")):
2997         filetype = "lzma"
2998     catfp.seek(0, 0)
2999     prefp = catfp.read(4)
3000     if(prefp == binascii.unhexlify("28b52ffd")):
3001         filetype = "zstd"
3002     if(prefp == binascii.unhexlify("04224d18")):
3003         filetype = "lz4"
3004     if(prefp == binascii.unhexlify("504B0304")):
3005         filetype = "zipfile"
3006     catfp.seek(0, 0)
3007     prefp = catfp.read(5)
3008     if(prefp == binascii.unhexlify("7573746172")):
3009         filetype = "tarfile"
3010     catfp.seek(0, 0)
3011     prefp = catfp.read(6)
3012     if(prefp == binascii.unhexlify("fd377a585a00")):
3013         filetype = "lzma"
3014     if(prefp == binascii.unhexlify("377abcaf271c")):
3015         filetype = "7zipfile"
3016     catfp.seek(0, 0)
3017     prefp = catfp.read(7)
3018     if(prefp == binascii.unhexlify("526172211a0700")):
3019         filetype = "rarfile"
3020     if(prefp == binascii.unhexlify("43617446696c65")):
3021         filetype = "catfile"
3022     catfp.seek(0, 0)
3023     prefp = catfp.read(8)
3024     if(prefp == binascii.unhexlify("526172211a070100")):
3025         filetype = "rarfile"
3026     catfp.seek(0, 0)
3027     prefp = catfp.read(formatspecs['format_len'])
3028     if(prefp == binascii.unhexlify(formatspecs['format_hex'])):
3029         filetype = formatspecs['format_lower']
3030     catfp.seek(0, 0)
3031     prefp = catfp.read(9)
3032     if(prefp == binascii.unhexlify("894c5a4f000d0a1a0a")):
3033         filetype = "lzo"
3034     catfp.seek(0, 0)
3035     prefp = catfp.read(10)
3036     if(prefp == binascii.unhexlify("7061785f676c6f62616c")):
3037         filetype = "tarfile"
3038     catfp.seek(0, 0)
3039     if(filetype == "gzip" or filetype == "bzip2" or filetype == "lzma" or filetype == "zstd" or filetype == "lz4" or filetype == "zlib"):
3040         if(TarFileCheck(catfp)):
3041             filetype = "tarfile"
3042     if(not filetype):
3043         if(TarFileCheck(catfp)):
3044             filetype = "tarfile"
3045         elif(zipfile.is_zipfile(catfp)):
3046             filetype = "zipfile"
3047         elif(rarfile_support and (rarfile.is_rarfile(catfp) or rarfile.is_rarfile_sfx(catfp))):
3048             filetype = "rarile"
3049         elif(py7zr_support and py7zr.is_7zfile(catfp)):
3050             return "7zipfile"
3051         else:
3052             filetype = False
3053     catfp.seek(0, 0)
3054     if(closefp):
3055         catfp.close()
3056     return filetype
3057
3058
3059 def CheckCompressionTypeFromString(instring, formatspecs=__file_format_dict__, closefp=True):
3060     formatspecs = FormatSpecsListToDict(formatspecs)
3061     try:
3062         instringsfile = BytesIO(instring)
3063     except TypeError:
3064         instringsfile = BytesIO(instring.encode("UTF-8"))
3065     return CheckCompressionType(instringsfile, formatspecs, closefp)
3066
3067
3068 def GetCompressionMimeType(infile, formatspecs=__file_format_dict__):
3069     formatspecs = FormatSpecsListToDict(formatspecs)
3070     compresscheck = CheckCompressionType(fp, formatspecs, False)
3071     if(compresscheck == "gzip" or compresscheck == "gz"):
3072         return archivefile_gzip_mimetype
3073     if(compresscheck == "zlib" or (compresscheck == "zz" or compresscheck == "zl" or compresscheck == "zlib")):
3074         return archivefile_zlib_mimetype
3075     if(compresscheck == "bzip2" or compresscheck == "bz2"):
3076         return archivefile_bzip2_mimetype
3077     if(compresscheck == "zstd" or compresscheck == "zstandard"):
3078         return archivefile_zstandard_mimetype
3079     if(compresscheck == "lz4"):
3080         return archivefile_lz4_mimetype
3081     if(compresscheck == "lzo" or compresscheck == "lzop"):
3082         return archivefile_lzop_mimetype
3083     if(compresscheck == "lzma"):
3084         return archivefile_lzma_mimetype
3085     if(compresscheck == "xz"):
3086         return archivefile_xz_mimetype
3087     if(compresscheck == "catfile" or compresscheck == "cat" or compresscheck == formatspecs['format_lower']):
3088         return archivefile_cat_mimetype
3089     if(not compresscheck):
3090         return False
3091     return False
3092
3093
3094 def UncompressArchiveFile(fp, formatspecs=__file_format_dict__):
3095     formatspecs = FormatSpecsListToDict(formatspecs)
3096     if(not hasattr(fp, "read") and not hasattr(fp, "write")):
3097         return False
3098     compresscheck = CheckCompressionType(fp, formatspecs, False)
3099     if(compresscheck == "gzip" and compresscheck in compressionsupport):
3100         catfp = gzip.GzipFile(fileobj=fp, mode="rb")
3101     elif(compresscheck == "bzip2" and compresscheck in compressionsupport):
3102         catfp = bz2.BZ2File(fp)
3103     elif(compresscheck == "zstd" and compresscheck in compressionsupport):
3104         catfp = zstd.ZstdDecompressor().stream_reader(fp)
3105     elif(compresscheck == "lz4" and compresscheck in compressionsupport):
3106         catfp = lz4.frame.open_fp(fp, mode='rb')
3107     elif((compresscheck == "lzo" or compresscheck == "lzop") and compresscheck in compressionsupport):
3108         catfp = BytesIO()
3109         catfp.write(lzo.decompress(fp.read()))
3110     elif((compresscheck == "lzma" or compresscheck == "xz") and compresscheck in compressionsupport):
3111         catfp = lzma.LZMAFile(fp)
3112     elif(compresscheck == "zlib" and compresscheck in compressionsupport):
3113         catfp = ZlibFile(fileobj=fp, mode="rb")
3114     if(compresscheck == "catfile" or compresscheck == formatspecs['format_lower']):
3115         catfp = fp
3116     if(not compresscheck):
3117         try:
3118             import lzma
3119         except ImportError:
3120             try:
3121                 from backports import lzma
3122             except ImportError:
3123                 return False
3124         catfp = BytesIO()
3125         with fp as fpcontent:
3126             try:
3127                 catfp.write(lzma.decompress(fp.read()))
3128             except lzma.LZMAError:
3129                 return False
3130         if(compresscheck != "catfile" or compresscheck != formatspecs['format_lower']):
3131             fp.close()
3132     return catfp
3133
3134
3135 create_alias_function("Uncompress", __file_format_name__,
3136                       "", UncompressArchiveFile)
3137
3138
3139 def UncompressFile(infile, formatspecs=__file_format_dict__, mode="rb"):
3140     formatspecs = FormatSpecsListToDict(formatspecs)
3141     compresscheck = CheckCompressionType(infile, formatspecs, False)
3142     if(sys.version_info[0] == 2 and compresscheck):
3143         if(mode == "rt"):
3144             mode = "r"
3145         if(mode == "wt"):
3146             mode = "w"
3147     try:
3148         if(compresscheck == "gzip" and compresscheck in compressionsupport):
3149             try:
3150                 filefp = gzip.open(infile, mode, encoding="UTF-8")
3151             except (ValueError, TypeError) as e:
3152                 filefp = gzip.open(infile, mode)
3153         if(compresscheck == "bzip2" and compresscheck in compressionsupport):
3154             try:
3155                 filefp = bz2.open(infile, mode, encoding="UTF-8")
3156             except (ValueError, TypeError) as e:
3157                 filefp = bz2.open(infile, mode)
3158         if(compresscheck == "zstd" and compresscheck in compressionsupport):
3159             try:
3160                 filefp = zstandard.open(infile, mode, encoding="UTF-8")
3161             except (ValueError, TypeError) as e:
3162                 filefp = zstandard.open(infile, mode)
3163         if(compresscheck == "lz4" and compresscheck in compressionsupport):
3164             try:
3165                 filefp = lz4.frame.open(infile, mode, encoding="UTF-8")
3166             except (ValueError, TypeError) as e:
3167                 filefp = lz4.frame.open(infile, mode)
3168         if((compresscheck == "lzo" or compresscheck == "lzop") and compresscheck in compressionsupport):
3169             try:
3170                 filefp = lzo.open(infile, mode, encoding="UTF-8")
3171             except (ValueError, TypeError) as e:
3172                 filefp = lzo.open(infile, mode)
3173         if((compresscheck == "lzma" or compresscheck == "xz") and compresscheck in compressionsupport):
3174             try:
3175                 filefp = lzma.open(infile, mode, encoding="UTF-8")
3176             except (ValueError, TypeError) as e:
3177                 filefp = lzma.open(infile, mode)
3178         if(compresscheck == "zlib" and compresscheck in compressionsupport):
3179             filefp = ZlibFile(infile, mode=mode)
3180         if(compresscheck == "catfile" or compresscheck == formatspecs['format_lower']):
3181             try:
3182                 filefp = open(infile, mode, encoding="UTF-8")
3183             except (ValueError, TypeError) as e:
3184                 filefp = open(infile, mode)
3185         if(not compresscheck):
3186             try:
3187                 filefp = open(infile, mode, encoding="UTF-8")
3188             except (ValueError, TypeError) as e:
3189                 filefp = open(infile, mode)
3190     except FileNotFoundError:
3191         return False
3192     try:
3193         filefp.write_through = True
3194     except AttributeError:
3195         pass
3196     return filefp
3197
3198
3199 def UncompressString(infile):
3200     compresscheck = CheckCompressionTypeFromString(infile, formatspecs, False)
3201     if(compresscheck == "gzip" and compresscheck in compressionsupport):
3202         fileuz = GzipDecompressData(infile)
3203     if(compresscheck == "bzip2" and compresscheck in compressionsupport):
3204         fileuz = BzipDecompressData(infile)
3205     if(compresscheck == "zstd" and compresscheck in compressionsupport):
3206         try:
3207             import zstandard
3208         except ImportError:
3209             return False
3210         fileuz = zstandard.decompress(infile)
3211     if(compresscheck == "lz4" and compresscheck in compressionsupport):
3212         fileuz = lz4.frame.decompress(infile)
3213     if((compresscheck == "lzo" or compresscheck == "lzop") and compresscheck in compressionsupport):
3214         fileuz = lzo.decompress(infile)
3215     if((compresscheck == "lzma" or compresscheck == "xz") and compresscheck in compressionsupport):
3216         fileuz = lzma.decompress(infile)
3217     if(compresscheck == "zlib" and compresscheck in compressionsupport):
3218         fileuz = zlib.decompress(infile)
3219     if(not compresscheck):
3220         fileuz = infile
3221     if(hasattr(fileuz, 'decode')):
3222         fileuz = fileuz.decode("UTF-8")
3223     return fileuz
3224
3225
3226 def UncompressStringAlt(infile):
3227     filefp = StringIO()
3228     outstring = UncompressString(infile)
3229     filefp.write(outstring)
3230     filefp.seek(0, 0)
3231     return filefp
3232
3233
3234 def CheckCompressionSubType(infile, formatspecs=__file_format_dict__, closefp=True):
3235     formatspecs = FormatSpecsListToDict(formatspecs)
3236     compresscheck = CheckCompressionType(infile, formatspecs, False)
3237     if(not compresscheck):
3238         fextname = os.path.splitext(infile)[1]
3239         if(fextname == ".gz"):
3240             compresscheck = "gzip"
3241         elif(fextname == ".bz2"):
3242             compresscheck = "bzip2"
3243         elif(fextname == ".zst"):
3244             compresscheck = "zstd"
3245         elif(fextname == ".lz4"):
3246             compresscheck = "lz4"
3247         elif(fextname == ".lzo" or fextname == ".lzop"):
3248             compresscheck = "lzo"
3249         elif(fextname == ".lzma"):
3250             compresscheck = "lzma"
3251         elif(fextname == ".xz"):
3252             compresscheck = "xz"
3253         elif(fextname == ".zz" or fextname == ".zl" or fextname == ".zlib"):
3254             compresscheck = "zlib"
3255         else:
3256             return False
3257     if(compresscheck == "gzip" or compresscheck == "bzip2" or compresscheck == "lzma" or compresscheck == "zstd" or compresscheck == "lz4" or compresscheck == "zlib"):
3258         if(TarFileCheck(infile)):
3259             filetype = "tarfile"
3260     if(not compresscheck):
3261         if(TarFileCheck(infile)):
3262             return "tarfile"
3263         elif(zipfile.is_zipfile(infile)):
3264             return "zipfile"
3265         elif(rarfile_support and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
3266             return "rarile"
3267         elif(py7zr_support and py7zr.is_7zfile(infile)):
3268             return "7zipfile"
3269         else:
3270             return False
3271         return False
3272     if(compresscheck == "catfile"):
3273         return "catfile"
3274     if(compresscheck == formatspecs['format_lower']):
3275         return formatspecs['format_lower']
3276     if(compresscheck == "tarfile"):
3277         return "tarfile"
3278     if(compresscheck == "zipfile"):
3279         return "zipfile"
3280     if(rarfile_support and compresscheck == "rarfile"):
3281         return "rarfile"
3282     if(py7zr_support and compresscheck == "7zipfile" and py7zr.is_7zfile(infile)):
3283         return "7zipfile"
3284     if(hasattr(infile, "read") or hasattr(infile, "write")):
3285         catfp = UncompressArchiveFile(infile, formatspecs['format_lower'])
3286     else:
3287         try:
3288             if(compresscheck == "gzip" and compresscheck in compressionsupport):
3289                 catfp = gzip.GzipFile(infile, "rb")
3290             elif(compresscheck == "bzip2" and compresscheck in compressionsupport):
3291                 catfp = bz2.BZ2File(infile, "rb")
3292             elif(compresscheck == "lz4" and compresscheck in compressionsupport):
3293                 catfp = lz4.frame.open(infile, "rb")
3294             elif(compresscheck == "zstd" and compresscheck in compressionsupport):
3295                 catfp = zstandard.open(infile, "rb")
3296             elif((compresscheck == "lzo" or compresscheck == "lzop") and compresscheck in compressionsupport):
3297                 catfp = lzo.open(infile, "rb")
3298             elif((compresscheck == "lzma" or compresscheck == "xz") and compresscheck in compressionsupport):
3299                 catfp = lzma.open(infile, "rb")
3300             elif(compresscheck == "zlib" and compresscheck in compressionsupport):
3301                 catfp = ZlibFile(infile, mode="rb")
3302             else:
3303                 catfp = open(infile, "rb")
3304         except FileNotFoundError:
3305             return False
3306     filetype = False
3307     prefp = catfp.read(5)
3308     if(prefp == binascii.unhexlify("7573746172")):
3309         filetype = "tarfile"
3310     catfp.seek(0, 0)
3311     prefp = catfp.read(7)
3312     if(prefp == binascii.unhexlify("43617446696c65")):
3313         filetype = "catfile"
3314     catfp.seek(0, 0)
3315     prefp = catfp.read(formatspecs['format_len'])
3316     if(prefp == binascii.unhexlify(formatspecs['format_hex'])):
3317         filetype = formatspecs['format_lower']
3318     catfp.seek(0, 0)
3319     prefp = catfp.read(10)
3320     if(prefp == binascii.unhexlify("7061785f676c6f62616c")):
3321         filetype = "tarfile"
3322     catfp.seek(0, 0)
3323     if(closefp):
3324         catfp.close()
3325     return filetype
3326
3327
3328 def GZipCompress(data, compresslevel=9):
3329     if("gzip" not in compressionsupport):
3330         return False
3331     tmpfp = tempfile.NamedTemporaryFile("wb", delete=False)
3332     tmpfp.close()
3333     tmpfp = gzip.GzipFile(tmpfp.name, mode="wb", compresslevel=compresslevel)
3334     tmpfp.write(data)
3335     tmpfp.close()
3336     try:
3337         catfp = open(tmpfp.name, "rb")
3338     except FileNotFoundError:
3339         return False
3340     catdata = catfp.read()
3341     catfp.close()
3342     return catdata
3343
3344
3345 def CompressArchiveFile(fp, compression="auto", compressionlevel=None, formatspecs=__file_format_dict__):
3346     formatspecs = FormatSpecsListToDict(formatspecs)
3347     if(not hasattr(fp, "read") and not hasattr(fp, "write")):
3348         return False
3349     fp.seek(0, 0)
3350     if(not compression or compression == "catfile" or compression == formatspecs['format_lower']):
3351         compression = "auto"
3352     if(compression not in compressionlist and compression is None):
3353         compression = "auto"
3354     if(compression == "gzip" and compression in compressionsupport):
3355         catfp = BytesIO()
3356         if(compressionlevel is None):
3357             compressionlevel = 9
3358         else:
3359             compressionlevel = int(compressionlevel)
3360         catfp.write(GzipCompressData(
3361             fp.read(), compresslevel=compressionlevel))
3362     if(compression == "bzip2" and compression in compressionsupport):
3363         catfp = BytesIO()
3364         if(compressionlevel is None):
3365             compressionlevel = 9
3366         else:
3367             compressionlevel = int(compressionlevel)
3368         catfp.write(BzipCompressData(
3369             fp.read(), compresslevel=compressionlevel))
3370     if(compression == "lz4" and compression in compressionsupport):
3371         catfp = BytesIO()
3372         if(compressionlevel is None):
3373             compressionlevel = 9
3374         else:
3375             compressionlevel = int(compressionlevel)
3376         catfp.write(lz4.frame.compress(
3377             fp.read(), compression_level=compressionlevel))
3378     if((compression == "lzo" or compression == "lzop") and compression in compressionsupport):
3379         catfp = BytesIO()
3380         if(compressionlevel is None):
3381             compressionlevel = 9
3382         else:
3383             compressionlevel = int(compressionlevel)
3384         catfp.write(lzo.compress(fp.read(), compresslevel=compressionlevel))
3385     if(compression == "zstd" and compression in compressionsupport):
3386         catfp = BytesIO()
3387         if(compressionlevel is None):
3388             compressionlevel = 10
3389         else:
3390             compressionlevel = int(compressionlevel)
3391         catfp.write(zstandard.compress(fp.read(), level=compressionlevel))
3392     if(compression == "lzma" and compression in compressionsupport):
3393         catfp = BytesIO()
3394         if(compressionlevel is None):
3395             compressionlevel = 9
3396         else:
3397             compressionlevel = int(compressionlevel)
3398         catfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_ALONE, filters=[
3399                     {"id": lzma.FILTER_LZMA1, "preset": compressionlevel}]))
3400     if(compression == "xz" and compression in compressionsupport):
3401         catfp = BytesIO()
3402         if(compressionlevel is None):
3403             compressionlevel = 9
3404         else:
3405             compressionlevel = int(compressionlevel)
3406         catfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_XZ, filters=[
3407                     {"id": lzma.FILTER_LZMA2, "preset": compressionlevel}]))
3408     if(compression == "zlib" and compression in compressionsupport):
3409         catfp = BytesIO()
3410         if(compressionlevel is None):
3411             compressionlevel = 9
3412         else:
3413             compressionlevel = int(compressionlevel)
3414         catfp.write(zlib.compress(fp.read(), compressionlevel))
3415     if(compression == "auto" or compression is None):
3416         catfp = fp
3417     catfp.seek(0, 0)
3418     return catfp
3419
3420
3421 create_alias_function("Compress", __file_format_name__,
3422                       "", CompressArchiveFile)
3423
3424
3425 def CompressOpenFile(outfile, compressionenable=True, compressionlevel=None):
3426     if(outfile is None):
3427         return False
3428     fbasename = os.path.splitext(outfile)[0]
3429     fextname = os.path.splitext(outfile)[1]
3430     if(compressionlevel is None and fextname != ".zst"):
3431         compressionlevel = 9
3432     elif(compressionlevel is None and fextname == ".zst"):
3433         compressionlevel = 10
3434     else:
3435         compressionlevel = int(compressionlevel)
3436     if(sys.version_info[0] == 2):
3437         mode = "w"
3438     else:
3439         mode = "wb"
3440     try:
3441         if(fextname not in outextlistwd or not compressionenable):
3442             try:
3443                 outfp = open(outfile, "wb", encoding="UTF-8")
3444             except (ValueError, TypeError) as e:
3445                 outfp = open(outfile, "wb")
3446         elif(fextname == ".gz" and "gzip" in compressionsupport):
3447             try:
3448                 outfp = gzip.open(
3449                     outfile, mode, compressionlevel, encoding="UTF-8")
3450             except (ValueError, TypeError) as e:
3451                 outfp = gzip.open(outfile, mode, compressionlevel)
3452         elif(fextname == ".bz2" and "bzip2" in compressionsupport):
3453             try:
3454                 outfp = bz2.open(
3455                     outfile, mode, compressionlevel, encoding="UTF-8")
3456             except (ValueError, TypeError) as e:
3457                 outfp = bz2.open(outfile, mode, compressionlevel)
3458         elif(fextname == ".zst" and "zstandard" in compressionsupport):
3459             try:
3460                 outfp = zstandard.open(outfile, mode, zstandard.ZstdCompressor(
3461                     level=compressionlevel), encoding="UTF-8")
3462             except (ValueError, TypeError) as e:
3463                 outfp = zstandard.open(
3464                     outfile, mode, zstandard.ZstdCompressor(level=compressionlevel))
3465         elif(fextname == ".xz" and "xz" in compressionsupport):
3466             try:
3467                 outfp = lzma.open(outfile, mode, format=lzma.FORMAT_XZ, filters=[
3468                                   {"id": lzma.FILTER_LZMA2, "preset": compressionlevel}], encoding="UTF-8")
3469             except (ValueError, TypeError) as e:
3470                 outfp = lzma.open(outfile, mode, format=lzma.FORMAT_XZ, filters=[
3471                                   {"id": lzma.FILTER_LZMA2, "preset": compressionlevel}])
3472         elif(fextname == ".lz4" and "lz4" in compressionsupport):
3473             try:
3474                 outfp = lz4.frame.open(
3475                     outfile, mode, compression_level=compressionlevel, encoding="UTF-8")
3476             except (ValueError, TypeError) as e:
3477                 outfp = lz4.frame.open(
3478                     outfile, mode, compression_level=compressionlevel)
3479         elif(fextname == ".lzo" and "lzop" in compressionsupport):
3480             try:
3481                 outfp = lzo.open(
3482                     outfile, mode, compresslevel=compressionlevel, encoding="UTF-8")
3483             except (ValueError, TypeError) as e:
3484                 outfp = lzo.open(outfile, mode, compresslevel=compressionlevel)
3485         elif(fextname == ".lzma" and "lzma" in compressionsupport):
3486             try:
3487                 outfp = lzma.open(outfile, mode, format=lzma.FORMAT_ALONE, filters=[
3488                                   {"id": lzma.FILTER_LZMA1, "preset": compressionlevel}], encoding="UTF-8")
3489             except (ValueError, TypeError) as e:
3490                 outfp = lzma.open(outfile, mode, format=lzma.FORMAT_ALONE, filters=[
3491                                   {"id": lzma.FILTER_LZMA1, "preset": compressionlevel}])
3492         elif((fextname == ".zz" or fextname == ".zl" or fextname == ".zlib") and "zlib" in compressionsupport):
3493             outfp = ZlibFile(outfile, mode=mode, level=compressionlevel)
3494     except FileNotFoundError:
3495         return False
3496     try:
3497         outfp.write_through = True
3498     except AttributeError:
3499         pass
3500     return outfp
3501
3502
3503 def GetDevMajorMinor(fdev):
3504     retdev = []
3505     if(hasattr(os, "minor")):
3506         retdev.append(os.minor(fdev))
3507     else:
3508         retdev.append(0)
3509     if(hasattr(os, "major")):
3510         retdev.append(os.major(fdev))
3511     else:
3512         retdev.append(0)
3513     return retdev
3514
3515
3516 def CheckSumSupport(checkfor, guaranteed=True):
3517     if(guaranteed):
3518         try:
3519             hash_list = sorted(list(hashlib.algorithms_guaranteed))
3520         except AttributeError:
3521             hash_list = sorted(list(hashlib.algorithms))
3522     else:
3523         try:
3524             hash_list = sorted(list(hashlib.algorithms_available))
3525         except AttributeError:
3526             hash_list = sorted(list(hashlib.algorithms))
3527     checklistout = sorted(hash_list + ['adler32', 'crc16', 'crc16_ansi', 'crc16_ibm',
3528                           'crc16_ccitt', 'crc32', 'crc64', 'crc64_ecma', 'crc64_iso', 'none'])
3529     if(checkfor in checklistout):
3530         return True
3531     else:
3532         return False
3533
3534
3535 def CheckSumSupportAlt(checkfor, guaranteed=True):
3536     if(guaranteed):
3537         try:
3538             hash_list = sorted(list(hashlib.algorithms_guaranteed))
3539         except AttributeError:
3540             hash_list = sorted(list(hashlib.algorithms))
3541     else:
3542         try:
3543             hash_list = sorted(list(hashlib.algorithms_available))
3544         except AttributeError:
3545             hash_list = sorted(list(hashlib.algorithms))
3546     checklistout = hash_list
3547     if(checkfor in checklistout):
3548         return True
3549     else:
3550         return False
3551
3552
3553 def PackArchiveFile(infiles, outfile, dirlistfromtxt=False, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
3554     formatspecs = FormatSpecsListToDict(formatspecs)
3555     advancedlist = formatspecs['use_advanced_list']
3556     altinode = formatspecs['use_alt_inode']
3557     if(outfile != "-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
3558         outfile = RemoveWindowsPath(outfile)
3559     checksumtype = checksumtype.lower()
3560     if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
3561         checksumtype = "crc32"
3562     if(checksumtype == "none"):
3563         checksumtype = ""
3564     if(not compression or compression == "catfile" or compression == formatspecs['format_lower']):
3565         compression = "auto"
3566     if(compression not in compressionlist and compression is None):
3567         compression = "auto"
3568     if(verbose):
3569         logging.basicConfig(format="%(message)s",
3570                             stream=sys.stdout, level=logging.DEBUG)
3571     if(outfile != "-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
3572         if(os.path.exists(outfile)):
3573             try:
3574                 os.unlink(outfile)
3575             except OSError as e:
3576                 pass
3577     if(outfile == "-"):
3578         verbose = False
3579         catfp = BytesIO()
3580     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
3581         catfp = outfile
3582     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
3583         catfp = BytesIO()
3584     else:
3585         fbasename = os.path.splitext(outfile)[0]
3586         fextname = os.path.splitext(outfile)[1]
3587         if(not compresswholefile and fextname in outextlistwd):
3588             compresswholefile = True
3589         catfp = CompressOpenFile(outfile, compresswholefile, compressionlevel)
3590     catver = formatspecs['format_ver']
3591     fileheaderver = str(int(catver.replace(".", "")))
3592     infilelist = []
3593     if(infiles == "-"):
3594         for line in sys.stdin:
3595             infilelist.append(line.strip())
3596         infilelist = list(filter(None, infilelist))
3597     elif(infiles != "-" and dirlistfromtxt and os.path.exists(infiles) and (os.path.isfile(infiles) or infiles == "/dev/null" or infiles == "NUL")):
3598         if(not os.path.exists(infiles) or not os.path.isfile(infiles)):
3599             return False
3600         with UncompressFile(infiles, formatspecs, "r") as finfile:
3601             for line in finfile:
3602                 infilelist.append(line.strip())
3603         infilelist = list(filter(None, infilelist))
3604     else:
3605         if(isinstance(infiles, (list, tuple, ))):
3606             infilelist = list(filter(None, infiles))
3607         elif(isinstance(infiles, (str, ))):
3608             infilelist = list(filter(None, [infiles]))
3609     if(advancedlist):
3610         GetDirList = ListDirAdvanced(infilelist, followlink, False)
3611     else:
3612         GetDirList = ListDir(infilelist, followlink, False)
3613     if(not GetDirList):
3614         return False
3615     curinode = 0
3616     curfid = 0
3617     inodelist = []
3618     inodetofile = {}
3619     filetoinode = {}
3620     inodetocatinode = {}
3621     numfiles = int(len(GetDirList))
3622     catfp = AppendFileHeader(catfp, numfiles, checksumtype, formatspecs)
3623     for curfname in GetDirList:
3624         if(re.findall("^[.|/]", curfname)):
3625             fname = curfname
3626         else:
3627             fname = "./"+curfname
3628         if(verbose):
3629             VerbosePrintOut(fname)
3630         if(not followlink or followlink is None):
3631             fstatinfo = os.lstat(fname)
3632         else:
3633             fstatinfo = os.stat(fname)
3634         fpremode = fstatinfo.st_mode
3635         finode = fstatinfo.st_ino
3636         flinkcount = fstatinfo.st_nlink
3637         ftype = 0
3638         if(stat.S_ISREG(fpremode)):
3639             ftype = 0
3640         elif(stat.S_ISLNK(fpremode)):
3641             ftype = 2
3642         elif(stat.S_ISCHR(fpremode)):
3643             ftype = 3
3644         elif(stat.S_ISBLK(fpremode)):
3645             ftype = 4
3646         elif(stat.S_ISDIR(fpremode)):
3647             ftype = 5
3648         elif(stat.S_ISFIFO(fpremode)):
3649             ftype = 6
3650         elif(stat.S_ISSOCK(fpremode)):
3651             ftype = 8
3652         elif(hasattr(stat, "S_ISDOOR") and stat.S_ISDOOR(fpremode)):
3653             ftype = 9
3654         elif(hasattr(stat, "S_ISPORT") and stat.S_ISPORT(fpremode)):
3655             ftype = 10
3656         elif(hasattr(stat, "S_ISWHT") and stat.S_ISWHT(fpremode)):
3657             ftype = 11
3658         else:
3659             ftype = 0
3660         flinkname = ""
3661         fcurfid = format(int(curfid), 'x').lower()
3662         if(not followlink and finode != 0):
3663             if(ftype != 1):
3664                 if(finode in inodelist):
3665                     ftype = 1
3666                     flinkname = inodetofile[finode]
3667                     if(altinode):
3668                         fcurinode = format(int(finode), 'x').lower()
3669                     else:
3670                         fcurinode = format(
3671                             int(inodetocatinode[finode]), 'x').lower()
3672                 if(finode not in inodelist):
3673                     inodelist.append(finode)
3674                     inodetofile.update({finode: fname})
3675                     inodetocatinode.update({finode: curinode})
3676                     if(altinode):
3677                         fcurinode = format(int(finode), 'x').lower()
3678                     else:
3679                         fcurinode = format(int(curinode), 'x').lower()
3680                     curinode = curinode + 1
3681         else:
3682             fcurinode = format(int(curinode), 'x').lower()
3683             curinode = curinode + 1
3684         curfid = curfid + 1
3685         if(ftype == 2):
3686             flinkname = os.readlink(fname)
3687         fdev = fstatinfo.st_dev
3688         getfdev = GetDevMajorMinor(fdev)
3689         fdev_minor = getfdev[0]
3690         fdev_major = getfdev[1]
3691         frdev = fstatinfo.st_dev
3692         if(hasattr(fstatinfo, "st_rdev")):
3693             frdev = fstatinfo.st_rdev
3694         else:
3695             frdev = fstatinfo.st_dev
3696         getfrdev = GetDevMajorMinor(frdev)
3697         frdev_minor = getfrdev[0]
3698         frdev_major = getfrdev[1]
3699         if(ftype == 1 or ftype == 2 or ftype == 3 or ftype == 4 or ftype == 5 or ftype == 6):
3700             fsize = format(int("0"), 'x').lower()
3701         elif(ftype == 0 or ftype == 7):
3702             fsize = format(int(fstatinfo.st_size), 'x').lower()
3703         else:
3704             fsize = format(int(fstatinfo.st_size)).lower()
3705         fatime = format(int(fstatinfo.st_atime), 'x').lower()
3706         fmtime = format(int(fstatinfo.st_mtime), 'x').lower()
3707         fctime = format(int(fstatinfo.st_ctime), 'x').lower()
3708         if(hasattr(fstatinfo, "st_birthtime")):
3709             fbtime = format(int(fstatinfo.st_birthtime), 'x').lower()
3710         else:
3711             fbtime = format(int(fstatinfo.st_ctime), 'x').lower()
3712         fmode = format(int(fstatinfo.st_mode), 'x').lower()
3713         fchmode = format(int(stat.S_IMODE(fstatinfo.st_mode)), 'x').lower()
3714         ftypemod = format(int(stat.S_IFMT(fstatinfo.st_mode)), 'x').lower()
3715         fuid = format(int(fstatinfo.st_uid), 'x').lower()
3716         fgid = format(int(fstatinfo.st_gid), 'x').lower()
3717         funame = ""
3718         try:
3719             import pwd
3720             try:
3721                 userinfo = pwd.getpwuid(fstatinfo.st_uid)
3722                 funame = userinfo.pw_name
3723             except KeyError:
3724                 funame = ""
3725         except ImportError:
3726             funame = ""
3727         fgname = ""
3728         try:
3729             import grp
3730             try:
3731                 groupinfo = grp.getgrgid(fstatinfo.st_gid)
3732                 fgname = groupinfo.gr_name
3733             except KeyError:
3734                 fgname = ""
3735         except ImportError:
3736             fgname = ""
3737         fdev_minor = format(int(fdev_minor), 'x').lower()
3738         fdev_major = format(int(fdev_major), 'x').lower()
3739         frdev_minor = format(int(frdev_minor), 'x').lower()
3740         frdev_major = format(int(frdev_major), 'x').lower()
3741         finode = format(int(finode), 'x').lower()
3742         flinkcount = format(int(flinkcount), 'x').lower()
3743         if(hasattr(fstatinfo, "st_file_attributes")):
3744             fwinattributes = format(
3745                 int(fstatinfo.st_file_attributes), 'x').lower()
3746         else:
3747             fwinattributes = format(int(0), 'x').lower()
3748         fcompression = ""
3749         fcsize = format(int(0), 'x').lower()
3750         fcontents = BytesIO()
3751         if(ftype == 0 or ftype == 7):
3752             with open(fname, "rb") as fpc:
3753                 shutil.copyfileobj(fpc, fcontents)
3754                 if(not compresswholefile):
3755                     fcontents.seek(0, 2)
3756                     ucfsize = fcontents.tell()
3757                     fcontents.seek(0, 0)
3758                     if(compression == "auto"):
3759                         ilsize = len(compressionlistalt)
3760                         ilmin = 0
3761                         ilcsize = []
3762                         while(ilmin < ilsize):
3763                             cfcontents = BytesIO()
3764                             shutil.copyfileobj(fcontents, cfcontents)
3765                             fcontents.seek(0, 0)
3766                             cfcontents.seek(0, 0)
3767                             cfcontents = CompressArchiveFile(
3768                                 cfcontents, compressionlistalt[ilmin], compressionlevel, formatspecs)
3769                             if(cfcontents):
3770                                 cfcontents.seek(0, 2)
3771                                 ilcsize.append(cfcontents.tell())
3772                                 cfcontents.close()
3773                             else:
3774                                 try:
3775                                     ilcsize.append(sys.maxint)
3776                                 except AttributeError:
3777                                     ilcsize.append(sys.maxsize)
3778                             ilmin = ilmin + 1
3779                         ilcmin = ilcsize.index(min(ilcsize))
3780                         compression = compressionlistalt[ilcmin]
3781                     fcontents.seek(0, 0)
3782                     cfcontents = BytesIO()
3783                     shutil.copyfileobj(fcontents, cfcontents)
3784                     cfcontents.seek(0, 0)
3785                     cfcontents = CompressArchiveFile(
3786                         cfcontents, compression, compressionlevel, formatspecs)
3787                     cfcontents.seek(0, 2)
3788                     cfsize = cfcontents.tell()
3789                     if(ucfsize > cfsize):
3790                         fcsize = format(int(cfsize), 'x').lower()
3791                         fcompression = compression
3792                         fcontents.close()
3793                         fcontents = cfcontents
3794         if(fcompression == "none"):
3795             fcompression = ""
3796         if(followlink and (ftype == 1 or ftype == 2)):
3797             flstatinfo = os.stat(flinkname)
3798             with open(flinkname, "rb") as fpc:
3799                 shutil.copyfileobj(fpc, fcontents)
3800                 if(not compresswholefile):
3801                     fcontents.seek(0, 2)
3802                     ucfsize = fcontents.tell()
3803                     fcontents.seek(0, 0)
3804                     if(compression == "auto"):
3805                         ilsize = len(compressionlistalt)
3806                         ilmin = 0
3807                         ilcsize = []
3808                         while(ilmin < ilsize):
3809                             cfcontents = BytesIO()
3810                             shutil.copyfileobj(fcontents, cfcontents)
3811                             fcontents.seek(0, 0)
3812                             cfcontents.seek(0, 0)
3813                             cfcontents = CompressArchiveFile(
3814                                 cfcontents, compressionlistalt[ilmin], compressionlevel, formatspecs)
3815                             if(cfcontents):
3816                                 cfcontents.seek(0, 2)
3817                                 ilcsize.append(cfcontents.tell())
3818                                 cfcontents.close()
3819                             else:
3820                                 try:
3821                                     ilcsize.append(sys.maxint)
3822                                 except AttributeError:
3823                                     ilcsize.append(sys.maxsize)
3824                             ilmin = ilmin + 1
3825                         ilcmin = ilcsize.index(min(ilcsize))
3826                         compression = compressionlistalt[ilcmin]
3827                     fcontents.seek(0, 0)
3828                     cfcontents = BytesIO()
3829                     shutil.copyfileobj(fcontents, cfcontents)
3830                     cfcontents.seek(0, 0)
3831                     cfcontents = CompressArchiveFile(
3832                         cfcontents, compression, compressionlevel, formatspecs)
3833                     cfcontents.seek(0, 2)
3834                     cfsize = cfcontents.tell()
3835                     if(ucfsize > cfsize):
3836                         fcsize = format(int(cfsize), 'x').lower()
3837                         fcompression = compression
3838                         fcontents.close()
3839                         fcontents = cfcontents
3840         fcontents.seek(0, 0)
3841         ftypehex = format(ftype, 'x').lower()
3842         catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
3843                       fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, "+1"]
3844         catfp = AppendFileHeaderWithContent(
3845             catfp, catoutlist, extradata, fcontents.read(), checksumtype, formatspecs)
3846         fcontents.close()
3847     if(numfiles > 0):
3848         catfp.write(AppendNullBytes(
3849             [0, 0], formatspecs['format_delimiter']).encode("UTF-8"))
3850     if(outfile == "-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
3851         catfp = CompressArchiveFile(
3852             catfp, compression, compressionlevel, formatspecs)
3853         try:
3854             catfp.flush()
3855             os.fsync(catfp.fileno())
3856         except io.UnsupportedOperation:
3857             pass
3858         except AttributeError:
3859             pass
3860         except OSError as e:
3861             pass
3862     if(outfile == "-"):
3863         catfp.seek(0, 0)
3864         if(hasattr(sys.stdout, "buffer")):
3865             shutil.copyfileobj(catfp, sys.stdout.buffer)
3866         else:
3867             shutil.copyfileobj(catfp, sys.stdout)
3868     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
3869         catfp = CompressArchiveFile(
3870             catfp, compression, compressionlevel, formatspecs)
3871         catfp.seek(0, 0)
3872         upload_file_to_internet_file(catfp, outfile)
3873     if(returnfp):
3874         catfp.seek(0, 0)
3875         return catfp
3876     else:
3877         catfp.close()
3878         return True
3879
3880
3881 create_alias_function("Pack", __file_format_name__, "", PackArchiveFile)
3882
3883 if(hasattr(shutil, "register_archive_format")):
3884     def PackArchiveFileFunc(archive_name, source_dir, **kwargs):
3885         return PackArchiveFile(source_dir, archive_name, False, "auto", True, None, False, "crc32", [], __file_format_dict__['format_delimiter'], False, False)
3886     create_alias_function("Pack", __file_format_name__,
3887                           "Func", PackArchiveFileFunc)
3888
3889
3890 def PackArchiveFileFromDirList(infiles, outfile, dirlistfromtxt=False, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
3891     formatspecs = FormatSpecsListToDict(formatspecs)
3892     return PackArchiveFile(infiles, outfile, dirlistfromtxt, compression, compresswholefile, compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, returnfp)
3893
3894
3895 create_alias_function("Pack", __file_format_name__,
3896                       "FromDirList", PackArchiveFileFromDirList)
3897
3898
3899 def PackArchiveFileFromTarFile(infile, outfile, compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
3900     formatspecs = FormatSpecsListToDict(formatspecs)
3901     if(outfile != "-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
3902         outfile = RemoveWindowsPath(outfile)
3903     checksumtype = checksumtype.lower()
3904     if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
3905         checksumtype = "crc32"
3906     if(checksumtype == "none"):
3907         checksumtype = ""
3908     if(not compression or compression == "catfile" or compression == formatspecs['format_lower']):
3909         compression = "auto"
3910     if(compression not in compressionlist and compression is None):
3911         compression = "auto"
3912     if(verbose):
3913         logging.basicConfig(format="%(message)s",
3914                             stream=sys.stdout, level=logging.DEBUG)
3915     if(outfile != "-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
3916         if(os.path.exists(outfile)):
3917             try:
3918                 os.unlink(outfile)
3919             except OSError as e:
3920                 pass
3921     if(outfile == "-"):
3922         verbose = False
3923         catfp = BytesIO()
3924     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
3925         catfp = outfile
3926     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
3927         catfp = BytesIO()
3928     else:
3929         fbasename = os.path.splitext(outfile)[0]
3930         fextname = os.path.splitext(outfile)[1]
3931         if(not compresswholefile and fextname in outextlistwd):
3932             compresswholefile = True
3933         catfp = CompressOpenFile(outfile, compresswholefile, compressionlevel)
3934     catver = formatspecs['format_ver']
3935     fileheaderver = str(int(catver.replace(".", "")))
3936     curinode = 0
3937     curfid = 0
3938     inodelist = []
3939     inodetofile = {}
3940     filetoinode = {}
3941     inodetocatinode = {}
3942     if(infile == "-"):
3943         infile = BytesIO()
3944         if(hasattr(sys.stdin, "buffer")):
3945             shutil.copyfileobj(sys.stdin.buffer, infile)
3946         else:
3947             shutil.copyfileobj(sys.stdin, infile)
3948         infile.seek(0, 0)
3949         if(not infile):
3950             return False
3951         infile.seek(0, 0)
3952     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
3953         infile = download_file_from_internet_file(infile)
3954         infile.seek(0, 0)
3955         if(not infile):
3956             return False
3957         infile.seek(0, 0)
3958     elif(not os.path.exists(infile) or not os.path.isfile(infile)):
3959         return False
3960     elif(os.path.exists(infile) and os.path.isfile(infile)):
3961         try:
3962             if(not tarfile.TarFileCheck(infile)):
3963                 return False
3964         except AttributeError:
3965             if(not TarFileCheck(infile)):
3966                 return False
3967     try:
3968         if(hasattr(infile, "read") or hasattr(infile, "write")):
3969             tarfp = tarfile.open(fileobj=infile, mode="r")
3970         else:
3971             tarfp = tarfile.open(infile, "r")
3972     except FileNotFoundError:
3973         return False
3974     numfiles = int(len(tarfp.getmembers()))
3975     catfp = AppendFileHeader(catfp, numfiles, checksumtype, formatspecs)
3976     for member in sorted(tarfp.getmembers(), key=lambda x: x.name):
3977         if(re.findall("^[.|/]", member.name)):
3978             fname = member.name
3979         else:
3980             fname = "./"+member.name
3981         if(verbose):
3982             VerbosePrintOut(fname)
3983         fpremode = member.mode
3984         ffullmode = member.mode
3985         flinkcount = 0
3986         ftype = 0
3987         if(member.isreg()):
3988             ffullmode = member.mode + stat.S_IFREG
3989             ftype = 0
3990         elif(member.isdev()):
3991             ffullmode = member.mode
3992             ftype = 7
3993         elif(member.islnk()):
3994             ffullmode = member.mode + stat.S_IFREG
3995             ftype = 1
3996         elif(member.issym()):
3997             ffullmode = member.mode + stat.S_IFLNK
3998             ftype = 2
3999         elif(member.ischr()):
4000             ffullmode = member.mode + stat.S_IFCHR
4001             ftype = 3
4002         elif(member.isblk()):
4003             ffullmode = member.mode + stat.S_IFBLK
4004             ftype = 4
4005         elif(member.isdir()):
4006             ffullmode = member.mode + stat.S_IFDIR
4007             ftype = 5
4008         elif(member.isfifo()):
4009             ffullmode = member.mode + stat.S_IFIFO
4010             ftype = 6
4011         elif(member.issparse()):
4012             ffullmode = member.mode
4013             ftype = 12
4014         else:
4015             ffullmode = member.mode
4016             ftype = 0
4017         flinkname = ""
4018         fcurfid = format(int(curfid), 'x').lower()
4019         fcurinode = format(int(curfid), 'x').lower()
4020         curfid = curfid + 1
4021         if(ftype == 2):
4022             flinkname = member.linkname
4023         fdev_minor = format(int(member.devminor), 'x').lower()
4024         fdev_major = format(int(member.devmajor), 'x').lower()
4025         frdev_minor = format(int(member.devminor), 'x').lower()
4026         frdev_major = format(int(member.devmajor), 'x').lower()
4027         if(ftype == 1 or ftype == 2 or ftype == 3 or ftype == 4 or ftype == 5 or ftype == 6):
4028             fsize = format(int("0"), 'x').lower()
4029         elif(ftype == 0 or ftype == 7):
4030             fsize = format(int(member.size), 'x').lower()
4031         else:
4032             fsize = format(int(member.size), 'x').lower()
4033         fatime = format(int(member.mtime), 'x').lower()
4034         fmtime = format(int(member.mtime), 'x').lower()
4035         fctime = format(int(member.mtime), 'x').lower()
4036         fbtime = format(int(member.mtime), 'x').lower()
4037         fmode = format(int(ffullmode), 'x').lower()
4038         fchmode = format(int(stat.S_IMODE(ffullmode)), 'x').lower()
4039         ftypemod = format(int(stat.S_IFMT(ffullmode)), 'x').lower()
4040         fuid = format(int(member.uid), 'x').lower()
4041         fgid = format(int(member.gid), 'x').lower()
4042         funame = member.uname
4043         fgname = member.gname
4044         flinkcount = format(int(flinkcount), 'x').lower()
4045         fwinattributes = format(int(0), 'x').lower()
4046         fcompression = ""
4047         fcsize = format(int(0), 'x').lower()
4048         fcontents = BytesIO()
4049         if(ftype == 0 or ftype == 7):
4050             with tarfp.extractfile(member) as fpc:
4051                 shutil.copyfileobj(fpc, fcontents)
4052                 if(not compresswholefile):
4053                     fcontents.seek(0, 2)
4054                     ucfsize = fcontents.tell()
4055                     fcontents.seek(0, 0)
4056                     if(compression == "auto"):
4057                         ilsize = len(compressionlistalt)
4058                         ilmin = 0
4059                         ilcsize = []
4060                         while(ilmin < ilsize):
4061                             cfcontents = BytesIO()
4062                             shutil.copyfileobj(fcontents, cfcontents)
4063                             fcontents.seek(0, 0)
4064                             cfcontents.seek(0, 0)
4065                             cfcontents = CompressArchiveFile(
4066                                 cfcontents, compressionlistalt[ilmin], compressionlevel, formatspecs)
4067                             if(cfcontents):
4068                                 cfcontents.seek(0, 2)
4069                                 ilcsize.append(cfcontents.tell())
4070                                 cfcontents.close()
4071                             else:
4072                                 try:
4073                                     ilcsize.append(sys.maxint)
4074                                 except AttributeError:
4075                                     ilcsize.append(sys.maxsize)
4076                             ilmin = ilmin + 1
4077                         ilcmin = ilcsize.index(min(ilcsize))
4078                         compression = compressionlistalt[ilcmin]
4079                     fcontents.seek(0, 0)
4080                     cfcontents = BytesIO()
4081                     shutil.copyfileobj(fcontents, cfcontents)
4082                     cfcontents.seek(0, 0)
4083                     cfcontents = CompressArchiveFile(
4084                         cfcontents, compression, compressionlevel, formatspecs)
4085                     cfcontents.seek(0, 2)
4086                     cfsize = cfcontents.tell()
4087                     if(ucfsize > cfsize):
4088                         fcsize = format(int(cfsize), 'x').lower()
4089                         fcompression = compression
4090                         fcontents.close()
4091                         fcontents = cfcontents
4092         if(fcompression == "none"):
4093             fcompression = ""
4094         fcontents.seek(0, 0)
4095         ftypehex = format(ftype, 'x').lower()
4096         catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
4097                       fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, "+1"]
4098         catfp = AppendFileHeaderWithContent(
4099             catfp, catoutlist, extradata, fcontents.read(), checksumtype, formatspecs)
4100         fcontents.close()
4101     if(numfiles > 0):
4102         catfp.write(AppendNullBytes(
4103             [0, 0], formatspecs['format_delimiter']).encode("UTF-8"))
4104     if(outfile == "-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
4105         catfp = CompressArchiveFile(
4106             catfp, compression, compressionlevel, formatspecs)
4107         try:
4108             catfp.flush()
4109             os.fsync(catfp.fileno())
4110         except io.UnsupportedOperation:
4111             pass
4112         except AttributeError:
4113             pass
4114         except OSError as e:
4115             pass
4116     if(outfile == "-"):
4117         catfp.seek(0, 0)
4118         if(hasattr(sys.stdout, "buffer")):
4119             shutil.copyfileobj(catfp, sys.stdout.buffer)
4120         else:
4121             shutil.copyfileobj(catfp, sys.stdout)
4122     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
4123         catfp = CompressArchiveFile(
4124             catfp, compression, compressionlevel, formatspecs)
4125         catfp.seek(0, 0)
4126         upload_file_to_internet_file(catfp, outfile)
4127     if(returnfp):
4128         catfp.seek(0, 0)
4129         return catfp
4130     else:
4131         catfp.close()
4132         return True
4133
4134
4135 create_alias_function("Pack", __file_format_name__,
4136                       "FromTarFile", PackArchiveFileFromTarFile)
4137
4138
4139 def PackArchiveFileFromZipFile(infile, outfile, compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
4140     formatspecs = FormatSpecsListToDict(formatspecs)
4141     if(outfile != "-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
4142         outfile = RemoveWindowsPath(outfile)
4143     checksumtype = checksumtype.lower()
4144     if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
4145         checksumtype = "crc32"
4146     if(checksumtype == "none"):
4147         checksumtype = ""
4148     if(not compression or compression == "catfile" or compression == formatspecs['format_lower']):
4149         compression = "auto"
4150     if(compression not in compressionlist and compression is None):
4151         compression = "auto"
4152     if(verbose):
4153         logging.basicConfig(format="%(message)s",
4154                             stream=sys.stdout, level=logging.DEBUG)
4155     if(outfile != "-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
4156         if(os.path.exists(outfile)):
4157             try:
4158                 os.unlink(outfile)
4159             except OSError as e:
4160                 pass
4161     if(outfile == "-"):
4162         verbose = False
4163         catfp = BytesIO()
4164     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
4165         catfp = outfile
4166     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
4167         catfp = BytesIO()
4168     else:
4169         fbasename = os.path.splitext(outfile)[0]
4170         fextname = os.path.splitext(outfile)[1]
4171         if(not compresswholefile and fextname in outextlistwd):
4172             compresswholefile = True
4173         catfp = CompressOpenFile(outfile, compresswholefile, compressionlevel)
4174     catver = formatspecs['format_ver']
4175     fileheaderver = str(int(catver.replace(".", "")))
4176     curinode = 0
4177     curfid = 0
4178     inodelist = []
4179     inodetofile = {}
4180     filetoinode = {}
4181     inodetocatinode = {}
4182     if(infile == "-"):
4183         infile = BytesIO()
4184         if(hasattr(sys.stdin, "buffer")):
4185             shutil.copyfileobj(sys.stdin.buffer, infile)
4186         else:
4187             shutil.copyfileobj(sys.stdin, infile)
4188         infile.seek(0, 0)
4189         if(not infile):
4190             return False
4191         infile.seek(0, 0)
4192     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
4193         infile = download_file_from_internet_file(infile)
4194         infile.seek(0, 0)
4195         if(not infile):
4196             return False
4197         infile.seek(0, 0)
4198     elif(not os.path.exists(infile) or not os.path.isfile(infile)):
4199         return False
4200     if(not zipfile.is_zipfile(infile)):
4201         return False
4202     try:
4203         zipfp = zipfile.ZipFile(infile, "r", allowZip64=True)
4204     except FileNotFoundError:
4205         return False
4206     ziptest = zipfp.testzip()
4207     if(ziptest):
4208         VerbosePrintOut("Bad file found!")
4209     numfiles = int(len(zipfp.infolist()))
4210     catfp = AppendFileHeader(catfp, numfiles, checksumtype, formatspecs)
4211     for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
4212         if(re.findall("^[.|/]", member.filename)):
4213             fname = member.filename
4214         else:
4215             fname = "./"+member.filename
4216         zipinfo = zipfp.getinfo(member.filename)
4217         if(verbose):
4218             VerbosePrintOut(fname)
4219         if(not member.is_dir()):
4220             fpremode = int(stat.S_IFREG + 438)
4221         elif(member.is_dir()):
4222             fpremode = int(stat.S_IFDIR + 511)
4223         flinkcount = 0
4224         ftype = 0
4225         if(not member.is_dir()):
4226             ftype = 0
4227         elif(member.is_dir()):
4228             ftype = 5
4229         flinkname = ""
4230         fcurfid = format(int(curfid), 'x').lower()
4231         fcurinode = format(int(curfid), 'x').lower()
4232         curfid = curfid + 1
4233         fdev_minor = format(int(0), 'x').lower()
4234         fdev_major = format(int(0), 'x').lower()
4235         frdev_minor = format(int(0), 'x').lower()
4236         frdev_major = format(int(0), 'x').lower()
4237         if(ftype == 5):
4238             fsize = format(int("0"), 'x').lower()
4239         elif(ftype == 0):
4240             fsize = format(int(member.file_size), 'x').lower()
4241         else:
4242             fsize = format(int(member.file_size), 'x').lower()
4243         fatime = format(
4244             int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower()
4245         fmtime = format(
4246             int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower()
4247         fctime = format(
4248             int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower()
4249         fbtime = format(
4250             int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower()
4251         if(zipinfo.create_system == 0 or zipinfo.create_system == 10):
4252             fwinattributes = format(int(zipinfo.external_attr), 'x').lower()
4253             if(not member.is_dir()):
4254                 fmode = format(int(stat.S_IFREG + 438), 'x').lower()
4255                 fchmode = stat.S_IMODE(int(stat.S_IFREG + 438))
4256                 ftypemod = stat.S_IFMT(int(stat.S_IFREG + 438))
4257             elif(member.is_dir()):
4258                 fmode = format(int(stat.S_IFDIR + 511), 'x').lower()
4259                 fchmode = stat.S_IMODE(int(stat.S_IFDIR + 511))
4260                 ftypemod = stat.S_IFMT(int(stat.S_IFDIR + 511))
4261         elif(zipinfo.create_system == 3):
4262             fwinattributes = format(int(0), 'x').lower()
4263             try:
4264                 fmode = format(int(zipinfo.external_attr), 'x').lower()
4265                 prefmode = int(zipinfo.external_attr)
4266                 fchmode = stat.S_IMODE(prefmode)
4267                 ftypemod = stat.S_IFMT(prefmode)
4268             except OverflowError:
4269                 fmode = format(int(zipinfo.external_attr >> 16), 'x').lower()
4270                 prefmode = int(zipinfo.external_attr >> 16)
4271                 fchmode = stat.S_IMODE(prefmode)
4272                 ftypemod = stat.S_IFMT(prefmode)
4273         else:
4274             fwinattributes = format(int(0), 'x').lower()
4275             if(not member.is_dir()):
4276                 fmode = format(int(stat.S_IFREG + 438), 'x').lower()
4277                 prefmode = int(stat.S_IFREG + 438)
4278                 fchmode = stat.S_IMODE(prefmode)
4279                 ftypemod = stat.S_IFMT(prefmode)
4280             elif(member.is_dir()):
4281                 fmode = format(int(stat.S_IFDIR + 511), 'x').lower()
4282                 prefmode = int(stat.S_IFDIR + 511)
4283                 fchmode = stat.S_IMODE(prefmode)
4284                 ftypemod = stat.S_IFMT(prefmode)
4285         fcompression = ""
4286         fcsize = format(int(0), 'x').lower()
4287         try:
4288             fuid = format(int(os.getuid()), 'x').lower()
4289         except AttributeError:
4290             fuid = format(int(0), 'x').lower()
4291         except KeyError:
4292             fuid = format(int(0), 'x').lower()
4293         try:
4294             fgid = format(int(os.getgid()), 'x').lower()
4295         except AttributeError:
4296             fgid = format(int(0), 'x').lower()
4297         except KeyError:
4298             fgid = format(int(0), 'x').lower()
4299         try:
4300             import pwd
4301             try:
4302                 userinfo = pwd.getpwuid(os.getuid())
4303                 funame = userinfo.pw_name
4304             except KeyError:
4305                 funame = ""
4306             except AttributeError:
4307                 funame = ""
4308         except ImportError:
4309             funame = ""
4310         fgname = ""
4311         try:
4312             import grp
4313             try:
4314                 groupinfo = grp.getgrgid(os.getgid())
4315                 fgname = groupinfo.gr_name
4316             except KeyError:
4317                 fgname = ""
4318             except AttributeError:
4319                 fgname = ""
4320         except ImportError:
4321             fgname = ""
4322         fcontents = BytesIO()
4323         if(ftype == 0):
4324             fcontents.write(zipfp.read(member.filename))
4325             if(not compresswholefile):
4326                 fcontents.seek(0, 2)
4327                 ucfsize = fcontents.tell()
4328                 fcontents.seek(0, 0)
4329                 if(compression == "auto"):
4330                     ilsize = len(compressionlistalt)
4331                     ilmin = 0
4332                     ilcsize = []
4333                     while(ilmin < ilsize):
4334                         cfcontents = BytesIO()
4335                         shutil.copyfileobj(fcontents, cfcontents)
4336                         fcontents.seek(0, 0)
4337                         cfcontents.seek(0, 0)
4338                         cfcontents = CompressArchiveFile(
4339                             cfcontents, compressionlistalt[ilmin], compressionlevel, formatspecs)
4340                         cfcontents.seek(0, 2)
4341                         ilcsize.append(cfcontents.tell())
4342                         cfcontents.close()
4343                         ilmin = ilmin + 1
4344                     ilcmin = ilcsize.index(min(ilcsize))
4345                     compression = compressionlistalt[ilcmin]
4346                 fcontents.seek(0, 0)
4347                 cfcontents = BytesIO()
4348                 shutil.copyfileobj(fcontents, cfcontents)
4349                 cfcontents.seek(0, 0)
4350                 cfcontents = CompressArchiveFile(
4351                     cfcontents, compression, compressionlevel, formatspecs)
4352                 cfcontents.seek(0, 2)
4353                 cfsize = cfcontents.tell()
4354                 if(ucfsize > cfsize):
4355                     fcsize = format(int(cfsize), 'x').lower()
4356                     fcompression = compression
4357                     fcontents.close()
4358                     fcontents = cfcontents
4359         if(fcompression == "none"):
4360             fcompression = ""
4361         fcontents.seek(0, 0)
4362         ftypehex = format(ftype, 'x').lower()
4363         catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
4364                       fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, "+1"]
4365         catfp = AppendFileHeaderWithContent(
4366             catfp, catoutlist, extradata, fcontents.read(), checksumtype, formatspecs)
4367         fcontents.close()
4368     if(numfiles > 0):
4369         catfp.write(AppendNullBytes(
4370             [0, 0], formatspecs['format_delimiter']).encode("UTF-8"))
4371     if(outfile == "-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
4372         catfp = CompressArchiveFile(
4373             catfp, compression, compressionlevel, formatspecs)
4374         try:
4375             catfp.flush()
4376             os.fsync(catfp.fileno())
4377         except io.UnsupportedOperation:
4378             pass
4379         except AttributeError:
4380             pass
4381         except OSError as e:
4382             pass
4383     if(outfile == "-"):
4384         catfp.seek(0, 0)
4385         if(hasattr(sys.stdout, "buffer")):
4386             shutil.copyfileobj(catfp, sys.stdout.buffer)
4387         else:
4388             shutil.copyfileobj(catfp, sys.stdout)
4389     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
4390         catfp = CompressArchiveFile(
4391             catfp, compression, compressionlevel, formatspecs)
4392         catfp.seek(0, 0)
4393         upload_file_to_internet_file(catfp, outfile)
4394     if(returnfp):
4395         catfp.seek(0, 0)
4396         return catfp
4397     else:
4398         catfp.close()
4399         return True
4400
4401
4402 create_alias_function("Pack", __file_format_name__,
4403                       "FromZipFile", PackArchiveFileFromZipFile)
4404
4405 if(not rarfile_support):
4406     def PackArchiveFileFromRarFile(infile, outfile, compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
4407         return False
4408
4409 if(rarfile_support):
4410     def PackArchiveFileFromRarFile(infile, outfile, compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
4411         formatspecs = FormatSpecsListToDict(formatspecs)
4412         if(outfile != "-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
4413             outfile = RemoveWindowsPath(outfile)
4414         checksumtype = checksumtype.lower()
4415         if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
4416             checksumtype = "crc32"
4417         if(checksumtype == "none"):
4418             checksumtype = ""
4419         if(not compression or compression == "catfile" or compression == formatspecs['format_lower']):
4420             compression = "auto"
4421         if(compression not in compressionlist and compression is None):
4422             compression = "auto"
4423         if(verbose):
4424             logging.basicConfig(format="%(message)s",
4425                                 stream=sys.stdout, level=logging.DEBUG)
4426         if(outfile != "-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
4427             if(os.path.exists(outfile)):
4428                 try:
4429                     os.unlink(outfile)
4430                 except OSError as e:
4431                     pass
4432         if(outfile == "-"):
4433             verbose = False
4434             catfp = BytesIO()
4435         elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
4436             catfp = outfile
4437         elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
4438             catfp = BytesIO()
4439         else:
4440             fbasename = os.path.splitext(outfile)[0]
4441             fextname = os.path.splitext(outfile)[1]
4442             if(not compresswholefile and fextname in outextlistwd):
4443                 compresswholefile = True
4444             catfp = CompressOpenFile(
4445                 outfile, compresswholefile, compressionlevel)
4446         catver = formatspecs['format_ver']
4447         fileheaderver = str(int(catver.replace(".", "")))
4448         curinode = 0
4449         curfid = 0
4450         inodelist = []
4451         inodetofile = {}
4452         filetoinode = {}
4453         inodetocatinode = {}
4454         if(not os.path.exists(infile) or not os.path.isfile(infile)):
4455             return False
4456         if(not rarfile.is_rarfile(infile) and not rarfile.is_rarfile_sfx(infile)):
4457             return False
4458         rarfp = rarfile.RarFile(infile, "r")
4459         rartest = rarfp.testrar()
4460         if(rartest):
4461             VerbosePrintOut("Bad file found!")
4462         numfiles = int(len(rarfp.infolist()))
4463         catfp = AppendFileHeader(catfp, numfiles, checksumtype, formatspecs)
4464         try:
4465             catfp.flush()
4466             os.fsync(catfp.fileno())
4467         except io.UnsupportedOperation:
4468             pass
4469         except AttributeError:
4470             pass
4471         except OSError as e:
4472             pass
4473         for member in sorted(rarfp.infolist(), key=lambda x: x.filename):
4474             is_unix = False
4475             is_windows = False
4476             if(member.host_os == rarfile.RAR_OS_UNIX):
4477                 is_windows = False
4478                 try:
4479                     member.external_attr
4480                     is_unix = True
4481                 except AttributeError:
4482                     is_unix = False
4483             elif(member.host_os == rarfile.RAR_OS_WIN32):
4484                 is_unix = False
4485                 try:
4486                     member.external_attr
4487                     is_windows = True
4488                 except AttributeError:
4489                     is_windows = False
4490             else:
4491                 is_unix = False
4492                 is_windows = False
4493             if(re.findall("^[.|/]", member.filename)):
4494                 fname = member.filename
4495             else:
4496                 fname = "./"+member.filename
4497             rarinfo = rarfp.getinfo(member.filename)
4498             if(verbose):
4499                 VerbosePrintOut(fname)
4500             if(is_unix and member.external_attr != 0):
4501                 fpremode = int(member.external_attr)
4502             elif(member.is_file()):
4503                 fpremode = int(stat.S_IFREG + 438)
4504             elif(member.is_symlink()):
4505                 fpremode = int(stat.S_IFLNK + 438)
4506             elif(member.is_dir()):
4507                 fpremode = int(stat.S_IFDIR + 511)
4508             if(is_windows and member.external_attr != 0):
4509                 fwinattributes = format(int(member.external_attr), 'x').lower()
4510             else:
4511                 fwinattributes = format(int(0), 'x').lower()
4512             fcompression = ""
4513             fcsize = format(int(0), 'x').lower()
4514             flinkcount = 0
4515             ftype = 0
4516             if(member.is_file()):
4517                 ftype = 0
4518             elif(member.is_symlink()):
4519                 ftype = 2
4520             elif(member.is_dir()):
4521                 ftype = 5
4522             flinkname = ""
4523             if(ftype == 2):
4524                 flinkname = rarfp.read(member.filename).decode("UTF-8")
4525             fcurfid = format(int(curfid), 'x').lower()
4526             fcurinode = format(int(curfid), 'x').lower()
4527             curfid = curfid + 1
4528             fdev_minor = format(int(0), 'x').lower()
4529             fdev_major = format(int(0), 'x').lower()
4530             frdev_minor = format(int(0), 'x').lower()
4531             frdev_major = format(int(0), 'x').lower()
4532             if(ftype == 5):
4533                 fsize = format(int("0"), 'x').lower()
4534             elif(ftype == 0):
4535                 fsize = format(int(member.file_size), 'x').lower()
4536             else:
4537                 fsize = format(int(member.file_size), 'x').lower()
4538             try:
4539                 if(member.atime):
4540                     fatime = format(int(member.atime.timestamp()), 'x').lower()
4541                 else:
4542                     fatime = format(int(member.mtime.timestamp()), 'x').lower()
4543             except AttributeError:
4544                 fatime = format(int(member.mtime.timestamp()), 'x').lower()
4545             fmtime = format(int(member.mtime.timestamp()), 'x').lower()
4546             try:
4547                 if(member.ctime):
4548                     fctime = format(int(member.ctime.timestamp()), 'x').lower()
4549                 else:
4550                     fctime = format(int(member.mtime.timestamp()), 'x').lower()
4551             except AttributeError:
4552                 fctime = format(int(member.mtime.timestamp()), 'x').lower()
4553             fbtime = format(int(member.mtime.timestamp()), 'x').lower()
4554             if(is_unix and member.external_attr != 0):
4555                 fmode = format(int(member.external_attr), 'x').lower()
4556                 fchmode = format(
4557                     int(stat.S_IMODE(member.external_attr)), 'x').lower()
4558                 ftypemod = format(
4559                     int(stat.S_IFMT(member.external_attr)), 'x').lower()
4560             elif(member.is_file()):
4561                 fmode = format(int(stat.S_IFREG + 438), 'x').lower()
4562                 fchmode = format(
4563                     int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower()
4564                 ftypemod = format(
4565                     int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower()
4566             elif(member.is_symlink()):
4567                 fmode = format(int(stat.S_IFLNK + 438), 'x').lower()
4568                 fchmode = format(
4569                     int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower()
4570                 ftypemod = format(
4571                     int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower()
4572             elif(member.is_dir()):
4573                 fmode = format(int(stat.S_IFDIR + 511), 'x').lower()
4574                 fchmode = format(
4575                     int(stat.S_IMODE(int(stat.S_IFDIR + 511))), 'x').lower()
4576                 ftypemod = format(
4577                     int(stat.S_IFMT(int(stat.S_IFDIR + 511))), 'x').lower()
4578             try:
4579                 fuid = format(int(os.getuid()), 'x').lower()
4580             except AttributeError:
4581                 fuid = format(int(0), 'x').lower()
4582             except KeyError:
4583                 fuid = format(int(0), 'x').lower()
4584             try:
4585                 fgid = format(int(os.getgid()), 'x').lower()
4586             except AttributeError:
4587                 fgid = format(int(0), 'x').lower()
4588             except KeyError:
4589                 fgid = format(int(0), 'x').lower()
4590             try:
4591                 import pwd
4592                 try:
4593                     userinfo = pwd.getpwuid(os.getuid())
4594                     funame = userinfo.pw_name
4595                 except KeyError:
4596                     funame = ""
4597                 except AttributeError:
4598                     funame = ""
4599             except ImportError:
4600                 funame = ""
4601             fgname = ""
4602             try:
4603                 import grp
4604                 try:
4605                     groupinfo = grp.getgrgid(os.getgid())
4606                     fgname = groupinfo.gr_name
4607                 except KeyError:
4608                     fgname = ""
4609                 except AttributeError:
4610                     fgname = ""
4611             except ImportError:
4612                 fgname = ""
4613             fcontents = BytesIO()
4614             if(ftype == 0):
4615                 fcontents.write(rarfp.read(member.filename))
4616                 if(not compresswholefile):
4617                     fcontents.seek(0, 2)
4618                     ucfsize = fcontents.tell()
4619                     fcontents.seek(0, 0)
4620                     if(compression == "auto"):
4621                         ilsize = len(compressionlistalt)
4622                         ilmin = 0
4623                         ilcsize = []
4624                         while(ilmin < ilsize):
4625                             cfcontents = BytesIO()
4626                             shutil.copyfileobj(fcontents, cfcontents)
4627                             fcontents.seek(0, 0)
4628                             cfcontents.seek(0, 0)
4629                             cfcontents = CompressArchiveFile(
4630                                 cfcontents, compressionlistalt[ilmin], compressionlevel, formatspecs)
4631                             if(cfcontents):
4632                                 cfcontents.seek(0, 2)
4633                                 ilcsize.append(cfcontents.tell())
4634                                 cfcontents.close()
4635                             else:
4636                                 try:
4637                                     ilcsize.append(sys.maxint)
4638                                 except AttributeError:
4639                                     ilcsize.append(sys.maxsize)
4640                             ilmin = ilmin + 1
4641                         ilcmin = ilcsize.index(min(ilcsize))
4642                         compression = compressionlistalt[ilcmin]
4643                     fcontents.seek(0, 0)
4644                     cfcontents = BytesIO()
4645                     shutil.copyfileobj(fcontents, cfcontents)
4646                     cfcontents.seek(0, 0)
4647                     cfcontents = CompressArchiveFile(
4648                         cfcontents, compression, compressionlevel, formatspecs)
4649                     cfcontents.seek(0, 2)
4650                     cfsize = cfcontents.tell()
4651                     if(ucfsize > cfsize):
4652                         fcsize = format(int(cfsize), 'x').lower()
4653                         fcompression = compression
4654                         fcontents.close()
4655                         fcontents = cfcontents
4656             if(fcompression == "none"):
4657                 fcompression = ""
4658             fcontents.seek(0, 0)
4659             ftypehex = format(ftype, 'x').lower()
4660             catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
4661                           fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, "+1"]
4662             catfp = AppendFileHeaderWithContent(
4663                 catfp, catoutlist, extradata, fcontents.read(), checksumtype, formatspecs)
4664             fcontents.close()
4665         if(numfiles > 0):
4666             catfp.write(AppendNullBytes(
4667                 [0, 0], formatspecs['format_delimiter']).encode("UTF-8"))
4668         if(outfile == "-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
4669             catfp = CompressArchiveFile(
4670                 catfp, compression, compressionlevel, formatspecs)
4671             try:
4672                 catfp.flush()
4673                 os.fsync(catfp.fileno())
4674             except io.UnsupportedOperation:
4675                 pass
4676             except AttributeError:
4677                 pass
4678             except OSError as e:
4679                 pass
4680         if(outfile == "-"):
4681             catfp.seek(0, 0)
4682             if(hasattr(sys.stdout, "buffer")):
4683                 shutil.copyfileobj(catfp, sys.stdout.buffer)
4684             else:
4685                 shutil.copyfileobj(catfp, sys.stdout)
4686         elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
4687             catfp = CompressArchiveFile(
4688                 catfp, compression, compressionlevel, formatspecs)
4689             catfp.seek(0, 0)
4690             upload_file_to_internet_file(catfp, outfile)
4691         if(returnfp):
4692             catfp.seek(0, 0)
4693             return catfp
4694         else:
4695             catfp.close()
4696             return True
4697
4698 create_alias_function("Pack", __file_format_name__,
4699                       "FromRarFile", PackArchiveFileFromRarFile)
4700
4701 if(not py7zr_support):
4702     def PackArchiveFileFromSevenZipFile(infile, outfile, compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
4703         return False
4704
4705 if(py7zr_support):
4706     def PackArchiveFileFromSevenZipFile(infile, outfile, compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
4707         formatspecs = FormatSpecsListToDict(formatspecs)
4708         if(outfile != "-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
4709             outfile = RemoveWindowsPath(outfile)
4710         checksumtype = checksumtype.lower()
4711         if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
4712             checksumtype = "crc32"
4713         if(checksumtype == "none"):
4714             checksumtype = ""
4715         if(not compression or compression == "catfile" or compression == formatspecs['format_lower']):
4716             compression = "auto"
4717         if(compression not in compressionlist and compression is None):
4718             compression = "auto"
4719         if(verbose):
4720             logging.basicConfig(format="%(message)s",
4721                                 stream=sys.stdout, level=logging.DEBUG)
4722         if(outfile != "-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
4723             if(os.path.exists(outfile)):
4724                 try:
4725                     os.unlink(outfile)
4726                 except OSError as e:
4727                     pass
4728         if(outfile == "-"):
4729             verbose = False
4730             catfp = BytesIO()
4731         elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
4732             catfp = outfile
4733         elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
4734             catfp = BytesIO()
4735         else:
4736             fbasename = os.path.splitext(outfile)[0]
4737             fextname = os.path.splitext(outfile)[1]
4738             if(not compresswholefile and fextname in outextlistwd):
4739                 compresswholefile = True
4740             catfp = CompressOpenFile(
4741                 outfile, compresswholefile, compressionlevel)
4742         catver = formatspecs['format_ver']
4743         fileheaderver = str(int(catver.replace(".", "")))
4744         curinode = 0
4745         curfid = 0
4746         inodelist = []
4747         inodetofile = {}
4748         filetoinode = {}
4749         inodetocatinode = {}
4750         if(not os.path.exists(infile) or not os.path.isfile(infile)):
4751             return False
4752         szpfp = py7zr.SevenZipFile(infile, mode="r")
4753         file_content = szpfp.readall()
4754         #sztest = szpfp.testzip();
4755         sztestalt = szpfp.test()
4756         if(sztestalt):
4757             VerbosePrintOut("Bad file found!")
4758         numfiles = int(len(szpfp.list()))
4759         AppendFileHeader(catfp, numfiles, checksumtype, formatspecs)
4760         for member in sorted(szpfp.list(), key=lambda x: x.filename):
4761             if(re.findall("^[.|/]", member.filename)):
4762                 fname = member.filename
4763             else:
4764                 fname = "./"+member.filename
4765             if(verbose):
4766                 VerbosePrintOut(fname)
4767             if(not member.is_directory):
4768                 fpremode = int(stat.S_IFREG + 438)
4769             elif(member.is_directory):
4770                 fpremode = int(stat.S_IFDIR + 511)
4771             fwinattributes = format(int(0), 'x').lower()
4772             fcompression = ""
4773             fcsize = format(int(0), 'x').lower()
4774             flinkcount = 0
4775             ftype = 0
4776             if(member.is_directory):
4777                 ftype = 5
4778             else:
4779                 ftype = 0
4780             flinkname = ""
4781             fcurfid = format(int(curfid), 'x').lower()
4782             fcurinode = format(int(curfid), 'x').lower()
4783             curfid = curfid + 1
4784             fdev_minor = format(int(0), 'x').lower()
4785             fdev_major = format(int(0), 'x').lower()
4786             frdev_minor = format(int(0), 'x').lower()
4787             frdev_major = format(int(0), 'x').lower()
4788             if(ftype == 5):
4789                 fsize = format(int("0"), 'x').lower()
4790             fatime = format(int(member.creationtime.timestamp()), 'x').lower()
4791             fmtime = format(int(member.creationtime.timestamp()), 'x').lower()
4792             fctime = format(int(member.creationtime.timestamp()), 'x').lower()
4793             fbtime = format(int(member.creationtime.timestamp()), 'x').lower()
4794             if(member.is_directory):
4795                 fmode = format(int(stat.S_IFDIR + 511), 'x').lower()
4796                 fchmode = format(
4797                     int(stat.S_IMODE(int(stat.S_IFDIR + 511))), 'x').lower()
4798                 ftypemod = format(
4799                     int(stat.S_IFMT(int(stat.S_IFDIR + 511))), 'x').lower()
4800             else:
4801                 fmode = format(int(stat.S_IFREG + 438), 'x').lower()
4802                 fchmode = format(
4803                     int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower()
4804                 ftypemod = format(
4805                     int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower()
4806             try:
4807                 fuid = format(int(os.getuid()), 'x').lower()
4808             except AttributeError:
4809                 fuid = format(int(0), 'x').lower()
4810             except KeyError:
4811                 fuid = format(int(0), 'x').lower()
4812             try:
4813                 fgid = format(int(os.getgid()), 'x').lower()
4814             except AttributeError:
4815                 fgid = format(int(0), 'x').lower()
4816             except KeyError:
4817                 fgid = format(int(0), 'x').lower()
4818             try:
4819                 import pwd
4820                 try:
4821                     userinfo = pwd.getpwuid(os.getuid())
4822                     funame = userinfo.pw_name
4823                 except KeyError:
4824                     funame = ""
4825                 except AttributeError:
4826                     funame = ""
4827             except ImportError:
4828                 funame = ""
4829             fgname = ""
4830             try:
4831                 import grp
4832                 try:
4833                     groupinfo = grp.getgrgid(os.getgid())
4834                     fgname = groupinfo.gr_name
4835                 except KeyError:
4836                     fgname = ""
4837                 except AttributeError:
4838                     fgname = ""
4839             except ImportError:
4840                 fgname = ""
4841             fcontents = BytesIO()
4842             if(ftype == 0):
4843                 fcontents.write(file_content[member.filename].read())
4844                 fsize = format(fcontents.tell(), 'x').lower()
4845                 file_content[member.filename].close()
4846                 if(not compresswholefile):
4847                     fcontents.seek(0, 2)
4848                     ucfsize = fcontents.tell()
4849                     fcontents.seek(0, 0)
4850                     if(compression == "auto"):
4851                         ilsize = len(compressionlistalt)
4852                         ilmin = 0
4853                         ilcsize = []
4854                         while(ilmin < ilsize):
4855                             cfcontents = BytesIO()
4856                             shutil.copyfileobj(fcontents, cfcontents)
4857                             fcontents.seek(0, 0)
4858                             cfcontents.seek(0, 0)
4859                             cfcontents = CompressArchiveFile(
4860                                 cfcontents, compressionlistalt[ilmin], compressionlevel, formatspecs)
4861                             if(cfcontents):
4862                                 cfcontents.seek(0, 2)
4863                                 ilcsize.append(cfcontents.tell())
4864                                 cfcontents.close()
4865                             else:
4866                                 try:
4867                                     ilcsize.append(sys.maxint)
4868                                 except AttributeError:
4869                                     ilcsize.append(sys.maxsize)
4870                             ilmin = ilmin + 1
4871                         ilcmin = ilcsize.index(min(ilcsize))
4872                         compression = compressionlistalt[ilcmin]
4873                     fcontents.seek(0, 0)
4874                     cfcontents = BytesIO()
4875                     shutil.copyfileobj(fcontents, cfcontents)
4876                     cfcontents.seek(0, 0)
4877                     cfcontents = CompressArchiveFile(
4878                         cfcontents, compression, compressionlevel, formatspecs)
4879                     cfcontents.seek(0, 2)
4880                     cfsize = cfcontents.tell()
4881                     if(ucfsize > cfsize):
4882                         fcsize = format(int(cfsize), 'x').lower()
4883                         fcompression = compression
4884                         fcontents.close()
4885                         fcontents = cfcontents
4886             if(fcompression == "none"):
4887                 fcompression = ""
4888             fcontents.seek(0, 0)
4889             ftypehex = format(ftype, 'x').lower()
4890             catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
4891                           fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, "+1"]
4892             catfp = AppendFileHeaderWithContent(
4893                 catfp, catoutlist, extradata, fcontents.read(), checksumtype, formatspecs)
4894             fcontents.close()
4895         if(numfiles > 0):
4896             catfp.write(AppendNullBytes(
4897                 [0, 0], formatspecs['format_delimiter']).encode("UTF-8"))
4898         if(outfile == "-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
4899             catfp = CompressArchiveFile(
4900                 catfp, compression, compressionlevel, formatspecs)
4901             try:
4902                 catfp.flush()
4903                 os.fsync(catfp.fileno())
4904             except io.UnsupportedOperation:
4905                 pass
4906             except AttributeError:
4907                 pass
4908             except OSError as e:
4909                 pass
4910         if(outfile == "-"):
4911             catfp.seek(0, 0)
4912             if(hasattr(sys.stdout, "buffer")):
4913                 shutil.copyfileobj(catfp, sys.stdout.buffer)
4914             else:
4915                 shutil.copyfileobj(catfp, sys.stdout)
4916         elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
4917             catfp = CompressArchiveFile(
4918                 catfp, compression, compressionlevel, formatspecs)
4919             catfp.seek(0, 0)
4920             upload_file_to_internet_file(catfp, outfile)
4921         if(returnfp):
4922             catfp.seek(0, 0)
4923             return catfp
4924         else:
4925             catfp.close()
4926             return True
4927
4928 create_alias_function("Pack", __file_format_name__,
4929                       "FromSevenZipFile", PackArchiveFileFromSevenZipFile)
4930
4931
4932 def PackArchiveFileFromInFile(infile, outfile, compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
4933     formatspecs = FormatSpecsListToDict(formatspecs)
4934     checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
4935     if(verbose):
4936         logging.basicConfig(format="%(message)s",
4937                             stream=sys.stdout, level=logging.DEBUG)
4938     if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
4939         return PackArchiveFileFromTarFile(infile, outfile, compression, compresswholefile, compressionlevel, checksumtype, extradata, formatspecs, verbose, returnfp)
4940     elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
4941         return PackArchiveFileFromZipFile(infile, outfile, compression, compresswholefile, compressionlevel, checksumtype, extradata, formatspecs, verbose, returnfp)
4942     elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
4943         return PackArchiveFileFromRarFile(infile, outfile, compression, compresswholefile, compressionlevel, checksumtype, extradata, formatspecs, verbose, returnfp)
4944     elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
4945         return PackArchiveFileFromSevenZipFile(infile, outfile, compression, compresswholefile, compressionlevel, checksumtype, extradata, formatspecs, verbose, returnfp)
4946     elif(checkcompressfile == "catfile"):
4947         return RePackArchiveFile(infile, outfile, compression, compresswholefile, compressionlevel, False, 0, 0, checksumtype, False, extradata, formatspecs, verbose, returnfp)
4948     else:
4949         return False
4950     return False
4951
4952
4953 create_alias_function("Pack", __file_format_name__,
4954                       "FromInFile", PackArchiveFileFromInFile)
4955
4956
4957 def ArchiveFileSeekToFileNum(infile, seekto=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, returnfp=False):
4958     formatspecs = FormatSpecsListToDict(formatspecs)
4959     if(hasattr(infile, "read") or hasattr(infile, "write")):
4960         catfp = infile
4961         catfp.seek(0, 0)
4962         catfp = UncompressArchiveFile(catfp, formatspecs)
4963         checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True)
4964         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
4965             return TarFileToArray(infile, seekto, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
4966         if(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
4967             return ZipFileToArray(infile, seekto, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
4968         if(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
4969             return RarFileToArray(infile, seekto, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
4970         if(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
4971             return SevenZipFileToArray(infile, seekto, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
4972         if(checkcompressfile != "catfile" and checkcompressfile != formatspecs['format_lower']):
4973             return False
4974         if(not catfp):
4975             return False
4976         catfp.seek(0, 0)
4977     elif(infile == "-"):
4978         catfp = BytesIO()
4979         if(hasattr(sys.stdin, "buffer")):
4980             shutil.copyfileobj(sys.stdin.buffer, catfp)
4981         else:
4982             shutil.copyfileobj(sys.stdin, catfp)
4983         catfp.seek(0, 0)
4984         catfp = UncompressArchiveFile(catfp, formatspecs)
4985         if(not catfp):
4986             return False
4987         catfp.seek(0, 0)
4988     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
4989         catfp = download_file_from_internet_file(infile)
4990         catfp.seek(0, 0)
4991         catfp = UncompressArchiveFile(catfp, formatspecs)
4992         if(not catfp):
4993             return False
4994         catfp.seek(0, 0)
4995     else:
4996         infile = RemoveWindowsPath(infile)
4997         checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
4998         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
4999             return TarFileToArray(infile, seekto, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
5000         if(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
5001             return ZipFileToArray(infile, seekto, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
5002         if(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
5003             return RarFileToArray(infile, seekto, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
5004         if(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
5005             return SevenZipFileToArray(infile, seekto, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
5006         if(checkcompressfile != "catfile" and checkcompressfile != formatspecs['format_lower']):
5007             return False
5008         compresscheck = CheckCompressionType(infile, formatspecs, True)
5009         if(not compresscheck):
5010             fextname = os.path.splitext(infile)[1]
5011             if(fextname == ".gz"):
5012                 compresscheck = "gzip"
5013             elif(fextname == ".bz2"):
5014                 compresscheck = "bzip2"
5015             elif(fextname == ".zst"):
5016                 compresscheck = "zstd"
5017             elif(fextname == ".lz4" or fextname == ".clz4"):
5018                 compresscheck = "lz4"
5019             elif(fextname == ".lzo" or fextname == ".lzop"):
5020                 compresscheck = "lzo"
5021             elif(fextname == ".lzma"):
5022                 compresscheck = "lzma"
5023             elif(fextname == ".xz"):
5024                 compresscheck = "xz"
5025             elif(fextname == ".zz" or fextname == ".zl" or fextname == ".zlib"):
5026                 compresscheck = "zlib"
5027             else:
5028                 return False
5029         if(not compresscheck):
5030             return False
5031         catfp = UncompressFile(infile, formatspecs, "rb")
5032     '''
5033  try:
5034   catfp.seek(0, 2);
5035  except OSError:
5036   SeekToEndOfFile(catfp);
5037  except ValueError:
5038   SeekToEndOfFile(catfp);
5039  CatSize = catfp.tell();
5040  CatSizeEnd = CatSize;
5041  '''
5042     try:
5043         catfp.seek(0, 0)
5044     except OSError:
5045         return False
5046     except ValueError:
5047         return False
5048     curloc = catfp.tell()
5049     if(curloc > 0):
5050         catfp.seek(0, 0)
5051     catheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
5052     catstring = catfp.read(len(formatspecs['format_magic']+catheaderver)).decode("UTF-8")
5053     catdel = catfp.read(1).decode("UTF-8")
5054     if(catstring != formatspecs['format_magic']+catheaderver):
5055         return False
5056     if(catdel != formatspecs['format_delimiter']):
5057         return False
5058     catheader = ReadFileHeaderData(catfp, 3, formatspecs['format_delimiter'])
5059     if(curloc > 0):
5060         catfp.seek(curloc, 0)
5061     catversion = re.findall("([\\d]+)", catstring)
5062     fprenumfiles = catheader[0]
5063     fnumfiles = int(fprenumfiles, 16)
5064     fprechecksumtype = catheader[1]
5065     fprechecksum = catheader[2]
5066     fileheader = AppendNullByte(catstring, formatspecs['format_delimiter'])
5067     fnumfileshex = format(int(fnumfiles), 'x').lower()
5068     fileheader = fileheader + \
5069         AppendNullBytes([fnumfileshex, fprechecksumtype],
5070                         formatspecs['format_delimiter'])
5071     catfileheadercshex = GetFileChecksum(
5072         fileheader, fprechecksumtype, True, formatspecs)
5073     fileheader = fileheader + \
5074         AppendNullByte(catfileheadercshex, formatspecs['format_delimiter'])
5075     fheadtell = len(fileheader)
5076     if(fprechecksum != catfileheadercshex and not skipchecksum):
5077         VerbosePrintOut("File Header Checksum Error with file " +
5078                         infile + " at offset " + str(0))
5079         VerbosePrintOut("'" + str(fprechecksum) + "' != " +
5080                         "'" + str(catfileheadercshex) + "'")
5081         return False
5082     catversions = re.search('(.*?)(\\d+)', catstring).groups()
5083     catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1],
5084                'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': {}}
5085     if(seekto >= fnumfiles):
5086         seekto = fnumfiles - 1
5087     if(seekto < 0):
5088         seekto = 0
5089     if(seekto >= 0):
5090         il = -1
5091         while(il < seekto):
5092             prefhstart = catfp.tell()
5093             if(formatspecs['new_style']):
5094                 preheaderdata = ReadFileHeaderDataBySize(
5095                     catfp, formatspecs['format_delimiter'])
5096             else:
5097                 preheaderdata = ReadFileHeaderDataWoSize(
5098                     catfp, formatspecs['format_delimiter'])
5099             if(len(preheaderdata) == 0):
5100                 break
5101             prefheadsize = int(preheaderdata[0], 16)
5102             prefnumfields = int(preheaderdata[1], 16)
5103             preftype = int(preheaderdata[2], 16)
5104             if(re.findall("^[.|/]", preheaderdata[3])):
5105                 prefname = preheaderdata[3]
5106             else:
5107                 prefname = "./"+preheaderdata[3]
5108             prefbasedir = os.path.dirname(prefname)
5109             preflinkname = preheaderdata[4]
5110             prefsize = int(preheaderdata[5], 16)
5111             prefatime = int(preheaderdata[6], 16)
5112             prefmtime = int(preheaderdata[7], 16)
5113             prefctime = int(preheaderdata[8], 16)
5114             prefbtime = int(preheaderdata[9], 16)
5115             prefmode = int(preheaderdata[10], 16)
5116             prefchmode = stat.S_IMODE(prefmode)
5117             preftypemod = stat.S_IFMT(prefmode)
5118             prefwinattributes = int(preheaderdata[11], 16)
5119             prefcompression = preheaderdata[12]
5120             prefcsize = int(preheaderdata[13], 16)
5121             prefuid = int(preheaderdata[14], 16)
5122             prefuname = preheaderdata[15]
5123             prefgid = int(preheaderdata[16], 16)
5124             prefgname = preheaderdata[17]
5125             fid = int(preheaderdata[18], 16)
5126             finode = int(preheaderdata[19], 16)
5127             flinkcount = int(preheaderdata[20], 16)
5128             prefdev_minor = int(preheaderdata[21], 16)
5129             prefdev_major = int(preheaderdata[22], 16)
5130             prefrdev_minor = int(preheaderdata[23], 16)
5131             prefrdev_major = int(preheaderdata[24], 16)
5132             prefseeknextfile = preheaderdata[25]
5133             prefextrasize = int(preheaderdata[26], 16)
5134             prefextrafields = int(preheaderdata[27], 16)
5135             extrafieldslist = []
5136             extrastart = 28
5137             extraend = extrastart + prefextrafields
5138             extrafieldslist = []
5139             if(extrastart < extraend):
5140                 extrafieldslist.append(preheaderdata[extrastart])
5141                 extrastart = extrastart + 1
5142             prefcs = preheaderdata[-2].lower()
5143             prenewfcs = preheaderdata[-1].lower()
5144             prenewfcs = GetHeaderChecksum(
5145                 preheaderdata[:-2], preheaderdata[-4].lower(), True, formatspecs)
5146             if(prefcs != prenewfcs and not skipchecksum):
5147                 VerbosePrintOut("File Header Checksum Error with file " +
5148                                 prefname + " at offset " + str(prefhstart))
5149                 VerbosePrintOut("'" + str(prefcs) + "' != " +
5150                                 "'" + str(prenewfcs) + "'")
5151                 return False
5152                 valid_archive = False
5153                 invalid_archive = True
5154             prefhend = catfp.tell() - 1
5155             prefcontentstart = catfp.tell()
5156             prefcontents = ""
5157             pyhascontents = False
5158             if(prefsize > 0):
5159                 if(prefcompression):
5160                     prefcontents = catfp.read(prefsize)
5161                 else:
5162                     prefcontents = catfp.read(prefcsize)
5163                 prenewfccs = GetFileChecksum(
5164                     prefcontents, preheaderdata[-3].lower(), False, formatspecs)
5165                 pyhascontents = True
5166                 if(prefccs != prenewfccs and not skipchecksum):
5167                     VerbosePrintOut("File Content Checksum Error with file " +
5168                                     prefname + " at offset " + str(prefcontentstart))
5169                     VerbosePrintOut("'" + str(prefccs) +
5170                                     "' != " + "'" + str(prenewfccs) + "'")
5171                     return False
5172             if(re.findall("^\\+([0-9]+)", prefseeknextfile)):
5173                 fseeknextasnum = int(prefseeknextfile.replace("+", ""))
5174                 if(abs(fseeknextasnum) == 0):
5175                     pass
5176                 catfp.seek(fseeknextasnum, 1)
5177             elif(re.findall("^\\-([0-9]+)", prefseeknextfile)):
5178                 fseeknextasnum = int(prefseeknextfile)
5179                 if(abs(fseeknextasnum) == 0):
5180                     pass
5181                 catfp.seek(fseeknextasnum, 1)
5182             elif(re.findall("^([0-9]+)", prefseeknextfile)):
5183                 fseeknextasnum = int(prefseeknextfile)
5184                 if(abs(fseeknextasnum) == 0):
5185                     pass
5186                 catfp.seek(fseeknextasnum, 0)
5187             else:
5188                 return False
5189             il = il + 1
5190     catfp.seek(seekstart, 0)
5191     fileidnum = il
5192     catfheadsize = int(preheaderdata[0], 16)
5193     catfnumfields = int(preheaderdata[1], 16)
5194     catftype = int(preheaderdata[2], 16)
5195     if(re.findall("^[.|/]", preheaderdata[3])):
5196         catfname = preheaderdata[3]
5197     else:
5198         catfname = "./"+preheaderdata[3]
5199     catflinkname = preheaderdata[4]
5200     catfsize = int(preheaderdata[5], 16)
5201     catfbasedir = os.path.dirname(catfname)
5202     catlist = {'fid': fileidnum, 'foffset': catfp.tell(), 'ftype': catftype, 'fname': catfname,
5203                'fbasedir': catfbasedir, 'flinkname': catflinkname, 'fsize': catfsize}
5204     if(returnfp):
5205         catlist.update({'catfp': catfp})
5206     else:
5207         catfp.close()
5208     return catlist
5209
5210
5211 create_alias_function("", __file_format_name__,
5212                       "SeekToFileNum", ArchiveFileSeekToFileNum)
5213
5214
5215 def ArchiveFileSeekToFileName(infile, seekfile=None, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, returnfp=False):
5216     formatspecs = FormatSpecsListToDict(formatspecs)
5217     if(hasattr(infile, "read") or hasattr(infile, "write")):
5218         catfp = infile
5219         catfp.seek(0, 0)
5220         catfp = UncompressArchiveFile(catfp, formatspecs)
5221         checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True)
5222         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
5223             return TarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
5224         if(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
5225             return ZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
5226         if(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
5227             return RarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
5228         if(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
5229             return SevenZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
5230         if(checkcompressfile != "catfile" and checkcompressfile != formatspecs['format_lower']):
5231             return False
5232         if(not catfp):
5233             return False
5234         catfp.seek(0, 0)
5235     elif(infile == "-"):
5236         catfp = BytesIO()
5237         if(hasattr(sys.stdin, "buffer")):
5238             shutil.copyfileobj(sys.stdin.buffer, catfp)
5239         else:
5240             shutil.copyfileobj(sys.stdin, catfp)
5241         catfp.seek(0, 0)
5242         catfp = UncompressArchiveFile(catfp, formatspecs)
5243         if(not catfp):
5244             return False
5245         catfp.seek(0, 0)
5246     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
5247         catfp = download_file_from_internet_file(infile)
5248         catfp = UncompressArchiveFile(catfp, formatspecs)
5249         catfp.seek(0, 0)
5250         if(not catfp):
5251             return False
5252         catfp.seek(0, 0)
5253     else:
5254         infile = RemoveWindowsPath(infile)
5255         checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
5256         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
5257             return TarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
5258         if(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
5259             return ZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
5260         if(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
5261             return RarFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
5262         if(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
5263             return SevenZipFileToArray(infile, 0, 0, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
5264         if(checkcompressfile != "catfile" and checkcompressfile != formatspecs['format_lower']):
5265             return False
5266         compresscheck = CheckCompressionType(infile, formatspecs, True)
5267         if(not compresscheck):
5268             fextname = os.path.splitext(infile)[1]
5269             if(fextname == ".gz"):
5270                 compresscheck = "gzip"
5271             elif(fextname == ".bz2"):
5272                 compresscheck = "bzip2"
5273             elif(fextname == ".zst"):
5274                 compresscheck = "zstd"
5275             elif(fextname == ".lz4" or fextname == ".clz4"):
5276                 compresscheck = "lz4"
5277             elif(fextname == ".lzo" or fextname == ".lzop"):
5278                 compresscheck = "lzo"
5279             elif(fextname == ".lzma"):
5280                 compresscheck = "lzma"
5281             elif(fextname == ".xz"):
5282                 compresscheck = "xz"
5283             elif(fextname == ".zz" or fextname == ".zl" or fextname == ".zlib"):
5284                 compresscheck = "zlib"
5285             else:
5286                 return False
5287         if(not compresscheck):
5288             return False
5289         catfp = UncompressFile(infile, formatspecs, "rb")
5290     '''
5291  try:
5292   catfp.seek(0, 2);
5293  except OSError:
5294   SeekToEndOfFile(catfp);
5295  except ValueError:
5296   SeekToEndOfFile(catfp);
5297  CatSize = catfp.tell();
5298  CatSizeEnd = CatSize;
5299  '''
5300     try:
5301         catfp.seek(0, 0)
5302     except OSError:
5303         return False
5304     except ValueError:
5305         return False
5306     curloc = catfp.tell()
5307     if(curloc > 0):
5308         catfp.seek(0, 0)
5309     catheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
5310     catstring = catfp.read(len(formatspecs['format_magic']+catheaderver)).decode("UTF-8")
5311     catdel = catfp.read(1).decode("UTF-8")
5312     if(catstring != formatspecs['format_magic']+catheaderver):
5313         return False
5314     if(catdel != formatspecs['format_delimiter']):
5315         return False
5316     catheader = ReadFileHeaderData(catfp, 3, formatspecs['format_delimiter'])
5317     if(curloc > 0):
5318         catfp.seek(curloc, 0)
5319     catversion = re.findall("([\\d]+)", catstring)
5320     fprenumfiles = catheader[0]
5321     fnumfiles = int(fprenumfiles, 16)
5322     fprechecksumtype = catheader[1]
5323     fprechecksum = catheader[2]
5324     fileheader = AppendNullByte(catstring, formatspecs['format_delimiter'])
5325     fnumfileshex = format(int(fnumfiles), 'x').lower()
5326     fileheader = fileheader + \
5327         AppendNullBytes([fnumfileshex, fprechecksumtype],
5328                         formatspecs['format_delimiter'])
5329     catfileheadercshex = GetFileChecksum(
5330         fileheader, fprechecksumtype, True, formatspecs)
5331     fileheader = fileheader + \
5332         AppendNullByte(catfileheadercshex, formatspecs['format_delimiter'])
5333     fheadtell = len(fileheader)
5334     if(fprechecksum != catfileheadercshex and not skipchecksum):
5335         VerbosePrintOut("File Header Checksum Error with file " +
5336                         infile + " at offset " + str(0))
5337         VerbosePrintOut("'" + str(fprechecksum) + "' != " +
5338                         "'" + str(catfileheadercshex) + "'")
5339         return False
5340     catversions = re.search('(.*?)(\\d+)', catstring).groups()
5341     catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1],
5342                'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': {}}
5343     seekto = fnumfiles - 1
5344     filefound = False
5345     if(seekto >= 0):
5346         il = -1
5347         while(il < seekto):
5348             prefhstart = catfp.tell()
5349             if(formatspecs['new_style']):
5350                 preheaderdata = ReadFileHeaderDataBySize(
5351                     catfp, formatspecs['format_delimiter'])
5352             else:
5353                 preheaderdata = ReadFileHeaderDataWoSize(
5354                     catfp, formatspecs['format_delimiter'])
5355             if(len(preheaderdata) == 0):
5356                 break
5357             prefheadsize = int(preheaderdata[0], 16)
5358             prefnumfields = int(preheaderdata[1], 16)
5359             preftype = int(preheaderdata[2], 16)
5360             if(re.findall("^[.|/]", preheaderdata[3])):
5361                 prefname = preheaderdata[3]
5362             else:
5363                 prefname = "./"+preheaderdata[3]
5364             prefbasedir = os.path.dirname(prefname)
5365             preflinkname = preheaderdata[4]
5366             prefsize = int(preheaderdata[5], 16)
5367             prefatime = int(preheaderdata[6], 16)
5368             prefmtime = int(preheaderdata[7], 16)
5369             prefctime = int(preheaderdata[8], 16)
5370             prefbtime = int(preheaderdata[9], 16)
5371             prefmode = int(preheaderdata[10], 16)
5372             prefchmode = stat.S_IMODE(prefmode)
5373             preftypemod = stat.S_IFMT(prefmode)
5374             prefwinattributes = int(preheaderdata[11], 16)
5375             prefcompression = preheaderdata[12]
5376             prefcsize = int(preheaderdata[13], 16)
5377             prefuid = int(preheaderdata[14], 16)
5378             prefuname = preheaderdata[15]
5379             prefgid = int(preheaderdata[16], 16)
5380             prefgname = preheaderdata[17]
5381             fid = int(preheaderdata[18], 16)
5382             finode = int(preheaderdata[19], 16)
5383             flinkcount = int(preheaderdata[20], 16)
5384             prefdev_minor = int(preheaderdata[21], 16)
5385             prefdev_major = int(preheaderdata[22], 16)
5386             prefrdev_minor = int(preheaderdata[23], 16)
5387             prefrdev_major = int(preheaderdata[24], 16)
5388             prefseeknextfile = preheaderdata[25]
5389             prefextrasize = int(preheaderdata[26], 16)
5390             prefextrafields = int(preheaderdata[27], 16)
5391             extrafieldslist = []
5392             extrastart = 28
5393             extraend = extrastart + prefextrafields
5394             extrafieldslist = []
5395             if(extrastart < extraend):
5396                 extrafieldslist.append(preheaderdata[extrastart])
5397                 extrastart = extrastart + 1
5398             prefcs = preheaderdata[-2].lower()
5399             prenewfcs = preheaderdata[-1].lower()
5400             prenewfcs = GetHeaderChecksum(
5401                 preheaderdata[:-2], preheaderdata[-4].lower(), True, formatspecs)
5402             if(prefcs != prenewfcs and not skipchecksum):
5403                 VerbosePrintOut("File Header Checksum Error with file " +
5404                                 prefname + " at offset " + str(prefhstart))
5405                 VerbosePrintOut("'" + str(prefcs) + "' != " +
5406                                 "'" + str(prenewfcs) + "'")
5407                 return False
5408                 valid_archive = False
5409                 invalid_archive = True
5410             prefhend = catfp.tell() - 1
5411             prefcontentstart = catfp.tell()
5412             prefcontents = ""
5413             pyhascontents = False
5414             if(prefsize > 0):
5415                 if(prefcompression):
5416                     prefcontents = catfp.read(prefsize)
5417                 else:
5418                     prefcontents = catfp.read(prefcsize)
5419                 prenewfccs = GetFileChecksum(
5420                     prefcontents, preheaderdata[-3].lower(), False, formatspecs)
5421                 pyhascontents = True
5422                 if(prefccs != prenewfccs and not skipchecksum):
5423                     VerbosePrintOut("File Content Checksum Error with file " +
5424                                     prefname + " at offset " + str(prefcontentstart))
5425                     VerbosePrintOut("'" + str(prefccs) +
5426                                     "' != " + "'" + str(prenewfccs) + "'")
5427                     return False
5428             if(re.findall("^\\+([0-9]+)", prefseeknextfile)):
5429                 fseeknextasnum = int(prefseeknextfile.replace("+", ""))
5430                 if(abs(fseeknextasnum) == 0):
5431                     pass
5432                 catfp.seek(fseeknextasnum, 1)
5433             elif(re.findall("^\\-([0-9]+)", prefseeknextfile)):
5434                 fseeknextasnum = int(prefseeknextfile)
5435                 if(abs(fseeknextasnum) == 0):
5436                     pass
5437                 catfp.seek(fseeknextasnum, 1)
5438             elif(re.findall("^([0-9]+)", prefseeknextfile)):
5439                 fseeknextasnum = int(prefseeknextfile)
5440                 if(abs(fseeknextasnum) == 0):
5441                     pass
5442                 catfp.seek(fseeknextasnum, 0)
5443             else:
5444                 return False
5445             il = il + 1
5446             filefound = False
5447             prefname = preheaderdata[2]
5448             if(re.findall("^[.|/]", preheaderdata[2])):
5449                 prefname = preheaderdata[2]
5450             else:
5451                 prefname = "./"+preheaderdata[2]
5452             if(prefname == seekfile):
5453                 filefound = True
5454                 break
5455     catfp.seek(seekstart, 0)
5456     fileidnum = il
5457     catfheadsize = int(preheaderdata[0], 16)
5458     catfnumfields = int(preheaderdata[1], 16)
5459     catftype = int(preheaderdata[2], 16)
5460     if(re.findall("^[.|/]", preheaderdata[3])):
5461         catfname = preheaderdata[3]
5462     else:
5463         catfname = "./"+preheaderdata[3]
5464     catflinkname = preheaderdata[4]
5465     catfsize = int(preheaderdata[5], 16)
5466     catfbasedir = os.path.dirname(catfname)
5467     if(filefound):
5468         catlist = {'fid': fileidnum, 'foffset': catfp.tell(), 'ftype': catftype, 'fname': catfname,
5469                    'fbasedir': catfbasedir, 'flinkname': catflinkname, 'fsize': catfsize}
5470     else:
5471         return False
5472     if(returnfp):
5473         catlist.update({'catfp': catfp})
5474     else:
5475         catfp.close()
5476     return catlist
5477
5478
5479 create_alias_function("", __file_format_name__,
5480                       "SeekToFileName", ArchiveFileSeekToFileName)
5481
5482
5483 def ArchiveFileValidate(infile, formatspecs=__file_format_dict__, verbose=False, returnfp=False):
5484     formatspecs = FormatSpecsListToDict(formatspecs)
5485     if(verbose):
5486         logging.basicConfig(format="%(message)s",
5487                             stream=sys.stdout, level=logging.DEBUG)
5488     if(hasattr(infile, "read") or hasattr(infile, "write")):
5489         catfp = infile
5490         catfp.seek(0, 0)
5491         catfp = UncompressArchiveFile(catfp, formatspecs)
5492         checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True)
5493         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
5494             return TarFileToArray(infile, 0, 0, False, True, False, formatspecs, returnfp)
5495         if(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
5496             return ZipFileToArray(infile, 0, 0, False, True, False, formatspecs, returnfp)
5497         if(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
5498             return RarFileToArray(infile, 0, 0, False, True, False, formatspecs, returnfp)
5499         if(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
5500             return SevenZipFileToArray(infile, 0, 0, False, True, False, formatspecs, returnfp)
5501         if(checkcompressfile != "catfile" and checkcompressfile != formatspecs['format_lower']):
5502             return False
5503         if(not catfp):
5504             return False
5505         catfp.seek(0, 0)
5506     elif(infile == "-"):
5507         catfp = BytesIO()
5508         if(hasattr(sys.stdin, "buffer")):
5509             shutil.copyfileobj(sys.stdin.buffer, catfp)
5510         else:
5511             shutil.copyfileobj(sys.stdin, catfp)
5512         catfp.seek(0, 0)
5513         catfp = UncompressArchiveFile(catfp, formatspecs)
5514         if(not catfp):
5515             return False
5516         catfp.seek(0, 0)
5517     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
5518         catfp = download_file_from_internet_file(infile)
5519         catfp = UncompressArchiveFile(catfp, formatspecs)
5520         catfp.seek(0, 0)
5521         if(not catfp):
5522             return False
5523         catfp.seek(0, 0)
5524     else:
5525         infile = RemoveWindowsPath(infile)
5526         checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
5527         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
5528             return TarFileToArray(infile, 0, 0, False, True, False, formatspecs, returnfp)
5529         if(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
5530             return ZipFileToArray(infile, 0, 0, False, True, False, formatspecs, returnfp)
5531         if(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
5532             return RarFileToArray(infile, 0, 0, False, True, False, formatspecs, returnfp)
5533         if(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
5534             return SevenZipFileToArray(infile, 0, 0, False, True, False, formatspecs, returnfp)
5535         if(checkcompressfile != "catfile" and checkcompressfile != formatspecs['format_lower']):
5536             return False
5537         compresscheck = CheckCompressionType(infile, formatspecs, True)
5538         if(not compresscheck):
5539             fextname = os.path.splitext(infile)[1]
5540             if(fextname == ".gz"):
5541                 compresscheck = "gzip"
5542             elif(fextname == ".bz2"):
5543                 compresscheck = "bzip2"
5544             elif(fextname == ".zst"):
5545                 compresscheck = "zstd"
5546             elif(fextname == ".lz4" or fextname == ".clz4"):
5547                 compresscheck = "lz4"
5548             elif(fextname == ".lzo" or fextname == ".lzop"):
5549                 compresscheck = "lzo"
5550             elif(fextname == ".lzma"):
5551                 compresscheck = "lzma"
5552             elif(fextname == ".xz"):
5553                 compresscheck = "xz"
5554             elif(fextname == ".zz" or fextname == ".zl" or fextname == ".zlib"):
5555                 compresscheck = "zlib"
5556             else:
5557                 return False
5558         if(not compresscheck):
5559             return False
5560         catfp = UncompressFile(infile, formatspecs, "rb")
5561     '''
5562  try:
5563   catfp.seek(0, 2);
5564  except OSError:
5565   SeekToEndOfFile(catfp);
5566  except ValueError:
5567   SeekToEndOfFile(catfp);
5568  CatSize = catfp.tell();
5569  CatSizeEnd = CatSize;
5570  '''
5571     try:
5572         catfp.seek(0, 0)
5573     except OSError:
5574         return False
5575     except ValueError:
5576         return False
5577     curloc = catfp.tell()
5578     if(curloc > 0):
5579         catfp.seek(0, 0)
5580     catheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
5581     catstring = catfp.read(len(formatspecs['format_magic']+catheaderver)).decode("UTF-8")
5582     catdel = catfp.read(1).decode("UTF-8")
5583     if(catstring != formatspecs['format_magic']+catheaderver):
5584         return False
5585     if(catdel != formatspecs['format_delimiter']):
5586         return False
5587     catheader = ReadFileHeaderData(catfp, 3, formatspecs['format_delimiter'])
5588     if(curloc > 0):
5589         catfp.seek(curloc, 0)
5590     catversion = re.findall("([\\d]+)", catstring)
5591     fprenumfiles = catheader[0]
5592     fnumfiles = int(fprenumfiles, 16)
5593     fprechecksumtype = catheader[1]
5594     fprechecksum = catheader[2]
5595     il = 0
5596     fileheader = AppendNullByte(catstring, formatspecs['format_delimiter'])
5597     fnumfileshex = format(int(fnumfiles), 'x').lower()
5598     fileheader = fileheader + \
5599         AppendNullBytes([fnumfileshex, fprechecksumtype],
5600                         formatspecs['format_delimiter'])
5601     catfileheadercshex = GetFileChecksum(
5602         fileheader, fprechecksumtype, True, formatspecs)
5603     fileheader = fileheader + \
5604         AppendNullByte(catfileheadercshex, formatspecs['format_delimiter'])
5605     valid_archive = True
5606     invalid_archive = False
5607     if(verbose):
5608         if(hasattr(infile, "read") or hasattr(infile, "write")):
5609             try:
5610                 VerbosePrintOut(infile.name)
5611             except AttributeError:
5612                 VerbosePrintOut(infile)
5613         else:
5614             VerbosePrintOut(infile)
5615         VerbosePrintOut("Number of Records " + str(fnumfiles))
5616     if(fprechecksum == catfileheadercshex):
5617         if(verbose):
5618             VerbosePrintOut("File Header Checksum Passed at offset " + str(0))
5619             VerbosePrintOut("'" + str(fprechecksum) + "' == " +
5620                             "'" + str(catfileheadercshex) + "'")
5621     else:
5622         if(verbose):
5623             VerbosePrintOut("File Header Checksum Failed at offset " + str(0))
5624             VerbosePrintOut("'" + str(fprechecksum) + "' != " +
5625                             "'" + str(catfileheadercshex) + "'")
5626             valid_archive = False
5627             invalid_archive = True
5628     if(verbose):
5629         VerbosePrintOut("")
5630     while(il < fnumfiles):
5631         catfhstart = catfp.tell()
5632         if(formatspecs['new_style']):
5633             catheaderdata = ReadFileHeaderDataBySize(
5634                 catfp, formatspecs['format_delimiter'])
5635         else:
5636             catheaderdata = ReadFileHeaderDataWoSize(
5637                 catfp, formatspecs['format_delimiter'])
5638         if(len(catheaderdata) == 0):
5639             break
5640         catfheadsize = int(catheaderdata[0], 16)
5641         catfnumfields = int(catheaderdata[1], 16)
5642         catftype = int(catheaderdata[2], 16)
5643         if(re.findall("^[.|/]", catheaderdata[3])):
5644             catfname = catheaderdata[3]
5645         else:
5646             catfname = "./"+catheaderdata[3]
5647         catfbasedir = os.path.dirname(catfname)
5648         catflinkname = catheaderdata[4]
5649         catfsize = int(catheaderdata[5], 16)
5650         catfatime = int(catheaderdata[6], 16)
5651         catfmtime = int(catheaderdata[7], 16)
5652         catfctime = int(catheaderdata[8], 16)
5653         catfbtime = int(catheaderdata[9], 16)
5654         catfmode = int(catheaderdata[10], 16)
5655         catfchmode = stat.S_IMODE(catfmode)
5656         catftypemod = stat.S_IFMT(catfmode)
5657         catfwinattributes = int(catheaderdata[11], 16)
5658         catfcompression = catheaderdata[12]
5659         catfcsize = int(catheaderdata[13], 16)
5660         catfuid = int(catheaderdata[14], 16)
5661         catfuname = catheaderdata[15]
5662         catfgid = int(catheaderdata[16], 16)
5663         catfgname = catheaderdata[17]
5664         fid = int(catheaderdata[18], 16)
5665         finode = int(catheaderdata[19], 16)
5666         flinkcount = int(catheaderdata[20], 16)
5667         catfdev_minor = int(catheaderdata[21], 16)
5668         catfdev_major = int(catheaderdata[22], 16)
5669         catfrdev_minor = int(catheaderdata[23], 16)
5670         catfrdev_major = int(catheaderdata[24], 16)
5671         catfseeknextfile = catheaderdata[25]
5672         catfextrasize = int(catheaderdata[26], 16)
5673         catfextrafields = int(catheaderdata[27], 16)
5674         extrafieldslist = []
5675         extrastart = 28
5676         extraend = extrastart + catfextrafields
5677         extrafieldslist = []
5678         if(extrastart < extraend):
5679             extrafieldslist.append(catheaderdata[extrastart])
5680             extrastart = extrastart + 1
5681         catfcs = catheaderdata[-2].lower()
5682         catfccs = catheaderdata[-1].lower()
5683         catnewfcs = GetHeaderChecksum(
5684             catheaderdata[:-2], catheaderdata[-4].lower(), True, formatspecs)
5685         if(verbose):
5686             VerbosePrintOut(catfname)
5687             VerbosePrintOut("Record Number " + str(il) + "; File ID " +
5688                             str(fid) + "; iNode Number " + str(finode))
5689         if(catfcs == catnewfcs):
5690             if(verbose):
5691                 VerbosePrintOut(
5692                     "File Header Checksum Passed at offset " + str(catfhstart))
5693                 VerbosePrintOut("'" + str(catfcs) + "' == " +
5694                                 "'" + str(catnewfcs) + "'")
5695         else:
5696             if(verbose):
5697                 VerbosePrintOut(
5698                     "File Header Checksum Failed at offset " + str(catfhstart))
5699                 VerbosePrintOut("'" + str(catfcs) + "' != " +
5700                                 "'" + str(catnewfcs) + "'")
5701             valid_archive = False
5702             invalid_archive = True
5703         catfhend = catfp.tell() - 1
5704         catfcontentstart = catfp.tell()
5705         catfcontents = ""
5706         pyhascontents = False
5707         if(catfsize > 0):
5708             if(catfcompression == "none" or catfcompression == "" or catfcompression == "auto"):
5709                 catfcontents = catfp.read(catfsize)
5710             else:
5711                 catfcontents = catfp.read(catfcsize)
5712             catnewfccs = GetFileChecksum(
5713                 catfcontents, catheaderdata[-3].lower(), False, formatspecs)
5714             pyhascontents = True
5715             if(catfccs == catnewfccs):
5716                 if(verbose):
5717                     VerbosePrintOut(
5718                         "File Content Checksum Passed at offset " + str(catfcontentstart))
5719                     VerbosePrintOut("'" + str(catfccs) +
5720                                     "' == " + "'" + str(catnewfccs) + "'")
5721             else:
5722                 if(verbose):
5723                     VerbosePrintOut(
5724                         "File Content Checksum Failed at offset " + str(catfcontentstart))
5725                     VerbosePrintOut("'" + str(catfccs) +
5726                                     "' != " + "'" + str(catnewfccs) + "'")
5727                 valid_archive = False
5728                 invalid_archive = True
5729         if(verbose):
5730             VerbosePrintOut("")
5731         if(re.findall("^\\+([0-9]+)", catfseeknextfile)):
5732             fseeknextasnum = int(catfseeknextfile.replace("+", ""))
5733             if(abs(fseeknextasnum) == 0):
5734                 pass
5735             catfp.seek(fseeknextasnum, 1)
5736         elif(re.findall("^\\-([0-9]+)", catfseeknextfile)):
5737             fseeknextasnum = int(catfseeknextfile)
5738             if(abs(fseeknextasnum) == 0):
5739                 pass
5740             catfp.seek(fseeknextasnum, 1)
5741         elif(re.findall("^([0-9]+)", catfseeknextfile)):
5742             fseeknextasnum = int(catfseeknextfile)
5743             if(abs(fseeknextasnum) == 0):
5744                 pass
5745             catfp.seek(fseeknextasnum, 0)
5746         else:
5747             return False
5748         il = il + 1
5749     if(valid_archive):
5750         if(returnfp):
5751             return catfp
5752         else:
5753             catfp.close()
5754             return True
5755     else:
5756         catfp.close()
5757         return False
5758
5759
5760 create_alias_function("", __file_format_name__,
5761                       "Validate", ArchiveFileValidate)
5762
5763
5764 def ArchiveFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, returnfp=False):
5765     formatspecs = FormatSpecsListToDict(formatspecs)
5766     if(hasattr(infile, "read") or hasattr(infile, "write")):
5767         catfp = infile
5768         catfp.seek(0, 0)
5769         catfp = UncompressArchiveFile(catfp, formatspecs)
5770         checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True)
5771         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
5772             return TarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
5773         if(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
5774             return ZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
5775         if(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
5776             return RarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
5777         if(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
5778             return SevenZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
5779         if(checkcompressfile != "catfile" and checkcompressfile != formatspecs['format_lower']):
5780             return False
5781         if(not catfp):
5782             return False
5783         catfp.seek(0, 0)
5784     elif(infile == "-"):
5785         catfp = BytesIO()
5786         if(hasattr(sys.stdin, "buffer")):
5787             shutil.copyfileobj(sys.stdin.buffer, catfp)
5788         else:
5789             shutil.copyfileobj(sys.stdin, catfp)
5790         catfp.seek(0, 0)
5791         catfp = UncompressArchiveFile(catfp, formatspecs)
5792         if(not catfp):
5793             return False
5794         catfp.seek(0, 0)
5795     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
5796         catfp = download_file_from_internet_file(infile)
5797         catfp = UncompressArchiveFile(catfp, formatspecs)
5798         catfp.seek(0, 0)
5799         if(not catfp):
5800             return False
5801         catfp.seek(0, 0)
5802     else:
5803         infile = RemoveWindowsPath(infile)
5804         checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
5805         if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
5806             return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp)
5807         if(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
5808             return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp)
5809         if(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
5810             return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp)
5811         if(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
5812             return SevenZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp)
5813         if(checkcompressfile != "catfile" and checkcompressfile != formatspecs['format_lower']):
5814             return False
5815         compresscheck = CheckCompressionType(infile, formatspecs, True)
5816         if(not compresscheck):
5817             fextname = os.path.splitext(infile)[1]
5818             if(fextname == ".gz"):
5819                 compresscheck = "gzip"
5820             elif(fextname == ".bz2"):
5821                 compresscheck = "bzip2"
5822             elif(fextname == ".zst"):
5823                 compresscheck = "zstd"
5824             elif(fextname == ".lz4" or fextname == ".clz4"):
5825                 compresscheck = "lz4"
5826             elif(fextname == ".lzo" or fextname == ".lzop"):
5827                 compresscheck = "lzo"
5828             elif(fextname == ".lzma"):
5829                 compresscheck = "lzma"
5830             elif(fextname == ".xz"):
5831                 compresscheck = "xz"
5832             elif(fextname == ".zz" or fextname == ".zl" or fextname == ".zlib"):
5833                 compresscheck = "zlib"
5834             else:
5835                 return False
5836         if(not compresscheck):
5837             return False
5838         catfp = UncompressFile(infile, formatspecs, "rb")
5839     '''
5840  try:
5841   catfp.seek(0, 2);
5842  except OSError:
5843   SeekToEndOfFile(catfp);
5844  except ValueError:
5845   SeekToEndOfFile(catfp);
5846  CatSize = catfp.tell();
5847  CatSizeEnd = CatSize;
5848  '''
5849     try:
5850         catfp.seek(0, 0)
5851     except OSError:
5852         return False
5853     except ValueError:
5854         return False
5855     curloc = catfp.tell()
5856     if(curloc > 0):
5857         catfp.seek(0, 0)
5858     catheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
5859     catstring = catfp.read(len(formatspecs['format_magic']+catheaderver)).decode("UTF-8")
5860     catdel = catfp.read(1).decode("UTF-8")
5861     if(catstring != formatspecs['format_magic']+catheaderver):
5862         return False
5863     if(catdel != formatspecs['format_delimiter']):
5864         return False
5865     catheader = ReadFileHeaderData(catfp, 3, formatspecs['format_delimiter'])
5866     if(curloc > 0):
5867         catfp.seek(curloc, 0)
5868     catversion = re.findall("([\\d]+)", catstring)
5869     fprenumfiles = catheader[0]
5870     fnumfiles = int(fprenumfiles, 16)
5871     fprechecksumtype = catheader[1]
5872     fprechecksum = catheader[2]
5873     fileheader = AppendNullByte(catstring, formatspecs['format_delimiter'])
5874     fnumfileshex = format(int(fnumfiles), 'x').lower()
5875     fileheader = fileheader + \
5876         AppendNullBytes([fnumfileshex, fprechecksumtype],
5877                         formatspecs['format_delimiter'])
5878     catfileheadercshex = GetFileChecksum(
5879         fileheader, fprechecksumtype, True, formatspecs)
5880     fileheader = fileheader + \
5881         AppendNullByte(catfileheadercshex, formatspecs['format_delimiter'])
5882     fheadtell = len(fileheader)
5883     if(fprechecksum != catfileheadercshex and not skipchecksum):
5884         VerbosePrintOut(
5885             "File Header Checksum Error with file at offset " + str(0))
5886         VerbosePrintOut("'" + str(fprechecksum) + "' != " +
5887                         "'" + str(catfileheadercshex) + "'")
5888         return False
5889     catversions = re.search('(.*?)(\\d+)', catstring).groups()
5890     catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1],
5891                'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': []}
5892     if(seekstart < 0 and seekstart > fnumfiles):
5893         seekstart = 0
5894     if(seekend == 0 or seekend > fnumfiles and seekend < seekstart):
5895         seekend = fnumfiles
5896     elif(seekend < 0 and abs(seekend) <= fnumfiles and abs(seekend) >= seekstart):
5897         seekend = fnumfiles - abs(seekend)
5898     if(seekstart > 0):
5899         il = 0
5900         while(il < seekstart):
5901             prefhstart = catfp.tell()
5902             if(formatspecs['new_style']):
5903                 preheaderdata = ReadFileHeaderDataBySize(
5904                     catfp, formatspecs['format_delimiter'])
5905             else:
5906                 preheaderdata = ReadFileHeaderDataWoSize(
5907                     catfp, formatspecs['format_delimiter'])
5908             if(len(preheaderdata) == 0):
5909                 break
5910             prefheadsize = int(preheaderdata[0], 16)
5911             prefnumfields = int(preheaderdata[1], 16)
5912             if(re.findall("^[.|/]", preheaderdata[3])):
5913                 prefname = preheaderdata[3]
5914             else:
5915                 prefname = "./"+preheaderdata[3]
5916             prefsize = int(preheaderdata[5], 16)
5917             prefcompression = preheaderdata[12]
5918             prefcsize = int(preheaderdata[13], 16)
5919             prefseeknextfile = preheaderdata[25]
5920             prefextrasize = int(preheaderdata[26], 16)
5921             prefextrafields = int(preheaderdata[27], 16)
5922             extrafieldslist = []
5923             extrastart = 28
5924             extraend = extrastart + prefextrafields
5925             extrafieldslist = []
5926             if(extrastart < extraend):
5927                 extrafieldslist.append(preheaderdata[extrastart])
5928                 extrastart = extrastart + 1
5929             prefcs = preheaderdata[-2].lower()
5930             prenewfcs = preheaderdata[-1].lower()
5931             prenewfcs = GetHeaderChecksum(
5932                 preheaderdata[:-2], preheaderdata[-4].lower(), True, formatspecs)
5933             if(prefcs != prenewfcs and not skipchecksum):
5934                 VerbosePrintOut("File Header Checksum Error with file " +
5935                                 prefname + " at offset " + str(prefhstart))
5936                 VerbosePrintOut("'" + str(prefcs) + "' != " +
5937                                 "'" + str(prenewfcs) + "'")
5938                 return False
5939                 valid_archive = False
5940                 invalid_archive = True
5941             prefhend = catfp.tell() - 1
5942             prefcontentstart = catfp.tell()
5943             prefcontents = ""
5944             pyhascontents = False
5945             if(prefsize > 0):
5946                 if(prefcompression == "none" or prefcompression == "" or prefcompression == "auto"):
5947                     prefcontents = catfp.read(prefsize)
5948                 else:
5949                     prefcontents = catfp.read(prefcsize)
5950                 prenewfccs = GetFileChecksum(
5951                     prefcontents, preheaderdata[-3].lower(), False, formatspecs)
5952                 pyhascontents = True
5953                 if(prefccs != prenewfccs and not skipchecksum):
5954                     VerbosePrintOut("File Content Checksum Error with file " +
5955                                     prefname + " at offset " + str(prefcontentstart))
5956                     VerbosePrintOut("'" + str(prefccs) +
5957                                     "' != " + "'" + str(prenewfccs) + "'")
5958                     return False
5959             if(re.findall("^\\+([0-9]+)", prefseeknextfile)):
5960                 fseeknextasnum = int(prefseeknextfile.replace("+", ""))
5961                 if(abs(fseeknextasnum) == 0):
5962                     pass
5963                 catfp.seek(fseeknextasnum, 1)
5964             elif(re.findall("^\\-([0-9]+)", prefseeknextfile)):
5965                 fseeknextasnum = int(prefseeknextfile)
5966                 if(abs(fseeknextasnum) == 0):
5967                     pass
5968                 catfp.seek(fseeknextasnum, 1)
5969             elif(re.findall("^([0-9]+)", prefseeknextfile)):
5970                 fseeknextasnum = int(prefseeknextfile)
5971                 if(abs(fseeknextasnum) == 0):
5972                     pass
5973                 catfp.seek(fseeknextasnum, 0)
5974             else:
5975                 return False
5976             il = il + 1
5977     fileidnum = seekstart
5978     realidnum = 0
5979     while(fileidnum < seekend):
5980         catfhstart = catfp.tell()
5981         if(formatspecs['new_style']):
5982             catheaderdata = ReadFileHeaderDataBySize(
5983                 catfp, formatspecs['format_delimiter'])
5984         else:
5985             catheaderdata = ReadFileHeaderDataWoSize(
5986                 catfp, formatspecs['format_delimiter'])
5987         if(len(catheaderdata) == 0):
5988             break
5989         catfheadsize = int(catheaderdata[0], 16)
5990         catfnumfields = int(catheaderdata[1], 16)
5991         catftype = int(catheaderdata[2], 16)
5992         if(re.findall("^[.|/]", catheaderdata[3])):
5993             catfname = catheaderdata[3]
5994         else:
5995             catfname = "./"+catheaderdata[3]
5996         catfbasedir = os.path.dirname(catfname)
5997         catflinkname = catheaderdata[4]
5998         catfsize = int(catheaderdata[5], 16)
5999         catfatime = int(catheaderdata[6], 16)
6000         catfmtime = int(catheaderdata[7], 16)
6001         catfctime = int(catheaderdata[8], 16)
6002         catfbtime = int(catheaderdata[9], 16)
6003         catfmode = int(catheaderdata[10], 16)
6004         catfchmode = stat.S_IMODE(catfmode)
6005         catftypemod = stat.S_IFMT(catfmode)
6006         catfwinattributes = int(catheaderdata[11], 16)
6007         catfcompression = catheaderdata[12]
6008         catfcsize = int(catheaderdata[13], 16)
6009         catfuid = int(catheaderdata[14], 16)
6010         catfuname = catheaderdata[15]
6011         catfgid = int(catheaderdata[16], 16)
6012         catfgname = catheaderdata[17]
6013         catfid = int(catheaderdata[18], 16)
6014         catfinode = int(catheaderdata[19], 16)
6015         catflinkcount = int(catheaderdata[20], 16)
6016         catfdev_minor = int(catheaderdata[21], 16)
6017         catfdev_major = int(catheaderdata[22], 16)
6018         catfrdev_minor = int(catheaderdata[23], 16)
6019         catfrdev_major = int(catheaderdata[24], 16)
6020         catfseeknextfile = catheaderdata[25]
6021         catfextrasize = int(catheaderdata[26], 16)
6022         catfextrafields = int(catheaderdata[27], 16)
6023         extrafieldslist = []
6024         extrastart = 28
6025         extraend = extrastart + catfextrafields
6026         extrafieldslist = []
6027         if(extrastart < extraend):
6028             extrafieldslist.append(catheaderdata[extrastart])
6029             extrastart = extrastart + 1
6030         catfcs = catheaderdata[-2].lower()
6031         catfccs = catheaderdata[-1].lower()
6032         catnewfcs = GetHeaderChecksum(
6033             catheaderdata[:-2], catheaderdata[-4].lower(), True, formatspecs)
6034         if(catfcs != catnewfcs and not skipchecksum):
6035             VerbosePrintOut("File Header Checksum Error with file " +
6036                             catfname + " at offset " + str(catfhstart))
6037             VerbosePrintOut("'" + str(catfcs) + "' != " +
6038                             "'" + str(catnewfcs) + "'")
6039             return False
6040         catfhend = catfp.tell() - 1
6041         catfcontentstart = catfp.tell()
6042         catfcontents = BytesIO()
6043         pyhascontents = False
6044         if(catfsize > 0 and not listonly):
6045             if(catfcompression == "none" or catfcompression == "" or catfcompression == "auto"):
6046                 catfcontents.write(catfp.read(catfsize))
6047             else:
6048                 catfcontents.write(catfp.read(catfcsize))
6049             catfcontents.seek(0, 0)
6050             catnewfccs = GetFileChecksum(
6051                 catfcontents.read(), catheaderdata[-3].lower(), False, formatspecs)
6052             pyhascontents = True
6053             if(catfccs != catnewfccs and skipchecksum):
6054                 VerbosePrintOut("File Content Checksum Error with file " +
6055                                 catfname + " at offset " + str(catfcontentstart))
6056                 VerbosePrintOut("'" + str(catfccs) + "' != " +
6057                                 "'" + str(catnewfccs) + "'")
6058                 return False
6059             if(catfcompression == "none" or catfcompression == "" or catfcompression == "auto"):
6060                 pass
6061             else:
6062                 catfcontents.seek(0, 0)
6063                 if(uncompress):
6064                     catfcontents = UncompressArchiveFile(
6065                         catfcontents, formatspecs)
6066                     catfcontents.seek(0, 0)
6067                     catfccs = GetFileChecksum(
6068                         catfcontents.read(), catheaderdata[-3].lower(), False, formatspecs)
6069         if(catfsize > 0 and listonly):
6070             if(catfcompression == "none" or catfcompression == "" or catfcompression == "auto"):
6071                 catfp.seek(catfsize, 1)
6072             else:
6073                 catfp.seek(catfcsize, 1)
6074             pyhascontents = False
6075         catfcontentend = catfp.tell()
6076         if(re.findall("^\\+([0-9]+)", catfseeknextfile)):
6077             fseeknextasnum = int(catfseeknextfile.replace("+", ""))
6078             if(abs(fseeknextasnum) == 0):
6079                 pass
6080             catfp.seek(fseeknextasnum, 1)
6081         elif(re.findall("^\\-([0-9]+)", catfseeknextfile)):
6082             fseeknextasnum = int(catfseeknextfile)
6083             if(abs(fseeknextasnum) == 0):
6084                 pass
6085             catfp.seek(fseeknextasnum, 1)
6086         elif(re.findall("^([0-9]+)", catfseeknextfile)):
6087             fseeknextasnum = int(catfseeknextfile)
6088             if(abs(fseeknextasnum) == 0):
6089                 pass
6090             catfp.seek(fseeknextasnum, 0)
6091         else:
6092             return False
6093         catfcontents.seek(0, 0)
6094         if(not contentasfile):
6095             catfcontents = catfcontents.read()
6096         catlist['ffilelist'].append({'fid': realidnum, 'fidalt': fileidnum, 'fheadersize': catfheadsize, 'fhstart': catfhstart, 'fhend': catfhend, 'ftype': catftype, 'fname': catfname, 'fbasedir': catfbasedir, 'flinkname': catflinkname, 'fsize': catfsize, 'fatime': catfatime, 'fmtime': catfmtime, 'fctime': catfctime, 'fbtime': catfbtime, 'fmode': catfmode, 'fchmode': catfchmode, 'ftypemod': catftypemod, 'fwinattributes': catfwinattributes, 'fcompression': catfcompression, 'fcsize': catfcsize, 'fuid': catfuid, 'funame': catfuname, 'fgid': catfgid, 'fgname': catfgname, 'finode': catfinode, 'flinkcount': catflinkcount,
6097                                     'fminor': catfdev_minor, 'fmajor': catfdev_major, 'frminor': catfrdev_minor, 'frmajor': catfrdev_major, 'fseeknextfile': catfseeknextfile, 'fheaderchecksumtype': catheaderdata[-4], 'fcontentchecksumtype': catheaderdata[-3], 'fnumfields': catfnumfields + 2, 'frawheader': catheaderdata, 'fextrafields': catfextrafields, 'fextrafieldsize': catfextrasize, 'fextralist': extrafieldslist, 'fheaderchecksum': catfcs, 'fcontentchecksum': catfccs, 'fhascontents': pyhascontents, 'fcontentstart': catfcontentstart, 'fcontentend': catfcontentend, 'fcontentasfile': contentasfile, 'fcontents': catfcontents})
6098         fileidnum = fileidnum + 1
6099         realidnum = realidnum + 1
6100     if(returnfp):
6101         catlist.update({'catfp': catfp})
6102     else:
6103         catfp.close()
6104     return catlist
6105
6106
6107 create_alias_function("", __file_format_name__, "ToArray", ArchiveFileToArray)
6108
6109
6110 def ArchiveFileStringToArray(catstr, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, returnfp=False):
6111     formatspecs = FormatSpecsListToDict(formatspecs)
6112     catfp = BytesIO(catstr)
6113     listcatfiles = ArchiveFileToArray(
6114         catfp, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, returnfp)
6115     return listcatfiles
6116
6117
6118 create_alias_function("", __file_format_name__,
6119                       "StringToArray", ArchiveFileStringToArray)
6120
6121
6122 def TarFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, returnfp=False):
6123     formatspecs = FormatSpecsListToDict(formatspecs)
6124     catfp = BytesIO()
6125     catfp = PackArchiveFileFromTarFile(
6126         infile, catfp, "auto", True, None, "crc32", [], formatspecs, False, True)
6127     listcatfiles = ArchiveFileToArray(
6128         catfp, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, returnfp)
6129     return listcatfiles
6130
6131
6132 def ZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, returnfp=False):
6133     formatspecs = FormatSpecsListToDict(formatspecs)
6134     catfp = BytesIO()
6135     catfp = PackArchiveFileFromZipFile(
6136         infile, catfp, "auto", True, None, "crc32", [], formatspecs, False, True)
6137     listcatfiles = ArchiveFileToArray(
6138         catfp, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, returnfp)
6139     return listcatfiles
6140
6141
6142 if(not rarfile_support):
6143     def RarFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, returnfp=False):
6144         return False
6145
6146 if(rarfile_support):
6147     def RarFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, returnfp=False):
6148         formatspecs = FormatSpecsListToDict(formatspecs)
6149         catfp = BytesIO()
6150         catfp = PackArchiveFileFromSevenZipFile(
6151             infile, catfp, "auto", True, None, "crc32", [], formatspecs, False, True)
6152         listcatfiles = ArchiveFileToArray(
6153             catfp, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, returnfp)
6154         return listcatfiles
6155
6156 if(not py7zr_support):
6157     def SevenZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, returnfp=False):
6158         return False
6159
6160 if(py7zr_support):
6161     def SevenZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, returnfp=False):
6162         formatspecs = FormatSpecsListToDict(formatspecs)
6163         catfp = BytesIO()
6164         catfp = PackArchiveFileFromSevenZipFile(
6165             infile, catfp, "auto", True, None, "crc32", [], formatspecs, False, True)
6166         listcatfiles = ArchiveFileToArray(
6167             catfp, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, returnfp)
6168         return listcatfiles
6169
6170
6171 def InFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_dict__, returnfp=False):
6172     formatspecs = FormatSpecsListToDict(formatspecs)
6173     checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
6174     if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
6175         return TarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
6176     elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
6177         return ZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
6178     elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
6179         return RarFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
6180     elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
6181         return SevenZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, returnfp)
6182     elif(checkcompressfile == "catfile"):
6183         return ArchiveFileToArray(infile, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, returnfp)
6184     else:
6185         return False
6186     return False
6187
6188
6189 def ListDirToArrayAlt(infiles, dirlistfromtxt=False, followlink=False, listonly=False, contentasfile=True, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False):
6190     formatspecs = FormatSpecsListToDict(formatspecs)
6191     catver = formatspecs['format_ver']
6192     fileheaderver = str(int(catver.replace(".", "")))
6193     fileheader = AppendNullByte(
6194         formatspecs['format_magic'] + fileheaderver, formatspecs['format_delimiter'])
6195     advancedlist = formatspecs['use_advanced_list']
6196     altinode = formatspecs['use_alt_inode']
6197     infilelist = []
6198     if(infiles == "-"):
6199         for line in sys.stdin:
6200             infilelist.append(line.strip())
6201         infilelist = list(filter(None, infilelist))
6202     elif(infiles != "-" and dirlistfromtxt and os.path.exists(infiles) and (os.path.isfile(infiles) or infiles == "/dev/null" or infiles == "NUL")):
6203         if(not os.path.exists(infiles) or not os.path.isfile(infiles)):
6204             return False
6205         with UncompressFile(infiles, formatspecs, "r") as finfile:
6206             for line in finfile:
6207                 infilelist.append(line.strip())
6208         infilelist = list(filter(None, infilelist))
6209     else:
6210         if(isinstance(infiles, (list, tuple, ))):
6211             infilelist = list(filter(None, infiles))
6212         elif(isinstance(infiles, (str, ))):
6213             infilelist = list(filter(None, [infiles]))
6214     if(advancedlist):
6215         GetDirList = ListDirAdvanced(infilelist, followlink, False)
6216     else:
6217         GetDirList = ListDir(infilelist, followlink, False)
6218     if(not GetDirList):
6219         return False
6220     curinode = 0
6221     curfid = 0
6222     inodelist = []
6223     inodetofile = {}
6224     filetoinode = {}
6225     inodetocatinode = {}
6226     fileidnum = 0
6227     fnumfiles = int(len(GetDirList))
6228     catver = formatspecs['format_ver']
6229     fileheaderver = str(int(catver.replace(".", "")))
6230     fileheader = AppendNullByte(
6231         formatspecs['format_magic'] + fileheaderver, formatspecs['format_delimiter'])
6232     fnumfileshex = format(int(fnumfiles), 'x').lower()
6233     fileheader = fileheader + \
6234         AppendNullBytes([fnumfileshex, checksumtype],
6235                         formatspecs['format_delimiter'])
6236     catversion = re.findall("([\\d]+)", fileheader)
6237     catversions = re.search('(.*?)(\\d+)', fileheader).groups()
6238     catfileheadercshex = GetFileChecksum(
6239         fileheader, checksumtype, True, formatspecs)
6240     fileheader = fileheader + \
6241         AppendNullByte(catfileheadercshex, formatspecs['format_delimiter'])
6242     fheadtell = len(fileheader)
6243     catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1],
6244                'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': []}
6245     for curfname in GetDirList:
6246         catfhstart = fheadtell
6247         if(re.findall("^[.|/]", curfname)):
6248             fname = curfname
6249         else:
6250             fname = "./"+curfname
6251         if(verbose):
6252             VerbosePrintOut(fname)
6253         if(not followlink or followlink is None):
6254             fstatinfo = os.lstat(fname)
6255         else:
6256             fstatinfo = os.stat(fname)
6257         fpremode = fstatinfo.st_mode
6258         finode = fstatinfo.st_ino
6259         flinkcount = fstatinfo.st_nlink
6260         ftype = 0
6261         if(stat.S_ISREG(fpremode)):
6262             ftype = 0
6263         elif(stat.S_ISLNK(fpremode)):
6264             ftype = 2
6265         elif(stat.S_ISCHR(fpremode)):
6266             ftype = 3
6267         elif(stat.S_ISBLK(fpremode)):
6268             ftype = 4
6269         elif(stat.S_ISDIR(fpremode)):
6270             ftype = 5
6271         elif(stat.S_ISFIFO(fpremode)):
6272             ftype = 6
6273         elif(stat.S_ISSOCK(fpremode)):
6274             ftype = 8
6275         elif(hasattr(stat, "S_ISDOOR") and stat.S_ISDOOR(fpremode)):
6276             ftype = 9
6277         elif(hasattr(stat, "S_ISPORT") and stat.S_ISPORT(fpremode)):
6278             ftype = 10
6279         elif(hasattr(stat, "S_ISWHT") and stat.S_ISWHT(fpremode)):
6280             ftype = 11
6281         else:
6282             ftype = 0
6283         flinkname = ""
6284         fbasedir = os.path.dirname(fname)
6285         fcurfid = curfid
6286         if(not followlink and finode != 0):
6287             if(ftype != 1):
6288                 if(finode in inodelist):
6289                     ftype = 1
6290                     flinkname = inodetofile[finode]
6291                     if(altinode):
6292                         fcurinode = finode
6293                     else:
6294                         fcurinode = inodetocatinode[finode]
6295                 if(finode not in inodelist):
6296                     inodelist.append(finode)
6297                     inodetofile.update({finode: fname})
6298                     inodetocatinode.update({finode: curinode})
6299                     if(altinode):
6300                         fcurinode = finode
6301                     else:
6302                         fcurinode = curinode
6303                     curinode = curinode + 1
6304         else:
6305             fcurinode = curinode
6306             curinode = curinode + 1
6307         curfid = curfid + 1
6308         if(ftype == 2):
6309             flinkname = os.readlink(fname)
6310         fdev = fstatinfo.st_dev
6311         getfdev = GetDevMajorMinor(fdev)
6312         fdev_minor = getfdev[0]
6313         fdev_major = getfdev[1]
6314         frdev = fstatinfo.st_dev
6315         if(hasattr(fstatinfo, "st_rdev")):
6316             frdev = fstatinfo.st_rdev
6317         else:
6318             frdev = fstatinfo.st_dev
6319         getfrdev = GetDevMajorMinor(frdev)
6320         frdev_minor = getfrdev[0]
6321         frdev_major = getfrdev[1]
6322         if(ftype == 1 or ftype == 2 or ftype == 3 or ftype == 4 or ftype == 5 or ftype == 6):
6323             fsize = "0"
6324         if(ftype == 0 or ftype == 7):
6325             fsize = fstatinfo.st_size
6326         fatime = fstatinfo.st_atime
6327         fmtime = fstatinfo.st_mtime
6328         fctime = fstatinfo.st_ctime
6329         if(hasattr(fstatinfo, "st_birthtime")):
6330             fbtime = fstatinfo.st_birthtime
6331         else:
6332             fbtime = fstatinfo.st_ctime
6333         fmode = fstatinfo.st_mode
6334         fchmode = stat.S_IMODE(fstatinfo.st_mode)
6335         ftypemod = stat.S_IFMT(fstatinfo.st_mode)
6336         fuid = fstatinfo.st_uid
6337         fgid = fstatinfo.st_gid
6338         funame = ""
6339         try:
6340             import pwd
6341             try:
6342                 userinfo = pwd.getpwuid(fstatinfo.st_uid)
6343                 funame = userinfo.pw_name
6344             except KeyError:
6345                 funame = ""
6346         except ImportError:
6347             funame = ""
6348         fgname = ""
6349         try:
6350             import grp
6351             try:
6352                 groupinfo = grp.getgrgid(fstatinfo.st_gid)
6353                 fgname = groupinfo.gr_name
6354             except KeyError:
6355                 fgname = ""
6356         except ImportError:
6357             fgname = ""
6358         fdev_minor = fdev_minor
6359         fdev_major = fdev_major
6360         frdev_minor = frdev_minor
6361         frdev_major = frdev_major
6362         flinkcount = flinkcount
6363         if(hasattr(fstatinfo, "st_file_attributes")):
6364             fwinattributes = fstatinfo.st_file_attributes
6365         else:
6366             fwinattributes = 0
6367         fcompression = ""
6368         fcsize = 0
6369         fcontents = BytesIO()
6370         if(ftype == 0 or ftype == 7):
6371             with open(fname, "rb") as fpc:
6372                 shutil.copyfileobj(fpc, fcontents)
6373         if(followlink and (ftype == 1 or ftype == 2)):
6374             flstatinfo = os.stat(flinkname)
6375             with open(flinkname, "rb") as fpc:
6376                 shutil.copyfileobj(fpc, fcontents)
6377         fcontents.seek(0, 0)
6378         ftypehex = format(ftype, 'x').lower()
6379         extrafields = len(extradata)
6380         extrafieldslist = extradata
6381         catfextrafields = extrafields
6382         extrasizestr = AppendNullByte(
6383             extrafields, formatspecs['format_delimiter'])
6384         if(len(extradata) > 0):
6385             extrasizestr = extrasizestr + \
6386                 AppendNullBytes(extradata, formatspecs['format_delimiter'])
6387         extrasizelen = len(extrasizestr)
6388         extrasizelenhex = format(extrasizelen, 'x').lower()
6389         catoutlist = [ftypehex, fname, flinkname, format(int(fsize), 'x').lower(), format(int(fatime), 'x').lower(), format(int(fmtime), 'x').lower(), format(int(fctime), 'x').lower(), format(int(fbtime), 'x').lower(), format(int(fmode), 'x').lower(), format(int(fwinattributes), 'x').lower(), fcompression, format(int(fcsize), 'x').lower(), format(int(fuid), 'x').lower(
6390         ), funame, format(int(fgid), 'x').lower(), fgname, format(int(fcurfid), 'x').lower(), format(int(fcurinode), 'x').lower(), format(int(flinkcount), 'x').lower(), format(int(fdev_minor), 'x').lower(), format(int(fdev_major), 'x').lower(), format(int(frdev_minor), 'x').lower(), format(int(frdev_major), 'x').lower(), "+1", extrasizelenhex, format(catfextrafields, 'x').lower()]
6391         catoutlen = len(catoutlist) + len(extradata) + 3
6392         catoutlenhex = format(catoutlen, 'x').lower()
6393         catoutlist.insert(0, catoutlenhex)
6394         catfileoutstr = AppendNullBytes(
6395             catoutlist, formatspecs['format_delimiter'])
6396         catheaderdata = catoutlist
6397         if(len(extradata) > 0):
6398             catfileoutstr = catfileoutstr + \
6399                 AppendNullBytes(extradata, formatspecs['format_delimiter'])
6400         if(fsize == 0):
6401             checksumlist = [checksumtype, "none"]
6402         else:
6403             checksumlist = [checksumtype, checksumtype]
6404         catfileoutstr = catfileoutstr + \
6405             AppendNullBytes(checksumlist, formatspecs['format_delimiter'])
6406         catfnumfields = catoutlen
6407         catfileheadercshex = GetFileChecksum(
6408             catfileoutstr, checksumtype, True, formatspecs)
6409         fcontents.seek(0, 0)
6410         if(fsize == 0):
6411             catfilecontentcshex = GetFileChecksum(
6412                 fcontents.read(), "none", False, formatspecs)
6413         else:
6414             catfilecontentcshex = GetFileChecksum(
6415                 fcontents.read(), checksumtype, False, formatspecs)
6416         tmpfileoutstr = catfileoutstr + \
6417             AppendNullBytes([catfileheadercshex, catfilecontentcshex],
6418                             formatspecs['format_delimiter'])
6419         catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
6420         catfileoutstr = AppendNullByte(
6421             catheaersize, formatspecs['format_delimiter']) + catfileoutstr
6422         catfileheadercshex = GetFileChecksum(
6423             catfileoutstr, checksumtype, True, formatspecs)
6424         catfileoutstr = catfileoutstr + \
6425             AppendNullBytes([catfileheadercshex, catfilecontentcshex],
6426                             formatspecs['format_delimiter'])
6427         catfileoutstrecd = catfileoutstr.encode('UTF-8')
6428         nullstrecd = formatspecs['format_delimiter'].encode('UTF-8')
6429         catfcontentstart = fheadtell
6430         fheadtell += len(catfileoutstr) + 1
6431         catfcontentend = fheadtell - 1
6432         catfhend = catfcontentend
6433         fcontents.seek(0, 0)
6434         catfileout = catfileoutstrecd + fcontents.read() + nullstrecd
6435         pyhascontents = False
6436         if(int(fsize) > 0 and not listonly):
6437             pyhascontents = True
6438         if(int(fsize) > 0 and listonly):
6439             fcontents = BytesIO()
6440             pyhascontents = False
6441         fcontents.seek(0, 0)
6442         if(not contentasfile):
6443             fcontents = fcontents.read()
6444         catlist['ffilelist'].append({'fid': fileidnum, 'fidalt': fileidnum, 'fheadersize': int(catheaersize, 16), 'fhstart': catfhstart, 'fhend': catfhend, 'ftype': ftype, 'fname': fname, 'fbasedir': fbasedir, 'flinkname': flinkname, 'fsize': fsize, 'fatime': fatime, 'fmtime': fmtime, 'fctime': fctime, 'fbtime': fbtime, 'fmode': fmode, 'fchmode': fchmode, 'ftypemod': ftypemod, 'fwinattributes': fwinattributes, 'fcompression': fcompression, 'fcsize': fcsize, 'fuid': fuid, 'funame': funame, 'fgid': fgid, 'fgname': fgname, 'finode': finode, 'flinkcount': flinkcount, 'fminor': fdev_minor,
6445                                     'fmajor': fdev_major, 'frminor': frdev_minor, 'frmajor': frdev_major, 'fseeknextfile': "+1", 'fheaderchecksumtype': checksumtype, 'fcontentchecksumtype': checksumtype, 'fnumfields': catfnumfields + 2, 'frawheader': catheaderdata, 'fextrafields': catfextrafields, 'fextrafieldsize': extrasizelen, 'fextralist': extrafieldslist, 'fheaderchecksum': int(catfileheadercshex, 16), 'fcontentchecksum': int(catfilecontentcshex, 16), 'fhascontents': pyhascontents, 'fcontentstart': catfcontentstart, 'fcontentend': catfcontentend, 'fcontentasfile': contentasfile, 'fcontents': fcontents})
6446         fileidnum = fileidnum + 1
6447     return catlist
6448
6449
6450 def TarFileToArrayAlt(infile, listonly=False, contentasfile=True, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False):
6451     formatspecs = FormatSpecsListToDict(formatspecs)
6452     curinode = 0
6453     curfid = 0
6454     inodelist = []
6455     inodetofile = {}
6456     filetoinode = {}
6457     inodetocatinode = {}
6458     fileidnum = 0
6459     if(infile == "-"):
6460         infile = BytesIO()
6461         if(hasattr(sys.stdin, "buffer")):
6462             shutil.copyfileobj(sys.stdin.buffer, infile)
6463         else:
6464             shutil.copyfileobj(sys.stdin, infile)
6465         infile.seek(0, 0)
6466         if(not infile):
6467             return False
6468         infile.seek(0, 0)
6469     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
6470         infile = download_file_from_internet_file(infile)
6471         infile.seek(0, 0)
6472         if(not infile):
6473             return False
6474         infile.seek(0, 0)
6475     elif(not os.path.exists(infile) or not os.path.isfile(infile)):
6476         return False
6477     elif(os.path.exists(infile) and os.path.isfile(infile)):
6478         try:
6479             if(not tarfile.TarFileCheck(infile)):
6480                 return False
6481         except AttributeError:
6482             if(not TarFileCheck(infile)):
6483                 return False
6484     try:
6485         if(hasattr(infile, "read") or hasattr(infile, "write")):
6486             tarfp = tarfile.open(fileobj=infile, mode="r")
6487         else:
6488             tarfp = tarfile.open(infile, "r")
6489     except FileNotFoundError:
6490         return False
6491     fnumfiles = int(len(tarfp.getmembers()))
6492     catver = formatspecs['format_ver']
6493     fileheaderver = str(int(catver.replace(".", "")))
6494     fileheader = AppendNullByte(
6495         formatspecs['format_magic'] + fileheaderver, formatspecs['format_delimiter'])
6496     fnumfileshex = format(int(fnumfiles), 'x').lower()
6497     fileheader = fileheader + \
6498         AppendNullBytes([fnumfileshex, checksumtype],
6499                         formatspecs['format_delimiter'])
6500     catversion = re.findall("([\\d]+)", fileheader)
6501     catversions = re.search('(.*?)(\\d+)', fileheader).groups()
6502     catfileheadercshex = GetFileChecksum(
6503         fileheader, checksumtype, True, formatspecs)
6504     fileheader = fileheader + \
6505         AppendNullByte(catfileheadercshex, formatspecs['format_delimiter'])
6506     fheadtell = len(fileheader)
6507     catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1],
6508                'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': []}
6509     for member in sorted(tarfp.getmembers(), key=lambda x: x.name):
6510         catfhstart = fheadtell
6511         if(re.findall("^[.|/]", member.name)):
6512             fname = member.name
6513         else:
6514             fname = "./"+member.name
6515         if(verbose):
6516             VerbosePrintOut(fname)
6517         fpremode = member.mode
6518         ffullmode = member.mode
6519         flinkcount = 0
6520         ftype = 0
6521         if(member.isreg()):
6522             ffullmode = member.mode + stat.S_IFREG
6523             ftype = 0
6524         elif(member.isdev()):
6525             ffullmode = member.mode
6526             ftype = 7
6527         elif(member.islnk()):
6528             ffullmode = member.mode + stat.S_IFREG
6529             ftype = 1
6530         elif(member.issym()):
6531             ffullmode = member.mode + stat.S_IFLNK
6532             ftype = 2
6533         elif(member.ischr()):
6534             ffullmode = member.mode + stat.S_IFCHR
6535             ftype = 3
6536         elif(member.isblk()):
6537             ffullmode = member.mode + stat.S_IFBLK
6538             ftype = 4
6539         elif(member.isdir()):
6540             ffullmode = member.mode + stat.S_IFDIR
6541             ftype = 5
6542         elif(member.isfifo()):
6543             ffullmode = member.mode + stat.S_IFIFO
6544             ftype = 6
6545         elif(member.issparse()):
6546             ffullmode = member.mode
6547             ftype = 12
6548         else:
6549             ffullmode = member.mode
6550             ftype = 0
6551         flinkname = ""
6552         fbasedir = os.path.dirname(fname)
6553         fcurfid = curfid
6554         fcurinode = curfid
6555         finode = fcurinode
6556         curfid = curfid + 1
6557         if(ftype == 2):
6558             flinkname = member.linkname
6559         fdev_minor = member.devminor
6560         fdev_major = member.devmajor
6561         frdev_minor = member.devminor
6562         frdev_major = member.devmajor
6563         if(ftype == 1 or ftype == 2 or ftype == 3 or ftype == 4 or ftype == 5 or ftype == 6):
6564             fsize = "0"
6565         elif(ftype == 0 or ftype == 7):
6566             fsize = member.size
6567         else:
6568             fsize = member.size
6569         fatime = member.mtime
6570         fmtime = member.mtime
6571         fctime = member.mtime
6572         fbtime = member.mtime
6573         fmode = ffullmode
6574         fchmode = stat.S_IMODE(ffullmode)
6575         ftypemod = stat.S_IFMT(ffullmode)
6576         fuid = member.uid
6577         fgid = member.gid
6578         funame = member.uname
6579         fgname = member.gname
6580         flinkcount = flinkcount
6581         fwinattributes = int(0)
6582         fcompression = ""
6583         fcsize = 0
6584         fcontents = BytesIO()
6585         if(ftype == 0 or ftype == 7):
6586             with tarfp.extractfile(member) as fpc:
6587                 shutil.copyfileobj(fpc, fcontents)
6588         fcontents.seek(0, 0)
6589         ftypehex = format(ftype, 'x').lower()
6590         extrafields = len(extradata)
6591         extrafieldslist = extradata
6592         catfextrafields = extrafields
6593         extrasizestr = AppendNullByte(
6594             extrafields, formatspecs['format_delimiter'])
6595         if(len(extradata) > 0):
6596             extrasizestr = extrasizestr + \
6597                 AppendNullBytes(extradata, formatspecs['format_delimiter'])
6598         extrasizelen = len(extrasizestr)
6599         extrasizelenhex = format(extrasizelen, 'x').lower()
6600         catoutlist = [ftypehex, fname, flinkname, format(int(fsize), 'x').lower(), format(int(fatime), 'x').lower(), format(int(fmtime), 'x').lower(), format(int(fctime), 'x').lower(), format(int(fbtime), 'x').lower(), format(int(fmode), 'x').lower(), format(int(fwinattributes), 'x').lower(), fcompression, format(int(fcsize), 'x').lower(), format(int(fuid), 'x').lower(
6601         ), funame, format(int(fgid), 'x').lower(), fgname, format(int(fcurfid), 'x').lower(), format(int(fcurinode), 'x').lower(), format(int(flinkcount), 'x').lower(), format(int(fdev_minor), 'x').lower(), format(int(fdev_major), 'x').lower(), format(int(frdev_minor), 'x').lower(), format(int(frdev_major), 'x').lower(), "+1", extrasizelenhex, format(catfextrafields, 'x').lower()]
6602         catoutlen = len(catoutlist) + len(extradata) + 3
6603         catoutlenhex = format(catoutlen, 'x').lower()
6604         catoutlist.insert(0, catoutlenhex)
6605         catfileoutstr = AppendNullBytes(
6606             catoutlist, formatspecs['format_delimiter'])
6607         catheaderdata = catoutlist
6608         if(len(extradata) > 0):
6609             catfileoutstr = catfileoutstr + \
6610                 AppendNullBytes(extradata, formatspecs['format_delimiter'])
6611         if(fsize == 0):
6612             checksumlist = [checksumtype, "none"]
6613         else:
6614             checksumlist = [checksumtype, checksumtype]
6615         catfileoutstr = catfileoutstr + \
6616             AppendNullBytes(checksumlist, formatspecs['format_delimiter'])
6617         catfnumfields = catoutlen
6618         catfileheadercshex = GetFileChecksum(
6619             catfileoutstr, checksumtype, True, formatspecs)
6620         fcontents.seek(0, 0)
6621         if(fsize == 0):
6622             catfilecontentcshex = GetFileChecksum(
6623                 fcontents.read(), "none", False, formatspecs)
6624         else:
6625             catfilecontentcshex = GetFileChecksum(
6626                 fcontents.read(), checksumtype, False, formatspecs)
6627         tmpfileoutstr = catfileoutstr + \
6628             AppendNullBytes([catfileheadercshex, catfilecontentcshex],
6629                             formatspecs['format_delimiter'])
6630         catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
6631         catfileoutstr = AppendNullByte(
6632             catheaersize, formatspecs['format_delimiter']) + catfileoutstr
6633         catfileheadercshex = GetFileChecksum(
6634             catfileoutstr, checksumtype, True, formatspecs)
6635         catfileoutstr = catfileoutstr + \
6636             AppendNullBytes([catfileheadercshex, catfilecontentcshex],
6637                             formatspecs['format_delimiter'])
6638         catfileoutstrecd = catfileoutstr.encode('UTF-8')
6639         nullstrecd = formatspecs['format_delimiter'].encode('UTF-8')
6640         catfcontentstart = fheadtell
6641         fheadtell += len(catfileoutstr) + 1
6642         catfcontentend = fheadtell - 1
6643         catfhend = catfcontentend
6644         fcontents.seek(0, 0)
6645         catfileout = catfileoutstrecd + fcontents.read() + nullstrecd
6646         pyhascontents = False
6647         if(int(fsize) > 0 and not listonly):
6648             pyhascontents = True
6649         if(int(fsize) > 0 and listonly):
6650             fcontents = BytesIO()
6651             pyhascontents = False
6652         fcontents.seek(0, 0)
6653         if(not contentasfile):
6654             fcontents = fcontents.read()
6655         catlist['ffilelist'].append({'fid': fileidnum, 'fidalt': fileidnum, 'fheadersize': int(catheaersize, 16), 'fhstart': catfhstart, 'fhend': catfhend, 'ftype': ftype, 'fname': fname, 'fbasedir': fbasedir, 'flinkname': flinkname, 'fsize': fsize, 'fatime': fatime, 'fmtime': fmtime, 'fctime': fctime, 'fbtime': fbtime, 'fmode': fmode, 'fchmode': fchmode, 'ftypemod': ftypemod, 'fwinattributes': fwinattributes, 'fcompression': fcompression, 'fcsize': fcsize, 'fuid': fuid, 'funame': funame, 'fgid': fgid, 'fgname': fgname, 'finode': finode, 'flinkcount': flinkcount, 'fminor': fdev_minor,
6656                                     'fmajor': fdev_major, 'frminor': frdev_minor, 'frmajor': frdev_major, 'fseeknextfile': "+1", 'fheaderchecksumtype': checksumtype, 'fcontentchecksumtype': checksumtype, 'fnumfields': catfnumfields + 2, 'frawheader': catheaderdata, 'fextrafields': catfextrafields, 'fextrafieldsize': extrasizelen, 'fextralist': extrafieldslist, 'fheaderchecksum': int(catfileheadercshex, 16), 'fcontentchecksum': int(catfilecontentcshex, 16), 'fhascontents': pyhascontents, 'fcontentstart': catfcontentstart, 'fcontentend': catfcontentend, 'fcontentasfile': contentasfile, 'fcontents': fcontents})
6657         fileidnum = fileidnum + 1
6658     return catlist
6659
6660
6661 def ZipFileToArrayAlt(infile, listonly=False, contentasfile=True, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False):
6662     formatspecs = FormatSpecsListToDict(formatspecs)
6663     curinode = 0
6664     curfid = 0
6665     inodelist = []
6666     inodetofile = {}
6667     filetoinode = {}
6668     inodetocatinode = {}
6669     fileidnum = 0
6670     if(infile == "-"):
6671         infile = BytesIO()
6672         if(hasattr(sys.stdin, "buffer")):
6673             shutil.copyfileobj(sys.stdin.buffer, infile)
6674         else:
6675             shutil.copyfileobj(sys.stdin, infile)
6676         infile.seek(0, 0)
6677         if(not infile):
6678             return False
6679         infile.seek(0, 0)
6680     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
6681         infile = download_file_from_internet_file(infile)
6682         infile.seek(0, 0)
6683         if(not infile):
6684             return False
6685         infile.seek(0, 0)
6686     elif(not os.path.exists(infile) or not os.path.isfile(infile)):
6687         return False
6688     if(not zipfile.is_zipfile(infile)):
6689         return False
6690     try:
6691         zipfp = zipfile.ZipFile(infile, "r", allowZip64=True)
6692     except FileNotFoundError:
6693         return False
6694     ziptest = zipfp.testzip()
6695     if(ziptest):
6696         VerbosePrintOut("Bad file found!")
6697     fnumfiles = int(len(zipfp.infolist()))
6698     catver = formatspecs['format_ver']
6699     fileheaderver = str(int(catver.replace(".", "")))
6700     fileheader = AppendNullByte(
6701         formatspecs['format_magic'] + fileheaderver, formatspecs['format_delimiter'])
6702     catversion = re.findall("([\\d]+)", fileheader)
6703     catversions = re.search('(.*?)(\\d+)', fileheader).groups()
6704     fnumfileshex = format(int(fnumfiles), 'x').lower()
6705     fileheader = fileheader + \
6706         AppendNullBytes([fnumfileshex, checksumtype],
6707                         formatspecs['format_delimiter'])
6708     catfileheadercshex = GetFileChecksum(
6709         fileheader, checksumtype, True, formatspecs)
6710     fileheader = fileheader + \
6711         AppendNullByte(catfileheadercshex, formatspecs['format_delimiter'])
6712     fheadtell = len(fileheader)
6713     catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1],
6714                'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': []}
6715     for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
6716         catfhstart = fheadtell
6717         if(re.findall("^[.|/]", member.filename)):
6718             fname = member.filename
6719         else:
6720             fname = "./"+member.filename
6721         zipinfo = zipfp.getinfo(member.filename)
6722         if(verbose):
6723             VerbosePrintOut(fname)
6724         if(not member.is_dir()):
6725             fpremode = stat.S_IFREG + 438
6726         elif(member.is_dir()):
6727             fpremode = stat.S_IFDIR + 511
6728         flinkcount = 0
6729         ftype = 0
6730         if(not member.is_dir()):
6731             ftype = 0
6732         elif(member.is_dir()):
6733             ftype = 5
6734         flinkname = ""
6735         fbasedir = os.path.dirname(fname)
6736         fcurfid = curfid
6737         fcurinode = curfid
6738         finode = fcurinode
6739         curfid = curfid + 1
6740         fdev_minor = 0
6741         fdev_major = 0
6742         frdev_minor = 0
6743         frdev_major = 0
6744         if(ftype == 5):
6745             fsize = "0"
6746         elif(ftype == 0):
6747             fsize = member.file_size
6748         else:
6749             fsize = member.file_size
6750         fatime = time.mktime(member.date_time + (0, 0, -1))
6751         fmtime = time.mktime(member.date_time + (0, 0, -1))
6752         fctime = time.mktime(member.date_time + (0, 0, -1))
6753         fbtime = time.mktime(member.date_time + (0, 0, -1))
6754         if(zipinfo.create_system == 0 or zipinfo.create_system == 10):
6755             fwinattributes = int(zipinfo.external_attr)
6756             if(not member.is_dir()):
6757                 fmode = int(stat.S_IFREG + 438)
6758                 fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)))
6759                 ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)))
6760             elif(member.is_dir()):
6761                 fmode = int(stat.S_IFDIR + 511)
6762                 fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)))
6763                 ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)))
6764         elif(zipinfo.create_system == 3):
6765             fwinattributes = int(0)
6766             try:
6767                 fmode = int(zipinfo.external_attr)
6768                 fchmode = stat.S_IMODE(fmode)
6769                 ftypemod = stat.S_IFMT(fmode)
6770             except OverflowError:
6771                 fmode = int(zipinfo.external_attr >> 16)
6772                 fchmode = stat.S_IMODE(fmode)
6773                 ftypemod = stat.S_IFMT(fmode)
6774         else:
6775             fwinattributes = int(0)
6776             if(not member.is_dir()):
6777                 fmode = int(stat.S_IFREG + 438)
6778                 fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)))
6779                 ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)))
6780             elif(member.is_dir()):
6781                 fmode = int(stat.S_IFDIR + 511)
6782                 fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)))
6783                 ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)))
6784         fcompression = ""
6785         fcsize = 0
6786         try:
6787             fuid = os.getuid()
6788         except AttributeError:
6789             fuid = 0
6790         except KeyError:
6791             fuid = 0
6792         try:
6793             fgid = os.getgid()
6794         except AttributeError:
6795             fgid = 0
6796         except KeyError:
6797             fgid = 0
6798         try:
6799             import pwd
6800             try:
6801                 userinfo = pwd.getpwuid(os.getuid())
6802                 funame = userinfo.pw_name
6803             except KeyError:
6804                 funame = ""
6805             except AttributeError:
6806                 funame = ""
6807         except ImportError:
6808             funame = ""
6809         fgname = ""
6810         try:
6811             import grp
6812             try:
6813                 groupinfo = grp.getgrgid(os.getgid())
6814                 fgname = groupinfo.gr_name
6815             except KeyError:
6816                 fgname = ""
6817             except AttributeError:
6818                 fgname = ""
6819         except ImportError:
6820             fgname = ""
6821         fcontents = BytesIO()
6822         if(ftype == 0):
6823             fcontents.write(zipfp.read(member.filename))
6824         fcontents.seek(0, 0)
6825         ftypehex = format(ftype, 'x').lower()
6826         extrafields = len(extradata)
6827         extrafieldslist = extradata
6828         catfextrafields = extrafields
6829         extrasizestr = AppendNullByte(
6830             extrafields, formatspecs['format_delimiter'])
6831         if(len(extradata) > 0):
6832             extrasizestr = extrasizestr + \
6833                 AppendNullBytes(extradata, formatspecs['format_delimiter'])
6834         extrasizelen = len(extrasizestr)
6835         extrasizelenhex = format(extrasizelen, 'x').lower()
6836         catoutlist = [ftypehex, fname, flinkname, format(int(fsize), 'x').lower(), format(int(fatime), 'x').lower(), format(int(fmtime), 'x').lower(), format(int(fctime), 'x').lower(), format(int(fbtime), 'x').lower(), format(int(fmode), 'x').lower(), format(int(fwinattributes), 'x').lower(), fcompression, format(int(fcsize), 'x').lower(), format(int(fuid), 'x').lower(
6837         ), funame, format(int(fgid), 'x').lower(), fgname, format(int(fcurfid), 'x').lower(), format(int(fcurinode), 'x').lower(), format(int(flinkcount), 'x').lower(), format(int(fdev_minor), 'x').lower(), format(int(fdev_major), 'x').lower(), format(int(frdev_minor), 'x').lower(), format(int(frdev_major), 'x').lower(), "+1", extrasizelenhex, format(catfextrafields, 'x').lower()]
6838         catoutlen = len(catoutlist) + len(extradata) + 3
6839         catoutlenhex = format(catoutlen, 'x').lower()
6840         catoutlist.insert(0, catoutlenhex)
6841         catfileoutstr = AppendNullBytes(
6842             catoutlist, formatspecs['format_delimiter'])
6843         catheaderdata = catoutlist
6844         if(len(extradata) > 0):
6845             catfileoutstr = catfileoutstr + \
6846                 AppendNullBytes(extradata, formatspecs['format_delimiter'])
6847         if(fsize == 0):
6848             checksumlist = [checksumtype, "none"]
6849         else:
6850             checksumlist = [checksumtype, checksumtype]
6851         catfileoutstr = catfileoutstr + \
6852             AppendNullBytes(checksumlist, formatspecs['format_delimiter'])
6853         catfnumfields = catoutlen
6854         catfileheadercshex = GetFileChecksum(
6855             catfileoutstr, checksumtype, True, formatspecs)
6856         fcontents.seek(0, 0)
6857         if(fsize == 0):
6858             catfilecontentcshex = GetFileChecksum(
6859                 fcontents.read(), "none", False, formatspecs)
6860         else:
6861             catfilecontentcshex = GetFileChecksum(
6862                 fcontents.read(), checksumtype, False, formatspecs)
6863         tmpfileoutstr = catfileoutstr + \
6864             AppendNullBytes([catfileheadercshex, catfilecontentcshex],
6865                             formatspecs['format_delimiter'])
6866         catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
6867         catfileoutstr = AppendNullByte(
6868             catheaersize, formatspecs['format_delimiter']) + catfileoutstr
6869         catfileheadercshex = GetFileChecksum(
6870             catfileoutstr, checksumtype, True, formatspecs)
6871         catfileoutstr = catfileoutstr + \
6872             AppendNullBytes([catfileheadercshex, catfilecontentcshex],
6873                             formatspecs['format_delimiter'])
6874         catfileoutstrecd = catfileoutstr.encode('UTF-8')
6875         nullstrecd = formatspecs['format_delimiter'].encode('UTF-8')
6876         catfcontentstart = fheadtell
6877         fheadtell += len(catfileoutstr) + 1
6878         catfcontentend = fheadtell - 1
6879         catfhend = catfcontentend
6880         fcontents.seek(0, 0)
6881         catfileout = catfileoutstrecd + fcontents.read() + nullstrecd
6882         pyhascontents = False
6883         if(int(fsize) > 0 and not listonly):
6884             pyhascontents = True
6885         if(int(fsize) > 0 and listonly):
6886             fcontents = BytesIO()
6887             pyhascontents = False
6888         fcontents.seek(0, 0)
6889         if(not contentasfile):
6890             fcontents = fcontents.read()
6891         catlist['ffilelist'].append({'fid': fileidnum, 'fidalt': fileidnum, 'fheadersize': int(catheaersize, 16), 'fhstart': catfhstart, 'fhend': catfhend, 'ftype': ftype, 'fname': fname, 'fbasedir': fbasedir, 'flinkname': flinkname, 'fsize': fsize, 'fatime': fatime, 'fmtime': fmtime, 'fctime': fctime, 'fbtime': fbtime, 'fmode': fmode, 'fchmode': fchmode, 'ftypemod': ftypemod, 'fwinattributes': fwinattributes, 'fcompression': fcompression, 'fcsize': fcsize, 'fuid': fuid, 'funame': funame, 'fgid': fgid, 'fgname': fgname, 'finode': finode, 'flinkcount': flinkcount, 'fminor': fdev_minor,
6892                                     'fmajor': fdev_major, 'frminor': frdev_minor, 'frmajor': frdev_major, 'fseeknextfile': "+1", 'fheaderchecksumtype': checksumtype, 'fcontentchecksumtype': checksumtype, 'fnumfields': catfnumfields + 2, 'frawheader': catheaderdata, 'fextrafields': catfextrafields, 'fextrafieldsize': extrasizelen, 'fextralist': extrafieldslist, 'fheaderchecksum': int(catfileheadercshex, 16), 'fcontentchecksum': int(catfilecontentcshex, 16), 'fhascontents': pyhascontents, 'fcontentstart': catfcontentstart, 'fcontentend': catfcontentend, 'fcontentasfile': contentasfile, 'fcontents': fcontents})
6893         fileidnum = fileidnum + 1
6894     return catlist
6895
6896
6897 if(not rarfile_support):
6898     def RarFileToArrayAlt(infile, listonly=False, contentasfile=True, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False):
6899         return False
6900
6901 if(rarfile_support):
6902     def RarFileToArrayAlt(infile, listonly=False, contentasfile=True, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False):
6903         formatspecs = FormatSpecsListToDict(formatspecs)
6904         curinode = 0
6905         curfid = 0
6906         inodelist = []
6907         inodetofile = {}
6908         filetoinode = {}
6909         inodetocatinode = {}
6910         fileidnum = 0
6911         if(not os.path.exists(infile,) or not os.path.isfile(infile,)):
6912             return False
6913         if(not rarfile.is_rarfile(infile) and not rarfile.is_rarfile_sfx(infile)):
6914             return False
6915         rarfp = rarfile.RarFile(infile, "r")
6916         rartest = rarfp.testrar()
6917         if(rartest):
6918             VerbosePrintOut("Bad file found!")
6919         fnumfiles = int(len(rarfp.infolist()))
6920         catver = formatspecs['format_ver']
6921         fileheaderver = str(int(catver.replace(".", "")))
6922         fileheader = AppendNullByte(
6923             formatspecs['format_magic'] + fileheaderver, formatspecs['format_delimiter'])
6924         catversion = re.findall("([\\d]+)", fileheader)
6925         catversions = re.search('(.*?)(\\d+)', fileheader).groups()
6926         fnumfileshex = format(int(fnumfiles), 'x').lower()
6927         fileheader = fileheader + \
6928             AppendNullBytes([fnumfileshex, checksumtype],
6929                             formatspecs['format_delimiter'])
6930         catfileheadercshex = GetFileChecksum(
6931             fileheader, checksumtype, True, formatspecs)
6932         fileheader = fileheader + \
6933             AppendNullByte(catfileheadercshex, formatspecs['format_delimiter'])
6934         fheadtell = len(fileheader)
6935         catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1],
6936                    'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': []}
6937         for member in sorted(rarfp.infolist(), key=lambda x: x.filename):
6938             catfhstart = fheadtell
6939             is_unix = False
6940             is_windows = False
6941             if(member.host_os == rarfile.RAR_OS_UNIX):
6942                 is_windows = False
6943                 try:
6944                     member.external_attr
6945                     is_unix = True
6946                 except AttributeError:
6947                     is_unix = False
6948             elif(member.host_os == rarfile.RAR_OS_WIN32):
6949                 is_unix = False
6950                 try:
6951                     member.external_attr
6952                     is_windows = True
6953                 except AttributeError:
6954                     is_windows = False
6955             else:
6956                 is_unix = False
6957                 is_windows = False
6958             if(re.findall("^[.|/]", member.filename)):
6959                 fname = member.filename
6960             else:
6961                 fname = "./"+member.filename
6962             rarinfo = rarfp.getinfo(member.filename)
6963             if(verbose):
6964                 VerbosePrintOut(fname)
6965             if(is_unix and member.external_attr != 0):
6966                 fpremode = int(member.external_attr)
6967             elif(member.is_file()):
6968                 fpremode = stat.S_IFREG + 438
6969             elif(member.is_symlink()):
6970                 fpremode = stat.S_IFLNK + 438
6971             elif(member.is_dir()):
6972                 fpremode = stat.S_IFDIR + 511
6973             if(is_windows and member.external_attr != 0):
6974                 fwinattributes = int(member.external_attr)
6975             else:
6976                 fwinattributes = int(0)
6977             fcompression = ""
6978             fcsize = 0
6979             flinkcount = 0
6980             ftype = 0
6981             if(member.is_file()):
6982                 ftype = 0
6983             elif(member.is_symlink()):
6984                 ftype = 2
6985             elif(member.is_dir()):
6986                 ftype = 5
6987             flinkname = ""
6988             if(ftype == 2):
6989                 flinkname = rarfp.read(member.filename).decode("UTF-8")
6990             fbasedir = os.path.dirname(fname)
6991             fcurfid = curfid
6992             fcurinode = curfid
6993             finode = fcurinode
6994             curfid = curfid + 1
6995             fdev_minor = 0
6996             fdev_major = 0
6997             frdev_minor = 0
6998             frdev_major = 0
6999             if(ftype == 5):
7000                 fsize = "0"
7001             if(ftype == 0):
7002                 fsize = member.file_size
7003             try:
7004                 if(member.atime):
7005                     fatime = int(member.atime.timestamp())
7006                 else:
7007                     fatime = int(member.mtime.timestamp())
7008             except AttributeError:
7009                 fatime = int(member.mtime.timestamp())
7010             fmtime = int(member.mtime.timestamp())
7011             try:
7012                 if(member.ctime):
7013                     fctime = int(member.ctime.timestamp())
7014                 else:
7015                     fctime = int(member.mtime.timestamp())
7016             except AttributeError:
7017                 fctime = int(member.mtime.timestamp())
7018             fbtime = int(member.mtime.timestamp())
7019             if(is_unix and member.external_attr != 0):
7020                 fmode = int(member.external_attr)
7021                 fchmode = int(stat.S_IMODE(member.external_attr))
7022                 ftypemod = int(stat.S_IFMT(member.external_attr))
7023             elif(member.is_file()):
7024                 fmode = int(stat.S_IFREG + 438)
7025                 fchmode = int(stat.S_IMODE(stat.S_IFREG + 438))
7026                 ftypemod = int(stat.S_IFMT(stat.S_IFREG + 438))
7027             elif(member.is_symlink()):
7028                 fmode = int(stat.S_IFLNK + 438)
7029                 fchmode = int(stat.S_IMODE(stat.S_IFREG + 438))
7030                 ftypemod = int(stat.S_IFMT(stat.S_IFREG + 438))
7031             elif(member.is_dir()):
7032                 fmode = int(stat.S_IFDIR + 511)
7033                 fchmode = int(stat.S_IMODE(stat.S_IFDIR + 511))
7034                 ftypemod = int(stat.S_IFMT(stat.S_IFDIR + 511))
7035             try:
7036                 fuid = os.getuid()
7037             except AttributeError:
7038                 fuid = 0
7039             except KeyError:
7040                 fuid = 0
7041             try:
7042                 fgid = os.getgid()
7043             except AttributeError:
7044                 fgid = 0
7045             except KeyError:
7046                 fgid = 0
7047             try:
7048                 import pwd
7049                 try:
7050                     userinfo = pwd.getpwuid(os.getuid())
7051                     funame = userinfo.pw_name
7052                 except KeyError:
7053                     funame = ""
7054                 except AttributeError:
7055                     funame = ""
7056             except ImportError:
7057                 funame = ""
7058             fgname = ""
7059             try:
7060                 import grp
7061                 try:
7062                     groupinfo = grp.getgrgid(os.getgid())
7063                     fgname = groupinfo.gr_name
7064                 except KeyError:
7065                     fgname = ""
7066                 except AttributeError:
7067                     fgname = ""
7068             except ImportError:
7069                 fgname = ""
7070             fcontents = BytesIO()
7071             if(ftype == 0):
7072                 fcontents.write(rarfp.read(member.filename))
7073             fcontents.seek(0, 0)
7074             ftypehex = format(ftype, 'x').lower()
7075             extrafields = len(extradata)
7076             extrafieldslist = extradata
7077             catfextrafields = extrafields
7078             extrasizestr = AppendNullByte(
7079                 extrafields, formatspecs['format_delimiter'])
7080             if(len(extradata) > 0):
7081                 extrasizestr = extrasizestr + \
7082                     AppendNullBytes(extradata, formatspecs['format_delimiter'])
7083             extrasizelen = len(extrasizestr)
7084             extrasizelenhex = format(extrasizelen, 'x').lower()
7085             catoutlist = [ftypehex, fname, flinkname, format(int(fsize), 'x').lower(), format(int(fatime), 'x').lower(), format(int(fmtime), 'x').lower(), format(int(fctime), 'x').lower(), format(int(fbtime), 'x').lower(), format(int(fmode), 'x').lower(), format(int(fwinattributes), 'x').lower(), fcompression, format(int(fcsize), 'x').lower(), format(int(fuid), 'x').lower(
7086             ), funame, format(int(fgid), 'x').lower(), fgname, format(int(fcurfid), 'x').lower(), format(int(fcurinode), 'x').lower(), format(int(flinkcount), 'x').lower(), format(int(fdev_minor), 'x').lower(), format(int(fdev_major), 'x').lower(), format(int(frdev_minor), 'x').lower(), format(int(frdev_major), 'x').lower(), "+1", extrasizelenhex, format(catfextrafields, 'x').lower()]
7087             catoutlen = len(catoutlist) + len(extradata) + 3
7088             catoutlenhex = format(catoutlen, 'x').lower()
7089             catoutlist.insert(0, catoutlenhex)
7090             catfileoutstr = AppendNullBytes(
7091                 catoutlist, formatspecs['format_delimiter'])
7092             if(len(extradata) > 0):
7093                 catfileoutstr = catfileoutstr + \
7094                     AppendNullBytes(extradata, formatspecs['format_delimiter'])
7095             if(fsize == 0):
7096                 checksumlist = [checksumtype, "none"]
7097             else:
7098                 checksumlist = [checksumtype, checksumtype]
7099             ccatfileoutstr = catfileoutstr + \
7100                 AppendNullBytes(checksumlist, formatspecs['format_delimiter'])
7101             catfnumfields = 24 + catfextrafields
7102             catfileheadercshex = GetFileChecksum(
7103                 catfileoutstr, checksumtype, True, formatspecs)
7104             fcontents.seek(0, 0)
7105             if(fsize == 0):
7106                 catfilecontentcshex = GetFileChecksum(
7107                     fcontents.read(), "none", False, formatspecs)
7108             else:
7109                 catfilecontentcshex = GetFileChecksum(
7110                     fcontents.read(), checksumtype, False, formatspecs)
7111             tmpfileoutstr = catfileoutstr + \
7112                 AppendNullBytes(
7113                     [catfileheadercshex, catfilecontentcshex], formatspecs['format_delimiter'])
7114             catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
7115             catfileoutstr = AppendNullByte(
7116                 catheaersize, formatspecs['format_delimiter']) + catfileoutstr
7117             catfileheadercshex = GetFileChecksum(
7118                 catfileoutstr, checksumtype, True, formatspecs)
7119             catfileoutstr = catfileoutstr + \
7120                 AppendNullBytes(
7121                     [catfileheadercshex, catfilecontentcshex], formatspecs['format_delimiter'])
7122             catheaderdata = catoutlist
7123             catfileoutstrecd = catfileoutstr.encode('UTF-8')
7124             nullstrecd = formatspecs['format_delimiter'].encode('UTF-8')
7125             catfcontentstart = fheadtell
7126             fheadtell += len(catfileoutstr) + 1
7127             catfcontentend = fheadtell - 1
7128             catfhend = catfcontentend
7129             fcontents.seek(0, 0)
7130             catfileout = catfileoutstrecd + fcontents.read() + nullstrecd
7131             pyhascontents = False
7132             if(int(fsize) > 0 and not listonly):
7133                 pyhascontents = True
7134             if(int(fsize) > 0 and listonly):
7135                 fcontents = BytesIO()
7136                 pyhascontents = False
7137             fcontents.seek(0, 0)
7138             if(not contentasfile):
7139                 fcontents = fcontents.read()
7140             catlist['ffilelist'].append({'fid': fileidnum, 'fidalt': fileidnum, 'fheadersize': int(catheaersize, 16), 'fhstart': catfhstart, 'fhend': catfhend, 'ftype': ftype, 'fname': fname, 'fbasedir': fbasedir, 'flinkname': flinkname, 'fsize': fsize, 'fatime': fatime, 'fmtime': fmtime, 'fctime': fctime, 'fbtime': fbtime, 'fmode': fmode, 'fchmode': fchmode, 'ftypemod': ftypemod, 'fwinattributes': fwinattributes, 'fcompression': fcompression, 'fcsize': fcsize, 'fuid': fuid, 'funame': funame, 'fgid': fgid, 'fgname': fgname, 'finode': finode, 'flinkcount': flinkcount, 'fminor': fdev_minor,
7141                                         'fmajor': fdev_major, 'frminor': frdev_minor, 'frmajor': frdev_major, 'fseeknextfile': "+1", 'fheaderchecksumtype': checksumtype, 'fcontentchecksumtype': checksumtype, 'fnumfields': catfnumfields + 2, 'frawheader': catheaderdata, 'fextrafields': catfextrafields, 'fextrafieldsize': extrasizelen, 'fextralist': extrafieldslist, 'fheaderchecksum': int(catfileheadercshex, 16), 'fcontentchecksum': int(catfilecontentcshex, 16), 'fhascontents': pyhascontents, 'fcontentstart': catfcontentstart, 'fcontentend': catfcontentend, 'fcontentasfile': contentasfile, 'fcontents': fcontents})
7142             fileidnum = fileidnum + 1
7143         return catlist
7144
7145 if(not py7zr_support):
7146     def SevenZipFileToArrayAlt(infile, listonly=False, contentasfile=True, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False):
7147         return False
7148
7149 if(py7zr_support):
7150     def SevenZipFileToArrayAlt(infile, listonly=False, contentasfile=True, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False):
7151         formatspecs = FormatSpecsListToDict(formatspecs)
7152         curinode = 0
7153         curfid = 0
7154         inodelist = []
7155         inodetofile = {}
7156         filetoinode = {}
7157         inodetocatinode = {}
7158         fileidnum = 0
7159         szpfp = py7zr.SevenZipFile(infile, mode="r")
7160         file_content = szpfp.readall()
7161         #sztest = szpfp.testzip();
7162         sztestalt = szpfp.test()
7163         if(sztestalt):
7164             VerbosePrintOut("Bad file found!")
7165         numfiles = int(len(szpfp.list()))
7166         catver = formatspecs['format_ver']
7167         fileheaderver = str(int(catver.replace(".", "")))
7168         fileheader = AppendNullByte(
7169             formatspecs['format_magic'] + fileheaderver, formatspecs['format_delimiter'])
7170         catversion = re.findall("([\\d]+)", fileheader)
7171         catversions = re.search('(.*?)(\\d+)', fileheader).groups()
7172         fnumfileshex = format(int(fnumfiles), 'x').lower()
7173         fileheader = fileheader + \
7174             AppendNullBytes([fnumfileshex, checksumtype],
7175                             formatspecs['format_delimiter'])
7176         catfileheadercshex = GetFileChecksum(
7177             fileheader, checksumtype, True, formatspecs)
7178         fileheader = fileheader + \
7179             AppendNullByte(catfileheadercshex, formatspecs['format_delimiter'])
7180         fheadtell = len(fileheader)
7181         catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1],
7182                    'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': []}
7183         for member in sorted(szpfp.list(), key=lambda x: x.filename):
7184             catfhstart = fheadtell
7185             if(re.findall("^[.|/]", member.filename)):
7186                 fname = member.filename
7187             else:
7188                 fname = "./"+member.filename
7189             if(not member.is_directory):
7190                 fpremode = int(stat.S_IFREG + 438)
7191             elif(member.is_directory):
7192                 fpremode = int(stat.S_IFDIR + 511)
7193             fwinattributes = int(0)
7194             fcompression = ""
7195             fcsize = 0
7196             flinkcount = 0
7197             ftype = 0
7198             if(member.is_directory):
7199                 ftype = 5
7200             else:
7201                 ftype = 0
7202             flinkname = ""
7203             fbasedir = os.path.dirname(fname)
7204             fcurfid = curfid
7205             fcurinode = curfid
7206             finode = fcurinode
7207             curfid = curfid + 1
7208             fdev_minor = 0
7209             fdev_major = 0
7210             frdev_minor = 0
7211             frdev_major = 0
7212             if(ftype == 5):
7213                 fsize = "0"
7214             fatime = int(member.creationtime.timestamp())
7215             fmtime = int(member.creationtime.timestamp())
7216             fctime = int(member.creationtime.timestamp())
7217             fbtime = int(member.creationtime.timestamp())
7218             if(member.is_directory):
7219                 fmode = int(stat.S_IFDIR + 511)
7220                 fchmode = int(stat.S_IMODE(stat.S_IFDIR + 511))
7221                 ftypemod = int(stat.S_IFMT(stat.S_IFDIR + 511))
7222             else:
7223                 fmode = int(stat.S_IFLNK + 438)
7224                 fchmode = int(stat.S_IMODE(stat.S_IFREG + 438))
7225                 ftypemod = int(stat.S_IFMT(stat.S_IFREG + 438))
7226             try:
7227                 fuid = os.getuid()
7228             except AttributeError:
7229                 fuid = 0
7230             except KeyError:
7231                 fuid = 0
7232             try:
7233                 fgid = os.getgid()
7234             except AttributeError:
7235                 fgid = 0
7236             except KeyError:
7237                 fgid = 0
7238             try:
7239                 import pwd
7240                 try:
7241                     userinfo = pwd.getpwuid(os.getuid())
7242                     funame = userinfo.pw_name
7243                 except KeyError:
7244                     funame = ""
7245                 except AttributeError:
7246                     funame = ""
7247             except ImportError:
7248                 funame = ""
7249             fgname = ""
7250             try:
7251                 import grp
7252                 try:
7253                     groupinfo = grp.getgrgid(os.getgid())
7254                     fgname = groupinfo.gr_name
7255                 except KeyError:
7256                     fgname = ""
7257                 except AttributeError:
7258                     fgname = ""
7259             except ImportError:
7260                 fgname = ""
7261             fcontents = BytesIO()
7262             if(ftype == 0):
7263                 fcontents.write(file_content[member.filename].read())
7264                 fsize = format(fcontents.tell(), 'x').lower()
7265                 fileop.close()
7266             fcontents.seek(0, 0)
7267             ftypehex = format(ftype, 'x').lower()
7268             extrafields = len(extradata)
7269             extrafieldslist = extradata
7270             catfextrafields = extrafields
7271             extrasizestr = AppendNullByte(
7272                 extrafields, formatspecs['format_delimiter'])
7273             if(len(extradata) > 0):
7274                 extrasizestr = extrasizestr + \
7275                     AppendNullBytes(extradata, formatspecs['format_delimiter'])
7276             extrasizelen = len(extrasizestr)
7277             extrasizelenhex = format(extrasizelen, 'x').lower()
7278             catoutlist = [ftypehex, fname, flinkname, format(int(fsize), 'x').lower(), format(int(fatime), 'x').lower(), format(int(fmtime), 'x').lower(), format(int(fctime), 'x').lower(), format(int(fbtime), 'x').lower(), format(int(fmode), 'x').lower(), format(int(fwinattributes), 'x').lower(), fcompression, format(int(fcsize), 'x').lower(), format(int(fuid), 'x').lower(
7279             ), funame, format(int(fgid), 'x').lower(), fgname, format(int(fcurfid), 'x').lower(), format(int(fcurinode), 'x').lower(), format(int(flinkcount), 'x').lower(), format(int(fdev_minor), 'x').lower(), format(int(fdev_major), 'x').lower(), format(int(frdev_minor), 'x').lower(), format(int(frdev_major), 'x').lower(), "+1", extrasizelenhex, format(catfextrafields, 'x').lower()]
7280             catoutlen = len(catoutlist) + len(extradata) + 3
7281             catoutlenhex = format(catoutlen, 'x').lower()
7282             catoutlist.insert(0, catoutlenhex)
7283             catfileoutstr = AppendNullBytes(
7284                 catoutlist, formatspecs['format_delimiter'])
7285             catheaderdata = catoutlist
7286             if(len(extradata) > 0):
7287                 catfileoutstr = catfileoutstr + \
7288                     AppendNullBytes(extradata, formatspecs['format_delimiter'])
7289             if(fsize == 0):
7290                 checksumlist = [checksumtype, "none"]
7291             else:
7292                 checksumlist = [checksumtype, checksumtype]
7293             catfileoutstr = catfileoutstr + \
7294                 AppendNullBytes(checksumlist, formatspecs['format_delimiter'])
7295             catfnumfields = 24 + catfextrafields
7296             catfileheadercshex = GetFileChecksum(
7297                 catfileoutstr, checksumtype, True, formatspecs)
7298             fcontents.seek(0, 0)
7299             if(fsize == 0):
7300                 catfilecontentcshex = GetFileChecksum(
7301                     fcontents.read(), "none", False, formatspecs)
7302             else:
7303                 catfilecontentcshex = GetFileChecksum(
7304                     fcontents.read(), checksumtype, False, formatspecs)
7305             tmpfileoutstr = catfileoutstr + \
7306                 AppendNullBytes(
7307                     [catfileheadercshex, catfilecontentcshex], formatspecs['format_delimiter'])
7308             catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
7309             catfileoutstr = AppendNullByte(
7310                 catheaersize, formatspecs['format_delimiter']) + catfileoutstr
7311             catfileheadercshex = GetFileChecksum(
7312                 catfileoutstr, checksumtype, True, formatspecs)
7313             catfileoutstr = catfileoutstr + \
7314                 AppendNullBytes(
7315                     [catfileheadercshex, catfilecontentcshex], formatspecs['format_delimiter'])
7316             catfileoutstrecd = catfileoutstr.encode('UTF-8')
7317             nullstrecd = formatspecs['format_delimiter'].encode('UTF-8')
7318             catfcontentstart = fheadtell
7319             fheadtell += len(catfileoutstr) + 1
7320             catfcontentend = fheadtell - 1
7321             catfhend = catfcontentend
7322             fcontents.seek(0, 0)
7323             catfileout = catfileoutstrecd + fcontents.read() + nullstrecd
7324             pyhascontents = False
7325             if(int(fsize) > 0 and not listonly):
7326                 pyhascontents = True
7327             if(int(fsize) > 0 and listonly):
7328                 fcontents = BytesIO()
7329                 pyhascontents = False
7330             fcontents.seek(0, 0)
7331             if(not contentasfile):
7332                 fcontents = fcontents.read()
7333             catlist['ffilelist'].append({'fid': fileidnum, 'fidalt': fileidnum, 'fheadersize': int(catheaersize, 16), 'fhstart': catfhstart, 'fhend': catfhend, 'ftype': ftype, 'fname': fname, 'fbasedir': fbasedir, 'flinkname': flinkname, 'fsize': fsize, 'fatime': fatime, 'fmtime': fmtime, 'fctime': fctime, 'fbtime': fbtime, 'fmode': fmode, 'fchmode': fchmode, 'ftypemod': ftypemod, 'fwinattributes': fwinattributes, 'fcompression': fcompression, 'fcsize': fcsize, 'fuid': fuid, 'funame': funame, 'fgid': fgid, 'fgname': fgname, 'finode': finode, 'flinkcount': flinkcount, 'fminor': fdev_minor,
7334                                         'fmajor': fdev_major, 'frminor': frdev_minor, 'frmajor': frdev_major, 'fseeknextfile': "+1", 'fheaderchecksumtype': checksumtype, 'fcontentchecksumtype': checksumtype, 'fnumfields': catfnumfields + 2, 'frawheader': catheaderdata, 'fextrafields': catfextrafields, 'fextrafieldsize': extrasizelen, 'fextralist': extrafieldslist, 'fheaderchecksum': int(catfileheadercshex, 16), 'fcontentchecksum': int(catfilecontentcshex, 16), 'fhascontents': pyhascontents, 'fcontentstart': catfcontentstart, 'fcontentend': catfcontentend, 'fcontentasfile': contentasfile, 'fcontents': fcontents})
7335             fileidnum = fileidnum + 1
7336         return catlist
7337
7338
7339 def InFileToArrayAlt(infile, listonly=False, contentasfile=True, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False):
7340     formatspecs = FormatSpecsListToDict(formatspecs)
7341     checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
7342     if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
7343         return TarFileToArrayAlt(infile, listonly, contentasfile, checksumtype, extradata, formatspecs, verbose)
7344     elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
7345         return ZipFileToArrayAlt(infile, listonly, contentasfile, checksumtype, extradata, formatspecs, verbose)
7346     elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
7347         return RarFileToArrayAlt(infile, listonly, contentasfile, checksumtype, extradata, formatspecs, verbose)
7348     elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
7349         return SevenZipFileToArrayAlt(infile, listonly, contentasfile, checksumtype, extradata, formatspecs, verbose)
7350     elif(checkcompressfile == "catfile"):
7351         return ArchiveFileToArray(infile, 0, 0, listonly, contentasfile, True, False, formatspecs, False)
7352     else:
7353         return False
7354     return False
7355
7356
7357 def ListDirToArray(infiles, dirlistfromtxt=False, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, seekstart=0, seekend=0, listonly=False, skipchecksum=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
7358     formatspecs = FormatSpecsListToDict(formatspecs)
7359     outarray = BytesIO()
7360     packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compresswholefile,
7361                               compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, True)
7362     listcatfiles = ArchiveFileToArray(
7363         outarray, seekstart, seekend, listonly, True, skipchecksum, formatspecs, returnfp)
7364     return listcatfiles
7365
7366
7367 def ArchiveFileArrayToArrayIndex(inarray, seekstart=0, seekend=0, listonly=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, returnfp=False):
7368     formatspecs = FormatSpecsListToDict(formatspecs)
7369     if(isinstance(inarray, dict)):
7370         listcatfiles = inarray
7371     else:
7372         return False
7373     if(not listcatfiles):
7374         return False
7375     catarray = {'list': listcatfiles, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {
7376     }, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}}
7377     if(returnfp):
7378         catarray.update({'catfp': listcatfiles['catfp']})
7379     lenlist = len(listcatfiles['ffilelist'])
7380     lcfi = 0
7381     lcfx = int(listcatfiles['fnumfiles'])
7382     if(lenlist > listcatfiles['fnumfiles'] or lenlist < listcatfiles['fnumfiles']):
7383         lcfx = int(lenlist)
7384     else:
7385         lcfx = int(listcatfiles['fnumfiles'])
7386     while(lcfi < lcfx):
7387         filetoidarray = {listcatfiles['ffilelist'][lcfi]
7388                          ['fname']: listcatfiles['ffilelist'][lcfi]['fid']}
7389         idtofilearray = {listcatfiles['ffilelist'][lcfi]
7390                          ['fid']: listcatfiles['ffilelist'][lcfi]['fname']}
7391         catarray['filetoid'].update(filetoidarray)
7392         catarray['idtofile'].update(idtofilearray)
7393         if(listcatfiles['ffilelist'][lcfi]['ftype'] == 0 or listcatfiles['ffilelist'][lcfi]['ftype'] == 7):
7394             catarray['filetypes']['files']['filetoid'].update(filetoidarray)
7395             catarray['filetypes']['files']['idtofile'].update(idtofilearray)
7396         if(listcatfiles['ffilelist'][lcfi]['ftype'] == 1):
7397             catarray['filetypes']['hardlinks']['filetoid'].update(
7398                 filetoidarray)
7399             catarray['filetypes']['hardlinks']['idtofile'].update(
7400                 idtofilearray)
7401             catarray['filetypes']['links']['filetoid'].update(filetoidarray)
7402             catarray['filetypes']['links']['idtofile'].update(idtofilearray)
7403         if(listcatfiles['ffilelist'][lcfi]['ftype'] == 2):
7404             catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray)
7405             catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray)
7406             catarray['filetypes']['links']['filetoid'].update(filetoidarray)
7407             catarray['filetypes']['links']['idtofile'].update(idtofilearray)
7408         if(listcatfiles['ffilelist'][lcfi]['ftype'] == 3):
7409             catarray['filetypes']['character']['filetoid'].update(
7410                 filetoidarray)
7411             catarray['filetypes']['character']['idtofile'].update(
7412                 idtofilearray)
7413             catarray['filetypes']['devices']['filetoid'].update(filetoidarray)
7414             catarray['filetypes']['devices']['idtofile'].update(idtofilearray)
7415         if(listcatfiles['ffilelist'][lcfi]['ftype'] == 4):
7416             catarray['filetypes']['block']['filetoid'].update(filetoidarray)
7417             catarray['filetypes']['block']['idtofile'].update(idtofilearray)
7418             catarray['filetypes']['devices']['filetoid'].update(filetoidarray)
7419             catarray['filetypes']['devices']['idtofile'].update(idtofilearray)
7420         if(listcatfiles['ffilelist'][lcfi]['ftype'] == 5):
7421             catarray['filetypes']['directories']['filetoid'].update(
7422                 filetoidarray)
7423             catarray['filetypes']['directories']['idtofile'].update(
7424                 idtofilearray)
7425         if(listcatfiles['ffilelist'][lcfi]['ftype'] == 6):
7426             catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray)
7427             catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray)
7428             catarray['filetypes']['devices']['filetoid'].update(filetoidarray)
7429             catarray['filetypes']['devices']['idtofile'].update(idtofilearray)
7430         lcfi = lcfi + 1
7431     return catarray
7432
7433
7434 create_alias_function("", __file_format_name__,
7435                       "ArrayToArrayIndex", ArchiveFileArrayToArrayIndex)
7436
7437
7438 def RePackArchiveFile(infile, outfile, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, seekstart=0, seekend=0, checksumtype="crc32", skipchecksum=False, extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
7439     formatspecs = FormatSpecsListToDict(formatspecs)
7440     if(isinstance(infile, dict)):
7441         listcatfiles = infile
7442     else:
7443         if(infile != "-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
7444             infile = RemoveWindowsPath(infile)
7445         listcatfiles = ArchiveFileToArray(
7446             infile, seekstart, seekend, False, True, skipchecksum, formatspecs, returnfp)
7447     if(outfile != "-" and not hasattr(infile, "read") and not hasattr(outfile, "write")):
7448         outfile = RemoveWindowsPath(outfile)
7449     checksumtype = checksumtype.lower()
7450     if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
7451         checksumtype = "crc32"
7452     if(checksumtype == "none"):
7453         checksumtype = ""
7454     if(not compression or compression == "catfile" or compression == formatspecs['format_lower']):
7455         compression = "auto"
7456     if(compression not in compressionlist and compression is None):
7457         compression = "auto"
7458     if(verbose):
7459         logging.basicConfig(format="%(message)s",
7460                             stream=sys.stdout, level=logging.DEBUG)
7461     if(outfile != "-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
7462         if(os.path.exists(outfile)):
7463             try:
7464                 os.unlink(outfile)
7465             except OSError as e:
7466                 pass
7467     if(not listcatfiles):
7468         return False
7469     if(outfile == "-"):
7470         verbose = False
7471         catfp = BytesIO()
7472     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
7473         catfp = outfile
7474     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
7475         catfp = BytesIO()
7476     else:
7477         fbasename = os.path.splitext(outfile)[0]
7478         fextname = os.path.splitext(outfile)[1]
7479         if(not compresswholefile and fextname in outextlistwd):
7480             compresswholefile = True
7481         catfp = CompressOpenFile(outfile, compresswholefile, compressionlevel)
7482     catver = formatspecs['format_ver']
7483     fileheaderver = str(int(catver.replace(".", "")))
7484     lenlist = len(listcatfiles['ffilelist'])
7485     fnumfiles = int(listcatfiles['fnumfiles'])
7486     if(lenlist > fnumfiles or lenlist < fnumfiles):
7487         fnumfiles = lenlist
7488     AppendFileHeader(catfp, fnumfiles, checksumtype, formatspecs)
7489     lenlist = len(listcatfiles['ffilelist'])
7490     fnumfiles = int(listcatfiles['fnumfiles'])
7491     lcfi = 0
7492     lcfx = int(listcatfiles['fnumfiles'])
7493     if(lenlist > listcatfiles['fnumfiles'] or lenlist < listcatfiles['fnumfiles']):
7494         lcfx = int(lenlist)
7495     else:
7496         lcfx = int(listcatfiles['fnumfiles'])
7497     curinode = 0
7498     curfid = 0
7499     inodelist = []
7500     inodetofile = {}
7501     filetoinode = {}
7502     reallcfi = 0
7503     while(lcfi < lcfx):
7504         if(re.findall("^[.|/]", listcatfiles['ffilelist'][reallcfi]['fname'])):
7505             fname = listcatfiles['ffilelist'][reallcfi]['fname']
7506         else:
7507             fname = "./"+listcatfiles['ffilelist'][reallcfi]['fname']
7508         if(verbose):
7509             VerbosePrintOut(fname)
7510         fheadersize = format(
7511             int(listcatfiles['ffilelist'][reallcfi]['fheadersize']), 'x').lower()
7512         fsize = format(
7513             int(listcatfiles['ffilelist'][reallcfi]['fsize']), 'x').lower()
7514         flinkname = listcatfiles['ffilelist'][reallcfi]['flinkname']
7515         fatime = format(
7516             int(listcatfiles['ffilelist'][reallcfi]['fatime']), 'x').lower()
7517         fmtime = format(
7518             int(listcatfiles['ffilelist'][reallcfi]['fmtime']), 'x').lower()
7519         fctime = format(
7520             int(listcatfiles['ffilelist'][reallcfi]['fctime']), 'x').lower()
7521         fbtime = format(
7522             int(listcatfiles['ffilelist'][reallcfi]['fbtime']), 'x').lower()
7523         fmode = format(
7524             int(listcatfiles['ffilelist'][reallcfi]['fmode']), 'x').lower()
7525         fchmode = format(
7526             int(listcatfiles['ffilelist'][reallcfi]['fchmode']), 'x').lower()
7527         fuid = format(
7528             int(listcatfiles['ffilelist'][reallcfi]['fuid']), 'x').lower()
7529         funame = listcatfiles['ffilelist'][reallcfi]['funame']
7530         fgid = format(
7531             int(listcatfiles['ffilelist'][reallcfi]['fgid']), 'x').lower()
7532         fgname = listcatfiles['ffilelist'][reallcfi]['fgname']
7533         finode = format(
7534             int(listcatfiles['ffilelist'][reallcfi]['finode']), 'x').lower()
7535         flinkcount = format(
7536             int(listcatfiles['ffilelist'][reallcfi]['flinkcount']), 'x').lower()
7537         fwinattributes = format(
7538             int(listcatfiles['ffilelist'][reallcfi]['fwinattributes']), 'x').lower()
7539         fcompression = listcatfiles['ffilelist'][reallcfi]['fcompression']
7540         fcsize = format(
7541             int(listcatfiles['ffilelist'][reallcfi]['fcsize']), 'x').lower()
7542         fdev_minor = format(
7543             int(listcatfiles['ffilelist'][reallcfi]['fminor']), 'x').lower()
7544         fdev_major = format(
7545             int(listcatfiles['ffilelist'][reallcfi]['fmajor']), 'x').lower()
7546         frdev_minor = format(
7547             int(listcatfiles['ffilelist'][reallcfi]['frminor']), 'x').lower()
7548         frdev_major = format(
7549             int(listcatfiles['ffilelist'][reallcfi]['frmajor']), 'x').lower()
7550         fseeknextfile = listcatfiles['ffilelist'][reallcfi]['fseeknextfile']
7551         if(len(listcatfiles['ffilelist'][reallcfi]['fextralist']) > listcatfiles['ffilelist'][reallcfi]['fextrafields'] and len(listcatfiles['ffilelist'][reallcfi]['fextralist']) > 0):
7552             listcatfiles['ffilelist'][reallcfi]['fextrafields'] = len(
7553                 listcatfiles['ffilelist'][reallcfi]['fextralist'])
7554         if(not followlink and len(extradata) < 0):
7555             extradata = listcatfiles['ffilelist'][reallcfi]['fextralist']
7556         fcontents = listcatfiles['ffilelist'][reallcfi]['fcontents']
7557         if(not listcatfiles['ffilelist'][reallcfi]['fcontentasfile']):
7558             fcontents = BytesIO(fcontents)
7559         fcompression = ""
7560         fcsize = format(int(0), 'x').lower()
7561         if(not compresswholefile):
7562             fcontents.seek(0, 2)
7563             ucfsize = fcontents.tell()
7564             fcontents.seek(0, 0)
7565             if(compression == "auto"):
7566                 ilsize = len(compressionlistalt)
7567                 ilmin = 0
7568                 ilcsize = []
7569                 while(ilmin < ilsize):
7570                     cfcontents = BytesIO()
7571                     shutil.copyfileobj(fcontents, cfcontents)
7572                     fcontents.seek(0, 0)
7573                     cfcontents.seek(0, 0)
7574                     cfcontents = CompressArchiveFile(
7575                         cfcontents, compressionlistalt[ilmin], compressionlevel, formatspecs)
7576                     if(cfcontents):
7577                         cfcontents.seek(0, 2)
7578                         ilcsize.append(cfcontents.tell())
7579                         cfcontents.close()
7580                     else:
7581                         try:
7582                             ilcsize.append(sys.maxint)
7583                         except AttributeError:
7584                             ilcsize.append(sys.maxsize)
7585                     ilmin = ilmin + 1
7586                 ilcmin = ilcsize.index(min(ilcsize))
7587                 compression = compressionlistalt[ilcmin]
7588             fcontents.seek(0, 0)
7589             cfcontents = BytesIO()
7590             shutil.copyfileobj(fcontents, cfcontents)
7591             cfcontents.seek(0, 0)
7592             cfcontents = CompressArchiveFile(
7593                 cfcontents, compression, compressionlevel, formatspecs)
7594             cfcontents.seek(0, 2)
7595             cfsize = cfcontents.tell()
7596             if(ucfsize > cfsize):
7597                 fcsize = format(int(cfsize), 'x').lower()
7598                 fcompression = compression
7599                 fcontents.close()
7600                 fcontents = cfcontents
7601         if(followlink):
7602             if(listcatfiles['ffilelist'][reallcfi]['ftype'] == 1 or listcatfiles['ffilelist'][reallcfi]['ftype'] == 2):
7603                 getflinkpath = listcatfiles['ffilelist'][reallcfi]['flinkname']
7604                 flinkid = prelistcatfiles['filetoid'][getflinkpath]
7605                 flinkinfo = listcatfiles['ffilelist'][flinkid]
7606                 fheadersize = format(
7607                     int(flinkinfo['fheadersize']), 'x').lower()
7608                 fsize = format(int(flinkinfo['fsize']), 'x').lower()
7609                 flinkname = flinkinfo['flinkname']
7610                 fatime = format(int(flinkinfo['fatime']), 'x').lower()
7611                 fmtime = format(int(flinkinfo['fmtime']), 'x').lower()
7612                 fctime = format(int(flinkinfo['fctime']), 'x').lower()
7613                 fbtime = format(int(flinkinfo['fbtime']), 'x').lower()
7614                 fmode = format(int(flinkinfo['fmode']), 'x').lower()
7615                 fchmode = format(int(flinkinfo['fchmode']), 'x').lower()
7616                 fuid = format(int(flinkinfo['fuid']), 'x').lower()
7617                 funame = flinkinfo['funame']
7618                 fgid = format(int(flinkinfo['fgid']), 'x').lower()
7619                 fgname = flinkinfo['fgname']
7620                 finode = format(int(flinkinfo['finode']), 'x').lower()
7621                 flinkcount = format(int(flinkinfo['flinkcount']), 'x').lower()
7622                 fwinattributes = format(
7623                     int(flinkinfo['fwinattributes']), 'x').lower()
7624                 fcompression = flinkinfo['fcompression']
7625                 fcsize = format(int(flinkinfo['fcsize']), 'x').lower()
7626                 fdev_minor = format(int(flinkinfo['fminor']), 'x').lower()
7627                 fdev_major = format(int(flinkinfo['fmajor']), 'x').lower()
7628                 frdev_minor = format(int(flinkinfo['frminor']), 'x').lower()
7629                 frdev_major = format(int(flinkinfo['frmajor']), 'x').lower()
7630                 fseeknextfile = flinkinfo['fseeknextfile']
7631                 if(len(flinkinfo['fextralist']) > flinkinfo['fextrafields'] and len(flinkinfo['fextralist']) > 0):
7632                     flinkinfo['fextrafields'] = len(flinkinfo['fextralist'])
7633                 if(len(extradata) < 0):
7634                     extradata = flinkinfo['fextralist']
7635                 fcontents = flinkinfo['fcontents']
7636                 if(not flinkinfo['fcontentasfile']):
7637                     fcontents = BytesIO(fcontents)
7638                 ftypehex = format(flinkinfo['ftype'], 'x').lower()
7639         else:
7640             ftypehex = format(
7641                 listcatfiles['ffilelist'][reallcfi]['ftype'], 'x').lower()
7642         fcurfid = format(curfid, 'x').lower()
7643         if(not followlink and finode != 0):
7644             if(listcatfiles['ffilelist'][reallcfi]['ftype'] != 1):
7645                 fcurinode = format(int(curinode), 'x').lower()
7646                 inodetofile.update({curinode: fname})
7647                 filetoinode.update({fname: curinode})
7648                 curinode = curinode + 1
7649             else:
7650                 fcurinode = format(int(filetoinode[flinkname]), 'x').lower()
7651         else:
7652             fcurinode = format(int(curinode), 'x').lower()
7653             curinode = curinode + 1
7654         curfid = curfid + 1
7655         if(fcompression == "none"):
7656             fcompression = ""
7657         catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression, fcsize,
7658                       fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, fseeknextfile]
7659         catfp = AppendFileHeaderWithContent(
7660             catfp, catoutlist, extradata, fcontents.read(), checksumtype, formatspecs)
7661         fcontents.close()
7662         lcfi = lcfi + 1
7663         reallcfi = reallcfi + 1
7664     if(lcfx > 0):
7665         catfp.write(AppendNullBytes(
7666             [0, 0], formatspecs['format_delimiter']).encode("UTF-8"))
7667     if(outfile == "-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
7668         catfp = CompressArchiveFile(
7669             catfp, compression, compressionlevel, formatspecs)
7670         try:
7671             catfp.flush()
7672             os.fsync(catfp.fileno())
7673         except io.UnsupportedOperation:
7674             pass
7675         except AttributeError:
7676             pass
7677         except OSError as e:
7678             pass
7679     if(outfile == "-"):
7680         catfp.seek(0, 0)
7681         if(hasattr(sys.stdout, "buffer")):
7682             shutil.copyfileobj(catfp, sys.stdout.buffer)
7683         else:
7684             shutil.copyfileobj(catfp, sys.stdout)
7685     elif(re.findall("^(ftp|ftps|sftp):\\/\\/", str(outfile))):
7686         catfp = CompressArchiveFile(
7687             catfp, compression, compressionlevel, formatspecs)
7688         catfp.seek(0, 0)
7689         upload_file_to_internet_file(catfp, outfile)
7690     if(returnfp):
7691         catfp.seek(0, 0)
7692         return catfp
7693     else:
7694         catfp.close()
7695         return True
7696
7697
7698 create_alias_function("RePack", __file_format_name__, "", RePackArchiveFile)
7699
7700
7701 def RePackArchiveFileFromString(catstr, outfile, compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", skipchecksum=False, extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
7702     formatspecs = FormatSpecsListToDict(formatspecs)
7703     catfp = BytesIO(catstr)
7704     listcatfiles = RePackArchiveFile(catfp, compression, compresswholefile, compressionlevel,
7705                                      checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp)
7706     return listcatfiles
7707
7708
7709 create_alias_function("RePack", __file_format_name__,
7710                       "FromString", RePackArchiveFileFromString)
7711
7712
7713 def PackArchiveFileFromListDir(infiles, outfile, dirlistfromtxt=False, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, skipchecksum=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
7714     formatspecs = FormatSpecsListToDict(formatspecs)
7715     outarray = BytesIO()
7716     packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compresswholefile,
7717                               compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, True)
7718     listcatfiles = RePackArchiveFile(outarray, outfile, compression, compresswholefile,
7719                                      compressionlevel, checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp)
7720     return listcatfiles
7721
7722
7723 create_alias_function("Pack", __file_format_name__,
7724                       "FromListDir", PackArchiveFileFromListDir)
7725
7726
7727 def UnPackArchiveFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_dict__, preservepermissions=True, preservetime=True, verbose=False, returnfp=False):
7728     formatspecs = FormatSpecsListToDict(formatspecs)
7729     if(outdir is not None):
7730         outdir = RemoveWindowsPath(outdir)
7731     if(verbose):
7732         logging.basicConfig(format="%(message)s",
7733                             stream=sys.stdout, level=logging.DEBUG)
7734     if(isinstance(infile, dict)):
7735         listcatfiles = infile
7736     else:
7737         if(infile != "-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
7738             infile = RemoveWindowsPath(infile)
7739         listcatfiles = ArchiveFileToArray(
7740             infile, seekstart, seekend, False, True, skipchecksum, formatspecs, returnfp)
7741     if(not listcatfiles):
7742         return False
7743     lenlist = len(listcatfiles['ffilelist'])
7744     fnumfiles = int(listcatfiles['fnumfiles'])
7745     lcfi = 0
7746     lcfx = int(listcatfiles['fnumfiles'])
7747     if(lenlist > listcatfiles['fnumfiles'] or lenlist < listcatfiles['fnumfiles']):
7748         lcfx = int(lenlist)
7749     else:
7750         lcfx = int(listcatfiles['fnumfiles'])
7751     while(lcfi < lcfx):
7752         funame = ""
7753         try:
7754             import pwd
7755             try:
7756                 userinfo = pwd.getpwuid(
7757                     listcatfiles['ffilelist'][lcfi]['fuid'])
7758                 funame = userinfo.pw_name
7759             except KeyError:
7760                 funame = ""
7761         except ImportError:
7762             funame = ""
7763         fgname = ""
7764         try:
7765             import grp
7766             try:
7767                 groupinfo = grp.getgrgid(
7768                     listcatfiles['ffilelist'][lcfi]['fgid'])
7769                 fgname = groupinfo.gr_name
7770             except KeyError:
7771                 fgname = ""
7772         except ImportError:
7773             fgname = ""
7774         if(verbose):
7775             VerbosePrintOut(PrependPath(
7776                 outdir, listcatfiles['ffilelist'][lcfi]['fname']))
7777         if(listcatfiles['ffilelist'][lcfi]['ftype'] == 0 or listcatfiles['ffilelist'][lcfi]['ftype'] == 7):
7778             with open(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
7779                 if(not listcatfiles['ffilelist'][lcfi]['fcontentasfile']):
7780                     listcatfiles['ffilelist'][lcfi]['fcontents'] = BytesIO(
7781                         listcatfiles['ffilelist'][lcfi]['fcontents'])
7782                 listcatfiles['ffilelist'][lcfi]['fcontents'].seek(0, 0)
7783                 shutil.copyfileobj(
7784                     listcatfiles['ffilelist'][lcfi]['fcontents'], fpc)
7785                 try:
7786                     fpc.flush()
7787                     os.fsync(fpc.fileno())
7788                 except io.UnsupportedOperation:
7789                     pass
7790                 except AttributeError:
7791                     pass
7792                 except OSError as e:
7793                     pass
7794             if(hasattr(os, "chown") and funame == listcatfiles['ffilelist'][lcfi]['funame'] and fgname == listcatfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
7795                 os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']),
7796                          listcatfiles['ffilelist'][lcfi]['fuid'], listcatfiles['ffilelist'][lcfi]['fgid'])
7797             if(preservepermissions):
7798                 os.chmod(PrependPath(
7799                     outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fchmode'])
7800             if(preservetime):
7801                 os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (
7802                     listcatfiles['ffilelist'][lcfi]['fatime'], listcatfiles['ffilelist'][lcfi]['fmtime']))
7803         if(listcatfiles['ffilelist'][lcfi]['ftype'] == 1):
7804             if(followlink):
7805                 getflinkpath = listcatfiles['ffilelist'][lcfi]['flinkname']
7806                 flinkid = prelistcatfiles['filetoid'][getflinkpath]
7807                 flinkinfo = listcatfiles['ffilelist'][flinkid]
7808                 funame = ""
7809                 try:
7810                     import pwd
7811                     try:
7812                         userinfo = pwd.getpwuid(flinkinfo['fuid'])
7813                         funame = userinfo.pw_name
7814                     except KeyError:
7815                         funame = ""
7816                 except ImportError:
7817                     funame = ""
7818                 fgname = ""
7819                 try:
7820                     import grp
7821                     try:
7822                         groupinfo = grp.getgrgid(flinkinfo['fgid'])
7823                         fgname = groupinfo.gr_name
7824                     except KeyError:
7825                         fgname = ""
7826                 except ImportError:
7827                     fgname = ""
7828                 if(flinkinfo['ftype'] == 0 or flinkinfo['ftype'] == 7):
7829                     with open(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
7830                         if(not flinkinfo['fcontentasfile']):
7831                             flinkinfo['fcontents'] = BytesIO(
7832                                 flinkinfo['fcontents'])
7833                         flinkinfo['fcontents'].seek(0, 0)
7834                         shutil.copyfileobj(flinkinfo['fcontents'], fpc)
7835                         try:
7836                             fpc.flush()
7837                             os.fsync(fpc.fileno())
7838                         except io.UnsupportedOperation:
7839                             pass
7840                         except AttributeError:
7841                             pass
7842                         except OSError as e:
7843                             pass
7844                     if(hasattr(os, "chown") and funame == flinkinfo['funame'] and fgname == flinkinfo['fgname'] and preservepermissions):
7845                         os.chown(PrependPath(
7846                             outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
7847                     if(preservepermissions):
7848                         os.chmod(PrependPath(
7849                             outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
7850                     if(preservetime):
7851                         os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (
7852                             flinkinfo['fatime'], flinkinfo['fmtime']))
7853                 if(flinkinfo['ftype'] == 1):
7854                     os.link(flinkinfo['flinkname'], PrependPath(
7855                         outdir, listcatfiles['ffilelist'][lcfi]['fname']))
7856                 if(flinkinfo['ftype'] == 2):
7857                     os.symlink(flinkinfo['flinkname'], PrependPath(
7858                         outdir, listcatfiles['ffilelist'][lcfi]['fname']))
7859                 if(flinkinfo['ftype'] == 5):
7860                     if(preservepermissions):
7861                         os.mkdir(PrependPath(
7862                             outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
7863                     else:
7864                         os.mkdir(PrependPath(
7865                             outdir, listcatfiles['ffilelist'][lcfi]['fname']))
7866                     if(hasattr(os, "chown") and funame == flinkinfo['funame'] and fgname == flinkinfo['fgname'] and preservepermissions):
7867                         os.chown(PrependPath(
7868                             outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
7869                     if(preservepermissions):
7870                         os.chmod(PrependPath(
7871                             outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
7872                     if(preservetime):
7873                         os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (
7874                             flinkinfo['fatime'], flinkinfo['fmtime']))
7875                 if(flinkinfo['ftype'] == 6 and hasattr(os, "mkfifo")):
7876                     os.mkfifo(PrependPath(
7877                         outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
7878             else:
7879                 os.link(listcatfiles['ffilelist'][lcfi]['flinkname'], PrependPath(
7880                     outdir, listcatfiles['ffilelist'][lcfi]['fname']))
7881         if(listcatfiles['ffilelist'][lcfi]['ftype'] == 2):
7882             if(followlink):
7883                 getflinkpath = listcatfiles['ffilelist'][lcfi]['flinkname']
7884                 flinkid = prelistcatfiles['filetoid'][getflinkpath]
7885                 flinkinfo = listcatfiles['ffilelist'][flinkid]
7886                 funame = ""
7887                 try:
7888                     import pwd
7889                     try:
7890                         userinfo = pwd.getpwuid(flinkinfo['fuid'])
7891                         funame = userinfo.pw_name
7892                     except KeyError:
7893                         funame = ""
7894                 except ImportError:
7895                     funame = ""
7896                 fgname = ""
7897                 try:
7898                     import grp
7899                     try:
7900                         groupinfo = grp.getgrgid(flinkinfo['fgid'])
7901                         fgname = groupinfo.gr_name
7902                     except KeyError:
7903                         fgname = ""
7904                 except ImportError:
7905                     fgname = ""
7906                 if(flinkinfo['ftype'] == 0 or flinkinfo['ftype'] == 7):
7907                     with open(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
7908                         if(not flinkinfo['fcontentasfile']):
7909                             flinkinfo['fcontents'] = BytesIO(
7910                                 flinkinfo['fcontents'])
7911                         flinkinfo['fcontents'].seek(0, 0)
7912                         shutil.copyfileobj(flinkinfo['fcontents'], fpc)
7913                         try:
7914                             fpc.flush()
7915                             os.fsync(fpc.fileno())
7916                         except io.UnsupportedOperation:
7917                             pass
7918                         except AttributeError:
7919                             pass
7920                         except OSError as e:
7921                             pass
7922                     if(hasattr(os, "chown") and funame == flinkinfo['funame'] and fgname == flinkinfo['fgname'] and preservepermissions):
7923                         os.chown(PrependPath(
7924                             outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
7925                     if(preservepermissions):
7926                         os.chmod(PrependPath(
7927                             outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
7928                     if(preservetime):
7929                         os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (
7930                             flinkinfo['fatime'], flinkinfo['fmtime']))
7931                 if(flinkinfo['ftype'] == 1):
7932                     os.link(flinkinfo['flinkname'], PrependPath(
7933                         outdir, listcatfiles['ffilelist'][lcfi]['fname']))
7934                 if(flinkinfo['ftype'] == 2):
7935                     os.symlink(flinkinfo['flinkname'], PrependPath(
7936                         outdir, listcatfiles['ffilelist'][lcfi]['fname']))
7937                 if(flinkinfo['ftype'] == 5):
7938                     if(preservepermissions):
7939                         os.mkdir(PrependPath(
7940                             outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
7941                     else:
7942                         os.mkdir(PrependPath(
7943                             outdir, listcatfiles['ffilelist'][lcfi]['fname']))
7944                     if(hasattr(os, "chown") and funame == flinkinfo['funame'] and fgname == flinkinfo['fgname'] and preservepermissions):
7945                         os.chown(PrependPath(
7946                             outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid'])
7947                     if(preservepermissions):
7948                         os.chmod(PrependPath(
7949                             outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
7950                     if(preservetime):
7951                         os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (
7952                             flinkinfo['fatime'], flinkinfo['fmtime']))
7953                 if(flinkinfo['ftype'] == 6 and hasattr(os, "mkfifo")):
7954                     os.mkfifo(PrependPath(
7955                         outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode'])
7956             else:
7957                 os.symlink(listcatfiles['ffilelist'][lcfi]['flinkname'], PrependPath(
7958                     outdir, listcatfiles['ffilelist'][lcfi]['fname']))
7959         if(listcatfiles['ffilelist'][lcfi]['ftype'] == 5):
7960             if(preservepermissions):
7961                 os.mkdir(PrependPath(
7962                     outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fchmode'])
7963             else:
7964                 os.mkdir(PrependPath(
7965                     outdir, listcatfiles['ffilelist'][lcfi]['fname']))
7966             if(hasattr(os, "chown") and funame == listcatfiles['ffilelist'][lcfi]['funame'] and fgname == listcatfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
7967                 os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']),
7968                          listcatfiles['ffilelist'][lcfi]['fuid'], listcatfiles['ffilelist'][lcfi]['fgid'])
7969             if(preservepermissions):
7970                 os.chmod(PrependPath(
7971                     outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fchmode'])
7972             if(preservetime):
7973                 os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (
7974                     listcatfiles['ffilelist'][lcfi]['fatime'], listcatfiles['ffilelist'][lcfi]['fmtime']))
7975         if(listcatfiles['ffilelist'][lcfi]['ftype'] == 6 and hasattr(os, "mkfifo")):
7976             os.mkfifo(PrependPath(
7977                 outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fchmode'])
7978         lcfi = lcfi + 1
7979     if(returnfp):
7980         return listcatfiles['ffilelist']['catfp']
7981     else:
7982         return True
7983
7984
7985 create_alias_function("UnPack", __file_format_name__, "", UnPackArchiveFile)
7986
7987 if(hasattr(shutil, "register_unpack_format")):
7988     def UnPackArchiveFileFunc(archive_name, extract_dir=None, **kwargs):
7989         return UnPackArchiveFile(archive_name, extract_dir, False, 0, 0, False, __file_format_dict__['format_delimiter'], False, False)
7990     create_alias_function("UnPack", __file_format_name__,
7991                           "Func", UnPackArchiveFileFunc)
7992
7993
7994 def UnPackArchiveFileString(catstr, outdir=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_dict__, verbose=False, returnfp=False):
7995     formatspecs = FormatSpecsListToDict(formatspecs)
7996     catfp = BytesIO(catstr)
7997     listcatfiles = UnPackArchiveFile(
7998         catfp, outdir, followlink, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp)
7999     return listcatfiles
8000
8001
8002 create_alias_function("UnPack", __file_format_name__,
8003                       "String", UnPackArchiveFileString)
8004
8005
8006 def ArchiveFileListFiles(infile, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_dict__, verbose=False, returnfp=False):
8007     formatspecs = FormatSpecsListToDict(formatspecs)
8008     logging.basicConfig(format="%(message)s",
8009                         stream=sys.stdout, level=logging.DEBUG)
8010     if(isinstance(infile, dict)):
8011         listcatfiles = infile
8012     else:
8013         if(infile != "-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
8014             infile = RemoveWindowsPath(infile)
8015         listcatfiles = ArchiveFileToArray(
8016             infile, seekstart, seekend, True, False, skipchecksum, formatspecs, returnfp)
8017     if(not listcatfiles):
8018         return False
8019     lenlist = len(listcatfiles['ffilelist'])
8020     fnumfiles = int(listcatfiles['fnumfiles'])
8021     lcfi = 0
8022     lcfx = int(listcatfiles['fnumfiles'])
8023     if(lenlist > listcatfiles['fnumfiles'] or lenlist < listcatfiles['fnumfiles']):
8024         lcfx = int(lenlist)
8025     else:
8026         lcfx = int(listcatfiles['fnumfiles'])
8027     returnval = {}
8028     while(lcfi < lcfx):
8029         returnval.update({lcfi: listcatfiles['ffilelist'][lcfi]['fname']})
8030         if(not verbose):
8031             VerbosePrintOut(listcatfiles['ffilelist'][lcfi]['fname'])
8032         if(verbose):
8033             permissions = {'access': {'0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': (
8034                 'r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx')}, 'roles': {0: 'owner', 1: 'group', 2: 'other'}}
8035             printfname = listcatfiles['ffilelist'][lcfi]['fname']
8036             if(listcatfiles['ffilelist'][lcfi]['ftype'] == 1):
8037                 printfname = listcatfiles['ffilelist'][lcfi]['fname'] + \
8038                     " link to " + listcatfiles['ffilelist'][lcfi]['flinkname']
8039             if(listcatfiles['ffilelist'][lcfi]['ftype'] == 2):
8040                 printfname = listcatfiles['ffilelist'][lcfi]['fname'] + \
8041                     " -> " + listcatfiles['ffilelist'][lcfi]['flinkname']
8042             fuprint = listcatfiles['ffilelist'][lcfi]['funame']
8043             if(len(fuprint) <= 0):
8044                 fuprint = listcatfiles['ffilelist'][lcfi]['fuid']
8045             fgprint = listcatfiles['ffilelist'][lcfi]['fgname']
8046             if(len(fgprint) <= 0):
8047                 fgprint = listcatfiles['ffilelist'][lcfi]['fgid']
8048             VerbosePrintOut(PrintPermissionString(listcatfiles['ffilelist'][lcfi]['fmode'], listcatfiles['ffilelist'][lcfi]['ftype']) + " " + str(str(fuprint) + "/" + str(fgprint) + " " + str(
8049                 listcatfiles['ffilelist'][lcfi]['fsize']).rjust(15) + " " + datetime.datetime.utcfromtimestamp(listcatfiles['ffilelist'][lcfi]['fmtime']).strftime('%Y-%m-%d %H:%M') + " " + printfname))
8050         lcfi = lcfi + 1
8051     if(returnfp):
8052         return listcatfiles['catfp']
8053     else:
8054         return True
8055
8056
8057 create_alias_function("", __file_format_name__,
8058                       "ListFiles", ArchiveFileListFiles)
8059
8060
8061 def ArchiveFileStringListFiles(catstr, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_dict__, verbose=False, returnfp=False):
8062     formatspecs = FormatSpecsListToDict(formatspecs)
8063     catfp = BytesIO(catstr)
8064     listcatfiles = ArchiveFileListFiles(
8065         catstr, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp)
8066     return listcatfiles
8067
8068
8069 create_alias_function("", __file_format_name__,
8070                       "StringListFiles", ArchiveFileStringListFiles)
8071
8072
8073 def TarFileListFiles(infile, verbose=False, returnfp=False):
8074     logging.basicConfig(format="%(message)s",
8075                         stream=sys.stdout, level=logging.DEBUG)
8076     if(infile == "-"):
8077         infile = BytesIO()
8078         if(hasattr(sys.stdin, "buffer")):
8079             shutil.copyfileobj(sys.stdin.buffer, infile)
8080         else:
8081             shutil.copyfileobj(sys.stdin, infile)
8082         infile.seek(0, 0)
8083         if(not infile):
8084             return False
8085         infile.seek(0, 0)
8086     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
8087         infile = download_file_from_internet_file(infile)
8088         infile.seek(0, 0)
8089         if(not infile):
8090             return False
8091         infile.seek(0, 0)
8092     elif(not os.path.exists(infile) or not os.path.isfile(infile)):
8093         return False
8094     elif(os.path.exists(infile) and os.path.isfile(infile)):
8095         try:
8096             if(not tarfile.TarFileCheck(infile)):
8097                 return False
8098         except AttributeError:
8099             if(not TarFileCheck(infile)):
8100                 return False
8101     try:
8102         if(hasattr(infile, "read") or hasattr(infile, "write")):
8103             tarfp = tarfile.open(fileobj=infile, mode="r")
8104         else:
8105             tarfp = tarfile.open(infile, "r")
8106     except FileNotFoundError:
8107         return False
8108     lcfi = 0
8109     returnval = {}
8110     for member in sorted(tarfp.getmembers(), key=lambda x: x.name):
8111         returnval.update({lcfi: member.name})
8112         fpremode = member.mode
8113         ffullmode = member.mode
8114         flinkcount = 0
8115         ftype = 0
8116         if(member.isreg()):
8117             ffullmode = member.mode + stat.S_IFREG
8118             ftype = 0
8119         elif(member.isdev()):
8120             ffullmode = member.mode
8121             ftype = 7
8122         elif(member.islnk()):
8123             ffullmode = member.mode + stat.S_IFREG
8124             ftype = 1
8125         elif(member.issym()):
8126             ffullmode = member.mode + stat.S_IFLNK
8127             ftype = 2
8128         elif(member.ischr()):
8129             ffullmode = member.mode + stat.S_IFCHR
8130             ftype = 3
8131         elif(member.isblk()):
8132             ffullmode = member.mode + stat.S_IFBLK
8133             ftype = 4
8134         elif(member.isdir()):
8135             ffullmode = member.mode + stat.S_IFDIR
8136             ftype = 5
8137         elif(member.isfifo()):
8138             ffullmode = member.mode + stat.S_IFIFO
8139             ftype = 6
8140         elif(member.issparse()):
8141             ffullmode = member.mode
8142             ftype = 12
8143         if(not verbose):
8144             VerbosePrintOut(member.name)
8145         elif(verbose):
8146             permissions = {'access': {'0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': (
8147                 'r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx')}, 'roles': {0: 'owner', 1: 'group', 2: 'other'}}
8148             printfname = member.name
8149             if(member.islnk()):
8150                 printfname = member.name + " link to " + member.linkname
8151             elif(member.issym()):
8152                 printfname = member.name + " -> " + member.linkname
8153             fuprint = member.uname
8154             if(len(fuprint) <= 0):
8155                 fuprint = member.uid
8156             fgprint = member.gname
8157             if(len(fgprint) <= 0):
8158                 fgprint = member.gid
8159             VerbosePrintOut(PrintPermissionString(ffullmode, ftype) + " " + str(str(fuprint) + "/" + str(fgprint) + " " + str(
8160                 member.size).rjust(15) + " " + datetime.datetime.utcfromtimestamp(member.mtime).strftime('%Y-%m-%d %H:%M') + " " + printfname))
8161         lcfi = lcfi + 1
8162     if(returnfp):
8163         return listcatfiles['catfp']
8164     else:
8165         return True
8166
8167
8168 def ZipFileListFiles(infile, verbose=False, returnfp=False):
8169     logging.basicConfig(format="%(message)s",
8170                         stream=sys.stdout, level=logging.DEBUG)
8171     if(infile == "-"):
8172         infile = BytesIO()
8173         if(hasattr(sys.stdin, "buffer")):
8174             shutil.copyfileobj(sys.stdin.buffer, infile)
8175         else:
8176             shutil.copyfileobj(sys.stdin, infile)
8177         infile.seek(0, 0)
8178         if(not infile):
8179             return False
8180         infile.seek(0, 0)
8181     elif(re.findall("^(http|https|ftp|ftps|sftp):\\/\\/", str(infile))):
8182         infile = download_file_from_internet_file(infile)
8183         infile.seek(0, 0)
8184         if(not infile):
8185             return False
8186         infile.seek(0, 0)
8187     elif(not os.path.exists(infile) or not os.path.isfile(infile)):
8188         return False
8189     if(not zipfile.is_zipfile(infile)):
8190         return False
8191     try:
8192         zipfp = zipfile.ZipFile(infile, "r", allowZip64=True)
8193     except FileNotFoundError:
8194         print(6)
8195         return False
8196     lcfi = 0
8197     returnval = {}
8198     ziptest = zipfp.testzip()
8199     if(ziptest):
8200         VerbosePrintOut("Bad file found!")
8201     for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
8202         if(zipinfo.create_system == 0 or zipinfo.create_system == 10):
8203             fwinattributes = int(zipinfo.external_attr)
8204             if(not member.is_dir()):
8205                 fmode = int(stat.S_IFREG + 438)
8206                 fchmode = int(stat.S_IMODE(fmode))
8207                 ftypemod = int(stat.S_IFMT(fmode))
8208             elif(member.is_dir()):
8209                 fmode = int(stat.S_IFDIR + 511)
8210                 fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)))
8211                 ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)))
8212         elif(zipinfo.create_system == 3):
8213             fwinattributes = int(0)
8214             try:
8215                 fmode = int(zipinfo.external_attr)
8216                 fchmode = stat.S_IMODE(fmode)
8217                 ftypemod = stat.S_IFMT(fmode)
8218             except OverflowError:
8219                 fmode = int(zipinfo.external_attr >> 16)
8220                 fchmode = stat.S_IMODE(fmode)
8221                 ftypemod = stat.S_IFMT(fmode)
8222         else:
8223             fwinattributes = int(0)
8224             if(not member.is_dir()):
8225                 fmode = int(stat.S_IFREG + 438)
8226                 fchmode = int(stat.S_IMODE(fmode))
8227                 ftypemod = int(stat.S_IFMT(fmode))
8228             elif(member.is_dir()):
8229                 fmode = int(stat.S_IFDIR + 511)
8230                 fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)))
8231                 ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)))
8232         returnval.update({lcfi: member.filename})
8233         if(not verbose):
8234             VerbosePrintOut(member.filename)
8235         if(verbose):
8236             permissions = {'access': {'0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': (
8237                 'r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx')}, 'roles': {0: 'owner', 1: 'group', 2: 'other'}}
8238             permissionstr = ""
8239             for fmodval in str(oct(fmode))[-3:]:
8240                 permissionstr = permissionstr + \
8241                     permissions['access'].get(fmodval, '---')
8242             if(not member.is_dir()):
8243                 ftype = 0
8244                 permissionstr = "-" + permissionstr
8245             elif(member.is_dir()):
8246                 ftype = 5
8247                 permissionstr = "d" + permissionstr
8248             printfname = member.filename
8249             try:
8250                 fuid = int(os.getuid())
8251             except AttributeError:
8252                 fuid = int(0)
8253             except KeyError:
8254                 fuid = int(0)
8255             try:
8256                 fgid = int(os.getgid())
8257             except AttributeError:
8258                 fgid = int(0)
8259             except KeyError:
8260                 fgid = int(0)
8261             try:
8262                 import pwd
8263                 try:
8264                     userinfo = pwd.getpwuid(os.getuid())
8265                     funame = userinfo.pw_name
8266                 except KeyError:
8267                     funame = ""
8268                 except AttributeError:
8269                     funame = ""
8270             except ImportError:
8271                 funame = ""
8272             fgname = ""
8273             try:
8274                 import grp
8275                 try:
8276                     groupinfo = grp.getgrgid(os.getgid())
8277                     fgname = groupinfo.gr_name
8278                 except KeyError:
8279                     fgname = ""
8280                 except AttributeError:
8281                     fgname = ""
8282             except ImportError:
8283                 fgname = ""
8284             fuprint = funame
8285             if(len(fuprint) <= 0):
8286                 fuprint = str(fuid)
8287             fgprint = fgname
8288             if(len(fgprint) <= 0):
8289                 fgprint = str(fgid)
8290             VerbosePrintOut(PrintPermissionString(fmode, ftype) + " " + str(str(fuprint) + "/" + str(fgprint) + " " + str(member.file_size).rjust(
8291                 15) + " " + datetime.datetime.utcfromtimestamp(int(time.mktime(member.date_time + (0, 0, -1)))).strftime('%Y-%m-%d %H:%M') + " " + printfname))
8292         lcfi = lcfi + 1
8293     if(returnfp):
8294         return listcatfiles['catfp']
8295     else:
8296         return True
8297
8298
8299 if(not rarfile_support):
8300     def RarFileListFiles(infile, verbose=False, returnfp=False):
8301         return False
8302
8303 if(rarfile_support):
8304     def RarFileListFiles(infile, verbose=False, returnfp=False):
8305         logging.basicConfig(format="%(message)s",
8306                             stream=sys.stdout, level=logging.DEBUG)
8307         if(not os.path.exists(infile) or not os.path.isfile(infile)):
8308             return False
8309         if(not rarfile.is_rarfile(infile) and not rarfile.is_rarfile_sfx(infile)):
8310             return False
8311         lcfi = 0
8312         returnval = {}
8313         rarfp = rarfile.RarFile(infile, "r")
8314         rartest = rarfp.testrar()
8315         if(rartest):
8316             VerbosePrintOut("Bad file found!")
8317         for member in sorted(rarfp.infolist(), key=lambda x: x.filename):
8318             is_unix = False
8319             is_windows = False
8320             if(member.host_os == rarfile.RAR_OS_UNIX):
8321                 is_windows = False
8322                 try:
8323                     member.external_attr
8324                     is_unix = True
8325                 except AttributeError:
8326                     is_unix = False
8327             elif(member.host_os == rarfile.RAR_OS_WIN32):
8328                 is_unix = False
8329                 try:
8330                     member.external_attr
8331                     is_windows = True
8332                 except AttributeError:
8333                     is_windows = False
8334             else:
8335                 is_unix = False
8336                 is_windows = False
8337             if(is_unix and member.external_attr != 0):
8338                 fpremode = int(member.external_attr)
8339             elif(member.is_file()):
8340                 fpremode = int(stat.S_IFREG + 438)
8341             elif(member.is_symlink()):
8342                 fpremode = int(stat.S_IFLNK + 438)
8343             elif(member.is_dir()):
8344                 fpremode = int(stat.S_IFDIR + 511)
8345             if(is_windows and member.external_attr != 0):
8346                 fwinattributes = int(member.external_attr)
8347             else:
8348                 fwinattributes = int(0)
8349             if(is_unix and member.external_attr != 0):
8350                 fmode = int(member.external_attr)
8351                 fchmode = int(stat.S_IMODE(member.external_attr))
8352                 ftypemod = int(stat.S_IFMT(member.external_attr))
8353             elif(member.is_file()):
8354                 fmode = int(stat.S_IFREG + 438)
8355                 fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)))
8356                 ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)))
8357             elif(member.is_symlink()):
8358                 fmode = int(stat.S_IFLNK + 438)
8359                 fchmode = int(stat.S_IMODE(int(stat.S_IFLNK + 438)))
8360                 ftypemod = int(stat.S_IFMT(int(stat.S_IFLNK + 438)))
8361             elif(member.is_dir()):
8362                 fmode = int(stat.S_IFDIR + 511)
8363                 fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)))
8364                 ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)))
8365             returnval.update({lcfi: member.filename})
8366             if(not verbose):
8367                 VerbosePrintOut(member.filename)
8368             if(verbose):
8369                 permissions = {'access': {'0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': (
8370                     'r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx')}, 'roles': {0: 'owner', 1: 'group', 2: 'other'}}
8371                 permissionstr = ""
8372                 for fmodval in str(oct(fmode))[-3:]:
8373                     permissionstr = permissionstr + \
8374                         permissions['access'].get(fmodval, '---')
8375                 if(member.is_file()):
8376                     ftype = 0
8377                     permissionstr = "-" + permissionstr
8378                     printfname = member.filename
8379                 elif(member.is_symlink()):
8380                     ftype = 2
8381                     permissionstr = "l" + permissionstr
8382                     printfname = member.name + " -> " + member.read().decode("UTF-8")
8383                 elif(member.is_dir()):
8384                     ftype = 5
8385                     permissionstr = "d" + permissionstr
8386                     printfname = member.filename
8387                 try:
8388                     fuid = int(os.getuid())
8389                 except AttributeError:
8390                     fuid = int(0)
8391                 except KeyError:
8392                     fuid = int(0)
8393                 try:
8394                     fgid = int(os.getgid())
8395                 except AttributeError:
8396                     fgid = int(0)
8397                 except KeyError:
8398                     fgid = int(0)
8399                 try:
8400                     import pwd
8401                     try:
8402                         userinfo = pwd.getpwuid(os.getuid())
8403                         funame = userinfo.pw_name
8404                     except KeyError:
8405                         funame = ""
8406                     except AttributeError:
8407                         funame = ""
8408                 except ImportError:
8409                     funame = ""
8410                 fgname = ""
8411                 try:
8412                     import grp
8413                     try:
8414                         groupinfo = grp.getgrgid(os.getgid())
8415                         fgname = groupinfo.gr_name
8416                     except KeyError:
8417                         fgname = ""
8418                     except AttributeError:
8419                         fgname = ""
8420                 except ImportError:
8421                     fgname = ""
8422                 fuprint = funame
8423                 if(len(fuprint) <= 0):
8424                     fuprint = str(fuid)
8425                 fgprint = fgname
8426                 if(len(fgprint) <= 0):
8427                     fgprint = str(fgid)
8428                 VerbosePrintOut(PrintPermissionString(fmode, ftype) + " " + str(str(fuprint) + "/" + str(fgprint) + " " + str(
8429                     member.file_size).rjust(15) + " " + member.mtime.strftime('%Y-%m-%d %H:%M') + " " + printfname))
8430             lcfi = lcfi + 1
8431         if(returnfp):
8432             return listcatfiles['catfp']
8433         else:
8434             return True
8435
8436 if(not py7zr_support):
8437     def SevenZipFileListFiles(infile, verbose=False, returnfp=False):
8438         return False
8439
8440 if(py7zr_support):
8441     def SevenZipFileListFiles(infile, verbose=False, returnfp=False):
8442         logging.basicConfig(format="%(message)s",
8443                             stream=sys.stdout, level=logging.DEBUG)
8444         if(not os.path.exists(infile) or not os.path.isfile(infile)):
8445             return False
8446         lcfi = 0
8447         returnval = {}
8448         szpfp = py7zr.SevenZipFile(infile, mode="r")
8449         file_content = szpfp.readall()
8450         #sztest = szpfp.testzip();
8451         sztestalt = szpfp.test()
8452         if(sztestalt):
8453             VerbosePrintOut("Bad file found!")
8454         for member in sorted(szpfp.list(), key=lambda x: x.filename):
8455             if(re.findall("^[.|/]", member.filename)):
8456                 fname = member.filename
8457             else:
8458                 fname = "./"+member.filename
8459             if(not member.is_directory):
8460                 fpremode = int(stat.S_IFREG + 438)
8461             elif(member.is_directory):
8462                 fpremode = int(stat.S_IFDIR + 511)
8463             fwinattributes = int(0)
8464             if(member.is_directory):
8465                 fmode = int(stat.S_IFDIR + 511)
8466                 fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)))
8467                 ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)))
8468             else:
8469                 fmode = int(stat.S_IFLNK + 438)
8470                 fchmode = int(stat.S_IMODE(int(stat.S_IFLNK + 438)))
8471                 ftypemod = int(stat.S_IFMT(int(stat.S_IFLNK + 438)))
8472             returnval.update({lcfi: member.filename})
8473             if(not verbose):
8474                 VerbosePrintOut(member.filename)
8475             if(verbose):
8476                 permissions = {'access': {'0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': (
8477                     'r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx')}, 'roles': {0: 'owner', 1: 'group', 2: 'other'}}
8478                 permissionstr = ""
8479                 for fmodval in str(oct(fmode))[-3:]:
8480                     permissionstr = permissionstr + \
8481                         permissions['access'].get(fmodval, '---')
8482                 fsize = int("0")
8483                 if(not member.is_directory):
8484                     ftype = 0
8485                     permissionstr = "-" + permissionstr
8486                     printfname = member.filename
8487                 elif(member.is_directory):
8488                     ftype = 5
8489                     permissionstr = "d" + permissionstr
8490                     printfname = member.filename
8491                 if(ftype == 0):
8492                     fsize = len(file_content[member.filename].read())
8493                     file_content[member.filename].close()
8494                 try:
8495                     fuid = int(os.getuid())
8496                 except AttributeError:
8497                     fuid = int(0)
8498                 except KeyError:
8499                     fuid = int(0)
8500                 try:
8501                     fgid = int(os.getgid())
8502                 except AttributeError:
8503                     fgid = int(0)
8504                 except KeyError:
8505                     fgid = int(0)
8506                 try:
8507                     import pwd
8508                     try:
8509                         userinfo = pwd.getpwuid(os.getuid())
8510                         funame = userinfo.pw_name
8511                     except KeyError:
8512                         funame = ""
8513                     except AttributeError:
8514                         funame = ""
8515                 except ImportError:
8516                     funame = ""
8517                 fgname = ""
8518                 try:
8519                     import grp
8520                     try:
8521                         groupinfo = grp.getgrgid(os.getgid())
8522                         fgname = groupinfo.gr_name
8523                     except KeyError:
8524                         fgname = ""
8525                     except AttributeError:
8526                         fgname = ""
8527                 except ImportError:
8528                     fgname = ""
8529                 fuprint = funame
8530                 if(len(fuprint) <= 0):
8531                     fuprint = str(fuid)
8532                 fgprint = fgname
8533                 if(len(fgprint) <= 0):
8534                     fgprint = str(fgid)
8535                 VerbosePrintOut(PrintPermissionString(fmode, ftype) + " " + str(str(fuprint) + "/" + str(fgprint) + " " + str(
8536                     fsize).rjust(15) + " " + member.creationtime.strftime('%Y-%m-%d %H:%M') + " " + printfname))
8537             lcfi = lcfi + 1
8538         if(returnfp):
8539             return listcatfiles['catfp']
8540         else:
8541             return True
8542
8543
8544 def InFileListFiles(infile, verbose=False, formatspecs=__file_format_dict__, returnfp=False):
8545     formatspecs = FormatSpecsListToDict(formatspecs)
8546     logging.basicConfig(format="%(message)s",
8547                         stream=sys.stdout, level=logging.DEBUG)
8548     checkcompressfile = CheckCompressionSubType(infile, formatspecs, True)
8549     if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
8550         return TarFileListFiles(infile, verbose, returnfp)
8551     elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
8552         return ZipFileListFiles(infile, verbose, returnfp)
8553     elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
8554         return RarFileListFiles(infile, verbose, returnfp)
8555     elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
8556         return SevenZipFileListFiles(infile, verbose, returnfp)
8557     elif(checkcompressfile == "catfile"):
8558         return ArchiveFileListFiles(infile, 0, 0, False, formatspecs, verbose, returnfp)
8559     else:
8560         return False
8561     return False
8562
8563
8564 def ListDirListFiles(infiles, dirlistfromtxt=False, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, checksumtype="crc32", formatspecs=__file_format_dict__, verbose=False, returnfp=False):
8565     formatspecs = FormatSpecsListToDict(formatspecs)
8566     outarray = BytesIO()
8567     packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compresswholefile,
8568                               compressionlevel, followlink, checksumtype, formatspecs, False, True)
8569     listcatfiles = ArchiveFileListFiles(
8570         outarray, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp)
8571     return listcatfiles
8572
8573
8574 def ListDirListFilesAlt(infiles, dirlistfromtxt=False, followlink=False, listonly=False, contentasfile=True, seekstart=0, seekend=0, skipchecksum=False, checksumtype="crc32", formatspecs=__file_format_dict__, verbose=False, returnfp=False):
8575     formatspecs = FormatSpecsListToDict(formatspecs)
8576     outarray = ListDirToArrayAlt(infiles, dirlistfromtxt, followlink,
8577                                  listonly, contentasfile, checksumtype, formatspecs, verbose)
8578     listcatfiles = ArchiveFileListFiles(
8579         outarray, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp)
8580     return listcatfiles
8581
8582
8583 def PackArchiveFileFromListDirAlt(infiles, outfile, dirlistfromtxt=False, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, skipchecksum=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
8584     formatspecs = FormatSpecsListToDict(formatspecs)
8585     outarray = ListDirToArrayAlt(infiles, dirlistfromtxt, followlink,
8586                                  False, True, checksumtype, extradata, formatspecs, False)
8587     listcatfiles = RePackArchiveFile(outarray, outfile, compression, compresswholefile, compressionlevel,
8588                                      followlink, checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp)
8589     return listcatfiles
8590
8591
8592 create_alias_function("Pack", __file_format_name__,
8593                       "FromListDirAlt", PackArchiveFileFromListDirAlt)
8594
8595
8596 def PackArchiveFileFromTarFileAlt(infile, outfile, compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
8597     formatspecs = FormatSpecsListToDict(formatspecs)
8598     outarray = TarFileToArrayAlt(
8599         infile, False, True, checksumtype, extradata, formatspecs, False)
8600     listcatfiles = RePackArchiveFile(outarray, outfile, compression, compresswholefile,
8601                                      compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp)
8602     return listcatfiles
8603
8604
8605 create_alias_function("Pack", __file_format_name__,
8606                       "FromTarFileAlt", PackArchiveFileFromTarFileAlt)
8607
8608
8609 def PackArchiveFileFromZipFileAlt(infile, outfile, compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
8610     formatspecs = FormatSpecsListToDict(formatspecs)
8611     outarray = ZipFileToArrayAlt(
8612         infile, False, True, checksumtype, extradata, formatspecs, False)
8613     listcatfiles = RePackArchiveFile(outarray, outfile, compression, compresswholefile,
8614                                      compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp)
8615     return listcatfiles
8616
8617
8618 create_alias_function("Pack", __file_format_name__,
8619                       "FromZipFileAlt", PackArchiveFileFromZipFileAlt)
8620
8621 if(not rarfile_support):
8622     def PackArchiveFileFromRarFileAlt(infile, outfile, compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
8623         return False
8624
8625 if(rarfile_support):
8626     def PackArchiveFileFromRarFileAlt(infile, outfile, compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
8627         formatspecs = FormatSpecsListToDict(formatspecs)
8628         outarray = RarFileToArrayAlt(
8629             infile, False, True, checksumtype, extradata, formatspecs, False)
8630         listcatfiles = RePackArchiveFile(outarray, outfile, compression, compresswholefile,
8631                                          compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp)
8632         return listcatfiles
8633
8634 create_alias_function("Pack", __file_format_name__,
8635                       "FromRarFileAlt", PackArchiveFileFromRarFileAlt)
8636
8637 if(not py7zr_support):
8638     def PackArchiveFileFromSevenZipFileAlt(infile, outfile, compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
8639         return False
8640
8641 if(py7zr_support):
8642     def PackArchiveFileFromSevenZipFileAlt(infile, outfile, compression="auto", compresswholefile=True, compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
8643         formatspecs = FormatSpecsListToDict(formatspecs)
8644         outarray = SevenZipFileToArrayAlt(
8645             infile, False, True, checksumtype, extradata, formatspecs, False)
8646         listcatfiles = RePackArchiveFile(outarray, outfile, compression, compresswholefile,
8647                                          compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp)
8648         return listcatfiles
8649
8650 create_alias_function("Pack", __file_format_name__,
8651                       "FromSevenZipFileAlt", PackArchiveFileFromSevenZipFileAlt)
8652
8653
8654 def download_file_from_ftp_file(url):
8655     urlparts = urlparse(url)
8656     file_name = os.path.basename(urlparts.path)
8657     file_dir = os.path.dirname(urlparts.path)
8658     if(urlparts.username is not None):
8659         ftp_username = urlparts.username
8660     else:
8661         ftp_username = "anonymous"
8662     if(urlparts.password is not None):
8663         ftp_password = urlparts.password
8664     elif(urlparts.password is None and urlparts.username == "anonymous"):
8665         ftp_password = "anonymous"
8666     else:
8667         ftp_password = ""
8668     if(urlparts.scheme == "ftp"):
8669         ftp = FTP()
8670     elif(urlparts.scheme == "ftps" and ftpssl):
8671         ftp = FTP_TLS()
8672     else:
8673         return False
8674     if(urlparts.scheme == "sftp"):
8675         if(__use_pysftp__):
8676             return download_file_from_pysftp_file(url)
8677         else:
8678             return download_file_from_sftp_file(url)
8679     elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
8680         return download_file_from_http_file(url)
8681     ftp_port = urlparts.port
8682     if(urlparts.port is None):
8683         ftp_port = 21
8684     try:
8685         ftp.connect(urlparts.hostname, ftp_port)
8686     except socket.gaierror:
8687         log.info("Error With URL "+url)
8688         return False
8689     except socket.timeout:
8690         log.info("Error With URL "+url)
8691         return False
8692     ftp.login(urlparts.username, urlparts.password)
8693     if(urlparts.scheme == "ftps"):
8694         ftp.prot_p()
8695     ftpfile = BytesIO()
8696     ftp.retrbinary("RETR "+urlparts.path, ftpfile.write)
8697     #ftp.storbinary("STOR "+urlparts.path, ftpfile.write);
8698     ftp.close()
8699     ftpfile.seek(0, 0)
8700     return ftpfile
8701
8702
8703 def download_file_from_ftp_string(url):
8704     ftpfile = download_file_from_ftp_file(url)
8705     return ftpfile.read()
8706
8707
8708 def upload_file_to_ftp_file(ftpfile, url):
8709     urlparts = urlparse(url)
8710     file_name = os.path.basename(urlparts.path)
8711     file_dir = os.path.dirname(urlparts.path)
8712     if(urlparts.username is not None):
8713         ftp_username = urlparts.username
8714     else:
8715         ftp_username = "anonymous"
8716     if(urlparts.password is not None):
8717         ftp_password = urlparts.password
8718     elif(urlparts.password is None and urlparts.username == "anonymous"):
8719         ftp_password = "anonymous"
8720     else:
8721         ftp_password = ""
8722     if(urlparts.scheme == "ftp"):
8723         ftp = FTP()
8724     elif(urlparts.scheme == "ftps" and ftpssl):
8725         ftp = FTP_TLS()
8726     else:
8727         return False
8728     if(urlparts.scheme == "sftp"):
8729         if(__use_pysftp__):
8730             return upload_file_to_pysftp_file(url)
8731         else:
8732             return upload_file_to_sftp_file(url)
8733     elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
8734         return False
8735     ftp_port = urlparts.port
8736     if(urlparts.port is None):
8737         ftp_port = 21
8738     try:
8739         ftp.connect(urlparts.hostname, ftp_port)
8740     except socket.gaierror:
8741         log.info("Error With URL "+url)
8742         return False
8743     except socket.timeout:
8744         log.info("Error With URL "+url)
8745         return False
8746     ftp.login(urlparts.username, urlparts.password)
8747     if(urlparts.scheme == "ftps"):
8748         ftp.prot_p()
8749     ftp.storbinary("STOR "+urlparts.path, ftpfile)
8750     ftp.close()
8751     ftpfile.seek(0, 0)
8752     return ftpfile
8753
8754
8755 def upload_file_to_ftp_string(ftpstring, url):
8756     ftpfileo = BytesIO(ftpstring)
8757     ftpfile = upload_file_to_ftp_file(ftpfileo, url)
8758     ftpfileo.close()
8759     return ftpfile
8760
8761
8762 class RawIteratorWrapper:
8763     def __init__(self, iterator):
8764         self.iterator = iterator
8765         self.buffer = b""
8766         self._iterator_exhausted = False
8767
8768     def read(self, size=-1):
8769         if self._iterator_exhausted:
8770             return b''
8771         while size < 0 or len(self.buffer) < size:
8772             try:
8773                 chunk = next(self.iterator)
8774                 self.buffer += chunk
8775             except StopIteration:
8776                 self._iterator_exhausted = True
8777                 break
8778         if size < 0:
8779             size = len(self.buffer)
8780         result, self.buffer = self.buffer[:size], self.buffer[size:]
8781         return result
8782
8783
8784 def download_file_from_http_file(url, headers=None, usehttp=__use_http_lib__):
8785     if headers is None:
8786         headers = {}
8787     # Parse the URL to extract username and password if present
8788     urlparts = urlparse(url)
8789     username = urlparts.username
8790     password = urlparts.password
8791     # Rebuild the URL without the username and password
8792     netloc = urlparts.hostname
8793     if urlparts.scheme == "sftp":
8794         if __use_pysftp__:
8795             return download_file_from_pysftp_file(url)
8796         else:
8797             return download_file_from_sftp_file(url)
8798     elif urlparts.scheme == "ftp" or urlparts.scheme == "ftps":
8799         return download_file_from_ftp_file(url)
8800     if urlparts.port:
8801         netloc += ':' + str(urlparts.port)
8802     rebuilt_url = urlunparse((urlparts.scheme, netloc, urlparts.path,
8803                              urlparts.params, urlparts.query, urlparts.fragment))
8804     # Create a temporary file object
8805     httpfile = BytesIO()
8806     if usehttp == 'requests' and haverequests:
8807         # Use the requests library if selected and available
8808         if username and password:
8809             response = requests.get(rebuilt_url, headers=headers, auth=(
8810                 username, password), stream=True)
8811         else:
8812             response = requests.get(rebuilt_url, headers=headers, stream=True)
8813         response.raw.decode_content = True
8814         shutil.copyfileobj(response.raw, httpfile)
8815     elif usehttp == 'httpx' and havehttpx:
8816         # Use httpx if selected and available
8817         with httpx.Client(follow_redirects=True) as client:
8818             if username and password:
8819                 response = client.get(
8820                     rebuilt_url, headers=headers, auth=(username, password))
8821             else:
8822                 response = client.get(rebuilt_url, headers=headers)
8823             raw_wrapper = RawIteratorWrapper(response.iter_bytes())
8824             shutil.copyfileobj(raw_wrapper, httpfile)
8825     else:
8826         # Use urllib as a fallback
8827         # Build a Request object for urllib
8828         request = Request(rebuilt_url, headers=headers)
8829         # Create an opener object for handling URLs
8830         if username and password:
8831             # Create a password manager
8832             password_mgr = HTTPPasswordMgrWithDefaultRealm()
8833             # Add the username and password
8834             password_mgr.add_password(None, rebuilt_url, username, password)
8835             # Create an authentication handler using the password manager
8836             auth_handler = HTTPBasicAuthHandler(password_mgr)
8837             # Build the opener with the authentication handler
8838             opener = build_opener(auth_handler)
8839         else:
8840             opener = build_opener()
8841         response = opener.open(request)
8842         shutil.copyfileobj(response, httpfile)
8843     # Reset file pointer to the start
8844     httpfile.seek(0, 0)
8845     # Return the temporary file object
8846     return httpfile
8847
8848
8849 def download_file_from_http_string(url, headers=geturls_headers_pycatfile_python_alt, usehttp=__use_http_lib__):
8850     httpfile = download_file_from_http_file(url, headers, usehttp)
8851     return httpfile.read()
8852
8853
8854 if(haveparamiko):
8855     def download_file_from_sftp_file(url):
8856         urlparts = urlparse(url)
8857         file_name = os.path.basename(urlparts.path)
8858         file_dir = os.path.dirname(urlparts.path)
8859         sftp_port = urlparts.port
8860         if(urlparts.port is None):
8861             sftp_port = 22
8862         else:
8863             sftp_port = urlparts.port
8864         if(urlparts.username is not None):
8865             sftp_username = urlparts.username
8866         else:
8867             sftp_username = "anonymous"
8868         if(urlparts.password is not None):
8869             sftp_password = urlparts.password
8870         elif(urlparts.password is None and urlparts.username == "anonymous"):
8871             sftp_password = "anonymous"
8872         else:
8873             sftp_password = ""
8874         if(urlparts.scheme == "ftp"):
8875             return download_file_from_ftp_file(url)
8876         elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
8877             return download_file_from_http_file(url)
8878         if(urlparts.scheme != "sftp"):
8879             return False
8880         ssh = paramiko.SSHClient()
8881         ssh.load_system_host_keys()
8882         ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
8883         try:
8884             ssh.connect(urlparts.hostname, port=sftp_port,
8885                         username=urlparts.username, password=urlparts.password)
8886         except paramiko.ssh_exception.SSHException:
8887             return False
8888         except socket.gaierror:
8889             log.info("Error With URL "+url)
8890             return False
8891         except socket.timeout:
8892             log.info("Error With URL "+url)
8893             return False
8894         sftp = ssh.open_sftp()
8895         sftpfile = BytesIO()
8896         sftp.getfo(urlparts.path, sftpfile)
8897         sftp.close()
8898         ssh.close()
8899         sftpfile.seek(0, 0)
8900         return sftpfile
8901 else:
8902     def download_file_from_sftp_file(url):
8903         return False
8904
8905 if(haveparamiko):
8906     def download_file_from_sftp_string(url):
8907         sftpfile = download_file_from_sftp_file(url)
8908         return sftpfile.read()
8909 else:
8910     def download_file_from_sftp_string(url):
8911         return False
8912
8913 if(haveparamiko):
8914     def upload_file_to_sftp_file(sftpfile, url):
8915         urlparts = urlparse(url)
8916         file_name = os.path.basename(urlparts.path)
8917         file_dir = os.path.dirname(urlparts.path)
8918         sftp_port = urlparts.port
8919         if(urlparts.port is None):
8920             sftp_port = 22
8921         else:
8922             sftp_port = urlparts.port
8923         if(urlparts.username is not None):
8924             sftp_username = urlparts.username
8925         else:
8926             sftp_username = "anonymous"
8927         if(urlparts.password is not None):
8928             sftp_password = urlparts.password
8929         elif(urlparts.password is None and urlparts.username == "anonymous"):
8930             sftp_password = "anonymous"
8931         else:
8932             sftp_password = ""
8933         if(urlparts.scheme == "ftp"):
8934             return upload_file_to_ftp_file(url)
8935         elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
8936             return False
8937         if(urlparts.scheme != "sftp"):
8938             return False
8939         ssh = paramiko.SSHClient()
8940         ssh.load_system_host_keys()
8941         ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
8942         try:
8943             ssh.connect(urlparts.hostname, port=sftp_port,
8944                         username=urlparts.username, password=urlparts.password)
8945         except paramiko.ssh_exception.SSHException:
8946             return False
8947         except socket.gaierror:
8948             log.info("Error With URL "+url)
8949             return False
8950         except socket.timeout:
8951             log.info("Error With URL "+url)
8952             return False
8953         sftp = ssh.open_sftp()
8954         sftp.putfo(sftpfile, urlparts.path)
8955         sftp.close()
8956         ssh.close()
8957         sftpfile.seek(0, 0)
8958         return sftpfile
8959 else:
8960     def upload_file_to_sftp_file(sftpfile, url):
8961         return False
8962
8963 if(haveparamiko):
8964     def upload_file_to_sftp_string(sftpstring, url):
8965         sftpfileo = BytesIO(sftpstring)
8966         sftpfile = upload_file_to_sftp_files(ftpfileo, url)
8967         sftpfileo.close()
8968         return sftpfile
8969 else:
8970     def upload_file_to_sftp_string(url):
8971         return False
8972
8973 if(havepysftp):
8974     def download_file_from_pysftp_file(url):
8975         urlparts = urlparse(url)
8976         file_name = os.path.basename(urlparts.path)
8977         file_dir = os.path.dirname(urlparts.path)
8978         sftp_port = urlparts.port
8979         if(urlparts.port is None):
8980             sftp_port = 22
8981         else:
8982             sftp_port = urlparts.port
8983         if(urlparts.username is not None):
8984             sftp_username = urlparts.username
8985         else:
8986             sftp_username = "anonymous"
8987         if(urlparts.password is not None):
8988             sftp_password = urlparts.password
8989         elif(urlparts.password is None and urlparts.username == "anonymous"):
8990             sftp_password = "anonymous"
8991         else:
8992             sftp_password = ""
8993         if(urlparts.scheme == "ftp"):
8994             return download_file_from_ftp_file(url)
8995         elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
8996             return download_file_from_http_file(url)
8997         if(urlparts.scheme != "sftp"):
8998             return False
8999         try:
9000             pysftp.Connection(urlparts.hostname, port=sftp_port,
9001                               username=urlparts.username, password=urlparts.password)
9002         except paramiko.ssh_exception.SSHException:
9003             return False
9004         except socket.gaierror:
9005             log.info("Error With URL "+url)
9006             return False
9007         except socket.timeout:
9008             log.info("Error With URL "+url)
9009             return False
9010         sftp = ssh.open_sftp()
9011         sftpfile = BytesIO()
9012         sftp.getfo(urlparts.path, sftpfile)
9013         sftp.close()
9014         ssh.close()
9015         sftpfile.seek(0, 0)
9016         return sftpfile
9017 else:
9018     def download_file_from_pysftp_file(url):
9019         return False
9020
9021 if(havepysftp):
9022     def download_file_from_pysftp_string(url):
9023         sftpfile = download_file_from_pysftp_file(url)
9024         return sftpfile.read()
9025 else:
9026     def download_file_from_pyftp_string(url):
9027         return False
9028
9029 if(havepysftp):
9030     def upload_file_to_pysftp_file(sftpfile, url):
9031         urlparts = urlparse(url)
9032         file_name = os.path.basename(urlparts.path)
9033         file_dir = os.path.dirname(urlparts.path)
9034         sftp_port = urlparts.port
9035         if(urlparts.port is None):
9036             sftp_port = 22
9037         else:
9038             sftp_port = urlparts.port
9039         if(urlparts.username is not None):
9040             sftp_username = urlparts.username
9041         else:
9042             sftp_username = "anonymous"
9043         if(urlparts.password is not None):
9044             sftp_password = urlparts.password
9045         elif(urlparts.password is None and urlparts.username == "anonymous"):
9046             sftp_password = "anonymous"
9047         else:
9048             sftp_password = ""
9049         if(urlparts.scheme == "ftp"):
9050             return upload_file_to_ftp_file(url)
9051         elif(urlparts.scheme == "http" or urlparts.scheme == "https"):
9052             return False
9053         if(urlparts.scheme != "sftp"):
9054             return False
9055         try:
9056             pysftp.Connection(urlparts.hostname, port=sftp_port,
9057                               username=urlparts.username, password=urlparts.password)
9058         except paramiko.ssh_exception.SSHException:
9059             return False
9060         except socket.gaierror:
9061             log.info("Error With URL "+url)
9062             return False
9063         except socket.timeout:
9064             log.info("Error With URL "+url)
9065             return False
9066         sftp = ssh.open_sftp()
9067         sftp.putfo(sftpfile, urlparts.path)
9068         sftp.close()
9069         ssh.close()
9070         sftpfile.seek(0, 0)
9071         return sftpfile
9072 else:
9073     def upload_file_to_pysftp_file(sftpfile, url):
9074         return False
9075
9076 if(havepysftp):
9077     def upload_file_to_pysftp_string(sftpstring, url):
9078         sftpfileo = BytesIO(sftpstring)
9079         sftpfile = upload_file_to_pysftp_files(ftpfileo, url)
9080         sftpfileo.close()
9081         return sftpfile
9082 else:
9083     def upload_file_to_pysftp_string(url):
9084         return False
9085
9086
9087 def download_file_from_internet_file(url, headers=geturls_headers_pycatfile_python_alt, usehttp=__use_http_lib__):
9088     urlparts = urlparse(url)
9089     if(urlparts.scheme == "http" or urlparts.scheme == "https"):
9090         return download_file_from_http_file(url, headers, usehttp)
9091     elif(urlparts.scheme == "ftp" or urlparts.scheme == "ftps"):
9092         return download_file_from_ftp_file(url)
9093     elif(urlparts.scheme == "sftp"):
9094         if(__use_pysftp__ and havepysftp):
9095             return download_file_from_pysftp_file(url)
9096         else:
9097             return download_file_from_sftp_file(url)
9098     else:
9099         return False
9100     return False
9101
9102
9103 def download_file_from_internet_uncompress_file(url, headers=geturls_headers_pycatfile_python_alt, formatspecs=__file_format_dict__):
9104     formatspecs = FormatSpecsListToDict(formatspecs)
9105     fp = download_file_from_internet_file(url)
9106     fp = UncompressArchiveFile(fp, formatspecs)
9107     fp.seek(0, 0)
9108     if(not fp):
9109         return False
9110     return fp
9111
9112
9113 def download_file_from_internet_string(url, headers=geturls_headers_pycatfile_python_alt):
9114     urlparts = urlparse(url)
9115     if(urlparts.scheme == "http" or urlparts.scheme == "https"):
9116         return download_file_from_http_string(url, headers)
9117     elif(urlparts.scheme == "ftp" or urlparts.scheme == "ftps"):
9118         return download_file_from_ftp_string(url)
9119     elif(urlparts.scheme == "sftp"):
9120         if(__use_pysftp__ and havepysftp):
9121             return download_file_from_pysftp_string(url)
9122         else:
9123             return download_file_from_sftp_string(url)
9124     else:
9125         return False
9126     return False
9127
9128
9129 def download_file_from_internet_uncompress_string(url, headers=geturls_headers_pycatfile_python_alt, formatspecs=__file_format_dict__):
9130     formatspecs = FormatSpecsListToDict(formatspecs)
9131     fp = download_file_from_internet_string(url)
9132     fp = UncompressArchiveFile(fp, formatspecs)
9133     fp.seek(0, 0)
9134     if(not fp):
9135         return False
9136     return fp
9137
9138
9139 def upload_file_to_internet_file(ifp, url):
9140     urlparts = urlparse(url)
9141     if(urlparts.scheme == "http" or urlparts.scheme == "https"):
9142         return False
9143     elif(urlparts.scheme == "ftp" or urlparts.scheme == "ftps"):
9144         return upload_file_to_ftp_file(ifp, url)
9145     elif(urlparts.scheme == "sftp"):
9146         if(__use_pysftp__ and havepysftp):
9147             return upload_file_to_pysftp_file(ifp, url)
9148         else:
9149             return upload_file_to_sftp_file(ifp, url)
9150     else:
9151         return False
9152     return False
9153
9154
9155 def upload_file_to_internet_compress_file(ifp, url, compression="auto", compressionlevel=None, formatspecs=__file_format_dict__):
9156     formatspecs = FormatSpecsListToDict(formatspecs)
9157     catfp = CompressArchiveFile(
9158         catfp, compression, compressionlevel, formatspecs)
9159     if(not catfileout):
9160         return False
9161     catfp.seek(0, 0)
9162     upload_file_to_internet_file(catfp, outfile)
9163     return True
9164
9165
9166 def upload_file_to_internet_string(ifp, url):
9167     urlparts = urlparse(url)
9168     if(urlparts.scheme == "http" or urlparts.scheme == "https"):
9169         return False
9170     elif(urlparts.scheme == "ftp" or urlparts.scheme == "ftps"):
9171         return upload_file_to_ftp_string(ifp, url)
9172     elif(urlparts.scheme == "sftp"):
9173         if(__use_pysftp__ and havepysftp):
9174             return upload_file_to_pysftp_string(ifp, url)
9175         else:
9176             return upload_file_to_sftp_string(ifp, url)
9177     else:
9178         return False
9179     return False
9180
9181
9182 def upload_file_to_internet_compress_string(ifp, url, compression="auto", compressionlevel=None, formatspecs=__file_format_dict__):
9183     formatspecs = FormatSpecsListToDict(formatspecs)
9184     catfp = CompressArchiveFile(
9185         BytesIO(ifp), compression, compressionlevel, formatspecs)
9186     if(not catfileout):
9187         return False
9188     catfp.seek(0, 0)
9189     upload_file_to_internet_file(catfp, outfile)
9190     return True
9191
9192
9193 try:
9194     if(hasattr(shutil, "register_archive_format")):
9195         # Register the packing format
9196         shutil.register_archive_format(
9197             __file_format_name__, PackArchiveFileFunc, description='Pack concatenated files')
9198 except shutil.RegistryError:
9199     pass
9200
9201 try:
9202     if(hasattr(shutil, "register_unpack_format")):
9203         # Register the unpacking format
9204         shutil.register_unpack_format(__file_format_name__, archivefile_extensions,
9205                                       UnPackArchiveFileFunc, description='UnPack concatenated files')
9206 except shutil.RegistryError:
9207     pass