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