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