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