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