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/26/2024 Ver. 0.8.6 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, 8, 6, "RC 1", 1);
 175 __version_date_info__ = (2024, 4, 26, "RC 1", 1);
 176 __version_date__ = str(__version_date_info__[0]) + "." + str(__version_date_info__[1]).zfill(2) + "." + str(__version_date_info__[2]).zfill(2);
 177 __revision__ = __version_info__[3];
 178 __revision_id__ = "$Id$";
 179 if(__version_info__[4] is not None):
 180  __version_date_plusrc__ = __version_date__ + "-" + str(__version_date_info__[4]);
 181 if(__version_info__[4] is None):
 182  __version_date_plusrc__ = __version_date__;
 183 if(__version_info__[3] is not None):
 184  __version__ = str(__version_info__[0]) + "." + str(__version_info__[1]) + "." + str(__version_info__[2]) + " " + str(__version_info__[3]);
 185 if(__version_info__[3] is None):
 186  __version__ = str(__version_info__[0]) + "." + str(__version_info__[1]) + "." + str(__version_info__[2]);
 187
 188 PyBitness = platform.architecture();
 189 if(PyBitness=="32bit" or PyBitness=="32"):
 190  PyBitness = "32";
 191 elif(PyBitness=="64bit" or PyBitness=="64"):
 192  PyBitness = "64";
 193 else:
 194  PyBitness = "32";
 195
 196 geturls_ua_pycatfile_python = "Mozilla/5.0 (compatible; {proname}/{prover}; +{prourl})".format(proname=__project__, prover=__version__, prourl=__project_url__);
 197 if(platform.python_implementation()!=""):
 198  py_implementation = platform.python_implementation();
 199 if(platform.python_implementation()==""):
 200  py_implementation = "Python";
 201 geturls_ua_pycatfile_python_alt = "Mozilla/5.0 ({osver}; {archtype}; +{prourl}) {pyimp}/{pyver} (KHTML, like Gecko) {proname}/{prover}".format(osver=platform.system()+" "+platform.release(), archtype=platform.machine(), prourl=__project_url__, pyimp=py_implementation, pyver=platform.python_version(), proname=__project__, prover=__version__);
 202 geturls_ua_googlebot_google = "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)";
 203 geturls_ua_googlebot_google_old = "Googlebot/2.1 (+http://www.google.com/bot.html)";
 204 geturls_headers_pycatfile_python = {'Referer': "http://google.com/", 'User-Agent': geturls_ua_pycatfile_python, 'Accept-Encoding': "none", 'Accept-Language': "en-US,en;q=0.8,en-CA,en-GB;q=0.6", 'Accept-Charset': "ISO-8859-1,ISO-8859-15,utf-8;q=0.7,*;q=0.7", 'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 'Connection': "close", 'SEC-CH-UA': "\""+__project__+"\";v=\""+str(__version__)+"\", \"Not;A=Brand\";v=\"8\", \""+py_implementation+"\";v=\""+str(platform.release())+"\"", 'SEC-CH-UA-FULL-VERSION': str(__version__), 'SEC-CH-UA-PLATFORM': ""+py_implementation+"", 'SEC-CH-UA-ARCH': ""+platform.machine()+"", 'SEC-CH-UA-PLATFORM': str(__version__), 'SEC-CH-UA-BITNESS': str(PyBitness)};
 205 geturls_headers_pycatfile_python_alt = {'Referer': "http://google.com/", 'User-Agent': geturls_ua_pycatfile_python_alt, 'Accept-Encoding': "none", 'Accept-Language': "en-US,en;q=0.8,en-CA,en-GB;q=0.6", 'Accept-Charset': "ISO-8859-1,ISO-8859-15,utf-8;q=0.7,*;q=0.7", 'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 'Connection': "close", 'SEC-CH-UA': "\""+__project__+"\";v=\""+str(__version__)+"\", \"Not;A=Brand\";v=\"8\", \""+py_implementation+"\";v=\""+str(platform.release())+"\"", 'SEC-CH-UA-FULL-VERSION': str(__version__), 'SEC-CH-UA-PLATFORM': ""+py_implementation+"", 'SEC-CH-UA-ARCH': ""+platform.machine()+"", 'SEC-CH-UA-PLATFORM': str(__version__), 'SEC-CH-UA-BITNESS': str(PyBitness)};
 206 geturls_headers_googlebot_google = {'Referer': "http://google.com/", 'User-Agent': geturls_ua_googlebot_google, 'Accept-Encoding': "none", 'Accept-Language': "en-US,en;q=0.8,en-CA,en-GB;q=0.6", 'Accept-Charset': "ISO-8859-1,ISO-8859-15,utf-8;q=0.7,*;q=0.7", 'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 'Connection': "close"};
 207 geturls_headers_googlebot_google_old = {'Referer': "http://google.com/", 'User-Agent': geturls_ua_googlebot_google_old, 'Accept-Encoding': "none", 'Accept-Language': "en-US,en;q=0.8,en-CA,en-GB;q=0.6", 'Accept-Charset': "ISO-8859-1,ISO-8859-15,utf-8;q=0.7,*;q=0.7", 'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", 'Connection': "close"};
 208
 209 compressionlist = ['auto', 'gzip', 'bzip2', 'zstd', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
 210 outextlist = ['gz', 'bz2', 'zst', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
 211 outextlistwd = ['.gz', '.bz2', '.zst', '.lz4', '.lzo', '.lzop', '.lzma', '.xz'];
 212
 213 tarfile_mimetype = "application/tar";
 214 tarfile_tar_mimetype = tarfile_mimetype;
 215 zipfile_mimetype = "application/zip";
 216 zipfile_zip_mimetype = zipfile_mimetype;
 217 rarfile_mimetype = "application/rar";
 218 rarfile_rar_mimetype = rarfile_mimetype;
 219 archivefile_mimetype = "application/x-"+__file_format_list__[1]+"";
 220 archivefile_cat_mimetype = archivefile_mimetype;
 221 archivefile_gzip_mimetype = "application/x-"+__file_format_list__[1]+"+gzip";
 222 archivefile_gz_mimetype = archivefile_gzip_mimetype;
 223 archivefile_bzip2_mimetype = "application/x-"+__file_format_list__[1]+"+bzip2";
 224 archivefile_bz2_mimetype = archivefile_bzip2_mimetype;
 225 archivefile_lz4_mimetype = "application/x-"+__file_format_list__[1]+"+lz4";
 226 archivefile_lzop_mimetype = "application/x-"+__file_format_list__[1]+"+lzop";
 227 archivefile_lzo_mimetype = archivefile_lzop_mimetype;
 228 archivefile_zstandard_mimetype = "application/x-"+__file_format_list__[1]+"+zstandard";
 229 archivefile_zstd_mimetype = archivefile_zstandard_mimetype;
 230 archivefile_lzma_mimetype = "application/x-"+__file_format_list__[1]+"+lzma";
 231 archivefile_xz_mimetype = "application/x-"+__file_format_list__[1]+"+xz";
 232 archivefile_extensions = ['.cat', '.cat.gz', '.cat.bz2', '.cat.zst', '.cat.lz4', '.cat.lzo', '.cat.lzop', '.cat.lzma', '.cat.xz'];
 233
 234 if __name__ == "__main__":
 235  import subprocess;
 236  curscrpath = os.path.dirname(sys.argv[0]);
 237  if(curscrpath==""):
 238   curscrpath = ".";
 239  if(os.sep=="\\"):
 240   curscrpath = curscrpath.replace(os.sep, "/");
 241  curscrpath = curscrpath + "/";
 242  scrfile = curscrpath + "catfile.py";
 243  if(os.path.exists(scrfile) and os.path.isfile(scrfile)):
 244   scrcmd = subprocess.Popen([sys.executable, scrfile] + sys.argv[1:]);
 245   scrcmd.wait();
 246
 247 def VerbosePrintOut(dbgtxt, outtype="log", dbgenable=True, dgblevel=20):
 248  if(not dbgenable):
 249   return True;
 250  log_functions = {
 251   "print": print,
 252   "log": logging.info,
 253   "warning": logging.warning,
 254   "error": logging.error,
 255   "critical": logging.critical,
 256   "exception": logging.exception,
 257   "logalt": lambda x: logging.log(dgblevel, x),
 258   "debug": logging.debug
 259  };
 260  log_function = log_functions.get(outtype);
 261  if(log_function):
 262   log_function(dbgtxt);
 263   return True;
 264  return False;
 265
 266 def VerbosePrintOutReturn(dbgtxt, outtype="log", dbgenable=True, dgblevel=20):
 267  VerbosePrintOut(dbgtxt, outtype, dbgenable, dgblevel);
 268  return dbgtxt;
 269
 270 def RemoveWindowsPath(dpath):
 271  if(dpath is None):
 272   dpath = "";
 273  if(os.sep!="/"):
 274   dpath = dpath.replace(os.path.sep, "/");
 275  dpath = dpath.rstrip("/");
 276  if(dpath=="." or dpath==".."):
 277   dpath = dpath + "/";
 278  return dpath;
 279
 280 def NormalizeRelativePath(inpath):
 281  inpath = RemoveWindowsPath(inpath);
 282  if(os.path.isabs(inpath)):
 283   outpath = inpath;
 284  else:
 285   if(inpath.startswith("./") or inpath.startswith("../")):
 286    outpath = inpath;
 287   else:
 288    outpath = "./" + inpath;
 289  return outpath;
 290
 291 def PrependPath(base_dir, child_path):
 292  # Check if base_dir is None or empty, if so, return child_path as is
 293  if not base_dir:
 294   return child_path;
 295  # Ensure base_dir ends with exactly one slash
 296  if not base_dir.endswith('/'):
 297   base_dir += '/';
 298  # Check if child_path starts with ./ or ../ (indicating a relative path)
 299  if child_path.startswith('./') or child_path.startswith('../'):
 300   # For relative paths, we don't alter the child_path
 301   return base_dir + child_path;
 302  else:
 303   # For non-relative paths, ensure there's no starting slash on child_path to avoid double slashes
 304   return base_dir + child_path.lstrip('/');
 305
 306 def ListDir(dirpath, followlink=False, duplicates=False):
 307  if(isinstance(dirpath, (list, tuple, ))):
 308   dirpath = list(filter(None, dirpath));
 309  elif(isinstance(dirpath, (str, ))):
 310   dirpath = list(filter(None, [dirpath]));
 311  retlist = [];
 312  for mydirfile in dirpath:
 313   if(not os.path.exists(mydirfile)):
 314    return False;
 315   mydirfile = NormalizeRelativePath(mydirfile);
 316   if(os.path.exists(mydirfile) and os.path.islink(mydirfile)):
 317    mydirfile = RemoveWindowsPath(os.path.realpath(mydirfile));
 318   if(os.path.exists(mydirfile) and os.path.isdir(mydirfile)):
 319    for root, dirs, filenames in os.walk(mydirfile):
 320     dpath = root;
 321     dpath = RemoveWindowsPath(dpath);
 322     if(dpath not in retlist and not duplicates):
 323      retlist.append(dpath);
 324     if(duplicates):
 325      retlist.append(dpath);
 326     for file in filenames:
 327      fpath = os.path.join(root, file);
 328      fpath = RemoveWindowsPath(fpath);
 329      if(fpath not in retlist and not duplicates):
 330       retlist.append(fpath);
 331      if(duplicates):
 332       retlist.append(fpath);
 333   else:
 334    retlist.append(RemoveWindowsPath(mydirfile));
 335  return retlist;
 336
 337 def ListDirAdvanced(dirpath, followlink=False, duplicates=False):
 338  if isinstance(dirpath, (list, tuple)):
 339   dirpath = list(filter(None, dirpath));
 340  elif isinstance(dirpath, str):
 341   dirpath = list(filter(None, [dirpath]));
 342  retlist = []
 343  for mydirfile in dirpath:
 344   if not os.path.exists(mydirfile):
 345    return False;
 346   mydirfile = NormalizeRelativePath(mydirfile);
 347   if os.path.exists(mydirfile) and os.path.islink(mydirfile) and followlink:
 348    mydirfile = RemoveWindowsPath(os.path.realpath(mydirfile))
 349   if os.path.exists(mydirfile) and os.path.isdir(mydirfile):
 350    for root, dirs, filenames in os.walk(mydirfile):
 351     # Sort dirs and filenames alphabetically in place
 352     dirs.sort(key=lambda x: x.lower());
 353     filenames.sort(key=lambda x: x.lower());
 354     dpath = RemoveWindowsPath(root);
 355     if not duplicates and dpath not in retlist:
 356      retlist.append(dpath);
 357     elif duplicates:
 358      retlist.append(dpath);
 359     for file in filenames:
 360      fpath = os.path.join(root, file);
 361      fpath = RemoveWindowsPath(fpath);
 362      if not duplicates and fpath not in retlist:
 363       retlist.append(fpath);
 364      elif duplicates:
 365       retlist.append(fpath);
 366   else:
 367    retlist.append(RemoveWindowsPath(mydirfile));
 368  return retlist;
 369
 370 def create_alias_function(prefix, base_name, suffix, target_function):
 371  # Define a new function that wraps the target function
 372  def alias_function(*args, **kwargs):
 373   return target_function(*args, **kwargs);
 374
 375  # Create the function name by combining the prefix, base name, and the suffix
 376  function_name = "{}{}{}".format(prefix, base_name, suffix);
 377
 378  # Add the new function to the global namespace
 379  globals()[function_name] = alias_function;
 380
 381 def create_alias_function_alt(prefix, base_name, suffix, target_function):
 382     # Create the function name by combining the prefix, base name, and the suffix
 383     # Use the format method for string formatting, compatible with Python 2 and 3
 384     function_name = "{}{}{}".format(prefix, base_name, suffix)
 385     # Add the new function (alias of the target_function) to the global namespace
 386     # This line is compatible as-is with both Python 2 and 3
 387     globals()[function_name] = target_function
 388
 389 # initial_value can be 0xFFFF or 0x0000
 390 def crc16_ansi(msg, initial_value=0xFFFF):
 391  # CRC-16-IBM / CRC-16-ANSI polynomial and initial value
 392  poly = 0x8005;  # Polynomial for CRC-16-IBM / CRC-16-ANSI
 393  crc = initial_value;  # Initial value
 394  for b in msg:
 395   crc ^= b << 8;  # XOR byte into CRC top byte
 396   for _ in range(8):  # Process each bit
 397    if crc & 0x8000:  # If the top bit is set
 398     crc = (crc << 1) ^ poly;  # Shift left and XOR with the polynomial
 399    else:
 400     crc = crc << 1;  # Just shift left
 401    crc &= 0xFFFF;  # Ensure CRC remains 16-bit
 402  return crc;
 403
 404 # initial_value can be 0xFFFF or 0x0000
 405 def crc16_ibm(msg, initial_value=0xFFFF):
 406  return crc16_ansi(msg, initial_value);
 407
 408 # initial_value is 0xFFFF
 409 def crc16(msg):
 410  return crc16_ansi(msg, 0xFFFF);
 411
 412 # initial_value can be 0xFFFF, 0x1D0F or 0x0000
 413 def crc16_ccitt(msg, initial_value=0xFFFF):
 414  # CRC-16-CCITT polynomial
 415  poly = 0x1021;  # Polynomial for CRC-16-CCITT
 416  # Use the specified initial value
 417  crc = initial_value;
 418  for b in msg:
 419   crc ^= b << 8;  # XOR byte into CRC top byte
 420   for _ in range(8):  # Process each bit
 421    if crc & 0x8000:  # If the top bit is set
 422     crc = (crc << 1) ^ poly;  # Shift left and XOR with the polynomial
 423    else:
 424     crc = crc << 1;  # Just shift left
 425    crc &= 0xFFFF;  # Ensure CRC remains 16-bit
 426  return crc;
 427
 428 # initial_value can be 0x42F0E1EBA9EA3693 or 0x0000000000000000
 429 def crc64_ecma(msg, initial_value=0x0000000000000000):
 430  # CRC-64-ECMA polynomial and initial value
 431  poly = 0x42F0E1EBA9EA3693;
 432  crc = initial_value;  # Initial value for CRC-64-ECMA
 433  for b in msg:
 434   crc ^= b << 56;  # XOR byte into the most significant byte of the CRC
 435   for _ in range(8):  # Process each bit
 436    if crc & (1 << 63):  # Check if the leftmost (most significant) bit is set
 437     crc = (crc << 1) ^ poly;  # Shift left and XOR with poly if the MSB is 1
 438    else:
 439     crc <<= 1;  # Just shift left if the MSB is 0
 440    crc &= 0xFFFFFFFFFFFFFFFF;  # Ensure CRC remains 64-bit
 441  return crc;
 442
 443 # initial_value can be 0x000000000000001B or 0xFFFFFFFFFFFFFFFF
 444 def crc64_iso(msg, initial_value=0xFFFFFFFFFFFFFFFF):
 445  # CRC-64-ISO polynomial and initial value
 446  poly = 0x000000000000001B;
 447  crc = initial_value;  # Common initial value for CRC-64-ISO
 448  for b in msg:
 449   crc ^= b << 56;  # XOR byte into the most significant byte of the CRC
 450   for _ in range(8):  # Process each bit
 451    if crc & (1 << 63):  # Check if the leftmost (most significant) bit is set
 452     crc = (crc << 1) ^ poly;  # Shift left and XOR with poly if the MSB is 1
 453    else:
 454     crc <<= 1;  # Just shift left if the MSB is 0
 455    crc &= 0xFFFFFFFFFFFFFFFF;  # Ensure CRC remains 64-bit
 456  return crc;
 457
 458 def GetDataFromArray(data, path, default=None):
 459  element = data;
 460  try:
 461   for key in path:
 462    element = element[key];
 463   return element;
 464  except (KeyError, TypeError, IndexError):
 465   return default;
 466
 467 def GetDataFromArrayAlt(structure, path, default=None):
 468  element = structure;
 469  for key in path:
 470   if isinstance(element, dict) and key in element:
 471    element = element[key];
 472   elif isinstance(element, list) and isinstance(key, int) and -len(element) <= key < len(element):
 473    element = element[key];
 474   else:
 475    return default;
 476  return element;
 477
 478 def GetHeaderChecksum(inlist=[], checksumtype="crc32", encodedata=True, formatspecs=__file_format_list__):
 479  if isinstance(inlist, list):
 480   fileheader = AppendNullBytes(inlist, formatspecs[5]);
 481  else:
 482   fileheader = AppendNullByte(inlist, formatspecs[5]);
 483  if(encodedata):
 484   fileheader = fileheader.encode('UTF-8');
 485  if(checksumtype=="none" or checksumtype==""):
 486   catfileheadercshex = format(0, 'x').lower();
 487  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
 488   catfileheadercshex = format(crc16(fileheader) & 0xffff, '04x').lower();
 489  elif(checksumtype=="crc16_ccitt"):
 490   catfileheadercshex = format(crc16_ccitt(fileheader) & 0xffff, '04x').lower();
 491  elif(checksumtype=="adler32"):
 492   catfileheadercshex = format(zlib.adler32(fileheader) & 0xffffffff, '08x').lower();
 493  elif(checksumtype=="crc32"):
 494   catfileheadercshex = format(crc32(fileheader) & 0xffffffff, '08x').lower();
 495  elif(checksumtype=="crc64_ecma"):
 496   catfileheadercshex = format(crc64_ecma(fileheader) & 0xffffffffffffffff, '016x').lower();
 497  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
 498   catfileheadercshex = format(crc64_iso(fileheader) & 0xffffffffffffffff, '016x').lower();
 499  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
 500   checksumoutstr = hashlib.new(checksumtype);
 501   checksumoutstr.update(fileheader);
 502   catfileheadercshex = checksumoutstr.hexdigest().lower();
 503  else:
 504   catfileheadercshex = format(0, 'x').lower();
 505  return catfileheadercshex;
 506
 507 def GetFileChecksum(instr, checksumtype="crc32", encodedata=True, formatspecs=__file_format_list__):
 508  if(encodedata):
 509   instr = instr.encode('UTF-8');
 510  if(checksumtype=="none" or checksumtype==""):
 511   catinstrcshex = format(0, 'x').lower();
 512  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
 513   catinstrcshex = format(crc16(instr) & 0xffff, '04x').lower();
 514  elif(checksumtype=="crc16_ccitt"):
 515   catinstrcshex = format(crc16_ccitt(instr) & 0xffff, '04x').lower();
 516  elif(checksumtype=="adler32"):
 517   catinstrcshex = format(zlib.adler32(instr) & 0xffffffff, '08x').lower();
 518  elif(checksumtype=="crc32"):
 519   catinstrcshex = format(crc32(instr) & 0xffffffff, '08x').lower();
 520  elif(checksumtype=="crc64_ecma"):
 521   catinstrcshex = format(crc64_ecma(instr) & 0xffffffffffffffff, '016x').lower();
 522  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
 523   catinstrcshex = format(crc64_iso(instr) & 0xffffffffffffffff, '016x').lower();
 524  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
 525   checksumoutstr = hashlib.new(checksumtype);
 526   checksumoutstr.update(instr);
 527   catinstrcshex = checksumoutstr.hexdigest().lower();
 528  else:
 529   catinstrcshex = format(0, 'x').lower();
 530  return catinstrcshex;
 531
 532 def ValidateHeaderChecksum(inlist=[], checksumtype="crc32", inchecksum="0", formatspecs=__file_format_list__):
 533  catfileheadercshex = GetHeaderChecksum(inlist, checksumtype, True, formatspecs);
 534  inchecksum = inchecksum.lower();
 535  catfileheadercshex = catfileheadercshex.lower();
 536  if(inchecksum==catfileheadercshex):
 537   return True;
 538  else:
 539   return False;
 540
 541 def ValidateFileChecksum(infile, checksumtype="crc32", inchecksum="0", formatspecs=__file_format_list__):
 542  catinfilecshex = GetFileChecksum(infile, checksumtype, True, formatspecs);
 543  inchecksum = inchecksum.lower();
 544  catinfilecshex = catinfilecshex.lower();
 545  if(inchecksum==catinfilecshex):
 546   return True;
 547  else:
 548   return False;
 549
 550 def ReadTillNullByte(fp, delimiter=__file_format_delimiter__):
 551  curbyte = b"";
 552  curfullbyte = b"";
 553  nullbyte = delimiter.encode("UTF-8");
 554  while(True):
 555   curbyte = fp.read(1);
 556   if(curbyte==nullbyte or not curbyte):
 557    break;
 558   curfullbyte = curfullbyte + curbyte;
 559  return curfullbyte.decode('UTF-8');
 560
 561 def ReadUntilNullByte(fp, delimiter=__file_format_delimiter__):
 562  return ReadTillNullByte(fp, delimiter);
 563
 564 def SeekToEndOfFile(fp):
 565  lasttell = 0;
 566  while(True):
 567   fp.seek(1, 1);
 568   if(lasttell==fp.tell()):
 569    break;
 570   lasttell = fp.tell();
 571  return True;
 572
 573 def ReadFileHeaderData(fp, rounds=0, delimiter=__file_format_delimiter__):
 574  rocount = 0;
 575  roend = int(rounds);
 576  HeaderOut = [];
 577  while(rocount<roend):
 578   HeaderOut.append(ReadTillNullByte(fp, delimiter));
 579   rocount = rocount + 1;
 580  return HeaderOut;
 581
 582 def ReadFileHeaderDataBySize(fp, delimiter=__file_format_delimiter__):
 583  headerpresize = ReadTillNullByte(fp, delimiter);
 584  headersize = int(headerpresize, 16);
 585  if(headersize<=0):
 586   return [];
 587  headercontent = str(fp.read(headersize).decode('UTF-8')).split(delimiter);
 588  fp.seek(1, 1);
 589  rocount = 0;
 590  roend = int(len(headercontent));
 591  HeaderOut = [headerpresize];
 592  while(rocount<roend):
 593   HeaderOut.append(headercontent[rocount]);
 594   rocount = rocount + 1;
 595  return HeaderOut;
 596
 597 def ReadFileHeaderDataWoSize(fp, delimiter=__file_format_delimiter__):
 598  preheaderdata = ReadFileHeaderData(fp, 2, delimiter);
 599  headersize = int(preheaderdata[0], 16);
 600  headernumfields = int(preheaderdata[1], 16);
 601  if(headersize<=0 or headernumfields<=0):
 602   return [];
 603  headerdata = ReadFileHeaderData(fp, headernumfields, delimiter);
 604  HeaderOut = preheaderdata + headerdata;
 605  return HeaderOut;
 606
 607 def ReadFileHeaderDataBySizeWithContent(fp, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
 608  delimiter = formatspecs[5];
 609  fheaderstart = fp.tell();
 610  HeaderOut = ReadFileHeaderDataBySize(fp, delimiter);
 611  if(len(HeaderOut)==0):
 612   return False;
 613  if(re.findall("^[.|/]", HeaderOut[3])):
 614   fname = HeaderOut[3];
 615  else:
 616   fname = "./"+HeaderOut[3];
 617  fchecksumtype = HeaderOut[-3].lower();
 618  fcs = HeaderOut[-2].lower();
 619  fccs = HeaderOut[-1].lower();
 620  fsize = int(HeaderOut[5], 16);
 621  newfcs = GetHeaderChecksum(HeaderOut[:-2], HeaderOut[-3].lower(), True, formatspecs);
 622  if(fcs!=newfcs and not skipchecksum):
 623   VerbosePrintOut("File Header Checksum Error with file " + fname + " at offset " + str(fheaderstart));
 624   return False;
 625  fhend = fp.tell() - 1;
 626  fcontentstart = fp.tell();
 627  fcontents = "".encode('UTF-8');
 628  if(fsize>0 and not listonly):
 629   fcontents = fp.read(fsize);
 630  elif(fsize>0 and listonly):
 631   fp.seek(fsize, 1);
 632  newfccs = GetFileChecksum(fcontents, HeaderOut[-3].lower(), False, formatspecs);
 633  if(fccs!=newfccs and not skipchecksum and not listonly):
 634   VerbosePrintOut("File Content Checksum Error with file " + fname + " at offset " + str(fcontentstart));
 635   return False;
 636  fp.seek(1, 1);
 637  fcontentend = fp.tell() - 1;
 638  HeaderOut.append(fcontents);
 639  return HeaderOut;
 640
 641 def ReadFileHeaderDataBySizeWithContentToArray(fp, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
 642  delimiter = formatspecs[5];
 643  fheaderstart = fp.tell();
 644  if(formatspecs[7]):
 645   HeaderOut = ReadFileHeaderDataBySize(fp, delimiter);
 646  else:
 647   HeaderOut = ReadFileHeaderDataWoSize(fp, delimiter);
 648  if(len(HeaderOut)==0):
 649   return False;
 650  fheadsize = int(HeaderOut[0], 16);
 651  fnumfields = int(HeaderOut[1], 16);
 652  ftype = int(HeaderOut[2], 16);
 653  if(re.findall("^[.|/]", HeaderOut[3])):
 654   fname = HeaderOut[3];
 655  else:
 656   fname = "./"+HeaderOut[3];
 657  fbasedir = os.path.dirname(fname);
 658  flinkname = HeaderOut[4];
 659  fsize = int(HeaderOut[5], 16);
 660  fatime = int(HeaderOut[6], 16);
 661  fmtime = int(HeaderOut[7], 16);
 662  fctime = int(HeaderOut[8], 16);
 663  fbtime = int(HeaderOut[9], 16);
 664  fmode = int(HeaderOut[10], 16);
 665  fchmode = stat.S_IMODE(fmode);
 666  ftypemod = stat.S_IFMT(fmode);
 667  fwinattributes = int(HeaderOut[11], 16);
 668  fuid = int(HeaderOut[12], 16);
 669  funame = HeaderOut[13];
 670  fgid = int(HeaderOut[14], 16);
 671  fgname = HeaderOut[15];
 672  fid = int(HeaderOut[16], 16);
 673  finode = int(HeaderOut[17], 16);
 674  flinkcount = int(HeaderOut[18], 16);
 675  fdev_minor = int(HeaderOut[19], 16);
 676  fdev_major = int(HeaderOut[20], 16);
 677  frdev_minor = int(HeaderOut[21], 16);
 678  frdev_major = int(HeaderOut[22], 16);
 679  fextrasize = int(HeaderOut[23], 16);
 680  fextrafields = int(HeaderOut[24], 16);
 681  extrafieldslist = [];
 682  extrastart = 25;
 683  extraend = extrastart + fextrafields;
 684  extrafieldslist = [];
 685  if(extrastart<extraend):
 686   extrafieldslist.append(HeaderOut[extrastart]);
 687   extrastart = extrastart + 1;
 688  fchecksumtype = HeaderOut[extrastart].lower();
 689  fcs = HeaderOut[extrastart + 1].lower();
 690  fccs = HeaderOut[extrastart + 2].lower();
 691  newfcs = GetHeaderChecksum(HeaderOut[:-2], HeaderOut[-3].lower(), True, formatspecs);
 692  if(fcs!=newfcs and not skipchecksum):
 693   VerbosePrintOut("File Header Checksum Error with file " + fname + " at offset " + str(fheaderstart));
 694   return False;
 695  fhend = fp.tell() - 1;
 696  fcontentstart = fp.tell();
 697  fcontents = "".encode('UTF-8');
 698  pyhascontents = False;
 699  if(fsize>0 and not listonly):
 700   fcontents = fp.read(fsize);
 701   pyhascontents = True;
 702  elif(fsize>0 and listonly):
 703   fp.seek(fsize, 1);
 704   pyhascontents = False;
 705  newfccs = GetFileChecksum(fcontents, HeaderOut[-3].lower(), False, formatspecs);
 706  if(fccs!=newfccs and not skipchecksum and not listonly):
 707   VerbosePrintOut("File Content Checksum Error with file " + fname + " at offset " + str(fcontentstart));
 708   return False;
 709  fp.seek(1, 1);
 710  fcontentend = fp.tell() - 1;
 711  catlist = {'fheadersize': fheadsize, 'fhstart': fheaderstart, 'fhend': fhend, 'ftype': ftype, 'fname': fname, 'fbasedir': fbasedir, 'flinkname': flinkname, 'fsize': fsize, 'fatime': fatime, 'fmtime': fmtime, 'fctime': fctime, 'fbtime': fbtime, 'fmode': fmode, 'fchmode': fchmode, 'ftypemod': ftypemod, 'fwinattributes': fwinattributes, 'fuid': fuid, 'funame': funame, 'fgid': fgid, 'fgname': fgname, 'finode': finode, 'flinkcount': flinkcount, 'fminor': fdev_minor, 'fmajor': fdev_major, 'frminor': frdev_minor, 'frmajor': frdev_major, 'fchecksumtype': fchecksumtype, 'fnumfields': fnumfields + 2, 'frawheader': HeaderOut, 'fextrafields': fextrafields, 'fextrafieldsize': fextrasize, 'fextralist': extrafieldslist, 'fheaderchecksum': fcs, 'fcontentchecksum': fccs, 'fhascontents': pyhascontents, 'fcontentstart': fcontentstart, 'fcontentend': fcontentend, 'fcontents': fcontents};
 712  return catlist;
 713
 714 def ReadFileHeaderDataBySizeWithContentToList(fp, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
 715  delimiter = formatspecs[5];
 716  fheaderstart = fp.tell();
 717  if(formatspecs[7]):
 718   HeaderOut = ReadFileHeaderDataBySize(fp, delimiter);
 719  else:
 720   HeaderOut = ReadFileHeaderDataWoSize(fp, delimiter);
 721  if(len(HeaderOut)==0):
 722   return False;
 723  fheadsize = int(HeaderOut[0], 16);
 724  fnumfields = int(HeaderOut[1], 16);
 725  ftype = int(HeaderOut[2], 16);
 726  if(re.findall("^[.|/]", HeaderOut[3])):
 727   fname = HeaderOut[3];
 728  else:
 729   fname = "./"+HeaderOut[3];
 730  fbasedir = os.path.dirname(fname);
 731  flinkname = HeaderOut[4];
 732  fsize = int(HeaderOut[5], 16);
 733  fatime = int(HeaderOut[6], 16);
 734  fmtime = int(HeaderOut[7], 16);
 735  fctime = int(HeaderOut[8], 16);
 736  fbtime = int(HeaderOut[9], 16);
 737  fmode = int(HeaderOut[10], 16);
 738  fchmode = stat.S_IMODE(fmode);
 739  ftypemod = stat.S_IFMT(fmode);
 740  fwinattributes = int(HeaderOut[11], 16);
 741  fuid = int(HeaderOut[12], 16);
 742  funame = HeaderOut[13];
 743  fgid = int(HeaderOut[14], 16);
 744  fgname = HeaderOut[15];
 745  fid = int(HeaderOut[16], 16);
 746  finode = int(HeaderOut[17], 16);
 747  flinkcount = int(HeaderOut[18], 16);
 748  fdev_minor = int(HeaderOut[19], 16);
 749  fdev_major = int(HeaderOut[20], 16);
 750  frdev_minor = int(HeaderOut[21], 16);
 751  frdev_major = int(HeaderOut[22], 16);
 752  fextrasize = int(HeaderOut[23], 16);
 753  fextrafields = int(HeaderOut[24], 16);
 754  extrafieldslist = [];
 755  extrastart = 25;
 756  extraend = extrastart + fextrafields;
 757  extrafieldslist = [];
 758  if(extrastart<extraend):
 759   extrafieldslist.append(HeaderOut[extrastart]);
 760   extrastart = extrastart + 1;
 761  fchecksumtype = HeaderOut[extrastart].lower();
 762  fcs = HeaderOut[extrastart + 1].lower();
 763  fccs = HeaderOut[extrastart + 2].lower();
 764  newfcs = GetHeaderChecksum(HeaderOut[:-2], HeaderOut[-3].lower(), True, formatspecs);
 765  if(fcs!=newfcs and not skipchecksum):
 766   VerbosePrintOut("File Header Checksum Error with file " + fname + " at offset " + str(fheaderstart));
 767   return False;
 768  fhend = fp.tell() - 1;
 769  fcontentstart = fp.tell();
 770  fcontents = "".encode('UTF-8');
 771  pyhascontents = False;
 772  if(fsize>0 and not listonly):
 773   fcontents = fp.read(fsize);
 774   pyhascontents = True;
 775  elif(fsize>0 and listonly):
 776   fp.seek(fsize, 1);
 777   pyhascontents = False;
 778  newfccs = GetFileChecksum(fcontents, HeaderOut[-3].lower(), False, formatspecs);
 779  if(fccs!=newfccs and not skipchecksum and not listonly):
 780   VerbosePrintOut("File Content Checksum Error with file " + fname + " at offset " + str(fcontentstart));
 781   return False;
 782  fp.seek(1, 1);
 783  fcontentend = fp.tell() - 1;
 784  catlist = [ftype, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fuid, funame, fgid, fgname, fid, finode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrafieldslist, fchecksumtype, fcontents];
 785  return catlist;
 786
 787 def ReadFileDataBySizeWithContent(fp, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
 788  delimiter = formatspecs[5];
 789  curloc = fp.tell();
 790  if(curloc>0):
 791   fp.seek(0, 0);
 792  catheader = ReadFileHeaderData(fp, 4, delimiter);
 793  if(curloc>0):
 794   fp.seek(curloc, 0);
 795  headercheck = ValidateHeaderChecksum(catheader[:-1], catheader[2], catheader[3], formatspecs);
 796  if(not headercheck and not skipchecksum):
 797   VerbosePrintOut("File Header Checksum Error with file at offset " + str(0));
 798   return False;
 799  fnumfiles = int(catheader[1], 16);
 800  countnum = 0;
 801  flist = [];
 802  while(countnum < fnumfiles):
 803   HeaderOut = ReadFileHeaderDataBySizeWithContent(fp, listonly, skipchecksum, formatspecs)
 804   if(len(HeaderOut)==0):
 805    break;
 806   flist.append(HeaderOut);
 807   countnum = countnum + 1;
 808  return flist;
 809
 810 def ReadFileDataBySizeWithContentToArray(fp, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
 811  delimiter = formatspecs[5];
 812  curloc = fp.tell();
 813  if(curloc>0):
 814   fp.seek(0, 0);
 815  catheader = ReadFileHeaderData(fp, 4, delimiter);
 816  if(curloc>0):
 817   fp.seek(curloc, 0);
 818  headercheck = ValidateHeaderChecksum(catheader[:-1], catheader[2], catheader[3], formatspecs);
 819  if(not headercheck and not skipchecksum):
 820   VerbosePrintOut("File Header Checksum Error with file at offset " + str(0));
 821   return False;
 822  catstring = catheader[0];
 823  catversion = re.findall(r"([\d]+)$", catstring);
 824  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
 825  fprenumfiles = catheader[1];
 826  fnumfiles = int(fprenumfiles, 16);
 827  fprechecksumtype = catheader[2];
 828  fprechecksum = catheader[3];
 829  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': {}};
 830  if(seekstart<0 and seekstart>fnumfiles):
 831    seekstart = 0;
 832  if(seekend==0 or seekend>fnumfiles and seekend<seekstart):
 833   seekend = fnumfiles;
 834  elif(seekend<0 and abs(seekend)<=fnumfiles and abs(seekend)>=seekstart):
 835   seekend = fnumfiles - abs(seekend);
 836  if(seekstart>0):
 837   il = 0;
 838   while(il < seekstart):
 839    prefhstart = fp.tell();
 840    preheaderdata = ReadFileHeaderDataBySize(fp, formatspecs[5]);
 841    if(len(preheaderdata)==0):
 842     break;
 843    prefsize = int(preheaderdata[5], 16);
 844    prenewfcs = GetHeaderChecksum(preheaderdata[:-2], preheaderdata[-3].lower(), True, formatspecs);
 845    prefcs = preheaderdata[-2];
 846    if(prefcs!=prenewfcs and not skipchecksum):
 847     VerbosePrintOut("File Header Checksum Error with file " + prefname + " at offset " + str(prefhstart));
 848     return False;
 849     valid_archive = False;
 850     invalid_archive = True;
 851    prefhend = fp.tell() - 1;
 852    prefcontentstart = fp.tell();
 853    prefcontents = "";
 854    pyhascontents = False;
 855    if(prefsize>0):
 856     prefcontents = fp.read(prefsize);
 857     prenewfccs = GetFileChecksum(prefcontents, preheaderdata[-3].lower(), False, formatspecs);
 858     prefccs = preheaderdata[-1];
 859     pyhascontents = True;
 860     if(prefccs!=prenewfccs and not skipchecksum):
 861      VerbosePrintOut("File Content Checksum Error with file " + prefname + " at offset " + str(prefcontentstart));
 862      return False;
 863    fp.seek(1, 1);
 864    il = il + 1;
 865  realidnum = 0;
 866  countnum = seekstart;
 867  while(countnum < seekend):
 868   catlist['ffilelist'].update({realidnum: {'fid': realidnum, 'fidalt': realidnum}});
 869   HeaderOut = ReadFileHeaderDataBySizeWithContentToArray(fp, listonly, skipchecksum, formatspecs);
 870   if(len(HeaderOut)):
 871    break;
 872   catlist['ffilelist'][realidnum].update(HeaderOut);
 873   countnum = countnum + 1;
 874   realidnum = realidnum + 1;
 875  return catlist;
 876
 877 def ReadFileDataBySizeWithContentToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
 878  if(isinstance(infile, dict)):
 879   listcatfiles = infile;
 880  else:
 881   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
 882    return False;
 883   listcatfiles = ReadFileDataBySizeWithContentToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs);
 884  if(not listcatfiles):
 885   return False;
 886  catarray = {'list': listcatfiles, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {}, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}};
 887  lenlist = len(listcatfiles['ffilelist']);
 888  lcfi = 0;
 889  lcfx = int(listcatfiles['fnumfiles']);
 890  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
 891   lcfx = int(lenlist);
 892  else:
 893   lcfx = int(listcatfiles['fnumfiles']);
 894  while(lcfi < lcfx):
 895   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
 896   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
 897   catarray['filetoid'].update(filetoidarray);
 898   catarray['idtofile'].update(idtofilearray);
 899   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
 900    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
 901    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
 902   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
 903    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
 904    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
 905    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
 906    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
 907   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
 908    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
 909    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
 910    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
 911    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
 912   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
 913    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
 914    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
 915    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
 916    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
 917   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
 918    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
 919    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
 920    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
 921    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
 922   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
 923    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
 924    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
 925   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
 926    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
 927    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
 928    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
 929    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
 930   lcfi = lcfi + 1;
 931  return catarray;
 932
 933 def ReadFileDataBySizeWithContentToList(fp, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
 934  delimiter = formatspecs[5];
 935  curloc = fp.tell();
 936  if(curloc>0):
 937   fp.seek(0, 0);
 938  catheader = ReadFileHeaderData(fp, 4, delimiter);
 939  if(curloc>0):
 940   fp.seek(curloc, 0);
 941  headercheck = ValidateHeaderChecksum(catheader[:-1], catheader[2], catheader[3], formatspecs);
 942  if(not headercheck and not skipchecksum):
 943   VerbosePrintOut("File Header Checksum Error with file at offset " + str(0));
 944   return False;
 945  catstring = catheader[0];
 946  catversion = re.findall(r"([\d]+)$", catstring);
 947  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
 948  fprenumfiles = catheader[1];
 949  fnumfiles = int(fprenumfiles, 16);
 950  fprechecksumtype = catheader[2];
 951  fprechecksum = catheader[3];
 952  catlist = [];
 953  if(seekstart<0 and seekstart>fnumfiles):
 954    seekstart = 0;
 955  if(seekend==0 or seekend>fnumfiles and seekend<seekstart):
 956   seekend = fnumfiles;
 957  elif(seekend<0 and abs(seekend)<=fnumfiles and abs(seekend)>=seekstart):
 958   seekend = fnumfiles - abs(seekend);
 959  if(seekstart>0):
 960   il = 0;
 961   while(il < seekstart):
 962    prefhstart = fp.tell();
 963    preheaderdata = ReadFileHeaderDataBySize(fp, formatspecs[5]);
 964    if(len(preheaderdata)==0):
 965     break;
 966    prefsize = int(preheaderdata[5], 16);
 967    prenewfcs = GetHeaderChecksum(preheaderdata[:-2], preheaderdata[-3].lower(), True, formatspecs);
 968    prefcs = preheaderdata[-2];
 969    if(prefcs!=prenewfcs and not skipchecksum):
 970     VerbosePrintOut("File Header Checksum Error with file " + prefname + " at offset " + str(prefhstart));
 971     return False;
 972     valid_archive = False;
 973     invalid_archive = True;
 974    prefhend = fp.tell() - 1;
 975    prefcontentstart = fp.tell();
 976    prefcontents = "";
 977    pyhascontents = False;
 978    if(prefsize>0):
 979     prefcontents = fp.read(prefsize);
 980     prenewfccs = GetFileChecksum(prefcontents, preheaderdata[-3].lower(), False, formatspecs);
 981     prefccs = preheaderdata[-1];
 982     pyhascontents = True;
 983     if(prefccs!=prenewfccs and not skipchecksum):
 984      VerbosePrintOut("File Content Checksum Error with file " + prefname + " at offset " + str(prefcontentstart));
 985      return False;
 986    fp.seek(1, 1);
 987    il = il + 1;
 988  realidnum = 0;
 989  countnum = seekstart;
 990  while(countnum < seekend):
 991   HeaderOut = ReadFileHeaderDataBySizeWithContentToList(fp, listonly, skipchecksum, formatspecs);
 992   if(len(HeaderOut)):
 993    break;
 994   catlist.append(HeaderOut);
 995   countnum = countnum + 1;
 996   realidnum = realidnum + 1;
 997  return catlist;
 998
 999 def ReadInFileBySizeWithContentToArray(infile, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
1000  delimiter = formatspecs[5];
1001  if(hasattr(infile, "read") or hasattr(infile, "write")):
1002   fp = infile;
1003   fp.seek(0, 0);
1004   fp = UncompressArchiveFile(fp, formatspecs);
1005   checkcompressfile = CheckCompressionSubType(fp, formatspecs, True);
1006   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
1007    return False;
1008   if(not fp):
1009    return False;
1010   fp.seek(0, 0);
1011  elif(infile=="-"):
1012   fp = BytesIO();
1013   if(hasattr(sys.stdin, "buffer")):
1014    shutil.copyfileobj(sys.stdin.buffer, fp);
1015   else:
1016    shutil.copyfileobj(sys.stdin, fp);
1017   fp.seek(0, 0);
1018   fp = UncompressArchiveFile(fp, formatspecs);
1019   if(not fp):
1020    return False;
1021   fp.seek(0, 0);
1022  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
1023   fp = download_file_from_internet_file(infile);
1024   fp = UncompressArchiveFile(fp, formatspecs);
1025   fp.seek(0, 0);
1026   if(not fp):
1027    return False;
1028   fp.seek(0, 0);
1029  else:
1030   infile = RemoveWindowsPath(infile);
1031   checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
1032   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
1033    return False;
1034   compresscheck = CheckCompressionType(infile, formatspecs, True);
1035   if(not compresscheck):
1036    fextname = os.path.splitext(infile)[1];
1037    if(fextname==".gz"):
1038     compresscheck = "gzip";
1039    elif(fextname==".bz2"):
1040     compresscheck = "bzip2";
1041    elif(fextname==".zst"):
1042     compresscheck = "zstd";
1043    elif(fextname==".lz4" or fextname==".clz4"):
1044     compresscheck = "lz4";
1045    elif(fextname==".lzo" or fextname==".lzop"):
1046     compresscheck = "lzo";
1047    elif(fextname==".lzma" or fextname==".xz"):
1048     compresscheck = "lzma";
1049    else:
1050     return False;
1051   if(not compresscheck):
1052    return False;
1053   fp = UncompressFile(infile, formatspecs, "rb");
1054  return ReadFileDataBySizeWithContentToArray(fp, listonly, skipchecksum, formatspecs);
1055
1056 def ReadInFileBySizeWithContentToList(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
1057  delimiter = formatspecs[5];
1058  if(hasattr(infile, "read") or hasattr(infile, "write")):
1059   fp = infile;
1060   fp.seek(0, 0);
1061   fp = UncompressArchiveFile(fp, formatspecs);
1062   checkcompressfile = CheckCompressionSubType(fp, formatspecs, True);
1063   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
1064    return False;
1065   if(not fp):
1066    return False;
1067   fp.seek(0, 0);
1068  elif(infile=="-"):
1069   fp = BytesIO();
1070   if(hasattr(sys.stdin, "buffer")):
1071    shutil.copyfileobj(sys.stdin.buffer, fp);
1072   else:
1073    shutil.copyfileobj(sys.stdin, fp);
1074   fp.seek(0, 0);
1075   fp = UncompressArchiveFile(fp, formatspecs);
1076   if(not fp):
1077    return False;
1078   fp.seek(0, 0);
1079  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
1080   fp = download_file_from_internet_file(infile);
1081   fp = UncompressArchiveFile(fp, formatspecs);
1082   fp.seek(0, 0);
1083   if(not fp):
1084    return False;
1085   fp.seek(0, 0);
1086  else:
1087   infile = RemoveWindowsPath(infile);
1088   checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
1089   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
1090    return False;
1091   compresscheck = CheckCompressionType(infile, formatspecs, True);
1092   if(not compresscheck):
1093    fextname = os.path.splitext(infile)[1];
1094    if(fextname==".gz"):
1095     compresscheck = "gzip";
1096    elif(fextname==".bz2"):
1097     compresscheck = "bzip2";
1098    elif(fextname==".zst"):
1099     compresscheck = "zstd";
1100    elif(fextname==".lz4" or fextname==".clz4"):
1101     compresscheck = "lz4";
1102    elif(fextname==".lzo" or fextname==".lzop"):
1103     compresscheck = "lzo";
1104    elif(fextname==".lzma" or fextname==".xz"):
1105     compresscheck = "lzma";
1106    else:
1107     return False;
1108   if(not compresscheck):
1109    return False;
1110   fp = UncompressFile(infile, formatspecs, "rb");
1111  return ReadFileDataBySizeWithContentToList(fp, seekstart, seekend, listonly, skipchecksum, formatspecs);
1112
1113 def ReadInFileBySizeWithContentToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__):
1114  if(isinstance(infile, dict)):
1115   listcatfiles = infile;
1116  else:
1117   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
1118    infile = RemoveWindowsPath(infile);
1119   listcatfiles = ReadInFileBySizeWithContentToArray(infile, listonly, skipchecksum, formatspecs);
1120  if(not listcatfiles):
1121   return False;
1122  catarray = {'list': listcatfiles, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {}, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}};
1123  lenlist = len(listcatfiles['ffilelist']);
1124  lcfi = 0;
1125  lcfx = int(listcatfiles['fnumfiles']);
1126  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
1127   lcfx = int(lenlist);
1128  else:
1129   lcfx = int(listcatfiles['fnumfiles']);
1130  while(lcfi < lcfx):
1131   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
1132   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
1133   catarray['filetoid'].update(filetoidarray);
1134   catarray['idtofile'].update(idtofilearray);
1135   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
1136    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
1137    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
1138   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
1139    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
1140    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
1141    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
1142    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
1143   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
1144    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
1145    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
1146    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
1147    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
1148   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
1149    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
1150    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
1151    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
1152    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
1153   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
1154    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
1155    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
1156    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
1157    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
1158   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
1159    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
1160    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
1161   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
1162    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
1163    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
1164    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
1165    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
1166   lcfi = lcfi + 1;
1167  return catarray;
1168
1169 def AppendNullByte(indata, delimiter=__file_format_delimiter__):
1170  outdata = str(indata) + delimiter;
1171  return outdata;
1172
1173 def AppendNullBytes(indata=[], delimiter=__file_format_delimiter__):
1174  outdata = "";
1175  inum = 0;
1176  il = len(indata);
1177  while(inum < il):
1178   outdata = outdata + AppendNullByte(indata[inum], delimiter);
1179   inum = inum + 1;
1180  return outdata;
1181
1182 def AppendFileHeader(fp, numfiles, checksumtype="crc32", formatspecs=__file_format_list__):
1183  delimiter = formatspecs[5];
1184  catver = formatspecs[6];
1185  fileheaderver = str(int(catver.replace(".", "")));
1186  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
1187  fp.write(fileheader.encode('UTF-8'));
1188  fnumfiles = format(int(numfiles), 'x').lower();
1189  fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
1190  catfileheadercshex = GetFileChecksum(fileheader + fnumfilesa, checksumtype, True, formatspecs);
1191  fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
1192  fp.write(fnumfilesa.encode('UTF-8'));
1193  try:
1194   fp.flush();
1195   os.fsync(fp.fileno());
1196  except io.UnsupportedOperation:
1197   pass;
1198  except AttributeError:
1199   pass;
1200  return fp;
1201
1202 def AppendFileHeaderWithContent(fp, filevalues=[], extradata=[], filecontent="", checksumtype="crc32", formatspecs=__file_format_list__):
1203  extrafields = format(len(extradata), 'x').lower();
1204  extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
1205  if(len(extradata)>0):
1206   extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
1207  extrasizelen = format(len(extrasizestr), 'x').lower();
1208  catoutlen = len(filevalues) + len(extradata) + 5;
1209  catoutlenhex = format(catoutlen, 'x').lower();
1210  catoutlist = filevalues;
1211  catoutlist.insert(0, catoutlenhex);
1212  catoutlist.append(extrasizelen);
1213  catoutlist.append(extrafields);
1214  catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
1215  if(len(extradata)>0):
1216   catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
1217  catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
1218  catfileheadercshex = GetFileChecksum(catfileoutstr, checksumtype, True, formatspecs);
1219  catfilecontentcshex = GetFileChecksum(filecontent, checksumtype, False, formatspecs);
1220  tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
1221  catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower();
1222  catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
1223  catfileheadercshex = GetFileChecksum(catfileoutstr, checksumtype, True, formatspecs);
1224  catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
1225  catfileoutstrecd = catfileoutstr.encode('UTF-8');
1226  nullstrecd = formatspecs[5].encode('UTF-8');
1227  catfileout = catfileoutstrecd + filecontent + nullstrecd;
1228  fp.write(catfileout);
1229  try:
1230   fp.flush();
1231   os.fsync(fp.fileno());
1232  except io.UnsupportedOperation:
1233   pass;
1234  except AttributeError:
1235   pass;
1236  return fp;
1237
1238 def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, filevalues=[], extradata=[], followlink=False, checksumtype="crc32", formatspecs=__file_format_list__, verbose=False):
1239  advancedlist = formatspecs[8];
1240  altinode = formatspecs[9];
1241  if(verbose):
1242   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
1243  if(infiles=="-"):
1244   for line in sys.stdin:
1245    infilelist.append(line.strip());
1246   infilelist = list(filter(None, infilelist));
1247  elif(infiles!="-" and dirlistfromtxt and os.path.exists(infiles) and (os.path.isfile(infiles) or infiles=="/dev/null" or infiles=="NUL")):
1248   if(not os.path.exists(infiles) or not os.path.isfile(infiles)):
1249    return False;
1250   with UncompressFile(infiles, formatspecs, "r") as finfile:
1251    for line in finfile:
1252     infilelist.append(line.strip());
1253   infilelist = list(filter(None, infilelist));
1254  else:
1255   if(isinstance(infiles, (list, tuple, ))):
1256    infilelist = list(filter(None, infiles));
1257   elif(isinstance(infiles, (str, ))):
1258    infilelist = list(filter(None, [infiles]));
1259  if(advancedlist):
1260   GetDirList = ListDirAdvanced(infilelist, followlink, False);
1261  else:
1262   GetDirList = ListDir(infilelist, followlink, False);
1263  if(not GetDirList):
1264   return False;
1265  curinode = 0;
1266  curfid = 0;
1267  inodelist = [];
1268  inodetofile = {};
1269  filetoinode = {};
1270  inodetocatinode = {};
1271  numfiles = int(len(GetDirList));
1272  fnumfiles = format(numfiles, 'x').lower();
1273  AppendFileHeader(fp, fnumfiles, checksumtype, formatspecs);
1274  for curfname in GetDirList:
1275   catfhstart = fp.tell();
1276   if(re.findall("^[.|/]", curfname)):
1277    fname = curfname;
1278   else:
1279    fname = "./"+curfname;
1280   if(verbose):
1281    VerbosePrintOut(fname);
1282   if(not followlink or followlink is None):
1283    fstatinfo = os.lstat(fname);
1284   else:
1285    fstatinfo = os.stat(fname);
1286   fpremode = fstatinfo.st_mode;
1287   finode = fstatinfo.st_ino;
1288   flinkcount = fstatinfo.st_nlink;
1289   ftype = 0;
1290   if(stat.S_ISREG(fpremode)):
1291    ftype = 0;
1292   elif(stat.S_ISLNK(fpremode)):
1293    ftype = 2;
1294   elif(stat.S_ISCHR(fpremode)):
1295    ftype = 3;
1296   elif(stat.S_ISBLK(fpremode)):
1297    ftype = 4;
1298   elif(stat.S_ISDIR(fpremode)):
1299    ftype = 5;
1300   elif(stat.S_ISFIFO(fpremode)):
1301    ftype = 6;
1302   elif(stat.S_ISSOCK(fpremode)):
1303    ftype = 8;
1304   elif(hasattr(stat, "S_ISDOOR") and stat.S_ISDOOR(fpremode)):
1305    ftype = 9;
1306   elif(hasattr(stat, "S_ISPORT") and stat.S_ISPORT(fpremode)):
1307    ftype = 10;
1308   elif(hasattr(stat, "S_ISWHT") and stat.S_ISWHT(fpremode)):
1309    ftype = 111;
1310   else:
1311    ftype = 0;
1312   flinkname = "";
1313   fcurfid = format(int(curfid), 'x').lower();
1314   if(not followlink and finode!=0):
1315    if(ftype!=1):
1316     if(finode in inodelist):
1317      ftype = 1;
1318      flinkname = inodetofile[finode];
1319      if(altinode):
1320       fcurinode = format(int(finode), 'x').lower();
1321      else:
1322       fcurinode = format(int(inodetocatinode[finode]), 'x').lower();
1323     if(finode not in inodelist):
1324      inodelist.append(finode);
1325      inodetofile.update({finode: fname});
1326      inodetocatinode.update({finode: curinode});
1327      if(altinode):
1328       fcurinode = format(int(finode), 'x').lower();
1329      else:
1330       fcurinode = format(int(curinode), 'x').lower();
1331      curinode = curinode + 1;
1332   else:
1333    fcurinode = format(int(curinode), 'x').lower();
1334    curinode = curinode + 1;
1335   curfid = curfid + 1;
1336   if(ftype==2):
1337    flinkname = os.readlink(fname);
1338   fdev = fstatinfo.st_dev;
1339   getfdev = GetDevMajorMinor(fdev);
1340   fdev_minor = getfdev[0];
1341   fdev_major = getfdev[1];
1342   frdev = fstatinfo.st_dev;
1343   if(hasattr(fstatinfo, "st_rdev")):
1344    frdev = fstatinfo.st_rdev;
1345   else:
1346    frdev = fstatinfo.st_dev;
1347   getfrdev = GetDevMajorMinor(frdev);
1348   frdev_minor = getfrdev[0];
1349   frdev_major = getfrdev[1];
1350   if(ftype==1 or ftype==2 or ftype==3 or ftype==4 or ftype==5 or ftype==6):
1351    fsize = format(int("0"), 'x').lower();
1352   elif(ftype==0 or ftype==7):
1353    fsize = format(int(fstatinfo.st_size), 'x').lower();
1354   else:
1355    fsize = format(int(fstatinfo.st_size)).lower();
1356   fatime = format(int(fstatinfo.st_atime), 'x').lower();
1357   fmtime = format(int(fstatinfo.st_mtime), 'x').lower();
1358   fctime = format(int(fstatinfo.st_ctime), 'x').lower();
1359   if(hasattr(fstatinfo, "st_birthtime")):
1360    fbtime = format(int(fstatinfo.st_birthtime), 'x').lower();
1361   else:
1362    fbtime = format(int(fstatinfo.st_ctime), 'x').lower();
1363   fmode = format(int(fstatinfo.st_mode), 'x').lower();
1364   fchmode = format(int(stat.S_IMODE(fstatinfo.st_mode)), 'x').lower();
1365   ftypemod = format(int(stat.S_IFMT(fstatinfo.st_mode)), 'x').lower();
1366   fuid = format(int(fstatinfo.st_uid), 'x').lower();
1367   fgid = format(int(fstatinfo.st_gid), 'x').lower();
1368   funame = "";
1369   try:
1370    import pwd;
1371    try:
1372     userinfo = pwd.getpwuid(fstatinfo.st_uid);
1373     funame = userinfo.pw_name;
1374    except KeyError:
1375     funame = "";
1376   except ImportError:
1377    funame = "";
1378   fgname = "";
1379   try:
1380    import grp;
1381    try:
1382     groupinfo = grp.getgrgid(fstatinfo.st_gid);
1383     fgname = groupinfo.gr_name;
1384    except KeyError:
1385     fgname = "";
1386   except ImportError:
1387    fgname = "";
1388   fdev_minor = format(int(fdev_minor), 'x').lower();
1389   fdev_major = format(int(fdev_major), 'x').lower();
1390   frdev_minor = format(int(frdev_minor), 'x').lower();
1391   frdev_major = format(int(frdev_major), 'x').lower();
1392   finode = format(int(finode), 'x').lower();
1393   flinkcount = format(int(flinkcount), 'x').lower();
1394   if(hasattr(fstatinfo, "st_file_attributes")):
1395    fwinattributes = format(int(fstatinfo.st_file_attributes), 'x').lower();
1396   else:
1397    fwinattributes = format(int(0), 'x').lower();
1398   fcontents = "".encode('UTF-8');
1399   chunk_size = 1024;
1400   if(ftype==0 or ftype==7):
1401    with open(fname, "rb") as fpc:
1402     while(True):
1403      chunk = fpc.read(chunk_size);
1404      if(not chunk):
1405       break
1406      fcontents += chunk;
1407   if(followlink and (ftype==1 or ftype==2)):
1408    flstatinfo = os.stat(flinkname);
1409    with open(flinkname, "rb") as fpc:
1410     while(True):
1411      chunk = fpc.read(chunk_size);
1412      if(not chunk):
1413       break;
1414      fcontents += chunk;
1415   ftypehex = format(ftype, 'x').lower();
1416   catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major];
1417   fp = AppendFileHeaderWithContent(fp, catoutlist, extradata, fcontents, checksumtype, formatspecs);
1418  if(numfiles>0):
1419   catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
1420  fp.seek(0, 0);
1421  return fp;
1422
1423 def AppendListsWithContent(inlist, fp, dirlistfromtxt=False, filevalues=[], extradata=[], followlink=False, checksumtype="crc32", formatspecs=__file_format_list__, verbose=False):
1424  if(verbose):
1425   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
1426  GetDirList = inlist;
1427  if(not GetDirList):
1428   return False;
1429  curinode = 0;
1430  curfid = 0;
1431  inodelist = [];
1432  inodetofile = {};
1433  filetoinode = {};
1434  inodetocatinode = {};
1435  numfiles = int(len(GetDirList));
1436  fnumfiles = format(numfiles, 'x').lower();
1437  AppendFileHeader(fp, fnumfiles, checksumtype, formatspecs);
1438  for curfname in GetDirList:
1439   ftype = format(curfname[0], 'x').lower();
1440   if(re.findall("^[.|/]", curfname[1])):
1441    fname = curfname[1];
1442   else:
1443    fname = "./"+curfname[1];
1444   fbasedir = os.path.dirname(fname);
1445   flinkname = curfname[2];
1446   fsize = format(curfname[3], 'x').lower();
1447   fatime = format(curfname[4], 'x').lower();
1448   fmtime = format(curfname[5], 'x').lower();
1449   fctime = format(curfname[6], 'x').lower();
1450   fbtime = format(curfname[7], 'x').lower();
1451   fmode = format(curfname[8], 'x').lower();
1452   fwinattributes = format(curfname[9], 'x').lower();
1453   fuid = format(curfname[10], 'x').lower();
1454   funame = curfname[11];
1455   fgid = format(curfname[12], 'x').lower();
1456   fgname = curfname[13];
1457   fid = format(curfname[14], 'x').lower();
1458   finode = format(curfname[15], 'x').lower();
1459   flinkcount = format(curfname[16], 'x').lower();
1460   fdev_minor = format(curfname[17], 'x').lower();
1461   fdev_major = format(curfname[18], 'x').lower();
1462   frdev_minor = format(curfname[19], 'x').lower();
1463   frdev_major = format(curfname[20], 'x').lower();
1464   extradata = curfname[21];
1465   fchecksumtype = curfname[22];
1466   fcontents = curfname[23];
1467   catoutlist = [ftype, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fuid, funame, fgid, fgname, fid, finode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major];
1468   fp = AppendFileHeaderWithContent(fp, catoutlist, extradata, fcontents, checksumtype, formatspecs);
1469  if(numfiles>0):
1470   catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
1471  fp.seek(0, 0);
1472  return fp;
1473
1474 def AppendInFileWithContent(infile, fp, dirlistfromtxt=False, filevalues=[], extradata=[], followlink=False, checksumtype="crc32", formatspecs=__file_format_list__, verbose=False):
1475  inlist = ReadInFileBySizeWithContentToList(infile, 0, 0, False, False, formatspecs);
1476  return AppendListsWithContent(inlist, fp, dirlistfromtxt, filevalues, extradata, followlink, checksumtype, formatspecs, verbose);
1477
1478 def AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt=False, compression="auto", compressionlevel=None, filevalues=[], extradata=[], followlink=False, checksumtype="crc32", formatspecs=__file_format_list__, verbose=False, returnfp=False):
1479  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
1480   if(os.path.exists(outfile)):
1481    os.unlink(outfile);
1482  if(outfile=="-"):
1483   verbose = False;
1484   catfpfp = BytesIO();
1485  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
1486   catfp = outfile;
1487  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
1488   catfp = BytesIO();
1489  else:
1490   fbasename = os.path.splitext(outfile)[0];
1491   fextname = os.path.splitext(outfile)[1];
1492   catfp = CompressOpenFile(outfile, compressionlevel);
1493  catfp = AppendFilesWithContent(infiles, catfp, dirlistfromtxt, filevalues, extradata, followlink, checksumtype, formatspecs, verbose);
1494  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
1495   catfp = CompressArchiveFile(catfp, compression, formatspecs);
1496   try:
1497    catfp.flush();
1498    os.fsync(catfp.fileno());
1499   except io.UnsupportedOperation:
1500    pass;
1501   except AttributeError:
1502    pass;
1503  if(outfile=="-"):
1504   catfp.seek(0, 0);
1505   if(hasattr(sys.stdout, "buffer")):
1506    shutil.copyfileobj(catfp, sys.stdout.buffer);
1507   else:
1508    shutil.copyfileobj(catfp, sys.stdout);
1509  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
1510   catfp = CompressArchiveFile(catfp, compression, formatspecs);
1511   catfp.seek(0, 0);
1512   upload_file_to_internet_file(catfp, outfile);
1513  if(returnfp):
1514   catfp.seek(0, 0);
1515   return catfp;
1516  else:
1517   catfp.close();
1518   return True;
1519
1520 def AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt=False, compression="auto", compressionlevel=None, filevalues=[], extradata=[], followlink=False, checksumtype="crc32", formatspecs=__file_format_list__, verbose=False, returnfp=False):
1521  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
1522   if(os.path.exists(outfile)):
1523    os.unlink(outfile);
1524  if(outfile=="-"):
1525   verbose = False;
1526   catfpfp = BytesIO();
1527  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
1528   catfp = outfile;
1529  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
1530   catfp = BytesIO();
1531  else:
1532   fbasename = os.path.splitext(outfile)[0];
1533   fextname = os.path.splitext(outfile)[1];
1534   catfp = CompressOpenFile(outfile, compressionlevel);
1535  catfp = AppendListsWithContent(inlist, catfp, dirlistfromtxt, filevalues, extradata, followlink, checksumtype, formatspecs, verbose);
1536  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
1537   catfp = CompressArchiveFile(catfp, compression, formatspecs);
1538   try:
1539    catfp.flush();
1540    os.fsync(catfp.fileno());
1541   except io.UnsupportedOperation:
1542    pass;
1543   except AttributeError:
1544    pass;
1545  if(outfile=="-"):
1546   catfp.seek(0, 0);
1547   if(hasattr(sys.stdout, "buffer")):
1548    shutil.copyfileobj(catfp, sys.stdout.buffer);
1549   else:
1550    shutil.copyfileobj(catfp, sys.stdout);
1551  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
1552   catfp = CompressArchiveFile(catfp, compression, formatspecs);
1553   catfp.seek(0, 0);
1554   upload_file_to_internet_file(catfp, outfile);
1555  if(returnfp):
1556   catfp.seek(0, 0);
1557   return catfp;
1558  else:
1559   catfp.close();
1560   return True;
1561
1562 def AppendInFileWithContentToOutFile(infile, outfile, dirlistfromtxt=False, compression="auto", compressionlevel=None, filevalues=[], extradata=[], followlink=False, checksumtype="crc32", formatspecs=__file_format_list__, verbose=False, returnfp=False):
1563  inlist = ReadInFileBySizeWithContentToList(infile, 0, 0, False, False, formatspecs);
1564  return AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt, compression, compressionlevel, filevalues, extradata, followlink, checksumtype, formatspecs, verbose, returnfp);
1565
1566 def PrintPermissionString(fchmode, ftype):
1567  permissions = { 'access': { '0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': ('r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx') }, 'roles': { 0: 'owner', 1: 'group', 2: 'other' } };
1568  permissionstr = "";
1569  for fmodval in str(oct(fchmode))[-3:]:
1570   permissionstr = permissionstr + permissions['access'].get(fmodval, '---');
1571  if(ftype==0 or ftype==7):
1572   permissionstr = "-" + permissionstr;
1573  if(ftype==1):
1574   permissionstr = "h" + permissionstr;
1575  if(ftype==2):
1576   permissionstr = "l" + permissionstr;
1577  if(ftype==3):
1578   permissionstr = "c" + permissionstr;
1579  if(ftype==4):
1580   permissionstr = "b" + permissionstr;
1581  if(ftype==5):
1582   permissionstr = "d" + permissionstr;
1583  if(ftype==6):
1584   permissionstr = "f" + permissionstr;
1585  if(ftype==8):
1586   permissionstr = "D" + permissionstr;
1587  if(ftype==9):
1588   permissionstr = "p" + permissionstr;
1589  if(ftype==10):
1590   permissionstr = "w" + permissionstr;
1591  try:
1592   permissionoutstr = stat.filemode(fchmode);
1593  except AttributeError:
1594   permissionoutstr = permissionstr;
1595  except KeyError:
1596   permissionoutstr = permissionstr;
1597  return permissionoutstr;
1598
1599 def PrintPermissionStringAlt(fchmode, ftype):
1600  permissions = {
1601   '0': '---', '1': '--x', '2': '-w-', '3': '-wx',
1602   '4': 'r--', '5': 'r-x', '6': 'rw-', '7': 'rwx'
1603  };
1604  # Translate file mode into permission string
1605  permissionstr = ''.join([permissions[i] for i in str(oct(fchmode))[-3:]]);
1606  # Append file type indicator
1607  type_indicators = {
1608   0: '-', 1: 'h', 2: 'l', 3: 'c', 4: 'b',
1609   5: 'd', 6: 'f', 8: 'D', 9: 'p', 10: 'w'
1610  };
1611  file_type = type_indicators.get(ftype, '-');
1612  permissionstr = file_type + permissionstr;
1613  try:
1614   permissionoutstr = stat.filemode(fchmode);
1615  except AttributeError:
1616   permissionoutstr = permissionstr;
1617  return permissionoutstr;
1618
1619 def CompressionSupport():
1620  compression_list = [];
1621  try:
1622   import gzip;
1623   compression_list.append("gz");
1624   compression_list.append("gzip");
1625  except ImportError:
1626   '''return False;'''
1627  try:
1628   import bz2;
1629   compression_list.append("bz2");
1630   compression_list.append("bzip2");
1631  except ImportError:
1632   '''return False;'''
1633  try:
1634   import lz4;
1635   compression_list.append("lz4");
1636  except ImportError:
1637   '''return False;'''
1638  try:
1639   import lzo;
1640   compression_list.append("lzo");
1641   compression_list.append("lzop");
1642  except ImportError:
1643   '''return False;'''
1644  try:
1645   import zstandard;
1646   compression_list.append("zstd");
1647   compression_list.append("zstandard");
1648  except ImportError:
1649   '''return False;'''
1650  try:
1651   import lzma;
1652   compression_list.append("lzma");
1653   compression_list.append("xz");
1654  except ImportError:
1655   '''return False;'''
1656  return compression_list;
1657
1658 def CheckCompressionType(infile, formatspecs=__file_format_list__, closefp=True):
1659  if(hasattr(infile, "read") or hasattr(infile, "write")):
1660   catfp = infile;
1661  else:
1662   try:
1663    catfp = open(infile, "rb");
1664   except FileNotFoundError:
1665    return False;
1666  catfp.seek(0, 0);
1667  prefp = catfp.read(2);
1668  filetype = False;
1669  if(prefp==binascii.unhexlify("1f8b")):
1670   filetype = "gzip";
1671  catfp.seek(0, 0);
1672  prefp = catfp.read(3);
1673  if(prefp==binascii.unhexlify("425a68")):
1674   filetype = "bzip2";
1675  if(prefp==binascii.unhexlify("5d0000")):
1676   filetype = "lzma";
1677  catfp.seek(0, 0);
1678  prefp = catfp.read(4);
1679  if(prefp==binascii.unhexlify("28b52ffd")):
1680   filetype = "zstd";
1681  if(prefp==binascii.unhexlify("04224d18")):
1682   filetype = "lz4";
1683  if(prefp==binascii.unhexlify("504B0304")):
1684   filetype = "zipfile";
1685  catfp.seek(0, 0);
1686  prefp = catfp.read(5);
1687  if(prefp==binascii.unhexlify("7573746172")):
1688   filetype = "tarfile";
1689  catfp.seek(0, 0);
1690  prefp = catfp.read(6);
1691  if(prefp==binascii.unhexlify("fd377a585a00")):
1692   filetype = "lzma";
1693  if(prefp==binascii.unhexlify("377abcaf271c")):
1694   filetype = "7zipfile";
1695  catfp.seek(0, 0);
1696  prefp = catfp.read(7);
1697  if(prefp==binascii.unhexlify("526172211a0700")):
1698   filetype = "rarfile";
1699  if(prefp==binascii.unhexlify("43617446696c65")):
1700   filetype = "catfile";
1701  catfp.seek(0, 0);
1702  prefp = catfp.read(8);
1703  if(prefp==binascii.unhexlify("526172211a070100")):
1704   filetype = "rarfile";
1705  catfp.seek(0, 0);
1706  prefp = catfp.read(formatspecs[3]);
1707  if(prefp==binascii.unhexlify(formatspecs[4])):
1708   filetype = formatspecs[2];
1709  catfp.seek(0, 0);
1710  prefp = catfp.read(9);
1711  if(prefp==binascii.unhexlify("894c5a4f000d0a1a0a")):
1712   filetype = "lzo";
1713  catfp.seek(0, 0);
1714  prefp = catfp.read(10);
1715  if(prefp==binascii.unhexlify("7061785f676c6f62616c")):
1716   filetype = "tarfile";
1717  catfp.seek(0, 0);
1718  if(closefp):
1719   catfp.close();
1720  return filetype;
1721
1722 def CheckCompressionTypeFromString(instring, formatspecs=__file_format_list__, closefp=True):
1723  try:
1724   instringsfile = BytesIO(instring);
1725  except TypeError:
1726   instringsfile = BytesIO(instring.encode("UTF-8"));
1727  return CheckCompressionType(instringsfile, formatspecs, closefp);
1728
1729 def GetCompressionMimeType(infile, formatspecs=__file_format_list__):
1730  compresscheck = CheckCompressionType(fp, formatspecs, False);
1731  if(compresscheck=="gzip" or compresscheck=="gz"):
1732   return archivefile_gzip_mimetype;
1733  if(compresscheck=="bzip2" or compresscheck=="bz2"):
1734   return archivefile_bzip2_mimetype;
1735  if(compresscheck=="zstd" or compresscheck=="zstandard"):
1736   return archivefile_zstandard_mimetype;
1737  if(compresscheck=="lz4"):
1738   return archivefile_lz4_mimetype;
1739  if(compresscheck=="lzo" or compresscheck=="lzop"):
1740   return archivefile_lzop_mimetype;
1741  if(compresscheck=="lzma"):
1742   return archivefile_lzma_mimetype;
1743  if(compresscheck=="xz"):
1744   return archivefile_xz_mimetype;
1745  if(compresscheck=="catfile" or compresscheck=="cat" or compresscheck==formatspecs[2]):
1746   return archivefile_cat_mimetype;
1747  if(not compresscheck):
1748   return False;
1749  return False;
1750
1751 def UncompressArchiveFile(fp, formatspecs=__file_format_list__):
1752  if(not hasattr(fp, "read") and not hasattr(fp, "write")):
1753   return False;
1754  compresscheck = CheckCompressionType(fp, formatspecs, False);
1755  if(compresscheck=="gzip"):
1756   try:
1757    import gzip;
1758   except ImportError:
1759    return False;
1760   catfp = gzip.GzipFile(fileobj=fp, mode="rb");
1761  if(compresscheck=="bzip2"):
1762   try:
1763    import bz2;
1764   except ImportError:
1765    return False;
1766   catfp = BytesIO();
1767   catfp.write(bz2.decompress(fp.read()));
1768  if(compresscheck=="zstd"):
1769   try:
1770    import zstandard;
1771   except ImportError:
1772    return False;
1773   catfp = BytesIO();
1774   catfp.write(zstandard.decompress(fp.read()));
1775  if(compresscheck=="lz4"):
1776   try:
1777    import lz4.frame;
1778   except ImportError:
1779    return False;
1780   catfp = BytesIO();
1781   catfp.write(lz4.frame.decompress(fp.read()));
1782  if(compresscheck=="lzo" or compresscheck=="lzop"):
1783   try:
1784    import lzo;
1785   except ImportError:
1786    return False;
1787   catfp = BytesIO();
1788   catfp.write(lzo.decompress(fp.read()));
1789  if(compresscheck=="lzma" or compresscheck=="xz"):
1790   try:
1791    import lzma;
1792   except ImportError:
1793    return False;
1794   catfp = BytesIO();
1795   catfp.write(lzma.decompress(fp.read()));
1796  if(compresscheck=="catfile" or compresscheck==formatspecs[2]):
1797   catfp = fp;
1798  if(not compresscheck):
1799   try:
1800    import lzma;
1801   except ImportError:
1802    return False;
1803   catfp = BytesIO();
1804   with fp as fpcontent:
1805    try:
1806     catfp.write(lzma.decompress(fp.read()));
1807    except lzma.LZMAError:
1808     return False;
1809  return catfp;
1810
1811 create_alias_function("Uncompress", __file_format_name__, "", UncompressArchiveFile);
1812
1813 def UncompressFile(infile, formatspecs=__file_format_list__, mode="rb"):
1814  compresscheck = CheckCompressionType(infile, formatspecs, False);
1815  if(sys.version_info[0]==2 and compresscheck):
1816   if(mode=="rt"):
1817    mode = "r";
1818   if(mode=="wt"):
1819    mode = "w";
1820  try:
1821   if(compresscheck=="gzip"):
1822    try:
1823     import gzip;
1824    except ImportError:
1825     return False;
1826    try:
1827     filefp = gzip.open(infile, mode, encoding="UTF-8");
1828    except (ValueError, TypeError) as e:
1829     filefp = gzip.open(infile, mode);
1830   if(compresscheck=="bzip2"):
1831    try:
1832     import bz2;
1833    except ImportError:
1834     return False;
1835    try:
1836     filefp = bz2.open(infile, mode, encoding="UTF-8");
1837    except (ValueError, TypeError) as e:
1838     filefp = bz2.open(infile, mode);
1839   if(compresscheck=="zstd"):
1840    try:
1841     import zstandard;
1842    except ImportError:
1843     return False;
1844    try:
1845     filefp = zstandard.open(infile, mode, encoding="UTF-8");
1846    except (ValueError, TypeError) as e:
1847     filefp = zstandard.open(infile, mode);
1848   if(compresscheck=="lz4"):
1849    try:
1850     import lz4.frame;
1851    except ImportError:
1852     return False;
1853    try:
1854     filefp = lz4.frame.open(infile, mode, encoding="UTF-8");
1855    except (ValueError, TypeError) as e:
1856     filefp = lz4.frame.open(infile, mode);
1857   if(compresscheck=="lzo"):
1858    try:
1859     import lzo;
1860    except ImportError:
1861     return False;
1862    try:
1863     filefp = lzo.open(infile, mode, encoding="UTF-8");
1864    except (ValueError, TypeError) as e:
1865     filefp = lzo.open(infile, mode);
1866   if(compresscheck=="lzma"):
1867    try:
1868     import lzma;
1869    except ImportError:
1870     return False;
1871    try:
1872     filefp = lzma.open(infile, mode, encoding="UTF-8");
1873    except (ValueError, TypeError) as e:
1874     filefp = lzma.open(infile, mode);
1875   if(compresscheck=="catfile" or compresscheck==formatspecs[2]):
1876    try:
1877     filefp = open(infile, mode, encoding="UTF-8");
1878    except (ValueError, TypeError) as e:
1879     filefp = open(infile, mode);
1880   if(not compresscheck):
1881    try:
1882     filefp = open(infile, mode, encoding="UTF-8");
1883    except (ValueError, TypeError) as e:
1884     filefp = open(infile, mode);
1885  except FileNotFoundError:
1886   return False;
1887  return filefp;
1888
1889 def UncompressString(infile):
1890  compresscheck = CheckCompressionTypeFromString(infile, formatspecs, False);
1891  if(compresscheck=="gzip"):
1892   try:
1893    import gzip;
1894   except ImportError:
1895    return False;
1896   fileuz = gzip.decompress(infile);
1897  if(compresscheck=="bzip2"):
1898   try:
1899    import bz2;
1900   except ImportError:
1901    return False;
1902   fileuz = bz2.decompress(infile);
1903  if(compresscheck=="zstd"):
1904   try:
1905    import zstandard;
1906   except ImportError:
1907    return False;
1908   fileuz = zstandard.decompress(infile);
1909  if(compresscheck=="lz4"):
1910   try:
1911    import lz4.frame;
1912   except ImportError:
1913    return False;
1914   fileuz = lz4.frame.decompress(infile);
1915  if(compresscheck=="lzo"):
1916   try:
1917    import lzo;
1918   except ImportError:
1919    return False;
1920   fileuz = lzo.decompress(infile);
1921  if(compresscheck=="lzma"):
1922   try:
1923    import lzma;
1924   except ImportError:
1925    return False;
1926   fileuz = lzma.decompress(infile);
1927  if(not compresscheck):
1928   fileuz = infile;
1929  if(hasattr(fileuz, 'decode')):
1930   fileuz = fileuz.decode("UTF-8");
1931  return fileuz;
1932
1933 def UncompressStringAlt(infile):
1934  filefp = StringIO();
1935  outstring = UncompressString(infile);
1936  filefp.write(outstring);
1937  filefp.seek(0, 0);
1938  return filefp;
1939
1940 def CheckCompressionSubType(infile, formatspecs=__file_format_list__, closefp=True):
1941  compresscheck = CheckCompressionType(infile, formatspecs, False);
1942  if(not compresscheck):
1943   fextname = os.path.splitext(infile)[1];
1944   if(fextname==".gz"):
1945    compresscheck = "gzip";
1946   elif(fextname==".bz2"):
1947    compresscheck = "bzip2";
1948   elif(fextname==".zst"):
1949    compresscheck = "zstd";
1950   elif(fextname==".lz4"):
1951    compresscheck = "lz4";
1952   elif(fextname==".lzo" or fextname==".lzop"):
1953    compresscheck = "lzo";
1954   elif(fextname==".lzma" or fextname==".xz"):
1955    compresscheck = "lzma";
1956   else:
1957    return False;
1958  if(not compresscheck):
1959   return False;
1960  if(compresscheck=="catfile"):
1961   return "catfile";
1962  if(compresscheck==formatspecs[2]):
1963   return formatspecs[2];
1964  if(compresscheck=="tarfile"):
1965   return "tarfile";
1966  if(compresscheck=="zipfile"):
1967   return "zipfile";
1968  if(rarfile_support and compresscheck=="rarfile"):
1969   return "rarfile";
1970  if(py7zr_support and compresscheck=="7zipfile"):
1971   return "7zipfile";
1972  if(hasattr(infile, "read") or hasattr(infile, "write")):
1973   catfp = UncompressArchiveFile(infile, formatspecs[2]);
1974  else:
1975   try:
1976    if(compresscheck=="gzip"):
1977     try:
1978      import gzip;
1979     except ImportError:
1980      return False;
1981     catfp = gzip.GzipFile(infile, "rb");
1982    if(compresscheck=="bzip2"):
1983     try:
1984      import bz2;
1985     except ImportError:
1986      return False;
1987     catfp = bz2.BZ2File(infile, "rb");
1988    if(compresscheck=="lz4"):
1989     try:
1990      import lz4.frame;
1991     except ImportError:
1992      return False;
1993     catfp = lz4.frame.open(infile, "rb");
1994    if(compresscheck=="zstd"):
1995     try:
1996      import zstandard;
1997     except ImportError:
1998      return False;
1999     catfp = zstandard.open(infile, "rb");
2000    if(compresscheck=="lzma" or compresscheck=="xz"):
2001     try:
2002      import lzma;
2003     except ImportError:
2004      return False;
2005     catfp = lzma.open(infile, "rb");
2006   except FileNotFoundError:
2007    return False;
2008  filetype = False;
2009  prefp = catfp.read(5);
2010  if(prefp==binascii.unhexlify("7573746172")):
2011   filetype = "tarfile";
2012  catfp.seek(0, 0);
2013  prefp = catfp.read(7);
2014  if(prefp==binascii.unhexlify("43617446696c65")):
2015   filetype = "catfile";
2016  catfp.seek(0, 0);
2017  prefp = catfp.read(formatspecs[3]);
2018  if(prefp==binascii.unhexlify(formatspecs[4])):
2019   filetype = formatspecs[2];
2020  catfp.seek(0, 0);
2021  prefp = catfp.read(10);
2022  if(prefp==binascii.unhexlify("7061785f676c6f62616c")):
2023   filetype = "tarfile";
2024  catfp.seek(0, 0);
2025  if(closefp):
2026   catfp.close();
2027  return filetype;
2028
2029 def GZipCompress(data, compresslevel=9):
2030  try:
2031   import gzip;
2032  except ImportError:
2033   return False;
2034  tmpfp = tempfile.NamedTemporaryFile("wb", delete=False);
2035  tmpfp.close();
2036  tmpfp = gzip.GzipFile(tmpfp.name, mode="wb", compresslevel=compresslevel);
2037  tmpfp.write(data);
2038  tmpfp.close();
2039  try:
2040   catfp = open(tmpfp.name, "rb");
2041  except FileNotFoundError:
2042   return False;
2043  catdata = catfp.read();
2044  catfp.close();
2045  return catdata;
2046
2047 def CompressArchiveFile(fp, compression="auto", compressionlevel=None, formatspecs=__file_format_list__):
2048  if(not hasattr(fp, "read") and not hasattr(fp, "write")):
2049   return False;
2050  fp.seek(0, 0);
2051  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
2052   compression = None;
2053  if(compression not in compressionlist and compression is None):
2054   compression = "auto";
2055  if(compression=="gzip"):
2056   try:
2057    import gzip;
2058   except ImportError:
2059    return False;
2060   catfp = BytesIO();
2061   if(compressionlevel is None):
2062    compressionlevel = 9;
2063   else:
2064    compressionlevel = int(compressionlevel);
2065   catfp.write(gzip.compress(fp.read(), compresslevel=compressionlevel));
2066  if(compression=="bzip2"):
2067   try:
2068    import bz2;
2069   except ImportError:
2070    return False;
2071   catfp = BytesIO();
2072   if(compressionlevel is None):
2073    compressionlevel = 9;
2074   else:
2075    compressionlevel = int(compressionlevel);
2076   catfp.write(bz2.compress(fp.read(), compresslevel=compressionlevel));
2077  if(compression=="lz4"):
2078   try:
2079    import lz4.frame;
2080   except ImportError:
2081    return False;
2082   catfp = BytesIO();
2083   if(compressionlevel is None):
2084    compressionlevel = 9;
2085   else:
2086    compressionlevel = int(compressionlevel);
2087   catfp.write(lz4.frame.compress(fp.read(), compression_level=compressionlevel));
2088  if(compression=="lzo" or compression=="lzop"):
2089   try:
2090    import lzo;
2091   except ImportError:
2092    return False;
2093   catfp = BytesIO();
2094   if(compressionlevel is None):
2095    compressionlevel = 9;
2096   else:
2097    compressionlevel = int(compressionlevel);
2098   catfp.write(lzo.compress(fp.read(), compresslevel=compressionlevel));
2099  if(compression=="zstd"):
2100   try:
2101    import zstandard;
2102   except ImportError:
2103    return False;
2104   catfp = BytesIO();
2105   if(compressionlevel is None):
2106    compressionlevel = 10;
2107   else:
2108    compressionlevel = int(compressionlevel);
2109   catfp.write(zstandard.compress(fp.read(), level=compressionlevel));
2110  if(compression=="lzma"):
2111   try:
2112    import lzma;
2113   except ImportError:
2114    return False;
2115   catfp = BytesIO();
2116   if(compressionlevel is None):
2117    compressionlevel = 9;
2118   else:
2119    compressionlevel = int(compressionlevel);
2120   catfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_ALONE, filters=[{"id": lzma.FILTER_LZMA1, "preset": compressionlevel}]));
2121  if(compression=="xz"):
2122   try:
2123    import lzma;
2124   except ImportError:
2125    return False;
2126   catfp = BytesIO();
2127   if(compressionlevel is None):
2128    compressionlevel = 9;
2129   else:
2130    compressionlevel = int(compressionlevel);
2131   catfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_XZ, filters=[{"id": lzma.FILTER_LZMA2, "preset": compressionlevel}]));
2132  if(compression=="auto" or compression is None):
2133   catfp = fp;
2134  catfp.seek(0, 0);
2135  return catfp;
2136
2137 create_alias_function("Compress", __file_format_name__, "", CompressArchiveFile);
2138
2139 def CompressOpenFile(outfile, compressionlevel=None):
2140  if(outfile is None):
2141   return False;
2142  fbasename = os.path.splitext(outfile)[0];
2143  fextname = os.path.splitext(outfile)[1];
2144  if(compressionlevel is None and fextname!=".zst"):
2145   compressionlevel = 9;
2146  elif(compressionlevel is None and fextname==".zst"):
2147   compressionlevel = 10;
2148  else:
2149   compressionlevel = int(compressionlevel);
2150  if(sys.version_info[0]==2):
2151   mode = "w";
2152  else:
2153   mode = "wb";
2154  try:
2155   if(fextname not in outextlistwd):
2156    try:
2157     outfp = open(outfile, "wb", encoding="UTF-8");
2158    except (ValueError, TypeError) as e:
2159     outfp = open(outfile, "wb");
2160   elif(fextname==".gz"):
2161    try:
2162     import gzip;
2163    except ImportError:
2164     return False;
2165    try:
2166     outfp = gzip.open(outfile, mode, compressionlevel, encoding="UTF-8");
2167    except (ValueError, TypeError) as e:
2168     outfp = gzip.open(outfile, mode, compressionlevel);
2169   elif(fextname==".bz2"):
2170    try:
2171     import bz2;
2172    except ImportError:
2173     return False;
2174    try:
2175     outfp = bz2.open(outfile, mode, compressionlevel, encoding="UTF-8");
2176    except (ValueError, TypeError) as e:
2177     outfp = bz2.open(outfile, mode, compressionlevel);
2178   elif(fextname==".zst"):
2179    try:
2180     import zstandard;
2181    except ImportError:
2182     return False;
2183    try:
2184     outfp = zstandard.open(outfile, mode, zstandard.ZstdCompressor(level=compressionlevel), encoding="UTF-8");
2185    except (ValueError, TypeError) as e:
2186     outfp = zstandard.open(outfile, mode, zstandard.ZstdCompressor(level=compressionlevel));
2187   elif(fextname==".xz"):
2188    try:
2189     import lzma;
2190    except ImportError:
2191     return False;
2192    try:
2193     outfp = lzma.open(outfile, mode, format=lzma.FORMAT_XZ, filters=[{"id": lzma.FILTER_LZMA2, "preset": compressionlevel}], encoding="UTF-8");
2194    except (ValueError, TypeError) as e:
2195     outfp = lzma.open(outfile, mode, format=lzma.FORMAT_XZ, filters=[{"id": lzma.FILTER_LZMA2, "preset": compressionlevel}]);
2196   elif(fextname==".lz4"):
2197    try:
2198     import lz4.frame;
2199    except ImportError:
2200     return False;
2201    try:
2202     outfp = lz4.frame.open(outfile, mode, compression_level=compressionlevel, encoding="UTF-8");
2203    except (ValueError, TypeError) as e:
2204     outfp = lz4.frame.open(outfile, mode, compression_level=compressionlevel);
2205   elif(fextname==".lzo"):
2206    try:
2207     import lzo;
2208    except ImportError:
2209     return False;
2210    try:
2211     outfp = lzo.open(outfile, mode, compresslevel=compressionlevel, encoding="UTF-8");
2212    except (ValueError, TypeError) as e:
2213     outfp = lzo.open(outfile, mode, compresslevel=compressionlevel);
2214   elif(fextname==".lzma"):
2215    try:
2216     import lzma;
2217    except ImportError:
2218     return False;
2219    try:
2220     outfp = lzma.open(outfile, mode, format=lzma.FORMAT_ALONE, filters=[{"id": lzma.FILTER_LZMA1, "preset": compressionlevel}], encoding="UTF-8");
2221    except (ValueError, TypeError) as e:
2222     outfp = lzma.open(outfile, mode, format=lzma.FORMAT_ALONE, filters=[{"id": lzma.FILTER_LZMA1, "preset": compressionlevel}]);
2223  except FileNotFoundError:
2224   return False;
2225  return outfp;
2226
2227 def GetDevMajorMinor(fdev):
2228  retdev = [];
2229  if(hasattr(os, "minor")):
2230   retdev.append(os.minor(fdev));
2231  else:
2232   retdev.append(0);
2233  if(hasattr(os, "major")):
2234   retdev.append(os.major(fdev));
2235  else:
2236   retdev.append(0);
2237  return retdev;
2238
2239 def CheckSumSupport(checkfor, guaranteed=True):
2240  if(guaranteed):
2241   hash_list = sorted(list(hashlib.algorithms_guaranteed));
2242  else:
2243   hash_list = sorted(list(hashlib.algorithms_available));
2244  checklistout = sorted(hash_list + ['adler32', 'crc16', 'crc16_ansi', 'crc16_ibm', 'crc16_ccitt', 'crc32', 'crc64', 'crc64_ecma', 'crc64_iso', 'none']);
2245  if(checkfor in checklistout):
2246   return True;
2247  else:
2248   return False;
2249
2250 def CheckSumSupportAlt(checkfor, guaranteed=True):
2251  if(guaranteed):
2252   hash_list = sorted(list(hashlib.algorithms_guaranteed));
2253  else:
2254   hash_list = sorted(list(hashlib.algorithms_available));
2255  checklistout = hash_list;
2256  if(checkfor in checklistout):
2257   return True;
2258  else:
2259   return False;
2260
2261 def PackArchiveFile(infiles, outfile, dirlistfromtxt=False, compression="auto", compressionlevel=None, followlink=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
2262  advancedlist = formatspecs[8];
2263  altinode = formatspecs[9];
2264  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2265   outfile = RemoveWindowsPath(outfile);
2266  checksumtype = checksumtype.lower();
2267  if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
2268   checksumtype="crc32";
2269  if(checksumtype=="none"):
2270   checksumtype = "";
2271  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
2272   compression = None;
2273  if(compression not in compressionlist and compression is None):
2274   compression = "auto";
2275  if(verbose):
2276   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
2277  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2278   if(os.path.exists(outfile)):
2279    os.unlink(outfile);
2280  if(outfile=="-"):
2281   verbose = False;
2282   catfp = BytesIO();
2283  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
2284   catfp = outfile;
2285  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
2286   catfp = BytesIO();
2287  else:
2288   fbasename = os.path.splitext(outfile)[0];
2289   fextname = os.path.splitext(outfile)[1];
2290   catfp = CompressOpenFile(outfile, compressionlevel);
2291  catver = formatspecs[6];
2292  fileheaderver = str(int(catver.replace(".", "")));
2293  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
2294  catfp.write(fileheader.encode('UTF-8'));
2295  infilelist = [];
2296  if(infiles=="-"):
2297   for line in sys.stdin:
2298    infilelist.append(line.strip());
2299   infilelist = list(filter(None, infilelist));
2300  elif(infiles!="-" and dirlistfromtxt and os.path.exists(infiles) and (os.path.isfile(infiles) or infiles=="/dev/null" or infiles=="NUL")):
2301   if(not os.path.exists(infiles) or not os.path.isfile(infiles)):
2302    return False;
2303   with UncompressFile(infiles, formatspecs, "r") as finfile:
2304    for line in finfile:
2305     infilelist.append(line.strip());
2306   infilelist = list(filter(None, infilelist));
2307  else:
2308   if(isinstance(infiles, (list, tuple, ))):
2309    infilelist = list(filter(None, infiles));
2310   elif(isinstance(infiles, (str, ))):
2311    infilelist = list(filter(None, [infiles]));
2312  if(advancedlist):
2313   GetDirList = ListDirAdvanced(infilelist, followlink, False);
2314  else:
2315   GetDirList = ListDir(infilelist, followlink, False);
2316  if(not GetDirList):
2317   return False;
2318  curinode = 0;
2319  curfid = 0;
2320  inodelist = [];
2321  inodetofile = {};
2322  filetoinode = {};
2323  inodetocatinode = {};
2324  numfiles = int(len(GetDirList));
2325  fnumfiles = format(int(len(GetDirList)), 'x').lower();
2326  fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
2327  if(checksumtype=="none" or checksumtype==""):
2328   catfileheadercshex = format(0, 'x').lower();
2329  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2330   catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2331  elif(checksumtype=="crc16_ccitt"):
2332   catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2333  elif(checksumtype=="adler32"):
2334   catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2335  elif(checksumtype=="crc32"):
2336   catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2337  elif(checksumtype=="crc64_ecma"):
2338   catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2339  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2340   catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2341  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2342   checksumoutstr = hashlib.new(checksumtype);
2343   checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
2344   catfileheadercshex = checksumoutstr.hexdigest().lower();
2345  else:
2346   catfileheadercshex = format(0, 'x').lower
2347  fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
2348  catfp.write(fnumfilesa.encode('UTF-8'));
2349  try:
2350   catfp.flush();
2351   os.fsync(catfp.fileno());
2352  except io.UnsupportedOperation:
2353   pass;
2354  except AttributeError:
2355   pass;
2356  for curfname in GetDirList:
2357   catfhstart = catfp.tell();
2358   if(re.findall("^[.|/]", curfname)):
2359    fname = curfname;
2360   else:
2361    fname = "./"+curfname;
2362   if(verbose):
2363    VerbosePrintOut(fname);
2364   if(not followlink or followlink is None):
2365    fstatinfo = os.lstat(fname);
2366   else:
2367    fstatinfo = os.stat(fname);
2368   fpremode = fstatinfo.st_mode;
2369   finode = fstatinfo.st_ino;
2370   flinkcount = fstatinfo.st_nlink;
2371   ftype = 0;
2372   if(stat.S_ISREG(fpremode)):
2373    ftype = 0;
2374   elif(stat.S_ISLNK(fpremode)):
2375    ftype = 2;
2376   elif(stat.S_ISCHR(fpremode)):
2377    ftype = 3;
2378   elif(stat.S_ISBLK(fpremode)):
2379    ftype = 4;
2380   elif(stat.S_ISDIR(fpremode)):
2381    ftype = 5;
2382   elif(stat.S_ISFIFO(fpremode)):
2383    ftype = 6;
2384   elif(stat.S_ISSOCK(fpremode)):
2385    ftype = 8;
2386   elif(hasattr(stat, "S_ISDOOR") and stat.S_ISDOOR(fpremode)):
2387    ftype = 9;
2388   elif(hasattr(stat, "S_ISPORT") and stat.S_ISPORT(fpremode)):
2389    ftype = 10;
2390   elif(hasattr(stat, "S_ISWHT") and stat.S_ISWHT(fpremode)):
2391    ftype = 111;
2392   else:
2393    ftype = 0;
2394   flinkname = "";
2395   fcurfid = format(int(curfid), 'x').lower();
2396   if(not followlink and finode!=0):
2397    if(ftype!=1):
2398     if(finode in inodelist):
2399      ftype = 1;
2400      flinkname = inodetofile[finode];
2401      if(altinode):
2402       fcurinode = format(int(finode), 'x').lower();
2403      else:
2404       fcurinode = format(int(inodetocatinode[finode]), 'x').lower();
2405     if(finode not in inodelist):
2406      inodelist.append(finode);
2407      inodetofile.update({finode: fname});
2408      inodetocatinode.update({finode: curinode});
2409      if(altinode):
2410       fcurinode = format(int(finode), 'x').lower();
2411      else:
2412       fcurinode = format(int(curinode), 'x').lower();
2413      curinode = curinode + 1;
2414   else:
2415    fcurinode = format(int(curinode), 'x').lower();
2416    curinode = curinode + 1;
2417   curfid = curfid + 1;
2418   if(ftype==2):
2419    flinkname = os.readlink(fname);
2420   fdev = fstatinfo.st_dev;
2421   getfdev = GetDevMajorMinor(fdev);
2422   fdev_minor = getfdev[0];
2423   fdev_major = getfdev[1];
2424   frdev = fstatinfo.st_dev;
2425   if(hasattr(fstatinfo, "st_rdev")):
2426    frdev = fstatinfo.st_rdev;
2427   else:
2428    frdev = fstatinfo.st_dev;
2429   getfrdev = GetDevMajorMinor(frdev);
2430   frdev_minor = getfrdev[0];
2431   frdev_major = getfrdev[1];
2432   if(ftype==1 or ftype==2 or ftype==3 or ftype==4 or ftype==5 or ftype==6):
2433    fsize = format(int("0"), 'x').lower();
2434   elif(ftype==0 or ftype==7):
2435    fsize = format(int(fstatinfo.st_size), 'x').lower();
2436   else:
2437    fsize = format(int(fstatinfo.st_size)).lower();
2438   fatime = format(int(fstatinfo.st_atime), 'x').lower();
2439   fmtime = format(int(fstatinfo.st_mtime), 'x').lower();
2440   fctime = format(int(fstatinfo.st_ctime), 'x').lower();
2441   if(hasattr(fstatinfo, "st_birthtime")):
2442    fbtime = format(int(fstatinfo.st_birthtime), 'x').lower();
2443   else:
2444    fbtime = format(int(fstatinfo.st_ctime), 'x').lower();
2445   fmode = format(int(fstatinfo.st_mode), 'x').lower();
2446   fchmode = format(int(stat.S_IMODE(fstatinfo.st_mode)), 'x').lower();
2447   ftypemod = format(int(stat.S_IFMT(fstatinfo.st_mode)), 'x').lower();
2448   fuid = format(int(fstatinfo.st_uid), 'x').lower();
2449   fgid = format(int(fstatinfo.st_gid), 'x').lower();
2450   funame = "";
2451   try:
2452    import pwd;
2453    try:
2454     userinfo = pwd.getpwuid(fstatinfo.st_uid);
2455     funame = userinfo.pw_name;
2456    except KeyError:
2457     funame = "";
2458   except ImportError:
2459    funame = "";
2460   fgname = "";
2461   try:
2462    import grp;
2463    try:
2464     groupinfo = grp.getgrgid(fstatinfo.st_gid);
2465     fgname = groupinfo.gr_name;
2466    except KeyError:
2467     fgname = "";
2468   except ImportError:
2469    fgname = "";
2470   fdev_minor = format(int(fdev_minor), 'x').lower();
2471   fdev_major = format(int(fdev_major), 'x').lower();
2472   frdev_minor = format(int(frdev_minor), 'x').lower();
2473   frdev_major = format(int(frdev_major), 'x').lower();
2474   finode = format(int(finode), 'x').lower();
2475   flinkcount = format(int(flinkcount), 'x').lower();
2476   if(hasattr(fstatinfo, "st_file_attributes")):
2477    fwinattributes = format(int(fstatinfo.st_file_attributes), 'x').lower();
2478   else:
2479    fwinattributes = format(int(0), 'x').lower();
2480   fcontents = "".encode('UTF-8');
2481   chunk_size = 1024;
2482   if(ftype==0 or ftype==7):
2483    with open(fname, "rb") as fpc:
2484     while(True):
2485      chunk = fpc.read(chunk_size);
2486      if(not chunk):
2487       break
2488      fcontents += chunk;
2489   if(followlink and (ftype==1 or ftype==2)):
2490    flstatinfo = os.stat(flinkname);
2491    with open(flinkname, "rb") as fpc:
2492     while(True):
2493      chunk = fpc.read(chunk_size);
2494      if(not chunk):
2495       break;
2496      fcontents += chunk;
2497   ftypehex = format(ftype, 'x').lower();
2498   extrafields = format(len(extradata), 'x').lower();
2499   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
2500   if(len(extradata)>0):
2501    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
2502   extrasizelen = format(len(extrasizestr), 'x').lower();
2503   catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrasizelen, extrafields];
2504   catoutlen = len(catoutlist) + len(extradata) + 3;
2505   catoutlenhex = format(catoutlen, 'x').lower();
2506   catoutlist.insert(0, catoutlenhex);
2507   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
2508   if(len(extradata)>0):
2509    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
2510   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
2511   if(checksumtype=="none" or checksumtype==""):
2512    catfileheadercshex = format(0, 'x').lower();
2513    catfilecontentcshex = format(0, 'x').lower();
2514   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2515    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
2516    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
2517   elif(checksumtype=="crc16_ccitt"):
2518    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
2519    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
2520   elif(checksumtype=="adler32"):
2521    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2522    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
2523   elif(checksumtype=="crc32"):
2524    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2525    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
2526   elif(checksumtype=="crc64_ecma"):
2527    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2528    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
2529   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2530    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2531    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
2532   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2533    checksumoutstr = hashlib.new(checksumtype);
2534    checksumoutstr.update("".encode('UTF-8'));
2535    catfileheadercshex = checksumoutstr.hexdigest().lower();
2536    checksumoutstr = hashlib.new(checksumtype);
2537    checksumoutstr.update(fcontents);
2538    catfilecontentcshex = checksumoutstr.hexdigest().lower();
2539   else:
2540    catfileheadercshex = format(0, 'x').lower();
2541    catfilecontentcshex = format(0, 'x').lower();
2542   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
2543   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
2544   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
2545   if(checksumtype=="none" or checksumtype==""):
2546    catfileheadercshex = format(0, 'x').lower();
2547   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2548    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
2549   elif(checksumtype=="crc16_ccitt"):
2550    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
2551   elif(checksumtype=="adler32"):
2552    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
2553   elif(checksumtype=="crc32"):
2554    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
2555   elif(checksumtype=="crc64_ecma"):
2556    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2557   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2558    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2559   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2560    checksumoutstr = hashlib.new(checksumtype);
2561    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
2562    catfileheadercshex = checksumoutstr.hexdigest().lower();
2563   else:
2564    catfileheadercshex = format(0, 'x').lower();
2565   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
2566   catfhend = (catfp.tell() - 1) + len(catfileoutstr);
2567   catfcontentstart = catfp.tell() + len(catfileoutstr);
2568   catfileoutstrecd = catfileoutstr.encode('UTF-8');
2569   nullstrecd = formatspecs[5].encode('UTF-8');
2570   catfileout = catfileoutstrecd + fcontents + nullstrecd;
2571   catfcontentend = (catfp.tell() - 1) + len(catfileout);
2572   catfp.write(catfileout);
2573   try:
2574    catfp.flush();
2575    os.fsync(catfp.fileno());
2576   except io.UnsupportedOperation:
2577    pass;
2578   except AttributeError:
2579    pass;
2580  if(numfiles>0):
2581   catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
2582  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
2583   catfp = CompressArchiveFile(catfp, compression, formatspecs);
2584   try:
2585    catfp.flush();
2586    os.fsync(catfp.fileno());
2587   except io.UnsupportedOperation:
2588    pass;
2589   except AttributeError:
2590    pass;
2591  if(outfile=="-"):
2592   catfp.seek(0, 0);
2593   if(hasattr(sys.stdout, "buffer")):
2594    shutil.copyfileobj(catfp, sys.stdout.buffer);
2595   else:
2596    shutil.copyfileobj(catfp, sys.stdout);
2597  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
2598   catfp = CompressArchiveFile(catfp, compression, formatspecs);
2599   catfp.seek(0, 0);
2600   upload_file_to_internet_file(catfp, outfile);
2601  if(returnfp):
2602   catfp.seek(0, 0);
2603   return catfp;
2604  else:
2605   catfp.close();
2606   return True;
2607
2608 create_alias_function("Pack", __file_format_name__, "", PackArchiveFile);
2609
2610 if(hasattr(shutil, "register_archive_format")):
2611  def PackArchiveFileFunc(archive_name, source_dir, **kwargs):
2612   return PackArchiveFile(source_dir, archive_name, False, "auto", None, False, "crc32", [], __file_format_delimiter__, False, False);
2613  create_alias_function("Pack", __file_format_name__, "Func", PackArchiveFileFunc);
2614
2615 def PackArchiveFileFromDirList(infiles, outfile, dirlistfromtxt=False, compression="auto", compressionlevel=None, followlink=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
2616  return PackArchiveFile(infiles, outfile, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, returnfp);
2617
2618 def PackArchiveFileFromTarFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
2619  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2620   outfile = RemoveWindowsPath(outfile);
2621  checksumtype = checksumtype.lower();
2622  if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
2623   checksumtype="crc32";
2624  if(checksumtype=="none"):
2625   checksumtype = "";
2626  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
2627   compression = None;
2628  if(compression not in compressionlist and compression is None):
2629   compression = "auto";
2630  if(verbose):
2631   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
2632  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2633   if(os.path.exists(outfile)):
2634    os.unlink(outfile);
2635  if(outfile=="-"):
2636   verbose = False;
2637   catfp = BytesIO();
2638  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
2639   catfp = outfile;
2640  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
2641   catfp = BytesIO();
2642  else:
2643   fbasename = os.path.splitext(outfile)[0];
2644   fextname = os.path.splitext(outfile)[1];
2645   catfp = CompressOpenFile(outfile, compressionlevel);
2646  catver = formatspecs[6];
2647  fileheaderver = str(int(catver.replace(".", "")));
2648  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
2649  catfp.write(fileheader.encode('UTF-8'));
2650  curinode = 0;
2651  curfid = 0;
2652  inodelist = [];
2653  inodetofile = {};
2654  filetoinode = {};
2655  inodetocatinode = {};
2656  if(infile=="-"):
2657   infile = BytesIO();
2658   if(hasattr(sys.stdin, "buffer")):
2659    shutil.copyfileobj(sys.stdin.buffer, infile);
2660   else:
2661    shutil.copyfileobj(sys.stdin, infile);
2662   infile.seek(0, 0);
2663   if(not infile):
2664    return False;
2665   infile.seek(0, 0);
2666  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
2667   infile = download_file_from_internet_file(infile);
2668   infile.seek(0, 0);
2669   if(not infile):
2670    return False;
2671   infile.seek(0, 0);
2672  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
2673   return False;
2674  elif(os.path.exists(infile) and os.path.isfile(infile)):
2675   try:
2676    if(not tarfile.is_tarfile(infile)):
2677     return False;
2678   except AttributeError:
2679    if(not is_tarfile(infile)):
2680     return False;
2681  else:
2682   return False;
2683  try:
2684   if(hasattr(infile, "read") or hasattr(infile, "write")):
2685    tarfp = tarfile.open(fileobj=infile, mode="r");
2686   else:
2687    tarfp = tarfile.open(infile, "r");
2688  except FileNotFoundError:
2689   return False;
2690  numfiles = int(len(tarfp.getmembers()));
2691  fnumfiles = format(int(len(tarfp.getmembers())), 'x').lower();
2692  fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
2693  if(checksumtype=="none" or checksumtype==""):
2694   catfileheadercshex = format(0, 'x').lower();
2695  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2696   catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2697  elif(checksumtype=="crc16_ccitt"):
2698   catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2699  elif(checksumtype=="adler32"):
2700   catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2701  elif(checksumtype=="crc32"):
2702   catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2703  elif(checksumtype=="crc64_ecma"):
2704   catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2705  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2706   catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2707  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2708   checksumoutstr = hashlib.new(checksumtype);
2709   checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
2710   catfileheadercshex = checksumoutstr.hexdigest().lower();
2711  else:
2712   catfileheadercshex = format(0, 'x').lower();
2713  fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
2714  catfp.write(fnumfilesa.encode('UTF-8'));
2715  try:
2716   catfp.flush();
2717   os.fsync(catfp.fileno());
2718  except io.UnsupportedOperation:
2719   pass;
2720  except AttributeError:
2721   pass;
2722  for member in sorted(tarfp.getmembers(), key=lambda x: x.name):
2723   catfhstart = catfp.tell();
2724   if(re.findall("^[.|/]", member.name)):
2725    fname = member.name;
2726   else:
2727    fname = "./"+member.name;
2728   if(verbose):
2729    VerbosePrintOut(fname);
2730   fpremode = member.mode;
2731   ffullmode = member.mode;
2732   flinkcount = 0;
2733   ftype = 0;
2734   if(member.isreg()):
2735    ffullmode = member.mode + stat.S_IFREG;
2736    ftype = 0;
2737   elif(member.isdev()):
2738    ffullmode = member.mode;
2739    ftype = 7;
2740   elif(member.islnk()):
2741    ffullmode = member.mode + stat.S_IFREG;
2742    ftype = 1;
2743   elif(member.issym()):
2744    ffullmode = member.mode + stat.S_IFLNK;
2745    ftype = 2;
2746   elif(member.ischr()):
2747    ffullmode = member.mode + stat.S_IFCHR;
2748    ftype = 3;
2749   elif(member.isblk()):
2750    ffullmode = member.mode + stat.S_IFBLK;
2751    ftype = 4;
2752   elif(member.isdir()):
2753    ffullmode = member.mode + stat.S_IFDIR;
2754    ftype = 5;
2755   elif(member.isfifo()):
2756    ffullmode = member.mode + stat.S_IFIFO;
2757    ftype = 6;
2758   elif(member.issparse()):
2759    ffullmode = member.mode;
2760    ftype = 12;
2761   else:
2762    ffullmode = member.mode;
2763    ftype = 0;
2764   flinkname = "";
2765   fcurfid = format(int(curfid), 'x').lower();
2766   fcurinode = format(int(curfid), 'x').lower();
2767   curfid = curfid + 1;
2768   if(ftype==2):
2769    flinkname = member.linkname;
2770   fdev_minor = format(int(member.devminor), 'x').lower();
2771   fdev_major = format(int(member.devmajor), 'x').lower();
2772   frdev_minor = format(int(member.devminor), 'x').lower();
2773   frdev_major = format(int(member.devmajor), 'x').lower();
2774   if(ftype==1 or ftype==2 or ftype==3 or ftype==4 or ftype==5 or ftype==6):
2775    fsize = format(int("0"), 'x').lower();
2776   elif(ftype==0 or ftype==7):
2777    fsize = format(int(member.size), 'x').lower();
2778   else:
2779    fsize = format(int(member.size), 'x').lower();
2780   fatime = format(int(member.mtime), 'x').lower();
2781   fmtime = format(int(member.mtime), 'x').lower();
2782   fctime = format(int(member.mtime), 'x').lower();
2783   fbtime = format(int(member.mtime), 'x').lower();
2784   fmode = format(int(ffullmode), 'x').lower();
2785   fchmode = format(int(stat.S_IMODE(ffullmode)), 'x').lower();
2786   ftypemod = format(int(stat.S_IFMT(ffullmode)), 'x').lower();
2787   fuid = format(int(member.uid), 'x').lower();
2788   fgid = format(int(member.gid), 'x').lower();
2789   funame = member.uname;
2790   fgname = member.gname;
2791   flinkcount = format(int(flinkcount), 'x').lower();
2792   fwinattributes = format(int(0), 'x').lower();
2793   fcontents = "".encode('UTF-8');
2794   chunk_size = 1024;
2795   if(ftype==0 or ftype==7):
2796    with tarfp.extractfile(member) as fpc:
2797     while(True):
2798      chunk = fpc.read(chunk_size);
2799      if(not chunk):
2800       break
2801      fcontents += chunk;
2802   ftypehex = format(ftype, 'x').lower();
2803   extrafields = format(len(extradata), 'x').lower();
2804   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
2805   if(len(extradata)>0):
2806    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
2807   extrasizelen = format(len(extrasizestr), 'x').lower();
2808   catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrasizelen, extrafields];
2809   catoutlen = len(catoutlist) + len(extradata) + 3;
2810   catoutlenhex = format(catoutlen, 'x').lower();
2811   catoutlist.insert(0, catoutlenhex);
2812   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
2813   if(len(extradata)>0):
2814    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
2815   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
2816   catfhend = (catfp.tell() - 1) + len(catfileoutstr);
2817   catfcontentstart = catfp.tell() + len(catfileoutstr);
2818   if(checksumtype=="none" or checksumtype==""):
2819    catfileheadercshex = format(0, 'x').lower();
2820    catfilecontentcshex = format(0, 'x').lower();
2821   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2822    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
2823    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
2824   elif(checksumtype=="crc16_ccitt"):
2825    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
2826    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
2827   elif(checksumtype=="adler32"):
2828    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2829    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
2830   elif(checksumtype=="crc32"):
2831    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2832    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
2833   elif(checksumtype=="crc64_ecma"):
2834    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2835    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
2836   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2837    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2838    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
2839   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2840    checksumoutstr = hashlib.new(checksumtype);
2841    checksumoutstr.update("".encode('UTF-8'));
2842    catfileheadercshex = checksumoutstr.hexdigest().lower();
2843    checksumoutstr = hashlib.new(checksumtype);
2844    checksumoutstr.update(fcontents);
2845    catfilecontentcshex = checksumoutstr.hexdigest().lower();
2846   else:
2847    catfileheadercshex = format(0, 'x').lower();
2848    catfilecontentcshex = format(0, 'x').lower();
2849   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
2850   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
2851   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
2852   if(checksumtype=="none" or checksumtype==""):
2853    catfileheadercshex = format(0, 'x').lower();
2854   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2855    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
2856   elif(checksumtype=="crc16_ccitt"):
2857    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
2858   elif(checksumtype=="adler32"):
2859    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
2860   elif(checksumtype=="crc32"):
2861    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
2862   elif(checksumtype=="crc64_ecma"):
2863    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2864   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2865    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2866   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2867    checksumoutstr = hashlib.new(checksumtype);
2868    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
2869    catfileheadercshex = checksumoutstr.hexdigest().lower();
2870   else:
2871    catfileheadercshex = format(0, 'x').lower();
2872   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
2873   catfileoutstrecd = catfileoutstr.encode('UTF-8');
2874   nullstrecd = formatspecs[5].encode('UTF-8');
2875   catfileout = catfileoutstrecd + fcontents + nullstrecd;
2876   catfcontentend = (catfp.tell() - 1) + len(catfileout);
2877   catfp.write(catfileout);
2878   try:
2879    catfp.flush();
2880    os.fsync(catfp.fileno());
2881   except io.UnsupportedOperation:
2882    pass;
2883   except AttributeError:
2884    pass;
2885  if(numfiles>0):
2886   catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
2887  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
2888   catfp = CompressArchiveFile(catfp, compression, formatspecs);
2889   try:
2890    catfp.flush();
2891    os.fsync(catfp.fileno());
2892   except io.UnsupportedOperation:
2893    pass;
2894   except AttributeError:
2895    pass;
2896  if(outfile=="-"):
2897   catfp.seek(0, 0);
2898   if(hasattr(sys.stdout, "buffer")):
2899    shutil.copyfileobj(catfp, sys.stdout.buffer);
2900   else:
2901    shutil.copyfileobj(catfp, sys.stdout);
2902  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
2903   catfp = CompressArchiveFile(catfp, compression, formatspecs);
2904   catfp.seek(0, 0);
2905   upload_file_from_internet_file(catfp, outfile);
2906  if(returnfp):
2907   catfp.seek(0, 0);
2908   return catfp;
2909  else:
2910   catfp.close();
2911   return True;
2912
2913 create_alias_function("Pack", __file_format_name__, "FromTarFile", PackArchiveFileFromTarFile);
2914
2915 def PackArchiveFileFromZipFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
2916  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2917   outfile = RemoveWindowsPath(outfile);
2918  checksumtype = checksumtype.lower();
2919  if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
2920   checksumtype="crc32";
2921  if(checksumtype=="none"):
2922   checksumtype = "";
2923  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
2924   compression = None;
2925  if(compression not in compressionlist and compression is None):
2926   compression = "auto";
2927  if(verbose):
2928   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
2929  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2930   if(os.path.exists(outfile)):
2931    os.unlink(outfile);
2932  if(outfile=="-"):
2933   verbose = False;
2934   catfp = BytesIO();
2935  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
2936   catfp = outfile;
2937  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
2938   catfp = BytesIO();
2939  else:
2940   fbasename = os.path.splitext(outfile)[0];
2941   fextname = os.path.splitext(outfile)[1];
2942   catfp = CompressOpenFile(outfile, compressionlevel);
2943  catver = formatspecs[6];
2944  fileheaderver = str(int(catver.replace(".", "")));
2945  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
2946  catfp.write(fileheader.encode('UTF-8'));
2947  curinode = 0;
2948  curfid = 0;
2949  inodelist = [];
2950  inodetofile = {};
2951  filetoinode = {};
2952  inodetocatinode = {};
2953  if(infile=="-"):
2954   infile = BytesIO();
2955   if(hasattr(sys.stdin, "buffer")):
2956    shutil.copyfileobj(sys.stdin.buffer, infile);
2957   else:
2958    shutil.copyfileobj(sys.stdin, infile);
2959   infile.seek(0, 0);
2960   if(not infile):
2961    return False;
2962   infile.seek(0, 0);
2963  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
2964   infile = download_file_from_internet_file(infile);
2965   infile.seek(0, 0);
2966   if(not infile):
2967    return False;
2968   infile.seek(0, 0);
2969  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
2970   return False;
2971  else:
2972   return False;
2973  if(not zipfile.is_zipfile(infile)):
2974   return False;
2975  try:
2976   zipfp = zipfile.ZipFile(infile, "r", allowZip64=True);
2977  except FileNotFoundError:
2978   return False;
2979  ziptest = zipfp.testzip();
2980  if(ziptest):
2981   VerbosePrintOut("Bad file found!");
2982  numfiles = int(len(zipfp.infolist()));
2983  fnumfiles = format(int(len(zipfp.infolist())), 'x').lower();
2984  fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
2985  if(checksumtype=="none" or checksumtype==""):
2986   catfileheadercshex = format(0, 'x').lower();
2987  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2988   catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2989  elif(checksumtype=="crc16_ccitt"):
2990   catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2991  elif(checksumtype=="adler32"):
2992   catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2993  elif(checksumtype=="crc32"):
2994   catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2995  elif(checksumtype=="crc64_ecma"):
2996   catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2997  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2998   catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2999  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3000   checksumoutstr = hashlib.new(checksumtype);
3001   checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
3002   catfileheadercshex = checksumoutstr.hexdigest().lower();
3003  else:
3004   catfileheadercshex = format(0, 'x').lower();
3005  fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
3006  catfp.write(fnumfilesa.encode('UTF-8'));
3007  try:
3008   catfp.flush();
3009   os.fsync(catfp.fileno());
3010  except io.UnsupportedOperation:
3011   pass;
3012  except AttributeError:
3013   pass;
3014  for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
3015   catfhstart = catfp.tell();
3016   if(re.findall("^[.|/]", member.filename)):
3017    fname = member.filename;
3018   else:
3019    fname = "./"+member.filename;
3020   zipinfo = zipfp.getinfo(member.filename);
3021   if(verbose):
3022    VerbosePrintOut(fname);
3023   if(not member.is_dir()):
3024    fpremode = int(stat.S_IFREG + 438);
3025   elif(member.is_dir()):
3026    fpremode = int(stat.S_IFDIR + 511);
3027   flinkcount = 0;
3028   ftype = 0;
3029   if(not member.is_dir()):
3030    ftype = 0;
3031   elif(member.is_dir()):
3032    ftype = 5;
3033   flinkname = "";
3034   fcurfid = format(int(curfid), 'x').lower();
3035   fcurinode = format(int(curfid), 'x').lower();
3036   curfid = curfid + 1;
3037   fdev_minor = format(int(0), 'x').lower();
3038   fdev_major = format(int(0), 'x').lower();
3039   frdev_minor = format(int(0), 'x').lower();
3040   frdev_major = format(int(0), 'x').lower();
3041   if(ftype==5):
3042    fsize = format(int("0"), 'x').lower();
3043   elif(ftype==0):
3044    fsize = format(int(member.file_size), 'x').lower();
3045   else:
3046    fsize = format(int(member.file_size), 'x').lower();
3047   fatime = format(int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower();
3048   fmtime = format(int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower();
3049   fctime = format(int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower();
3050   fbtime = format(int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower();
3051   if(zipinfo.create_system==0 or zipinfo.create_system==10):
3052    fwinattributes = format(int(zipinfo.external_attr), 'x').lower();
3053    if(not member.is_dir()):
3054     fmode = format(int(stat.S_IFREG + 438), 'x').lower();
3055     fchmode = stat.S_IMODE(fmode);
3056     ftypemod = stat.S_IFMT(fmode);
3057    elif(member.is_dir()):
3058     fmode = format(int(stat.S_IFDIR + 511), 'x').lower();
3059     fchmode = stat.S_IMODE(fmode);
3060     ftypemod = stat.S_IFMT(fmode);
3061   elif(zipinfo.create_system==3):
3062    fwinattributes = format(int(0), 'x').lower();
3063    fmode = format(int(zipinfo.external_attr), 'x').lower();
3064    fchmode = stat.S_IMODE(fmode);
3065    ftypemod = stat.S_IFMT(fmode);
3066   else:
3067    fwinattributes = format(int(0), 'x').lower();
3068    if(not member.is_dir()):
3069     fmode = format(int(stat.S_IFREG + 438), 'x').lower();
3070     fchmode = stat.S_IMODE(fmode);
3071     ftypemod = stat.S_IFMT(fmode);
3072    elif(member.is_dir()):
3073     fmode = format(int(stat.S_IFDIR + 511), 'x').lower();
3074     fchmode = stat.S_IMODE(fmode);
3075     ftypemod = stat.S_IFMT(fmode);
3076   try:
3077    fuid = format(int(os.getuid()), 'x').lower();
3078   except AttributeError:
3079    fuid = format(int(0), 'x').lower();
3080   except KeyError:
3081    fuid = format(int(0), 'x').lower();
3082   try:
3083    fgid = format(int(os.getgid()), 'x').lower();
3084   except AttributeError:
3085    fgid = format(int(0), 'x').lower();
3086   except KeyError:
3087    fgid = format(int(0), 'x').lower();
3088   try:
3089    import pwd;
3090    try:
3091     userinfo = pwd.getpwuid(os.getuid());
3092     funame = userinfo.pw_name;
3093    except KeyError:
3094     funame = "";
3095    except AttributeError:
3096     funame = "";
3097   except ImportError:
3098    funame = "";
3099   fgname = "";
3100   try:
3101    import grp;
3102    try:
3103     groupinfo = grp.getgrgid(os.getgid());
3104     fgname = groupinfo.gr_name;
3105    except KeyError:
3106     fgname = "";
3107    except AttributeError:
3108     fgname = "";
3109   except ImportError:
3110    fgname = "";
3111   fcontents = "".encode('UTF-8');
3112   if(ftype==0):
3113    fcontents = zipfp.read(member.filename);
3114   ftypehex = format(ftype, 'x').lower();
3115   extrafields = format(len(extradata), 'x').lower();
3116   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
3117   if(len(extradata)>0):
3118    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
3119   extrasizelen = format(len(extrasizestr), 'x').lower();
3120   catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrasizelen, extrafields];
3121   catoutlen = len(catoutlist) + len(extradata) + 3;
3122   catoutlenhex = format(catoutlen, 'x').lower();
3123   catoutlist.insert(0, catoutlenhex);
3124   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
3125   if(len(extradata)>0):
3126    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
3127   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
3128   catfhend = (catfp.tell() - 1) + len(catfileoutstr);
3129   catfcontentstart = catfp.tell() + len(catfileoutstr);
3130   if(checksumtype=="none" or checksumtype==""):
3131    catfileheadercshex = format(0, 'x').lower();
3132    catfilecontentcshex = format(0, 'x').lower();
3133   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3134    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3135    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
3136   elif(checksumtype=="crc16_ccitt"):
3137    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3138    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
3139   elif(checksumtype=="adler32"):
3140    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3141    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
3142   elif(checksumtype=="crc32"):
3143    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3144    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
3145   elif(checksumtype=="crc64_ecma"):
3146    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3147    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
3148   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3149    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3150    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
3151   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3152    checksumoutstr = hashlib.new(checksumtype);
3153    checksumoutstr.update("".encode('UTF-8'));
3154    catfileheadercshex = checksumoutstr.hexdigest().lower();
3155    checksumoutstr = hashlib.new(checksumtype);
3156    checksumoutstr.update(fcontents);
3157    catfilecontentcshex = checksumoutstr.hexdigest().lower();
3158   else:
3159    catfileheadercshex = format(0, 'x').lower();
3160    catfilecontentcshex = format(0, 'x').lower();
3161   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
3162   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
3163   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
3164   if(checksumtype=="none" or checksumtype==""):
3165    catfileheadercshex = format(0, 'x').lower();
3166   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3167    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
3168   elif(checksumtype=="crc16_ccitt"):
3169    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
3170   elif(checksumtype=="adler32"):
3171    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
3172   elif(checksumtype=="crc32"):
3173    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
3174   elif(checksumtype=="crc64_ecma"):
3175    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3176   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3177    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3178   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3179    checksumoutstr = hashlib.new(checksumtype);
3180    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
3181    catfileheadercshex = checksumoutstr.hexdigest().lower();
3182   else:
3183    catfileheadercshex = format(0, 'x').lower();
3184   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
3185   catfileoutstrecd = catfileoutstr.encode('UTF-8');
3186   nullstrecd = formatspecs[5].encode('UTF-8');
3187   catfileout = catfileoutstrecd + fcontents + nullstrecd;
3188   catfcontentend = (catfp.tell() - 1) + len(catfileout);
3189   catfp.write(catfileout);
3190   try:
3191    catfp.flush();
3192    os.fsync(catfp.fileno());
3193   except io.UnsupportedOperation:
3194    pass;
3195   except AttributeError:
3196    pass;
3197  if(numfiles>0):
3198   catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
3199  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
3200   catfp = CompressArchiveFile(catfp, compression, formatspecs);
3201   try:
3202    catfp.flush();
3203    os.fsync(catfp.fileno());
3204   except io.UnsupportedOperation:
3205    pass;
3206   except AttributeError:
3207    pass;
3208  if(outfile=="-"):
3209   catfp.seek(0, 0);
3210   if(hasattr(sys.stdout, "buffer")):
3211    shutil.copyfileobj(catfp, sys.stdout.buffer);
3212   else:
3213    shutil.copyfileobj(catfp, sys.stdout);
3214  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
3215   catfp = CompressArchiveFile(catfp, compression, formatspecs);
3216   catfp.seek(0, 0);
3217   upload_file_to_internet_file(catfp, outfile);
3218  if(returnfp):
3219   catfp.seek(0, 0);
3220   return catfp;
3221  else:
3222   catfp.close();
3223   return True;
3224
3225 create_alias_function("Pack", __file_format_name__, "FromZipFile", PackArchiveFileFromZipFile);
3226
3227 if(not rarfile_support):
3228  def PackArchiveFileFromRarFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
3229   return False
3230
3231 if(rarfile_support):
3232  def PackArchiveFileFromRarFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
3233   if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
3234    outfile = RemoveWindowsPath(outfile);
3235   checksumtype = checksumtype.lower();
3236   if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
3237    checksumtype="crc32";
3238   if(checksumtype=="none"):
3239    checksumtype = "";
3240   if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
3241    compression = None;
3242   if(compression not in compressionlist and compression is None):
3243    compression = "auto";
3244   if(verbose):
3245    logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
3246   if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
3247    if(os.path.exists(outfile)):
3248     os.unlink(outfile);
3249   if(outfile=="-"):
3250    verbose = False;
3251    catfp = BytesIO();
3252   elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
3253    catfp = outfile;
3254   elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
3255    catfp = BytesIO();
3256   else:
3257    fbasename = os.path.splitext(outfile)[0];
3258    fextname = os.path.splitext(outfile)[1];
3259    catfp = CompressOpenFile(outfile, compressionlevel);
3260   catver = formatspecs[6];
3261   fileheaderver = str(int(catver.replace(".", "")));
3262   fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
3263   catfp.write(fileheader.encode('UTF-8'));
3264   curinode = 0;
3265   curfid = 0;
3266   inodelist = [];
3267   inodetofile = {};
3268   filetoinode = {};
3269   inodetocatinode = {};
3270   if(not os.path.exists(infile) or not os.path.isfile(infile)):
3271    return False;
3272   if(not rarfile.is_rarfile(infile) and not rarfile.is_rarfile_sfx(infile)):
3273    return False;
3274   rarfp = rarfile.RarFile(infile, "r");
3275   rartest = rarfp.testrar();
3276   if(rartest):
3277    VerbosePrintOut("Bad file found!");
3278   numfiles = int(len(rarfp.infolist()));
3279   fnumfiles = format(int(len(rarfp.infolist())), 'x').lower();
3280   fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
3281   if(checksumtype=="none" or checksumtype==""):
3282    catfileheadercshex = format(0, 'x').lower();
3283   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3284    catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
3285   elif(checksumtype=="crc16_ccitt"):
3286    catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
3287   elif(checksumtype=="adler32"):
3288    catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
3289   elif(checksumtype=="crc32"):
3290    catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
3291   elif(checksumtype=="crc64_ecma"):
3292    catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3293   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3294    catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3295   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3296    checksumoutstr = hashlib.new(checksumtype);
3297    checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
3298    catfileheadercshex = checksumoutstr.hexdigest().lower();
3299   else:
3300    catfileheadercshex = format(0, 'x').lower();
3301   fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
3302   catfp.write(fnumfilesa.encode('UTF-8'));
3303   try:
3304    catfp.flush();
3305    os.fsync(catfp.fileno());
3306   except io.UnsupportedOperation:
3307    pass;
3308   except AttributeError:
3309    pass;
3310   for member in sorted(rarfp.infolist(), key=lambda x: x.filename):
3311    is_unix = False;
3312    is_windows = False;
3313    if(member.host_os==rarfile.RAR_OS_UNIX):
3314     is_windows = False;
3315     try:
3316      member.external_attr
3317      is_unix = True;
3318     except AttributeError:
3319      is_unix = False;
3320    elif(member.host_os==rarfile.RAR_OS_WIN32):
3321     is_unix = False;
3322     try:
3323      member.external_attr
3324      is_windows = True;
3325     except AttributeError:
3326      is_windows = False;
3327    else:
3328     is_unix = False;
3329     is_windows = False;
3330    catfhstart = catfp.tell();
3331    if(re.findall("^[.|/]", member.filename)):
3332     fname = member.filename;
3333    else:
3334     fname = "./"+member.filename;
3335    rarinfo = rarfp.getinfo(member.filename);
3336    if(verbose):
3337     VerbosePrintOut(fname);
3338    if(is_unix and member.external_attr !=0):
3339     fpremode = int(member.external_attr);
3340    elif(member.is_file()):
3341     fpremode = int(stat.S_IFREG + 438);
3342    elif(member.is_symlink()):
3343     fpremode = int(stat.S_IFLNK + 438);
3344    elif(member.is_dir()):
3345     fpremode = int(stat.S_IFDIR + 511);
3346    if(is_windows and member.external_attr !=0):
3347     fwinattributes = format(int(member.external_attr), 'x').lower();
3348    else:
3349     fwinattributes = format(int(0), 'x').lower();
3350    flinkcount = 0;
3351    ftype = 0;
3352    if(member.is_file()):
3353     ftype = 0;
3354    elif(member.is_symlink()):
3355     ftype = 2;
3356    elif(member.is_dir()):
3357     ftype = 5;
3358    flinkname = "";
3359    if(ftype==2):
3360     flinkname = rarfp.read(member.filename).decode("UTF-8");
3361    fcurfid = format(int(curfid), 'x').lower();
3362    fcurinode = format(int(curfid), 'x').lower();
3363    curfid = curfid + 1;
3364    fdev_minor = format(int(0), 'x').lower();
3365    fdev_major = format(int(0), 'x').lower();
3366    frdev_minor = format(int(0), 'x').lower();
3367    frdev_major = format(int(0), 'x').lower();
3368    if(ftype==5):
3369     fsize = format(int("0"), 'x').lower();
3370    elif(ftype==0):
3371     fsize = format(int(member.file_size), 'x').lower();
3372    else:
3373     fsize = format(int(member.file_size), 'x').lower();
3374    try:
3375     if(member.atime):
3376      fatime = format(int(member.atime.timestamp()), 'x').lower();
3377     else:
3378      fatime = format(int(member.mtime.timestamp()), 'x').lower();
3379    except AttributeError:
3380     fatime = format(int(member.mtime.timestamp()), 'x').lower();
3381    fmtime = format(int(member.mtime.timestamp()), 'x').lower();
3382    try:
3383     if(member.ctime):
3384      fctime = format(int(member.ctime.timestamp()), 'x').lower();
3385     else:
3386      fctime = format(int(member.mtime.timestamp()), 'x').lower();
3387    except AttributeError:
3388     fctime = format(int(member.mtime.timestamp()), 'x').lower();
3389    fbtime = format(int(member.mtime.timestamp()), 'x').lower();
3390    if(is_unix and member.external_attr !=0):
3391     fmode = format(int(member.external_attr), 'x').lower();
3392     fchmode = format(int(stat.S_IMODE(member.external_attr)), 'x').lower();
3393     ftypemod = format(int(stat.S_IFMT(member.external_attr)), 'x').lower();
3394    elif(member.is_file()):
3395     fmode = format(int(stat.S_IFREG + 438), 'x').lower();
3396     fchmode = format(int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower();
3397     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower();
3398    elif(member.is_symlink()):
3399     fmode = format(int(stat.S_IFLNK + 438), 'x').lower();
3400     fchmode = format(int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower();
3401     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower();
3402    elif(member.is_dir()):
3403     fmode = format(int(stat.S_IFDIR + 511), 'x').lower();
3404     fchmode = format(int(stat.S_IMODE(int(stat.S_IFDIR + 511))), 'x').lower();
3405     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFDIR + 511))), 'x').lower();
3406    try:
3407     fuid = format(int(os.getuid()), 'x').lower();
3408    except AttributeError:
3409     fuid = format(int(0), 'x').lower();
3410    except KeyError:
3411     fuid = format(int(0), 'x').lower();
3412    try:
3413     fgid = format(int(os.getgid()), 'x').lower();
3414    except AttributeError:
3415     fgid = format(int(0), 'x').lower();
3416    except KeyError:
3417     fgid = format(int(0), 'x').lower();
3418    try:
3419     import pwd;
3420     try:
3421      userinfo = pwd.getpwuid(os.getuid());
3422      funame = userinfo.pw_name;
3423     except KeyError:
3424      funame = "";
3425     except AttributeError:
3426      funame = "";
3427    except ImportError:
3428     funame = "";
3429    fgname = "";
3430    try:
3431     import grp;
3432     try:
3433      groupinfo = grp.getgrgid(os.getgid());
3434      fgname = groupinfo.gr_name;
3435     except KeyError:
3436      fgname = "";
3437     except AttributeError:
3438      fgname = "";
3439    except ImportError:
3440     fgname = "";
3441    fcontents = "".encode('UTF-8');
3442    if(ftype==0):
3443     fcontents = rarfp.read(member.filename);
3444    ftypehex = format(ftype, 'x').lower();
3445    extrafields = format(len(extradata), 'x').lower();
3446    extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
3447    if(len(extradata)>0):
3448     extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
3449    extrasizelen = format(len(extrasizestr), 'x').lower();
3450    catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrasizelen, extrafields];
3451    catoutlen = len(catoutlist) + len(extradata) + 3;
3452    catoutlenhex = format(catoutlen, 'x').lower();
3453    catoutlist.insert(0, catoutlenhex);
3454    catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
3455    if(len(extradata)>0):
3456     catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
3457    catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
3458    catfhend = (catfp.tell() - 1) + len(catfileoutstr);
3459    catfcontentstart = catfp.tell() + len(catfileoutstr);
3460    if(checksumtype=="none" or checksumtype==""):
3461     catfileheadercshex = format(0, 'x').lower();
3462     catfilecontentcshex = format(0, 'x').lower();
3463    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3464     catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3465     catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
3466    elif(checksumtype=="crc16_ccitt"):
3467     catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3468     catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
3469    elif(checksumtype=="adler32"):
3470     catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3471     catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
3472    elif(checksumtype=="crc32"):
3473     catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3474     catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
3475    elif(checksumtype=="crc64_ecma"):
3476     catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3477     catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
3478    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3479     catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3480     catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
3481    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3482     checksumoutstr = hashlib.new(checksumtype);
3483     checksumoutstr.update("".encode('UTF-8'));
3484     catfileheadercshex = checksumoutstr.hexdigest().lower();
3485     checksumoutstr = hashlib.new(checksumtype);
3486     checksumoutstr.update(fcontents);
3487     catfilecontentcshex = checksumoutstr.hexdigest().lower();
3488    else:
3489     catfileheadercshex = format(0, 'x').lower();
3490     catfilecontentcshex = format(0, 'x').lower();
3491    tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
3492    catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
3493    catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr
3494    if(checksumtype=="none" or checksumtype==""):
3495     catfileheadercshex = format(0, 'x').lower()
3496    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3497     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower()
3498    elif(checksumtype=="crc16_ccitt"):
3499     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower()
3500    elif(checksumtype=="adler32"):
3501     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower()
3502    elif(checksumtype=="crc32"):
3503     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower()
3504    elif(checksumtype=="crc64_ecma"):
3505     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
3506    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3507     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
3508    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3509     checksumoutstr = hashlib.new(checksumtype)
3510     checksumoutstr.update(catfileoutstr.encode('UTF-8'))
3511     catfileheadercshex = checksumoutstr.hexdigest().lower()
3512    else:
3513     catfileheadercshex = format(0, 'x').lower()
3514    catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5])
3515    catfileoutstrecd = catfileoutstr.encode('UTF-8')
3516    nullstrecd = formatspecs[5].encode('UTF-8')
3517    catfileout = catfileoutstrecd + fcontents + nullstrecd
3518    catfcontentend = (catfp.tell() - 1) + len(catfileout)
3519    catfp.write(catfileout)
3520    try:
3521     catfp.flush()
3522     os.fsync(catfp.fileno())
3523    except io.UnsupportedOperation:
3524     pass
3525    except AttributeError:
3526     pass
3527   if(numfiles>0):
3528    catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
3529   if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
3530    catfp = CompressArchiveFile(catfp, compression, formatspecs)
3531    try:
3532     catfp.flush()
3533     os.fsync(catfp.fileno())
3534    except io.UnsupportedOperation:
3535     pass
3536    except AttributeError:
3537     pass
3538   if(outfile=="-"):
3539    catfp.seek(0, 0)
3540    if(hasattr(sys.stdout, "buffer")):
3541     shutil.copyfileobj(catfp, sys.stdout.buffer);
3542    else:
3543     shutil.copyfileobj(catfp, sys.stdout);
3544   elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
3545    catfp = CompressArchiveFile(catfp, compression, formatspecs);
3546    catfp.seek(0, 0);
3547    upload_file_to_internet_file(catfp, outfile);
3548   if(returnfp):
3549    catfp.seek(0, 0)
3550    return catfp
3551   else:
3552    catfp.close()
3553    return True;
3554
3555 create_alias_function("Pack", __file_format_name__, "FromRarFile", PackArchiveFileFromRarFile);
3556
3557 if(not py7zr_support):
3558  def PackArchiveFileFromSevenZipFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
3559   return False
3560
3561 if(py7zr_support):
3562  def PackArchiveFileFromSevenZipFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
3563   if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
3564    outfile = RemoveWindowsPath(outfile);
3565   checksumtype = checksumtype.lower();
3566   if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
3567    checksumtype="crc32";
3568   if(checksumtype=="none"):
3569    checksumtype = "";
3570   if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
3571    compression = None;
3572   if(compression not in compressionlist and compression is None):
3573    compression = "auto";
3574   if(verbose):
3575    logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
3576   if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
3577    if(os.path.exists(outfile)):
3578     os.unlink(outfile);
3579   if(outfile=="-"):
3580    verbose = False;
3581    catfp = BytesIO();
3582   elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
3583    catfp = outfile;
3584   elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
3585    catfp = BytesIO();
3586   else:
3587    fbasename = os.path.splitext(outfile)[0];
3588    fextname = os.path.splitext(outfile)[1];
3589    catfp = CompressOpenFile(outfile, compressionlevel);
3590   catver = formatspecs[6];
3591   fileheaderver = str(int(catver.replace(".", "")));
3592   fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
3593   catfp.write(fileheader.encode('UTF-8'));
3594   curinode = 0;
3595   curfid = 0;
3596   inodelist = [];
3597   inodetofile = {};
3598   filetoinode = {};
3599   inodetocatinode = {};
3600   if(not os.path.exists(infile) or not os.path.isfile(infile)):
3601    return False;
3602   szpfp = py7zr.SevenZipFile(infile, mode="r");
3603   file_content = szpfp.readall();
3604   #sztest = szpfp.testzip();
3605   sztestalt = szpfp.test();
3606   if(sztestalt):
3607    VerbosePrintOut("Bad file found!");
3608   numfiles = int(len(szpfp.list()));
3609   fnumfiles = format(int(len(szpfp.list())), 'x').lower();
3610   fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
3611   if(checksumtype=="none" or checksumtype==""):
3612    catfileheadercshex = format(0, 'x').lower();
3613   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3614    catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
3615   elif(checksumtype=="crc16_ccitt"):
3616    catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
3617   elif(checksumtype=="adler32"):
3618    catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
3619   elif(checksumtype=="crc32"):
3620    catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
3621   elif(checksumtype=="crc64_ecma"):
3622    catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3623   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3624    catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3625   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3626    checksumoutstr = hashlib.new(checksumtype);
3627    checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
3628    catfileheadercshex = checksumoutstr.hexdigest().lower();
3629   else:
3630    catfileheadercshex = format(0, 'x').lower();
3631   fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
3632   catfp.write(fnumfilesa.encode('UTF-8'));
3633   try:
3634    catfp.flush();
3635    os.fsync(catfp.fileno());
3636   except io.UnsupportedOperation:
3637    pass;
3638   except AttributeError:
3639    pass;
3640   for member in sorted(szpfp.list(), key=lambda x: x.filename):
3641    catfhstart = catfp.tell();
3642    if(re.findall("^[.|/]", member.filename)):
3643     fname = member.filename;
3644    else:
3645     fname = "./"+member.filename;
3646    if(verbose):
3647     VerbosePrintOut(fname);
3648    if(not member.is_directory):
3649     fpremode = int(stat.S_IFREG + 438);
3650    elif(member.is_directory):
3651     fpremode = int(stat.S_IFDIR + 511);
3652    fwinattributes = format(int(0), 'x').lower();
3653    flinkcount = 0;
3654    ftype = 0;
3655    if(member.is_directory):
3656     ftype = 5;
3657    else:
3658     ftype = 0;
3659    flinkname = "";
3660    fcurfid = format(int(curfid), 'x').lower();
3661    fcurinode = format(int(curfid), 'x').lower();
3662    curfid = curfid + 1;
3663    fdev_minor = format(int(0), 'x').lower();
3664    fdev_major = format(int(0), 'x').lower();
3665    frdev_minor = format(int(0), 'x').lower();
3666    frdev_major = format(int(0), 'x').lower();
3667    if(ftype==5):
3668     fsize = format(int("0"), 'x').lower();
3669    fatime = format(int(member.creationtime.timestamp()), 'x').lower();
3670    fmtime = format(int(member.creationtime.timestamp()), 'x').lower();
3671    fctime = format(int(member.creationtime.timestamp()), 'x').lower();
3672    fbtime = format(int(member.creationtime.timestamp()), 'x').lower();
3673    if(member.is_directory):
3674     fmode = format(int(stat.S_IFDIR + 511), 'x').lower();
3675     fchmode = format(int(stat.S_IMODE(int(stat.S_IFDIR + 511))), 'x').lower();
3676     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFDIR + 511))), 'x').lower();
3677    else:
3678     fmode = format(int(stat.S_IFREG + 438), 'x').lower();
3679     fchmode = format(int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower();
3680     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower();
3681    try:
3682     fuid = format(int(os.getuid()), 'x').lower();
3683    except AttributeError:
3684     fuid = format(int(0), 'x').lower();
3685    except KeyError:
3686     fuid = format(int(0), 'x').lower();
3687    try:
3688     fgid = format(int(os.getgid()), 'x').lower();
3689    except AttributeError:
3690     fgid = format(int(0), 'x').lower();
3691    except KeyError:
3692     fgid = format(int(0), 'x').lower();
3693    try:
3694     import pwd;
3695     try:
3696      userinfo = pwd.getpwuid(os.getuid());
3697      funame = userinfo.pw_name;
3698     except KeyError:
3699      funame = "";
3700     except AttributeError:
3701      funame = "";
3702    except ImportError:
3703     funame = "";
3704    fgname = "";
3705    try:
3706     import grp;
3707     try:
3708      groupinfo = grp.getgrgid(os.getgid());
3709      fgname = groupinfo.gr_name;
3710     except KeyError:
3711      fgname = "";
3712     except AttributeError:
3713      fgname = "";
3714    except ImportError:
3715     fgname = "";
3716    fcontents = "".encode('UTF-8');
3717    if(ftype==0):
3718     fcontents = file_content[member.filename].read();
3719     fsize = format(len(fcontents), 'x').lower();
3720     file_content[member.filename].close();
3721    ftypehex = format(ftype, 'x').lower();
3722    extrafields = format(len(extradata), 'x').lower();
3723    extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
3724    if(len(extradata)>0):
3725     extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
3726    extrasizelen = format(len(extrasizestr), 'x').lower();
3727    catoutlist = [ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrasizelen, extrafields];
3728    catoutlen = len(catoutlist) + len(extradata) + 3;
3729    catoutlenhex = format(catoutlen, 'x').lower();
3730    catoutlist.insert(0, catoutlenhex);
3731    catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
3732    if(len(extradata)>0):
3733     catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
3734    catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
3735    catfhend = (catfp.tell() - 1) + len(catfileoutstr);
3736    catfcontentstart = catfp.tell() + len(catfileoutstr);
3737    if(checksumtype=="none" or checksumtype==""):
3738     catfileheadercshex = format(0, 'x').lower();
3739     catfilecontentcshex = format(0, 'x').lower();
3740    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3741     catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3742     catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
3743    elif(checksumtype=="crc16_ccitt"):
3744     catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3745     catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
3746    elif(checksumtype=="adler32"):
3747     catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3748     catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
3749    elif(checksumtype=="crc32"):
3750     catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3751     catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
3752    elif(checksumtype=="crc64_ecma"):
3753     catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3754     catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
3755    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3756     catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3757     catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
3758    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3759     checksumoutstr = hashlib.new(checksumtype);
3760     checksumoutstr.update("".encode('UTF-8'));
3761     catfileheadercshex = checksumoutstr.hexdigest().lower();
3762     checksumoutstr = hashlib.new(checksumtype);
3763     checksumoutstr.update(fcontents);
3764     catfilecontentcshex = checksumoutstr.hexdigest().lower();
3765    else:
3766     catfileheadercshex = format(0, 'x').lower();
3767     catfilecontentcshex = format(0, 'x').lower();
3768    tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
3769    catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
3770    catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr
3771    if(checksumtype=="none" or checksumtype==""):
3772     catfileheadercshex = format(0, 'x').lower()
3773    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3774     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower()
3775    elif(checksumtype=="crc16_ccitt"):
3776     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower()
3777    elif(checksumtype=="adler32"):
3778     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower()
3779    elif(checksumtype=="crc32"):
3780     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower()
3781    elif(checksumtype=="crc64_ecma"):
3782     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
3783    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3784     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
3785    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3786     checksumoutstr = hashlib.new(checksumtype)
3787     checksumoutstr.update(catfileoutstr.encode('UTF-8'))
3788     catfileheadercshex = checksumoutstr.hexdigest().lower()
3789    else:
3790     catfileheadercshex = format(0, 'x').lower()
3791    catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5])
3792    catfileoutstrecd = catfileoutstr.encode('UTF-8')
3793    nullstrecd = formatspecs[5].encode('UTF-8')
3794    catfileout = catfileoutstrecd + fcontents + nullstrecd
3795    catfcontentend = (catfp.tell() - 1) + len(catfileout)
3796    catfp.write(catfileout)
3797    try:
3798     catfp.flush()
3799     os.fsync(catfp.fileno())
3800    except io.UnsupportedOperation:
3801     pass
3802    except AttributeError:
3803     pass
3804   if(numfiles>0):
3805    catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
3806   if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
3807    catfp = CompressArchiveFile(catfp, compression, formatspecs)
3808    try:
3809     catfp.flush()
3810     os.fsync(catfp.fileno())
3811    except io.UnsupportedOperation:
3812     pass
3813    except AttributeError:
3814     pass
3815   if(outfile=="-"):
3816    catfp.seek(0, 0)
3817    if(hasattr(sys.stdout, "buffer")):
3818     shutil.copyfileobj(catfp, sys.stdout.buffer);
3819    else:
3820     shutil.copyfileobj(catfp, sys.stdout);
3821   elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
3822    catfp = CompressArchiveFile(catfp, compression, formatspecs);
3823    catfp.seek(0, 0);
3824    upload_file_to_internet_file(catfp, outfile);
3825   if(returnfp):
3826    catfp.seek(0, 0)
3827    return catfp
3828   else:
3829    catfp.close()
3830    return True;
3831
3832 create_alias_function("Pack", __file_format_name__, "FromSevenZipFile", PackArchiveFileFromSevenZipFile);
3833
3834 def PackArchiveFileFromInFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
3835  checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
3836  if(checkcompressfile=="tarfile"):
3837   return PackArchiveFileFromTarFile(infile, outfile, compression, compressionlevel, checksumtype, extradata, formatspecs, verbose, returnfp);
3838  elif(checkcompressfile=="zipfile"):
3839   return PackArchiveFileFromZipFile(infile, outfile, compression, compressionlevel, checksumtype, extradata, formatspecs, verbose, returnfp);
3840  elif(checkcompressfile=="catfile"):
3841   return RePackArchiveFile(infile, outfile, compression, compressionlevel, False, 0, 0, checksumtype, False, extradata, formatspecs, verbose, returnfp);
3842  elif(rarfile_support and checkcompressfile=="rarfile"):
3843   return PackArchiveFileFromRarFile(infile, outfile, compression, compressionlevel, checksumtype, extradata, formatspecs, verbose, returnfp);
3844  elif(py7zr_support and checkcompressfile=="7zipfile"):
3845   return PackArchiveFileFromSevenZipFile(infile, outfile, compression, compressionlevel, checksumtype, extradata, formatspecs, verbose, returnfp);
3846  else:
3847   return False;
3848  return False;
3849
3850 create_alias_function("Pack", __file_format_name__, "FromInFile", PackArchiveFileFromInFile);
3851
3852 def ArchiveFileSeekToFileNum(infile, seekto=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
3853  if(hasattr(infile, "read") or hasattr(infile, "write")):
3854   catfp = infile;
3855   catfp.seek(0, 0);
3856   catfp = UncompressArchiveFile(catfp, formatspecs);
3857   checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True);
3858   if(checkcompressfile=="tarfile"):
3859    return TarFileToArray(infile, seekto, 0, listonly, skipchecksum, formatspecs, returnfp);
3860   if(checkcompressfile=="zipfile"):
3861    return ZipFileToArray(infile, seekto, 0, listonly, skipchecksum, formatspecs, returnfp);
3862   if(rarfile_support and checkcompressfile=="rarfile"):
3863    return RarFileToArray(infile, seekto, 0, listonly, skipchecksum, formatspecs, returnfp);
3864   if(py7zr_support and checkcompressfile=="7zipfile"):
3865    return SevenZipFileToArray(infile, seekto, 0, listonly, skipchecksum, formatspecs, returnfp);
3866   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
3867    return False;
3868   if(not catfp):
3869    return False;
3870   catfp.seek(0, 0);
3871  elif(infile=="-"):
3872   catfp = BytesIO();
3873   if(hasattr(sys.stdin, "buffer")):
3874    shutil.copyfileobj(sys.stdin.buffer, catfp);
3875   else:
3876    shutil.copyfileobj(sys.stdin, catfp);
3877   catfp.seek(0, 0);
3878   catfp = UncompressArchiveFile(catfp, formatspecs);
3879   if(not catfp):
3880    return False;
3881   catfp.seek(0, 0);
3882  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
3883   catfp = download_file_from_internet_file(infile);
3884   catfp.seek(0, 0);
3885   catfp = UncompressArchiveFile(catfp, formatspecs);
3886   if(not catfp):
3887    return False;
3888   catfp.seek(0, 0);
3889  else:
3890   infile = RemoveWindowsPath(infile);
3891   checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
3892   if(checkcompressfile=="tarfile"):
3893    return TarFileToArray(infile, seekto, 0, listonly, skipchecksum, formatspecs, returnfp);
3894   if(checkcompressfile=="zipfile"):
3895    return ZipFileToArray(infile, seekto, 0, listonly, skipchecksum, formatspecs, returnfp);
3896   if(rarfile_support and checkcompressfile=="rarfile"):
3897    return RarFileToArray(infile, seekto, 0, listonly, skipchecksum, formatspecs, returnfp);
3898   if(py7zr_support and checkcompressfile=="7zipfile"):
3899    return SevenZipFileToArray(infile, seekto, 0, listonly, skipchecksum, formatspecs, returnfp);
3900   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
3901    return False;
3902   compresscheck = CheckCompressionType(infile, formatspecs, True);
3903   if(not compresscheck):
3904    fextname = os.path.splitext(infile)[1];
3905    if(fextname==".gz"):
3906     compresscheck = "gzip";
3907    elif(fextname==".bz2"):
3908     compresscheck = "bzip2";
3909    elif(fextname==".zst"):
3910     compresscheck = "zstd";
3911    elif(fextname==".lz4" or fextname==".clz4"):
3912     compresscheck = "lz4";
3913    elif(fextname==".lzo" or fextname==".lzop"):
3914     compresscheck = "lzo";
3915    elif(fextname==".lzma" or fextname==".xz"):
3916     compresscheck = "lzma";
3917    else:
3918     return False;
3919   if(not compresscheck):
3920    return False;
3921   catfp = UncompressFile(infile, formatspecs, "rb");
3922  '''
3923  try:
3924   catfp.seek(0, 2);
3925  except OSError:
3926   SeekToEndOfFile(catfp);
3927  except ValueError:
3928   SeekToEndOfFile(catfp);
3929  CatSize = catfp.tell();
3930  CatSizeEnd = CatSize;
3931  '''
3932  try:
3933   catfp.seek(0, 0);
3934  except OSError:
3935   return False;
3936  except ValueError:
3937   return False;
3938  curloc = catfp.tell();
3939  if(curloc>0):
3940   catfp.seek(0, 0);
3941  catheader = ReadFileHeaderData(catfp, 4, formatspecs[5]);
3942  if(curloc>0):
3943   catfp.seek(curloc, 0);
3944  catstring = catheader[0];
3945  catversion = re.findall(r"([\d]+)$", catstring);
3946  fprenumfiles = catheader[1];
3947  fnumfiles = int(fprenumfiles, 16);
3948  fprechecksumtype = catheader[2];
3949  fprechecksum = catheader[3];
3950  fileheader = AppendNullByte(catstring, formatspecs[5]);
3951  fnumfileshex = format(int(fnumfiles), 'x').lower();
3952  fileheader = fileheader + AppendNullBytes([fnumfileshex, fprechecksumtype], formatspecs[5]);
3953  if(fprechecksumtype=="none" or fprechecksumtype==""):
3954   catfileheadercshex = format(0, 'x').lower();
3955  elif(fprechecksumtype=="crc16" or fprechecksumtype=="crc16_ansi" or fprechecksumtype=="crc16_ibm"):
3956   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
3957  elif(fprechecksumtype=="crc16_ccitt"):
3958   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
3959  elif(fprechecksumtype=="adler32"):
3960   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
3961  elif(fprechecksumtype=="crc32"):
3962   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
3963  elif(fprechecksumtype=="crc64_ecma"):
3964   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3965  elif(fprechecksumtype=="crc64" or fprechecksumtype=="crc64_iso"):
3966   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3967  elif(CheckSumSupportAlt(fprechecksumtype, hashlib_guaranteed)):
3968   checksumoutstr = hashlib.new(fprechecksumtype);
3969   checksumoutstr.update(fileheader.encode('UTF-8'));
3970   catfileheadercshex = checksumoutstr.hexdigest().lower();
3971  else:
3972   catfileheadercshex = format(0, 'x').lower();
3973  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
3974  fheadtell = len(fileheader);
3975  if(fprechecksum!=catfileheadercshex and not skipchecksum):
3976   VerbosePrintOut("File Header Checksum Error with file " + infile + " at offset " + str(0));
3977   return False;
3978  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
3979  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': {}};
3980  if(seekto>=fnumfiles):
3981   seekto = fnumfiles - 1;
3982  if(seekto<0):
3983   seekto = 0;
3984  if(seekto>=0):
3985   il = -1;
3986   while(il < seekto):
3987    prefhstart = catfp.tell();
3988    if(formatspecs[7]):
3989     preheaderdata = ReadFileHeaderDataBySize(catfp, formatspecs[5]);
3990    else:
3991     preheaderdata = ReadFileHeaderDataWoSize(catfp, formatspecs[5]);
3992    if(len(preheaderdata)==0):
3993     break;
3994    prefheadsize = int(preheaderdata[0], 16);
3995    prefnumfields = int(preheaderdata[1], 16);
3996    preftype = int(preheaderdata[2], 16);
3997    if(re.findall("^[.|/]", preheaderdata[3])):
3998     prefname = preheaderdata[3];
3999    else:
4000     prefname = "./"+preheaderdata[3];
4001    prefbasedir = os.path.dirname(prefname);
4002    preflinkname = preheaderdata[4];
4003    prefsize = int(preheaderdata[5], 16);
4004    prefatime = int(preheaderdata[6], 16);
4005    prefmtime = int(preheaderdata[7], 16);
4006    prefctime = int(preheaderdata[8], 16);
4007    prefbtime = int(preheaderdata[9], 16);
4008    prefmode = int(preheaderdata[10], 16);
4009    prefchmode = stat.S_IMODE(prefmode);
4010    preftypemod = stat.S_IFMT(prefmode);
4011    prefwinattributes = int(preheaderdata[11], 16);
4012    prefuid = int(preheaderdata[12], 16);
4013    prefuname = preheaderdata[13];
4014    prefgid = int(preheaderdata[14], 16);
4015    prefgname = preheaderdata[15];
4016    fid = int(preheaderdata[16], 16);
4017    finode = int(preheaderdata[17], 16);
4018    flinkcount = int(preheaderdata[18], 16);
4019    prefdev_minor = int(preheaderdata[19], 16);
4020    prefdev_major = int(preheaderdata[20], 16);
4021    prefrdev_minor = int(preheaderdata[22], 16);
4022    prefrdev_major = int(preheaderdata[23], 16);
4023    prefextrasize = int(preheaderdata[24], 16);
4024    prefextrafields = int(preheaderdata[25], 16);
4025    extrafieldslist = [];
4026    extrastart = 25;
4027    extraend = extrastart + prefextrafields;
4028    extrafieldslist = [];
4029    if(extrastart<extraend):
4030     extrafieldslist.append(preheaderdata[extrastart]);
4031     extrastart = extrastart + 1;
4032    prefchecksumtype = preheaderdata[extrastart].lower();
4033    prefcs = preheaderdata[extrastart + 1].lower();
4034    prefccs = preheaderdata[extrastart + 2].lower();
4035    hc = 0;
4036    hcmax = len(preheaderdata) - 2;
4037    hout = "";
4038    while(hc<hcmax):
4039     hout = hout + AppendNullByte(preheaderdata[hc], formatspecs[5]);
4040     hc = hc + 1;
4041    prenewfcs = GetFileChecksum(hout, preheaderdata[-3].lower(), True, formatspecs);
4042    if(prefcs!=prenewfcs and not skipchecksum):
4043     VerbosePrintOut("File Header Checksum Error with file " + prefname + " at offset " + str(prefhstart));
4044     return False;
4045     valid_archive = False;
4046     invalid_archive = True;
4047    prefhend = catfp.tell() - 1;
4048    prefcontentstart = catfp.tell();
4049    prefcontents = "";
4050    pyhascontents = False;
4051    if(prefsize>0):
4052     prefcontents = catfp.read(prefsize);
4053     prenewfccs = GetFileChecksum(prefcontents, preheaderdata[-3].lower(), False, formatspecs);
4054     pyhascontents = True;
4055     if(prefccs!=prenewfccs and not skipchecksum):
4056      VerbosePrintOut("File Content Checksum Error with file " + prefname + " at offset " + str(prefcontentstart));
4057      return False;
4058    catfp.seek(1, 1);
4059    il = il + 1;
4060  catfp.seek(seekstart, 0);
4061  fileidnum = il;
4062  catfheadsize = int(preheaderdata[0], 16);
4063  catfnumfields = int(preheaderdata[1], 16);
4064  catftype = int(preheaderdata[2], 16);
4065  if(re.findall("^[.|/]", preheaderdata[3])):
4066   catfname = preheaderdata[3];
4067  else:
4068   catfname = "./"+preheaderdata[3];
4069  catflinkname = preheaderdata[4];
4070  catfsize = int(preheaderdata[5], 16);
4071  catfbasedir = os.path.dirname(catfname);
4072  catlist = {'fid': fileidnum, 'foffset': catfp.tell(), 'ftype': catftype, 'fname': catfname, 'fbasedir': catfbasedir, 'flinkname': catflinkname, 'fsize': catfsize};
4073  if(returnfp):
4074   catlist.update({'catfp': catfp});
4075  else:
4076   catfp.close();
4077  return catlist;
4078
4079 create_alias_function("", __file_format_name__, "SeekToFileNum", ArchiveFileSeekToFileNum);
4080
4081 def ArchiveFileSeekToFileName(infile, seekfile=None, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4082  if(hasattr(infile, "read") or hasattr(infile, "write")):
4083   catfp = infile;
4084   catfp.seek(0, 0);
4085   catfp = UncompressArchiveFile(catfp, formatspecs);
4086   checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True);
4087   if(checkcompressfile=="tarfile"):
4088    return TarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4089   if(checkcompressfile=="zipfile"):
4090    return ZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4091   if(rarfile_support and checkcompressfile=="rarfile"):
4092    return RarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4093   if(py7zr_support and checkcompressfile=="7zipfile"):
4094    return SevenZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4095   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4096    return False;
4097   if(not catfp):
4098    return False;
4099   catfp.seek(0, 0);
4100  elif(infile=="-"):
4101   catfp = BytesIO();
4102   if(hasattr(sys.stdin, "buffer")):
4103    shutil.copyfileobj(sys.stdin.buffer, catfp);
4104   else:
4105    shutil.copyfileobj(sys.stdin, catfp);
4106   catfp.seek(0, 0);
4107   catfp = UncompressArchiveFile(catfp, formatspecs);
4108   if(not catfp):
4109    return False;
4110   catfp.seek(0, 0);
4111  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
4112   catfp = download_file_from_internet_file(infile);
4113   catfp = UncompressArchiveFile(catfp, formatspecs);
4114   catfp.seek(0, 0);
4115   if(not catfp):
4116    return False;
4117   catfp.seek(0, 0);
4118  else:
4119   infile = RemoveWindowsPath(infile);
4120   checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
4121   if(checkcompressfile=="tarfile"):
4122    return TarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4123   if(checkcompressfile=="zipfile"):
4124    return ZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4125   if(rarfile_support and checkcompressfile=="rarfile"):
4126    return RarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4127   if(py7zr_support and checkcompressfile=="7zipfile"):
4128    return SevenZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
4129   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4130    return False;
4131   compresscheck = CheckCompressionType(infile, formatspecs, True);
4132   if(not compresscheck):
4133    fextname = os.path.splitext(infile)[1];
4134    if(fextname==".gz"):
4135     compresscheck = "gzip";
4136    elif(fextname==".bz2"):
4137     compresscheck = "bzip2";
4138    elif(fextname==".zst"):
4139     compresscheck = "zstd";
4140    elif(fextname==".lz4" or fextname==".clz4"):
4141     compresscheck = "lz4";
4142    elif(fextname==".lzo" or fextname==".lzop"):
4143     compresscheck = "lzo";
4144    elif(fextname==".lzma" or fextname==".xz"):
4145     compresscheck = "lzma";
4146    else:
4147     return False;
4148   if(not compresscheck):
4149    return False;
4150   catfp = UncompressFile(infile, formatspecs, "rb");
4151  '''
4152  try:
4153   catfp.seek(0, 2);
4154  except OSError:
4155   SeekToEndOfFile(catfp);
4156  except ValueError:
4157   SeekToEndOfFile(catfp);
4158  CatSize = catfp.tell();
4159  CatSizeEnd = CatSize;
4160  '''
4161  try:
4162   catfp.seek(0, 0);
4163  except OSError:
4164   return False;
4165  except ValueError:
4166   return False;
4167  curloc = catfp.tell();
4168  if(curloc>0):
4169   catfp.seek(0, 0);
4170  catheader = ReadFileHeaderData(catfp, 4, formatspecs[5]);
4171  if(curloc>0):
4172   catfp.seek(curloc, 0);
4173  catstring = catheader[0];
4174  catversion = re.findall(r"([\d]+)$", catstring);
4175  fprenumfiles = catheader[1];
4176  fnumfiles = int(fprenumfiles, 16);
4177  fprechecksumtype = catheader[2];
4178  fprechecksum = catheader[3];
4179  fileheader = AppendNullByte(catstring, formatspecs[5]);
4180  fnumfileshex = format(int(fnumfiles), 'x').lower();
4181  fileheader = fileheader + AppendNullBytes([fnumfileshex, fprechecksumtype], formatspecs[5]);
4182  if(fprechecksumtype=="none" or fprechecksumtype==""):
4183   catfileheadercshex = format(0, 'x').lower();
4184  elif(fprechecksumtype=="crc16" or fprechecksumtype=="crc16_ansi" or fprechecksumtype=="crc16_ibm"):
4185   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4186  elif(fprechecksumtype=="crc16_ccitt"):
4187   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4188  elif(fprechecksumtype=="adler32"):
4189   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4190  elif(fprechecksumtype=="crc32"):
4191   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4192  elif(fprechecksumtype=="crc64_ecma"):
4193   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4194  elif(fprechecksumtype=="crc64" or fprechecksumtype=="crc64_iso"):
4195   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4196  elif(CheckSumSupportAlt(fprechecksumtype, hashlib_guaranteed)):
4197   checksumoutstr = hashlib.new(fprechecksumtype);
4198   checksumoutstr.update(fileheader.encode('UTF-8'));
4199   catfileheadercshex = checksumoutstr.hexdigest().lower();
4200  else:
4201   catfileheadercshex = format(0, 'x').lower();
4202  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
4203  fheadtell = len(fileheader);
4204  if(fprechecksum!=catfileheadercshex and not skipchecksum):
4205   VerbosePrintOut("File Header Checksum Error with file " + infile + " at offset " + str(0));
4206   return False;
4207  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
4208  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': {}};
4209  seekto = fnumfiles - 1
4210  filefound = False;
4211  if(seekto>=0):
4212   il = -1;
4213   while(il < seekto):
4214    prefhstart = catfp.tell();
4215    if(formatspecs[7]):
4216     preheaderdata = ReadFileHeaderDataBySize(catfp, formatspecs[5]);
4217    else:
4218     preheaderdata = ReadFileHeaderDataWoSize(catfp, formatspecs[5]);
4219    if(len(preheaderdata)==0):
4220     break;
4221    prefheadsize = int(preheaderdata[0], 16);
4222    prefnumfields = int(preheaderdata[1], 16);
4223    preftype = int(preheaderdata[2], 16);
4224    if(re.findall("^[.|/]", preheaderdata[3])):
4225     prefname = preheaderdata[3];
4226    else:
4227     prefname = "./"+preheaderdata[3];
4228    prefbasedir = os.path.dirname(prefname);
4229    preflinkname = preheaderdata[4];
4230    prefsize = int(preheaderdata[5], 16);
4231    prefatime = int(preheaderdata[6], 16);
4232    prefmtime = int(preheaderdata[7], 16);
4233    prefctime = int(preheaderdata[8], 16);
4234    prefbtime = int(preheaderdata[9], 16);
4235    prefmode = int(preheaderdata[10], 16);
4236    prefchmode = stat.S_IMODE(prefmode);
4237    preftypemod = stat.S_IFMT(prefmode);
4238    prefwinattributes = int(preheaderdata[11], 16);
4239    prefuid = int(preheaderdata[12], 16);
4240    prefuname = preheaderdata[13];
4241    prefgid = int(preheaderdata[14], 16);
4242    prefgname = preheaderdata[15];
4243    fid = int(preheaderdata[16], 16);
4244    finode = int(preheaderdata[17], 16);
4245    flinkcount = int(preheaderdata[18], 16);
4246    prefdev_minor = int(preheaderdata[19], 16);
4247    prefdev_major = int(preheaderdata[20], 16);
4248    prefrdev_minor = int(preheaderdata[22], 16);
4249    prefrdev_major = int(preheaderdata[23], 16);
4250    prefextrasize = int(preheaderdata[24], 16);
4251    prefextrafields = int(preheaderdata[25], 16);
4252    extrafieldslist = [];
4253    extrastart = 25;
4254    extraend = extrastart + prefextrafields;
4255    extrafieldslist = [];
4256    if(extrastart<extraend):
4257     extrafieldslist.append(preheaderdata[extrastart]);
4258     extrastart = extrastart + 1;
4259    prefchecksumtype = preheaderdata[extrastart].lower();
4260    prefcs = preheaderdata[extrastart + 1].lower();
4261    prefccs = preheaderdata[extrastart + 2].lower();
4262    hc = 0;
4263    hcmax = len(preheaderdata) - 2;
4264    hout = "";
4265    while(hc<hcmax):
4266     hout = hout + AppendNullByte(preheaderdata[hc], formatspecs[5]);
4267     hc = hc + 1;
4268    prenewfcs = GetFileChecksum(hout, preheaderdata[-3].lower(), True, formatspecs);
4269    if(prefcs!=prenewfcs and not skipchecksum):
4270     VerbosePrintOut("File Header Checksum Error with file " + prefname + " at offset " + str(prefhstart));
4271     return False;
4272     valid_archive = False;
4273     invalid_archive = True;
4274    prefhend = catfp.tell() - 1;
4275    prefcontentstart = catfp.tell();
4276    prefcontents = "";
4277    pyhascontents = False;
4278    if(prefsize>0):
4279     prefcontents = catfp.read(prefsize);
4280     prenewfccs = GetFileChecksum(prefcontents, preheaderdata[-3].lower(), False, formatspecs);
4281     pyhascontents = True;
4282     if(prefccs!=prenewfccs and not skipchecksum):
4283      VerbosePrintOut("File Content Checksum Error with file " + prefname + " at offset " + str(prefcontentstart));
4284      return False;
4285    catfp.seek(1, 1);
4286    il = il + 1;
4287    filefound = False;
4288    prefname = preheaderdata[2];
4289    if(re.findall("^[.|/]", preheaderdata[2])):
4290     prefname = preheaderdata[2];
4291    else:
4292     prefname = "./"+preheaderdata[2];
4293    if(prefname==seekfile):
4294     filefound = True;
4295     break;
4296  catfp.seek(seekstart, 0);
4297  fileidnum = il;
4298  catfheadsize = int(preheaderdata[0], 16);
4299  catfnumfields = int(preheaderdata[1], 16);
4300  catftype = int(preheaderdata[2], 16);
4301  if(re.findall("^[.|/]", preheaderdata[3])):
4302   catfname = preheaderdata[3];
4303  else:
4304   catfname = "./"+preheaderdata[3];
4305  catflinkname = preheaderdata[4];
4306  catfsize = int(preheaderdata[5], 16);
4307  catfbasedir = os.path.dirname(catfname);
4308  if(filefound):
4309   catlist = {'fid': fileidnum, 'foffset': catfp.tell(), 'ftype': catftype, 'fname': catfname, 'fbasedir': catfbasedir, 'flinkname': catflinkname, 'fsize': catfsize};
4310  else:
4311   return False;
4312  if(returnfp):
4313   catlist.update({'catfp': catfp});
4314  else:
4315   catfp.close();
4316  return catlist;
4317
4318 create_alias_function("", __file_format_name__, "SeekToFileName", ArchiveFileSeekToFileName);
4319
4320 def ArchiveFileValidate(infile, formatspecs=__file_format_list__, verbose=False, returnfp=False):
4321  if(verbose):
4322   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
4323  if(hasattr(infile, "read") or hasattr(infile, "write")):
4324   catfp = infile;
4325   catfp.seek(0, 0);
4326   catfp = UncompressArchiveFile(catfp, formatspecs);
4327   checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True);
4328   if(checkcompressfile=="tarfile"):
4329    return TarFileToArray(infile, 0, 0, False, False, formatspecs, returnfp);
4330   if(checkcompressfile=="zipfile"):
4331    return ZipFileToArray(infile, 0, 0, False, False, formatspecs, returnfp);
4332   if(rarfile_support and checkcompressfile=="rarfile"):
4333    return RarFileToArray(infile, 0, 0, False, False, formatspecs, returnfp);
4334   if(py7zr_support and checkcompressfile=="7zipfile"):
4335    return SevenZipFileToArray(infile, 0, 0, False, False, formatspecs, returnfp);
4336   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4337    return False;
4338   if(not catfp):
4339    return False;
4340   catfp.seek(0, 0);
4341  elif(infile=="-"):
4342   catfp = BytesIO();
4343   if(hasattr(sys.stdin, "buffer")):
4344    shutil.copyfileobj(sys.stdin.buffer, catfp);
4345   else:
4346    shutil.copyfileobj(sys.stdin, catfp);
4347   catfp.seek(0, 0);
4348   catfp = UncompressArchiveFile(catfp, formatspecs);
4349   if(not catfp):
4350    return False;
4351   catfp.seek(0, 0);
4352  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
4353   catfp = download_file_from_internet_file(infile);
4354   catfp = UncompressArchiveFile(catfp, formatspecs);
4355   catfp.seek(0, 0);
4356   if(not catfp):
4357    return False;
4358   catfp.seek(0, 0);
4359  else:
4360   infile = RemoveWindowsPath(infile);
4361   checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
4362   if(checkcompressfile=="tarfile"):
4363    return TarFileToArray(infile, 0, 0, False, False, formatspecs, returnfp);
4364   if(checkcompressfile=="zipfile"):
4365    return ZipFileToArray(infile, 0, 0, False, False, formatspecs, returnfp);
4366   if(rarfile_support and checkcompressfile=="rarfile"):
4367    return RarFileToArray(infile, 0, 0, False, False, formatspecs, returnfp);
4368   if(py7zr_support and checkcompressfile=="7zipfile"):
4369    return SevenZipFileToArray(infile, 0, 0, False, False, formatspecs, returnfp);
4370   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4371    return False;
4372   compresscheck = CheckCompressionType(infile, formatspecs, True);
4373   if(not compresscheck):
4374    fextname = os.path.splitext(infile)[1];
4375    if(fextname==".gz"):
4376     compresscheck = "gzip";
4377    elif(fextname==".bz2"):
4378     compresscheck = "bzip2";
4379    elif(fextname==".zst"):
4380     compresscheck = "zstd";
4381    elif(fextname==".lz4" or fextname==".clz4"):
4382     compresscheck = "lz4";
4383    elif(fextname==".lzo" or fextname==".lzop"):
4384     compresscheck = "lzo";
4385    elif(fextname==".lzma" or fextname==".xz"):
4386     compresscheck = "lzma";
4387    else:
4388     return False;
4389   if(not compresscheck):
4390    return False;
4391   catfp = UncompressFile(infile, formatspecs, "rb");
4392  '''
4393  try:
4394   catfp.seek(0, 2);
4395  except OSError:
4396   SeekToEndOfFile(catfp);
4397  except ValueError:
4398   SeekToEndOfFile(catfp);
4399  CatSize = catfp.tell();
4400  CatSizeEnd = CatSize;
4401  '''
4402  try:
4403   catfp.seek(0, 0);
4404  except OSError:
4405   return False;
4406  except ValueError:
4407   return False;
4408  curloc = catfp.tell();
4409  if(curloc>0):
4410   catfp.seek(0, 0);
4411  catheader = ReadFileHeaderData(catfp, 4, formatspecs[5]);
4412  if(curloc>0):
4413   catfp.seek(curloc, 0);
4414  catstring = catheader[0];
4415  catversion = re.findall(r"([\d]+)$", catstring);
4416  fprenumfiles = catheader[1];
4417  fnumfiles = int(fprenumfiles, 16);
4418  fprechecksumtype = catheader[2];
4419  fprechecksum = catheader[3];
4420  il = 0;
4421  fileheader = AppendNullByte(catstring, formatspecs[5]);
4422  fnumfileshex = format(int(fnumfiles), 'x').lower();
4423  fileheader = fileheader + AppendNullBytes([fnumfileshex, fprechecksumtype], formatspecs[5]);
4424  if(fprechecksumtype=="none" or fprechecksumtype==""):
4425   catfileheadercshex = format(0, 'x').lower();
4426  elif(fprechecksumtype=="crc16" or fprechecksumtype=="crc16_ansi" or fprechecksumtype=="crc16_ibm"):
4427   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4428  elif(fprechecksumtype=="crc16_ccitt"):
4429   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4430  elif(fprechecksumtype=="adler32"):
4431   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4432  elif(fprechecksumtype=="crc32"):
4433   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4434  elif(fprechecksumtype=="crc64_ecma"):
4435   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4436  elif(fprechecksumtype=="crc64" or fprechecksumtype=="crc64_iso"):
4437   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4438  elif(CheckSumSupportAlt(fprechecksumtype, hashlib_guaranteed)):
4439   checksumoutstr = hashlib.new(fprechecksumtype);
4440   checksumoutstr.update(fileheader.encode('UTF-8'));
4441   catfileheadercshex = checksumoutstr.hexdigest().lower();
4442  else:
4443   catfileheadercshex = format(0, 'x').lower();
4444  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
4445  valid_archive = True;
4446  invalid_archive = False;
4447  if(verbose):
4448   VerbosePrintOut(infile);
4449   VerbosePrintOut("Number of Records " + str(fnumfiles));
4450  if(fprechecksum==catfileheadercshex):
4451   if(verbose):
4452    VerbosePrintOut("File Header Checksum Passed at offset " + str(0));
4453  else:
4454   if(verbose):
4455    VerbosePrintOut("File Header Checksum Failed at offset " + str(0));
4456    valid_archive = False;
4457    invalid_archive = True;
4458  if(verbose):
4459   VerbosePrintOut("");
4460  while(il<fnumfiles):
4461   catfhstart = catfp.tell();
4462   if(formatspecs[7]):
4463    catheaderdata = ReadFileHeaderDataBySize(catfp, formatspecs[5]);
4464   else:
4465    catheaderdata = ReadFileHeaderDataWoSize(catfp, formatspecs[5]);
4466   if(len(catheaderdata)==0):
4467    break;
4468   catfheadsize = int(catheaderdata[0], 16);
4469   catfnumfields = int(catheaderdata[1], 16);
4470   catftype = int(catheaderdata[2], 16);
4471   if(re.findall("^[.|/]", catheaderdata[3])):
4472    catfname = catheaderdata[3];
4473   else:
4474    catfname = "./"+catheaderdata[3];
4475   catfbasedir = os.path.dirname(catfname);
4476   catflinkname = catheaderdata[4];
4477   catfsize = int(catheaderdata[5], 16);
4478   catfatime = int(catheaderdata[6], 16);
4479   catfmtime = int(catheaderdata[7], 16);
4480   catfctime = int(catheaderdata[8], 16);
4481   catfbtime = int(catheaderdata[9], 16);
4482   catfmode = int(catheaderdata[10], 16);
4483   catfchmode = stat.S_IMODE(catfmode);
4484   catftypemod = stat.S_IFMT(catfmode);
4485   prefwinattributes = int(catheaderdata[11], 16);
4486   catfuid = int(catheaderdata[12], 16);
4487   catfuname = catheaderdata[13];
4488   catfgid = int(catheaderdata[14], 16);
4489   catfgname = catheaderdata[15];
4490   fid = int(catheaderdata[16], 16);
4491   finode = int(catheaderdata[17], 16);
4492   flinkcount = int(catheaderdata[18], 16);
4493   catfdev_minor = int(catheaderdata[19], 16);
4494   catfdev_major = int(catheaderdata[20], 16);
4495   catfrdev_minor = int(catheaderdata[21], 16);
4496   catfrdev_major = int(catheaderdata[22], 16);
4497   catfextrasize = int(catheaderdata[23], 16);
4498   catfextrafields = int(catheaderdata[24], 16);
4499   extrafieldslist = [];
4500   extrastart = 25;
4501   extraend = extrastart + catfextrafields;
4502   extrafieldslist = [];
4503   if(extrastart<extraend):
4504    extrafieldslist.append(catheaderdata[extrastart]);
4505    extrastart = extrastart + 1;
4506   catfchecksumtype = catheaderdata[extrastart].lower();
4507   catfcs = catheaderdata[extrastart + 1].lower();
4508   catfccs = catheaderdata[extrastart + 2].lower();
4509   hc = 0;
4510   hcmax = len(catheaderdata) - 2;
4511   hout = "";
4512   while(hc<hcmax):
4513    hout = hout + AppendNullByte(catheaderdata[hc], formatspecs[5]);
4514    hc = hc + 1;
4515   catnewfcs = GetFileChecksum(hout, catheaderdata[-3].lower(), True, formatspecs);
4516   if(verbose):
4517    VerbosePrintOut(catfname);
4518    VerbosePrintOut("Record Number " + str(il) + "; File ID " + str(fid) + "; iNode Number " + str(finode));
4519   if(catfcs==catnewfcs):
4520    if(verbose):
4521     VerbosePrintOut("File Header Checksum Passed at offset " + str(catfhstart));
4522   else:
4523    if(verbose):
4524     VerbosePrintOut("File Header Checksum Failed at offset " + str(catfhstart));
4525    valid_archive = False;
4526    invalid_archive = True;
4527   catfhend = catfp.tell() - 1;
4528   catfcontentstart = catfp.tell();
4529   catfcontents = "";
4530   pyhascontents = False;
4531   if(catfsize>0):
4532    catfcontents = catfp.read(catfsize);
4533    catnewfccs = GetFileChecksum(catfcontents, catheaderdata[-3].lower(), False, formatspecs);
4534    pyhascontents = True;
4535    if(catfccs==catnewfccs):
4536     if(verbose):
4537      VerbosePrintOut("File Content Checksum Passed at offset " + str(catfcontentstart));
4538    else:
4539     if(verbose):
4540      VerbosePrintOut("File Content Checksum Failed at offset " + str(catfcontentstart));
4541     valid_archive = False;
4542     invalid_archive = True;
4543   if(verbose):
4544    VerbosePrintOut("");
4545   catfp.seek(1, 1);
4546   il = il + 1;
4547  if(valid_archive):
4548   if(returnfp):
4549    return catfp;
4550   else:
4551    catfp.close();
4552    return True;
4553  else:
4554   catfp.close();
4555   return False;
4556
4557 create_alias_function("", __file_format_name__, "Validate", ArchiveFileValidate);
4558
4559 def ArchiveFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4560  if(hasattr(infile, "read") or hasattr(infile, "write")):
4561   catfp = infile;
4562   catfp.seek(0, 0);
4563   catfp = UncompressArchiveFile(catfp, formatspecs);
4564   checkcompressfile = CheckCompressionSubType(catfp, formatspecs, True);
4565   if(checkcompressfile=="tarfile"):
4566    return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4567   if(checkcompressfile=="zipfile"):
4568    return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4569   if(rarfile_support and checkcompressfile=="rarfile"):
4570    return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4571   if(py7zr_support and checkcompressfile=="7zipfile"):
4572    return SevenZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4573   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4574    return False;
4575   if(not catfp):
4576    return False;
4577   catfp.seek(0, 0);
4578  elif(infile=="-"):
4579   catfp = BytesIO();
4580   if(hasattr(sys.stdin, "buffer")):
4581    shutil.copyfileobj(sys.stdin.buffer, catfp);
4582   else:
4583    shutil.copyfileobj(sys.stdin, catfp);
4584   catfp.seek(0, 0);
4585   catfp = UncompressArchiveFile(catfp, formatspecs);
4586   if(not catfp):
4587    return False;
4588   catfp.seek(0, 0);
4589  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
4590   catfp = download_file_from_internet_file(infile);
4591   catfp = UncompressArchiveFile(catfp, formatspecs);
4592   catfp.seek(0, 0);
4593   if(not catfp):
4594    return False;
4595   catfp.seek(0, 0);
4596  else:
4597   infile = RemoveWindowsPath(infile);
4598   checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
4599   if(checkcompressfile=="tarfile"):
4600    return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4601   if(checkcompressfile=="zipfile"):
4602    return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4603   if(rarfile_support and checkcompressfile=="rarfile"):
4604    return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4605   if(py7zr_support and checkcompressfile=="7zipfile"):
4606    return SevenZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4607   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
4608    return False;
4609   compresscheck = CheckCompressionType(infile, formatspecs, True);
4610   if(not compresscheck):
4611    fextname = os.path.splitext(infile)[1];
4612    if(fextname==".gz"):
4613     compresscheck = "gzip";
4614    elif(fextname==".bz2"):
4615     compresscheck = "bzip2";
4616    elif(fextname==".zst"):
4617     compresscheck = "zstd";
4618    elif(fextname==".lz4" or fextname==".clz4"):
4619     compresscheck = "lz4";
4620    elif(fextname==".lzo" or fextname==".lzop"):
4621     compresscheck = "lzo";
4622    elif(fextname==".lzma" or fextname==".xz"):
4623     compresscheck = "lzma";
4624    else:
4625     return False;
4626   if(not compresscheck):
4627    return False;
4628   catfp = UncompressFile(infile, formatspecs, "rb");
4629  '''
4630  try:
4631   catfp.seek(0, 2);
4632  except OSError:
4633   SeekToEndOfFile(catfp);
4634  except ValueError:
4635   SeekToEndOfFile(catfp);
4636  CatSize = catfp.tell();
4637  CatSizeEnd = CatSize;
4638  '''
4639  try:
4640   catfp.seek(0, 0);
4641  except OSError:
4642   return False;
4643  except ValueError:
4644   return False;
4645  curloc = catfp.tell();
4646  if(curloc>0):
4647   catfp.seek(0, 0);
4648  catheader = ReadFileHeaderData(catfp, 4, formatspecs[5]);
4649  if(curloc>0):
4650   catfp.seek(curloc, 0);
4651  catstring = catheader[0];
4652  catversion = re.findall(r"([\d]+)$", catstring);
4653  fprenumfiles = catheader[1];
4654  fnumfiles = int(fprenumfiles, 16);
4655  fprechecksumtype = catheader[2];
4656  fprechecksum = catheader[3];
4657  fileheader = AppendNullByte(catstring, formatspecs[5]);
4658  fnumfileshex = format(int(fnumfiles), 'x').lower();
4659  fileheader = fileheader + AppendNullBytes([fnumfileshex, fprechecksumtype], formatspecs[5]);
4660  if(fprechecksumtype=="none" or fprechecksumtype==""):
4661   catfileheadercshex = format(0, 'x').lower();
4662  elif(fprechecksumtype=="crc16" or fprechecksumtype=="crc16_ansi" or fprechecksumtype=="crc16_ibm"):
4663   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4664  elif(fprechecksumtype=="crc16_ccitt"):
4665   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4666  elif(fprechecksumtype=="adler32"):
4667   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4668  elif(fprechecksumtype=="crc32"):
4669   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4670  elif(fprechecksumtype=="crc64_ecma"):
4671   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4672  elif(fprechecksumtype=="crc64" or fprechecksumtype=="crc64_iso"):
4673   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4674  elif(CheckSumSupportAlt(fprechecksumtype, hashlib_guaranteed)):
4675   checksumoutstr = hashlib.new(fprechecksumtype);
4676   checksumoutstr.update(fileheader.encode('UTF-8'));
4677   catfileheadercshex = checksumoutstr.hexdigest().lower();
4678  else:
4679   catfileheadercshex = format(0, 'x').lower();
4680  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
4681  fheadtell = len(fileheader);
4682  if(fprechecksum!=catfileheadercshex and not skipchecksum):
4683   VerbosePrintOut("File Header Checksum Error with file " + infile + " at offset " + str(0));
4684   return False;
4685  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
4686  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': {}};
4687  if(seekstart<0 and seekstart>fnumfiles):
4688    seekstart = 0;
4689  if(seekend==0 or seekend>fnumfiles and seekend<seekstart):
4690   seekend = fnumfiles;
4691  elif(seekend<0 and abs(seekend)<=fnumfiles and abs(seekend)>=seekstart):
4692   seekend = fnumfiles - abs(seekend);
4693  if(seekstart>0):
4694   il = 0;
4695   while(il < seekstart):
4696    prefhstart = catfp.tell();
4697    if(formatspecs[7]):
4698     preheaderdata = ReadFileHeaderDataBySize(catfp, formatspecs[5]);
4699    else:
4700     preheaderdata = ReadFileHeaderDataWoSize(catfp, formatspecs[5]);
4701    if(len(preheaderdata)==0):
4702     break;
4703    prefheadsize = int(preheaderdata[0], 16);
4704    prefnumfields = int(preheaderdata[1], 16);
4705    if(re.findall("^[.|/]", preheaderdata[3])):
4706     prefname = preheaderdata[3];
4707    else:
4708     prefname = "./"+preheaderdata[3];
4709    prefsize = int(preheaderdata[5], 16);
4710    prefextrasize = int(preheaderdata[23], 16);
4711    prefextrafields = int(preheaderdata[24], 16);
4712    extrafieldslist = [];
4713    extrastart = 25;
4714    extraend = extrastart + prefextrafields;
4715    extrafieldslist = [];
4716    if(extrastart<extraend):
4717     extrafieldslist.append(preheaderdata[extrastart]);
4718     extrastart = extrastart + 1;
4719    prefchecksumtype = preheaderdata[extrastart].lower();
4720    prefcs = preheaderdata[extrastart + 1].lower();
4721    prefccs = preheaderdata[extrastart + 2].lower();
4722    hc = 0;
4723    hcmax = len(preheaderdata) - 2;
4724    hout = "";
4725    while(hc<hcmax):
4726     hout = hout + AppendNullByte(preheaderdata[hc], formatspecs[5]);
4727     hc = hc + 1;
4728    prenewfcs = GetFileChecksum(hout, preheaderdata[-3].lower(), True, formatspecs);
4729    if(prefcs!=prenewfcs and not skipchecksum):
4730     VerbosePrintOut("File Header Checksum Error with file " + prefname + " at offset " + str(prefhstart));
4731     return False;
4732     valid_archive = False;
4733     invalid_archive = True;
4734    prefhend = catfp.tell() - 1;
4735    prefcontentstart = catfp.tell();
4736    prefcontents = "";
4737    pyhascontents = False;
4738    if(prefsize>0):
4739     prefcontents = catfp.read(prefsize);
4740     prenewfccs = GetFileChecksum(prefcontents, preheaderdata[-3].lower(), False, formatspecs);
4741     pyhascontents = True;
4742     if(prefccs!=prenewfccs and not skipchecksum):
4743      VerbosePrintOut("File Content Checksum Error with file " + prefname + " at offset " + str(prefcontentstart));
4744      return False;
4745    catfp.seek(1, 1);
4746    il = il + 1;
4747  fileidnum = seekstart;
4748  realidnum = 0;
4749  while(fileidnum<seekend):
4750   catfhstart = catfp.tell();
4751   if(formatspecs[7]):
4752    catheaderdata = ReadFileHeaderDataBySize(catfp, formatspecs[5]);
4753   else:
4754    catheaderdata = ReadFileHeaderDataWoSize(catfp, formatspecs[5]);
4755   if(len(catheaderdata)==0):
4756    break;
4757   catfheadsize = int(catheaderdata[0], 16);
4758   catfnumfields = int(catheaderdata[1], 16);
4759   catftype = int(catheaderdata[2], 16);
4760   if(re.findall("^[.|/]", catheaderdata[3])):
4761    catfname = catheaderdata[3];
4762   else:
4763    catfname = "./"+catheaderdata[3];
4764   catfbasedir = os.path.dirname(catfname);
4765   catflinkname = catheaderdata[4];
4766   catfsize = int(catheaderdata[5], 16);
4767   catfatime = int(catheaderdata[6], 16);
4768   catfmtime = int(catheaderdata[7], 16);
4769   catfctime = int(catheaderdata[8], 16);
4770   catfbtime = int(catheaderdata[9], 16);
4771   catfmode = int(catheaderdata[10], 16);
4772   catfchmode = stat.S_IMODE(catfmode);
4773   catftypemod = stat.S_IFMT(catfmode);
4774   catfwinattributes = int(catheaderdata[11], 16);
4775   catfuid = int(catheaderdata[12], 16);
4776   catfuname = catheaderdata[13];
4777   catfgid = int(catheaderdata[14], 16);
4778   catfgname = catheaderdata[15];
4779   fid = int(catheaderdata[16], 16);
4780   finode = int(catheaderdata[17], 16);
4781   flinkcount = int(catheaderdata[18], 16);
4782   catfdev_minor = int(catheaderdata[19], 16);
4783   catfdev_major = int(catheaderdata[20], 16);
4784   catfrdev_minor = int(catheaderdata[21], 16);
4785   catfrdev_major = int(catheaderdata[22], 16);
4786   catfextrasize = int(catheaderdata[23], 16);
4787   catfextrafields = int(catheaderdata[24], 16);
4788   extrafieldslist = [];
4789   extrastart = 25;
4790   extraend = extrastart + catfextrafields;
4791   extrafieldslist = [];
4792   if(extrastart<extraend):
4793    extrafieldslist.append(catheaderdata[extrastart]);
4794    extrastart = extrastart + 1;
4795   catfchecksumtype = catheaderdata[extrastart].lower();
4796   catfcs = catheaderdata[extrastart + 1].lower();
4797   catfccs = catheaderdata[extrastart + 2].lower();
4798   hc = 0;
4799   hcmax = len(catheaderdata) - 2;
4800   hout = "";
4801   while(hc<hcmax):
4802    hout = hout + AppendNullByte(catheaderdata[hc], formatspecs[5]);
4803    hc = hc + 1;
4804   catnewfcs = GetFileChecksum(hout, catheaderdata[-3].lower(), True, formatspecs);
4805   if(catfcs!=catnewfcs and not skipchecksum):
4806    VerbosePrintOut("File Header Checksum Error with file " + catfname + " at offset " + str(catfhstart));
4807    return False;
4808   catfhend = catfp.tell() - 1;
4809   catfcontentstart = catfp.tell();
4810   catfcontents = "";
4811   pyhascontents = False;
4812   if(catfsize>0 and not listonly):
4813    catfcontents = catfp.read(catfsize);
4814    catnewfccs = GetFileChecksum(catfcontents, catheaderdata[-3].lower(), False, formatspecs);
4815    pyhascontents = True;
4816    if(catfccs!=catnewfccs and skipchecksum):
4817     VerbosePrintOut("File Content Checksum Error with file " + catfname + " at offset " + str(catfcontentstart));
4818     return False;
4819   if(catfsize>0 and listonly):
4820    catfp.seek(catfsize, 1);
4821    pyhascontents = False;
4822   catfp.seek(1, 1);
4823   catfcontentend = catfp.tell() - 1;
4824   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} });
4825   fileidnum = fileidnum + 1;
4826   realidnum = realidnum + 1;
4827  if(returnfp):
4828   catlist.update({'catfp': catfp});
4829  else:
4830   catfp.close();
4831  return catlist;
4832
4833 create_alias_function("", __file_format_name__, "ToArray", ArchiveFileToArray);
4834
4835 def ArchiveFileStringToArray(catstr, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4836  catfp = BytesIO(catstr);
4837  listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4838  return listcatfiles;
4839
4840 create_alias_function("", __file_format_name__, "StringToArray", ArchiveFileStringToArray);
4841
4842 def TarFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4843  catfp = BytesIO();
4844  catfp = PackArchiveFileFromTarFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
4845  listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4846  return listcatfiles;
4847
4848 def ZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4849  catfp = BytesIO();
4850  catfp = PackArchiveFileFromZipFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
4851  listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4852  return listcatfiles;
4853
4854 if(not rarfile_support):
4855  def RarFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4856   return False;
4857
4858 if(rarfile_support):
4859  def RarFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4860   catfp = BytesIO();
4861   catfp = PackArchiveFileFromSevenZipFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
4862   listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4863   return listcatfiles;
4864
4865 if(not py7zr_support):
4866  def SevenZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4867   return False;
4868
4869 if(py7zr_support):
4870  def SevenZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4871   catfp = BytesIO();
4872   catfp = PackArchiveFileFromSevenZipFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
4873   listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4874   return listcatfiles;
4875
4876 def InFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4877  checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
4878  if(checkcompressfile=="tarfile"):
4879   return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4880  elif(checkcompressfile=="zipfile"):
4881   return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4882  elif(checkcompressfile=="catfile"):
4883   return ArchiveFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4884  elif(rarfile_support and checkcompressfile=="rarfile"):
4885   return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4886  elif(py7zr_support and checkcompressfile=="7zipfile"):
4887   return SevenZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4888  else:
4889   return False;
4890  return False;
4891
4892 def ListDirToArrayAlt(infiles, dirlistfromtxt=False, followlink=False, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
4893  catver = formatspecs[6];
4894  fileheaderver = str(int(catver.replace(".", "")));
4895  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
4896  advancedlist = formatspecs[8];
4897  altinode = formatspecs[9];
4898  infilelist = [];
4899  if(infiles=="-"):
4900   for line in sys.stdin:
4901    infilelist.append(line.strip());
4902   infilelist = list(filter(None, infilelist));
4903  elif(infiles!="-" and dirlistfromtxt and os.path.exists(infiles) and (os.path.isfile(infiles) or infiles=="/dev/null" or infiles=="NUL")):
4904   if(not os.path.exists(infiles) or not os.path.isfile(infiles)):
4905    return False;
4906   with UncompressFile(infiles, formatspecs, "r") as finfile:
4907    for line in finfile:
4908     infilelist.append(line.strip());
4909   infilelist = list(filter(None, infilelist));
4910  else:
4911   if(isinstance(infiles, (list, tuple, ))):
4912    infilelist = list(filter(None, infiles));
4913   elif(isinstance(infiles, (str, ))):
4914    infilelist = list(filter(None, [infiles]));
4915  if(advancedlist):
4916   GetDirList = ListDirAdvanced(infilelist, followlink, False);
4917  else:
4918   GetDirList = ListDir(infilelist, followlink, False);
4919  if(not GetDirList):
4920   return False;
4921  curinode = 0;
4922  curfid = 0;
4923  inodelist = [];
4924  inodetofile = {};
4925  filetoinode = {};
4926  inodetocatinode = {};
4927  fileidnum = 0;
4928  fnumfiles = int(len(GetDirList));
4929  catver = formatspecs[6];
4930  fileheaderver = str(int(catver.replace(".", "")));
4931  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
4932  fnumfileshex = format(int(fnumfiles), 'x').lower();
4933  fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
4934  catversion = re.findall(r"([\d]+)$", fileheader);
4935  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
4936  if(checksumtype=="none" or checksumtype==""):
4937   catfileheadercshex = format(0, 'x').lower();
4938  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
4939   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4940  elif(checksumtype=="crc16_ccitt"):
4941   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4942  elif(checksumtype=="adler32"):
4943   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4944  elif(checksumtype=="crc32"):
4945   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4946  elif(checksumtype=="crc64_ecma"):
4947   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4948  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
4949   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4950  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
4951   checksumoutstr = hashlib.new(checksumtype);
4952   checksumoutstr.update(fileheader.encode('UTF-8'));
4953   catfileheadercshex = checksumoutstr.hexdigest().lower();
4954  else:
4955   catfileheadercshex = format(0, 'x').lower();
4956  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
4957  fheadtell = len(fileheader);
4958  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
4959  for curfname in GetDirList:
4960   if(re.findall("^[.|/]", curfname)):
4961    fname = curfname;
4962   else:
4963    fname = "./"+curfname;
4964   if(verbose):
4965    VerbosePrintOut(fname);
4966   if(not followlink or followlink is None):
4967    fstatinfo = os.lstat(fname);
4968   else:
4969    fstatinfo = os.stat(fname);
4970   fpremode = fstatinfo.st_mode;
4971   finode = fstatinfo.st_ino;
4972   flinkcount = fstatinfo.st_nlink;
4973   ftype = 0;
4974   if(stat.S_ISREG(fpremode)):
4975    ftype = 0;
4976   elif(stat.S_ISLNK(fpremode)):
4977    ftype = 2;
4978   elif(stat.S_ISCHR(fpremode)):
4979    ftype = 3;
4980   elif(stat.S_ISBLK(fpremode)):
4981    ftype = 4;
4982   elif(stat.S_ISDIR(fpremode)):
4983    ftype = 5;
4984   elif(stat.S_ISFIFO(fpremode)):
4985    ftype = 6;
4986   elif(stat.S_ISSOCK(fpremode)):
4987    ftype = 8;
4988   elif(hasattr(stat, "S_ISDOOR") and stat.S_ISDOOR(fpremode)):
4989    ftype = 9;
4990   elif(hasattr(stat, "S_ISPORT") and stat.S_ISPORT(fpremode)):
4991    ftype = 10;
4992   elif(hasattr(stat, "S_ISWHT") and stat.S_ISWHT(fpremode)):
4993    ftype = 11;
4994   else:
4995    ftype = 0;
4996   flinkname = "";
4997   fbasedir = os.path.dirname(fname);
4998   fcurfid = curfid;
4999   if(not followlink and finode!=0):
5000    if(ftype!=1):
5001     if(finode in inodelist):
5002      ftype = 1;
5003      flinkname = inodetofile[finode];
5004      if(altinode):
5005       fcurinode = finode;
5006      else:
5007       fcurinode = inodetocatinode[finode];
5008     if(finode not in inodelist):
5009      inodelist.append(finode);
5010      inodetofile.update({finode: fname});
5011      inodetocatinode.update({finode: curinode});
5012      if(altinode):
5013       fcurinode = finode;
5014      else:
5015       fcurinode = curinode;
5016      curinode = curinode + 1;
5017   else:
5018    fcurinode = curinode;
5019    curinode = curinode + 1;
5020   curfid = curfid + 1;
5021   if(ftype==2):
5022    flinkname = os.readlink(fname);
5023   fdev = fstatinfo.st_dev;
5024   getfdev = GetDevMajorMinor(fdev);
5025   fdev_minor = getfdev[0];
5026   fdev_major = getfdev[1];
5027   frdev = fstatinfo.st_dev;
5028   if(hasattr(fstatinfo, "st_rdev")):
5029    frdev = fstatinfo.st_rdev;
5030   else:
5031    frdev = fstatinfo.st_dev;
5032   getfrdev = GetDevMajorMinor(frdev);
5033   frdev_minor = getfrdev[0];
5034   frdev_major = getfrdev[1];
5035   if(ftype==1 or ftype==2 or ftype==3 or ftype==4 or ftype==5 or ftype==6):
5036    fsize = "0";
5037   if(ftype==0 or ftype==7):
5038    fsize = fstatinfo.st_size;
5039   fatime = fstatinfo.st_atime;
5040   fmtime = fstatinfo.st_mtime;
5041   fctime = fstatinfo.st_ctime;
5042   if(hasattr(fstatinfo, "st_birthtime")):
5043    fbtime = fstatinfo.st_birthtime;
5044   else:
5045    fbtime = fstatinfo.st_ctime;
5046   fmode = fstatinfo.st_mode;
5047   fchmode = stat.S_IMODE(fstatinfo.st_mode);
5048   ftypemod = stat.S_IFMT(fstatinfo.st_mode);
5049   fuid = fstatinfo.st_uid;
5050   fgid = fstatinfo.st_gid;
5051   funame = "";
5052   try:
5053    import pwd;
5054    try:
5055     userinfo = pwd.getpwuid(fstatinfo.st_uid);
5056     funame = userinfo.pw_name;
5057    except KeyError:
5058     funame = "";
5059   except ImportError:
5060    funame = "";
5061   fgname = "";
5062   try:
5063    import grp;
5064    try:
5065     groupinfo = grp.getgrgid(fstatinfo.st_gid);
5066     fgname = groupinfo.gr_name;
5067    except KeyError:
5068     fgname = "";
5069   except ImportError:
5070    fgname = "";
5071   fdev_minor = fdev_minor;
5072   fdev_major = fdev_major;
5073   frdev_minor = frdev_minor;
5074   frdev_major = frdev_major;
5075   finode = finode;
5076   flinkcount = flinkcount;
5077   if(hasattr(fstatinfo, "st_file_attributes")):
5078    fwinattributes = fstatinfo.st_file_attributes;
5079   else:
5080    fwinattributes = 0;
5081   fcontents = "".encode('UTF-8');
5082   chunk_size = 1024;
5083   if(ftype==0 or ftype==7):
5084    with open(fname, "rb") as fpc:
5085     while(True):
5086      chunk = fpc.read(chunk_size);
5087      if(not chunk):
5088       break
5089      fcontents += chunk;
5090   if(followlink and (ftype==1 or ftype==2)):
5091    flstatinfo = os.stat(flinkname);
5092    with open(flinkname, "rb") as fpc:
5093     while(True):
5094      chunk = fpc.read(chunk_size);
5095      if(not chunk):
5096       break;
5097      fcontents += chunk;
5098   ftypehex = format(ftype, 'x').lower();
5099   extrafields = len(extradata);
5100   extrafieldslist = extradata;
5101   catfextrafields = extrafields;
5102   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
5103   if(len(extradata)>0):
5104    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
5105   extrasizelen = len(extrasizestr);
5106   extrasizelenhex = format(extrasizelen, 'x').lower();
5107   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()];
5108   catoutlen = len(catoutlist) + len(extradata) + 3;
5109   catoutlenhex = format(catoutlen, 'x').lower();
5110   catoutlist.insert(0, catoutlenhex);
5111   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
5112   if(len(extradata)>0):
5113    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
5114   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
5115   catfnumfields = catoutlen;
5116   if(checksumtype=="none" or checksumtype==""):
5117    catfileheadercshex = format(0, 'x').lower();
5118    catfilecontentcshex = format(0, 'x').lower();
5119   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5120    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
5121    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
5122   elif(checksumtype=="crc16_ccitt"):
5123    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
5124    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
5125   elif(checksumtype=="adler32"):
5126    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5127    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
5128   elif(checksumtype=="crc32"):
5129    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5130    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
5131   elif(checksumtype=="crc64_ecma"):
5132    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5133    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
5134   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5135    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5136    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
5137   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5138    checksumoutstr = hashlib.new(checksumtype);
5139    checksumoutstr.update("".encode('UTF-8'));
5140    catfileheadercshex = checksumoutstr.hexdigest().lower();
5141    checksumoutstr = hashlib.new(checksumtype);
5142    checksumoutstr.update(fcontents);
5143    catfilecontentcshex = checksumoutstr.hexdigest().lower();
5144   else:
5145    catfileheadercshex = format(0, 'x').lower();
5146    catfilecontentcshex = format(0, 'x').lower();
5147   catfhstart = fheadtell;
5148   fheadtell += len(catfileoutstr);
5149   catfhend = fheadtell - 1;
5150   catfcontentstart = fheadtell;
5151   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5152   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
5153   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
5154   catheaderdata = [catheaersize] + catoutlist + extradata + [checksumtype, catfileheadercshex, catfilecontentcshex]
5155   if(checksumtype=="none" or checksumtype==""):
5156    catfileheadercshex = format(0, 'x').lower();
5157   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5158    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5159   elif(checksumtype=="crc16_ccitt"):
5160    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5161   elif(checksumtype=="adler32"):
5162    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5163   elif(checksumtype=="crc32"):
5164    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5165   elif(checksumtype=="crc64_ecma"):
5166    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5167   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5168    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5169   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5170    checksumoutstr = hashlib.new(checksumtype);
5171    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
5172    catfileheadercshex = checksumoutstr.hexdigest().lower();
5173   else:
5174    catfileheadercshex = format(0, 'x').lower();
5175   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5176   catfileoutstrecd = catfileoutstr.encode('UTF-8');
5177   nullstrecd = formatspecs[5].encode('UTF-8');
5178   fheadtell += len(catfileoutstr) + 1;
5179   catfcontentend = fheadtell - 1;
5180   catfileout = catfileoutstrecd + fcontents + nullstrecd;
5181   pyhascontents = False;
5182   if(int(fsize)>0 and not listonly):
5183    pyhascontents = True;
5184   if(int(fsize)>0 and listonly):
5185    fcontents = "";
5186    pyhascontents = False;
5187   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} });
5188   fileidnum = fileidnum + 1;
5189  return catlist;
5190
5191 def TarFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5192  curinode = 0;
5193  curfid = 0;
5194  inodelist = [];
5195  inodetofile = {};
5196  filetoinode = {};
5197  inodetocatinode = {};
5198  fileidnum = 0;
5199  if(infile=="-"):
5200   infile = BytesIO();
5201   if(hasattr(sys.stdin, "buffer")):
5202    shutil.copyfileobj(sys.stdin.buffer, infile);
5203   else:
5204    shutil.copyfileobj(sys.stdin, infile);
5205   infile.seek(0, 0);
5206   if(not infile):
5207    return False;
5208   infile.seek(0, 0);
5209  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
5210   infile = download_file_from_internet_file(infile);
5211   infile.seek(0, 0);
5212   if(not infile):
5213    return False;
5214   infile.seek(0, 0);
5215  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
5216   return False;
5217  elif(os.path.exists(infile) and os.path.isfile(infile)):
5218   try:
5219    if(not tarfile.is_tarfile(infile)):
5220     return False;
5221   except AttributeError:
5222    if(not is_tarfile(infile)):
5223     return False;
5224  else:
5225   return False;
5226  try:
5227   if(hasattr(infile, "read") or hasattr(infile, "write")):
5228    tarfp = tarfile.open(fileobj=infile, mode="r");
5229   else:
5230    tarfp = tarfile.open(infile, "r");
5231  except FileNotFoundError:
5232   return False;
5233  fnumfiles = int(len(tarfp.getmembers()));
5234  catver = formatspecs[6];
5235  fileheaderver = str(int(catver.replace(".", "")));
5236  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
5237  fnumfileshex = format(int(fnumfiles), 'x').lower();
5238  fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
5239  catversion = re.findall(r"([\d]+)$", fileheader);
5240  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
5241  if(checksumtype=="none" or checksumtype==""):
5242   catfileheadercshex = format(0, 'x').lower();
5243  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5244   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5245  elif(checksumtype=="crc16_ccitt"):
5246   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5247  elif(checksumtype=="adler32"):
5248   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5249  elif(checksumtype=="crc32"):
5250   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5251  elif(checksumtype=="crc64_ecma"):
5252   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5253  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5254   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5255  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5256   checksumoutstr = hashlib.new(checksumtype);
5257   checksumoutstr.update(fileheader.encode('UTF-8'));
5258   catfileheadercshex = checksumoutstr.hexdigest().lower();
5259  else:
5260   catfileheadercshex = format(0, 'x').lower();
5261  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
5262  fheadtell = len(fileheader);
5263  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
5264  for member in sorted(tarfp.getmembers(), key=lambda x: x.name):
5265   if(re.findall("^[.|/]", member.name)):
5266    fname = member.name;
5267   else:
5268    fname = "./"+member.name;
5269   if(verbose):
5270    VerbosePrintOut(fname);
5271   fpremode = member.mode;
5272   ffullmode = member.mode;
5273   flinkcount = 0;
5274   ftype = 0;
5275   if(member.isreg()):
5276    ffullmode = member.mode + stat.S_IFREG;
5277    ftype = 0;
5278   elif(member.isdev()):
5279    ffullmode = member.mode;
5280    ftype = 7;
5281   elif(member.islnk()):
5282    ffullmode = member.mode + stat.S_IFREG;
5283    ftype = 1;
5284   elif(member.issym()):
5285    ffullmode = member.mode + stat.S_IFLNK;
5286    ftype = 2;
5287   elif(member.ischr()):
5288    ffullmode = member.mode + stat.S_IFCHR;
5289    ftype = 3;
5290   elif(member.isblk()):
5291    ffullmode = member.mode + stat.S_IFBLK;
5292    ftype = 4;
5293   elif(member.isdir()):
5294    ffullmode = member.mode + stat.S_IFDIR;
5295    ftype = 5;
5296   elif(member.isfifo()):
5297    ffullmode = member.mode + stat.S_IFIFO;
5298    ftype = 6;
5299   elif(member.issparse()):
5300    ffullmode = member.mode;
5301    ftype = 12;
5302   else:
5303    ffullmode = member.mode;
5304    ftype = 0;
5305   flinkname = "";
5306   fbasedir = os.path.dirname(fname);
5307   fcurfid = curfid;
5308   fcurinode = curfid;
5309   finode = fcurinode;
5310   curfid = curfid + 1;
5311   if(ftype==2):
5312    flinkname = member.linkname;
5313   fdev_minor = member.devminor;
5314   fdev_major = member.devmajor;
5315   frdev_minor = member.devminor;
5316   frdev_major = member.devmajor;
5317   if(ftype==1 or ftype==2 or ftype==3 or ftype==4 or ftype==5 or ftype==6):
5318    fsize = "0";
5319   elif(ftype==0 or ftype==7):
5320    fsize = member.size;
5321   else:
5322    fsize = member.size;
5323   fatime = member.mtime;
5324   fmtime = member.mtime;
5325   fctime = member.mtime;
5326   fbtime = member.mtime;
5327   fmode = ffullmode;
5328   fchmode = stat.S_IMODE(ffullmode);
5329   ftypemod = stat.S_IFMT(ffullmode);
5330   fuid = member.uid;
5331   fgid = member.gid;
5332   funame = member.uname;
5333   fgname = member.gname;
5334   flinkcount = flinkcount;
5335   fwinattributes = int(0);
5336   fcontents = "".encode('UTF-8');
5337   chunk_size = 1024;
5338   if(ftype==0 or ftype==7):
5339    with tarfp.extractfile(member) as fpc:
5340     while(True):
5341      chunk = fpc.read(chunk_size);
5342      if(not chunk):
5343       break
5344      fcontents += chunk;
5345   ftypehex = format(ftype, 'x').lower();
5346   extrafields = len(extradata);
5347   extrafieldslist = extradata;
5348   catfextrafields = extrafields;
5349   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
5350   if(len(extradata)>0):
5351    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
5352   extrasizelen = len(extrasizestr);
5353   extrasizelenhex = format(extrasizelen, 'x').lower();
5354   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()];
5355   catoutlen = len(catoutlist) + len(extradata) + 3;
5356   catoutlenhex = format(catoutlen, 'x').lower();
5357   catoutlist.insert(0, catoutlenhex);
5358   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
5359   if(len(extradata)>0):
5360    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
5361   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
5362   catfnumfields = catoutlen;
5363   if(checksumtype=="none" or checksumtype==""):
5364    catfileheadercshex = format(0, 'x').lower();
5365    catfilecontentcshex = format(0, 'x').lower();
5366   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5367    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
5368    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
5369   elif(checksumtype=="crc16_ccitt"):
5370    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
5371    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
5372   elif(checksumtype=="adler32"):
5373    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5374    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
5375   elif(checksumtype=="crc32"):
5376    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5377    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
5378   elif(checksumtype=="crc64_ecma"):
5379    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5380    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
5381   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5382    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5383    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
5384   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5385    checksumoutstr = hashlib.new(checksumtype);
5386    checksumoutstr.update("".encode('UTF-8'));
5387    catfileheadercshex = checksumoutstr.hexdigest().lower();
5388    checksumoutstr = hashlib.new(checksumtype);
5389    checksumoutstr.update(fcontents);
5390    catfilecontentcshex = checksumoutstr.hexdigest().lower();
5391   else:
5392    catfileheadercshex = format(0, 'x').lower();
5393    catfilecontentcshex = format(0, 'x').lower();
5394   catfhstart = fheadtell;
5395   fheadtell += len(catfileoutstr);
5396   catfhend = fheadtell - 1;
5397   catfcontentstart = fheadtell;
5398   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5399   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
5400   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
5401   catheaderdata = [catheaersize] + catoutlist + extradata + [checksumtype, catfileheadercshex, catfilecontentcshex]
5402   if(checksumtype=="none" or checksumtype==""):
5403    catfileheadercshex = format(0, 'x').lower();
5404   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5405    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5406   elif(checksumtype=="crc16_ccitt"):
5407    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5408   elif(checksumtype=="adler32"):
5409    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5410   elif(checksumtype=="crc32"):
5411    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5412   elif(checksumtype=="crc64_ecma"):
5413    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5414   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5415    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5416   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5417    checksumoutstr = hashlib.new(checksumtype);
5418    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
5419    catfileheadercshex = checksumoutstr.hexdigest().lower();
5420   else:
5421    catfileheadercshex = format(0, 'x').lower();
5422   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5423   catfileoutstrecd = catfileoutstr.encode('UTF-8');
5424   nullstrecd = formatspecs[5].encode('UTF-8');
5425   fheadtell += len(catfileoutstr) + 1;
5426   catfcontentend = fheadtell - 1;
5427   catfileout = catfileoutstrecd + fcontents + nullstrecd;
5428   pyhascontents = False;
5429   if(int(fsize)>0 and not listonly):
5430    pyhascontents = True;
5431   if(int(fsize)>0 and listonly):
5432    fcontents = "";
5433    pyhascontents = False;
5434   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} });
5435   fileidnum = fileidnum + 1;
5436  return catlist;
5437
5438 def ZipFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5439  curinode = 0;
5440  curfid = 0;
5441  inodelist = [];
5442  inodetofile = {};
5443  filetoinode = {};
5444  inodetocatinode = {};
5445  fileidnum = 0;
5446  if(infile=="-"):
5447   infile = BytesIO();
5448   if(hasattr(sys.stdin, "buffer")):
5449    shutil.copyfileobj(sys.stdin.buffer, infile);
5450   else:
5451    shutil.copyfileobj(sys.stdin, infile);
5452   infile.seek(0, 0);
5453   if(not infile):
5454    return False;
5455   infile.seek(0, 0);
5456  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
5457   infile = download_file_from_internet_file(infile);
5458   infile.seek(0, 0);
5459   if(not infile):
5460    return False;
5461   infile.seek(0, 0);
5462  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
5463   return False;
5464  else:
5465   return False;
5466  if(not zipfile.is_zipfile(infile)):
5467   return False;
5468  try:
5469   zipfp = zipfile.ZipFile(infile, "r", allowZip64=True);
5470  except FileNotFoundError:
5471   return False;
5472  ziptest = zipfp.testzip();
5473  if(ziptest):
5474   VerbosePrintOut("Bad file found!");
5475  fnumfiles = int(len(zipfp.infolist()));
5476  catver = formatspecs[6];
5477  fileheaderver = str(int(catver.replace(".", "")));
5478  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
5479  catversion = re.findall(r"([\d]+)$", fileheader);
5480  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
5481  fnumfileshex = format(int(fnumfiles), 'x').lower();
5482  fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
5483  if(checksumtype=="none" or checksumtype==""):
5484   catfileheadercshex = format(0, 'x').lower();
5485  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5486   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5487  elif(checksumtype=="crc16_ccitt"):
5488   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5489  elif(checksumtype=="adler32"):
5490   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5491  elif(checksumtype=="crc32"):
5492   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5493  elif(checksumtype=="crc64_ecma"):
5494   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5495  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5496   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5497  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5498   checksumoutstr = hashlib.new(checksumtype);
5499   checksumoutstr.update(fileheader.encode('UTF-8'));
5500   catfileheadercshex = checksumoutstr.hexdigest().lower();
5501  else:
5502   catfileheadercshex = format(0, 'x').lower();
5503  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
5504  fheadtell = len(fileheader);
5505  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
5506  for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
5507   if(re.findall("^[.|/]", member.filename)):
5508    fname = member.filename;
5509   else:
5510    fname = "./"+member.filename;
5511   zipinfo = zipfp.getinfo(member.filename);
5512   if(verbose):
5513    VerbosePrintOut(fname);
5514   if(not member.is_dir()):
5515    fpremode = stat.S_IFREG + 438;
5516   elif(member.is_dir()):
5517    fpremode = stat.S_IFDIR + 511;
5518   flinkcount = 0;
5519   ftype = 0;
5520   if(not member.is_dir()):
5521    ftype = 0;
5522   elif(member.is_dir()):
5523    ftype = 5;
5524   flinkname = "";
5525   fbasedir = os.path.dirname(fname);
5526   fcurfid = curfid;
5527   fcurinode = curfid;
5528   finode = fcurinode;
5529   curfid = curfid + 1;
5530   fdev_minor = 0;
5531   fdev_major = 0;
5532   frdev_minor = 0;
5533   frdev_major = 0;
5534   if(ftype==5):
5535    fsize = "0";
5536   elif(ftype==0):
5537    fsize = member.file_size;
5538   else:
5539    fsize = member.file_size;
5540   fatime = time.mktime(member.date_time + (0, 0, -1));
5541   fmtime = time.mktime(member.date_time + (0, 0, -1));
5542   fctime = time.mktime(member.date_time + (0, 0, -1));
5543   fbtime = time.mktime(member.date_time + (0, 0, -1));
5544   if(zipinfo.create_system==0 or zipinfo.create_system==10):
5545    fwinattributes = int(zipinfo.external_attr);
5546    if(not member.is_dir()):
5547     fmode = int(stat.S_IFREG + 438);
5548     fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)));
5549     ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)));
5550    elif(member.is_dir()):
5551     fmode = int(stat.S_IFDIR + 511);
5552     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
5553     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
5554   elif(zipinfo.create_system==3):
5555    fwinattributes = int(0);
5556    fmode = int(zipinfo.external_attr);
5557   else:
5558    fwinattributes = int(0);
5559    if(not member.is_dir()):
5560     fmode = int(stat.S_IFREG + 438);
5561     fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)));
5562     ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)));
5563    elif(member.is_dir()):
5564     fmode = int(stat.S_IFDIR + 511);
5565     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
5566     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
5567   try:
5568    fuid = os.getuid();
5569   except AttributeError:
5570    fuid = 0;
5571   except KeyError:
5572    fuid = 0;
5573   try:
5574    fgid = os.getgid();
5575   except AttributeError:
5576    fgid = 0;
5577   except KeyError:
5578    fgid = 0;
5579   try:
5580    import pwd;
5581    try:
5582     userinfo = pwd.getpwuid(os.getuid());
5583     funame = userinfo.pw_name;
5584    except KeyError:
5585     funame = "";
5586    except AttributeError:
5587     funame = "";
5588   except ImportError:
5589    funame = "";
5590   fgname = "";
5591   try:
5592    import grp;
5593    try:
5594     groupinfo = grp.getgrgid(os.getgid());
5595     fgname = groupinfo.gr_name;
5596    except KeyError:
5597     fgname = "";
5598    except AttributeError:
5599     fgname = "";
5600   except ImportError:
5601    fgname = "";
5602   fcontents = "".encode('UTF-8');
5603   if(ftype==0):
5604    fcontents = zipfp.read(member.filename);
5605   ftypehex = format(ftype, 'x').lower();
5606   extrafields = len(extradata);
5607   extrafieldslist = extradata;
5608   catfextrafields = extrafields;
5609   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
5610   if(len(extradata)>0):
5611    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
5612   extrasizelen = len(extrasizestr);
5613   extrasizelenhex = format(extrasizelen, 'x').lower();
5614   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()];
5615   catoutlen = len(catoutlist) + len(extradata) + 3;
5616   catoutlenhex = format(catoutlen, 'x').lower();
5617   catoutlist.insert(0, catoutlenhex);
5618   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
5619   if(len(extradata)>0):
5620    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
5621   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
5622   catfnumfields = catoutlen;
5623   if(checksumtype=="none" or checksumtype==""):
5624    catfileheadercshex = format(0, 'x').lower();
5625    catfilecontentcshex = format(0, 'x').lower();
5626   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5627    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
5628    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
5629   elif(checksumtype=="crc16_ccitt"):
5630    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
5631    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
5632   elif(checksumtype=="adler32"):
5633    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5634    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
5635   elif(checksumtype=="crc32"):
5636    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5637    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
5638   elif(checksumtype=="crc64_ecma"):
5639    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5640    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
5641   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5642    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5643    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
5644   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5645    checksumoutstr = hashlib.new(checksumtype);
5646    checksumoutstr.update("".encode('UTF-8'));
5647    catfileheadercshex = checksumoutstr.hexdigest().lower();
5648    checksumoutstr = hashlib.new(checksumtype);
5649    checksumoutstr.update(fcontents);
5650    catfilecontentcshex = checksumoutstr.hexdigest().lower();
5651   else:
5652    catfileheadercshex = format(0, 'x').lower();
5653    catfilecontentcshex = format(0, 'x').lower();
5654   catfhstart = fheadtell;
5655   fheadtell += len(catfileoutstr);
5656   catfhend = fheadtell - 1;
5657   catfcontentstart = fheadtell;
5658   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5659   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
5660   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
5661   catheaderdata = [catheaersize] + catoutlist + extradata + [checksumtype, catfileheadercshex, catfilecontentcshex];
5662   if(checksumtype=="none" or checksumtype==""):
5663    catfileheadercshex = format(0, 'x').lower();
5664   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5665    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5666   elif(checksumtype=="crc16_ccitt"):
5667    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5668   elif(checksumtype=="adler32"):
5669    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5670   elif(checksumtype=="crc32"):
5671    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5672   elif(checksumtype=="crc64_ecma"):
5673    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5674   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5675    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5676   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5677    checksumoutstr = hashlib.new(checksumtype);
5678    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
5679    catfileheadercshex = checksumoutstr.hexdigest().lower();
5680   else:
5681    catfileheadercshex = format(0, 'x').lower();
5682   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5683   catfileoutstrecd = catfileoutstr.encode('UTF-8');
5684   nullstrecd = formatspecs[5].encode('UTF-8');
5685   fheadtell += len(catfileoutstr) + 1;
5686   catfcontentend = fheadtell - 1;
5687   catfileout = catfileoutstrecd + fcontents + nullstrecd;
5688   pyhascontents = False;
5689   if(int(fsize)>0 and not listonly):
5690    pyhascontents = True;
5691   if(int(fsize)>0 and listonly):
5692    fcontents = "";
5693    pyhascontents = False;
5694   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} });
5695   fileidnum = fileidnum + 1;
5696  return catlist;
5697
5698 if(not rarfile_support):
5699  def RarFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5700   return False;
5701
5702 if(rarfile_support):
5703  def RarFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5704   curinode = 0;
5705   curfid = 0;
5706   inodelist = [];
5707   inodetofile = {};
5708   filetoinode = {};
5709   inodetocatinode = {};
5710   fileidnum = 0;
5711   if(not os.path.exists(infiles) or not os.path.isfile(infiles)):
5712    return False;
5713   if(not rarfile.is_rarfile(infile) and not rarfile.is_rarfile_sfx(infile)):
5714    return False;
5715   rarfp = rarfile.RarFile(infile, "r");
5716   rartest = rarfp.testrar();
5717   if(rartest):
5718    VerbosePrintOut("Bad file found!");
5719   fnumfiles = int(len(rarfp.infolist()));
5720   catver = formatspecs[6];
5721   fileheaderver = str(int(catver.replace(".", "")));
5722   fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
5723   catversion = re.findall(r"([\d]+)$", fileheader);
5724   catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
5725   fnumfileshex = format(int(fnumfiles), 'x').lower();
5726   fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
5727   if(checksumtype=="none" or checksumtype==""):
5728    catfileheadercshex = format(0, 'x').lower();
5729   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5730    catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5731   elif(checksumtype=="crc16_ccitt"):
5732    catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
5733   elif(checksumtype=="adler32"):
5734    catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5735   elif(checksumtype=="crc32"):
5736    catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
5737   elif(checksumtype=="crc64_ecma"):
5738    catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5739   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5740    catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5741   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5742    checksumoutstr = hashlib.new(checksumtype);
5743    checksumoutstr.update(fileheader.encode('UTF-8'));
5744    catfileheadercshex = checksumoutstr.hexdigest().lower();
5745   else:
5746    catfileheadercshex = format(0, 'x').lower();
5747   fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
5748   fheadtell = len(fileheader);
5749   catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
5750   for member in sorted(rarfp.infolist(), key=lambda x: x.filename):
5751    is_unix = False;
5752    is_windows = False;
5753    if(member.host_os==rarfile.RAR_OS_UNIX):
5754     is_windows = False;
5755     try:
5756      member.external_attr
5757      is_unix = True;
5758     except AttributeError:
5759      is_unix = False;
5760    elif(member.host_os==rarfile.RAR_OS_WIN32):
5761     is_unix = False;
5762     try:
5763      member.external_attr
5764      is_windows = True;
5765     except AttributeError:
5766      is_windows = False;
5767    else:
5768     is_unix = False;
5769     is_windows = False;
5770    if(re.findall("^[.|/]", member.filename)):
5771     fname = member.filename;
5772    else:
5773     fname = "./"+member.filename;
5774    rarinfo = rarfp.getinfo(member.filename);
5775    if(verbose):
5776     VerbosePrintOut(fname);
5777    if(is_unix and member.external_attr !=0):
5778     fpremode = int(member.external_attr);
5779    elif(member.is_file()):
5780     fpremode = stat.S_IFREG + 438;
5781    elif(member.is_symlink()):
5782     fpremode = stat.S_IFLNK + 438;
5783    elif(member.is_dir()):
5784     fpremode = stat.S_IFDIR + 511;
5785    if(is_windows and member.external_attr !=0):
5786     fwinattributes = int(member.external_attr);
5787    else:
5788     fwinattributes = int(0);
5789    flinkcount = 0;
5790    ftype = 0;
5791    if(member.is_file()):
5792     ftype = 0;
5793    elif(member.is_symlink()):
5794     ftype = 2;
5795    elif(member.is_dir()):
5796     ftype = 5;
5797    flinkname = "";
5798    if(ftype==2):
5799     flinkname = rarfp.read(member.filename).decode("UTF-8");
5800    fbasedir = os.path.dirname(fname);
5801    fcurfid = curfid;
5802    fcurinode = curfid;
5803    finode = fcurinode;
5804    curfid = curfid + 1;
5805    fdev_minor = 0;
5806    fdev_major = 0;
5807    frdev_minor = 0;
5808    frdev_major = 0;
5809    if(ftype==5):
5810     fsize = "0";
5811    if(ftype==0):
5812     fsize = member.file_size;
5813    try:
5814     if(member.atime):
5815      fatime = int(member.atime.timestamp());
5816     else:
5817      fatime = int(member.mtime.timestamp());
5818    except AttributeError:
5819     fatime = int(member.mtime.timestamp());
5820    fmtime = int(member.mtime.timestamp());
5821    try:
5822     if(member.ctime):
5823      fctime = int(member.ctime.timestamp());
5824     else:
5825      fctime = int(member.mtime.timestamp());
5826    except AttributeError:
5827     fctime = int(member.mtime.timestamp());
5828    fbtime = int(member.mtime.timestamp());
5829    if(is_unix and member.external_attr !=0):
5830     fmode = int(member.external_attr);
5831     fchmode = int(stat.S_IMODE(member.external_attr));
5832     ftypemod = int(stat.S_IFMT(member.external_attr));
5833    elif(member.is_file()):
5834     fmode = int(stat.S_IFREG + 438)
5835     fchmode = int(stat.S_IMODE(stat.S_IFREG + 438));
5836     ftypemod = int(stat.S_IFMT(stat.S_IFREG + 438));
5837    elif(member.is_symlink()):
5838     fmode = int(stat.S_IFLNK + 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_dir()):
5842     fmode = int(stat.S_IFDIR + 511)
5843     fchmode = int(stat.S_IMODE(stat.S_IFDIR + 511));
5844     ftypemod = int(stat.S_IFMT(stat.S_IFDIR + 511));
5845    try:
5846     fuid = os.getuid();
5847    except AttributeError:
5848     fuid = 0;
5849    except KeyError:
5850     fuid = 0;
5851    try:
5852     fgid = os.getgid();
5853    except AttributeError:
5854     fgid = 0;
5855    except KeyError:
5856     fgid = 0;
5857    try:
5858     import pwd;
5859     try:
5860      userinfo = pwd.getpwuid(os.getuid());
5861      funame = userinfo.pw_name;
5862     except KeyError:
5863      funame = "";
5864     except AttributeError:
5865      funame = "";
5866    except ImportError:
5867     funame = "";
5868    fgname = "";
5869    try:
5870     import grp;
5871     try:
5872      groupinfo = grp.getgrgid(os.getgid());
5873      fgname = groupinfo.gr_name;
5874     except KeyError:
5875      fgname = "";
5876     except AttributeError:
5877      fgname = "";
5878    except ImportError:
5879     fgname = "";
5880    fcontents = "".encode('UTF-8');
5881    if(ftype==0):
5882     fcontents = rarfp.read(member.filename);
5883    ftypehex = format(ftype, 'x').lower();
5884    extrafields = len(extradata);
5885    extrafieldslist = extradata;
5886    catfextrafields = extrafields;
5887    extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
5888    if(len(extradata)>0):
5889     extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
5890    extrasizelen = len(extrasizestr);
5891    extrasizelenhex = format(extrasizelen, 'x').lower();
5892    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()];
5893    catoutlen = len(catoutlist) + len(extradata) + 3;
5894    catoutlenhex = format(catoutlen, 'x').lower();
5895    catoutlist.insert(0, catoutlenhex);
5896    catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
5897    if(len(extradata)>0):
5898     catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
5899    catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
5900    catfnumfields = 24 + catfextrafields;
5901    if(checksumtype=="none" or checksumtype==""):
5902     catfileheadercshex = format(0, 'x').lower();
5903     catfilecontentcshex = format(0, 'x').lower();
5904    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5905     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5906     catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
5907    elif(checksumtype=="crc16_ccitt"):
5908     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5909     catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
5910    elif(checksumtype=="adler32"):
5911     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5912     catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
5913    elif(checksumtype=="crc32"):
5914     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5915     catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
5916    elif(checksumtype=="crc64_ecma"):
5917     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5918     catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
5919    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5920     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5921     catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
5922    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5923     checksumoutstr = hashlib.new(checksumtype);
5924     checksumoutstr.update(catfileoutstr.encode('UTF-8'));
5925     catfileheadercshex = checksumoutstr.hexdigest().lower();
5926    else:
5927     catfileheadercshex = format(0, 'x').lower();
5928     catfilecontentcshex = format(0, 'x').lower();
5929    catfhstart = fheadtell;
5930    fheadtell += len(catfileoutstr);
5931    catfhend = fheadtell - 1;
5932    catfcontentstart = fheadtell;
5933    tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5934    catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
5935    catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
5936    catheaderdata = [catheaersize] + catoutlist + extradata + [checksumtype, catfileheadercshex, catfilecontentcshex];
5937    if(checksumtype=="none" or checksumtype==""):
5938     catfileheadercshex = format(0, 'x').lower();
5939    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
5940     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5941    elif(checksumtype=="crc16_ccitt"):
5942     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
5943    elif(checksumtype=="adler32"):
5944     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5945    elif(checksumtype=="crc32"):
5946     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
5947    elif(checksumtype=="crc64_ecma"):
5948     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5949    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
5950     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5951    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
5952     checksumoutstr = hashlib.new(checksumtype);
5953     checksumoutstr.update(catfileoutstr.encode('UTF-8'));
5954     catfileheadercshex = checksumoutstr.hexdigest().lower();
5955    else:
5956     catfileheadercshex = format(0, 'x').lower();
5957    catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
5958    catfileoutstrecd = catfileoutstr.encode('UTF-8');
5959    nullstrecd = formatspecs[5].encode('UTF-8');
5960    fheadtell += len(catfileoutstr) + 1;
5961    catfcontentend = fheadtell - 1;
5962    catfileout = catfileoutstrecd + fcontents + nullstrecd;
5963    pyhascontents = False;
5964    if(int(fsize)>0 and not listonly):
5965     pyhascontents = True;
5966    if(int(fsize)>0 and listonly):
5967     fcontents = "";
5968     pyhascontents = False;
5969    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} });
5970    fileidnum = fileidnum + 1;
5971   return catlist;
5972
5973 if(not py7zr_support):
5974  def SevenZipFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5975   return False;
5976
5977 if(py7zr_support):
5978  def SevenZipFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
5979   curinode = 0;
5980   curfid = 0;
5981   inodelist = [];
5982   inodetofile = {};
5983   filetoinode = {};
5984   inodetocatinode = {};
5985   fileidnum = 0;
5986   szpfp = py7zr.SevenZipFile(infile, mode="r");
5987   file_content = szpfp.readall();
5988   #sztest = szpfp.testzip();
5989   sztestalt = szpfp.test();
5990   if(sztestalt):
5991    VerbosePrintOut("Bad file found!");
5992   numfiles = int(len(szpfp.list()));
5993   catver = formatspecs[6];
5994   fileheaderver = str(int(catver.replace(".", "")));
5995   fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
5996   catversion = re.findall(r"([\d]+)$", fileheader);
5997   catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
5998   fnumfileshex = format(int(fnumfiles), 'x').lower();
5999   fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
6000   if(checksumtype=="none" or checksumtype==""):
6001    catfileheadercshex = format(0, 'x').lower();
6002   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
6003    catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
6004   elif(checksumtype=="crc16_ccitt"):
6005    catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
6006   elif(checksumtype=="adler32"):
6007    catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
6008   elif(checksumtype=="crc32"):
6009    catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
6010   elif(checksumtype=="crc64_ecma"):
6011    catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6012   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
6013    catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6014   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
6015    checksumoutstr = hashlib.new(checksumtype);
6016    checksumoutstr.update(fileheader.encode('UTF-8'));
6017    catfileheadercshex = checksumoutstr.hexdigest().lower();
6018   else:
6019    catfileheadercshex = format(0, 'x').lower();
6020   fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
6021   fheadtell = len(fileheader);
6022   catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
6023   for member in sorted(szpfp.list(), key=lambda x: x.filename):
6024    if(re.findall("^[.|/]", member.filename)):
6025     fname = member.filename;
6026    else:
6027     fname = "./"+member.filename;
6028    if(not member.is_directory):
6029     fpremode = int(stat.S_IFREG + 438);
6030    elif(member.is_directory):
6031     fpremode = int(stat.S_IFDIR + 511);
6032    fwinattributes = int(0);
6033    flinkcount = 0;
6034    ftype = 0;
6035    if(member.is_directory):
6036     ftype = 5;
6037    else:
6038     ftype = 0;
6039    flinkname = "";
6040    fbasedir = os.path.dirname(fname);
6041    fcurfid = curfid;
6042    fcurinode = curfid;
6043    finode = fcurinode;
6044    curfid = curfid + 1;
6045    fdev_minor = 0;
6046    fdev_major = 0;
6047    frdev_minor = 0;
6048    frdev_major = 0;
6049    if(ftype==5):
6050     fsize = "0";
6051    fatime = int(member.creationtime.timestamp());
6052    fmtime = int(member.creationtime.timestamp());
6053    fctime = int(member.creationtime.timestamp());
6054    fbtime = int(member.creationtime.timestamp());
6055    if(member.is_directory):
6056     fmode = int(stat.S_IFDIR + 511)
6057     fchmode = int(stat.S_IMODE(stat.S_IFDIR + 511));
6058     ftypemod = int(stat.S_IFMT(stat.S_IFDIR + 511));
6059    else:
6060     fmode = int(stat.S_IFLNK + 438)
6061     fchmode = int(stat.S_IMODE(stat.S_IFREG + 438));
6062     ftypemod = int(stat.S_IFMT(stat.S_IFREG + 438));
6063    try:
6064     fuid = os.getuid();
6065    except AttributeError:
6066     fuid = 0;
6067    except KeyError:
6068     fuid = 0;
6069    try:
6070     fgid = os.getgid();
6071    except AttributeError:
6072     fgid = 0;
6073    except KeyError:
6074     fgid = 0;
6075    try:
6076     import pwd;
6077     try:
6078      userinfo = pwd.getpwuid(os.getuid());
6079      funame = userinfo.pw_name;
6080     except KeyError:
6081      funame = "";
6082     except AttributeError:
6083      funame = "";
6084    except ImportError:
6085     funame = "";
6086    fgname = "";
6087    try:
6088     import grp;
6089     try:
6090      groupinfo = grp.getgrgid(os.getgid());
6091      fgname = groupinfo.gr_name;
6092     except KeyError:
6093      fgname = "";
6094     except AttributeError:
6095      fgname = "";
6096    except ImportError:
6097     fgname = "";
6098    fcontents = "".encode('UTF-8');
6099    if(ftype==0):
6100     fcontents = file_content[member.filename].read();
6101     fsize = format(len(fcontents), 'x').lower();
6102     fileop.close();
6103    ftypehex = format(ftype, 'x').lower();
6104    extrafields = len(extradata);
6105    extrafieldslist = extradata;
6106    catfextrafields = extrafields;
6107    extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
6108    if(len(extradata)>0):
6109     extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
6110    extrasizelen = len(extrasizestr);
6111    extrasizelenhex = format(extrasizelen, 'x').lower();
6112    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()];
6113    catoutlen = len(catoutlist) + len(extradata) + 3;
6114    catoutlenhex = format(catoutlen, 'x').lower();
6115    catoutlist.insert(0, catoutlenhex);
6116    catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
6117    if(len(extradata)>0):
6118     catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
6119    catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
6120    catfnumfields = 24 + catfextrafields;
6121    if(checksumtype=="none" or checksumtype==""):
6122     catfileheadercshex = format(0, 'x').lower();
6123     catfilecontentcshex = format(0, 'x').lower();
6124    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
6125     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6126     catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
6127    elif(checksumtype=="crc16_ccitt"):
6128     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6129     catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
6130    elif(checksumtype=="adler32"):
6131     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6132     catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
6133    elif(checksumtype=="crc32"):
6134     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6135     catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
6136    elif(checksumtype=="crc64_ecma"):
6137     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6138     catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
6139    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
6140     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6141     catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
6142    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
6143     checksumoutstr = hashlib.new(checksumtype);
6144     checksumoutstr.update(catfileoutstr.encode('UTF-8'));
6145     catfileheadercshex = checksumoutstr.hexdigest().lower();
6146    else:
6147     catfileheadercshex = format(0, 'x').lower();
6148     catfilecontentcshex = format(0, 'x').lower();
6149    catfhstart = fheadtell;
6150    fheadtell += len(catfileoutstr);
6151    catfhend = fheadtell - 1;
6152    catfcontentstart = fheadtell;
6153    tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
6154    catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
6155    catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
6156    catheaderdata = [catheaersize] + catoutlist + extradata + [checksumtype, catfileheadercshex, catfilecontentcshex];
6157    if(checksumtype=="none" or checksumtype==""):
6158     catfileheadercshex = format(0, 'x').lower();
6159    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
6160     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6161    elif(checksumtype=="crc16_ccitt"):
6162     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6163    elif(checksumtype=="adler32"):
6164     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6165    elif(checksumtype=="crc32"):
6166     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6167    elif(checksumtype=="crc64_ecma"):
6168     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6169    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
6170     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6171    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
6172     checksumoutstr = hashlib.new(checksumtype);
6173     checksumoutstr.update(catfileoutstr.encode('UTF-8'));
6174     catfileheadercshex = checksumoutstr.hexdigest().lower();
6175    else:
6176     catfileheadercshex = format(0, 'x').lower();
6177    catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
6178    catfileoutstrecd = catfileoutstr.encode('UTF-8');
6179    nullstrecd = formatspecs[5].encode('UTF-8');
6180    fheadtell += len(catfileoutstr) + 1;
6181    catfcontentend = fheadtell - 1;
6182    catfileout = catfileoutstrecd + fcontents + nullstrecd;
6183    pyhascontents = False;
6184    if(int(fsize)>0 and not listonly):
6185     pyhascontents = True;
6186    if(int(fsize)>0 and listonly):
6187     fcontents = "";
6188     pyhascontents = False;
6189    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} });
6190    fileidnum = fileidnum + 1;
6191   return catlist;
6192
6193 def InFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6194  checkcompressfile = CheckCompressionSubType(infiles, formatspecs, True);
6195  if(checkcompressfile=="tarfile"):
6196   return TarFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6197  elif(checkcompressfile=="zipfile"):
6198   return ZipFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6199  elif(checkcompressfile=="catfile"):
6200   return ArchiveFileToArray(infile, 0, 0, listonly, False, formatspecs, False);
6201  elif(rarfile_support and checkcompressfile=="rarfile"):
6202   return RarFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6203  elif(py7zr_support and checkcompressfile=="7zipfile"):
6204   return SevenZipFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6205  else:
6206   return False;
6207  return False;
6208
6209 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):
6210  outarray = BytesIO();
6211  packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, True);
6212  listcatfiles = ArchiveFileToArray(outarray, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6213  return listcatfiles;
6214
6215 def ArchiveFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6216  if(isinstance(infile, dict)):
6217   listcatfiles = infile;
6218  else:
6219   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
6220    infile = RemoveWindowsPath(infile);
6221   listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6222  if(not listcatfiles):
6223   return False;
6224  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': {}}}};
6225  if(returnfp):
6226   catarray.update({'catfp': listcatfiles['catfp']});
6227  lenlist = len(listcatfiles['ffilelist']);
6228  lcfi = 0;
6229  lcfx = int(listcatfiles['fnumfiles']);
6230  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6231   lcfx = int(lenlist);
6232  else:
6233   lcfx = int(listcatfiles['fnumfiles']);
6234  while(lcfi < lcfx):
6235   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6236   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6237   catarray['filetoid'].update(filetoidarray);
6238   catarray['idtofile'].update(idtofilearray);
6239   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6240    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6241    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6242   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6243    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6244    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6245    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6246    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6247   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6248    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6249    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6250    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6251    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6252   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6253    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6254    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6255    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6256    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6257   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6258    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6259    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6260    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6261    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6262   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6263    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6264    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6265   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6266    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6267    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6268    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6269    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6270   lcfi = lcfi + 1;
6271  return catarray;
6272
6273 create_alias_function("", __file_format_name__, "ToArrayIndex", ArchiveFileToArrayIndex);
6274
6275 def ListDirToArrayIndexAlt(infiles, dirlistfromtxt=False, followlink=False, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6276  listcatfiles = ListDirToArrayAlt(infiles, dirlistfromtxt, followlink, listonly, checksumtype, extradata, formatspecs, verbose);
6277  if(not listcatfiles):
6278   return False;
6279  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': {}}}};
6280  lenlist = len(listcatfiles['ffilelist']);
6281  lcfi = 0;
6282  lcfx = int(listcatfiles['fnumfiles']);
6283  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6284   lcfx = int(lenlist);
6285  else:
6286   lcfx = int(listcatfiles['fnumfiles']);
6287  while(lcfi < lcfx):
6288   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6289   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6290   catarray['filetoid'].update(filetoidarray);
6291   catarray['idtofile'].update(idtofilearray);
6292   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6293    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6294    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6295   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6296    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6297    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6298    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6299    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6300   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6301    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6302    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6303    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6304    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6305   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6306    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6307    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6308    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6309    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6310   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6311    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6312    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6313    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6314    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6315   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6316    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6317    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6318   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6319    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6320    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6321    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6322    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6323   lcfi = lcfi + 1;
6324  return catarray;
6325
6326 def TarFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6327  listcatfiles = TarFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6328  if(not listcatfiles):
6329   return False;
6330  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': {}}}};
6331  lenlist = len(listcatfiles['ffilelist']);
6332  lcfi = 0;
6333  lcfx = int(listcatfiles['fnumfiles']);
6334  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6335   lcfx = int(lenlist);
6336  else:
6337   lcfx = int(listcatfiles['fnumfiles']);
6338  while(lcfi < lcfx):
6339   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6340   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6341   catarray['filetoid'].update(filetoidarray);
6342   catarray['idtofile'].update(idtofilearray);
6343   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6344    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6345    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6346   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6347    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6348    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6349    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6350    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6351   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6352    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6353    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6354    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6355    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6356   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6357    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6358    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6359    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6360    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6361   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6362    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6363    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6364    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6365    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6366   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6367    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6368    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6369   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6370    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6371    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6372    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6373    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6374   lcfi = lcfi + 1;
6375  return catarray;
6376
6377 def ZipFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6378  listcatfiles = ZipFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6379  if(not listcatfiles):
6380   return False;
6381  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': {}}}};
6382  lenlist = len(listcatfiles['ffilelist']);
6383  lcfi = 0;
6384  lcfx = int(listcatfiles['fnumfiles']);
6385  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6386   lcfx = int(lenlist);
6387  else:
6388   lcfx = int(listcatfiles['fnumfiles']);
6389  while(lcfi < lcfx):
6390   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6391   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6392   catarray['filetoid'].update(filetoidarray);
6393   catarray['idtofile'].update(idtofilearray);
6394   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6395    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6396    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6397   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6398    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6399    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6400    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6401    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6402   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6403    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6404    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6405    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6406    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6407   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6408    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6409    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6410    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6411    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6412   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6413    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6414    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6415    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6416    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6417   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6418    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6419    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6420   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6421    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6422    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6423    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6424    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6425   lcfi = lcfi + 1;
6426  return catarray;
6427
6428 if(not rarfile_support):
6429  def RarFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6430   return False;
6431
6432 if(rarfile_support):
6433  def RarFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6434   listcatfiles = RarFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6435   if(not listcatfiles):
6436    return False;
6437   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': {}}}};
6438   lenlist = len(listcatfiles['ffilelist']);
6439   lcfi = 0;
6440   lcfx = int(listcatfiles['fnumfiles']);
6441   if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6442    lcfx = int(lenlist);
6443   else:
6444    lcfx = int(listcatfiles['fnumfiles']);
6445   while(lcfi < lcfx):
6446    filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6447    idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6448    catarray['filetoid'].update(filetoidarray);
6449    catarray['idtofile'].update(idtofilearray);
6450    if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6451     catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6452     catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6453    if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6454     catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6455     catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6456     catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6457     catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6458    if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6459     catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6460     catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6461     catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6462     catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6463    if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6464     catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6465     catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6466     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6467     catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6468    if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6469     catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6470     catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6471     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6472    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6473    if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6474     catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6475     catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6476    if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6477     catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6478     catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6479     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6480     catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6481    lcfi = lcfi + 1;
6482   return catarray;
6483
6484 if(not py7zr_support):
6485  def SevenZipFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6486   return False;
6487
6488 if(py7zr_support):
6489  def SevenZipFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
6490   listcatfiles = SevenZipFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
6491   if(not listcatfiles):
6492    return False;
6493   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': {}}}};
6494   lenlist = len(listcatfiles['ffilelist']);
6495   lcfi = 0;
6496   lcfx = int(listcatfiles['fnumfiles']);
6497   if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6498    lcfx = int(lenlist);
6499   else:
6500    lcfx = int(listcatfiles['fnumfiles']);
6501   while(lcfi < lcfx):
6502    filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
6503    idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
6504    catarray['filetoid'].update(filetoidarray);
6505    catarray['idtofile'].update(idtofilearray);
6506    if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
6507     catarray['filetypes']['files']['filetoid'].update(filetoidarray);
6508     catarray['filetypes']['files']['idtofile'].update(idtofilearray);
6509    if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
6510     catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
6511     catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
6512     catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6513     catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6514    if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
6515     catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6516     catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6517     catarray['filetypes']['links']['filetoid'].update(filetoidarray);
6518     catarray['filetypes']['links']['idtofile'].update(idtofilearray);
6519    if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
6520     catarray['filetypes']['character']['filetoid'].update(filetoidarray);
6521     catarray['filetypes']['character']['idtofile'].update(idtofilearray);
6522     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6523     catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6524    if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
6525     catarray['filetypes']['block']['filetoid'].update(filetoidarray);
6526     catarray['filetypes']['block']['idtofile'].update(idtofilearray);
6527     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6528    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6529    if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
6530     catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
6531     catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
6532    if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
6533     catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
6534     catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
6535     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
6536     catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
6537    lcfi = lcfi + 1;
6538   return catarray;
6539
6540 def ArchiveFileStringToArrayIndex(catstr, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6541  catfp = BytesIO(catstr);
6542  listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6543  return listcatfiles;
6544
6545 create_alias_function("", __file_format_name__, "StringToArrayIndex", ArchiveFileStringToArrayIndex);
6546
6547 def TarFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6548  catfp = BytesIO();
6549  catfp = PackArchiveFileFromTarFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
6550  listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6551  return listcatfiles;
6552
6553 def ZipFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6554  catfp = BytesIO();
6555  catfp = PackArchiveFileFromZipFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
6556  listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6557  return listcatfiles;
6558
6559 if(not rarfile_support):
6560  def RarFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6561   return False;
6562
6563 if(rarfile_support):
6564  def RarFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6565   catfp = BytesIO();
6566   catfp = PackArchiveFileFromRarFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
6567   listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6568   return listcatfiles;
6569
6570 if(not py7zr_support):
6571  def SevenZipFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6572   return False;
6573
6574 if(py7zr_support):
6575  def SevenZipFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
6576   catfp = BytesIO();
6577   catfp = PackArchiveFileFromSevenZipFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
6578   listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
6579   return listcatfiles;
6580
6581 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):
6582  outarray = BytesIO();
6583  packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, formatspecs, verbose, True);
6584  listcatfiles = ArchiveFileToArrayIndex(outarray, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp)
6585  return listcatfiles;
6586
6587 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):
6588  if(isinstance(infile, dict)):
6589   prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6590   listcatfiles = prelistcatfiles['list'];
6591  else:
6592   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
6593    infile = RemoveWindowsPath(infile);
6594   if(followlink):
6595    prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6596    listcatfiles = prelistcatfiles['list'];
6597   else:
6598    listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6599  if(outfile!="-" and not hasattr(infile, "read") and not hasattr(outfile, "write")):
6600   outfile = RemoveWindowsPath(outfile);
6601  checksumtype = checksumtype.lower();
6602  if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
6603   checksumtype="crc32";
6604  if(checksumtype=="none"):
6605   checksumtype = "";
6606  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
6607   compression = None;
6608  if(compression not in compressionlist and compression is None):
6609   compression = "auto";
6610  if(verbose):
6611   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
6612  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
6613   if(os.path.exists(outfile)):
6614    os.unlink(outfile);
6615  if(not listcatfiles):
6616   return False;
6617  if(outfile=="-"):
6618   verbose = False;
6619   catfp = BytesIO();
6620  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
6621   catfp = outfile;
6622  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
6623   catfp = BytesIO();
6624  else:
6625   fbasename = os.path.splitext(outfile)[0];
6626   fextname = os.path.splitext(outfile)[1];
6627   catfp = CompressOpenFile(outfile, compressionlevel);
6628  catver = formatspecs[6];
6629  fileheaderver = str(int(catver.replace(".", "")));
6630  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
6631  catfp.write(fileheader.encode('UTF-8'));
6632  lenlist = len(listcatfiles['ffilelist']);
6633  fnumfiles = int(listcatfiles['fnumfiles']);
6634  if(lenlist>fnumfiles or lenlist<fnumfiles):
6635   fnumfiles = lenlist;
6636  fnumfileshex = format(int(fnumfiles), 'x').lower();
6637  fnumfilesa = AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
6638  if(checksumtype=="none" or checksumtype==""):
6639   catfileheadercshex = format(0, 'x').lower();
6640  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
6641   catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
6642  elif(checksumtype=="crc16_ccitt"):
6643   catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
6644  elif(checksumtype=="adler32"):
6645   catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
6646  elif(checksumtype=="crc32"):
6647   catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
6648  elif(checksumtype=="crc64_ecma"):
6649   catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6650  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
6651   catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6652  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
6653   checksumoutstr = hashlib.new(checksumtype);
6654   checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
6655   catfileheadercshex = checksumoutstr.hexdigest().lower();
6656  else:
6657   catfileheadercshex = format(0, 'x').lower();
6658  fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
6659  catfp.write(fnumfilesa.encode('UTF-8'));
6660  try:
6661   catfp.flush();
6662   os.fsync(catfp.fileno());
6663  except io.UnsupportedOperation:
6664   pass;
6665  except AttributeError:
6666   pass;
6667  lenlist = len(listcatfiles['ffilelist']);
6668  fnumfiles = int(listcatfiles['fnumfiles']);
6669  lcfi = 0;
6670  lcfx = int(listcatfiles['fnumfiles']);
6671  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6672   lcfx = int(lenlist);
6673  else:
6674   lcfx = int(listcatfiles['fnumfiles']);
6675  curinode = 0;
6676  curfid = 0;
6677  inodelist = [];
6678  inodetofile = {};
6679  filetoinode = {};
6680  reallcfi = 0;
6681  while(lcfi < lcfx):
6682   catfhstart = catfp.tell();
6683   if(re.findall("^[.|/]", listcatfiles['ffilelist'][reallcfi]['fname'])):
6684    fname = listcatfiles['ffilelist'][reallcfi]['fname'];
6685   else:
6686    fname = "./"+listcatfiles['ffilelist'][reallcfi]['fname'];
6687   if(verbose):
6688    VerbosePrintOut(fname);
6689   fheadersize = format(int(listcatfiles['ffilelist'][reallcfi]['fheadersize']), 'x').lower();
6690   fsize = format(int(listcatfiles['ffilelist'][reallcfi]['fsize']), 'x').lower();
6691   flinkname = listcatfiles['ffilelist'][reallcfi]['flinkname'];
6692   fatime = format(int(listcatfiles['ffilelist'][reallcfi]['fatime']), 'x').lower();
6693   fmtime = format(int(listcatfiles['ffilelist'][reallcfi]['fmtime']), 'x').lower();
6694   fctime = format(int(listcatfiles['ffilelist'][reallcfi]['fctime']), 'x').lower();
6695   fbtime = format(int(listcatfiles['ffilelist'][reallcfi]['fbtime']), 'x').lower();
6696   fmode = format(int(listcatfiles['ffilelist'][reallcfi]['fmode']), 'x').lower();
6697   fchmode = format(int(listcatfiles['ffilelist'][reallcfi]['fchmode']), 'x').lower();
6698   fuid = format(int(listcatfiles['ffilelist'][reallcfi]['fuid']), 'x').lower();
6699   funame = listcatfiles['ffilelist'][reallcfi]['funame'];
6700   fgid = format(int(listcatfiles['ffilelist'][reallcfi]['fgid']), 'x').lower();
6701   fgname = listcatfiles['ffilelist'][reallcfi]['fgname'];
6702   finode = listcatfiles['ffilelist'][reallcfi]['finode'];
6703   flinkcount = listcatfiles['ffilelist'][reallcfi]['flinkcount'];
6704   fwinattributes = flinkinfo['ffilelist'][reallcfi]['fwinattributes'];
6705   fdev_minor = format(int(listcatfiles['ffilelist'][reallcfi]['fminor']), 'x').lower();
6706   fdev_major = format(int(listcatfiles['ffilelist'][reallcfi]['fmajor']), 'x').lower();
6707   frdev_minor = format(int(listcatfiles['ffilelist'][reallcfi]['frminor']), 'x').lower();
6708   frdev_major = format(int(listcatfiles['ffilelist'][reallcfi]['frmajor']), 'x').lower();
6709   if(len(listcatfiles['ffilelist'][reallcfi]['fextralist'])>listcatfiles['ffilelist'][reallcfi]['fextrafields'] and len(listcatfiles['ffilelist'][reallcfi]['fextralist'])>0):
6710    listcatfiles['ffilelist'][reallcfi]['fextrafields'] = len(listcatfiles['ffilelist'][reallcfi]['fextralist']);
6711   if(len(extradata)>0):
6712    listcatfiles['ffilelist'][reallcfi]['fextrafields'] = len(extradata);
6713    listcatfiles['ffilelist'][reallcfi]['fextralist'] = extradata;
6714   extrafields = format(int(listcatfiles['ffilelist'][reallcfi]['fextrafields']), 'x').lower();
6715   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
6716   if(len(extradata)>0):
6717    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
6718   extrasizelen = format(len(extrasizestr), 'x').lower();
6719   fcontents = listcatfiles['ffilelist'][reallcfi]['fcontents'];
6720   if(followlink):
6721    if(listcatfiles['ffilelist'][reallcfi]['ftype']==1 or listcatfiles['ffilelist'][reallcfi]['ftype']==2):
6722     getflinkpath = listcatfiles['ffilelist'][reallcfi]['flinkname'];
6723     flinkid = prelistcatfiles['filetoid'][getflinkpath];
6724     flinkinfo = listcatfiles['ffilelist'][flinkid];
6725     fheadersize = format(int(flinkinfo['fheadersize']), 'x').lower();
6726     fsize = format(int(flinkinfo['fsize']), 'x').lower();
6727     flinkname = flinkinfo['flinkname'];
6728     fatime = format(int(flinkinfo['fatime']), 'x').lower();
6729     fmtime = format(int(flinkinfo['fmtime']), 'x').lower();
6730     fctime = format(int(flinkinfo['fctime']), 'x').lower();
6731     fbtime = format(int(flinkinfo['fbtime']), 'x').lower();
6732     fmode = format(int(flinkinfo['fmode']), 'x').lower();
6733     fchmode = format(int(flinkinfo['fchmode']), 'x').lower();
6734     fuid = format(int(flinkinfo['fuid']), 'x').lower();
6735     funame = flinkinfo['funame'];
6736     fgid = format(int(flinkinfo['fgid']), 'x').lower();
6737     fgname = flinkinfo['fgname'];
6738     finode = flinkinfo['finode'];
6739     flinkcount = flinkinfo['flinkcount'];
6740     fwinattributes = flinkinfo['fwinattributes'];
6741     fdev_minor = format(int(flinkinfo['fminor']), 'x').lower();
6742     fdev_major = format(int(flinkinfo['fmajor']), 'x').lower();
6743     frdev_minor = format(int(flinkinfo['frminor']), 'x').lower();
6744     frdev_major = format(int(flinkinfo['frmajor']), 'x').lower();
6745     if(len(flinkinfo['fextralist'])>flinkinfo['fextrafields'] and len(flinkinfo['fextralist'])>0):
6746      flinkinfo['fextrafields'] = len(flinkinfo['fextralist']);
6747     if(len(extradata)>0):
6748      flinkinfo['fextrafields'] = len(extradata);
6749      flinkinfo['fextralist'] = extradata;
6750     extrafields = format(int(flinkinfo['fextrafields']), 'x').lower();
6751     extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
6752     if(len(extradata)>0):
6753      extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
6754     extrasizelen = format(len(extrasizestr), 'x').lower();
6755     fcontents = flinkinfo['fcontents'];
6756     if(flinkinfo['ftype']!=0 and flinkinfo['ftype']!=7):
6757      try:
6758       fcontents = fcontents.encode('UTF-8');
6759      except AttributeError:
6760       pass;
6761     ftypehex = format(flinkinfo['ftype'], 'x').lower();
6762   else:
6763    if(listcatfiles['ffilelist'][reallcfi]['ftype']!=0 and listcatfiles['ffilelist'][reallcfi]['ftype']!=7):
6764     try:
6765      fcontents = fcontents.encode('UTF-8');
6766     except AttributeError:
6767      pass;
6768    ftypehex = format(listcatfiles['ffilelist'][reallcfi]['ftype'], 'x').lower();
6769   fcurfid = format(curfid, 'x').lower();
6770   if(not followlink and finode!=0):
6771    if(listcatfiles['ffilelist'][reallcfi]['ftype']!=1):
6772     fcurinode = format(int(curinode), 'x').lower();
6773     inodetofile.update({curinode: fname});
6774     filetoinode.update({fname: curinode});
6775     curinode = curinode + 1;
6776    else:
6777     fcurinode = format(int(filetoinode[flinkname]), 'x').lower();
6778   else:
6779     fcurinode = format(int(curinode), 'x').lower();
6780     curinode = curinode + 1;
6781   curfid = curfid + 1;
6782   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];
6783   catoutlen = len(catoutlist) + len(extradata) + 3;
6784   catoutlenhex = format(catoutlen, 'x').lower();
6785   catoutlist.insert(0, catoutlenhex);
6786   catfileoutstr = AppendNullBytes(catoutlist, formatspecs[5]);
6787   if(listcatfiles['ffilelist'][reallcfi]['fextrafields']>0):
6788    extrafieldslist = [];
6789    exi = 0;
6790    exil = listcatfiles['ffilelist'][reallcfi]['fextrafields'];
6791    while(exi<exil):
6792     extrafieldslist.append(listcatfiles['ffilelist'][reallcfi]['fextralist']);
6793     exi = exi + 1;
6794    catfileoutstr += AppendNullBytes([extrafieldslist], formatspecs[5]);
6795   catfileoutstr += AppendNullBytes([checksumtype], formatspecs[5]);
6796   catfhend = (catfp.tell() - 1) + len(catfileoutstr);
6797   catfcontentstart = catfp.tell() + len(catfileoutstr);
6798   if(checksumtype=="none" or checksumtype==""):
6799    catfileheadercshex = format(0, 'x').lower();
6800    catfilecontentcshex = format(0, 'x').lower();
6801   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
6802    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
6803    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
6804   elif(checksumtype=="crc16_ccitt"):
6805    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
6806    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
6807   elif(checksumtype=="adler32"):
6808    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
6809    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
6810   elif(checksumtype=="crc32"):
6811    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
6812    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
6813   elif(checksumtype=="crc64_ecma"):
6814    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6815    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
6816   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
6817    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6818    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
6819   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
6820    checksumoutstr = hashlib.new(checksumtype);
6821    checksumoutstr.update("".encode('UTF-8'));
6822    catfileheadercshex = checksumoutstr.hexdigest().lower();
6823    checksumoutstr = hashlib.new(checksumtype);
6824    checksumoutstr.update(fcontents);
6825    catfilecontentcshex = checksumoutstr.hexdigest().lower();
6826   else:
6827    catfileheadercshex = format(0, 'x').lower();
6828    catfilecontentcshex = format(0, 'x').lower();
6829   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
6830   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
6831   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
6832   if(checksumtype=="none" or checksumtype==""):
6833    catfileheadercshex = format(0, 'x').lower();
6834   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
6835    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6836   elif(checksumtype=="crc16_ccitt"):
6837    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
6838   elif(checksumtype=="adler32"):
6839    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6840   elif(checksumtype=="crc32"):
6841    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
6842   elif(checksumtype=="crc64_ecma"):
6843    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6844   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
6845    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6846   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
6847    checksumoutstr = hashlib.new(checksumtype);
6848    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
6849    catfileheadercshex = checksumoutstr.hexdigest().lower();
6850   else:
6851    catfileheadercshex = format(0, 'x').lower();
6852   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
6853   catfileoutstrecd = catfileoutstr.encode('UTF-8');
6854   nullstrecd = formatspecs[5].encode('UTF-8');
6855   catfileout = catfileoutstrecd + fcontents + nullstrecd;
6856   catfcontentend = (catfp.tell() - 1) + len(catfileout);
6857   catfp.write(catfileout);
6858   try:
6859    catfp.flush();
6860    os.fsync(catfp.fileno());
6861   except io.UnsupportedOperation:
6862    pass;
6863   except AttributeError:
6864    pass;
6865   lcfi = lcfi + 1;
6866   reallcfi = reallcfi + 1;
6867  if(lcfx>0):
6868   catfp.write(AppendNullBytes([0, 0], formatspecs[5]).encode("UTF-8"));
6869  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
6870   catfp = CompressArchiveFile(catfp, compression, formatspecs);
6871   try:
6872    catfp.flush();
6873    os.fsync(catfp.fileno());
6874   except io.UnsupportedOperation:
6875    pass;
6876   except AttributeError:
6877    pass;
6878  if(outfile=="-"):
6879   catfp.seek(0, 0);
6880   if(hasattr(sys.stdout, "buffer")):
6881    shutil.copyfileobj(catfp, sys.stdout.buffer);
6882   else:
6883    shutil.copyfileobj(catfp, sys.stdout);
6884  elif(re.findall(r"^(ftp|ftps|sftp)\:\/\/", str(outfile))):
6885   catfp = CompressArchiveFile(catfp, compression, formatspecs);
6886   catfp.seek(0, 0);
6887   upload_file_to_internet_file(catfp, outfile);
6888  if(returnfp):
6889   catfp.seek(0, 0);
6890   return catfp;
6891  else:
6892   catfp.close();
6893   return True;
6894
6895 create_alias_function("RePack", __file_format_name__, "", RePackArchiveFile);
6896
6897 def RePackArchiveFileFromString(catstr, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", skipchecksum=False, extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
6898  catfp = BytesIO(catstr);
6899  listcatfiles = RePackArchiveFile(catfp, compression, compressionlevel, checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp);
6900  return listcatfiles;
6901
6902 create_alias_function("RePack", __file_format_name__, "FromString", RePackArchiveFileFromString);
6903
6904 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):
6905  outarray = BytesIO();
6906  packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, True);
6907  listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp);
6908  return listcatfiles;
6909
6910 create_alias_function("Pack", __file_format_name__, "FromListDir", PackArchiveFileFromListDir);
6911
6912 def ArchiveFileArrayBase64Encode(infile, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
6913  if(verbose):
6914   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
6915  if(isinstance(infile, dict)):
6916   prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6917   listcatfiles = prelistcatfiles['list'];
6918  else:
6919   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
6920    infile = RemoveWindowsPath(infile);
6921   if(followlink):
6922    prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6923    listcatfiles = prelistcatfiles['list'];
6924   else:
6925    listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6926  if(not listcatfiles):
6927   return False;
6928  lenlist = len(listcatfiles['ffilelist']);
6929  fnumfiles = int(listcatfiles['fnumfiles']);
6930  lcfi = 0;
6931  lcfx = int(listcatfiles['fnumfiles']);
6932  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6933   lcfx = int(lenlist);
6934  else:
6935   lcfx = int(listcatfiles['fnumfiles']);
6936  while(lcfi<lcfx):
6937   if(listcatfiles['ffilelist'][lcfi]['fhascontents']):
6938    listcatfiles['ffilelist'][lcfi]['fcontents'] = base64.b64encode(listcatfiles['ffilelist'][lcfi]['fcontents']).decode("UTF-8");
6939   lcfi = lcfi + 1;
6940  return listcatfiles;
6941
6942 create_alias_function("", __file_format_name__, "ArrayBase64Encode", ArchiveFileArrayBase64Encode);
6943
6944 def ArchiveFileArrayBase64Decode(infile, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
6945  if(verbose):
6946   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
6947  if(isinstance(infile, dict)):
6948   prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6949   listcatfiles = prelistcatfiles['list'];
6950  else:
6951   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
6952    infile = RemoveWindowsPath(infile);
6953   if(followlink):
6954    prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6955    listcatfiles = prelistcatfiles['list'];
6956   else:
6957    listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6958  if(not listcatfiles):
6959   return False;
6960  lenlist = len(listcatfiles['ffilelist']);
6961  fnumfiles = int(listcatfiles['fnumfiles']);
6962  lcfi = 0;
6963  lcfx = int(listcatfiles['fnumfiles']);
6964  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6965   lcfx = int(lenlist);
6966  else:
6967   lcfx = int(listcatfiles['fnumfiles']);
6968  while(lcfi<lcfx):
6969   if(listcatfiles['ffilelist'][lcfi]['fhascontents']):
6970    listcatfiles['ffilelist'][lcfi]['fcontents'] = base64.b64decode(listcatfiles['ffilelist'][lcfi]['fcontents'].encode("UTF-8"));
6971   lcfi = lcfi + 1;
6972  return listcatfiles;
6973
6974 create_alias_function("", __file_format_name__, "ArrayBase64Decode", ArchiveFileArrayBase64Decode);
6975
6976 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):
6977  if(outdir is not None):
6978   outdir = RemoveWindowsPath(outdir);
6979  if(verbose):
6980   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
6981  if(isinstance(infile, dict)):
6982   prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6983   listcatfiles = prelistcatfiles['list'];
6984  else:
6985   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
6986    infile = RemoveWindowsPath(infile);
6987   if(followlink):
6988    prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6989    listcatfiles = prelistcatfiles['list'];
6990   else:
6991    listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
6992  if(not listcatfiles):
6993   return False;
6994  lenlist = len(listcatfiles['ffilelist']);
6995  fnumfiles = int(listcatfiles['fnumfiles']);
6996  lcfi = 0;
6997  lcfx = int(listcatfiles['fnumfiles']);
6998  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
6999   lcfx = int(lenlist);
7000  else:
7001   lcfx = int(listcatfiles['fnumfiles']);
7002  while(lcfi<lcfx):
7003   funame = "";
7004   try:
7005    import pwd;
7006    try:
7007     userinfo = pwd.getpwuid(listcatfiles['ffilelist'][lcfi]['fuid']);
7008     funame = userinfo.pw_name;
7009    except KeyError:
7010     funame = "";
7011   except ImportError:
7012    funame = "";
7013   fgname = "";
7014   try:
7015    import grp;
7016    try:
7017     groupinfo = grp.getgrgid(listcatfiles['ffilelist'][lcfi]['fgid']);
7018     fgname = groupinfo.gr_name;
7019    except KeyError:
7020     fgname = "";
7021   except ImportError:
7022    fgname = "";
7023   if(verbose):
7024    VerbosePrintOut(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7025   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
7026    with open(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
7027     fpc.write(listcatfiles['ffilelist'][lcfi]['fcontents'])
7028     try:
7029      fpc.flush()
7030      os.fsync(fpc.fileno())
7031     except io.UnsupportedOperation:
7032      pass
7033     except AttributeError:
7034      pass
7035    if(hasattr(os, "chown") and funame==listcatfiles['ffilelist'][lcfi]['funame'] and fgname==listcatfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
7036     os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fuid'], listcatfiles['ffilelist'][lcfi]['fgid']);
7037    if(preservepermissions):
7038     os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fchmode']);
7039    if(preservetime):
7040     os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (listcatfiles['ffilelist'][lcfi]['fatime'], listcatfiles['ffilelist'][lcfi]['fmtime']));
7041   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
7042    if(followlink):
7043     getflinkpath = listcatfiles['ffilelist'][lcfi]['flinkname'];
7044     flinkid = prelistcatfiles['filetoid'][getflinkpath];
7045     flinkinfo = listcatfiles['ffilelist'][flinkid];
7046     funame = "";
7047     try:
7048      import pwd;
7049      try:
7050       userinfo = pwd.getpwuid(flinkinfo['fuid']);
7051       funame = userinfo.pw_name;
7052      except KeyError:
7053       funame = "";
7054     except ImportError:
7055      funame = "";
7056     fgname = "";
7057     try:
7058      import grp;
7059      try:
7060       groupinfo = grp.getgrgid(flinkinfo['fgid']);
7061       fgname = groupinfo.gr_name;
7062      except KeyError:
7063       fgname = "";
7064     except ImportError:
7065      fgname = "";
7066     if(flinkinfo['ftype']==0 or flinkinfo['ftype']==7):
7067      with open(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
7068       fpc.write(flinkinfo['fcontents'])
7069       try:
7070        fpc.flush()
7071        os.fsync(fpc.fileno())
7072       except io.UnsupportedOperation:
7073        pass
7074       except AttributeError:
7075        pass
7076      if(hasattr(os, "chown") and funame==flinkinfo['funame'] and fgname==flinkinfo['fgname'] and preservepermissions):
7077       os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid']);
7078      if(preservepermissions):
7079       os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7080      if(preservetime):
7081       os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (flinkinfo['fatime'], flinkinfo['fmtime']));
7082     if(flinkinfo['ftype']==1):
7083      os.link(flinkinfo['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7084     if(flinkinfo['ftype']==2):
7085      os.symlink(flinkinfo['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7086     if(flinkinfo['ftype']==5):
7087      if(preservepermissions):
7088       os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7089      else:
7090       os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7091      if(hasattr(os, "chown") and funame==flinkinfo['funame'] and fgname==flinkinfo['fgname'] and preservepermissions):
7092       os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid']);
7093      if(preservepermissions):
7094       os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7095      if(preservetime):
7096       os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (flinkinfo['fatime'], flinkinfo['fmtime']));
7097     if(flinkinfo['ftype']==6 and hasattr(os, "mkfifo")):
7098      os.mkfifo(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7099    else:
7100     os.link(listcatfiles['ffilelist'][lcfi]['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7101   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
7102    if(followlink):
7103     getflinkpath = listcatfiles['ffilelist'][lcfi]['flinkname'];
7104     flinkid = prelistcatfiles['filetoid'][getflinkpath];
7105     flinkinfo = listcatfiles['ffilelist'][flinkid];
7106     funame = "";
7107     try:
7108      import pwd;
7109      try:
7110       userinfo = pwd.getpwuid(flinkinfo['fuid']);
7111       funame = userinfo.pw_name;
7112      except KeyError:
7113       funame = "";
7114     except ImportError:
7115      funame = "";
7116     fgname = "";
7117     try:
7118      import grp;
7119      try:
7120       groupinfo = grp.getgrgid(flinkinfo['fgid']);
7121       fgname = groupinfo.gr_name;
7122      except KeyError:
7123       fgname = "";
7124     except ImportError:
7125      fgname = "";
7126     if(flinkinfo['ftype']==0 or flinkinfo['ftype']==7):
7127      with open(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), "wb") as fpc:
7128       fpc.write(flinkinfo['fcontents'])
7129       try:
7130        fpc.flush()
7131        os.fsync(fpc.fileno())
7132       except io.UnsupportedOperation:
7133        pass
7134       except AttributeError:
7135        pass
7136      if(hasattr(os, "chown") and funame==flinkinfo['funame'] and fgname==flinkinfo['fgname'] and preservepermissions):
7137       os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid']);
7138      if(preservepermissions):
7139       os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7140      if(preservetime):
7141       os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (flinkinfo['fatime'], flinkinfo['fmtime']));
7142     if(flinkinfo['ftype']==1):
7143      os.link(flinkinfo['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7144     if(flinkinfo['ftype']==2):
7145      os.symlink(flinkinfo['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7146     if(flinkinfo['ftype']==5):
7147      if(preservepermissions):
7148       os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7149      else:
7150       os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7151      if(hasattr(os, "chown") and funame==flinkinfo['funame'] and fgname==flinkinfo['fgname'] and preservepermissions):
7152       os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fuid'], flinkinfo['fgid']);
7153      if(preservepermissions):
7154       os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7155      if(preservetime):
7156       os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (flinkinfo['fatime'], flinkinfo['fmtime']));
7157     if(flinkinfo['ftype']==6 and hasattr(os, "mkfifo")):
7158      os.mkfifo(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), flinkinfo['fchmode']);
7159    else:
7160     os.symlink(listcatfiles['ffilelist'][lcfi]['flinkname'], PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7161   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
7162    if(preservepermissions):
7163     os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fchmode']);
7164    else:
7165     os.mkdir(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']));
7166    if(hasattr(os, "chown") and funame==listcatfiles['ffilelist'][lcfi]['funame'] and fgname==listcatfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
7167     os.chown(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fuid'], listcatfiles['ffilelist'][lcfi]['fgid']);
7168    if(preservepermissions):
7169     os.chmod(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fchmode']);
7170    if(preservetime):
7171     os.utime(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), (listcatfiles['ffilelist'][lcfi]['fatime'], listcatfiles['ffilelist'][lcfi]['fmtime']));
7172   if(listcatfiles['ffilelist'][lcfi]['ftype']==6 and hasattr(os, "mkfifo")):
7173    os.mkfifo(PrependPath(outdir, listcatfiles['ffilelist'][lcfi]['fname']), listcatfiles['ffilelist'][lcfi]['fchmode']);
7174   lcfi = lcfi + 1;
7175  if(returnfp):
7176   return listcatfiles['ffilelist']['catfp'];
7177  else:
7178   return True;
7179
7180 create_alias_function("UnPack", __file_format_name__, "", UnPackArchiveFile);
7181
7182 if(hasattr(shutil, "register_unpack_format")):
7183  def UnPackArchiveFileFunc(archive_name, extract_dir=None, **kwargs):
7184   return UnPackArchiveFile(archive_name, extract_dir, False, 0, 0, False, __file_format_delimiter__, False, False);
7185  create_alias_function("UnPack", __file_format_name__, "Func", UnPackArchiveFileFunc);
7186
7187 def UnPackArchiveFileString(catstr, outdir=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
7188  catfp = BytesIO(catstr);
7189  listcatfiles = UnPackArchiveFile(catfp, outdir, followlink, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp);
7190  return listcatfiles;
7191
7192 create_alias_function("UnPack", __file_format_name__, "String", UnPackArchiveFileString);
7193
7194 def ArchiveFileListFiles(infile, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
7195  logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7196  if(isinstance(infile, dict)):
7197   listcatfiles = infile;
7198  else:
7199   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
7200    infile = RemoveWindowsPath(infile);
7201   listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, True, skipchecksum, formatspecs, returnfp);
7202  if(not listcatfiles):
7203   return False;
7204  lenlist = len(listcatfiles['ffilelist']);
7205  fnumfiles = int(listcatfiles['fnumfiles']);
7206  lcfi = 0;
7207  lcfx = int(listcatfiles['fnumfiles']);
7208  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
7209   lcfx = int(lenlist);
7210  else:
7211   lcfx = int(listcatfiles['fnumfiles']);
7212  returnval = {};
7213  while(lcfi<lcfx):
7214   returnval.update({lcfi: listcatfiles['ffilelist'][lcfi]['fname']});
7215   if(not verbose):
7216    VerbosePrintOut(listcatfiles['ffilelist'][lcfi]['fname']);
7217   if(verbose):
7218    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' } };
7219    printfname = listcatfiles['ffilelist'][lcfi]['fname'];
7220    if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
7221     printfname = listcatfiles['ffilelist'][lcfi]['fname'] + " link to " + listcatfiles['ffilelist'][lcfi]['flinkname'];
7222    if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
7223     printfname = listcatfiles['ffilelist'][lcfi]['fname'] + " -> " + listcatfiles['ffilelist'][lcfi]['flinkname'];
7224    fuprint = listcatfiles['ffilelist'][lcfi]['funame'];
7225    if(len(fuprint)<=0):
7226     fuprint = listcatfiles['ffilelist'][lcfi]['fuid'];
7227    fgprint = listcatfiles['ffilelist'][lcfi]['fgname'];
7228    if(len(fgprint)<=0):
7229     fgprint = listcatfiles['ffilelist'][lcfi]['fgid'];
7230    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));
7231   lcfi = lcfi + 1;
7232  if(returnfp):
7233   return listcatfiles['catfp'];
7234  else:
7235   return True;
7236
7237 create_alias_function("", __file_format_name__, "ListFiles", ArchiveFileListFiles);
7238
7239 def ArchiveFileStringListFiles(catstr, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
7240  catfp = BytesIO(catstr);
7241  listcatfiles = ArchiveFileListFiles(catstr, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp);
7242  return listcatfiles;
7243
7244 create_alias_function("", __file_format_name__, "StringListFiles", ArchiveFileListFiles);
7245
7246 def ArchiveFileListFilesAlt(infile, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
7247  logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7248  if(isinstance(infile, dict)):
7249   listcatfiles = infile;
7250  else:
7251   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
7252    infile = RemoveWindowsPath(infile);
7253   listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, True, skipchecksum, formatspecs, returnfp);
7254  if(not listcatfiles):
7255   return False;
7256  lenlist = len(listcatfiles['ffilelist']);
7257  fnumfiles = int(listcatfiles['fnumfiles']);
7258  lcfi = 0;
7259  lcfx = int(listcatfiles['fnumfiles']);
7260  if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
7261   lcfx = int(lenlist);
7262  else:
7263   lcfx = int(listcatfiles['fnumfiles']);
7264  returnval = {};
7265  while(lcfi<lcfx):
7266   returnval.update({lcfi: listcatfiles['ffilelist'][lcfi]['fname']});
7267   if(not verbose):
7268    VerbosePrintOut(listcatfiles['ffilelist'][lcfi]['fname']);
7269   if(verbose):
7270    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' } };
7271    printfname = listcatfiles['ffilelist'][lcfi]['fname'];
7272    if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
7273     printfname = listcatfiles['ffilelist'][lcfi]['fname'] + " link to " + listcatfiles['ffilelist'][lcfi]['flinkname'];
7274    if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
7275     printfname = listcatfiles['ffilelist'][lcfi]['fname'] + " -> " + listcatfiles['ffilelist'][lcfi]['flinkname'];
7276    fuprint = listcatfiles['ffilelist'][lcfi]['funame'];
7277    if(len(fuprint)<=0):
7278     fuprint = listcatfiles['ffilelist'][lcfi]['fuid'];
7279    fgprint = listcatfiles['ffilelist'][lcfi]['fgname'];
7280    if(len(fgprint)<=0):
7281     fgprint = listcatfiles['ffilelist'][lcfi]['fgid'];
7282    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));
7283   lcfi = lcfi + 1;
7284  if(returnfp):
7285   return listcatfiles['catfp'];
7286  else:
7287   return True;
7288
7289 create_alias_function("", __file_format_name__, "ListFilesAlt", ArchiveFileListFilesAlt);
7290
7291 def ArchiveFileStringListFilesAlt(catstr, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
7292  catfp = BytesIO(catstr);
7293  listcatfiles = ArchiveFileListFilesAlt(catstr, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp);
7294  return listcatfiles;
7295
7296 create_alias_function("", __file_format_name__, "StringListFilesAlt", ArchiveFileListFilesAlt);
7297
7298 def TarFileListFiles(infile, verbose=False, returnfp=False):
7299  logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7300  if(infile=="-"):
7301   infile = BytesIO();
7302   if(hasattr(sys.stdin, "buffer")):
7303    shutil.copyfileobj(sys.stdin.buffer, infile);
7304   else:
7305    shutil.copyfileobj(sys.stdin, infile);
7306   infile.seek(0, 0);
7307   if(not infile):
7308    return False;
7309   infile.seek(0, 0);
7310  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
7311   infile = download_file_from_internet_file(infile);
7312   infile.seek(0, 0);
7313   if(not infile):
7314    return False;
7315   infile.seek(0, 0);
7316  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
7317   return False;
7318  elif(os.path.exists(infile) and os.path.isfile(infile)):
7319   try:
7320    if(not tarfile.is_tarfile(infile)):
7321     return False;
7322   except AttributeError:
7323    if(not is_tarfile(infile)):
7324     return False;
7325  else:
7326   return False;
7327  try:
7328   if(hasattr(infile, "read") or hasattr(infile, "write")):
7329    tarfp = tarfile.open(fileobj=infile, mode="r");
7330   else:
7331    tarfp = tarfile.open(infile, "r");
7332  except FileNotFoundError:
7333   return False;
7334  lcfi = 0
7335  returnval = {};
7336  for member in sorted(tarfp.getmembers(), key=lambda x: x.name):
7337   returnval.update({lcfi: member.name});
7338   fpremode = member.mode;
7339   ffullmode = member.mode;
7340   flinkcount = 0;
7341   ftype = 0;
7342   if(member.isreg()):
7343    ffullmode = member.mode + stat.S_IFREG;
7344    ftype = 0;
7345   elif(member.isdev()):
7346    ffullmode = member.mode;
7347    ftype = 7;
7348   elif(member.islnk()):
7349    ffullmode = member.mode + stat.S_IFREG;
7350    ftype = 1;
7351   elif(member.issym()):
7352    ffullmode = member.mode + stat.S_IFLNK;
7353    ftype = 2;
7354   elif(member.ischr()):
7355    ffullmode = member.mode + stat.S_IFCHR;
7356    ftype = 3;
7357   elif(member.isblk()):
7358    ffullmode = member.mode + stat.S_IFBLK;
7359    ftype = 4;
7360   elif(member.isdir()):
7361    ffullmode = member.mode + stat.S_IFDIR;
7362    ftype = 5;
7363   elif(member.isfifo()):
7364    ffullmode = member.mode + stat.S_IFIFO;
7365    ftype = 6;
7366   elif(member.issparse()):
7367    ffullmode = member.mode;
7368    ftype = 12;
7369   if(not verbose):
7370    VerbosePrintOut(member.name);
7371   elif(verbose):
7372    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' } };
7373    printfname = member.name;
7374    if(member.islnk()):
7375     printfname = member.name + " link to " + member.linkname;
7376    elif(member.issym()):
7377     printfname = member.name + " -> " + member.linkname;
7378    fuprint = member.uname;
7379    if(len(fuprint)<=0):
7380     fuprint = member.uid;
7381    fgprint = member.gname;
7382    if(len(fgprint)<=0):
7383     fgprint = member.gid;
7384    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));
7385   lcfi = lcfi + 1;
7386  if(returnfp):
7387   return listcatfiles['catfp'];
7388  else:
7389   return True;
7390
7391 def ZipFileListFiles(infile, verbose=False, returnfp=False):
7392  logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7393  if(infile=="-"):
7394   infile = BytesIO();
7395   if(hasattr(sys.stdin, "buffer")):
7396    shutil.copyfileobj(sys.stdin.buffer, infile);
7397   else:
7398    shutil.copyfileobj(sys.stdin, infile);
7399   infile.seek(0, 0);
7400   if(not infile):
7401    return False;
7402   infile.seek(0, 0);
7403  elif(re.findall(r"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile))):
7404   infile = download_file_from_internet_file(infile);
7405   infile.seek(0, 0);
7406   if(not infile):
7407    return False;
7408   infile.seek(0, 0);
7409  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
7410   return False;
7411  else:
7412   return False;
7413  if(not zipfile.is_zipfile(infile)):
7414   return False;
7415  try:
7416   zipfp = zipfile.ZipFile(infile, "r", allowZip64=True);
7417  except FileNotFoundError:
7418   return False;
7419  lcfi = 0;
7420  returnval = {};
7421  ziptest = zipfp.testzip();
7422  if(ziptest):
7423   VerbosePrintOut("Bad file found!");
7424  for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
7425   if(zipinfo.create_system==0 or zipinfo.create_system==10):
7426    fwinattributes = int(zipinfo.external_attr);
7427    if(not member.is_dir()):
7428     fmode = int(stat.S_IFREG + 438);
7429     fchmode = int(stat.S_IMODE(fmode));
7430     ftypemod = int(stat.S_IFMT(fmode));
7431    elif(member.is_dir()):
7432     fmode = int(stat.S_IFDIR + 511);
7433     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
7434     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
7435   elif(zipinfo.create_system==3):
7436    fwinattributes =int(0);
7437    fmode = int(zipinfo.external_attr);
7438    fchmode = int(stat.S_IMODE(fmode));
7439    ftypemod = int(stat.S_IFMT(fmode));
7440   else:
7441    fwinattributes = int(0);
7442    if(not member.is_dir()):
7443     fmode = int(stat.S_IFREG + 438);
7444     fchmode = int(stat.S_IMODE(fmode));
7445     ftypemod = int(stat.S_IFMT(fmode));
7446    elif(member.is_dir()):
7447     fmode = int(stat.S_IFDIR + 511);
7448     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
7449     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
7450   returnval.update({lcfi: member.filename});
7451   if(not verbose):
7452    VerbosePrintOut(member.filename);
7453   if(verbose):
7454    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' } };
7455    permissionstr = "";
7456    for fmodval in str(oct(fmode))[-3:]:
7457     permissionstr = permissionstr + permissions['access'].get(fmodval, '---');
7458    if(not member.is_dir()):
7459     ftype = 0;
7460     permissionstr = "-" + permissionstr;
7461    elif(member.is_dir()):
7462     ftype = 5;
7463     permissionstr = "d" + permissionstr;
7464    printfname = member.filename;
7465    try:
7466     fuid = int(os.getuid());
7467    except AttributeError:
7468     fuid = int(0);
7469    except KeyError:
7470     fuid = int(0);
7471    try:
7472     fgid = int(os.getgid());
7473    except AttributeError:
7474     fgid = int(0);
7475    except KeyError:
7476     fgid = int(0);
7477    try:
7478     import pwd;
7479     try:
7480      userinfo = pwd.getpwuid(os.getuid());
7481      funame = userinfo.pw_name;
7482     except KeyError:
7483      funame = "";
7484     except AttributeError:
7485      funame = "";
7486    except ImportError:
7487     funame = "";
7488    fgname = "";
7489    try:
7490     import grp;
7491     try:
7492      groupinfo = grp.getgrgid(os.getgid());
7493      fgname = groupinfo.gr_name;
7494     except KeyError:
7495      fgname = "";
7496     except AttributeError:
7497      fgname = "";
7498    except ImportError:
7499     fgname = "";
7500    fuprint = funame;
7501    if(len(fuprint)<=0):
7502     fuprint = str(fuid);
7503    fgprint = fgname;
7504    if(len(fgprint)<=0):
7505     fgprint = str(fgid);
7506    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));
7507   lcfi = lcfi + 1;
7508  if(returnfp):
7509   return listcatfiles['catfp'];
7510  else:
7511   return True;
7512
7513 if(not rarfile_support):
7514  def RarFileListFiles(infile, verbose=False, returnfp=False):
7515   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7516   if(not os.path.exists(infile) or not os.path.isfile(infile)):
7517    return False;
7518
7519 if(rarfile_support):
7520  def RarFileListFiles(infile, verbose=False, returnfp=False):
7521   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7522   if(not os.path.exists(infile) or not os.path.isfile(infile)):
7523    return False;
7524   if(not rarfile.is_rarfile(infile) and not rarfile.is_rarfile_sfx(infile)):
7525    return False;
7526   lcfi = 0;
7527   returnval = {};
7528   rarfp = rarfile.RarFile(infile, "r");
7529   rartest = rarfp.testrar();
7530   if(rartest):
7531    VerbosePrintOut("Bad file found!");
7532   for member in sorted(rarfp.infolist(), key=lambda x: x.filename):
7533    is_unix = False;
7534    is_windows = False;
7535    if(member.host_os==rarfile.RAR_OS_UNIX):
7536     is_windows = False;
7537     try:
7538      member.external_attr
7539      is_unix = True;
7540     except AttributeError:
7541      is_unix = False;
7542    elif(member.host_os==rarfile.RAR_OS_WIN32):
7543     is_unix = False;
7544     try:
7545      member.external_attr
7546      is_windows = True;
7547     except AttributeError:
7548      is_windows = False;
7549    else:
7550     is_unix = False;
7551     is_windows = False;
7552    if(is_unix and member.external_attr !=0):
7553     fpremode = int(member.external_attr);
7554    elif(member.is_file()):
7555     fpremode = int(stat.S_IFREG + 438);
7556    elif(member.is_symlink()):
7557     fpremode = int(stat.S_IFLNK + 438);
7558    elif(member.is_dir()):
7559     fpremode = int(stat.S_IFDIR + 511);
7560    if(is_windows and member.external_attr !=0):
7561     fwinattributes = int(member.external_attr);
7562    else:
7563     fwinattributes = int(0);
7564    if(is_unix and member.external_attr !=0):
7565     fmode = int(member.external_attr);
7566     fchmode = int(stat.S_IMODE(member.external_attr));
7567     ftypemod = int(stat.S_IFMT(member.external_attr));
7568    elif(member.is_file()):
7569     fmode = int(stat.S_IFREG + 438);
7570     fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)));
7571     ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)));
7572    elif(member.is_symlink()):
7573     fmode = int(stat.S_IFLNK + 438);
7574     fchmode = int(stat.S_IMODE(int(stat.S_IFLNK + 438)));
7575     ftypemod = int(stat.S_IFMT(int(stat.S_IFLNK + 438)));
7576    elif(member.is_dir()):
7577     fmode = int(stat.S_IFDIR + 511);
7578     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
7579     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
7580    returnval.update({lcfi: member.filename});
7581    if(not verbose):
7582     VerbosePrintOut(member.filename);
7583    if(verbose):
7584     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' } };
7585     permissionstr = "";
7586     for fmodval in str(oct(fmode))[-3:]:
7587      permissionstr = permissionstr + permissions['access'].get(fmodval, '---');
7588     if(member.is_file()):
7589      ftype = 0;
7590      permissionstr = "-" + permissionstr;
7591      printfname = member.filename;
7592     elif(member.is_symlink()):
7593      ftype = 2;
7594      permissionstr = "l" + permissionstr;
7595      printfname = member.name + " -> " + member.read().decode("UTF-8");
7596     elif(member.is_dir()):
7597      ftype = 5;
7598      permissionstr = "d" + permissionstr;
7599      printfname = member.filename;
7600     try:
7601      fuid = int(os.getuid());
7602     except AttributeError:
7603      fuid = int(0);
7604     except KeyError:
7605      fuid = int(0);
7606     try:
7607      fgid = int(os.getgid());
7608     except AttributeError:
7609      fgid = int(0);
7610     except KeyError:
7611      fgid = int(0);
7612     try:
7613      import pwd;
7614      try:
7615       userinfo = pwd.getpwuid(os.getuid());
7616       funame = userinfo.pw_name;
7617      except KeyError:
7618       funame = "";
7619      except AttributeError:
7620       funame = "";
7621     except ImportError:
7622      funame = "";
7623     fgname = "";
7624     try:
7625      import grp;
7626      try:
7627       groupinfo = grp.getgrgid(os.getgid());
7628       fgname = groupinfo.gr_name;
7629      except KeyError:
7630       fgname = "";
7631      except AttributeError:
7632       fgname = "";
7633     except ImportError:
7634      fgname = "";
7635     fuprint = funame;
7636     if(len(fuprint)<=0):
7637      fuprint = str(fuid);
7638     fgprint = fgname;
7639     if(len(fgprint)<=0):
7640      fgprint = str(fgid);
7641     VerbosePrintOut(PrintPermissionString(fmode, ftype) + " " + str(str(fuprint) + "/" + str(fgprint) + " " + str(member.file_size).rjust(15) + " " + member.mtime.strftime('%Y-%m-%d %H:%M') + " " + printfname));
7642    lcfi = lcfi + 1;
7643   if(returnfp):
7644    return listcatfiles['catfp'];
7645   else:
7646    return True;
7647
7648 if(not py7zr_support):
7649  def SevenZipFileListFiles(infile, verbose=False, returnfp=False):
7650   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7651   if(not os.path.exists(infile) or not os.path.isfile(infile)):
7652    return False;
7653
7654 if(py7zr_support):
7655  def SevenZipFileListFiles(infile, verbose=False, returnfp=False):
7656   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
7657   if(not os.path.exists(infile) or not os.path.isfile(infile)):
7658    return False;
7659   lcfi = 0;
7660   returnval = {};
7661   szpfp = py7zr.SevenZipFile(infile, mode="r");
7662   file_content = szpfp.readall();
7663   #sztest = szpfp.testzip();
7664   sztestalt = szpfp.test();
7665   if(sztestalt):
7666    VerbosePrintOut("Bad file found!");
7667   for member in sorted(szpfp.list(), key=lambda x: x.filename):
7668    if(re.findall("^[.|/]", member.filename)):
7669     fname = member.filename;
7670    else:
7671     fname = "./"+member.filename;
7672    if(not member.is_directory):
7673     fpremode = int(stat.S_IFREG + 438);
7674    elif(member.is_directory):
7675     fpremode = int(stat.S_IFDIR + 511);
7676    fwinattributes = int(0);
7677    if(member.is_directory):
7678     fmode = int(stat.S_IFDIR + 511);
7679     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
7680     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
7681    else:
7682     fmode = int(stat.S_IFLNK + 438);
7683     fchmode = int(stat.S_IMODE(int(stat.S_IFLNK + 438)));
7684     ftypemod = int(stat.S_IFMT(int(stat.S_IFLNK + 438)));
7685    returnval.update({lcfi: member.filename});
7686    if(not verbose):
7687     VerbosePrintOut(member.filename);
7688    if(verbose):
7689     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' } };
7690     permissionstr = "";
7691     for fmodval in str(oct(fmode))[-3:]:
7692      permissionstr = permissionstr + permissions['access'].get(fmodval, '---');
7693     fsize = int("0");
7694     if(not member.is_directory):
7695      ftype = 0;
7696      permissionstr = "-" + permissionstr;
7697      printfname = member.filename;
7698     elif(member.is_directory):
7699      ftype = 5;
7700      permissionstr = "d" + permissionstr;
7701      printfname = member.filename;
7702     if(ftype==0):
7703      fsize = len(file_content[member.filename].read());
7704      file_content[member.filename].close();
7705     try:
7706      fuid = int(os.getuid());
7707     except AttributeError:
7708      fuid = int(0);
7709     except KeyError:
7710      fuid = int(0);
7711     try:
7712      fgid = int(os.getgid());
7713     except AttributeError:
7714      fgid = int(0);
7715     except KeyError:
7716      fgid = int(0);
7717     try:
7718      import pwd;
7719      try:
7720       userinfo = pwd.getpwuid(os.getuid());
7721       funame = userinfo.pw_name;
7722      except KeyError:
7723       funame = "";
7724      except AttributeError:
7725       funame = "";
7726     except ImportError:
7727      funame = "";
7728     fgname = "";
7729     try:
7730      import grp;
7731      try:
7732       groupinfo = grp.getgrgid(os.getgid());
7733       fgname = groupinfo.gr_name;
7734      except KeyError:
7735       fgname = "";
7736      except AttributeError:
7737       fgname = "";
7738     except ImportError:
7739      fgname = "";
7740     fuprint = funame;
7741     if(len(fuprint)<=0):
7742      fuprint = str(fuid);
7743     fgprint = fgname;
7744     if(len(fgprint)<=0):
7745      fgprint = str(fgid);
7746     VerbosePrintOut(PrintPermissionString(fmode, ftype) + " " + str(str(fuprint) + "/" + str(fgprint) + " " + str(fsize).rjust(15) + " " + member.creationtime.strftime('%Y-%m-%d %H:%M') + " " + printfname));
7747    lcfi = lcfi + 1;
7748   if(returnfp):
7749    return listcatfiles['catfp'];
7750   else:
7751    return True;
7752
7753 def InFileListFiles(infile, verbose=False, formatspecs=__file_format_list__, returnfp=False):
7754  checkcompressfile = CheckCompressionSubType(infile, formatspecs, True);
7755  if(checkcompressfile=="tarfile"):
7756   return TarFileListFiles(infile, verbose, returnfp);
7757  elif(checkcompressfile=="zipfile"):
7758   return ZipFileListFiles(infile, verbose, returnfp);
7759  elif(checkcompressfile=="catfile"):
7760   return ArchiveFileListFiles(infile, verbose, returnfp);
7761  elif(rarfile_support and checkcompressfile=="rarfile"):
7762   return RarFileListFiles(infile, verbose, returnfp);
7763  elif(py7zr_support and checkcompressfile=="7zipfile"):
7764   return SevenZipFileListFiles(infile, verbose, returnfp);
7765  else:
7766   return False;
7767  return False;
7768
7769 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):
7770  outarray = BytesIO();
7771  packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, formatspecs, False, True);
7772  listcatfiles = ArchiveFileListFiles(outarray, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp);
7773  return listcatfiles;
7774
7775 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):
7776  outarray = ListDirToArrayAlt(infiles, dirlistfromtxt, followlink, listonly, checksumtype, formatspecs, verbose);
7777  listcatfiles = ArchiveFileListFiles(outarray, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp);
7778  return listcatfiles;
7779
7780 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):
7781  outarray = ListDirToArrayAlt(infiles, dirlistfromtxt, followlink, False, checksumtype, extradata, formatspecs, False);
7782  listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, followlink, checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp);
7783  return listcatfiles;
7784
7785 create_alias_function("Pack", __file_format_name__, "FromListDirAlt", PackArchiveFileFromListDirAlt);
7786
7787 def PackArchiveFileFromTarFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7788  outarray = TarFileToArrayAlt(infile, False, checksumtype, extradata, formatspecs, False);
7789  listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp);
7790  return listcatfiles;
7791
7792 create_alias_function("Pack", __file_format_name__, "FromTarFileAlt", PackArchiveFileFromTarFileAlt);
7793
7794 def PackArchiveFileFromZipFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7795  outarray = ZipFileToArrayAlt(infile, False, checksumtype, extradata, formatspecs, False);
7796  listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp);
7797  return listcatfiles;
7798
7799 create_alias_function("Pack", __file_format_name__, "FromZipFileAlt", PackArchiveFileFromZipFileAlt);
7800
7801 if(not rarfile_support):
7802  def PackArchiveFileFromRarFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7803   return False;
7804
7805 if(rarfile_support):
7806  def PackArchiveFileFromRarFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7807   outarray = RarFileToArrayAlt(infile, False, checksumtype, extradata, formatspecs, False);
7808   listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp);
7809   return listcatfiles;
7810
7811 create_alias_function("Pack", __file_format_name__, "FromRarFileAlt", PackArchiveFileFromRarFileAlt);
7812
7813 if(not py7zr_support):
7814  def PackArchiveFileFromSevenZipFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7815   return False;
7816
7817 if(py7zr_support):
7818  def PackArchiveFileFromSevenZipFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
7819   outarray = SevenZipFileToArrayAlt(infile, False, checksumtype, extradata, formatspecs, False);
7820   listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp);
7821   return listcatfiles;
7822
7823 create_alias_function("Pack", __file_format_name__, "FromSevenZipFileAlt", PackArchiveFileFromSevenZipFileAlt);
7824
7825 def download_file_from_ftp_file(url):
7826  urlparts = urlparse(url);
7827  file_name = os.path.basename(urlparts.path);
7828  file_dir = os.path.dirname(urlparts.path);
7829  if(urlparts.username is not None):
7830   ftp_username = urlparts.username;
7831  else:
7832   ftp_username = "anonymous";
7833  if(urlparts.password is not None):
7834   ftp_password = urlparts.password;
7835  elif(urlparts.password is None and urlparts.username=="anonymous"):
7836   ftp_password = "anonymous";
7837  else:
7838   ftp_password = "";
7839  if(urlparts.scheme=="ftp"):
7840   ftp = FTP();
7841  elif(urlparts.scheme=="ftps"):
7842   ftp = FTP_TLS();
7843  else:
7844   return False;
7845  if(urlparts.scheme=="sftp"):
7846   if(__use_pysftp__):
7847    return download_file_from_pysftp_file(url);
7848   else:
7849    return download_file_from_sftp_file(url);
7850  elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
7851   return download_file_from_http_file(url);
7852  ftp_port = urlparts.port;
7853  if(urlparts.port is None):
7854   ftp_port = 21;
7855  try:
7856   ftp.connect(urlparts.hostname, ftp_port);
7857  except socket.gaierror:
7858   log.info("Error With URL "+url);
7859   return False;
7860  except socket.timeout:
7861   log.info("Error With URL "+url);
7862   return False;
7863  ftp.login(urlparts.username, urlparts.password);
7864  if(urlparts.scheme=="ftps"):
7865   ftp.prot_p();
7866  ftpfile = BytesIO();
7867  ftp.retrbinary("RETR "+urlparts.path, ftpfile.write);
7868  #ftp.storbinary("STOR "+urlparts.path, ftpfile.write);
7869  ftp.close();
7870  ftpfile.seek(0, 0);
7871  return ftpfile;
7872
7873 def download_file_from_ftp_string(url):
7874  ftpfile = download_file_from_ftp_file(url);
7875  return ftpfile.read();
7876
7877 def upload_file_to_ftp_file(ftpfile, url):
7878  urlparts = urlparse(url);
7879  file_name = os.path.basename(urlparts.path);
7880  file_dir = os.path.dirname(urlparts.path);
7881  if(urlparts.username is not None):
7882   ftp_username = urlparts.username;
7883  else:
7884   ftp_username = "anonymous";
7885  if(urlparts.password is not None):
7886   ftp_password = urlparts.password;
7887  elif(urlparts.password is None and urlparts.username=="anonymous"):
7888   ftp_password = "anonymous";
7889  else:
7890   ftp_password = "";
7891  if(urlparts.scheme=="ftp"):
7892   ftp = FTP();
7893  elif(urlparts.scheme=="ftps"):
7894   ftp = FTP_TLS();
7895  else:
7896   return False;
7897  if(urlparts.scheme=="sftp"):
7898   if(__use_pysftp__):
7899    return upload_file_from_pysftp_file(url);
7900   else:
7901    return upload_file_from_sftp_file(url);
7902  elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
7903   return False;
7904  ftp_port = urlparts.port;
7905  if(urlparts.port is None):
7906   ftp_port = 21;
7907  try:
7908   ftp.connect(urlparts.hostname, ftp_port);
7909  except socket.gaierror:
7910   log.info("Error With URL "+url);
7911   return False;
7912  except socket.timeout:
7913   log.info("Error With URL "+url);
7914   return False;
7915  ftp.login(urlparts.username, urlparts.password);
7916  if(urlparts.scheme=="ftps"):
7917   ftp.prot_p();
7918  ftp.storbinary("STOR "+urlparts.path, ftpfile);
7919  ftp.close();
7920  ftpfile.seek(0, 0);
7921  return ftpfile;
7922
7923 def upload_file_to_ftp_string(ftpstring, url):
7924  ftpfileo = BytesIO(ftpstring);
7925  ftpfile = upload_file_to_ftp_file(ftpfileo, url);
7926  ftpfileo.close();
7927  return ftpfile;
7928
7929 def download_file_from_http_file(url, headers=geturls_headers_pycatfile_python_alt):
7930  # Parse the URL to extract username and password if present
7931  urlparts = urlparse(url);
7932  username = urlparts.username;
7933  password = urlparts.password;
7934  # Rebuild the URL without the username and password
7935  netloc = urlparts.hostname;
7936  if(urlparts.scheme=="sftp"):
7937   if(__use_pysftp__):
7938    return download_file_from_pysftp_file(url);
7939   else:
7940    return download_file_from_sftp_file(url);
7941  elif(urlparts.scheme=="ftp" or urlparts.scheme=="ftps"):
7942   return download_file_from_ftp_file(url);
7943  if urlparts.port:
7944    netloc += ':' + str(urlparts.port);
7945  rebuilt_url = urlunparse((urlparts.scheme, netloc, urlparts.path, urlparts.params, urlparts.query, urlparts.fragment));
7946  # Create a temporary file object
7947  httpfile = BytesIO();
7948  if haverequests:
7949   # Use the requests library if available
7950   if username and password:
7951    response = requests.get(rebuilt_url, headers=headers, auth=(username, password), stream=True);
7952   else:
7953    response = requests.get(rebuilt_url, headers=headers, stream=True);
7954   response.raw.decode_content = True
7955   shutil.copyfileobj(response.raw, httpfile);
7956  else:
7957   # Build a Request object for urllib
7958   request = Request(rebuilt_url, headers=headers);
7959   # Create an opener object for handling URLs
7960   if username and password:
7961    # Create a password manager
7962    password_mgr = HTTPPasswordMgrWithDefaultRealm();
7963    # Add the username and password
7964    password_mgr.add_password(None, rebuilt_url, username, password);
7965    # Create an authentication handler using the password manager
7966    auth_handler = HTTPBasicAuthHandler(password_mgr);
7967    # Build the opener with the authentication handler
7968    opener = build_opener(auth_handler);
7969   else:
7970       opener = build_opener();
7971   with opener.open(request) as response:
7972    shutil.copyfileobj(response, httpfile);
7973  # Reset file pointer to the start
7974  httpfile.seek(0, 0);
7975  # Return the temporary file object
7976  return httpfile;
7977
7978 def download_file_from_http_string(url, headers=geturls_headers_pycatfile_python_alt):
7979  httpfile = download_file_from_http_file(url, headers);
7980  return ftpfile.read();
7981
7982 if(haveparamiko):
7983  def download_file_from_sftp_file(url):
7984   urlparts = urlparse(url);
7985   file_name = os.path.basename(urlparts.path);
7986   file_dir = os.path.dirname(urlparts.path);
7987   sftp_port = urlparts.port;
7988   if(urlparts.port is None):
7989    sftp_port = 22;
7990   else:
7991    sftp_port = urlparts.port;
7992   if(urlparts.username is not None):
7993    sftp_username = urlparts.username;
7994   else:
7995    sftp_username = "anonymous";
7996   if(urlparts.password is not None):
7997    sftp_password = urlparts.password;
7998   elif(urlparts.password is None and urlparts.username=="anonymous"):
7999    sftp_password = "anonymous";
8000   else:
8001    sftp_password = "";
8002   if(urlparts.scheme=="ftp"):
8003    return download_file_from_ftp_file(url);
8004   elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
8005    return download_file_from_http_file(url);
8006   if(urlparts.scheme!="sftp"):
8007    return False;
8008   ssh = paramiko.SSHClient();
8009   ssh.load_system_host_keys();
8010   ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy());
8011   try:
8012    ssh.connect(urlparts.hostname, port=sftp_port, username=urlparts.username, password=urlparts.password);
8013   except paramiko.ssh_exception.SSHException:
8014    return False;
8015   except socket.gaierror:
8016    log.info("Error With URL "+url);
8017    return False;
8018   except socket.timeout:
8019    log.info("Error With URL "+url);
8020    return False;
8021   sftp = ssh.open_sftp();
8022   sftpfile = BytesIO();
8023   sftp.getfo(urlparts.path, sftpfile);
8024   sftp.close();
8025   ssh.close();
8026   sftpfile.seek(0, 0);
8027   return sftpfile;
8028 else:
8029  def download_file_from_sftp_file(url):
8030   return False;
8031
8032 if(haveparamiko):
8033  def download_file_from_sftp_string(url):
8034   sftpfile = download_file_from_sftp_file(url);
8035   return sftpfile.read();
8036 else:
8037  def download_file_from_ftp_string(url):
8038   return False;
8039
8040 if(haveparamiko):
8041  def upload_file_to_sftp_file(sftpfile, url):
8042   urlparts = urlparse(url);
8043   file_name = os.path.basename(urlparts.path);
8044   file_dir = os.path.dirname(urlparts.path);
8045   sftp_port = urlparts.port;
8046   if(urlparts.port is None):
8047    sftp_port = 22;
8048   else:
8049    sftp_port = urlparts.port;
8050   if(urlparts.username is not None):
8051    sftp_username = urlparts.username;
8052   else:
8053    sftp_username = "anonymous";
8054   if(urlparts.password is not None):
8055    sftp_password = urlparts.password;
8056   elif(urlparts.password is None and urlparts.username=="anonymous"):
8057    sftp_password = "anonymous";
8058   else:
8059    sftp_password = "";
8060   if(urlparts.scheme=="ftp"):
8061    return upload_file_from_ftp_file(url);
8062   elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
8063    return False;
8064   if(urlparts.scheme!="sftp"):
8065    return False;
8066   ssh = paramiko.SSHClient();
8067   ssh.load_system_host_keys();
8068   ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy());
8069   try:
8070    ssh.connect(urlparts.hostname, port=sftp_port, username=urlparts.username, password=urlparts.password);
8071   except paramiko.ssh_exception.SSHException:
8072    return False;
8073   except socket.gaierror:
8074    log.info("Error With URL "+url);
8075    return False;
8076   except socket.timeout:
8077    log.info("Error With URL "+url);
8078    return False;
8079   sftp = ssh.open_sftp();
8080   sftp.putfo(sftpfile, urlparts.path);
8081   sftp.close();
8082   ssh.close();
8083   sftpfile.seek(0, 0);
8084   return sftpfile;
8085 else:
8086  def upload_file_to_sftp_file(sftpfile, url):
8087   return False;
8088
8089 if(haveparamiko):
8090  def upload_file_to_sftp_string(sftpstring, url):
8091   sftpfileo = BytesIO(sftpstring);
8092   sftpfile = upload_file_to_sftp_files(ftpfileo, url);
8093   sftpfileo.close();
8094   return sftpfile;
8095 else:
8096  def upload_file_to_sftp_string(url):
8097   return False;
8098
8099 if(havepysftp):
8100  def download_file_from_pysftp_file(url):
8101   urlparts = urlparse(url);
8102   file_name = os.path.basename(urlparts.path);
8103   file_dir = os.path.dirname(urlparts.path);
8104   sftp_port = urlparts.port;
8105   if(urlparts.port is None):
8106    sftp_port = 22;
8107   else:
8108    sftp_port = urlparts.port;
8109   if(urlparts.username is not None):
8110    sftp_username = urlparts.username;
8111   else:
8112    sftp_username = "anonymous";
8113   if(urlparts.password is not None):
8114    sftp_password = urlparts.password;
8115   elif(urlparts.password is None and urlparts.username=="anonymous"):
8116    sftp_password = "anonymous";
8117   else:
8118    sftp_password = "";
8119   if(urlparts.scheme=="ftp"):
8120    return download_file_from_ftp_file(url);
8121   elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
8122    return download_file_from_http_file(url);
8123   if(urlparts.scheme!="sftp"):
8124    return False;
8125   try:
8126    pysftp.Connection(urlparts.hostname, port=sftp_port, username=urlparts.username, password=urlparts.password);
8127   except paramiko.ssh_exception.SSHException:
8128    return False;
8129   except socket.gaierror:
8130    log.info("Error With URL "+url);
8131    return False;
8132   except socket.timeout:
8133    log.info("Error With URL "+url);
8134    return False;
8135   sftp = ssh.open_sftp();
8136   sftpfile = BytesIO();
8137   sftp.getfo(urlparts.path, sftpfile);
8138   sftp.close();
8139   ssh.close();
8140   sftpfile.seek(0, 0);
8141   return sftpfile;
8142 else:
8143  def download_file_from_pysftp_file(url):
8144   return False;
8145
8146 if(havepysftp):
8147  def download_file_from_pysftp_string(url):
8148   sftpfile = download_file_from_pysftp_file(url);
8149   return sftpfile.read();
8150 else:
8151  def download_file_from_ftp_string(url):
8152   return False;
8153
8154 if(havepysftp):
8155  def upload_file_to_pysftp_file(sftpfile, url):
8156   urlparts = urlparse(url);
8157   file_name = os.path.basename(urlparts.path);
8158   file_dir = os.path.dirname(urlparts.path);
8159   sftp_port = urlparts.port;
8160   if(urlparts.port is None):
8161    sftp_port = 22;
8162   else:
8163    sftp_port = urlparts.port;
8164   if(urlparts.username is not None):
8165    sftp_username = urlparts.username;
8166   else:
8167    sftp_username = "anonymous";
8168   if(urlparts.password is not None):
8169    sftp_password = urlparts.password;
8170   elif(urlparts.password is None and urlparts.username=="anonymous"):
8171    sftp_password = "anonymous";
8172   else:
8173    sftp_password = "";
8174   if(urlparts.scheme=="ftp"):
8175    return upload_file_from_ftp_file(url);
8176   elif(urlparts.scheme=="http" or urlparts.scheme=="https"):
8177    return False;
8178   if(urlparts.scheme!="sftp"):
8179    return False;
8180   try:
8181    pysftp.Connection(urlparts.hostname, port=sftp_port, username=urlparts.username, password=urlparts.password);
8182   except paramiko.ssh_exception.SSHException:
8183    return False;
8184   except socket.gaierror:
8185    log.info("Error With URL "+url);
8186    return False;
8187   except socket.timeout:
8188    log.info("Error With URL "+url);
8189    return False;
8190   sftp = ssh.open_sftp();
8191   sftp.putfo(sftpfile, urlparts.path);
8192   sftp.close();
8193   ssh.close();
8194   sftpfile.seek(0, 0);
8195   return sftpfile;
8196 else:
8197  def upload_file_to_pysftp_file(sftpfile, url):
8198   return False;
8199
8200 if(havepysftp):
8201  def upload_file_to_pysftp_string(sftpstring, url):
8202   sftpfileo = BytesIO(sftpstring);
8203   sftpfile = upload_file_to_pysftp_files(ftpfileo, url);
8204   sftpfileo.close();
8205   return sftpfile;
8206 else:
8207  def upload_file_to_pysftp_string(url):
8208   return False;
8209
8210 def download_file_from_internet_file(url, headers=geturls_headers_pycatfile_python_alt):
8211  urlparts = urlparse(url);
8212  if(urlparts.scheme=="http" or urlparts.scheme=="https"):
8213   return download_file_from_http_file(url, headers);
8214  elif(urlparts.scheme=="ftp" or urlparts.scheme=="ftps"):
8215   return download_file_from_ftp_file(url);
8216  elif(urlparts.scheme=="sftp"):
8217   if(__use_pysftp__ and havepysftp):
8218    return download_file_from_pysftp_file(url);
8219   else:
8220    return download_file_from_sftp_file(url);
8221  else:
8222   return False;
8223  return False;
8224
8225 def download_file_from_internet_uncompress_file(url, headers=geturls_headers_pycatfile_python_alt, formatspecs=__file_format_list__):
8226  fp = download_file_from_internet_file(url);
8227  fp = UncompressArchiveFile(fp, formatspecs);
8228  fp.seek(0, 0);
8229  if(not fp):
8230   return False;
8231  return fp;
8232
8233 def download_file_from_internet_string(url, headers=geturls_headers_pycatfile_python_alt):
8234  urlparts = urlparse(url);
8235  if(urlparts.scheme=="http" or urlparts.scheme=="https"):
8236   return download_file_from_http_string(url, headers);
8237  elif(urlparts.scheme=="ftp" or urlparts.scheme=="ftps"):
8238   return download_file_from_ftp_string(url);
8239  elif(urlparts.scheme=="sftp"):
8240   if(__use_pysftp__ and havepysftp):
8241    return download_file_from_pysftp_string(url);
8242   else:
8243    return download_file_from_sftp_string(url);
8244  else:
8245   return False;
8246  return False;
8247
8248 def download_file_from_internet_uncompress_string(url, headers=geturls_headers_pycatfile_python_alt, formatspecs=__file_format_list__):
8249  fp = download_file_from_internet_string(url);
8250  fp = UncompressArchiveFile(fp, formatspecs);
8251  fp.seek(0, 0);
8252  if(not fp):
8253   return False;
8254  return fp;
8255
8256 def upload_file_to_internet_file(ifp, url):
8257  urlparts = urlparse(url);
8258  if(urlparts.scheme=="http" or urlparts.scheme=="https"):
8259   return False;
8260  elif(urlparts.scheme=="ftp" or urlparts.scheme=="ftps"):
8261   return upload_file_from_ftp_file(ifp, url);
8262  elif(urlparts.scheme=="sftp"):
8263   if(__use_pysftp__ and havepysftp):
8264    return upload_file_from_pysftp_file(ifp, url);
8265   else:
8266    return download_file_from_sftp_file(ifp, url);
8267  else:
8268   return False;
8269  return False;
8270
8271 def upload_file_to_internet_compress_file(ifp, url, formatspecs=__file_format_list__):
8272  catfp = CompressArchiveFile(catfp, compression, formatspecs);
8273  if(not catfileout):
8274   return False;
8275  catfp.seek(0, 0);
8276  upload_file_to_internet_file(catfp, outfile);
8277  return True;
8278
8279 def upload_file_to_internet_string(ifp, url):
8280  urlparts = urlparse(url);
8281  if(urlparts.scheme=="http" or urlparts.scheme=="https"):
8282   return False;
8283  elif(urlparts.scheme=="ftp" or urlparts.scheme=="ftps"):
8284   return upload_file_from_ftp_string(ifp, url);
8285  elif(urlparts.scheme=="sftp"):
8286   if(__use_pysftp__ and havepysftp):
8287    return upload_file_from_pysftp_string(ifp, url);
8288   else:
8289    return download_file_from_sftp_string(ifp, url);
8290  else:
8291   return False;
8292  return False;
8293
8294 def upload_file_to_internet_compress_string(ifp, url, formatspecs=__file_format_list__):
8295  catfp = CompressArchiveFile(BytesIO(ifp), compression, formatspecs);
8296  if(not catfileout):
8297   return False;
8298  catfp.seek(0, 0);
8299  upload_file_to_internet_file(catfp, outfile);
8300  return True;
8301
8302 try:
8303  if(hasattr(shutil, "register_archive_format")):
8304   # Register the packing format
8305   shutil.register_archive_format(__file_format_name__, PackArchiveFileFunc, description='Pack concatenated files');
8306 except shutil.RegistryError:
8307  pass;
8308
8309 try:
8310  if(hasattr(shutil, "register_unpack_format")):
8311   # Register the unpacking format
8312   shutil.register_unpack_format(__file_format_name__, archivefile_extensions, UnPackArchiveFileFunc, description='UnPack concatenated files');
8313 except shutil.RegistryError:
8314  pass;