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: 3/15/2024 Ver. 0.5.0 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, ftplib, platform;
  22 from ftplib import FTP, FTP_TLS;
  23 if(sys.version[0]=="2"):
  24  from urlparse import urlparse, urlunparse, urlsplit, urlunsplit, urljoin;
  25 elif(sys.version[0]>="3"):
  26  from urllib.parse import urlunparse, urlsplit, urlunsplit, urljoin, urlencode;
  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  import simplejson as json;
  57 except ImportError:
  58  import json;
  59
  60 try:
  61  from zlib import crc32;
  62 except ImportError:
  63  from binascii import crc32;
  64
  65 rarfile_support = False;
  66 try:
  67  import rarfile;
  68  rarfile_support = True;
  69 except ImportError:
  70  rarfile_support = False;
  71
  72 try:
  73  from safetar import is_tarfile;
  74 except ImportError:
  75  try:
  76   from xtarfile import is_tarfile;
  77  except ImportError:
  78   from tarfile import is_tarfile;
  79
  80 try:
  81  import safetar as tarfile;
  82 except ImportError:
  83  try:
  84   import xtarfile as tarfile;
  85  except ImportError:
  86   import tarfile;
  87
  88 haveparamiko = False;
  89 try:
  90  import paramiko;
  91  haveparamiko = True;
  92 except ImportError:
  93  haveparamiko = False;
  94
  95 havepysftp = False;
  96 try:
  97  import pysftp;
  98  havepysftp = True;
  99 except ImportError:
 100  havepysftp = False;
 101
 102 haverequests = False;
 103 try:
 104  import requests;
 105  haverequests = True;
 106 except ImportError:
 107  haverequests = False;
 108
 109 try:
 110  # Python 3 imports
 111  from urllib.request import Request, build_opener, HTTPBasicAuthHandler;
 112  from urllib.parse import urlparse;
 113 except ImportError:
 114  # Python 2 imports
 115  from urllib2 import Request, build_opener, HTTPBasicAuthHandler;
 116  from urlparse import urlparse;
 117
 118 if(sys.version[0]=="2"):
 119  try:
 120   from io import StringIO, BytesIO;
 121  except ImportError:
 122   try:
 123    from cStringIO import StringIO;
 124    from cStringIO import StringIO as BytesIO;
 125   except ImportError:
 126    from StringIO import StringIO;
 127    from StringIO import StringIO as BytesIO;
 128 elif(sys.version[0]>="3"):
 129  from io import StringIO, BytesIO;
 130 else:
 131  teststringio = 0;
 132  if(teststringio<=0):
 133   try:
 134    from cStringIO import StringIO as BytesIO;
 135    teststringio = 1;
 136   except ImportError:
 137    teststringio = 0;
 138  if(teststringio<=0):
 139   try:
 140    from StringIO import StringIO as BytesIO;
 141    teststringio = 2;
 142   except ImportError:
 143    teststringio = 0;
 144  if(teststringio<=0):
 145   try:
 146    from io import BytesIO;
 147    teststringio = 3;
 148   except ImportError:
 149    teststringio = 0;
 150
 151 __use_pysftp__ = False;
 152 if(not havepysftp):
 153  __use_pysftp__ = False;
 154 __file_format_name__ = "CatFile";
 155 __program_name__ = "Py"+__file_format_name__;
 156 __file_format_lower__ = __file_format_name__.lower();
 157 __file_format_magic__ = __file_format_name__;
 158 __file_format_len__ = len(__file_format_magic__);
 159 __file_format_hex__ = binascii.hexlify(__file_format_magic__.encode("UTF-8")).decode("UTF-8");
 160 __file_format_delimiter__ = "\x00";
 161 __file_format_ver__ = "001";
 162 __use_new_style__ = True;
 163 __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__];
 164 __project__ = __program_name__;
 165 __project_url__ = "https://github.com/GameMaker2k/PyCatFile";
 166 __version_info__ = (0, 5, 0, "RC 1", 1);
 167 __version_date_info__ = (2024, 3, 15, "RC 1", 1);
 168 __version_date__ = str(__version_date_info__[0]) + "." + str(__version_date_info__[1]).zfill(2) + "." + str(__version_date_info__[2]).zfill(2);
 169 __revision__ = __version_info__[3];
 170 __revision_id__ = "$Id$";
 171 if(__version_info__[4] is not None):
 172  __version_date_plusrc__ = __version_date__ + "-" + str(__version_date_info__[4]);
 173 if(__version_info__[4] is None):
 174  __version_date_plusrc__ = __version_date__;
 175 if(__version_info__[3] is not None):
 176  __version__ = str(__version_info__[0]) + "." + str(__version_info__[1]) + "." + str(__version_info__[2]) + " " + str(__version_info__[3]);
 177 if(__version_info__[3] is None):
 178  __version__ = str(__version_info__[0]) + "." + str(__version_info__[1]) + "." + str(__version_info__[2]);
 179
 180 PyBitness = platform.architecture();
 181 if(PyBitness=="32bit" or PyBitness=="32"):
 182  PyBitness = "32";
 183 elif(PyBitness=="64bit" or PyBitness=="64"):
 184  PyBitness = "64";
 185 else:
 186  PyBitness = "32";
 187
 188 geturls_ua_pycatfile_python = "Mozilla/5.0 (compatible; {proname}/{prover}; +{prourl})".format(proname=__project__, prover=__version__, prourl=__project_url__);
 189 if(platform.python_implementation()!=""):
 190  py_implementation = platform.python_implementation();
 191 if(platform.python_implementation()==""):
 192  py_implementation = "Python";
 193 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__);
 194 geturls_ua_googlebot_google = "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)";
 195 geturls_ua_googlebot_google_old = "Googlebot/2.1 (+http://www.google.com/bot.html)";
 196 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)};
 197 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)};
 198 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"};
 199 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"};
 200
 201 compressionlist = ['auto', 'gzip', 'bzip2', 'zstd', 'xz', 'lz4', 'lzo', 'lzma'];
 202 outextlist = ['gz', 'bz2', 'zst', 'xz', 'lz4', 'lzo', 'lzma'];
 203 outextlistwd = ['.gz', '.bz2', '.zst', '.xz', '.lz4', '.lzo', '.lzma'];
 204
 205 tarfile_mimetype = "application/tar";
 206 tarfile_tar_mimetype = tarfile_mimetype;
 207 zipfile_mimetype = "application/zip";
 208 zipfile_zip_mimetype = zipfile_mimetype;
 209 rarfile_mimetype = "application/rar";
 210 rarfile_rar_mimetype = rarfile_mimetype;
 211 archivefile_mimetype = "application/x-"+__file_format_list__[1]+"";
 212 archivefile_cat_mimetype = archivefile_mimetype;
 213 archivefile_gzip_mimetype = "application/x-"+__file_format_list__[1]+"+gzip";
 214 archivefile_gz_mimetype = archivefile_gzip_mimetype;
 215 archivefile_bzip2_mimetype = "application/x-"+__file_format_list__[1]+"+bzip2";
 216 archivefile_bz2_mimetype = archivefile_bzip2_mimetype;
 217 archivefile_lz4_mimetype = "application/x-"+__file_format_list__[1]+"+lz4";
 218 archivefile_lzop_mimetype = "application/x-"+__file_format_list__[1]+"+lzop";
 219 archivefile_lzo_mimetype = archivefile_lzop_mimetype;
 220 archivefile_zstandard_mimetype = "application/x-"+__file_format_list__[1]+"+zstandard";
 221 archivefile_zstd_mimetype = archivefile_zstandard_mimetype;
 222 archivefile_lzma_mimetype = "application/x-"+__file_format_list__[1]+"+lzma";
 223 archivefile_xz_mimetype = "application/x-"+__file_format_list__[1]+"+xz";
 224 archivefile_extensions = ['.cat', '.cat.gz', '.cat.bz2', '.cat.zst', '.cat.lz4', '.cat.lzo', '.cat.lzop', '.cat.lzma', '.cat.xz'];
 225
 226 if __name__ == "__main__":
 227  import subprocess;
 228  curscrpath = os.path.dirname(sys.argv[0]);
 229  if(curscrpath==""):
 230   curscrpath = ".";
 231  if(os.sep=="\\"):
 232   curscrpath = curscrpath.replace(os.sep, "/");
 233  curscrpath = curscrpath + "/";
 234  scrfile = curscrpath + "catfile.py";
 235  if(os.path.exists(scrfile) and os.path.isfile(scrfile)):
 236   scrcmd = subprocess.Popen([sys.executable, scrfile] + sys.argv[1:]);
 237   scrcmd.wait();
 238
 239 def VerbosePrintOut(dbgtxt, outtype="log", dbgenable=True, dgblevel=20):
 240  if(not dbgenable):
 241   return True;
 242  log_functions = {
 243   "print": print,
 244   "log": logging.info,
 245   "warning": logging.warning,
 246   "error": logging.error,
 247   "critical": logging.critical,
 248   "exception": logging.exception,
 249   "logalt": lambda x: logging.log(dgblevel, x),
 250   "debug": logging.debug
 251  };
 252  log_function = log_functions.get(outtype);
 253  if(log_function):
 254   log_function(dbgtxt);
 255   return True;
 256  return False;
 257
 258 def VerbosePrintOutReturn(dbgtxt, outtype="log", dbgenable=True, dgblevel=20):
 259  VerbosePrintOut(dbgtxt, outtype, dbgenable, dgblevel);
 260  return dbgtxt;
 261
 262 def RemoveWindowsPath(dpath):
 263  if(dpath is None):
 264   dpath = "";
 265  if(os.sep!="/"):
 266   dpath = dpath.replace(os.path.sep, "/");
 267  dpath = dpath.rstrip("/");
 268  if(dpath=="." or dpath==".."):
 269   dpath = dpath + "/";
 270  return dpath;
 271
 272 def NormalizeRelativePath(inpath):
 273  inpath = RemoveWindowsPath(inpath);
 274  if(os.path.isabs(inpath)):
 275   outpath = inpath;
 276  else:
 277   if(inpath.startswith("./") or inpath.startswith("../")):
 278    outpath = inpath;
 279   else:
 280    outpath = "./" + inpath;
 281  return outpath;
 282
 283 def ListDir(dirpath, followlink=False, duplicates=False):
 284  if(isinstance(dirpath, (list, tuple, ))):
 285   dirpath = list(filter(None, dirpath));
 286  elif(isinstance(dirpath, (str, ))):
 287   dirpath = list(filter(None, [dirpath]));
 288  retlist = [];
 289  for mydirfile in dirpath:
 290   if(not os.path.exists(mydirfile)):
 291    return False;
 292   mydirfile = NormalizeRelativePath(mydirfile);
 293   if(os.path.exists(mydirfile) and os.path.islink(mydirfile)):
 294    mydirfile = RemoveWindowsPath(os.path.realpath(mydirfile));
 295   if(os.path.exists(mydirfile) and os.path.isdir(mydirfile)):
 296    for root, dirs, filenames in os.walk(mydirfile):
 297     dpath = root;
 298     dpath = RemoveWindowsPath(dpath);
 299     if(dpath not in retlist and not duplicates):
 300      retlist.append(dpath);
 301     if(duplicates):
 302      retlist.append(dpath);
 303     for file in filenames:
 304      fpath = os.path.join(root, file);
 305      fpath = RemoveWindowsPath(fpath);
 306      if(fpath not in retlist and not duplicates):
 307       retlist.append(fpath);
 308      if(duplicates):
 309       retlist.append(fpath);
 310   else:
 311    retlist.append(RemoveWindowsPath(mydirfile));
 312  return retlist;
 313
 314 def ListDirAdvanced(dirpath, followlink=False, duplicates=False):
 315  if isinstance(dirpath, (list, tuple)):
 316   dirpath = list(filter(None, dirpath));
 317  elif isinstance(dirpath, str):
 318   dirpath = list(filter(None, [dirpath]));
 319  retlist = []
 320  for mydirfile in dirpath:
 321   if not os.path.exists(mydirfile):
 322    return False;
 323   mydirfile = NormalizeRelativePath(mydirfile);
 324   if os.path.exists(mydirfile) and os.path.islink(mydirfile) and followlink:
 325    mydirfile = RemoveWindowsPath(os.path.realpath(mydirfile))
 326   if os.path.exists(mydirfile) and os.path.isdir(mydirfile):
 327    for root, dirs, filenames in os.walk(mydirfile):
 328     # Sort dirs and filenames alphabetically in place
 329     dirs.sort(key=lambda x: x.lower());
 330     filenames.sort(key=lambda x: x.lower());
 331     dpath = RemoveWindowsPath(root);
 332     if not duplicates and dpath not in retlist:
 333      retlist.append(dpath);
 334     elif duplicates:
 335      retlist.append(dpath);
 336     for file in filenames:
 337      fpath = os.path.join(root, file);
 338      fpath = RemoveWindowsPath(fpath);
 339      if not duplicates and fpath not in retlist:
 340       retlist.append(fpath);
 341      elif duplicates:
 342       retlist.append(fpath);
 343   else:
 344    retlist.append(RemoveWindowsPath(mydirfile));
 345  return retlist;
 346
 347 def create_alias_function(prefix, base_name, suffix, target_function):
 348  # Define a new function that wraps the target function
 349  def alias_function(*args, **kwargs):
 350   return target_function(*args, **kwargs);
 351
 352  # Create the function name by combining the prefix, base name, and the suffix
 353  function_name = "{}{}{}".format(prefix, base_name, suffix);
 354
 355  # Add the new function to the global namespace
 356  globals()[function_name] = alias_function;
 357
 358 # initial_value can be 0xFFFF or 0x0000
 359 def crc16_ansi(msg, initial_value=0xFFFF):
 360  # CRC-16-IBM / CRC-16-ANSI polynomial and initial value
 361  poly = 0x8005;  # Polynomial for CRC-16-IBM / CRC-16-ANSI
 362  crc = initial_value;  # Initial value
 363  for b in msg:
 364   crc ^= b << 8;  # XOR byte into CRC top byte
 365   for _ in range(8):  # Process each bit
 366    if crc & 0x8000:  # If the top bit is set
 367     crc = (crc << 1) ^ poly;  # Shift left and XOR with the polynomial
 368    else:
 369     crc = crc << 1;  # Just shift left
 370    crc &= 0xFFFF;  # Ensure CRC remains 16-bit
 371  return crc;
 372
 373 # initial_value can be 0xFFFF or 0x0000
 374 def crc16_ibm(msg, initial_value=0xFFFF):
 375  return crc16_ansi(msg, initial_value);
 376
 377 # initial_value is 0xFFFF
 378 def crc16(msg):
 379  return crc16_ansi(msg, 0xFFFF);
 380
 381 # initial_value can be 0xFFFF, 0x1D0F or 0x0000
 382 def crc16_ccitt(msg, initial_value=0xFFFF):
 383  # CRC-16-CCITT polynomial
 384  poly = 0x1021;  # Polynomial for CRC-16-CCITT
 385  # Use the specified initial value
 386  crc = initial_value;
 387  for b in msg:
 388   crc ^= b << 8;  # XOR byte into CRC top byte
 389   for _ in range(8):  # Process each bit
 390    if crc & 0x8000:  # If the top bit is set
 391     crc = (crc << 1) ^ poly;  # Shift left and XOR with the polynomial
 392    else:
 393     crc = crc << 1;  # Just shift left
 394    crc &= 0xFFFF;  # Ensure CRC remains 16-bit
 395  return crc;
 396
 397 # initial_value can be 0x42F0E1EBA9EA3693 or 0x0000000000000000
 398 def crc64_ecma(msg, initial_value=0x0000000000000000):
 399  # CRC-64-ECMA polynomial and initial value
 400  poly = 0x42F0E1EBA9EA3693;
 401  crc = initial_value;  # Initial value for CRC-64-ECMA
 402  for b in msg:
 403   crc ^= b << 56;  # XOR byte into the most significant byte of the CRC
 404   for _ in range(8):  # Process each bit
 405    if crc & (1 << 63):  # Check if the leftmost (most significant) bit is set
 406     crc = (crc << 1) ^ poly;  # Shift left and XOR with poly if the MSB is 1
 407    else:
 408     crc <<= 1;  # Just shift left if the MSB is 0
 409    crc &= 0xFFFFFFFFFFFFFFFF;  # Ensure CRC remains 64-bit
 410  return crc;
 411
 412 # initial_value can be 0x000000000000001B or 0xFFFFFFFFFFFFFFFF
 413 def crc64_iso(msg, initial_value=0xFFFFFFFFFFFFFFFF):
 414  # CRC-64-ISO polynomial and initial value
 415  poly = 0x000000000000001B;
 416  crc = initial_value;  # Common initial value for CRC-64-ISO
 417  for b in msg:
 418   crc ^= b << 56;  # XOR byte into the most significant byte of the CRC
 419   for _ in range(8):  # Process each bit
 420    if crc & (1 << 63):  # Check if the leftmost (most significant) bit is set
 421     crc = (crc << 1) ^ poly;  # Shift left and XOR with poly if the MSB is 1
 422    else:
 423     crc <<= 1;  # Just shift left if the MSB is 0
 424    crc &= 0xFFFFFFFFFFFFFFFF;  # Ensure CRC remains 64-bit
 425  return crc;
 426
 427 def GetDataFromArray(data, path, default=None):
 428  element = data;
 429  try:
 430   for key in path:
 431    element = element[key];
 432   return element;
 433  except (KeyError, TypeError, IndexError):
 434   return default;
 435
 436 def GetDataFromArrayAlt(structure, path, default=None):
 437  element = structure;
 438  for key in path:
 439   if isinstance(element, dict) and key in element:
 440    element = element[key];
 441   elif isinstance(element, list) and isinstance(key, int) and -len(element) <= key < len(element):
 442    element = element[key];
 443   else:
 444    return default;
 445  return element;
 446
 447 def ReadTillNullByte(fp, delimiter=__file_format_delimiter__):
 448  curbyte = b"";
 449  curfullbyte = b"";
 450  nullbyte = delimiter.encode("UTF-8");
 451  while(True):
 452   curbyte = fp.read(1);
 453   if(curbyte==nullbyte or not curbyte):
 454    break;
 455   curfullbyte = curfullbyte + curbyte;
 456  return curfullbyte.decode('UTF-8');
 457
 458 def ReadUntilNullByte(fp, delimiter=__file_format_delimiter__):
 459  return ReadTillNullByte(fp, delimiter);
 460
 461 def SeekToEndOfFile(fp):
 462  lasttell = 0;
 463  while(True):
 464   fp.seek(1, 1);
 465   if(lasttell==fp.tell()):
 466    break;
 467   lasttell = fp.tell();
 468  return True;
 469
 470 def ReadFileHeaderData(fp, rounds=0, delimiter=__file_format_delimiter__):
 471  rocount = 0;
 472  roend = int(rounds);
 473  HeaderOut = [];
 474  while(rocount<roend):
 475   HeaderOut.append(ReadTillNullByte(fp, delimiter));
 476   rocount = rocount + 1;
 477  return HeaderOut;
 478
 479 def ReadFileHeaderDataBySize(fp, delimiter=__file_format_delimiter__):
 480  headerpresize = ReadTillNullByte(fp, delimiter);
 481  headersize = int(headerpresize, 16);
 482  headercontent = str(fp.read(headersize).decode('UTF-8')).split(delimiter);
 483  fp.seek(1, 1);
 484  rocount = 0;
 485  roend = int(len(headercontent));
 486  HeaderOut = [headerpresize];
 487  while(rocount<roend):
 488   HeaderOut.append(headercontent[rocount]);
 489   rocount = rocount + 1;
 490  return HeaderOut;
 491
 492 def ReadFileHeaderDataByList(fp, listval=[], delimiter=__file_format_delimiter__):
 493  rocount = 0;
 494  roend = int(len(listval));
 495  HeaderOut = {};
 496  while(rocount<roend):
 497   RoundArray = {listval[rocount]: ReadTillNullByte(fp, delimiter)};
 498   HeaderOut.update(RoundArray);
 499   rocount = rocount + 1;
 500  return HeaderOut;
 501
 502 def ReadFileHeaderDataByListSize(fp, listval=[], delimiter=__file_format_delimiter__):
 503  headerpresize = ReadTillNullByte(fp, delimiter);
 504  headersize = int(headerpresize, 16);
 505  headercontent = str(fp.read(headersize).decode('UTF-8')).split(delimiter);
 506  fp.seek(1, 1);
 507  rocount = 0;
 508  listcount = 1;
 509  roend = int(len(headercontent));
 510  HeaderOut = {listval[0]: headerpresize};
 511  while(rocount<roend):
 512   RoundArray = {listval[rocount]: headercontent[rocount]};
 513   HeaderOut.update(RoundArray);
 514   rocount = rocount + 1;
 515   listcount = listcount + 1;
 516  return HeaderOut;
 517
 518 def AppendNullByte(indata, delimiter=__file_format_delimiter__):
 519  outdata = str(indata) + delimiter;
 520  return outdata;
 521
 522 def AppendNullBytes(indata=[], delimiter=__file_format_delimiter__):
 523  outdata = "";
 524  inum = 0;
 525  il = len(indata);
 526  while(inum < il):
 527   outdata = outdata + AppendNullByte(indata[inum], delimiter);
 528   inum = inum + 1;
 529  return outdata;
 530
 531 def ReadTillNullByteAlt(fp, delimiter=__file_format_delimiter__):
 532  """Read bytes from file pointer until a null byte is encountered."""
 533  bytes_list = []  # Use list for efficient append operation.
 534  while True:
 535   cur_byte = fp.read(1);
 536   if cur_byte == delimiter.encode() or not cur_byte:
 537    break;
 538   bytes_list.append(cur_byte);
 539  return b''.join(bytes_list).decode('UTF-8');
 540
 541 def ReadUntilNullByteAlt(fp, delimiter=__file_format_delimiter__):
 542  return ReadTillNullByteAlt(fp, delimiter);
 543
 544 def ReadFileHeaderDataAlt(fp, rounds=0, delimiter=__file_format_delimiter__):
 545  """Read multiple null-byte terminated strings from a file."""
 546  header_out = [];
 547  for round_count in range(rounds):
 548   header_out[round_count] = ReadTillNullByteAlt(fp, delimiter);
 549  return header_out;
 550
 551 def ReadFileHeaderDataBySizeAlt(fp, delimiter=__file_format_delimiter__):
 552  # Read and convert header size from hexadecimal to integer
 553  header_pre_size = ReadTillNullByte(fp, delimiter);
 554  header_size = int(header_pre_size, 16);
 555  # Read and split the header content
 556  header_content = str(fp.read(header_size).decode('UTF-8')).split(delimiter);
 557  fp.seek(1, 1);
 558  # Prepend the pre-size and return the combined list
 559  return [header_pre_size] + header_content;
 560
 561 def ReadFileHeaderDataByListSizeAlt(fp, listval=[], delimiter=__file_format_delimiter__):
 562  # Read the size and content from the header
 563  header_pre_size = ReadTillNullByte(fp, delimiter);
 564  header_size = int(header_pre_size, 16);
 565  header_content = str(fp.read(header_size).decode('UTF-8')).split(delimiter);
 566  fp.seek(1, 1);
 567  # Initialize HeaderOut with the header pre-size if listval is not empty
 568  HeaderOut = {listval[0]: header_pre_size} if listval else {};
 569  # Map the remaining listval items to their corresponding header content, starting from the second item
 570  for i in range(1, min(len(header_content) + 1, len(listval))):
 571   HeaderOut[listval[i]] = header_content[i - 1];  # -1 because header_content is 0-indexed
 572  return HeaderOut;
 573
 574 def ReadFileHeaderDataByListAlt(fp, listval=[], delimiter=__file_format_delimiter__):
 575  """Read multiple null-byte terminated strings from a file."""
 576  header_out = {};
 577  for round_count in listval:
 578   header_out.append(ReadTillNullByteAlt(fp, delimiter));
 579  return header_out;
 580
 581 def AppendNullByteAlt(indata, delimiter=__file_format_delimiter__):
 582  """Append a null byte to the given data."""
 583  return str(indata) + delimiter;
 584
 585 def AppendNullBytesAlt(indata=[], delimiter=__file_format_delimiter__):
 586  """Append a null byte to each element in the list and concatenate."""
 587  return delimiter.join(map(str, indata)) + delimiter;  # Efficient concatenation with null byte.
 588
 589 def PrintPermissionString(fchmode, ftype):
 590  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' } };
 591  permissionstr = "";
 592  for fmodval in str(oct(fchmode))[-3:]:
 593   permissionstr = permissionstr + permissions['access'].get(fmodval, '---');
 594  if(ftype==0 or ftype==7):
 595   permissionstr = "-" + permissionstr;
 596  if(ftype==1):
 597   permissionstr = "h" + permissionstr;
 598  if(ftype==2):
 599   permissionstr = "l" + permissionstr;
 600  if(ftype==3):
 601   permissionstr = "c" + permissionstr;
 602  if(ftype==4):
 603   permissionstr = "b" + permissionstr;
 604  if(ftype==5):
 605   permissionstr = "d" + permissionstr;
 606  if(ftype==6):
 607   permissionstr = "f" + permissionstr;
 608  if(ftype==8):
 609   permissionstr = "D" + permissionstr;
 610  if(ftype==9):
 611   permissionstr = "p" + permissionstr;
 612  if(ftype==10):
 613   permissionstr = "w" + permissionstr;
 614  try:
 615   permissionoutstr = stat.filemode(fchmode);
 616  except AttributeError:
 617   permissionoutstr = permissionstr;
 618  except KeyError:
 619   permissionoutstr = permissionstr;
 620  return permissionoutstr;
 621
 622 def PrintPermissionStringAlt(fchmode, ftype):
 623  permissions = {
 624   '0': '---', '1': '--x', '2': '-w-', '3': '-wx',
 625   '4': 'r--', '5': 'r-x', '6': 'rw-', '7': 'rwx'
 626  };
 627  # Translate file mode into permission string
 628  permissionstr = ''.join([permissions[i] for i in str(oct(fchmode))[-3:]]);
 629  # Append file type indicator
 630  type_indicators = {
 631   0: '-', 1: 'h', 2: 'l', 3: 'c', 4: 'b',
 632   5: 'd', 6: 'f', 8: 'D', 9: 'p', 10: 'w'
 633  };
 634  file_type = type_indicators.get(ftype, '-');
 635  permissionstr = file_type + permissionstr;
 636  try:
 637   permissionoutstr = stat.filemode(fchmode);
 638  except AttributeError:
 639   permissionoutstr = permissionstr;
 640  return permissionoutstr;
 641
 642 def CompressionSupport():
 643  compression_list = [];
 644  try:
 645   import gzip;
 646   compression_list.append("gz");
 647   compression_list.append("gzip");
 648  except ImportError:
 649   '''return False;'''
 650  try:
 651   import bz2;
 652   compression_list.append("bz2");
 653   compression_list.append("bzip2");
 654  except ImportError:
 655   '''return False;'''
 656  try:
 657   import lz4;
 658   compression_list.append("lz4");
 659  except ImportError:
 660   '''return False;'''
 661  try:
 662   import lzo;
 663   compression_list.append("lzo");
 664   compression_list.append("lzop");
 665  except ImportError:
 666   '''return False;'''
 667  try:
 668   import zstandard;
 669   compression_list.append("zstd");
 670   compression_list.append("zstandard");
 671  except ImportError:
 672   '''return False;'''
 673  try:
 674   import lzma;
 675   compression_list.append("lzma");
 676   compression_list.append("xz");
 677  except ImportError:
 678   '''return False;'''
 679  return compression_list;
 680
 681 def CheckCompressionType(infile, formatspecs=__file_format_list__, closefp=True):
 682  if(hasattr(infile, "read") or hasattr(infile, "write")):
 683   catfp = infile;
 684  else:
 685   try:
 686    catfp = open(infile, "rb");
 687   except FileNotFoundError:
 688    return False;
 689  catfp.seek(0, 0);
 690  prefp = catfp.read(2);
 691  filetype = False;
 692  if(prefp==binascii.unhexlify("1f8b")):
 693   filetype = "gzip";
 694  catfp.seek(0, 0);
 695  prefp = catfp.read(3);
 696  if(prefp==binascii.unhexlify("425a68")):
 697   filetype = "bzip2";
 698  if(prefp==binascii.unhexlify("5d0000")):
 699   filetype = "lzma";
 700  catfp.seek(0, 0);
 701  prefp = catfp.read(4);
 702  if(prefp==binascii.unhexlify("28b52ffd")):
 703   filetype = "zstd";
 704  if(prefp==binascii.unhexlify("04224d18")):
 705   filetype = "lz4";
 706  if(prefp==binascii.unhexlify("504B0304")):
 707   filetype = "zipfile";
 708  catfp.seek(0, 0);
 709  prefp = catfp.read(5);
 710  if(prefp==binascii.unhexlify("7573746172")):
 711   filetype = "tarfile";
 712  catfp.seek(0, 0);
 713  prefp = catfp.read(6);
 714  if(prefp==binascii.unhexlify("fd377a585a00")):
 715   filetype = "lzma";
 716  catfp.seek(0, 0);
 717  prefp = catfp.read(7);
 718  if(prefp==binascii.unhexlify("526172211a0700")):
 719   filetype = "rarfile";
 720  if(prefp==binascii.unhexlify("43617446696c65")):
 721   filetype = "catfile";
 722  catfp.seek(0, 0);
 723  prefp = catfp.read(8);
 724  if(prefp==binascii.unhexlify("526172211a070100")):
 725   filetype = "rarfile";
 726  catfp.seek(0, 0);
 727  prefp = catfp.read(formatspecs[3]);
 728  if(prefp==binascii.unhexlify(formatspecs[4])):
 729   filetype = formatspecs[2];
 730  catfp.seek(0, 0);
 731  prefp = catfp.read(9);
 732  if(prefp==binascii.unhexlify("894c5a4f000d0a1a0a")):
 733   filetype = "lzo";
 734  catfp.seek(0, 0);
 735  prefp = catfp.read(10);
 736  if(prefp==binascii.unhexlify("7061785f676c6f62616c")):
 737   filetype = "tarfile";
 738  catfp.seek(0, 0);
 739  if(closefp):
 740   catfp.close();
 741  return filetype;
 742
 743 def CheckCompressionTypeFromString(instring, formatspecs=__file_format_list__, closefp=True):
 744  try:
 745   instringsfile = BytesIO(instring);
 746  except TypeError:
 747   instringsfile = BytesIO(instring.encode("UTF-8"));
 748  return CheckCompressionType(instringsfile, formatspecs, closefp);
 749
 750 def GetCompressionMimeType(infile, formatspecs=__file_format_list__):
 751  compresscheck = CheckCompressionType(fp, formatspecs, False);
 752  if(compresscheck=="gzip" or compresscheck=="gz"):
 753   return archivefile_gzip_mimetype;
 754  if(compresscheck=="bzip2" or compresscheck=="bz2"):
 755   return archivefile_bzip2_mimetype;
 756  if(compresscheck=="zstd" or compresscheck=="zstandard"):
 757   return archivefile_zstandard_mimetype;
 758  if(compresscheck=="lz4"):
 759   return archivefile_lz4_mimetype;
 760  if(compresscheck=="lzo" or compresscheck=="lzop"):
 761   return archivefile_lzop_mimetype;
 762  if(compresscheck=="lzma"):
 763   return archivefile_lzma_mimetype;
 764  if(compresscheck=="xz"):
 765   return archivefile_xz_mimetype;
 766  if(compresscheck=="catfile" or compresscheck=="cat" or compresscheck==formatspecs[2]):
 767   return archivefile_cat_mimetype;
 768  if(not compresscheck):
 769   return False;
 770  return False;
 771
 772 def UncompressArchiveFile(fp, formatspecs=__file_format_list__):
 773  if(not hasattr(fp, "read") and not hasattr(fp, "write")):
 774   return False;
 775  compresscheck = CheckCompressionType(fp, formatspecs, False);
 776  if(compresscheck=="gzip"):
 777   try:
 778    import gzip;
 779   except ImportError:
 780    return False;
 781   catfp = gzip.GzipFile(fileobj=fp, mode="rb");
 782  if(compresscheck=="bzip2"):
 783   try:
 784    import bz2;
 785   except ImportError:
 786    return False;
 787   catfp = BytesIO();
 788   catfp.write(bz2.decompress(fp.read()));
 789  if(compresscheck=="zstd"):
 790   try:
 791    import zstandard;
 792   except ImportError:
 793    return False;
 794   catfp = BytesIO();
 795   catfp.write(zstandard.decompress(fp.read()));
 796  if(compresscheck=="lz4"):
 797   try:
 798    import lz4.frame;
 799   except ImportError:
 800    return False;
 801   catfp = BytesIO();
 802   catfp.write(lz4.frame.decompress(fp.read()));
 803  if(compresscheck=="lzo" or compresscheck=="lzop"):
 804   try:
 805    import lzo;
 806   except ImportError:
 807    return False;
 808   catfp = BytesIO();
 809   catfp.write(lzo.decompress(fp.read()));
 810  if(compresscheck=="lzma" or compresscheck=="xz"):
 811   try:
 812    import lzma;
 813   except ImportError:
 814    return False;
 815   catfp = BytesIO();
 816   catfp.write(lzma.decompress(fp.read()));
 817  if(compresscheck=="catfile" or compresscheck==formatspecs[2]):
 818   catfp = fp;
 819  if(not compresscheck):
 820   try:
 821    import lzma;
 822   except ImportError:
 823    return False;
 824   catfp = BytesIO();
 825   with fp as fpcontent:
 826    try:
 827     catfp.write(lzma.decompress(fp.read()));
 828    except lzma.LZMAError:
 829     return False;
 830  return catfp;
 831
 832 create_alias_function("Uncompress", __file_format_name__, "", UncompressArchiveFile);
 833
 834 def UncompressFile(infile, formatspecs=__file_format_list__, mode="rb"):
 835  compresscheck = CheckCompressionType(infile, formatspecs, False);
 836  if(sys.version_info[0]==2 and compresscheck):
 837   if(mode=="rt"):
 838    mode = "r";
 839   if(mode=="wt"):
 840    mode = "w";
 841  try:
 842   if(compresscheck=="gzip"):
 843    try:
 844     import gzip;
 845    except ImportError:
 846     return False;
 847    try:
 848     filefp = gzip.open(infile, mode, encoding="UTF-8");
 849    except (ValueError, TypeError) as e:
 850     filefp = gzip.open(infile, mode);
 851   if(compresscheck=="bzip2"):
 852    try:
 853     import bz2;
 854    except ImportError:
 855     return False;
 856    try:
 857     filefp = bz2.open(infile, mode, encoding="UTF-8");
 858    except (ValueError, TypeError) as e:
 859     filefp = bz2.open(infile, mode);
 860   if(compresscheck=="zstd"):
 861    try:
 862     import zstandard;
 863    except ImportError:
 864     return False;
 865    try:
 866     filefp = zstandard.open(infile, mode, encoding="UTF-8");
 867    except (ValueError, TypeError) as e:
 868     filefp = zstandard.open(infile, mode);
 869   if(compresscheck=="lz4"):
 870    try:
 871     import lz4.frame;
 872    except ImportError:
 873     return False;
 874    try:
 875     filefp = lz4.frame.open(infile, mode, encoding="UTF-8");
 876    except (ValueError, TypeError) as e:
 877     filefp = lz4.frame.open(infile, mode);
 878   if(compresscheck=="lzo"):
 879    try:
 880     import lzo;
 881    except ImportError:
 882     return False;
 883    try:
 884     filefp = lzo.open(infile, mode, encoding="UTF-8");
 885    except (ValueError, TypeError) as e:
 886     filefp = lzo.open(infile, mode);
 887   if(compresscheck=="lzma"):
 888    try:
 889     import lzma;
 890    except ImportError:
 891     return False;
 892    try:
 893     filefp = lzma.open(infile, mode, encoding="UTF-8");
 894    except (ValueError, TypeError) as e:
 895     filefp = lzma.open(infile, mode);
 896   if(compresscheck=="catfile" or compresscheck==formatspecs[2]):
 897    try:
 898     filefp = open(infile, mode, encoding="UTF-8");
 899    except (ValueError, TypeError) as e:
 900     filefp = open(infile, mode);
 901   if(not compresscheck):
 902    try:
 903     filefp = open(infile, mode, encoding="UTF-8");
 904    except (ValueError, TypeError) as e:
 905     filefp = open(infile, mode);
 906  except FileNotFoundError:
 907   return False;
 908  return filefp;
 909
 910 def UncompressString(infile):
 911  compresscheck = CheckCompressionTypeFromString(infile, formatspecs, False);
 912  if(compresscheck=="gzip"):
 913   try:
 914    import gzip;
 915   except ImportError:
 916    return False;
 917   fileuz = gzip.decompress(infile);
 918  if(compresscheck=="bzip2"):
 919   try:
 920    import bz2;
 921   except ImportError:
 922    return False;
 923   fileuz = bz2.decompress(infile);
 924  if(compresscheck=="zstd"):
 925   try:
 926    import zstandard;
 927   except ImportError:
 928    return False;
 929   fileuz = zstandard.decompress(infile);
 930  if(compresscheck=="lz4"):
 931   try:
 932    import lz4.frame;
 933   except ImportError:
 934    return False;
 935   fileuz = lz4.frame.decompress(infile);
 936  if(compresscheck=="lzo"):
 937   try:
 938    import lzo;
 939   except ImportError:
 940    return False;
 941   fileuz = lzo.decompress(infile);
 942  if(compresscheck=="lzma"):
 943   try:
 944    import lzma;
 945   except ImportError:
 946    return False;
 947   fileuz = lzma.decompress(infile);
 948  if(not compresscheck):
 949   fileuz = infile;
 950  if(hasattr(fileuz, 'decode')):
 951   fileuz = fileuz.decode("UTF-8");
 952  return fileuz;
 953
 954 def UncompressStringAlt(infile):
 955  filefp = StringIO();
 956  outstring = UncompressString(infile);
 957  filefp.write(outstring);
 958  filefp.seek(0);
 959  return filefp;
 960
 961 def CheckCompressionSubType(infile, formatspecs=__file_format_list__):
 962  compresscheck = CheckCompressionType(infile, formatspecs, False);
 963  if(not compresscheck):
 964   fextname = os.path.splitext(infile)[1];
 965   if(fextname==".gz"):
 966    compresscheck = "gzip";
 967   if(fextname==".bz2"):
 968    compresscheck = "bzip2";
 969   if(fextname==".zst"):
 970    compresscheck = "zstd";
 971   if(fextname==".lz4"):
 972    compresscheck = "lz4";
 973   if(fextname==".lzo" or fextname==".lzop"):
 974    compresscheck = "lzo";
 975   if(fextname==".lzma" or fextname==".xz"):
 976    compresscheck = "lzma";
 977  if(not compresscheck):
 978   return False;
 979  if(compresscheck=="catfile"):
 980   return "catfile";
 981  if(compresscheck==formatspecs[2]):
 982   return formatspecs[2];
 983  if(compresscheck=="tarfile"):
 984   return "tarfile";
 985  if(compresscheck=="zipfile"):
 986   return "zipfile";
 987  if(hasattr(infile, "read") or hasattr(infile, "write")):
 988   catfp = UncompressArchiveFile(infile, formatspecs[2]);
 989  else:
 990   try:
 991    if(compresscheck=="gzip"):
 992     try:
 993      import gzip;
 994     except ImportError:
 995      return False;
 996     catfp = gzip.GzipFile(infile, "rb");
 997    if(compresscheck=="bzip2"):
 998     try:
 999      import bz2;
1000     except ImportError:
1001      return False;
1002     catfp = bz2.BZ2File(infile, "rb");
1003    if(compresscheck=="lz4"):
1004     try:
1005      import lz4.frame;
1006     except ImportError:
1007      return False;
1008     catfp = lz4.frame.open(infile, "rb");
1009    if(compresscheck=="zstd"):
1010     try:
1011      import zstandard;
1012     except ImportError:
1013      return False;
1014     catfp = zstandard.open(infile, "rb");
1015    if(compresscheck=="lzma" or compresscheck=="xz"):
1016     try:
1017      import lzma;
1018     except ImportError:
1019      return False;
1020     catfp = lzma.open(infile, "rb");
1021   except FileNotFoundError:
1022    return False;
1023  filetype = False;
1024  prefp = catfp.read(5);
1025  if(prefp==binascii.unhexlify("7573746172")):
1026   filetype = "tarfile";
1027  catfp.seek(0, 0);
1028  prefp = catfp.read(7);
1029  if(prefp==binascii.unhexlify("43617446696c65")):
1030   filetype = "catfile";
1031  catfp.seek(0, 0);
1032  prefp = catfp.read(formatspecs[3]);
1033  if(prefp==binascii.unhexlify(formatspecs[4])):
1034   filetype = formatspecs[2];
1035  catfp.seek(0, 0);
1036  prefp = catfp.read(10);
1037  if(prefp==binascii.unhexlify("7061785f676c6f62616c")):
1038   filetype = "tarfile";
1039  catfp.seek(0, 0);
1040  catfp.close();
1041  return filetype;
1042
1043 def GZipCompress(data, compresslevel=9):
1044  try:
1045   import gzip;
1046  except ImportError:
1047   return False;
1048  tmpfp = tempfile.NamedTemporaryFile("wb", delete=False);
1049  tmpfp.close();
1050  tmpfp = gzip.GzipFile(tmpfp.name, mode="wb", compresslevel=compresslevel);
1051  tmpfp.write(data);
1052  tmpfp.close();
1053  try:
1054   catfp = open(tmpfp.name, "rb");
1055  except FileNotFoundError:
1056   return False;
1057  catdata = catfp.read();
1058  catfp.close();
1059  return catdata;
1060
1061 def CompressArchiveFile(fp, compression="auto", compressionlevel=None, formatspecs=__file_format_list__):
1062  compressionlist = ['auto', 'gzip', 'bzip2', 'zstd', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
1063  if(not hasattr(fp, "read") and not hasattr(fp, "write")):
1064   return False;
1065  fp.seek(0, 0);
1066  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
1067   compression = None;
1068  if(compression not in compressionlist and compression is None):
1069   compression = "auto";
1070  if(compression=="gzip"):
1071   try:
1072    import gzip;
1073   except ImportError:
1074    return False;
1075   catfp = BytesIO();
1076   if(compressionlevel is None):
1077    compressionlevel = 9;
1078   else:
1079    compressionlevel = int(compressionlevel);
1080   catfp.write(gzip.compress(fp.read(), compresslevel=compressionlevel));
1081  if(compression=="bzip2"):
1082   try:
1083    import bz2;
1084   except ImportError:
1085    return False;
1086   catfp = BytesIO();
1087   if(compressionlevel is None):
1088    compressionlevel = 9;
1089   else:
1090    compressionlevel = int(compressionlevel);
1091   catfp.write(bz2.compress(fp.read(), compresslevel=compressionlevel));
1092  if(compression=="lz4"):
1093   try:
1094    import lz4.frame;
1095   except ImportError:
1096    return False;
1097   catfp = BytesIO();
1098   if(compressionlevel is None):
1099    compressionlevel = 9;
1100   else:
1101    compressionlevel = int(compressionlevel);
1102   catfp.write(lz4.frame.compress(fp.read(), compression_level=compressionlevel));
1103  if(compression=="lzo" or compression=="lzop"):
1104   try:
1105    import lzo;
1106   except ImportError:
1107    return False;
1108   catfp = BytesIO();
1109   if(compressionlevel is None):
1110    compressionlevel = 9;
1111   else:
1112    compressionlevel = int(compressionlevel);
1113   catfp.write(lzo.compress(fp.read(), compresslevel=compressionlevel));
1114  if(compression=="zstd"):
1115   try:
1116    import zstandard;
1117   except ImportError:
1118    return False;
1119   catfp = BytesIO();
1120   if(compressionlevel is None):
1121    compressionlevel = 10;
1122   else:
1123    compressionlevel = int(compressionlevel);
1124   catfp.write(zstandard.compress(fp.read(), level=compressionlevel));
1125  if(compression=="lzma"):
1126   try:
1127    import lzma;
1128   except ImportError:
1129    return False;
1130   catfp = BytesIO();
1131   if(compressionlevel is None):
1132    compressionlevel = 9;
1133   else:
1134    compressionlevel = int(compressionlevel);
1135   catfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_ALONE, filters=[{"id": lzma.FILTER_LZMA1, "preset": compressionlevel}]));
1136  if(compression=="xz"):
1137   try:
1138    import lzma;
1139   except ImportError:
1140    return False;
1141   catfp = BytesIO();
1142   if(compressionlevel is None):
1143    compressionlevel = 9;
1144   else:
1145    compressionlevel = int(compressionlevel);
1146   catfp.write(lzma.compress(fp.read(), format=lzma.FORMAT_XZ, filters=[{"id": lzma.FILTER_LZMA2, "preset": compressionlevel}]));
1147  if(compression=="auto" or compression is None):
1148   catfp = fp;
1149  catfp.seek(0, 0);
1150  return catfp;
1151
1152 create_alias_function("Compress", __file_format_name__, "", CompressArchiveFile);
1153
1154 def CompressOpenFile(outfile, compressionlevel=None):
1155  if(outfile is None):
1156   return False;
1157  fbasename = os.path.splitext(outfile)[0];
1158  fextname = os.path.splitext(outfile)[1];
1159  if(compressionlevel is None and fextname!=".zst"):
1160   compressionlevel = 9;
1161  elif(compressionlevel is None and fextname==".zst"):
1162   compressionlevel = 10;
1163  else:
1164   compressionlevel = int(compressionlevel);
1165  if(sys.version_info[0]==2):
1166   mode = "w";
1167  else:
1168   mode = "wb";
1169  try:
1170   if(fextname not in outextlistwd):
1171    try:
1172     outfp = open(outfile, "wb", encoding="UTF-8");
1173    except (ValueError, TypeError) as e:
1174     outfp = open(outfile, "wb");
1175   elif(fextname==".gz"):
1176    try:
1177     import gzip;
1178    except ImportError:
1179     return False;
1180    try:
1181     outfp = gzip.open(outfile, mode, compressionlevel, encoding="UTF-8");
1182    except (ValueError, TypeError) as e:
1183     outfp = gzip.open(outfile, mode, compressionlevel);
1184   elif(fextname==".bz2"):
1185    try:
1186     import bz2;
1187    except ImportError:
1188     return False;
1189    try:
1190     outfp = bz2.open(outfile, mode, compressionlevel, encoding="UTF-8");
1191    except (ValueError, TypeError) as e:
1192     outfp = bz2.open(outfile, mode, compressionlevel);
1193   elif(fextname==".zst"):
1194    try:
1195     import zstandard;
1196    except ImportError:
1197     return False;
1198    try:
1199     outfp = zstandard.open(outfile, mode, zstandard.ZstdCompressor(level=compressionlevel), encoding="UTF-8");
1200    except (ValueError, TypeError) as e:
1201     outfp = zstandard.open(outfile, mode, zstandard.ZstdCompressor(level=compressionlevel));
1202   elif(fextname==".xz"):
1203    try:
1204     import lzma;
1205    except ImportError:
1206     return False;
1207    try:
1208     outfp = lzma.open(outfile, mode, format=lzma.FORMAT_XZ, filters=[{"id": lzma.FILTER_LZMA2, "preset": compressionlevel}], encoding="UTF-8");
1209    except (ValueError, TypeError) as e:
1210     outfp = lzma.open(outfile, mode, format=lzma.FORMAT_XZ, filters=[{"id": lzma.FILTER_LZMA2, "preset": compressionlevel}]);
1211   elif(fextname==".lz4"):
1212    try:
1213     import lz4.frame;
1214    except ImportError:
1215     return False;
1216    try:
1217     outfp = lz4.frame.open(outfile, mode, compression_level=compressionlevel, encoding="UTF-8");
1218    except (ValueError, TypeError) as e:
1219     outfp = lz4.frame.open(outfile, mode, compression_level=compressionlevel);
1220   elif(fextname==".lzo"):
1221    try:
1222     import lzo;
1223    except ImportError:
1224     return False;
1225    try:
1226     outfp = lzo.open(outfile, mode, compresslevel=compressionlevel, encoding="UTF-8");
1227    except (ValueError, TypeError) as e:
1228     outfp = lzo.open(outfile, mode, compresslevel=compressionlevel);
1229   elif(fextname==".lzma"):
1230    try:
1231     import lzma;
1232    except ImportError:
1233     return False;
1234    try:
1235     outfp = lzma.open(outfile, mode, format=lzma.FORMAT_ALONE, filters=[{"id": lzma.FILTER_LZMA1, "preset": compressionlevel}], encoding="UTF-8");
1236    except (ValueError, TypeError) as e:
1237     outfp = lzma.open(outfile, mode, format=lzma.FORMAT_ALONE, filters=[{"id": lzma.FILTER_LZMA1, "preset": compressionlevel}]);
1238  except FileNotFoundError:
1239   return False;
1240  return outfp;
1241
1242 def GetDevMajorMinor(fdev):
1243  retdev = [];
1244  if(hasattr(os, "minor")):
1245   retdev.append(os.minor(fdev));
1246  else:
1247   retdev.append(0);
1248  if(hasattr(os, "major")):
1249   retdev.append(os.major(fdev));
1250  else:
1251   retdev.append(0);
1252  return retdev;
1253
1254 def CheckSumSupport(checkfor, guaranteed=True):
1255  if(guaranteed):
1256   hash_list = sorted(list(hashlib.algorithms_guaranteed));
1257  else:
1258   hash_list = sorted(list(hashlib.algorithms_available));
1259  checklistout = sorted(hash_list + ['adler32', 'crc16', 'crc16_ansi', 'crc16_ibm', 'crc16_ccitt', 'crc32', 'crc64', 'crc64_ecma', 'crc64_iso', 'none']);
1260  if(checkfor in checklistout):
1261   return True;
1262  else:
1263   return False;
1264
1265 def CheckSumSupportAlt(checkfor, guaranteed=True):
1266  if(guaranteed):
1267   hash_list = sorted(list(hashlib.algorithms_guaranteed));
1268  else:
1269   hash_list = sorted(list(hashlib.algorithms_available));
1270  checklistout = hash_list;
1271  if(checkfor in checklistout):
1272   return True;
1273  else:
1274   return False;
1275
1276 def PackArchiveFile(infiles, outfile, dirlistfromtxt=False, compression="auto", compressionlevel=None, followlink=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
1277  compressionlist = ['auto', 'gzip', 'bzip2', 'zstd', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
1278  outextlist = ['gz', 'bz2', 'zst', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
1279  outextlistwd = ['.gz', '.bz2', '.zst', '.lz4', '.lzo', '.lzop', '.lzma', '.xz'];
1280  advancedlist = True;
1281  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
1282   outfile = RemoveWindowsPath(outfile);
1283  checksumtype = checksumtype.lower();
1284  if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
1285   checksumtype="crc32";
1286  if(checksumtype=="none"):
1287   checksumtype = "";
1288  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
1289   compression = None;
1290  if(compression not in compressionlist and compression is None):
1291   compression = "auto";
1292  if(verbose):
1293   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
1294  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
1295   if(os.path.exists(outfile)):
1296    os.unlink(outfile);
1297  if(outfile=="-"):
1298   verbose = False;
1299   catfp = BytesIO();
1300  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
1301   catfp = outfile;
1302  elif(re.findall(r"^(ftp|ftps)\:\/\/", outfile)):
1303   catfp = BytesIO();
1304  elif(re.findall(r"^(sftp)\:\/\/", outfile) and haveparamiko):
1305   catfp = BytesIO();
1306  else:
1307   fbasename = os.path.splitext(outfile)[0];
1308   fextname = os.path.splitext(outfile)[1];
1309   catfp = CompressOpenFile(outfile, compressionlevel);
1310  catver = formatspecs[6];
1311  fileheaderver = str(int(catver.replace(".", "")));
1312  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
1313  catfp.write(fileheader.encode('UTF-8'));
1314  infilelist = [];
1315  if(infiles=="-"):
1316   for line in sys.stdin:
1317    infilelist.append(line.strip());
1318   infilelist = list(filter(None, infilelist));
1319  elif(infiles!="-" and dirlistfromtxt and os.path.exists(infiles) and (os.path.isfile(infiles) or infiles=="/dev/null" or infiles=="NUL")):
1320   if(not os.path.exists(infiles) or not os.path.isfile(infiles)):
1321    return False;
1322   with open(infiles, "r") as finfile:
1323    for line in finfile:
1324     infilelist.append(line.strip());
1325   infilelist = list(filter(None, infilelist));
1326  else:
1327   if(isinstance(infiles, (list, tuple, ))):
1328    infilelist = list(filter(None, infiles));
1329   elif(isinstance(infiles, (str, ))):
1330    infilelist = list(filter(None, [infiles]));
1331  if(advancedlist):
1332   GetDirList = ListDirAdvanced(infilelist, followlink, False);
1333  else:
1334   GetDirList = ListDir(infilelist, followlink, False);
1335  if(not GetDirList):
1336   return False;
1337  curinode = 0;
1338  curfid = 0;
1339  inodelist = [];
1340  inodetofile = {};
1341  filetoinode = {};
1342  inodetocatinode = {};
1343  fnumfiles = format(int(len(GetDirList)), 'x').lower();
1344  fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
1345  if(checksumtype=="none" or checksumtype==""):
1346   catfileheadercshex = format(0, 'x').lower();
1347  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
1348   catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
1349  elif(checksumtype=="crc16_ccitt"):
1350   catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
1351  elif(checksumtype=="adler32"):
1352   catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
1353  elif(checksumtype=="crc32"):
1354   catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
1355  elif(checksumtype=="crc64_ecma"):
1356   catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1357  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
1358   catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1359  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
1360   checksumoutstr = hashlib.new(checksumtype);
1361   checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
1362   catfileheadercshex = checksumoutstr.hexdigest().lower();
1363  else:
1364   catfileheadercshex = format(0, 'x').lower
1365  fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
1366  catfp.write(fnumfilesa.encode('UTF-8'));
1367  try:
1368   catfp.flush();
1369   os.fsync(catfp.fileno());
1370  except io.UnsupportedOperation:
1371   pass;
1372  except AttributeError:
1373   pass;
1374  for curfname in GetDirList:
1375   catfhstart = catfp.tell();
1376   if(re.findall("^[.|/]", curfname)):
1377    fname = curfname;
1378   else:
1379    fname = "./"+curfname;
1380   if(verbose):
1381    VerbosePrintOut(fname);
1382   if(not followlink or followlink is None):
1383    fstatinfo = os.lstat(fname);
1384   else:
1385    fstatinfo = os.stat(fname);
1386   fpremode = fstatinfo.st_mode;
1387   finode = fstatinfo.st_ino;
1388   flinkcount = fstatinfo.st_nlink;
1389   ftype = 0;
1390   if(stat.S_ISREG(fpremode)):
1391    ftype = 0;
1392   elif(stat.S_ISLNK(fpremode)):
1393    ftype = 2;
1394   elif(stat.S_ISCHR(fpremode)):
1395    ftype = 3;
1396   elif(stat.S_ISBLK(fpremode)):
1397    ftype = 4;
1398   elif(stat.S_ISDIR(fpremode)):
1399    ftype = 5;
1400   elif(stat.S_ISFIFO(fpremode)):
1401    ftype = 6;
1402   elif(hasattr(stat, "S_ISDOOR") and stat.S_ISDOOR(fpremode)):
1403    ftype = 8;
1404   elif(hasattr(stat, "S_ISPORT") and stat.S_ISPORT(fpremode)):
1405    ftype = 9;
1406   elif(hasattr(stat, "S_ISWHT") and stat.S_ISWHT(fpremode)):
1407    ftype = 10;
1408   else:
1409    ftype = 0;
1410   flinkname = "";
1411   fcurfid = format(int(curfid), 'x').lower();
1412   if(not followlink and finode!=0):
1413    if(ftype!=1):
1414     if(finode in inodelist):
1415      ftype = 1;
1416      flinkname = inodetofile[finode];
1417      fcurinode = format(int(inodetocatinode[finode]), 'x').lower();
1418     if(finode not in inodelist):
1419      inodelist.append(finode);
1420      inodetofile.update({finode: fname});
1421      inodetocatinode.update({finode: curinode});
1422      fcurinode = format(int(curinode), 'x').lower();
1423      curinode = curinode + 1;
1424   else:
1425    fcurinode = format(int(curinode), 'x').lower();
1426    curinode = curinode + 1;
1427   curfid = curfid + 1;
1428   if(ftype==2):
1429    flinkname = os.readlink(fname);
1430   fdev = fstatinfo.st_dev;
1431   getfdev = GetDevMajorMinor(fdev);
1432   fdev_minor = getfdev[0];
1433   fdev_major = getfdev[1];
1434   frdev = fstatinfo.st_dev;
1435   if(hasattr(fstatinfo, "st_rdev")):
1436    frdev = fstatinfo.st_rdev;
1437   else:
1438    frdev = fstatinfo.st_dev;
1439   getfrdev = GetDevMajorMinor(frdev);
1440   frdev_minor = getfrdev[0];
1441   frdev_major = getfrdev[1];
1442   if(ftype==1 or ftype==2 or ftype==3 or ftype==4 or ftype==5 or ftype==6):
1443    fsize = format(int("0"), 'x').lower();
1444   elif(ftype==0 or ftype==7):
1445    fsize = format(int(fstatinfo.st_size), 'x').lower();
1446   else:
1447    fsize = format(int(fstatinfo.st_size)).lower();
1448   fatime = format(int(fstatinfo.st_atime), 'x').lower();
1449   fmtime = format(int(fstatinfo.st_mtime), 'x').lower();
1450   fctime = format(int(fstatinfo.st_ctime), 'x').lower();
1451   if(hasattr(fstatinfo, "st_birthtime")):
1452    fbtime = format(int(fstatinfo.st_birthtime), 'x').lower();
1453   else:
1454    fbtime = format(int(fstatinfo.st_ctime), 'x').lower();
1455   fmode = format(int(fstatinfo.st_mode), 'x').lower();
1456   fchmode = format(int(stat.S_IMODE(fstatinfo.st_mode)), 'x').lower();
1457   ftypemod = format(int(stat.S_IFMT(fstatinfo.st_mode)), 'x').lower();
1458   fuid = format(int(fstatinfo.st_uid), 'x').lower();
1459   fgid = format(int(fstatinfo.st_gid), 'x').lower();
1460   funame = "";
1461   try:
1462    import pwd;
1463    try:
1464     userinfo = pwd.getpwuid(fstatinfo.st_uid);
1465     funame = userinfo.pw_name;
1466    except KeyError:
1467     funame = "";
1468   except ImportError:
1469    funame = "";
1470   fgname = "";
1471   try:
1472    import grp;
1473    try:
1474     groupinfo = grp.getgrgid(fstatinfo.st_gid);
1475     fgname = groupinfo.gr_name;
1476    except KeyError:
1477     fgname = "";
1478   except ImportError:
1479    fgname = "";
1480   fdev_minor = format(int(fdev_minor), 'x').lower();
1481   fdev_major = format(int(fdev_major), 'x').lower();
1482   frdev_minor = format(int(frdev_minor), 'x').lower();
1483   frdev_major = format(int(frdev_major), 'x').lower();
1484   finode = format(int(finode), 'x').lower();
1485   flinkcount = format(int(flinkcount), 'x').lower();
1486   if(hasattr(fstatinfo, "st_file_attributes")):
1487    fwinattributes = format(int(fstatinfo.st_file_attributes), 'x').lower();
1488   else:
1489    fwinattributes = format(int(0), 'x').lower();
1490   fcontents = "".encode('UTF-8');
1491   chunk_size = 1024;
1492   if(ftype == 0 or ftype == 7):
1493    with open(fname, "rb") as fpc:
1494     while(True):
1495      chunk = fpc.read(chunk_size);
1496      if(not chunk):
1497       break
1498      fcontents += chunk;
1499   if(followlink and (ftype == 1 or ftype == 2)):
1500    flstatinfo = os.stat(flinkname);
1501    with open(flinkname, "rb") as fpc:
1502     while(True):
1503      chunk = fpc.read(chunk_size);
1504      if(not chunk):
1505       break;
1506      fcontents += chunk;
1507   ftypehex = format(ftype, 'x').lower();
1508   extrafields = format(len(extradata), 'x').lower();
1509   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
1510   if(len(extradata)>0):
1511    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
1512   extrasizelen = format(len(extrasizestr), 'x').lower();
1513   catfileoutstr = AppendNullBytes([ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrasizelen, extrafields], formatspecs[5]);
1514   if(len(extradata)>0):
1515    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
1516   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
1517   if(checksumtype=="none" or checksumtype==""):
1518    catfileheadercshex = format(0, 'x').lower();
1519    catfilecontentcshex = format(0, 'x').lower();
1520   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
1521    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
1522    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
1523   elif(checksumtype=="crc16_ccitt"):
1524    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
1525    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
1526   elif(checksumtype=="adler32"):
1527    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
1528    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
1529   elif(checksumtype=="crc32"):
1530    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
1531    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
1532   elif(checksumtype=="crc64_ecma"):
1533    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1534    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
1535   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
1536    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1537    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
1538   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
1539    checksumoutstr = hashlib.new(checksumtype);
1540    checksumoutstr.update("".encode('UTF-8'));
1541    catfileheadercshex = checksumoutstr.hexdigest().lower();
1542    checksumoutstr = hashlib.new(checksumtype);
1543    checksumoutstr.update(fcontents);
1544    catfilecontentcshex = checksumoutstr.hexdigest().lower();
1545   else:
1546    catfileheadercshex = format(0, 'x').lower();
1547    catfilecontentcshex = format(0, 'x').lower();
1548   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
1549   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
1550   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
1551   if(checksumtype=="none" or checksumtype==""):
1552    catfileheadercshex = format(0, 'x').lower();
1553   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
1554    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
1555   elif(checksumtype=="crc16_ccitt"):
1556    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
1557   elif(checksumtype=="adler32"):
1558    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
1559   elif(checksumtype=="crc32"):
1560    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
1561   elif(checksumtype=="crc64_ecma"):
1562    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1563   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
1564    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1565   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
1566    checksumoutstr = hashlib.new(checksumtype);
1567    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
1568    catfileheadercshex = checksumoutstr.hexdigest().lower();
1569   else:
1570    catfileheadercshex = format(0, 'x').lower();
1571   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
1572   catfhend = (catfp.tell() - 1) + len(catfileoutstr);
1573   catfcontentstart = catfp.tell() + len(catfileoutstr);
1574   catfileoutstrecd = catfileoutstr.encode('UTF-8');
1575   nullstrecd = formatspecs[5].encode('UTF-8');
1576   catfileout = catfileoutstrecd + fcontents + nullstrecd;
1577   catfcontentend = (catfp.tell() - 1) + len(catfileout);
1578   catfp.write(catfileout);
1579   try:
1580    catfp.flush();
1581    os.fsync(catfp.fileno());
1582   except io.UnsupportedOperation:
1583    pass;
1584   except AttributeError:
1585    pass;
1586  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
1587   catfp = CompressArchiveFile(catfp, compression, formatspecs);
1588   try:
1589    catfp.flush();
1590    os.fsync(catfp.fileno());
1591   except io.UnsupportedOperation:
1592    pass;
1593   except AttributeError:
1594    pass;
1595  if(outfile=="-"):
1596   catfp.seek(0, 0);
1597   if(hasattr(sys.stdout, "buffer")):
1598    shutil.copyfileobj(catfp, sys.stdout.buffer);
1599   else:
1600    shutil.copyfileobj(catfp, sys.stdout);
1601  elif(re.findall(r"^(ftp|ftps)\:\/\/", outfile)):
1602   catfp = CompressArchiveFile(catfp, compression, formatspecs);
1603   catfp.seek(0, 0);
1604   upload_file_to_ftp_file(catfp, outfile);
1605  elif(re.findall(r"^(sftp)\:\/\/", outfile) and haveparamiko):
1606   catfp = CompressArchiveFile(catfp, compression, formatspecs);
1607   catfp.seek(0, 0);
1608   if(__use_pysftp__):
1609    upload_file_to_pysftp_file(catfp, outfile);
1610   else:
1611    upload_file_to_sftp_file(catfp, outfile);
1612  if(returnfp):
1613   catfp.seek(0, 0);
1614   return catfp;
1615  else:
1616   catfp.close();
1617   return True;
1618
1619 create_alias_function("Pack", __file_format_name__, "", PackArchiveFile);
1620
1621 if(hasattr(shutil, "register_archive_format")):
1622  def PackArchiveFileFunc(archive_name, source_dir, **kwargs):
1623   return PackArchiveFile(source_dir, archive_name, False, "auto", None, False, "crc32", [], __file_format_delimiter__, False, False);
1624  create_alias_function("Pack", __file_format_name__, "Func", PackArchiveFileFunc);
1625
1626 def PackArchiveFileFromDirList(infiles, outfile, dirlistfromtxt=False, compression="auto", compressionlevel=None, followlink=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
1627  return PackArchiveFile(infiles, outfile, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, returnfp);
1628
1629 def PackArchiveFileFromTarFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
1630  compressionlist = ['auto', 'gzip', 'bzip2', 'zstd', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
1631  outextlist = ['gz', 'bz2', 'zst', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
1632  outextlistwd = ['.gz', '.bz2', '.zst', '.lz4', '.lzo', '.lzop', '.lzma', '.xz'];
1633  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
1634   outfile = RemoveWindowsPath(outfile);
1635  checksumtype = checksumtype.lower();
1636  if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
1637   checksumtype="crc32";
1638  if(checksumtype=="none"):
1639   checksumtype = "";
1640  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
1641   compression = None;
1642  if(compression not in compressionlist and compression is None):
1643   compression = "auto";
1644  if(verbose):
1645   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
1646  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
1647   if(os.path.exists(outfile)):
1648    os.unlink(outfile);
1649  if(outfile=="-"):
1650   verbose = False;
1651   catfp = BytesIO();
1652  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
1653   catfp = outfile;
1654  elif(re.findall(r"^(ftp|ftps)\:\/\/", outfile)):
1655   catfp = BytesIO();
1656  elif(re.findall(r"^(sftp)\:\/\/", outfile) and haveparamiko):
1657   catfp = BytesIO();
1658  else:
1659   fbasename = os.path.splitext(outfile)[0];
1660   fextname = os.path.splitext(outfile)[1];
1661   catfp = CompressOpenFile(outfile, compressionlevel);
1662  catver = formatspecs[6];
1663  fileheaderver = str(int(catver.replace(".", "")));
1664  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
1665  catfp.write(fileheader.encode('UTF-8'));
1666  curinode = 0;
1667  curfid = 0;
1668  inodelist = [];
1669  inodetofile = {};
1670  filetoinode = {};
1671  inodetocatinode = {};
1672  if(infile=="-"):
1673   infile = BytesIO();
1674   if(hasattr(sys.stdin, "buffer")):
1675    shutil.copyfileobj(sys.stdin.buffer, infile);
1676   else:
1677    shutil.copyfileobj(sys.stdin, infile);
1678   infile.seek(0, 0);
1679   if(not infile):
1680    return False;
1681   infile.seek(0, 0);
1682  elif(re.findall(r"^(http|https)\:\/\/", infile)):
1683   infile = download_file_from_http_file(infile);
1684   infile.seek(0, 0);
1685   if(not infile):
1686    return False;
1687   infile.seek(0, 0);
1688  elif(re.findall(r"^(ftp|ftps)\:\/\/", infile)):
1689   infile = download_file_from_ftp_file(infile);
1690   infile.seek(0, 0);
1691   if(not infile):
1692    return False;
1693   infile.seek(0, 0);
1694  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
1695   return False;
1696  elif(os.path.exists(infile) and os.path.isfile(infile)):
1697   try:
1698    if(not tarfile.is_tarfile(infile)):
1699     return False;
1700   except AttributeError:
1701    if(not is_tarfile(infile)):
1702     return False;
1703  else:
1704   return False;
1705  try:
1706   if(hasattr(infile, "read") or hasattr(infile, "write")):
1707    tarfp = tarfile.open(fileobj=infile, mode="r");
1708   else:
1709    tarfp = tarfile.open(infile, "r");
1710  except FileNotFoundError:
1711   return False;
1712  fnumfiles = format(int(len(tarfp.getmembers())), 'x').lower();
1713  fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
1714  if(checksumtype=="none" or checksumtype==""):
1715   catfileheadercshex = format(0, 'x').lower();
1716  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
1717   catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
1718  elif(checksumtype=="crc16_ccitt"):
1719   catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
1720  elif(checksumtype=="adler32"):
1721   catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
1722  elif(checksumtype=="crc32"):
1723   catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
1724  elif(checksumtype=="crc64_ecma"):
1725   catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1726  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
1727   catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1728  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
1729   checksumoutstr = hashlib.new(checksumtype);
1730   checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
1731   catfileheadercshex = checksumoutstr.hexdigest().lower();
1732  else:
1733   catfileheadercshex = format(0, 'x').lower();
1734  fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
1735  catfp.write(fnumfilesa.encode('UTF-8'));
1736  try:
1737   catfp.flush();
1738   os.fsync(catfp.fileno());
1739  except io.UnsupportedOperation:
1740   pass;
1741  except AttributeError:
1742   pass;
1743  for member in sorted(tarfp.getmembers(), key=lambda x: x.name):
1744   catfhstart = catfp.tell();
1745   if(re.findall("^[.|/]", member.name)):
1746    fname = member.name;
1747   else:
1748    fname = "./"+member.name;
1749   if(verbose):
1750    VerbosePrintOut(fname);
1751   fpremode = member.mode;
1752   ffullmode = member.mode;
1753   flinkcount = 0;
1754   ftype = 0;
1755   if(member.isreg()):
1756    ffullmode = member.mode + stat.S_IFREG;
1757    ftype = 0;
1758   elif(member.isdev()):
1759    ffullmode = member.mode;
1760    ftype = 7;
1761   elif(member.islnk()):
1762    ffullmode = member.mode + stat.S_IFREG;
1763    ftype = 1;
1764   elif(member.issym()):
1765    ffullmode = member.mode + stat.S_IFLNK;
1766    ftype = 2;
1767   elif(member.ischr()):
1768    ffullmode = member.mode + stat.S_IFCHR;
1769    ftype = 3;
1770   elif(member.isblk()):
1771    ffullmode = member.mode + stat.S_IFBLK;
1772    ftype = 4;
1773   elif(member.isdir()):
1774    ffullmode = member.mode + stat.S_IFDIR;
1775    ftype = 5;
1776   elif(member.isfifo()):
1777    ffullmode = member.mode + stat.S_IFIFO;
1778    ftype = 6;
1779   elif(member.issparse()):
1780    ffullmode = member.mode;
1781    ftype = 8;
1782   else:
1783    ffullmode = member.mode;
1784    ftype = 0;
1785   flinkname = "";
1786   fcurfid = format(int(curfid), 'x').lower();
1787   fcurinode = format(int(0), 'x').lower();
1788   curfid = curfid + 1;
1789   if(ftype==2):
1790    flinkname = member.linkname;
1791   fdev_minor = format(int(member.devminor), 'x').lower();
1792   fdev_major = format(int(member.devmajor), 'x').lower();
1793   frdev_minor = format(int(member.devminor), 'x').lower();
1794   frdev_major = format(int(member.devmajor), 'x').lower();
1795   if(ftype==1 or ftype==2 or ftype==3 or ftype==4 or ftype==5 or ftype==6):
1796    fsize = format(int("0"), 'x').lower();
1797   elif(ftype==0 or ftype==7):
1798    fsize = format(int(member.size), 'x').lower();
1799   else:
1800    fsize = format(int(member.size), 'x').lower();
1801   fatime = format(int(member.mtime), 'x').lower();
1802   fmtime = format(int(member.mtime), 'x').lower();
1803   fctime = format(int(member.mtime), 'x').lower();
1804   fbtime = format(int(member.mtime), 'x').lower();
1805   fmode = format(int(ffullmode), 'x').lower();
1806   fchmode = format(int(stat.S_IMODE(ffullmode)), 'x').lower();
1807   ftypemod = format(int(stat.S_IFMT(ffullmode)), 'x').lower();
1808   fuid = format(int(member.uid), 'x').lower();
1809   fgid = format(int(member.gid), 'x').lower();
1810   funame = member.uname;
1811   fgname = member.gname;
1812   flinkcount = format(int(flinkcount), 'x').lower();
1813   fcontents = "".encode('UTF-8');
1814   chunk_size = 1024;
1815   if(ftype == 0 or ftype == 7):
1816    with tarfp.extractfile(member) as fpc:
1817     while(True):
1818      chunk = fpc.read(chunk_size);
1819      if(not chunk):
1820       break
1821      fcontents += chunk;
1822   ftypehex = format(ftype, 'x').lower();
1823   extrafields = format(len(extradata), 'x').lower();
1824   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
1825   if(len(extradata)>0):
1826    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
1827   extrasizelen = format(len(extrasizestr), 'x').lower();
1828   catfileoutstr = AppendNullBytes([ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrasizelen, extrafields], formatspecs[5]);
1829   if(len(extradata)>0):
1830    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
1831   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
1832   catfhend = (catfp.tell() - 1) + len(catfileoutstr);
1833   catfcontentstart = catfp.tell() + len(catfileoutstr);
1834   if(checksumtype=="none" or checksumtype==""):
1835    catfileheadercshex = format(0, 'x').lower();
1836    catfilecontentcshex = format(0, 'x').lower();
1837   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
1838    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
1839    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
1840   elif(checksumtype=="crc16_ccitt"):
1841    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
1842    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
1843   elif(checksumtype=="adler32"):
1844    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
1845    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
1846   elif(checksumtype=="crc32"):
1847    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
1848    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
1849   elif(checksumtype=="crc64_ecma"):
1850    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1851    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
1852   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
1853    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1854    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
1855   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
1856    checksumoutstr = hashlib.new(checksumtype);
1857    checksumoutstr.update("".encode('UTF-8'));
1858    catfileheadercshex = checksumoutstr.hexdigest().lower();
1859    checksumoutstr = hashlib.new(checksumtype);
1860    checksumoutstr.update(fcontents);
1861    catfilecontentcshex = checksumoutstr.hexdigest().lower();
1862   else:
1863    catfileheadercshex = format(0, 'x').lower();
1864    catfilecontentcshex = format(0, 'x').lower();
1865   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
1866   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
1867   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
1868   if(checksumtype=="none" or checksumtype==""):
1869    catfileheadercshex = format(0, 'x').lower();
1870   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
1871    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
1872   elif(checksumtype=="crc16_ccitt"):
1873    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
1874   elif(checksumtype=="adler32"):
1875    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
1876   elif(checksumtype=="crc32"):
1877    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
1878   elif(checksumtype=="crc64_ecma"):
1879    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1880   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
1881    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1882   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
1883    checksumoutstr = hashlib.new(checksumtype);
1884    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
1885    catfileheadercshex = checksumoutstr.hexdigest().lower();
1886   else:
1887    catfileheadercshex = format(0, 'x').lower();
1888   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
1889   catfileoutstrecd = catfileoutstr.encode('UTF-8');
1890   nullstrecd = formatspecs[5].encode('UTF-8');
1891   catfileout = catfileoutstrecd + fcontents + nullstrecd;
1892   catfcontentend = (catfp.tell() - 1) + len(catfileout);
1893   catfp.write(catfileout);
1894   try:
1895    catfp.flush();
1896    os.fsync(catfp.fileno());
1897   except io.UnsupportedOperation:
1898    pass;
1899   except AttributeError:
1900    pass;
1901  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
1902   catfp = CompressArchiveFile(catfp, compression, formatspecs);
1903   try:
1904    catfp.flush();
1905    os.fsync(catfp.fileno());
1906   except io.UnsupportedOperation:
1907    pass;
1908   except AttributeError:
1909    pass;
1910  if(outfile=="-"):
1911   catfp.seek(0, 0);
1912   if(hasattr(sys.stdout, "buffer")):
1913    shutil.copyfileobj(catfp, sys.stdout.buffer);
1914   else:
1915    shutil.copyfileobj(catfp, sys.stdout);
1916  elif(re.findall(r"^(ftp|ftps)\:\/\/", outfile)):
1917   catfp = CompressArchiveFile(catfp, compression, formatspecs);
1918   catfp.seek(0, 0);
1919   upload_file_to_ftp_file(catfp, outfile);
1920  elif(re.findall(r"^(sftp)\:\/\/", outfile) and haveparamiko):
1921   catfp = CompressArchiveFile(catfp, compression, formatspecs);
1922   catfp.seek(0, 0);
1923   if(__use_pysftp__):
1924    upload_file_to_pysftp_file(catfp, outfile);
1925   else:
1926    upload_file_to_sftp_file(catfp, outfile);
1927  if(returnfp):
1928   catfp.seek(0, 0);
1929   return catfp;
1930  else:
1931   catfp.close();
1932   return True;
1933
1934 create_alias_function("Pack", __file_format_name__, "FromTarFile", PackArchiveFileFromTarFile);
1935
1936 def PackArchiveFileFromZipFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
1937  compressionlist = ['auto', 'gzip', 'bzip2', 'zstd', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
1938  outextlist = ['gz', 'bz2', 'zst', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
1939  outextlistwd = ['.gz', '.bz2', '.zst', '.lz4', '.lzo', '.lzop', '.lzma', '.xz'];
1940  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
1941   outfile = RemoveWindowsPath(outfile);
1942  checksumtype = checksumtype.lower();
1943  if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
1944   checksumtype="crc32";
1945  if(checksumtype=="none"):
1946   checksumtype = "";
1947  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
1948   compression = None;
1949  if(compression not in compressionlist and compression is None):
1950   compression = "auto";
1951  if(verbose):
1952   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
1953  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
1954   if(os.path.exists(outfile)):
1955    os.unlink(outfile);
1956  if(outfile=="-"):
1957   verbose = False;
1958   catfp = BytesIO();
1959  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
1960   catfp = outfile;
1961  elif(re.findall(r"^(ftp|ftps)\:\/\/", outfile)):
1962   catfp = BytesIO();
1963  elif(re.findall(r"^(sftp)\:\/\/", outfile) and haveparamiko):
1964   catfp = BytesIO();
1965  else:
1966   fbasename = os.path.splitext(outfile)[0];
1967   fextname = os.path.splitext(outfile)[1];
1968   catfp = CompressOpenFile(outfile, compressionlevel);
1969  catver = formatspecs[6];
1970  fileheaderver = str(int(catver.replace(".", "")));
1971  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
1972  catfp.write(fileheader.encode('UTF-8'));
1973  curinode = 0;
1974  curfid = 0;
1975  inodelist = [];
1976  inodetofile = {};
1977  filetoinode = {};
1978  inodetocatinode = {};
1979  if(infile=="-"):
1980   infile = BytesIO();
1981   if(hasattr(sys.stdin, "buffer")):
1982    shutil.copyfileobj(sys.stdin.buffer, infile);
1983   else:
1984    shutil.copyfileobj(sys.stdin, infile);
1985   infile.seek(0, 0);
1986   if(not infile):
1987    return False;
1988   infile.seek(0, 0);
1989  elif(re.findall(r"^(http|https)\:\/\/", infile)):
1990   infile = download_file_from_http_file(infile);
1991   infile.seek(0, 0);
1992   if(not infile):
1993    return False;
1994   infile.seek(0, 0);
1995  elif(re.findall(r"^(ftp|ftps)\:\/\/", infile)):
1996   infile = download_file_from_ftp_file(infile);
1997   infile.seek(0, 0);
1998   if(not infile):
1999    return False;
2000   infile.seek(0, 0);
2001  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
2002   return False;
2003  else:
2004   return False;
2005  if(not zipfile.is_zipfile(infile)):
2006   return False;
2007  try:
2008   zipfp = zipfile.ZipFile(infile, "r", allowZip64=True);
2009  except FileNotFoundError:
2010   return False;
2011  ziptest = zipfp.testzip();
2012  if(ziptest):
2013   VerbosePrintOut("Bad file found!");
2014  fnumfiles = format(int(len(zipfp.infolist())), 'x').lower();
2015  fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
2016  if(checksumtype=="none" or checksumtype==""):
2017   catfileheadercshex = format(0, 'x').lower();
2018  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2019   catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2020  elif(checksumtype=="crc16_ccitt"):
2021   catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2022  elif(checksumtype=="adler32"):
2023   catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2024  elif(checksumtype=="crc32"):
2025   catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2026  elif(checksumtype=="crc64_ecma"):
2027   catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2028  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2029   catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2030  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2031   checksumoutstr = hashlib.new(checksumtype);
2032   checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
2033   catfileheadercshex = checksumoutstr.hexdigest().lower();
2034  else:
2035   catfileheadercshex = format(0, 'x').lower();
2036  fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
2037  catfp.write(fnumfilesa.encode('UTF-8'));
2038  try:
2039   catfp.flush();
2040   os.fsync(catfp.fileno());
2041  except io.UnsupportedOperation:
2042   pass;
2043  except AttributeError:
2044   pass;
2045  for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
2046   catfhstart = catfp.tell();
2047   if(re.findall("^[.|/]", member.filename)):
2048    fname = member.filename;
2049   else:
2050    fname = "./"+member.filename;
2051   zipinfo = zipfp.getinfo(member.filename);
2052   if(verbose):
2053    VerbosePrintOut(fname);
2054   if(not member.is_dir()):
2055    fpremode = int(stat.S_IFREG + 438);
2056   elif(member.is_dir()):
2057    fpremode = int(stat.S_IFDIR + 511);
2058   flinkcount = 0;
2059   ftype = 0;
2060   if(not member.is_dir()):
2061    ftype = 0;
2062   elif(member.is_dir()):
2063    ftype = 5;
2064   flinkname = "";
2065   fcurfid = format(int(curfid), 'x').lower();
2066   fcurinode = format(int(0), 'x').lower();
2067   curfid = curfid + 1;
2068   fdev_minor = format(int(0), 'x').lower();
2069   fdev_major = format(int(0), 'x').lower();
2070   frdev_minor = format(int(0), 'x').lower();
2071   frdev_major = format(int(0), 'x').lower();
2072   if(ftype==5):
2073    fsize = format(int("0"), 'x').lower();
2074   elif(ftype==0):
2075    fsize = format(int(member.file_size), 'x').lower();
2076   else:
2077    fsize = format(int(member.file_size), 'x').lower();
2078   fatime = format(int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower();
2079   fmtime = format(int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower();
2080   fctime = format(int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower();
2081   fbtime = format(int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower();
2082   if(not member.is_dir()):
2083    fmode = format(int(stat.S_IFREG + 438), 'x').lower();
2084    fchmode = format(int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower();
2085    ftypemod = format(int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower();
2086   if(member.is_dir()):
2087    fmode = format(int(stat.S_IFDIR + 511), 'x').lower();
2088    fchmode = format(int(stat.S_IMODE(int(stat.S_IFDIR + 511))), 'x').lower();
2089    ftypemod = format(int(stat.S_IFMT(int(stat.S_IFDIR + 511))), 'x').lower();
2090   try:
2091    fuid = format(int(os.getuid()), 'x').lower();
2092   except AttributeError:
2093    fuid = format(int(0), 'x').lower();
2094   except KeyError:
2095    fuid = format(int(0), 'x').lower();
2096   try:
2097    fgid = format(int(os.getgid()), 'x').lower();
2098   except AttributeError:
2099    fgid = format(int(0), 'x').lower();
2100   except KeyError:
2101    fgid = format(int(0), 'x').lower();
2102   try:
2103    import pwd;
2104    try:
2105     userinfo = pwd.getpwuid(os.getuid());
2106     funame = userinfo.pw_name;
2107    except KeyError:
2108     funame = "";
2109    except AttributeError:
2110     funame = "";
2111   except ImportError:
2112    funame = "";
2113   fgname = "";
2114   try:
2115    import grp;
2116    try:
2117     groupinfo = grp.getgrgid(os.getgid());
2118     fgname = groupinfo.gr_name;
2119    except KeyError:
2120     fgname = "";
2121    except AttributeError:
2122     fgname = "";
2123   except ImportError:
2124    fgname = "";
2125   fcontents = "".encode('UTF-8');
2126   if(ftype==0):
2127    fcontents = zipfp.read(member.filename);
2128   ftypehex = format(ftype, 'x').lower();
2129   extrafields = format(len(extradata), 'x').lower();
2130   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
2131   if(len(extradata)>0):
2132    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
2133   extrasizelen = format(len(extrasizestr), 'x').lower();
2134   catfileoutstr = AppendNullBytes([ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrasizelen, extrafields], formatspecs[5]);
2135   if(len(extradata)>0):
2136    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
2137   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
2138   catfhend = (catfp.tell() - 1) + len(catfileoutstr);
2139   catfcontentstart = catfp.tell() + len(catfileoutstr);
2140   if(checksumtype=="none" or checksumtype==""):
2141    catfileheadercshex = format(0, 'x').lower();
2142    catfilecontentcshex = format(0, 'x').lower();
2143   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2144    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
2145    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
2146   elif(checksumtype=="crc16_ccitt"):
2147    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
2148    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
2149   elif(checksumtype=="adler32"):
2150    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2151    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
2152   elif(checksumtype=="crc32"):
2153    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2154    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
2155   elif(checksumtype=="crc64_ecma"):
2156    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2157    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
2158   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2159    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2160    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
2161   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2162    checksumoutstr = hashlib.new(checksumtype);
2163    checksumoutstr.update("".encode('UTF-8'));
2164    catfileheadercshex = checksumoutstr.hexdigest().lower();
2165    checksumoutstr = hashlib.new(checksumtype);
2166    checksumoutstr.update(fcontents);
2167    catfilecontentcshex = checksumoutstr.hexdigest().lower();
2168   else:
2169    catfileheadercshex = format(0, 'x').lower();
2170    catfilecontentcshex = format(0, 'x').lower();
2171   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
2172   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
2173   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
2174   if(checksumtype=="none" or checksumtype==""):
2175    catfileheadercshex = format(0, 'x').lower();
2176   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2177    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
2178   elif(checksumtype=="crc16_ccitt"):
2179    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
2180   elif(checksumtype=="adler32"):
2181    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
2182   elif(checksumtype=="crc32"):
2183    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
2184   elif(checksumtype=="crc64_ecma"):
2185    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2186   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2187    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2188   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2189    checksumoutstr = hashlib.new(checksumtype);
2190    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
2191    catfileheadercshex = checksumoutstr.hexdigest().lower();
2192   else:
2193    catfileheadercshex = format(0, 'x').lower();
2194   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
2195   catfileoutstrecd = catfileoutstr.encode('UTF-8');
2196   nullstrecd = formatspecs[5].encode('UTF-8');
2197   catfileout = catfileoutstrecd + fcontents + nullstrecd;
2198   catfcontentend = (catfp.tell() - 1) + len(catfileout);
2199   catfp.write(catfileout);
2200   try:
2201    catfp.flush();
2202    os.fsync(catfp.fileno());
2203   except io.UnsupportedOperation:
2204    pass;
2205   except AttributeError:
2206    pass;
2207  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
2208   catfp = CompressArchiveFile(catfp, compression, formatspecs);
2209   try:
2210    catfp.flush();
2211    os.fsync(catfp.fileno());
2212   except io.UnsupportedOperation:
2213    pass;
2214   except AttributeError:
2215    pass;
2216  if(outfile=="-"):
2217   catfp.seek(0, 0);
2218   if(hasattr(sys.stdout, "buffer")):
2219    shutil.copyfileobj(catfp, sys.stdout.buffer);
2220   else:
2221    shutil.copyfileobj(catfp, sys.stdout);
2222  elif(re.findall(r"^(ftp|ftps)\:\/\/", outfile)):
2223   catfp = CompressArchiveFile(catfp, compression, formatspecs);
2224   catfp.seek(0, 0);
2225   upload_file_to_ftp_file(catfp, outfile);
2226  elif(re.findall(r"^(sftp)\:\/\/", outfile) and haveparamiko):
2227   catfp = CompressArchiveFile(catfp, compression, formatspecs);
2228   catfp.seek(0, 0);
2229   if(__use_pysftp__):
2230    upload_file_to_pysftp_file(catfp, outfile);
2231   else:
2232    upload_file_to_sftp_file(catfp, outfile);
2233  if(returnfp):
2234   catfp.seek(0, 0);
2235   return catfp;
2236  else:
2237   catfp.close();
2238   return True;
2239
2240 create_alias_function("Pack", __file_format_name__, "FromZipFile", PackArchiveFileFromZipFile);
2241
2242 if(not rarfile_support):
2243  def PackArchiveFileFromRarFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
2244   return False
2245
2246 if(rarfile_support):
2247  def PackArchiveFileFromRarFile(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
2248   compressionlist = ['auto', 'gzip', 'bzip2', 'zstd', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
2249   outextlist = ['gz', 'bz2', 'zst', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
2250   outextlistwd = ['.gz', '.bz2', '.zst', '.lz4', '.lzo', '.lzop', '.lzma', '.xz'];
2251   if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2252    outfile = RemoveWindowsPath(outfile);
2253   checksumtype = checksumtype.lower();
2254   if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
2255    checksumtype="crc32";
2256   if(checksumtype=="none"):
2257    checksumtype = "";
2258   if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
2259    compression = None;
2260   if(compression not in compressionlist and compression is None):
2261    compression = "auto";
2262   if(verbose):
2263    logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
2264   if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
2265    if(os.path.exists(outfile)):
2266     os.unlink(outfile);
2267   if(outfile=="-"):
2268    verbose = False;
2269    catfp = BytesIO();
2270   elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
2271    catfp = outfile;
2272   elif(re.findall(r"^(ftp|ftps)\:\/\/", outfile)):
2273    catfp = BytesIO();
2274   elif(re.findall(r"^(sftp)\:\/\/", outfile) and haveparamiko):
2275    catfp = BytesIO();
2276   else:
2277    fbasename = os.path.splitext(outfile)[0];
2278    fextname = os.path.splitext(outfile)[1];
2279    catfp = CompressOpenFile(outfile, compressionlevel);
2280   catver = formatspecs[6];
2281   fileheaderver = str(int(catver.replace(".", "")));
2282   fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
2283   catfp.write(fileheader.encode('UTF-8'));
2284   curinode = 0;
2285   curfid = 0;
2286   inodelist = [];
2287   inodetofile = {};
2288   filetoinode = {};
2289   inodetocatinode = {};
2290   if(not os.path.exists(infile) or not os.path.isfile(infile)):
2291    return False;
2292   if(not rarfile.is_rarfile(infile) and not rarfile.is_rarfile_sfx(infile)):
2293    return False;
2294   rarfp = rarfile.RarFile(infile, "r");
2295   rartest = rarfp.testrar();
2296   if(rartest):
2297    VerbosePrintOut("Bad file found!");
2298   fnumfiles = format(int(len(rarfp.infolist())), 'x').lower();
2299   fnumfilesa = AppendNullBytes([fnumfiles, checksumtype], formatspecs[5]);
2300   if(checksumtype=="none" or checksumtype==""):
2301    catfileheadercshex = format(0, 'x').lower();
2302   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2303    catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2304   elif(checksumtype=="crc16_ccitt"):
2305    catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
2306   elif(checksumtype=="adler32"):
2307    catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2308   elif(checksumtype=="crc32"):
2309    catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
2310   elif(checksumtype=="crc64_ecma"):
2311    catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2312   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2313    catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2314   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2315    checksumoutstr = hashlib.new(checksumtype);
2316    checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
2317    catfileheadercshex = checksumoutstr.hexdigest().lower();
2318   else:
2319    catfileheadercshex = format(0, 'x').lower();
2320   fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
2321   catfp.write(fnumfilesa.encode('UTF-8'));
2322   try:
2323    catfp.flush();
2324    os.fsync(catfp.fileno());
2325   except io.UnsupportedOperation:
2326    pass;
2327   except AttributeError:
2328    pass;
2329   for member in sorted(rarfp.infolist(), key=lambda x: x.filename):
2330    is_unix = False;
2331    is_windows = False;
2332    if(member.host_os == rarfile.RAR_OS_UNIX):
2333     is_windows = False;
2334     try:
2335      member.external_attr
2336      is_unix = True;
2337     except AttributeError:
2338      is_unix = False;
2339    elif(member.host_os == rarfile.RAR_OS_WIN32):
2340     is_unix = False;
2341     try:
2342      member.external_attr
2343      is_windows = True;
2344     except AttributeError:
2345      is_windows = False;
2346    else:
2347     is_unix = False;
2348     is_windows = False;
2349    catfhstart = catfp.tell();
2350    if(re.findall("^[.|/]", member.filename)):
2351     fname = member.filename;
2352    else:
2353     fname = "./"+member.filename;
2354    rarinfo = rarfp.getinfo(member.filename);
2355    if(verbose):
2356     VerbosePrintOut(fname);
2357    if(is_unix and member.external_attr !=0):
2358     fpremode = int(member.external_attr);
2359    elif(member.is_file()):
2360     fpremode = int(stat.S_IFREG + 438);
2361    elif(member.is_symlink()):
2362     fpremode = int(stat.S_IFLNK + 438);
2363    elif(member.is_dir()):
2364     fpremode = int(stat.S_IFDIR + 511);
2365    if(is_windows and member.external_attr !=0):
2366     fwinattributes = format(int(member.external_attr), 'x').lower();
2367    else:
2368     fwinattributes = format(int(0), 'x').lower();
2369    flinkcount = 0;
2370    ftype = 0;
2371    if(member.is_file()):
2372     ftype = 0;
2373    elif(member.is_symlink()):
2374     ftype = 2;
2375    elif(member.is_dir()):
2376     ftype = 5;
2377    flinkname = "";
2378    if(ftype==2):
2379     flinkname = rarfp.read(member.filename).decode("UTF-8");
2380    fcurfid = format(int(curfid), 'x').lower();
2381    fcurinode = format(int(0), 'x').lower();
2382    curfid = curfid + 1;
2383    fdev_minor = format(int(0), 'x').lower();
2384    fdev_major = format(int(0), 'x').lower();
2385    frdev_minor = format(int(0), 'x').lower();
2386    frdev_major = format(int(0), 'x').lower();
2387    if(ftype==5):
2388     fsize = format(int("0"), 'x').lower();
2389    elif(ftype==0):
2390     fsize = format(int(member.file_size), 'x').lower();
2391    else:
2392     fsize = format(int(member.file_size), 'x').lower();
2393    try:
2394     if(member.atime):
2395      fatime = format(int(member.atime.timestamp()), 'x').lower();
2396     else:
2397      fatime = format(int(member.mtime.timestamp()), 'x').lower();
2398    except AttributeError:
2399     fatime = format(int(member.mtime.timestamp()), 'x').lower();
2400    fmtime = format(int(member.mtime.timestamp()), 'x').lower();
2401    try:
2402     if(member.ctime):
2403      fctime = format(int(member.ctime.timestamp()), 'x').lower();
2404     else:
2405      fctime = format(int(member.mtime.timestamp()), 'x').lower();
2406    except AttributeError:
2407     fctime = format(int(member.mtime.timestamp()), 'x').lower();
2408    fbtime = format(int(member.mtime.timestamp()), 'x').lower();
2409    if(is_unix and member.external_attr !=0):
2410     fmode = format(int(member.external_attr), 'x').lower();
2411     fchmode = format(int(stat.S_IMODE(member.external_attr)), 'x').lower();
2412     ftypemod = format(int(stat.S_IFMT(member.external_attr)), 'x').lower();
2413    elif(member.is_file()):
2414     fmode = format(int(stat.S_IFREG + 438), 'x').lower();
2415     fchmode = format(int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower();
2416     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower();
2417    elif(member.is_symlink()):
2418     fmode = format(int(stat.S_IFLNK + 438), 'x').lower();
2419     fchmode = format(int(stat.S_IMODE(int(stat.S_IFREG + 438))), 'x').lower();
2420     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFREG + 438))), 'x').lower();
2421    elif(member.is_dir()):
2422     fmode = format(int(stat.S_IFDIR + 511), 'x').lower();
2423     fchmode = format(int(stat.S_IMODE(int(stat.S_IFDIR + 511))), 'x').lower();
2424     ftypemod = format(int(stat.S_IFMT(int(stat.S_IFDIR + 511))), 'x').lower();
2425    try:
2426     fuid = format(int(os.getuid()), 'x').lower();
2427    except AttributeError:
2428     fuid = format(int(0), 'x').lower();
2429    except KeyError:
2430     fuid = format(int(0), 'x').lower();
2431    try:
2432     fgid = format(int(os.getgid()), 'x').lower();
2433    except AttributeError:
2434     fgid = format(int(0), 'x').lower();
2435    except KeyError:
2436     fgid = format(int(0), 'x').lower();
2437    try:
2438     import pwd;
2439     try:
2440      userinfo = pwd.getpwuid(os.getuid());
2441      funame = userinfo.pw_name;
2442     except KeyError:
2443      funame = "";
2444     except AttributeError:
2445      funame = "";
2446    except ImportError:
2447     funame = "";
2448    fgname = "";
2449    try:
2450     import grp;
2451     try:
2452      groupinfo = grp.getgrgid(os.getgid());
2453      fgname = groupinfo.gr_name;
2454     except KeyError:
2455      fgname = "";
2456     except AttributeError:
2457      fgname = "";
2458    except ImportError:
2459     fgname = "";
2460    fcontents = "".encode('UTF-8');
2461    if(ftype==0):
2462     fcontents = rarfp.read(member.filename);
2463    ftypehex = format(ftype, 'x').lower();
2464    extrafields = format(len(extradata), 'x').lower();
2465    extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
2466    if(len(extradata)>0):
2467     extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
2468    extrasizelen = format(len(extrasizestr), 'x').lower();
2469    catfileoutstr = AppendNullBytes([ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrasizelen, extrafields], formatspecs[5]);
2470    if(len(extradata)>0):
2471     catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
2472    catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
2473    catfhend = (catfp.tell() - 1) + len(catfileoutstr);
2474    catfcontentstart = catfp.tell() + len(catfileoutstr);
2475    if(checksumtype=="none" or checksumtype==""):
2476     catfileheadercshex = format(0, 'x').lower();
2477     catfilecontentcshex = format(0, 'x').lower();
2478    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2479     catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
2480     catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
2481    elif(checksumtype=="crc16_ccitt"):
2482     catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
2483     catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
2484    elif(checksumtype=="adler32"):
2485     catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2486     catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
2487    elif(checksumtype=="crc32"):
2488     catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2489     catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
2490    elif(checksumtype=="crc64_ecma"):
2491     catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2492     catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
2493    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2494     catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2495     catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
2496    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2497     checksumoutstr = hashlib.new(checksumtype);
2498     checksumoutstr.update("".encode('UTF-8'));
2499     catfileheadercshex = checksumoutstr.hexdigest().lower();
2500     checksumoutstr = hashlib.new(checksumtype);
2501     checksumoutstr.update(fcontents);
2502     catfilecontentcshex = checksumoutstr.hexdigest().lower();
2503    else:
2504     catfileheadercshex = format(0, 'x').lower();
2505     catfilecontentcshex = format(0, 'x').lower();
2506    tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
2507    catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
2508    catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr
2509    if(checksumtype=="none" or checksumtype==""):
2510     catfileheadercshex = format(0, 'x').lower()
2511    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
2512     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower()
2513    elif(checksumtype=="crc16_ccitt"):
2514     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower()
2515    elif(checksumtype=="adler32"):
2516     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower()
2517    elif(checksumtype=="crc32"):
2518     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower()
2519    elif(checksumtype=="crc64_ecma"):
2520     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
2521    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
2522     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
2523    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
2524     checksumoutstr = hashlib.new(checksumtype)
2525     checksumoutstr.update(catfileoutstr.encode('UTF-8'))
2526     catfileheadercshex = checksumoutstr.hexdigest().lower()
2527    else:
2528     catfileheadercshex = format(0, 'x').lower()
2529    catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5])
2530    catfileoutstrecd = catfileoutstr.encode('UTF-8')
2531    nullstrecd = formatspecs[5].encode('UTF-8')
2532    catfileout = catfileoutstrecd + fcontents + nullstrecd
2533    catfcontentend = (catfp.tell() - 1) + len(catfileout)
2534    catfp.write(catfileout)
2535    try:
2536     catfp.flush()
2537     os.fsync(catfp.fileno())
2538    except io.UnsupportedOperation:
2539     pass
2540    except AttributeError:
2541     pass
2542   if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
2543    catfp = CompressArchiveFile(catfp, compression, formatspecs)
2544    try:
2545     catfp.flush()
2546     os.fsync(catfp.fileno())
2547    except io.UnsupportedOperation:
2548     pass
2549    except AttributeError:
2550     pass
2551   if(outfile=="-"):
2552    catfp.seek(0, 0)
2553    if(hasattr(sys.stdout, "buffer")):
2554     shutil.copyfileobj(catfp, sys.stdout.buffer);
2555    else:
2556     shutil.copyfileobj(catfp, sys.stdout);
2557   elif(re.findall(r"^(ftp|ftps)\:\/\/", outfile)):
2558    catfp = CompressArchiveFile(catfp, compression, formatspecs);
2559    catfp.seek(0, 0);
2560    upload_file_to_ftp_file(catfp, outfile);
2561   elif(re.findall(r"^(sftp)\:\/\/", outfile) and haveparamiko):
2562    catfp = CompressArchiveFile(catfp, compression, formatspecs);
2563    catfp.seek(0, 0);
2564    if(__use_pysftp__):
2565     upload_file_to_pysftp_file(catfp, outfile);
2566    else:
2567     upload_file_to_sftp_file(catfp, outfile);
2568   if(returnfp):
2569    catfp.seek(0, 0)
2570    return catfp
2571   else:
2572    catfp.close()
2573    return True;
2574
2575 create_alias_function("Pack", __file_format_name__, "FromRarFile", PackArchiveFileFromRarFile);
2576
2577 def ArchiveFileSeekToFileNum(infile, seekto=0, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
2578  if(hasattr(infile, "read") or hasattr(infile, "write")):
2579   catfp = infile;
2580   catfp.seek(0, 0);
2581   catfp = UncompressArchiveFile(catfp, formatspecs);
2582   checkcompressfile = CheckCompressionSubType(catfp, formatspecs);
2583   if(checkcompressfile=="tarfile"):
2584    return TarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
2585   if(checkcompressfile=="zipfile"):
2586    return ZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
2587   if(rarfile_support and checkcompressfile=="rarfile"):
2588    return RarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
2589   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
2590    return False;
2591   if(not catfp):
2592    return False;
2593   catfp.seek(0, 0);
2594  elif(infile=="-"):
2595   catfp = BytesIO();
2596   if(hasattr(sys.stdin, "buffer")):
2597    shutil.copyfileobj(sys.stdin.buffer, catfp);
2598   else:
2599    shutil.copyfileobj(sys.stdin, catfp);
2600   catfp.seek(0, 0);
2601   catfp = UncompressArchiveFile(catfp, formatspecs);
2602   if(not catfp):
2603    return False;
2604   catfp.seek(0, 0);
2605  elif(re.findall(r"^(http|https)\:\/\/", infile)):
2606   catfp = download_file_from_http_file(infile);
2607   catfp.seek(0, 0);
2608   catfp = UncompressArchiveFile(catfp, formatspecs);
2609   if(not catfp):
2610    return False;
2611   catfp.seek(0, 0);
2612  elif(re.findall(r"^(ftp|ftps)\:\/\/", infile)):
2613   catfp = download_file_from_ftp_file(infile);
2614   catfp.seek(0, 0);
2615   catfp = UncompressArchiveFile(catfp, formatspecs);
2616   if(not catfp):
2617    return False;
2618   catfp.seek(0, 0);
2619  elif(re.findall(r"^(sftp)\:\/\/", infile) and haveparamiko):
2620   if(__use_pysftp__):
2621    catfp = download_file_from_pysftp_file(infile);
2622   else:
2623    catfp = download_file_from_sftp_file(infile);
2624   catfp.seek(0, 0);
2625   catfp = UncompressArchiveFile(catfp, formatspecs);
2626   if(not catfp):
2627    return False;
2628   catfp.seek(0, 0);
2629  else:
2630   infile = RemoveWindowsPath(infile);
2631   checkcompressfile = CheckCompressionSubType(infile, formatspecs);
2632   if(checkcompressfile=="tarfile"):
2633    return TarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
2634   if(checkcompressfile=="zipfile"):
2635    return ZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
2636   if(rarfile_support and checkcompressfile=="rarfile"):
2637    return RarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
2638   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
2639    return False;
2640   compresscheck = CheckCompressionType(infile, formatspecs, True);
2641   if(not compresscheck):
2642    fextname = os.path.splitext(infile)[1];
2643    if(fextname==".gz"):
2644     compresscheck = "gzip";
2645    if(fextname==".bz2"):
2646     compresscheck = "bzip2";
2647    if(fextname==".zst"):
2648     compresscheck = "zstd";
2649    if(fextname==".lz4" or fextname==".clz4"):
2650     compresscheck = "lz4";
2651    if(fextname==".lzo" or fextname==".lzop"):
2652     compresscheck = "lzo";
2653    if(fextname==".lzma" or fextname==".xz"):
2654     compresscheck = "lzma";
2655   if(not compresscheck):
2656    return False;
2657   catfp = UncompressFile(infile, formatspecs, "rb");
2658  '''
2659  try:
2660   catfp.seek(0, 2);
2661  except OSError:
2662   SeekToEndOfFile(catfp);
2663  except ValueError:
2664   SeekToEndOfFile(catfp);
2665  CatSize = catfp.tell();
2666  CatSizeEnd = CatSize;
2667  '''
2668  try:
2669   catfp.seek(0, 0);
2670  except OSError:
2671   return False;
2672  except ValueError:
2673   return False;
2674  catheader = ReadFileHeaderData(catfp, 4, formatspecs[5]);
2675  catstring = catheader[0];
2676  catversion = re.findall(r"([\d]+)$", catstring);
2677  fprenumfiles = catheader[1];
2678  fnumfiles = int(fprenumfiles, 16);
2679  fprechecksumtype = catheader[2];
2680  fprechecksum = catheader[3];
2681  fileheader = AppendNullByte(catstring, formatspecs[5]);
2682  fnumfileshex = format(int(fnumfiles), 'x').lower();
2683  fileheader = fileheader + AppendNullBytes([fnumfileshex, fprechecksumtype], formatspecs[5]);
2684  if(fprechecksumtype=="none" or fprechecksumtype==""):
2685   catfileheadercshex = format(0, 'x').lower();
2686  elif(fprechecksumtype=="crc16" or fprechecksumtype=="crc16_ansi" or fprechecksumtype=="crc16_ibm"):
2687   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
2688  elif(fprechecksumtype=="crc16_ccitt"):
2689   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
2690  elif(fprechecksumtype=="adler32"):
2691   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
2692  elif(fprechecksumtype=="crc32"):
2693   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
2694  elif(fprechecksumtype=="crc64_ecma"):
2695   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2696  elif(fprechecksumtype=="crc64" or fprechecksumtype=="crc64_iso"):
2697   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2698  elif(CheckSumSupportAlt(fprechecksumtype, hashlib_guaranteed)):
2699   checksumoutstr = hashlib.new(fprechecksumtype);
2700   checksumoutstr.update(fileheader.encode('UTF-8'));
2701   catfileheadercshex = checksumoutstr.hexdigest().lower();
2702  else:
2703   catfileheadercshex = format(0, 'x').lower();
2704  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
2705  fheadtell = len(fileheader);
2706  if(fprechecksum!=catfileheadercshex and not skipchecksum):
2707   VerbosePrintOut("File Header Checksum Error with file " + infile + " at offset " + str(catfp.tell()));
2708   return False;
2709  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
2710  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': {}};
2711  if(seekto>=fnumfiles):
2712   seekto = fnumfiles - 1;
2713  if(seekto<0):
2714   seekto = 0;
2715  if(seekto>=0):
2716   il = -1;
2717   while(il < seekto):
2718    seekstart = catfp.tell();
2719    preheaderdata = ReadFileHeaderData(catfp, 5, formatspecs[5]);
2720    prefheadsize = int(preheaderdata[0], 16);
2721    prefseek = prefheadsize - (int(len(preheaderdata[1]) + 1) + int(len(preheaderdata[2]) + 1) + int(len(preheaderdata[3]) + 1) + int(len(preheaderdata[4]) + 1));
2722    preftype = int(preheaderdata[1], 16);
2723    prefsize = int(preheaderdata[4], 16);
2724    catfp.seek(prefseek, 1);
2725    catfp.seek(1, 1);
2726    catfp.seek(prefsize, 1);
2727    catfp.seek(1, 1);
2728    il = il + 1;
2729  catfp.seek(seekstart, 0);
2730  fileidnum = il;
2731  catfheadsize = int(preheaderdata[0], 16);
2732  catftype = int(preheaderdata[1], 16);
2733  if(re.findall("^[.|/]", preheaderdata[2])):
2734   catfname = preheaderdata[2];
2735  else:
2736   catfname = "./"+preheaderdata[2];
2737  catflinkname = preheaderdata[3];
2738  catfsize = int(preheaderdata[4], 16);
2739  catfbasedir = os.path.dirname(catfname);
2740  catlist = {'fid': fileidnum, 'foffset': catfp.tell(), 'ftype': catftype, 'fname': catfname, 'fbasedir': catfbasedir, 'flinkname': catflinkname, 'fsize': catfsize};
2741  if(returnfp):
2742   catlist.update({'catfp': catfp});
2743  else:
2744   catfp.close();
2745  return catlist;
2746
2747 create_alias_function("", __file_format_name__, "SeekToFileNum", ArchiveFileSeekToFileNum);
2748
2749 def ArchiveFileSeekToFileName(infile, seekfile=None, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
2750  if(hasattr(infile, "read") or hasattr(infile, "write")):
2751   catfp = infile;
2752   catfp.seek(0, 0);
2753   catfp = UncompressArchiveFile(catfp, formatspecs);
2754   checkcompressfile = CheckCompressionSubType(catfp, formatspecs);
2755   if(checkcompressfile=="tarfile"):
2756    return TarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
2757   if(checkcompressfile=="zipfile"):
2758    return ZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
2759   if(rarfile_support and checkcompressfile=="rarfile"):
2760    return RarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
2761   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
2762    return False;
2763   if(not catfp):
2764    return False;
2765   catfp.seek(0, 0);
2766  elif(infile=="-"):
2767   catfp = BytesIO();
2768   if(hasattr(sys.stdin, "buffer")):
2769    shutil.copyfileobj(sys.stdin.buffer, catfp);
2770   else:
2771    shutil.copyfileobj(sys.stdin, catfp);
2772   catfp.seek(0, 0);
2773   catfp = UncompressArchiveFile(catfp, formatspecs);
2774   if(not catfp):
2775    return False;
2776   catfp.seek(0, 0);
2777  elif(re.findall(r"^(http|https)\:\/\/", infile)):
2778   catfp = download_file_from_http_file(infile);
2779   catfp.seek(0, 0);
2780   catfp = UncompressArchiveFile(catfp, formatspecs);
2781   if(not catfp):
2782    return False;
2783   catfp.seek(0, 0);
2784  elif(re.findall(r"^(ftp|ftps)\:\/\/", infile)):
2785   catfp = download_file_from_ftp_file(infile);
2786   catfp.seek(0, 0);
2787   catfp = UncompressArchiveFile(catfp, formatspecs);
2788   if(not catfp):
2789    return False;
2790   catfp.seek(0, 0);
2791  elif(re.findall(r"^(sftp)\:\/\/", infile) and haveparamiko):
2792   if(__use_pysftp__):
2793    catfp = download_file_from_pysftp_file(infile);
2794   else:
2795    catfp = download_file_from_sftp_file(infile);
2796   catfp.seek(0, 0);
2797   catfp = UncompressArchiveFile(catfp, formatspecs);
2798   if(not catfp):
2799    return False;
2800   catfp.seek(0, 0);
2801  else:
2802   infile = RemoveWindowsPath(infile);
2803   checkcompressfile = CheckCompressionSubType(infile, formatspecs);
2804   if(checkcompressfile=="tarfile"):
2805    return TarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
2806   if(checkcompressfile=="zipfile"):
2807    return ZipFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
2808   if(rarfile_support and checkcompressfile=="rarfile"):
2809    return RarFileToArray(infile, 0, 0, listonly, skipchecksum, formatspecs, returnfp);
2810   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
2811    return False;
2812   compresscheck = CheckCompressionType(infile, formatspecs, True);
2813   if(not compresscheck):
2814    fextname = os.path.splitext(infile)[1];
2815    if(fextname==".gz"):
2816     compresscheck = "gzip";
2817    if(fextname==".bz2"):
2818     compresscheck = "bzip2";
2819    if(fextname==".zst"):
2820     compresscheck = "zstd";
2821    if(fextname==".lz4" or fextname==".clz4"):
2822     compresscheck = "lz4";
2823    if(fextname==".lzo" or fextname==".lzop"):
2824     compresscheck = "lzo";
2825    if(fextname==".lzma" or fextname==".xz"):
2826     compresscheck = "lzma";
2827   if(not compresscheck):
2828    return False;
2829   catfp = UncompressFile(infile, formatspecs, "rb");
2830  '''
2831  try:
2832   catfp.seek(0, 2);
2833  except OSError:
2834   SeekToEndOfFile(catfp);
2835  except ValueError:
2836   SeekToEndOfFile(catfp);
2837  CatSize = catfp.tell();
2838  CatSizeEnd = CatSize;
2839  '''
2840  try:
2841   catfp.seek(0, 0);
2842  except OSError:
2843   return False;
2844  except ValueError:
2845   return False;
2846  catheader = ReadFileHeaderData(catfp, 4, formatspecs[5]);
2847  catstring = catheader[0];
2848  catversion = re.findall(r"([\d]+)$", catstring);
2849  fprenumfiles = catheader[1];
2850  fnumfiles = int(fprenumfiles, 16);
2851  fprechecksumtype = catheader[2];
2852  fprechecksum = catheader[3];
2853  fileheader = AppendNullByte(catstring, formatspecs[5]);
2854  fnumfileshex = format(int(fnumfiles), 'x').lower();
2855  fileheader = fileheader + AppendNullBytes([fnumfileshex, fprechecksumtype], formatspecs[5]);
2856  if(fprechecksumtype=="none" or fprechecksumtype==""):
2857   catfileheadercshex = format(0, 'x').lower();
2858  elif(fprechecksumtype=="crc16" or fprechecksumtype=="crc16_ansi" or fprechecksumtype=="crc16_ibm"):
2859   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
2860  elif(fprechecksumtype=="crc16_ccitt"):
2861   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
2862  elif(fprechecksumtype=="adler32"):
2863   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
2864  elif(fprechecksumtype=="crc32"):
2865   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
2866  elif(fprechecksumtype=="crc64_ecma"):
2867   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2868  elif(fprechecksumtype=="crc64" or fprechecksumtype=="crc64_iso"):
2869   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2870  elif(CheckSumSupportAlt(fprechecksumtype, hashlib_guaranteed)):
2871   checksumoutstr = hashlib.new(fprechecksumtype);
2872   checksumoutstr.update(fileheader.encode('UTF-8'));
2873   catfileheadercshex = checksumoutstr.hexdigest().lower();
2874  else:
2875   catfileheadercshex = format(0, 'x').lower();
2876  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
2877  fheadtell = len(fileheader);
2878  if(fprechecksum!=catfileheadercshex and not skipchecksum):
2879   VerbosePrintOut("File Header Checksum Error with file " + infile + " at offset " + str(catfp.tell()));
2880   return False;
2881  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
2882  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': {}};
2883  seekto = fnumfiles - 1
2884  filefound = False;
2885  if(seekto>=0):
2886   il = -1;
2887   while(il < seekto):
2888    seekstart = catfp.tell();
2889    preheaderdata = ReadFileHeaderData(catfp, 5, formatspecs[5]);
2890    prefheadsize = int(preheaderdata[0], 16);
2891    prefseek = prefheadsize - (int(len(preheaderdata[1]) + 1) + int(len(preheaderdata[2]) + 1) + int(len(preheaderdata[3]) + 1) + int(len(preheaderdata[4]) + 1));
2892    preftype = int(preheaderdata[1], 16);
2893    prefsize = int(preheaderdata[4], 16);
2894    catfp.seek(prefseek, 1);
2895    catfp.seek(1, 1);
2896    catfp.seek(prefsize, 1);
2897    catfp.seek(1, 1);
2898    il = il + 1;
2899    filefound = False;
2900    prefname = preheaderdata[2];
2901    if(re.findall("^[.|/]", preheaderdata[2])):
2902     prefname = preheaderdata[2];
2903    else:
2904     prefname = "./"+preheaderdata[2];
2905    if(prefname==seekfile):
2906     filefound = True;
2907     break;
2908  catfp.seek(seekstart, 0);
2909  fileidnum = il;
2910  catfheadsize = int(preheaderdata[0], 16);
2911  catftype = int(preheaderdata[1], 16);
2912  if(re.findall("^[.|/]", preheaderdata[2])):
2913   catfname = preheaderdata[2];
2914  else:
2915   catfname = "./"+preheaderdata[2];
2916  catflinkname = preheaderdata[3];
2917  catfsize = int(preheaderdata[4], 16);
2918  catfbasedir = os.path.dirname(catfname);
2919  if(filefound):
2920   catlist = {'fid': fileidnum, 'foffset': catfp.tell(), 'ftype': catftype, 'fname': catfname, 'fbasedir': catfbasedir, 'flinkname': catflinkname, 'fsize': catfsize};
2921  else:
2922   return False;
2923  if(returnfp):
2924   catlist.update({'catfp': catfp});
2925  else:
2926   catfp.close();
2927  return catlist;
2928
2929 create_alias_function("", __file_format_name__, "SeekToFileName", ArchiveFileSeekToFileName);
2930
2931 def ArchiveFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
2932  if(hasattr(infile, "read") or hasattr(infile, "write")):
2933   catfp = infile;
2934   catfp.seek(0, 0);
2935   catfp = UncompressArchiveFile(catfp, formatspecs);
2936   checkcompressfile = CheckCompressionSubType(catfp, formatspecs);
2937   if(checkcompressfile=="tarfile"):
2938    return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
2939   if(checkcompressfile=="zipfile"):
2940    return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
2941   if(rarfile_support and checkcompressfile=="rarfile"):
2942    return RarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
2943   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
2944    return False;
2945   if(not catfp):
2946    return False;
2947   catfp.seek(0, 0);
2948  elif(infile=="-"):
2949   catfp = BytesIO();
2950   if(hasattr(sys.stdin, "buffer")):
2951    shutil.copyfileobj(sys.stdin.buffer, catfp);
2952   else:
2953    shutil.copyfileobj(sys.stdin, catfp);
2954   catfp.seek(0, 0);
2955   catfp = UncompressArchiveFile(catfp, formatspecs);
2956   if(not catfp):
2957    return False;
2958   catfp.seek(0, 0);
2959  elif(re.findall(r"^(http|https)\:\/\/", infile)):
2960   catfp = download_file_from_http_file(infile);
2961   catfp.seek(0, 0);
2962   catfp = UncompressArchiveFile(catfp, formatspecs);
2963   if(not catfp):
2964    return False;
2965   catfp.seek(0, 0);
2966  elif(re.findall(r"^(ftp|ftps)\:\/\/", infile)):
2967   catfp = download_file_from_ftp_file(infile);
2968   catfp.seek(0, 0);
2969   catfp = UncompressArchiveFile(catfp, formatspecs);
2970   if(not catfp):
2971    return False;
2972   catfp.seek(0, 0);
2973  elif(re.findall(r"^(sftp)\:\/\/", infile) and haveparamiko):
2974   if(__use_pysftp__):
2975    catfp = download_file_from_pysftp_file(infile);
2976   else:
2977    catfp = download_file_from_sftp_file(infile);
2978   catfp.seek(0, 0);
2979   catfp = UncompressArchiveFile(catfp, formatspecs);
2980   if(not catfp):
2981    return False;
2982   catfp.seek(0, 0);
2983  else:
2984   infile = RemoveWindowsPath(infile);
2985   checkcompressfile = CheckCompressionSubType(infile, formatspecs);
2986   if(checkcompressfile=="tarfile"):
2987    return TarFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
2988   if(checkcompressfile=="zipfile"):
2989    return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
2990   if(rarfile_support and checkcompressfile=="rarfile"):
2991    return ZipFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
2992   if(checkcompressfile!="catfile" and checkcompressfile!=formatspecs[2]):
2993    return False;
2994   compresscheck = CheckCompressionType(infile, formatspecs, True);
2995   if(not compresscheck):
2996    fextname = os.path.splitext(infile)[1];
2997    if(fextname==".gz"):
2998     compresscheck = "gzip";
2999    if(fextname==".bz2"):
3000     compresscheck = "bzip2";
3001    if(fextname==".zst"):
3002     compresscheck = "zstd";
3003    if(fextname==".lz4" or fextname==".clz4"):
3004     compresscheck = "lz4";
3005    if(fextname==".lzo" or fextname==".lzop"):
3006     compresscheck = "lzo";
3007    if(fextname==".lzma" or fextname==".xz"):
3008     compresscheck = "lzma";
3009   if(not compresscheck):
3010    return False;
3011   catfp = UncompressFile(infile, formatspecs, "rb");
3012  '''
3013  try:
3014   catfp.seek(0, 2);
3015  except OSError:
3016   SeekToEndOfFile(catfp);
3017  except ValueError:
3018   SeekToEndOfFile(catfp);
3019  CatSize = catfp.tell();
3020  CatSizeEnd = CatSize;
3021  '''
3022  try:
3023   catfp.seek(0, 0);
3024  except OSError:
3025   return False;
3026  except ValueError:
3027   return False;
3028  catheader = ReadFileHeaderData(catfp, 4, formatspecs[5]);
3029  catstring = catheader[0];
3030  catversion = re.findall(r"([\d]+)$", catstring);
3031  fprenumfiles = catheader[1];
3032  fnumfiles = int(fprenumfiles, 16);
3033  fprechecksumtype = catheader[2];
3034  fprechecksum = catheader[3];
3035  fileheader = AppendNullByte(catstring, formatspecs[5]);
3036  fnumfileshex = format(int(fnumfiles), 'x').lower();
3037  fileheader = fileheader + AppendNullBytes([fnumfileshex, fprechecksumtype], formatspecs[5]);
3038  if(fprechecksumtype=="none" or fprechecksumtype==""):
3039   catfileheadercshex = format(0, 'x').lower();
3040  elif(fprechecksumtype=="crc16" or fprechecksumtype=="crc16_ansi" or fprechecksumtype=="crc16_ibm"):
3041   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
3042  elif(fprechecksumtype=="crc16_ccitt"):
3043   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
3044  elif(fprechecksumtype=="adler32"):
3045   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
3046  elif(fprechecksumtype=="crc32"):
3047   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
3048  elif(fprechecksumtype=="crc64_ecma"):
3049   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3050  elif(fprechecksumtype=="crc64" or fprechecksumtype=="crc64_iso"):
3051   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3052  elif(CheckSumSupportAlt(fprechecksumtype, hashlib_guaranteed)):
3053   checksumoutstr = hashlib.new(fprechecksumtype);
3054   checksumoutstr.update(fileheader.encode('UTF-8'));
3055   catfileheadercshex = checksumoutstr.hexdigest().lower();
3056  else:
3057   catfileheadercshex = format(0, 'x').lower();
3058  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
3059  fheadtell = len(fileheader);
3060  if(fprechecksum!=catfileheadercshex and not skipchecksum):
3061   VerbosePrintOut("File Header Checksum Error with file " + infile + " at offset " + str(catfp.tell()));
3062   return False;
3063  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
3064  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'ffilelist': {}};
3065  if(seekstart<0 and seekstart>fnumfiles):
3066    seekstart = 0;
3067  if(seekend==0 or seekend>fnumfiles and seekend<seekstart):
3068   seekend = fnumfiles;
3069  elif(seekend<0 and abs(seekend)<=fnumfiles and abs(seekend)>=seekstart):
3070   seekend = fnumfiles - abs(seekend);
3071  if(seekstart>0):
3072   il = 0;
3073   while(il < seekstart):
3074    preheaderdata = ReadFileHeaderData(catfp, 5, formatspecs[5]);
3075    prefheadsize = int(preheaderdata[0], 16);
3076    prefseek = prefheadsize - (int(len(preheaderdata[1]) + 1) + int(len(preheaderdata[2]) + 1) + int(len(preheaderdata[3]) + 1) + int(len(preheaderdata[4]) + 1));
3077    preftype = int(preheaderdata[1], 16);
3078    prefsize = int(preheaderdata[4], 16);
3079    catfp.seek(prefseek, 1);
3080    catfp.seek(1, 1);
3081    catfp.seek(prefsize, 1);
3082    catfp.seek(1, 1);
3083    il = il + 1;
3084  fileidnum = seekstart;
3085  realidnum = 0;
3086  while(fileidnum<seekend):
3087   catfhstart = catfp.tell();
3088   if(formatspecs[7]):
3089    catheaderdata = ReadFileHeaderDataBySize(catfp, formatspecs[5]);
3090   else:
3091    catheaderdata = ReadFileHeaderData(catfp, 23, formatspecs[5]);
3092   catfheadsize = int(catheaderdata[0], 16);
3093   catftype = int(catheaderdata[1], 16);
3094   if(re.findall("^[.|/]", catheaderdata[2])):
3095    catfname = catheaderdata[2];
3096   else:
3097    catfname = "./"+catheaderdata[2];
3098   catfbasedir = os.path.dirname(catfname);
3099   catflinkname = catheaderdata[3];
3100   catfsize = int(catheaderdata[4], 16);
3101   catfatime = int(catheaderdata[5], 16);
3102   catfmtime = int(catheaderdata[6], 16);
3103   catfctime = int(catheaderdata[7], 16);
3104   catfbtime = int(catheaderdata[8], 16);
3105   catfmode = int(catheaderdata[9], 16);
3106   catfchmode = stat.S_IMODE(catfmode);
3107   catftypemod = stat.S_IFMT(catfmode);
3108   catfuid = int(catheaderdata[10], 16);
3109   catfuname = catheaderdata[11];
3110   catfgid = int(catheaderdata[12], 16);
3111   catfgname = catheaderdata[13];
3112   fid = int(catheaderdata[14], 16);
3113   finode = int(catheaderdata[15], 16);
3114   flinkcount = int(catheaderdata[16], 16);
3115   catfdev_minor = int(catheaderdata[17], 16);
3116   catfdev_major = int(catheaderdata[18], 16);
3117   catfrdev_minor = int(catheaderdata[19], 16);
3118   catfrdev_major = int(catheaderdata[20], 16);
3119   catfextrasize = int(catheaderdata[21], 16);
3120   catfextrafields = int(catheaderdata[22], 16);
3121   extrafieldslist = [];
3122   if(formatspecs[7]):
3123    extrastart = 23;
3124    extraend = extrastart + catfextrafields;
3125    extrafieldslist = [];
3126    if(extrastart<extraend):
3127     extrafieldslist.append(catheaderdata[extrastart]);
3128     extrastart = extrastart + 1;
3129    catfchecksumtype = catheaderdata[extrastart].lower();
3130    catfcs = catheaderdata[extrastart + 1].lower();
3131    catfccs = catheaderdata[extrastart + 2].lower();
3132   else:
3133    extrafieldslist = [];
3134    if(formatspecs[7]):
3135     extrafieldslist = ReadFileHeaderData(catfp, catfextrafields, formatspecs[5]);
3136    checksumsval = ReadFileHeaderData(catfp, 3, formatspecs[5]);
3137    catfchecksumtype = checksumsval[0].lower();
3138    catfcs = checksumsval[1].lower();
3139    catfccs = checksumsval[2].lower();
3140   hc = 0;
3141   if(formatspecs[7]):
3142    hcmax = len(catheaderdata) - 2;
3143   else:
3144    hcmax = len(catheaderdata);
3145   hout = "";
3146   while(hc<hcmax):
3147    hout = hout + AppendNullByte(catheaderdata[hc], formatspecs[5]);
3148    hc = hc + 1;
3149   catfnumfields = 24 + catfextrafields;
3150   if(catfchecksumtype=="none" or catfchecksumtype==""):
3151    catnewfcs = 0;
3152   elif(catfchecksumtype=="crc16" or catfchecksumtype=="crc16_ansi" or catfchecksumtype=="crc16_ibm"):
3153    catnewfcs = format(crc16(hout.encode('UTF-8')) & 0xffff, '04x').lower();
3154   elif(catfchecksumtype=="adler32"):
3155    catnewfcs = format(zlib.adler32(hout.encode('UTF-8')) & 0xffffffff, '08x').lower();
3156   elif(catfchecksumtype=="crc32"):
3157    catnewfcs = format(crc32(hout.encode('UTF-8')) & 0xffffffff, '08x').lower();
3158   elif(catfchecksumtype=="crc64_ecma"):
3159    catnewfcs = format(crc64_ecma(hout.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3160   elif(catfchecksumtype=="crc64" or catfchecksumtype=="crc64_iso"):
3161    catnewfcs = format(crc64_iso(hout.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3162   elif(CheckSumSupportAlt(catfchecksumtype, hashlib_guaranteed)):
3163    checksumoutstr = hashlib.new(catfchecksumtype);
3164    checksumoutstr.update(hout.encode('UTF-8'));
3165    catnewfcs = checksumoutstr.hexdigest().lower();
3166   if(catfcs!=catnewfcs and not skipchecksum):
3167    VerbosePrintOut("File Header Checksum Error with file " + catfname + " at offset " + str(catfhstart));
3168    return False;
3169   catfhend = catfp.tell() - 1;
3170   catfcontentstart = catfp.tell();
3171   catfcontents = "";
3172   pyhascontents = False;
3173   if(catfsize>0 and not listonly):
3174    catfcontents = catfp.read(catfsize);
3175    if(catfchecksumtype=="none" or catfchecksumtype==""):
3176     catnewfccs = 0;
3177    elif(catfchecksumtype=="crc16" or catfchecksumtype=="crc16_ansi" or catfchecksumtype=="crc16_ibm"):
3178     catnewfccs = format(crc16(catfcontents) & 0xffff, '04x').lower();
3179    elif(catfchecksumtype=="crc16_ccitt"):
3180     catnewfcs = format(crc16_ccitt(catfcontents) & 0xffff, '04x').lower();
3181    elif(catfchecksumtype=="adler32"):
3182     catnewfccs = format(zlib.adler32(catfcontents) & 0xffffffff, '08x').lower();
3183    elif(catfchecksumtype=="crc32"):
3184     catnewfccs = format(crc32(catfcontents) & 0xffffffff, '08x').lower();
3185    elif(catfchecksumtype=="crc64_ecma"):
3186     catnewfcs = format(crc64_ecma(catfcontents) & 0xffffffffffffffff, '016x').lower();
3187    elif(catfchecksumtype=="crc64" or catfchecksumtype=="crc64_iso"):
3188     catnewfcs = format(crc64_iso(catfcontents) & 0xffffffffffffffff, '016x').lower();
3189    elif(CheckSumSupportAlt(catfchecksumtype, hashlib_guaranteed)):
3190     checksumoutstr = hashlib.new(catfchecksumtype);
3191     checksumoutstr.update(catfcontents);
3192     catnewfccs = checksumoutstr.hexdigest().lower();
3193    pyhascontents = True;
3194    if(catfccs!=catnewfccs and skipchecksum):
3195     VerbosePrintOut("File Content Checksum Error with file " + catfname + " at offset " + str(catfhstart));
3196     return False;
3197   if(catfsize>0 and listonly):
3198    catfp.seek(catfsize, 1);
3199    pyhascontents = False;
3200   catfp.seek(1, 1);
3201   catfcontentend = catfp.tell() - 1;
3202   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, '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, 'fextrafields': catfextrafields, 'fextrafieldsize': catfextrasize, 'fextralist': extrafieldslist, 'fheaderchecksum': catfcs, 'fcontentchecksum': catfccs, 'fhascontents': pyhascontents, 'fcontentstart': catfcontentstart, 'fcontentend': catfcontentend, 'fcontents': catfcontents} });
3203   fileidnum = fileidnum + 1;
3204   realidnum = realidnum + 1;
3205  if(returnfp):
3206   catlist.update({'catfp': catfp});
3207  else:
3208   catfp.close();
3209  return catlist;
3210
3211 create_alias_function("", __file_format_name__, "ToArray", ArchiveFileToArray);
3212
3213 def ArchiveFileStringToArray(catstr, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
3214  catfp = BytesIO(catstr);
3215  listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
3216  return listcatfiles;
3217
3218 create_alias_function("", __file_format_name__, "StringToArray", ArchiveFileStringToArray);
3219
3220 def TarFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
3221  catfp = BytesIO();
3222  catfp = PackArchiveFileFromTarFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
3223  listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
3224  return listcatfiles;
3225
3226 def ZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
3227  catfp = BytesIO();
3228  catfp = PackArchiveFileFromZipFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
3229  listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
3230  return listcatfiles;
3231
3232 if(not rarfile_support):
3233  def RarFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
3234   return False;
3235
3236 if(rarfile_support):
3237  def RarFileToArray(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
3238   catfp = BytesIO();
3239   catfp = PackArchiveFileFromRarFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
3240   listcatfiles = ArchiveFileToArray(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
3241   return listcatfiles;
3242
3243 def ListDirToArrayAlt(infiles, dirlistfromtxt=False, followlink=False, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
3244  catver = formatspecs[6];
3245  fileheaderver = str(int(catver.replace(".", "")));
3246  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
3247  advancedlist = True;
3248  infilelist = [];
3249  if(infiles=="-"):
3250   for line in sys.stdin:
3251    infilelist.append(line.strip());
3252   infilelist = list(filter(None, infilelist));
3253  elif(infiles!="-" and dirlistfromtxt and os.path.exists(infiles) and (os.path.isfile(infiles) or infiles=="/dev/null" or infiles=="NUL")):
3254   if(not os.path.exists(infiles) or not os.path.isfile(infiles)):
3255    return False;
3256   with open(infiles, "r") as finfile:
3257    for line in finfile:
3258     infilelist.append(line.strip());
3259   infilelist = list(filter(None, infilelist));
3260  else:
3261   if(isinstance(infiles, (list, tuple, ))):
3262    infilelist = list(filter(None, infiles));
3263   elif(isinstance(infiles, (str, ))):
3264    infilelist = list(filter(None, [infiles]));
3265  if(advancedlist):
3266   GetDirList = ListDirAdvanced(infilelist, followlink, False);
3267  else:
3268   GetDirList = ListDir(infilelist, followlink, False);
3269  if(not GetDirList):
3270   return False;
3271  curinode = 0;
3272  curfid = 0;
3273  inodelist = [];
3274  inodetofile = {};
3275  filetoinode = {};
3276  inodetocatinode = {};
3277  fileidnum = 0;
3278  fnumfiles = int(len(GetDirList));
3279  catver = formatspecs[6];
3280  fileheaderver = str(int(catver.replace(".", "")));
3281  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
3282  fnumfileshex = format(int(fnumfiles), 'x').lower();
3283  fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
3284  catversion = re.findall(r"([\d]+)$", fileheader);
3285  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
3286  if(checksumtype=="none" or checksumtype==""):
3287   catfileheadercshex = format(0, 'x').lower();
3288  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3289   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
3290  elif(checksumtype=="crc16_ccitt"):
3291   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
3292  elif(checksumtype=="adler32"):
3293   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
3294  elif(checksumtype=="crc32"):
3295   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
3296  elif(checksumtype=="crc64_ecma"):
3297   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3298  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3299   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3300  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3301   checksumoutstr = hashlib.new(checksumtype);
3302   checksumoutstr.update(fileheader.encode('UTF-8'));
3303   catfileheadercshex = checksumoutstr.hexdigest().lower();
3304  else:
3305   catfileheadercshex = format(0, 'x').lower();
3306  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
3307  fheadtell = len(fileheader);
3308  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
3309  for curfname in GetDirList:
3310   if(re.findall("^[.|/]", curfname)):
3311    fname = curfname;
3312   else:
3313    fname = "./"+curfname;
3314   if(verbose):
3315    VerbosePrintOut(fname);
3316   if(not followlink or followlink is None):
3317    fstatinfo = os.lstat(fname);
3318   else:
3319    fstatinfo = os.stat(fname);
3320   fpremode = fstatinfo.st_mode;
3321   finode = fstatinfo.st_ino;
3322   flinkcount = fstatinfo.st_nlink;
3323   ftype = 0;
3324   if(stat.S_ISREG(fpremode)):
3325    ftype = 0;
3326   elif(stat.S_ISLNK(fpremode)):
3327    ftype = 2;
3328   elif(stat.S_ISCHR(fpremode)):
3329    ftype = 3;
3330   elif(stat.S_ISBLK(fpremode)):
3331    ftype = 4;
3332   elif(stat.S_ISDIR(fpremode)):
3333    ftype = 5;
3334   elif(stat.S_ISFIFO(fpremode)):
3335    ftype = 6;
3336   elif(hasattr(stat, "S_ISDOOR") and stat.S_ISDOOR(fpremode)):
3337    ftype = 8;
3338   elif(hasattr(stat, "S_ISPORT") and stat.S_ISPORT(fpremode)):
3339    ftype = 9;
3340   elif(hasattr(stat, "S_ISWHT") and stat.S_ISWHT(fpremode)):
3341    ftype = 10;
3342   else:
3343    ftype = 0;
3344   flinkname = "";
3345   fbasedir = os.path.dirname(fname);
3346   fcurfid = curfid;
3347   if(not followlink and finode!=0):
3348    if(ftype!=1):
3349     if(finode in inodelist):
3350      ftype = 1;
3351      flinkname = inodetofile[finode];
3352      fcurinode = inodetocatinode[finode];
3353     if(finode not in inodelist):
3354      inodelist.append(finode);
3355      inodetofile.update({finode: fname});
3356      inodetocatinode.update({finode: curinode});
3357      fcurinode = curinode;
3358      curinode = curinode + 1;
3359   else:
3360    fcurinode = curinode;
3361    curinode = curinode + 1;
3362   curfid = curfid + 1;
3363   if(ftype==2):
3364    flinkname = os.readlink(fname);
3365   fdev = fstatinfo.st_dev;
3366   getfdev = GetDevMajorMinor(fdev);
3367   fdev_minor = getfdev[0];
3368   fdev_major = getfdev[1];
3369   frdev = fstatinfo.st_dev;
3370   if(hasattr(fstatinfo, "st_rdev")):
3371    frdev = fstatinfo.st_rdev;
3372   else:
3373    frdev = fstatinfo.st_dev;
3374   getfrdev = GetDevMajorMinor(frdev);
3375   frdev_minor = getfrdev[0];
3376   frdev_major = getfrdev[1];
3377   if(ftype==1 or ftype==2 or ftype==3 or ftype==4 or ftype==5 or ftype==6):
3378    fsize = "0";
3379   if(ftype==0 or ftype==7):
3380    fsize = fstatinfo.st_size;
3381   fatime = fstatinfo.st_atime;
3382   fmtime = fstatinfo.st_mtime;
3383   fctime = fstatinfo.st_ctime;
3384   if(hasattr(fstatinfo, "st_birthtime")):
3385    fbtime = fstatinfo.st_birthtime;
3386   else:
3387    fbtime = fstatinfo.st_ctime;
3388   fmode = fstatinfo.st_mode;
3389   fchmode = stat.S_IMODE(fstatinfo.st_mode);
3390   ftypemod = stat.S_IFMT(fstatinfo.st_mode);
3391   fuid = fstatinfo.st_uid;
3392   fgid = fstatinfo.st_gid;
3393   funame = "";
3394   try:
3395    import pwd;
3396    try:
3397     userinfo = pwd.getpwuid(fstatinfo.st_uid);
3398     funame = userinfo.pw_name;
3399    except KeyError:
3400     funame = "";
3401   except ImportError:
3402    funame = "";
3403   fgname = "";
3404   try:
3405    import grp;
3406    try:
3407     groupinfo = grp.getgrgid(fstatinfo.st_gid);
3408     fgname = groupinfo.gr_name;
3409    except KeyError:
3410     fgname = "";
3411   except ImportError:
3412    fgname = "";
3413   fdev_minor = fdev_minor;
3414   fdev_major = fdev_major;
3415   frdev_minor = frdev_minor;
3416   frdev_major = frdev_major;
3417   finode = finode;
3418   flinkcount = flinkcount;
3419   if(hasattr(fstatinfo, "st_file_attributes")):
3420    fwinattributes = fstatinfo.st_file_attributes;
3421   else:
3422    fwinattributes = 0;
3423   fcontents = "".encode('UTF-8');
3424   chunk_size = 1024;
3425   if(ftype == 0 or ftype == 7):
3426    with open(fname, "rb") as fpc:
3427     while(True):
3428      chunk = fpc.read(chunk_size);
3429      if(not chunk):
3430       break
3431      fcontents += chunk;
3432   if(followlink and (ftype == 1 or ftype == 2)):
3433    flstatinfo = os.stat(flinkname);
3434    with open(flinkname, "rb") as fpc:
3435     while(True):
3436      chunk = fpc.read(chunk_size);
3437      if(not chunk):
3438       break;
3439      fcontents += chunk;
3440   ftypehex = format(ftype, 'x').lower();
3441   extrafields = len(extradata);
3442   extrafieldslist = extradata;
3443   catfextrafields = extrafields;
3444   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
3445   if(len(extradata)>0):
3446    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
3447   extrasizelen = len(extrasizestr);
3448   extrasizelenhex = format(extrasizelen, 'x').lower();
3449   catfileoutstr = AppendNullBytes([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(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()], formatspecs[5]);
3450   if(len(extradata)>0):
3451    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
3452   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
3453   catfnumfields = 24 + catfextrafields;
3454   if(checksumtype=="none" or checksumtype==""):
3455    catfileheadercshex = format(0, 'x').lower();
3456    catfilecontentcshex = format(0, 'x').lower();
3457   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3458    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3459    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
3460   elif(checksumtype=="crc16_ccitt"):
3461    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3462    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
3463   elif(checksumtype=="adler32"):
3464    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3465    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
3466   elif(checksumtype=="crc32"):
3467    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3468    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
3469   elif(checksumtype=="crc64_ecma"):
3470    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3471    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
3472   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3473    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3474    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
3475   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3476    checksumoutstr = hashlib.new(checksumtype);
3477    checksumoutstr.update("".encode('UTF-8'));
3478    catfileheadercshex = checksumoutstr.hexdigest().lower();
3479    checksumoutstr = hashlib.new(checksumtype);
3480    checksumoutstr.update(fcontents);
3481    catfilecontentcshex = checksumoutstr.hexdigest().lower();
3482   else:
3483    catfileheadercshex = format(0, 'x').lower();
3484    catfilecontentcshex = format(0, 'x').lower();
3485   catfhstart = fheadtell;
3486   fheadtell += len(catfileoutstr);
3487   catfhend = fheadtell - 1;
3488   catfcontentstart = fheadtell;
3489   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
3490   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
3491   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
3492   if(checksumtype=="none" or checksumtype==""):
3493    catfileheadercshex = format(0, 'x').lower();
3494   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3495    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
3496   elif(checksumtype=="crc16_ccitt"):
3497    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
3498   elif(checksumtype=="adler32"):
3499    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
3500   elif(checksumtype=="crc32"):
3501    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
3502   elif(checksumtype=="crc64_ecma"):
3503    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3504   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3505    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3506   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3507    checksumoutstr = hashlib.new(checksumtype);
3508    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
3509    catfileheadercshex = checksumoutstr.hexdigest().lower();
3510   else:
3511    catfileheadercshex = format(0, 'x').lower();
3512   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
3513   catfileoutstrecd = catfileoutstr.encode('UTF-8');
3514   nullstrecd = formatspecs[5].encode('UTF-8');
3515   fheadtell += len(catfileoutstr) + 1;
3516   catfcontentend = fheadtell - 1;
3517   catfileout = catfileoutstrecd + fcontents + nullstrecd;
3518   pyhascontents = False;
3519   if(int(fsize)>0 and not listonly):
3520    pyhascontents = True;
3521   if(int(fsize)>0 and listonly):
3522    fcontents = "";
3523    pyhascontents = False;
3524   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, '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, 'fextrafields': catfextrafields, 'fextrafieldsize': extrasizelen, 'fextralist': extrafieldslist, 'fheaderchecksum': int(catfileheadercshex, 16), 'fcontentchecksum': int(catfilecontentcshex, 16), 'fhascontents': pyhascontents, 'fcontentstart': catfcontentstart, 'fcontentend': catfcontentend, 'fcontents': fcontents} });
3525   fileidnum = fileidnum + 1;
3526  return catlist;
3527
3528 def TarFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
3529  curinode = 0;
3530  curfid = 0;
3531  inodelist = [];
3532  inodetofile = {};
3533  filetoinode = {};
3534  inodetocatinode = {};
3535  fileidnum = 0;
3536  if(infile=="-"):
3537   infile = BytesIO();
3538   if(hasattr(sys.stdin, "buffer")):
3539    shutil.copyfileobj(sys.stdin.buffer, infile);
3540   else:
3541    shutil.copyfileobj(sys.stdin, infile);
3542   infile.seek(0, 0);
3543   if(not infile):
3544    return False;
3545   infile.seek(0, 0);
3546  elif(re.findall(r"^(http|https)\:\/\/", infile)):
3547   infile = download_file_from_http_file(infile);
3548   infile.seek(0, 0);
3549   if(not infile):
3550    return False;
3551   infile.seek(0, 0);
3552  elif(re.findall(r"^(ftp|ftps)\:\/\/", infile)):
3553   infile = download_file_from_ftp_file(infile);
3554   infile.seek(0, 0);
3555   if(not infile):
3556    return False;
3557   infile.seek(0, 0);
3558  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
3559   return False;
3560  elif(os.path.exists(infile) and os.path.isfile(infile)):
3561   try:
3562    if(not tarfile.is_tarfile(infile)):
3563     return False;
3564   except AttributeError:
3565    if(not is_tarfile(infile)):
3566     return False;
3567  else:
3568   return False;
3569  try:
3570   if(hasattr(infile, "read") or hasattr(infile, "write")):
3571    tarfp = tarfile.open(fileobj=infile, mode="r");
3572   else:
3573    tarfp = tarfile.open(infile, "r");
3574  except FileNotFoundError:
3575   return False;
3576  fnumfiles = int(len(tarfp.getmembers()));
3577  catver = formatspecs[6];
3578  fileheaderver = str(int(catver.replace(".", "")));
3579  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
3580  fnumfileshex = format(int(fnumfiles), 'x').lower();
3581  fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
3582  catversion = re.findall(r"([\d]+)$", fileheader);
3583  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
3584  if(checksumtype=="none" or checksumtype==""):
3585   catfileheadercshex = format(0, 'x').lower();
3586  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3587   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
3588  elif(checksumtype=="crc16_ccitt"):
3589   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
3590  elif(checksumtype=="adler32"):
3591   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
3592  elif(checksumtype=="crc32"):
3593   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
3594  elif(checksumtype=="crc64_ecma"):
3595   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3596  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3597   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3598  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3599   checksumoutstr = hashlib.new(checksumtype);
3600   checksumoutstr.update(fileheader.encode('UTF-8'));
3601   catfileheadercshex = checksumoutstr.hexdigest().lower();
3602  else:
3603   catfileheadercshex = format(0, 'x').lower();
3604  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
3605  fheadtell = len(fileheader);
3606  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
3607  for member in sorted(tarfp.getmembers(), key=lambda x: x.name):
3608   if(re.findall("^[.|/]", member.name)):
3609    fname = member.name;
3610   else:
3611    fname = "./"+member.name;
3612   if(verbose):
3613    VerbosePrintOut(fname);
3614   fpremode = member.mode;
3615   ffullmode = member.mode;
3616   flinkcount = 0;
3617   ftype = 0;
3618   if(member.isreg()):
3619    ffullmode = member.mode + stat.S_IFREG;
3620    ftype = 0;
3621   elif(member.isdev()):
3622    ffullmode = member.mode;
3623    ftype = 7;
3624   elif(member.islnk()):
3625    ffullmode = member.mode + stat.S_IFREG;
3626    ftype = 1;
3627   elif(member.issym()):
3628    ffullmode = member.mode + stat.S_IFLNK;
3629    ftype = 2;
3630   elif(member.ischr()):
3631    ffullmode = member.mode + stat.S_IFCHR;
3632    ftype = 3;
3633   elif(member.isblk()):
3634    ffullmode = member.mode + stat.S_IFBLK;
3635    ftype = 4;
3636   elif(member.isdir()):
3637    ffullmode = member.mode + stat.S_IFDIR;
3638    ftype = 5;
3639   elif(member.isfifo()):
3640    ffullmode = member.mode + stat.S_IFIFO;
3641    ftype = 6;
3642   elif(member.issparse()):
3643    ffullmode = member.mode;
3644    ftype = 8;
3645   else:
3646    ffullmode = member.mode;
3647    ftype = 0;
3648   flinkname = "";
3649   fbasedir = os.path.dirname(fname);
3650   fcurfid = curfid;
3651   fcurinode = 0;
3652   finode = fcurinode;
3653   curfid = curfid + 1;
3654   if(ftype==2):
3655    flinkname = member.linkname;
3656   fdev_minor = member.devminor;
3657   fdev_major = member.devmajor;
3658   frdev_minor = member.devminor;
3659   frdev_major = member.devmajor;
3660   if(ftype==1 or ftype==2 or ftype==3 or ftype==4 or ftype==5 or ftype==6):
3661    fsize = "0";
3662   elif(ftype==0 or ftype==7):
3663    fsize = member.size;
3664   else:
3665    fsize = member.size;
3666   fatime = member.mtime;
3667   fmtime = member.mtime;
3668   fctime = member.mtime;
3669   fbtime = member.mtime;
3670   fmode = ffullmode;
3671   fchmode = stat.S_IMODE(ffullmode);
3672   ftypemod = stat.S_IFMT(ffullmode);
3673   fuid = member.uid;
3674   fgid = member.gid;
3675   funame = member.uname;
3676   fgname = member.gname;
3677   flinkcount = flinkcount;
3678   fcontents = "".encode('UTF-8');
3679   chunk_size = 1024;
3680   if(ftype == 0 or ftype == 7):
3681    with tarfp.extractfile(member) as fpc:
3682     while(True):
3683      chunk = fpc.read(chunk_size);
3684      if(not chunk):
3685       break
3686      fcontents += chunk;
3687   ftypehex = format(ftype, 'x').lower();
3688   extrafields = len(extradata);
3689   extrafieldslist = extradata;
3690   catfextrafields = extrafields;
3691   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
3692   if(len(extradata)>0):
3693    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
3694   extrasizelen = len(extrasizestr);
3695   extrasizelenhex = format(extrasizelen, 'x').lower();
3696   catfileoutstr = AppendNullBytes([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(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()], formatspecs[5]);
3697   if(len(extradata)>0):
3698    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
3699   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
3700   catfnumfields = 24 + catfextrafields;
3701   if(checksumtype=="none" or checksumtype==""):
3702    catfileheadercshex = format(0, 'x').lower();
3703    catfilecontentcshex = format(0, 'x').lower();
3704   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3705    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3706    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
3707   elif(checksumtype=="crc16_ccitt"):
3708    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3709    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
3710   elif(checksumtype=="adler32"):
3711    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3712    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
3713   elif(checksumtype=="crc32"):
3714    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3715    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
3716   elif(checksumtype=="crc64_ecma"):
3717    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3718    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
3719   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3720    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3721    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
3722   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3723    checksumoutstr = hashlib.new(checksumtype);
3724    checksumoutstr.update("".encode('UTF-8'));
3725    catfileheadercshex = checksumoutstr.hexdigest().lower();
3726    checksumoutstr = hashlib.new(checksumtype);
3727    checksumoutstr.update(fcontents);
3728    catfilecontentcshex = checksumoutstr.hexdigest().lower();
3729   else:
3730    catfileheadercshex = format(0, 'x').lower();
3731    catfilecontentcshex = format(0, 'x').lower();
3732   catfhstart = fheadtell;
3733   fheadtell += len(catfileoutstr);
3734   catfhend = fheadtell - 1;
3735   catfcontentstart = fheadtell;
3736   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
3737   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
3738   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
3739   if(checksumtype=="none" or checksumtype==""):
3740    catfileheadercshex = format(0, 'x').lower();
3741   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3742    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
3743   elif(checksumtype=="crc16_ccitt"):
3744    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
3745   elif(checksumtype=="adler32"):
3746    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
3747   elif(checksumtype=="crc32"):
3748    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
3749   elif(checksumtype=="crc64_ecma"):
3750    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3751   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3752    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3753   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3754    checksumoutstr = hashlib.new(checksumtype);
3755    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
3756    catfileheadercshex = checksumoutstr.hexdigest().lower();
3757   else:
3758    catfileheadercshex = format(0, 'x').lower();
3759   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
3760   catfileoutstrecd = catfileoutstr.encode('UTF-8');
3761   nullstrecd = formatspecs[5].encode('UTF-8');
3762   fheadtell += len(catfileoutstr) + 1;
3763   catfcontentend = fheadtell - 1;
3764   catfileout = catfileoutstrecd + fcontents + nullstrecd;
3765   pyhascontents = False;
3766   if(int(fsize)>0 and not listonly):
3767    pyhascontents = True;
3768   if(int(fsize)>0 and listonly):
3769    fcontents = "";
3770    pyhascontents = False;
3771   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, '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, 'fextrafields': catfextrafields, 'fextrafieldsize': extrasizelen, 'fextralist': extrafieldslist, 'fheaderchecksum': int(catfileheadercshex, 16), 'fcontentchecksum': int(catfilecontentcshex, 16), 'fhascontents': pyhascontents, 'fcontentstart': catfcontentstart, 'fcontentend': catfcontentend, 'fcontents': fcontents} });
3772   fileidnum = fileidnum + 1;
3773  return catlist;
3774
3775 def ZipFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
3776  advancedlist = True;
3777  curinode = 0;
3778  curfid = 0;
3779  inodelist = [];
3780  inodetofile = {};
3781  filetoinode = {};
3782  inodetocatinode = {};
3783  fileidnum = 0;
3784  if(infile=="-"):
3785   infile = BytesIO();
3786   if(hasattr(sys.stdin, "buffer")):
3787    shutil.copyfileobj(sys.stdin.buffer, infile);
3788   else:
3789    shutil.copyfileobj(sys.stdin, infile);
3790   infile.seek(0, 0);
3791   if(not infile):
3792    return False;
3793   infile.seek(0, 0);
3794  elif(re.findall(r"^(http|https)\:\/\/", infile)):
3795   infile = download_file_from_http_file(infile);
3796   infile.seek(0, 0);
3797   if(not infile):
3798    return False;
3799   infile.seek(0, 0);
3800  elif(re.findall(r"^(ftp|ftps)\:\/\/", infile)):
3801   infile = download_file_from_ftp_file(infile);
3802   infile.seek(0, 0);
3803   if(not infile):
3804    return False;
3805   infile.seek(0, 0);
3806  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
3807   return False;
3808  else:
3809   return False;
3810  if(not zipfile.is_zipfile(infile)):
3811   return False;
3812  try:
3813   zipfp = zipfile.ZipFile(infile, "r", allowZip64=True);
3814  except FileNotFoundError:
3815   return False;
3816  ziptest = zipfp.testzip();
3817  if(ziptest):
3818   VerbosePrintOut("Bad file found!");
3819  fnumfiles = int(len(zipfp.infolist()));
3820  catver = formatspecs[6];
3821  fileheaderver = str(int(catver.replace(".", "")));
3822  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
3823  catversion = re.findall(r"([\d]+)$", fileheader);
3824  catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
3825  fnumfileshex = format(int(fnumfiles), 'x').lower();
3826  fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
3827  if(checksumtype=="none" or checksumtype==""):
3828   catfileheadercshex = format(0, 'x').lower();
3829  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3830   catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
3831  elif(checksumtype=="crc16_ccitt"):
3832   catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
3833  elif(checksumtype=="adler32"):
3834   catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
3835  elif(checksumtype=="crc32"):
3836   catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
3837  elif(checksumtype=="crc64_ecma"):
3838   catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3839  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3840   catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3841  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3842   checksumoutstr = hashlib.new(checksumtype);
3843   checksumoutstr.update(fileheader.encode('UTF-8'));
3844   catfileheadercshex = checksumoutstr.hexdigest().lower();
3845  else:
3846   catfileheadercshex = format(0, 'x').lower();
3847  fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
3848  fheadtell = len(fileheader);
3849  catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
3850  for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
3851   if(re.findall("^[.|/]", member.filename)):
3852    fname = member.filename;
3853   else:
3854    fname = "./"+member.filename;
3855   zipinfo = zipfp.getinfo(member.filename);
3856   if(verbose):
3857    VerbosePrintOut(fname);
3858   if(not member.is_dir()):
3859    fpremode = stat.S_IFREG + 438;
3860   elif(member.is_dir()):
3861    fpremode = stat.S_IFDIR + 511;
3862   flinkcount = 0;
3863   ftype = 0;
3864   if(not member.is_dir()):
3865    ftype = 0;
3866   elif(member.is_dir()):
3867    ftype = 5;
3868   flinkname = "";
3869   fbasedir = os.path.dirname(fname);
3870   fcurfid = curfid;
3871   fcurinode = 0;
3872   finode = fcurinode;
3873   curfid = curfid + 1;
3874   fdev_minor = 0;
3875   fdev_major = 0;
3876   frdev_minor = 0;
3877   frdev_major = 0;
3878   if(ftype==5):
3879    fsize = "0";
3880   elif(ftype==0):
3881    fsize = member.file_size;
3882   else:
3883    fsize = member.file_size;
3884   fatime = time.mktime(member.date_time + (0, 0, -1));
3885   fmtime = time.mktime(member.date_time + (0, 0, -1));
3886   fctime = time.mktime(member.date_time + (0, 0, -1));
3887   fbtime = time.mktime(member.date_time + (0, 0, -1));
3888   if(not member.is_dir()):
3889    fmode = stat.S_IFREG + 438;
3890    fchmode = stat.S_IMODE(int(stat.S_IFREG + 438));
3891    ftypemod = stat.S_IFMT(int(stat.S_IFREG + 438));
3892   if(member.is_dir()):
3893    fmode = stat.S_IFDIR + 511;
3894    fchmode = stat.S_IMODE(int(stat.S_IFDIR + 511));
3895    ftypemod = stat.S_IFMT(int(stat.S_IFDIR + 511));
3896   try:
3897    fuid = os.getuid();
3898   except AttributeError:
3899    fuid = 0;
3900   except KeyError:
3901    fuid = 0;
3902   try:
3903    fgid = os.getgid();
3904   except AttributeError:
3905    fgid = 0;
3906   except KeyError:
3907    fgid = 0;
3908   try:
3909    import pwd;
3910    try:
3911     userinfo = pwd.getpwuid(os.getuid());
3912     funame = userinfo.pw_name;
3913    except KeyError:
3914     funame = "";
3915    except AttributeError:
3916     funame = "";
3917   except ImportError:
3918    funame = "";
3919   fgname = "";
3920   try:
3921    import grp;
3922    try:
3923     groupinfo = grp.getgrgid(os.getgid());
3924     fgname = groupinfo.gr_name;
3925    except KeyError:
3926     fgname = "";
3927    except AttributeError:
3928     fgname = "";
3929   except ImportError:
3930    fgname = "";
3931   fcontents = "".encode('UTF-8');
3932   if(ftype==0):
3933    fcontents = zipfp.read(member.filename);
3934   ftypehex = format(ftype, 'x').lower();
3935   extrafields = len(extradata);
3936   extrafieldslist = extradata;
3937   catfextrafields = extrafields;
3938   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
3939   if(len(extradata)>0):
3940    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
3941   extrasizelen = len(extrasizestr);
3942   extrasizelenhex = format(extrasizelen, 'x').lower();
3943   catfileoutstr = AppendNullBytes([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(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()], formatspecs[5]);
3944   if(len(extradata)>0):
3945    catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
3946   catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
3947   catfnumfields = 24 + catfextrafields;
3948   if(checksumtype=="none" or checksumtype==""):
3949    catfileheadercshex = format(0, 'x').lower();
3950    catfilecontentcshex = format(0, 'x').lower();
3951   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3952    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3953    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
3954   elif(checksumtype=="crc16_ccitt"):
3955    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3956    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
3957   elif(checksumtype=="adler32"):
3958    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3959    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
3960   elif(checksumtype=="crc32"):
3961    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3962    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
3963   elif(checksumtype=="crc64_ecma"):
3964    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3965    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
3966   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3967    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3968    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
3969   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
3970    checksumoutstr = hashlib.new(checksumtype);
3971    checksumoutstr.update("".encode('UTF-8'));
3972    catfileheadercshex = checksumoutstr.hexdigest().lower();
3973    checksumoutstr = hashlib.new(checksumtype);
3974    checksumoutstr.update(fcontents);
3975    catfilecontentcshex = checksumoutstr.hexdigest().lower();
3976   else:
3977    catfileheadercshex = format(0, 'x').lower();
3978    catfilecontentcshex = format(0, 'x').lower();
3979   catfhstart = fheadtell;
3980   fheadtell += len(catfileoutstr);
3981   catfhend = fheadtell - 1;
3982   catfcontentstart = fheadtell;
3983   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
3984   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
3985   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
3986   if(checksumtype=="none" or checksumtype==""):
3987    catfileheadercshex = format(0, 'x').lower();
3988   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
3989    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
3990   elif(checksumtype=="crc16_ccitt"):
3991    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
3992   elif(checksumtype=="adler32"):
3993    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
3994   elif(checksumtype=="crc32"):
3995    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
3996   elif(checksumtype=="crc64_ecma"):
3997    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3998   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
3999    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4000   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
4001    checksumoutstr = hashlib.new(checksumtype);
4002    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
4003    catfileheadercshex = checksumoutstr.hexdigest().lower();
4004   else:
4005    catfileheadercshex = format(0, 'x').lower();
4006   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
4007   catfileoutstrecd = catfileoutstr.encode('UTF-8');
4008   nullstrecd = formatspecs[5].encode('UTF-8');
4009   fheadtell += len(catfileoutstr) + 1;
4010   catfcontentend = fheadtell - 1;
4011   catfileout = catfileoutstrecd + fcontents + nullstrecd;
4012   pyhascontents = False;
4013   if(int(fsize)>0 and not listonly):
4014    pyhascontents = True;
4015   if(int(fsize)>0 and listonly):
4016    fcontents = "";
4017    pyhascontents = False;
4018   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, '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, 'fextrafields': catfextrafields, 'fextrafieldsize': extrasizelen, 'fextralist': extrafieldslist, 'fheaderchecksum': int(catfileheadercshex, 16), 'fcontentchecksum': int(catfilecontentcshex, 16), 'fhascontents': pyhascontents, 'fcontentstart': catfcontentstart, 'fcontentend': catfcontentend, 'fcontents': fcontents} });
4019   fileidnum = fileidnum + 1;
4020  return catlist;
4021
4022 if(not rarfile_support):
4023  def RarFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
4024   return False;
4025
4026 if(rarfile_support):
4027  def RarFileToArrayAlt(infiles, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
4028   advancedlist = True;
4029   curinode = 0;
4030   curfid = 0;
4031   inodelist = [];
4032   inodetofile = {};
4033   filetoinode = {};
4034   inodetocatinode = {};
4035   fileidnum = 0;
4036   if(not os.path.exists(infiles) or not os.path.isfile(infiles)):
4037    return False;
4038   if(not rarfile.is_rarfile(infile) and not rarfile.is_rarfile_sfx(infile)):
4039    return False;
4040   rarfp = rarfile.RarFile(infile, "r");
4041   rartest = rarfp.testrar();
4042   if(rartest):
4043    VerbosePrintOut("Bad file found!");
4044   fnumfiles = int(len(rarfp.infolist()));
4045   catver = formatspecs[6];
4046   fileheaderver = str(int(catver.replace(".", "")));
4047   fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
4048   catversion = re.findall(r"([\d]+)$", fileheader);
4049   catversions = re.search(r'(.*?)(\d+)$', catstring).groups();
4050   fnumfileshex = format(int(fnumfiles), 'x').lower();
4051   fileheader = fileheader + AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
4052   if(checksumtype=="none" or checksumtype==""):
4053    catfileheadercshex = format(0, 'x').lower();
4054   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
4055    catfileheadercshex = format(crc16(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4056   elif(checksumtype=="crc16_ccitt"):
4057    catfileheadercshex = format(crc16_ccitt(fileheader.encode('UTF-8')) & 0xffff, '04x').lower();
4058   elif(checksumtype=="adler32"):
4059    catfileheadercshex = format(zlib.adler32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4060   elif(checksumtype=="crc32"):
4061    catfileheadercshex = format(crc32(fileheader.encode('UTF-8')) & 0xffffffff, '08x').lower();
4062   elif(checksumtype=="crc64_ecma"):
4063    catfileheadercshex = format(crc64_ecma(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4064   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
4065    catfileheadercshex = format(crc64_iso(fileheader.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4066   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
4067    checksumoutstr = hashlib.new(checksumtype);
4068    checksumoutstr.update(fileheader.encode('UTF-8'));
4069    catfileheadercshex = checksumoutstr.hexdigest().lower();
4070   else:
4071    catfileheadercshex = format(0, 'x').lower();
4072   fileheader = fileheader + AppendNullByte(catfileheadercshex, formatspecs[5]);
4073   fheadtell = len(fileheader);
4074   catlist = {'fnumfiles': fnumfiles, 'fformat': catversions[0], 'fversion': catversions[1], 'fformatspecs': formatspecs, 'fchecksumtype': checksumtype, 'fheaderchecksum': catfileheadercshex, 'ffilelist': {}};
4075   for member in sorted(rarfp.infolist(), key=lambda x: x.filename):
4076    is_unix = False;
4077    is_windows = False;
4078    if(member.host_os == rarfile.RAR_OS_UNIX):
4079     is_windows = False;
4080     try:
4081      member.external_attr
4082      is_unix = True;
4083     except AttributeError:
4084      is_unix = False;
4085    elif(member.host_os == rarfile.RAR_OS_WIN32):
4086     is_unix = False;
4087     try:
4088      member.external_attr
4089      is_windows = True;
4090     except AttributeError:
4091      is_windows = False;
4092    else:
4093     is_unix = False;
4094     is_windows = False;
4095    if(re.findall("^[.|/]", member.filename)):
4096     fname = member.filename;
4097    else:
4098     fname = "./"+member.filename;
4099    rarinfo = rarfp.getinfo(member.filename);
4100    if(verbose):
4101     VerbosePrintOut(fname);
4102    if(is_unix and member.external_attr !=0):
4103     fpremode = int(member.external_attr);
4104    elif(member.is_file()):
4105     fpremode = stat.S_IFREG + 438;
4106    elif(member.is_symlink()):
4107     fpremode = stat.S_IFLNK + 438;
4108    elif(member.is_dir()):
4109     fpremode = stat.S_IFDIR + 511;
4110    if(is_windows and member.external_attr !=0):
4111     fwinattributes = int(member.external_attr);
4112    else:
4113     fwinattributes = int(0);
4114    flinkcount = 0;
4115    ftype = 0;
4116    if(member.is_file()):
4117     ftype = 0;
4118    elif(member.is_symlink()):
4119     ftype = 2;
4120    elif(member.is_dir()):
4121     ftype = 5;
4122    flinkname = "";
4123    if(ftype==2):
4124     flinkname = rarfp.read(member.filename).decode("UTF-8");
4125    fbasedir = os.path.dirname(fname);
4126    fcurfid = curfid;
4127    fcurinode = 0;
4128    finode = fcurinode;
4129    curfid = curfid + 1;
4130    fdev_minor = 0;
4131    fdev_major = 0;
4132    frdev_minor = 0;
4133    frdev_major = 0;
4134    if(ftype==5):
4135     fsize = "0";
4136    if(ftype==0):
4137     fsize = member.file_size;
4138    try:
4139     if(member.atime):
4140      fatime = int(member.atime.timestamp());
4141     else:
4142      fatime = int(member.mtime.timestamp());
4143    except AttributeError:
4144     fatime = int(member.mtime.timestamp());
4145    fmtime = int(member.mtime.timestamp());
4146    try:
4147     if(member.ctime):
4148      fctime = int(member.ctime.timestamp());
4149     else:
4150      fctime = int(member.mtime.timestamp());
4151    except AttributeError:
4152     fctime = int(member.mtime.timestamp());
4153    fbtime = int(member.mtime.timestamp());
4154    if(is_unix and member.external_attr !=0):
4155     fmode = format(int(member.external_attr), 'x').lower();
4156     fchmode = format(int(stat.S_IMODE(member.external_attr)), 'x').lower();
4157     ftypemod = format(int(stat.S_IFMT(member.external_attr)), 'x').lower();
4158    elif(member.is_file()):
4159     fmode = int(stat.S_IFREG + 438)
4160     fchmode = int(stat.S_IMODE(stat.S_IFREG + 438));
4161     ftypemod = int(stat.S_IFMT(stat.S_IFREG + 438));
4162    elif(member.is_symlink()):
4163     fmode = int(stat.S_IFLNK + 438)
4164     fchmode = int(stat.S_IMODE(stat.S_IFREG + 438));
4165     ftypemod = int(stat.S_IFMT(stat.S_IFREG + 438));
4166    elif(member.is_dir()):
4167     fmode = int(stat.S_IFDIR + 511)
4168     fchmode = int(stat.S_IMODE(stat.S_IFDIR + 511));
4169     ftypemod = int(stat.S_IFMT(stat.S_IFDIR + 511));
4170    try:
4171     fuid = os.getuid();
4172    except AttributeError:
4173     fuid = 0;
4174    except KeyError:
4175     fuid = 0;
4176    try:
4177     fgid = os.getgid();
4178    except AttributeError:
4179     fgid = 0;
4180    except KeyError:
4181     fgid = 0;
4182    try:
4183     import pwd;
4184     try:
4185      userinfo = pwd.getpwuid(os.getuid());
4186      funame = userinfo.pw_name;
4187     except KeyError:
4188      funame = "";
4189     except AttributeError:
4190      funame = "";
4191    except ImportError:
4192     funame = "";
4193    fgname = "";
4194    try:
4195     import grp;
4196     try:
4197      groupinfo = grp.getgrgid(os.getgid());
4198      fgname = groupinfo.gr_name;
4199     except KeyError:
4200      fgname = "";
4201     except AttributeError:
4202      fgname = "";
4203    except ImportError:
4204     fgname = "";
4205    fcontents = "".encode('UTF-8');
4206    if(ftype==0):
4207     fcontents = rarfp.read(member.filename);
4208    ftypehex = format(ftype, 'x').lower();
4209    extrafields = len(extradata);
4210    extrafieldslist = extradata;
4211    catfextrafields = extrafields;
4212    extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
4213    if(len(extradata)>0):
4214     extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
4215    extrasizelen = len(extrasizestr);
4216    extrasizelenhex = format(extrasizelen, 'x').lower();
4217    catfileoutstr = AppendNullBytes([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(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()], formatspecs[5]);
4218    if(len(extradata)>0):
4219     catfileoutstr = catfileoutstr + AppendNullBytes(extradata, formatspecs[5]);
4220    catfileoutstr = catfileoutstr + AppendNullByte(checksumtype, formatspecs[5]);
4221    catfnumfields = 24 + catfextrafields;
4222    if(checksumtype=="none" or checksumtype==""):
4223     catfileheadercshex = format(0, 'x').lower();
4224     catfilecontentcshex = format(0, 'x').lower();
4225    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
4226     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
4227     catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
4228    elif(checksumtype=="crc16_ccitt"):
4229     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
4230     catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
4231    elif(checksumtype=="adler32"):
4232     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
4233     catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
4234    elif(checksumtype=="crc32"):
4235     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
4236     catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
4237    elif(checksumtype=="crc64_ecma"):
4238     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4239     catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
4240    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
4241     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4242     catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
4243    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
4244     checksumoutstr = hashlib.new(checksumtype);
4245     checksumoutstr.update(catfileoutstr.encode('UTF-8'));
4246     catfileheadercshex = checksumoutstr.hexdigest().lower();
4247    else:
4248     catfileheadercshex = format(0, 'x').lower();
4249     catfilecontentcshex = format(0, 'x').lower();
4250    catfhstart = fheadtell;
4251    fheadtell += len(catfileoutstr);
4252    catfhend = fheadtell - 1;
4253    catfcontentstart = fheadtell;
4254    tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
4255    catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
4256    catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
4257    if(checksumtype=="none" or checksumtype==""):
4258     catfileheadercshex = format(0, 'x').lower();
4259    elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
4260     catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
4261    elif(checksumtype=="crc16_ccitt"):
4262     catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
4263    elif(checksumtype=="adler32"):
4264     catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
4265    elif(checksumtype=="crc32"):
4266     catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
4267    elif(checksumtype=="crc64_ecma"):
4268     catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4269    elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
4270     catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4271    elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
4272     checksumoutstr = hashlib.new(checksumtype);
4273     checksumoutstr.update(catfileoutstr.encode('UTF-8'));
4274     catfileheadercshex = checksumoutstr.hexdigest().lower();
4275    else:
4276     catfileheadercshex = format(0, 'x').lower();
4277    catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
4278    catfileoutstrecd = catfileoutstr.encode('UTF-8');
4279    nullstrecd = formatspecs[5].encode('UTF-8');
4280    fheadtell += len(catfileoutstr) + 1;
4281    catfcontentend = fheadtell - 1;
4282    catfileout = catfileoutstrecd + fcontents + nullstrecd;
4283    pyhascontents = False;
4284    if(int(fsize)>0 and not listonly):
4285     pyhascontents = True;
4286    if(int(fsize)>0 and listonly):
4287     fcontents = "";
4288     pyhascontents = False;
4289    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, '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, 'fextrafields': catfextrafields, 'fextrafieldsize': extrasizelen, 'fextralist': extrafieldslist, 'fheaderchecksum': int(catfileheadercshex, 16), 'fcontentchecksum': int(catfilecontentcshex, 16), 'fhascontents': pyhascontents, 'fcontentstart': catfcontentstart, 'fcontentend': catfcontentend, 'fcontents': fcontents} });
4290    fileidnum = fileidnum + 1;
4291   return catlist;
4292
4293 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):
4294  outarray = BytesIO();
4295  packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, True);
4296  listcatfiles = ArchiveFileToArray(outarray, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4297  return listcatfiles;
4298
4299 def ArchiveFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4300  if(isinstance(infile, dict)):
4301   listcatfiles = infile;
4302  else:
4303   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
4304    infile = RemoveWindowsPath(infile);
4305   listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4306  if(not listcatfiles):
4307   return False;
4308  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': {}}}};
4309  if(returnfp):
4310   catarray.update({'catfp': listcatfiles['catfp']});
4311  lenlist = len(listcatfiles['ffilelist']);
4312  if(seekstart>0):
4313   lcfi = seekstart;
4314  else:
4315   lcfi = 0;
4316  if(seekend>0 and seekend<listcatfiles['fnumfiles']):
4317   lcfx = seekend;
4318  else:
4319   if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
4320    lcfx = listcatfiles['fnumfiles'];
4321   else:
4322    lcfx = int(listcatfiles['fnumfiles']);
4323  while(lcfi < lcfx):
4324   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
4325   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
4326   catarray['filetoid'].update(filetoidarray);
4327   catarray['idtofile'].update(idtofilearray);
4328   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
4329    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
4330    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
4331   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
4332    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
4333    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
4334    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
4335    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
4336   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
4337    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
4338    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
4339    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
4340    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
4341   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
4342    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
4343    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
4344    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
4345    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
4346   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
4347    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
4348    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
4349    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
4350    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
4351   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
4352    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
4353    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
4354   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
4355    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
4356    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
4357    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
4358    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
4359   lcfi = lcfi + 1;
4360  return catarray;
4361
4362 create_alias_function("", __file_format_name__, "ToArrayIndex", ArchiveFileToArrayIndex);
4363
4364 def ListDirToArrayIndexAlt(infiles, dirlistfromtxt=False, followlink=False, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
4365  listcatfiles = ListDirToArrayAlt(infiles, dirlistfromtxt, followlink, listonly, checksumtype, extradata, formatspecs, verbose);
4366  if(not listcatfiles):
4367   return False;
4368  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': {}}}};
4369  lenlist = len(listcatfiles['ffilelist']);
4370  if(seekstart>0):
4371   lcfi = seekstart;
4372  else:
4373   lcfi = 0;
4374  if(seekend>0 and seekend<listcatfiles['fnumfiles']):
4375   lcfx = seekend;
4376  else:
4377   if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
4378    lcfx = listcatfiles['fnumfiles'];
4379   else:
4380    lcfx = int(listcatfiles['fnumfiles']);
4381  while(lcfi < lcfx):
4382   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
4383   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
4384   catarray['filetoid'].update(filetoidarray);
4385   catarray['idtofile'].update(idtofilearray);
4386   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
4387    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
4388    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
4389   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
4390    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
4391    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
4392    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
4393    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
4394   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
4395    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
4396    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
4397    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
4398    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
4399   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
4400    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
4401    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
4402    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
4403    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
4404   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
4405    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
4406    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
4407    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
4408    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
4409   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
4410    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
4411    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
4412   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
4413    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
4414    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
4415    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
4416    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
4417   lcfi = lcfi + 1;
4418  return catarray;
4419
4420 def TarFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
4421  listcatfiles = TarFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
4422  if(not listcatfiles):
4423   return False;
4424  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': {}}}};
4425  lenlist = len(listcatfiles['ffilelist']);
4426  if(seekstart>0):
4427   lcfi = seekstart;
4428  else:
4429   lcfi = 0;
4430  if(seekend>0 and seekend<listcatfiles['fnumfiles']):
4431   lcfx = seekend;
4432  else:
4433   if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
4434    lcfx = listcatfiles['fnumfiles'];
4435   else:
4436    lcfx = int(listcatfiles['fnumfiles']);
4437  while(lcfi < lcfx):
4438   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
4439   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
4440   catarray['filetoid'].update(filetoidarray);
4441   catarray['idtofile'].update(idtofilearray);
4442   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
4443    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
4444    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
4445   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
4446    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
4447    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
4448    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
4449    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
4450   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
4451    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
4452    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
4453    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
4454    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
4455   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
4456    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
4457    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
4458    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
4459    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
4460   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
4461    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
4462    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
4463    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
4464    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
4465   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
4466    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
4467    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
4468   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
4469    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
4470    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
4471    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
4472    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
4473   lcfi = lcfi + 1;
4474  return catarray;
4475
4476 def ZipFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
4477  listcatfiles = ZipFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
4478  if(not listcatfiles):
4479   return False;
4480  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': {}}}};
4481  lenlist = len(listcatfiles['ffilelist']);
4482  if(seekstart>0):
4483   lcfi = seekstart;
4484  else:
4485   lcfi = 0;
4486  if(seekend>0 and seekend<listcatfiles['fnumfiles']):
4487   lcfx = seekend;
4488  else:
4489   if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
4490    lcfx = listcatfiles['fnumfiles'];
4491   else:
4492    lcfx = int(listcatfiles['fnumfiles']);
4493  while(lcfi < lcfx):
4494   filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
4495   idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
4496   catarray['filetoid'].update(filetoidarray);
4497   catarray['idtofile'].update(idtofilearray);
4498   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
4499    catarray['filetypes']['files']['filetoid'].update(filetoidarray);
4500    catarray['filetypes']['files']['idtofile'].update(idtofilearray);
4501   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
4502    catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
4503    catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
4504    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
4505    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
4506   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
4507    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
4508    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
4509    catarray['filetypes']['links']['filetoid'].update(filetoidarray);
4510    catarray['filetypes']['links']['idtofile'].update(idtofilearray);
4511   if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
4512    catarray['filetypes']['character']['filetoid'].update(filetoidarray);
4513    catarray['filetypes']['character']['idtofile'].update(idtofilearray);
4514    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
4515    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
4516   if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
4517    catarray['filetypes']['block']['filetoid'].update(filetoidarray);
4518    catarray['filetypes']['block']['idtofile'].update(idtofilearray);
4519    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
4520    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
4521   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
4522    catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
4523    catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
4524   if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
4525    catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
4526    catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
4527    catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
4528    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
4529   lcfi = lcfi + 1;
4530  return catarray;
4531
4532 if(not rarfile_support):
4533  def RarFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
4534   return False;
4535
4536 if(rarfile_support):
4537  def RarFileToArrayIndexAlt(infiles, seekstart=0, seekend=0, listonly=False, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False):
4538   listcatfiles = RarFileToArrayAlt(infiles, listonly, checksumtype, extradata, formatspecs, verbose);
4539   if(not listcatfiles):
4540    return False;
4541   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': {}}}};
4542   lenlist = len(listcatfiles['ffilelist']);
4543   if(seekstart>0):
4544    lcfi = seekstart;
4545   else:
4546    lcfi = 0;
4547   if(seekend>0 and seekend<listcatfiles['fnumfiles']):
4548    lcfx = seekend;
4549   else:
4550    if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
4551     lcfx = listcatfiles['fnumfiles'];
4552    else:
4553     lcfx = int(listcatfiles['fnumfiles']);
4554   while(lcfi < lcfx):
4555    filetoidarray = {listcatfiles['ffilelist'][lcfi]['fname']: listcatfiles['ffilelist'][lcfi]['fid']};
4556    idtofilearray = {listcatfiles['ffilelist'][lcfi]['fid']: listcatfiles['ffilelist'][lcfi]['fname']};
4557    catarray['filetoid'].update(filetoidarray);
4558    catarray['idtofile'].update(idtofilearray);
4559    if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
4560     catarray['filetypes']['files']['filetoid'].update(filetoidarray);
4561     catarray['filetypes']['files']['idtofile'].update(idtofilearray);
4562    if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
4563     catarray['filetypes']['hardlinks']['filetoid'].update(filetoidarray);
4564     catarray['filetypes']['hardlinks']['idtofile'].update(idtofilearray);
4565     catarray['filetypes']['links']['filetoid'].update(filetoidarray);
4566     catarray['filetypes']['links']['idtofile'].update(idtofilearray);
4567    if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
4568     catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
4569     catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
4570     catarray['filetypes']['links']['filetoid'].update(filetoidarray);
4571     catarray['filetypes']['links']['idtofile'].update(idtofilearray);
4572    if(listcatfiles['ffilelist'][lcfi]['ftype']==3):
4573     catarray['filetypes']['character']['filetoid'].update(filetoidarray);
4574     catarray['filetypes']['character']['idtofile'].update(idtofilearray);
4575     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
4576     catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
4577    if(listcatfiles['ffilelist'][lcfi]['ftype']==4):
4578     catarray['filetypes']['block']['filetoid'].update(filetoidarray);
4579     catarray['filetypes']['block']['idtofile'].update(idtofilearray);
4580     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
4581    catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
4582    if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
4583     catarray['filetypes']['directories']['filetoid'].update(filetoidarray);
4584     catarray['filetypes']['directories']['idtofile'].update(idtofilearray);
4585    if(listcatfiles['ffilelist'][lcfi]['ftype']==6):
4586     catarray['filetypes']['symlinks']['filetoid'].update(filetoidarray);
4587     catarray['filetypes']['symlinks']['idtofile'].update(idtofilearray);
4588     catarray['filetypes']['devices']['filetoid'].update(filetoidarray);
4589     catarray['filetypes']['devices']['idtofile'].update(idtofilearray);
4590    lcfi = lcfi + 1;
4591   return catarray;
4592
4593 def ArchiveFileStringToArrayIndex(catstr, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4594  catfp = BytesIO(catstr);
4595  listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4596  return listcatfiles;
4597
4598 create_alias_function("", __file_format_name__, "StringToArrayIndex", ArchiveFileStringToArrayIndex);
4599
4600 def TarFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4601  catfp = BytesIO();
4602  catfp = PackArchiveFileFromTarFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
4603  listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4604  return listcatfiles;
4605
4606 def ZipFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4607  catfp = BytesIO();
4608  catfp = PackArchiveFileFromZipFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
4609  listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4610  return listcatfiles;
4611
4612 if(not rarfile_support):
4613  def RarFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4614   return False;
4615
4616 if(rarfile_support):
4617  def RarFileToArrayIndex(infile, seekstart=0, seekend=0, listonly=False, skipchecksum=False, formatspecs=__file_format_list__, returnfp=False):
4618   catfp = BytesIO();
4619   catfp = PackArchiveFileFromRarFile(infile, catfp, "auto", None, "crc32", [], formatspecs, False, True);
4620   listcatfiles = ArchiveFileToArrayIndex(catfp, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp);
4621   return listcatfiles;
4622
4623 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):
4624  outarray = BytesIO();
4625  packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, formatspecs, verbose, True);
4626  listcatfiles = ArchiveFileToArrayIndex(outarray, seekstart, seekend, listonly, skipchecksum, formatspecs, returnfp)
4627  return listcatfiles;
4628
4629 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):
4630  compressionlist = ['auto', 'gzip', 'bzip2', 'zstd', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
4631  outextlist = ['gz', 'bz2', 'zst', 'lz4', 'lzop', 'lzo', 'lzma', 'xz'];
4632  outextlistwd = ['.gz', '.bz2', '.zst', '.lz4', 'lzop', '.lzo', '.lzma', '.xz'];
4633  if(isinstance(infile, dict)):
4634   prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
4635   listcatfiles = prelistcatfiles['list'];
4636  else:
4637   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
4638    infile = RemoveWindowsPath(infile);
4639   if(followlink):
4640    prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
4641    listcatfiles = prelistcatfiles['list'];
4642   else:
4643    listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
4644  if(outfile!="-" and not hasattr(infile, "read") and not hasattr(outfile, "write")):
4645   outfile = RemoveWindowsPath(outfile);
4646  checksumtype = checksumtype.lower();
4647  if(not CheckSumSupport(checksumtype, hashlib_guaranteed)):
4648   checksumtype="crc32";
4649  if(checksumtype=="none"):
4650   checksumtype = "";
4651  if(not compression or compression or compression=="catfile" or compression==formatspecs[2]):
4652   compression = None;
4653  if(compression not in compressionlist and compression is None):
4654   compression = "auto";
4655  if(verbose):
4656   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
4657  if(outfile!="-" and not hasattr(outfile, "read") and not hasattr(outfile, "write")):
4658   if(os.path.exists(outfile)):
4659    os.unlink(outfile);
4660  if(not listcatfiles):
4661   return False;
4662  if(outfile=="-"):
4663   verbose = False;
4664   catfp = BytesIO();
4665  elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
4666   catfp = outfile;
4667  elif(re.findall(r"^(ftp|ftps)\:\/\/", outfile)):
4668   catfp = BytesIO();
4669  elif(re.findall(r"^(sftp)\:\/\/", outfile) and haveparamiko):
4670   catfp = BytesIO();
4671  else:
4672   fbasename = os.path.splitext(outfile)[0];
4673   fextname = os.path.splitext(outfile)[1];
4674   catfp = CompressOpenFile(outfile, compressionlevel);
4675  catver = formatspecs[6];
4676  fileheaderver = str(int(catver.replace(".", "")));
4677  fileheader = AppendNullByte(formatspecs[1] + fileheaderver, formatspecs[5]);
4678  catfp.write(fileheader.encode('UTF-8'));
4679  lenlist = len(listcatfiles['ffilelist']);
4680  fnumfiles = int(listcatfiles['fnumfiles']);
4681  if(lenlist>fnumfiles or lenlist<fnumfiles):
4682   fnumfiles = lenlist;
4683  fnumfileshex = format(int(fnumfiles), 'x').lower();
4684  fnumfilesa = AppendNullBytes([fnumfileshex, checksumtype], formatspecs[5]);
4685  if(checksumtype=="none" or checksumtype==""):
4686   catfileheadercshex = format(0, 'x').lower();
4687  elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
4688   catfileheadercshex = format(crc16(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
4689  elif(checksumtype=="crc16_ccitt"):
4690   catfileheadercshex = format(crc16_ccitt(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffff, '04x').lower();
4691  elif(checksumtype=="adler32"):
4692   catfileheadercshex = format(zlib.adler32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
4693  elif(checksumtype=="crc32"):
4694   catfileheadercshex = format(crc32(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffff, '08x').lower();
4695  elif(checksumtype=="crc64_ecma"):
4696   catfileheadercshex = format(crc64_ecma(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4697  elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
4698   catfileheadercshex = format(crc64_iso(str(fileheader + fnumfilesa).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4699  elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
4700   checksumoutstr = hashlib.new(checksumtype);
4701   checksumoutstr.update(str(fileheader + fnumfilesa).encode('UTF-8'));
4702   catfileheadercshex = checksumoutstr.hexdigest().lower();
4703  else:
4704   catfileheadercshex = format(0, 'x').lower();
4705  fnumfilesa = fnumfilesa + AppendNullByte(catfileheadercshex, formatspecs[5]);
4706  catfp.write(fnumfilesa.encode('UTF-8'));
4707  try:
4708   catfp.flush();
4709   os.fsync(catfp.fileno());
4710  except io.UnsupportedOperation:
4711   pass;
4712  except AttributeError:
4713   pass;
4714  if(seekstart>0):
4715   lcfi = seekstart;
4716  else:
4717   lcfi = 0;
4718  if(seekend>0 and seekend<listcatfiles['fnumfiles']):
4719   lcfx = seekend;
4720  else:
4721   lcfx = int(listcatfiles['fnumfiles']);
4722  curinode = 0;
4723  curfid = 0;
4724  inodelist = [];
4725  inodetofile = {};
4726  filetoinode = {};
4727  reallcfi = 0;
4728  while(lcfi < lcfx):
4729   catfhstart = catfp.tell();
4730   if(re.findall("^[.|/]", listcatfiles['ffilelist'][reallcfi]['fname'])):
4731    fname = listcatfiles['ffilelist'][reallcfi]['fname'];
4732   else:
4733    fname = "./"+listcatfiles['ffilelist'][reallcfi]['fname'];
4734   if(verbose):
4735    VerbosePrintOut(fname);
4736   fheadersize = format(int(listcatfiles['ffilelist'][reallcfi]['fheadersize']), 'x').lower();
4737   fsize = format(int(listcatfiles['ffilelist'][reallcfi]['fsize']), 'x').lower();
4738   flinkname = listcatfiles['ffilelist'][reallcfi]['flinkname'];
4739   fatime = format(int(listcatfiles['ffilelist'][reallcfi]['fatime']), 'x').lower();
4740   fmtime = format(int(listcatfiles['ffilelist'][reallcfi]['fmtime']), 'x').lower();
4741   fctime = format(int(listcatfiles['ffilelist'][reallcfi]['fctime']), 'x').lower();
4742   fbtime = format(int(listcatfiles['ffilelist'][reallcfi]['fbtime']), 'x').lower();
4743   fmode = format(int(listcatfiles['ffilelist'][reallcfi]['fmode']), 'x').lower();
4744   fchmode = format(int(listcatfiles['ffilelist'][reallcfi]['fchmode']), 'x').lower();
4745   fuid = format(int(listcatfiles['ffilelist'][reallcfi]['fuid']), 'x').lower();
4746   funame = listcatfiles['ffilelist'][reallcfi]['funame'];
4747   fgid = format(int(listcatfiles['ffilelist'][reallcfi]['fgid']), 'x').lower();
4748   fgname = listcatfiles['ffilelist'][reallcfi]['fgname'];
4749   finode = listcatfiles['ffilelist'][reallcfi]['finode'];
4750   flinkcount = listcatfiles['ffilelist'][reallcfi]['flinkcount'];
4751   fdev_minor = format(int(listcatfiles['ffilelist'][reallcfi]['fminor']), 'x').lower();
4752   fdev_major = format(int(listcatfiles['ffilelist'][reallcfi]['fmajor']), 'x').lower();
4753   frdev_minor = format(int(listcatfiles['ffilelist'][reallcfi]['frminor']), 'x').lower();
4754   frdev_major = format(int(listcatfiles['ffilelist'][reallcfi]['frmajor']), 'x').lower();
4755   if(len(listcatfiles['ffilelist'][reallcfi]['fextralist'])>listcatfiles['ffilelist'][reallcfi]['fextrafields'] and len(listcatfiles['ffilelist'][reallcfi]['fextralist'])>0):
4756    listcatfiles['ffilelist'][reallcfi]['fextrafields'] = len(listcatfiles['ffilelist'][reallcfi]['fextralist']);
4757   if(len(extradata) > 0):
4758    listcatfiles['ffilelist'][reallcfi]['fextrafields'] = len(extradata);
4759    listcatfiles['ffilelist'][reallcfi]['fextralist'] = extradata;
4760   extrafields = format(int(listcatfiles['ffilelist'][reallcfi]['fextrafields']), 'x').lower();
4761   extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
4762   if(len(extradata)>0):
4763    extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
4764   extrasizelen = format(len(extrasizestr), 'x').lower();
4765   fcontents = listcatfiles['ffilelist'][reallcfi]['fcontents'];
4766   if(followlink):
4767    if(listcatfiles['ffilelist'][reallcfi]['ftype']==1 or listcatfiles['ffilelist'][reallcfi]['ftype']==2):
4768     getflinkpath = listcatfiles['ffilelist'][reallcfi]['flinkname'];
4769     flinkid = prelistcatfiles['filetoid'][getflinkpath];
4770     flinkinfo = listcatfiles['ffilelist'][flinkid];
4771     fheadersize = format(int(flinkinfo['fheadersize']), 'x').lower();
4772     fsize = format(int(flinkinfo['fsize']), 'x').lower();
4773     flinkname = flinkinfo['flinkname'];
4774     fatime = format(int(flinkinfo['fatime']), 'x').lower();
4775     fmtime = format(int(flinkinfo['fmtime']), 'x').lower();
4776     fctime = format(int(flinkinfo['fctime']), 'x').lower();
4777     fbtime = format(int(flinkinfo['fbtime']), 'x').lower();
4778     fmode = format(int(flinkinfo['fmode']), 'x').lower();
4779     fchmode = format(int(flinkinfo['fchmode']), 'x').lower();
4780     fuid = format(int(flinkinfo['fuid']), 'x').lower();
4781     funame = flinkinfo['funame'];
4782     fgid = format(int(flinkinfo['fgid']), 'x').lower();
4783     fgname = flinkinfo['fgname'];
4784     finode = flinkinfo['finode'];
4785     flinkcount = flinkinfo['flinkcount'];
4786     fdev_minor = format(int(flinkinfo['fminor']), 'x').lower();
4787     fdev_major = format(int(flinkinfo['fmajor']), 'x').lower();
4788     frdev_minor = format(int(flinkinfo['frminor']), 'x').lower();
4789     frdev_major = format(int(flinkinfo['frmajor']), 'x').lower();
4790     if(len(flinkinfo['fextralist'])>flinkinfo['fextrafields'] and len(flinkinfo['fextralist'])>0):
4791      flinkinfo['fextrafields'] = len(flinkinfo['fextralist']);
4792     if(len(extradata) > 0):
4793      flinkinfo['fextrafields'] = len(extradata);
4794      flinkinfo['fextralist'] = extradata;
4795     extrafields = format(int(flinkinfo['fextrafields']), 'x').lower();
4796     extrasizestr = AppendNullByte(extrafields, formatspecs[5]);
4797     if(len(extradata)>0):
4798      extrasizestr = extrasizestr + AppendNullBytes(extradata, formatspecs[5]);
4799     extrasizelen = format(len(extrasizestr), 'x').lower();
4800     fcontents = flinkinfo['fcontents'];
4801     if(flinkinfo['ftype']!=0 and flinkinfo['ftype']!=7):
4802      try:
4803       fcontents = fcontents.encode('UTF-8');
4804      except AttributeError:
4805       pass;
4806     ftypehex = format(flinkinfo['ftype'], 'x').lower();
4807   else:
4808    if(listcatfiles['ffilelist'][reallcfi]['ftype']!=0 and listcatfiles['ffilelist'][reallcfi]['ftype']!=7):
4809     try:
4810      fcontents = fcontents.encode('UTF-8');
4811     except AttributeError:
4812      pass;
4813    ftypehex = format(listcatfiles['ffilelist'][reallcfi]['ftype'], 'x').lower();
4814   fcurfid = format(curfid, 'x').lower();
4815   if(not followlink and finode!=0):
4816    if(listcatfiles['ffilelist'][reallcfi]['ftype']!=1):
4817     fcurinode = format(int(curinode), 'x').lower();
4818     inodetofile.update({curinode: fname});
4819     filetoinode.update({fname: curinode});
4820     curinode = curinode + 1;
4821    else:
4822     fcurinode = format(int(filetoinode[flinkname]), 'x').lower();
4823   else:
4824     fcurinode = format(int(curinode), 'x').lower();
4825     curinode = curinode + 1;
4826   curfid = curfid + 1;
4827   catfileoutstr = AppendNullBytes([ftypehex, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev_minor, fdev_major, frdev_minor, frdev_major, extrasizelen, extrafields], formatspecs[5]);
4828   if(listcatfiles['ffilelist'][reallcfi]['fextrafields']>0):
4829    extrafieldslist = [];
4830    exi = 0;
4831    exil = listcatfiles['ffilelist'][reallcfi]['fextrafields'];
4832    while(exi < exil):
4833     extrafieldslist.append(listcatfiles['ffilelist'][reallcfi]['fextralist']);
4834     exi = exi + 1;
4835    catfileoutstr += AppendNullBytes([extrafieldslist], formatspecs[5]);
4836   catfileoutstr += AppendNullBytes([checksumtype], formatspecs[5]);
4837   catfhend = (catfp.tell() - 1) + len(catfileoutstr);
4838   catfcontentstart = catfp.tell() + len(catfileoutstr);
4839   if(checksumtype=="none" or checksumtype==""):
4840    catfileheadercshex = format(0, 'x').lower();
4841    catfilecontentcshex = format(0, 'x').lower();
4842   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
4843    catfileheadercshex = format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
4844    catfilecontentcshex = format(crc16(fcontents) & 0xffff, '04x').lower();
4845   elif(checksumtype=="crc16_ccitt"):
4846    catfileheadercshex = format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
4847    catfilecontentcshex = format(crc16_ccitt(fcontents) & 0xffff, '04x').lower();
4848   elif(checksumtype=="adler32"):
4849    catfileheadercshex = format(zlib.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
4850    catfilecontentcshex = format(zlib.adler32(fcontents) & 0xffffffff, '08x').lower();
4851   elif(checksumtype=="crc32"):
4852    catfileheadercshex = format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
4853    catfilecontentcshex = format(crc32(fcontents) & 0xffffffff, '08x').lower();
4854   elif(checksumtype=="crc64_ecma"):
4855    catfileheadercshex = format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4856    catfilecontentcshex = format(crc64_ecma(fcontents) & 0xffffffffffffffff, '016x').lower();
4857   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
4858    catfileheadercshex = format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4859    catfilecontentcshex = format(crc64_iso(fcontents) & 0xffffffffffffffff, '016x').lower();
4860   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
4861    checksumoutstr = hashlib.new(checksumtype);
4862    checksumoutstr.update("".encode('UTF-8'));
4863    catfileheadercshex = checksumoutstr.hexdigest().lower();
4864    checksumoutstr = hashlib.new(checksumtype);
4865    checksumoutstr.update(fcontents);
4866    catfilecontentcshex = checksumoutstr.hexdigest().lower();
4867   else:
4868    catfileheadercshex = format(0, 'x').lower();
4869    catfilecontentcshex = format(0, 'x').lower();
4870   tmpfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
4871   catheaersize = format(int(len(tmpfileoutstr) - 1), 'x').lower()
4872   catfileoutstr = AppendNullByte(catheaersize, formatspecs[5]) + catfileoutstr;
4873   if(checksumtype=="none" or checksumtype==""):
4874    catfileheadercshex = format(0, 'x').lower();
4875   elif(checksumtype=="crc16" or checksumtype=="crc16_ansi" or checksumtype=="crc16_ibm"):
4876    catfileheadercshex = format(crc16(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
4877   elif(checksumtype=="crc16_ccitt"):
4878    catfileheadercshex = format(crc16_ccitt(catfileoutstr.encode('UTF-8')) & 0xffff, '04x').lower();
4879   elif(checksumtype=="adler32"):
4880    catfileheadercshex = format(zlib.adler32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
4881   elif(checksumtype=="crc32"):
4882    catfileheadercshex = format(crc32(catfileoutstr.encode('UTF-8')) & 0xffffffff, '08x').lower();
4883   elif(checksumtype=="crc64_ecma"):
4884    catfileheadercshex = format(crc64_ecma(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4885   elif(checksumtype=="crc64" or checksumtype=="crc64_iso"):
4886    catfileheadercshex = format(crc64_iso(catfileoutstr.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4887   elif(CheckSumSupportAlt(checksumtype, hashlib_guaranteed)):
4888    checksumoutstr = hashlib.new(checksumtype);
4889    checksumoutstr.update(catfileoutstr.encode('UTF-8'));
4890    catfileheadercshex = checksumoutstr.hexdigest().lower();
4891   else:
4892    catfileheadercshex = format(0, 'x').lower();
4893   catfileoutstr = catfileoutstr + AppendNullBytes([catfileheadercshex, catfilecontentcshex], formatspecs[5]);
4894   catfileoutstrecd = catfileoutstr.encode('UTF-8');
4895   nullstrecd = formatspecs[5].encode('UTF-8');
4896   catfileout = catfileoutstrecd + fcontents + nullstrecd;
4897   catfcontentend = (catfp.tell() - 1) + len(catfileout);
4898   catfp.write(catfileout);
4899   try:
4900    catfp.flush();
4901    os.fsync(catfp.fileno());
4902   except io.UnsupportedOperation:
4903    pass;
4904   except AttributeError:
4905    pass;
4906   lcfi = lcfi + 1;
4907   reallcfi = reallcfi + 1;
4908  if(outfile=="-" or hasattr(outfile, "read") or hasattr(outfile, "write")):
4909   catfp = CompressArchiveFile(catfp, compression, formatspecs);
4910   try:
4911    catfp.flush();
4912    os.fsync(catfp.fileno());
4913   except io.UnsupportedOperation:
4914    pass;
4915   except AttributeError:
4916    pass;
4917  if(outfile=="-"):
4918   catfp.seek(0, 0);
4919   if(hasattr(sys.stdout, "buffer")):
4920    shutil.copyfileobj(catfp, sys.stdout.buffer);
4921   else:
4922    shutil.copyfileobj(catfp, sys.stdout);
4923  elif(re.findall(r"^(ftp|ftps)\:\/\/", outfile)):
4924   catfp = CompressArchiveFile(catfp, compression, formatspecs);
4925   catfp.seek(0, 0);
4926   upload_file_to_ftp_file(catfp, outfile);
4927  elif(re.findall(r"^(sftp)\:\/\/", outfile) and haveparamiko):
4928   catfp = CompressArchiveFile(catfp, compression, formatspecs);
4929   catfp.seek(0, 0);
4930   if(__use_pysftp__):
4931    upload_file_to_pysftp_file(catfp, outfile);
4932   else:
4933    upload_file_to_sftp_file(catfp, outfile);
4934  if(returnfp):
4935   catfp.seek(0, 0);
4936   return catfp;
4937  else:
4938   catfp.close();
4939   return True;
4940
4941 create_alias_function("RePack", __file_format_name__, "", RePackArchiveFile);
4942
4943 def RePackArchiveFileFromString(catstr, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", skipchecksum=False, extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
4944  catfp = BytesIO(catstr);
4945  listcatfiles = RePackArchiveFile(catfp, compression, compressionlevel, checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp);
4946  return listcatfiles;
4947
4948 create_alias_function("RePack", __file_format_name__, "FromString", RePackArchiveFileFromString);
4949
4950 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):
4951  outarray = BytesIO();
4952  packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, True);
4953  listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp);
4954  return listcatfiles;
4955
4956 create_alias_function("Pack", __file_format_name__, "FromListDir", PackArchiveFileFromListDir);
4957
4958 def ArchiveFileArrayBase64Encode(infile, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
4959  if(verbose):
4960   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
4961  if(isinstance(infile, dict)):
4962   prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
4963   listcatfiles = prelistcatfiles['list'];
4964  else:
4965   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
4966    infile = RemoveWindowsPath(infile);
4967   if(followlink):
4968    prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
4969    listcatfiles = prelistcatfiles['list'];
4970   else:
4971    listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
4972  if(not listcatfiles):
4973   return False;
4974  lenlist = len(listcatfiles['ffilelist']);
4975  if(seekstart>0):
4976   lcfi = seekstart;
4977  else:
4978   lcfi = 0;
4979  if(seekend>0 and seekend<listcatfiles['fnumfiles']):
4980   lcfx = seekend;
4981  else:
4982   if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
4983    lcfx = listcatfiles['fnumfiles'];
4984   else:
4985    lcfx = int(listcatfiles['fnumfiles']);
4986  if(lenlist>lcfx or lenlist<lcfx):
4987   lcfx = lenlist;
4988  while(lcfi < lcfx):
4989   if(listcatfiles['ffilelist'][lcfi]['fhascontents']):
4990    listcatfiles['ffilelist'][lcfi]['fcontents'] = base64.b64encode(listcatfiles['ffilelist'][lcfi]['fcontents']).decode("UTF-8");
4991   lcfi = lcfi + 1;
4992  return listcatfiles;
4993
4994 create_alias_function("", __file_format_name__, "ArrayBase64Encode", ArchiveFileArrayBase64Encode);
4995
4996 def ArchiveFileArrayBase64Decode(infile, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
4997  if(verbose):
4998   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
4999  if(isinstance(infile, dict)):
5000   prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
5001   listcatfiles = prelistcatfiles['list'];
5002  else:
5003   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
5004    infile = RemoveWindowsPath(infile);
5005   if(followlink):
5006    prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
5007    listcatfiles = prelistcatfiles['list'];
5008   else:
5009    listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
5010  if(not listcatfiles):
5011   return False;
5012  lenlist = len(listcatfiles['ffilelist']);
5013  if(seekstart>0):
5014   lcfi = seekstart;
5015  else:
5016   lcfi = 0;
5017  if(seekend>0 and seekend<listcatfiles['fnumfiles']):
5018   lcfx = seekend;
5019  else:
5020   if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
5021    lcfx = listcatfiles['fnumfiles'];
5022   else:
5023    lcfx = int(listcatfiles['fnumfiles']);
5024  if(lenlist>lcfx or lenlist<lcfx):
5025   lcfx = lenlist;
5026  while(lcfi < lcfx):
5027   if(listcatfiles['ffilelist'][lcfi]['fhascontents']):
5028    listcatfiles['ffilelist'][lcfi]['fcontents'] = base64.b64decode(listcatfiles['ffilelist'][lcfi]['fcontents'].encode("UTF-8"));
5029   lcfi = lcfi + 1;
5030  return listcatfiles;
5031
5032 create_alias_function("", __file_format_name__, "ArrayBase64Decode", ArchiveFileArrayBase64Decode);
5033
5034 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):
5035  if(outdir is not None):
5036   outdir = RemoveWindowsPath(outdir);
5037  if(verbose):
5038   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
5039  if(isinstance(infile, dict)):
5040   prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
5041   listcatfiles = prelistcatfiles['list'];
5042  else:
5043   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
5044    infile = RemoveWindowsPath(infile);
5045   if(followlink):
5046    prelistcatfiles = ArchiveFileToArrayIndex(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
5047    listcatfiles = prelistcatfiles['list'];
5048   else:
5049    listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, False, skipchecksum, formatspecs, returnfp);
5050  if(not listcatfiles):
5051   return False;
5052  lenlist = len(listcatfiles['ffilelist']);
5053  if(seekstart>0):
5054   lcfi = seekstart;
5055  else:
5056   lcfi = 0;
5057  if(seekend>0 and seekend<listcatfiles['fnumfiles']):
5058   lcfx = seekend;
5059  else:
5060   if(lenlist>listcatfiles['fnumfiles'] or lenlist<listcatfiles['fnumfiles']):
5061    lcfx = listcatfiles['fnumfiles'];
5062   else:
5063    lcfx = int(listcatfiles['fnumfiles']);
5064  if(lenlist>lcfx or lenlist<lcfx):
5065   lcfx = lenlist;
5066  while(lcfi < lcfx):
5067   funame = "";
5068   try:
5069    import pwd;
5070    try:
5071     userinfo = pwd.getpwuid(listcatfiles['ffilelist'][lcfi]['fuid']);
5072     funame = userinfo.pw_name;
5073    except KeyError:
5074     funame = "";
5075   except ImportError:
5076    funame = "";
5077   fgname = "";
5078   try:
5079    import grp;
5080    try:
5081     groupinfo = grp.getgrgid(listcatfiles['ffilelist'][lcfi]['fgid']);
5082     fgname = groupinfo.gr_name;
5083    except KeyError:
5084     fgname = "";
5085   except ImportError:
5086    fgname = "";
5087   if(verbose):
5088    VerbosePrintOut(listcatfiles['ffilelist'][lcfi]['fname']);
5089   if(listcatfiles['ffilelist'][lcfi]['ftype']==0 or listcatfiles['ffilelist'][lcfi]['ftype']==7):
5090    with open(listcatfiles['ffilelist'][lcfi]['fname'], "wb") as fpc:
5091     fpc.write(listcatfiles['ffilelist'][lcfi]['fcontents'])
5092     try:
5093      fpc.flush()
5094      os.fsync(fpc.fileno())
5095     except io.UnsupportedOperation:
5096      pass
5097     except AttributeError:
5098      pass
5099    if(hasattr(os, "chown") and funame==listcatfiles['ffilelist'][lcfi]['funame'] and fgname==listcatfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
5100     os.chown(listcatfiles['ffilelist'][lcfi]['fname'], listcatfiles['ffilelist'][lcfi]['fuid'], listcatfiles['ffilelist'][lcfi]['fgid']);
5101    if(preservepermissions):
5102     os.chmod(listcatfiles['ffilelist'][lcfi]['fname'], listcatfiles['ffilelist'][lcfi]['fchmode']);
5103    if(preservetime):
5104     os.utime(listcatfiles['ffilelist'][lcfi]['fname'], (listcatfiles['ffilelist'][lcfi]['fatime'], listcatfiles['ffilelist'][lcfi]['fmtime']));
5105   if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
5106    if(followlink):
5107     getflinkpath = listcatfiles['ffilelist'][lcfi]['flinkname'];
5108     flinkid = prelistcatfiles['filetoid'][getflinkpath];
5109     flinkinfo = listcatfiles['ffilelist'][flinkid];
5110     funame = "";
5111     try:
5112      import pwd;
5113      try:
5114       userinfo = pwd.getpwuid(flinkinfo['fuid']);
5115       funame = userinfo.pw_name;
5116      except KeyError:
5117       funame = "";
5118     except ImportError:
5119      funame = "";
5120     fgname = "";
5121     try:
5122      import grp;
5123      try:
5124       groupinfo = grp.getgrgid(flinkinfo['fgid']);
5125       fgname = groupinfo.gr_name;
5126      except KeyError:
5127       fgname = "";
5128     except ImportError:
5129      fgname = "";
5130     if(flinkinfo['ftype'] == 0 or flinkinfo['ftype'] == 7):
5131      with open(listcatfiles['ffilelist'][lcfi]['fname'], "wb") as fpc:
5132       fpc.write(flinkinfo['fcontents'])
5133       try:
5134        fpc.flush()
5135        os.fsync(fpc.fileno())
5136       except io.UnsupportedOperation:
5137        pass
5138       except AttributeError:
5139        pass
5140      if(hasattr(os, "chown") and funame==flinkinfo['funame'] and fgname==flinkinfo['fgname'] and preservepermissions):
5141       os.chown(listcatfiles['ffilelist'][lcfi]['fname'], flinkinfo['fuid'], flinkinfo['fgid']);
5142      if(preservepermissions):
5143       os.chmod(listcatfiles['ffilelist'][lcfi]['fname'], flinkinfo['fchmode']);
5144      if(preservetime):
5145       os.utime(listcatfiles['ffilelist'][lcfi]['fname'], (flinkinfo['fatime'], flinkinfo['fmtime']));
5146     if(flinkinfo['ftype']==1):
5147      os.link(flinkinfo['flinkname'], listcatfiles['ffilelist'][lcfi]['fname']);
5148     if(flinkinfo['ftype']==2):
5149      os.symlink(flinkinfo['flinkname'], listcatfiles['ffilelist'][lcfi]['fname']);
5150     if(flinkinfo['ftype']==5):
5151      if(preservepermissions):
5152       os.mkdir(listcatfiles['ffilelist'][lcfi]['fname'], flinkinfo['fchmode']);
5153      else:
5154       os.mkdir(listcatfiles['ffilelist'][lcfi]['fname']);
5155      if(hasattr(os, "chown") and funame==flinkinfo['funame'] and fgname==flinkinfo['fgname'] and preservepermissions):
5156       os.chown(listcatfiles['ffilelist'][lcfi]['fname'], flinkinfo['fuid'], flinkinfo['fgid']);
5157      if(preservepermissions):
5158       os.chmod(listcatfiles['ffilelist'][lcfi]['fname'], flinkinfo['fchmode']);
5159      if(preservetime):
5160       os.utime(listcatfiles['ffilelist'][lcfi]['fname'], (flinkinfo['fatime'], flinkinfo['fmtime']));
5161     if(flinkinfo['ftype']==6 and hasattr(os, "mkfifo")):
5162      os.mkfifo(listcatfiles['ffilelist'][lcfi]['fname'], flinkinfo['fchmode']);
5163    else:
5164     os.link(listcatfiles['ffilelist'][lcfi]['flinkname'], listcatfiles['ffilelist'][lcfi]['fname']);
5165   if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
5166    if(followlink):
5167     getflinkpath = listcatfiles['ffilelist'][lcfi]['flinkname'];
5168     flinkid = prelistcatfiles['filetoid'][getflinkpath];
5169     flinkinfo = listcatfiles['ffilelist'][flinkid];
5170     funame = "";
5171     try:
5172      import pwd;
5173      try:
5174       userinfo = pwd.getpwuid(flinkinfo['fuid']);
5175       funame = userinfo.pw_name;
5176      except KeyError:
5177       funame = "";
5178     except ImportError:
5179      funame = "";
5180     fgname = "";
5181     try:
5182      import grp;
5183      try:
5184       groupinfo = grp.getgrgid(flinkinfo['fgid']);
5185       fgname = groupinfo.gr_name;
5186      except KeyError:
5187       fgname = "";
5188     except ImportError:
5189      fgname = "";
5190     if(flinkinfo['ftype']==0 or flinkinfo['ftype']==7):
5191      with open(listcatfiles['ffilelist'][lcfi]['fname'], "wb") as fpc:
5192       fpc.write(flinkinfo['fcontents'])
5193       try:
5194        fpc.flush()
5195        os.fsync(fpc.fileno())
5196       except io.UnsupportedOperation:
5197        pass
5198       except AttributeError:
5199        pass
5200      if(hasattr(os, "chown") and funame==flinkinfo['funame'] and fgname==flinkinfo['fgname'] and preservepermissions):
5201       os.chown(listcatfiles['ffilelist'][lcfi]['fname'], flinkinfo['fuid'], flinkinfo['fgid']);
5202      if(preservepermissions):
5203       os.chmod(listcatfiles['ffilelist'][lcfi]['fname'], flinkinfo['fchmode']);
5204      if(preservetime):
5205       os.utime(listcatfiles['ffilelist'][lcfi]['fname'], (flinkinfo['fatime'], flinkinfo['fmtime']));
5206     if(flinkinfo['ftype']==1):
5207      os.link(flinkinfo['flinkname'], listcatfiles['ffilelist'][lcfi]['fname']);
5208     if(flinkinfo['ftype']==2):
5209      os.symlink(flinkinfo['flinkname'], listcatfiles['ffilelist'][lcfi]['fname']);
5210     if(flinkinfo['ftype']==5):
5211      if(preservepermissions):
5212       os.mkdir(listcatfiles['ffilelist'][lcfi]['fname'], flinkinfo['fchmode']);
5213      else:
5214       os.mkdir(listcatfiles['ffilelist'][lcfi]['fname']);
5215      if(hasattr(os, "chown") and funame==flinkinfo['funame'] and fgname==flinkinfo['fgname'] and preservepermissions):
5216       os.chown(listcatfiles['ffilelist'][lcfi]['fname'], flinkinfo['fuid'], flinkinfo['fgid']);
5217      if(preservepermissions):
5218       os.chmod(listcatfiles['ffilelist'][lcfi]['fname'], flinkinfo['fchmode']);
5219      if(preservetime):
5220       os.utime(listcatfiles['ffilelist'][lcfi]['fname'], (flinkinfo['fatime'], flinkinfo['fmtime']));
5221     if(flinkinfo['ftype']==6 and hasattr(os, "mkfifo")):
5222      os.mkfifo(listcatfiles['ffilelist'][lcfi]['fname'], flinkinfo['fchmode']);
5223    else:
5224     os.symlink(listcatfiles['ffilelist'][lcfi]['flinkname'], listcatfiles['ffilelist'][lcfi]['fname']);
5225   if(listcatfiles['ffilelist'][lcfi]['ftype']==5):
5226    if(preservepermissions):
5227     os.mkdir(listcatfiles['ffilelist'][lcfi]['fname'], listcatfiles['ffilelist'][lcfi]['fchmode']);
5228    else:
5229     os.mkdir(listcatfiles['ffilelist'][lcfi]['fname']);
5230    if(hasattr(os, "chown") and funame==listcatfiles['ffilelist'][lcfi]['funame'] and fgname==listcatfiles['ffilelist'][lcfi]['fgname'] and preservepermissions):
5231     os.chown(listcatfiles['ffilelist'][lcfi]['fname'], listcatfiles['ffilelist'][lcfi]['fuid'], listcatfiles['ffilelist'][lcfi]['fgid']);
5232    if(preservepermissions):
5233     os.chmod(listcatfiles['ffilelist'][lcfi]['fname'], listcatfiles['ffilelist'][lcfi]['fchmode']);
5234    if(preservetime):
5235     os.utime(listcatfiles['ffilelist'][lcfi]['fname'], (listcatfiles['ffilelist'][lcfi]['fatime'], listcatfiles['ffilelist'][lcfi]['fmtime']));
5236   if(listcatfiles['ffilelist'][lcfi]['ftype']==6 and hasattr(os, "mkfifo")):
5237    os.mkfifo(listcatfiles['ffilelist'][lcfi]['fname'], listcatfiles['ffilelist'][lcfi]['fchmode']);
5238   lcfi = lcfi + 1;
5239  if(returnfp):
5240   return listcatfiles['ffilelist']['catfp'];
5241  else:
5242   return True;
5243
5244 create_alias_function("UnPack", __file_format_name__, "", UnPackArchiveFile);
5245
5246 if(hasattr(shutil, "register_unpack_format")):
5247  def UnPackArchiveFileFunc(archive_name, extract_dir=None, **kwargs):
5248   return UnPackArchiveFile(archive_name, extract_dir, False, 0, 0, False, __file_format_delimiter__, False, False);
5249  create_alias_function("UnPack", __file_format_name__, "Func", UnPackArchiveFileFunc);
5250
5251 def UnPackArchiveFileString(catstr, outdir=None, followlink=False, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
5252  catfp = BytesIO(catstr);
5253  listcatfiles = UnPackArchiveFile(catfp, outdir, followlink, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp);
5254  return listcatfiles;
5255
5256 create_alias_function("UnPack", __file_format_name__, "String", UnPackArchiveFileString);
5257
5258 def ArchiveFileListFiles(infile, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
5259  logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
5260  if(isinstance(infile, dict)):
5261   listcatfiles = infile;
5262  else:
5263   if(infile!="-" and not hasattr(infile, "read") and not hasattr(infile, "write")):
5264    infile = RemoveWindowsPath(infile);
5265   listcatfiles = ArchiveFileToArray(infile, seekstart, seekend, True, skipchecksum, formatspecs, returnfp);
5266  if(not listcatfiles):
5267   return False;
5268  lenlist = len(listcatfiles['ffilelist']);
5269  lcfi = 0;
5270  lcfx = lenlist;
5271  returnval = {};
5272  while(lcfi < lcfx):
5273   returnval.update({lcfi: listcatfiles['ffilelist'][lcfi]['fname']});
5274   if(not verbose):
5275    VerbosePrintOut(listcatfiles['ffilelist'][lcfi]['fname']);
5276   if(verbose):
5277    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' } };
5278    printfname = listcatfiles['ffilelist'][lcfi]['fname'];
5279    if(listcatfiles['ffilelist'][lcfi]['ftype']==1):
5280     printfname = listcatfiles['ffilelist'][lcfi]['fname'] + " link to " + listcatfiles['ffilelist'][lcfi]['flinkname'];
5281    if(listcatfiles['ffilelist'][lcfi]['ftype']==2):
5282     printfname = listcatfiles['ffilelist'][lcfi]['fname'] + " -> " + listcatfiles['ffilelist'][lcfi]['flinkname'];
5283    fuprint = listcatfiles['ffilelist'][lcfi]['funame'];
5284    if(len(fuprint)<=0):
5285     fuprint = listcatfiles['ffilelist'][lcfi]['fuid'];
5286    fgprint = listcatfiles['ffilelist'][lcfi]['fgname'];
5287    if(len(fgprint)<=0):
5288     fgprint = listcatfiles['ffilelist'][lcfi]['fgid'];
5289    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));
5290   lcfi = lcfi + 1;
5291  if(returnfp):
5292   return listcatfiles['catfp'];
5293  else:
5294   return True;
5295
5296 create_alias_function("", __file_format_name__, "ListFiles", ArchiveFileListFiles);
5297
5298 def ArchiveFileStringListFiles(catstr, followlink=False, skipchecksum=False, formatspecs=__file_format_list__, verbose=False, returnfp=False):
5299  catfp = BytesIO(catstr);
5300  listcatfiles = UnPackArchiveFile(catfp, None, followlink, skipchecksum, formatspecs, verbose, returnfp);
5301  return listcatfiles;
5302
5303 create_alias_function("", __file_format_name__, "StringListFiles", ArchiveFileListFiles);
5304
5305 def TarFileListFiles(infile, verbose=False, returnfp=False):
5306  logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
5307  if(infile=="-"):
5308   infile = BytesIO();
5309   if(hasattr(sys.stdin, "buffer")):
5310    shutil.copyfileobj(sys.stdin.buffer, infile);
5311   else:
5312    shutil.copyfileobj(sys.stdin, infile);
5313   infile.seek(0, 0);
5314   if(not infile):
5315    return False;
5316   infile.seek(0, 0);
5317  elif(re.findall(r"^(http|https)\:\/\/", infile)):
5318   infile = download_file_from_http_file(infile);
5319   infile.seek(0, 0);
5320   if(not infile):
5321    return False;
5322   infile.seek(0, 0);
5323  elif(re.findall(r"^(ftp|ftps)\:\/\/", infile)):
5324   infile = download_file_from_ftp_file(infile);
5325   infile.seek(0, 0);
5326   if(not infile):
5327    return False;
5328   infile.seek(0, 0);
5329  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
5330   return False;
5331  elif(os.path.exists(infile) and os.path.isfile(infile)):
5332   try:
5333    if(not tarfile.is_tarfile(infile)):
5334     return False;
5335   except AttributeError:
5336    if(not is_tarfile(infile)):
5337     return False;
5338  else:
5339   return False;
5340  try:
5341   if(hasattr(infile, "read") or hasattr(infile, "write")):
5342    tarfp = tarfile.open(fileobj=infile, mode="r");
5343   else:
5344    tarfp = tarfile.open(infile, "r");
5345  except FileNotFoundError:
5346   return False;
5347  for member in sorted(tarfp.getmembers(), key=lambda x: x.name):
5348   returnval.update({lcfi: member.name});
5349   fpremode = member.mode;
5350   ffullmode = member.mode;
5351   flinkcount = 0;
5352   ftype = 0;
5353   if(member.isreg()):
5354    ffullmode = member.mode + stat.S_IFREG;
5355    ftype = 0;
5356   elif(member.isdev()):
5357    ffullmode = member.mode;
5358    ftype = 7;
5359   elif(member.islnk()):
5360    ffullmode = member.mode + stat.S_IFREG;
5361    ftype = 1;
5362   elif(member.issym()):
5363    ffullmode = member.mode + stat.S_IFLNK;
5364    ftype = 2;
5365   elif(member.ischr()):
5366    ffullmode = member.mode + stat.S_IFCHR;
5367    ftype = 3;
5368   elif(member.isblk()):
5369    ffullmode = member.mode + stat.S_IFBLK;
5370    ftype = 4;
5371   elif(member.isdir()):
5372    ffullmode = member.mode + stat.S_IFDIR;
5373    ftype = 5;
5374   elif(member.isfifo()):
5375    ffullmode = member.mode + stat.S_IFIFO;
5376    ftype = 6;
5377   elif(member.issparse()):
5378    ffullmode = member.mode;
5379    ftype = 8;
5380   if(not verbose):
5381    VerbosePrintOut(member.name);
5382   elif(verbose):
5383    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' } };
5384    printfname = member.name;
5385    if(member.islnk()):
5386     printfname = member.name + " link to " + member.linkname;
5387    elif(member.issym()):
5388     printfname = member.name + " -> " + member.linkname;
5389    fuprint = member.uname;
5390    if(len(fuprint)<=0):
5391     fuprint = member.uid;
5392    fgprint = member.gname;
5393    if(len(fgprint)<=0):
5394     fgprint = member.gid;
5395    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));
5396   lcfi = lcfi + 1;
5397  if(returnfp):
5398   return listcatfiles['catfp'];
5399  else:
5400   return True;
5401
5402 def ZipFileListFiles(infile, verbose=False, returnfp=False):
5403  logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
5404  if(infile=="-"):
5405   infile = BytesIO();
5406   if(hasattr(sys.stdin, "buffer")):
5407    shutil.copyfileobj(sys.stdin.buffer, infile);
5408   else:
5409    shutil.copyfileobj(sys.stdin, infile);
5410   infile.seek(0, 0);
5411   if(not infile):
5412    return False;
5413   infile.seek(0, 0);
5414  elif(re.findall(r"^(http|https)\:\/\/", infile)):
5415   infile = download_file_from_http_file(infile);
5416   infile.seek(0, 0);
5417   if(not infile):
5418    return False;
5419   infile.seek(0, 0);
5420  elif(re.findall(r"^(ftp|ftps)\:\/\/", infile)):
5421   infile = download_file_from_ftp_file(infile);
5422   infile.seek(0, 0);
5423   if(not infile):
5424    return False;
5425   infile.seek(0, 0);
5426  elif(not os.path.exists(infile) or not os.path.isfile(infile)):
5427   return False;
5428  else:
5429   return False;
5430  if(not zipfile.is_zipfile(infile)):
5431   return False;
5432  try:
5433   zipfp = zipfile.ZipFile(infile, "r", allowZip64=True);
5434  except FileNotFoundError:
5435   return False;
5436  lcfi = 0;
5437  returnval = {};
5438  ziptest = zipfp.testzip();
5439  if(ziptest):
5440   VerbosePrintOut("Bad file found!");
5441  for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
5442   if(not member.is_dir()):
5443    fpremode = int(stat.S_IFREG + 438);
5444   elif(member.is_dir()):
5445    fpremode = int(stat.S_IFDIR + 511);
5446   if(not member.is_dir()):
5447    fmode = int(stat.S_IFREG + 438);
5448    fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)));
5449    ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)));
5450   elif(member.is_dir()):
5451    fmode = int(stat.S_IFDIR + 511);
5452    fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
5453    ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
5454   returnval.update({lcfi: member.filename});
5455   if(not verbose):
5456    VerbosePrintOut(member.filename);
5457   if(verbose):
5458    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' } };
5459    permissionstr = "";
5460    for fmodval in str(oct(fmode))[-3:]:
5461     permissionstr = permissionstr + permissions['access'].get(fmodval, '---');
5462    if(not member.is_dir()):
5463     ftype = 0;
5464     permissionstr = "-" + permissionstr;
5465    elif(member.is_dir()):
5466     ftype = 5;
5467     permissionstr = "d" + permissionstr;
5468    printfname = member.filename;
5469    try:
5470     fuid = int(os.getuid());
5471    except AttributeError:
5472     fuid = int(0);
5473    except KeyError:
5474     fuid = int(0);
5475    try:
5476     fgid = int(os.getgid());
5477    except AttributeError:
5478     fgid = int(0);
5479    except KeyError:
5480     fgid = int(0);
5481    try:
5482     import pwd;
5483     try:
5484      userinfo = pwd.getpwuid(os.getuid());
5485      funame = userinfo.pw_name;
5486     except KeyError:
5487      funame = "";
5488     except AttributeError:
5489      funame = "";
5490    except ImportError:
5491     funame = "";
5492    fgname = "";
5493    try:
5494     import grp;
5495     try:
5496      groupinfo = grp.getgrgid(os.getgid());
5497      fgname = groupinfo.gr_name;
5498     except KeyError:
5499      fgname = "";
5500     except AttributeError:
5501      fgname = "";
5502    except ImportError:
5503     fgname = "";
5504    fuprint = funame;
5505    if(len(fuprint)<=0):
5506     fuprint = str(fuid);
5507    fgprint = fgname;
5508    if(len(fgprint)<=0):
5509     fgprint = str(fgid);
5510    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));
5511   lcfi = lcfi + 1;
5512  if(returnfp):
5513   return listcatfiles['catfp'];
5514  else:
5515   return True;
5516
5517 if(not rarfile_support):
5518  def RarFileListFiles(infile, verbose=False, returnfp=False):
5519   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
5520   if(not os.path.exists(infile) or not os.path.isfile(infile)):
5521    return False;
5522
5523 if(rarfile_support):
5524  def RarFileListFiles(infile, verbose=False, returnfp=False):
5525   logging.basicConfig(format="%(message)s", stream=sys.stdout, level=logging.DEBUG);
5526   if(not os.path.exists(infile) or not os.path.isfile(infile)):
5527    return False;
5528   if(not rarfile.is_rarfile(infile) and not rarfile.is_rarfile_sfx(infile)):
5529    return False;
5530   lcfi = 0;
5531   returnval = {};
5532   rarfp = rarfile.RarFile(infile, "r");
5533   rartest = rarfp.testrar();
5534   if(rartest):
5535    VerbosePrintOut("Bad file found!");
5536   for member in sorted(rarfp.infolist(), key=lambda x: x.filename):
5537    is_unix = False;
5538    is_windows = False;
5539    if(member.host_os == rarfile.RAR_OS_UNIX):
5540     is_windows = False;
5541     try:
5542      member.external_attr
5543      is_unix = True;
5544     except AttributeError:
5545      is_unix = False;
5546    elif(member.host_os == rarfile.RAR_OS_WIN32):
5547     is_unix = False;
5548     try:
5549      member.external_attr
5550      is_windows = True;
5551     except AttributeError:
5552      is_windows = False;
5553    else:
5554     is_unix = False;
5555     is_windows = False;
5556    if(is_unix and member.external_attr !=0):
5557     fpremode = int(member.external_attr);
5558    elif(member.is_file()):
5559     fpremode = int(stat.S_IFREG + 438);
5560    elif(member.is_symlink()):
5561     fpremode = int(stat.S_IFLNK + 438);
5562    elif(member.is_dir()):
5563     fpremode = int(stat.S_IFDIR + 511);
5564    if(is_windows and member.external_attr !=0):
5565     fwinattributes = int(member.external_attr);
5566    else:
5567     fwinattributes = int(0);
5568    if(is_unix and member.external_attr !=0):
5569     fmode = int(member.external_attr);
5570     fchmode = int(stat.S_IMODE(member.external_attr));
5571     ftypemod = int(stat.S_IFMT(member.external_attr));
5572    elif(member.is_file()):
5573     fmode = int(stat.S_IFREG + 438);
5574     fchmode = int(stat.S_IMODE(int(stat.S_IFREG + 438)));
5575     ftypemod = int(stat.S_IFMT(int(stat.S_IFREG + 438)));
5576    elif(member.is_symlink()):
5577     fmode = int(stat.S_IFLNK + 438);
5578     fchmode = int(stat.S_IMODE(int(stat.S_IFLNK + 438)));
5579     ftypemod = int(stat.S_IFMT(int(stat.S_IFLNK + 438)));
5580    elif(member.is_dir()):
5581     fmode = int(stat.S_IFDIR + 511);
5582     fchmode = int(stat.S_IMODE(int(stat.S_IFDIR + 511)));
5583     ftypemod = int(stat.S_IFMT(int(stat.S_IFDIR + 511)));
5584    returnval.update({lcfi: member.filename});
5585    if(not verbose):
5586     VerbosePrintOut(member.filename);
5587    if(verbose):
5588     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' } };
5589     permissionstr = "";
5590     for fmodval in str(oct(fmode))[-3:]:
5591      permissionstr = permissionstr + permissions['access'].get(fmodval, '---');
5592     if(member.is_file()):
5593      ftype = 0;
5594      permissionstr = "-" + permissionstr;
5595      printfname = member.filename;
5596     elif(member.is_symlink()):
5597      ftype = 2;
5598      permissionstr = "l" + permissionstr;
5599      printfname = member.name + " -> " + member.read().decode("UTF-8");
5600     elif(member.is_dir()):
5601      ftype = 5;
5602      permissionstr = "d" + permissionstr;
5603      printfname = member.filename;
5604     try:
5605      fuid = int(os.getuid());
5606     except AttributeError:
5607      fuid = int(0);
5608     except KeyError:
5609      fuid = int(0);
5610     try:
5611      fgid = int(os.getgid());
5612     except AttributeError:
5613      fgid = int(0);
5614     except KeyError:
5615      fgid = int(0);
5616     try:
5617      import pwd;
5618      try:
5619       userinfo = pwd.getpwuid(os.getuid());
5620       funame = userinfo.pw_name;
5621      except KeyError:
5622       funame = "";
5623      except AttributeError:
5624       funame = "";
5625     except ImportError:
5626      funame = "";
5627     fgname = "";
5628     try:
5629      import grp;
5630      try:
5631       groupinfo = grp.getgrgid(os.getgid());
5632       fgname = groupinfo.gr_name;
5633      except KeyError:
5634       fgname = "";
5635      except AttributeError:
5636       fgname = "";
5637     except ImportError:
5638      fgname = "";
5639     fuprint = funame;
5640     if(len(fuprint)<=0):
5641      fuprint = str(fuid);
5642     fgprint = fgname;
5643     if(len(fgprint)<=0):
5644      fgprint = str(fgid);
5645     VerbosePrintOut(PrintPermissionString(fmode, ftype) + " " + str(str(fuprint) + "/" + str(fgprint) + " " + str(member.file_size).rjust(15) + " " + member.mtime.strftime('%Y-%m-%d %H:%M') + " " + printfname));
5646    lcfi = lcfi + 1;
5647   if(returnfp):
5648    return listcatfiles['catfp'];
5649   else:
5650    return True;
5651
5652 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):
5653  outarray = BytesIO();
5654  packcat = PackArchiveFile(infiles, outarray, dirlistfromtxt, compression, compressionlevel, followlink, checksumtype, formatspecs, False, True);
5655  listcatfiles = ArchiveFileListFiles(outarray, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp);
5656  return listcatfiles;
5657
5658 def ListDirListFilesAlt(infiles, dirlistfromtxt=False, followlink=False, listonly=True, seekstart=0, seekend=0, skipchecksum=False, checksumtype="crc32", formatspecs=__file_format_list__, verbose=False, returnfp=False):
5659  outarray = ListDirToArrayAlt(infiles, dirlistfromtxt, followlink, listonly, checksumtype, formatspecs, verbose);
5660  listcatfiles = ArchiveFileListFiles(outarray, seekstart, seekend, skipchecksum, formatspecs, verbose, returnfp);
5661  return listcatfiles;
5662
5663 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):
5664  outarray = ListDirToArrayAlt(infiles, dirlistfromtxt, followlink, False, checksumtype, extradata, formatspecs, False);
5665  listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, followlink, checksumtype, skipchecksum, extradata, formatspecs, verbose, returnfp);
5666  return listcatfiles;
5667
5668 create_alias_function("Pack", __file_format_name__, "FromListDirAlt", PackArchiveFileFromListDirAlt);
5669
5670 def PackArchiveFileFromTarFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
5671  outarray = TarFileToArrayAlt(infile, False, checksumtype, extradata, formatspecs, False);
5672  listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp);
5673  return listcatfiles;
5674
5675 create_alias_function("Pack", __file_format_name__, "FromTarFileAlt", PackArchiveFileFromTarFileAlt);
5676
5677 def PackArchiveFileFromZipFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
5678  outarray = ZipFileToArrayAlt(infile, False, checksumtype, extradata, formatspecs, False);
5679  listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp);
5680  return listcatfiles;
5681
5682 create_alias_function("Pack", __file_format_name__, "FromZipFileAlt", PackArchiveFileFromZipFileAlt);
5683
5684 if(not rarfile_support):
5685  def PackArchiveFileFromRarFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
5686   return False;
5687
5688 if(rarfile_support):
5689  def PackArchiveFileFromRarFileAlt(infile, outfile, compression="auto", compressionlevel=None, checksumtype="crc32", extradata=[], formatspecs=__file_format_list__, verbose=False, returnfp=False):
5690   outarray = RarFileToArrayAlt(infile, False, checksumtype, extradata, formatspecs, False);
5691   listcatfiles = RePackArchiveFile(outarray, outfile, compression, compressionlevel, False, checksumtype, False, extradata, formatspecs, verbose, returnfp);
5692   return listcatfiles;
5693
5694 create_alias_function("Pack", __file_format_name__, "FromRarFileAlt", PackArchiveFileFromRarFileAlt);
5695
5696 def download_file_from_ftp_file(url):
5697  urlparts = urlparse(url);
5698  file_name = os.path.basename(urlparts.path);
5699  file_dir = os.path.dirname(urlparts.path);
5700  if(urlparts.username is not None):
5701   ftp_username = urlparts.username;
5702  else:
5703   ftp_username = "anonymous";
5704  if(urlparts.password is not None):
5705   ftp_password = urlparts.password;
5706  elif(urlparts.password is None and urlparts.username=="anonymous"):
5707   ftp_password = "anonymous";
5708  else:
5709   ftp_password = "";
5710  if(urlparts.scheme=="ftp"):
5711   ftp = FTP();
5712  elif(urlparts.scheme=="ftps"):
5713   ftp = FTP_TLS();
5714  else:
5715   return False;
5716  if(urlparts.scheme=="http" or urlparts.scheme=="https"):
5717   return False;
5718  ftp_port = urlparts.port;
5719  if(urlparts.port is None):
5720   ftp_port = 21;
5721  try:
5722   ftp.connect(urlparts.hostname, ftp_port);
5723  except socket.gaierror:
5724   log.info("Error With URL "+url);
5725   return False;
5726  except socket.timeout:
5727   log.info("Error With URL "+url);
5728   return False;
5729  ftp.login(urlparts.username, urlparts.password);
5730  if(urlparts.scheme=="ftps"):
5731   ftp.prot_p();
5732  ftpfile = BytesIO();
5733  ftp.retrbinary("RETR "+urlparts.path, ftpfile.write);
5734  #ftp.storbinary("STOR "+urlparts.path, ftpfile.write);
5735  ftp.close();
5736  ftpfile.seek(0, 0);
5737  return ftpfile;
5738
5739 def download_file_from_ftp_string(url):
5740  ftpfile = download_file_from_ftp_file(url);
5741  return ftpfile.read();
5742
5743 def upload_file_to_ftp_file(ftpfile, url):
5744  urlparts = urlparse(url);
5745  file_name = os.path.basename(urlparts.path);
5746  file_dir = os.path.dirname(urlparts.path);
5747  if(urlparts.username is not None):
5748   ftp_username = urlparts.username;
5749  else:
5750   ftp_username = "anonymous";
5751  if(urlparts.password is not None):
5752   ftp_password = urlparts.password;
5753  elif(urlparts.password is None and urlparts.username=="anonymous"):
5754   ftp_password = "anonymous";
5755  else:
5756   ftp_password = "";
5757  if(urlparts.scheme=="ftp"):
5758   ftp = FTP();
5759  elif(urlparts.scheme=="ftps"):
5760   ftp = FTP_TLS();
5761  else:
5762   return False;
5763  if(urlparts.scheme=="http" or urlparts.scheme=="https"):
5764   return False;
5765  ftp_port = urlparts.port;
5766  if(urlparts.port is None):
5767   ftp_port = 21;
5768  try:
5769   ftp.connect(urlparts.hostname, ftp_port);
5770  except socket.gaierror:
5771   log.info("Error With URL "+url);
5772   return False;
5773  except socket.timeout:
5774   log.info("Error With URL "+url);
5775   return False;
5776  ftp.login(urlparts.username, urlparts.password);
5777  if(urlparts.scheme=="ftps"):
5778   ftp.prot_p();
5779  ftp.storbinary("STOR "+urlparts.path, ftpfile);
5780  ftp.close();
5781  ftpfile.seek(0, 0);
5782  return ftpfile;
5783
5784 def upload_file_to_ftp_string(ftpstring, url):
5785  ftpfileo = BytesIO(ftpstring);
5786  ftpfile = upload_file_to_ftp_file(ftpfileo, url);
5787  ftpfileo.close();
5788  return ftpfile;
5789
5790 def download_file_from_http_file(url, headers):
5791  # Parse the URL to extract username and password if present
5792  parsed_url = urlparse(url);
5793  username = parsed_url.username;
5794  password = parsed_url.password;
5795  # Rebuild the URL without the username and password
5796  netloc = parsed_url.hostname;
5797  if parsed_url.port:
5798   netloc += ':' + str(parsed_url.port);
5799  rebuilt_url = urlunparse((parsed_url.scheme, netloc, parsed_url.path, parsed_url.params, parsed_url.query, parsed_url.fragment));
5800  if haverequests:
5801   # Use the requests library if available
5802   if username and password:
5803    response = requests.get(rebuilt_url, headers=headers, auth=(username, password));
5804   else:
5805    response = requests.get(rebuilt_url, headers=headers);
5806   # Open a temporary file object and write the data
5807   temp_file = BytesIO(response.content);
5808  else:
5809   # Build a Request object for urllib
5810   request = Request(rebuilt_url, headers=headers);
5811   # Create an opener object for handling URLs
5812   if username and password:
5813    # Create a password manager
5814    password_mgr = HTTPPasswordMgrWithDefaultRealm();
5815    # Add the username and password
5816    password_mgr.add_password(None, rebuilt_url, username, password);
5817    # Create an authentication handler using the password manager
5818    auth_handler = HTTPBasicAuthHandler(password_mgr);
5819    # Build the opener with the authentication handler
5820    opener = build_opener(auth_handler);
5821   else:
5822    opener = build_opener();
5823   # Open the URL using the custom opener
5824   response = opener.open(request);
5825   data = response.read();
5826   # Write the data to a temporary file object
5827   temp_file = BytesIO(data);
5828  # Reset file pointer to the start
5829  temp_file.seek(0);
5830  # Return the temporary file object
5831  return temp_file;
5832
5833 def download_file_from_http_string(url, headers=geturls_headers_pycatfile_python_alt):
5834  httpfile = download_file_from_http_file(url, headers);
5835  return ftpfile.read();
5836
5837 if(haveparamiko):
5838  def download_file_from_sftp_file(url):
5839   urlparts = urlparse(url);
5840   file_name = os.path.basename(urlparts.path);
5841   file_dir = os.path.dirname(urlparts.path);
5842   if(urlparts.scheme=="http" or urlparts.scheme=="https"):
5843    return False;
5844   sftp_port = urlparts.port;
5845   if(urlparts.port is None):
5846    sftp_port = 22;
5847   else:
5848    sftp_port = urlparts.port;
5849   if(urlparts.username is not None):
5850    sftp_username = urlparts.username;
5851   else:
5852    sftp_username = "anonymous";
5853   if(urlparts.password is not None):
5854    sftp_password = urlparts.password;
5855   elif(urlparts.password is None and urlparts.username=="anonymous"):
5856    sftp_password = "anonymous";
5857   else:
5858    sftp_password = "";
5859   if(urlparts.scheme!="sftp"):
5860    return False;
5861   ssh = paramiko.SSHClient();
5862   ssh.load_system_host_keys();
5863   ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy());
5864   try:
5865    ssh.connect(urlparts.hostname, port=sftp_port, username=urlparts.username, password=urlparts.password);
5866   except paramiko.ssh_exception.SSHException:
5867    return False;
5868   except socket.gaierror:
5869    log.info("Error With URL "+url);
5870    return False;
5871   except socket.timeout:
5872    log.info("Error With URL "+url);
5873    return False;
5874   sftp = ssh.open_sftp();
5875   sftpfile = BytesIO();
5876   sftp.getfo(urlparts.path, sftpfile);
5877   sftp.close();
5878   ssh.close();
5879   sftpfile.seek(0, 0);
5880   return sftpfile;
5881 else:
5882  def download_file_from_sftp_file(url):
5883   return False;
5884
5885 if(haveparamiko):
5886  def download_file_from_sftp_string(url):
5887   sftpfile = download_file_from_sftp_file(url);
5888   return sftpfile.read();
5889 else:
5890  def download_file_from_ftp_string(url):
5891   return False;
5892
5893 if(haveparamiko):
5894  def upload_file_to_sftp_file(sftpfile, url):
5895   urlparts = urlparse(url);
5896   file_name = os.path.basename(urlparts.path);
5897   file_dir = os.path.dirname(urlparts.path);
5898   sftp_port = urlparts.port;
5899   if(urlparts.scheme=="http" or urlparts.scheme=="https"):
5900    return False;
5901   if(urlparts.port is None):
5902    sftp_port = 22;
5903   else:
5904    sftp_port = urlparts.port;
5905   if(urlparts.username is not None):
5906    sftp_username = urlparts.username;
5907   else:
5908    sftp_username = "anonymous";
5909   if(urlparts.password is not None):
5910    sftp_password = urlparts.password;
5911   elif(urlparts.password is None and urlparts.username=="anonymous"):
5912    sftp_password = "anonymous";
5913   else:
5914    sftp_password = "";
5915   if(urlparts.scheme!="sftp"):
5916    return False;
5917   ssh = paramiko.SSHClient();
5918   ssh.load_system_host_keys();
5919   ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy());
5920   try:
5921    ssh.connect(urlparts.hostname, port=sftp_port, username=urlparts.username, password=urlparts.password);
5922   except paramiko.ssh_exception.SSHException:
5923    return False;
5924   except socket.gaierror:
5925    log.info("Error With URL "+url);
5926    return False;
5927   except socket.timeout:
5928    log.info("Error With URL "+url);
5929    return False;
5930   sftp = ssh.open_sftp();
5931   sftp.putfo(sftpfile, urlparts.path);
5932   sftp.close();
5933   ssh.close();
5934   sftpfile.seek(0, 0);
5935   return sftpfile;
5936 else:
5937  def upload_file_to_sftp_file(sftpfile, url):
5938   return False;
5939
5940 if(haveparamiko):
5941  def upload_file_to_sftp_string(sftpstring, url):
5942   sftpfileo = BytesIO(sftpstring);
5943   sftpfile = upload_file_to_sftp_files(ftpfileo, url);
5944   sftpfileo.close();
5945   return sftpfile;
5946 else:
5947  def upload_file_to_sftp_string(url):
5948   return False;
5949
5950 if(havepysftp):
5951  def download_file_from_pysftp_file(url):
5952   urlparts = urlparse(url);
5953   file_name = os.path.basename(urlparts.path);
5954   file_dir = os.path.dirname(urlparts.path);
5955   if(urlparts.scheme=="http" or urlparts.scheme=="https"):
5956    return False;
5957   sftp_port = urlparts.port;
5958   if(urlparts.port is None):
5959    sftp_port = 22;
5960   else:
5961    sftp_port = urlparts.port;
5962   if(urlparts.username is not None):
5963    sftp_username = urlparts.username;
5964   else:
5965    sftp_username = "anonymous";
5966   if(urlparts.password is not None):
5967    sftp_password = urlparts.password;
5968   elif(urlparts.password is None and urlparts.username=="anonymous"):
5969    sftp_password = "anonymous";
5970   else:
5971    sftp_password = "";
5972   if(urlparts.scheme!="sftp"):
5973    return False;
5974   try:
5975    pysftp.Connection(urlparts.hostname, port=sftp_port, username=urlparts.username, password=urlparts.password);
5976   except paramiko.ssh_exception.SSHException:
5977    return False;
5978   except socket.gaierror:
5979    log.info("Error With URL "+url);
5980    return False;
5981   except socket.timeout:
5982    log.info("Error With URL "+url);
5983    return False;
5984   sftp = ssh.open_sftp();
5985   sftpfile = BytesIO();
5986   sftp.getfo(urlparts.path, sftpfile);
5987   sftp.close();
5988   ssh.close();
5989   sftpfile.seek(0, 0);
5990   return sftpfile;
5991 else:
5992  def download_file_from_pysftp_file(url):
5993   return False;
5994
5995 if(havepysftp):
5996  def download_file_from_pysftp_string(url):
5997   sftpfile = download_file_from_pysftp_file(url);
5998   return sftpfile.read();
5999 else:
6000  def download_file_from_ftp_string(url):
6001   return False;
6002
6003 if(havepysftp):
6004  def upload_file_to_pysftp_file(sftpfile, url):
6005   urlparts = urlparse(url);
6006   file_name = os.path.basename(urlparts.path);
6007   file_dir = os.path.dirname(urlparts.path);
6008   sftp_port = urlparts.port;
6009   if(urlparts.scheme=="http" or urlparts.scheme=="https"):
6010    return False;
6011   if(urlparts.port is None):
6012    sftp_port = 22;
6013   else:
6014    sftp_port = urlparts.port;
6015   if(urlparts.username is not None):
6016    sftp_username = urlparts.username;
6017   else:
6018    sftp_username = "anonymous";
6019   if(urlparts.password is not None):
6020    sftp_password = urlparts.password;
6021   elif(urlparts.password is None and urlparts.username=="anonymous"):
6022    sftp_password = "anonymous";
6023   else:
6024    sftp_password = "";
6025   if(urlparts.scheme!="sftp"):
6026    return False;
6027   try:
6028    pysftp.Connection(urlparts.hostname, port=sftp_port, username=urlparts.username, password=urlparts.password);
6029   except paramiko.ssh_exception.SSHException:
6030    return False;
6031   except socket.gaierror:
6032    log.info("Error With URL "+url);
6033    return False;
6034   except socket.timeout:
6035    log.info("Error With URL "+url);
6036    return False;
6037   sftp = ssh.open_sftp();
6038   sftp.putfo(sftpfile, urlparts.path);
6039   sftp.close();
6040   ssh.close();
6041   sftpfile.seek(0, 0);
6042   return sftpfile;
6043 else:
6044  def upload_file_to_pysftp_file(sftpfile, url):
6045   return False;
6046
6047 if(havepysftp):
6048  def upload_file_to_pysftp_string(sftpstring, url):
6049   sftpfileo = BytesIO(sftpstring);
6050   sftpfile = upload_file_to_pysftp_files(ftpfileo, url);
6051   sftpfileo.close();
6052   return sftpfile;
6053 else:
6054  def upload_file_to_pysftp_string(url):
6055   return False;
6056
6057 try:
6058  if(hasattr(shutil, "register_archive_format")):
6059   # Register the packing format
6060   shutil.register_archive_format(__file_format_name__, PackArchiveFileFunc, description='Pack concatenated files');
6061 except shutil.RegistryError:
6062  pass;
6063
6064 try:
6065  if(hasattr(shutil, "register_unpack_format")):
6066   # Register the unpacking format
6067   shutil.register_unpack_format(__file_format_name__, archivefile_extensions, UnPackArchiveFileFunc, description='UnPack concatenated files');
6068 except shutil.RegistryError:
6069  pass;