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/29/2024 Ver. 0.9.0 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, 9, 0, "RC 1", 1);
 175 __version_date_info__ = (2024, 4, 29, "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 create_alias_function("Pack", __file_format_name__, "FromDirList", PackArchiveFileFromDirList);
2619
2620 def PackArchiveFileFromTarFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
2621  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2622   outfile = RemoveWindowsPath(outfile);
2623  checksumtype = checksumtype.lower();
2624  if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
2625   checksumtype="crc32";
2626  if(checksumtype=="none"):
2627   checksumtype = "";
2628  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
2629   compression = None;
2630  if(compression not in compressionlist and compression is None):
2631   compression = "auto";
2632  if(verbose):
2633   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
2634  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2635   if(os.path.exists(outfile)):
2636    os.unlink(outfile);
2637  if(outfile=="-"):
2638   verbose = False;
2639   catfp = BytesIO();
2640  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
2641   catfp = outfile;
2642  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
2643   catfp = BytesIO();
2644  else:
2645   fbasename = os.path.splitext(outfile)[0];
2646   fextname = os.path.splitext(outfile)[1];
2647   catfp = CompressOpenFile(outfile, compressionlevel);
2648  catver = formatspecs[6];
2649  fileheaderver = str(int(catver.replace(".", "")));
2650  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
2651  catfp.write(fileheader.encode('UTF-8'));
2652  curinode = 0;
2653  curfid = 0;
2654  inodelist = [];
2655  inodetofile = {};
2656  filetoinode = {};
2657  inodetocatinode = {};
2658  if(infile=="-"):
2659   infile = BytesIO();
2660   if(hasattr(sys.stdin, "buffer")):
2661    shutil.copyfileobj(sys.stdin.buffer, infile);
2662   else:
2663    shutil.copyfileobj(sys.stdin, infile);
2664   infile.seek(0, 0);
2665   if(not infile):
2666    return False;
2667   infile.seek(0, 0);
2668  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
2669   infile = download_file_from_internet_file(infile);
2670   infile.seek(0, 0);
2671   if(not infile):
2672    return False;
2673   infile.seek(0, 0);
2674  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
2675   return False;
2676  elif(os.path.exists(infile) and os.path.isfile(infile)):
2677   try:
2678    if(not tarfile.is_tarfile(infile)):
2679     return False;
2680   except AttributeError:
2681    if(not is_tarfile(infile)):
2682     return False;
2683  else:
2684   return False;
2685  try:
2686   if(hasattr(infile, "read") or hasattr(infile, "write")):
2687    tarfp = tarfile.open(fileobj=infile, mode="r");
2688   else:
2689    tarfp = tarfile.open(infile, "r");
2690  except FileNotFoundError:
2691   return False;
2692  numfiles = int(len(tarfp.getmembers()));
2693  fnumfiles = format(int(len(tarfp.getmembers())), 'x').lower();
2694  fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
2695  if(checksumtype=="none" or checksumtype==""):
2696   catfileheadercshex = format(0, 'x').lower();
2697  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2698   catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2699  elif(checksumtype=="crc16_ccitt"):
2700   catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2701  elif(checksumtype=="adler32"):
2702   catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2703  elif(checksumtype=="crc32"):
2704   catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2705  elif(checksumtype=="crc64_ecma"):
2706   catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2707  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2708   catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2709  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2710   checksumoutstr = hashlib.new(checksumtype);
2711   checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
2712   catfileheadercshex = checksumoutstr.hexdigest().lower();
2713  else:
2714   catfileheadercshex = format(0, 'x').lower();
2715  fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
2716  catfp.write(fnumfilesa.encode('UTF-8'));
2717  try:
2718   catfp.flush();
2719   os.fsync(catfp.fileno());
2720  except io.UnsupportedOperation:
2721   pass;
2722  except AttributeError:
2723   pass;
2724  for member in sorted(tarfp.getmembers(), key=lambda x: x.name):
2725   catfhstart = catfp.tell();
2726   if(re.findall("^[.|/]", member.name)):
2727    fname = member.name;
2728   else:
2729    fname = "./"+member.name;
2730   if(verbose):
2731    VerbosePrintOut(fname);
2732   fpremode = member.mode;
2733   ffullmode = member.mode;
2734   flinkcount = 0;
2735   ftype = 0;
2736   if(member.isreg()):
2737    ffullmode = member.mode + stat.S_IFREG;
2738    ftype = 0;
2739   elif(member.isdev()):
2740    ffullmode = member.mode;
2741    ftype = 7;
2742   elif(member.islnk()):
2743    ffullmode = member.mode + stat.S_IFREG;
2744    ftype = 1;
2745   elif(member.issym()):
2746    ffullmode = member.mode + stat.S_IFLNK;
2747    ftype = 2;
2748   elif(member.ischr()):
2749    ffullmode = member.mode + stat.S_IFCHR;
2750    ftype = 3;
2751   elif(member.isblk()):
2752    ffullmode = member.mode + stat.S_IFBLK;
2753    ftype = 4;
2754   elif(member.isdir()):
2755    ffullmode = member.mode + stat.S_IFDIR;
2756    ftype = 5;
2757   elif(member.isfifo()):
2758    ffullmode = member.mode + stat.S_IFIFO;
2759    ftype = 6;
2760   elif(member.issparse()):
2761    ffullmode = member.mode;
2762    ftype = 12;
2763   else:
2764    ffullmode = member.mode;
2765    ftype = 0;
2766   flinkname = "";
2767   fcurfid = format(int(curfid), 'x').lower();
2768   fcurinode = format(int(curfid), 'x').lower();
2769   curfid = curfid + 1;
2770   if(ftype==2):
2771    flinkname = member.linkname;
2772   fdev_minor = format(int(member.devminor), 'x').lower();
2773   fdev_major = format(int(member.devmajor), 'x').lower();
2774   frdev_minor = format(int(member.devminor), 'x').lower();
2775   frdev_major = format(int(member.devmajor), 'x').lower();
2776   if(ftype==1 or ftype==2 or ftype==3 or ftype==4 or ftype==5 or ftype==6):
2777    fsize = format(int("0"), 'x').lower();
2778   elif(ftype==0 or ftype==7):
2779    fsize = format(int(member.size), 'x').lower();
2780   else:
2781    fsize = format(int(member.size), 'x').lower();
2782   fatime = format(int(member.mtime), 'x').lower();
2783   fmtime = format(int(member.mtime), 'x').lower();
2784   fctime = format(int(member.mtime), 'x').lower();
2785   fbtime = format(int(member.mtime), 'x').lower();
2786   fmode = format(int(ffullmode), 'x').lower();
2787   fchmode = format(int(stat.S_IMODE(ffullmode)), 'x').lower();
2788   ftypemod = format(int(stat.S_IFMT(ffullmode)), 'x').lower();
2789   fuid = format(int(member.uid), 'x').lower();
2790   fgid = format(int(member.gid), 'x').lower();
2791   funame = member.uname;
2792   fgname = member.gname;
2793   flinkcount = format(int(flinkcount), 'x').lower();
2794   fwinattributes = format(int(0), 'x').lower();
2795   fcontents = "".encode('UTF-8');
2796   chunk_size = 1024;
2797   if(ftype==0 or ftype==7):
2798    with tarfp.extractfile(member) as fpc:
2799     while(True):
2800      chunk = fpc.read(chunk_size);
2801      if(not chunk):
2802       break
2803      fcontents += chunk;
2804   ftypehex = format(ftype, 'x').lower();
2805   extrafields = format(len(extradata), 'x').lower();
2806   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
2807   if(len(extradata)>0):
2808    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
2809   extrasizelen = format(len(extrasizestr), 'x').lower();
2810   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];
2811   catoutlen = len(catoutlist) + len(extradata) + 3;
2812   catoutlenhex = format(catoutlen, 'x').lower();
2813   catoutlist.insert(0, catoutlenhex);
2814   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
2815   if(len(extradata)>0):
2816    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
2817   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
2818   catfhend = (catfp.tell() - 1) + len(catfileoutstr);
2819   catfcontentstart = catfp.tell() + len(catfileoutstr);
2820   if(checksumtype=="none" or checksumtype==""):
2821    catfileheadercshex = format(0, 'x').lower();
2822    catfilecontentcshex = format(0, 'x').lower();
2823   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2824    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
2825    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
2826   elif(checksumtype=="crc16_ccitt"):
2827    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
2828    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
2829   elif(checksumtype=="adler32"):
2830    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2831    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
2832   elif(checksumtype=="crc32"):
2833    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2834    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
2835   elif(checksumtype=="crc64_ecma"):
2836    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2837    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
2838   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2839    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2840    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
2841   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2842    checksumoutstr = hashlib.new(checksumtype);
2843    checksumoutstr.update("".encode('UTF-8'));
2844    catfileheadercshex = checksumoutstr.hexdigest().lower();
2845    checksumoutstr = hashlib.new(checksumtype);
2846    checksumoutstr.update(fcontents);
2847    catfilecontentcshex = checksumoutstr.hexdigest().lower();
2848   else:
2849    catfileheadercshex = format(0, 'x').lower();
2850    catfilecontentcshex = format(0, 'x').lower();
2851   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
2852   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
2853   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
2854   if(checksumtype=="none" or checksumtype==""):
2855    catfileheadercshex = format(0, 'x').lower();
2856   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2857    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
2858   elif(checksumtype=="crc16_ccitt"):
2859    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
2860   elif(checksumtype=="adler32"):
2861    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
2862   elif(checksumtype=="crc32"):
2863    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
2864   elif(checksumtype=="crc64_ecma"):
2865    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2866   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2867    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2868   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2869    checksumoutstr = hashlib.new(checksumtype);
2870    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
2871    catfileheadercshex = checksumoutstr.hexdigest().lower();
2872   else:
2873    catfileheadercshex = format(0, 'x').lower();
2874   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
2875   catfileoutstrecd = catfileoutstr.encode('UTF-8');
2876   nullstrecd = formatspecs[5].encode('UTF-8');
2877   catfileout = catfileoutstrecd + fcontents + nullstrecd;
2878   catfcontentend = (catfp.tell() - 1) + len(catfileout);
2879   catfp.write(catfileout);
2880   try:
2881    catfp.flush();
2882    os.fsync(catfp.fileno());
2883   except io.UnsupportedOperation:
2884    pass;
2885   except AttributeError:
2886    pass;
2887  if(numfiles>0):
2888   catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
2889  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
2890   catfp = CompressArchiveFile(catfp, compression, formatspecs);
2891   try:
2892    catfp.flush();
2893    os.fsync(catfp.fileno());
2894   except io.UnsupportedOperation:
2895    pass;
2896   except AttributeError:
2897    pass;
2898  if(outfile=="-"):
2899   catfp.seek(0, 0);
2900   if(hasattr(sys.stdout, "buffer")):
2901    shutil.copyfileobj(catfp, sys.stdout.buffer);
2902   else:
2903    shutil.copyfileobj(catfp, sys.stdout);
2904  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
2905   catfp = CompressArchiveFile(catfp, compression, formatspecs);
2906   catfp.seek(0, 0);
2907   upload_file_to_internet_file(catfp, outfile);
2908  if(returnfp):
2909   catfp.seek(0, 0);
2910   return catfp;
2911  else:
2912   catfp.close();
2913   return True;
2914
2915 create_alias_function("Pack", __file_format_name__, "FromTarFile", PackArchiveFileFromTarFile);
2916
2917 def PackArchiveFileFromZipFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
2918  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2919   outfile = RemoveWindowsPath(outfile);
2920  checksumtype = checksumtype.lower();
2921  if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
2922   checksumtype="crc32";
2923  if(checksumtype=="none"):
2924   checksumtype = "";
2925  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
2926   compression = None;
2927  if(compression not in compressionlist and compression is None):
2928   compression = "auto";
2929  if(verbose):
2930   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
2931  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2932   if(os.path.exists(outfile)):
2933    os.unlink(outfile);
2934  if(outfile=="-"):
2935   verbose = False;
2936   catfp = BytesIO();
2937  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
2938   catfp = outfile;
2939  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
2940   catfp = BytesIO();
2941  else:
2942   fbasename = os.path.splitext(outfile)[0];
2943   fextname = os.path.splitext(outfile)[1];
2944   catfp = CompressOpenFile(outfile, compressionlevel);
2945  catver = formatspecs[6];
2946  fileheaderver = str(int(catver.replace(".", "")));
2947  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
2948  catfp.write(fileheader.encode('UTF-8'));
2949  curinode = 0;
2950  curfid = 0;
2951  inodelist = [];
2952  inodetofile = {};
2953  filetoinode = {};
2954  inodetocatinode = {};
2955  if(infile=="-"):
2956   infile = BytesIO();
2957   if(hasattr(sys.stdin, "buffer")):
2958    shutil.copyfileobj(sys.stdin.buffer, infile);
2959   else:
2960    shutil.copyfileobj(sys.stdin, infile);
2961   infile.seek(0, 0);
2962   if(not infile):
2963    return False;
2964   infile.seek(0, 0);
2965  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
2966   infile = download_file_from_internet_file(infile);
2967   infile.seek(0, 0);
2968   if(not infile):
2969    return False;
2970   infile.seek(0, 0);
2971  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
2972   return False;
2973  else:
2974   return False;
2975  if(not zipfile.is_zipfile(infile)):
2976   return False;
2977  try:
2978   zipfp = zipfile.ZipFile(infile, "r", allowZip64=True);
2979  except FileNotFoundError:
2980   return False;
2981  ziptest = zipfp.testzip();
2982  if(ziptest):
2983   VerbosePrintOut("Bad file found!");
2984  numfiles = int(len(zipfp.infolist()));
2985  fnumfiles = format(int(len(zipfp.infolist())), 'x').lower();
2986  fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
2987  if(checksumtype=="none" or checksumtype==""):
2988   catfileheadercshex = format(0, 'x').lower();
2989  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2990   catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2991  elif(checksumtype=="crc16_ccitt"):
2992   catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2993  elif(checksumtype=="adler32"):
2994   catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2995  elif(checksumtype=="crc32"):
2996   catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2997  elif(checksumtype=="crc64_ecma"):
2998   catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2999  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3000   catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3001  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3002   checksumoutstr = hashlib.new(checksumtype);
3003   checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
3004   catfileheadercshex = checksumoutstr.hexdigest().lower();
3005  else:
3006   catfileheadercshex = format(0, 'x').lower();
3007  fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
3008  catfp.write(fnumfilesa.encode('UTF-8'));
3009  try:
3010   catfp.flush();
3011   os.fsync(catfp.fileno());
3012  except io.UnsupportedOperation:
3013   pass;
3014  except AttributeError:
3015   pass;
3016  for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
3017   catfhstart = catfp.tell();
3018   if(re.findall("^[.|/]", member.filename)):
3019    fname = member.filename;
3020   else:
3021    fname = "./"+member.filename;
3022   zipinfo = zipfp.getinfo(member.filename);
3023   if(verbose):
3024    VerbosePrintOut(fname);
3025   if(not member.is_dir()):
3026    fpremode = int(stat.S_IFREG + 438);
3027   elif(member.is_dir()):
3028    fpremode = int(stat.S_IFDIR + 511);
3029   flinkcount = 0;
3030   ftype = 0;
3031   if(not member.is_dir()):
3032    ftype = 0;
3033   elif(member.is_dir()):
3034    ftype = 5;
3035   flinkname = "";
3036   fcurfid = format(int(curfid), 'x').lower();
3037   fcurinode = format(int(curfid), 'x').lower();
3038   curfid = curfid + 1;
3039   fdev_minor = format(int(0), 'x').lower();
3040   fdev_major = format(int(0), 'x').lower();
3041   frdev_minor = format(int(0), 'x').lower();
3042   frdev_major = format(int(0), 'x').lower();
3043   if(ftype==5):
3044    fsize = format(int("0"), 'x').lower();
3045   elif(ftype==0):
3046    fsize = format(int(member.file_size), 'x').lower();
3047   else:
3048    fsize = format(int(member.file_size), 'x').lower();
3049   fatime = format(int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower();
3050   fmtime = format(int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower();
3051   fctime = format(int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower();
3052   fbtime = format(int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower();
3053   if(zipinfo.create_system==0 or zipinfo.create_system==10):
3054    fwinattributes = format(int(zipinfo.external_attr), 'x').lower();
3055    if(not member.is_dir()):
3056     fmode = format(int(stat.S_IFREG + 438), 'x').lower();
3057     fchmode = stat.S_IMODE(fmode);
3058     ftypemod = stat.S_IFMT(fmode);
3059    elif(member.is_dir()):
3060     fmode = format(int(stat.S_IFDIR + 511), 'x').lower();
3061     fchmode = stat.S_IMODE(fmode);
3062     ftypemod = stat.S_IFMT(fmode);
3063   elif(zipinfo.create_system==3):
3064    fwinattributes = format(int(0), 'x').lower();
3065    fmode = format(int(zipinfo.external_attr), 'x').lower();
3066    fchmode = stat.S_IMODE(fmode);
3067    ftypemod = stat.S_IFMT(fmode);
3068   else:
3069    fwinattributes = format(int(0), 'x').lower();
3070    if(not member.is_dir()):
3071     fmode = format(int(stat.S_IFREG + 438), 'x').lower();
3072     fchmode = stat.S_IMODE(fmode);
3073     ftypemod = stat.S_IFMT(fmode);
3074    elif(member.is_dir()):
3075     fmode = format(int(stat.S_IFDIR + 511), 'x').lower();
3076     fchmode = stat.S_IMODE(fmode);
3077     ftypemod = stat.S_IFMT(fmode);
3078   try:
3079    fuid = format(int(os.getuid()), 'x').lower();
3080   except AttributeError:
3081    fuid = format(int(0), 'x').lower();
3082   except KeyError:
3083    fuid = format(int(0), 'x').lower();
3084   try:
3085    fgid = format(int(os.getgid()), 'x').lower();
3086   except AttributeError:
3087    fgid = format(int(0), 'x').lower();
3088   except KeyError:
3089    fgid = format(int(0), 'x').lower();
3090   try:
3091    import pwd;
3092    try:
3093     userinfo = pwd.getpwuid(os.getuid());
3094     funame = userinfo.pw_name;
3095    except KeyError:
3096     funame = "";
3097    except AttributeError:
3098     funame = "";
3099   except ImportError:
3100    funame = "";
3101   fgname = "";
3102   try:
3103    import grp;
3104    try:
3105     groupinfo = grp.getgrgid(os.getgid());
3106     fgname = groupinfo.gr_name;
3107    except KeyError:
3108     fgname = "";
3109    except AttributeError:
3110     fgname = "";
3111   except ImportError:
3112    fgname = "";
3113   fcontents = "".encode('UTF-8');
3114   if(ftype==0):
3115    fcontents = zipfp.read(member.filename);
3116   ftypehex = format(ftype, 'x').lower();
3117   extrafields = format(len(extradata), 'x').lower();
3118   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
3119   if(len(extradata)>0):
3120    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
3121   extrasizelen = format(len(extrasizestr), 'x').lower();
3122   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];
3123   catoutlen = len(catoutlist) + len(extradata) + 3;
3124   catoutlenhex = format(catoutlen, 'x').lower();
3125   catoutlist.insert(0, catoutlenhex);
3126   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
3127   if(len(extradata)>0):
3128    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
3129   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
3130   catfhend = (catfp.tell() - 1) + len(catfileoutstr);
3131   catfcontentstart = catfp.tell() + len(catfileoutstr);
3132   if(checksumtype=="none" or checksumtype==""):
3133    catfileheadercshex = format(0, 'x').lower();
3134    catfilecontentcshex = format(0, 'x').lower();
3135   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3136    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3137    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
3138   elif(checksumtype=="crc16_ccitt"):
3139    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3140    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
3141   elif(checksumtype=="adler32"):
3142    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3143    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
3144   elif(checksumtype=="crc32"):
3145    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3146    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
3147   elif(checksumtype=="crc64_ecma"):
3148    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3149    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
3150   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3151    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3152    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
3153   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3154    checksumoutstr = hashlib.new(checksumtype);
3155    checksumoutstr.update("".encode('UTF-8'));
3156    catfileheadercshex = checksumoutstr.hexdigest().lower();
3157    checksumoutstr = hashlib.new(checksumtype);
3158    checksumoutstr.update(fcontents);
3159    catfilecontentcshex = checksumoutstr.hexdigest().lower();
3160   else:
3161    catfileheadercshex = format(0, 'x').lower();
3162    catfilecontentcshex = format(0, 'x').lower();
3163   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
3164   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
3165   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
3166   if(checksumtype=="none" or checksumtype==""):
3167    catfileheadercshex = format(0, 'x').lower();
3168   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3169    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
3170   elif(checksumtype=="crc16_ccitt"):
3171    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
3172   elif(checksumtype=="adler32"):
3173    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
3174   elif(checksumtype=="crc32"):
3175    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
3176   elif(checksumtype=="crc64_ecma"):
3177    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3178   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3179    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3180   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3181    checksumoutstr = hashlib.new(checksumtype);
3182    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
3183    catfileheadercshex = checksumoutstr.hexdigest().lower();
3184   else:
3185    catfileheadercshex = format(0, 'x').lower();
3186   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
3187   catfileoutstrecd = catfileoutstr.encode('UTF-8');
3188   nullstrecd = formatspecs[5].encode('UTF-8');
3189   catfileout = catfileoutstrecd + fcontents + nullstrecd;
3190   catfcontentend = (catfp.tell() - 1) + len(catfileout);
3191   catfp.write(catfileout);
3192   try:
3193    catfp.flush();
3194    os.fsync(catfp.fileno());
3195   except io.UnsupportedOperation:
3196    pass;
3197   except AttributeError:
3198    pass;
3199  if(numfiles>0):
3200   catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
3201  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
3202   catfp = CompressArchiveFile(catfp, compression, formatspecs);
3203   try:
3204    catfp.flush();
3205    os.fsync(catfp.fileno());
3206   except io.UnsupportedOperation:
3207    pass;
3208   except AttributeError:
3209    pass;
3210  if(outfile=="-"):
3211   catfp.seek(0, 0);
3212   if(hasattr(sys.stdout, "buffer")):
3213    shutil.copyfileobj(catfp, sys.stdout.buffer);
3214   else:
3215    shutil.copyfileobj(catfp, sys.stdout);
3216  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
3217   catfp = CompressArchiveFile(catfp, compression, formatspecs);
3218   catfp.seek(0, 0);
3219   upload_file_to_internet_file(catfp, outfile);
3220  if(returnfp):
3221   catfp.seek(0, 0);
3222   return catfp;
3223  else:
3224   catfp.close();
3225   return True;
3226
3227 create_alias_function("Pack", __file_format_name__, "FromZipFile", PackArchiveFileFromZipFile);
3228
3229 if(not rarfile_support):
3230  def PackArchiveFileFromRarFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
3231   return False
3232
3233 if(rarfile_support):
3234  def PackArchiveFileFromRarFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
3235   if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
3236    outfile = RemoveWindowsPath(outfile);
3237   checksumtype = checksumtype.lower();
3238   if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
3239    checksumtype="crc32";
3240   if(checksumtype=="none"):
3241    checksumtype = "";
3242   if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
3243    compression = None;
3244   if(compression not in compressionlist and compression is None):
3245    compression = "auto";
3246   if(verbose):
3247    logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
3248   if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
3249    if(os.path.exists(outfile)):
3250     os.unlink(outfile);
3251   if(outfile=="-"):
3252    verbose = False;
3253    catfp = BytesIO();
3254   elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
3255    catfp = outfile;
3256   elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
3257    catfp = BytesIO();
3258   else:
3259    fbasename = os.path.splitext(outfile)[0];
3260    fextname = os.path.splitext(outfile)[1];
3261    catfp = CompressOpenFile(outfile, compressionlevel);
3262   catver = formatspecs[6];
3263   fileheaderver = str(int(catver.replace(".", "")));
3264   fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
3265   catfp.write(fileheader.encode('UTF-8'));
3266   curinode = 0;
3267   curfid = 0;
3268   inodelist = [];
3269   inodetofile = {};
3270   filetoinode = {};
3271   inodetocatinode = {};
3272   if(not os.path.exists(infile) or not os.path.isfile(infile)):
3273    return False;
3274   if(not rarfile.is_rarfile(infile) and not rarfile.is_rarfile_sfx(infile)):
3275    return False;
3276   rarfp = rarfile.RarFile(infile, "r");
3277   rartest = rarfp.testrar();
3278   if(rartest):
3279    VerbosePrintOut("Bad file found!");
3280   numfiles = int(len(rarfp.infolist()));
3281   fnumfiles = format(int(len(rarfp.infolist())), 'x').lower();
3282   fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
3283   if(checksumtype=="none" or checksumtype==""):
3284    catfileheadercshex = format(0, 'x').lower();
3285   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3286    catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
3287   elif(checksumtype=="crc16_ccitt"):
3288    catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
3289   elif(checksumtype=="adler32"):
3290    catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
3291   elif(checksumtype=="crc32"):
3292    catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
3293   elif(checksumtype=="crc64_ecma"):
3294    catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3295   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3296    catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3297   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3298    checksumoutstr = hashlib.new(checksumtype);
3299    checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
3300    catfileheadercshex = checksumoutstr.hexdigest().lower();
3301   else:
3302    catfileheadercshex = format(0, 'x').lower();
3303   fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
3304   catfp.write(fnumfilesa.encode('UTF-8'));
3305   try:
3306    catfp.flush();
3307    os.fsync(catfp.fileno());
3308   except io.UnsupportedOperation:
3309    pass;
3310   except AttributeError:
3311    pass;
3312   for member in sorted(rarfp.infolist(), key=lambda x: x.filename):
3313    is_unix = False;
3314    is_windows = False;
3315    if(member.host_os==rarfile.RAR_OS_UNIX):
3316     is_windows = False;
3317     try:
3318      member.external_attr
3319      is_unix = True;
3320     except AttributeError:
3321      is_unix = False;
3322    elif(member.host_os==rarfile.RAR_OS_WIN32):
3323     is_unix = False;
3324     try:
3325      member.external_attr
3326      is_windows = True;
3327     except AttributeError:
3328      is_windows = False;
3329    else:
3330     is_unix = False;
3331     is_windows = False;
3332    catfhstart = catfp.tell();
3333    if(re.findall("^[.|/]", member.filename)):
3334     fname = member.filename;
3335    else:
3336     fname = "./"+member.filename;
3337    rarinfo = rarfp.getinfo(member.filename);
3338    if(verbose):
3339     VerbosePrintOut(fname);
3340    if(is_unix and member.external_attr !=0):
3341     fpremode = int(member.external_attr);
3342    elif(member.is_file()):
3343     fpremode = int(stat.S_IFREG + 438);
3344    elif(member.is_symlink()):
3345     fpremode = int(stat.S_IFLNK + 438);
3346    elif(member.is_dir()):
3347     fpremode = int(stat.S_IFDIR + 511);
3348    if(is_windows and member.external_attr !=0):
3349     fwinattributes = format(int(member.external_attr), 'x').lower();
3350    else:
3351     fwinattributes = format(int(0), 'x').lower();
3352    flinkcount = 0;
3353    ftype = 0;
3354    if(member.is_file()):
3355     ftype = 0;
3356    elif(member.is_symlink()):
3357     ftype = 2;
3358    elif(member.is_dir()):
3359     ftype = 5;
3360    flinkname = "";
3361    if(ftype==2):
3362     flinkname = rarfp.read(member.filename).decode("UTF-8");
3363    fcurfid = format(int(curfid), 'x').lower();
3364    fcurinode = format(int(curfid), 'x').lower();
3365    curfid = curfid + 1;
3366    fdev_minor = format(int(0), 'x').lower();
3367    fdev_major = format(int(0), 'x').lower();
3368    frdev_minor = format(int(0), 'x').lower();
3369    frdev_major = format(int(0), 'x').lower();
3370    if(ftype==5):
3371     fsize = format(int("0"), 'x').lower();
3372    elif(ftype==0):
3373     fsize = format(int(member.file_size), 'x').lower();
3374    else:
3375     fsize = format(int(member.file_size), 'x').lower();
3376    try:
3377     if(member.atime):
3378      fatime = format(int(member.atime.timestamp()), 'x').lower();
3379     else:
3380      fatime = format(int(member.mtime.timestamp()), 'x').lower();
3381    except AttributeError:
3382     fatime = format(int(member.mtime.timestamp()), 'x').lower();
3383    fmtime = format(int(member.mtime.timestamp()), 'x').lower();
3384    try:
3385     if(member.ctime):
3386      fctime = format(int(member.ctime.timestamp()), 'x').lower();
3387     else:
3388      fctime = format(int(member.mtime.timestamp()), 'x').lower();
3389    except AttributeError:
3390     fctime = format(int(member.mtime.timestamp()), 'x').lower();
3391    fbtime = format(int(member.mtime.timestamp()), 'x').lower();
3392    if(is_unix and member.external_attr !=0):
3393     fmode = format(int(member.external_attr), 'x').lower();
3394     fchmode = format(int(stat.S_IMODE(member.external_attr)), 'x').lower();
3395     ftypemod = format(int(stat.S_IFMT(member.external_attr)), 'x').lower();
3396    elif(member.is_file()):
3397     fmode = format(int(stat.S_IFREG + 438), 'x').lower();
3398     fchmode = format(int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower();
3399     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower();
3400    elif(member.is_symlink()):
3401     fmode = format(int(stat.S_IFLNK + 438), 'x').lower();
3402     fchmode = format(int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower();
3403     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower();
3404    elif(member.is_dir()):
3405     fmode = format(int(stat.S_IFDIR + 511), 'x').lower();
3406     fchmode = format(int(stat.S_IMODE(int(stat.S_IFDIR + 511))), 'x').lower();
3407     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFDIR + 511))), 'x').lower();
3408    try:
3409     fuid = format(int(os.getuid()), 'x').lower();
3410    except AttributeError:
3411     fuid = format(int(0), 'x').lower();
3412    except KeyError:
3413     fuid = format(int(0), 'x').lower();
3414    try:
3415     fgid = format(int(os.getgid()), 'x').lower();
3416    except AttributeError:
3417     fgid = format(int(0), 'x').lower();
3418    except KeyError:
3419     fgid = format(int(0), 'x').lower();
3420    try:
3421     import pwd;
3422     try:
3423      userinfo = pwd.getpwuid(os.getuid());
3424      funame = userinfo.pw_name;
3425     except KeyError:
3426      funame = "";
3427     except AttributeError:
3428      funame = "";
3429    except ImportError:
3430     funame = "";
3431    fgname = "";
3432    try:
3433     import grp;
3434     try:
3435      groupinfo = grp.getgrgid(os.getgid());
3436      fgname = groupinfo.gr_name;
3437     except KeyError:
3438      fgname = "";
3439     except AttributeError:
3440      fgname = "";
3441    except ImportError:
3442     fgname = "";
3443    fcontents = "".encode('UTF-8');
3444    if(ftype==0):
3445     fcontents = rarfp.read(member.filename);
3446    ftypehex = format(ftype, 'x').lower();
3447    extrafields = format(len(extradata), 'x').lower();
3448    extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
3449    if(len(extradata)>0):
3450     extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
3451    extrasizelen = format(len(extrasizestr), 'x').lower();
3452    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];
3453    catoutlen = len(catoutlist) + len(extradata) + 3;
3454    catoutlenhex = format(catoutlen, 'x').lower();
3455    catoutlist.insert(0, catoutlenhex);
3456    catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
3457    if(len(extradata)>0):
3458     catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
3459    catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
3460    catfhend = (catfp.tell() - 1) + len(catfileoutstr);
3461    catfcontentstart = catfp.tell() + len(catfileoutstr);
3462    if(checksumtype=="none" or checksumtype==""):
3463     catfileheadercshex = format(0, 'x').lower();
3464     catfilecontentcshex = format(0, 'x').lower();
3465    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3466     catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3467     catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
3468    elif(checksumtype=="crc16_ccitt"):
3469     catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3470     catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
3471    elif(checksumtype=="adler32"):
3472     catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3473     catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
3474    elif(checksumtype=="crc32"):
3475     catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3476     catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
3477    elif(checksumtype=="crc64_ecma"):
3478     catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3479     catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
3480    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3481     catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3482     catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
3483    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3484     checksumoutstr = hashlib.new(checksumtype);
3485     checksumoutstr.update("".encode('UTF-8'));
3486     catfileheadercshex = checksumoutstr.hexdigest().lower();
3487     checksumoutstr = hashlib.new(checksumtype);
3488     checksumoutstr.update(fcontents);
3489     catfilecontentcshex = checksumoutstr.hexdigest().lower();
3490    else:
3491     catfileheadercshex = format(0, 'x').lower();
3492     catfilecontentcshex = format(0, 'x').lower();
3493    tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
3494    catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
3495    catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr
3496    if(checksumtype=="none" or checksumtype==""):
3497     catfileheadercshex = format(0, 'x').lower()
3498    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3499     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower()
3500    elif(checksumtype=="crc16_ccitt"):
3501     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower()
3502    elif(checksumtype=="adler32"):
3503     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower()
3504    elif(checksumtype=="crc32"):
3505     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower()
3506    elif(checksumtype=="crc64_ecma"):
3507     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
3508    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3509     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
3510    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3511     checksumoutstr = hashlib.new(checksumtype)
3512     checksumoutstr.update(catfileoutstr.encode('UTF-8'))
3513     catfileheadercshex = checksumoutstr.hexdigest().lower()
3514    else:
3515     catfileheadercshex = format(0, 'x').lower()
3516    catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5])
3517    catfileoutstrecd = catfileoutstr.encode('UTF-8')
3518    nullstrecd = formatspecs[5].encode('UTF-8')
3519    catfileout = catfileoutstrecd + fcontents + nullstrecd
3520    catfcontentend = (catfp.tell() - 1) + len(catfileout)
3521    catfp.write(catfileout)
3522    try:
3523     catfp.flush()
3524     os.fsync(catfp.fileno())
3525    except io.UnsupportedOperation:
3526     pass
3527    except AttributeError:
3528     pass
3529   if(numfiles>0):
3530    catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
3531   if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
3532    catfp = CompressArchiveFile(catfp, compression, formatspecs)
3533    try:
3534     catfp.flush()
3535     os.fsync(catfp.fileno())
3536    except io.UnsupportedOperation:
3537     pass
3538    except AttributeError:
3539     pass
3540   if(outfile=="-"):
3541    catfp.seek(0, 0)
3542    if(hasattr(sys.stdout, "buffer")):
3543     shutil.copyfileobj(catfp, sys.stdout.buffer);
3544    else:
3545     shutil.copyfileobj(catfp, sys.stdout);
3546   elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
3547    catfp = CompressArchiveFile(catfp, compression, formatspecs);
3548    catfp.seek(0, 0);
3549    upload_file_to_internet_file(catfp, outfile);
3550   if(returnfp):
3551    catfp.seek(0, 0)
3552    return catfp
3553   else:
3554    catfp.close()
3555    return True;
3556
3557 create_alias_function("Pack", __file_format_name__, "FromRarFile", PackArchiveFileFromRarFile);
3558
3559 if(not py7zr_support):
3560  def PackArchiveFileFromSevenZipFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
3561   return False
3562
3563 if(py7zr_support):
3564  def PackArchiveFileFromSevenZipFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
3565   if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
3566    outfile = RemoveWindowsPath(outfile);
3567   checksumtype = checksumtype.lower();
3568   if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
3569    checksumtype="crc32";
3570   if(checksumtype=="none"):
3571    checksumtype = "";
3572   if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
3573    compression = None;
3574   if(compression not in compressionlist and compression is None):
3575    compression = "auto";
3576   if(verbose):
3577    logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
3578   if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
3579    if(os.path.exists(outfile)):
3580     os.unlink(outfile);
3581   if(outfile=="-"):
3582    verbose = False;
3583    catfp = BytesIO();
3584   elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
3585    catfp = outfile;
3586   elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
3587    catfp = BytesIO();
3588   else:
3589    fbasename = os.path.splitext(outfile)[0];
3590    fextname = os.path.splitext(outfile)[1];
3591    catfp = CompressOpenFile(outfile, compressionlevel);
3592   catver = formatspecs[6];
3593   fileheaderver = str(int(catver.replace(".", "")));
3594   fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
3595   catfp.write(fileheader.encode('UTF-8'));
3596   curinode = 0;
3597   curfid = 0;
3598   inodelist = [];
3599   inodetofile = {};
3600   filetoinode = {};
3601   inodetocatinode = {};
3602   if(not os.path.exists(infile) or not os.path.isfile(infile)):
3603    return False;
3604   szpfp = py7zr.SevenZipFile(infile, mode="r");
3605   file_content = szpfp.readall();
3606   #sztest = szpfp.testzip();
3607   sztestalt = szpfp.test();
3608   if(sztestalt):
3609    VerbosePrintOut("Bad file found!");
3610   numfiles = int(len(szpfp.list()));
3611   fnumfiles = format(int(len(szpfp.list())), 'x').lower();
3612   fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
3613   if(checksumtype=="none" or checksumtype==""):
3614    catfileheadercshex = format(0, 'x').lower();
3615   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3616    catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
3617   elif(checksumtype=="crc16_ccitt"):
3618    catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
3619   elif(checksumtype=="adler32"):
3620    catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
3621   elif(checksumtype=="crc32"):
3622    catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
3623   elif(checksumtype=="crc64_ecma"):
3624    catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3625   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3626    catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3627   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3628    checksumoutstr = hashlib.new(checksumtype);
3629    checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
3630    catfileheadercshex = checksumoutstr.hexdigest().lower();
3631   else:
3632    catfileheadercshex = format(0, 'x').lower();
3633   fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
3634   catfp.write(fnumfilesa.encode('UTF-8'));
3635   try:
3636    catfp.flush();
3637    os.fsync(catfp.fileno());
3638   except io.UnsupportedOperation:
3639    pass;
3640   except AttributeError:
3641    pass;
3642   for member in sorted(szpfp.list(), key=lambda x: x.filename):
3643    catfhstart = catfp.tell();
3644    if(re.findall("^[.|/]", member.filename)):
3645     fname = member.filename;
3646    else:
3647     fname = "./"+member.filename;
3648    if(verbose):
3649     VerbosePrintOut(fname);
3650    if(not member.is_directory):
3651     fpremode = int(stat.S_IFREG + 438);
3652    elif(member.is_directory):
3653     fpremode = int(stat.S_IFDIR + 511);
3654    fwinattributes = format(int(0), 'x').lower();
3655    flinkcount = 0;
3656    ftype = 0;
3657    if(member.is_directory):
3658     ftype = 5;
3659    else:
3660     ftype = 0;
3661    flinkname = "";
3662    fcurfid = format(int(curfid), 'x').lower();
3663    fcurinode = format(int(curfid), 'x').lower();
3664    curfid = curfid + 1;
3665    fdev_minor = format(int(0), 'x').lower();
3666    fdev_major = format(int(0), 'x').lower();
3667    frdev_minor = format(int(0), 'x').lower();
3668    frdev_major = format(int(0), 'x').lower();
3669    if(ftype==5):
3670     fsize = format(int("0"), 'x').lower();
3671    fatime = format(int(member.creationtime.timestamp()), 'x').lower();
3672    fmtime = format(int(member.creationtime.timestamp()), 'x').lower();
3673    fctime = format(int(member.creationtime.timestamp()), 'x').lower();
3674    fbtime = format(int(member.creationtime.timestamp()), 'x').lower();
3675    if(member.is_directory):
3676     fmode = format(int(stat.S_IFDIR + 511), 'x').lower();
3677     fchmode = format(int(stat.S_IMODE(int(stat.S_IFDIR + 511))), 'x').lower();
3678     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFDIR + 511))), 'x').lower();
3679    else:
3680     fmode = format(int(stat.S_IFREG + 438), 'x').lower();
3681     fchmode = format(int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower();
3682     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower();
3683    try:
3684     fuid = format(int(os.getuid()), 'x').lower();
3685    except AttributeError:
3686     fuid = format(int(0), 'x').lower();
3687    except KeyError:
3688     fuid = format(int(0), 'x').lower();
3689    try:
3690     fgid = format(int(os.getgid()), 'x').lower();
3691    except AttributeError:
3692     fgid = format(int(0), 'x').lower();
3693    except KeyError:
3694     fgid = format(int(0), 'x').lower();
3695    try:
3696     import pwd;
3697     try:
3698      userinfo = pwd.getpwuid(os.getuid());
3699      funame = userinfo.pw_name;
3700     except KeyError:
3701      funame = "";
3702     except AttributeError:
3703      funame = "";
3704    except ImportError:
3705     funame = "";
3706    fgname = "";
3707    try:
3708     import grp;
3709     try:
3710      groupinfo = grp.getgrgid(os.getgid());
3711      fgname = groupinfo.gr_name;
3712     except KeyError:
3713      fgname = "";
3714     except AttributeError:
3715      fgname = "";
3716    except ImportError:
3717     fgname = "";
3718    fcontents = "".encode('UTF-8');
3719    if(ftype==0):
3720     fcontents = file_content[member.filename].read();
3721     fsize = format(len(fcontents), 'x').lower();
3722     file_content[member.filename].close();
3723    ftypehex = format(ftype, 'x').lower();
3724    extrafields = format(len(extradata), 'x').lower();
3725    extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
3726    if(len(extradata)>0):
3727     extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
3728    extrasizelen = format(len(extrasizestr), 'x').lower();
3729    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];
3730    catoutlen = len(catoutlist) + len(extradata) + 3;
3731    catoutlenhex = format(catoutlen, 'x').lower();
3732    catoutlist.insert(0, catoutlenhex);
3733    catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
3734    if(len(extradata)>0):
3735     catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
3736    catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
3737    catfhend = (catfp.tell() - 1) + len(catfileoutstr);
3738    catfcontentstart = catfp.tell() + len(catfileoutstr);
3739    if(checksumtype=="none" or checksumtype==""):
3740     catfileheadercshex = format(0, 'x').lower();
3741     catfilecontentcshex = format(0, 'x').lower();
3742    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3743     catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3744     catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
3745    elif(checksumtype=="crc16_ccitt"):
3746     catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3747     catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
3748    elif(checksumtype=="adler32"):
3749     catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3750     catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
3751    elif(checksumtype=="crc32"):
3752     catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3753     catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
3754    elif(checksumtype=="crc64_ecma"):
3755     catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3756     catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
3757    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3758     catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3759     catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
3760    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3761     checksumoutstr = hashlib.new(checksumtype);
3762     checksumoutstr.update("".encode('UTF-8'));
3763     catfileheadercshex = checksumoutstr.hexdigest().lower();
3764     checksumoutstr = hashlib.new(checksumtype);
3765     checksumoutstr.update(fcontents);
3766     catfilecontentcshex = checksumoutstr.hexdigest().lower();
3767    else:
3768     catfileheadercshex = format(0, 'x').lower();
3769     catfilecontentcshex = format(0, 'x').lower();
3770    tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
3771    catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
3772    catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr
3773    if(checksumtype=="none" or checksumtype==""):
3774     catfileheadercshex = format(0, 'x').lower()
3775    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3776     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower()
3777    elif(checksumtype=="crc16_ccitt"):
3778     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower()
3779    elif(checksumtype=="adler32"):
3780     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower()
3781    elif(checksumtype=="crc32"):
3782     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower()
3783    elif(checksumtype=="crc64_ecma"):
3784     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
3785    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3786     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
3787    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3788     checksumoutstr = hashlib.new(checksumtype)
3789     checksumoutstr.update(catfileoutstr.encode('UTF-8'))
3790     catfileheadercshex = checksumoutstr.hexdigest().lower()
3791    else:
3792     catfileheadercshex = format(0, 'x').lower()
3793    catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5])
3794    catfileoutstrecd = catfileoutstr.encode('UTF-8')
3795    nullstrecd = formatspecs[5].encode('UTF-8')
3796    catfileout = catfileoutstrecd + fcontents + nullstrecd
3797    catfcontentend = (catfp.tell() - 1) + len(catfileout)
3798    catfp.write(catfileout)
3799    try:
3800     catfp.flush()
3801     os.fsync(catfp.fileno())
3802    except io.UnsupportedOperation:
3803     pass
3804    except AttributeError:
3805     pass
3806   if(numfiles>0):
3807    catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
3808   if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
3809    catfp = CompressArchiveFile(catfp, compression, formatspecs)
3810    try:
3811     catfp.flush()
3812     os.fsync(catfp.fileno())
3813    except io.UnsupportedOperation:
3814     pass
3815    except AttributeError:
3816     pass
3817   if(outfile=="-"):
3818    catfp.seek(0, 0)
3819    if(hasattr(sys.stdout, "buffer")):
3820     shutil.copyfileobj(catfp, sys.stdout.buffer);
3821    else:
3822     shutil.copyfileobj(catfp, sys.stdout);
3823   elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
3824    catfp = CompressArchiveFile(catfp, compression, formatspecs);
3825    catfp.seek(0, 0);
3826    upload_file_to_internet_file(catfp, outfile);
3827   if(returnfp):
3828    catfp.seek(0, 0)
3829    return catfp
3830   else:
3831    catfp.close()
3832    return True;
3833
3834 create_alias_function("Pack", __file_format_name__, "FromSevenZipFile", PackArchiveFileFromSevenZipFile);
3835
3836 def PackArchiveFileFromInFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
3837  checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
3838  if(verbose):
3839   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
3840  if(checkcompressfile=="tarfile"):
3841   return PackArchiveFileFromTarFile(infile, outfile, compression, compressionlevel, checksumtype, extradata, formatspecs, verbose, returnfp);
3842  elif(checkcompressfile=="zipfile"):
3843   return PackArchiveFileFromZipFile(infile, outfile, compression, compressionlevel, checksumtype, extradata, formatspecs, verbose, returnfp);
3844  elif(checkcompressfile=="catfile"):
3845   return RePackArchiveFile(infile, outfile, compression, compressionlevel, False, 0, 0, checksumtype, False, extradata, formatspecs, verbose, returnfp);
3846  elif(rarfile_support and checkcompressfile=="rarfile"):
3847   return PackArchiveFileFromRarFile(infile, outfile, compression, compressionlevel, checksumtype, extradata, formatspecs, verbose, returnfp);
3848  elif(py7zr_support and checkcompressfile=="7zipfile"):
3849   return PackArchiveFileFromSevenZipFile(infile, outfile, compression, compressionlevel, checksumtype, extradata, formatspecs, verbose, returnfp);
3850  else:
3851   return False;
3852  return False;
3853
3854 create_alias_function("Pack", __file_format_name__, "FromInFile", PackArchiveFileFromInFile);
3855
3856 def ArchiveFileSeekToFileNum(infile, seekto=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
3857  if(hasattr(infile, "read") or hasattr(infile, "write")):
3858   catfp = infile;
3859   catfp.seek(0, 0);
3860   catfp = UncompressArchiveFile(catfp, formatspecs);
3861   checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True);
3862   if(checkcompressfile=="tarfile"):
3863    return TarFileToArray(infile, seekto, 0, listonly, skipchecksum, formatspecs, returnfp);
3864   if(checkcompressfile=="zipfile"):
3865    return ZipFileToArray(infile, seekto, 0, listonly, skipchecksum, formatspecs, returnfp);
3866   if(rarfile_support and checkcompressfile=="rarfile"):
3867    return RarFileToArray(infile, seekto, 0, listonly, skipchecksum, formatspecs, returnfp);
3868   if(py7zr_support and checkcompressfile=="7zipfile"):
3869    return SevenZipFileToArray(infile, seekto, 0, listonly, skipchecksum, formatspecs, returnfp);
3870   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
3871    return False;
3872   if(not catfp):
3873    return False;
3874   catfp.seek(0, 0);
3875  elif(infile=="-"):
3876   catfp = BytesIO();
3877   if(hasattr(sys.stdin, "buffer")):
3878    shutil.copyfileobj(sys.stdin.buffer, catfp);
3879   else:
3880    shutil.copyfileobj(sys.stdin, catfp);
3881   catfp.seek(0, 0);
3882   catfp = UncompressArchiveFile(catfp, formatspecs);
3883   if(not catfp):
3884    return False;
3885   catfp.seek(0, 0);
3886  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
3887   catfp = download_file_from_internet_file(infile);
3888   catfp.seek(0, 0);
3889   catfp = UncompressArchiveFile(catfp, formatspecs);
3890   if(not catfp):
3891    return False;
3892   catfp.seek(0, 0);
3893  else:
3894   infile = RemoveWindowsPath(infile);
3895   checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
3896   if(checkcompressfile=="tarfile"):
3897    return TarFileToArray(infile, seekto, 0, listonly, skipchecksum, formatspecs, returnfp);
3898   if(checkcompressfile=="zipfile"):
3899    return ZipFileToArray(infile, seekto, 0, listonly, skipchecksum, formatspecs, returnfp);
3900   if(rarfile_support and checkcompressfile=="rarfile"):
3901    return RarFileToArray(infile, seekto, 0, listonly, skipchecksum, formatspecs, returnfp);
3902   if(py7zr_support and checkcompressfile=="7zipfile"):
3903    return SevenZipFileToArray(infile, seekto, 0, listonly, skipchecksum, formatspecs, returnfp);
3904   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
3905    return False;
3906   compresscheck = CheckCompressionType(infile, formatspecs, True);
3907   if(not compresscheck):
3908    fextname = os.path.splitext(infile)[1];
3909    if(fextname==".gz"):
3910     compresscheck = "gzip";
3911    elif(fextname==".bz2"):
3912     compresscheck = "bzip2";
3913    elif(fextname==".zst"):
3914     compresscheck = "zstd";
3915    elif(fextname==".lz4" or fextname==".clz4"):
3916     compresscheck = "lz4";
3917    elif(fextname==".lzo" or fextname==".lzop"):
3918     compresscheck = "lzo";
3919    elif(fextname==".lzma" or fextname==".xz"):
3920     compresscheck = "lzma";
3921    else:
3922     return False;
3923   if(not compresscheck):
3924    return False;
3925   catfp = UncompressFile(infile, formatspecs, "rb");
3926  '''
3927  try:
3928   catfp.seek(0, 2);
3929  except OSError:
3930   SeekToEndOfFile(catfp);
3931  except ValueError:
3932   SeekToEndOfFile(catfp);
3933  CatSize = catfp.tell();
3934  CatSizeEnd = CatSize;
3935  '''
3936  try:
3937   catfp.seek(0, 0);
3938  except OSError:
3939   return False;
3940  except ValueError:
3941   return False;
3942  curloc = catfp.tell();
3943  if(curloc>0):
3944   catfp.seek(0, 0);
3945  catheader = ReadFileHeaderData(catfp, 4, formatspecs[5]);
3946  if(curloc>0):
3947   catfp.seek(curloc, 0);
3948  catstring = catheader[0];
3949  catversion = re.findall(r"([\d]+)$", catstring);
3950  fprenumfiles = catheader[1];
3951  fnumfiles = int(fprenumfiles, 16);
3952  fprechecksumtype = catheader[2];
3953  fprechecksum = catheader[3];
3954  fileheader = AppendNullByte(catstring, formatspecs[5]);
3955  fnumfileshex = format(int(fnumfiles), 'x').lower();
3956  fileheader = fileheader + AppendNullBytes([fnumfileshex, fprechecksumtype], formatspecs[5]);
3957  if(fprechecksumtype=="none" or fprechecksumtype==""):
3958   catfileheadercshex = format(0, 'x').lower();
3959  elif(fprechecksumtype=="crc16" or fprechecksumtype=="crc16_ansi" or fprechecksumtype=="crc16_ibm"):
3960   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
3961  elif(fprechecksumtype=="crc16_ccitt"):
3962   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
3963  elif(fprechecksumtype=="adler32"):
3964   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
3965  elif(fprechecksumtype=="crc32"):
3966   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
3967  elif(fprechecksumtype=="crc64_ecma"):
3968   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3969  elif(fprechecksumtype=="crc64" or fprechecksumtype=="crc64_iso"):
3970   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3971  elif(CheckSumSupportAlt(fprechecksumtype, hashlib_guaranteed)):
3972   checksumoutstr = hashlib.new(fprechecksumtype);
3973   checksumoutstr.update(fileheader.encode('UTF-8'));
3974   catfileheadercshex = checksumoutstr.hexdigest().lower();
3975  else:
3976   catfileheadercshex = format(0, 'x').lower();
3977  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
3978  fheadtell = len(fileheader);
3979  if(fprechecksum!=catfileheadercshex and not skipchecksum):
3980   VerbosePrintOut("File Header Checksum Error with file " + infile + " at offset " + str(0));
3981   return False;
3982  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
3983  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': {}};
3984  if(seekto>=fnumfiles):
3985   seekto = fnumfiles - 1;
3986  if(seekto<0):
3987   seekto = 0;
3988  if(seekto>=0):
3989   il = -1;
3990   while(il < seekto):
3991    prefhstart = catfp.tell();
3992    if(formatspecs[7]):
3993     preheaderdata = ReadFileHeaderDataBySize(catfp, formatspecs[5]);
3994    else:
3995     preheaderdata = ReadFileHeaderDataWoSize(catfp, formatspecs[5]);
3996    if(len(preheaderdata)==0):
3997     break;
3998    prefheadsize = int(preheaderdata[0], 16);
3999    prefnumfields = int(preheaderdata[1], 16);
4000    preftype = int(preheaderdata[2], 16);
4001    if(re.findall("^[.|/]", preheaderdata[3])):
4002     prefname = preheaderdata[3];
4003    else:
4004     prefname = "./"+preheaderdata[3];
4005    prefbasedir = os.path.dirname(prefname);
4006    preflinkname = preheaderdata[4];
4007    prefsize = int(preheaderdata[5], 16);
4008    prefatime = int(preheaderdata[6], 16);
4009    prefmtime = int(preheaderdata[7], 16);
4010    prefctime = int(preheaderdata[8], 16);
4011    prefbtime = int(preheaderdata[9], 16);
4012    prefmode = int(preheaderdata[10], 16);
4013    prefchmode = stat.S_IMODE(prefmode);
4014    preftypemod = stat.S_IFMT(prefmode);
4015    prefwinattributes = int(preheaderdata[11], 16);
4016    prefuid = int(preheaderdata[12], 16);
4017    prefuname = preheaderdata[13];
4018    prefgid = int(preheaderdata[14], 16);
4019    prefgname = preheaderdata[15];
4020    fid = int(preheaderdata[16], 16);
4021    finode = int(preheaderdata[17], 16);
4022    flinkcount = int(preheaderdata[18], 16);
4023    prefdev_minor = int(preheaderdata[19], 16);
4024    prefdev_major = int(preheaderdata[20], 16);
4025    prefrdev_minor = int(preheaderdata[22], 16);
4026    prefrdev_major = int(preheaderdata[23], 16);
4027    prefextrasize = int(preheaderdata[24], 16);
4028    prefextrafields = int(preheaderdata[25], 16);
4029    extrafieldslist = [];
4030    extrastart = 25;
4031    extraend = extrastart + prefextrafields;
4032    extrafieldslist = [];
4033    if(extrastart<extraend):
4034     extrafieldslist.append(preheaderdata[extrastart]);
4035     extrastart = extrastart + 1;
4036    prefchecksumtype = preheaderdata[extrastart].lower();
4037    prefcs = preheaderdata[extrastart + 1].lower();
4038    prefccs = preheaderdata[extrastart + 2].lower();
4039    hc = 0;
4040    hcmax = len(preheaderdata) - 2;
4041    hout = "";
4042    while(hc<hcmax):
4043     hout = hout + AppendNullByte(preheaderdata[hc], formatspecs[5]);
4044     hc = hc + 1;
4045    prenewfcs = GetFileChecksum(hout, preheaderdata[-3].lower(), True, formatspecs);
4046    if(prefcs!=prenewfcs and not skipchecksum):
4047     VerbosePrintOut("File Header Checksum Error with file " + prefname + " at offset " + str(prefhstart));
4048     return False;
4049     valid_archive = False;
4050     invalid_archive = True;
4051    prefhend = catfp.tell() - 1;
4052    prefcontentstart = catfp.tell();
4053    prefcontents = "";
4054    pyhascontents = False;
4055    if(prefsize>0):
4056     prefcontents = catfp.read(prefsize);
4057     prenewfccs = GetFileChecksum(prefcontents, preheaderdata[-3].lower(), False, formatspecs);
4058     pyhascontents = True;
4059     if(prefccs!=prenewfccs and not skipchecksum):
4060      VerbosePrintOut("File Content Checksum Error with file " + prefname + " at offset " + str(prefcontentstart));
4061      return False;
4062    catfp.seek(1, 1);
4063    il = il + 1;
4064  catfp.seek(seekstart, 0);
4065  fileidnum = il;
4066  catfheadsize = int(preheaderdata[0], 16);
4067  catfnumfields = int(preheaderdata[1], 16);
4068  catftype = int(preheaderdata[2], 16);
4069  if(re.findall("^[.|/]", preheaderdata[3])):
4070   catfname = preheaderdata[3];
4071  else:
4072   catfname = "./"+preheaderdata[3];
4073  catflinkname = preheaderdata[4];
4074  catfsize = int(preheaderdata[5], 16);
4075  catfbasedir = os.path.dirname(catfname);
4076  catlist = {'fid': fileidnum, 'foffset': catfp.tell(), 'ftype': catftype, 'fname': catfname, 'fbasedir': catfbasedir, 'flinkname': catflinkname, 'fsize': catfsize};
4077  if(returnfp):
4078   catlist.update({'catfp': catfp});
4079  else:
4080   catfp.close();
4081  return catlist;
4082
4083 create_alias_function("", __file_format_name__, "SeekToFileNum", ArchiveFileSeekToFileNum);
4084
4085 def ArchiveFileSeekToFileName(infile, seekfile=None, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4086  if(hasattr(infile, "read") or hasattr(infile, "write")):
4087   catfp = infile;
4088   catfp.seek(0, 0);
4089   catfp = UncompressArchiveFile(catfp, formatspecs);
4090   checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True);
4091   if(checkcompressfile=="tarfile"):
4092    return TarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4093   if(checkcompressfile=="zipfile"):
4094    return ZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4095   if(rarfile_support and checkcompressfile=="rarfile"):
4096    return RarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4097   if(py7zr_support and checkcompressfile=="7zipfile"):
4098    return SevenZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4099   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4100    return False;
4101   if(not catfp):
4102    return False;
4103   catfp.seek(0, 0);
4104  elif(infile=="-"):
4105   catfp = BytesIO();
4106   if(hasattr(sys.stdin, "buffer")):
4107    shutil.copyfileobj(sys.stdin.buffer, catfp);
4108   else:
4109    shutil.copyfileobj(sys.stdin, catfp);
4110   catfp.seek(0, 0);
4111   catfp = UncompressArchiveFile(catfp, formatspecs);
4112   if(not catfp):
4113    return False;
4114   catfp.seek(0, 0);
4115  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
4116   catfp = download_file_from_internet_file(infile);
4117   catfp = UncompressArchiveFile(catfp, formatspecs);
4118   catfp.seek(0, 0);
4119   if(not catfp):
4120    return False;
4121   catfp.seek(0, 0);
4122  else:
4123   infile = RemoveWindowsPath(infile);
4124   checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
4125   if(checkcompressfile=="tarfile"):
4126    return TarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4127   if(checkcompressfile=="zipfile"):
4128    return ZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4129   if(rarfile_support and checkcompressfile=="rarfile"):
4130    return RarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4131   if(py7zr_support and checkcompressfile=="7zipfile"):
4132    return SevenZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4133   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4134    return False;
4135   compresscheck = CheckCompressionType(infile, formatspecs, True);
4136   if(not compresscheck):
4137    fextname = os.path.splitext(infile)[1];
4138    if(fextname==".gz"):
4139     compresscheck = "gzip";
4140    elif(fextname==".bz2"):
4141     compresscheck = "bzip2";
4142    elif(fextname==".zst"):
4143     compresscheck = "zstd";
4144    elif(fextname==".lz4" or fextname==".clz4"):
4145     compresscheck = "lz4";
4146    elif(fextname==".lzo" or fextname==".lzop"):
4147     compresscheck = "lzo";
4148    elif(fextname==".lzma" or fextname==".xz"):
4149     compresscheck = "lzma";
4150    else:
4151     return False;
4152   if(not compresscheck):
4153    return False;
4154   catfp = UncompressFile(infile, formatspecs, "rb");
4155  '''
4156  try:
4157   catfp.seek(0, 2);
4158  except OSError:
4159   SeekToEndOfFile(catfp);
4160  except ValueError:
4161   SeekToEndOfFile(catfp);
4162  CatSize = catfp.tell();
4163  CatSizeEnd = CatSize;
4164  '''
4165  try:
4166   catfp.seek(0, 0);
4167  except OSError:
4168   return False;
4169  except ValueError:
4170   return False;
4171  curloc = catfp.tell();
4172  if(curloc>0):
4173   catfp.seek(0, 0);
4174  catheader = ReadFileHeaderData(catfp, 4, formatspecs[5]);
4175  if(curloc>0):
4176   catfp.seek(curloc, 0);
4177  catstring = catheader[0];
4178  catversion = re.findall(r"([\d]+)$", catstring);
4179  fprenumfiles = catheader[1];
4180  fnumfiles = int(fprenumfiles, 16);
4181  fprechecksumtype = catheader[2];
4182  fprechecksum = catheader[3];
4183  fileheader = AppendNullByte(catstring, formatspecs[5]);
4184  fnumfileshex = format(int(fnumfiles), 'x').lower();
4185  fileheader = fileheader + AppendNullBytes([fnumfileshex, fprechecksumtype], formatspecs[5]);
4186  if(fprechecksumtype=="none" or fprechecksumtype==""):
4187   catfileheadercshex = format(0, 'x').lower();
4188  elif(fprechecksumtype=="crc16" or fprechecksumtype=="crc16_ansi" or fprechecksumtype=="crc16_ibm"):
4189   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4190  elif(fprechecksumtype=="crc16_ccitt"):
4191   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4192  elif(fprechecksumtype=="adler32"):
4193   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4194  elif(fprechecksumtype=="crc32"):
4195   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4196  elif(fprechecksumtype=="crc64_ecma"):
4197   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4198  elif(fprechecksumtype=="crc64" or fprechecksumtype=="crc64_iso"):
4199   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4200  elif(CheckSumSupportAlt(fprechecksumtype, hashlib_guaranteed)):
4201   checksumoutstr = hashlib.new(fprechecksumtype);
4202   checksumoutstr.update(fileheader.encode('UTF-8'));
4203   catfileheadercshex = checksumoutstr.hexdigest().lower();
4204  else:
4205   catfileheadercshex = format(0, 'x').lower();
4206  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
4207  fheadtell = len(fileheader);
4208  if(fprechecksum!=catfileheadercshex and not skipchecksum):
4209   VerbosePrintOut("File Header Checksum Error with file " + infile + " at offset " + str(0));
4210   return False;
4211  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
4212  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': {}};
4213  seekto = fnumfiles - 1
4214  filefound = False;
4215  if(seekto>=0):
4216   il = -1;
4217   while(il < seekto):
4218    prefhstart = catfp.tell();
4219    if(formatspecs[7]):
4220     preheaderdata = ReadFileHeaderDataBySize(catfp, formatspecs[5]);
4221    else:
4222     preheaderdata = ReadFileHeaderDataWoSize(catfp, formatspecs[5]);
4223    if(len(preheaderdata)==0):
4224     break;
4225    prefheadsize = int(preheaderdata[0], 16);
4226    prefnumfields = int(preheaderdata[1], 16);
4227    preftype = int(preheaderdata[2], 16);
4228    if(re.findall("^[.|/]", preheaderdata[3])):
4229     prefname = preheaderdata[3];
4230    else:
4231     prefname = "./"+preheaderdata[3];
4232    prefbasedir = os.path.dirname(prefname);
4233    preflinkname = preheaderdata[4];
4234    prefsize = int(preheaderdata[5], 16);
4235    prefatime = int(preheaderdata[6], 16);
4236    prefmtime = int(preheaderdata[7], 16);
4237    prefctime = int(preheaderdata[8], 16);
4238    prefbtime = int(preheaderdata[9], 16);
4239    prefmode = int(preheaderdata[10], 16);
4240    prefchmode = stat.S_IMODE(prefmode);
4241    preftypemod = stat.S_IFMT(prefmode);
4242    prefwinattributes = int(preheaderdata[11], 16);
4243    prefuid = int(preheaderdata[12], 16);
4244    prefuname = preheaderdata[13];
4245    prefgid = int(preheaderdata[14], 16);
4246    prefgname = preheaderdata[15];
4247    fid = int(preheaderdata[16], 16);
4248    finode = int(preheaderdata[17], 16);
4249    flinkcount = int(preheaderdata[18], 16);
4250    prefdev_minor = int(preheaderdata[19], 16);
4251    prefdev_major = int(preheaderdata[20], 16);
4252    prefrdev_minor = int(preheaderdata[22], 16);
4253    prefrdev_major = int(preheaderdata[23], 16);
4254    prefextrasize = int(preheaderdata[24], 16);
4255    prefextrafields = int(preheaderdata[25], 16);
4256    extrafieldslist = [];
4257    extrastart = 25;
4258    extraend = extrastart + prefextrafields;
4259    extrafieldslist = [];
4260    if(extrastart<extraend):
4261     extrafieldslist.append(preheaderdata[extrastart]);
4262     extrastart = extrastart + 1;
4263    prefchecksumtype = preheaderdata[extrastart].lower();
4264    prefcs = preheaderdata[extrastart + 1].lower();
4265    prefccs = preheaderdata[extrastart + 2].lower();
4266    hc = 0;
4267    hcmax = len(preheaderdata) - 2;
4268    hout = "";
4269    while(hc<hcmax):
4270     hout = hout + AppendNullByte(preheaderdata[hc], formatspecs[5]);
4271     hc = hc + 1;
4272    prenewfcs = GetFileChecksum(hout, preheaderdata[-3].lower(), True, formatspecs);
4273    if(prefcs!=prenewfcs and not skipchecksum):
4274     VerbosePrintOut("File Header Checksum Error with file " + prefname + " at offset " + str(prefhstart));
4275     return False;
4276     valid_archive = False;
4277     invalid_archive = True;
4278    prefhend = catfp.tell() - 1;
4279    prefcontentstart = catfp.tell();
4280    prefcontents = "";
4281    pyhascontents = False;
4282    if(prefsize>0):
4283     prefcontents = catfp.read(prefsize);
4284     prenewfccs = GetFileChecksum(prefcontents, preheaderdata[-3].lower(), False, formatspecs);
4285     pyhascontents = True;
4286     if(prefccs!=prenewfccs and not skipchecksum):
4287      VerbosePrintOut("File Content Checksum Error with file " + prefname + " at offset " + str(prefcontentstart));
4288      return False;
4289    catfp.seek(1, 1);
4290    il = il + 1;
4291    filefound = False;
4292    prefname = preheaderdata[2];
4293    if(re.findall("^[.|/]", preheaderdata[2])):
4294     prefname = preheaderdata[2];
4295    else:
4296     prefname = "./"+preheaderdata[2];
4297    if(prefname==seekfile):
4298     filefound = True;
4299     break;
4300  catfp.seek(seekstart, 0);
4301  fileidnum = il;
4302  catfheadsize = int(preheaderdata[0], 16);
4303  catfnumfields = int(preheaderdata[1], 16);
4304  catftype = int(preheaderdata[2], 16);
4305  if(re.findall("^[.|/]", preheaderdata[3])):
4306   catfname = preheaderdata[3];
4307  else:
4308   catfname = "./"+preheaderdata[3];
4309  catflinkname = preheaderdata[4];
4310  catfsize = int(preheaderdata[5], 16);
4311  catfbasedir = os.path.dirname(catfname);
4312  if(filefound):
4313   catlist = {'fid': fileidnum, 'foffset': catfp.tell(), 'ftype': catftype, 'fname': catfname, 'fbasedir': catfbasedir, 'flinkname': catflinkname, 'fsize': catfsize};
4314  else:
4315   return False;
4316  if(returnfp):
4317   catlist.update({'catfp': catfp});
4318  else:
4319   catfp.close();
4320  return catlist;
4321
4322 create_alias_function("", __file_format_name__, "SeekToFileName", ArchiveFileSeekToFileName);
4323
4324 def ArchiveFileValidate(infile, formatspecs=__file_format_list__, verbose=False, returnfp=False):
4325  if(verbose):
4326   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
4327  if(hasattr(infile, "read") or hasattr(infile, "write")):
4328   catfp = infile;
4329   catfp.seek(0, 0);
4330   catfp = UncompressArchiveFile(catfp, formatspecs);
4331   checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True);
4332   if(checkcompressfile=="tarfile"):
4333    return TarFileToArray(infile, 0, 0, False, False, formatspecs, returnfp);
4334   if(checkcompressfile=="zipfile"):
4335    return ZipFileToArray(infile, 0, 0, False, False, formatspecs, returnfp);
4336   if(rarfile_support and checkcompressfile=="rarfile"):
4337    return RarFileToArray(infile, 0, 0, False, False, formatspecs, returnfp);
4338   if(py7zr_support and checkcompressfile=="7zipfile"):
4339    return SevenZipFileToArray(infile, 0, 0, False, False, formatspecs, returnfp);
4340   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4341    return False;
4342   if(not catfp):
4343    return False;
4344   catfp.seek(0, 0);
4345  elif(infile=="-"):
4346   catfp = BytesIO();
4347   if(hasattr(sys.stdin, "buffer")):
4348    shutil.copyfileobj(sys.stdin.buffer, catfp);
4349   else:
4350    shutil.copyfileobj(sys.stdin, catfp);
4351   catfp.seek(0, 0);
4352   catfp = UncompressArchiveFile(catfp, formatspecs);
4353   if(not catfp):
4354    return False;
4355   catfp.seek(0, 0);
4356  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
4357   catfp = download_file_from_internet_file(infile);
4358   catfp = UncompressArchiveFile(catfp, formatspecs);
4359   catfp.seek(0, 0);
4360   if(not catfp):
4361    return False;
4362   catfp.seek(0, 0);
4363  else:
4364   infile = RemoveWindowsPath(infile);
4365   checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
4366   if(checkcompressfile=="tarfile"):
4367    return TarFileToArray(infile, 0, 0, False, False, formatspecs, returnfp);
4368   if(checkcompressfile=="zipfile"):
4369    return ZipFileToArray(infile, 0, 0, False, False, formatspecs, returnfp);
4370   if(rarfile_support and checkcompressfile=="rarfile"):
4371    return RarFileToArray(infile, 0, 0, False, False, formatspecs, returnfp);
4372   if(py7zr_support and checkcompressfile=="7zipfile"):
4373    return SevenZipFileToArray(infile, 0, 0, False, False, formatspecs, returnfp);
4374   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4375    return False;
4376   compresscheck = CheckCompressionType(infile, formatspecs, True);
4377   if(not compresscheck):
4378    fextname = os.path.splitext(infile)[1];
4379    if(fextname==".gz"):
4380     compresscheck = "gzip";
4381    elif(fextname==".bz2"):
4382     compresscheck = "bzip2";
4383    elif(fextname==".zst"):
4384     compresscheck = "zstd";
4385    elif(fextname==".lz4" or fextname==".clz4"):
4386     compresscheck = "lz4";
4387    elif(fextname==".lzo" or fextname==".lzop"):
4388     compresscheck = "lzo";
4389    elif(fextname==".lzma" or fextname==".xz"):
4390     compresscheck = "lzma";
4391    else:
4392     return False;
4393   if(not compresscheck):
4394    return False;
4395   catfp = UncompressFile(infile, formatspecs, "rb");
4396  '''
4397  try:
4398   catfp.seek(0, 2);
4399  except OSError:
4400   SeekToEndOfFile(catfp);
4401  except ValueError:
4402   SeekToEndOfFile(catfp);
4403  CatSize = catfp.tell();
4404  CatSizeEnd = CatSize;
4405  '''
4406  try:
4407   catfp.seek(0, 0);
4408  except OSError:
4409   return False;
4410  except ValueError:
4411   return False;
4412  curloc = catfp.tell();
4413  if(curloc>0):
4414   catfp.seek(0, 0);
4415  catheader = ReadFileHeaderData(catfp, 4, formatspecs[5]);
4416  if(curloc>0):
4417   catfp.seek(curloc, 0);
4418  catstring = catheader[0];
4419  catversion = re.findall(r"([\d]+)$", catstring);
4420  fprenumfiles = catheader[1];
4421  fnumfiles = int(fprenumfiles, 16);
4422  fprechecksumtype = catheader[2];
4423  fprechecksum = catheader[3];
4424  il = 0;
4425  fileheader = AppendNullByte(catstring, formatspecs[5]);
4426  fnumfileshex = format(int(fnumfiles), 'x').lower();
4427  fileheader = fileheader + AppendNullBytes([fnumfileshex, fprechecksumtype], formatspecs[5]);
4428  if(fprechecksumtype=="none" or fprechecksumtype==""):
4429   catfileheadercshex = format(0, 'x').lower();
4430  elif(fprechecksumtype=="crc16" or fprechecksumtype=="crc16_ansi" or fprechecksumtype=="crc16_ibm"):
4431   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4432  elif(fprechecksumtype=="crc16_ccitt"):
4433   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4434  elif(fprechecksumtype=="adler32"):
4435   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4436  elif(fprechecksumtype=="crc32"):
4437   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4438  elif(fprechecksumtype=="crc64_ecma"):
4439   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4440  elif(fprechecksumtype=="crc64" or fprechecksumtype=="crc64_iso"):
4441   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4442  elif(CheckSumSupportAlt(fprechecksumtype, hashlib_guaranteed)):
4443   checksumoutstr = hashlib.new(fprechecksumtype);
4444   checksumoutstr.update(fileheader.encode('UTF-8'));
4445   catfileheadercshex = checksumoutstr.hexdigest().lower();
4446  else:
4447   catfileheadercshex = format(0, 'x').lower();
4448  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
4449  valid_archive = True;
4450  invalid_archive = False;
4451  if(verbose):
4452   VerbosePrintOut(infile);
4453   VerbosePrintOut("Number of Records " + str(fnumfiles));
4454  if(fprechecksum==catfileheadercshex):
4455   if(verbose):
4456    VerbosePrintOut("File Header Checksum Passed at offset " + str(0));
4457  else:
4458   if(verbose):
4459    VerbosePrintOut("File Header Checksum Failed at offset " + str(0));
4460    valid_archive = False;
4461    invalid_archive = True;
4462  if(verbose):
4463   VerbosePrintOut("");
4464  while(il<fnumfiles):
4465   catfhstart = catfp.tell();
4466   if(formatspecs[7]):
4467    catheaderdata = ReadFileHeaderDataBySize(catfp, formatspecs[5]);
4468   else:
4469    catheaderdata = ReadFileHeaderDataWoSize(catfp, formatspecs[5]);
4470   if(len(catheaderdata)==0):
4471    break;
4472   catfheadsize = int(catheaderdata[0], 16);
4473   catfnumfields = int(catheaderdata[1], 16);
4474   catftype = int(catheaderdata[2], 16);
4475   if(re.findall("^[.|/]", catheaderdata[3])):
4476    catfname = catheaderdata[3];
4477   else:
4478    catfname = "./"+catheaderdata[3];
4479   catfbasedir = os.path.dirname(catfname);
4480   catflinkname = catheaderdata[4];
4481   catfsize = int(catheaderdata[5], 16);
4482   catfatime = int(catheaderdata[6], 16);
4483   catfmtime = int(catheaderdata[7], 16);
4484   catfctime = int(catheaderdata[8], 16);
4485   catfbtime = int(catheaderdata[9], 16);
4486   catfmode = int(catheaderdata[10], 16);
4487   catfchmode = stat.S_IMODE(catfmode);
4488   catftypemod = stat.S_IFMT(catfmode);
4489   prefwinattributes = int(catheaderdata[11], 16);
4490   catfuid = int(catheaderdata[12], 16);
4491   catfuname = catheaderdata[13];
4492   catfgid = int(catheaderdata[14], 16);
4493   catfgname = catheaderdata[15];
4494   fid = int(catheaderdata[16], 16);
4495   finode = int(catheaderdata[17], 16);
4496   flinkcount = int(catheaderdata[18], 16);
4497   catfdev_minor = int(catheaderdata[19], 16);
4498   catfdev_major = int(catheaderdata[20], 16);
4499   catfrdev_minor = int(catheaderdata[21], 16);
4500   catfrdev_major = int(catheaderdata[22], 16);
4501   catfextrasize = int(catheaderdata[23], 16);
4502   catfextrafields = int(catheaderdata[24], 16);
4503   extrafieldslist = [];
4504   extrastart = 25;
4505   extraend = extrastart + catfextrafields;
4506   extrafieldslist = [];
4507   if(extrastart<extraend):
4508    extrafieldslist.append(catheaderdata[extrastart]);
4509    extrastart = extrastart + 1;
4510   catfchecksumtype = catheaderdata[extrastart].lower();
4511   catfcs = catheaderdata[extrastart + 1].lower();
4512   catfccs = catheaderdata[extrastart + 2].lower();
4513   hc = 0;
4514   hcmax = len(catheaderdata) - 2;
4515   hout = "";
4516   while(hc<hcmax):
4517    hout = hout + AppendNullByte(catheaderdata[hc], formatspecs[5]);
4518    hc = hc + 1;
4519   catnewfcs = GetFileChecksum(hout, catheaderdata[-3].lower(), True, formatspecs);
4520   if(verbose):
4521    VerbosePrintOut(catfname);
4522    VerbosePrintOut("Record Number " + str(il) + "; File ID " + str(fid) + "; iNode Number " + str(finode));
4523   if(catfcs==catnewfcs):
4524    if(verbose):
4525     VerbosePrintOut("File Header Checksum Passed at offset " + str(catfhstart));
4526   else:
4527    if(verbose):
4528     VerbosePrintOut("File Header Checksum Failed at offset " + str(catfhstart));
4529    valid_archive = False;
4530    invalid_archive = True;
4531   catfhend = catfp.tell() - 1;
4532   catfcontentstart = catfp.tell();
4533   catfcontents = "";
4534   pyhascontents = False;
4535   if(catfsize>0):
4536    catfcontents = catfp.read(catfsize);
4537    catnewfccs = GetFileChecksum(catfcontents, catheaderdata[-3].lower(), False, formatspecs);
4538    pyhascontents = True;
4539    if(catfccs==catnewfccs):
4540     if(verbose):
4541      VerbosePrintOut("File Content Checksum Passed at offset " + str(catfcontentstart));
4542    else:
4543     if(verbose):
4544      VerbosePrintOut("File Content Checksum Failed at offset " + str(catfcontentstart));
4545     valid_archive = False;
4546     invalid_archive = True;
4547   if(verbose):
4548    VerbosePrintOut("");
4549   catfp.seek(1, 1);
4550   il = il + 1;
4551  if(valid_archive):
4552   if(returnfp):
4553    return catfp;
4554   else:
4555    catfp.close();
4556    return True;
4557  else:
4558   catfp.close();
4559   return False;
4560
4561 create_alias_function("", __file_format_name__, "Validate", ArchiveFileValidate);
4562
4563 def ArchiveFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4564  if(hasattr(infile, "read") or hasattr(infile, "write")):
4565   catfp = infile;
4566   catfp.seek(0, 0);
4567   catfp = UncompressArchiveFile(catfp, formatspecs);
4568   checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True);
4569   if(checkcompressfile=="tarfile"):
4570    return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4571   if(checkcompressfile=="zipfile"):
4572    return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4573   if(rarfile_support and checkcompressfile=="rarfile"):
4574    return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4575   if(py7zr_support and checkcompressfile=="7zipfile"):
4576    return SevenZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4577   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4578    return False;
4579   if(not catfp):
4580    return False;
4581   catfp.seek(0, 0);
4582  elif(infile=="-"):
4583   catfp = BytesIO();
4584   if(hasattr(sys.stdin, "buffer")):
4585    shutil.copyfileobj(sys.stdin.buffer, catfp);
4586   else:
4587    shutil.copyfileobj(sys.stdin, catfp);
4588   catfp.seek(0, 0);
4589   catfp = UncompressArchiveFile(catfp, formatspecs);
4590   if(not catfp):
4591    return False;
4592   catfp.seek(0, 0);
4593  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
4594   catfp = download_file_from_internet_file(infile);
4595   catfp = UncompressArchiveFile(catfp, formatspecs);
4596   catfp.seek(0, 0);
4597   if(not catfp):
4598    return False;
4599   catfp.seek(0, 0);
4600  else:
4601   infile = RemoveWindowsPath(infile);
4602   checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
4603   if(checkcompressfile=="tarfile"):
4604    return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4605   if(checkcompressfile=="zipfile"):
4606    return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4607   if(rarfile_support and checkcompressfile=="rarfile"):
4608    return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4609   if(py7zr_support and checkcompressfile=="7zipfile"):
4610    return SevenZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4611   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4612    return False;
4613   compresscheck = CheckCompressionType(infile, formatspecs, True);
4614   if(not compresscheck):
4615    fextname = os.path.splitext(infile)[1];
4616    if(fextname==".gz"):
4617     compresscheck = "gzip";
4618    elif(fextname==".bz2"):
4619     compresscheck = "bzip2";
4620    elif(fextname==".zst"):
4621     compresscheck = "zstd";
4622    elif(fextname==".lz4" or fextname==".clz4"):
4623     compresscheck = "lz4";
4624    elif(fextname==".lzo" or fextname==".lzop"):
4625     compresscheck = "lzo";
4626    elif(fextname==".lzma" or fextname==".xz"):
4627     compresscheck = "lzma";
4628    else:
4629     return False;
4630   if(not compresscheck):
4631    return False;
4632   catfp = UncompressFile(infile, formatspecs, "rb");
4633  '''
4634  try:
4635   catfp.seek(0, 2);
4636  except OSError:
4637   SeekToEndOfFile(catfp);
4638  except ValueError:
4639   SeekToEndOfFile(catfp);
4640  CatSize = catfp.tell();
4641  CatSizeEnd = CatSize;
4642  '''
4643  try:
4644   catfp.seek(0, 0);
4645  except OSError:
4646   return False;
4647  except ValueError:
4648   return False;
4649  curloc = catfp.tell();
4650  if(curloc>0):
4651   catfp.seek(0, 0);
4652  catheader = ReadFileHeaderData(catfp, 4, formatspecs[5]);
4653  if(curloc>0):
4654   catfp.seek(curloc, 0);
4655  catstring = catheader[0];
4656  catversion = re.findall(r"([\d]+)$", catstring);
4657  fprenumfiles = catheader[1];
4658  fnumfiles = int(fprenumfiles, 16);
4659  fprechecksumtype = catheader[2];
4660  fprechecksum = catheader[3];
4661  fileheader = AppendNullByte(catstring, formatspecs[5]);
4662  fnumfileshex = format(int(fnumfiles), 'x').lower();
4663  fileheader = fileheader + AppendNullBytes([fnumfileshex, fprechecksumtype], formatspecs[5]);
4664  if(fprechecksumtype=="none" or fprechecksumtype==""):
4665   catfileheadercshex = format(0, 'x').lower();
4666  elif(fprechecksumtype=="crc16" or fprechecksumtype=="crc16_ansi" or fprechecksumtype=="crc16_ibm"):
4667   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4668  elif(fprechecksumtype=="crc16_ccitt"):
4669   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4670  elif(fprechecksumtype=="adler32"):
4671   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4672  elif(fprechecksumtype=="crc32"):
4673   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4674  elif(fprechecksumtype=="crc64_ecma"):
4675   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4676  elif(fprechecksumtype=="crc64" or fprechecksumtype=="crc64_iso"):
4677   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4678  elif(CheckSumSupportAlt(fprechecksumtype, hashlib_guaranteed)):
4679   checksumoutstr = hashlib.new(fprechecksumtype);
4680   checksumoutstr.update(fileheader.encode('UTF-8'));
4681   catfileheadercshex = checksumoutstr.hexdigest().lower();
4682  else:
4683   catfileheadercshex = format(0, 'x').lower();
4684  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
4685  fheadtell = len(fileheader);
4686  if(fprechecksum!=catfileheadercshex and not skipchecksum):
4687   VerbosePrintOut("File Header Checksum Error with file " + infile + " at offset " + str(0));
4688   return False;
4689  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
4690  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': {}};
4691  if(seekstart<0 and seekstart>fnumfiles):
4692    seekstart = 0;
4693  if(seekend==0 or seekend>fnumfiles and seekend<seekstart):
4694   seekend = fnumfiles;
4695  elif(seekend<0 and abs(seekend)<=fnumfiles and abs(seekend)>=seekstart):
4696   seekend = fnumfiles - abs(seekend);
4697  if(seekstart>0):
4698   il = 0;
4699   while(il < seekstart):
4700    prefhstart = catfp.tell();
4701    if(formatspecs[7]):
4702     preheaderdata = ReadFileHeaderDataBySize(catfp, formatspecs[5]);
4703    else:
4704     preheaderdata = ReadFileHeaderDataWoSize(catfp, formatspecs[5]);
4705    if(len(preheaderdata)==0):
4706     break;
4707    prefheadsize = int(preheaderdata[0], 16);
4708    prefnumfields = int(preheaderdata[1], 16);
4709    if(re.findall("^[.|/]", preheaderdata[3])):
4710     prefname = preheaderdata[3];
4711    else:
4712     prefname = "./"+preheaderdata[3];
4713    prefsize = int(preheaderdata[5], 16);
4714    prefextrasize = int(preheaderdata[23], 16);
4715    prefextrafields = int(preheaderdata[24], 16);
4716    extrafieldslist = [];
4717    extrastart = 25;
4718    extraend = extrastart + prefextrafields;
4719    extrafieldslist = [];
4720    if(extrastart<extraend):
4721     extrafieldslist.append(preheaderdata[extrastart]);
4722     extrastart = extrastart + 1;
4723    prefchecksumtype = preheaderdata[extrastart].lower();
4724    prefcs = preheaderdata[extrastart + 1].lower();
4725    prefccs = preheaderdata[extrastart + 2].lower();
4726    hc = 0;
4727    hcmax = len(preheaderdata) - 2;
4728    hout = "";
4729    while(hc<hcmax):
4730     hout = hout + AppendNullByte(preheaderdata[hc], formatspecs[5]);
4731     hc = hc + 1;
4732    prenewfcs = GetFileChecksum(hout, preheaderdata[-3].lower(), True, formatspecs);
4733    if(prefcs!=prenewfcs and not skipchecksum):
4734     VerbosePrintOut("File Header Checksum Error with file " + prefname + " at offset " + str(prefhstart));
4735     return False;
4736     valid_archive = False;
4737     invalid_archive = True;
4738    prefhend = catfp.tell() - 1;
4739    prefcontentstart = catfp.tell();
4740    prefcontents = "";
4741    pyhascontents = False;
4742    if(prefsize>0):
4743     prefcontents = catfp.read(prefsize);
4744     prenewfccs = GetFileChecksum(prefcontents, preheaderdata[-3].lower(), False, formatspecs);
4745     pyhascontents = True;
4746     if(prefccs!=prenewfccs and not skipchecksum):
4747      VerbosePrintOut("File Content Checksum Error with file " + prefname + " at offset " + str(prefcontentstart));
4748      return False;
4749    catfp.seek(1, 1);
4750    il = il + 1;
4751  fileidnum = seekstart;
4752  realidnum = 0;
4753  while(fileidnum<seekend):
4754   catfhstart = catfp.tell();
4755   if(formatspecs[7]):
4756    catheaderdata = ReadFileHeaderDataBySize(catfp, formatspecs[5]);
4757   else:
4758    catheaderdata = ReadFileHeaderDataWoSize(catfp, formatspecs[5]);
4759   if(len(catheaderdata)==0):
4760    break;
4761   catfheadsize = int(catheaderdata[0], 16);
4762   catfnumfields = int(catheaderdata[1], 16);
4763   catftype = int(catheaderdata[2], 16);
4764   if(re.findall("^[.|/]", catheaderdata[3])):
4765    catfname = catheaderdata[3];
4766   else:
4767    catfname = "./"+catheaderdata[3];
4768   catfbasedir = os.path.dirname(catfname);
4769   catflinkname = catheaderdata[4];
4770   catfsize = int(catheaderdata[5], 16);
4771   catfatime = int(catheaderdata[6], 16);
4772   catfmtime = int(catheaderdata[7], 16);
4773   catfctime = int(catheaderdata[8], 16);
4774   catfbtime = int(catheaderdata[9], 16);
4775   catfmode = int(catheaderdata[10], 16);
4776   catfchmode = stat.S_IMODE(catfmode);
4777   catftypemod = stat.S_IFMT(catfmode);
4778   catfwinattributes = int(catheaderdata[11], 16);
4779   catfuid = int(catheaderdata[12], 16);
4780   catfuname = catheaderdata[13];
4781   catfgid = int(catheaderdata[14], 16);
4782   catfgname = catheaderdata[15];
4783   fid = int(catheaderdata[16], 16);
4784   finode = int(catheaderdata[17], 16);
4785   flinkcount = int(catheaderdata[18], 16);
4786   catfdev_minor = int(catheaderdata[19], 16);
4787   catfdev_major = int(catheaderdata[20], 16);
4788   catfrdev_minor = int(catheaderdata[21], 16);
4789   catfrdev_major = int(catheaderdata[22], 16);
4790   catfextrasize = int(catheaderdata[23], 16);
4791   catfextrafields = int(catheaderdata[24], 16);
4792   extrafieldslist = [];
4793   extrastart = 25;
4794   extraend = extrastart + catfextrafields;
4795   extrafieldslist = [];
4796   if(extrastart<extraend):
4797    extrafieldslist.append(catheaderdata[extrastart]);
4798    extrastart = extrastart + 1;
4799   catfchecksumtype = catheaderdata[extrastart].lower();
4800   catfcs = catheaderdata[extrastart + 1].lower();
4801   catfccs = catheaderdata[extrastart + 2].lower();
4802   hc = 0;
4803   hcmax = len(catheaderdata) - 2;
4804   hout = "";
4805   while(hc<hcmax):
4806    hout = hout + AppendNullByte(catheaderdata[hc], formatspecs[5]);
4807    hc = hc + 1;
4808   catnewfcs = GetFileChecksum(hout, catheaderdata[-3].lower(), True, formatspecs);
4809   if(catfcs!=catnewfcs and not skipchecksum):
4810    VerbosePrintOut("File Header Checksum Error with file " + catfname + " at offset " + str(catfhstart));
4811    return False;
4812   catfhend = catfp.tell() - 1;
4813   catfcontentstart = catfp.tell();
4814   catfcontents = "";
4815   pyhascontents = False;
4816   if(catfsize>0 and not listonly):
4817    catfcontents = catfp.read(catfsize);
4818    catnewfccs = GetFileChecksum(catfcontents, catheaderdata[-3].lower(), False, formatspecs);
4819    pyhascontents = True;
4820    if(catfccs!=catnewfccs and skipchecksum):
4821     VerbosePrintOut("File Content Checksum Error with file " + catfname + " at offset " + str(catfcontentstart));
4822     return False;
4823   if(catfsize>0 and listonly):
4824    catfp.seek(catfsize, 1);
4825    pyhascontents = False;
4826   catfp.seek(1, 1);
4827   catfcontentend = catfp.tell() - 1;
4828   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} });
4829   fileidnum = fileidnum + 1;
4830   realidnum = realidnum + 1;
4831  if(returnfp):
4832   catlist.update({'catfp': catfp});
4833  else:
4834   catfp.close();
4835  return catlist;
4836
4837 create_alias_function("", __file_format_name__, "ToArray", ArchiveFileToArray);
4838
4839 def ArchiveFileStringToArray(catstr, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4840  catfp = BytesIO(catstr);
4841  listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4842  return listcatfiles;
4843
4844 create_alias_function("", __file_format_name__, "StringToArray", ArchiveFileStringToArray);
4845
4846 def TarFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4847  catfp = BytesIO();
4848  catfp = PackArchiveFileFromTarFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
4849  listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4850  return listcatfiles;
4851
4852 def ZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4853  catfp = BytesIO();
4854  catfp = PackArchiveFileFromZipFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
4855  listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4856  return listcatfiles;
4857
4858 if(not rarfile_support):
4859  def RarFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4860   return False;
4861
4862 if(rarfile_support):
4863  def RarFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4864   catfp = BytesIO();
4865   catfp = PackArchiveFileFromSevenZipFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
4866   listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4867   return listcatfiles;
4868
4869 if(not py7zr_support):
4870  def SevenZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4871   return False;
4872
4873 if(py7zr_support):
4874  def SevenZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4875   catfp = BytesIO();
4876   catfp = PackArchiveFileFromSevenZipFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
4877   listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4878   return listcatfiles;
4879
4880 def InFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4881  checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
4882  if(checkcompressfile=="tarfile"):
4883   return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4884  elif(checkcompressfile=="zipfile"):
4885   return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4886  elif(checkcompressfile=="catfile"):
4887   return ArchiveFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4888  elif(rarfile_support and checkcompressfile=="rarfile"):
4889   return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4890  elif(py7zr_support and checkcompressfile=="7zipfile"):
4891   return SevenZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4892  else:
4893   return False;
4894  return False;
4895
4896 def ListDirToArrayAlt(infiles, dirlistfromtxt=False, followlink=False, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
4897  catver = formatspecs[6];
4898  fileheaderver = str(int(catver.replace(".", "")));
4899  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
4900  advancedlist = formatspecs[8];
4901  altinode = formatspecs[9];
4902  infilelist = [];
4903  if(infiles=="-"):
4904   for line in sys.stdin:
4905    infilelist.append(line.strip());
4906   infilelist = list(filter(None, infilelist));
4907  elif(infiles!="-" and dirlistfromtxt and os.path.exists(infiles) and (os.path.isfile(infiles) or infiles=="/dev/null" or infiles=="NUL")):
4908   if(not os.path.exists(infiles) or not os.path.isfile(infiles)):
4909    return False;
4910   with UncompressFile(infiles, formatspecs, "r") as finfile:
4911    for line in finfile:
4912     infilelist.append(line.strip());
4913   infilelist = list(filter(None, infilelist));
4914  else:
4915   if(isinstance(infiles, (list, tuple, ))):
4916    infilelist = list(filter(None, infiles));
4917   elif(isinstance(infiles, (str, ))):
4918    infilelist = list(filter(None, [infiles]));
4919  if(advancedlist):
4920   GetDirList = ListDirAdvanced(infilelist, followlink, False);
4921  else:
4922   GetDirList = ListDir(infilelist, followlink, False);
4923  if(not GetDirList):
4924   return False;
4925  curinode = 0;
4926  curfid = 0;
4927  inodelist = [];
4928  inodetofile = {};
4929  filetoinode = {};
4930  inodetocatinode = {};
4931  fileidnum = 0;
4932  fnumfiles = int(len(GetDirList));
4933  catver = formatspecs[6];
4934  fileheaderver = str(int(catver.replace(".", "")));
4935  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
4936  fnumfileshex = format(int(fnumfiles), 'x').lower();
4937  fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
4938  catversion = re.findall(r"([\d]+)$", fileheader);
4939  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
4940  if(checksumtype=="none" or checksumtype==""):
4941   catfileheadercshex = format(0, 'x').lower();
4942  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
4943   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4944  elif(checksumtype=="crc16_ccitt"):
4945   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4946  elif(checksumtype=="adler32"):
4947   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4948  elif(checksumtype=="crc32"):
4949   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4950  elif(checksumtype=="crc64_ecma"):
4951   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4952  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
4953   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4954  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
4955   checksumoutstr = hashlib.new(checksumtype);
4956   checksumoutstr.update(fileheader.encode('UTF-8'));
4957   catfileheadercshex = checksumoutstr.hexdigest().lower();
4958  else:
4959   catfileheadercshex = format(0, 'x').lower();
4960  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
4961  fheadtell = len(fileheader);
4962  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
4963  for curfname in GetDirList:
4964   if(re.findall("^[.|/]", curfname)):
4965    fname = curfname;
4966   else:
4967    fname = "./"+curfname;
4968   if(verbose):
4969    VerbosePrintOut(fname);
4970   if(not followlink or followlink is None):
4971    fstatinfo = os.lstat(fname);
4972   else:
4973    fstatinfo = os.stat(fname);
4974   fpremode = fstatinfo.st_mode;
4975   finode = fstatinfo.st_ino;
4976   flinkcount = fstatinfo.st_nlink;
4977   ftype = 0;
4978   if(stat.S_ISREG(fpremode)):
4979    ftype = 0;
4980   elif(stat.S_ISLNK(fpremode)):
4981    ftype = 2;
4982   elif(stat.S_ISCHR(fpremode)):
4983    ftype = 3;
4984   elif(stat.S_ISBLK(fpremode)):
4985    ftype = 4;
4986   elif(stat.S_ISDIR(fpremode)):
4987    ftype = 5;
4988   elif(stat.S_ISFIFO(fpremode)):
4989    ftype = 6;
4990   elif(stat.S_ISSOCK(fpremode)):
4991    ftype = 8;
4992   elif(hasattr(stat, "S_ISDOOR") and stat.S_ISDOOR(fpremode)):
4993    ftype = 9;
4994   elif(hasattr(stat, "S_ISPORT") and stat.S_ISPORT(fpremode)):
4995    ftype = 10;
4996   elif(hasattr(stat, "S_ISWHT") and stat.S_ISWHT(fpremode)):
4997    ftype = 11;
4998   else:
4999    ftype = 0;
5000   flinkname = "";
5001   fbasedir = os.path.dirname(fname);
5002   fcurfid = curfid;
5003   if(not followlink and finode!=0):
5004    if(ftype!=1):
5005     if(finode in inodelist):
5006      ftype = 1;
5007      flinkname = inodetofile[finode];
5008      if(altinode):
5009       fcurinode = finode;
5010      else:
5011       fcurinode = inodetocatinode[finode];
5012     if(finode not in inodelist):
5013      inodelist.append(finode);
5014      inodetofile.update({finode: fname});
5015      inodetocatinode.update({finode: curinode});
5016      if(altinode):
5017       fcurinode = finode;
5018      else:
5019       fcurinode = curinode;
5020      curinode = curinode + 1;
5021   else:
5022    fcurinode = curinode;
5023    curinode = curinode + 1;
5024   curfid = curfid + 1;
5025   if(ftype==2):
5026    flinkname = os.readlink(fname);
5027   fdev = fstatinfo.st_dev;
5028   getfdev = GetDevMajorMinor(fdev);
5029   fdev_minor = getfdev[0];
5030   fdev_major = getfdev[1];
5031   frdev = fstatinfo.st_dev;
5032   if(hasattr(fstatinfo, "st_rdev")):
5033    frdev = fstatinfo.st_rdev;
5034   else:
5035    frdev = fstatinfo.st_dev;
5036   getfrdev = GetDevMajorMinor(frdev);
5037   frdev_minor = getfrdev[0];
5038   frdev_major = getfrdev[1];
5039   if(ftype==1 or ftype==2 or ftype==3 or ftype==4 or ftype==5 or ftype==6):
5040    fsize = "0";
5041   if(ftype==0 or ftype==7):
5042    fsize = fstatinfo.st_size;
5043   fatime = fstatinfo.st_atime;
5044   fmtime = fstatinfo.st_mtime;
5045   fctime = fstatinfo.st_ctime;
5046   if(hasattr(fstatinfo, "st_birthtime")):
5047    fbtime = fstatinfo.st_birthtime;
5048   else:
5049    fbtime = fstatinfo.st_ctime;
5050   fmode = fstatinfo.st_mode;
5051   fchmode = stat.S_IMODE(fstatinfo.st_mode);
5052   ftypemod = stat.S_IFMT(fstatinfo.st_mode);
5053   fuid = fstatinfo.st_uid;
5054   fgid = fstatinfo.st_gid;
5055   funame = "";
5056   try:
5057    import pwd;
5058    try:
5059     userinfo = pwd.getpwuid(fstatinfo.st_uid);
5060     funame = userinfo.pw_name;
5061    except KeyError:
5062     funame = "";
5063   except ImportError:
5064    funame = "";
5065   fgname = "";
5066   try:
5067    import grp;
5068    try:
5069     groupinfo = grp.getgrgid(fstatinfo.st_gid);
5070     fgname = groupinfo.gr_name;
5071    except KeyError:
5072     fgname = "";
5073   except ImportError:
5074    fgname = "";
5075   fdev_minor = fdev_minor;
5076   fdev_major = fdev_major;
5077   frdev_minor = frdev_minor;
5078   frdev_major = frdev_major;
5079   finode = finode;
5080   flinkcount = flinkcount;
5081   if(hasattr(fstatinfo, "st_file_attributes")):
5082    fwinattributes = fstatinfo.st_file_attributes;
5083   else:
5084    fwinattributes = 0;
5085   fcontents = "".encode('UTF-8');
5086   chunk_size = 1024;
5087   if(ftype==0 or ftype==7):
5088    with open(fname, "rb") as fpc:
5089     while(True):
5090      chunk = fpc.read(chunk_size);
5091      if(not chunk):
5092       break
5093      fcontents += chunk;
5094   if(followlink and (ftype==1 or ftype==2)):
5095    flstatinfo = os.stat(flinkname);
5096    with open(flinkname, "rb") as fpc:
5097     while(True):
5098      chunk = fpc.read(chunk_size);
5099      if(not chunk):
5100       break;
5101      fcontents += chunk;
5102   ftypehex = format(ftype, 'x').lower();
5103   extrafields = len(extradata);
5104   extrafieldslist = extradata;
5105   catfextrafields = extrafields;
5106   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
5107   if(len(extradata)>0):
5108    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
5109   extrasizelen = len(extrasizestr);
5110   extrasizelenhex = format(extrasizelen, 'x').lower();
5111   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()];
5112   catoutlen = len(catoutlist) + len(extradata) + 3;
5113   catoutlenhex = format(catoutlen, 'x').lower();
5114   catoutlist.insert(0, catoutlenhex);
5115   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
5116   if(len(extradata)>0):
5117    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
5118   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
5119   catfnumfields = catoutlen;
5120   if(checksumtype=="none" or checksumtype==""):
5121    catfileheadercshex = format(0, 'x').lower();
5122    catfilecontentcshex = format(0, 'x').lower();
5123   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5124    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
5125    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
5126   elif(checksumtype=="crc16_ccitt"):
5127    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
5128    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
5129   elif(checksumtype=="adler32"):
5130    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5131    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
5132   elif(checksumtype=="crc32"):
5133    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5134    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
5135   elif(checksumtype=="crc64_ecma"):
5136    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5137    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
5138   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5139    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5140    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
5141   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5142    checksumoutstr = hashlib.new(checksumtype);
5143    checksumoutstr.update("".encode('UTF-8'));
5144    catfileheadercshex = checksumoutstr.hexdigest().lower();
5145    checksumoutstr = hashlib.new(checksumtype);
5146    checksumoutstr.update(fcontents);
5147    catfilecontentcshex = checksumoutstr.hexdigest().lower();
5148   else:
5149    catfileheadercshex = format(0, 'x').lower();
5150    catfilecontentcshex = format(0, 'x').lower();
5151   catfhstart = fheadtell;
5152   fheadtell += len(catfileoutstr);
5153   catfhend = fheadtell - 1;
5154   catfcontentstart = fheadtell;
5155   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5156   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
5157   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
5158   catheaderdata = [catheaersize] + catoutlist + extradata + [checksumtype, catfileheadercshex, catfilecontentcshex]
5159   if(checksumtype=="none" or checksumtype==""):
5160    catfileheadercshex = format(0, 'x').lower();
5161   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5162    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5163   elif(checksumtype=="crc16_ccitt"):
5164    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5165   elif(checksumtype=="adler32"):
5166    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5167   elif(checksumtype=="crc32"):
5168    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5169   elif(checksumtype=="crc64_ecma"):
5170    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5171   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5172    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5173   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5174    checksumoutstr = hashlib.new(checksumtype);
5175    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
5176    catfileheadercshex = checksumoutstr.hexdigest().lower();
5177   else:
5178    catfileheadercshex = format(0, 'x').lower();
5179   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5180   catfileoutstrecd = catfileoutstr.encode('UTF-8');
5181   nullstrecd = formatspecs[5].encode('UTF-8');
5182   fheadtell += len(catfileoutstr) + 1;
5183   catfcontentend = fheadtell - 1;
5184   catfileout = catfileoutstrecd + fcontents + nullstrecd;
5185   pyhascontents = False;
5186   if(int(fsize)>0 and not listonly):
5187    pyhascontents = True;
5188   if(int(fsize)>0 and listonly):
5189    fcontents = "";
5190    pyhascontents = False;
5191   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} });
5192   fileidnum = fileidnum + 1;
5193  return catlist;
5194
5195 def TarFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5196  curinode = 0;
5197  curfid = 0;
5198  inodelist = [];
5199  inodetofile = {};
5200  filetoinode = {};
5201  inodetocatinode = {};
5202  fileidnum = 0;
5203  if(infile=="-"):
5204   infile = BytesIO();
5205   if(hasattr(sys.stdin, "buffer")):
5206    shutil.copyfileobj(sys.stdin.buffer, infile);
5207   else:
5208    shutil.copyfileobj(sys.stdin, infile);
5209   infile.seek(0, 0);
5210   if(not infile):
5211    return False;
5212   infile.seek(0, 0);
5213  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
5214   infile = download_file_from_internet_file(infile);
5215   infile.seek(0, 0);
5216   if(not infile):
5217    return False;
5218   infile.seek(0, 0);
5219  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
5220   return False;
5221  elif(os.path.exists(infile) and os.path.isfile(infile)):
5222   try:
5223    if(not tarfile.is_tarfile(infile)):
5224     return False;
5225   except AttributeError:
5226    if(not is_tarfile(infile)):
5227     return False;
5228  else:
5229   return False;
5230  try:
5231   if(hasattr(infile, "read") or hasattr(infile, "write")):
5232    tarfp = tarfile.open(fileobj=infile, mode="r");
5233   else:
5234    tarfp = tarfile.open(infile, "r");
5235  except FileNotFoundError:
5236   return False;
5237  fnumfiles = int(len(tarfp.getmembers()));
5238  catver = formatspecs[6];
5239  fileheaderver = str(int(catver.replace(".", "")));
5240  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
5241  fnumfileshex = format(int(fnumfiles), 'x').lower();
5242  fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
5243  catversion = re.findall(r"([\d]+)$", fileheader);
5244  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
5245  if(checksumtype=="none" or checksumtype==""):
5246   catfileheadercshex = format(0, 'x').lower();
5247  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5248   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5249  elif(checksumtype=="crc16_ccitt"):
5250   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5251  elif(checksumtype=="adler32"):
5252   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5253  elif(checksumtype=="crc32"):
5254   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5255  elif(checksumtype=="crc64_ecma"):
5256   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5257  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5258   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5259  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5260   checksumoutstr = hashlib.new(checksumtype);
5261   checksumoutstr.update(fileheader.encode('UTF-8'));
5262   catfileheadercshex = checksumoutstr.hexdigest().lower();
5263  else:
5264   catfileheadercshex = format(0, 'x').lower();
5265  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
5266  fheadtell = len(fileheader);
5267  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
5268  for member in sorted(tarfp.getmembers(), key=lambda x: x.name):
5269   if(re.findall("^[.|/]", member.name)):
5270    fname = member.name;
5271   else:
5272    fname = "./"+member.name;
5273   if(verbose):
5274    VerbosePrintOut(fname);
5275   fpremode = member.mode;
5276   ffullmode = member.mode;
5277   flinkcount = 0;
5278   ftype = 0;
5279   if(member.isreg()):
5280    ffullmode = member.mode + stat.S_IFREG;
5281    ftype = 0;
5282   elif(member.isdev()):
5283    ffullmode = member.mode;
5284    ftype = 7;
5285   elif(member.islnk()):
5286    ffullmode = member.mode + stat.S_IFREG;
5287    ftype = 1;
5288   elif(member.issym()):
5289    ffullmode = member.mode + stat.S_IFLNK;
5290    ftype = 2;
5291   elif(member.ischr()):
5292    ffullmode = member.mode + stat.S_IFCHR;
5293    ftype = 3;
5294   elif(member.isblk()):
5295    ffullmode = member.mode + stat.S_IFBLK;
5296    ftype = 4;
5297   elif(member.isdir()):
5298    ffullmode = member.mode + stat.S_IFDIR;
5299    ftype = 5;
5300   elif(member.isfifo()):
5301    ffullmode = member.mode + stat.S_IFIFO;
5302    ftype = 6;
5303   elif(member.issparse()):
5304    ffullmode = member.mode;
5305    ftype = 12;
5306   else:
5307    ffullmode = member.mode;
5308    ftype = 0;
5309   flinkname = "";
5310   fbasedir = os.path.dirname(fname);
5311   fcurfid = curfid;
5312   fcurinode = curfid;
5313   finode = fcurinode;
5314   curfid = curfid + 1;
5315   if(ftype==2):
5316    flinkname = member.linkname;
5317   fdev_minor = member.devminor;
5318   fdev_major = member.devmajor;
5319   frdev_minor = member.devminor;
5320   frdev_major = member.devmajor;
5321   if(ftype==1 or ftype==2 or ftype==3 or ftype==4 or ftype==5 or ftype==6):
5322    fsize = "0";
5323   elif(ftype==0 or ftype==7):
5324    fsize = member.size;
5325   else:
5326    fsize = member.size;
5327   fatime = member.mtime;
5328   fmtime = member.mtime;
5329   fctime = member.mtime;
5330   fbtime = member.mtime;
5331   fmode = ffullmode;
5332   fchmode = stat.S_IMODE(ffullmode);
5333   ftypemod = stat.S_IFMT(ffullmode);
5334   fuid = member.uid;
5335   fgid = member.gid;
5336   funame = member.uname;
5337   fgname = member.gname;
5338   flinkcount = flinkcount;
5339   fwinattributes = int(0);
5340   fcontents = "".encode('UTF-8');
5341   chunk_size = 1024;
5342   if(ftype==0 or ftype==7):
5343    with tarfp.extractfile(member) as fpc:
5344     while(True):
5345      chunk = fpc.read(chunk_size);
5346      if(not chunk):
5347       break
5348      fcontents += chunk;
5349   ftypehex = format(ftype, 'x').lower();
5350   extrafields = len(extradata);
5351   extrafieldslist = extradata;
5352   catfextrafields = extrafields;
5353   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
5354   if(len(extradata)>0):
5355    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
5356   extrasizelen = len(extrasizestr);
5357   extrasizelenhex = format(extrasizelen, 'x').lower();
5358   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()];
5359   catoutlen = len(catoutlist) + len(extradata) + 3;
5360   catoutlenhex = format(catoutlen, 'x').lower();
5361   catoutlist.insert(0, catoutlenhex);
5362   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
5363   if(len(extradata)>0):
5364    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
5365   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
5366   catfnumfields = catoutlen;
5367   if(checksumtype=="none" or checksumtype==""):
5368    catfileheadercshex = format(0, 'x').lower();
5369    catfilecontentcshex = format(0, 'x').lower();
5370   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5371    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
5372    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
5373   elif(checksumtype=="crc16_ccitt"):
5374    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
5375    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
5376   elif(checksumtype=="adler32"):
5377    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5378    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
5379   elif(checksumtype=="crc32"):
5380    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5381    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
5382   elif(checksumtype=="crc64_ecma"):
5383    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5384    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
5385   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5386    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5387    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
5388   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5389    checksumoutstr = hashlib.new(checksumtype);
5390    checksumoutstr.update("".encode('UTF-8'));
5391    catfileheadercshex = checksumoutstr.hexdigest().lower();
5392    checksumoutstr = hashlib.new(checksumtype);
5393    checksumoutstr.update(fcontents);
5394    catfilecontentcshex = checksumoutstr.hexdigest().lower();
5395   else:
5396    catfileheadercshex = format(0, 'x').lower();
5397    catfilecontentcshex = format(0, 'x').lower();
5398   catfhstart = fheadtell;
5399   fheadtell += len(catfileoutstr);
5400   catfhend = fheadtell - 1;
5401   catfcontentstart = fheadtell;
5402   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5403   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
5404   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
5405   catheaderdata = [catheaersize] + catoutlist + extradata + [checksumtype, catfileheadercshex, catfilecontentcshex]
5406   if(checksumtype=="none" or checksumtype==""):
5407    catfileheadercshex = format(0, 'x').lower();
5408   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5409    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5410   elif(checksumtype=="crc16_ccitt"):
5411    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5412   elif(checksumtype=="adler32"):
5413    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5414   elif(checksumtype=="crc32"):
5415    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5416   elif(checksumtype=="crc64_ecma"):
5417    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5418   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5419    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5420   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5421    checksumoutstr = hashlib.new(checksumtype);
5422    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
5423    catfileheadercshex = checksumoutstr.hexdigest().lower();
5424   else:
5425    catfileheadercshex = format(0, 'x').lower();
5426   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5427   catfileoutstrecd = catfileoutstr.encode('UTF-8');
5428   nullstrecd = formatspecs[5].encode('UTF-8');
5429   fheadtell += len(catfileoutstr) + 1;
5430   catfcontentend = fheadtell - 1;
5431   catfileout = catfileoutstrecd + fcontents + nullstrecd;
5432   pyhascontents = False;
5433   if(int(fsize)>0 and not listonly):
5434    pyhascontents = True;
5435   if(int(fsize)>0 and listonly):
5436    fcontents = "";
5437    pyhascontents = False;
5438   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} });
5439   fileidnum = fileidnum + 1;
5440  return catlist;
5441
5442 def ZipFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5443  curinode = 0;
5444  curfid = 0;
5445  inodelist = [];
5446  inodetofile = {};
5447  filetoinode = {};
5448  inodetocatinode = {};
5449  fileidnum = 0;
5450  if(infile=="-"):
5451   infile = BytesIO();
5452   if(hasattr(sys.stdin, "buffer")):
5453    shutil.copyfileobj(sys.stdin.buffer, infile);
5454   else:
5455    shutil.copyfileobj(sys.stdin, infile);
5456   infile.seek(0, 0);
5457   if(not infile):
5458    return False;
5459   infile.seek(0, 0);
5460  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
5461   infile = download_file_from_internet_file(infile);
5462   infile.seek(0, 0);
5463   if(not infile):
5464    return False;
5465   infile.seek(0, 0);
5466  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
5467   return False;
5468  else:
5469   return False;
5470  if(not zipfile.is_zipfile(infile)):
5471   return False;
5472  try:
5473   zipfp = zipfile.ZipFile(infile, "r", allowZip64=True);
5474  except FileNotFoundError:
5475   return False;
5476  ziptest = zipfp.testzip();
5477  if(ziptest):
5478   VerbosePrintOut("Bad file found!");
5479  fnumfiles = int(len(zipfp.infolist()));
5480  catver = formatspecs[6];
5481  fileheaderver = str(int(catver.replace(".", "")));
5482  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
5483  catversion = re.findall(r"([\d]+)$", fileheader);
5484  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
5485  fnumfileshex = format(int(fnumfiles), 'x').lower();
5486  fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
5487  if(checksumtype=="none" or checksumtype==""):
5488   catfileheadercshex = format(0, 'x').lower();
5489  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5490   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5491  elif(checksumtype=="crc16_ccitt"):
5492   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5493  elif(checksumtype=="adler32"):
5494   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5495  elif(checksumtype=="crc32"):
5496   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5497  elif(checksumtype=="crc64_ecma"):
5498   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5499  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5500   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5501  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5502   checksumoutstr = hashlib.new(checksumtype);
5503   checksumoutstr.update(fileheader.encode('UTF-8'));
5504   catfileheadercshex = checksumoutstr.hexdigest().lower();
5505  else:
5506   catfileheadercshex = format(0, 'x').lower();
5507  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
5508  fheadtell = len(fileheader);
5509  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
5510  for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
5511   if(re.findall("^[.|/]", member.filename)):
5512    fname = member.filename;
5513   else:
5514    fname = "./"+member.filename;
5515   zipinfo = zipfp.getinfo(member.filename);
5516   if(verbose):
5517    VerbosePrintOut(fname);
5518   if(not member.is_dir()):
5519    fpremode = stat.S_IFREG + 438;
5520   elif(member.is_dir()):
5521    fpremode = stat.S_IFDIR + 511;
5522   flinkcount = 0;
5523   ftype = 0;
5524   if(not member.is_dir()):
5525    ftype = 0;
5526   elif(member.is_dir()):
5527    ftype = 5;
5528   flinkname = "";
5529   fbasedir = os.path.dirname(fname);
5530   fcurfid = curfid;
5531   fcurinode = curfid;
5532   finode = fcurinode;
5533   curfid = curfid + 1;
5534   fdev_minor = 0;
5535   fdev_major = 0;
5536   frdev_minor = 0;
5537   frdev_major = 0;
5538   if(ftype==5):
5539    fsize = "0";
5540   elif(ftype==0):
5541    fsize = member.file_size;
5542   else:
5543    fsize = member.file_size;
5544   fatime = time.mktime(member.date_time + (0, 0, -1));
5545   fmtime = time.mktime(member.date_time + (0, 0, -1));
5546   fctime = time.mktime(member.date_time + (0, 0, -1));
5547   fbtime = time.mktime(member.date_time + (0, 0, -1));
5548   if(zipinfo.create_system==0 or zipinfo.create_system==10):
5549    fwinattributes = int(zipinfo.external_attr);
5550    if(not member.is_dir()):
5551     fmode = int(stat.S_IFREG + 438);
5552     fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)));
5553     ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)));
5554    elif(member.is_dir()):
5555     fmode = int(stat.S_IFDIR + 511);
5556     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
5557     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
5558   elif(zipinfo.create_system==3):
5559    fwinattributes = int(0);
5560    fmode = int(zipinfo.external_attr);
5561   else:
5562    fwinattributes = int(0);
5563    if(not member.is_dir()):
5564     fmode = int(stat.S_IFREG + 438);
5565     fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)));
5566     ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)));
5567    elif(member.is_dir()):
5568     fmode = int(stat.S_IFDIR + 511);
5569     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
5570     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
5571   try:
5572    fuid = os.getuid();
5573   except AttributeError:
5574    fuid = 0;
5575   except KeyError:
5576    fuid = 0;
5577   try:
5578    fgid = os.getgid();
5579   except AttributeError:
5580    fgid = 0;
5581   except KeyError:
5582    fgid = 0;
5583   try:
5584    import pwd;
5585    try:
5586     userinfo = pwd.getpwuid(os.getuid());
5587     funame = userinfo.pw_name;
5588    except KeyError:
5589     funame = "";
5590    except AttributeError:
5591     funame = "";
5592   except ImportError:
5593    funame = "";
5594   fgname = "";
5595   try:
5596    import grp;
5597    try:
5598     groupinfo = grp.getgrgid(os.getgid());
5599     fgname = groupinfo.gr_name;
5600    except KeyError:
5601     fgname = "";
5602    except AttributeError:
5603     fgname = "";
5604   except ImportError:
5605    fgname = "";
5606   fcontents = "".encode('UTF-8');
5607   if(ftype==0):
5608    fcontents = zipfp.read(member.filename);
5609   ftypehex = format(ftype, 'x').lower();
5610   extrafields = len(extradata);
5611   extrafieldslist = extradata;
5612   catfextrafields = extrafields;
5613   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
5614   if(len(extradata)>0):
5615    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
5616   extrasizelen = len(extrasizestr);
5617   extrasizelenhex = format(extrasizelen, 'x').lower();
5618   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()];
5619   catoutlen = len(catoutlist) + len(extradata) + 3;
5620   catoutlenhex = format(catoutlen, 'x').lower();
5621   catoutlist.insert(0, catoutlenhex);
5622   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
5623   if(len(extradata)>0):
5624    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
5625   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
5626   catfnumfields = catoutlen;
5627   if(checksumtype=="none" or checksumtype==""):
5628    catfileheadercshex = format(0, 'x').lower();
5629    catfilecontentcshex = format(0, 'x').lower();
5630   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5631    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
5632    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
5633   elif(checksumtype=="crc16_ccitt"):
5634    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
5635    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
5636   elif(checksumtype=="adler32"):
5637    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5638    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
5639   elif(checksumtype=="crc32"):
5640    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5641    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
5642   elif(checksumtype=="crc64_ecma"):
5643    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5644    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
5645   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5646    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5647    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
5648   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5649    checksumoutstr = hashlib.new(checksumtype);
5650    checksumoutstr.update("".encode('UTF-8'));
5651    catfileheadercshex = checksumoutstr.hexdigest().lower();
5652    checksumoutstr = hashlib.new(checksumtype);
5653    checksumoutstr.update(fcontents);
5654    catfilecontentcshex = checksumoutstr.hexdigest().lower();
5655   else:
5656    catfileheadercshex = format(0, 'x').lower();
5657    catfilecontentcshex = format(0, 'x').lower();
5658   catfhstart = fheadtell;
5659   fheadtell += len(catfileoutstr);
5660   catfhend = fheadtell - 1;
5661   catfcontentstart = fheadtell;
5662   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5663   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
5664   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
5665   catheaderdata = [catheaersize] + catoutlist + extradata + [checksumtype, catfileheadercshex, catfilecontentcshex];
5666   if(checksumtype=="none" or checksumtype==""):
5667    catfileheadercshex = format(0, 'x').lower();
5668   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5669    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5670   elif(checksumtype=="crc16_ccitt"):
5671    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5672   elif(checksumtype=="adler32"):
5673    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5674   elif(checksumtype=="crc32"):
5675    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5676   elif(checksumtype=="crc64_ecma"):
5677    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5678   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5679    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5680   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5681    checksumoutstr = hashlib.new(checksumtype);
5682    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
5683    catfileheadercshex = checksumoutstr.hexdigest().lower();
5684   else:
5685    catfileheadercshex = format(0, 'x').lower();
5686   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5687   catfileoutstrecd = catfileoutstr.encode('UTF-8');
5688   nullstrecd = formatspecs[5].encode('UTF-8');
5689   fheadtell += len(catfileoutstr) + 1;
5690   catfcontentend = fheadtell - 1;
5691   catfileout = catfileoutstrecd + fcontents + nullstrecd;
5692   pyhascontents = False;
5693   if(int(fsize)>0 and not listonly):
5694    pyhascontents = True;
5695   if(int(fsize)>0 and listonly):
5696    fcontents = "";
5697    pyhascontents = False;
5698   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} });
5699   fileidnum = fileidnum + 1;
5700  return catlist;
5701
5702 if(not rarfile_support):
5703  def RarFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5704   return False;
5705
5706 if(rarfile_support):
5707  def RarFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5708   curinode = 0;
5709   curfid = 0;
5710   inodelist = [];
5711   inodetofile = {};
5712   filetoinode = {};
5713   inodetocatinode = {};
5714   fileidnum = 0;
5715   if(not os.path.exists(infiles) or not os.path.isfile(infiles)):
5716    return False;
5717   if(not rarfile.is_rarfile(infile) and not rarfile.is_rarfile_sfx(infile)):
5718    return False;
5719   rarfp = rarfile.RarFile(infile, "r");
5720   rartest = rarfp.testrar();
5721   if(rartest):
5722    VerbosePrintOut("Bad file found!");
5723   fnumfiles = int(len(rarfp.infolist()));
5724   catver = formatspecs[6];
5725   fileheaderver = str(int(catver.replace(".", "")));
5726   fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
5727   catversion = re.findall(r"([\d]+)$", fileheader);
5728   catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
5729   fnumfileshex = format(int(fnumfiles), 'x').lower();
5730   fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
5731   if(checksumtype=="none" or checksumtype==""):
5732    catfileheadercshex = format(0, 'x').lower();
5733   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5734    catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5735   elif(checksumtype=="crc16_ccitt"):
5736    catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5737   elif(checksumtype=="adler32"):
5738    catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5739   elif(checksumtype=="crc32"):
5740    catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5741   elif(checksumtype=="crc64_ecma"):
5742    catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5743   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5744    catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5745   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5746    checksumoutstr = hashlib.new(checksumtype);
5747    checksumoutstr.update(fileheader.encode('UTF-8'));
5748    catfileheadercshex = checksumoutstr.hexdigest().lower();
5749   else:
5750    catfileheadercshex = format(0, 'x').lower();
5751   fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
5752   fheadtell = len(fileheader);
5753   catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
5754   for member in sorted(rarfp.infolist(), key=lambda x: x.filename):
5755    is_unix = False;
5756    is_windows = False;
5757    if(member.host_os==rarfile.RAR_OS_UNIX):
5758     is_windows = False;
5759     try:
5760      member.external_attr
5761      is_unix = True;
5762     except AttributeError:
5763      is_unix = False;
5764    elif(member.host_os==rarfile.RAR_OS_WIN32):
5765     is_unix = False;
5766     try:
5767      member.external_attr
5768      is_windows = True;
5769     except AttributeError:
5770      is_windows = False;
5771    else:
5772     is_unix = False;
5773     is_windows = False;
5774    if(re.findall("^[.|/]", member.filename)):
5775     fname = member.filename;
5776    else:
5777     fname = "./"+member.filename;
5778    rarinfo = rarfp.getinfo(member.filename);
5779    if(verbose):
5780     VerbosePrintOut(fname);
5781    if(is_unix and member.external_attr !=0):
5782     fpremode = int(member.external_attr);
5783    elif(member.is_file()):
5784     fpremode = stat.S_IFREG + 438;
5785    elif(member.is_symlink()):
5786     fpremode = stat.S_IFLNK + 438;
5787    elif(member.is_dir()):
5788     fpremode = stat.S_IFDIR + 511;
5789    if(is_windows and member.external_attr !=0):
5790     fwinattributes = int(member.external_attr);
5791    else:
5792     fwinattributes = int(0);
5793    flinkcount = 0;
5794    ftype = 0;
5795    if(member.is_file()):
5796     ftype = 0;
5797    elif(member.is_symlink()):
5798     ftype = 2;
5799    elif(member.is_dir()):
5800     ftype = 5;
5801    flinkname = "";
5802    if(ftype==2):
5803     flinkname = rarfp.read(member.filename).decode("UTF-8");
5804    fbasedir = os.path.dirname(fname);
5805    fcurfid = curfid;
5806    fcurinode = curfid;
5807    finode = fcurinode;
5808    curfid = curfid + 1;
5809    fdev_minor = 0;
5810    fdev_major = 0;
5811    frdev_minor = 0;
5812    frdev_major = 0;
5813    if(ftype==5):
5814     fsize = "0";
5815    if(ftype==0):
5816     fsize = member.file_size;
5817    try:
5818     if(member.atime):
5819      fatime = int(member.atime.timestamp());
5820     else:
5821      fatime = int(member.mtime.timestamp());
5822    except AttributeError:
5823     fatime = int(member.mtime.timestamp());
5824    fmtime = int(member.mtime.timestamp());
5825    try:
5826     if(member.ctime):
5827      fctime = int(member.ctime.timestamp());
5828     else:
5829      fctime = int(member.mtime.timestamp());
5830    except AttributeError:
5831     fctime = int(member.mtime.timestamp());
5832    fbtime = int(member.mtime.timestamp());
5833    if(is_unix and member.external_attr !=0):
5834     fmode = int(member.external_attr);
5835     fchmode = int(stat.S_IMODE(member.external_attr));
5836     ftypemod = int(stat.S_IFMT(member.external_attr));
5837    elif(member.is_file()):
5838     fmode = int(stat.S_IFREG + 438)
5839     fchmode = int(stat.S_IMODE(stat.S_IFREG + 438));
5840     ftypemod = int(stat.S_IFMT(stat.S_IFREG + 438));
5841    elif(member.is_symlink()):
5842     fmode = int(stat.S_IFLNK + 438)
5843     fchmode = int(stat.S_IMODE(stat.S_IFREG + 438));
5844     ftypemod = int(stat.S_IFMT(stat.S_IFREG + 438));
5845    elif(member.is_dir()):
5846     fmode = int(stat.S_IFDIR + 511)
5847     fchmode = int(stat.S_IMODE(stat.S_IFDIR + 511));
5848     ftypemod = int(stat.S_IFMT(stat.S_IFDIR + 511));
5849    try:
5850     fuid = os.getuid();
5851    except AttributeError:
5852     fuid = 0;
5853    except KeyError:
5854     fuid = 0;
5855    try:
5856     fgid = os.getgid();
5857    except AttributeError:
5858     fgid = 0;
5859    except KeyError:
5860     fgid = 0;
5861    try:
5862     import pwd;
5863     try:
5864      userinfo = pwd.getpwuid(os.getuid());
5865      funame = userinfo.pw_name;
5866     except KeyError:
5867      funame = "";
5868     except AttributeError:
5869      funame = "";
5870    except ImportError:
5871     funame = "";
5872    fgname = "";
5873    try:
5874     import grp;
5875     try:
5876      groupinfo = grp.getgrgid(os.getgid());
5877      fgname = groupinfo.gr_name;
5878     except KeyError:
5879      fgname = "";
5880     except AttributeError:
5881      fgname = "";
5882    except ImportError:
5883     fgname = "";
5884    fcontents = "".encode('UTF-8');
5885    if(ftype==0):
5886     fcontents = rarfp.read(member.filename);
5887    ftypehex = format(ftype, 'x').lower();
5888    extrafields = len(extradata);
5889    extrafieldslist = extradata;
5890    catfextrafields = extrafields;
5891    extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
5892    if(len(extradata)>0):
5893     extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
5894    extrasizelen = len(extrasizestr);
5895    extrasizelenhex = format(extrasizelen, 'x').lower();
5896    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()];
5897    catoutlen = len(catoutlist) + len(extradata) + 3;
5898    catoutlenhex = format(catoutlen, 'x').lower();
5899    catoutlist.insert(0, catoutlenhex);
5900    catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
5901    if(len(extradata)>0):
5902     catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
5903    catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
5904    catfnumfields = 24 + catfextrafields;
5905    if(checksumtype=="none" or checksumtype==""):
5906     catfileheadercshex = format(0, 'x').lower();
5907     catfilecontentcshex = format(0, 'x').lower();
5908    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5909     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5910     catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
5911    elif(checksumtype=="crc16_ccitt"):
5912     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5913     catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
5914    elif(checksumtype=="adler32"):
5915     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5916     catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
5917    elif(checksumtype=="crc32"):
5918     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5919     catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
5920    elif(checksumtype=="crc64_ecma"):
5921     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5922     catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
5923    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5924     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5925     catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
5926    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5927     checksumoutstr = hashlib.new(checksumtype);
5928     checksumoutstr.update(catfileoutstr.encode('UTF-8'));
5929     catfileheadercshex = checksumoutstr.hexdigest().lower();
5930    else:
5931     catfileheadercshex = format(0, 'x').lower();
5932     catfilecontentcshex = format(0, 'x').lower();
5933    catfhstart = fheadtell;
5934    fheadtell += len(catfileoutstr);
5935    catfhend = fheadtell - 1;
5936    catfcontentstart = fheadtell;
5937    tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5938    catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
5939    catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
5940    catheaderdata = [catheaersize] + catoutlist + extradata + [checksumtype, catfileheadercshex, catfilecontentcshex];
5941    if(checksumtype=="none" or checksumtype==""):
5942     catfileheadercshex = format(0, 'x').lower();
5943    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5944     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5945    elif(checksumtype=="crc16_ccitt"):
5946     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5947    elif(checksumtype=="adler32"):
5948     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5949    elif(checksumtype=="crc32"):
5950     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5951    elif(checksumtype=="crc64_ecma"):
5952     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5953    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5954     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5955    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5956     checksumoutstr = hashlib.new(checksumtype);
5957     checksumoutstr.update(catfileoutstr.encode('UTF-8'));
5958     catfileheadercshex = checksumoutstr.hexdigest().lower();
5959    else:
5960     catfileheadercshex = format(0, 'x').lower();
5961    catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5962    catfileoutstrecd = catfileoutstr.encode('UTF-8');
5963    nullstrecd = formatspecs[5].encode('UTF-8');
5964    fheadtell += len(catfileoutstr) + 1;
5965    catfcontentend = fheadtell - 1;
5966    catfileout = catfileoutstrecd + fcontents + nullstrecd;
5967    pyhascontents = False;
5968    if(int(fsize)>0 and not listonly):
5969     pyhascontents = True;
5970    if(int(fsize)>0 and listonly):
5971     fcontents = "";
5972     pyhascontents = False;
5973    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} });
5974    fileidnum = fileidnum + 1;
5975   return catlist;
5976
5977 if(not py7zr_support):
5978  def SevenZipFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5979   return False;
5980
5981 if(py7zr_support):
5982  def SevenZipFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5983   curinode = 0;
5984   curfid = 0;
5985   inodelist = [];
5986   inodetofile = {};
5987   filetoinode = {};
5988   inodetocatinode = {};
5989   fileidnum = 0;
5990   szpfp = py7zr.SevenZipFile(infile, mode="r");
5991   file_content = szpfp.readall();
5992   #sztest = szpfp.testzip();
5993   sztestalt = szpfp.test();
5994   if(sztestalt):
5995    VerbosePrintOut("Bad file found!");
5996   numfiles = int(len(szpfp.list()));
5997   catver = formatspecs[6];
5998   fileheaderver = str(int(catver.replace(".", "")));
5999   fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
6000   catversion = re.findall(r"([\d]+)$", fileheader);
6001   catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
6002   fnumfileshex = format(int(fnumfiles), 'x').lower();
6003   fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
6004   if(checksumtype=="none" or checksumtype==""):
6005    catfileheadercshex = format(0, 'x').lower();
6006   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
6007    catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
6008   elif(checksumtype=="crc16_ccitt"):
6009    catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
6010   elif(checksumtype=="adler32"):
6011    catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
6012   elif(checksumtype=="crc32"):
6013    catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
6014   elif(checksumtype=="crc64_ecma"):
6015    catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6016   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
6017    catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6018   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
6019    checksumoutstr = hashlib.new(checksumtype);
6020    checksumoutstr.update(fileheader.encode('UTF-8'));
6021    catfileheadercshex = checksumoutstr.hexdigest().lower();
6022   else:
6023    catfileheadercshex = format(0, 'x').lower();
6024   fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
6025   fheadtell = len(fileheader);
6026   catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
6027   for member in sorted(szpfp.list(), key=lambda x: x.filename):
6028    if(re.findall("^[.|/]", member.filename)):
6029     fname = member.filename;
6030    else:
6031     fname = "./"+member.filename;
6032    if(not member.is_directory):
6033     fpremode = int(stat.S_IFREG + 438);
6034    elif(member.is_directory):
6035     fpremode = int(stat.S_IFDIR + 511);
6036    fwinattributes = int(0);
6037    flinkcount = 0;
6038    ftype = 0;
6039    if(member.is_directory):
6040     ftype = 5;
6041    else:
6042     ftype = 0;
6043    flinkname = "";
6044    fbasedir = os.path.dirname(fname);
6045    fcurfid = curfid;
6046    fcurinode = curfid;
6047    finode = fcurinode;
6048    curfid = curfid + 1;
6049    fdev_minor = 0;
6050    fdev_major = 0;
6051    frdev_minor = 0;
6052    frdev_major = 0;
6053    if(ftype==5):
6054     fsize = "0";
6055    fatime = int(member.creationtime.timestamp());
6056    fmtime = int(member.creationtime.timestamp());
6057    fctime = int(member.creationtime.timestamp());
6058    fbtime = int(member.creationtime.timestamp());
6059    if(member.is_directory):
6060     fmode = int(stat.S_IFDIR + 511)
6061     fchmode = int(stat.S_IMODE(stat.S_IFDIR + 511));
6062     ftypemod = int(stat.S_IFMT(stat.S_IFDIR + 511));
6063    else:
6064     fmode = int(stat.S_IFLNK + 438)
6065     fchmode = int(stat.S_IMODE(stat.S_IFREG + 438));
6066     ftypemod = int(stat.S_IFMT(stat.S_IFREG + 438));
6067    try:
6068     fuid = os.getuid();
6069    except AttributeError:
6070     fuid = 0;
6071    except KeyError:
6072     fuid = 0;
6073    try:
6074     fgid = os.getgid();
6075    except AttributeError:
6076     fgid = 0;
6077    except KeyError:
6078     fgid = 0;
6079    try:
6080     import pwd;
6081     try:
6082      userinfo = pwd.getpwuid(os.getuid());
6083      funame = userinfo.pw_name;
6084     except KeyError:
6085      funame = "";
6086     except AttributeError:
6087      funame = "";
6088    except ImportError:
6089     funame = "";
6090    fgname = "";
6091    try:
6092     import grp;
6093     try:
6094      groupinfo = grp.getgrgid(os.getgid());
6095      fgname = groupinfo.gr_name;
6096     except KeyError:
6097      fgname = "";
6098     except AttributeError:
6099      fgname = "";
6100    except ImportError:
6101     fgname = "";
6102    fcontents = "".encode('UTF-8');
6103    if(ftype==0):
6104     fcontents = file_content[member.filename].read();
6105     fsize = format(len(fcontents), 'x').lower();
6106     fileop.close();
6107    ftypehex = format(ftype, 'x').lower();
6108    extrafields = len(extradata);
6109    extrafieldslist = extradata;
6110    catfextrafields = extrafields;
6111    extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
6112    if(len(extradata)>0):
6113     extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
6114    extrasizelen = len(extrasizestr);
6115    extrasizelenhex = format(extrasizelen, 'x').lower();
6116    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()];
6117    catoutlen = len(catoutlist) + len(extradata) + 3;
6118    catoutlenhex = format(catoutlen, 'x').lower();
6119    catoutlist.insert(0, catoutlenhex);
6120    catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
6121    if(len(extradata)>0):
6122     catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
6123    catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
6124    catfnumfields = 24 + catfextrafields;
6125    if(checksumtype=="none" or checksumtype==""):
6126     catfileheadercshex = format(0, 'x').lower();
6127     catfilecontentcshex = format(0, 'x').lower();
6128    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
6129     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6130     catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
6131    elif(checksumtype=="crc16_ccitt"):
6132     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6133     catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
6134    elif(checksumtype=="adler32"):
6135     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6136     catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
6137    elif(checksumtype=="crc32"):
6138     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6139     catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
6140    elif(checksumtype=="crc64_ecma"):
6141     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6142     catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
6143    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
6144     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6145     catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
6146    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
6147     checksumoutstr = hashlib.new(checksumtype);
6148     checksumoutstr.update(catfileoutstr.encode('UTF-8'));
6149     catfileheadercshex = checksumoutstr.hexdigest().lower();
6150    else:
6151     catfileheadercshex = format(0, 'x').lower();
6152     catfilecontentcshex = format(0, 'x').lower();
6153    catfhstart = fheadtell;
6154    fheadtell += len(catfileoutstr);
6155    catfhend = fheadtell - 1;
6156    catfcontentstart = fheadtell;
6157    tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
6158    catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
6159    catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
6160    catheaderdata = [catheaersize] + catoutlist + extradata + [checksumtype, catfileheadercshex, catfilecontentcshex];
6161    if(checksumtype=="none" or checksumtype==""):
6162     catfileheadercshex = format(0, 'x').lower();
6163    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
6164     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6165    elif(checksumtype=="crc16_ccitt"):
6166     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6167    elif(checksumtype=="adler32"):
6168     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6169    elif(checksumtype=="crc32"):
6170     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6171    elif(checksumtype=="crc64_ecma"):
6172     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6173    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
6174     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6175    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
6176     checksumoutstr = hashlib.new(checksumtype);
6177     checksumoutstr.update(catfileoutstr.encode('UTF-8'));
6178     catfileheadercshex = checksumoutstr.hexdigest().lower();
6179    else:
6180     catfileheadercshex = format(0, 'x').lower();
6181    catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
6182    catfileoutstrecd = catfileoutstr.encode('UTF-8');
6183    nullstrecd = formatspecs[5].encode('UTF-8');
6184    fheadtell += len(catfileoutstr) + 1;
6185    catfcontentend = fheadtell - 1;
6186    catfileout = catfileoutstrecd + fcontents + nullstrecd;
6187    pyhascontents = False;
6188    if(int(fsize)>0 and not listonly):
6189     pyhascontents = True;
6190    if(int(fsize)>0 and listonly):
6191     fcontents = "";
6192     pyhascontents = False;
6193    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} });
6194    fileidnum = fileidnum + 1;
6195   return catlist;
6196
6197 def InFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6198  checkcompressfile = CheckCompressionSubType(infiles, formatspecs, True);
6199  if(checkcompressfile=="tarfile"):
6200   return TarFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6201  elif(checkcompressfile=="zipfile"):
6202   return ZipFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6203  elif(checkcompressfile=="catfile"):
6204   return ArchiveFileToArray(infile, 0, 0, listonly, False, formatspecs, False);
6205  elif(rarfile_support and checkcompressfile=="rarfile"):
6206   return RarFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6207  elif(py7zr_support and checkcompressfile=="7zipfile"):
6208   return SevenZipFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6209  else:
6210   return False;
6211  return False;
6212
6213 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):
6214  outarray = BytesIO();
6215  packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, True);
6216  listcatfiles = ArchiveFileToArray(outarray, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6217  return listcatfiles;
6218
6219 def ArchiveFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6220  if(isinstance(infile, dict)):
6221   listcatfiles = infile;
6222  else:
6223   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
6224    infile = RemoveWindowsPath(infile);
6225   listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6226  if(not listcatfiles):
6227   return False;
6228  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': {}}}};
6229  if(returnfp):
6230   catarray.update({'catfp': listcatfiles['catfp']});
6231  lenlist = len(listcatfiles['ffilelist']);
6232  lcfi = 0;
6233  lcfx = int(listcatfiles['fnumfiles']);
6234  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6235   lcfx = int(lenlist);
6236  else:
6237   lcfx = int(listcatfiles['fnumfiles']);
6238  while(lcfi < lcfx):
6239   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6240   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6241   catarray['filetoid'].update(filetoidarray);
6242   catarray['idtofile'].update(idtofilearray);
6243   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6244    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6245    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6246   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6247    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6248    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6249    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6250    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6251   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6252    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6253    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6254    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6255    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6256   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6257    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6258    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6259    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6260    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6261   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6262    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6263    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6264    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6265    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6266   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6267    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6268    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6269   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6270    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6271    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6272    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6273    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6274   lcfi = lcfi + 1;
6275  return catarray;
6276
6277 create_alias_function("", __file_format_name__, "ToArrayIndex", ArchiveFileToArrayIndex);
6278
6279 def ListDirToArrayIndexAlt(infiles, dirlistfromtxt=False, followlink=False, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6280  listcatfiles = ListDirToArrayAlt(infiles, dirlistfromtxt, followlink, listonly, checksumtype, extradata, formatspecs, verbose);
6281  if(not listcatfiles):
6282   return False;
6283  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': {}}}};
6284  lenlist = len(listcatfiles['ffilelist']);
6285  lcfi = 0;
6286  lcfx = int(listcatfiles['fnumfiles']);
6287  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6288   lcfx = int(lenlist);
6289  else:
6290   lcfx = int(listcatfiles['fnumfiles']);
6291  while(lcfi < lcfx):
6292   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6293   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6294   catarray['filetoid'].update(filetoidarray);
6295   catarray['idtofile'].update(idtofilearray);
6296   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6297    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6298    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6299   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6300    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6301    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6302    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6303    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6304   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6305    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6306    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6307    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6308    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6309   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6310    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6311    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6312    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6313    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6314   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6315    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6316    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6317    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6318    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6319   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6320    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6321    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6322   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6323    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6324    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6325    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6326    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6327   lcfi = lcfi + 1;
6328  return catarray;
6329
6330 def TarFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6331  listcatfiles = TarFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6332  if(not listcatfiles):
6333   return False;
6334  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': {}}}};
6335  lenlist = len(listcatfiles['ffilelist']);
6336  lcfi = 0;
6337  lcfx = int(listcatfiles['fnumfiles']);
6338  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6339   lcfx = int(lenlist);
6340  else:
6341   lcfx = int(listcatfiles['fnumfiles']);
6342  while(lcfi < lcfx):
6343   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6344   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6345   catarray['filetoid'].update(filetoidarray);
6346   catarray['idtofile'].update(idtofilearray);
6347   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6348    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6349    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6350   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6351    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6352    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6353    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6354    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6355   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6356    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6357    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6358    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6359    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6360   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6361    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6362    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6363    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6364    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6365   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6366    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6367    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6368    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6369    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6370   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6371    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6372    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6373   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6374    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6375    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6376    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6377    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6378   lcfi = lcfi + 1;
6379  return catarray;
6380
6381 def ZipFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6382  listcatfiles = ZipFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6383  if(not listcatfiles):
6384   return False;
6385  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': {}}}};
6386  lenlist = len(listcatfiles['ffilelist']);
6387  lcfi = 0;
6388  lcfx = int(listcatfiles['fnumfiles']);
6389  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6390   lcfx = int(lenlist);
6391  else:
6392   lcfx = int(listcatfiles['fnumfiles']);
6393  while(lcfi < lcfx):
6394   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6395   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6396   catarray['filetoid'].update(filetoidarray);
6397   catarray['idtofile'].update(idtofilearray);
6398   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6399    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6400    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6401   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6402    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6403    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6404    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6405    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6406   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6407    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6408    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6409    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6410    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6411   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6412    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6413    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6414    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6415    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6416   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6417    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6418    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6419    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6420    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6421   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6422    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6423    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6424   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6425    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6426    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6427    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6428    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6429   lcfi = lcfi + 1;
6430  return catarray;
6431
6432 if(not rarfile_support):
6433  def RarFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6434   return False;
6435
6436 if(rarfile_support):
6437  def RarFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6438   listcatfiles = RarFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6439   if(not listcatfiles):
6440    return False;
6441   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': {}}}};
6442   lenlist = len(listcatfiles['ffilelist']);
6443   lcfi = 0;
6444   lcfx = int(listcatfiles['fnumfiles']);
6445   if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6446    lcfx = int(lenlist);
6447   else:
6448    lcfx = int(listcatfiles['fnumfiles']);
6449   while(lcfi < lcfx):
6450    filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6451    idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6452    catarray['filetoid'].update(filetoidarray);
6453    catarray['idtofile'].update(idtofilearray);
6454    if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6455     catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6456     catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6457    if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6458     catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6459     catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6460     catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6461     catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6462    if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6463     catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6464     catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6465     catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6466     catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6467    if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6468     catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6469     catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6470     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6471     catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6472    if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6473     catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6474     catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6475     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6476    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6477    if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6478     catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6479     catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6480    if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6481     catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6482     catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6483     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6484     catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6485    lcfi = lcfi + 1;
6486   return catarray;
6487
6488 if(not py7zr_support):
6489  def SevenZipFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6490   return False;
6491
6492 if(py7zr_support):
6493  def SevenZipFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6494   listcatfiles = SevenZipFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6495   if(not listcatfiles):
6496    return False;
6497   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': {}}}};
6498   lenlist = len(listcatfiles['ffilelist']);
6499   lcfi = 0;
6500   lcfx = int(listcatfiles['fnumfiles']);
6501   if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6502    lcfx = int(lenlist);
6503   else:
6504    lcfx = int(listcatfiles['fnumfiles']);
6505   while(lcfi < lcfx):
6506    filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6507    idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6508    catarray['filetoid'].update(filetoidarray);
6509    catarray['idtofile'].update(idtofilearray);
6510    if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6511     catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6512     catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6513    if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6514     catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6515     catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6516     catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6517     catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6518    if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6519     catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6520     catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6521     catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6522     catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6523    if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6524     catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6525     catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6526     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6527     catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6528    if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6529     catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6530     catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6531     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6532    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6533    if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6534     catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6535     catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6536    if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6537     catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6538     catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6539     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6540     catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6541    lcfi = lcfi + 1;
6542   return catarray;
6543
6544 def ArchiveFileStringToArrayIndex(catstr, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6545  catfp = BytesIO(catstr);
6546  listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6547  return listcatfiles;
6548
6549 create_alias_function("", __file_format_name__, "StringToArrayIndex", ArchiveFileStringToArrayIndex);
6550
6551 def TarFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6552  catfp = BytesIO();
6553  catfp = PackArchiveFileFromTarFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
6554  listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6555  return listcatfiles;
6556
6557 def ZipFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6558  catfp = BytesIO();
6559  catfp = PackArchiveFileFromZipFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
6560  listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6561  return listcatfiles;
6562
6563 if(not rarfile_support):
6564  def RarFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6565   return False;
6566
6567 if(rarfile_support):
6568  def RarFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6569   catfp = BytesIO();
6570   catfp = PackArchiveFileFromRarFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
6571   listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6572   return listcatfiles;
6573
6574 if(not py7zr_support):
6575  def SevenZipFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6576   return False;
6577
6578 if(py7zr_support):
6579  def SevenZipFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6580   catfp = BytesIO();
6581   catfp = PackArchiveFileFromSevenZipFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
6582   listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6583   return listcatfiles;
6584
6585 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):
6586  outarray = BytesIO();
6587  packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, formatspecs, verbose, True);
6588  listcatfiles = ArchiveFileToArrayIndex(outarray, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp)
6589  return listcatfiles;
6590
6591 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):
6592  if(isinstance(infile, dict)):
6593   prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6594   listcatfiles = prelistcatfiles['list'];
6595  else:
6596   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
6597    infile = RemoveWindowsPath(infile);
6598   if(followlink):
6599    prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6600    listcatfiles = prelistcatfiles['list'];
6601   else:
6602    listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6603  if(outfile!="-" and not hasattr(infile, "read") and not hasattr(outfile, "write")):
6604   outfile = RemoveWindowsPath(outfile);
6605  checksumtype = checksumtype.lower();
6606  if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
6607   checksumtype="crc32";
6608  if(checksumtype=="none"):
6609   checksumtype = "";
6610  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
6611   compression = None;
6612  if(compression not in compressionlist and compression is None):
6613   compression = "auto";
6614  if(verbose):
6615   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
6616  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
6617   if(os.path.exists(outfile)):
6618    os.unlink(outfile);
6619  if(not listcatfiles):
6620   return False;
6621  if(outfile=="-"):
6622   verbose = False;
6623   catfp = BytesIO();
6624  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
6625   catfp = outfile;
6626  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
6627   catfp = BytesIO();
6628  else:
6629   fbasename = os.path.splitext(outfile)[0];
6630   fextname = os.path.splitext(outfile)[1];
6631   catfp = CompressOpenFile(outfile, compressionlevel);
6632  catver = formatspecs[6];
6633  fileheaderver = str(int(catver.replace(".", "")));
6634  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
6635  catfp.write(fileheader.encode('UTF-8'));
6636  lenlist = len(listcatfiles['ffilelist']);
6637  fnumfiles = int(listcatfiles['fnumfiles']);
6638  if(lenlist>fnumfiles or lenlist<fnumfiles):
6639   fnumfiles = lenlist;
6640  fnumfileshex = format(int(fnumfiles), 'x').lower();
6641  fnumfilesa = AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
6642  if(checksumtype=="none" or checksumtype==""):
6643   catfileheadercshex = format(0, 'x').lower();
6644  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
6645   catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
6646  elif(checksumtype=="crc16_ccitt"):
6647   catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
6648  elif(checksumtype=="adler32"):
6649   catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
6650  elif(checksumtype=="crc32"):
6651   catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
6652  elif(checksumtype=="crc64_ecma"):
6653   catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6654  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
6655   catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6656  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
6657   checksumoutstr = hashlib.new(checksumtype);
6658   checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
6659   catfileheadercshex = checksumoutstr.hexdigest().lower();
6660  else:
6661   catfileheadercshex = format(0, 'x').lower();
6662  fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
6663  catfp.write(fnumfilesa.encode('UTF-8'));
6664  try:
6665   catfp.flush();
6666   os.fsync(catfp.fileno());
6667  except io.UnsupportedOperation:
6668   pass;
6669  except AttributeError:
6670   pass;
6671  lenlist = len(listcatfiles['ffilelist']);
6672  fnumfiles = int(listcatfiles['fnumfiles']);
6673  lcfi = 0;
6674  lcfx = int(listcatfiles['fnumfiles']);
6675  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6676   lcfx = int(lenlist);
6677  else:
6678   lcfx = int(listcatfiles['fnumfiles']);
6679  curinode = 0;
6680  curfid = 0;
6681  inodelist = [];
6682  inodetofile = {};
6683  filetoinode = {};
6684  reallcfi = 0;
6685  while(lcfi < lcfx):
6686   catfhstart = catfp.tell();
6687   if(re.findall("^[.|/]", listcatfiles['ffilelist'][reallcfi]['fname'])):
6688    fname = listcatfiles['ffilelist'][reallcfi]['fname'];
6689   else:
6690    fname = "./"+listcatfiles['ffilelist'][reallcfi]['fname'];
6691   if(verbose):
6692    VerbosePrintOut(fname);
6693   fheadersize = format(int(listcatfiles['ffilelist'][reallcfi]['fheadersize']), 'x').lower();
6694   fsize = format(int(listcatfiles['ffilelist'][reallcfi]['fsize']), 'x').lower();
6695   flinkname = listcatfiles['ffilelist'][reallcfi]['flinkname'];
6696   fatime = format(int(listcatfiles['ffilelist'][reallcfi]['fatime']), 'x').lower();
6697   fmtime = format(int(listcatfiles['ffilelist'][reallcfi]['fmtime']), 'x').lower();
6698   fctime = format(int(listcatfiles['ffilelist'][reallcfi]['fctime']), 'x').lower();
6699   fbtime = format(int(listcatfiles['ffilelist'][reallcfi]['fbtime']), 'x').lower();
6700   fmode = format(int(listcatfiles['ffilelist'][reallcfi]['fmode']), 'x').lower();
6701   fchmode = format(int(listcatfiles['ffilelist'][reallcfi]['fchmode']), 'x').lower();
6702   fuid = format(int(listcatfiles['ffilelist'][reallcfi]['fuid']), 'x').lower();
6703   funame = listcatfiles['ffilelist'][reallcfi]['funame'];
6704   fgid = format(int(listcatfiles['ffilelist'][reallcfi]['fgid']), 'x').lower();
6705   fgname = listcatfiles['ffilelist'][reallcfi]['fgname'];
6706   finode = listcatfiles['ffilelist'][reallcfi]['finode'];
6707   flinkcount = listcatfiles['ffilelist'][reallcfi]['flinkcount'];
6708   fwinattributes = flinkinfo['ffilelist'][reallcfi]['fwinattributes'];
6709   fdev_minor = format(int(listcatfiles['ffilelist'][reallcfi]['fminor']), 'x').lower();
6710   fdev_major = format(int(listcatfiles['ffilelist'][reallcfi]['fmajor']), 'x').lower();
6711   frdev_minor = format(int(listcatfiles['ffilelist'][reallcfi]['frminor']), 'x').lower();
6712   frdev_major = format(int(listcatfiles['ffilelist'][reallcfi]['frmajor']), 'x').lower();
6713   if(len(listcatfiles['ffilelist'][reallcfi]['fextralist'])>listcatfiles['ffilelist'][reallcfi]['fextrafields'] and len(listcatfiles['ffilelist'][reallcfi]['fextralist'])>0):
6714    listcatfiles['ffilelist'][reallcfi]['fextrafields'] = len(listcatfiles['ffilelist'][reallcfi]['fextralist']);
6715   if(len(extradata)>0):
6716    listcatfiles['ffilelist'][reallcfi]['fextrafields'] = len(extradata);
6717    listcatfiles['ffilelist'][reallcfi]['fextralist'] = extradata;
6718   extrafields = format(int(listcatfiles['ffilelist'][reallcfi]['fextrafields']), 'x').lower();
6719   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
6720   if(len(extradata)>0):
6721    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
6722   extrasizelen = format(len(extrasizestr), 'x').lower();
6723   fcontents = listcatfiles['ffilelist'][reallcfi]['fcontents'];
6724   if(followlink):
6725    if(listcatfiles['ffilelist'][reallcfi]['ftype']==1 or listcatfiles['ffilelist'][reallcfi]['ftype']==2):
6726     getflinkpath = listcatfiles['ffilelist'][reallcfi]['flinkname'];
6727     flinkid = prelistcatfiles['filetoid'][getflinkpath];
6728     flinkinfo = listcatfiles['ffilelist'][flinkid];
6729     fheadersize = format(int(flinkinfo['fheadersize']), 'x').lower();
6730     fsize = format(int(flinkinfo['fsize']), 'x').lower();
6731     flinkname = flinkinfo['flinkname'];
6732     fatime = format(int(flinkinfo['fatime']), 'x').lower();
6733     fmtime = format(int(flinkinfo['fmtime']), 'x').lower();
6734     fctime = format(int(flinkinfo['fctime']), 'x').lower();
6735     fbtime = format(int(flinkinfo['fbtime']), 'x').lower();
6736     fmode = format(int(flinkinfo['fmode']), 'x').lower();
6737     fchmode = format(int(flinkinfo['fchmode']), 'x').lower();
6738     fuid = format(int(flinkinfo['fuid']), 'x').lower();
6739     funame = flinkinfo['funame'];
6740     fgid = format(int(flinkinfo['fgid']), 'x').lower();
6741     fgname = flinkinfo['fgname'];
6742     finode = flinkinfo['finode'];
6743     flinkcount = flinkinfo['flinkcount'];
6744     fwinattributes = flinkinfo['fwinattributes'];
6745     fdev_minor = format(int(flinkinfo['fminor']), 'x').lower();
6746     fdev_major = format(int(flinkinfo['fmajor']), 'x').lower();
6747     frdev_minor = format(int(flinkinfo['frminor']), 'x').lower();
6748     frdev_major = format(int(flinkinfo['frmajor']), 'x').lower();
6749     if(len(flinkinfo['fextralist'])>flinkinfo['fextrafields'] and len(flinkinfo['fextralist'])>0):
6750      flinkinfo['fextrafields'] = len(flinkinfo['fextralist']);
6751     if(len(extradata)>0):
6752      flinkinfo['fextrafields'] = len(extradata);
6753      flinkinfo['fextralist'] = extradata;
6754     extrafields = format(int(flinkinfo['fextrafields']), 'x').lower();
6755     extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
6756     if(len(extradata)>0):
6757      extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
6758     extrasizelen = format(len(extrasizestr), 'x').lower();
6759     fcontents = flinkinfo['fcontents'];
6760     if(flinkinfo['ftype']!=0 and flinkinfo['ftype']!=7):
6761      try:
6762       fcontents = fcontents.encode('UTF-8');
6763      except AttributeError:
6764       pass;
6765     ftypehex = format(flinkinfo['ftype'], 'x').lower();
6766   else:
6767    if(listcatfiles['ffilelist'][reallcfi]['ftype']!=0 and listcatfiles['ffilelist'][reallcfi]['ftype']!=7):
6768     try:
6769      fcontents = fcontents.encode('UTF-8');
6770     except AttributeError:
6771      pass;
6772    ftypehex = format(listcatfiles['ffilelist'][reallcfi]['ftype'], 'x').lower();
6773   fcurfid = format(curfid, 'x').lower();
6774   if(not followlink and finode!=0):
6775    if(listcatfiles['ffilelist'][reallcfi]['ftype']!=1):
6776     fcurinode = format(int(curinode), 'x').lower();
6777     inodetofile.update({curinode: fname});
6778     filetoinode.update({fname: curinode});
6779     curinode = curinode + 1;
6780    else:
6781     fcurinode = format(int(filetoinode[flinkname]), 'x').lower();
6782   else:
6783     fcurinode = format(int(curinode), 'x').lower();
6784     curinode = curinode + 1;
6785   curfid = curfid + 1;
6786   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];
6787   catoutlen = len(catoutlist) + len(extradata) + 3;
6788   catoutlenhex = format(catoutlen, 'x').lower();
6789   catoutlist.insert(0, catoutlenhex);
6790   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
6791   if(listcatfiles['ffilelist'][reallcfi]['fextrafields']>0):
6792    extrafieldslist = [];
6793    exi = 0;
6794    exil = listcatfiles['ffilelist'][reallcfi]['fextrafields'];
6795    while(exi<exil):
6796     extrafieldslist.append(listcatfiles['ffilelist'][reallcfi]['fextralist']);
6797     exi = exi + 1;
6798    catfileoutstr += AppendNullBytes([extrafieldslist], formatspecs[5]);
6799   catfileoutstr += AppendNullBytes([checksumtype], formatspecs[5]);
6800   catfhend = (catfp.tell() - 1) + len(catfileoutstr);
6801   catfcontentstart = catfp.tell() + len(catfileoutstr);
6802   if(checksumtype=="none" or checksumtype==""):
6803    catfileheadercshex = format(0, 'x').lower();
6804    catfilecontentcshex = format(0, 'x').lower();
6805   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
6806    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
6807    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
6808   elif(checksumtype=="crc16_ccitt"):
6809    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
6810    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
6811   elif(checksumtype=="adler32"):
6812    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
6813    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
6814   elif(checksumtype=="crc32"):
6815    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
6816    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
6817   elif(checksumtype=="crc64_ecma"):
6818    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6819    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
6820   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
6821    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6822    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
6823   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
6824    checksumoutstr = hashlib.new(checksumtype);
6825    checksumoutstr.update("".encode('UTF-8'));
6826    catfileheadercshex = checksumoutstr.hexdigest().lower();
6827    checksumoutstr = hashlib.new(checksumtype);
6828    checksumoutstr.update(fcontents);
6829    catfilecontentcshex = checksumoutstr.hexdigest().lower();
6830   else:
6831    catfileheadercshex = format(0, 'x').lower();
6832    catfilecontentcshex = format(0, 'x').lower();
6833   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
6834   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
6835   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
6836   if(checksumtype=="none" or checksumtype==""):
6837    catfileheadercshex = format(0, 'x').lower();
6838   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
6839    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6840   elif(checksumtype=="crc16_ccitt"):
6841    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6842   elif(checksumtype=="adler32"):
6843    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6844   elif(checksumtype=="crc32"):
6845    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6846   elif(checksumtype=="crc64_ecma"):
6847    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6848   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
6849    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6850   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
6851    checksumoutstr = hashlib.new(checksumtype);
6852    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
6853    catfileheadercshex = checksumoutstr.hexdigest().lower();
6854   else:
6855    catfileheadercshex = format(0, 'x').lower();
6856   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
6857   catfileoutstrecd = catfileoutstr.encode('UTF-8');
6858   nullstrecd = formatspecs[5].encode('UTF-8');
6859   catfileout = catfileoutstrecd + fcontents + nullstrecd;
6860   catfcontentend = (catfp.tell() - 1) + len(catfileout);
6861   catfp.write(catfileout);
6862   try:
6863    catfp.flush();
6864    os.fsync(catfp.fileno());
6865   except io.UnsupportedOperation:
6866    pass;
6867   except AttributeError:
6868    pass;
6869   lcfi = lcfi + 1;
6870   reallcfi = reallcfi + 1;
6871  if(lcfx>0):
6872   catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
6873  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
6874   catfp = CompressArchiveFile(catfp, compression, formatspecs);
6875   try:
6876    catfp.flush();
6877    os.fsync(catfp.fileno());
6878   except io.UnsupportedOperation:
6879    pass;
6880   except AttributeError:
6881    pass;
6882  if(outfile=="-"):
6883   catfp.seek(0, 0);
6884   if(hasattr(sys.stdout, "buffer")):
6885    shutil.copyfileobj(catfp, sys.stdout.buffer);
6886   else:
6887    shutil.copyfileobj(catfp, sys.stdout);
6888  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
6889   catfp = CompressArchiveFile(catfp, compression, formatspecs);
6890   catfp.seek(0, 0);
6891   upload_file_to_internet_file(catfp, outfile);
6892  if(returnfp):
6893   catfp.seek(0, 0);
6894   return catfp;
6895  else:
6896   catfp.close();
6897   return True;
6898
6899 create_alias_function("RePack", __file_format_name__, "", RePackArchiveFile);
6900
6901 def RePackArchiveFileFromString(catstr, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", skipchecksum=False, extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
6902  catfp = BytesIO(catstr);
6903  listcatfiles = RePackArchiveFile(catfp, compression, compressionlevel, checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp);
6904  return listcatfiles;
6905
6906 create_alias_function("RePack", __file_format_name__, "FromString", RePackArchiveFileFromString);
6907
6908 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):
6909  outarray = BytesIO();
6910  packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, True);
6911  listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp);
6912  return listcatfiles;
6913
6914 create_alias_function("Pack", __file_format_name__, "FromListDir", PackArchiveFileFromListDir);
6915
6916 def ArchiveFileArrayBase64Encode(infile, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
6917  if(verbose):
6918   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
6919  if(isinstance(infile, dict)):
6920   prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6921   listcatfiles = prelistcatfiles['list'];
6922  else:
6923   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
6924    infile = RemoveWindowsPath(infile);
6925   if(followlink):
6926    prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6927    listcatfiles = prelistcatfiles['list'];
6928   else:
6929    listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6930  if(not listcatfiles):
6931   return False;
6932  lenlist = len(listcatfiles['ffilelist']);
6933  fnumfiles = int(listcatfiles['fnumfiles']);
6934  lcfi = 0;
6935  lcfx = int(listcatfiles['fnumfiles']);
6936  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6937   lcfx = int(lenlist);
6938  else:
6939   lcfx = int(listcatfiles['fnumfiles']);
6940  while(lcfi<lcfx):
6941   if(listcatfiles['ffilelist'][lcfi]['fhascontents']):
6942    listcatfiles['ffilelist'][lcfi]['fcontents'] = base64.b64encode(listcatfiles['ffilelist'][lcfi]['fcontents']).decode("UTF-8");
6943   lcfi = lcfi + 1;
6944  return listcatfiles;
6945
6946 create_alias_function("", __file_format_name__, "ArrayBase64Encode", ArchiveFileArrayBase64Encode);
6947
6948 def ArchiveFileArrayBase64Decode(infile, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
6949  if(verbose):
6950   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
6951  if(isinstance(infile, dict)):
6952   prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6953   listcatfiles = prelistcatfiles['list'];
6954  else:
6955   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
6956    infile = RemoveWindowsPath(infile);
6957   if(followlink):
6958    prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6959    listcatfiles = prelistcatfiles['list'];
6960   else:
6961    listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6962  if(not listcatfiles):
6963   return False;
6964  lenlist = len(listcatfiles['ffilelist']);
6965  fnumfiles = int(listcatfiles['fnumfiles']);
6966  lcfi = 0;
6967  lcfx = int(listcatfiles['fnumfiles']);
6968  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6969   lcfx = int(lenlist);
6970  else:
6971   lcfx = int(listcatfiles['fnumfiles']);
6972  while(lcfi<lcfx):
6973   if(listcatfiles['ffilelist'][lcfi]['fhascontents']):
6974    listcatfiles['ffilelist'][lcfi]['fcontents'] = base64.b64decode(listcatfiles['ffilelist'][lcfi]['fcontents'].encode("UTF-8"));
6975   lcfi = lcfi + 1;
6976  return listcatfiles;
6977
6978 create_alias_function("", __file_format_name__, "ArrayBase64Decode", ArchiveFileArrayBase64Decode);
6979
6980 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):
6981  if(outdir is not None):
6982   outdir = RemoveWindowsPath(outdir);
6983  if(verbose):
6984   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
6985  if(isinstance(infile, dict)):
6986   prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6987   listcatfiles = prelistcatfiles['list'];
6988  else:
6989   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
6990    infile = RemoveWindowsPath(infile);
6991   if(followlink):
6992    prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6993    listcatfiles = prelistcatfiles['list'];
6994   else:
6995    listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6996  if(not listcatfiles):
6997   return False;
6998  lenlist = len(listcatfiles['ffilelist']);
6999  fnumfiles = int(listcatfiles['fnumfiles']);
7000  lcfi = 0;
7001  lcfx = int(listcatfiles['fnumfiles']);
7002  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
7003   lcfx = int(lenlist);
7004  else:
7005   lcfx = int(listcatfiles['fnumfiles']);
7006  while(lcfi<lcfx):
7007   funame = "";
7008   try:
7009    import pwd;
7010    try:
7011     userinfo = pwd.getpwuid(listcatfiles['ffilelist'][lcfi]['fuid']);
7012     funame = userinfo.pw_name;
7013    except KeyError:
7014     funame = "";
7015   except ImportError:
7016    funame = "";
7017   fgname = "";
7018   try:
7019    import grp;
7020    try:
7021     groupinfo = grp.getgrgid(listcatfiles['ffilelist'][lcfi]['fgid']);
7022     fgname = groupinfo.gr_name;
7023    except KeyError:
7024     fgname = "";
7025   except ImportError:
7026    fgname = "";
7027   if(verbose):
7028    VerbosePrintOut(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7029   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
7030    with open(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
7031     fpc.write(listcatfiles['ffilelist'][lcfi]['fcontents'])
7032     try:
7033      fpc.flush()
7034      os.fsync(fpc.fileno())
7035     except io.UnsupportedOperation:
7036      pass
7037     except AttributeError:
7038      pass
7039    if(hasattr(os, "chown") and funame==listcatfiles['ffilelist'][lcfi]['funame'] and fgname==listcatfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
7040     os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fuid'], listcatfiles['ffilelist'][lcfi]['fgid']);
7041    if(preservepermissions):
7042     os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fchmode']);
7043    if(preservetime):
7044     os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (listcatfiles['ffilelist'][lcfi]['fatime'], listcatfiles['ffilelist'][lcfi]['fmtime']));
7045   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
7046    if(followlink):
7047     getflinkpath = listcatfiles['ffilelist'][lcfi]['flinkname'];
7048     flinkid = prelistcatfiles['filetoid'][getflinkpath];
7049     flinkinfo = listcatfiles['ffilelist'][flinkid];
7050     funame = "";
7051     try:
7052      import pwd;
7053      try:
7054       userinfo = pwd.getpwuid(flinkinfo['fuid']);
7055       funame = userinfo.pw_name;
7056      except KeyError:
7057       funame = "";
7058     except ImportError:
7059      funame = "";
7060     fgname = "";
7061     try:
7062      import grp;
7063      try:
7064       groupinfo = grp.getgrgid(flinkinfo['fgid']);
7065       fgname = groupinfo.gr_name;
7066      except KeyError:
7067       fgname = "";
7068     except ImportError:
7069      fgname = "";
7070     if(flinkinfo['ftype']==0 or flinkinfo['ftype']==7):
7071      with open(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
7072       fpc.write(flinkinfo['fcontents'])
7073       try:
7074        fpc.flush()
7075        os.fsync(fpc.fileno())
7076       except io.UnsupportedOperation:
7077        pass
7078       except AttributeError:
7079        pass
7080      if(hasattr(os, "chown") and funame==flinkinfo['funame'] and fgname==flinkinfo['fgname'] and preservepermissions):
7081       os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid']);
7082      if(preservepermissions):
7083       os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7084      if(preservetime):
7085       os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (flinkinfo['fatime'], flinkinfo['fmtime']));
7086     if(flinkinfo['ftype']==1):
7087      os.link(flinkinfo['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7088     if(flinkinfo['ftype']==2):
7089      os.symlink(flinkinfo['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7090     if(flinkinfo['ftype']==5):
7091      if(preservepermissions):
7092       os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7093      else:
7094       os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7095      if(hasattr(os, "chown") and funame==flinkinfo['funame'] and fgname==flinkinfo['fgname'] and preservepermissions):
7096       os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid']);
7097      if(preservepermissions):
7098       os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7099      if(preservetime):
7100       os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (flinkinfo['fatime'], flinkinfo['fmtime']));
7101     if(flinkinfo['ftype']==6 and hasattr(os, "mkfifo")):
7102      os.mkfifo(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7103    else:
7104     os.link(listcatfiles['ffilelist'][lcfi]['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7105   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
7106    if(followlink):
7107     getflinkpath = listcatfiles['ffilelist'][lcfi]['flinkname'];
7108     flinkid = prelistcatfiles['filetoid'][getflinkpath];
7109     flinkinfo = listcatfiles['ffilelist'][flinkid];
7110     funame = "";
7111     try:
7112      import pwd;
7113      try:
7114       userinfo = pwd.getpwuid(flinkinfo['fuid']);
7115       funame = userinfo.pw_name;
7116      except KeyError:
7117       funame = "";
7118     except ImportError:
7119      funame = "";
7120     fgname = "";
7121     try:
7122      import grp;
7123      try:
7124       groupinfo = grp.getgrgid(flinkinfo['fgid']);
7125       fgname = groupinfo.gr_name;
7126      except KeyError:
7127       fgname = "";
7128     except ImportError:
7129      fgname = "";
7130     if(flinkinfo['ftype']==0 or flinkinfo['ftype']==7):
7131      with open(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
7132       fpc.write(flinkinfo['fcontents'])
7133       try:
7134        fpc.flush()
7135        os.fsync(fpc.fileno())
7136       except io.UnsupportedOperation:
7137        pass
7138       except AttributeError:
7139        pass
7140      if(hasattr(os, "chown") and funame==flinkinfo['funame'] and fgname==flinkinfo['fgname'] and preservepermissions):
7141       os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid']);
7142      if(preservepermissions):
7143       os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7144      if(preservetime):
7145       os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (flinkinfo['fatime'], flinkinfo['fmtime']));
7146     if(flinkinfo['ftype']==1):
7147      os.link(flinkinfo['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7148     if(flinkinfo['ftype']==2):
7149      os.symlink(flinkinfo['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7150     if(flinkinfo['ftype']==5):
7151      if(preservepermissions):
7152       os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7153      else:
7154       os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7155      if(hasattr(os, "chown") and funame==flinkinfo['funame'] and fgname==flinkinfo['fgname'] and preservepermissions):
7156       os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid']);
7157      if(preservepermissions):
7158       os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7159      if(preservetime):
7160       os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (flinkinfo['fatime'], flinkinfo['fmtime']));
7161     if(flinkinfo['ftype']==6 and hasattr(os, "mkfifo")):
7162      os.mkfifo(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7163    else:
7164     os.symlink(listcatfiles['ffilelist'][lcfi]['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7165   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
7166    if(preservepermissions):
7167     os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fchmode']);
7168    else:
7169     os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7170    if(hasattr(os, "chown") and funame==listcatfiles['ffilelist'][lcfi]['funame'] and fgname==listcatfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
7171     os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fuid'], listcatfiles['ffilelist'][lcfi]['fgid']);
7172    if(preservepermissions):
7173     os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fchmode']);
7174    if(preservetime):
7175     os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (listcatfiles['ffilelist'][lcfi]['fatime'], listcatfiles['ffilelist'][lcfi]['fmtime']));
7176   if(listcatfiles['ffilelist'][lcfi]['ftype']==6 and hasattr(os, "mkfifo")):
7177    os.mkfifo(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fchmode']);
7178   lcfi = lcfi + 1;
7179  if(returnfp):
7180   return listcatfiles['ffilelist']['catfp'];
7181  else:
7182   return True;
7183
7184 create_alias_function("UnPack", __file_format_name__, "", UnPackArchiveFile);
7185
7186 if(hasattr(shutil, "register_unpack_format")):
7187  def UnPackArchiveFileFunc(archive_name, extract_dir=None, **kwargs):
7188   return UnPackArchiveFile(archive_name, extract_dir, False, 0, 0, False, __file_format_delimiter__, False, False);
7189  create_alias_function("UnPack", __file_format_name__, "Func", UnPackArchiveFileFunc);
7190
7191 def UnPackArchiveFileString(catstr, outdir=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
7192  catfp = BytesIO(catstr);
7193  listcatfiles = UnPackArchiveFile(catfp, outdir, followlink, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp);
7194  return listcatfiles;
7195
7196 create_alias_function("UnPack", __file_format_name__, "String", UnPackArchiveFileString);
7197
7198 def ArchiveFileListFiles(infile, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
7199  logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7200  if(isinstance(infile, dict)):
7201   listcatfiles = infile;
7202  else:
7203   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
7204    infile = RemoveWindowsPath(infile);
7205   listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, True, skipchecksum, formatspecs, returnfp);
7206  if(not listcatfiles):
7207   return False;
7208  lenlist = len(listcatfiles['ffilelist']);
7209  fnumfiles = int(listcatfiles['fnumfiles']);
7210  lcfi = 0;
7211  lcfx = int(listcatfiles['fnumfiles']);
7212  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
7213   lcfx = int(lenlist);
7214  else:
7215   lcfx = int(listcatfiles['fnumfiles']);
7216  returnval = {};
7217  while(lcfi<lcfx):
7218   returnval.update({lcfi: listcatfiles['ffilelist'][lcfi]['fname']});
7219   if(not verbose):
7220    VerbosePrintOut(listcatfiles['ffilelist'][lcfi]['fname']);
7221   if(verbose):
7222    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' } };
7223    printfname = listcatfiles['ffilelist'][lcfi]['fname'];
7224    if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
7225     printfname = listcatfiles['ffilelist'][lcfi]['fname'] + " link to " + listcatfiles['ffilelist'][lcfi]['flinkname'];
7226    if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
7227     printfname = listcatfiles['ffilelist'][lcfi]['fname'] + " -> " + listcatfiles['ffilelist'][lcfi]['flinkname'];
7228    fuprint = listcatfiles['ffilelist'][lcfi]['funame'];
7229    if(len(fuprint)<=0):
7230     fuprint = listcatfiles['ffilelist'][lcfi]['fuid'];
7231    fgprint = listcatfiles['ffilelist'][lcfi]['fgname'];
7232    if(len(fgprint)<=0):
7233     fgprint = listcatfiles['ffilelist'][lcfi]['fgid'];
7234    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));
7235   lcfi = lcfi + 1;
7236  if(returnfp):
7237   return listcatfiles['catfp'];
7238  else:
7239   return True;
7240
7241 create_alias_function("", __file_format_name__, "ListFiles", ArchiveFileListFiles);
7242
7243 def ArchiveFileStringListFiles(catstr, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
7244  catfp = BytesIO(catstr);
7245  listcatfiles = ArchiveFileListFiles(catstr, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp);
7246  return listcatfiles;
7247
7248 create_alias_function("", __file_format_name__, "StringListFiles", ArchiveFileStringListFiles);
7249
7250 def TarFileListFiles(infile, verbose=False, returnfp=False):
7251  logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7252  if(infile=="-"):
7253   infile = BytesIO();
7254   if(hasattr(sys.stdin, "buffer")):
7255    shutil.copyfileobj(sys.stdin.buffer, infile);
7256   else:
7257    shutil.copyfileobj(sys.stdin, infile);
7258   infile.seek(0, 0);
7259   if(not infile):
7260    return False;
7261   infile.seek(0, 0);
7262  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
7263   infile = download_file_from_internet_file(infile);
7264   infile.seek(0, 0);
7265   if(not infile):
7266    return False;
7267   infile.seek(0, 0);
7268  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
7269   return False;
7270  elif(os.path.exists(infile) and os.path.isfile(infile)):
7271   try:
7272    if(not tarfile.is_tarfile(infile)):
7273     return False;
7274   except AttributeError:
7275    if(not is_tarfile(infile)):
7276     return False;
7277  else:
7278   return False;
7279  try:
7280   if(hasattr(infile, "read") or hasattr(infile, "write")):
7281    tarfp = tarfile.open(fileobj=infile, mode="r");
7282   else:
7283    tarfp = tarfile.open(infile, "r");
7284  except FileNotFoundError:
7285   return False;
7286  lcfi = 0
7287  returnval = {};
7288  for member in sorted(tarfp.getmembers(), key=lambda x: x.name):
7289   returnval.update({lcfi: member.name});
7290   fpremode = member.mode;
7291   ffullmode = member.mode;
7292   flinkcount = 0;
7293   ftype = 0;
7294   if(member.isreg()):
7295    ffullmode = member.mode + stat.S_IFREG;
7296    ftype = 0;
7297   elif(member.isdev()):
7298    ffullmode = member.mode;
7299    ftype = 7;
7300   elif(member.islnk()):
7301    ffullmode = member.mode + stat.S_IFREG;
7302    ftype = 1;
7303   elif(member.issym()):
7304    ffullmode = member.mode + stat.S_IFLNK;
7305    ftype = 2;
7306   elif(member.ischr()):
7307    ffullmode = member.mode + stat.S_IFCHR;
7308    ftype = 3;
7309   elif(member.isblk()):
7310    ffullmode = member.mode + stat.S_IFBLK;
7311    ftype = 4;
7312   elif(member.isdir()):
7313    ffullmode = member.mode + stat.S_IFDIR;
7314    ftype = 5;
7315   elif(member.isfifo()):
7316    ffullmode = member.mode + stat.S_IFIFO;
7317    ftype = 6;
7318   elif(member.issparse()):
7319    ffullmode = member.mode;
7320    ftype = 12;
7321   if(not verbose):
7322    VerbosePrintOut(member.name);
7323   elif(verbose):
7324    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' } };
7325    printfname = member.name;
7326    if(member.islnk()):
7327     printfname = member.name + " link to " + member.linkname;
7328    elif(member.issym()):
7329     printfname = member.name + " -> " + member.linkname;
7330    fuprint = member.uname;
7331    if(len(fuprint)<=0):
7332     fuprint = member.uid;
7333    fgprint = member.gname;
7334    if(len(fgprint)<=0):
7335     fgprint = member.gid;
7336    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));
7337   lcfi = lcfi + 1;
7338  if(returnfp):
7339   return listcatfiles['catfp'];
7340  else:
7341   return True;
7342
7343 def ZipFileListFiles(infile, verbose=False, returnfp=False):
7344  logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7345  if(infile=="-"):
7346   infile = BytesIO();
7347   if(hasattr(sys.stdin, "buffer")):
7348    shutil.copyfileobj(sys.stdin.buffer, infile);
7349   else:
7350    shutil.copyfileobj(sys.stdin, infile);
7351   infile.seek(0, 0);
7352   if(not infile):
7353    return False;
7354   infile.seek(0, 0);
7355  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
7356   infile = download_file_from_internet_file(infile);
7357   infile.seek(0, 0);
7358   if(not infile):
7359    return False;
7360   infile.seek(0, 0);
7361  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
7362   return False;
7363  else:
7364   return False;
7365  if(not zipfile.is_zipfile(infile)):
7366   return False;
7367  try:
7368   zipfp = zipfile.ZipFile(infile, "r", allowZip64=True);
7369  except FileNotFoundError:
7370   return False;
7371  lcfi = 0;
7372  returnval = {};
7373  ziptest = zipfp.testzip();
7374  if(ziptest):
7375   VerbosePrintOut("Bad file found!");
7376  for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
7377   if(zipinfo.create_system==0 or zipinfo.create_system==10):
7378    fwinattributes = int(zipinfo.external_attr);
7379    if(not member.is_dir()):
7380     fmode = int(stat.S_IFREG + 438);
7381     fchmode = int(stat.S_IMODE(fmode));
7382     ftypemod = int(stat.S_IFMT(fmode));
7383    elif(member.is_dir()):
7384     fmode = int(stat.S_IFDIR + 511);
7385     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
7386     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
7387   elif(zipinfo.create_system==3):
7388    fwinattributes =int(0);
7389    fmode = int(zipinfo.external_attr);
7390    fchmode = int(stat.S_IMODE(fmode));
7391    ftypemod = int(stat.S_IFMT(fmode));
7392   else:
7393    fwinattributes = int(0);
7394    if(not member.is_dir()):
7395     fmode = int(stat.S_IFREG + 438);
7396     fchmode = int(stat.S_IMODE(fmode));
7397     ftypemod = int(stat.S_IFMT(fmode));
7398    elif(member.is_dir()):
7399     fmode = int(stat.S_IFDIR + 511);
7400     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
7401     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
7402   returnval.update({lcfi: member.filename});
7403   if(not verbose):
7404    VerbosePrintOut(member.filename);
7405   if(verbose):
7406    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' } };
7407    permissionstr = "";
7408    for fmodval in str(oct(fmode))[-3:]:
7409     permissionstr = permissionstr + permissions['access'].get(fmodval, '---');
7410    if(not member.is_dir()):
7411     ftype = 0;
7412     permissionstr = "-" + permissionstr;
7413    elif(member.is_dir()):
7414     ftype = 5;
7415     permissionstr = "d" + permissionstr;
7416    printfname = member.filename;
7417    try:
7418     fuid = int(os.getuid());
7419    except AttributeError:
7420     fuid = int(0);
7421    except KeyError:
7422     fuid = int(0);
7423    try:
7424     fgid = int(os.getgid());
7425    except AttributeError:
7426     fgid = int(0);
7427    except KeyError:
7428     fgid = int(0);
7429    try:
7430     import pwd;
7431     try:
7432      userinfo = pwd.getpwuid(os.getuid());
7433      funame = userinfo.pw_name;
7434     except KeyError:
7435      funame = "";
7436     except AttributeError:
7437      funame = "";
7438    except ImportError:
7439     funame = "";
7440    fgname = "";
7441    try:
7442     import grp;
7443     try:
7444      groupinfo = grp.getgrgid(os.getgid());
7445      fgname = groupinfo.gr_name;
7446     except KeyError:
7447      fgname = "";
7448     except AttributeError:
7449      fgname = "";
7450    except ImportError:
7451     fgname = "";
7452    fuprint = funame;
7453    if(len(fuprint)<=0):
7454     fuprint = str(fuid);
7455    fgprint = fgname;
7456    if(len(fgprint)<=0):
7457     fgprint = str(fgid);
7458    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));
7459   lcfi = lcfi + 1;
7460  if(returnfp):
7461   return listcatfiles['catfp'];
7462  else:
7463   return True;
7464
7465 if(not rarfile_support):
7466  def RarFileListFiles(infile, verbose=False, returnfp=False):
7467   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7468   if(not os.path.exists(infile) or not os.path.isfile(infile)):
7469    return False;
7470
7471 if(rarfile_support):
7472  def RarFileListFiles(infile, verbose=False, returnfp=False):
7473   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7474   if(not os.path.exists(infile) or not os.path.isfile(infile)):
7475    return False;
7476   if(not rarfile.is_rarfile(infile) and not rarfile.is_rarfile_sfx(infile)):
7477    return False;
7478   lcfi = 0;
7479   returnval = {};
7480   rarfp = rarfile.RarFile(infile, "r");
7481   rartest = rarfp.testrar();
7482   if(rartest):
7483    VerbosePrintOut("Bad file found!");
7484   for member in sorted(rarfp.infolist(), key=lambda x: x.filename):
7485    is_unix = False;
7486    is_windows = False;
7487    if(member.host_os==rarfile.RAR_OS_UNIX):
7488     is_windows = False;
7489     try:
7490      member.external_attr
7491      is_unix = True;
7492     except AttributeError:
7493      is_unix = False;
7494    elif(member.host_os==rarfile.RAR_OS_WIN32):
7495     is_unix = False;
7496     try:
7497      member.external_attr
7498      is_windows = True;
7499     except AttributeError:
7500      is_windows = False;
7501    else:
7502     is_unix = False;
7503     is_windows = False;
7504    if(is_unix and member.external_attr !=0):
7505     fpremode = int(member.external_attr);
7506    elif(member.is_file()):
7507     fpremode = int(stat.S_IFREG + 438);
7508    elif(member.is_symlink()):
7509     fpremode = int(stat.S_IFLNK + 438);
7510    elif(member.is_dir()):
7511     fpremode = int(stat.S_IFDIR + 511);
7512    if(is_windows and member.external_attr !=0):
7513     fwinattributes = int(member.external_attr);
7514    else:
7515     fwinattributes = int(0);
7516    if(is_unix and member.external_attr !=0):
7517     fmode = int(member.external_attr);
7518     fchmode = int(stat.S_IMODE(member.external_attr));
7519     ftypemod = int(stat.S_IFMT(member.external_attr));
7520    elif(member.is_file()):
7521     fmode = int(stat.S_IFREG + 438);
7522     fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)));
7523     ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)));
7524    elif(member.is_symlink()):
7525     fmode = int(stat.S_IFLNK + 438);
7526     fchmode = int(stat.S_IMODE(int(stat.S_IFLNK + 438)));
7527     ftypemod = int(stat.S_IFMT(int(stat.S_IFLNK + 438)));
7528    elif(member.is_dir()):
7529     fmode = int(stat.S_IFDIR + 511);
7530     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
7531     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
7532    returnval.update({lcfi: member.filename});
7533    if(not verbose):
7534     VerbosePrintOut(member.filename);
7535    if(verbose):
7536     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' } };
7537     permissionstr = "";
7538     for fmodval in str(oct(fmode))[-3:]:
7539      permissionstr = permissionstr + permissions['access'].get(fmodval, '---');
7540     if(member.is_file()):
7541      ftype = 0;
7542      permissionstr = "-" + permissionstr;
7543      printfname = member.filename;
7544     elif(member.is_symlink()):
7545      ftype = 2;
7546      permissionstr = "l" + permissionstr;
7547      printfname = member.name + " -> " + member.read().decode("UTF-8");
7548     elif(member.is_dir()):
7549      ftype = 5;
7550      permissionstr = "d" + permissionstr;
7551      printfname = member.filename;
7552     try:
7553      fuid = int(os.getuid());
7554     except AttributeError:
7555      fuid = int(0);
7556     except KeyError:
7557      fuid = int(0);
7558     try:
7559      fgid = int(os.getgid());
7560     except AttributeError:
7561      fgid = int(0);
7562     except KeyError:
7563      fgid = int(0);
7564     try:
7565      import pwd;
7566      try:
7567       userinfo = pwd.getpwuid(os.getuid());
7568       funame = userinfo.pw_name;
7569      except KeyError:
7570       funame = "";
7571      except AttributeError:
7572       funame = "";
7573     except ImportError:
7574      funame = "";
7575     fgname = "";
7576     try:
7577      import grp;
7578      try:
7579       groupinfo = grp.getgrgid(os.getgid());
7580       fgname = groupinfo.gr_name;
7581      except KeyError:
7582       fgname = "";
7583      except AttributeError:
7584       fgname = "";
7585     except ImportError:
7586      fgname = "";
7587     fuprint = funame;
7588     if(len(fuprint)<=0):
7589      fuprint = str(fuid);
7590     fgprint = fgname;
7591     if(len(fgprint)<=0):
7592      fgprint = str(fgid);
7593     VerbosePrintOut(PrintPermissionString(fmode, ftype) + " " + str(str(fuprint) + "/" + str(fgprint) + " " + str(member.file_size).rjust(15) + " " + member.mtime.strftime('%Y-%m-%d %H:%M') + " " + printfname));
7594    lcfi = lcfi + 1;
7595   if(returnfp):
7596    return listcatfiles['catfp'];
7597   else:
7598    return True;
7599
7600 if(not py7zr_support):
7601  def SevenZipFileListFiles(infile, verbose=False, returnfp=False):
7602   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7603   if(not os.path.exists(infile) or not os.path.isfile(infile)):
7604    return False;
7605
7606 if(py7zr_support):
7607  def SevenZipFileListFiles(infile, verbose=False, returnfp=False):
7608   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7609   if(not os.path.exists(infile) or not os.path.isfile(infile)):
7610    return False;
7611   lcfi = 0;
7612   returnval = {};
7613   szpfp = py7zr.SevenZipFile(infile, mode="r");
7614   file_content = szpfp.readall();
7615   #sztest = szpfp.testzip();
7616   sztestalt = szpfp.test();
7617   if(sztestalt):
7618    VerbosePrintOut("Bad file found!");
7619   for member in sorted(szpfp.list(), key=lambda x: x.filename):
7620    if(re.findall("^[.|/]", member.filename)):
7621     fname = member.filename;
7622    else:
7623     fname = "./"+member.filename;
7624    if(not member.is_directory):
7625     fpremode = int(stat.S_IFREG + 438);
7626    elif(member.is_directory):
7627     fpremode = int(stat.S_IFDIR + 511);
7628    fwinattributes = int(0);
7629    if(member.is_directory):
7630     fmode = int(stat.S_IFDIR + 511);
7631     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
7632     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
7633    else:
7634     fmode = int(stat.S_IFLNK + 438);
7635     fchmode = int(stat.S_IMODE(int(stat.S_IFLNK + 438)));
7636     ftypemod = int(stat.S_IFMT(int(stat.S_IFLNK + 438)));
7637    returnval.update({lcfi: member.filename});
7638    if(not verbose):
7639     VerbosePrintOut(member.filename);
7640    if(verbose):
7641     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' } };
7642     permissionstr = "";
7643     for fmodval in str(oct(fmode))[-3:]:
7644      permissionstr = permissionstr + permissions['access'].get(fmodval, '---');
7645     fsize = int("0");
7646     if(not member.is_directory):
7647      ftype = 0;
7648      permissionstr = "-" + permissionstr;
7649      printfname = member.filename;
7650     elif(member.is_directory):
7651      ftype = 5;
7652      permissionstr = "d" + permissionstr;
7653      printfname = member.filename;
7654     if(ftype==0):
7655      fsize = len(file_content[member.filename].read());
7656      file_content[member.filename].close();
7657     try:
7658      fuid = int(os.getuid());
7659     except AttributeError:
7660      fuid = int(0);
7661     except KeyError:
7662      fuid = int(0);
7663     try:
7664      fgid = int(os.getgid());
7665     except AttributeError:
7666      fgid = int(0);
7667     except KeyError:
7668      fgid = int(0);
7669     try:
7670      import pwd;
7671      try:
7672       userinfo = pwd.getpwuid(os.getuid());
7673       funame = userinfo.pw_name;
7674      except KeyError:
7675       funame = "";
7676      except AttributeError:
7677       funame = "";
7678     except ImportError:
7679      funame = "";
7680     fgname = "";
7681     try:
7682      import grp;
7683      try:
7684       groupinfo = grp.getgrgid(os.getgid());
7685       fgname = groupinfo.gr_name;
7686      except KeyError:
7687       fgname = "";
7688      except AttributeError:
7689       fgname = "";
7690     except ImportError:
7691      fgname = "";
7692     fuprint = funame;
7693     if(len(fuprint)<=0):
7694      fuprint = str(fuid);
7695     fgprint = fgname;
7696     if(len(fgprint)<=0):
7697      fgprint = str(fgid);
7698     VerbosePrintOut(PrintPermissionString(fmode, ftype) + " " + str(str(fuprint) + "/" + str(fgprint) + " " + str(fsize).rjust(15) + " " + member.creationtime.strftime('%Y-%m-%d %H:%M') + " " + printfname));
7699    lcfi = lcfi + 1;
7700   if(returnfp):
7701    return listcatfiles['catfp'];
7702   else:
7703    return True;
7704
7705 def InFileListFiles(infile, verbose=False, formatspecs=__file_format_list__, returnfp=False):
7706  logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7707  checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
7708  if(checkcompressfile=="tarfile"):
7709   return TarFileListFiles(infile, verbose, returnfp);
7710  elif(checkcompressfile=="zipfile"):
7711   return ZipFileListFiles(infile, verbose, returnfp);
7712  elif(checkcompressfile=="catfile"):
7713   return ArchiveFileListFiles(infile, 0, 0, False, formatspecs, verbose, returnfp);
7714  elif(rarfile_support and checkcompressfile=="rarfile"):
7715   return RarFileListFiles(infile, verbose, returnfp);
7716  elif(py7zr_support and checkcompressfile=="7zipfile"):
7717   return SevenZipFileListFiles(infile, verbose, returnfp);
7718  else:
7719   return False;
7720  return False;
7721
7722 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):
7723  outarray = BytesIO();
7724  packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, formatspecs, False, True);
7725  listcatfiles = ArchiveFileListFiles(outarray, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp);
7726  return listcatfiles;
7727
7728 def ListDirListFilesAlt(infiles, dirlistfromtxt=False, followlink=False, listonly=False, seekstart=0, seekend=0, skipchecksum=False, checksumtype="crc32", formatspecs=__file_format_list__, verbose=False, returnfp=False):
7729  outarray = ListDirToArrayAlt(infiles, dirlistfromtxt, followlink, listonly, checksumtype, formatspecs, verbose);
7730  listcatfiles = ArchiveFileListFiles(outarray, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp);
7731  return listcatfiles;
7732
7733 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):
7734  outarray = ListDirToArrayAlt(infiles, dirlistfromtxt, followlink, False, checksumtype, extradata, formatspecs, False);
7735  listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, followlink, checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp);
7736  return listcatfiles;
7737
7738 create_alias_function("Pack", __file_format_name__, "FromListDirAlt", PackArchiveFileFromListDirAlt);
7739
7740 def PackArchiveFileFromTarFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7741  outarray = TarFileToArrayAlt(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 create_alias_function("Pack", __file_format_name__, "FromTarFileAlt", PackArchiveFileFromTarFileAlt);
7746
7747 def PackArchiveFileFromZipFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7748  outarray = ZipFileToArrayAlt(infile, False, checksumtype, extradata, formatspecs, False);
7749  listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp);
7750  return listcatfiles;
7751
7752 create_alias_function("Pack", __file_format_name__, "FromZipFileAlt", PackArchiveFileFromZipFileAlt);
7753
7754 if(not rarfile_support):
7755  def PackArchiveFileFromRarFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7756   return False;
7757
7758 if(rarfile_support):
7759  def PackArchiveFileFromRarFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7760   outarray = RarFileToArrayAlt(infile, False, checksumtype, extradata, formatspecs, False);
7761   listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp);
7762   return listcatfiles;
7763
7764 create_alias_function("Pack", __file_format_name__, "FromRarFileAlt", PackArchiveFileFromRarFileAlt);
7765
7766 if(not py7zr_support):
7767  def PackArchiveFileFromSevenZipFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7768   return False;
7769
7770 if(py7zr_support):
7771  def PackArchiveFileFromSevenZipFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7772   outarray = SevenZipFileToArrayAlt(infile, False, checksumtype, extradata, formatspecs, False);
7773   listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp);
7774   return listcatfiles;
7775
7776 create_alias_function("Pack", __file_format_name__, "FromSevenZipFileAlt", PackArchiveFileFromSevenZipFileAlt);
7777
7778 def download_file_from_ftp_file(url):
7779  urlparts = urlparse(url);
7780  file_name = os.path.basename(urlparts.path);
7781  file_dir = os.path.dirname(urlparts.path);
7782  if(urlparts.username is not None):
7783   ftp_username = urlparts.username;
7784  else:
7785   ftp_username = "anonymous";
7786  if(urlparts.password is not None):
7787   ftp_password = urlparts.password;
7788  elif(urlparts.password is None and urlparts.username=="anonymous"):
7789   ftp_password = "anonymous";
7790  else:
7791   ftp_password = "";
7792  if(urlparts.scheme=="ftp"):
7793   ftp = FTP();
7794  elif(urlparts.scheme=="ftps"):
7795   ftp = FTP_TLS();
7796  else:
7797   return False;
7798  if(urlparts.scheme=="sftp"):
7799   if(__use_pysftp__):
7800    return download_file_from_pysftp_file(url);
7801   else:
7802    return download_file_from_sftp_file(url);
7803  elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
7804   return download_file_from_http_file(url);
7805  ftp_port = urlparts.port;
7806  if(urlparts.port is None):
7807   ftp_port = 21;
7808  try:
7809   ftp.connect(urlparts.hostname, ftp_port);
7810  except socket.gaierror:
7811   log.info("Error With URL "+url);
7812   return False;
7813  except socket.timeout:
7814   log.info("Error With URL "+url);
7815   return False;
7816  ftp.login(urlparts.username, urlparts.password);
7817  if(urlparts.scheme=="ftps"):
7818   ftp.prot_p();
7819  ftpfile = BytesIO();
7820  ftp.retrbinary("RETR "+urlparts.path, ftpfile.write);
7821  #ftp.storbinary("STOR "+urlparts.path, ftpfile.write);
7822  ftp.close();
7823  ftpfile.seek(0, 0);
7824  return ftpfile;
7825
7826 def download_file_from_ftp_string(url):
7827  ftpfile = download_file_from_ftp_file(url);
7828  return ftpfile.read();
7829
7830 def upload_file_to_ftp_file(ftpfile, url):
7831  urlparts = urlparse(url);
7832  file_name = os.path.basename(urlparts.path);
7833  file_dir = os.path.dirname(urlparts.path);
7834  if(urlparts.username is not None):
7835   ftp_username = urlparts.username;
7836  else:
7837   ftp_username = "anonymous";
7838  if(urlparts.password is not None):
7839   ftp_password = urlparts.password;
7840  elif(urlparts.password is None and urlparts.username=="anonymous"):
7841   ftp_password = "anonymous";
7842  else:
7843   ftp_password = "";
7844  if(urlparts.scheme=="ftp"):
7845   ftp = FTP();
7846  elif(urlparts.scheme=="ftps"):
7847   ftp = FTP_TLS();
7848  else:
7849   return False;
7850  if(urlparts.scheme=="sftp"):
7851   if(__use_pysftp__):
7852    return upload_file_to_pysftp_file(url);
7853   else:
7854    return upload_file_to_sftp_file(url);
7855  elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
7856   return False;
7857  ftp_port = urlparts.port;
7858  if(urlparts.port is None):
7859   ftp_port = 21;
7860  try:
7861   ftp.connect(urlparts.hostname, ftp_port);
7862  except socket.gaierror:
7863   log.info("Error With URL "+url);
7864   return False;
7865  except socket.timeout:
7866   log.info("Error With URL "+url);
7867   return False;
7868  ftp.login(urlparts.username, urlparts.password);
7869  if(urlparts.scheme=="ftps"):
7870   ftp.prot_p();
7871  ftp.storbinary("STOR "+urlparts.path, ftpfile);
7872  ftp.close();
7873  ftpfile.seek(0, 0);
7874  return ftpfile;
7875
7876 def upload_file_to_ftp_string(ftpstring, url):
7877  ftpfileo = BytesIO(ftpstring);
7878  ftpfile = upload_file_to_ftp_file(ftpfileo, url);
7879  ftpfileo.close();
7880  return ftpfile;
7881
7882 def download_file_from_http_file(url, headers=geturls_headers_pycatfile_python_alt):
7883  # Parse the URL to extract username and password if present
7884  urlparts = urlparse(url);
7885  username = urlparts.username;
7886  password = urlparts.password;
7887  # Rebuild the URL without the username and password
7888  netloc = urlparts.hostname;
7889  if(urlparts.scheme=="sftp"):
7890   if(__use_pysftp__):
7891    return download_file_from_pysftp_file(url);
7892   else:
7893    return download_file_from_sftp_file(url);
7894  elif(urlparts.scheme=="ftp" or urlparts.scheme=="ftps"):
7895   return download_file_from_ftp_file(url);
7896  if urlparts.port:
7897    netloc += ':' + str(urlparts.port);
7898  rebuilt_url = urlunparse((urlparts.scheme, netloc, urlparts.path, urlparts.params, urlparts.query, urlparts.fragment));
7899  # Create a temporary file object
7900  httpfile = BytesIO();
7901  if haverequests:
7902   # Use the requests library if available
7903   if username and password:
7904    response = requests.get(rebuilt_url, headers=headers, auth=(username, password), stream=True);
7905   else:
7906    response = requests.get(rebuilt_url, headers=headers, stream=True);
7907   response.raw.decode_content = True
7908   shutil.copyfileobj(response.raw, httpfile);
7909  else:
7910   # Build a Request object for urllib
7911   request = Request(rebuilt_url, headers=headers);
7912   # Create an opener object for handling URLs
7913   if username and password:
7914    # Create a password manager
7915    password_mgr = HTTPPasswordMgrWithDefaultRealm();
7916    # Add the username and password
7917    password_mgr.add_password(None, rebuilt_url, username, password);
7918    # Create an authentication handler using the password manager
7919    auth_handler = HTTPBasicAuthHandler(password_mgr);
7920    # Build the opener with the authentication handler
7921    opener = build_opener(auth_handler);
7922   else:
7923       opener = build_opener();
7924   with opener.open(request) as response:
7925    shutil.copyfileobj(response, httpfile);
7926  # Reset file pointer to the start
7927  httpfile.seek(0, 0);
7928  # Return the temporary file object
7929  return httpfile;
7930
7931 def download_file_from_http_string(url, headers=geturls_headers_pycatfile_python_alt):
7932  httpfile = download_file_from_http_file(url, headers);
7933  return ftpfile.read();
7934
7935 if(haveparamiko):
7936  def download_file_from_sftp_file(url):
7937   urlparts = urlparse(url);
7938   file_name = os.path.basename(urlparts.path);
7939   file_dir = os.path.dirname(urlparts.path);
7940   sftp_port = urlparts.port;
7941   if(urlparts.port is None):
7942    sftp_port = 22;
7943   else:
7944    sftp_port = urlparts.port;
7945   if(urlparts.username is not None):
7946    sftp_username = urlparts.username;
7947   else:
7948    sftp_username = "anonymous";
7949   if(urlparts.password is not None):
7950    sftp_password = urlparts.password;
7951   elif(urlparts.password is None and urlparts.username=="anonymous"):
7952    sftp_password = "anonymous";
7953   else:
7954    sftp_password = "";
7955   if(urlparts.scheme=="ftp"):
7956    return download_file_from_ftp_file(url);
7957   elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
7958    return download_file_from_http_file(url);
7959   if(urlparts.scheme!="sftp"):
7960    return False;
7961   ssh = paramiko.SSHClient();
7962   ssh.load_system_host_keys();
7963   ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy());
7964   try:
7965    ssh.connect(urlparts.hostname, port=sftp_port, username=urlparts.username, password=urlparts.password);
7966   except paramiko.ssh_exception.SSHException:
7967    return False;
7968   except socket.gaierror:
7969    log.info("Error With URL "+url);
7970    return False;
7971   except socket.timeout:
7972    log.info("Error With URL "+url);
7973    return False;
7974   sftp = ssh.open_sftp();
7975   sftpfile = BytesIO();
7976   sftp.getfo(urlparts.path, sftpfile);
7977   sftp.close();
7978   ssh.close();
7979   sftpfile.seek(0, 0);
7980   return sftpfile;
7981 else:
7982  def download_file_from_sftp_file(url):
7983   return False;
7984
7985 if(haveparamiko):
7986  def download_file_from_sftp_string(url):
7987   sftpfile = download_file_from_sftp_file(url);
7988   return sftpfile.read();
7989 else:
7990  def download_file_from_ftp_string(url):
7991   return False;
7992
7993 if(haveparamiko):
7994  def upload_file_to_sftp_file(sftpfile, url):
7995   urlparts = urlparse(url);
7996   file_name = os.path.basename(urlparts.path);
7997   file_dir = os.path.dirname(urlparts.path);
7998   sftp_port = urlparts.port;
7999   if(urlparts.port is None):
8000    sftp_port = 22;
8001   else:
8002    sftp_port = urlparts.port;
8003   if(urlparts.username is not None):
8004    sftp_username = urlparts.username;
8005   else:
8006    sftp_username = "anonymous";
8007   if(urlparts.password is not None):
8008    sftp_password = urlparts.password;
8009   elif(urlparts.password is None and urlparts.username=="anonymous"):
8010    sftp_password = "anonymous";
8011   else:
8012    sftp_password = "";
8013   if(urlparts.scheme=="ftp"):
8014    return upload_file_to_ftp_file(url);
8015   elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
8016    return False;
8017   if(urlparts.scheme!="sftp"):
8018    return False;
8019   ssh = paramiko.SSHClient();
8020   ssh.load_system_host_keys();
8021   ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy());
8022   try:
8023    ssh.connect(urlparts.hostname, port=sftp_port, username=urlparts.username, password=urlparts.password);
8024   except paramiko.ssh_exception.SSHException:
8025    return False;
8026   except socket.gaierror:
8027    log.info("Error With URL "+url);
8028    return False;
8029   except socket.timeout:
8030    log.info("Error With URL "+url);
8031    return False;
8032   sftp = ssh.open_sftp();
8033   sftp.putfo(sftpfile, urlparts.path);
8034   sftp.close();
8035   ssh.close();
8036   sftpfile.seek(0, 0);
8037   return sftpfile;
8038 else:
8039  def upload_file_to_sftp_file(sftpfile, url):
8040   return False;
8041
8042 if(haveparamiko):
8043  def upload_file_to_sftp_string(sftpstring, url):
8044   sftpfileo = BytesIO(sftpstring);
8045   sftpfile = upload_file_to_sftp_files(ftpfileo, url);
8046   sftpfileo.close();
8047   return sftpfile;
8048 else:
8049  def upload_file_to_sftp_string(url):
8050   return False;
8051
8052 if(havepysftp):
8053  def download_file_from_pysftp_file(url):
8054   urlparts = urlparse(url);
8055   file_name = os.path.basename(urlparts.path);
8056   file_dir = os.path.dirname(urlparts.path);
8057   sftp_port = urlparts.port;
8058   if(urlparts.port is None):
8059    sftp_port = 22;
8060   else:
8061    sftp_port = urlparts.port;
8062   if(urlparts.username is not None):
8063    sftp_username = urlparts.username;
8064   else:
8065    sftp_username = "anonymous";
8066   if(urlparts.password is not None):
8067    sftp_password = urlparts.password;
8068   elif(urlparts.password is None and urlparts.username=="anonymous"):
8069    sftp_password = "anonymous";
8070   else:
8071    sftp_password = "";
8072   if(urlparts.scheme=="ftp"):
8073    return download_file_from_ftp_file(url);
8074   elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
8075    return download_file_from_http_file(url);
8076   if(urlparts.scheme!="sftp"):
8077    return False;
8078   try:
8079    pysftp.Connection(urlparts.hostname, port=sftp_port, username=urlparts.username, password=urlparts.password);
8080   except paramiko.ssh_exception.SSHException:
8081    return False;
8082   except socket.gaierror:
8083    log.info("Error With URL "+url);
8084    return False;
8085   except socket.timeout:
8086    log.info("Error With URL "+url);
8087    return False;
8088   sftp = ssh.open_sftp();
8089   sftpfile = BytesIO();
8090   sftp.getfo(urlparts.path, sftpfile);
8091   sftp.close();
8092   ssh.close();
8093   sftpfile.seek(0, 0);
8094   return sftpfile;
8095 else:
8096  def download_file_from_pysftp_file(url):
8097   return False;
8098
8099 if(havepysftp):
8100  def download_file_from_pysftp_string(url):
8101   sftpfile = download_file_from_pysftp_file(url);
8102   return sftpfile.read();
8103 else:
8104  def download_file_from_ftp_string(url):
8105   return False;
8106
8107 if(havepysftp):
8108  def upload_file_to_pysftp_file(sftpfile, url):
8109   urlparts = urlparse(url);
8110   file_name = os.path.basename(urlparts.path);
8111   file_dir = os.path.dirname(urlparts.path);
8112   sftp_port = urlparts.port;
8113   if(urlparts.port is None):
8114    sftp_port = 22;
8115   else:
8116    sftp_port = urlparts.port;
8117   if(urlparts.username is not None):
8118    sftp_username = urlparts.username;
8119   else:
8120    sftp_username = "anonymous";
8121   if(urlparts.password is not None):
8122    sftp_password = urlparts.password;
8123   elif(urlparts.password is None and urlparts.username=="anonymous"):
8124    sftp_password = "anonymous";
8125   else:
8126    sftp_password = "";
8127   if(urlparts.scheme=="ftp"):
8128    return upload_file_to_ftp_file(url);
8129   elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
8130    return False;
8131   if(urlparts.scheme!="sftp"):
8132    return False;
8133   try:
8134    pysftp.Connection(urlparts.hostname, port=sftp_port, username=urlparts.username, password=urlparts.password);
8135   except paramiko.ssh_exception.SSHException:
8136    return False;
8137   except socket.gaierror:
8138    log.info("Error With URL "+url);
8139    return False;
8140   except socket.timeout:
8141    log.info("Error With URL "+url);
8142    return False;
8143   sftp = ssh.open_sftp();
8144   sftp.putfo(sftpfile, urlparts.path);
8145   sftp.close();
8146   ssh.close();
8147   sftpfile.seek(0, 0);
8148   return sftpfile;
8149 else:
8150  def upload_file_to_pysftp_file(sftpfile, url):
8151   return False;
8152
8153 if(havepysftp):
8154  def upload_file_to_pysftp_string(sftpstring, url):
8155   sftpfileo = BytesIO(sftpstring);
8156   sftpfile = upload_file_to_pysftp_files(ftpfileo, url);
8157   sftpfileo.close();
8158   return sftpfile;
8159 else:
8160  def upload_file_to_pysftp_string(url):
8161   return False;
8162
8163 def download_file_from_internet_file(url, headers=geturls_headers_pycatfile_python_alt):
8164  urlparts = urlparse(url);
8165  if(urlparts.scheme=="http" or urlparts.scheme=="https"):
8166   return download_file_from_http_file(url, headers);
8167  elif(urlparts.scheme=="ftp" or urlparts.scheme=="ftps"):
8168   return download_file_from_ftp_file(url);
8169  elif(urlparts.scheme=="sftp"):
8170   if(__use_pysftp__ and havepysftp):
8171    return download_file_from_pysftp_file(url);
8172   else:
8173    return download_file_from_sftp_file(url);
8174  else:
8175   return False;
8176  return False;
8177
8178 def download_file_from_internet_uncompress_file(url, headers=geturls_headers_pycatfile_python_alt, formatspecs=__file_format_list__):
8179  fp = download_file_from_internet_file(url);
8180  fp = UncompressArchiveFile(fp, formatspecs);
8181  fp.seek(0, 0);
8182  if(not fp):
8183   return False;
8184  return fp;
8185
8186 def download_file_from_internet_string(url, headers=geturls_headers_pycatfile_python_alt):
8187  urlparts = urlparse(url);
8188  if(urlparts.scheme=="http" or urlparts.scheme=="https"):
8189   return download_file_from_http_string(url, headers);
8190  elif(urlparts.scheme=="ftp" or urlparts.scheme=="ftps"):
8191   return download_file_from_ftp_string(url);
8192  elif(urlparts.scheme=="sftp"):
8193   if(__use_pysftp__ and havepysftp):
8194    return download_file_from_pysftp_string(url);
8195   else:
8196    return download_file_from_sftp_string(url);
8197  else:
8198   return False;
8199  return False;
8200
8201 def download_file_from_internet_uncompress_string(url, headers=geturls_headers_pycatfile_python_alt, formatspecs=__file_format_list__):
8202  fp = download_file_from_internet_string(url);
8203  fp = UncompressArchiveFile(fp, formatspecs);
8204  fp.seek(0, 0);
8205  if(not fp):
8206   return False;
8207  return fp;
8208
8209 def upload_file_to_internet_file(ifp, url):
8210  urlparts = urlparse(url);
8211  if(urlparts.scheme=="http" or urlparts.scheme=="https"):
8212   return False;
8213  elif(urlparts.scheme=="ftp" or urlparts.scheme=="ftps"):
8214   return upload_file_to_ftp_file(ifp, url);
8215  elif(urlparts.scheme=="sftp"):
8216   if(__use_pysftp__ and havepysftp):
8217    return upload_file_to_pysftp_file(ifp, url);
8218   else:
8219    return upload_file_to_sftp_file(ifp, url);
8220  else:
8221   return False;
8222  return False;
8223
8224 def upload_file_to_internet_compress_file(ifp, url, formatspecs=__file_format_list__):
8225  catfp = CompressArchiveFile(catfp, compression, formatspecs);
8226  if(not catfileout):
8227   return False;
8228  catfp.seek(0, 0);
8229  upload_file_to_internet_file(catfp, outfile);
8230  return True;
8231
8232 def upload_file_to_internet_string(ifp, url):
8233  urlparts = urlparse(url);
8234  if(urlparts.scheme=="http" or urlparts.scheme=="https"):
8235   return False;
8236  elif(urlparts.scheme=="ftp" or urlparts.scheme=="ftps"):
8237   return upload_file_to_ftp_string(ifp, url);
8238  elif(urlparts.scheme=="sftp"):
8239   if(__use_pysftp__ and havepysftp):
8240    return upload_file_to_pysftp_string(ifp, url);
8241   else:
8242    return upload_file_to_sftp_string(ifp, url);
8243  else:
8244   return False;
8245  return False;
8246
8247 def upload_file_to_internet_compress_string(ifp, url, formatspecs=__file_format_list__):
8248  catfp = CompressArchiveFile(BytesIO(ifp), compression, formatspecs);
8249  if(not catfileout):
8250   return False;
8251  catfp.seek(0, 0);
8252  upload_file_to_internet_file(catfp, outfile);
8253  return True;
8254
8255 try:
8256  if(hasattr(shutil, "register_archive_format")):
8257   # Register the packing format
8258   shutil.register_archive_format(__file_format_name__, PackArchiveFileFunc, description='Pack concatenated files');
8259 except shutil.RegistryError:
8260  pass;
8261
8262 try:
8263  if(hasattr(shutil, "register_unpack_format")):
8264   # Register the unpacking format
8265   shutil.register_unpack_format(__file_format_name__, archivefile_extensions, UnPackArchiveFileFunc, description='UnPack concatenated files');
8266 except shutil.RegistryError:
8267  pass;