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: 4/12/2024 Ver. 0.7.8 RC 1 - Author: cooldude2k $
  18 '''
  19
  20 from __future__ import absolute_import, division, print_function, unicode_literals;
  21 import io, os, re, sys, time, stat, zlib, base64, shutil, socket, hashlib, datetime, logging, binascii, tempfile, zipfile, platform;
  22 from ftplib import FTP, FTP_TLS;
  23 if(sys.version[0]=="2"):
  24  from urlparse import urlparse, urlunparse;
  25 elif(sys.version[0]>="3"):
  26  from urllib.parse import urlunparse;
  27  from urllib.parse import urlparse;
  28
  29 if os.name == 'nt':  # Only modify if on Windows
  30  if sys.version[0] == "2":
  31   import codecs;
  32   sys.stdout = codecs.getwriter('utf-8')(sys.stdout);
  33   sys.stderr = codecs.getwriter('utf-8')(sys.stderr);
  34  else:
  35   import io;
  36   sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace', line_buffering=True);
  37   sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace', line_buffering=True);
  38
  39 hashlib_guaranteed = False;
  40 os.environ["PYTHONIOENCODING"] = "UTF-8";
  41 os.environ["LC_CTYPE"] = "UTF-8";
  42 try:
  43  reload(sys);
  44  try:
  45   sys.setdefaultencoding('UTF-8');
  46  except NameError:
  47   pass;
  48  except AttributeError:
  49   pass;
  50 except NameError:
  51  pass;
  52 except AttributeError:
  53  pass;
  54
  55 try:
  56  from zlib import crc32;
  57 except ImportError:
  58  from binascii import crc32;
  59
  60 rarfile_support = False;
  61 try:
  62  import rarfile;
  63  rarfile_support = True;
  64 except ImportError:
  65  rarfile_support = False;
  66
  67 py7zr_support = False;
  68 try:
  69  import py7zr;
  70  py7zr_support = True;
  71 except ImportError:
  72  py7zr_support = False;
  73
  74 try:
  75  from safetar import is_tarfile;
  76 except ImportError:
  77  try:
  78   from xtarfile import is_tarfile;
  79  except ImportError:
  80   from tarfile import is_tarfile;
  81
  82 try:
  83  import safetar as tarfile;
  84 except ImportError:
  85  try:
  86   import xtarfile as tarfile;
  87  except ImportError:
  88   import tarfile;
  89
  90 haveparamiko = False;
  91 try:
  92  import paramiko;
  93  haveparamiko = True;
  94 except ImportError:
  95  haveparamiko = False;
  96
  97 havepysftp = False;
  98 try:
  99  import pysftp;
 100  havepysftp = True;
 101 except ImportError:
 102  havepysftp = False;
 103
 104 haverequests = False;
 105 try:
 106  import requests;
 107  haverequests = True;
 108 except ImportError:
 109  haverequests = False;
 110
 111 if(haverequests):
 112  import urllib3;
 113  logging.getLogger("urllib3").setLevel(logging.WARNING);
 114
 115 try:
 116  # Python 3 imports
 117  from urllib.request import Request, build_opener, HTTPBasicAuthHandler;
 118  from urllib.parse import urlparse;
 119 except ImportError:
 120  # Python 2 imports
 121  from urllib2 import Request, build_opener, HTTPBasicAuthHandler;
 122  from urlparse import urlparse;
 123
 124 if(sys.version[0]=="2"):
 125  try:
 126   from io import StringIO, BytesIO;
 127  except ImportError:
 128   try:
 129    from cStringIO import StringIO;
 130    from cStringIO import StringIO as BytesIO;
 131   except ImportError:
 132    from StringIO import StringIO;
 133    from StringIO import StringIO as BytesIO;
 134 elif(sys.version[0]>="3"):
 135  from io import StringIO, BytesIO;
 136 else:
 137  teststringio = 0;
 138  if(teststringio<=0):
 139   try:
 140    from cStringIO import StringIO as BytesIO;
 141    teststringio = 1;
 142   except ImportError:
 143    teststringio = 0;
 144  if(teststringio<=0):
 145   try:
 146    from StringIO import StringIO as BytesIO;
 147    teststringio = 2;
 148   except ImportError:
 149    teststringio = 0;
 150  if(teststringio<=0):
 151   try:
 152    from io import BytesIO;
 153    teststringio = 3;
 154   except ImportError:
 155    teststringio = 0;
 156
 157 __use_pysftp__ = False;
 158 if(not havepysftp):
 159  __use_pysftp__ = False;
 160 __file_format_name__ = "CatFile";
 161 __program_name__ = "Py"+__file_format_name__;
 162 __file_format_lower__ = __file_format_name__.lower();
 163 __file_format_magic__ = __file_format_name__;
 164 __file_format_len__ = len(__file_format_magic__);
 165 __file_format_hex__ = binascii.hexlify(__file_format_magic__.encode("UTF-8")).decode("UTF-8");
 166 __file_format_delimiter__ = "\x00";
 167 __file_format_ver__ = "001";
 168 __use_new_style__ = True;
 169 __use_advanced_list__ = True;
 170 __use_alt_inode__ = False;
 171 __file_format_list__ = [__file_format_name__, __file_format_magic__, __file_format_lower__, __file_format_len__, __file_format_hex__, __file_format_delimiter__, __file_format_ver__, __use_new_style__, __use_advanced_list__, __use_alt_inode__];
 172 __project__ = __program_name__;
 173 __project_url__ = "https://github.com/GameMaker2k/PyCatFile";
 174 __version_info__ = (0, 7, 8, "RC 1", 1);
 175 __version_date_info__ = (2024, 4, 12, "RC 1", 1);
 176 __version_date__ = str(__version_date_info__[0]) + "." + str(__version_date_info__[1]).zfill(2) + "." + str(__version_date_info__[2]).zfill(2);
 177 __revision__ = __version_info__[3];
 178 __revision_id__ = "$Id$";
 179 if(__version_info__[4] is not None):
 180  __version_date_plusrc__ = __version_date__ + "-" + str(__version_date_info__[4]);
 181 if(__version_info__[4] is None):
 182  __version_date_plusrc__ = __version_date__;
 183 if(__version_info__[3] is not None):
 184  __version__ = str(__version_info__[0]) + "." + str(__version_info__[1]) + "." + str(__version_info__[2]) + " " + str(__version_info__[3]);
 185 if(__version_info__[3] is None):
 186  __version__ = str(__version_info__[0]) + "." + str(__version_info__[1]) + "." + str(__version_info__[2]);
 187
 188 PyBitness = platform.architecture();
 189 if(PyBitness=="32bit" or PyBitness=="32"):
 190  PyBitness = "32";
 191 elif(PyBitness=="64bit" or PyBitness=="64"):
 192  PyBitness = "64";
 193 else:
 194  PyBitness = "32";
 195
 196 geturls_ua_pycatfile_python = "Mozilla/5.0 (compatible; {proname}/{prover}; +{prourl})".format(proname=__project__, prover=__version__, prourl=__project_url__);
 197 if(platform.python_implementation()!=""):
 198  py_implementation = platform.python_implementation();
 199 if(platform.python_implementation()==""):
 200  py_implementation = "Python";
 201 geturls_ua_pycatfile_python_alt = "Mozilla/5.0 ({osver}; {archtype}; +{prourl}) {pyimp}/{pyver} (KHTML, like Gecko) {proname}/{prover}".format(osver=platform.system()+" "+platform.release(), archtype=platform.machine(), prourl=__project_url__, pyimp=py_implementation, pyver=platform.python_version(), proname=__project__, prover=__version__);
 202 geturls_ua_googlebot_google = "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)";
 203 geturls_ua_googlebot_google_old = "Googlebot/2.1 (+http://www.google.com/bot.html)";
 204 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", '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)};
 205 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", '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)};
 206 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", '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"};
 207 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", '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"};
 208
 209 compressionlist = ['auto', 'gzip', 'bzip2', 'zstd', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
 210 outextlist = ['gz', 'bz2', 'zst', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
 211 outextlistwd = ['.gz', '.bz2', '.zst', '.lz4', '.lzo', '.lzop', '.lzma', '.xz'];
 212
 213 tarfile_mimetype = "application/tar";
 214 tarfile_tar_mimetype = tarfile_mimetype;
 215 zipfile_mimetype = "application/zip";
 216 zipfile_zip_mimetype = zipfile_mimetype;
 217 rarfile_mimetype = "application/rar";
 218 rarfile_rar_mimetype = rarfile_mimetype;
 219 archivefile_mimetype = "application/x-"+__file_format_list__[1]+"";
 220 archivefile_cat_mimetype = archivefile_mimetype;
 221 archivefile_gzip_mimetype = "application/x-"+__file_format_list__[1]+"+gzip";
 222 archivefile_gz_mimetype = archivefile_gzip_mimetype;
 223 archivefile_bzip2_mimetype = "application/x-"+__file_format_list__[1]+"+bzip2";
 224 archivefile_bz2_mimetype = archivefile_bzip2_mimetype;
 225 archivefile_lz4_mimetype = "application/x-"+__file_format_list__[1]+"+lz4";
 226 archivefile_lzop_mimetype = "application/x-"+__file_format_list__[1]+"+lzop";
 227 archivefile_lzo_mimetype = archivefile_lzop_mimetype;
 228 archivefile_zstandard_mimetype = "application/x-"+__file_format_list__[1]+"+zstandard";
 229 archivefile_zstd_mimetype = archivefile_zstandard_mimetype;
 230 archivefile_lzma_mimetype = "application/x-"+__file_format_list__[1]+"+lzma";
 231 archivefile_xz_mimetype = "application/x-"+__file_format_list__[1]+"+xz";
 232 archivefile_extensions = ['.cat', '.cat.gz', '.cat.bz2', '.cat.zst', '.cat.lz4', '.cat.lzo', '.cat.lzop', '.cat.lzma', '.cat.xz'];
 233
 234 if __name__ == "__main__":
 235  import subprocess;
 236  curscrpath = os.path.dirname(sys.argv[0]);
 237  if(curscrpath==""):
 238   curscrpath = ".";
 239  if(os.sep=="\\"):
 240   curscrpath = curscrpath.replace(os.sep, "/");
 241  curscrpath = curscrpath + "/";
 242  scrfile = curscrpath + "catfile.py";
 243  if(os.path.exists(scrfile) and os.path.isfile(scrfile)):
 244   scrcmd = subprocess.Popen([sys.executable, scrfile] + sys.argv[1:]);
 245   scrcmd.wait();
 246
 247 def VerbosePrintOut(dbgtxt, outtype="log", dbgenable=True, dgblevel=20):
 248  if(not dbgenable):
 249   return True;
 250  log_functions = {
 251   "print": print,
 252   "log": logging.info,
 253   "warning": logging.warning,
 254   "error": logging.error,
 255   "critical": logging.critical,
 256   "exception": logging.exception,
 257   "logalt": lambda x: logging.log(dgblevel, x),
 258   "debug": logging.debug
 259  };
 260  log_function = log_functions.get(outtype);
 261  if(log_function):
 262   log_function(dbgtxt);
 263   return True;
 264  return False;
 265
 266 def VerbosePrintOutReturn(dbgtxt, outtype="log", dbgenable=True, dgblevel=20):
 267  VerbosePrintOut(dbgtxt, outtype, dbgenable, dgblevel);
 268  return dbgtxt;
 269
 270 def RemoveWindowsPath(dpath):
 271  if(dpath is None):
 272   dpath = "";
 273  if(os.sep!="/"):
 274   dpath = dpath.replace(os.path.sep, "/");
 275  dpath = dpath.rstrip("/");
 276  if(dpath=="." or dpath==".."):
 277   dpath = dpath + "/";
 278  return dpath;
 279
 280 def NormalizeRelativePath(inpath):
 281  inpath = RemoveWindowsPath(inpath);
 282  if(os.path.isabs(inpath)):
 283   outpath = inpath;
 284  else:
 285   if(inpath.startswith("./") or inpath.startswith("../")):
 286    outpath = inpath;
 287   else:
 288    outpath = "./" + inpath;
 289  return outpath;
 290
 291 def PrependPath(base_dir, child_path):
 292  # Check if base_dir is None or empty, if so, return child_path as is
 293  if not base_dir:
 294   return child_path;
 295  # Ensure base_dir ends with exactly one slash
 296  if not base_dir.endswith('/'):
 297   base_dir += '/';
 298  # Check if child_path starts with ./ or ../ (indicating a relative path)
 299  if child_path.startswith('./') or child_path.startswith('../'):
 300   # For relative paths, we don't alter the child_path
 301   return base_dir + child_path;
 302  else:
 303   # For non-relative paths, ensure there's no starting slash on child_path to avoid double slashes
 304   return base_dir + child_path.lstrip('/');
 305
 306 def ListDir(dirpath, followlink=False, duplicates=False):
 307  if(isinstance(dirpath, (list, tuple, ))):
 308   dirpath = list(filter(None, dirpath));
 309  elif(isinstance(dirpath, (str, ))):
 310   dirpath = list(filter(None, [dirpath]));
 311  retlist = [];
 312  for mydirfile in dirpath:
 313   if(not os.path.exists(mydirfile)):
 314    return False;
 315   mydirfile = NormalizeRelativePath(mydirfile);
 316   if(os.path.exists(mydirfile) and os.path.islink(mydirfile)):
 317    mydirfile = RemoveWindowsPath(os.path.realpath(mydirfile));
 318   if(os.path.exists(mydirfile) and os.path.isdir(mydirfile)):
 319    for root, dirs, filenames in os.walk(mydirfile):
 320     dpath = root;
 321     dpath = RemoveWindowsPath(dpath);
 322     if(dpath not in retlist and not duplicates):
 323      retlist.append(dpath);
 324     if(duplicates):
 325      retlist.append(dpath);
 326     for file in filenames:
 327      fpath = os.path.join(root, file);
 328      fpath = RemoveWindowsPath(fpath);
 329      if(fpath not in retlist and not duplicates):
 330       retlist.append(fpath);
 331      if(duplicates):
 332       retlist.append(fpath);
 333   else:
 334    retlist.append(RemoveWindowsPath(mydirfile));
 335  return retlist;
 336
 337 def ListDirAdvanced(dirpath, followlink=False, duplicates=False):
 338  if isinstance(dirpath, (list, tuple)):
 339   dirpath = list(filter(None, dirpath));
 340  elif isinstance(dirpath, str):
 341   dirpath = list(filter(None, [dirpath]));
 342  retlist = []
 343  for mydirfile in dirpath:
 344   if not os.path.exists(mydirfile):
 345    return False;
 346   mydirfile = NormalizeRelativePath(mydirfile);
 347   if os.path.exists(mydirfile) and os.path.islink(mydirfile) and followlink:
 348    mydirfile = RemoveWindowsPath(os.path.realpath(mydirfile))
 349   if os.path.exists(mydirfile) and os.path.isdir(mydirfile):
 350    for root, dirs, filenames in os.walk(mydirfile):
 351     # Sort dirs and filenames alphabetically in place
 352     dirs.sort(key=lambda x: x.lower());
 353     filenames.sort(key=lambda x: x.lower());
 354     dpath = RemoveWindowsPath(root);
 355     if not duplicates and dpath not in retlist:
 356      retlist.append(dpath);
 357     elif duplicates:
 358      retlist.append(dpath);
 359     for file in filenames:
 360      fpath = os.path.join(root, file);
 361      fpath = RemoveWindowsPath(fpath);
 362      if not duplicates and fpath not in retlist:
 363       retlist.append(fpath);
 364      elif duplicates:
 365       retlist.append(fpath);
 366   else:
 367    retlist.append(RemoveWindowsPath(mydirfile));
 368  return retlist;
 369
 370 def create_alias_function(prefix, base_name, suffix, target_function):
 371  # Define a new function that wraps the target function
 372  def alias_function(*args, **kwargs):
 373   return target_function(*args, **kwargs);
 374
 375  # Create the function name by combining the prefix, base name, and the suffix
 376  function_name = "{}{}{}".format(prefix, base_name, suffix);
 377
 378  # Add the new function to the global namespace
 379  globals()[function_name] = alias_function;
 380
 381 def create_alias_function_alt(prefix, base_name, suffix, target_function):
 382     # Create the function name by combining the prefix, base name, and the suffix
 383     # Use the format method for string formatting, compatible with Python 2 and 3
 384     function_name = "{}{}{}".format(prefix, base_name, suffix)
 385     # Add the new function (alias of the target_function) to the global namespace
 386     # This line is compatible as-is with both Python 2 and 3
 387     globals()[function_name] = target_function
 388
 389 # initial_value can be 0xFFFF or 0x0000
 390 def crc16_ansi(msg, initial_value=0xFFFF):
 391  # CRC-16-IBM / CRC-16-ANSI polynomial and initial value
 392  poly = 0x8005;  # Polynomial for CRC-16-IBM / CRC-16-ANSI
 393  crc = initial_value;  # Initial value
 394  for b in msg:
 395   crc ^= b << 8;  # XOR byte into CRC top byte
 396   for _ in range(8):  # Process each bit
 397    if crc & 0x8000:  # If the top bit is set
 398     crc = (crc << 1) ^ poly;  # Shift left and XOR with the polynomial
 399    else:
 400     crc = crc << 1;  # Just shift left
 401    crc &= 0xFFFF;  # Ensure CRC remains 16-bit
 402  return crc;
 403
 404 # initial_value can be 0xFFFF or 0x0000
 405 def crc16_ibm(msg, initial_value=0xFFFF):
 406  return crc16_ansi(msg, initial_value);
 407
 408 # initial_value is 0xFFFF
 409 def crc16(msg):
 410  return crc16_ansi(msg, 0xFFFF);
 411
 412 # initial_value can be 0xFFFF, 0x1D0F or 0x0000
 413 def crc16_ccitt(msg, initial_value=0xFFFF):
 414  # CRC-16-CCITT polynomial
 415  poly = 0x1021;  # Polynomial for CRC-16-CCITT
 416  # Use the specified initial value
 417  crc = initial_value;
 418  for b in msg:
 419   crc ^= b << 8;  # XOR byte into CRC top byte
 420   for _ in range(8):  # Process each bit
 421    if crc & 0x8000:  # If the top bit is set
 422     crc = (crc << 1) ^ poly;  # Shift left and XOR with the polynomial
 423    else:
 424     crc = crc << 1;  # Just shift left
 425    crc &= 0xFFFF;  # Ensure CRC remains 16-bit
 426  return crc;
 427
 428 # initial_value can be 0x42F0E1EBA9EA3693 or 0x0000000000000000
 429 def crc64_ecma(msg, initial_value=0x0000000000000000):
 430  # CRC-64-ECMA polynomial and initial value
 431  poly = 0x42F0E1EBA9EA3693;
 432  crc = initial_value;  # Initial value for CRC-64-ECMA
 433  for b in msg:
 434   crc ^= b << 56;  # XOR byte into the most significant byte of the CRC
 435   for _ in range(8):  # Process each bit
 436    if crc & (1 << 63):  # Check if the leftmost (most significant) bit is set
 437     crc = (crc << 1) ^ poly;  # Shift left and XOR with poly if the MSB is 1
 438    else:
 439     crc <<= 1;  # Just shift left if the MSB is 0
 440    crc &= 0xFFFFFFFFFFFFFFFF;  # Ensure CRC remains 64-bit
 441  return crc;
 442
 443 # initial_value can be 0x000000000000001B or 0xFFFFFFFFFFFFFFFF
 444 def crc64_iso(msg, initial_value=0xFFFFFFFFFFFFFFFF):
 445  # CRC-64-ISO polynomial and initial value
 446  poly = 0x000000000000001B;
 447  crc = initial_value;  # Common initial value for CRC-64-ISO
 448  for b in msg:
 449   crc ^= b << 56;  # XOR byte into the most significant byte of the CRC
 450   for _ in range(8):  # Process each bit
 451    if crc & (1 << 63):  # Check if the leftmost (most significant) bit is set
 452     crc = (crc << 1) ^ poly;  # Shift left and XOR with poly if the MSB is 1
 453    else:
 454     crc <<= 1;  # Just shift left if the MSB is 0
 455    crc &= 0xFFFFFFFFFFFFFFFF;  # Ensure CRC remains 64-bit
 456  return crc;
 457
 458 def GetDataFromArray(data, path, default=None):
 459  element = data;
 460  try:
 461   for key in path:
 462    element = element[key];
 463   return element;
 464  except (KeyError, TypeError, IndexError):
 465   return default;
 466
 467 def GetDataFromArrayAlt(structure, path, default=None):
 468  element = structure;
 469  for key in path:
 470   if isinstance(element, dict) and key in element:
 471    element = element[key];
 472   elif isinstance(element, list) and isinstance(key, int) and -len(element) <= key < len(element):
 473    element = element[key];
 474   else:
 475    return default;
 476  return element;
 477
 478 def GetHeaderChecksum(inlist=[], checksumtype="crc32", encodedata=True, formatspecs=__file_format_list__):
 479  if isinstance(inlist, list):
 480   fileheader = AppendNullBytes(inlist, formatspecs[5]);
 481  else:
 482   fileheader = AppendNullByte(inlist, formatspecs[5]);
 483  if(encodedata):
 484   fileheader = fileheader.encode('UTF-8');
 485  if(checksumtype=="none" or checksumtype==""):
 486   catfileheadercshex = format(0, 'x').lower();
 487  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
 488   catfileheadercshex = format(crc16(fileheader) & 0xffff, '04x').lower();
 489  elif(checksumtype=="crc16_ccitt"):
 490   catfileheadercshex = format(crc16_ccitt(fileheader) & 0xffff, '04x').lower();
 491  elif(checksumtype=="adler32"):
 492   catfileheadercshex = format(zlib.adler32(fileheader) & 0xffffffff, '08x').lower();
 493  elif(checksumtype=="crc32"):
 494   catfileheadercshex = format(crc32(fileheader) & 0xffffffff, '08x').lower();
 495  elif(checksumtype=="crc64_ecma"):
 496   catfileheadercshex = format(crc64_ecma(fileheader) & 0xffffffffffffffff, '016x').lower();
 497  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
 498   catfileheadercshex = format(crc64_iso(fileheader) & 0xffffffffffffffff, '016x').lower();
 499  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
 500   checksumoutstr = hashlib.new(checksumtype);
 501   checksumoutstr.update(fileheader);
 502   catfileheadercshex = checksumoutstr.hexdigest().lower();
 503  else:
 504   catfileheadercshex = format(0, 'x').lower();
 505  return catfileheadercshex;
 506
 507 def GetFileChecksum(instr, checksumtype="crc32", encodedata=True, formatspecs=__file_format_list__):
 508  if(encodedata):
 509   instr = instr.encode('UTF-8');
 510  if(checksumtype=="none" or checksumtype==""):
 511   catinstrcshex = format(0, 'x').lower();
 512  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
 513   catinstrcshex = format(crc16(instr) & 0xffff, '04x').lower();
 514  elif(checksumtype=="crc16_ccitt"):
 515   catinstrcshex = format(crc16_ccitt(instr) & 0xffff, '04x').lower();
 516  elif(checksumtype=="adler32"):
 517   catinstrcshex = format(zlib.adler32(instr) & 0xffffffff, '08x').lower();
 518  elif(checksumtype=="crc32"):
 519   catinstrcshex = format(crc32(instr) & 0xffffffff, '08x').lower();
 520  elif(checksumtype=="crc64_ecma"):
 521   catinstrcshex = format(crc64_ecma(instr) & 0xffffffffffffffff, '016x').lower();
 522  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
 523   catinstrcshex = format(crc64_iso(instr) & 0xffffffffffffffff, '016x').lower();
 524  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
 525   checksumoutstr = hashlib.new(checksumtype);
 526   checksumoutstr.update(instr);
 527   catinstrcshex = checksumoutstr.hexdigest().lower();
 528  else:
 529   catinstrcshex = format(0, 'x').lower();
 530  return catinstrcshex;
 531
 532 def ValidateHeaderChecksum(inlist=[], checksumtype="crc32", inchecksum="0", formatspecs=__file_format_list__):
 533  catfileheadercshex = GetHeaderChecksum(inlist, checksumtype, True, formatspecs);
 534  inchecksum = inchecksum.lower();
 535  catfileheadercshex = catfileheadercshex.lower();
 536  if(inchecksum==catfileheadercshex):
 537   return True;
 538  else:
 539   return False;
 540
 541 def ValidateFileChecksum(infile, checksumtype="crc32", inchecksum="0", formatspecs=__file_format_list__):
 542  catinfilecshex = GetFileChecksum(infile, checksumtype, True, formatspecs);
 543  inchecksum = inchecksum.lower();
 544  catinfilecshex = catinfilecshex.lower();
 545  if(inchecksum==catinfilecshex):
 546   return True;
 547  else:
 548   return False;
 549
 550 def ReadTillNullByte(fp, delimiter=__file_format_delimiter__):
 551  curbyte = b"";
 552  curfullbyte = b"";
 553  nullbyte = delimiter.encode("UTF-8");
 554  while(True):
 555   curbyte = fp.read(1);
 556   if(curbyte==nullbyte or not curbyte):
 557    break;
 558   curfullbyte = curfullbyte + curbyte;
 559  return curfullbyte.decode('UTF-8');
 560
 561 def ReadUntilNullByte(fp, delimiter=__file_format_delimiter__):
 562  return ReadTillNullByte(fp, delimiter);
 563
 564 def SeekToEndOfFile(fp):
 565  lasttell = 0;
 566  while(True):
 567   fp.seek(1, 1);
 568   if(lasttell==fp.tell()):
 569    break;
 570   lasttell = fp.tell();
 571  return True;
 572
 573 def ReadFileHeaderData(fp, rounds=0, delimiter=__file_format_delimiter__):
 574  rocount = 0;
 575  roend = int(rounds);
 576  HeaderOut = [];
 577  while(rocount<roend):
 578   HeaderOut.append(ReadTillNullByte(fp, delimiter));
 579   rocount = rocount + 1;
 580  return HeaderOut;
 581
 582 def ReadFileHeaderDataBySize(fp, delimiter=__file_format_delimiter__):
 583  headerpresize = ReadTillNullByte(fp, delimiter);
 584  headersize = int(headerpresize, 16);
 585  if(headersize<=0):
 586   return [];
 587  headercontent = str(fp.read(headersize).decode('UTF-8')).split(delimiter);
 588  fp.seek(1, 1);
 589  rocount = 0;
 590  roend = int(len(headercontent));
 591  HeaderOut = [headerpresize];
 592  while(rocount<roend):
 593   HeaderOut.append(headercontent[rocount]);
 594   rocount = rocount + 1;
 595  return HeaderOut;
 596
 597 def ReadFileHeaderDataWoSize(fp, delimiter=__file_format_delimiter__):
 598  preheaderdata = ReadFileHeaderData(fp, 2, delimiter);
 599  headersize = int(preheaderdata[0], 16);
 600  headernumfields = int(preheaderdata[1], 16);
 601  if(headersize<=0 or headernumfields<=0):
 602   return [];
 603  headerdata = ReadFileHeaderData(fp, headernumfields, delimiter);
 604  HeaderOut = preheaderdata + headerdata;
 605  return HeaderOut;
 606
 607 def ReadFileHeaderDataBySizeWithContent(fp, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
 608  delimiter = formatspecs[5];
 609  fheaderstart = fp.tell();
 610  HeaderOut = ReadFileHeaderDataBySize(fp, delimiter);
 611  if(len(HeaderOut)==0):
 612   return False;
 613  if(re.findall("^[.|/]", HeaderOut[3])):
 614   fname = HeaderOut[3];
 615  else:
 616   fname = "./"+HeaderOut[3];
 617  fchecksumtype = HeaderOut[-3].lower();
 618  fcs = HeaderOut[-2].lower();
 619  fccs = HeaderOut[-1].lower();
 620  fsize = int(HeaderOut[5], 16);
 621  newfcs = GetHeaderChecksum(HeaderOut[:-2], HeaderOut[-3].lower(), True, formatspecs);
 622  if(fcs!=newfcs and not skipchecksum):
 623   VerbosePrintOut("File Header Checksum Error with file " + fname + " at offset " + str(fheaderstart));
 624   return False;
 625  fhend = fp.tell() - 1;
 626  fcontentstart = fp.tell();
 627  fcontents = "".encode('UTF-8');
 628  if(fsize>0 and not listonly):
 629   fcontents = fp.read(fsize);
 630  elif(fsize>0 and listonly):
 631   fp.seek(fsize, 1);
 632  newfccs = GetFileChecksum(fcontents, HeaderOut[-3].lower(), False, formatspecs);
 633  if(fccs!=newfccs and not skipchecksum and not listonly):
 634   VerbosePrintOut("File Content Checksum Error with file " + fname + " at offset " + str(fcontentstart));
 635   return False;
 636  fp.seek(1, 1);
 637  fcontentend = fp.tell() - 1;
 638  HeaderOut.append(fcontents);
 639  return HeaderOut;
 640
 641 def ReadFileHeaderDataBySizeWithContentToArray(fp, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
 642  delimiter = formatspecs[5];
 643  fheaderstart = fp.tell();
 644  if(formatspecs[7]):
 645   HeaderOut = ReadFileHeaderDataBySize(fp, delimiter);
 646  else:
 647   HeaderOut = ReadFileHeaderDataWoSize(fp, delimiter);
 648  if(len(HeaderOut)==0):
 649   return False;
 650  fheadsize = int(HeaderOut[0], 16);
 651  fnumfields = int(HeaderOut[1], 16);
 652  ftype = int(HeaderOut[2], 16);
 653  if(re.findall("^[.|/]", HeaderOut[3])):
 654   fname = HeaderOut[3];
 655  else:
 656   fname = "./"+HeaderOut[3];
 657  fbasedir = os.path.dirname(fname);
 658  flinkname = HeaderOut[4];
 659  fsize = int(HeaderOut[5], 16);
 660  fatime = int(HeaderOut[6], 16);
 661  fmtime = int(HeaderOut[7], 16);
 662  fctime = int(HeaderOut[8], 16);
 663  fbtime = int(HeaderOut[9], 16);
 664  fmode = int(HeaderOut[10], 16);
 665  fchmode = stat.S_IMODE(fmode);
 666  ftypemod = stat.S_IFMT(fmode);
 667  fwinattributes = int(HeaderOut[11], 16);
 668  fuid = int(HeaderOut[12], 16);
 669  funame = HeaderOut[13];
 670  fgid = int(HeaderOut[14], 16);
 671  fgname = HeaderOut[15];
 672  fid = int(HeaderOut[16], 16);
 673  finode = int(HeaderOut[17], 16);
 674  flinkcount = int(HeaderOut[18], 16);
 675  fdev_minor = int(HeaderOut[19], 16);
 676  fdev_major = int(HeaderOut[20], 16);
 677  frdev_minor = int(HeaderOut[21], 16);
 678  frdev_major = int(HeaderOut[22], 16);
 679  fextrasize = int(HeaderOut[23], 16);
 680  fextrafields = int(HeaderOut[24], 16);
 681  extrafieldslist = [];
 682  extrastart = 25;
 683  extraend = extrastart + fextrafields;
 684  extrafieldslist = [];
 685  if(extrastart<extraend):
 686   extrafieldslist.append(HeaderOut[extrastart]);
 687   extrastart = extrastart + 1;
 688  fchecksumtype = HeaderOut[extrastart].lower();
 689  fcs = HeaderOut[extrastart + 1].lower();
 690  fccs = HeaderOut[extrastart + 2].lower();
 691  newfcs = GetHeaderChecksum(HeaderOut[:-2], HeaderOut[-3].lower(), True, formatspecs);
 692  if(fcs!=newfcs and not skipchecksum):
 693   VerbosePrintOut("File Header Checksum Error with file " + fname + " at offset " + str(fheaderstart));
 694   return False;
 695  fhend = fp.tell() - 1;
 696  fcontentstart = fp.tell();
 697  fcontents = "".encode('UTF-8');
 698  pyhascontents = False;
 699  if(fsize>0 and not listonly):
 700   fcontents = fp.read(fsize);
 701   pyhascontents = True;
 702  elif(fsize>0 and listonly):
 703   fp.seek(fsize, 1);
 704   pyhascontents = False;
 705  newfccs = GetFileChecksum(fcontents, HeaderOut[-3].lower(), False, formatspecs);
 706  if(fccs!=newfccs and not skipchecksum and not listonly):
 707   VerbosePrintOut("File Content Checksum Error with file " + fname + " at offset " + str(fcontentstart));
 708   return False;
 709  fp.seek(1, 1);
 710  fcontentend = fp.tell() - 1;
 711  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, 'fuid': fuid, 'funame': funame, 'fgid': fgid, 'fgname': fgname, 'finode': finode, 'flinkcount': flinkcount, 'fminor': fdev_minor, 'fmajor': fdev_major, 'frminor': frdev_minor, 'frmajor': frdev_major, 'fchecksumtype': fchecksumtype, 'fnumfields': fnumfields + 2, 'frawheader': HeaderOut, 'fextrafields': fextrafields, 'fextrafieldsize': fextrasize, 'fextralist': extrafieldslist, 'fheaderchecksum': fcs, 'fcontentchecksum': fccs, 'fhascontents': pyhascontents, 'fcontentstart': fcontentstart, 'fcontentend': fcontentend, 'fcontents': fcontents};
 712  return catlist;
 713
 714 def ReadFileHeaderDataBySizeWithContentToList(fp, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
 715  delimiter = formatspecs[5];
 716  fheaderstart = fp.tell();
 717  if(formatspecs[7]):
 718   HeaderOut = ReadFileHeaderDataBySize(fp, delimiter);
 719  else:
 720   HeaderOut = ReadFileHeaderDataWoSize(fp, delimiter);
 721  if(len(HeaderOut)==0):
 722   return False;
 723  fheadsize = int(HeaderOut[0], 16);
 724  fnumfields = int(HeaderOut[1], 16);
 725  ftype = int(HeaderOut[2], 16);
 726  if(re.findall("^[.|/]", HeaderOut[3])):
 727   fname = HeaderOut[3];
 728  else:
 729   fname = "./"+HeaderOut[3];
 730  fbasedir = os.path.dirname(fname);
 731  flinkname = HeaderOut[4];
 732  fsize = int(HeaderOut[5], 16);
 733  fatime = int(HeaderOut[6], 16);
 734  fmtime = int(HeaderOut[7], 16);
 735  fctime = int(HeaderOut[8], 16);
 736  fbtime = int(HeaderOut[9], 16);
 737  fmode = int(HeaderOut[10], 16);
 738  fchmode = stat.S_IMODE(fmode);
 739  ftypemod = stat.S_IFMT(fmode);
 740  fwinattributes = int(HeaderOut[11], 16);
 741  fuid = int(HeaderOut[12], 16);
 742  funame = HeaderOut[13];
 743  fgid = int(HeaderOut[14], 16);
 744  fgname = HeaderOut[15];
 745  fid = int(HeaderOut[16], 16);
 746  finode = int(HeaderOut[17], 16);
 747  flinkcount = int(HeaderOut[18], 16);
 748  fdev_minor = int(HeaderOut[19], 16);
 749  fdev_major = int(HeaderOut[20], 16);
 750  frdev_minor = int(HeaderOut[21], 16);
 751  frdev_major = int(HeaderOut[22], 16);
 752  fextrasize = int(HeaderOut[23], 16);
 753  fextrafields = int(HeaderOut[24], 16);
 754  extrafieldslist = [];
 755  extrastart = 25;
 756  extraend = extrastart + fextrafields;
 757  extrafieldslist = [];
 758  if(extrastart<extraend):
 759   extrafieldslist.append(HeaderOut[extrastart]);
 760   extrastart = extrastart + 1;
 761  fchecksumtype = HeaderOut[extrastart].lower();
 762  fcs = HeaderOut[extrastart + 1].lower();
 763  fccs = HeaderOut[extrastart + 2].lower();
 764  newfcs = GetHeaderChecksum(HeaderOut[:-2], HeaderOut[-3].lower(), True, formatspecs);
 765  if(fcs!=newfcs and not skipchecksum):
 766   VerbosePrintOut("File Header Checksum Error with file " + fname + " at offset " + str(fheaderstart));
 767   return False;
 768  fhend = fp.tell() - 1;
 769  fcontentstart = fp.tell();
 770  fcontents = "".encode('UTF-8');
 771  pyhascontents = False;
 772  if(fsize>0 and not listonly):
 773   fcontents = fp.read(fsize);
 774   pyhascontents = True;
 775  elif(fsize>0 and listonly):
 776   fp.seek(fsize, 1);
 777   pyhascontents = False;
 778  newfccs = GetFileChecksum(fcontents, HeaderOut[-3].lower(), False, formatspecs);
 779  if(fccs!=newfccs and not skipchecksum and not listonly):
 780   VerbosePrintOut("File Content Checksum Error with file " + fname + " at offset " + str(fcontentstart));
 781   return False;
 782  fp.seek(1, 1);
 783  fcontentend = fp.tell() - 1;
 784  catlist = [ftype, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fuid, funame, fgid, fgname, fid, finode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrafieldslist, fchecksumtype, fcontents];
 785  return catlist;
 786
 787 def ReadFileDataBySizeWithContent(fp, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
 788  delimiter = formatspecs[5];
 789  curloc = fp.tell();
 790  if(curloc>0):
 791   fp.seek(0, 0);
 792  catheader = ReadFileHeaderData(fp, 4, delimiter);
 793  if(curloc>0):
 794   fp.seek(curloc, 0);
 795  headercheck = ValidateHeaderChecksum(catheader[:-1], catheader[2], catheader[3], formatspecs);
 796  if(not headercheck and not skipchecksum):
 797   VerbosePrintOut("File Header Checksum Error with file at offset " + str(0));
 798   return False;
 799  fnumfiles = int(catheader[1], 16);
 800  countnum = 0;
 801  flist = [];
 802  while(countnum < fnumfiles):
 803   HeaderOut = ReadFileHeaderDataBySizeWithContent(fp, listonly, skipchecksum, formatspecs)
 804   if(len(HeaderOut)==0):
 805    break;
 806   flist.append(HeaderOut);
 807   countnum = countnum + 1;
 808  return flist;
 809
 810 def ReadFileDataBySizeWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
 811  delimiter = formatspecs[5];
 812  curloc = fp.tell();
 813  if(curloc>0):
 814   fp.seek(0, 0);
 815  catheader = ReadFileHeaderData(fp, 4, delimiter);
 816  if(curloc>0):
 817   fp.seek(curloc, 0);
 818  headercheck = ValidateHeaderChecksum(catheader[:-1], catheader[2], catheader[3], formatspecs);
 819  if(not headercheck and not skipchecksum):
 820   VerbosePrintOut("File Header Checksum Error with file at offset " + str(0));
 821   return False;
 822  catstring = catheader[0];
 823  catversion = re.findall(r"([\d]+)$", catstring);
 824  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
 825  fprenumfiles = catheader[1];
 826  fnumfiles = int(fprenumfiles, 16);
 827  fprechecksumtype = catheader[2];
 828  fprechecksum = catheader[3];
 829  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': {}};
 830  if(seekstart<0 and seekstart>fnumfiles):
 831    seekstart = 0;
 832  if(seekend==0 or seekend>fnumfiles and seekend<seekstart):
 833   seekend = fnumfiles;
 834  elif(seekend<0 and abs(seekend)<=fnumfiles and abs(seekend)>=seekstart):
 835   seekend = fnumfiles - abs(seekend);
 836  if(seekstart>0):
 837   il = 0;
 838   while(il < seekstart):
 839    prefhstart = fp.tell();
 840    preheaderdata = ReadFileHeaderDataBySize(fp, formatspecs[5]);
 841    if(len(preheaderdata)==0):
 842     break;
 843    prefsize = int(preheaderdata[5], 16);
 844    prenewfcs = GetHeaderChecksum(preheaderdata[:-2], preheaderdata[-3].lower(), True, formatspecs);
 845    prefcs = preheaderdata[-2];
 846    if(prefcs!=prenewfcs and not skipchecksum):
 847     VerbosePrintOut("File Header Checksum Error with file " + prefname + " at offset " + str(prefhstart));
 848     return False;
 849     valid_archive = False;
 850     invalid_archive = True;
 851    prefhend = fp.tell() - 1;
 852    prefcontentstart = fp.tell();
 853    prefcontents = "";
 854    pyhascontents = False;
 855    if(prefsize>0):
 856     prefcontents = fp.read(prefsize);
 857     prenewfccs = GetFileChecksum(prefcontents, preheaderdata[-3].lower(), False, formatspecs);
 858     prefccs = preheaderdata[-1];
 859     pyhascontents = True;
 860     if(prefccs!=prenewfccs and not skipchecksum):
 861      VerbosePrintOut("File Content Checksum Error with file " + prefname + " at offset " + str(prefcontentstart));
 862      return False;
 863    fp.seek(1, 1);
 864    il = il + 1;
 865  realidnum = 0;
 866  countnum = seekstart;
 867  while(countnum < seekend):
 868   catlist['ffilelist'].update({realidnum: {'fid': realidnum, 'fidalt': realidnum}});
 869   HeaderOut = ReadFileHeaderDataBySizeWithContentToArray(fp, listonly, skipchecksum, formatspecs);
 870   if(len(HeaderOut)):
 871    break;
 872   catlist['ffilelist'][realidnum].update(HeaderOut);
 873   countnum = countnum + 1;
 874   realidnum = realidnum + 1;
 875  return catlist;
 876
 877 def ReadFileDataBySizeWithContentToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
 878  if(isinstance(infile, dict)):
 879   listcatfiles = infile;
 880  else:
 881   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
 882    return False;
 883   listcatfiles = ReadFileDataBySizeWithContentToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs);
 884  if(not listcatfiles):
 885   return False;
 886  catarray = {'list': listcatfiles, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {}, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}};
 887  lenlist = len(listcatfiles['ffilelist']);
 888  lcfi = 0;
 889  lcfx = int(listcatfiles['fnumfiles']);
 890  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
 891   lcfx = int(lenlist);
 892  else:
 893   lcfx = int(listcatfiles['fnumfiles']);
 894  while(lcfi < lcfx):
 895   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
 896   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
 897   catarray['filetoid'].update(filetoidarray);
 898   catarray['idtofile'].update(idtofilearray);
 899   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
 900    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
 901    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
 902   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
 903    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
 904    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
 905    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
 906    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
 907   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
 908    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
 909    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
 910    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
 911    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
 912   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
 913    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
 914    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
 915    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
 916    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
 917   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
 918    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
 919    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
 920    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
 921    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
 922   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
 923    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
 924    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
 925   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
 926    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
 927    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
 928    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
 929    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
 930   lcfi = lcfi + 1;
 931  return catarray;
 932
 933 def ReadFileDataBySizeWithContentToList(fp, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
 934  delimiter = formatspecs[5];
 935  curloc = fp.tell();
 936  if(curloc>0):
 937   fp.seek(0, 0);
 938  catheader = ReadFileHeaderData(fp, 4, delimiter);
 939  if(curloc>0):
 940   fp.seek(curloc, 0);
 941  headercheck = ValidateHeaderChecksum(catheader[:-1], catheader[2], catheader[3], formatspecs);
 942  if(not headercheck and not skipchecksum):
 943   VerbosePrintOut("File Header Checksum Error with file at offset " + str(0));
 944   return False;
 945  catstring = catheader[0];
 946  catversion = re.findall(r"([\d]+)$", catstring);
 947  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
 948  fprenumfiles = catheader[1];
 949  fnumfiles = int(fprenumfiles, 16);
 950  fprechecksumtype = catheader[2];
 951  fprechecksum = catheader[3];
 952  catlist = [];
 953  if(seekstart<0 and seekstart>fnumfiles):
 954    seekstart = 0;
 955  if(seekend==0 or seekend>fnumfiles and seekend<seekstart):
 956   seekend = fnumfiles;
 957  elif(seekend<0 and abs(seekend)<=fnumfiles and abs(seekend)>=seekstart):
 958   seekend = fnumfiles - abs(seekend);
 959  if(seekstart>0):
 960   il = 0;
 961   while(il < seekstart):
 962    prefhstart = fp.tell();
 963    preheaderdata = ReadFileHeaderDataBySize(fp, formatspecs[5]);
 964    if(len(preheaderdata)==0):
 965     break;
 966    prefsize = int(preheaderdata[5], 16);
 967    prenewfcs = GetHeaderChecksum(preheaderdata[:-2], preheaderdata[-3].lower(), True, formatspecs);
 968    prefcs = preheaderdata[-2];
 969    if(prefcs!=prenewfcs and not skipchecksum):
 970     VerbosePrintOut("File Header Checksum Error with file " + prefname + " at offset " + str(prefhstart));
 971     return False;
 972     valid_archive = False;
 973     invalid_archive = True;
 974    prefhend = fp.tell() - 1;
 975    prefcontentstart = fp.tell();
 976    prefcontents = "";
 977    pyhascontents = False;
 978    if(prefsize>0):
 979     prefcontents = fp.read(prefsize);
 980     prenewfccs = GetFileChecksum(prefcontents, preheaderdata[-3].lower(), False, formatspecs);
 981     prefccs = preheaderdata[-1];
 982     pyhascontents = True;
 983     if(prefccs!=prenewfccs and not skipchecksum):
 984      VerbosePrintOut("File Content Checksum Error with file " + prefname + " at offset " + str(prefcontentstart));
 985      return False;
 986    fp.seek(1, 1);
 987    il = il + 1;
 988  realidnum = 0;
 989  countnum = seekstart;
 990  while(countnum < seekend):
 991   HeaderOut = ReadFileHeaderDataBySizeWithContentToList(fp, listonly, skipchecksum, formatspecs);
 992   if(len(HeaderOut)):
 993    break;
 994   catlist.append(HeaderOut);
 995   countnum = countnum + 1;
 996   realidnum = realidnum + 1;
 997  return catlist;
 998
 999 def ReadInFileBySizeWithContentToArray(infile, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
1000  delimiter = formatspecs[5];
1001  if(hasattr(infile, "read") or hasattr(infile, "write")):
1002   fp = infile;
1003   fp.seek(0, 0);
1004   fp = UncompressArchiveFile(fp, formatspecs);
1005   checkcompressfile = CheckCompressionSubType(fp, formatspecs, True);
1006   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
1007    return False;
1008   if(not fp):
1009    return False;
1010   fp.seek(0, 0);
1011  elif(infile=="-"):
1012   fp = BytesIO();
1013   if(hasattr(sys.stdin, "buffer")):
1014    shutil.copyfileobj(sys.stdin.buffer, fp);
1015   else:
1016    shutil.copyfileobj(sys.stdin, fp);
1017   fp.seek(0, 0);
1018   fp = UncompressArchiveFile(fp, formatspecs);
1019   if(not fp):
1020    return False;
1021   fp.seek(0, 0);
1022  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
1023   fp = download_file_from_internet_file(infile);
1024   fp = UncompressArchiveFile(fp, formatspecs);
1025   fp.seek(0, 0);
1026   if(not fp):
1027    return False;
1028   fp.seek(0, 0);
1029  else:
1030   infile = RemoveWindowsPath(infile);
1031   checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
1032   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
1033    return False;
1034   compresscheck = CheckCompressionType(infile, formatspecs, True);
1035   if(not compresscheck):
1036    fextname = os.path.splitext(infile)[1];
1037    if(fextname==".gz"):
1038     compresscheck = "gzip";
1039    elif(fextname==".bz2"):
1040     compresscheck = "bzip2";
1041    elif(fextname==".zst"):
1042     compresscheck = "zstd";
1043    elif(fextname==".lz4" or fextname==".clz4"):
1044     compresscheck = "lz4";
1045    elif(fextname==".lzo" or fextname==".lzop"):
1046     compresscheck = "lzo";
1047    elif(fextname==".lzma" or fextname==".xz"):
1048     compresscheck = "lzma";
1049    else:
1050     return False;
1051   if(not compresscheck):
1052    return False;
1053   fp = UncompressFile(infile, formatspecs, "rb");
1054  return ReadFileDataBySizeWithContentToArray(fp, listonly, skipchecksum, formatspecs);
1055
1056 def ReadInFileBySizeWithContentToList(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
1057  delimiter = formatspecs[5];
1058  if(hasattr(infile, "read") or hasattr(infile, "write")):
1059   fp = infile;
1060   fp.seek(0, 0);
1061   fp = UncompressArchiveFile(fp, formatspecs);
1062   checkcompressfile = CheckCompressionSubType(fp, formatspecs, True);
1063   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
1064    return False;
1065   if(not fp):
1066    return False;
1067   fp.seek(0, 0);
1068  elif(infile=="-"):
1069   fp = BytesIO();
1070   if(hasattr(sys.stdin, "buffer")):
1071    shutil.copyfileobj(sys.stdin.buffer, fp);
1072   else:
1073    shutil.copyfileobj(sys.stdin, fp);
1074   fp.seek(0, 0);
1075   fp = UncompressArchiveFile(fp, formatspecs);
1076   if(not fp):
1077    return False;
1078   fp.seek(0, 0);
1079  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
1080   fp = download_file_from_internet_file(infile);
1081   fp = UncompressArchiveFile(fp, formatspecs);
1082   fp.seek(0, 0);
1083   if(not fp):
1084    return False;
1085   fp.seek(0, 0);
1086  else:
1087   infile = RemoveWindowsPath(infile);
1088   checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
1089   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
1090    return False;
1091   compresscheck = CheckCompressionType(infile, formatspecs, True);
1092   if(not compresscheck):
1093    fextname = os.path.splitext(infile)[1];
1094    if(fextname==".gz"):
1095     compresscheck = "gzip";
1096    elif(fextname==".bz2"):
1097     compresscheck = "bzip2";
1098    elif(fextname==".zst"):
1099     compresscheck = "zstd";
1100    elif(fextname==".lz4" or fextname==".clz4"):
1101     compresscheck = "lz4";
1102    elif(fextname==".lzo" or fextname==".lzop"):
1103     compresscheck = "lzo";
1104    elif(fextname==".lzma" or fextname==".xz"):
1105     compresscheck = "lzma";
1106    else:
1107     return False;
1108   if(not compresscheck):
1109    return False;
1110   fp = UncompressFile(infile, formatspecs, "rb");
1111  return ReadFileDataBySizeWithContentToList(fp, seekstart, seekend, listonly, skipchecksum, formatspecs);
1112
1113 def ReadInFileBySizeWithContentToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
1114  if(isinstance(infile, dict)):
1115   listcatfiles = infile;
1116  else:
1117   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
1118    infile = RemoveWindowsPath(infile);
1119   listcatfiles = ReadInFileBySizeWithContentToArray(infile, listonly, skipchecksum, formatspecs);
1120  if(not listcatfiles):
1121   return False;
1122  catarray = {'list': listcatfiles, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {}, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}};
1123  lenlist = len(listcatfiles['ffilelist']);
1124  lcfi = 0;
1125  lcfx = int(listcatfiles['fnumfiles']);
1126  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
1127   lcfx = int(lenlist);
1128  else:
1129   lcfx = int(listcatfiles['fnumfiles']);
1130  while(lcfi < lcfx):
1131   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
1132   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
1133   catarray['filetoid'].update(filetoidarray);
1134   catarray['idtofile'].update(idtofilearray);
1135   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
1136    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
1137    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
1138   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
1139    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
1140    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
1141    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
1142    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
1143   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
1144    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
1145    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
1146    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
1147    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
1148   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
1149    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
1150    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
1151    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
1152    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
1153   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
1154    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
1155    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
1156    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
1157    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
1158   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
1159    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
1160    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
1161   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
1162    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
1163    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
1164    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
1165    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
1166   lcfi = lcfi + 1;
1167  return catarray;
1168
1169 def AppendNullByte(indata, delimiter=__file_format_delimiter__):
1170  outdata = str(indata) + delimiter;
1171  return outdata;
1172
1173 def AppendNullBytes(indata=[], delimiter=__file_format_delimiter__):
1174  outdata = "";
1175  inum = 0;
1176  il = len(indata);
1177  while(inum < il):
1178   outdata = outdata + AppendNullByte(indata[inum], delimiter);
1179   inum = inum + 1;
1180  return outdata;
1181
1182 def AppendFileHeader(fp, numfiles, checksumtype="crc32", formatspecs=__file_format_list__):
1183  delimiter = formatspecs[5];
1184  catver = formatspecs[6];
1185  fileheaderver = str(int(catver.replace(".", "")));
1186  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
1187  fp.write(fileheader.encode('UTF-8'));
1188  fnumfiles = format(int(numfiles), 'x').lower();
1189  fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
1190  catfileheadercshex = GetFileChecksum(fileheader + fnumfilesa, checksumtype, True, formatspecs);
1191  fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
1192  fp.write(fnumfilesa.encode('UTF-8'));
1193  try:
1194   fp.flush();
1195   os.fsync(fp.fileno());
1196  except io.UnsupportedOperation:
1197   pass;
1198  except AttributeError:
1199   pass;
1200  return fp;
1201
1202 def AppendFileHeaderWithContent(fp, filevalues=[], extradata=[], filecontent="", checksumtype="crc32", formatspecs=__file_format_list__):
1203  extrafields = format(len(extradata), 'x').lower();
1204  extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
1205  if(len(extradata)>0):
1206   extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
1207  extrasizelen = format(len(extrasizestr), 'x').lower();
1208  catoutlen = len(filevalues) + len(extradata) + 5;
1209  catoutlenhex = format(catoutlen, 'x').lower();
1210  catoutlist = filevalues;
1211  catoutlist.insert(0, catoutlenhex);
1212  catoutlist.append(extrasizelen);
1213  catoutlist.append(extrafields);
1214  catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
1215  if(len(extradata)>0):
1216   catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
1217  catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
1218  catfileheadercshex = GetFileChecksum(catfileoutstr, checksumtype, True, formatspecs);
1219  catfilecontentcshex = GetFileChecksum(filecontent, checksumtype, False, formatspecs);
1220  tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
1221  catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower();
1222  catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
1223  catfileheadercshex = GetFileChecksum(catfileoutstr, checksumtype, True, formatspecs);
1224  catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
1225  catfileoutstrecd = catfileoutstr.encode('UTF-8');
1226  nullstrecd = formatspecs[5].encode('UTF-8');
1227  catfileout = catfileoutstrecd + filecontent + nullstrecd;
1228  fp.write(catfileout);
1229  try:
1230   fp.flush();
1231   os.fsync(fp.fileno());
1232  except io.UnsupportedOperation:
1233   pass;
1234  except AttributeError:
1235   pass;
1236  return fp;
1237
1238 def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], extradata=[], followlink=False, checksumtype="crc32", formatspecs=__file_format_list__, verbose=False):
1239  advancedlist = formatspecs[8];
1240  altinode = formatspecs[9];
1241  if(verbose):
1242   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
1243  if(infiles=="-"):
1244   for line in sys.stdin:
1245    infilelist.append(line.strip());
1246   infilelist = list(filter(None, infilelist));
1247  elif(infiles!="-" and dirlistfromtxt and os.path.exists(infiles) and (os.path.isfile(infiles) or infiles=="/dev/null" or infiles=="NUL")):
1248   if(not os.path.exists(infiles) or not os.path.isfile(infiles)):
1249    return False;
1250   with UncompressFile(infiles, formatspecs, "r") as finfile:
1251    for line in finfile:
1252     infilelist.append(line.strip());
1253   infilelist = list(filter(None, infilelist));
1254  else:
1255   if(isinstance(infiles, (list, tuple, ))):
1256    infilelist = list(filter(None, infiles));
1257   elif(isinstance(infiles, (str, ))):
1258    infilelist = list(filter(None, [infiles]));
1259  if(advancedlist):
1260   GetDirList = ListDirAdvanced(infilelist, followlink, False);
1261  else:
1262   GetDirList = ListDir(infilelist, followlink, False);
1263  if(not GetDirList):
1264   return False;
1265  curinode = 0;
1266  curfid = 0;
1267  inodelist = [];
1268  inodetofile = {};
1269  filetoinode = {};
1270  inodetocatinode = {};
1271  numfiles = int(len(GetDirList));
1272  fnumfiles = format(numfiles, 'x').lower();
1273  AppendFileHeader(fp, fnumfiles, checksumtype, formatspecs);
1274  for curfname in GetDirList:
1275   catfhstart = fp.tell();
1276   if(re.findall("^[.|/]", curfname)):
1277    fname = curfname;
1278   else:
1279    fname = "./"+curfname;
1280   if(verbose):
1281    VerbosePrintOut(fname);
1282   if(not followlink or followlink is None):
1283    fstatinfo = os.lstat(fname);
1284   else:
1285    fstatinfo = os.stat(fname);
1286   fpremode = fstatinfo.st_mode;
1287   finode = fstatinfo.st_ino;
1288   flinkcount = fstatinfo.st_nlink;
1289   ftype = 0;
1290   if(stat.S_ISREG(fpremode)):
1291    ftype = 0;
1292   elif(stat.S_ISLNK(fpremode)):
1293    ftype = 2;
1294   elif(stat.S_ISCHR(fpremode)):
1295    ftype = 3;
1296   elif(stat.S_ISBLK(fpremode)):
1297    ftype = 4;
1298   elif(stat.S_ISDIR(fpremode)):
1299    ftype = 5;
1300   elif(stat.S_ISFIFO(fpremode)):
1301    ftype = 6;
1302   elif(stat.S_ISSOCK(fpremode)):
1303    ftype = 8;
1304   elif(hasattr(stat, "S_ISDOOR") and stat.S_ISDOOR(fpremode)):
1305    ftype = 9;
1306   elif(hasattr(stat, "S_ISPORT") and stat.S_ISPORT(fpremode)):
1307    ftype = 10;
1308   elif(hasattr(stat, "S_ISWHT") and stat.S_ISWHT(fpremode)):
1309    ftype = 111;
1310   else:
1311    ftype = 0;
1312   flinkname = "";
1313   fcurfid = format(int(curfid), 'x').lower();
1314   if(not followlink and finode!=0):
1315    if(ftype!=1):
1316     if(finode in inodelist):
1317      ftype = 1;
1318      flinkname = inodetofile[finode];
1319      if(altinode):
1320       fcurinode = format(int(finode), 'x').lower();
1321      else:
1322       fcurinode = format(int(inodetocatinode[finode]), 'x').lower();
1323     if(finode not in inodelist):
1324      inodelist.append(finode);
1325      inodetofile.update({finode: fname});
1326      inodetocatinode.update({finode: curinode});
1327      if(altinode):
1328       fcurinode = format(int(finode), 'x').lower();
1329      else:
1330       fcurinode = format(int(curinode), 'x').lower();
1331      curinode = curinode + 1;
1332   else:
1333    fcurinode = format(int(curinode), 'x').lower();
1334    curinode = curinode + 1;
1335   curfid = curfid + 1;
1336   if(ftype==2):
1337    flinkname = os.readlink(fname);
1338   fdev = fstatinfo.st_dev;
1339   getfdev = GetDevMajorMinor(fdev);
1340   fdev_minor = getfdev[0];
1341   fdev_major = getfdev[1];
1342   frdev = fstatinfo.st_dev;
1343   if(hasattr(fstatinfo, "st_rdev")):
1344    frdev = fstatinfo.st_rdev;
1345   else:
1346    frdev = fstatinfo.st_dev;
1347   getfrdev = GetDevMajorMinor(frdev);
1348   frdev_minor = getfrdev[0];
1349   frdev_major = getfrdev[1];
1350   if(ftype==1 or ftype==2 or ftype==3 or ftype==4 or ftype==5 or ftype==6):
1351    fsize = format(int("0"), 'x').lower();
1352   elif(ftype==0 or ftype==7):
1353    fsize = format(int(fstatinfo.st_size), 'x').lower();
1354   else:
1355    fsize = format(int(fstatinfo.st_size)).lower();
1356   fatime = format(int(fstatinfo.st_atime), 'x').lower();
1357   fmtime = format(int(fstatinfo.st_mtime), 'x').lower();
1358   fctime = format(int(fstatinfo.st_ctime), 'x').lower();
1359   if(hasattr(fstatinfo, "st_birthtime")):
1360    fbtime = format(int(fstatinfo.st_birthtime), 'x').lower();
1361   else:
1362    fbtime = format(int(fstatinfo.st_ctime), 'x').lower();
1363   fmode = format(int(fstatinfo.st_mode), 'x').lower();
1364   fchmode = format(int(stat.S_IMODE(fstatinfo.st_mode)), 'x').lower();
1365   ftypemod = format(int(stat.S_IFMT(fstatinfo.st_mode)), 'x').lower();
1366   fuid = format(int(fstatinfo.st_uid), 'x').lower();
1367   fgid = format(int(fstatinfo.st_gid), 'x').lower();
1368   funame = "";
1369   try:
1370    import pwd;
1371    try:
1372     userinfo = pwd.getpwuid(fstatinfo.st_uid);
1373     funame = userinfo.pw_name;
1374    except KeyError:
1375     funame = "";
1376   except ImportError:
1377    funame = "";
1378   fgname = "";
1379   try:
1380    import grp;
1381    try:
1382     groupinfo = grp.getgrgid(fstatinfo.st_gid);
1383     fgname = groupinfo.gr_name;
1384    except KeyError:
1385     fgname = "";
1386   except ImportError:
1387    fgname = "";
1388   fdev_minor = format(int(fdev_minor), 'x').lower();
1389   fdev_major = format(int(fdev_major), 'x').lower();
1390   frdev_minor = format(int(frdev_minor), 'x').lower();
1391   frdev_major = format(int(frdev_major), 'x').lower();
1392   finode = format(int(finode), 'x').lower();
1393   flinkcount = format(int(flinkcount), 'x').lower();
1394   if(hasattr(fstatinfo, "st_file_attributes")):
1395    fwinattributes = format(int(fstatinfo.st_file_attributes), 'x').lower();
1396   else:
1397    fwinattributes = format(int(0), 'x').lower();
1398   fcontents = "".encode('UTF-8');
1399   chunk_size = 1024;
1400   if(ftype==0 or ftype==7):
1401    with open(fname, "rb") as fpc:
1402     while(True):
1403      chunk = fpc.read(chunk_size);
1404      if(not chunk):
1405       break
1406      fcontents += chunk;
1407   if(followlink and (ftype==1 or ftype==2)):
1408    flstatinfo = os.stat(flinkname);
1409    with open(flinkname, "rb") as fpc:
1410     while(True):
1411      chunk = fpc.read(chunk_size);
1412      if(not chunk):
1413       break;
1414      fcontents += chunk;
1415   ftypehex = format(ftype, 'x').lower();
1416   catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major];
1417   fp = AppendFileHeaderWithContent(fp, catoutlist, extradata, fcontents, checksumtype, formatspecs);
1418  if(numfiles>0):
1419   catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
1420  fp.seek(0, 0);
1421  return fp;
1422
1423 def AppendListsWithContent(inlist, fp, dirlistfromtxt=False, filevalues=[], extradata=[], followlink=False, checksumtype="crc32", formatspecs=__file_format_list__, verbose=False):
1424  if(verbose):
1425   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
1426  GetDirList = inlist;
1427  if(not GetDirList):
1428   return False;
1429  curinode = 0;
1430  curfid = 0;
1431  inodelist = [];
1432  inodetofile = {};
1433  filetoinode = {};
1434  inodetocatinode = {};
1435  numfiles = int(len(GetDirList));
1436  fnumfiles = format(numfiles, 'x').lower();
1437  AppendFileHeader(fp, fnumfiles, checksumtype, formatspecs);
1438  for curfname in GetDirList:
1439   ftype = format(curfname[0], 'x').lower();
1440   if(re.findall("^[.|/]", curfname[1])):
1441    fname = curfname[1];
1442   else:
1443    fname = "./"+curfname[1];
1444   fbasedir = os.path.dirname(fname);
1445   flinkname = curfname[2];
1446   fsize = format(curfname[3], 'x').lower();
1447   fatime = format(curfname[4], 'x').lower();
1448   fmtime = format(curfname[5], 'x').lower();
1449   fctime = format(curfname[6], 'x').lower();
1450   fbtime = format(curfname[7], 'x').lower();
1451   fmode = format(curfname[8], 'x').lower();
1452   fwinattributes = format(curfname[9], 'x').lower();
1453   fuid = format(curfname[10], 'x').lower();
1454   funame = curfname[11];
1455   fgid = format(curfname[12], 'x').lower();
1456   fgname = curfname[13];
1457   fid = format(curfname[14], 'x').lower();
1458   finode = format(curfname[15], 'x').lower();
1459   flinkcount = format(curfname[16], 'x').lower();
1460   fdev_minor = format(curfname[17], 'x').lower();
1461   fdev_major = format(curfname[18], 'x').lower();
1462   frdev_minor = format(curfname[19], 'x').lower();
1463   frdev_major = format(curfname[20], 'x').lower();
1464   extradata = curfname[21];
1465   fchecksumtype = curfname[22];
1466   fcontents = curfname[23];
1467   catoutlist = [ftype, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fuid, funame, fgid, fgname, fid, finode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major];
1468   fp = AppendFileHeaderWithContent(fp, catoutlist, extradata, fcontents, checksumtype, formatspecs);
1469  if(numfiles>0):
1470   catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
1471  fp.seek(0, 0);
1472  return fp;
1473
1474 def AppendInFileWithContent(infile, fp, dirlistfromtxt=False, filevalues=[], extradata=[], followlink=False, checksumtype="crc32", formatspecs=__file_format_list__, verbose=False):
1475  inlist = ReadInFileBySizeWithContentToList(infile, 0, 0, False, False, formatspecs);
1476  return AppendListsWithContent(inlist, fp, dirlistfromtxt, filevalues, extradata, followlink, checksumtype, formatspecs, verbose);
1477
1478 def AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt=False, compression="auto", compressionlevel=None, filevalues=[], extradata=[], followlink=False, checksumtype="crc32", formatspecs=__file_format_list__, verbose=False, returnfp=False):
1479  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
1480   if(os.path.exists(outfile)):
1481    os.unlink(outfile);
1482  if(outfile=="-"):
1483   verbose = False;
1484   catfpfp = BytesIO();
1485  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
1486   catfp = outfile;
1487  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
1488   catfp = BytesIO();
1489  else:
1490   fbasename = os.path.splitext(outfile)[0];
1491   fextname = os.path.splitext(outfile)[1];
1492   catfp = CompressOpenFile(outfile, compressionlevel);
1493  catfp = AppendFilesWithContent(infiles, catfp, dirlistfromtxt, filevalues, extradata, followlink, checksumtype, formatspecs, verbose);
1494  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
1495   catfp = CompressArchiveFile(catfp, compression, formatspecs);
1496   try:
1497    catfp.flush();
1498    os.fsync(catfp.fileno());
1499   except io.UnsupportedOperation:
1500    pass;
1501   except AttributeError:
1502    pass;
1503  if(outfile=="-"):
1504   catfp.seek(0, 0);
1505   if(hasattr(sys.stdout, "buffer")):
1506    shutil.copyfileobj(catfp, sys.stdout.buffer);
1507   else:
1508    shutil.copyfileobj(catfp, sys.stdout);
1509  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
1510   catfp = CompressArchiveFile(catfp, compression, formatspecs);
1511   catfp.seek(0, 0);
1512   upload_file_to_internet_file(catfp, outfile);
1513  if(returnfp):
1514   catfp.seek(0, 0);
1515   return catfp;
1516  else:
1517   catfp.close();
1518   return True;
1519
1520 def AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt=False, compression="auto", compressionlevel=None, filevalues=[], extradata=[], followlink=False, checksumtype="crc32", formatspecs=__file_format_list__, verbose=False, returnfp=False):
1521  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
1522   if(os.path.exists(outfile)):
1523    os.unlink(outfile);
1524  if(outfile=="-"):
1525   verbose = False;
1526   catfpfp = BytesIO();
1527  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
1528   catfp = outfile;
1529  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
1530   catfp = BytesIO();
1531  else:
1532   fbasename = os.path.splitext(outfile)[0];
1533   fextname = os.path.splitext(outfile)[1];
1534   catfp = CompressOpenFile(outfile, compressionlevel);
1535  catfp = AppendListsWithContent(inlist, catfp, dirlistfromtxt, filevalues, extradata, followlink, checksumtype, formatspecs, verbose);
1536  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
1537   catfp = CompressArchiveFile(catfp, compression, formatspecs);
1538   try:
1539    catfp.flush();
1540    os.fsync(catfp.fileno());
1541   except io.UnsupportedOperation:
1542    pass;
1543   except AttributeError:
1544    pass;
1545  if(outfile=="-"):
1546   catfp.seek(0, 0);
1547   if(hasattr(sys.stdout, "buffer")):
1548    shutil.copyfileobj(catfp, sys.stdout.buffer);
1549   else:
1550    shutil.copyfileobj(catfp, sys.stdout);
1551  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
1552   catfp = CompressArchiveFile(catfp, compression, formatspecs);
1553   catfp.seek(0, 0);
1554   upload_file_to_internet_file(catfp, outfile);
1555  if(returnfp):
1556   catfp.seek(0, 0);
1557   return catfp;
1558  else:
1559   catfp.close();
1560   return True;
1561
1562 def AppendInFileWithContentToOutFile(infile, outfile, dirlistfromtxt=False, compression="auto", compressionlevel=None, filevalues=[], extradata=[], followlink=False, checksumtype="crc32", formatspecs=__file_format_list__, verbose=False, returnfp=False):
1563  inlist = ReadInFileBySizeWithContentToList(infile, 0, 0, False, False, formatspecs);
1564  return AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt, compression, compressionlevel, filevalues, extradata, followlink, checksumtype, formatspecs, verbose, returnfp);
1565
1566 def PrintPermissionString(fchmode, ftype):
1567  permissions = { 'access': { '0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': ('r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx') }, 'roles': { 0: 'owner', 1: 'group', 2: 'other' } };
1568  permissionstr = "";
1569  for fmodval in str(oct(fchmode))[-3:]:
1570   permissionstr = permissionstr + permissions['access'].get(fmodval, '---');
1571  if(ftype==0 or ftype==7):
1572   permissionstr = "-" + permissionstr;
1573  if(ftype==1):
1574   permissionstr = "h" + permissionstr;
1575  if(ftype==2):
1576   permissionstr = "l" + permissionstr;
1577  if(ftype==3):
1578   permissionstr = "c" + permissionstr;
1579  if(ftype==4):
1580   permissionstr = "b" + permissionstr;
1581  if(ftype==5):
1582   permissionstr = "d" + permissionstr;
1583  if(ftype==6):
1584   permissionstr = "f" + permissionstr;
1585  if(ftype==8):
1586   permissionstr = "D" + permissionstr;
1587  if(ftype==9):
1588   permissionstr = "p" + permissionstr;
1589  if(ftype==10):
1590   permissionstr = "w" + permissionstr;
1591  try:
1592   permissionoutstr = stat.filemode(fchmode);
1593  except AttributeError:
1594   permissionoutstr = permissionstr;
1595  except KeyError:
1596   permissionoutstr = permissionstr;
1597  return permissionoutstr;
1598
1599 def PrintPermissionStringAlt(fchmode, ftype):
1600  permissions = {
1601   '0': '---', '1': '--x', '2': '-w-', '3': '-wx',
1602   '4': 'r--', '5': 'r-x', '6': 'rw-', '7': 'rwx'
1603  };
1604  # Translate file mode into permission string
1605  permissionstr = ''.join([permissions[i] for i in str(oct(fchmode))[-3:]]);
1606  # Append file type indicator
1607  type_indicators = {
1608   0: '-', 1: 'h', 2: 'l', 3: 'c', 4: 'b',
1609   5: 'd', 6: 'f', 8: 'D', 9: 'p', 10: 'w'
1610  };
1611  file_type = type_indicators.get(ftype, '-');
1612  permissionstr = file_type + permissionstr;
1613  try:
1614   permissionoutstr = stat.filemode(fchmode);
1615  except AttributeError:
1616   permissionoutstr = permissionstr;
1617  return permissionoutstr;
1618
1619 def CompressionSupport():
1620  compression_list = [];
1621  try:
1622   import gzip;
1623   compression_list.append("gz");
1624   compression_list.append("gzip");
1625  except ImportError:
1626   '''return False;'''
1627  try:
1628   import bz2;
1629   compression_list.append("bz2");
1630   compression_list.append("bzip2");
1631  except ImportError:
1632   '''return False;'''
1633  try:
1634   import lz4;
1635   compression_list.append("lz4");
1636  except ImportError:
1637   '''return False;'''
1638  try:
1639   import lzo;
1640   compression_list.append("lzo");
1641   compression_list.append("lzop");
1642  except ImportError:
1643   '''return False;'''
1644  try:
1645   import zstandard;
1646   compression_list.append("zstd");
1647   compression_list.append("zstandard");
1648  except ImportError:
1649   '''return False;'''
1650  try:
1651   import lzma;
1652   compression_list.append("lzma");
1653   compression_list.append("xz");
1654  except ImportError:
1655   '''return False;'''
1656  return compression_list;
1657
1658 def CheckCompressionType(infile, formatspecs=__file_format_list__, closefp=True):
1659  if(hasattr(infile, "read") or hasattr(infile, "write")):
1660   catfp = infile;
1661  else:
1662   try:
1663    catfp = open(infile, "rb");
1664   except FileNotFoundError:
1665    return False;
1666  catfp.seek(0, 0);
1667  prefp = catfp.read(2);
1668  filetype = False;
1669  if(prefp==binascii.unhexlify("1f8b")):
1670   filetype = "gzip";
1671  catfp.seek(0, 0);
1672  prefp = catfp.read(3);
1673  if(prefp==binascii.unhexlify("425a68")):
1674   filetype = "bzip2";
1675  if(prefp==binascii.unhexlify("5d0000")):
1676   filetype = "lzma";
1677  catfp.seek(0, 0);
1678  prefp = catfp.read(4);
1679  if(prefp==binascii.unhexlify("28b52ffd")):
1680   filetype = "zstd";
1681  if(prefp==binascii.unhexlify("04224d18")):
1682   filetype = "lz4";
1683  if(prefp==binascii.unhexlify("504B0304")):
1684   filetype = "zipfile";
1685  catfp.seek(0, 0);
1686  prefp = catfp.read(5);
1687  if(prefp==binascii.unhexlify("7573746172")):
1688   filetype = "tarfile";
1689  catfp.seek(0, 0);
1690  prefp = catfp.read(6);
1691  if(prefp==binascii.unhexlify("fd377a585a00")):
1692   filetype = "lzma";
1693  if(prefp==binascii.unhexlify("377abcaf271c")):
1694   filetype = "7zipfile";
1695  catfp.seek(0, 0);
1696  prefp = catfp.read(7);
1697  if(prefp==binascii.unhexlify("526172211a0700")):
1698   filetype = "rarfile";
1699  if(prefp==binascii.unhexlify("43617446696c65")):
1700   filetype = "catfile";
1701  catfp.seek(0, 0);
1702  prefp = catfp.read(8);
1703  if(prefp==binascii.unhexlify("526172211a070100")):
1704   filetype = "rarfile";
1705  catfp.seek(0, 0);
1706  prefp = catfp.read(formatspecs[3]);
1707  if(prefp==binascii.unhexlify(formatspecs[4])):
1708   filetype = formatspecs[2];
1709  catfp.seek(0, 0);
1710  prefp = catfp.read(9);
1711  if(prefp==binascii.unhexlify("894c5a4f000d0a1a0a")):
1712   filetype = "lzo";
1713  catfp.seek(0, 0);
1714  prefp = catfp.read(10);
1715  if(prefp==binascii.unhexlify("7061785f676c6f62616c")):
1716   filetype = "tarfile";
1717  catfp.seek(0, 0);
1718  if(closefp):
1719   catfp.close();
1720  return filetype;
1721
1722 def CheckCompressionTypeFromString(instring, formatspecs=__file_format_list__, closefp=True):
1723  try:
1724   instringsfile = BytesIO(instring);
1725  except TypeError:
1726   instringsfile = BytesIO(instring.encode("UTF-8"));
1727  return CheckCompressionType(instringsfile, formatspecs, closefp);
1728
1729 def GetCompressionMimeType(infile, formatspecs=__file_format_list__):
1730  compresscheck = CheckCompressionType(fp, formatspecs, False);
1731  if(compresscheck=="gzip" or compresscheck=="gz"):
1732   return archivefile_gzip_mimetype;
1733  if(compresscheck=="bzip2" or compresscheck=="bz2"):
1734   return archivefile_bzip2_mimetype;
1735  if(compresscheck=="zstd" or compresscheck=="zstandard"):
1736   return archivefile_zstandard_mimetype;
1737  if(compresscheck=="lz4"):
1738   return archivefile_lz4_mimetype;
1739  if(compresscheck=="lzo" or compresscheck=="lzop"):
1740   return archivefile_lzop_mimetype;
1741  if(compresscheck=="lzma"):
1742   return archivefile_lzma_mimetype;
1743  if(compresscheck=="xz"):
1744   return archivefile_xz_mimetype;
1745  if(compresscheck=="catfile" or compresscheck=="cat" or compresscheck==formatspecs[2]):
1746   return archivefile_cat_mimetype;
1747  if(not compresscheck):
1748   return False;
1749  return False;
1750
1751 def UncompressArchiveFile(fp, formatspecs=__file_format_list__):
1752  if(not hasattr(fp, "read") and not hasattr(fp, "write")):
1753   return False;
1754  compresscheck = CheckCompressionType(fp, formatspecs, False);
1755  if(compresscheck=="gzip"):
1756   try:
1757    import gzip;
1758   except ImportError:
1759    return False;
1760   catfp = gzip.GzipFile(fileobj=fp, mode="rb");
1761  if(compresscheck=="bzip2"):
1762   try:
1763    import bz2;
1764   except ImportError:
1765    return False;
1766   catfp = BytesIO();
1767   catfp.write(bz2.decompress(fp.read()));
1768  if(compresscheck=="zstd"):
1769   try:
1770    import zstandard;
1771   except ImportError:
1772    return False;
1773   catfp = BytesIO();
1774   catfp.write(zstandard.decompress(fp.read()));
1775  if(compresscheck=="lz4"):
1776   try:
1777    import lz4.frame;
1778   except ImportError:
1779    return False;
1780   catfp = BytesIO();
1781   catfp.write(lz4.frame.decompress(fp.read()));
1782  if(compresscheck=="lzo" or compresscheck=="lzop"):
1783   try:
1784    import lzo;
1785   except ImportError:
1786    return False;
1787   catfp = BytesIO();
1788   catfp.write(lzo.decompress(fp.read()));
1789  if(compresscheck=="lzma" or compresscheck=="xz"):
1790   try:
1791    import lzma;
1792   except ImportError:
1793    return False;
1794   catfp = BytesIO();
1795   catfp.write(lzma.decompress(fp.read()));
1796  if(compresscheck=="catfile" or compresscheck==formatspecs[2]):
1797   catfp = fp;
1798  if(not compresscheck):
1799   try:
1800    import lzma;
1801   except ImportError:
1802    return False;
1803   catfp = BytesIO();
1804   with fp as fpcontent:
1805    try:
1806     catfp.write(lzma.decompress(fp.read()));
1807    except lzma.LZMAError:
1808     return False;
1809  return catfp;
1810
1811 create_alias_function("Uncompress", __file_format_name__, "", UncompressArchiveFile);
1812
1813 def UncompressFile(infile, formatspecs=__file_format_list__, mode="rb"):
1814  compresscheck = CheckCompressionType(infile, formatspecs, False);
1815  if(sys.version_info[0]==2 and compresscheck):
1816   if(mode=="rt"):
1817    mode = "r";
1818   if(mode=="wt"):
1819    mode = "w";
1820  try:
1821   if(compresscheck=="gzip"):
1822    try:
1823     import gzip;
1824    except ImportError:
1825     return False;
1826    try:
1827     filefp = gzip.open(infile, mode, encoding="UTF-8");
1828    except (ValueError, TypeError) as e:
1829     filefp = gzip.open(infile, mode);
1830   if(compresscheck=="bzip2"):
1831    try:
1832     import bz2;
1833    except ImportError:
1834     return False;
1835    try:
1836     filefp = bz2.open(infile, mode, encoding="UTF-8");
1837    except (ValueError, TypeError) as e:
1838     filefp = bz2.open(infile, mode);
1839   if(compresscheck=="zstd"):
1840    try:
1841     import zstandard;
1842    except ImportError:
1843     return False;
1844    try:
1845     filefp = zstandard.open(infile, mode, encoding="UTF-8");
1846    except (ValueError, TypeError) as e:
1847     filefp = zstandard.open(infile, mode);
1848   if(compresscheck=="lz4"):
1849    try:
1850     import lz4.frame;
1851    except ImportError:
1852     return False;
1853    try:
1854     filefp = lz4.frame.open(infile, mode, encoding="UTF-8");
1855    except (ValueError, TypeError) as e:
1856     filefp = lz4.frame.open(infile, mode);
1857   if(compresscheck=="lzo"):
1858    try:
1859     import lzo;
1860    except ImportError:
1861     return False;
1862    try:
1863     filefp = lzo.open(infile, mode, encoding="UTF-8");
1864    except (ValueError, TypeError) as e:
1865     filefp = lzo.open(infile, mode);
1866   if(compresscheck=="lzma"):
1867    try:
1868     import lzma;
1869    except ImportError:
1870     return False;
1871    try:
1872     filefp = lzma.open(infile, mode, encoding="UTF-8");
1873    except (ValueError, TypeError) as e:
1874     filefp = lzma.open(infile, mode);
1875   if(compresscheck=="catfile" or compresscheck==formatspecs[2]):
1876    try:
1877     filefp = open(infile, mode, encoding="UTF-8");
1878    except (ValueError, TypeError) as e:
1879     filefp = open(infile, mode);
1880   if(not compresscheck):
1881    try:
1882     filefp = open(infile, mode, encoding="UTF-8");
1883    except (ValueError, TypeError) as e:
1884     filefp = open(infile, mode);
1885  except FileNotFoundError:
1886   return False;
1887  return filefp;
1888
1889 def UncompressString(infile):
1890  compresscheck = CheckCompressionTypeFromString(infile, formatspecs, False);
1891  if(compresscheck=="gzip"):
1892   try:
1893    import gzip;
1894   except ImportError:
1895    return False;
1896   fileuz = gzip.decompress(infile);
1897  if(compresscheck=="bzip2"):
1898   try:
1899    import bz2;
1900   except ImportError:
1901    return False;
1902   fileuz = bz2.decompress(infile);
1903  if(compresscheck=="zstd"):
1904   try:
1905    import zstandard;
1906   except ImportError:
1907    return False;
1908   fileuz = zstandard.decompress(infile);
1909  if(compresscheck=="lz4"):
1910   try:
1911    import lz4.frame;
1912   except ImportError:
1913    return False;
1914   fileuz = lz4.frame.decompress(infile);
1915  if(compresscheck=="lzo"):
1916   try:
1917    import lzo;
1918   except ImportError:
1919    return False;
1920   fileuz = lzo.decompress(infile);
1921  if(compresscheck=="lzma"):
1922   try:
1923    import lzma;
1924   except ImportError:
1925    return False;
1926   fileuz = lzma.decompress(infile);
1927  if(not compresscheck):
1928   fileuz = infile;
1929  if(hasattr(fileuz, 'decode')):
1930   fileuz = fileuz.decode("UTF-8");
1931  return fileuz;
1932
1933 def UncompressStringAlt(infile):
1934  filefp = StringIO();
1935  outstring = UncompressString(infile);
1936  filefp.write(outstring);
1937  filefp.seek(0, 0);
1938  return filefp;
1939
1940 def CheckCompressionSubType(infile, formatspecs=__file_format_list__, closefp=True):
1941  compresscheck = CheckCompressionType(infile, formatspecs, False);
1942  if(not compresscheck):
1943   fextname = os.path.splitext(infile)[1];
1944   if(fextname==".gz"):
1945    compresscheck = "gzip";
1946   elif(fextname==".bz2"):
1947    compresscheck = "bzip2";
1948   elif(fextname==".zst"):
1949    compresscheck = "zstd";
1950   elif(fextname==".lz4"):
1951    compresscheck = "lz4";
1952   elif(fextname==".lzo" or fextname==".lzop"):
1953    compresscheck = "lzo";
1954   elif(fextname==".lzma" or fextname==".xz"):
1955    compresscheck = "lzma";
1956   else:
1957    return False;
1958  if(not compresscheck):
1959   return False;
1960  if(compresscheck=="catfile"):
1961   return "catfile";
1962  if(compresscheck==formatspecs[2]):
1963   return formatspecs[2];
1964  if(compresscheck=="tarfile"):
1965   return "tarfile";
1966  if(compresscheck=="zipfile"):
1967   return "zipfile";
1968  if(rarfile_support and compresscheck=="rarfile"):
1969   return "rarfile";
1970  if(py7zr_support and compresscheck=="7zipfile"):
1971   return "7zipfile";
1972  if(hasattr(infile, "read") or hasattr(infile, "write")):
1973   catfp = UncompressArchiveFile(infile, formatspecs[2]);
1974  else:
1975   try:
1976    if(compresscheck=="gzip"):
1977     try:
1978      import gzip;
1979     except ImportError:
1980      return False;
1981     catfp = gzip.GzipFile(infile, "rb");
1982    if(compresscheck=="bzip2"):
1983     try:
1984      import bz2;
1985     except ImportError:
1986      return False;
1987     catfp = bz2.BZ2File(infile, "rb");
1988    if(compresscheck=="lz4"):
1989     try:
1990      import lz4.frame;
1991     except ImportError:
1992      return False;
1993     catfp = lz4.frame.open(infile, "rb");
1994    if(compresscheck=="zstd"):
1995     try:
1996      import zstandard;
1997     except ImportError:
1998      return False;
1999     catfp = zstandard.open(infile, "rb");
2000    if(compresscheck=="lzma" or compresscheck=="xz"):
2001     try:
2002      import lzma;
2003     except ImportError:
2004      return False;
2005     catfp = lzma.open(infile, "rb");
2006   except FileNotFoundError:
2007    return False;
2008  filetype = False;
2009  prefp = catfp.read(5);
2010  if(prefp==binascii.unhexlify("7573746172")):
2011   filetype = "tarfile";
2012  catfp.seek(0, 0);
2013  prefp = catfp.read(7);
2014  if(prefp==binascii.unhexlify("43617446696c65")):
2015   filetype = "catfile";
2016  catfp.seek(0, 0);
2017  prefp = catfp.read(formatspecs[3]);
2018  if(prefp==binascii.unhexlify(formatspecs[4])):
2019   filetype = formatspecs[2];
2020  catfp.seek(0, 0);
2021  prefp = catfp.read(10);
2022  if(prefp==binascii.unhexlify("7061785f676c6f62616c")):
2023   filetype = "tarfile";
2024  catfp.seek(0, 0);
2025  if(closefp):
2026   catfp.close();
2027  return filetype;
2028
2029 def GZipCompress(data, compresslevel=9):
2030  try:
2031   import gzip;
2032  except ImportError:
2033   return False;
2034  tmpfp = tempfile.NamedTemporaryFile("wb", delete=False);
2035  tmpfp.close();
2036  tmpfp = gzip.GzipFile(tmpfp.name, mode="wb", compresslevel=compresslevel);
2037  tmpfp.write(data);
2038  tmpfp.close();
2039  try:
2040   catfp = open(tmpfp.name, "rb");
2041  except FileNotFoundError:
2042   return False;
2043  catdata = catfp.read();
2044  catfp.close();
2045  return catdata;
2046
2047 def CompressArchiveFile(fp, compression="auto", compressionlevel=None, formatspecs=__file_format_list__):
2048  if(not hasattr(fp, "read") and not hasattr(fp, "write")):
2049   return False;
2050  fp.seek(0, 0);
2051  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
2052   compression = None;
2053  if(compression not in compressionlist and compression is None):
2054   compression = "auto";
2055  if(compression=="gzip"):
2056   try:
2057    import gzip;
2058   except ImportError:
2059    return False;
2060   catfp = BytesIO();
2061   if(compressionlevel is None):
2062    compressionlevel = 9;
2063   else:
2064    compressionlevel = int(compressionlevel);
2065   catfp.write(gzip.compress(fp.read(), compresslevel=compressionlevel));
2066  if(compression=="bzip2"):
2067   try:
2068    import bz2;
2069   except ImportError:
2070    return False;
2071   catfp = BytesIO();
2072   if(compressionlevel is None):
2073    compressionlevel = 9;
2074   else:
2075    compressionlevel = int(compressionlevel);
2076   catfp.write(bz2.compress(fp.read(), compresslevel=compressionlevel));
2077  if(compression=="lz4"):
2078   try:
2079    import lz4.frame;
2080   except ImportError:
2081    return False;
2082   catfp = BytesIO();
2083   if(compressionlevel is None):
2084    compressionlevel = 9;
2085   else:
2086    compressionlevel = int(compressionlevel);
2087   catfp.write(lz4.frame.compress(fp.read(), compression_level=compressionlevel));
2088  if(compression=="lzo" or compression=="lzop"):
2089   try:
2090    import lzo;
2091   except ImportError:
2092    return False;
2093   catfp = BytesIO();
2094   if(compressionlevel is None):
2095    compressionlevel = 9;
2096   else:
2097    compressionlevel = int(compressionlevel);
2098   catfp.write(lzo.compress(fp.read(), compresslevel=compressionlevel));
2099  if(compression=="zstd"):
2100   try:
2101    import zstandard;
2102   except ImportError:
2103    return False;
2104   catfp = BytesIO();
2105   if(compressionlevel is None):
2106    compressionlevel = 10;
2107   else:
2108    compressionlevel = int(compressionlevel);
2109   catfp.write(zstandard.compress(fp.read(), level=compressionlevel));
2110  if(compression=="lzma"):
2111   try:
2112    import lzma;
2113   except ImportError:
2114    return False;
2115   catfp = BytesIO();
2116   if(compressionlevel is None):
2117    compressionlevel = 9;
2118   else:
2119    compressionlevel = int(compressionlevel);
2120   catfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_ALONE, filters=[{"id": lzma.FILTER_LZMA1, "preset": compressionlevel}]));
2121  if(compression=="xz"):
2122   try:
2123    import lzma;
2124   except ImportError:
2125    return False;
2126   catfp = BytesIO();
2127   if(compressionlevel is None):
2128    compressionlevel = 9;
2129   else:
2130    compressionlevel = int(compressionlevel);
2131   catfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_XZ, filters=[{"id": lzma.FILTER_LZMA2, "preset": compressionlevel}]));
2132  if(compression=="auto" or compression is None):
2133   catfp = fp;
2134  catfp.seek(0, 0);
2135  return catfp;
2136
2137 create_alias_function("Compress", __file_format_name__, "", CompressArchiveFile);
2138
2139 def CompressOpenFile(outfile, compressionlevel=None):
2140  if(outfile is None):
2141   return False;
2142  fbasename = os.path.splitext(outfile)[0];
2143  fextname = os.path.splitext(outfile)[1];
2144  if(compressionlevel is None and fextname!=".zst"):
2145   compressionlevel = 9;
2146  elif(compressionlevel is None and fextname==".zst"):
2147   compressionlevel = 10;
2148  else:
2149   compressionlevel = int(compressionlevel);
2150  if(sys.version_info[0]==2):
2151   mode = "w";
2152  else:
2153   mode = "wb";
2154  try:
2155   if(fextname not in outextlistwd):
2156    try:
2157     outfp = open(outfile, "wb", encoding="UTF-8");
2158    except (ValueError, TypeError) as e:
2159     outfp = open(outfile, "wb");
2160   elif(fextname==".gz"):
2161    try:
2162     import gzip;
2163    except ImportError:
2164     return False;
2165    try:
2166     outfp = gzip.open(outfile, mode, compressionlevel, encoding="UTF-8");
2167    except (ValueError, TypeError) as e:
2168     outfp = gzip.open(outfile, mode, compressionlevel);
2169   elif(fextname==".bz2"):
2170    try:
2171     import bz2;
2172    except ImportError:
2173     return False;
2174    try:
2175     outfp = bz2.open(outfile, mode, compressionlevel, encoding="UTF-8");
2176    except (ValueError, TypeError) as e:
2177     outfp = bz2.open(outfile, mode, compressionlevel);
2178   elif(fextname==".zst"):
2179    try:
2180     import zstandard;
2181    except ImportError:
2182     return False;
2183    try:
2184     outfp = zstandard.open(outfile, mode, zstandard.ZstdCompressor(level=compressionlevel), encoding="UTF-8");
2185    except (ValueError, TypeError) as e:
2186     outfp = zstandard.open(outfile, mode, zstandard.ZstdCompressor(level=compressionlevel));
2187   elif(fextname==".xz"):
2188    try:
2189     import lzma;
2190    except ImportError:
2191     return False;
2192    try:
2193     outfp = lzma.open(outfile, mode, format=lzma.FORMAT_XZ, filters=[{"id": lzma.FILTER_LZMA2, "preset": compressionlevel}], encoding="UTF-8");
2194    except (ValueError, TypeError) as e:
2195     outfp = lzma.open(outfile, mode, format=lzma.FORMAT_XZ, filters=[{"id": lzma.FILTER_LZMA2, "preset": compressionlevel}]);
2196   elif(fextname==".lz4"):
2197    try:
2198     import lz4.frame;
2199    except ImportError:
2200     return False;
2201    try:
2202     outfp = lz4.frame.open(outfile, mode, compression_level=compressionlevel, encoding="UTF-8");
2203    except (ValueError, TypeError) as e:
2204     outfp = lz4.frame.open(outfile, mode, compression_level=compressionlevel);
2205   elif(fextname==".lzo"):
2206    try:
2207     import lzo;
2208    except ImportError:
2209     return False;
2210    try:
2211     outfp = lzo.open(outfile, mode, compresslevel=compressionlevel, encoding="UTF-8");
2212    except (ValueError, TypeError) as e:
2213     outfp = lzo.open(outfile, mode, compresslevel=compressionlevel);
2214   elif(fextname==".lzma"):
2215    try:
2216     import lzma;
2217    except ImportError:
2218     return False;
2219    try:
2220     outfp = lzma.open(outfile, mode, format=lzma.FORMAT_ALONE, filters=[{"id": lzma.FILTER_LZMA1, "preset": compressionlevel}], encoding="UTF-8");
2221    except (ValueError, TypeError) as e:
2222     outfp = lzma.open(outfile, mode, format=lzma.FORMAT_ALONE, filters=[{"id": lzma.FILTER_LZMA1, "preset": compressionlevel}]);
2223  except FileNotFoundError:
2224   return False;
2225  return outfp;
2226
2227 def GetDevMajorMinor(fdev):
2228  retdev = [];
2229  if(hasattr(os, "minor")):
2230   retdev.append(os.minor(fdev));
2231  else:
2232   retdev.append(0);
2233  if(hasattr(os, "major")):
2234   retdev.append(os.major(fdev));
2235  else:
2236   retdev.append(0);
2237  return retdev;
2238
2239 def CheckSumSupport(checkfor, guaranteed=True):
2240  if(guaranteed):
2241   hash_list = sorted(list(hashlib.algorithms_guaranteed));
2242  else:
2243   hash_list = sorted(list(hashlib.algorithms_available));
2244  checklistout = sorted(hash_list + ['adler32', 'crc16', 'crc16_ansi', 'crc16_ibm', 'crc16_ccitt', 'crc32', 'crc64', 'crc64_ecma', 'crc64_iso', 'none']);
2245  if(checkfor in checklistout):
2246   return True;
2247  else:
2248   return False;
2249
2250 def CheckSumSupportAlt(checkfor, guaranteed=True):
2251  if(guaranteed):
2252   hash_list = sorted(list(hashlib.algorithms_guaranteed));
2253  else:
2254   hash_list = sorted(list(hashlib.algorithms_available));
2255  checklistout = hash_list;
2256  if(checkfor in checklistout):
2257   return True;
2258  else:
2259   return False;
2260
2261 def PackArchiveFile(infiles, outfile, dirlistfromtxt=False, compression="auto", compressionlevel=None, followlink=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
2262  advancedlist = formatspecs[8];
2263  altinode = formatspecs[9];
2264  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2265   outfile = RemoveWindowsPath(outfile);
2266  checksumtype = checksumtype.lower();
2267  if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
2268   checksumtype="crc32";
2269  if(checksumtype=="none"):
2270   checksumtype = "";
2271  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
2272   compression = None;
2273  if(compression not in compressionlist and compression is None):
2274   compression = "auto";
2275  if(verbose):
2276   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
2277  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2278   if(os.path.exists(outfile)):
2279    os.unlink(outfile);
2280  if(outfile=="-"):
2281   verbose = False;
2282   catfp = BytesIO();
2283  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
2284   catfp = outfile;
2285  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
2286   catfp = BytesIO();
2287  else:
2288   fbasename = os.path.splitext(outfile)[0];
2289   fextname = os.path.splitext(outfile)[1];
2290   catfp = CompressOpenFile(outfile, compressionlevel);
2291  catver = formatspecs[6];
2292  fileheaderver = str(int(catver.replace(".", "")));
2293  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
2294  catfp.write(fileheader.encode('UTF-8'));
2295  infilelist = [];
2296  if(infiles=="-"):
2297   for line in sys.stdin:
2298    infilelist.append(line.strip());
2299   infilelist = list(filter(None, infilelist));
2300  elif(infiles!="-" and dirlistfromtxt and os.path.exists(infiles) and (os.path.isfile(infiles) or infiles=="/dev/null" or infiles=="NUL")):
2301   if(not os.path.exists(infiles) or not os.path.isfile(infiles)):
2302    return False;
2303   with UncompressFile(infiles, formatspecs, "r") as finfile:
2304    for line in finfile:
2305     infilelist.append(line.strip());
2306   infilelist = list(filter(None, infilelist));
2307  else:
2308   if(isinstance(infiles, (list, tuple, ))):
2309    infilelist = list(filter(None, infiles));
2310   elif(isinstance(infiles, (str, ))):
2311    infilelist = list(filter(None, [infiles]));
2312  if(advancedlist):
2313   GetDirList = ListDirAdvanced(infilelist, followlink, False);
2314  else:
2315   GetDirList = ListDir(infilelist, followlink, False);
2316  if(not GetDirList):
2317   return False;
2318  curinode = 0;
2319  curfid = 0;
2320  inodelist = [];
2321  inodetofile = {};
2322  filetoinode = {};
2323  inodetocatinode = {};
2324  numfiles = int(len(GetDirList));
2325  fnumfiles = format(int(len(GetDirList)), 'x').lower();
2326  fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
2327  if(checksumtype=="none" or checksumtype==""):
2328   catfileheadercshex = format(0, 'x').lower();
2329  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2330   catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2331  elif(checksumtype=="crc16_ccitt"):
2332   catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2333  elif(checksumtype=="adler32"):
2334   catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2335  elif(checksumtype=="crc32"):
2336   catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2337  elif(checksumtype=="crc64_ecma"):
2338   catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2339  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2340   catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2341  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2342   checksumoutstr = hashlib.new(checksumtype);
2343   checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
2344   catfileheadercshex = checksumoutstr.hexdigest().lower();
2345  else:
2346   catfileheadercshex = format(0, 'x').lower
2347  fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
2348  catfp.write(fnumfilesa.encode('UTF-8'));
2349  try:
2350   catfp.flush();
2351   os.fsync(catfp.fileno());
2352  except io.UnsupportedOperation:
2353   pass;
2354  except AttributeError:
2355   pass;
2356  for curfname in GetDirList:
2357   catfhstart = catfp.tell();
2358   if(re.findall("^[.|/]", curfname)):
2359    fname = curfname;
2360   else:
2361    fname = "./"+curfname;
2362   if(verbose):
2363    VerbosePrintOut(fname);
2364   if(not followlink or followlink is None):
2365    fstatinfo = os.lstat(fname);
2366   else:
2367    fstatinfo = os.stat(fname);
2368   fpremode = fstatinfo.st_mode;
2369   finode = fstatinfo.st_ino;
2370   flinkcount = fstatinfo.st_nlink;
2371   ftype = 0;
2372   if(stat.S_ISREG(fpremode)):
2373    ftype = 0;
2374   elif(stat.S_ISLNK(fpremode)):
2375    ftype = 2;
2376   elif(stat.S_ISCHR(fpremode)):
2377    ftype = 3;
2378   elif(stat.S_ISBLK(fpremode)):
2379    ftype = 4;
2380   elif(stat.S_ISDIR(fpremode)):
2381    ftype = 5;
2382   elif(stat.S_ISFIFO(fpremode)):
2383    ftype = 6;
2384   elif(stat.S_ISSOCK(fpremode)):
2385    ftype = 8;
2386   elif(hasattr(stat, "S_ISDOOR") and stat.S_ISDOOR(fpremode)):
2387    ftype = 9;
2388   elif(hasattr(stat, "S_ISPORT") and stat.S_ISPORT(fpremode)):
2389    ftype = 10;
2390   elif(hasattr(stat, "S_ISWHT") and stat.S_ISWHT(fpremode)):
2391    ftype = 111;
2392   else:
2393    ftype = 0;
2394   flinkname = "";
2395   fcurfid = format(int(curfid), 'x').lower();
2396   if(not followlink and finode!=0):
2397    if(ftype!=1):
2398     if(finode in inodelist):
2399      ftype = 1;
2400      flinkname = inodetofile[finode];
2401      if(altinode):
2402       fcurinode = format(int(finode), 'x').lower();
2403      else:
2404       fcurinode = format(int(inodetocatinode[finode]), 'x').lower();
2405     if(finode not in inodelist):
2406      inodelist.append(finode);
2407      inodetofile.update({finode: fname});
2408      inodetocatinode.update({finode: curinode});
2409      if(altinode):
2410       fcurinode = format(int(finode), 'x').lower();
2411      else:
2412       fcurinode = format(int(curinode), 'x').lower();
2413      curinode = curinode + 1;
2414   else:
2415    fcurinode = format(int(curinode), 'x').lower();
2416    curinode = curinode + 1;
2417   curfid = curfid + 1;
2418   if(ftype==2):
2419    flinkname = os.readlink(fname);
2420   fdev = fstatinfo.st_dev;
2421   getfdev = GetDevMajorMinor(fdev);
2422   fdev_minor = getfdev[0];
2423   fdev_major = getfdev[1];
2424   frdev = fstatinfo.st_dev;
2425   if(hasattr(fstatinfo, "st_rdev")):
2426    frdev = fstatinfo.st_rdev;
2427   else:
2428    frdev = fstatinfo.st_dev;
2429   getfrdev = GetDevMajorMinor(frdev);
2430   frdev_minor = getfrdev[0];
2431   frdev_major = getfrdev[1];
2432   if(ftype==1 or ftype==2 or ftype==3 or ftype==4 or ftype==5 or ftype==6):
2433    fsize = format(int("0"), 'x').lower();
2434   elif(ftype==0 or ftype==7):
2435    fsize = format(int(fstatinfo.st_size), 'x').lower();
2436   else:
2437    fsize = format(int(fstatinfo.st_size)).lower();
2438   fatime = format(int(fstatinfo.st_atime), 'x').lower();
2439   fmtime = format(int(fstatinfo.st_mtime), 'x').lower();
2440   fctime = format(int(fstatinfo.st_ctime), 'x').lower();
2441   if(hasattr(fstatinfo, "st_birthtime")):
2442    fbtime = format(int(fstatinfo.st_birthtime), 'x').lower();
2443   else:
2444    fbtime = format(int(fstatinfo.st_ctime), 'x').lower();
2445   fmode = format(int(fstatinfo.st_mode), 'x').lower();
2446   fchmode = format(int(stat.S_IMODE(fstatinfo.st_mode)), 'x').lower();
2447   ftypemod = format(int(stat.S_IFMT(fstatinfo.st_mode)), 'x').lower();
2448   fuid = format(int(fstatinfo.st_uid), 'x').lower();
2449   fgid = format(int(fstatinfo.st_gid), 'x').lower();
2450   funame = "";
2451   try:
2452    import pwd;
2453    try:
2454     userinfo = pwd.getpwuid(fstatinfo.st_uid);
2455     funame = userinfo.pw_name;
2456    except KeyError:
2457     funame = "";
2458   except ImportError:
2459    funame = "";
2460   fgname = "";
2461   try:
2462    import grp;
2463    try:
2464     groupinfo = grp.getgrgid(fstatinfo.st_gid);
2465     fgname = groupinfo.gr_name;
2466    except KeyError:
2467     fgname = "";
2468   except ImportError:
2469    fgname = "";
2470   fdev_minor = format(int(fdev_minor), 'x').lower();
2471   fdev_major = format(int(fdev_major), 'x').lower();
2472   frdev_minor = format(int(frdev_minor), 'x').lower();
2473   frdev_major = format(int(frdev_major), 'x').lower();
2474   finode = format(int(finode), 'x').lower();
2475   flinkcount = format(int(flinkcount), 'x').lower();
2476   if(hasattr(fstatinfo, "st_file_attributes")):
2477    fwinattributes = format(int(fstatinfo.st_file_attributes), 'x').lower();
2478   else:
2479    fwinattributes = format(int(0), 'x').lower();
2480   fcontents = "".encode('UTF-8');
2481   chunk_size = 1024;
2482   if(ftype==0 or ftype==7):
2483    with open(fname, "rb") as fpc:
2484     while(True):
2485      chunk = fpc.read(chunk_size);
2486      if(not chunk):
2487       break
2488      fcontents += chunk;
2489   if(followlink and (ftype==1 or ftype==2)):
2490    flstatinfo = os.stat(flinkname);
2491    with open(flinkname, "rb") as fpc:
2492     while(True):
2493      chunk = fpc.read(chunk_size);
2494      if(not chunk):
2495       break;
2496      fcontents += chunk;
2497   ftypehex = format(ftype, 'x').lower();
2498   extrafields = format(len(extradata), 'x').lower();
2499   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
2500   if(len(extradata)>0):
2501    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
2502   extrasizelen = format(len(extrasizestr), 'x').lower();
2503   catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrasizelen, extrafields];
2504   catoutlen = len(catoutlist) + len(extradata) + 3;
2505   catoutlenhex = format(catoutlen, 'x').lower();
2506   catoutlist.insert(0, catoutlenhex);
2507   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
2508   if(len(extradata)>0):
2509    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
2510   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
2511   if(checksumtype=="none" or checksumtype==""):
2512    catfileheadercshex = format(0, 'x').lower();
2513    catfilecontentcshex = format(0, 'x').lower();
2514   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2515    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
2516    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
2517   elif(checksumtype=="crc16_ccitt"):
2518    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
2519    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
2520   elif(checksumtype=="adler32"):
2521    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2522    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
2523   elif(checksumtype=="crc32"):
2524    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2525    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
2526   elif(checksumtype=="crc64_ecma"):
2527    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2528    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
2529   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2530    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2531    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
2532   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2533    checksumoutstr = hashlib.new(checksumtype);
2534    checksumoutstr.update("".encode('UTF-8'));
2535    catfileheadercshex = checksumoutstr.hexdigest().lower();
2536    checksumoutstr = hashlib.new(checksumtype);
2537    checksumoutstr.update(fcontents);
2538    catfilecontentcshex = checksumoutstr.hexdigest().lower();
2539   else:
2540    catfileheadercshex = format(0, 'x').lower();
2541    catfilecontentcshex = format(0, 'x').lower();
2542   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
2543   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
2544   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
2545   if(checksumtype=="none" or checksumtype==""):
2546    catfileheadercshex = format(0, 'x').lower();
2547   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2548    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
2549   elif(checksumtype=="crc16_ccitt"):
2550    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
2551   elif(checksumtype=="adler32"):
2552    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
2553   elif(checksumtype=="crc32"):
2554    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
2555   elif(checksumtype=="crc64_ecma"):
2556    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2557   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2558    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2559   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2560    checksumoutstr = hashlib.new(checksumtype);
2561    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
2562    catfileheadercshex = checksumoutstr.hexdigest().lower();
2563   else:
2564    catfileheadercshex = format(0, 'x').lower();
2565   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
2566   catfhend = (catfp.tell() - 1) + len(catfileoutstr);
2567   catfcontentstart = catfp.tell() + len(catfileoutstr);
2568   catfileoutstrecd = catfileoutstr.encode('UTF-8');
2569   nullstrecd = formatspecs[5].encode('UTF-8');
2570   catfileout = catfileoutstrecd + fcontents + nullstrecd;
2571   catfcontentend = (catfp.tell() - 1) + len(catfileout);
2572   catfp.write(catfileout);
2573   try:
2574    catfp.flush();
2575    os.fsync(catfp.fileno());
2576   except io.UnsupportedOperation:
2577    pass;
2578   except AttributeError:
2579    pass;
2580  if(numfiles>0):
2581   catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
2582  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
2583   catfp = CompressArchiveFile(catfp, compression, formatspecs);
2584   try:
2585    catfp.flush();
2586    os.fsync(catfp.fileno());
2587   except io.UnsupportedOperation:
2588    pass;
2589   except AttributeError:
2590    pass;
2591  if(outfile=="-"):
2592   catfp.seek(0, 0);
2593   if(hasattr(sys.stdout, "buffer")):
2594    shutil.copyfileobj(catfp, sys.stdout.buffer);
2595   else:
2596    shutil.copyfileobj(catfp, sys.stdout);
2597  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
2598   catfp = CompressArchiveFile(catfp, compression, formatspecs);
2599   catfp.seek(0, 0);
2600   upload_file_to_internet_file(catfp, outfile);
2601  if(returnfp):
2602   catfp.seek(0, 0);
2603   return catfp;
2604  else:
2605   catfp.close();
2606   return True;
2607
2608 create_alias_function("Pack", __file_format_name__, "", PackArchiveFile);
2609
2610 if(hasattr(shutil, "register_archive_format")):
2611  def PackArchiveFileFunc(archive_name, source_dir, **kwargs):
2612   return PackArchiveFile(source_dir, archive_name, False, "auto", None, False, "crc32", [], __file_format_delimiter__, False, False);
2613  create_alias_function("Pack", __file_format_name__, "Func", PackArchiveFileFunc);
2614
2615 def PackArchiveFileFromDirList(infiles, outfile, dirlistfromtxt=False, compression="auto", compressionlevel=None, followlink=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
2616  return PackArchiveFile(infiles, outfile, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, returnfp);
2617
2618 def PackArchiveFileFromTarFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
2619  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2620   outfile = RemoveWindowsPath(outfile);
2621  checksumtype = checksumtype.lower();
2622  if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
2623   checksumtype="crc32";
2624  if(checksumtype=="none"):
2625   checksumtype = "";
2626  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
2627   compression = None;
2628  if(compression not in compressionlist and compression is None):
2629   compression = "auto";
2630  if(verbose):
2631   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
2632  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2633   if(os.path.exists(outfile)):
2634    os.unlink(outfile);
2635  if(outfile=="-"):
2636   verbose = False;
2637   catfp = BytesIO();
2638  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
2639   catfp = outfile;
2640  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
2641   catfp = BytesIO();
2642  else:
2643   fbasename = os.path.splitext(outfile)[0];
2644   fextname = os.path.splitext(outfile)[1];
2645   catfp = CompressOpenFile(outfile, compressionlevel);
2646  catver = formatspecs[6];
2647  fileheaderver = str(int(catver.replace(".", "")));
2648  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
2649  catfp.write(fileheader.encode('UTF-8'));
2650  curinode = 0;
2651  curfid = 0;
2652  inodelist = [];
2653  inodetofile = {};
2654  filetoinode = {};
2655  inodetocatinode = {};
2656  if(infile=="-"):
2657   infile = BytesIO();
2658   if(hasattr(sys.stdin, "buffer")):
2659    shutil.copyfileobj(sys.stdin.buffer, infile);
2660   else:
2661    shutil.copyfileobj(sys.stdin, infile);
2662   infile.seek(0, 0);
2663   if(not infile):
2664    return False;
2665   infile.seek(0, 0);
2666  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
2667   infile = download_file_from_internet_file(infile);
2668   infile.seek(0, 0);
2669   if(not infile):
2670    return False;
2671   infile.seek(0, 0);
2672  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
2673   return False;
2674  elif(os.path.exists(infile) and os.path.isfile(infile)):
2675   try:
2676    if(not tarfile.is_tarfile(infile)):
2677     return False;
2678   except AttributeError:
2679    if(not is_tarfile(infile)):
2680     return False;
2681  else:
2682   return False;
2683  try:
2684   if(hasattr(infile, "read") or hasattr(infile, "write")):
2685    tarfp = tarfile.open(fileobj=infile, mode="r");
2686   else:
2687    tarfp = tarfile.open(infile, "r");
2688  except FileNotFoundError:
2689   return False;
2690  numfiles = int(len(tarfp.getmembers()));
2691  fnumfiles = format(int(len(tarfp.getmembers())), 'x').lower();
2692  fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
2693  if(checksumtype=="none" or checksumtype==""):
2694   catfileheadercshex = format(0, 'x').lower();
2695  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2696   catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2697  elif(checksumtype=="crc16_ccitt"):
2698   catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2699  elif(checksumtype=="adler32"):
2700   catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2701  elif(checksumtype=="crc32"):
2702   catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2703  elif(checksumtype=="crc64_ecma"):
2704   catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2705  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2706   catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2707  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2708   checksumoutstr = hashlib.new(checksumtype);
2709   checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
2710   catfileheadercshex = checksumoutstr.hexdigest().lower();
2711  else:
2712   catfileheadercshex = format(0, 'x').lower();
2713  fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
2714  catfp.write(fnumfilesa.encode('UTF-8'));
2715  try:
2716   catfp.flush();
2717   os.fsync(catfp.fileno());
2718  except io.UnsupportedOperation:
2719   pass;
2720  except AttributeError:
2721   pass;
2722  for member in sorted(tarfp.getmembers(), key=lambda x: x.name):
2723   catfhstart = catfp.tell();
2724   if(re.findall("^[.|/]", member.name)):
2725    fname = member.name;
2726   else:
2727    fname = "./"+member.name;
2728   if(verbose):
2729    VerbosePrintOut(fname);
2730   fpremode = member.mode;
2731   ffullmode = member.mode;
2732   flinkcount = 0;
2733   ftype = 0;
2734   if(member.isreg()):
2735    ffullmode = member.mode + stat.S_IFREG;
2736    ftype = 0;
2737   elif(member.isdev()):
2738    ffullmode = member.mode;
2739    ftype = 7;
2740   elif(member.islnk()):
2741    ffullmode = member.mode + stat.S_IFREG;
2742    ftype = 1;
2743   elif(member.issym()):
2744    ffullmode = member.mode + stat.S_IFLNK;
2745    ftype = 2;
2746   elif(member.ischr()):
2747    ffullmode = member.mode + stat.S_IFCHR;
2748    ftype = 3;
2749   elif(member.isblk()):
2750    ffullmode = member.mode + stat.S_IFBLK;
2751    ftype = 4;
2752   elif(member.isdir()):
2753    ffullmode = member.mode + stat.S_IFDIR;
2754    ftype = 5;
2755   elif(member.isfifo()):
2756    ffullmode = member.mode + stat.S_IFIFO;
2757    ftype = 6;
2758   elif(member.issparse()):
2759    ffullmode = member.mode;
2760    ftype = 12;
2761   else:
2762    ffullmode = member.mode;
2763    ftype = 0;
2764   flinkname = "";
2765   fcurfid = format(int(curfid), 'x').lower();
2766   fcurinode = format(int(curfid), 'x').lower();
2767   curfid = curfid + 1;
2768   if(ftype==2):
2769    flinkname = member.linkname;
2770   fdev_minor = format(int(member.devminor), 'x').lower();
2771   fdev_major = format(int(member.devmajor), 'x').lower();
2772   frdev_minor = format(int(member.devminor), 'x').lower();
2773   frdev_major = format(int(member.devmajor), 'x').lower();
2774   if(ftype==1 or ftype==2 or ftype==3 or ftype==4 or ftype==5 or ftype==6):
2775    fsize = format(int("0"), 'x').lower();
2776   elif(ftype==0 or ftype==7):
2777    fsize = format(int(member.size), 'x').lower();
2778   else:
2779    fsize = format(int(member.size), 'x').lower();
2780   fatime = format(int(member.mtime), 'x').lower();
2781   fmtime = format(int(member.mtime), 'x').lower();
2782   fctime = format(int(member.mtime), 'x').lower();
2783   fbtime = format(int(member.mtime), 'x').lower();
2784   fmode = format(int(ffullmode), 'x').lower();
2785   fchmode = format(int(stat.S_IMODE(ffullmode)), 'x').lower();
2786   ftypemod = format(int(stat.S_IFMT(ffullmode)), 'x').lower();
2787   fuid = format(int(member.uid), 'x').lower();
2788   fgid = format(int(member.gid), 'x').lower();
2789   funame = member.uname;
2790   fgname = member.gname;
2791   flinkcount = format(int(flinkcount), 'x').lower();
2792   fwinattributes = format(int(0), 'x').lower();
2793   fcontents = "".encode('UTF-8');
2794   chunk_size = 1024;
2795   if(ftype==0 or ftype==7):
2796    with tarfp.extractfile(member) as fpc:
2797     while(True):
2798      chunk = fpc.read(chunk_size);
2799      if(not chunk):
2800       break
2801      fcontents += chunk;
2802   ftypehex = format(ftype, 'x').lower();
2803   extrafields = format(len(extradata), 'x').lower();
2804   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
2805   if(len(extradata)>0):
2806    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
2807   extrasizelen = format(len(extrasizestr), 'x').lower();
2808   catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrasizelen, extrafields];
2809   catoutlen = len(catoutlist) + len(extradata) + 3;
2810   catoutlenhex = format(catoutlen, 'x').lower();
2811   catoutlist.insert(0, catoutlenhex);
2812   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
2813   if(len(extradata)>0):
2814    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
2815   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
2816   catfhend = (catfp.tell() - 1) + len(catfileoutstr);
2817   catfcontentstart = catfp.tell() + len(catfileoutstr);
2818   if(checksumtype=="none" or checksumtype==""):
2819    catfileheadercshex = format(0, 'x').lower();
2820    catfilecontentcshex = format(0, 'x').lower();
2821   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2822    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
2823    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
2824   elif(checksumtype=="crc16_ccitt"):
2825    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
2826    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
2827   elif(checksumtype=="adler32"):
2828    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2829    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
2830   elif(checksumtype=="crc32"):
2831    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2832    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
2833   elif(checksumtype=="crc64_ecma"):
2834    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2835    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
2836   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2837    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2838    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
2839   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2840    checksumoutstr = hashlib.new(checksumtype);
2841    checksumoutstr.update("".encode('UTF-8'));
2842    catfileheadercshex = checksumoutstr.hexdigest().lower();
2843    checksumoutstr = hashlib.new(checksumtype);
2844    checksumoutstr.update(fcontents);
2845    catfilecontentcshex = checksumoutstr.hexdigest().lower();
2846   else:
2847    catfileheadercshex = format(0, 'x').lower();
2848    catfilecontentcshex = format(0, 'x').lower();
2849   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
2850   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
2851   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
2852   if(checksumtype=="none" or checksumtype==""):
2853    catfileheadercshex = format(0, 'x').lower();
2854   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2855    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
2856   elif(checksumtype=="crc16_ccitt"):
2857    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
2858   elif(checksumtype=="adler32"):
2859    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
2860   elif(checksumtype=="crc32"):
2861    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
2862   elif(checksumtype=="crc64_ecma"):
2863    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2864   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2865    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2866   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2867    checksumoutstr = hashlib.new(checksumtype);
2868    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
2869    catfileheadercshex = checksumoutstr.hexdigest().lower();
2870   else:
2871    catfileheadercshex = format(0, 'x').lower();
2872   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
2873   catfileoutstrecd = catfileoutstr.encode('UTF-8');
2874   nullstrecd = formatspecs[5].encode('UTF-8');
2875   catfileout = catfileoutstrecd + fcontents + nullstrecd;
2876   catfcontentend = (catfp.tell() - 1) + len(catfileout);
2877   catfp.write(catfileout);
2878   try:
2879    catfp.flush();
2880    os.fsync(catfp.fileno());
2881   except io.UnsupportedOperation:
2882    pass;
2883   except AttributeError:
2884    pass;
2885  if(numfiles>0):
2886   catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
2887  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
2888   catfp = CompressArchiveFile(catfp, compression, formatspecs);
2889   try:
2890    catfp.flush();
2891    os.fsync(catfp.fileno());
2892   except io.UnsupportedOperation:
2893    pass;
2894   except AttributeError:
2895    pass;
2896  if(outfile=="-"):
2897   catfp.seek(0, 0);
2898   if(hasattr(sys.stdout, "buffer")):
2899    shutil.copyfileobj(catfp, sys.stdout.buffer);
2900   else:
2901    shutil.copyfileobj(catfp, sys.stdout);
2902  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
2903   catfp = CompressArchiveFile(catfp, compression, formatspecs);
2904   catfp.seek(0, 0);
2905   upload_file_from_internet_file(catfp, outfile);
2906  if(returnfp):
2907   catfp.seek(0, 0);
2908   return catfp;
2909  else:
2910   catfp.close();
2911   return True;
2912
2913 create_alias_function("Pack", __file_format_name__, "FromTarFile", PackArchiveFileFromTarFile);
2914
2915 def PackArchiveFileFromZipFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
2916  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2917   outfile = RemoveWindowsPath(outfile);
2918  checksumtype = checksumtype.lower();
2919  if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
2920   checksumtype="crc32";
2921  if(checksumtype=="none"):
2922   checksumtype = "";
2923  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
2924   compression = None;
2925  if(compression not in compressionlist and compression is None):
2926   compression = "auto";
2927  if(verbose):
2928   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
2929  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2930   if(os.path.exists(outfile)):
2931    os.unlink(outfile);
2932  if(outfile=="-"):
2933   verbose = False;
2934   catfp = BytesIO();
2935  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
2936   catfp = outfile;
2937  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
2938   catfp = BytesIO();
2939  else:
2940   fbasename = os.path.splitext(outfile)[0];
2941   fextname = os.path.splitext(outfile)[1];
2942   catfp = CompressOpenFile(outfile, compressionlevel);
2943  catver = formatspecs[6];
2944  fileheaderver = str(int(catver.replace(".", "")));
2945  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
2946  catfp.write(fileheader.encode('UTF-8'));
2947  curinode = 0;
2948  curfid = 0;
2949  inodelist = [];
2950  inodetofile = {};
2951  filetoinode = {};
2952  inodetocatinode = {};
2953  if(infile=="-"):
2954   infile = BytesIO();
2955   if(hasattr(sys.stdin, "buffer")):
2956    shutil.copyfileobj(sys.stdin.buffer, infile);
2957   else:
2958    shutil.copyfileobj(sys.stdin, infile);
2959   infile.seek(0, 0);
2960   if(not infile):
2961    return False;
2962   infile.seek(0, 0);
2963  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
2964   infile = download_file_from_internet_file(infile);
2965   infile.seek(0, 0);
2966   if(not infile):
2967    return False;
2968   infile.seek(0, 0);
2969  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
2970   return False;
2971  else:
2972   return False;
2973  if(not zipfile.is_zipfile(infile)):
2974   return False;
2975  try:
2976   zipfp = zipfile.ZipFile(infile, "r", allowZip64=True);
2977  except FileNotFoundError:
2978   return False;
2979  ziptest = zipfp.testzip();
2980  if(ziptest):
2981   VerbosePrintOut("Bad file found!");
2982  numfiles = int(len(zipfp.infolist()));
2983  fnumfiles = format(int(len(zipfp.infolist())), 'x').lower();
2984  fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
2985  if(checksumtype=="none" or checksumtype==""):
2986   catfileheadercshex = format(0, 'x').lower();
2987  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2988   catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2989  elif(checksumtype=="crc16_ccitt"):
2990   catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2991  elif(checksumtype=="adler32"):
2992   catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2993  elif(checksumtype=="crc32"):
2994   catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2995  elif(checksumtype=="crc64_ecma"):
2996   catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2997  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2998   catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2999  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3000   checksumoutstr = hashlib.new(checksumtype);
3001   checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
3002   catfileheadercshex = checksumoutstr.hexdigest().lower();
3003  else:
3004   catfileheadercshex = format(0, 'x').lower();
3005  fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
3006  catfp.write(fnumfilesa.encode('UTF-8'));
3007  try:
3008   catfp.flush();
3009   os.fsync(catfp.fileno());
3010  except io.UnsupportedOperation:
3011   pass;
3012  except AttributeError:
3013   pass;
3014  for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
3015   catfhstart = catfp.tell();
3016   if(re.findall("^[.|/]", member.filename)):
3017    fname = member.filename;
3018   else:
3019    fname = "./"+member.filename;
3020   zipinfo = zipfp.getinfo(member.filename);
3021   if(verbose):
3022    VerbosePrintOut(fname);
3023   if(not member.is_dir()):
3024    fpremode = int(stat.S_IFREG + 438);
3025   elif(member.is_dir()):
3026    fpremode = int(stat.S_IFDIR + 511);
3027   flinkcount = 0;
3028   ftype = 0;
3029   if(not member.is_dir()):
3030    ftype = 0;
3031   elif(member.is_dir()):
3032    ftype = 5;
3033   flinkname = "";
3034   fcurfid = format(int(curfid), 'x').lower();
3035   fcurinode = format(int(curfid), 'x').lower();
3036   curfid = curfid + 1;
3037   fdev_minor = format(int(0), 'x').lower();
3038   fdev_major = format(int(0), 'x').lower();
3039   frdev_minor = format(int(0), 'x').lower();
3040   frdev_major = format(int(0), 'x').lower();
3041   if(ftype==5):
3042    fsize = format(int("0"), 'x').lower();
3043   elif(ftype==0):
3044    fsize = format(int(member.file_size), 'x').lower();
3045   else:
3046    fsize = format(int(member.file_size), 'x').lower();
3047   fatime = format(int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower();
3048   fmtime = format(int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower();
3049   fctime = format(int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower();
3050   fbtime = format(int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower();
3051   if(zipinfo.create_system==0 or zipinfo.create_system==10):
3052    fwinattributes = format(int(zipinfo.external_attr), 'x').lower();
3053    if(not member.is_dir()):
3054     fmode = format(int(stat.S_IFREG + 438), 'x').lower();
3055     fchmode = stat.S_IMODE(fmode);
3056     ftypemod = stat.S_IFMT(fmode);
3057    elif(member.is_dir()):
3058     fmode = format(int(stat.S_IFDIR + 511), 'x').lower();
3059     fchmode = stat.S_IMODE(fmode);
3060     ftypemod = stat.S_IFMT(fmode);
3061   elif(zipinfo.create_system==3):
3062    fwinattributes = format(int(0), 'x').lower();
3063    fmode = format(int(zipinfo.external_attr), 'x').lower();
3064    fchmode = stat.S_IMODE(fmode);
3065    ftypemod = stat.S_IFMT(fmode);
3066   else:
3067    fwinattributes = format(int(0), 'x').lower();
3068    if(not member.is_dir()):
3069     fmode = format(int(stat.S_IFREG + 438), 'x').lower();
3070     fchmode = stat.S_IMODE(fmode);
3071     ftypemod = stat.S_IFMT(fmode);
3072    elif(member.is_dir()):
3073     fmode = format(int(stat.S_IFDIR + 511), 'x').lower();
3074     fchmode = stat.S_IMODE(fmode);
3075     ftypemod = stat.S_IFMT(fmode);
3076   try:
3077    fuid = format(int(os.getuid()), 'x').lower();
3078   except AttributeError:
3079    fuid = format(int(0), 'x').lower();
3080   except KeyError:
3081    fuid = format(int(0), 'x').lower();
3082   try:
3083    fgid = format(int(os.getgid()), 'x').lower();
3084   except AttributeError:
3085    fgid = format(int(0), 'x').lower();
3086   except KeyError:
3087    fgid = format(int(0), 'x').lower();
3088   try:
3089    import pwd;
3090    try:
3091     userinfo = pwd.getpwuid(os.getuid());
3092     funame = userinfo.pw_name;
3093    except KeyError:
3094     funame = "";
3095    except AttributeError:
3096     funame = "";
3097   except ImportError:
3098    funame = "";
3099   fgname = "";
3100   try:
3101    import grp;
3102    try:
3103     groupinfo = grp.getgrgid(os.getgid());
3104     fgname = groupinfo.gr_name;
3105    except KeyError:
3106     fgname = "";
3107    except AttributeError:
3108     fgname = "";
3109   except ImportError:
3110    fgname = "";
3111   fcontents = "".encode('UTF-8');
3112   if(ftype==0):
3113    fcontents = zipfp.read(member.filename);
3114   ftypehex = format(ftype, 'x').lower();
3115   extrafields = format(len(extradata), 'x').lower();
3116   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
3117   if(len(extradata)>0):
3118    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
3119   extrasizelen = format(len(extrasizestr), 'x').lower();
3120   catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrasizelen, extrafields];
3121   catoutlen = len(catoutlist) + len(extradata) + 3;
3122   catoutlenhex = format(catoutlen, 'x').lower();
3123   catoutlist.insert(0, catoutlenhex);
3124   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
3125   if(len(extradata)>0):
3126    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
3127   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
3128   catfhend = (catfp.tell() - 1) + len(catfileoutstr);
3129   catfcontentstart = catfp.tell() + len(catfileoutstr);
3130   if(checksumtype=="none" or checksumtype==""):
3131    catfileheadercshex = format(0, 'x').lower();
3132    catfilecontentcshex = format(0, 'x').lower();
3133   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3134    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3135    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
3136   elif(checksumtype=="crc16_ccitt"):
3137    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3138    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
3139   elif(checksumtype=="adler32"):
3140    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3141    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
3142   elif(checksumtype=="crc32"):
3143    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3144    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
3145   elif(checksumtype=="crc64_ecma"):
3146    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3147    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
3148   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3149    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3150    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
3151   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3152    checksumoutstr = hashlib.new(checksumtype);
3153    checksumoutstr.update("".encode('UTF-8'));
3154    catfileheadercshex = checksumoutstr.hexdigest().lower();
3155    checksumoutstr = hashlib.new(checksumtype);
3156    checksumoutstr.update(fcontents);
3157    catfilecontentcshex = checksumoutstr.hexdigest().lower();
3158   else:
3159    catfileheadercshex = format(0, 'x').lower();
3160    catfilecontentcshex = format(0, 'x').lower();
3161   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
3162   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
3163   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
3164   if(checksumtype=="none" or checksumtype==""):
3165    catfileheadercshex = format(0, 'x').lower();
3166   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3167    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
3168   elif(checksumtype=="crc16_ccitt"):
3169    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
3170   elif(checksumtype=="adler32"):
3171    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
3172   elif(checksumtype=="crc32"):
3173    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
3174   elif(checksumtype=="crc64_ecma"):
3175    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3176   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3177    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3178   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3179    checksumoutstr = hashlib.new(checksumtype);
3180    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
3181    catfileheadercshex = checksumoutstr.hexdigest().lower();
3182   else:
3183    catfileheadercshex = format(0, 'x').lower();
3184   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
3185   catfileoutstrecd = catfileoutstr.encode('UTF-8');
3186   nullstrecd = formatspecs[5].encode('UTF-8');
3187   catfileout = catfileoutstrecd + fcontents + nullstrecd;
3188   catfcontentend = (catfp.tell() - 1) + len(catfileout);
3189   catfp.write(catfileout);
3190   try:
3191    catfp.flush();
3192    os.fsync(catfp.fileno());
3193   except io.UnsupportedOperation:
3194    pass;
3195   except AttributeError:
3196    pass;
3197  if(numfiles>0):
3198   catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
3199  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
3200   catfp = CompressArchiveFile(catfp, compression, formatspecs);
3201   try:
3202    catfp.flush();
3203    os.fsync(catfp.fileno());
3204   except io.UnsupportedOperation:
3205    pass;
3206   except AttributeError:
3207    pass;
3208  if(outfile=="-"):
3209   catfp.seek(0, 0);
3210   if(hasattr(sys.stdout, "buffer")):
3211    shutil.copyfileobj(catfp, sys.stdout.buffer);
3212   else:
3213    shutil.copyfileobj(catfp, sys.stdout);
3214  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
3215   catfp = CompressArchiveFile(catfp, compression, formatspecs);
3216   catfp.seek(0, 0);
3217   upload_file_to_internet_file(catfp, outfile);
3218  if(returnfp):
3219   catfp.seek(0, 0);
3220   return catfp;
3221  else:
3222   catfp.close();
3223   return True;
3224
3225 create_alias_function("Pack", __file_format_name__, "FromZipFile", PackArchiveFileFromZipFile);
3226
3227 if(not rarfile_support):
3228  def PackArchiveFileFromRarFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
3229   return False
3230
3231 if(rarfile_support):
3232  def PackArchiveFileFromRarFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
3233   if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
3234    outfile = RemoveWindowsPath(outfile);
3235   checksumtype = checksumtype.lower();
3236   if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
3237    checksumtype="crc32";
3238   if(checksumtype=="none"):
3239    checksumtype = "";
3240   if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
3241    compression = None;
3242   if(compression not in compressionlist and compression is None):
3243    compression = "auto";
3244   if(verbose):
3245    logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
3246   if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
3247    if(os.path.exists(outfile)):
3248     os.unlink(outfile);
3249   if(outfile=="-"):
3250    verbose = False;
3251    catfp = BytesIO();
3252   elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
3253    catfp = outfile;
3254   elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
3255    catfp = BytesIO();
3256   else:
3257    fbasename = os.path.splitext(outfile)[0];
3258    fextname = os.path.splitext(outfile)[1];
3259    catfp = CompressOpenFile(outfile, compressionlevel);
3260   catver = formatspecs[6];
3261   fileheaderver = str(int(catver.replace(".", "")));
3262   fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
3263   catfp.write(fileheader.encode('UTF-8'));
3264   curinode = 0;
3265   curfid = 0;
3266   inodelist = [];
3267   inodetofile = {};
3268   filetoinode = {};
3269   inodetocatinode = {};
3270   if(not os.path.exists(infile) or not os.path.isfile(infile)):
3271    return False;
3272   if(not rarfile.is_rarfile(infile) and not rarfile.is_rarfile_sfx(infile)):
3273    return False;
3274   rarfp = rarfile.RarFile(infile, "r");
3275   rartest = rarfp.testrar();
3276   if(rartest):
3277    VerbosePrintOut("Bad file found!");
3278   numfiles = int(len(rarfp.infolist()));
3279   fnumfiles = format(int(len(rarfp.infolist())), 'x').lower();
3280   fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
3281   if(checksumtype=="none" or checksumtype==""):
3282    catfileheadercshex = format(0, 'x').lower();
3283   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3284    catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
3285   elif(checksumtype=="crc16_ccitt"):
3286    catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
3287   elif(checksumtype=="adler32"):
3288    catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
3289   elif(checksumtype=="crc32"):
3290    catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
3291   elif(checksumtype=="crc64_ecma"):
3292    catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3293   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3294    catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3295   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3296    checksumoutstr = hashlib.new(checksumtype);
3297    checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
3298    catfileheadercshex = checksumoutstr.hexdigest().lower();
3299   else:
3300    catfileheadercshex = format(0, 'x').lower();
3301   fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
3302   catfp.write(fnumfilesa.encode('UTF-8'));
3303   try:
3304    catfp.flush();
3305    os.fsync(catfp.fileno());
3306   except io.UnsupportedOperation:
3307    pass;
3308   except AttributeError:
3309    pass;
3310   for member in sorted(rarfp.infolist(), key=lambda x: x.filename):
3311    is_unix = False;
3312    is_windows = False;
3313    if(member.host_os==rarfile.RAR_OS_UNIX):
3314     is_windows = False;
3315     try:
3316      member.external_attr
3317      is_unix = True;
3318     except AttributeError:
3319      is_unix = False;
3320    elif(member.host_os==rarfile.RAR_OS_WIN32):
3321     is_unix = False;
3322     try:
3323      member.external_attr
3324      is_windows = True;
3325     except AttributeError:
3326      is_windows = False;
3327    else:
3328     is_unix = False;
3329     is_windows = False;
3330    catfhstart = catfp.tell();
3331    if(re.findall("^[.|/]", member.filename)):
3332     fname = member.filename;
3333    else:
3334     fname = "./"+member.filename;
3335    rarinfo = rarfp.getinfo(member.filename);
3336    if(verbose):
3337     VerbosePrintOut(fname);
3338    if(is_unix and member.external_attr !=0):
3339     fpremode = int(member.external_attr);
3340    elif(member.is_file()):
3341     fpremode = int(stat.S_IFREG + 438);
3342    elif(member.is_symlink()):
3343     fpremode = int(stat.S_IFLNK + 438);
3344    elif(member.is_dir()):
3345     fpremode = int(stat.S_IFDIR + 511);
3346    if(is_windows and member.external_attr !=0):
3347     fwinattributes = format(int(member.external_attr), 'x').lower();
3348    else:
3349     fwinattributes = format(int(0), 'x').lower();
3350    flinkcount = 0;
3351    ftype = 0;
3352    if(member.is_file()):
3353     ftype = 0;
3354    elif(member.is_symlink()):
3355     ftype = 2;
3356    elif(member.is_dir()):
3357     ftype = 5;
3358    flinkname = "";
3359    if(ftype==2):
3360     flinkname = rarfp.read(member.filename).decode("UTF-8");
3361    fcurfid = format(int(curfid), 'x').lower();
3362    fcurinode = format(int(curfid), 'x').lower();
3363    curfid = curfid + 1;
3364    fdev_minor = format(int(0), 'x').lower();
3365    fdev_major = format(int(0), 'x').lower();
3366    frdev_minor = format(int(0), 'x').lower();
3367    frdev_major = format(int(0), 'x').lower();
3368    if(ftype==5):
3369     fsize = format(int("0"), 'x').lower();
3370    elif(ftype==0):
3371     fsize = format(int(member.file_size), 'x').lower();
3372    else:
3373     fsize = format(int(member.file_size), 'x').lower();
3374    try:
3375     if(member.atime):
3376      fatime = format(int(member.atime.timestamp()), 'x').lower();
3377     else:
3378      fatime = format(int(member.mtime.timestamp()), 'x').lower();
3379    except AttributeError:
3380     fatime = format(int(member.mtime.timestamp()), 'x').lower();
3381    fmtime = format(int(member.mtime.timestamp()), 'x').lower();
3382    try:
3383     if(member.ctime):
3384      fctime = format(int(member.ctime.timestamp()), 'x').lower();
3385     else:
3386      fctime = format(int(member.mtime.timestamp()), 'x').lower();
3387    except AttributeError:
3388     fctime = format(int(member.mtime.timestamp()), 'x').lower();
3389    fbtime = format(int(member.mtime.timestamp()), 'x').lower();
3390    if(is_unix and member.external_attr !=0):
3391     fmode = format(int(member.external_attr), 'x').lower();
3392     fchmode = format(int(stat.S_IMODE(member.external_attr)), 'x').lower();
3393     ftypemod = format(int(stat.S_IFMT(member.external_attr)), 'x').lower();
3394    elif(member.is_file()):
3395     fmode = format(int(stat.S_IFREG + 438), 'x').lower();
3396     fchmode = format(int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower();
3397     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower();
3398    elif(member.is_symlink()):
3399     fmode = format(int(stat.S_IFLNK + 438), 'x').lower();
3400     fchmode = format(int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower();
3401     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower();
3402    elif(member.is_dir()):
3403     fmode = format(int(stat.S_IFDIR + 511), 'x').lower();
3404     fchmode = format(int(stat.S_IMODE(int(stat.S_IFDIR + 511))), 'x').lower();
3405     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFDIR + 511))), 'x').lower();
3406    try:
3407     fuid = format(int(os.getuid()), 'x').lower();
3408    except AttributeError:
3409     fuid = format(int(0), 'x').lower();
3410    except KeyError:
3411     fuid = format(int(0), 'x').lower();
3412    try:
3413     fgid = format(int(os.getgid()), 'x').lower();
3414    except AttributeError:
3415     fgid = format(int(0), 'x').lower();
3416    except KeyError:
3417     fgid = format(int(0), 'x').lower();
3418    try:
3419     import pwd;
3420     try:
3421      userinfo = pwd.getpwuid(os.getuid());
3422      funame = userinfo.pw_name;
3423     except KeyError:
3424      funame = "";
3425     except AttributeError:
3426      funame = "";
3427    except ImportError:
3428     funame = "";
3429    fgname = "";
3430    try:
3431     import grp;
3432     try:
3433      groupinfo = grp.getgrgid(os.getgid());
3434      fgname = groupinfo.gr_name;
3435     except KeyError:
3436      fgname = "";
3437     except AttributeError:
3438      fgname = "";
3439    except ImportError:
3440     fgname = "";
3441    fcontents = "".encode('UTF-8');
3442    if(ftype==0):
3443     fcontents = rarfp.read(member.filename);
3444    ftypehex = format(ftype, 'x').lower();
3445    extrafields = format(len(extradata), 'x').lower();
3446    extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
3447    if(len(extradata)>0):
3448     extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
3449    extrasizelen = format(len(extrasizestr), 'x').lower();
3450    catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrasizelen, extrafields];
3451    catoutlen = len(catoutlist) + len(extradata) + 3;
3452    catoutlenhex = format(catoutlen, 'x').lower();
3453    catoutlist.insert(0, catoutlenhex);
3454    catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
3455    if(len(extradata)>0):
3456     catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
3457    catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
3458    catfhend = (catfp.tell() - 1) + len(catfileoutstr);
3459    catfcontentstart = catfp.tell() + len(catfileoutstr);
3460    if(checksumtype=="none" or checksumtype==""):
3461     catfileheadercshex = format(0, 'x').lower();
3462     catfilecontentcshex = format(0, 'x').lower();
3463    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3464     catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3465     catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
3466    elif(checksumtype=="crc16_ccitt"):
3467     catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3468     catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
3469    elif(checksumtype=="adler32"):
3470     catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3471     catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
3472    elif(checksumtype=="crc32"):
3473     catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3474     catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
3475    elif(checksumtype=="crc64_ecma"):
3476     catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3477     catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
3478    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3479     catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3480     catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
3481    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3482     checksumoutstr = hashlib.new(checksumtype);
3483     checksumoutstr.update("".encode('UTF-8'));
3484     catfileheadercshex = checksumoutstr.hexdigest().lower();
3485     checksumoutstr = hashlib.new(checksumtype);
3486     checksumoutstr.update(fcontents);
3487     catfilecontentcshex = checksumoutstr.hexdigest().lower();
3488    else:
3489     catfileheadercshex = format(0, 'x').lower();
3490     catfilecontentcshex = format(0, 'x').lower();
3491    tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
3492    catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
3493    catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr
3494    if(checksumtype=="none" or checksumtype==""):
3495     catfileheadercshex = format(0, 'x').lower()
3496    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3497     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower()
3498    elif(checksumtype=="crc16_ccitt"):
3499     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower()
3500    elif(checksumtype=="adler32"):
3501     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower()
3502    elif(checksumtype=="crc32"):
3503     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower()
3504    elif(checksumtype=="crc64_ecma"):
3505     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
3506    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3507     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
3508    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3509     checksumoutstr = hashlib.new(checksumtype)
3510     checksumoutstr.update(catfileoutstr.encode('UTF-8'))
3511     catfileheadercshex = checksumoutstr.hexdigest().lower()
3512    else:
3513     catfileheadercshex = format(0, 'x').lower()
3514    catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5])
3515    catfileoutstrecd = catfileoutstr.encode('UTF-8')
3516    nullstrecd = formatspecs[5].encode('UTF-8')
3517    catfileout = catfileoutstrecd + fcontents + nullstrecd
3518    catfcontentend = (catfp.tell() - 1) + len(catfileout)
3519    catfp.write(catfileout)
3520    try:
3521     catfp.flush()
3522     os.fsync(catfp.fileno())
3523    except io.UnsupportedOperation:
3524     pass
3525    except AttributeError:
3526     pass
3527   if(numfiles>0):
3528    catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
3529   if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
3530    catfp = CompressArchiveFile(catfp, compression, formatspecs)
3531    try:
3532     catfp.flush()
3533     os.fsync(catfp.fileno())
3534    except io.UnsupportedOperation:
3535     pass
3536    except AttributeError:
3537     pass
3538   if(outfile=="-"):
3539    catfp.seek(0, 0)
3540    if(hasattr(sys.stdout, "buffer")):
3541     shutil.copyfileobj(catfp, sys.stdout.buffer);
3542    else:
3543     shutil.copyfileobj(catfp, sys.stdout);
3544   elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
3545    catfp = CompressArchiveFile(catfp, compression, formatspecs);
3546    catfp.seek(0, 0);
3547    upload_file_to_internet_file(catfp, outfile);
3548   if(returnfp):
3549    catfp.seek(0, 0)
3550    return catfp
3551   else:
3552    catfp.close()
3553    return True;
3554
3555 create_alias_function("Pack", __file_format_name__, "FromRarFile", PackArchiveFileFromRarFile);
3556
3557 if(not py7zr_support):
3558  def PackArchiveFileFromSevenZipFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
3559   return False
3560
3561 if(py7zr_support):
3562  def PackArchiveFileFromSevenZipFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
3563   if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
3564    outfile = RemoveWindowsPath(outfile);
3565   checksumtype = checksumtype.lower();
3566   if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
3567    checksumtype="crc32";
3568   if(checksumtype=="none"):
3569    checksumtype = "";
3570   if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
3571    compression = None;
3572   if(compression not in compressionlist and compression is None):
3573    compression = "auto";
3574   if(verbose):
3575    logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
3576   if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
3577    if(os.path.exists(outfile)):
3578     os.unlink(outfile);
3579   if(outfile=="-"):
3580    verbose = False;
3581    catfp = BytesIO();
3582   elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
3583    catfp = outfile;
3584   elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
3585    catfp = BytesIO();
3586   else:
3587    fbasename = os.path.splitext(outfile)[0];
3588    fextname = os.path.splitext(outfile)[1];
3589    catfp = CompressOpenFile(outfile, compressionlevel);
3590   catver = formatspecs[6];
3591   fileheaderver = str(int(catver.replace(".", "")));
3592   fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
3593   catfp.write(fileheader.encode('UTF-8'));
3594   curinode = 0;
3595   curfid = 0;
3596   inodelist = [];
3597   inodetofile = {};
3598   filetoinode = {};
3599   inodetocatinode = {};
3600   if(not os.path.exists(infile) or not os.path.isfile(infile)):
3601    return False;
3602   szpfp = py7zr.SevenZipFile(infile, mode="r");
3603   file_content = szpfp.readall();
3604   #sztest = szpfp.testzip();
3605   sztestalt = szpfp.test();
3606   if(sztestalt):
3607    VerbosePrintOut("Bad file found!");
3608   numfiles = int(len(szpfp.list()));
3609   fnumfiles = format(int(len(szpfp.list())), 'x').lower();
3610   fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
3611   if(checksumtype=="none" or checksumtype==""):
3612    catfileheadercshex = format(0, 'x').lower();
3613   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3614    catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
3615   elif(checksumtype=="crc16_ccitt"):
3616    catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
3617   elif(checksumtype=="adler32"):
3618    catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
3619   elif(checksumtype=="crc32"):
3620    catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
3621   elif(checksumtype=="crc64_ecma"):
3622    catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3623   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3624    catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3625   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3626    checksumoutstr = hashlib.new(checksumtype);
3627    checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
3628    catfileheadercshex = checksumoutstr.hexdigest().lower();
3629   else:
3630    catfileheadercshex = format(0, 'x').lower();
3631   fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
3632   catfp.write(fnumfilesa.encode('UTF-8'));
3633   try:
3634    catfp.flush();
3635    os.fsync(catfp.fileno());
3636   except io.UnsupportedOperation:
3637    pass;
3638   except AttributeError:
3639    pass;
3640   for member in sorted(szpfp.list(), key=lambda x: x.filename):
3641    catfhstart = catfp.tell();
3642    if(re.findall("^[.|/]", member.filename)):
3643     fname = member.filename;
3644    else:
3645     fname = "./"+member.filename;
3646    if(verbose):
3647     VerbosePrintOut(fname);
3648    if(not member.is_directory):
3649     fpremode = int(stat.S_IFREG + 438);
3650    elif(member.is_directory):
3651     fpremode = int(stat.S_IFDIR + 511);
3652    fwinattributes = format(int(0), 'x').lower();
3653    flinkcount = 0;
3654    ftype = 0;
3655    if(member.is_directory):
3656     ftype = 5;
3657    else:
3658     ftype = 0;
3659    flinkname = "";
3660    fcurfid = format(int(curfid), 'x').lower();
3661    fcurinode = format(int(curfid), 'x').lower();
3662    curfid = curfid + 1;
3663    fdev_minor = format(int(0), 'x').lower();
3664    fdev_major = format(int(0), 'x').lower();
3665    frdev_minor = format(int(0), 'x').lower();
3666    frdev_major = format(int(0), 'x').lower();
3667    if(ftype==5):
3668     fsize = format(int("0"), 'x').lower();
3669    fatime = format(int(member.creationtime.timestamp()), 'x').lower();
3670    fmtime = format(int(member.creationtime.timestamp()), 'x').lower();
3671    fctime = format(int(member.creationtime.timestamp()), 'x').lower();
3672    fbtime = format(int(member.creationtime.timestamp()), 'x').lower();
3673    if(member.is_directory):
3674     fmode = format(int(stat.S_IFDIR + 511), 'x').lower();
3675     fchmode = format(int(stat.S_IMODE(int(stat.S_IFDIR + 511))), 'x').lower();
3676     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFDIR + 511))), 'x').lower();
3677    else:
3678     fmode = format(int(stat.S_IFREG + 438), 'x').lower();
3679     fchmode = format(int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower();
3680     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower();
3681    try:
3682     fuid = format(int(os.getuid()), 'x').lower();
3683    except AttributeError:
3684     fuid = format(int(0), 'x').lower();
3685    except KeyError:
3686     fuid = format(int(0), 'x').lower();
3687    try:
3688     fgid = format(int(os.getgid()), 'x').lower();
3689    except AttributeError:
3690     fgid = format(int(0), 'x').lower();
3691    except KeyError:
3692     fgid = format(int(0), 'x').lower();
3693    try:
3694     import pwd;
3695     try:
3696      userinfo = pwd.getpwuid(os.getuid());
3697      funame = userinfo.pw_name;
3698     except KeyError:
3699      funame = "";
3700     except AttributeError:
3701      funame = "";
3702    except ImportError:
3703     funame = "";
3704    fgname = "";
3705    try:
3706     import grp;
3707     try:
3708      groupinfo = grp.getgrgid(os.getgid());
3709      fgname = groupinfo.gr_name;
3710     except KeyError:
3711      fgname = "";
3712     except AttributeError:
3713      fgname = "";
3714    except ImportError:
3715     fgname = "";
3716    fcontents = "".encode('UTF-8');
3717    if(ftype==0):
3718     fcontents = file_content[member.filename].read();
3719     fsize = format(len(fcontents), 'x').lower();
3720     file_content[member.filename].close();
3721    ftypehex = format(ftype, 'x').lower();
3722    extrafields = format(len(extradata), 'x').lower();
3723    extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
3724    if(len(extradata)>0):
3725     extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
3726    extrasizelen = format(len(extrasizestr), 'x').lower();
3727    catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrasizelen, extrafields];
3728    catoutlen = len(catoutlist) + len(extradata) + 3;
3729    catoutlenhex = format(catoutlen, 'x').lower();
3730    catoutlist.insert(0, catoutlenhex);
3731    catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
3732    if(len(extradata)>0):
3733     catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
3734    catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
3735    catfhend = (catfp.tell() - 1) + len(catfileoutstr);
3736    catfcontentstart = catfp.tell() + len(catfileoutstr);
3737    if(checksumtype=="none" or checksumtype==""):
3738     catfileheadercshex = format(0, 'x').lower();
3739     catfilecontentcshex = format(0, 'x').lower();
3740    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3741     catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3742     catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
3743    elif(checksumtype=="crc16_ccitt"):
3744     catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3745     catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
3746    elif(checksumtype=="adler32"):
3747     catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3748     catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
3749    elif(checksumtype=="crc32"):
3750     catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3751     catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
3752    elif(checksumtype=="crc64_ecma"):
3753     catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3754     catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
3755    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3756     catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3757     catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
3758    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3759     checksumoutstr = hashlib.new(checksumtype);
3760     checksumoutstr.update("".encode('UTF-8'));
3761     catfileheadercshex = checksumoutstr.hexdigest().lower();
3762     checksumoutstr = hashlib.new(checksumtype);
3763     checksumoutstr.update(fcontents);
3764     catfilecontentcshex = checksumoutstr.hexdigest().lower();
3765    else:
3766     catfileheadercshex = format(0, 'x').lower();
3767     catfilecontentcshex = format(0, 'x').lower();
3768    tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
3769    catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
3770    catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr
3771    if(checksumtype=="none" or checksumtype==""):
3772     catfileheadercshex = format(0, 'x').lower()
3773    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3774     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower()
3775    elif(checksumtype=="crc16_ccitt"):
3776     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower()
3777    elif(checksumtype=="adler32"):
3778     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower()
3779    elif(checksumtype=="crc32"):
3780     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower()
3781    elif(checksumtype=="crc64_ecma"):
3782     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
3783    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3784     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
3785    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3786     checksumoutstr = hashlib.new(checksumtype)
3787     checksumoutstr.update(catfileoutstr.encode('UTF-8'))
3788     catfileheadercshex = checksumoutstr.hexdigest().lower()
3789    else:
3790     catfileheadercshex = format(0, 'x').lower()
3791    catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5])
3792    catfileoutstrecd = catfileoutstr.encode('UTF-8')
3793    nullstrecd = formatspecs[5].encode('UTF-8')
3794    catfileout = catfileoutstrecd + fcontents + nullstrecd
3795    catfcontentend = (catfp.tell() - 1) + len(catfileout)
3796    catfp.write(catfileout)
3797    try:
3798     catfp.flush()
3799     os.fsync(catfp.fileno())
3800    except io.UnsupportedOperation:
3801     pass
3802    except AttributeError:
3803     pass
3804   if(numfiles>0):
3805    catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
3806   if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
3807    catfp = CompressArchiveFile(catfp, compression, formatspecs)
3808    try:
3809     catfp.flush()
3810     os.fsync(catfp.fileno())
3811    except io.UnsupportedOperation:
3812     pass
3813    except AttributeError:
3814     pass
3815   if(outfile=="-"):
3816    catfp.seek(0, 0)
3817    if(hasattr(sys.stdout, "buffer")):
3818     shutil.copyfileobj(catfp, sys.stdout.buffer);
3819    else:
3820     shutil.copyfileobj(catfp, sys.stdout);
3821   elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
3822    catfp = CompressArchiveFile(catfp, compression, formatspecs);
3823    catfp.seek(0, 0);
3824    upload_file_to_internet_file(catfp, outfile);
3825   if(returnfp):
3826    catfp.seek(0, 0)
3827    return catfp
3828   else:
3829    catfp.close()
3830    return True;
3831
3832 create_alias_function("Pack", __file_format_name__, "FromSevenZipFile", PackArchiveFileFromSevenZipFile);
3833
3834 def ArchiveFileSeekToFileNum(infile, seekto=0, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
3835  if(hasattr(infile, "read") or hasattr(infile, "write")):
3836   catfp = infile;
3837   catfp.seek(0, 0);
3838   catfp = UncompressArchiveFile(catfp, formatspecs);
3839   checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True);
3840   if(checkcompressfile=="tarfile"):
3841    return TarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
3842   if(checkcompressfile=="zipfile"):
3843    return ZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
3844   if(rarfile_support and checkcompressfile=="rarfile"):
3845    return RarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
3846   if(py7zr_support and checkcompressfile=="7zipfile"):
3847    return SevenZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
3848   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
3849    return False;
3850   if(not catfp):
3851    return False;
3852   catfp.seek(0, 0);
3853  elif(infile=="-"):
3854   catfp = BytesIO();
3855   if(hasattr(sys.stdin, "buffer")):
3856    shutil.copyfileobj(sys.stdin.buffer, catfp);
3857   else:
3858    shutil.copyfileobj(sys.stdin, catfp);
3859   catfp.seek(0, 0);
3860   catfp = UncompressArchiveFile(catfp, formatspecs);
3861   if(not catfp):
3862    return False;
3863   catfp.seek(0, 0);
3864  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
3865   catfp = download_file_from_internet_file(infile);
3866   catfp.seek(0, 0);
3867   catfp = UncompressArchiveFile(catfp, formatspecs);
3868   if(not catfp):
3869    return False;
3870   catfp.seek(0, 0);
3871  else:
3872   infile = RemoveWindowsPath(infile);
3873   checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
3874   if(checkcompressfile=="tarfile"):
3875    return TarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
3876   if(checkcompressfile=="zipfile"):
3877    return ZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
3878   if(rarfile_support and checkcompressfile=="rarfile"):
3879    return RarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
3880   if(py7zr_support and checkcompressfile=="7zipfile"):
3881    return SevenZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
3882   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
3883    return False;
3884   compresscheck = CheckCompressionType(infile, formatspecs, True);
3885   if(not compresscheck):
3886    fextname = os.path.splitext(infile)[1];
3887    if(fextname==".gz"):
3888     compresscheck = "gzip";
3889    elif(fextname==".bz2"):
3890     compresscheck = "bzip2";
3891    elif(fextname==".zst"):
3892     compresscheck = "zstd";
3893    elif(fextname==".lz4" or fextname==".clz4"):
3894     compresscheck = "lz4";
3895    elif(fextname==".lzo" or fextname==".lzop"):
3896     compresscheck = "lzo";
3897    elif(fextname==".lzma" or fextname==".xz"):
3898     compresscheck = "lzma";
3899    else:
3900     return False;
3901   if(not compresscheck):
3902    return False;
3903   catfp = UncompressFile(infile, formatspecs, "rb");
3904  '''
3905  try:
3906   catfp.seek(0, 2);
3907  except OSError:
3908   SeekToEndOfFile(catfp);
3909  except ValueError:
3910   SeekToEndOfFile(catfp);
3911  CatSize = catfp.tell();
3912  CatSizeEnd = CatSize;
3913  '''
3914  try:
3915   catfp.seek(0, 0);
3916  except OSError:
3917   return False;
3918  except ValueError:
3919   return False;
3920  curloc = catfp.tell();
3921  if(curloc>0):
3922   catfp.seek(0, 0);
3923  catheader = ReadFileHeaderData(catfp, 4, formatspecs[5]);
3924  if(curloc>0):
3925   catfp.seek(curloc, 0);
3926  catstring = catheader[0];
3927  catversion = re.findall(r"([\d]+)$", catstring);
3928  fprenumfiles = catheader[1];
3929  fnumfiles = int(fprenumfiles, 16);
3930  fprechecksumtype = catheader[2];
3931  fprechecksum = catheader[3];
3932  fileheader = AppendNullByte(catstring, formatspecs[5]);
3933  fnumfileshex = format(int(fnumfiles), 'x').lower();
3934  fileheader = fileheader + AppendNullBytes([fnumfileshex, fprechecksumtype], formatspecs[5]);
3935  if(fprechecksumtype=="none" or fprechecksumtype==""):
3936   catfileheadercshex = format(0, 'x').lower();
3937  elif(fprechecksumtype=="crc16" or fprechecksumtype=="crc16_ansi" or fprechecksumtype=="crc16_ibm"):
3938   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
3939  elif(fprechecksumtype=="crc16_ccitt"):
3940   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
3941  elif(fprechecksumtype=="adler32"):
3942   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
3943  elif(fprechecksumtype=="crc32"):
3944   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
3945  elif(fprechecksumtype=="crc64_ecma"):
3946   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3947  elif(fprechecksumtype=="crc64" or fprechecksumtype=="crc64_iso"):
3948   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3949  elif(CheckSumSupportAlt(fprechecksumtype, hashlib_guaranteed)):
3950   checksumoutstr = hashlib.new(fprechecksumtype);
3951   checksumoutstr.update(fileheader.encode('UTF-8'));
3952   catfileheadercshex = checksumoutstr.hexdigest().lower();
3953  else:
3954   catfileheadercshex = format(0, 'x').lower();
3955  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
3956  fheadtell = len(fileheader);
3957  if(fprechecksum!=catfileheadercshex and not skipchecksum):
3958   VerbosePrintOut("File Header Checksum Error with file " + infile + " at offset " + str(0));
3959   return False;
3960  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
3961  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': {}};
3962  if(seekto>=fnumfiles):
3963   seekto = fnumfiles - 1;
3964  if(seekto<0):
3965   seekto = 0;
3966  if(seekto>=0):
3967   il = -1;
3968   while(il < seekto):
3969    prefhstart = catfp.tell();
3970    if(formatspecs[7]):
3971     preheaderdata = ReadFileHeaderDataBySize(catfp, formatspecs[5]);
3972    else:
3973     preheaderdata = ReadFileHeaderDataWoSize(catfp, formatspecs[5]);
3974    if(len(preheaderdata)==0):
3975     break;
3976    prefheadsize = int(preheaderdata[0], 16);
3977    prefnumfields = int(preheaderdata[1], 16);
3978    preftype = int(preheaderdata[2], 16);
3979    if(re.findall("^[.|/]", preheaderdata[3])):
3980     prefname = preheaderdata[3];
3981    else:
3982     prefname = "./"+preheaderdata[3];
3983    prefbasedir = os.path.dirname(prefname);
3984    preflinkname = preheaderdata[4];
3985    prefsize = int(preheaderdata[5], 16);
3986    prefatime = int(preheaderdata[6], 16);
3987    prefmtime = int(preheaderdata[7], 16);
3988    prefctime = int(preheaderdata[8], 16);
3989    prefbtime = int(preheaderdata[9], 16);
3990    prefmode = int(preheaderdata[10], 16);
3991    prefchmode = stat.S_IMODE(prefmode);
3992    preftypemod = stat.S_IFMT(prefmode);
3993    prefwinattributes = int(preheaderdata[11], 16);
3994    prefuid = int(preheaderdata[12], 16);
3995    prefuname = preheaderdata[13];
3996    prefgid = int(preheaderdata[14], 16);
3997    prefgname = preheaderdata[15];
3998    fid = int(preheaderdata[16], 16);
3999    finode = int(preheaderdata[17], 16);
4000    flinkcount = int(preheaderdata[18], 16);
4001    prefdev_minor = int(preheaderdata[19], 16);
4002    prefdev_major = int(preheaderdata[20], 16);
4003    prefrdev_minor = int(preheaderdata[22], 16);
4004    prefrdev_major = int(preheaderdata[23], 16);
4005    prefextrasize = int(preheaderdata[24], 16);
4006    prefextrafields = int(preheaderdata[25], 16);
4007    extrafieldslist = [];
4008    extrastart = 25;
4009    extraend = extrastart + prefextrafields;
4010    extrafieldslist = [];
4011    if(extrastart<extraend):
4012     extrafieldslist.append(preheaderdata[extrastart]);
4013     extrastart = extrastart + 1;
4014    prefchecksumtype = preheaderdata[extrastart].lower();
4015    prefcs = preheaderdata[extrastart + 1].lower();
4016    prefccs = preheaderdata[extrastart + 2].lower();
4017    hc = 0;
4018    hcmax = len(preheaderdata) - 2;
4019    hout = "";
4020    while(hc<hcmax):
4021     hout = hout + AppendNullByte(preheaderdata[hc], formatspecs[5]);
4022     hc = hc + 1;
4023    prenewfcs = GetFileChecksum(hout, preheaderdata[-3].lower(), True, formatspecs);
4024    if(prefcs!=prenewfcs and not skipchecksum):
4025     VerbosePrintOut("File Header Checksum Error with file " + prefname + " at offset " + str(prefhstart));
4026     return False;
4027     valid_archive = False;
4028     invalid_archive = True;
4029    prefhend = catfp.tell() - 1;
4030    prefcontentstart = catfp.tell();
4031    prefcontents = "";
4032    pyhascontents = False;
4033    if(prefsize>0):
4034     prefcontents = catfp.read(prefsize);
4035     prenewfccs = GetFileChecksum(prefcontents, preheaderdata[-3].lower(), False, formatspecs);
4036     pyhascontents = True;
4037     if(prefccs!=prenewfccs and not skipchecksum):
4038      VerbosePrintOut("File Content Checksum Error with file " + prefname + " at offset " + str(prefcontentstart));
4039      return False;
4040    catfp.seek(1, 1);
4041    il = il + 1;
4042  catfp.seek(seekstart, 0);
4043  fileidnum = il;
4044  catfheadsize = int(preheaderdata[0], 16);
4045  catfnumfields = int(preheaderdata[1], 16);
4046  catftype = int(preheaderdata[2], 16);
4047  if(re.findall("^[.|/]", preheaderdata[3])):
4048   catfname = preheaderdata[3];
4049  else:
4050   catfname = "./"+preheaderdata[3];
4051  catflinkname = preheaderdata[4];
4052  catfsize = int(preheaderdata[5], 16);
4053  catfbasedir = os.path.dirname(catfname);
4054  catlist = {'fid': fileidnum, 'foffset': catfp.tell(), 'ftype': catftype, 'fname': catfname, 'fbasedir': catfbasedir, 'flinkname': catflinkname, 'fsize': catfsize};
4055  if(returnfp):
4056   catlist.update({'catfp': catfp});
4057  else:
4058   catfp.close();
4059  return catlist;
4060
4061 create_alias_function("", __file_format_name__, "SeekToFileNum", ArchiveFileSeekToFileNum);
4062
4063 def ArchiveFileSeekToFileName(infile, seekfile=None, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4064  if(hasattr(infile, "read") or hasattr(infile, "write")):
4065   catfp = infile;
4066   catfp.seek(0, 0);
4067   catfp = UncompressArchiveFile(catfp, formatspecs);
4068   checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True);
4069   if(checkcompressfile=="tarfile"):
4070    return TarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4071   if(checkcompressfile=="zipfile"):
4072    return ZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4073   if(rarfile_support and checkcompressfile=="rarfile"):
4074    return RarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4075   if(py7zr_support and checkcompressfile=="7zipfile"):
4076    return SevenZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4077   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4078    return False;
4079   if(not catfp):
4080    return False;
4081   catfp.seek(0, 0);
4082  elif(infile=="-"):
4083   catfp = BytesIO();
4084   if(hasattr(sys.stdin, "buffer")):
4085    shutil.copyfileobj(sys.stdin.buffer, catfp);
4086   else:
4087    shutil.copyfileobj(sys.stdin, catfp);
4088   catfp.seek(0, 0);
4089   catfp = UncompressArchiveFile(catfp, formatspecs);
4090   if(not catfp):
4091    return False;
4092   catfp.seek(0, 0);
4093  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
4094   catfp = download_file_from_internet_file(infile);
4095   catfp = UncompressArchiveFile(catfp, formatspecs);
4096   catfp.seek(0, 0);
4097   if(not catfp):
4098    return False;
4099   catfp.seek(0, 0);
4100  else:
4101   infile = RemoveWindowsPath(infile);
4102   checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
4103   if(checkcompressfile=="tarfile"):
4104    return TarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4105   if(checkcompressfile=="zipfile"):
4106    return ZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4107   if(rarfile_support and checkcompressfile=="rarfile"):
4108    return RarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4109   if(py7zr_support and checkcompressfile=="7zipfile"):
4110    return SevenZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4111   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4112    return False;
4113   compresscheck = CheckCompressionType(infile, formatspecs, True);
4114   if(not compresscheck):
4115    fextname = os.path.splitext(infile)[1];
4116    if(fextname==".gz"):
4117     compresscheck = "gzip";
4118    elif(fextname==".bz2"):
4119     compresscheck = "bzip2";
4120    elif(fextname==".zst"):
4121     compresscheck = "zstd";
4122    elif(fextname==".lz4" or fextname==".clz4"):
4123     compresscheck = "lz4";
4124    elif(fextname==".lzo" or fextname==".lzop"):
4125     compresscheck = "lzo";
4126    elif(fextname==".lzma" or fextname==".xz"):
4127     compresscheck = "lzma";
4128    else:
4129     return False;
4130   if(not compresscheck):
4131    return False;
4132   catfp = UncompressFile(infile, formatspecs, "rb");
4133  '''
4134  try:
4135   catfp.seek(0, 2);
4136  except OSError:
4137   SeekToEndOfFile(catfp);
4138  except ValueError:
4139   SeekToEndOfFile(catfp);
4140  CatSize = catfp.tell();
4141  CatSizeEnd = CatSize;
4142  '''
4143  try:
4144   catfp.seek(0, 0);
4145  except OSError:
4146   return False;
4147  except ValueError:
4148   return False;
4149  curloc = catfp.tell();
4150  if(curloc>0):
4151   catfp.seek(0, 0);
4152  catheader = ReadFileHeaderData(catfp, 4, formatspecs[5]);
4153  if(curloc>0):
4154   catfp.seek(curloc, 0);
4155  catstring = catheader[0];
4156  catversion = re.findall(r"([\d]+)$", catstring);
4157  fprenumfiles = catheader[1];
4158  fnumfiles = int(fprenumfiles, 16);
4159  fprechecksumtype = catheader[2];
4160  fprechecksum = catheader[3];
4161  fileheader = AppendNullByte(catstring, formatspecs[5]);
4162  fnumfileshex = format(int(fnumfiles), 'x').lower();
4163  fileheader = fileheader + AppendNullBytes([fnumfileshex, fprechecksumtype], formatspecs[5]);
4164  if(fprechecksumtype=="none" or fprechecksumtype==""):
4165   catfileheadercshex = format(0, 'x').lower();
4166  elif(fprechecksumtype=="crc16" or fprechecksumtype=="crc16_ansi" or fprechecksumtype=="crc16_ibm"):
4167   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4168  elif(fprechecksumtype=="crc16_ccitt"):
4169   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4170  elif(fprechecksumtype=="adler32"):
4171   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4172  elif(fprechecksumtype=="crc32"):
4173   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4174  elif(fprechecksumtype=="crc64_ecma"):
4175   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4176  elif(fprechecksumtype=="crc64" or fprechecksumtype=="crc64_iso"):
4177   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4178  elif(CheckSumSupportAlt(fprechecksumtype, hashlib_guaranteed)):
4179   checksumoutstr = hashlib.new(fprechecksumtype);
4180   checksumoutstr.update(fileheader.encode('UTF-8'));
4181   catfileheadercshex = checksumoutstr.hexdigest().lower();
4182  else:
4183   catfileheadercshex = format(0, 'x').lower();
4184  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
4185  fheadtell = len(fileheader);
4186  if(fprechecksum!=catfileheadercshex and not skipchecksum):
4187   VerbosePrintOut("File Header Checksum Error with file " + infile + " at offset " + str(0));
4188   return False;
4189  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
4190  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': {}};
4191  seekto = fnumfiles - 1
4192  filefound = False;
4193  if(seekto>=0):
4194   il = -1;
4195   while(il < seekto):
4196    prefhstart = catfp.tell();
4197    if(formatspecs[7]):
4198     preheaderdata = ReadFileHeaderDataBySize(catfp, formatspecs[5]);
4199    else:
4200     preheaderdata = ReadFileHeaderDataWoSize(catfp, formatspecs[5]);
4201    if(len(preheaderdata)==0):
4202     break;
4203    prefheadsize = int(preheaderdata[0], 16);
4204    prefnumfields = int(preheaderdata[1], 16);
4205    preftype = int(preheaderdata[2], 16);
4206    if(re.findall("^[.|/]", preheaderdata[3])):
4207     prefname = preheaderdata[3];
4208    else:
4209     prefname = "./"+preheaderdata[3];
4210    prefbasedir = os.path.dirname(prefname);
4211    preflinkname = preheaderdata[4];
4212    prefsize = int(preheaderdata[5], 16);
4213    prefatime = int(preheaderdata[6], 16);
4214    prefmtime = int(preheaderdata[7], 16);
4215    prefctime = int(preheaderdata[8], 16);
4216    prefbtime = int(preheaderdata[9], 16);
4217    prefmode = int(preheaderdata[10], 16);
4218    prefchmode = stat.S_IMODE(prefmode);
4219    preftypemod = stat.S_IFMT(prefmode);
4220    prefwinattributes = int(preheaderdata[11], 16);
4221    prefuid = int(preheaderdata[12], 16);
4222    prefuname = preheaderdata[13];
4223    prefgid = int(preheaderdata[14], 16);
4224    prefgname = preheaderdata[15];
4225    fid = int(preheaderdata[16], 16);
4226    finode = int(preheaderdata[17], 16);
4227    flinkcount = int(preheaderdata[18], 16);
4228    prefdev_minor = int(preheaderdata[19], 16);
4229    prefdev_major = int(preheaderdata[20], 16);
4230    prefrdev_minor = int(preheaderdata[22], 16);
4231    prefrdev_major = int(preheaderdata[23], 16);
4232    prefextrasize = int(preheaderdata[24], 16);
4233    prefextrafields = int(preheaderdata[25], 16);
4234    extrafieldslist = [];
4235    extrastart = 25;
4236    extraend = extrastart + prefextrafields;
4237    extrafieldslist = [];
4238    if(extrastart<extraend):
4239     extrafieldslist.append(preheaderdata[extrastart]);
4240     extrastart = extrastart + 1;
4241    prefchecksumtype = preheaderdata[extrastart].lower();
4242    prefcs = preheaderdata[extrastart + 1].lower();
4243    prefccs = preheaderdata[extrastart + 2].lower();
4244    hc = 0;
4245    hcmax = len(preheaderdata) - 2;
4246    hout = "";
4247    while(hc<hcmax):
4248     hout = hout + AppendNullByte(preheaderdata[hc], formatspecs[5]);
4249     hc = hc + 1;
4250    prenewfcs = GetFileChecksum(hout, preheaderdata[-3].lower(), True, formatspecs);
4251    if(prefcs!=prenewfcs and not skipchecksum):
4252     VerbosePrintOut("File Header Checksum Error with file " + prefname + " at offset " + str(prefhstart));
4253     return False;
4254     valid_archive = False;
4255     invalid_archive = True;
4256    prefhend = catfp.tell() - 1;
4257    prefcontentstart = catfp.tell();
4258    prefcontents = "";
4259    pyhascontents = False;
4260    if(prefsize>0):
4261     prefcontents = catfp.read(prefsize);
4262     prenewfccs = GetFileChecksum(prefcontents, preheaderdata[-3].lower(), False, formatspecs);
4263     pyhascontents = True;
4264     if(prefccs!=prenewfccs and not skipchecksum):
4265      VerbosePrintOut("File Content Checksum Error with file " + prefname + " at offset " + str(prefcontentstart));
4266      return False;
4267    catfp.seek(1, 1);
4268    il = il + 1;
4269    filefound = False;
4270    prefname = preheaderdata[2];
4271    if(re.findall("^[.|/]", preheaderdata[2])):
4272     prefname = preheaderdata[2];
4273    else:
4274     prefname = "./"+preheaderdata[2];
4275    if(prefname==seekfile):
4276     filefound = True;
4277     break;
4278  catfp.seek(seekstart, 0);
4279  fileidnum = il;
4280  catfheadsize = int(preheaderdata[0], 16);
4281  catfnumfields = int(preheaderdata[1], 16);
4282  catftype = int(preheaderdata[2], 16);
4283  if(re.findall("^[.|/]", preheaderdata[3])):
4284   catfname = preheaderdata[3];
4285  else:
4286   catfname = "./"+preheaderdata[3];
4287  catflinkname = preheaderdata[4];
4288  catfsize = int(preheaderdata[5], 16);
4289  catfbasedir = os.path.dirname(catfname);
4290  if(filefound):
4291   catlist = {'fid': fileidnum, 'foffset': catfp.tell(), 'ftype': catftype, 'fname': catfname, 'fbasedir': catfbasedir, 'flinkname': catflinkname, 'fsize': catfsize};
4292  else:
4293   return False;
4294  if(returnfp):
4295   catlist.update({'catfp': catfp});
4296  else:
4297   catfp.close();
4298  return catlist;
4299
4300 create_alias_function("", __file_format_name__, "SeekToFileName", ArchiveFileSeekToFileName);
4301
4302 def ArchiveFileValidate(infile, formatspecs=__file_format_list__, verbose=False, returnfp=False):
4303  if(verbose):
4304   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
4305  if(hasattr(infile, "read") or hasattr(infile, "write")):
4306   catfp = infile;
4307   catfp.seek(0, 0);
4308   catfp = UncompressArchiveFile(catfp, formatspecs);
4309   checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True);
4310   if(checkcompressfile=="tarfile"):
4311    return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4312   if(checkcompressfile=="zipfile"):
4313    return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4314   if(rarfile_support and checkcompressfile=="rarfile"):
4315    return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4316   if(py7zr_support and checkcompressfile=="7zipfile"):
4317    return SevenZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4318   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4319    return False;
4320   if(not catfp):
4321    return False;
4322   catfp.seek(0, 0);
4323  elif(infile=="-"):
4324   catfp = BytesIO();
4325   if(hasattr(sys.stdin, "buffer")):
4326    shutil.copyfileobj(sys.stdin.buffer, catfp);
4327   else:
4328    shutil.copyfileobj(sys.stdin, catfp);
4329   catfp.seek(0, 0);
4330   catfp = UncompressArchiveFile(catfp, formatspecs);
4331   if(not catfp):
4332    return False;
4333   catfp.seek(0, 0);
4334  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
4335   catfp = download_file_from_internet_file(infile);
4336   catfp = UncompressArchiveFile(catfp, formatspecs);
4337   catfp.seek(0, 0);
4338   if(not catfp):
4339    return False;
4340   catfp.seek(0, 0);
4341  else:
4342   infile = RemoveWindowsPath(infile);
4343   checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
4344   if(checkcompressfile=="tarfile"):
4345    return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4346   if(checkcompressfile=="zipfile"):
4347    return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4348   if(rarfile_support and checkcompressfile=="rarfile"):
4349    return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4350   if(py7zr_support and checkcompressfile=="7zipfile"):
4351    return SevenZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4352   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4353    return False;
4354   compresscheck = CheckCompressionType(infile, formatspecs, True);
4355   if(not compresscheck):
4356    fextname = os.path.splitext(infile)[1];
4357    if(fextname==".gz"):
4358     compresscheck = "gzip";
4359    elif(fextname==".bz2"):
4360     compresscheck = "bzip2";
4361    elif(fextname==".zst"):
4362     compresscheck = "zstd";
4363    elif(fextname==".lz4" or fextname==".clz4"):
4364     compresscheck = "lz4";
4365    elif(fextname==".lzo" or fextname==".lzop"):
4366     compresscheck = "lzo";
4367    elif(fextname==".lzma" or fextname==".xz"):
4368     compresscheck = "lzma";
4369    else:
4370     return False;
4371   if(not compresscheck):
4372    return False;
4373   catfp = UncompressFile(infile, formatspecs, "rb");
4374  '''
4375  try:
4376   catfp.seek(0, 2);
4377  except OSError:
4378   SeekToEndOfFile(catfp);
4379  except ValueError:
4380   SeekToEndOfFile(catfp);
4381  CatSize = catfp.tell();
4382  CatSizeEnd = CatSize;
4383  '''
4384  try:
4385   catfp.seek(0, 0);
4386  except OSError:
4387   return False;
4388  except ValueError:
4389   return False;
4390  curloc = catfp.tell();
4391  if(curloc>0):
4392   catfp.seek(0, 0);
4393  catheader = ReadFileHeaderData(catfp, 4, formatspecs[5]);
4394  if(curloc>0):
4395   catfp.seek(curloc, 0);
4396  catstring = catheader[0];
4397  catversion = re.findall(r"([\d]+)$", catstring);
4398  fprenumfiles = catheader[1];
4399  fnumfiles = int(fprenumfiles, 16);
4400  fprechecksumtype = catheader[2];
4401  fprechecksum = catheader[3];
4402  il = 0;
4403  fileheader = AppendNullByte(catstring, formatspecs[5]);
4404  fnumfileshex = format(int(fnumfiles), 'x').lower();
4405  fileheader = fileheader + AppendNullBytes([fnumfileshex, fprechecksumtype], formatspecs[5]);
4406  if(fprechecksumtype=="none" or fprechecksumtype==""):
4407   catfileheadercshex = format(0, 'x').lower();
4408  elif(fprechecksumtype=="crc16" or fprechecksumtype=="crc16_ansi" or fprechecksumtype=="crc16_ibm"):
4409   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4410  elif(fprechecksumtype=="crc16_ccitt"):
4411   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4412  elif(fprechecksumtype=="adler32"):
4413   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4414  elif(fprechecksumtype=="crc32"):
4415   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4416  elif(fprechecksumtype=="crc64_ecma"):
4417   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4418  elif(fprechecksumtype=="crc64" or fprechecksumtype=="crc64_iso"):
4419   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4420  elif(CheckSumSupportAlt(fprechecksumtype, hashlib_guaranteed)):
4421   checksumoutstr = hashlib.new(fprechecksumtype);
4422   checksumoutstr.update(fileheader.encode('UTF-8'));
4423   catfileheadercshex = checksumoutstr.hexdigest().lower();
4424  else:
4425   catfileheadercshex = format(0, 'x').lower();
4426  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
4427  valid_archive = True;
4428  invalid_archive = False;
4429  if(verbose):
4430   VerbosePrintOut(infile);
4431   VerbosePrintOut("Number of Records " + str(fnumfiles));
4432  if(fprechecksum==catfileheadercshex):
4433   if(verbose):
4434    VerbosePrintOut("File Header Checksum Passed at offset " + str(0));
4435  else:
4436   if(verbose):
4437    VerbosePrintOut("File Header Checksum Failed at offset " + str(0));
4438    valid_archive = False;
4439    invalid_archive = True;
4440  if(verbose):
4441   VerbosePrintOut("");
4442  while(il<fnumfiles):
4443   catfhstart = catfp.tell();
4444   if(formatspecs[7]):
4445    catheaderdata = ReadFileHeaderDataBySize(catfp, formatspecs[5]);
4446   else:
4447    catheaderdata = ReadFileHeaderDataWoSize(catfp, formatspecs[5]);
4448   if(len(catheaderdata)==0):
4449    break;
4450   catfheadsize = int(catheaderdata[0], 16);
4451   catfnumfields = int(catheaderdata[1], 16);
4452   catftype = int(catheaderdata[2], 16);
4453   if(re.findall("^[.|/]", catheaderdata[3])):
4454    catfname = catheaderdata[3];
4455   else:
4456    catfname = "./"+catheaderdata[3];
4457   catfbasedir = os.path.dirname(catfname);
4458   catflinkname = catheaderdata[4];
4459   catfsize = int(catheaderdata[5], 16);
4460   catfatime = int(catheaderdata[6], 16);
4461   catfmtime = int(catheaderdata[7], 16);
4462   catfctime = int(catheaderdata[8], 16);
4463   catfbtime = int(catheaderdata[9], 16);
4464   catfmode = int(catheaderdata[10], 16);
4465   catfchmode = stat.S_IMODE(catfmode);
4466   catftypemod = stat.S_IFMT(catfmode);
4467   prefwinattributes = int(catheaderdata[11], 16);
4468   catfuid = int(catheaderdata[12], 16);
4469   catfuname = catheaderdata[13];
4470   catfgid = int(catheaderdata[14], 16);
4471   catfgname = catheaderdata[15];
4472   fid = int(catheaderdata[16], 16);
4473   finode = int(catheaderdata[17], 16);
4474   flinkcount = int(catheaderdata[18], 16);
4475   catfdev_minor = int(catheaderdata[19], 16);
4476   catfdev_major = int(catheaderdata[20], 16);
4477   catfrdev_minor = int(catheaderdata[21], 16);
4478   catfrdev_major = int(catheaderdata[22], 16);
4479   catfextrasize = int(catheaderdata[23], 16);
4480   catfextrafields = int(catheaderdata[24], 16);
4481   extrafieldslist = [];
4482   extrastart = 25;
4483   extraend = extrastart + catfextrafields;
4484   extrafieldslist = [];
4485   if(extrastart<extraend):
4486    extrafieldslist.append(catheaderdata[extrastart]);
4487    extrastart = extrastart + 1;
4488   catfchecksumtype = catheaderdata[extrastart].lower();
4489   catfcs = catheaderdata[extrastart + 1].lower();
4490   catfccs = catheaderdata[extrastart + 2].lower();
4491   hc = 0;
4492   hcmax = len(catheaderdata) - 2;
4493   hout = "";
4494   while(hc<hcmax):
4495    hout = hout + AppendNullByte(catheaderdata[hc], formatspecs[5]);
4496    hc = hc + 1;
4497   catnewfcs = GetFileChecksum(hout, catheaderdata[-3].lower(), True, formatspecs);
4498   if(verbose):
4499    VerbosePrintOut(catfname);
4500    VerbosePrintOut("Record Number " + str(il) + "; File ID " + str(fid) + "; iNode Number " + str(finode));
4501   if(catfcs==catnewfcs):
4502    if(verbose):
4503     VerbosePrintOut("File Header Checksum Passed at offset " + str(catfhstart));
4504   else:
4505    if(verbose):
4506     VerbosePrintOut("File Header Checksum Failed at offset " + str(catfhstart));
4507    valid_archive = False;
4508    invalid_archive = True;
4509   catfhend = catfp.tell() - 1;
4510   catfcontentstart = catfp.tell();
4511   catfcontents = "";
4512   pyhascontents = False;
4513   if(catfsize>0):
4514    catfcontents = catfp.read(catfsize);
4515    catnewfccs = GetFileChecksum(catfcontents, catheaderdata[-3].lower(), False, formatspecs);
4516    pyhascontents = True;
4517    if(catfccs==catnewfccs):
4518     if(verbose):
4519      VerbosePrintOut("File Content Checksum Passed at offset " + str(catfcontentstart));
4520    else:
4521     if(verbose):
4522      VerbosePrintOut("File Content Checksum Failed at offset " + str(catfcontentstart));
4523     valid_archive = False;
4524     invalid_archive = True;
4525   if(verbose):
4526    VerbosePrintOut("");
4527   catfp.seek(1, 1);
4528   il = il + 1;
4529  if(valid_archive):
4530   if(returnfp):
4531    return catfp;
4532   else:
4533    catfp.close();
4534    return True;
4535  else:
4536   catfp.close();
4537   return False;
4538
4539 create_alias_function("", __file_format_name__, "Validate", ArchiveFileValidate);
4540
4541 def ArchiveFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4542  if(hasattr(infile, "read") or hasattr(infile, "write")):
4543   catfp = infile;
4544   catfp.seek(0, 0);
4545   catfp = UncompressArchiveFile(catfp, formatspecs);
4546   checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True);
4547   if(checkcompressfile=="tarfile"):
4548    return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4549   if(checkcompressfile=="zipfile"):
4550    return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4551   if(rarfile_support and checkcompressfile=="rarfile"):
4552    return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4553   if(py7zr_support and checkcompressfile=="7zipfile"):
4554    return SevenZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4555   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4556    return False;
4557   if(not catfp):
4558    return False;
4559   catfp.seek(0, 0);
4560  elif(infile=="-"):
4561   catfp = BytesIO();
4562   if(hasattr(sys.stdin, "buffer")):
4563    shutil.copyfileobj(sys.stdin.buffer, catfp);
4564   else:
4565    shutil.copyfileobj(sys.stdin, catfp);
4566   catfp.seek(0, 0);
4567   catfp = UncompressArchiveFile(catfp, formatspecs);
4568   if(not catfp):
4569    return False;
4570   catfp.seek(0, 0);
4571  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
4572   catfp = download_file_from_internet_file(infile);
4573   catfp = UncompressArchiveFile(catfp, formatspecs);
4574   catfp.seek(0, 0);
4575   if(not catfp):
4576    return False;
4577   catfp.seek(0, 0);
4578  else:
4579   infile = RemoveWindowsPath(infile);
4580   checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
4581   if(checkcompressfile=="tarfile"):
4582    return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4583   if(checkcompressfile=="zipfile"):
4584    return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4585   if(rarfile_support and checkcompressfile=="rarfile"):
4586    return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4587   if(py7zr_support and checkcompressfile=="7zipfile"):
4588    return SevenZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4589   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4590    return False;
4591   compresscheck = CheckCompressionType(infile, formatspecs, True);
4592   if(not compresscheck):
4593    fextname = os.path.splitext(infile)[1];
4594    if(fextname==".gz"):
4595     compresscheck = "gzip";
4596    elif(fextname==".bz2"):
4597     compresscheck = "bzip2";
4598    elif(fextname==".zst"):
4599     compresscheck = "zstd";
4600    elif(fextname==".lz4" or fextname==".clz4"):
4601     compresscheck = "lz4";
4602    elif(fextname==".lzo" or fextname==".lzop"):
4603     compresscheck = "lzo";
4604    elif(fextname==".lzma" or fextname==".xz"):
4605     compresscheck = "lzma";
4606    else:
4607     return False;
4608   if(not compresscheck):
4609    return False;
4610   catfp = UncompressFile(infile, formatspecs, "rb");
4611  '''
4612  try:
4613   catfp.seek(0, 2);
4614  except OSError:
4615   SeekToEndOfFile(catfp);
4616  except ValueError:
4617   SeekToEndOfFile(catfp);
4618  CatSize = catfp.tell();
4619  CatSizeEnd = CatSize;
4620  '''
4621  try:
4622   catfp.seek(0, 0);
4623  except OSError:
4624   return False;
4625  except ValueError:
4626   return False;
4627  curloc = catfp.tell();
4628  if(curloc>0):
4629   catfp.seek(0, 0);
4630  catheader = ReadFileHeaderData(catfp, 4, formatspecs[5]);
4631  if(curloc>0):
4632   catfp.seek(curloc, 0);
4633  catstring = catheader[0];
4634  catversion = re.findall(r"([\d]+)$", catstring);
4635  fprenumfiles = catheader[1];
4636  fnumfiles = int(fprenumfiles, 16);
4637  fprechecksumtype = catheader[2];
4638  fprechecksum = catheader[3];
4639  fileheader = AppendNullByte(catstring, formatspecs[5]);
4640  fnumfileshex = format(int(fnumfiles), 'x').lower();
4641  fileheader = fileheader + AppendNullBytes([fnumfileshex, fprechecksumtype], formatspecs[5]);
4642  if(fprechecksumtype=="none" or fprechecksumtype==""):
4643   catfileheadercshex = format(0, 'x').lower();
4644  elif(fprechecksumtype=="crc16" or fprechecksumtype=="crc16_ansi" or fprechecksumtype=="crc16_ibm"):
4645   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4646  elif(fprechecksumtype=="crc16_ccitt"):
4647   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4648  elif(fprechecksumtype=="adler32"):
4649   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4650  elif(fprechecksumtype=="crc32"):
4651   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4652  elif(fprechecksumtype=="crc64_ecma"):
4653   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4654  elif(fprechecksumtype=="crc64" or fprechecksumtype=="crc64_iso"):
4655   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4656  elif(CheckSumSupportAlt(fprechecksumtype, hashlib_guaranteed)):
4657   checksumoutstr = hashlib.new(fprechecksumtype);
4658   checksumoutstr.update(fileheader.encode('UTF-8'));
4659   catfileheadercshex = checksumoutstr.hexdigest().lower();
4660  else:
4661   catfileheadercshex = format(0, 'x').lower();
4662  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
4663  fheadtell = len(fileheader);
4664  if(fprechecksum!=catfileheadercshex and not skipchecksum):
4665   VerbosePrintOut("File Header Checksum Error with file " + infile + " at offset " + str(0));
4666   return False;
4667  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
4668  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': {}};
4669  if(seekstart<0 and seekstart>fnumfiles):
4670    seekstart = 0;
4671  if(seekend==0 or seekend>fnumfiles and seekend<seekstart):
4672   seekend = fnumfiles;
4673  elif(seekend<0 and abs(seekend)<=fnumfiles and abs(seekend)>=seekstart):
4674   seekend = fnumfiles - abs(seekend);
4675  if(seekstart>0):
4676   il = 0;
4677   while(il < seekstart):
4678    prefhstart = catfp.tell();
4679    if(formatspecs[7]):
4680     preheaderdata = ReadFileHeaderDataBySize(catfp, formatspecs[5]);
4681    else:
4682     preheaderdata = ReadFileHeaderDataWoSize(catfp, formatspecs[5]);
4683    if(len(preheaderdata)==0):
4684     break;
4685    prefheadsize = int(preheaderdata[0], 16);
4686    prefnumfields = int(preheaderdata[1], 16);
4687    if(re.findall("^[.|/]", preheaderdata[3])):
4688     prefname = preheaderdata[3];
4689    else:
4690     prefname = "./"+preheaderdata[3];
4691    prefsize = int(preheaderdata[5], 16);
4692    prefextrasize = int(preheaderdata[23], 16);
4693    prefextrafields = int(preheaderdata[24], 16);
4694    extrafieldslist = [];
4695    extrastart = 25;
4696    extraend = extrastart + prefextrafields;
4697    extrafieldslist = [];
4698    if(extrastart<extraend):
4699     extrafieldslist.append(preheaderdata[extrastart]);
4700     extrastart = extrastart + 1;
4701    prefchecksumtype = preheaderdata[extrastart].lower();
4702    prefcs = preheaderdata[extrastart + 1].lower();
4703    prefccs = preheaderdata[extrastart + 2].lower();
4704    hc = 0;
4705    hcmax = len(preheaderdata) - 2;
4706    hout = "";
4707    while(hc<hcmax):
4708     hout = hout + AppendNullByte(preheaderdata[hc], formatspecs[5]);
4709     hc = hc + 1;
4710    prenewfcs = GetFileChecksum(hout, preheaderdata[-3].lower(), True, formatspecs);
4711    if(prefcs!=prenewfcs and not skipchecksum):
4712     VerbosePrintOut("File Header Checksum Error with file " + prefname + " at offset " + str(prefhstart));
4713     return False;
4714     valid_archive = False;
4715     invalid_archive = True;
4716    prefhend = catfp.tell() - 1;
4717    prefcontentstart = catfp.tell();
4718    prefcontents = "";
4719    pyhascontents = False;
4720    if(prefsize>0):
4721     prefcontents = catfp.read(prefsize);
4722     prenewfccs = GetFileChecksum(prefcontents, preheaderdata[-3].lower(), False, formatspecs);
4723     pyhascontents = True;
4724     if(prefccs!=prenewfccs and not skipchecksum):
4725      VerbosePrintOut("File Content Checksum Error with file " + prefname + " at offset " + str(prefcontentstart));
4726      return False;
4727    catfp.seek(1, 1);
4728    il = il + 1;
4729  fileidnum = seekstart;
4730  realidnum = 0;
4731  while(fileidnum<seekend):
4732   catfhstart = catfp.tell();
4733   if(formatspecs[7]):
4734    catheaderdata = ReadFileHeaderDataBySize(catfp, formatspecs[5]);
4735   else:
4736    catheaderdata = ReadFileHeaderDataWoSize(catfp, formatspecs[5]);
4737   if(len(catheaderdata)==0):
4738    break;
4739   catfheadsize = int(catheaderdata[0], 16);
4740   catfnumfields = int(catheaderdata[1], 16);
4741   catftype = int(catheaderdata[2], 16);
4742   if(re.findall("^[.|/]", catheaderdata[3])):
4743    catfname = catheaderdata[3];
4744   else:
4745    catfname = "./"+catheaderdata[3];
4746   catfbasedir = os.path.dirname(catfname);
4747   catflinkname = catheaderdata[4];
4748   catfsize = int(catheaderdata[5], 16);
4749   catfatime = int(catheaderdata[6], 16);
4750   catfmtime = int(catheaderdata[7], 16);
4751   catfctime = int(catheaderdata[8], 16);
4752   catfbtime = int(catheaderdata[9], 16);
4753   catfmode = int(catheaderdata[10], 16);
4754   catfchmode = stat.S_IMODE(catfmode);
4755   catftypemod = stat.S_IFMT(catfmode);
4756   catfwinattributes = int(catheaderdata[11], 16);
4757   catfuid = int(catheaderdata[12], 16);
4758   catfuname = catheaderdata[13];
4759   catfgid = int(catheaderdata[14], 16);
4760   catfgname = catheaderdata[15];
4761   fid = int(catheaderdata[16], 16);
4762   finode = int(catheaderdata[17], 16);
4763   flinkcount = int(catheaderdata[18], 16);
4764   catfdev_minor = int(catheaderdata[19], 16);
4765   catfdev_major = int(catheaderdata[20], 16);
4766   catfrdev_minor = int(catheaderdata[21], 16);
4767   catfrdev_major = int(catheaderdata[22], 16);
4768   catfextrasize = int(catheaderdata[23], 16);
4769   catfextrafields = int(catheaderdata[24], 16);
4770   extrafieldslist = [];
4771   extrastart = 25;
4772   extraend = extrastart + catfextrafields;
4773   extrafieldslist = [];
4774   if(extrastart<extraend):
4775    extrafieldslist.append(catheaderdata[extrastart]);
4776    extrastart = extrastart + 1;
4777   catfchecksumtype = catheaderdata[extrastart].lower();
4778   catfcs = catheaderdata[extrastart + 1].lower();
4779   catfccs = catheaderdata[extrastart + 2].lower();
4780   hc = 0;
4781   hcmax = len(catheaderdata) - 2;
4782   hout = "";
4783   while(hc<hcmax):
4784    hout = hout + AppendNullByte(catheaderdata[hc], formatspecs[5]);
4785    hc = hc + 1;
4786   catnewfcs = GetFileChecksum(hout, catheaderdata[-3].lower(), True, formatspecs);
4787   if(catfcs!=catnewfcs and not skipchecksum):
4788    VerbosePrintOut("File Header Checksum Error with file " + catfname + " at offset " + str(catfhstart));
4789    return False;
4790   catfhend = catfp.tell() - 1;
4791   catfcontentstart = catfp.tell();
4792   catfcontents = "";
4793   pyhascontents = False;
4794   if(catfsize>0 and not listonly):
4795    catfcontents = catfp.read(catfsize);
4796    catnewfccs = GetFileChecksum(catfcontents, catheaderdata[-3].lower(), False, formatspecs);
4797    pyhascontents = True;
4798    if(catfccs!=catnewfccs and skipchecksum):
4799     VerbosePrintOut("File Content Checksum Error with file " + catfname + " at offset " + str(catfcontentstart));
4800     return False;
4801   if(catfsize>0 and listonly):
4802    catfp.seek(catfsize, 1);
4803    pyhascontents = False;
4804   catfp.seek(1, 1);
4805   catfcontentend = catfp.tell() - 1;
4806   catlist['ffilelist'].update({realidnum: {'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, 'fuid': catfuid, 'funame': catfuname, 'fgid': catfgid, 'fgname': catfgname, 'finode': finode, 'flinkcount': flinkcount, 'fminor': catfdev_minor, 'fmajor': catfdev_major, 'frminor': catfrdev_minor, 'frmajor': catfrdev_major, 'fchecksumtype': catfchecksumtype, 'fnumfields': catfnumfields + 2, 'frawheader': catheaderdata, 'fextrafields': catfextrafields, 'fextrafieldsize': catfextrasize, 'fextralist': extrafieldslist, 'fheaderchecksum': catfcs, 'fcontentchecksum': catfccs, 'fhascontents': pyhascontents, 'fcontentstart': catfcontentstart, 'fcontentend': catfcontentend, 'fcontents': catfcontents} });
4807   fileidnum = fileidnum + 1;
4808   realidnum = realidnum + 1;
4809  if(returnfp):
4810   catlist.update({'catfp': catfp});
4811  else:
4812   catfp.close();
4813  return catlist;
4814
4815 create_alias_function("", __file_format_name__, "ToArray", ArchiveFileToArray);
4816
4817 def ArchiveFileStringToArray(catstr, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4818  catfp = BytesIO(catstr);
4819  listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4820  return listcatfiles;
4821
4822 create_alias_function("", __file_format_name__, "StringToArray", ArchiveFileStringToArray);
4823
4824 def TarFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4825  catfp = BytesIO();
4826  catfp = PackArchiveFileFromTarFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
4827  listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4828  return listcatfiles;
4829
4830 def ZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4831  catfp = BytesIO();
4832  catfp = PackArchiveFileFromZipFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
4833  listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4834  return listcatfiles;
4835
4836 if(not rarfile_support):
4837  def RarFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4838   return False;
4839
4840 if(rarfile_support):
4841  def RarFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4842   catfp = BytesIO();
4843   catfp = PackArchiveFileFromSevenZipFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
4844   listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4845   return listcatfiles;
4846
4847 if(not py7zr_support):
4848  def SevenZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4849   return False;
4850
4851 if(py7zr_support):
4852  def SevenZipToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4853   catfp = BytesIO();
4854   catfp = PackArchiveFileFromSevenZipFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
4855   listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4856   return listcatfiles;
4857
4858 def ListDirToArrayAlt(infiles, dirlistfromtxt=False, followlink=False, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
4859  catver = formatspecs[6];
4860  fileheaderver = str(int(catver.replace(".", "")));
4861  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
4862  advancedlist = formatspecs[8];
4863  altinode = formatspecs[9];
4864  infilelist = [];
4865  if(infiles=="-"):
4866   for line in sys.stdin:
4867    infilelist.append(line.strip());
4868   infilelist = list(filter(None, infilelist));
4869  elif(infiles!="-" and dirlistfromtxt and os.path.exists(infiles) and (os.path.isfile(infiles) or infiles=="/dev/null" or infiles=="NUL")):
4870   if(not os.path.exists(infiles) or not os.path.isfile(infiles)):
4871    return False;
4872   with UncompressFile(infiles, formatspecs, "r") as finfile:
4873    for line in finfile:
4874     infilelist.append(line.strip());
4875   infilelist = list(filter(None, infilelist));
4876  else:
4877   if(isinstance(infiles, (list, tuple, ))):
4878    infilelist = list(filter(None, infiles));
4879   elif(isinstance(infiles, (str, ))):
4880    infilelist = list(filter(None, [infiles]));
4881  if(advancedlist):
4882   GetDirList = ListDirAdvanced(infilelist, followlink, False);
4883  else:
4884   GetDirList = ListDir(infilelist, followlink, False);
4885  if(not GetDirList):
4886   return False;
4887  curinode = 0;
4888  curfid = 0;
4889  inodelist = [];
4890  inodetofile = {};
4891  filetoinode = {};
4892  inodetocatinode = {};
4893  fileidnum = 0;
4894  fnumfiles = int(len(GetDirList));
4895  catver = formatspecs[6];
4896  fileheaderver = str(int(catver.replace(".", "")));
4897  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
4898  fnumfileshex = format(int(fnumfiles), 'x').lower();
4899  fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
4900  catversion = re.findall(r"([\d]+)$", fileheader);
4901  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
4902  if(checksumtype=="none" or checksumtype==""):
4903   catfileheadercshex = format(0, 'x').lower();
4904  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
4905   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4906  elif(checksumtype=="crc16_ccitt"):
4907   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4908  elif(checksumtype=="adler32"):
4909   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4910  elif(checksumtype=="crc32"):
4911   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4912  elif(checksumtype=="crc64_ecma"):
4913   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4914  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
4915   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4916  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
4917   checksumoutstr = hashlib.new(checksumtype);
4918   checksumoutstr.update(fileheader.encode('UTF-8'));
4919   catfileheadercshex = checksumoutstr.hexdigest().lower();
4920  else:
4921   catfileheadercshex = format(0, 'x').lower();
4922  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
4923  fheadtell = len(fileheader);
4924  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
4925  for curfname in GetDirList:
4926   if(re.findall("^[.|/]", curfname)):
4927    fname = curfname;
4928   else:
4929    fname = "./"+curfname;
4930   if(verbose):
4931    VerbosePrintOut(fname);
4932   if(not followlink or followlink is None):
4933    fstatinfo = os.lstat(fname);
4934   else:
4935    fstatinfo = os.stat(fname);
4936   fpremode = fstatinfo.st_mode;
4937   finode = fstatinfo.st_ino;
4938   flinkcount = fstatinfo.st_nlink;
4939   ftype = 0;
4940   if(stat.S_ISREG(fpremode)):
4941    ftype = 0;
4942   elif(stat.S_ISLNK(fpremode)):
4943    ftype = 2;
4944   elif(stat.S_ISCHR(fpremode)):
4945    ftype = 3;
4946   elif(stat.S_ISBLK(fpremode)):
4947    ftype = 4;
4948   elif(stat.S_ISDIR(fpremode)):
4949    ftype = 5;
4950   elif(stat.S_ISFIFO(fpremode)):
4951    ftype = 6;
4952   elif(stat.S_ISSOCK(fpremode)):
4953    ftype = 8;
4954   elif(hasattr(stat, "S_ISDOOR") and stat.S_ISDOOR(fpremode)):
4955    ftype = 9;
4956   elif(hasattr(stat, "S_ISPORT") and stat.S_ISPORT(fpremode)):
4957    ftype = 10;
4958   elif(hasattr(stat, "S_ISWHT") and stat.S_ISWHT(fpremode)):
4959    ftype = 11;
4960   else:
4961    ftype = 0;
4962   flinkname = "";
4963   fbasedir = os.path.dirname(fname);
4964   fcurfid = curfid;
4965   if(not followlink and finode!=0):
4966    if(ftype!=1):
4967     if(finode in inodelist):
4968      ftype = 1;
4969      flinkname = inodetofile[finode];
4970      if(altinode):
4971       fcurinode = finode;
4972      else:
4973       fcurinode = inodetocatinode[finode];
4974     if(finode not in inodelist):
4975      inodelist.append(finode);
4976      inodetofile.update({finode: fname});
4977      inodetocatinode.update({finode: curinode});
4978      if(altinode):
4979       fcurinode = finode;
4980      else:
4981       fcurinode = curinode;
4982      curinode = curinode + 1;
4983   else:
4984    fcurinode = curinode;
4985    curinode = curinode + 1;
4986   curfid = curfid + 1;
4987   if(ftype==2):
4988    flinkname = os.readlink(fname);
4989   fdev = fstatinfo.st_dev;
4990   getfdev = GetDevMajorMinor(fdev);
4991   fdev_minor = getfdev[0];
4992   fdev_major = getfdev[1];
4993   frdev = fstatinfo.st_dev;
4994   if(hasattr(fstatinfo, "st_rdev")):
4995    frdev = fstatinfo.st_rdev;
4996   else:
4997    frdev = fstatinfo.st_dev;
4998   getfrdev = GetDevMajorMinor(frdev);
4999   frdev_minor = getfrdev[0];
5000   frdev_major = getfrdev[1];
5001   if(ftype==1 or ftype==2 or ftype==3 or ftype==4 or ftype==5 or ftype==6):
5002    fsize = "0";
5003   if(ftype==0 or ftype==7):
5004    fsize = fstatinfo.st_size;
5005   fatime = fstatinfo.st_atime;
5006   fmtime = fstatinfo.st_mtime;
5007   fctime = fstatinfo.st_ctime;
5008   if(hasattr(fstatinfo, "st_birthtime")):
5009    fbtime = fstatinfo.st_birthtime;
5010   else:
5011    fbtime = fstatinfo.st_ctime;
5012   fmode = fstatinfo.st_mode;
5013   fchmode = stat.S_IMODE(fstatinfo.st_mode);
5014   ftypemod = stat.S_IFMT(fstatinfo.st_mode);
5015   fuid = fstatinfo.st_uid;
5016   fgid = fstatinfo.st_gid;
5017   funame = "";
5018   try:
5019    import pwd;
5020    try:
5021     userinfo = pwd.getpwuid(fstatinfo.st_uid);
5022     funame = userinfo.pw_name;
5023    except KeyError:
5024     funame = "";
5025   except ImportError:
5026    funame = "";
5027   fgname = "";
5028   try:
5029    import grp;
5030    try:
5031     groupinfo = grp.getgrgid(fstatinfo.st_gid);
5032     fgname = groupinfo.gr_name;
5033    except KeyError:
5034     fgname = "";
5035   except ImportError:
5036    fgname = "";
5037   fdev_minor = fdev_minor;
5038   fdev_major = fdev_major;
5039   frdev_minor = frdev_minor;
5040   frdev_major = frdev_major;
5041   finode = finode;
5042   flinkcount = flinkcount;
5043   if(hasattr(fstatinfo, "st_file_attributes")):
5044    fwinattributes = fstatinfo.st_file_attributes;
5045   else:
5046    fwinattributes = 0;
5047   fcontents = "".encode('UTF-8');
5048   chunk_size = 1024;
5049   if(ftype==0 or ftype==7):
5050    with open(fname, "rb") as fpc:
5051     while(True):
5052      chunk = fpc.read(chunk_size);
5053      if(not chunk):
5054       break
5055      fcontents += chunk;
5056   if(followlink and (ftype==1 or ftype==2)):
5057    flstatinfo = os.stat(flinkname);
5058    with open(flinkname, "rb") as fpc:
5059     while(True):
5060      chunk = fpc.read(chunk_size);
5061      if(not chunk):
5062       break;
5063      fcontents += chunk;
5064   ftypehex = format(ftype, 'x').lower();
5065   extrafields = len(extradata);
5066   extrafieldslist = extradata;
5067   catfextrafields = extrafields;
5068   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
5069   if(len(extradata)>0):
5070    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
5071   extrasizelen = len(extrasizestr);
5072   extrasizelenhex = format(extrasizelen, 'x').lower();
5073   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(), format(int(fuid), 'x').lower(), 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(), extrasizelenhex, format(catfextrafields, 'x').lower()];
5074   catoutlen = len(catoutlist) + len(extradata) + 3;
5075   catoutlenhex = format(catoutlen, 'x').lower();
5076   catoutlist.insert(0, catoutlenhex);
5077   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
5078   if(len(extradata)>0):
5079    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
5080   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
5081   catfnumfields = catoutlen;
5082   if(checksumtype=="none" or checksumtype==""):
5083    catfileheadercshex = format(0, 'x').lower();
5084    catfilecontentcshex = format(0, 'x').lower();
5085   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5086    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
5087    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
5088   elif(checksumtype=="crc16_ccitt"):
5089    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
5090    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
5091   elif(checksumtype=="adler32"):
5092    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5093    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
5094   elif(checksumtype=="crc32"):
5095    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5096    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
5097   elif(checksumtype=="crc64_ecma"):
5098    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5099    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
5100   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5101    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5102    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
5103   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5104    checksumoutstr = hashlib.new(checksumtype);
5105    checksumoutstr.update("".encode('UTF-8'));
5106    catfileheadercshex = checksumoutstr.hexdigest().lower();
5107    checksumoutstr = hashlib.new(checksumtype);
5108    checksumoutstr.update(fcontents);
5109    catfilecontentcshex = checksumoutstr.hexdigest().lower();
5110   else:
5111    catfileheadercshex = format(0, 'x').lower();
5112    catfilecontentcshex = format(0, 'x').lower();
5113   catfhstart = fheadtell;
5114   fheadtell += len(catfileoutstr);
5115   catfhend = fheadtell - 1;
5116   catfcontentstart = fheadtell;
5117   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5118   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
5119   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
5120   catheaderdata = [catheaersize] + catoutlist + extradata + [checksumtype, catfileheadercshex, catfilecontentcshex]
5121   if(checksumtype=="none" or checksumtype==""):
5122    catfileheadercshex = format(0, 'x').lower();
5123   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5124    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5125   elif(checksumtype=="crc16_ccitt"):
5126    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5127   elif(checksumtype=="adler32"):
5128    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5129   elif(checksumtype=="crc32"):
5130    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5131   elif(checksumtype=="crc64_ecma"):
5132    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5133   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5134    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5135   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5136    checksumoutstr = hashlib.new(checksumtype);
5137    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
5138    catfileheadercshex = checksumoutstr.hexdigest().lower();
5139   else:
5140    catfileheadercshex = format(0, 'x').lower();
5141   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5142   catfileoutstrecd = catfileoutstr.encode('UTF-8');
5143   nullstrecd = formatspecs[5].encode('UTF-8');
5144   fheadtell += len(catfileoutstr) + 1;
5145   catfcontentend = fheadtell - 1;
5146   catfileout = catfileoutstrecd + fcontents + nullstrecd;
5147   pyhascontents = False;
5148   if(int(fsize)>0 and not listonly):
5149    pyhascontents = True;
5150   if(int(fsize)>0 and listonly):
5151    fcontents = "";
5152    pyhascontents = False;
5153   catlist['ffilelist'].update({fileidnum: {'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, 'fuid': fuid, 'funame': funame, 'fgid': fgid, 'fgname': fgname, 'finode': finode, 'flinkcount': flinkcount, 'fminor': fdev_minor, 'fmajor': fdev_major, 'frminor': frdev_minor, 'frmajor': frdev_major, 'fchecksumtype': 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, 'fcontents': fcontents} });
5154   fileidnum = fileidnum + 1;
5155  return catlist;
5156
5157 def TarFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5158  curinode = 0;
5159  curfid = 0;
5160  inodelist = [];
5161  inodetofile = {};
5162  filetoinode = {};
5163  inodetocatinode = {};
5164  fileidnum = 0;
5165  if(infile=="-"):
5166   infile = BytesIO();
5167   if(hasattr(sys.stdin, "buffer")):
5168    shutil.copyfileobj(sys.stdin.buffer, infile);
5169   else:
5170    shutil.copyfileobj(sys.stdin, infile);
5171   infile.seek(0, 0);
5172   if(not infile):
5173    return False;
5174   infile.seek(0, 0);
5175  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
5176   infile = download_file_from_internet_file(infile);
5177   infile.seek(0, 0);
5178   if(not infile):
5179    return False;
5180   infile.seek(0, 0);
5181  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
5182   return False;
5183  elif(os.path.exists(infile) and os.path.isfile(infile)):
5184   try:
5185    if(not tarfile.is_tarfile(infile)):
5186     return False;
5187   except AttributeError:
5188    if(not is_tarfile(infile)):
5189     return False;
5190  else:
5191   return False;
5192  try:
5193   if(hasattr(infile, "read") or hasattr(infile, "write")):
5194    tarfp = tarfile.open(fileobj=infile, mode="r");
5195   else:
5196    tarfp = tarfile.open(infile, "r");
5197  except FileNotFoundError:
5198   return False;
5199  fnumfiles = int(len(tarfp.getmembers()));
5200  catver = formatspecs[6];
5201  fileheaderver = str(int(catver.replace(".", "")));
5202  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
5203  fnumfileshex = format(int(fnumfiles), 'x').lower();
5204  fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
5205  catversion = re.findall(r"([\d]+)$", fileheader);
5206  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
5207  if(checksumtype=="none" or checksumtype==""):
5208   catfileheadercshex = format(0, 'x').lower();
5209  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5210   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5211  elif(checksumtype=="crc16_ccitt"):
5212   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5213  elif(checksumtype=="adler32"):
5214   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5215  elif(checksumtype=="crc32"):
5216   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5217  elif(checksumtype=="crc64_ecma"):
5218   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5219  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5220   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5221  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5222   checksumoutstr = hashlib.new(checksumtype);
5223   checksumoutstr.update(fileheader.encode('UTF-8'));
5224   catfileheadercshex = checksumoutstr.hexdigest().lower();
5225  else:
5226   catfileheadercshex = format(0, 'x').lower();
5227  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
5228  fheadtell = len(fileheader);
5229  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
5230  for member in sorted(tarfp.getmembers(), key=lambda x: x.name):
5231   if(re.findall("^[.|/]", member.name)):
5232    fname = member.name;
5233   else:
5234    fname = "./"+member.name;
5235   if(verbose):
5236    VerbosePrintOut(fname);
5237   fpremode = member.mode;
5238   ffullmode = member.mode;
5239   flinkcount = 0;
5240   ftype = 0;
5241   if(member.isreg()):
5242    ffullmode = member.mode + stat.S_IFREG;
5243    ftype = 0;
5244   elif(member.isdev()):
5245    ffullmode = member.mode;
5246    ftype = 7;
5247   elif(member.islnk()):
5248    ffullmode = member.mode + stat.S_IFREG;
5249    ftype = 1;
5250   elif(member.issym()):
5251    ffullmode = member.mode + stat.S_IFLNK;
5252    ftype = 2;
5253   elif(member.ischr()):
5254    ffullmode = member.mode + stat.S_IFCHR;
5255    ftype = 3;
5256   elif(member.isblk()):
5257    ffullmode = member.mode + stat.S_IFBLK;
5258    ftype = 4;
5259   elif(member.isdir()):
5260    ffullmode = member.mode + stat.S_IFDIR;
5261    ftype = 5;
5262   elif(member.isfifo()):
5263    ffullmode = member.mode + stat.S_IFIFO;
5264    ftype = 6;
5265   elif(member.issparse()):
5266    ffullmode = member.mode;
5267    ftype = 12;
5268   else:
5269    ffullmode = member.mode;
5270    ftype = 0;
5271   flinkname = "";
5272   fbasedir = os.path.dirname(fname);
5273   fcurfid = curfid;
5274   fcurinode = curfid;
5275   finode = fcurinode;
5276   curfid = curfid + 1;
5277   if(ftype==2):
5278    flinkname = member.linkname;
5279   fdev_minor = member.devminor;
5280   fdev_major = member.devmajor;
5281   frdev_minor = member.devminor;
5282   frdev_major = member.devmajor;
5283   if(ftype==1 or ftype==2 or ftype==3 or ftype==4 or ftype==5 or ftype==6):
5284    fsize = "0";
5285   elif(ftype==0 or ftype==7):
5286    fsize = member.size;
5287   else:
5288    fsize = member.size;
5289   fatime = member.mtime;
5290   fmtime = member.mtime;
5291   fctime = member.mtime;
5292   fbtime = member.mtime;
5293   fmode = ffullmode;
5294   fchmode = stat.S_IMODE(ffullmode);
5295   ftypemod = stat.S_IFMT(ffullmode);
5296   fuid = member.uid;
5297   fgid = member.gid;
5298   funame = member.uname;
5299   fgname = member.gname;
5300   flinkcount = flinkcount;
5301   fwinattributes = int(0);
5302   fcontents = "".encode('UTF-8');
5303   chunk_size = 1024;
5304   if(ftype==0 or ftype==7):
5305    with tarfp.extractfile(member) as fpc:
5306     while(True):
5307      chunk = fpc.read(chunk_size);
5308      if(not chunk):
5309       break
5310      fcontents += chunk;
5311   ftypehex = format(ftype, 'x').lower();
5312   extrafields = len(extradata);
5313   extrafieldslist = extradata;
5314   catfextrafields = extrafields;
5315   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
5316   if(len(extradata)>0):
5317    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
5318   extrasizelen = len(extrasizestr);
5319   extrasizelenhex = format(extrasizelen, 'x').lower();
5320   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(), format(int(fuid), 'x').lower(), 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(), extrasizelenhex, format(catfextrafields, 'x').lower()];
5321   catoutlen = len(catoutlist) + len(extradata) + 3;
5322   catoutlenhex = format(catoutlen, 'x').lower();
5323   catoutlist.insert(0, catoutlenhex);
5324   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
5325   if(len(extradata)>0):
5326    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
5327   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
5328   catfnumfields = catoutlen;
5329   if(checksumtype=="none" or checksumtype==""):
5330    catfileheadercshex = format(0, 'x').lower();
5331    catfilecontentcshex = format(0, 'x').lower();
5332   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5333    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
5334    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
5335   elif(checksumtype=="crc16_ccitt"):
5336    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
5337    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
5338   elif(checksumtype=="adler32"):
5339    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5340    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
5341   elif(checksumtype=="crc32"):
5342    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5343    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
5344   elif(checksumtype=="crc64_ecma"):
5345    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5346    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
5347   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5348    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5349    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
5350   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5351    checksumoutstr = hashlib.new(checksumtype);
5352    checksumoutstr.update("".encode('UTF-8'));
5353    catfileheadercshex = checksumoutstr.hexdigest().lower();
5354    checksumoutstr = hashlib.new(checksumtype);
5355    checksumoutstr.update(fcontents);
5356    catfilecontentcshex = checksumoutstr.hexdigest().lower();
5357   else:
5358    catfileheadercshex = format(0, 'x').lower();
5359    catfilecontentcshex = format(0, 'x').lower();
5360   catfhstart = fheadtell;
5361   fheadtell += len(catfileoutstr);
5362   catfhend = fheadtell - 1;
5363   catfcontentstart = fheadtell;
5364   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5365   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
5366   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
5367   catheaderdata = [catheaersize] + catoutlist + extradata + [checksumtype, catfileheadercshex, catfilecontentcshex]
5368   if(checksumtype=="none" or checksumtype==""):
5369    catfileheadercshex = format(0, 'x').lower();
5370   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5371    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5372   elif(checksumtype=="crc16_ccitt"):
5373    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5374   elif(checksumtype=="adler32"):
5375    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5376   elif(checksumtype=="crc32"):
5377    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5378   elif(checksumtype=="crc64_ecma"):
5379    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5380   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5381    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5382   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5383    checksumoutstr = hashlib.new(checksumtype);
5384    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
5385    catfileheadercshex = checksumoutstr.hexdigest().lower();
5386   else:
5387    catfileheadercshex = format(0, 'x').lower();
5388   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5389   catfileoutstrecd = catfileoutstr.encode('UTF-8');
5390   nullstrecd = formatspecs[5].encode('UTF-8');
5391   fheadtell += len(catfileoutstr) + 1;
5392   catfcontentend = fheadtell - 1;
5393   catfileout = catfileoutstrecd + fcontents + nullstrecd;
5394   pyhascontents = False;
5395   if(int(fsize)>0 and not listonly):
5396    pyhascontents = True;
5397   if(int(fsize)>0 and listonly):
5398    fcontents = "";
5399    pyhascontents = False;
5400   catlist['ffilelist'].update({fileidnum: {'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, 'fuid': fuid, 'funame': funame, 'fgid': fgid, 'fgname': fgname, 'finode': finode, 'flinkcount': flinkcount, 'fminor': fdev_minor, 'fmajor': fdev_major, 'frminor': frdev_minor, 'frmajor': frdev_major, 'fchecksumtype': 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, 'fcontents': fcontents} });
5401   fileidnum = fileidnum + 1;
5402  return catlist;
5403
5404 def ZipFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5405  curinode = 0;
5406  curfid = 0;
5407  inodelist = [];
5408  inodetofile = {};
5409  filetoinode = {};
5410  inodetocatinode = {};
5411  fileidnum = 0;
5412  if(infile=="-"):
5413   infile = BytesIO();
5414   if(hasattr(sys.stdin, "buffer")):
5415    shutil.copyfileobj(sys.stdin.buffer, infile);
5416   else:
5417    shutil.copyfileobj(sys.stdin, infile);
5418   infile.seek(0, 0);
5419   if(not infile):
5420    return False;
5421   infile.seek(0, 0);
5422  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
5423   infile = download_file_from_internet_file(infile);
5424   infile.seek(0, 0);
5425   if(not infile):
5426    return False;
5427   infile.seek(0, 0);
5428  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
5429   return False;
5430  else:
5431   return False;
5432  if(not zipfile.is_zipfile(infile)):
5433   return False;
5434  try:
5435   zipfp = zipfile.ZipFile(infile, "r", allowZip64=True);
5436  except FileNotFoundError:
5437   return False;
5438  ziptest = zipfp.testzip();
5439  if(ziptest):
5440   VerbosePrintOut("Bad file found!");
5441  fnumfiles = int(len(zipfp.infolist()));
5442  catver = formatspecs[6];
5443  fileheaderver = str(int(catver.replace(".", "")));
5444  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
5445  catversion = re.findall(r"([\d]+)$", fileheader);
5446  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
5447  fnumfileshex = format(int(fnumfiles), 'x').lower();
5448  fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
5449  if(checksumtype=="none" or checksumtype==""):
5450   catfileheadercshex = format(0, 'x').lower();
5451  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5452   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5453  elif(checksumtype=="crc16_ccitt"):
5454   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5455  elif(checksumtype=="adler32"):
5456   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5457  elif(checksumtype=="crc32"):
5458   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5459  elif(checksumtype=="crc64_ecma"):
5460   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5461  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5462   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5463  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5464   checksumoutstr = hashlib.new(checksumtype);
5465   checksumoutstr.update(fileheader.encode('UTF-8'));
5466   catfileheadercshex = checksumoutstr.hexdigest().lower();
5467  else:
5468   catfileheadercshex = format(0, 'x').lower();
5469  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
5470  fheadtell = len(fileheader);
5471  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
5472  for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
5473   if(re.findall("^[.|/]", member.filename)):
5474    fname = member.filename;
5475   else:
5476    fname = "./"+member.filename;
5477   zipinfo = zipfp.getinfo(member.filename);
5478   if(verbose):
5479    VerbosePrintOut(fname);
5480   if(not member.is_dir()):
5481    fpremode = stat.S_IFREG + 438;
5482   elif(member.is_dir()):
5483    fpremode = stat.S_IFDIR + 511;
5484   flinkcount = 0;
5485   ftype = 0;
5486   if(not member.is_dir()):
5487    ftype = 0;
5488   elif(member.is_dir()):
5489    ftype = 5;
5490   flinkname = "";
5491   fbasedir = os.path.dirname(fname);
5492   fcurfid = curfid;
5493   fcurinode = curfid;
5494   finode = fcurinode;
5495   curfid = curfid + 1;
5496   fdev_minor = 0;
5497   fdev_major = 0;
5498   frdev_minor = 0;
5499   frdev_major = 0;
5500   if(ftype==5):
5501    fsize = "0";
5502   elif(ftype==0):
5503    fsize = member.file_size;
5504   else:
5505    fsize = member.file_size;
5506   fatime = time.mktime(member.date_time + (0, 0, -1));
5507   fmtime = time.mktime(member.date_time + (0, 0, -1));
5508   fctime = time.mktime(member.date_time + (0, 0, -1));
5509   fbtime = time.mktime(member.date_time + (0, 0, -1));
5510   if(zipinfo.create_system==0 or zipinfo.create_system==10):
5511    fwinattributes = int(zipinfo.external_attr);
5512    if(not member.is_dir()):
5513     fmode = int(stat.S_IFREG + 438);
5514     fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)));
5515     ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)));
5516    elif(member.is_dir()):
5517     fmode = int(stat.S_IFDIR + 511);
5518     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
5519     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
5520   elif(zipinfo.create_system==3):
5521    fwinattributes = int(0);
5522    fmode = int(zipinfo.external_attr);
5523   else:
5524    fwinattributes = int(0);
5525    if(not member.is_dir()):
5526     fmode = int(stat.S_IFREG + 438);
5527     fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)));
5528     ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)));
5529    elif(member.is_dir()):
5530     fmode = int(stat.S_IFDIR + 511);
5531     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
5532     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
5533   try:
5534    fuid = os.getuid();
5535   except AttributeError:
5536    fuid = 0;
5537   except KeyError:
5538    fuid = 0;
5539   try:
5540    fgid = os.getgid();
5541   except AttributeError:
5542    fgid = 0;
5543   except KeyError:
5544    fgid = 0;
5545   try:
5546    import pwd;
5547    try:
5548     userinfo = pwd.getpwuid(os.getuid());
5549     funame = userinfo.pw_name;
5550    except KeyError:
5551     funame = "";
5552    except AttributeError:
5553     funame = "";
5554   except ImportError:
5555    funame = "";
5556   fgname = "";
5557   try:
5558    import grp;
5559    try:
5560     groupinfo = grp.getgrgid(os.getgid());
5561     fgname = groupinfo.gr_name;
5562    except KeyError:
5563     fgname = "";
5564    except AttributeError:
5565     fgname = "";
5566   except ImportError:
5567    fgname = "";
5568   fcontents = "".encode('UTF-8');
5569   if(ftype==0):
5570    fcontents = zipfp.read(member.filename);
5571   ftypehex = format(ftype, 'x').lower();
5572   extrafields = len(extradata);
5573   extrafieldslist = extradata;
5574   catfextrafields = extrafields;
5575   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
5576   if(len(extradata)>0):
5577    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
5578   extrasizelen = len(extrasizestr);
5579   extrasizelenhex = format(extrasizelen, 'x').lower();
5580   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(), format(int(fuid), 'x').lower(), 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(), extrasizelenhex, format(catfextrafields, 'x').lower()];
5581   catoutlen = len(catoutlist) + len(extradata) + 3;
5582   catoutlenhex = format(catoutlen, 'x').lower();
5583   catoutlist.insert(0, catoutlenhex);
5584   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
5585   if(len(extradata)>0):
5586    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
5587   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
5588   catfnumfields = catoutlen;
5589   if(checksumtype=="none" or checksumtype==""):
5590    catfileheadercshex = format(0, 'x').lower();
5591    catfilecontentcshex = format(0, 'x').lower();
5592   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5593    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
5594    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
5595   elif(checksumtype=="crc16_ccitt"):
5596    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
5597    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
5598   elif(checksumtype=="adler32"):
5599    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5600    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
5601   elif(checksumtype=="crc32"):
5602    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5603    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
5604   elif(checksumtype=="crc64_ecma"):
5605    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5606    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
5607   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5608    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5609    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
5610   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5611    checksumoutstr = hashlib.new(checksumtype);
5612    checksumoutstr.update("".encode('UTF-8'));
5613    catfileheadercshex = checksumoutstr.hexdigest().lower();
5614    checksumoutstr = hashlib.new(checksumtype);
5615    checksumoutstr.update(fcontents);
5616    catfilecontentcshex = checksumoutstr.hexdigest().lower();
5617   else:
5618    catfileheadercshex = format(0, 'x').lower();
5619    catfilecontentcshex = format(0, 'x').lower();
5620   catfhstart = fheadtell;
5621   fheadtell += len(catfileoutstr);
5622   catfhend = fheadtell - 1;
5623   catfcontentstart = fheadtell;
5624   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5625   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
5626   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
5627   catheaderdata = [catheaersize] + catoutlist + extradata + [checksumtype, catfileheadercshex, catfilecontentcshex];
5628   if(checksumtype=="none" or checksumtype==""):
5629    catfileheadercshex = format(0, 'x').lower();
5630   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5631    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5632   elif(checksumtype=="crc16_ccitt"):
5633    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5634   elif(checksumtype=="adler32"):
5635    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5636   elif(checksumtype=="crc32"):
5637    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5638   elif(checksumtype=="crc64_ecma"):
5639    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5640   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5641    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5642   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5643    checksumoutstr = hashlib.new(checksumtype);
5644    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
5645    catfileheadercshex = checksumoutstr.hexdigest().lower();
5646   else:
5647    catfileheadercshex = format(0, 'x').lower();
5648   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5649   catfileoutstrecd = catfileoutstr.encode('UTF-8');
5650   nullstrecd = formatspecs[5].encode('UTF-8');
5651   fheadtell += len(catfileoutstr) + 1;
5652   catfcontentend = fheadtell - 1;
5653   catfileout = catfileoutstrecd + fcontents + nullstrecd;
5654   pyhascontents = False;
5655   if(int(fsize)>0 and not listonly):
5656    pyhascontents = True;
5657   if(int(fsize)>0 and listonly):
5658    fcontents = "";
5659    pyhascontents = False;
5660   catlist['ffilelist'].update({fileidnum: {'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, 'fuid': fuid, 'funame': funame, 'fgid': fgid, 'fgname': fgname, 'finode': finode, 'flinkcount': flinkcount, 'fminor': fdev_minor, 'fmajor': fdev_major, 'frminor': frdev_minor, 'frmajor': frdev_major, 'fchecksumtype': 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, 'fcontents': fcontents} });
5661   fileidnum = fileidnum + 1;
5662  return catlist;
5663
5664 if(not rarfile_support):
5665  def RarFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5666   return False;
5667
5668 if(rarfile_support):
5669  def RarFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5670   curinode = 0;
5671   curfid = 0;
5672   inodelist = [];
5673   inodetofile = {};
5674   filetoinode = {};
5675   inodetocatinode = {};
5676   fileidnum = 0;
5677   if(not os.path.exists(infiles) or not os.path.isfile(infiles)):
5678    return False;
5679   if(not rarfile.is_rarfile(infile) and not rarfile.is_rarfile_sfx(infile)):
5680    return False;
5681   rarfp = rarfile.RarFile(infile, "r");
5682   rartest = rarfp.testrar();
5683   if(rartest):
5684    VerbosePrintOut("Bad file found!");
5685   fnumfiles = int(len(rarfp.infolist()));
5686   catver = formatspecs[6];
5687   fileheaderver = str(int(catver.replace(".", "")));
5688   fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
5689   catversion = re.findall(r"([\d]+)$", fileheader);
5690   catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
5691   fnumfileshex = format(int(fnumfiles), 'x').lower();
5692   fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
5693   if(checksumtype=="none" or checksumtype==""):
5694    catfileheadercshex = format(0, 'x').lower();
5695   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5696    catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5697   elif(checksumtype=="crc16_ccitt"):
5698    catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5699   elif(checksumtype=="adler32"):
5700    catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5701   elif(checksumtype=="crc32"):
5702    catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5703   elif(checksumtype=="crc64_ecma"):
5704    catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5705   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5706    catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5707   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5708    checksumoutstr = hashlib.new(checksumtype);
5709    checksumoutstr.update(fileheader.encode('UTF-8'));
5710    catfileheadercshex = checksumoutstr.hexdigest().lower();
5711   else:
5712    catfileheadercshex = format(0, 'x').lower();
5713   fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
5714   fheadtell = len(fileheader);
5715   catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
5716   for member in sorted(rarfp.infolist(), key=lambda x: x.filename):
5717    is_unix = False;
5718    is_windows = False;
5719    if(member.host_os==rarfile.RAR_OS_UNIX):
5720     is_windows = False;
5721     try:
5722      member.external_attr
5723      is_unix = True;
5724     except AttributeError:
5725      is_unix = False;
5726    elif(member.host_os==rarfile.RAR_OS_WIN32):
5727     is_unix = False;
5728     try:
5729      member.external_attr
5730      is_windows = True;
5731     except AttributeError:
5732      is_windows = False;
5733    else:
5734     is_unix = False;
5735     is_windows = False;
5736    if(re.findall("^[.|/]", member.filename)):
5737     fname = member.filename;
5738    else:
5739     fname = "./"+member.filename;
5740    rarinfo = rarfp.getinfo(member.filename);
5741    if(verbose):
5742     VerbosePrintOut(fname);
5743    if(is_unix and member.external_attr !=0):
5744     fpremode = int(member.external_attr);
5745    elif(member.is_file()):
5746     fpremode = stat.S_IFREG + 438;
5747    elif(member.is_symlink()):
5748     fpremode = stat.S_IFLNK + 438;
5749    elif(member.is_dir()):
5750     fpremode = stat.S_IFDIR + 511;
5751    if(is_windows and member.external_attr !=0):
5752     fwinattributes = int(member.external_attr);
5753    else:
5754     fwinattributes = int(0);
5755    flinkcount = 0;
5756    ftype = 0;
5757    if(member.is_file()):
5758     ftype = 0;
5759    elif(member.is_symlink()):
5760     ftype = 2;
5761    elif(member.is_dir()):
5762     ftype = 5;
5763    flinkname = "";
5764    if(ftype==2):
5765     flinkname = rarfp.read(member.filename).decode("UTF-8");
5766    fbasedir = os.path.dirname(fname);
5767    fcurfid = curfid;
5768    fcurinode = curfid;
5769    finode = fcurinode;
5770    curfid = curfid + 1;
5771    fdev_minor = 0;
5772    fdev_major = 0;
5773    frdev_minor = 0;
5774    frdev_major = 0;
5775    if(ftype==5):
5776     fsize = "0";
5777    if(ftype==0):
5778     fsize = member.file_size;
5779    try:
5780     if(member.atime):
5781      fatime = int(member.atime.timestamp());
5782     else:
5783      fatime = int(member.mtime.timestamp());
5784    except AttributeError:
5785     fatime = int(member.mtime.timestamp());
5786    fmtime = int(member.mtime.timestamp());
5787    try:
5788     if(member.ctime):
5789      fctime = int(member.ctime.timestamp());
5790     else:
5791      fctime = int(member.mtime.timestamp());
5792    except AttributeError:
5793     fctime = int(member.mtime.timestamp());
5794    fbtime = int(member.mtime.timestamp());
5795    if(is_unix and member.external_attr !=0):
5796     fmode = int(member.external_attr);
5797     fchmode = int(stat.S_IMODE(member.external_attr));
5798     ftypemod = int(stat.S_IFMT(member.external_attr));
5799    elif(member.is_file()):
5800     fmode = int(stat.S_IFREG + 438)
5801     fchmode = int(stat.S_IMODE(stat.S_IFREG + 438));
5802     ftypemod = int(stat.S_IFMT(stat.S_IFREG + 438));
5803    elif(member.is_symlink()):
5804     fmode = int(stat.S_IFLNK + 438)
5805     fchmode = int(stat.S_IMODE(stat.S_IFREG + 438));
5806     ftypemod = int(stat.S_IFMT(stat.S_IFREG + 438));
5807    elif(member.is_dir()):
5808     fmode = int(stat.S_IFDIR + 511)
5809     fchmode = int(stat.S_IMODE(stat.S_IFDIR + 511));
5810     ftypemod = int(stat.S_IFMT(stat.S_IFDIR + 511));
5811    try:
5812     fuid = os.getuid();
5813    except AttributeError:
5814     fuid = 0;
5815    except KeyError:
5816     fuid = 0;
5817    try:
5818     fgid = os.getgid();
5819    except AttributeError:
5820     fgid = 0;
5821    except KeyError:
5822     fgid = 0;
5823    try:
5824     import pwd;
5825     try:
5826      userinfo = pwd.getpwuid(os.getuid());
5827      funame = userinfo.pw_name;
5828     except KeyError:
5829      funame = "";
5830     except AttributeError:
5831      funame = "";
5832    except ImportError:
5833     funame = "";
5834    fgname = "";
5835    try:
5836     import grp;
5837     try:
5838      groupinfo = grp.getgrgid(os.getgid());
5839      fgname = groupinfo.gr_name;
5840     except KeyError:
5841      fgname = "";
5842     except AttributeError:
5843      fgname = "";
5844    except ImportError:
5845     fgname = "";
5846    fcontents = "".encode('UTF-8');
5847    if(ftype==0):
5848     fcontents = rarfp.read(member.filename);
5849    ftypehex = format(ftype, 'x').lower();
5850    extrafields = len(extradata);
5851    extrafieldslist = extradata;
5852    catfextrafields = extrafields;
5853    extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
5854    if(len(extradata)>0):
5855     extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
5856    extrasizelen = len(extrasizestr);
5857    extrasizelenhex = format(extrasizelen, 'x').lower();
5858    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(), format(int(fuid), 'x').lower(), 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(), extrasizelenhex, format(catfextrafields, 'x').lower()];
5859    catoutlen = len(catoutlist) + len(extradata) + 3;
5860    catoutlenhex = format(catoutlen, 'x').lower();
5861    catoutlist.insert(0, catoutlenhex);
5862    catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
5863    if(len(extradata)>0):
5864     catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
5865    catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
5866    catfnumfields = 24 + catfextrafields;
5867    if(checksumtype=="none" or checksumtype==""):
5868     catfileheadercshex = format(0, 'x').lower();
5869     catfilecontentcshex = format(0, 'x').lower();
5870    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5871     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5872     catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
5873    elif(checksumtype=="crc16_ccitt"):
5874     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5875     catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
5876    elif(checksumtype=="adler32"):
5877     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5878     catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
5879    elif(checksumtype=="crc32"):
5880     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5881     catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
5882    elif(checksumtype=="crc64_ecma"):
5883     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5884     catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
5885    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5886     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5887     catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
5888    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5889     checksumoutstr = hashlib.new(checksumtype);
5890     checksumoutstr.update(catfileoutstr.encode('UTF-8'));
5891     catfileheadercshex = checksumoutstr.hexdigest().lower();
5892    else:
5893     catfileheadercshex = format(0, 'x').lower();
5894     catfilecontentcshex = format(0, 'x').lower();
5895    catfhstart = fheadtell;
5896    fheadtell += len(catfileoutstr);
5897    catfhend = fheadtell - 1;
5898    catfcontentstart = fheadtell;
5899    tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5900    catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
5901    catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
5902    catheaderdata = [catheaersize] + catoutlist + extradata + [checksumtype, catfileheadercshex, catfilecontentcshex];
5903    if(checksumtype=="none" or checksumtype==""):
5904     catfileheadercshex = format(0, 'x').lower();
5905    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5906     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5907    elif(checksumtype=="crc16_ccitt"):
5908     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5909    elif(checksumtype=="adler32"):
5910     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5911    elif(checksumtype=="crc32"):
5912     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5913    elif(checksumtype=="crc64_ecma"):
5914     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5915    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5916     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5917    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5918     checksumoutstr = hashlib.new(checksumtype);
5919     checksumoutstr.update(catfileoutstr.encode('UTF-8'));
5920     catfileheadercshex = checksumoutstr.hexdigest().lower();
5921    else:
5922     catfileheadercshex = format(0, 'x').lower();
5923    catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5924    catfileoutstrecd = catfileoutstr.encode('UTF-8');
5925    nullstrecd = formatspecs[5].encode('UTF-8');
5926    fheadtell += len(catfileoutstr) + 1;
5927    catfcontentend = fheadtell - 1;
5928    catfileout = catfileoutstrecd + fcontents + nullstrecd;
5929    pyhascontents = False;
5930    if(int(fsize)>0 and not listonly):
5931     pyhascontents = True;
5932    if(int(fsize)>0 and listonly):
5933     fcontents = "";
5934     pyhascontents = False;
5935    catlist['ffilelist'].update({fileidnum: {'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, 'fuid': fuid, 'funame': funame, 'fgid': fgid, 'fgname': fgname, 'finode': finode, 'flinkcount': flinkcount, 'fminor': fdev_minor, 'fmajor': fdev_major, 'frminor': frdev_minor, 'frmajor': frdev_major, 'fchecksumtype': 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, 'fcontents': fcontents} });
5936    fileidnum = fileidnum + 1;
5937   return catlist;
5938
5939 if(not py7zr_support):
5940  def SevenZipFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5941   return False;
5942
5943 if(py7zr_support):
5944  def SevenZipFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5945   curinode = 0;
5946   curfid = 0;
5947   inodelist = [];
5948   inodetofile = {};
5949   filetoinode = {};
5950   inodetocatinode = {};
5951   fileidnum = 0;
5952   szpfp = py7zr.SevenZipFile(infile, mode="r");
5953   file_content = szpfp.readall();
5954   #sztest = szpfp.testzip();
5955   sztestalt = szpfp.test();
5956   if(sztestalt):
5957    VerbosePrintOut("Bad file found!");
5958   numfiles = int(len(szpfp.list()));
5959   catver = formatspecs[6];
5960   fileheaderver = str(int(catver.replace(".", "")));
5961   fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
5962   catversion = re.findall(r"([\d]+)$", fileheader);
5963   catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
5964   fnumfileshex = format(int(fnumfiles), 'x').lower();
5965   fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
5966   if(checksumtype=="none" or checksumtype==""):
5967    catfileheadercshex = format(0, 'x').lower();
5968   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5969    catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5970   elif(checksumtype=="crc16_ccitt"):
5971    catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5972   elif(checksumtype=="adler32"):
5973    catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5974   elif(checksumtype=="crc32"):
5975    catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5976   elif(checksumtype=="crc64_ecma"):
5977    catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5978   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5979    catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5980   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5981    checksumoutstr = hashlib.new(checksumtype);
5982    checksumoutstr.update(fileheader.encode('UTF-8'));
5983    catfileheadercshex = checksumoutstr.hexdigest().lower();
5984   else:
5985    catfileheadercshex = format(0, 'x').lower();
5986   fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
5987   fheadtell = len(fileheader);
5988   catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
5989   for member in sorted(szpfp.list(), key=lambda x: x.filename):
5990    if(re.findall("^[.|/]", member.filename)):
5991     fname = member.filename;
5992    else:
5993     fname = "./"+member.filename;
5994    if(not member.is_directory):
5995     fpremode = int(stat.S_IFREG + 438);
5996    elif(member.is_directory):
5997     fpremode = int(stat.S_IFDIR + 511);
5998    fwinattributes = int(0);
5999    flinkcount = 0;
6000    ftype = 0;
6001    if(member.is_directory):
6002     ftype = 5;
6003    else:
6004     ftype = 0;
6005    flinkname = "";
6006    fbasedir = os.path.dirname(fname);
6007    fcurfid = curfid;
6008    fcurinode = curfid;
6009    finode = fcurinode;
6010    curfid = curfid + 1;
6011    fdev_minor = 0;
6012    fdev_major = 0;
6013    frdev_minor = 0;
6014    frdev_major = 0;
6015    if(ftype==5):
6016     fsize = "0";
6017    fatime = int(member.creationtime.timestamp());
6018    fmtime = int(member.creationtime.timestamp());
6019    fctime = int(member.creationtime.timestamp());
6020    fbtime = int(member.creationtime.timestamp());
6021    if(member.is_directory):
6022     fmode = int(stat.S_IFDIR + 511)
6023     fchmode = int(stat.S_IMODE(stat.S_IFDIR + 511));
6024     ftypemod = int(stat.S_IFMT(stat.S_IFDIR + 511));
6025    else:
6026     fmode = int(stat.S_IFLNK + 438)
6027     fchmode = int(stat.S_IMODE(stat.S_IFREG + 438));
6028     ftypemod = int(stat.S_IFMT(stat.S_IFREG + 438));
6029    try:
6030     fuid = os.getuid();
6031    except AttributeError:
6032     fuid = 0;
6033    except KeyError:
6034     fuid = 0;
6035    try:
6036     fgid = os.getgid();
6037    except AttributeError:
6038     fgid = 0;
6039    except KeyError:
6040     fgid = 0;
6041    try:
6042     import pwd;
6043     try:
6044      userinfo = pwd.getpwuid(os.getuid());
6045      funame = userinfo.pw_name;
6046     except KeyError:
6047      funame = "";
6048     except AttributeError:
6049      funame = "";
6050    except ImportError:
6051     funame = "";
6052    fgname = "";
6053    try:
6054     import grp;
6055     try:
6056      groupinfo = grp.getgrgid(os.getgid());
6057      fgname = groupinfo.gr_name;
6058     except KeyError:
6059      fgname = "";
6060     except AttributeError:
6061      fgname = "";
6062    except ImportError:
6063     fgname = "";
6064    fcontents = "".encode('UTF-8');
6065    if(ftype==0):
6066     fcontents = file_content[member.filename].read();
6067     fsize = format(len(fcontents), 'x').lower();
6068     fileop.close();
6069    ftypehex = format(ftype, 'x').lower();
6070    extrafields = len(extradata);
6071    extrafieldslist = extradata;
6072    catfextrafields = extrafields;
6073    extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
6074    if(len(extradata)>0):
6075     extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
6076    extrasizelen = len(extrasizestr);
6077    extrasizelenhex = format(extrasizelen, 'x').lower();
6078    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(), format(int(fuid), 'x').lower(), 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(), extrasizelenhex, format(catfextrafields, 'x').lower()];
6079    catoutlen = len(catoutlist) + len(extradata) + 3;
6080    catoutlenhex = format(catoutlen, 'x').lower();
6081    catoutlist.insert(0, catoutlenhex);
6082    catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
6083    if(len(extradata)>0):
6084     catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
6085    catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
6086    catfnumfields = 24 + catfextrafields;
6087    if(checksumtype=="none" or checksumtype==""):
6088     catfileheadercshex = format(0, 'x').lower();
6089     catfilecontentcshex = format(0, 'x').lower();
6090    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
6091     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6092     catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
6093    elif(checksumtype=="crc16_ccitt"):
6094     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6095     catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
6096    elif(checksumtype=="adler32"):
6097     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6098     catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
6099    elif(checksumtype=="crc32"):
6100     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6101     catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
6102    elif(checksumtype=="crc64_ecma"):
6103     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6104     catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
6105    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
6106     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6107     catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
6108    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
6109     checksumoutstr = hashlib.new(checksumtype);
6110     checksumoutstr.update(catfileoutstr.encode('UTF-8'));
6111     catfileheadercshex = checksumoutstr.hexdigest().lower();
6112    else:
6113     catfileheadercshex = format(0, 'x').lower();
6114     catfilecontentcshex = format(0, 'x').lower();
6115    catfhstart = fheadtell;
6116    fheadtell += len(catfileoutstr);
6117    catfhend = fheadtell - 1;
6118    catfcontentstart = fheadtell;
6119    tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
6120    catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
6121    catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
6122    catheaderdata = [catheaersize] + catoutlist + extradata + [checksumtype, catfileheadercshex, catfilecontentcshex];
6123    if(checksumtype=="none" or checksumtype==""):
6124     catfileheadercshex = format(0, 'x').lower();
6125    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
6126     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6127    elif(checksumtype=="crc16_ccitt"):
6128     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6129    elif(checksumtype=="adler32"):
6130     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6131    elif(checksumtype=="crc32"):
6132     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6133    elif(checksumtype=="crc64_ecma"):
6134     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6135    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
6136     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6137    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
6138     checksumoutstr = hashlib.new(checksumtype);
6139     checksumoutstr.update(catfileoutstr.encode('UTF-8'));
6140     catfileheadercshex = checksumoutstr.hexdigest().lower();
6141    else:
6142     catfileheadercshex = format(0, 'x').lower();
6143    catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
6144    catfileoutstrecd = catfileoutstr.encode('UTF-8');
6145    nullstrecd = formatspecs[5].encode('UTF-8');
6146    fheadtell += len(catfileoutstr) + 1;
6147    catfcontentend = fheadtell - 1;
6148    catfileout = catfileoutstrecd + fcontents + nullstrecd;
6149    pyhascontents = False;
6150    if(int(fsize)>0 and not listonly):
6151     pyhascontents = True;
6152    if(int(fsize)>0 and listonly):
6153     fcontents = "";
6154     pyhascontents = False;
6155    catlist['ffilelist'].update({fileidnum: {'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, 'fuid': fuid, 'funame': funame, 'fgid': fgid, 'fgname': fgname, 'finode': finode, 'flinkcount': flinkcount, 'fminor': fdev_minor, 'fmajor': fdev_major, 'frminor': frdev_minor, 'frmajor': frdev_major, 'fchecksumtype': 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, 'fcontents': fcontents} });
6156    fileidnum = fileidnum + 1;
6157   return catlist;
6158
6159 def ListDirToArray(infiles, dirlistfromtxt=False, compression="auto", compressionlevel=None, followlink=False, seekstart=0, seekend=0, listonly=False, skipchecksum=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
6160  outarray = BytesIO();
6161  packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, True);
6162  listcatfiles = ArchiveFileToArray(outarray, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6163  return listcatfiles;
6164
6165 def ArchiveFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6166  if(isinstance(infile, dict)):
6167   listcatfiles = infile;
6168  else:
6169   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
6170    infile = RemoveWindowsPath(infile);
6171   listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6172  if(not listcatfiles):
6173   return False;
6174  catarray = {'list': listcatfiles, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {}, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}};
6175  if(returnfp):
6176   catarray.update({'catfp': listcatfiles['catfp']});
6177  lenlist = len(listcatfiles['ffilelist']);
6178  lcfi = 0;
6179  lcfx = int(listcatfiles['fnumfiles']);
6180  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6181   lcfx = int(lenlist);
6182  else:
6183   lcfx = int(listcatfiles['fnumfiles']);
6184  while(lcfi < lcfx):
6185   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6186   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6187   catarray['filetoid'].update(filetoidarray);
6188   catarray['idtofile'].update(idtofilearray);
6189   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6190    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6191    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6192   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6193    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6194    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6195    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6196    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6197   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6198    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6199    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6200    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6201    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6202   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6203    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6204    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6205    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6206    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6207   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6208    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6209    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6210    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6211    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6212   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6213    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6214    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6215   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6216    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6217    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6218    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6219    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6220   lcfi = lcfi + 1;
6221  return catarray;
6222
6223 create_alias_function("", __file_format_name__, "ToArrayIndex", ArchiveFileToArrayIndex);
6224
6225 def ListDirToArrayIndexAlt(infiles, dirlistfromtxt=False, followlink=False, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6226  listcatfiles = ListDirToArrayAlt(infiles, dirlistfromtxt, followlink, listonly, checksumtype, extradata, formatspecs, verbose);
6227  if(not listcatfiles):
6228   return False;
6229  catarray = {'list': listcatfiles, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {}, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}};
6230  lenlist = len(listcatfiles['ffilelist']);
6231  lcfi = 0;
6232  lcfx = int(listcatfiles['fnumfiles']);
6233  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6234   lcfx = int(lenlist);
6235  else:
6236   lcfx = int(listcatfiles['fnumfiles']);
6237  while(lcfi < lcfx):
6238   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6239   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6240   catarray['filetoid'].update(filetoidarray);
6241   catarray['idtofile'].update(idtofilearray);
6242   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6243    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6244    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6245   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6246    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6247    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6248    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6249    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6250   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6251    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6252    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6253    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6254    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6255   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6256    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6257    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6258    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6259    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6260   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6261    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6262    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6263    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6264    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6265   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6266    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6267    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6268   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6269    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6270    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6271    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6272    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6273   lcfi = lcfi + 1;
6274  return catarray;
6275
6276 def TarFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6277  listcatfiles = TarFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6278  if(not listcatfiles):
6279   return False;
6280  catarray = {'list': listcatfiles, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {}, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}};
6281  lenlist = len(listcatfiles['ffilelist']);
6282  lcfi = 0;
6283  lcfx = int(listcatfiles['fnumfiles']);
6284  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6285   lcfx = int(lenlist);
6286  else:
6287   lcfx = int(listcatfiles['fnumfiles']);
6288  while(lcfi < lcfx):
6289   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6290   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6291   catarray['filetoid'].update(filetoidarray);
6292   catarray['idtofile'].update(idtofilearray);
6293   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6294    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6295    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6296   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6297    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6298    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6299    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6300    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6301   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6302    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6303    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6304    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6305    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6306   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6307    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6308    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6309    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6310    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6311   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6312    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6313    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6314    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6315    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6316   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6317    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6318    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6319   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6320    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6321    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6322    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6323    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6324   lcfi = lcfi + 1;
6325  return catarray;
6326
6327 def ZipFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6328  listcatfiles = ZipFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6329  if(not listcatfiles):
6330   return False;
6331  catarray = {'list': listcatfiles, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {}, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}};
6332  lenlist = len(listcatfiles['ffilelist']);
6333  lcfi = 0;
6334  lcfx = int(listcatfiles['fnumfiles']);
6335  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6336   lcfx = int(lenlist);
6337  else:
6338   lcfx = int(listcatfiles['fnumfiles']);
6339  while(lcfi < lcfx):
6340   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6341   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6342   catarray['filetoid'].update(filetoidarray);
6343   catarray['idtofile'].update(idtofilearray);
6344   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6345    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6346    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6347   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6348    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6349    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6350    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6351    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6352   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6353    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6354    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6355    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6356    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6357   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6358    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6359    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6360    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6361    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6362   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6363    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6364    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6365    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6366    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6367   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6368    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6369    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6370   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6371    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6372    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6373    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6374    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6375   lcfi = lcfi + 1;
6376  return catarray;
6377
6378 if(not rarfile_support):
6379  def RarFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6380   return False;
6381
6382 if(rarfile_support):
6383  def RarFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6384   listcatfiles = RarFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6385   if(not listcatfiles):
6386    return False;
6387   catarray = {'list': listcatfiles, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {}, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}};
6388   lenlist = len(listcatfiles['ffilelist']);
6389   lcfi = 0;
6390   lcfx = int(listcatfiles['fnumfiles']);
6391   if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6392    lcfx = int(lenlist);
6393   else:
6394    lcfx = int(listcatfiles['fnumfiles']);
6395   while(lcfi < lcfx):
6396    filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6397    idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6398    catarray['filetoid'].update(filetoidarray);
6399    catarray['idtofile'].update(idtofilearray);
6400    if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6401     catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6402     catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6403    if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6404     catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6405     catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6406     catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6407     catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6408    if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6409     catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6410     catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6411     catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6412     catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6413    if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6414     catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6415     catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6416     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6417     catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6418    if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6419     catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6420     catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6421     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6422    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6423    if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6424     catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6425     catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6426    if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6427     catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6428     catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6429     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6430     catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6431    lcfi = lcfi + 1;
6432   return catarray;
6433
6434 if(not py7zr_support):
6435  def SevenZipFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6436   return False;
6437
6438 if(py7zr_support):
6439  def SevenZipFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6440   listcatfiles = SevenZipFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6441   if(not listcatfiles):
6442    return False;
6443   catarray = {'list': listcatfiles, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {}, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}};
6444   lenlist = len(listcatfiles['ffilelist']);
6445   lcfi = 0;
6446   lcfx = int(listcatfiles['fnumfiles']);
6447   if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6448    lcfx = int(lenlist);
6449   else:
6450    lcfx = int(listcatfiles['fnumfiles']);
6451   while(lcfi < lcfx):
6452    filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6453    idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6454    catarray['filetoid'].update(filetoidarray);
6455    catarray['idtofile'].update(idtofilearray);
6456    if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6457     catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6458     catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6459    if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6460     catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6461     catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6462     catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6463     catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6464    if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6465     catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6466     catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6467     catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6468     catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6469    if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6470     catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6471     catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6472     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6473     catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6474    if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6475     catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6476     catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6477     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6478    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6479    if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6480     catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6481     catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6482    if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6483     catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6484     catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6485     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6486     catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6487    lcfi = lcfi + 1;
6488   return catarray;
6489
6490 def ArchiveFileStringToArrayIndex(catstr, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6491  catfp = BytesIO(catstr);
6492  listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6493  return listcatfiles;
6494
6495 create_alias_function("", __file_format_name__, "StringToArrayIndex", ArchiveFileStringToArrayIndex);
6496
6497 def TarFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6498  catfp = BytesIO();
6499  catfp = PackArchiveFileFromTarFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
6500  listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6501  return listcatfiles;
6502
6503 def ZipFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6504  catfp = BytesIO();
6505  catfp = PackArchiveFileFromZipFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
6506  listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6507  return listcatfiles;
6508
6509 if(not rarfile_support):
6510  def RarFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6511   return False;
6512
6513 if(rarfile_support):
6514  def RarFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6515   catfp = BytesIO();
6516   catfp = PackArchiveFileFromRarFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
6517   listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6518   return listcatfiles;
6519
6520 if(not py7zr_support):
6521  def SevenZipFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6522   return False;
6523
6524 if(py7zr_support):
6525  def SevenZipFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6526   catfp = BytesIO();
6527   catfp = PackArchiveFileFromSevenZipFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
6528   listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6529   return listcatfiles;
6530
6531 def ListDirToArrayIndex(infiles, dirlistfromtxt=False, compression="auto", compressionlevel=None, followlink=False, seekstart=0, seekend=0, listonly=False, skipchecksum=False, checksumtype="crc32", formatspecs=__file_format_list__, verbose=False, returnfp=False):
6532  outarray = BytesIO();
6533  packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, formatspecs, verbose, True);
6534  listcatfiles = ArchiveFileToArrayIndex(outarray, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp)
6535  return listcatfiles;
6536
6537 def RePackArchiveFile(infile, outfile, compression="auto", compressionlevel=None, followlink=False, seekstart=0, seekend=0, checksumtype="crc32", skipchecksum=False, extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
6538  if(isinstance(infile, dict)):
6539   prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6540   listcatfiles = prelistcatfiles['list'];
6541  else:
6542   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
6543    infile = RemoveWindowsPath(infile);
6544   if(followlink):
6545    prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6546    listcatfiles = prelistcatfiles['list'];
6547   else:
6548    listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6549  if(outfile!="-" and not hasattr(infile, "read") and not hasattr(outfile, "write")):
6550   outfile = RemoveWindowsPath(outfile);
6551  checksumtype = checksumtype.lower();
6552  if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
6553   checksumtype="crc32";
6554  if(checksumtype=="none"):
6555   checksumtype = "";
6556  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
6557   compression = None;
6558  if(compression not in compressionlist and compression is None):
6559   compression = "auto";
6560  if(verbose):
6561   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
6562  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
6563   if(os.path.exists(outfile)):
6564    os.unlink(outfile);
6565  if(not listcatfiles):
6566   return False;
6567  if(outfile=="-"):
6568   verbose = False;
6569   catfp = BytesIO();
6570  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
6571   catfp = outfile;
6572  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
6573   catfp = BytesIO();
6574  else:
6575   fbasename = os.path.splitext(outfile)[0];
6576   fextname = os.path.splitext(outfile)[1];
6577   catfp = CompressOpenFile(outfile, compressionlevel);
6578  catver = formatspecs[6];
6579  fileheaderver = str(int(catver.replace(".", "")));
6580  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
6581  catfp.write(fileheader.encode('UTF-8'));
6582  lenlist = len(listcatfiles['ffilelist']);
6583  fnumfiles = int(listcatfiles['fnumfiles']);
6584  if(lenlist>fnumfiles or lenlist<fnumfiles):
6585   fnumfiles = lenlist;
6586  fnumfileshex = format(int(fnumfiles), 'x').lower();
6587  fnumfilesa = AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
6588  if(checksumtype=="none" or checksumtype==""):
6589   catfileheadercshex = format(0, 'x').lower();
6590  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
6591   catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
6592  elif(checksumtype=="crc16_ccitt"):
6593   catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
6594  elif(checksumtype=="adler32"):
6595   catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
6596  elif(checksumtype=="crc32"):
6597   catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
6598  elif(checksumtype=="crc64_ecma"):
6599   catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6600  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
6601   catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6602  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
6603   checksumoutstr = hashlib.new(checksumtype);
6604   checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
6605   catfileheadercshex = checksumoutstr.hexdigest().lower();
6606  else:
6607   catfileheadercshex = format(0, 'x').lower();
6608  fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
6609  catfp.write(fnumfilesa.encode('UTF-8'));
6610  try:
6611   catfp.flush();
6612   os.fsync(catfp.fileno());
6613  except io.UnsupportedOperation:
6614   pass;
6615  except AttributeError:
6616   pass;
6617  lenlist = len(listcatfiles['ffilelist']);
6618  fnumfiles = int(listcatfiles['fnumfiles']);
6619  lcfi = 0;
6620  lcfx = int(listcatfiles['fnumfiles']);
6621  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6622   lcfx = int(lenlist);
6623  else:
6624   lcfx = int(listcatfiles['fnumfiles']);
6625  curinode = 0;
6626  curfid = 0;
6627  inodelist = [];
6628  inodetofile = {};
6629  filetoinode = {};
6630  reallcfi = 0;
6631  while(lcfi < lcfx):
6632   catfhstart = catfp.tell();
6633   if(re.findall("^[.|/]", listcatfiles['ffilelist'][reallcfi]['fname'])):
6634    fname = listcatfiles['ffilelist'][reallcfi]['fname'];
6635   else:
6636    fname = "./"+listcatfiles['ffilelist'][reallcfi]['fname'];
6637   if(verbose):
6638    VerbosePrintOut(fname);
6639   fheadersize = format(int(listcatfiles['ffilelist'][reallcfi]['fheadersize']), 'x').lower();
6640   fsize = format(int(listcatfiles['ffilelist'][reallcfi]['fsize']), 'x').lower();
6641   flinkname = listcatfiles['ffilelist'][reallcfi]['flinkname'];
6642   fatime = format(int(listcatfiles['ffilelist'][reallcfi]['fatime']), 'x').lower();
6643   fmtime = format(int(listcatfiles['ffilelist'][reallcfi]['fmtime']), 'x').lower();
6644   fctime = format(int(listcatfiles['ffilelist'][reallcfi]['fctime']), 'x').lower();
6645   fbtime = format(int(listcatfiles['ffilelist'][reallcfi]['fbtime']), 'x').lower();
6646   fmode = format(int(listcatfiles['ffilelist'][reallcfi]['fmode']), 'x').lower();
6647   fchmode = format(int(listcatfiles['ffilelist'][reallcfi]['fchmode']), 'x').lower();
6648   fuid = format(int(listcatfiles['ffilelist'][reallcfi]['fuid']), 'x').lower();
6649   funame = listcatfiles['ffilelist'][reallcfi]['funame'];
6650   fgid = format(int(listcatfiles['ffilelist'][reallcfi]['fgid']), 'x').lower();
6651   fgname = listcatfiles['ffilelist'][reallcfi]['fgname'];
6652   finode = listcatfiles['ffilelist'][reallcfi]['finode'];
6653   flinkcount = listcatfiles['ffilelist'][reallcfi]['flinkcount'];
6654   fwinattributes = flinkinfo['ffilelist'][reallcfi]['fwinattributes'];
6655   fdev_minor = format(int(listcatfiles['ffilelist'][reallcfi]['fminor']), 'x').lower();
6656   fdev_major = format(int(listcatfiles['ffilelist'][reallcfi]['fmajor']), 'x').lower();
6657   frdev_minor = format(int(listcatfiles['ffilelist'][reallcfi]['frminor']), 'x').lower();
6658   frdev_major = format(int(listcatfiles['ffilelist'][reallcfi]['frmajor']), 'x').lower();
6659   if(len(listcatfiles['ffilelist'][reallcfi]['fextralist'])>listcatfiles['ffilelist'][reallcfi]['fextrafields'] and len(listcatfiles['ffilelist'][reallcfi]['fextralist'])>0):
6660    listcatfiles['ffilelist'][reallcfi]['fextrafields'] = len(listcatfiles['ffilelist'][reallcfi]['fextralist']);
6661   if(len(extradata)>0):
6662    listcatfiles['ffilelist'][reallcfi]['fextrafields'] = len(extradata);
6663    listcatfiles['ffilelist'][reallcfi]['fextralist'] = extradata;
6664   extrafields = format(int(listcatfiles['ffilelist'][reallcfi]['fextrafields']), 'x').lower();
6665   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
6666   if(len(extradata)>0):
6667    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
6668   extrasizelen = format(len(extrasizestr), 'x').lower();
6669   fcontents = listcatfiles['ffilelist'][reallcfi]['fcontents'];
6670   if(followlink):
6671    if(listcatfiles['ffilelist'][reallcfi]['ftype']==1 or listcatfiles['ffilelist'][reallcfi]['ftype']==2):
6672     getflinkpath = listcatfiles['ffilelist'][reallcfi]['flinkname'];
6673     flinkid = prelistcatfiles['filetoid'][getflinkpath];
6674     flinkinfo = listcatfiles['ffilelist'][flinkid];
6675     fheadersize = format(int(flinkinfo['fheadersize']), 'x').lower();
6676     fsize = format(int(flinkinfo['fsize']), 'x').lower();
6677     flinkname = flinkinfo['flinkname'];
6678     fatime = format(int(flinkinfo['fatime']), 'x').lower();
6679     fmtime = format(int(flinkinfo['fmtime']), 'x').lower();
6680     fctime = format(int(flinkinfo['fctime']), 'x').lower();
6681     fbtime = format(int(flinkinfo['fbtime']), 'x').lower();
6682     fmode = format(int(flinkinfo['fmode']), 'x').lower();
6683     fchmode = format(int(flinkinfo['fchmode']), 'x').lower();
6684     fuid = format(int(flinkinfo['fuid']), 'x').lower();
6685     funame = flinkinfo['funame'];
6686     fgid = format(int(flinkinfo['fgid']), 'x').lower();
6687     fgname = flinkinfo['fgname'];
6688     finode = flinkinfo['finode'];
6689     flinkcount = flinkinfo['flinkcount'];
6690     fwinattributes = flinkinfo['fwinattributes'];
6691     fdev_minor = format(int(flinkinfo['fminor']), 'x').lower();
6692     fdev_major = format(int(flinkinfo['fmajor']), 'x').lower();
6693     frdev_minor = format(int(flinkinfo['frminor']), 'x').lower();
6694     frdev_major = format(int(flinkinfo['frmajor']), 'x').lower();
6695     if(len(flinkinfo['fextralist'])>flinkinfo['fextrafields'] and len(flinkinfo['fextralist'])>0):
6696      flinkinfo['fextrafields'] = len(flinkinfo['fextralist']);
6697     if(len(extradata)>0):
6698      flinkinfo['fextrafields'] = len(extradata);
6699      flinkinfo['fextralist'] = extradata;
6700     extrafields = format(int(flinkinfo['fextrafields']), 'x').lower();
6701     extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
6702     if(len(extradata)>0):
6703      extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
6704     extrasizelen = format(len(extrasizestr), 'x').lower();
6705     fcontents = flinkinfo['fcontents'];
6706     if(flinkinfo['ftype']!=0 and flinkinfo['ftype']!=7):
6707      try:
6708       fcontents = fcontents.encode('UTF-8');
6709      except AttributeError:
6710       pass;
6711     ftypehex = format(flinkinfo['ftype'], 'x').lower();
6712   else:
6713    if(listcatfiles['ffilelist'][reallcfi]['ftype']!=0 and listcatfiles['ffilelist'][reallcfi]['ftype']!=7):
6714     try:
6715      fcontents = fcontents.encode('UTF-8');
6716     except AttributeError:
6717      pass;
6718    ftypehex = format(listcatfiles['ffilelist'][reallcfi]['ftype'], 'x').lower();
6719   fcurfid = format(curfid, 'x').lower();
6720   if(not followlink and finode!=0):
6721    if(listcatfiles['ffilelist'][reallcfi]['ftype']!=1):
6722     fcurinode = format(int(curinode), 'x').lower();
6723     inodetofile.update({curinode: fname});
6724     filetoinode.update({fname: curinode});
6725     curinode = curinode + 1;
6726    else:
6727     fcurinode = format(int(filetoinode[flinkname]), 'x').lower();
6728   else:
6729     fcurinode = format(int(curinode), 'x').lower();
6730     curinode = curinode + 1;
6731   curfid = curfid + 1;
6732   catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrasizelen, extrafields];
6733   catoutlen = len(catoutlist) + len(extradata) + 3;
6734   catoutlenhex = format(catoutlen, 'x').lower();
6735   catoutlist.insert(0, catoutlenhex);
6736   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
6737   if(listcatfiles['ffilelist'][reallcfi]['fextrafields']>0):
6738    extrafieldslist = [];
6739    exi = 0;
6740    exil = listcatfiles['ffilelist'][reallcfi]['fextrafields'];
6741    while(exi<exil):
6742     extrafieldslist.append(listcatfiles['ffilelist'][reallcfi]['fextralist']);
6743     exi = exi + 1;
6744    catfileoutstr += AppendNullBytes([extrafieldslist], formatspecs[5]);
6745   catfileoutstr += AppendNullBytes([checksumtype], formatspecs[5]);
6746   catfhend = (catfp.tell() - 1) + len(catfileoutstr);
6747   catfcontentstart = catfp.tell() + len(catfileoutstr);
6748   if(checksumtype=="none" or checksumtype==""):
6749    catfileheadercshex = format(0, 'x').lower();
6750    catfilecontentcshex = format(0, 'x').lower();
6751   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
6752    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
6753    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
6754   elif(checksumtype=="crc16_ccitt"):
6755    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
6756    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
6757   elif(checksumtype=="adler32"):
6758    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
6759    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
6760   elif(checksumtype=="crc32"):
6761    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
6762    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
6763   elif(checksumtype=="crc64_ecma"):
6764    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6765    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
6766   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
6767    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6768    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
6769   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
6770    checksumoutstr = hashlib.new(checksumtype);
6771    checksumoutstr.update("".encode('UTF-8'));
6772    catfileheadercshex = checksumoutstr.hexdigest().lower();
6773    checksumoutstr = hashlib.new(checksumtype);
6774    checksumoutstr.update(fcontents);
6775    catfilecontentcshex = checksumoutstr.hexdigest().lower();
6776   else:
6777    catfileheadercshex = format(0, 'x').lower();
6778    catfilecontentcshex = format(0, 'x').lower();
6779   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
6780   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
6781   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
6782   if(checksumtype=="none" or checksumtype==""):
6783    catfileheadercshex = format(0, 'x').lower();
6784   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
6785    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6786   elif(checksumtype=="crc16_ccitt"):
6787    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6788   elif(checksumtype=="adler32"):
6789    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6790   elif(checksumtype=="crc32"):
6791    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6792   elif(checksumtype=="crc64_ecma"):
6793    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6794   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
6795    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6796   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
6797    checksumoutstr = hashlib.new(checksumtype);
6798    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
6799    catfileheadercshex = checksumoutstr.hexdigest().lower();
6800   else:
6801    catfileheadercshex = format(0, 'x').lower();
6802   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
6803   catfileoutstrecd = catfileoutstr.encode('UTF-8');
6804   nullstrecd = formatspecs[5].encode('UTF-8');
6805   catfileout = catfileoutstrecd + fcontents + nullstrecd;
6806   catfcontentend = (catfp.tell() - 1) + len(catfileout);
6807   catfp.write(catfileout);
6808   try:
6809    catfp.flush();
6810    os.fsync(catfp.fileno());
6811   except io.UnsupportedOperation:
6812    pass;
6813   except AttributeError:
6814    pass;
6815   lcfi = lcfi + 1;
6816   reallcfi = reallcfi + 1;
6817  if(lcfx>0):
6818   catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
6819  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
6820   catfp = CompressArchiveFile(catfp, compression, formatspecs);
6821   try:
6822    catfp.flush();
6823    os.fsync(catfp.fileno());
6824   except io.UnsupportedOperation:
6825    pass;
6826   except AttributeError:
6827    pass;
6828  if(outfile=="-"):
6829   catfp.seek(0, 0);
6830   if(hasattr(sys.stdout, "buffer")):
6831    shutil.copyfileobj(catfp, sys.stdout.buffer);
6832   else:
6833    shutil.copyfileobj(catfp, sys.stdout);
6834  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
6835   catfp = CompressArchiveFile(catfp, compression, formatspecs);
6836   catfp.seek(0, 0);
6837   upload_file_to_internet_file(catfp, outfile);
6838  if(returnfp):
6839   catfp.seek(0, 0);
6840   return catfp;
6841  else:
6842   catfp.close();
6843   return True;
6844
6845 create_alias_function("RePack", __file_format_name__, "", RePackArchiveFile);
6846
6847 def RePackArchiveFileFromString(catstr, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", skipchecksum=False, extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
6848  catfp = BytesIO(catstr);
6849  listcatfiles = RePackArchiveFile(catfp, compression, compressionlevel, checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp);
6850  return listcatfiles;
6851
6852 create_alias_function("RePack", __file_format_name__, "FromString", RePackArchiveFileFromString);
6853
6854 def PackArchiveFileFromListDir(infiles, outfile, dirlistfromtxt=False, compression="auto", compressionlevel=None, followlink=False, skipchecksum=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
6855  outarray = BytesIO();
6856  packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, True);
6857  listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp);
6858  return listcatfiles;
6859
6860 create_alias_function("Pack", __file_format_name__, "FromListDir", PackArchiveFileFromListDir);
6861
6862 def ArchiveFileArrayBase64Encode(infile, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
6863  if(verbose):
6864   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
6865  if(isinstance(infile, dict)):
6866   prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6867   listcatfiles = prelistcatfiles['list'];
6868  else:
6869   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
6870    infile = RemoveWindowsPath(infile);
6871   if(followlink):
6872    prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6873    listcatfiles = prelistcatfiles['list'];
6874   else:
6875    listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6876  if(not listcatfiles):
6877   return False;
6878  lenlist = len(listcatfiles['ffilelist']);
6879  fnumfiles = int(listcatfiles['fnumfiles']);
6880  lcfi = 0;
6881  lcfx = int(listcatfiles['fnumfiles']);
6882  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6883   lcfx = int(lenlist);
6884  else:
6885   lcfx = int(listcatfiles['fnumfiles']);
6886  while(lcfi<lcfx):
6887   if(listcatfiles['ffilelist'][lcfi]['fhascontents']):
6888    listcatfiles['ffilelist'][lcfi]['fcontents'] = base64.b64encode(listcatfiles['ffilelist'][lcfi]['fcontents']).decode("UTF-8");
6889   lcfi = lcfi + 1;
6890  return listcatfiles;
6891
6892 create_alias_function("", __file_format_name__, "ArrayBase64Encode", ArchiveFileArrayBase64Encode);
6893
6894 def ArchiveFileArrayBase64Decode(infile, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
6895  if(verbose):
6896   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
6897  if(isinstance(infile, dict)):
6898   prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6899   listcatfiles = prelistcatfiles['list'];
6900  else:
6901   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
6902    infile = RemoveWindowsPath(infile);
6903   if(followlink):
6904    prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6905    listcatfiles = prelistcatfiles['list'];
6906   else:
6907    listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6908  if(not listcatfiles):
6909   return False;
6910  lenlist = len(listcatfiles['ffilelist']);
6911  fnumfiles = int(listcatfiles['fnumfiles']);
6912  lcfi = 0;
6913  lcfx = int(listcatfiles['fnumfiles']);
6914  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6915   lcfx = int(lenlist);
6916  else:
6917   lcfx = int(listcatfiles['fnumfiles']);
6918  while(lcfi<lcfx):
6919   if(listcatfiles['ffilelist'][lcfi]['fhascontents']):
6920    listcatfiles['ffilelist'][lcfi]['fcontents'] = base64.b64decode(listcatfiles['ffilelist'][lcfi]['fcontents'].encode("UTF-8"));
6921   lcfi = lcfi + 1;
6922  return listcatfiles;
6923
6924 create_alias_function("", __file_format_name__, "ArrayBase64Decode", ArchiveFileArrayBase64Decode);
6925
6926 def UnPackArchiveFile(infile, outdir=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, preservepermissions=True, preservetime=True, verbose=False, returnfp=False):
6927  if(outdir is not None):
6928   outdir = RemoveWindowsPath(outdir);
6929  if(verbose):
6930   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
6931  if(isinstance(infile, dict)):
6932   prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6933   listcatfiles = prelistcatfiles['list'];
6934  else:
6935   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
6936    infile = RemoveWindowsPath(infile);
6937   if(followlink):
6938    prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6939    listcatfiles = prelistcatfiles['list'];
6940   else:
6941    listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6942  if(not listcatfiles):
6943   return False;
6944  lenlist = len(listcatfiles['ffilelist']);
6945  fnumfiles = int(listcatfiles['fnumfiles']);
6946  lcfi = 0;
6947  lcfx = int(listcatfiles['fnumfiles']);
6948  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6949   lcfx = int(lenlist);
6950  else:
6951   lcfx = int(listcatfiles['fnumfiles']);
6952  while(lcfi<lcfx):
6953   funame = "";
6954   try:
6955    import pwd;
6956    try:
6957     userinfo = pwd.getpwuid(listcatfiles['ffilelist'][lcfi]['fuid']);
6958     funame = userinfo.pw_name;
6959    except KeyError:
6960     funame = "";
6961   except ImportError:
6962    funame = "";
6963   fgname = "";
6964   try:
6965    import grp;
6966    try:
6967     groupinfo = grp.getgrgid(listcatfiles['ffilelist'][lcfi]['fgid']);
6968     fgname = groupinfo.gr_name;
6969    except KeyError:
6970     fgname = "";
6971   except ImportError:
6972    fgname = "";
6973   if(verbose):
6974    VerbosePrintOut(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
6975   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6976    with open(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
6977     fpc.write(listcatfiles['ffilelist'][lcfi]['fcontents'])
6978     try:
6979      fpc.flush()
6980      os.fsync(fpc.fileno())
6981     except io.UnsupportedOperation:
6982      pass
6983     except AttributeError:
6984      pass
6985    if(hasattr(os, "chown") and funame==listcatfiles['ffilelist'][lcfi]['funame'] and fgname==listcatfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
6986     os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fuid'], listcatfiles['ffilelist'][lcfi]['fgid']);
6987    if(preservepermissions):
6988     os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fchmode']);
6989    if(preservetime):
6990     os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (listcatfiles['ffilelist'][lcfi]['fatime'], listcatfiles['ffilelist'][lcfi]['fmtime']));
6991   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6992    if(followlink):
6993     getflinkpath = listcatfiles['ffilelist'][lcfi]['flinkname'];
6994     flinkid = prelistcatfiles['filetoid'][getflinkpath];
6995     flinkinfo = listcatfiles['ffilelist'][flinkid];
6996     funame = "";
6997     try:
6998      import pwd;
6999      try:
7000       userinfo = pwd.getpwuid(flinkinfo['fuid']);
7001       funame = userinfo.pw_name;
7002      except KeyError:
7003       funame = "";
7004     except ImportError:
7005      funame = "";
7006     fgname = "";
7007     try:
7008      import grp;
7009      try:
7010       groupinfo = grp.getgrgid(flinkinfo['fgid']);
7011       fgname = groupinfo.gr_name;
7012      except KeyError:
7013       fgname = "";
7014     except ImportError:
7015      fgname = "";
7016     if(flinkinfo['ftype']==0 or flinkinfo['ftype']==7):
7017      with open(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
7018       fpc.write(flinkinfo['fcontents'])
7019       try:
7020        fpc.flush()
7021        os.fsync(fpc.fileno())
7022       except io.UnsupportedOperation:
7023        pass
7024       except AttributeError:
7025        pass
7026      if(hasattr(os, "chown") and funame==flinkinfo['funame'] and fgname==flinkinfo['fgname'] and preservepermissions):
7027       os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid']);
7028      if(preservepermissions):
7029       os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7030      if(preservetime):
7031       os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (flinkinfo['fatime'], flinkinfo['fmtime']));
7032     if(flinkinfo['ftype']==1):
7033      os.link(flinkinfo['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7034     if(flinkinfo['ftype']==2):
7035      os.symlink(flinkinfo['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7036     if(flinkinfo['ftype']==5):
7037      if(preservepermissions):
7038       os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7039      else:
7040       os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7041      if(hasattr(os, "chown") and funame==flinkinfo['funame'] and fgname==flinkinfo['fgname'] and preservepermissions):
7042       os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid']);
7043      if(preservepermissions):
7044       os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7045      if(preservetime):
7046       os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (flinkinfo['fatime'], flinkinfo['fmtime']));
7047     if(flinkinfo['ftype']==6 and hasattr(os, "mkfifo")):
7048      os.mkfifo(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7049    else:
7050     os.link(listcatfiles['ffilelist'][lcfi]['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7051   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
7052    if(followlink):
7053     getflinkpath = listcatfiles['ffilelist'][lcfi]['flinkname'];
7054     flinkid = prelistcatfiles['filetoid'][getflinkpath];
7055     flinkinfo = listcatfiles['ffilelist'][flinkid];
7056     funame = "";
7057     try:
7058      import pwd;
7059      try:
7060       userinfo = pwd.getpwuid(flinkinfo['fuid']);
7061       funame = userinfo.pw_name;
7062      except KeyError:
7063       funame = "";
7064     except ImportError:
7065      funame = "";
7066     fgname = "";
7067     try:
7068      import grp;
7069      try:
7070       groupinfo = grp.getgrgid(flinkinfo['fgid']);
7071       fgname = groupinfo.gr_name;
7072      except KeyError:
7073       fgname = "";
7074     except ImportError:
7075      fgname = "";
7076     if(flinkinfo['ftype']==0 or flinkinfo['ftype']==7):
7077      with open(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
7078       fpc.write(flinkinfo['fcontents'])
7079       try:
7080        fpc.flush()
7081        os.fsync(fpc.fileno())
7082       except io.UnsupportedOperation:
7083        pass
7084       except AttributeError:
7085        pass
7086      if(hasattr(os, "chown") and funame==flinkinfo['funame'] and fgname==flinkinfo['fgname'] and preservepermissions):
7087       os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid']);
7088      if(preservepermissions):
7089       os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7090      if(preservetime):
7091       os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (flinkinfo['fatime'], flinkinfo['fmtime']));
7092     if(flinkinfo['ftype']==1):
7093      os.link(flinkinfo['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7094     if(flinkinfo['ftype']==2):
7095      os.symlink(flinkinfo['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7096     if(flinkinfo['ftype']==5):
7097      if(preservepermissions):
7098       os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7099      else:
7100       os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7101      if(hasattr(os, "chown") and funame==flinkinfo['funame'] and fgname==flinkinfo['fgname'] and preservepermissions):
7102       os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid']);
7103      if(preservepermissions):
7104       os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7105      if(preservetime):
7106       os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (flinkinfo['fatime'], flinkinfo['fmtime']));
7107     if(flinkinfo['ftype']==6 and hasattr(os, "mkfifo")):
7108      os.mkfifo(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7109    else:
7110     os.symlink(listcatfiles['ffilelist'][lcfi]['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7111   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
7112    if(preservepermissions):
7113     os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fchmode']);
7114    else:
7115     os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7116    if(hasattr(os, "chown") and funame==listcatfiles['ffilelist'][lcfi]['funame'] and fgname==listcatfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
7117     os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fuid'], listcatfiles['ffilelist'][lcfi]['fgid']);
7118    if(preservepermissions):
7119     os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fchmode']);
7120    if(preservetime):
7121     os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (listcatfiles['ffilelist'][lcfi]['fatime'], listcatfiles['ffilelist'][lcfi]['fmtime']));
7122   if(listcatfiles['ffilelist'][lcfi]['ftype']==6 and hasattr(os, "mkfifo")):
7123    os.mkfifo(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fchmode']);
7124   lcfi = lcfi + 1;
7125  if(returnfp):
7126   return listcatfiles['ffilelist']['catfp'];
7127  else:
7128   return True;
7129
7130 create_alias_function("UnPack", __file_format_name__, "", UnPackArchiveFile);
7131
7132 if(hasattr(shutil, "register_unpack_format")):
7133  def UnPackArchiveFileFunc(archive_name, extract_dir=None, **kwargs):
7134   return UnPackArchiveFile(archive_name, extract_dir, False, 0, 0, False, __file_format_delimiter__, False, False);
7135  create_alias_function("UnPack", __file_format_name__, "Func", UnPackArchiveFileFunc);
7136
7137 def UnPackArchiveFileString(catstr, outdir=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
7138  catfp = BytesIO(catstr);
7139  listcatfiles = UnPackArchiveFile(catfp, outdir, followlink, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp);
7140  return listcatfiles;
7141
7142 create_alias_function("UnPack", __file_format_name__, "String", UnPackArchiveFileString);
7143
7144 def ArchiveFileListFiles(infile, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
7145  logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7146  if(isinstance(infile, dict)):
7147   listcatfiles = infile;
7148  else:
7149   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
7150    infile = RemoveWindowsPath(infile);
7151   listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, True, skipchecksum, formatspecs, returnfp);
7152  if(not listcatfiles):
7153   return False;
7154  lenlist = len(listcatfiles['ffilelist']);
7155  fnumfiles = int(listcatfiles['fnumfiles']);
7156  lcfi = 0;
7157  lcfx = int(listcatfiles['fnumfiles']);
7158  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
7159   lcfx = int(lenlist);
7160  else:
7161   lcfx = int(listcatfiles['fnumfiles']);
7162  returnval = {};
7163  while(lcfi<lcfx):
7164   returnval.update({lcfi: listcatfiles['ffilelist'][lcfi]['fname']});
7165   if(not verbose):
7166    VerbosePrintOut(listcatfiles['ffilelist'][lcfi]['fname']);
7167   if(verbose):
7168    permissions = { 'access': { '0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': ('r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx') }, 'roles': { 0: 'owner', 1: 'group', 2: 'other' } };
7169    printfname = listcatfiles['ffilelist'][lcfi]['fname'];
7170    if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
7171     printfname = listcatfiles['ffilelist'][lcfi]['fname'] + " link to " + listcatfiles['ffilelist'][lcfi]['flinkname'];
7172    if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
7173     printfname = listcatfiles['ffilelist'][lcfi]['fname'] + " -> " + listcatfiles['ffilelist'][lcfi]['flinkname'];
7174    fuprint = listcatfiles['ffilelist'][lcfi]['funame'];
7175    if(len(fuprint)<=0):
7176     fuprint = listcatfiles['ffilelist'][lcfi]['fuid'];
7177    fgprint = listcatfiles['ffilelist'][lcfi]['fgname'];
7178    if(len(fgprint)<=0):
7179     fgprint = listcatfiles['ffilelist'][lcfi]['fgid'];
7180    VerbosePrintOut(PrintPermissionString(listcatfiles['ffilelist'][lcfi]['fmode'], listcatfiles['ffilelist'][lcfi]['ftype']) + " " + str(str(fuprint) + "/" + str(fgprint) + " " + str(listcatfiles['ffilelist'][lcfi]['fsize']).rjust(15) + " " + datetime.datetime.utcfromtimestamp(listcatfiles['ffilelist'][lcfi]['fmtime']).strftime('%Y-%m-%d %H:%M') + " " + printfname));
7181   lcfi = lcfi + 1;
7182  if(returnfp):
7183   return listcatfiles['catfp'];
7184  else:
7185   return True;
7186
7187 create_alias_function("", __file_format_name__, "ListFiles", ArchiveFileListFiles);
7188
7189 def ArchiveFileStringListFiles(catstr, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
7190  catfp = BytesIO(catstr);
7191  listcatfiles = ArchiveFileListFiles(catstr, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp);
7192  return listcatfiles;
7193
7194 create_alias_function("", __file_format_name__, "StringListFiles", ArchiveFileListFiles);
7195
7196 def ArchiveFileListFilesAlt(infile, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
7197  logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7198  if(isinstance(infile, dict)):
7199   listcatfiles = infile;
7200  else:
7201   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
7202    infile = RemoveWindowsPath(infile);
7203   listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, True, skipchecksum, formatspecs, returnfp);
7204  if(not listcatfiles):
7205   return False;
7206  lenlist = len(listcatfiles['ffilelist']);
7207  fnumfiles = int(listcatfiles['fnumfiles']);
7208  lcfi = 0;
7209  lcfx = int(listcatfiles['fnumfiles']);
7210  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
7211   lcfx = int(lenlist);
7212  else:
7213   lcfx = int(listcatfiles['fnumfiles']);
7214  returnval = {};
7215  while(lcfi<lcfx):
7216   returnval.update({lcfi: listcatfiles['ffilelist'][lcfi]['fname']});
7217   if(not verbose):
7218    VerbosePrintOut(listcatfiles['ffilelist'][lcfi]['fname']);
7219   if(verbose):
7220    permissions = { 'access': { '0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': ('r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx') }, 'roles': { 0: 'owner', 1: 'group', 2: 'other' } };
7221    printfname = listcatfiles['ffilelist'][lcfi]['fname'];
7222    if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
7223     printfname = listcatfiles['ffilelist'][lcfi]['fname'] + " link to " + listcatfiles['ffilelist'][lcfi]['flinkname'];
7224    if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
7225     printfname = listcatfiles['ffilelist'][lcfi]['fname'] + " -> " + listcatfiles['ffilelist'][lcfi]['flinkname'];
7226    fuprint = listcatfiles['ffilelist'][lcfi]['funame'];
7227    if(len(fuprint)<=0):
7228     fuprint = listcatfiles['ffilelist'][lcfi]['fuid'];
7229    fgprint = listcatfiles['ffilelist'][lcfi]['fgname'];
7230    if(len(fgprint)<=0):
7231     fgprint = listcatfiles['ffilelist'][lcfi]['fgid'];
7232    VerbosePrintOut(PrintPermissionString(listcatfiles['ffilelist'][lcfi]['fmode'], listcatfiles['ffilelist'][lcfi]['ftype']) + " " + str(str(fuprint) + "/" + str(fgprint) + " " + str(listcatfiles['ffilelist'][lcfi]['fsize']).rjust(15) + " " + datetime.datetime.utcfromtimestamp(listcatfiles['ffilelist'][lcfi]['fmtime']).strftime('%Y-%m-%d %H:%M') + " " + printfname));
7233   lcfi = lcfi + 1;
7234  if(returnfp):
7235   return listcatfiles['catfp'];
7236  else:
7237   return True;
7238
7239 create_alias_function("", __file_format_name__, "ListFilesAlt", ArchiveFileListFilesAlt);
7240
7241 def ArchiveFileStringListFilesAlt(catstr, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
7242  catfp = BytesIO(catstr);
7243  listcatfiles = ArchiveFileListFilesAlt(catstr, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp);
7244  return listcatfiles;
7245
7246 create_alias_function("", __file_format_name__, "StringListFilesAlt", ArchiveFileListFilesAlt);
7247
7248 def TarFileListFiles(infile, verbose=False, returnfp=False):
7249  logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7250  if(infile=="-"):
7251   infile = BytesIO();
7252   if(hasattr(sys.stdin, "buffer")):
7253    shutil.copyfileobj(sys.stdin.buffer, infile);
7254   else:
7255    shutil.copyfileobj(sys.stdin, infile);
7256   infile.seek(0, 0);
7257   if(not infile):
7258    return False;
7259   infile.seek(0, 0);
7260  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
7261   infile = download_file_from_internet_file(infile);
7262   infile.seek(0, 0);
7263   if(not infile):
7264    return False;
7265   infile.seek(0, 0);
7266  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
7267   return False;
7268  elif(os.path.exists(infile) and os.path.isfile(infile)):
7269   try:
7270    if(not tarfile.is_tarfile(infile)):
7271     return False;
7272   except AttributeError:
7273    if(not is_tarfile(infile)):
7274     return False;
7275  else:
7276   return False;
7277  try:
7278   if(hasattr(infile, "read") or hasattr(infile, "write")):
7279    tarfp = tarfile.open(fileobj=infile, mode="r");
7280   else:
7281    tarfp = tarfile.open(infile, "r");
7282  except FileNotFoundError:
7283   return False;
7284  lcfi = 0
7285  returnval = {};
7286  for member in sorted(tarfp.getmembers(), key=lambda x: x.name):
7287   returnval.update({lcfi: member.name});
7288   fpremode = member.mode;
7289   ffullmode = member.mode;
7290   flinkcount = 0;
7291   ftype = 0;
7292   if(member.isreg()):
7293    ffullmode = member.mode + stat.S_IFREG;
7294    ftype = 0;
7295   elif(member.isdev()):
7296    ffullmode = member.mode;
7297    ftype = 7;
7298   elif(member.islnk()):
7299    ffullmode = member.mode + stat.S_IFREG;
7300    ftype = 1;
7301   elif(member.issym()):
7302    ffullmode = member.mode + stat.S_IFLNK;
7303    ftype = 2;
7304   elif(member.ischr()):
7305    ffullmode = member.mode + stat.S_IFCHR;
7306    ftype = 3;
7307   elif(member.isblk()):
7308    ffullmode = member.mode + stat.S_IFBLK;
7309    ftype = 4;
7310   elif(member.isdir()):
7311    ffullmode = member.mode + stat.S_IFDIR;
7312    ftype = 5;
7313   elif(member.isfifo()):
7314    ffullmode = member.mode + stat.S_IFIFO;
7315    ftype = 6;
7316   elif(member.issparse()):
7317    ffullmode = member.mode;
7318    ftype = 12;
7319   if(not verbose):
7320    VerbosePrintOut(member.name);
7321   elif(verbose):
7322    permissions = { 'access': { '0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': ('r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx') }, 'roles': { 0: 'owner', 1: 'group', 2: 'other' } };
7323    printfname = member.name;
7324    if(member.islnk()):
7325     printfname = member.name + " link to " + member.linkname;
7326    elif(member.issym()):
7327     printfname = member.name + " -> " + member.linkname;
7328    fuprint = member.uname;
7329    if(len(fuprint)<=0):
7330     fuprint = member.uid;
7331    fgprint = member.gname;
7332    if(len(fgprint)<=0):
7333     fgprint = member.gid;
7334    VerbosePrintOut(PrintPermissionString(ffullmode, ftype) + " " + str(str(fuprint) + "/" + str(fgprint) + " " + str(member.size).rjust(15) + " " + datetime.datetime.utcfromtimestamp(member.mtime).strftime('%Y-%m-%d %H:%M') + " " + printfname));
7335   lcfi = lcfi + 1;
7336  if(returnfp):
7337   return listcatfiles['catfp'];
7338  else:
7339   return True;
7340
7341 def ZipFileListFiles(infile, verbose=False, returnfp=False):
7342  logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7343  if(infile=="-"):
7344   infile = BytesIO();
7345   if(hasattr(sys.stdin, "buffer")):
7346    shutil.copyfileobj(sys.stdin.buffer, infile);
7347   else:
7348    shutil.copyfileobj(sys.stdin, infile);
7349   infile.seek(0, 0);
7350   if(not infile):
7351    return False;
7352   infile.seek(0, 0);
7353  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
7354   infile = download_file_from_internet_file(infile);
7355   infile.seek(0, 0);
7356   if(not infile):
7357    return False;
7358   infile.seek(0, 0);
7359  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
7360   return False;
7361  else:
7362   return False;
7363  if(not zipfile.is_zipfile(infile)):
7364   return False;
7365  try:
7366   zipfp = zipfile.ZipFile(infile, "r", allowZip64=True);
7367  except FileNotFoundError:
7368   return False;
7369  lcfi = 0;
7370  returnval = {};
7371  ziptest = zipfp.testzip();
7372  if(ziptest):
7373   VerbosePrintOut("Bad file found!");
7374  for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
7375   if(zipinfo.create_system==0 or zipinfo.create_system==10):
7376    fwinattributes = int(zipinfo.external_attr);
7377    if(not member.is_dir()):
7378     fmode = int(stat.S_IFREG + 438);
7379     fchmode = int(stat.S_IMODE(fmode));
7380     ftypemod = int(stat.S_IFMT(fmode));
7381    elif(member.is_dir()):
7382     fmode = int(stat.S_IFDIR + 511);
7383     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
7384     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
7385   elif(zipinfo.create_system==3):
7386    fwinattributes =int(0);
7387    fmode = int(zipinfo.external_attr);
7388    fchmode = int(stat.S_IMODE(fmode));
7389    ftypemod = int(stat.S_IFMT(fmode));
7390   else:
7391    fwinattributes = int(0);
7392    if(not member.is_dir()):
7393     fmode = int(stat.S_IFREG + 438);
7394     fchmode = int(stat.S_IMODE(fmode));
7395     ftypemod = int(stat.S_IFMT(fmode));
7396    elif(member.is_dir()):
7397     fmode = int(stat.S_IFDIR + 511);
7398     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
7399     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
7400   returnval.update({lcfi: member.filename});
7401   if(not verbose):
7402    VerbosePrintOut(member.filename);
7403   if(verbose):
7404    permissions = { 'access': { '0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': ('r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx') }, 'roles': { 0: 'owner', 1: 'group', 2: 'other' } };
7405    permissionstr = "";
7406    for fmodval in str(oct(fmode))[-3:]:
7407     permissionstr = permissionstr + permissions['access'].get(fmodval, '---');
7408    if(not member.is_dir()):
7409     ftype = 0;
7410     permissionstr = "-" + permissionstr;
7411    elif(member.is_dir()):
7412     ftype = 5;
7413     permissionstr = "d" + permissionstr;
7414    printfname = member.filename;
7415    try:
7416     fuid = int(os.getuid());
7417    except AttributeError:
7418     fuid = int(0);
7419    except KeyError:
7420     fuid = int(0);
7421    try:
7422     fgid = int(os.getgid());
7423    except AttributeError:
7424     fgid = int(0);
7425    except KeyError:
7426     fgid = int(0);
7427    try:
7428     import pwd;
7429     try:
7430      userinfo = pwd.getpwuid(os.getuid());
7431      funame = userinfo.pw_name;
7432     except KeyError:
7433      funame = "";
7434     except AttributeError:
7435      funame = "";
7436    except ImportError:
7437     funame = "";
7438    fgname = "";
7439    try:
7440     import grp;
7441     try:
7442      groupinfo = grp.getgrgid(os.getgid());
7443      fgname = groupinfo.gr_name;
7444     except KeyError:
7445      fgname = "";
7446     except AttributeError:
7447      fgname = "";
7448    except ImportError:
7449     fgname = "";
7450    fuprint = funame;
7451    if(len(fuprint)<=0):
7452     fuprint = str(fuid);
7453    fgprint = fgname;
7454    if(len(fgprint)<=0):
7455     fgprint = str(fgid);
7456    VerbosePrintOut(PrintPermissionString(fmode, ftype) + " " + str(str(fuprint) + "/" + str(fgprint) + " " + str(member.file_size).rjust(15) + " " + datetime.datetime.utcfromtimestamp(int(time.mktime(member.date_time + (0, 0, -1)))).strftime('%Y-%m-%d %H:%M') + " " + printfname));
7457   lcfi = lcfi + 1;
7458  if(returnfp):
7459   return listcatfiles['catfp'];
7460  else:
7461   return True;
7462
7463 if(not rarfile_support):
7464  def RarFileListFiles(infile, verbose=False, returnfp=False):
7465   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7466   if(not os.path.exists(infile) or not os.path.isfile(infile)):
7467    return False;
7468
7469 if(rarfile_support):
7470  def RarFileListFiles(infile, verbose=False, returnfp=False):
7471   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7472   if(not os.path.exists(infile) or not os.path.isfile(infile)):
7473    return False;
7474   if(not rarfile.is_rarfile(infile) and not rarfile.is_rarfile_sfx(infile)):
7475    return False;
7476   lcfi = 0;
7477   returnval = {};
7478   rarfp = rarfile.RarFile(infile, "r");
7479   rartest = rarfp.testrar();
7480   if(rartest):
7481    VerbosePrintOut("Bad file found!");
7482   for member in sorted(rarfp.infolist(), key=lambda x: x.filename):
7483    is_unix = False;
7484    is_windows = False;
7485    if(member.host_os==rarfile.RAR_OS_UNIX):
7486     is_windows = False;
7487     try:
7488      member.external_attr
7489      is_unix = True;
7490     except AttributeError:
7491      is_unix = False;
7492    elif(member.host_os==rarfile.RAR_OS_WIN32):
7493     is_unix = False;
7494     try:
7495      member.external_attr
7496      is_windows = True;
7497     except AttributeError:
7498      is_windows = False;
7499    else:
7500     is_unix = False;
7501     is_windows = False;
7502    if(is_unix and member.external_attr !=0):
7503     fpremode = int(member.external_attr);
7504    elif(member.is_file()):
7505     fpremode = int(stat.S_IFREG + 438);
7506    elif(member.is_symlink()):
7507     fpremode = int(stat.S_IFLNK + 438);
7508    elif(member.is_dir()):
7509     fpremode = int(stat.S_IFDIR + 511);
7510    if(is_windows and member.external_attr !=0):
7511     fwinattributes = int(member.external_attr);
7512    else:
7513     fwinattributes = int(0);
7514    if(is_unix and member.external_attr !=0):
7515     fmode = int(member.external_attr);
7516     fchmode = int(stat.S_IMODE(member.external_attr));
7517     ftypemod = int(stat.S_IFMT(member.external_attr));
7518    elif(member.is_file()):
7519     fmode = int(stat.S_IFREG + 438);
7520     fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)));
7521     ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)));
7522    elif(member.is_symlink()):
7523     fmode = int(stat.S_IFLNK + 438);
7524     fchmode = int(stat.S_IMODE(int(stat.S_IFLNK + 438)));
7525     ftypemod = int(stat.S_IFMT(int(stat.S_IFLNK + 438)));
7526    elif(member.is_dir()):
7527     fmode = int(stat.S_IFDIR + 511);
7528     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
7529     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
7530    returnval.update({lcfi: member.filename});
7531    if(not verbose):
7532     VerbosePrintOut(member.filename);
7533    if(verbose):
7534     permissions = { 'access': { '0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': ('r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx') }, 'roles': { 0: 'owner', 1: 'group', 2: 'other' } };
7535     permissionstr = "";
7536     for fmodval in str(oct(fmode))[-3:]:
7537      permissionstr = permissionstr + permissions['access'].get(fmodval, '---');
7538     if(member.is_file()):
7539      ftype = 0;
7540      permissionstr = "-" + permissionstr;
7541      printfname = member.filename;
7542     elif(member.is_symlink()):
7543      ftype = 2;
7544      permissionstr = "l" + permissionstr;
7545      printfname = member.name + " -> " + member.read().decode("UTF-8");
7546     elif(member.is_dir()):
7547      ftype = 5;
7548      permissionstr = "d" + permissionstr;
7549      printfname = member.filename;
7550     try:
7551      fuid = int(os.getuid());
7552     except AttributeError:
7553      fuid = int(0);
7554     except KeyError:
7555      fuid = int(0);
7556     try:
7557      fgid = int(os.getgid());
7558     except AttributeError:
7559      fgid = int(0);
7560     except KeyError:
7561      fgid = int(0);
7562     try:
7563      import pwd;
7564      try:
7565       userinfo = pwd.getpwuid(os.getuid());
7566       funame = userinfo.pw_name;
7567      except KeyError:
7568       funame = "";
7569      except AttributeError:
7570       funame = "";
7571     except ImportError:
7572      funame = "";
7573     fgname = "";
7574     try:
7575      import grp;
7576      try:
7577       groupinfo = grp.getgrgid(os.getgid());
7578       fgname = groupinfo.gr_name;
7579      except KeyError:
7580       fgname = "";
7581      except AttributeError:
7582       fgname = "";
7583     except ImportError:
7584      fgname = "";
7585     fuprint = funame;
7586     if(len(fuprint)<=0):
7587      fuprint = str(fuid);
7588     fgprint = fgname;
7589     if(len(fgprint)<=0):
7590      fgprint = str(fgid);
7591     VerbosePrintOut(PrintPermissionString(fmode, ftype) + " " + str(str(fuprint) + "/" + str(fgprint) + " " + str(member.file_size).rjust(15) + " " + member.mtime.strftime('%Y-%m-%d %H:%M') + " " + printfname));
7592    lcfi = lcfi + 1;
7593   if(returnfp):
7594    return listcatfiles['catfp'];
7595   else:
7596    return True;
7597
7598 if(not py7zr_support):
7599  def SevenZipFileListFiles(infile, verbose=False, returnfp=False):
7600   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7601   if(not os.path.exists(infile) or not os.path.isfile(infile)):
7602    return False;
7603
7604 if(py7zr_support):
7605  def SevenZipFileListFiles(infile, verbose=False, returnfp=False):
7606   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7607   if(not os.path.exists(infile) or not os.path.isfile(infile)):
7608    return False;
7609   lcfi = 0;
7610   returnval = {};
7611   szpfp = py7zr.SevenZipFile(infile, mode="r");
7612   file_content = szpfp.readall();
7613   #sztest = szpfp.testzip();
7614   sztestalt = szpfp.test();
7615   if(sztestalt):
7616    VerbosePrintOut("Bad file found!");
7617   for member in sorted(szpfp.list(), key=lambda x: x.filename):
7618    if(re.findall("^[.|/]", member.filename)):
7619     fname = member.filename;
7620    else:
7621     fname = "./"+member.filename;
7622    if(not member.is_directory):
7623     fpremode = int(stat.S_IFREG + 438);
7624    elif(member.is_directory):
7625     fpremode = int(stat.S_IFDIR + 511);
7626    fwinattributes = int(0);
7627    if(member.is_directory):
7628     fmode = int(stat.S_IFDIR + 511);
7629     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
7630     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
7631    else:
7632     fmode = int(stat.S_IFLNK + 438);
7633     fchmode = int(stat.S_IMODE(int(stat.S_IFLNK + 438)));
7634     ftypemod = int(stat.S_IFMT(int(stat.S_IFLNK + 438)));
7635    returnval.update({lcfi: member.filename});
7636    if(not verbose):
7637     VerbosePrintOut(member.filename);
7638    if(verbose):
7639     permissions = { 'access': { '0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': ('r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx') }, 'roles': { 0: 'owner', 1: 'group', 2: 'other' } };
7640     permissionstr = "";
7641     for fmodval in str(oct(fmode))[-3:]:
7642      permissionstr = permissionstr + permissions['access'].get(fmodval, '---');
7643     fsize = int("0");
7644     if(not member.is_directory):
7645      ftype = 0;
7646      permissionstr = "-" + permissionstr;
7647      printfname = member.filename;
7648     elif(member.is_directory):
7649      ftype = 5;
7650      permissionstr = "d" + permissionstr;
7651      printfname = member.filename;
7652     if(ftype==0):
7653      fsize = len(file_content[member.filename].read());
7654      file_content[member.filename].close();
7655     try:
7656      fuid = int(os.getuid());
7657     except AttributeError:
7658      fuid = int(0);
7659     except KeyError:
7660      fuid = int(0);
7661     try:
7662      fgid = int(os.getgid());
7663     except AttributeError:
7664      fgid = int(0);
7665     except KeyError:
7666      fgid = int(0);
7667     try:
7668      import pwd;
7669      try:
7670       userinfo = pwd.getpwuid(os.getuid());
7671       funame = userinfo.pw_name;
7672      except KeyError:
7673       funame = "";
7674      except AttributeError:
7675       funame = "";
7676     except ImportError:
7677      funame = "";
7678     fgname = "";
7679     try:
7680      import grp;
7681      try:
7682       groupinfo = grp.getgrgid(os.getgid());
7683       fgname = groupinfo.gr_name;
7684      except KeyError:
7685       fgname = "";
7686      except AttributeError:
7687       fgname = "";
7688     except ImportError:
7689      fgname = "";
7690     fuprint = funame;
7691     if(len(fuprint)<=0):
7692      fuprint = str(fuid);
7693     fgprint = fgname;
7694     if(len(fgprint)<=0):
7695      fgprint = str(fgid);
7696     VerbosePrintOut(PrintPermissionString(fmode, ftype) + " " + str(str(fuprint) + "/" + str(fgprint) + " " + str(fsize).rjust(15) + " " + member.creationtime.strftime('%Y-%m-%d %H:%M') + " " + printfname));
7697    lcfi = lcfi + 1;
7698   if(returnfp):
7699    return listcatfiles['catfp'];
7700   else:
7701    return True;
7702
7703 def ListDirListFiles(infiles, dirlistfromtxt=False, compression="auto", compressionlevel=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, checksumtype="crc32", formatspecs=__file_format_list__, verbose=False, returnfp=False):
7704  outarray = BytesIO();
7705  packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, formatspecs, False, True);
7706  listcatfiles = ArchiveFileListFiles(outarray, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp);
7707  return listcatfiles;
7708
7709 def ListDirListFilesAlt(infiles, dirlistfromtxt=False, followlink=False, listonly=True, seekstart=0, seekend=0, skipchecksum=False, checksumtype="crc32", formatspecs=__file_format_list__, verbose=False, returnfp=False):
7710  outarray = ListDirToArrayAlt(infiles, dirlistfromtxt, followlink, listonly, checksumtype, formatspecs, verbose);
7711  listcatfiles = ArchiveFileListFiles(outarray, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp);
7712  return listcatfiles;
7713
7714 def PackArchiveFileFromListDirAlt(infiles, outfile, dirlistfromtxt=False, compression="auto", compressionlevel=None, followlink=False, skipchecksum=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7715  outarray = ListDirToArrayAlt(infiles, dirlistfromtxt, followlink, False, checksumtype, extradata, formatspecs, False);
7716  listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, followlink, checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp);
7717  return listcatfiles;
7718
7719 create_alias_function("Pack", __file_format_name__, "FromListDirAlt", PackArchiveFileFromListDirAlt);
7720
7721 def PackArchiveFileFromTarFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7722  outarray = TarFileToArrayAlt(infile, False, checksumtype, extradata, formatspecs, False);
7723  listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp);
7724  return listcatfiles;
7725
7726 create_alias_function("Pack", __file_format_name__, "FromTarFileAlt", PackArchiveFileFromTarFileAlt);
7727
7728 def PackArchiveFileFromZipFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7729  outarray = ZipFileToArrayAlt(infile, False, checksumtype, extradata, formatspecs, False);
7730  listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp);
7731  return listcatfiles;
7732
7733 create_alias_function("Pack", __file_format_name__, "FromZipFileAlt", PackArchiveFileFromZipFileAlt);
7734
7735 if(not rarfile_support):
7736  def PackArchiveFileFromRarFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7737   return False;
7738
7739 if(rarfile_support):
7740  def PackArchiveFileFromRarFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7741   outarray = RarFileToArrayAlt(infile, False, checksumtype, extradata, formatspecs, False);
7742   listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp);
7743   return listcatfiles;
7744
7745 if(rarfile_support):
7746  create_alias_function("Pack", __file_format_name__, "FromRarFileAlt", PackArchiveFileFromRarFileAlt);
7747
7748 if(not py7zr_support):
7749  def PackArchiveFileFromSevenZipFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7750   return False;
7751
7752 if(py7zr_support):
7753  def PackArchiveFileFromSevenZipFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7754   outarray = SevenZipFileToArrayAlt(infile, False, checksumtype, extradata, formatspecs, False);
7755   listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp);
7756   return listcatfiles;
7757
7758 if(py7zr_support):
7759  create_alias_function("Pack", __file_format_name__, "FromSevenZipFileAlt", PackArchiveFileFromSevenZipFileAlt);
7760
7761 def download_file_from_ftp_file(url):
7762  urlparts = urlparse(url);
7763  file_name = os.path.basename(urlparts.path);
7764  file_dir = os.path.dirname(urlparts.path);
7765  if(urlparts.username is not None):
7766   ftp_username = urlparts.username;
7767  else:
7768   ftp_username = "anonymous";
7769  if(urlparts.password is not None):
7770   ftp_password = urlparts.password;
7771  elif(urlparts.password is None and urlparts.username=="anonymous"):
7772   ftp_password = "anonymous";
7773  else:
7774   ftp_password = "";
7775  if(urlparts.scheme=="ftp"):
7776   ftp = FTP();
7777  elif(urlparts.scheme=="ftps"):
7778   ftp = FTP_TLS();
7779  else:
7780   return False;
7781  if(urlparts.scheme=="sftp"):
7782   if(__use_pysftp__):
7783    return download_file_from_pysftp_file(url);
7784   else:
7785    return download_file_from_sftp_file(url);
7786  elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
7787   return download_file_from_http_file(url);
7788  ftp_port = urlparts.port;
7789  if(urlparts.port is None):
7790   ftp_port = 21;
7791  try:
7792   ftp.connect(urlparts.hostname, ftp_port);
7793  except socket.gaierror:
7794   log.info("Error With URL "+url);
7795   return False;
7796  except socket.timeout:
7797   log.info("Error With URL "+url);
7798   return False;
7799  ftp.login(urlparts.username, urlparts.password);
7800  if(urlparts.scheme=="ftps"):
7801   ftp.prot_p();
7802  ftpfile = BytesIO();
7803  ftp.retrbinary("RETR "+urlparts.path, ftpfile.write);
7804  #ftp.storbinary("STOR "+urlparts.path, ftpfile.write);
7805  ftp.close();
7806  ftpfile.seek(0, 0);
7807  return ftpfile;
7808
7809 def download_file_from_ftp_string(url):
7810  ftpfile = download_file_from_ftp_file(url);
7811  return ftpfile.read();
7812
7813 def upload_file_to_ftp_file(ftpfile, url):
7814  urlparts = urlparse(url);
7815  file_name = os.path.basename(urlparts.path);
7816  file_dir = os.path.dirname(urlparts.path);
7817  if(urlparts.username is not None):
7818   ftp_username = urlparts.username;
7819  else:
7820   ftp_username = "anonymous";
7821  if(urlparts.password is not None):
7822   ftp_password = urlparts.password;
7823  elif(urlparts.password is None and urlparts.username=="anonymous"):
7824   ftp_password = "anonymous";
7825  else:
7826   ftp_password = "";
7827  if(urlparts.scheme=="ftp"):
7828   ftp = FTP();
7829  elif(urlparts.scheme=="ftps"):
7830   ftp = FTP_TLS();
7831  else:
7832   return False;
7833  if(urlparts.scheme=="sftp"):
7834   if(__use_pysftp__):
7835    return upload_file_from_pysftp_file(url);
7836   else:
7837    return upload_file_from_sftp_file(url);
7838  elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
7839   return False;
7840  ftp_port = urlparts.port;
7841  if(urlparts.port is None):
7842   ftp_port = 21;
7843  try:
7844   ftp.connect(urlparts.hostname, ftp_port);
7845  except socket.gaierror:
7846   log.info("Error With URL "+url);
7847   return False;
7848  except socket.timeout:
7849   log.info("Error With URL "+url);
7850   return False;
7851  ftp.login(urlparts.username, urlparts.password);
7852  if(urlparts.scheme=="ftps"):
7853   ftp.prot_p();
7854  ftp.storbinary("STOR "+urlparts.path, ftpfile);
7855  ftp.close();
7856  ftpfile.seek(0, 0);
7857  return ftpfile;
7858
7859 def upload_file_to_ftp_string(ftpstring, url):
7860  ftpfileo = BytesIO(ftpstring);
7861  ftpfile = upload_file_to_ftp_file(ftpfileo, url);
7862  ftpfileo.close();
7863  return ftpfile;
7864
7865 def download_file_from_http_file(url, headers=geturls_headers_pycatfile_python_alt):
7866  # Parse the URL to extract username and password if present
7867  urlparts = urlparse(url);
7868  username = urlparts.username;
7869  password = urlparts.password;
7870  # Rebuild the URL without the username and password
7871  netloc = urlparts.hostname;
7872  if(urlparts.scheme=="sftp"):
7873   if(__use_pysftp__):
7874    return download_file_from_pysftp_file(url);
7875   else:
7876    return download_file_from_sftp_file(url);
7877  elif(urlparts.scheme=="ftp" or urlparts.scheme=="ftps"):
7878   return download_file_from_ftp_file(url);
7879  if urlparts.port:
7880    netloc += ':' + str(urlparts.port);
7881  rebuilt_url = urlunparse((urlparts.scheme, netloc, urlparts.path, urlparts.params, urlparts.query, urlparts.fragment));
7882  # Create a temporary file object
7883  httpfile = BytesIO();
7884  if haverequests:
7885   # Use the requests library if available
7886   if username and password:
7887    response = requests.get(rebuilt_url, headers=headers, auth=(username, password), stream=True);
7888   else:
7889    response = requests.get(rebuilt_url, headers=headers, stream=True);
7890   response.raw.decode_content = True
7891   shutil.copyfileobj(response.raw, httpfile);
7892  else:
7893   # Build a Request object for urllib
7894   request = Request(rebuilt_url, headers=headers);
7895   # Create an opener object for handling URLs
7896   if username and password:
7897    # Create a password manager
7898    password_mgr = HTTPPasswordMgrWithDefaultRealm();
7899    # Add the username and password
7900    password_mgr.add_password(None, rebuilt_url, username, password);
7901    # Create an authentication handler using the password manager
7902    auth_handler = HTTPBasicAuthHandler(password_mgr);
7903    # Build the opener with the authentication handler
7904    opener = build_opener(auth_handler);
7905   else:
7906       opener = build_opener();
7907   with opener.open(request) as response:
7908    shutil.copyfileobj(response, httpfile);
7909  # Reset file pointer to the start
7910  httpfile.seek(0, 0);
7911  # Return the temporary file object
7912  return httpfile;
7913
7914 def download_file_from_http_string(url, headers=geturls_headers_pycatfile_python_alt):
7915  httpfile = download_file_from_http_file(url, headers);
7916  return ftpfile.read();
7917
7918 if(haveparamiko):
7919  def download_file_from_sftp_file(url):
7920   urlparts = urlparse(url);
7921   file_name = os.path.basename(urlparts.path);
7922   file_dir = os.path.dirname(urlparts.path);
7923   sftp_port = urlparts.port;
7924   if(urlparts.port is None):
7925    sftp_port = 22;
7926   else:
7927    sftp_port = urlparts.port;
7928   if(urlparts.username is not None):
7929    sftp_username = urlparts.username;
7930   else:
7931    sftp_username = "anonymous";
7932   if(urlparts.password is not None):
7933    sftp_password = urlparts.password;
7934   elif(urlparts.password is None and urlparts.username=="anonymous"):
7935    sftp_password = "anonymous";
7936   else:
7937    sftp_password = "";
7938   if(urlparts.scheme=="ftp"):
7939    return download_file_from_ftp_file(url);
7940   elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
7941    return download_file_from_http_file(url);
7942   if(urlparts.scheme!="sftp"):
7943    return False;
7944   ssh = paramiko.SSHClient();
7945   ssh.load_system_host_keys();
7946   ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy());
7947   try:
7948    ssh.connect(urlparts.hostname, port=sftp_port, username=urlparts.username, password=urlparts.password);
7949   except paramiko.ssh_exception.SSHException:
7950    return False;
7951   except socket.gaierror:
7952    log.info("Error With URL "+url);
7953    return False;
7954   except socket.timeout:
7955    log.info("Error With URL "+url);
7956    return False;
7957   sftp = ssh.open_sftp();
7958   sftpfile = BytesIO();
7959   sftp.getfo(urlparts.path, sftpfile);
7960   sftp.close();
7961   ssh.close();
7962   sftpfile.seek(0, 0);
7963   return sftpfile;
7964 else:
7965  def download_file_from_sftp_file(url):
7966   return False;
7967
7968 if(haveparamiko):
7969  def download_file_from_sftp_string(url):
7970   sftpfile = download_file_from_sftp_file(url);
7971   return sftpfile.read();
7972 else:
7973  def download_file_from_ftp_string(url):
7974   return False;
7975
7976 if(haveparamiko):
7977  def upload_file_to_sftp_file(sftpfile, url):
7978   urlparts = urlparse(url);
7979   file_name = os.path.basename(urlparts.path);
7980   file_dir = os.path.dirname(urlparts.path);
7981   sftp_port = urlparts.port;
7982   if(urlparts.port is None):
7983    sftp_port = 22;
7984   else:
7985    sftp_port = urlparts.port;
7986   if(urlparts.username is not None):
7987    sftp_username = urlparts.username;
7988   else:
7989    sftp_username = "anonymous";
7990   if(urlparts.password is not None):
7991    sftp_password = urlparts.password;
7992   elif(urlparts.password is None and urlparts.username=="anonymous"):
7993    sftp_password = "anonymous";
7994   else:
7995    sftp_password = "";
7996   if(urlparts.scheme=="ftp"):
7997    return upload_file_from_ftp_file(url);
7998   elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
7999    return False;
8000   if(urlparts.scheme!="sftp"):
8001    return False;
8002   ssh = paramiko.SSHClient();
8003   ssh.load_system_host_keys();
8004   ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy());
8005   try:
8006    ssh.connect(urlparts.hostname, port=sftp_port, username=urlparts.username, password=urlparts.password);
8007   except paramiko.ssh_exception.SSHException:
8008    return False;
8009   except socket.gaierror:
8010    log.info("Error With URL "+url);
8011    return False;
8012   except socket.timeout:
8013    log.info("Error With URL "+url);
8014    return False;
8015   sftp = ssh.open_sftp();
8016   sftp.putfo(sftpfile, urlparts.path);
8017   sftp.close();
8018   ssh.close();
8019   sftpfile.seek(0, 0);
8020   return sftpfile;
8021 else:
8022  def upload_file_to_sftp_file(sftpfile, url):
8023   return False;
8024
8025 if(haveparamiko):
8026  def upload_file_to_sftp_string(sftpstring, url):
8027   sftpfileo = BytesIO(sftpstring);
8028   sftpfile = upload_file_to_sftp_files(ftpfileo, url);
8029   sftpfileo.close();
8030   return sftpfile;
8031 else:
8032  def upload_file_to_sftp_string(url):
8033   return False;
8034
8035 if(havepysftp):
8036  def download_file_from_pysftp_file(url):
8037   urlparts = urlparse(url);
8038   file_name = os.path.basename(urlparts.path);
8039   file_dir = os.path.dirname(urlparts.path);
8040   sftp_port = urlparts.port;
8041   if(urlparts.port is None):
8042    sftp_port = 22;
8043   else:
8044    sftp_port = urlparts.port;
8045   if(urlparts.username is not None):
8046    sftp_username = urlparts.username;
8047   else:
8048    sftp_username = "anonymous";
8049   if(urlparts.password is not None):
8050    sftp_password = urlparts.password;
8051   elif(urlparts.password is None and urlparts.username=="anonymous"):
8052    sftp_password = "anonymous";
8053   else:
8054    sftp_password = "";
8055   if(urlparts.scheme=="ftp"):
8056    return download_file_from_ftp_file(url);
8057   elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
8058    return download_file_from_http_file(url);
8059   if(urlparts.scheme!="sftp"):
8060    return False;
8061   try:
8062    pysftp.Connection(urlparts.hostname, port=sftp_port, username=urlparts.username, password=urlparts.password);
8063   except paramiko.ssh_exception.SSHException:
8064    return False;
8065   except socket.gaierror:
8066    log.info("Error With URL "+url);
8067    return False;
8068   except socket.timeout:
8069    log.info("Error With URL "+url);
8070    return False;
8071   sftp = ssh.open_sftp();
8072   sftpfile = BytesIO();
8073   sftp.getfo(urlparts.path, sftpfile);
8074   sftp.close();
8075   ssh.close();
8076   sftpfile.seek(0, 0);
8077   return sftpfile;
8078 else:
8079  def download_file_from_pysftp_file(url):
8080   return False;
8081
8082 if(havepysftp):
8083  def download_file_from_pysftp_string(url):
8084   sftpfile = download_file_from_pysftp_file(url);
8085   return sftpfile.read();
8086 else:
8087  def download_file_from_ftp_string(url):
8088   return False;
8089
8090 if(havepysftp):
8091  def upload_file_to_pysftp_file(sftpfile, url):
8092   urlparts = urlparse(url);
8093   file_name = os.path.basename(urlparts.path);
8094   file_dir = os.path.dirname(urlparts.path);
8095   sftp_port = urlparts.port;
8096   if(urlparts.port is None):
8097    sftp_port = 22;
8098   else:
8099    sftp_port = urlparts.port;
8100   if(urlparts.username is not None):
8101    sftp_username = urlparts.username;
8102   else:
8103    sftp_username = "anonymous";
8104   if(urlparts.password is not None):
8105    sftp_password = urlparts.password;
8106   elif(urlparts.password is None and urlparts.username=="anonymous"):
8107    sftp_password = "anonymous";
8108   else:
8109    sftp_password = "";
8110   if(urlparts.scheme=="ftp"):
8111    return upload_file_from_ftp_file(url);
8112   elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
8113    return False;
8114   if(urlparts.scheme!="sftp"):
8115    return False;
8116   try:
8117    pysftp.Connection(urlparts.hostname, port=sftp_port, username=urlparts.username, password=urlparts.password);
8118   except paramiko.ssh_exception.SSHException:
8119    return False;
8120   except socket.gaierror:
8121    log.info("Error With URL "+url);
8122    return False;
8123   except socket.timeout:
8124    log.info("Error With URL "+url);
8125    return False;
8126   sftp = ssh.open_sftp();
8127   sftp.putfo(sftpfile, urlparts.path);
8128   sftp.close();
8129   ssh.close();
8130   sftpfile.seek(0, 0);
8131   return sftpfile;
8132 else:
8133  def upload_file_to_pysftp_file(sftpfile, url):
8134   return False;
8135
8136 if(havepysftp):
8137  def upload_file_to_pysftp_string(sftpstring, url):
8138   sftpfileo = BytesIO(sftpstring);
8139   sftpfile = upload_file_to_pysftp_files(ftpfileo, url);
8140   sftpfileo.close();
8141   return sftpfile;
8142 else:
8143  def upload_file_to_pysftp_string(url):
8144   return False;
8145
8146 def download_file_from_internet_file(url, headers=geturls_headers_pycatfile_python_alt):
8147  urlparts = urlparse(url);
8148  if(urlparts.scheme=="http" or urlparts.scheme=="https"):
8149   return download_file_from_http_file(url, headers);
8150  elif(urlparts.scheme=="ftp" or urlparts.scheme=="ftps"):
8151   return download_file_from_ftp_file(url);
8152  elif(urlparts.scheme=="sftp"):
8153   if(__use_pysftp__ and havepysftp):
8154    return download_file_from_pysftp_file(url);
8155   else:
8156    return download_file_from_sftp_file(url);
8157  else:
8158   return False;
8159  return False;
8160
8161 def download_file_from_internet_uncompress_file(url, headers=geturls_headers_pycatfile_python_alt, formatspecs=__file_format_list__):
8162  fp = download_file_from_internet_file(url);
8163  fp = UncompressArchiveFile(fp, formatspecs);
8164  fp.seek(0, 0);
8165  if(not fp):
8166   return False;
8167  return fp;
8168
8169 def download_file_from_internet_string(url, headers=geturls_headers_pycatfile_python_alt):
8170  urlparts = urlparse(url);
8171  if(urlparts.scheme=="http" or urlparts.scheme=="https"):
8172   return download_file_from_http_string(url, headers);
8173  elif(urlparts.scheme=="ftp" or urlparts.scheme=="ftps"):
8174   return download_file_from_ftp_string(url);
8175  elif(urlparts.scheme=="sftp"):
8176   if(__use_pysftp__ and havepysftp):
8177    return download_file_from_pysftp_string(url);
8178   else:
8179    return download_file_from_sftp_string(url);
8180  else:
8181   return False;
8182  return False;
8183
8184 def download_file_from_internet_uncompress_string(url, headers=geturls_headers_pycatfile_python_alt, formatspecs=__file_format_list__):
8185  fp = download_file_from_internet_string(url);
8186  fp = UncompressArchiveFile(fp, formatspecs);
8187  fp.seek(0, 0);
8188  if(not fp):
8189   return False;
8190  return fp;
8191
8192 def upload_file_to_internet_file(ifp, url):
8193  urlparts = urlparse(url);
8194  if(urlparts.scheme=="http" or urlparts.scheme=="https"):
8195   return False;
8196  elif(urlparts.scheme=="ftp" or urlparts.scheme=="ftps"):
8197   return upload_file_from_ftp_file(ifp, url);
8198  elif(urlparts.scheme=="sftp"):
8199   if(__use_pysftp__ and havepysftp):
8200    return upload_file_from_pysftp_file(ifp, url);
8201   else:
8202    return download_file_from_sftp_file(ifp, url);
8203  else:
8204   return False;
8205  return False;
8206
8207 def upload_file_to_internet_compress_file(ifp, url, formatspecs=__file_format_list__):
8208  catfp = CompressArchiveFile(catfp, compression, formatspecs);
8209  if(not catfileout):
8210   return False;
8211  catfp.seek(0, 0);
8212  upload_file_to_internet_file(catfp, outfile);
8213  return True;
8214
8215 def upload_file_to_internet_string(ifp, url):
8216  urlparts = urlparse(url);
8217  if(urlparts.scheme=="http" or urlparts.scheme=="https"):
8218   return False;
8219  elif(urlparts.scheme=="ftp" or urlparts.scheme=="ftps"):
8220   return upload_file_from_ftp_string(ifp, url);
8221  elif(urlparts.scheme=="sftp"):
8222   if(__use_pysftp__ and havepysftp):
8223    return upload_file_from_pysftp_string(ifp, url);
8224   else:
8225    return download_file_from_sftp_string(ifp, url);
8226  else:
8227   return False;
8228  return False;
8229
8230 def upload_file_to_internet_compress_string(ifp, url, formatspecs=__file_format_list__):
8231  catfp = CompressArchiveFile(BytesIO(ifp), compression, formatspecs);
8232  if(not catfileout):
8233   return False;
8234  catfp.seek(0, 0);
8235  upload_file_to_internet_file(catfp, outfile);
8236  return True;
8237
8238 try:
8239  if(hasattr(shutil, "register_archive_format")):
8240   # Register the packing format
8241   shutil.register_archive_format(__file_format_name__, PackArchiveFileFunc, description='Pack concatenated files');
8242 except shutil.RegistryError:
8243  pass;
8244
8245 try:
8246  if(hasattr(shutil, "register_unpack_format")):
8247   # Register the unpacking format
8248   shutil.register_unpack_format(__file_format_name__, archivefile_extensions, UnPackArchiveFileFunc, description='UnPack concatenated files');
8249 except shutil.RegistryError:
8250  pass;