pycatfile.py

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