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