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