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