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