2 # -*- coding: utf-8 -*-
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the Revised BSD License.
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.
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
17 $FileInfo: pycatfile.py - Last Update: 4/29/2024 Ver. 0.9.0 RC 1 - Author: cooldude2k $
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
, platform
;
22 from ftplib
import FTP
, FTP_TLS
;
23 if(sys
.version
[0]=="2"):
24 from urlparse
import urlparse
, urlunparse
;
25 elif(sys
.version
[0]>="3"):
26 from urllib
.parse
import urlunparse
;
27 from urllib
.parse
import urlparse
;
29 if os
.name
== 'nt': # Only modify if on Windows
30 if sys
.version
[0] == "2":
32 sys
.stdout
= codecs
.getwriter('utf-8')(sys
.stdout
);
33 sys
.stderr
= codecs
.getwriter('utf-8')(sys
.stderr
);
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);
39 hashlib_guaranteed
= False;
40 os
.environ
["PYTHONIOENCODING"] = "UTF-8";
41 os
.environ
["LC_CTYPE"] = "UTF-8";
45 sys
.setdefaultencoding('UTF-8');
48 except AttributeError:
52 except AttributeError:
56 from zlib
import crc32
;
58 from binascii
import crc32
;
60 rarfile_support
= False;
63 rarfile_support
= True;
65 rarfile_support
= False;
67 py7zr_support
= False;
72 py7zr_support
= False;
75 from safetar
import is_tarfile
;
78 from xtarfile
import is_tarfile
;
80 from tarfile
import is_tarfile
;
83 import safetar
as tarfile
;
86 import xtarfile
as tarfile
;
104 haverequests
= False;
109 haverequests
= False;
113 logging
.getLogger("urllib3").setLevel(logging
.WARNING
);
117 from urllib
.request
import Request
, build_opener
, HTTPBasicAuthHandler
;
118 from urllib
.parse
import urlparse
;
121 from urllib2
import Request
, build_opener
, HTTPBasicAuthHandler
;
122 from urlparse
import urlparse
;
124 if(sys
.version
[0]=="2"):
126 from io
import StringIO
, BytesIO
;
129 from cStringIO
import StringIO
;
130 from cStringIO
import StringIO
as BytesIO
;
132 from StringIO
import StringIO
;
133 from StringIO
import StringIO
as BytesIO
;
134 elif(sys
.version
[0]>="3"):
135 from io
import StringIO
, BytesIO
;
140 from cStringIO
import StringIO
as BytesIO
;
146 from StringIO
import StringIO
as BytesIO
;
152 from io
import BytesIO
;
157 __use_pysftp__
= False;
159 __use_pysftp__
= False;
160 __file_format_name__
= "CatFile";
161 __program_name__
= "Py"+__file_format_name__
;
162 __file_format_lower__
= __file_format_name__
.lower();
163 __file_format_magic__
= __file_format_name__
;
164 __file_format_len__
= len(__file_format_magic__
);
165 __file_format_hex__
= binascii
.hexlify(__file_format_magic__
.encode("UTF-8")).decode("UTF-8");
166 __file_format_delimiter__
= "\x00";
167 __file_format_ver__
= "001";
168 __use_new_style__
= True;
169 __use_advanced_list__
= True;
170 __use_alt_inode__
= False;
171 __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__
, __use_advanced_list__
, __use_alt_inode__
];
172 __project__
= __program_name__
;
173 __project_url__
= "https://github.com/GameMaker2k/PyCatFile";
174 __version_info__
= (0, 9, 0, "RC 1", 1);
175 __version_date_info__
= (2024, 4, 29, "RC 1", 1);
176 __version_date__
= str(__version_date_info__
[0]) + "." + str(__version_date_info__
[1]).zfill(2) + "." + str(__version_date_info__
[2]).zfill(2);
177 __revision__
= __version_info__
[3];
178 __revision_id__
= "$Id$";
179 if(__version_info__
[4] is not None):
180 __version_date_plusrc__
= __version_date__
+ "-" + str(__version_date_info__
[4]);
181 if(__version_info__
[4] is None):
182 __version_date_plusrc__
= __version_date__
;
183 if(__version_info__
[3] is not None):
184 __version__
= str(__version_info__
[0]) + "." + str(__version_info__
[1]) + "." + str(__version_info__
[2]) + " " + str(__version_info__
[3]);
185 if(__version_info__
[3] is None):
186 __version__
= str(__version_info__
[0]) + "." + str(__version_info__
[1]) + "." + str(__version_info__
[2]);
188 PyBitness
= platform
.architecture();
189 if(PyBitness
=="32bit" or PyBitness
=="32"):
191 elif(PyBitness
=="64bit" or PyBitness
=="64"):
196 geturls_ua_pycatfile_python
= "Mozilla/5.0 (compatible; {proname}/{prover}; +{prourl})".format(proname
=__project__
, prover
=__version__
, prourl
=__project_url__
);
197 if(platform
.python_implementation()!=""):
198 py_implementation
= platform
.python_implementation();
199 if(platform
.python_implementation()==""):
200 py_implementation
= "Python";
201 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__
);
202 geturls_ua_googlebot_google
= "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)";
203 geturls_ua_googlebot_google_old
= "Googlebot/2.1 (+http://www.google.com/bot.html)";
204 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
)};
205 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
)};
206 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"};
207 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"};
209 compressionlist
= ['auto', 'gzip', 'bzip2', 'zstd', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
210 outextlist
= ['gz', 'bz2', 'zst', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
211 outextlistwd
= ['.gz', '.bz2', '.zst', '.lz4', '.lzo', '.lzop', '.lzma', '.xz'];
213 tarfile_mimetype
= "application/tar";
214 tarfile_tar_mimetype
= tarfile_mimetype
;
215 zipfile_mimetype
= "application/zip";
216 zipfile_zip_mimetype
= zipfile_mimetype
;
217 rarfile_mimetype
= "application/rar";
218 rarfile_rar_mimetype
= rarfile_mimetype
;
219 archivefile_mimetype
= "application/x-"+__file_format_list__
[1]+"";
220 archivefile_cat_mimetype
= archivefile_mimetype
;
221 archivefile_gzip_mimetype
= "application/x-"+__file_format_list__
[1]+"+gzip";
222 archivefile_gz_mimetype
= archivefile_gzip_mimetype
;
223 archivefile_bzip2_mimetype
= "application/x-"+__file_format_list__
[1]+"+bzip2";
224 archivefile_bz2_mimetype
= archivefile_bzip2_mimetype
;
225 archivefile_lz4_mimetype
= "application/x-"+__file_format_list__
[1]+"+lz4";
226 archivefile_lzop_mimetype
= "application/x-"+__file_format_list__
[1]+"+lzop";
227 archivefile_lzo_mimetype
= archivefile_lzop_mimetype
;
228 archivefile_zstandard_mimetype
= "application/x-"+__file_format_list__
[1]+"+zstandard";
229 archivefile_zstd_mimetype
= archivefile_zstandard_mimetype
;
230 archivefile_lzma_mimetype
= "application/x-"+__file_format_list__
[1]+"+lzma";
231 archivefile_xz_mimetype
= "application/x-"+__file_format_list__
[1]+"+xz";
232 archivefile_extensions
= ['.cat', '.cat.gz', '.cat.bz2', '.cat.zst', '.cat.lz4', '.cat.lzo', '.cat.lzop', '.cat.lzma', '.cat.xz'];
234 if __name__
== "__main__":
236 curscrpath
= os
.path
.dirname(sys
.argv
[0]);
240 curscrpath
= curscrpath
.replace(os
.sep
, "/");
241 curscrpath
= curscrpath
+ "/";
242 scrfile
= curscrpath
+ "catfile.py";
243 if(os
.path
.exists(scrfile
) and os
.path
.isfile(scrfile
)):
244 scrcmd
= subprocess
.Popen([sys
.executable
, scrfile
] + sys
.argv
[1:]);
247 def VerbosePrintOut(dbgtxt
, outtype
="log", dbgenable
=True, dgblevel
=20):
253 "warning": logging
.warning
,
254 "error": logging
.error
,
255 "critical": logging
.critical
,
256 "exception": logging
.exception
,
257 "logalt": lambda x
: logging
.log(dgblevel
, x
),
258 "debug": logging
.debug
260 log_function
= log_functions
.get(outtype
);
262 log_function(dbgtxt
);
266 def VerbosePrintOutReturn(dbgtxt
, outtype
="log", dbgenable
=True, dgblevel
=20):
267 VerbosePrintOut(dbgtxt
, outtype
, dbgenable
, dgblevel
);
270 def RemoveWindowsPath(dpath
):
274 dpath
= dpath
.replace(os
.path
.sep
, "/");
275 dpath
= dpath
.rstrip("/");
276 if(dpath
=="." or dpath
==".."):
280 def NormalizeRelativePath(inpath
):
281 inpath
= RemoveWindowsPath(inpath
);
282 if(os
.path
.isabs(inpath
)):
285 if(inpath
.startswith("./") or inpath
.startswith("../")):
288 outpath
= "./" + inpath
;
291 def PrependPath(base_dir
, child_path
):
292 # Check if base_dir is None or empty, if so, return child_path as is
295 # Ensure base_dir ends with exactly one slash
296 if not base_dir
.endswith('/'):
298 # Check if child_path starts with ./ or ../ (indicating a relative path)
299 if child_path
.startswith('./') or child_path
.startswith('../'):
300 # For relative paths, we don't alter the child_path
301 return base_dir
+ child_path
;
303 # For non-relative paths, ensure there's no starting slash on child_path to avoid double slashes
304 return base_dir
+ child_path
.lstrip('/');
306 def ListDir(dirpath
, followlink
=False, duplicates
=False):
307 if(isinstance(dirpath
, (list, tuple, ))):
308 dirpath
= list(filter(None, dirpath
));
309 elif(isinstance(dirpath
, (str, ))):
310 dirpath
= list(filter(None, [dirpath
]));
312 for mydirfile
in dirpath
:
313 if(not os
.path
.exists(mydirfile
)):
315 mydirfile
= NormalizeRelativePath(mydirfile
);
316 if(os
.path
.exists(mydirfile
) and os
.path
.islink(mydirfile
)):
317 mydirfile
= RemoveWindowsPath(os
.path
.realpath(mydirfile
));
318 if(os
.path
.exists(mydirfile
) and os
.path
.isdir(mydirfile
)):
319 for root
, dirs
, filenames
in os
.walk(mydirfile
):
321 dpath
= RemoveWindowsPath(dpath
);
322 if(dpath
not in retlist
and not duplicates
):
323 retlist
.append(dpath
);
325 retlist
.append(dpath
);
326 for file in filenames
:
327 fpath
= os
.path
.join(root
, file);
328 fpath
= RemoveWindowsPath(fpath
);
329 if(fpath
not in retlist
and not duplicates
):
330 retlist
.append(fpath
);
332 retlist
.append(fpath
);
334 retlist
.append(RemoveWindowsPath(mydirfile
));
337 def ListDirAdvanced(dirpath
, followlink
=False, duplicates
=False):
338 if isinstance(dirpath
, (list, tuple)):
339 dirpath
= list(filter(None, dirpath
));
340 elif isinstance(dirpath
, str):
341 dirpath
= list(filter(None, [dirpath
]));
343 for mydirfile
in dirpath
:
344 if not os
.path
.exists(mydirfile
):
346 mydirfile
= NormalizeRelativePath(mydirfile
);
347 if os
.path
.exists(mydirfile
) and os
.path
.islink(mydirfile
) and followlink
:
348 mydirfile
= RemoveWindowsPath(os
.path
.realpath(mydirfile
))
349 if os
.path
.exists(mydirfile
) and os
.path
.isdir(mydirfile
):
350 for root
, dirs
, filenames
in os
.walk(mydirfile
):
351 # Sort dirs and filenames alphabetically in place
352 dirs
.sort(key
=lambda x
: x
.lower());
353 filenames
.sort(key
=lambda x
: x
.lower());
354 dpath
= RemoveWindowsPath(root
);
355 if not duplicates
and dpath
not in retlist
:
356 retlist
.append(dpath
);
358 retlist
.append(dpath
);
359 for file in filenames
:
360 fpath
= os
.path
.join(root
, file);
361 fpath
= RemoveWindowsPath(fpath
);
362 if not duplicates
and fpath
not in retlist
:
363 retlist
.append(fpath
);
365 retlist
.append(fpath
);
367 retlist
.append(RemoveWindowsPath(mydirfile
));
370 def create_alias_function(prefix
, base_name
, suffix
, target_function
):
371 # Define a new function that wraps the target function
372 def alias_function(*args
, **kwargs
):
373 return target_function(*args
, **kwargs
);
375 # Create the function name by combining the prefix, base name, and the suffix
376 function_name
= "{}{}{}".format(prefix
, base_name
, suffix
);
378 # Add the new function to the global namespace
379 globals()[function_name
] = alias_function
;
381 def create_alias_function_alt(prefix
, base_name
, suffix
, target_function
):
382 # Create the function name by combining the prefix, base name, and the suffix
383 # Use the format method for string formatting, compatible with Python 2 and 3
384 function_name
= "{}{}{}".format(prefix
, base_name
, suffix
)
385 # Add the new function (alias of the target_function) to the global namespace
386 # This line is compatible as-is with both Python 2 and 3
387 globals()[function_name
] = target_function
389 # initial_value can be 0xFFFF or 0x0000
390 def crc16_ansi(msg
, initial_value
=0xFFFF):
391 # CRC-16-IBM / CRC-16-ANSI polynomial and initial value
392 poly
= 0x8005; # Polynomial for CRC-16-IBM / CRC-16-ANSI
393 crc
= initial_value
; # Initial value
395 crc ^
= b
<< 8; # XOR byte into CRC top byte
396 for _
in range(8): # Process each bit
397 if crc
& 0x8000: # If the top bit is set
398 crc
= (crc
<< 1) ^ poly
; # Shift left and XOR with the polynomial
400 crc
= crc
<< 1; # Just shift left
401 crc
&= 0xFFFF; # Ensure CRC remains 16-bit
404 # initial_value can be 0xFFFF or 0x0000
405 def crc16_ibm(msg
, initial_value
=0xFFFF):
406 return crc16_ansi(msg
, initial_value
);
408 # initial_value is 0xFFFF
410 return crc16_ansi(msg
, 0xFFFF);
412 # initial_value can be 0xFFFF, 0x1D0F or 0x0000
413 def crc16_ccitt(msg
, initial_value
=0xFFFF):
414 # CRC-16-CCITT polynomial
415 poly
= 0x1021; # Polynomial for CRC-16-CCITT
416 # Use the specified initial value
419 crc ^
= b
<< 8; # XOR byte into CRC top byte
420 for _
in range(8): # Process each bit
421 if crc
& 0x8000: # If the top bit is set
422 crc
= (crc
<< 1) ^ poly
; # Shift left and XOR with the polynomial
424 crc
= crc
<< 1; # Just shift left
425 crc
&= 0xFFFF; # Ensure CRC remains 16-bit
428 # initial_value can be 0x42F0E1EBA9EA3693 or 0x0000000000000000
429 def crc64_ecma(msg
, initial_value
=0x0000000000000000):
430 # CRC-64-ECMA polynomial and initial value
431 poly
= 0x42F0E1EBA9EA3693;
432 crc
= initial_value
; # Initial value for CRC-64-ECMA
434 crc ^
= b
<< 56; # XOR byte into the most significant byte of the CRC
435 for _
in range(8): # Process each bit
436 if crc
& (1 << 63): # Check if the leftmost (most significant) bit is set
437 crc
= (crc
<< 1) ^ poly
; # Shift left and XOR with poly if the MSB is 1
439 crc
<<= 1; # Just shift left if the MSB is 0
440 crc
&= 0xFFFFFFFFFFFFFFFF; # Ensure CRC remains 64-bit
443 # initial_value can be 0x000000000000001B or 0xFFFFFFFFFFFFFFFF
444 def crc64_iso(msg
, initial_value
=0xFFFFFFFFFFFFFFFF):
445 # CRC-64-ISO polynomial and initial value
446 poly
= 0x000000000000001B;
447 crc
= initial_value
; # Common initial value for CRC-64-ISO
449 crc ^
= b
<< 56; # XOR byte into the most significant byte of the CRC
450 for _
in range(8): # Process each bit
451 if crc
& (1 << 63): # Check if the leftmost (most significant) bit is set
452 crc
= (crc
<< 1) ^ poly
; # Shift left and XOR with poly if the MSB is 1
454 crc
<<= 1; # Just shift left if the MSB is 0
455 crc
&= 0xFFFFFFFFFFFFFFFF; # Ensure CRC remains 64-bit
458 def GetDataFromArray(data
, path
, default
=None):
462 element
= element
[key
];
464 except (KeyError, TypeError, IndexError):
467 def GetDataFromArrayAlt(structure
, path
, default
=None):
470 if isinstance(element
, dict) and key
in element
:
471 element
= element
[key
];
472 elif isinstance(element
, list) and isinstance(key
, int) and -len(element
) <= key
< len(element
):
473 element
= element
[key
];
478 def GetHeaderChecksum(inlist
=[], checksumtype
="crc32", encodedata
=True, formatspecs
=__file_format_list__
):
479 if isinstance(inlist
, list):
480 fileheader
= AppendNullBytes(inlist
, formatspecs
[5]);
482 fileheader
= AppendNullByte(inlist
, formatspecs
[5]);
484 fileheader
= fileheader
.encode('UTF-8');
485 if(checksumtype
=="none" or checksumtype
==""):
486 catfileheadercshex
= format(0, 'x').lower();
487 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
488 catfileheadercshex
= format(crc16(fileheader
) & 0xffff, '04x').lower();
489 elif(checksumtype
=="crc16_ccitt"):
490 catfileheadercshex
= format(crc16_ccitt(fileheader
) & 0xffff, '04x').lower();
491 elif(checksumtype
=="adler32"):
492 catfileheadercshex
= format(zlib
.adler32(fileheader
) & 0xffffffff, '08x').lower();
493 elif(checksumtype
=="crc32"):
494 catfileheadercshex
= format(crc32(fileheader
) & 0xffffffff, '08x').lower();
495 elif(checksumtype
=="crc64_ecma"):
496 catfileheadercshex
= format(crc64_ecma(fileheader
) & 0xffffffffffffffff, '016x').lower();
497 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
498 catfileheadercshex
= format(crc64_iso(fileheader
) & 0xffffffffffffffff, '016x').lower();
499 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
500 checksumoutstr
= hashlib
.new(checksumtype
);
501 checksumoutstr
.update(fileheader
);
502 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
504 catfileheadercshex
= format(0, 'x').lower();
505 return catfileheadercshex
;
507 def GetFileChecksum(instr
, checksumtype
="crc32", encodedata
=True, formatspecs
=__file_format_list__
):
509 instr
= instr
.encode('UTF-8');
510 if(checksumtype
=="none" or checksumtype
==""):
511 catinstrcshex
= format(0, 'x').lower();
512 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
513 catinstrcshex
= format(crc16(instr
) & 0xffff, '04x').lower();
514 elif(checksumtype
=="crc16_ccitt"):
515 catinstrcshex
= format(crc16_ccitt(instr
) & 0xffff, '04x').lower();
516 elif(checksumtype
=="adler32"):
517 catinstrcshex
= format(zlib
.adler32(instr
) & 0xffffffff, '08x').lower();
518 elif(checksumtype
=="crc32"):
519 catinstrcshex
= format(crc32(instr
) & 0xffffffff, '08x').lower();
520 elif(checksumtype
=="crc64_ecma"):
521 catinstrcshex
= format(crc64_ecma(instr
) & 0xffffffffffffffff, '016x').lower();
522 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
523 catinstrcshex
= format(crc64_iso(instr
) & 0xffffffffffffffff, '016x').lower();
524 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
525 checksumoutstr
= hashlib
.new(checksumtype
);
526 checksumoutstr
.update(instr
);
527 catinstrcshex
= checksumoutstr
.hexdigest().lower();
529 catinstrcshex
= format(0, 'x').lower();
530 return catinstrcshex
;
532 def ValidateHeaderChecksum(inlist
=[], checksumtype
="crc32", inchecksum
="0", formatspecs
=__file_format_list__
):
533 catfileheadercshex
= GetHeaderChecksum(inlist
, checksumtype
, True, formatspecs
);
534 inchecksum
= inchecksum
.lower();
535 catfileheadercshex
= catfileheadercshex
.lower();
536 if(inchecksum
==catfileheadercshex
):
541 def ValidateFileChecksum(infile
, checksumtype
="crc32", inchecksum
="0", formatspecs
=__file_format_list__
):
542 catinfilecshex
= GetFileChecksum(infile
, checksumtype
, True, formatspecs
);
543 inchecksum
= inchecksum
.lower();
544 catinfilecshex
= catinfilecshex
.lower();
545 if(inchecksum
==catinfilecshex
):
550 def ReadTillNullByte(fp
, delimiter
=__file_format_delimiter__
):
553 nullbyte
= delimiter
.encode("UTF-8");
555 curbyte
= fp
.read(1);
556 if(curbyte
==nullbyte
or not curbyte
):
558 curfullbyte
= curfullbyte
+ curbyte
;
559 return curfullbyte
.decode('UTF-8');
561 def ReadUntilNullByte(fp
, delimiter
=__file_format_delimiter__
):
562 return ReadTillNullByte(fp
, delimiter
);
564 def SeekToEndOfFile(fp
):
568 if(lasttell
==fp
.tell()):
570 lasttell
= fp
.tell();
573 def ReadFileHeaderData(fp
, rounds
=0, delimiter
=__file_format_delimiter__
):
577 while(rocount
<roend
):
578 HeaderOut
.append(ReadTillNullByte(fp
, delimiter
));
579 rocount
= rocount
+ 1;
582 def ReadFileHeaderDataBySize(fp
, delimiter
=__file_format_delimiter__
):
583 headerpresize
= ReadTillNullByte(fp
, delimiter
);
584 headersize
= int(headerpresize
, 16);
587 headercontent
= str(fp
.read(headersize
).decode('UTF-8')).split(delimiter
);
590 roend
= int(len(headercontent
));
591 HeaderOut
= [headerpresize
];
592 while(rocount
<roend
):
593 HeaderOut
.append(headercontent
[rocount
]);
594 rocount
= rocount
+ 1;
597 def ReadFileHeaderDataWoSize(fp
, delimiter
=__file_format_delimiter__
):
598 preheaderdata
= ReadFileHeaderData(fp
, 2, delimiter
);
599 headersize
= int(preheaderdata
[0], 16);
600 headernumfields
= int(preheaderdata
[1], 16);
601 if(headersize
<=0 or headernumfields
<=0):
603 headerdata
= ReadFileHeaderData(fp
, headernumfields
, delimiter
);
604 HeaderOut
= preheaderdata
+ headerdata
;
607 def ReadFileHeaderDataBySizeWithContent(fp
, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
):
608 delimiter
= formatspecs
[5];
609 fheaderstart
= fp
.tell();
610 HeaderOut
= ReadFileHeaderDataBySize(fp
, delimiter
);
611 if(len(HeaderOut
)==0):
613 if(re
.findall("^[.|/]", HeaderOut
[3])):
614 fname
= HeaderOut
[3];
616 fname
= "./"+HeaderOut
[3];
617 fchecksumtype
= HeaderOut
[-3].lower();
618 fcs
= HeaderOut
[-2].lower();
619 fccs
= HeaderOut
[-1].lower();
620 fsize
= int(HeaderOut
[5], 16);
621 newfcs
= GetHeaderChecksum(HeaderOut
[:-2], HeaderOut
[-3].lower(), True, formatspecs
);
622 if(fcs
!=newfcs
and not skipchecksum
):
623 VerbosePrintOut("File Header Checksum Error with file " + fname
+ " at offset " + str(fheaderstart
));
625 fhend
= fp
.tell() - 1;
626 fcontentstart
= fp
.tell();
627 fcontents
= "".encode('UTF-8');
628 if(fsize
>0 and not listonly
):
629 fcontents
= fp
.read(fsize
);
630 elif(fsize
>0 and listonly
):
632 newfccs
= GetFileChecksum(fcontents
, HeaderOut
[-3].lower(), False, formatspecs
);
633 if(fccs
!=newfccs
and not skipchecksum
and not listonly
):
634 VerbosePrintOut("File Content Checksum Error with file " + fname
+ " at offset " + str(fcontentstart
));
637 fcontentend
= fp
.tell() - 1;
638 HeaderOut
.append(fcontents
);
641 def ReadFileHeaderDataBySizeWithContentToArray(fp
, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
):
642 delimiter
= formatspecs
[5];
643 fheaderstart
= fp
.tell();
645 HeaderOut
= ReadFileHeaderDataBySize(fp
, delimiter
);
647 HeaderOut
= ReadFileHeaderDataWoSize(fp
, delimiter
);
648 if(len(HeaderOut
)==0):
650 fheadsize
= int(HeaderOut
[0], 16);
651 fnumfields
= int(HeaderOut
[1], 16);
652 ftype
= int(HeaderOut
[2], 16);
653 if(re
.findall("^[.|/]", HeaderOut
[3])):
654 fname
= HeaderOut
[3];
656 fname
= "./"+HeaderOut
[3];
657 fbasedir
= os
.path
.dirname(fname
);
658 flinkname
= HeaderOut
[4];
659 fsize
= int(HeaderOut
[5], 16);
660 fatime
= int(HeaderOut
[6], 16);
661 fmtime
= int(HeaderOut
[7], 16);
662 fctime
= int(HeaderOut
[8], 16);
663 fbtime
= int(HeaderOut
[9], 16);
664 fmode
= int(HeaderOut
[10], 16);
665 fchmode
= stat
.S_IMODE(fmode
);
666 ftypemod
= stat
.S_IFMT(fmode
);
667 fwinattributes
= int(HeaderOut
[11], 16);
668 fuid
= int(HeaderOut
[12], 16);
669 funame
= HeaderOut
[13];
670 fgid
= int(HeaderOut
[14], 16);
671 fgname
= HeaderOut
[15];
672 fid
= int(HeaderOut
[16], 16);
673 finode
= int(HeaderOut
[17], 16);
674 flinkcount
= int(HeaderOut
[18], 16);
675 fdev_minor
= int(HeaderOut
[19], 16);
676 fdev_major
= int(HeaderOut
[20], 16);
677 frdev_minor
= int(HeaderOut
[21], 16);
678 frdev_major
= int(HeaderOut
[22], 16);
679 fextrasize
= int(HeaderOut
[23], 16);
680 fextrafields
= int(HeaderOut
[24], 16);
681 extrafieldslist
= [];
683 extraend
= extrastart
+ fextrafields
;
684 extrafieldslist
= [];
685 if(extrastart
<extraend
):
686 extrafieldslist
.append(HeaderOut
[extrastart
]);
687 extrastart
= extrastart
+ 1;
688 fchecksumtype
= HeaderOut
[extrastart
].lower();
689 fcs
= HeaderOut
[extrastart
+ 1].lower();
690 fccs
= HeaderOut
[extrastart
+ 2].lower();
691 newfcs
= GetHeaderChecksum(HeaderOut
[:-2], HeaderOut
[-3].lower(), True, formatspecs
);
692 if(fcs
!=newfcs
and not skipchecksum
):
693 VerbosePrintOut("File Header Checksum Error with file " + fname
+ " at offset " + str(fheaderstart
));
695 fhend
= fp
.tell() - 1;
696 fcontentstart
= fp
.tell();
697 fcontents
= "".encode('UTF-8');
698 pyhascontents
= False;
699 if(fsize
>0 and not listonly
):
700 fcontents
= fp
.read(fsize
);
701 pyhascontents
= True;
702 elif(fsize
>0 and listonly
):
704 pyhascontents
= False;
705 newfccs
= GetFileChecksum(fcontents
, HeaderOut
[-3].lower(), False, formatspecs
);
706 if(fccs
!=newfccs
and not skipchecksum
and not listonly
):
707 VerbosePrintOut("File Content Checksum Error with file " + fname
+ " at offset " + str(fcontentstart
));
710 fcontentend
= fp
.tell() - 1;
711 catlist
= {'fheadersize': fheadsize
, 'fhstart': fheaderstart
, 'fhend': fhend
, 'ftype': ftype
, 'fname': fname
, 'fbasedir': fbasedir
, 'flinkname': flinkname
, 'fsize': fsize
, 'fatime': fatime
, 'fmtime': fmtime
, 'fctime': fctime
, 'fbtime': fbtime
, 'fmode': fmode
, 'fchmode': fchmode
, 'ftypemod': ftypemod
, 'fwinattributes': fwinattributes
, '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': fchecksumtype
, 'fnumfields': fnumfields
+ 2, 'frawheader': HeaderOut
, 'fextrafields': fextrafields
, 'fextrafieldsize': fextrasize
, 'fextralist': extrafieldslist
, 'fheaderchecksum': fcs
, 'fcontentchecksum': fccs
, 'fhascontents': pyhascontents
, 'fcontentstart': fcontentstart
, 'fcontentend': fcontentend
, 'fcontents': fcontents
};
714 def ReadFileHeaderDataBySizeWithContentToList(fp
, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
):
715 delimiter
= formatspecs
[5];
716 fheaderstart
= fp
.tell();
718 HeaderOut
= ReadFileHeaderDataBySize(fp
, delimiter
);
720 HeaderOut
= ReadFileHeaderDataWoSize(fp
, delimiter
);
721 if(len(HeaderOut
)==0):
723 fheadsize
= int(HeaderOut
[0], 16);
724 fnumfields
= int(HeaderOut
[1], 16);
725 ftype
= int(HeaderOut
[2], 16);
726 if(re
.findall("^[.|/]", HeaderOut
[3])):
727 fname
= HeaderOut
[3];
729 fname
= "./"+HeaderOut
[3];
730 fbasedir
= os
.path
.dirname(fname
);
731 flinkname
= HeaderOut
[4];
732 fsize
= int(HeaderOut
[5], 16);
733 fatime
= int(HeaderOut
[6], 16);
734 fmtime
= int(HeaderOut
[7], 16);
735 fctime
= int(HeaderOut
[8], 16);
736 fbtime
= int(HeaderOut
[9], 16);
737 fmode
= int(HeaderOut
[10], 16);
738 fchmode
= stat
.S_IMODE(fmode
);
739 ftypemod
= stat
.S_IFMT(fmode
);
740 fwinattributes
= int(HeaderOut
[11], 16);
741 fuid
= int(HeaderOut
[12], 16);
742 funame
= HeaderOut
[13];
743 fgid
= int(HeaderOut
[14], 16);
744 fgname
= HeaderOut
[15];
745 fid
= int(HeaderOut
[16], 16);
746 finode
= int(HeaderOut
[17], 16);
747 flinkcount
= int(HeaderOut
[18], 16);
748 fdev_minor
= int(HeaderOut
[19], 16);
749 fdev_major
= int(HeaderOut
[20], 16);
750 frdev_minor
= int(HeaderOut
[21], 16);
751 frdev_major
= int(HeaderOut
[22], 16);
752 fextrasize
= int(HeaderOut
[23], 16);
753 fextrafields
= int(HeaderOut
[24], 16);
754 extrafieldslist
= [];
756 extraend
= extrastart
+ fextrafields
;
757 extrafieldslist
= [];
758 if(extrastart
<extraend
):
759 extrafieldslist
.append(HeaderOut
[extrastart
]);
760 extrastart
= extrastart
+ 1;
761 fchecksumtype
= HeaderOut
[extrastart
].lower();
762 fcs
= HeaderOut
[extrastart
+ 1].lower();
763 fccs
= HeaderOut
[extrastart
+ 2].lower();
764 newfcs
= GetHeaderChecksum(HeaderOut
[:-2], HeaderOut
[-3].lower(), True, formatspecs
);
765 if(fcs
!=newfcs
and not skipchecksum
):
766 VerbosePrintOut("File Header Checksum Error with file " + fname
+ " at offset " + str(fheaderstart
));
768 fhend
= fp
.tell() - 1;
769 fcontentstart
= fp
.tell();
770 fcontents
= "".encode('UTF-8');
771 pyhascontents
= False;
772 if(fsize
>0 and not listonly
):
773 fcontents
= fp
.read(fsize
);
774 pyhascontents
= True;
775 elif(fsize
>0 and listonly
):
777 pyhascontents
= False;
778 newfccs
= GetFileChecksum(fcontents
, HeaderOut
[-3].lower(), False, formatspecs
);
779 if(fccs
!=newfccs
and not skipchecksum
and not listonly
):
780 VerbosePrintOut("File Content Checksum Error with file " + fname
+ " at offset " + str(fcontentstart
));
783 fcontentend
= fp
.tell() - 1;
784 catlist
= [ftype
, fname
, flinkname
, fsize
, fatime
, fmtime
, fctime
, fbtime
, fmode
, fwinattributes
, fuid
, funame
, fgid
, fgname
, fid
, finode
, flinkcount
, fdev_minor
, fdev_major
, frdev_minor
, frdev_major
, extrafieldslist
, fchecksumtype
, fcontents
];
787 def ReadFileDataBySizeWithContent(fp
, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
):
788 delimiter
= formatspecs
[5];
792 catheader
= ReadFileHeaderData(fp
, 4, delimiter
);
795 headercheck
= ValidateHeaderChecksum(catheader
[:-1], catheader
[2], catheader
[3], formatspecs
);
796 if(not headercheck
and not skipchecksum
):
797 VerbosePrintOut("File Header Checksum Error with file at offset " + str(0));
799 fnumfiles
= int(catheader
[1], 16);
802 while(countnum
< fnumfiles
):
803 HeaderOut
= ReadFileHeaderDataBySizeWithContent(fp
, listonly
, skipchecksum
, formatspecs
)
804 if(len(HeaderOut
)==0):
806 flist
.append(HeaderOut
);
807 countnum
= countnum
+ 1;
810 def ReadFileDataBySizeWithContentToArray(fp
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
):
811 delimiter
= formatspecs
[5];
815 catheader
= ReadFileHeaderData(fp
, 4, delimiter
);
818 headercheck
= ValidateHeaderChecksum(catheader
[:-1], catheader
[2], catheader
[3], formatspecs
);
819 if(not headercheck
and not skipchecksum
):
820 VerbosePrintOut("File Header Checksum Error with file at offset " + str(0));
822 catstring
= catheader
[0];
823 catversion
= re
.findall(r
"([\d]+)$", catstring
);
824 catversions
= re
.search(r
'(.*?)(\d+)$', catstring
).groups();
825 fprenumfiles
= catheader
[1];
826 fnumfiles
= int(fprenumfiles
, 16);
827 fprechecksumtype
= catheader
[2];
828 fprechecksum
= catheader
[3];
829 catlist
= {'fnumfiles': fnumfiles
, 'fformat': catversions
[0], 'fversion': catversions
[1], 'fformatspecs': formatspecs
, 'fchecksumtype': fprechecksumtype
, 'fheaderchecksum': fprechecksum
, 'ffilelist': {}};
830 if(seekstart
<0 and seekstart
>fnumfiles
):
832 if(seekend
==0 or seekend
>fnumfiles
and seekend
<seekstart
):
834 elif(seekend
<0 and abs(seekend
)<=fnumfiles
and abs(seekend
)>=seekstart
):
835 seekend
= fnumfiles
- abs(seekend
);
838 while(il
< seekstart
):
839 prefhstart
= fp
.tell();
840 preheaderdata
= ReadFileHeaderDataBySize(fp
, formatspecs
[5]);
841 if(len(preheaderdata
)==0):
843 prefsize
= int(preheaderdata
[5], 16);
844 prenewfcs
= GetHeaderChecksum(preheaderdata
[:-2], preheaderdata
[-3].lower(), True, formatspecs
);
845 prefcs
= preheaderdata
[-2];
846 if(prefcs
!=prenewfcs
and not skipchecksum
):
847 VerbosePrintOut("File Header Checksum Error with file " + prefname
+ " at offset " + str(prefhstart
));
849 valid_archive
= False;
850 invalid_archive
= True;
851 prefhend
= fp
.tell() - 1;
852 prefcontentstart
= fp
.tell();
854 pyhascontents
= False;
856 prefcontents
= fp
.read(prefsize
);
857 prenewfccs
= GetFileChecksum(prefcontents
, preheaderdata
[-3].lower(), False, formatspecs
);
858 prefccs
= preheaderdata
[-1];
859 pyhascontents
= True;
860 if(prefccs
!=prenewfccs
and not skipchecksum
):
861 VerbosePrintOut("File Content Checksum Error with file " + prefname
+ " at offset " + str(prefcontentstart
));
866 countnum
= seekstart
;
867 while(countnum
< seekend
):
868 catlist
['ffilelist'].update({realidnum
: {'fid': realidnum
, 'fidalt': realidnum
}});
869 HeaderOut
= ReadFileHeaderDataBySizeWithContentToArray(fp
, listonly
, skipchecksum
, formatspecs
);
872 catlist
['ffilelist'][realidnum
].update(HeaderOut
);
873 countnum
= countnum
+ 1;
874 realidnum
= realidnum
+ 1;
877 def ReadFileDataBySizeWithContentToArrayIndex(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
):
878 if(isinstance(infile
, dict)):
879 listcatfiles
= infile
;
881 if(infile
!="-" and not hasattr(infile
, "read") and not hasattr(infile
, "write")):
883 listcatfiles
= ReadFileDataBySizeWithContentToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
);
884 if(not listcatfiles
):
886 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': {}}}};
887 lenlist
= len(listcatfiles
['ffilelist']);
889 lcfx
= int(listcatfiles
['fnumfiles']);
890 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
893 lcfx
= int(listcatfiles
['fnumfiles']);
895 filetoidarray
= {listcatfiles
['ffilelist'][lcfi
]['fname']: listcatfiles
['ffilelist'][lcfi
]['fid']};
896 idtofilearray
= {listcatfiles
['ffilelist'][lcfi
]['fid']: listcatfiles
['ffilelist'][lcfi
]['fname']};
897 catarray
['filetoid'].update(filetoidarray
);
898 catarray
['idtofile'].update(idtofilearray
);
899 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==0 or listcatfiles
['ffilelist'][lcfi
]['ftype']==7):
900 catarray
['filetypes']['files']['filetoid'].update(filetoidarray
);
901 catarray
['filetypes']['files']['idtofile'].update(idtofilearray
);
902 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==1):
903 catarray
['filetypes']['hardlinks']['filetoid'].update(filetoidarray
);
904 catarray
['filetypes']['hardlinks']['idtofile'].update(idtofilearray
);
905 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
906 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
907 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==2):
908 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
909 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
910 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
911 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
912 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==3):
913 catarray
['filetypes']['character']['filetoid'].update(filetoidarray
);
914 catarray
['filetypes']['character']['idtofile'].update(idtofilearray
);
915 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
916 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
917 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==4):
918 catarray
['filetypes']['block']['filetoid'].update(filetoidarray
);
919 catarray
['filetypes']['block']['idtofile'].update(idtofilearray
);
920 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
921 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
922 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==5):
923 catarray
['filetypes']['directories']['filetoid'].update(filetoidarray
);
924 catarray
['filetypes']['directories']['idtofile'].update(idtofilearray
);
925 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==6):
926 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
927 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
928 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
929 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
933 def ReadFileDataBySizeWithContentToList(fp
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
):
934 delimiter
= formatspecs
[5];
938 catheader
= ReadFileHeaderData(fp
, 4, delimiter
);
941 headercheck
= ValidateHeaderChecksum(catheader
[:-1], catheader
[2], catheader
[3], formatspecs
);
942 if(not headercheck
and not skipchecksum
):
943 VerbosePrintOut("File Header Checksum Error with file at offset " + str(0));
945 catstring
= catheader
[0];
946 catversion
= re
.findall(r
"([\d]+)$", catstring
);
947 catversions
= re
.search(r
'(.*?)(\d+)$', catstring
).groups();
948 fprenumfiles
= catheader
[1];
949 fnumfiles
= int(fprenumfiles
, 16);
950 fprechecksumtype
= catheader
[2];
951 fprechecksum
= catheader
[3];
953 if(seekstart
<0 and seekstart
>fnumfiles
):
955 if(seekend
==0 or seekend
>fnumfiles
and seekend
<seekstart
):
957 elif(seekend
<0 and abs(seekend
)<=fnumfiles
and abs(seekend
)>=seekstart
):
958 seekend
= fnumfiles
- abs(seekend
);
961 while(il
< seekstart
):
962 prefhstart
= fp
.tell();
963 preheaderdata
= ReadFileHeaderDataBySize(fp
, formatspecs
[5]);
964 if(len(preheaderdata
)==0):
966 prefsize
= int(preheaderdata
[5], 16);
967 prenewfcs
= GetHeaderChecksum(preheaderdata
[:-2], preheaderdata
[-3].lower(), True, formatspecs
);
968 prefcs
= preheaderdata
[-2];
969 if(prefcs
!=prenewfcs
and not skipchecksum
):
970 VerbosePrintOut("File Header Checksum Error with file " + prefname
+ " at offset " + str(prefhstart
));
972 valid_archive
= False;
973 invalid_archive
= True;
974 prefhend
= fp
.tell() - 1;
975 prefcontentstart
= fp
.tell();
977 pyhascontents
= False;
979 prefcontents
= fp
.read(prefsize
);
980 prenewfccs
= GetFileChecksum(prefcontents
, preheaderdata
[-3].lower(), False, formatspecs
);
981 prefccs
= preheaderdata
[-1];
982 pyhascontents
= True;
983 if(prefccs
!=prenewfccs
and not skipchecksum
):
984 VerbosePrintOut("File Content Checksum Error with file " + prefname
+ " at offset " + str(prefcontentstart
));
989 countnum
= seekstart
;
990 while(countnum
< seekend
):
991 HeaderOut
= ReadFileHeaderDataBySizeWithContentToList(fp
, listonly
, skipchecksum
, formatspecs
);
994 catlist
.append(HeaderOut
);
995 countnum
= countnum
+ 1;
996 realidnum
= realidnum
+ 1;
999 def ReadInFileBySizeWithContentToArray(infile
, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
):
1000 delimiter
= formatspecs
[5];
1001 if(hasattr(infile
, "read") or hasattr(infile
, "write")):
1004 fp
= UncompressArchiveFile(fp
, formatspecs
);
1005 checkcompressfile
= CheckCompressionSubType(fp
, formatspecs
, True);
1006 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[2]):
1013 if(hasattr(sys
.stdin
, "buffer")):
1014 shutil
.copyfileobj(sys
.stdin
.buffer, fp
);
1016 shutil
.copyfileobj(sys
.stdin
, fp
);
1018 fp
= UncompressArchiveFile(fp
, formatspecs
);
1022 elif(re
.findall(r
"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile
))):
1023 fp
= download_file_from_internet_file(infile
);
1024 fp
= UncompressArchiveFile(fp
, formatspecs
);
1030 infile
= RemoveWindowsPath(infile
);
1031 checkcompressfile
= CheckCompressionSubType(infile
, formatspecs
, True);
1032 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[2]):
1034 compresscheck
= CheckCompressionType(infile
, formatspecs
, True);
1035 if(not compresscheck
):
1036 fextname
= os
.path
.splitext(infile
)[1];
1037 if(fextname
==".gz"):
1038 compresscheck
= "gzip";
1039 elif(fextname
==".bz2"):
1040 compresscheck
= "bzip2";
1041 elif(fextname
==".zst"):
1042 compresscheck
= "zstd";
1043 elif(fextname
==".lz4" or fextname
==".clz4"):
1044 compresscheck
= "lz4";
1045 elif(fextname
==".lzo" or fextname
==".lzop"):
1046 compresscheck
= "lzo";
1047 elif(fextname
==".lzma" or fextname
==".xz"):
1048 compresscheck
= "lzma";
1051 if(not compresscheck
):
1053 fp
= UncompressFile(infile
, formatspecs
, "rb");
1054 return ReadFileDataBySizeWithContentToArray(fp
, listonly
, skipchecksum
, formatspecs
);
1056 def ReadInFileBySizeWithContentToList(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
):
1057 delimiter
= formatspecs
[5];
1058 if(hasattr(infile
, "read") or hasattr(infile
, "write")):
1061 fp
= UncompressArchiveFile(fp
, formatspecs
);
1062 checkcompressfile
= CheckCompressionSubType(fp
, formatspecs
, True);
1063 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[2]):
1070 if(hasattr(sys
.stdin
, "buffer")):
1071 shutil
.copyfileobj(sys
.stdin
.buffer, fp
);
1073 shutil
.copyfileobj(sys
.stdin
, fp
);
1075 fp
= UncompressArchiveFile(fp
, formatspecs
);
1079 elif(re
.findall(r
"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile
))):
1080 fp
= download_file_from_internet_file(infile
);
1081 fp
= UncompressArchiveFile(fp
, formatspecs
);
1087 infile
= RemoveWindowsPath(infile
);
1088 checkcompressfile
= CheckCompressionSubType(infile
, formatspecs
, True);
1089 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[2]):
1091 compresscheck
= CheckCompressionType(infile
, formatspecs
, True);
1092 if(not compresscheck
):
1093 fextname
= os
.path
.splitext(infile
)[1];
1094 if(fextname
==".gz"):
1095 compresscheck
= "gzip";
1096 elif(fextname
==".bz2"):
1097 compresscheck
= "bzip2";
1098 elif(fextname
==".zst"):
1099 compresscheck
= "zstd";
1100 elif(fextname
==".lz4" or fextname
==".clz4"):
1101 compresscheck
= "lz4";
1102 elif(fextname
==".lzo" or fextname
==".lzop"):
1103 compresscheck
= "lzo";
1104 elif(fextname
==".lzma" or fextname
==".xz"):
1105 compresscheck
= "lzma";
1108 if(not compresscheck
):
1110 fp
= UncompressFile(infile
, formatspecs
, "rb");
1111 return ReadFileDataBySizeWithContentToList(fp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
);
1113 def ReadInFileBySizeWithContentToArrayIndex(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
):
1114 if(isinstance(infile
, dict)):
1115 listcatfiles
= infile
;
1117 if(infile
!="-" and not hasattr(infile
, "read") and not hasattr(infile
, "write")):
1118 infile
= RemoveWindowsPath(infile
);
1119 listcatfiles
= ReadInFileBySizeWithContentToArray(infile
, listonly
, skipchecksum
, formatspecs
);
1120 if(not listcatfiles
):
1122 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': {}}}};
1123 lenlist
= len(listcatfiles
['ffilelist']);
1125 lcfx
= int(listcatfiles
['fnumfiles']);
1126 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
1127 lcfx
= int(lenlist
);
1129 lcfx
= int(listcatfiles
['fnumfiles']);
1131 filetoidarray
= {listcatfiles
['ffilelist'][lcfi
]['fname']: listcatfiles
['ffilelist'][lcfi
]['fid']};
1132 idtofilearray
= {listcatfiles
['ffilelist'][lcfi
]['fid']: listcatfiles
['ffilelist'][lcfi
]['fname']};
1133 catarray
['filetoid'].update(filetoidarray
);
1134 catarray
['idtofile'].update(idtofilearray
);
1135 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==0 or listcatfiles
['ffilelist'][lcfi
]['ftype']==7):
1136 catarray
['filetypes']['files']['filetoid'].update(filetoidarray
);
1137 catarray
['filetypes']['files']['idtofile'].update(idtofilearray
);
1138 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==1):
1139 catarray
['filetypes']['hardlinks']['filetoid'].update(filetoidarray
);
1140 catarray
['filetypes']['hardlinks']['idtofile'].update(idtofilearray
);
1141 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
1142 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
1143 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==2):
1144 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
1145 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
1146 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
1147 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
1148 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==3):
1149 catarray
['filetypes']['character']['filetoid'].update(filetoidarray
);
1150 catarray
['filetypes']['character']['idtofile'].update(idtofilearray
);
1151 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
1152 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
1153 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==4):
1154 catarray
['filetypes']['block']['filetoid'].update(filetoidarray
);
1155 catarray
['filetypes']['block']['idtofile'].update(idtofilearray
);
1156 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
1157 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
1158 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==5):
1159 catarray
['filetypes']['directories']['filetoid'].update(filetoidarray
);
1160 catarray
['filetypes']['directories']['idtofile'].update(idtofilearray
);
1161 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==6):
1162 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
1163 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
1164 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
1165 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
1169 def AppendNullByte(indata
, delimiter
=__file_format_delimiter__
):
1170 outdata
= str(indata
) + delimiter
;
1173 def AppendNullBytes(indata
=[], delimiter
=__file_format_delimiter__
):
1178 outdata
= outdata
+ AppendNullByte(indata
[inum
], delimiter
);
1182 def AppendFileHeader(fp
, numfiles
, checksumtype
="crc32", formatspecs
=__file_format_list__
):
1183 delimiter
= formatspecs
[5];
1184 catver
= formatspecs
[6];
1185 fileheaderver
= str(int(catver
.replace(".", "")));
1186 fileheader
= AppendNullByte(formatspecs
[1] + fileheaderver
, formatspecs
[5]);
1187 fp
.write(fileheader
.encode('UTF-8'));
1188 fnumfiles
= format(int(numfiles
), 'x').lower();
1189 fnumfilesa
= AppendNullBytes([fnumfiles
, checksumtype
], formatspecs
[5]);
1190 catfileheadercshex
= GetFileChecksum(fileheader
+ fnumfilesa
, checksumtype
, True, formatspecs
);
1191 fnumfilesa
= fnumfilesa
+ AppendNullByte(catfileheadercshex
, formatspecs
[5]);
1192 fp
.write(fnumfilesa
.encode('UTF-8'));
1195 os
.fsync(fp
.fileno());
1196 except io
.UnsupportedOperation
:
1198 except AttributeError:
1202 def AppendFileHeaderWithContent(fp
, filevalues
=[], extradata
=[], filecontent
="", checksumtype
="crc32", formatspecs
=__file_format_list__
):
1203 extrafields
= format(len(extradata
), 'x').lower();
1204 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[5]);
1205 if(len(extradata
)>0):
1206 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[5]);
1207 extrasizelen
= format(len(extrasizestr
), 'x').lower();
1208 catoutlen
= len(filevalues
) + len(extradata
) + 5;
1209 catoutlenhex
= format(catoutlen
, 'x').lower();
1210 catoutlist
= filevalues
;
1211 catoutlist
.insert(0, catoutlenhex
);
1212 catoutlist
.append(extrasizelen
);
1213 catoutlist
.append(extrafields
);
1214 catfileoutstr
= AppendNullBytes(catoutlist
, formatspecs
[5]);
1215 if(len(extradata
)>0):
1216 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[5]);
1217 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[5]);
1218 catfileheadercshex
= GetFileChecksum(catfileoutstr
, checksumtype
, True, formatspecs
);
1219 catfilecontentcshex
= GetFileChecksum(filecontent
, checksumtype
, False, formatspecs
);
1220 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
1221 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower();
1222 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[5]) + catfileoutstr
;
1223 catfileheadercshex
= GetFileChecksum(catfileoutstr
, checksumtype
, True, formatspecs
);
1224 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
1225 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
1226 nullstrecd
= formatspecs
[5].encode('UTF-8');
1227 catfileout
= catfileoutstrecd
+ filecontent
+ nullstrecd
;
1228 fp
.write(catfileout
);
1231 os
.fsync(fp
.fileno());
1232 except io
.UnsupportedOperation
:
1234 except AttributeError:
1238 def AppendFilesWithContent(infiles
, fp
, dirlistfromtxt
=False, filevalues
=[], extradata
=[], followlink
=False, checksumtype
="crc32", formatspecs
=__file_format_list__
, verbose
=False):
1239 advancedlist
= formatspecs
[8];
1240 altinode
= formatspecs
[9];
1242 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
1244 for line
in sys
.stdin
:
1245 infilelist
.append(line
.strip());
1246 infilelist
= list(filter(None, infilelist
));
1247 elif(infiles
!="-" and dirlistfromtxt
and os
.path
.exists(infiles
) and (os
.path
.isfile(infiles
) or infiles
=="/dev/null" or infiles
=="NUL")):
1248 if(not os
.path
.exists(infiles
) or not os
.path
.isfile(infiles
)):
1250 with
UncompressFile(infiles
, formatspecs
, "r") as finfile
:
1251 for line
in finfile
:
1252 infilelist
.append(line
.strip());
1253 infilelist
= list(filter(None, infilelist
));
1255 if(isinstance(infiles
, (list, tuple, ))):
1256 infilelist
= list(filter(None, infiles
));
1257 elif(isinstance(infiles
, (str, ))):
1258 infilelist
= list(filter(None, [infiles
]));
1260 GetDirList
= ListDirAdvanced(infilelist
, followlink
, False);
1262 GetDirList
= ListDir(infilelist
, followlink
, False);
1270 inodetocatinode
= {};
1271 numfiles
= int(len(GetDirList
));
1272 fnumfiles
= format(numfiles
, 'x').lower();
1273 AppendFileHeader(fp
, fnumfiles
, checksumtype
, formatspecs
);
1274 for curfname
in GetDirList
:
1275 catfhstart
= fp
.tell();
1276 if(re
.findall("^[.|/]", curfname
)):
1279 fname
= "./"+curfname
;
1281 VerbosePrintOut(fname
);
1282 if(not followlink
or followlink
is None):
1283 fstatinfo
= os
.lstat(fname
);
1285 fstatinfo
= os
.stat(fname
);
1286 fpremode
= fstatinfo
.st_mode
;
1287 finode
= fstatinfo
.st_ino
;
1288 flinkcount
= fstatinfo
.st_nlink
;
1290 if(stat
.S_ISREG(fpremode
)):
1292 elif(stat
.S_ISLNK(fpremode
)):
1294 elif(stat
.S_ISCHR(fpremode
)):
1296 elif(stat
.S_ISBLK(fpremode
)):
1298 elif(stat
.S_ISDIR(fpremode
)):
1300 elif(stat
.S_ISFIFO(fpremode
)):
1302 elif(stat
.S_ISSOCK(fpremode
)):
1304 elif(hasattr(stat
, "S_ISDOOR") and stat
.S_ISDOOR(fpremode
)):
1306 elif(hasattr(stat
, "S_ISPORT") and stat
.S_ISPORT(fpremode
)):
1308 elif(hasattr(stat
, "S_ISWHT") and stat
.S_ISWHT(fpremode
)):
1313 fcurfid
= format(int(curfid
), 'x').lower();
1314 if(not followlink
and finode
!=0):
1316 if(finode
in inodelist
):
1318 flinkname
= inodetofile
[finode
];
1320 fcurinode
= format(int(finode
), 'x').lower();
1322 fcurinode
= format(int(inodetocatinode
[finode
]), 'x').lower();
1323 if(finode
not in inodelist
):
1324 inodelist
.append(finode
);
1325 inodetofile
.update({finode
: fname
});
1326 inodetocatinode
.update({finode
: curinode
});
1328 fcurinode
= format(int(finode
), 'x').lower();
1330 fcurinode
= format(int(curinode
), 'x').lower();
1331 curinode
= curinode
+ 1;
1333 fcurinode
= format(int(curinode
), 'x').lower();
1334 curinode
= curinode
+ 1;
1335 curfid
= curfid
+ 1;
1337 flinkname
= os
.readlink(fname
);
1338 fdev
= fstatinfo
.st_dev
;
1339 getfdev
= GetDevMajorMinor(fdev
);
1340 fdev_minor
= getfdev
[0];
1341 fdev_major
= getfdev
[1];
1342 frdev
= fstatinfo
.st_dev
;
1343 if(hasattr(fstatinfo
, "st_rdev")):
1344 frdev
= fstatinfo
.st_rdev
;
1346 frdev
= fstatinfo
.st_dev
;
1347 getfrdev
= GetDevMajorMinor(frdev
);
1348 frdev_minor
= getfrdev
[0];
1349 frdev_major
= getfrdev
[1];
1350 if(ftype
==1 or ftype
==2 or ftype
==3 or ftype
==4 or ftype
==5 or ftype
==6):
1351 fsize
= format(int("0"), 'x').lower();
1352 elif(ftype
==0 or ftype
==7):
1353 fsize
= format(int(fstatinfo
.st_size
), 'x').lower();
1355 fsize
= format(int(fstatinfo
.st_size
)).lower();
1356 fatime
= format(int(fstatinfo
.st_atime
), 'x').lower();
1357 fmtime
= format(int(fstatinfo
.st_mtime
), 'x').lower();
1358 fctime
= format(int(fstatinfo
.st_ctime
), 'x').lower();
1359 if(hasattr(fstatinfo
, "st_birthtime")):
1360 fbtime
= format(int(fstatinfo
.st_birthtime
), 'x').lower();
1362 fbtime
= format(int(fstatinfo
.st_ctime
), 'x').lower();
1363 fmode
= format(int(fstatinfo
.st_mode
), 'x').lower();
1364 fchmode
= format(int(stat
.S_IMODE(fstatinfo
.st_mode
)), 'x').lower();
1365 ftypemod
= format(int(stat
.S_IFMT(fstatinfo
.st_mode
)), 'x').lower();
1366 fuid
= format(int(fstatinfo
.st_uid
), 'x').lower();
1367 fgid
= format(int(fstatinfo
.st_gid
), 'x').lower();
1372 userinfo
= pwd
.getpwuid(fstatinfo
.st_uid
);
1373 funame
= userinfo
.pw_name
;
1382 groupinfo
= grp
.getgrgid(fstatinfo
.st_gid
);
1383 fgname
= groupinfo
.gr_name
;
1388 fdev_minor
= format(int(fdev_minor
), 'x').lower();
1389 fdev_major
= format(int(fdev_major
), 'x').lower();
1390 frdev_minor
= format(int(frdev_minor
), 'x').lower();
1391 frdev_major
= format(int(frdev_major
), 'x').lower();
1392 finode
= format(int(finode
), 'x').lower();
1393 flinkcount
= format(int(flinkcount
), 'x').lower();
1394 if(hasattr(fstatinfo
, "st_file_attributes")):
1395 fwinattributes
= format(int(fstatinfo
.st_file_attributes
), 'x').lower();
1397 fwinattributes
= format(int(0), 'x').lower();
1398 fcontents
= "".encode('UTF-8');
1400 if(ftype
==0 or ftype
==7):
1401 with
open(fname
, "rb") as fpc
:
1403 chunk
= fpc
.read(chunk_size
);
1407 if(followlink
and (ftype
==1 or ftype
==2)):
1408 flstatinfo
= os
.stat(flinkname
);
1409 with
open(flinkname
, "rb") as fpc
:
1411 chunk
= fpc
.read(chunk_size
);
1415 ftypehex
= format(ftype
, 'x').lower();
1416 catoutlist
= [ftypehex
, fname
, flinkname
, fsize
, fatime
, fmtime
, fctime
, fbtime
, fmode
, fwinattributes
, fuid
, funame
, fgid
, fgname
, fcurfid
, fcurinode
, flinkcount
, fdev_minor
, fdev_major
, frdev_minor
, frdev_major
];
1417 fp
= AppendFileHeaderWithContent(fp
, catoutlist
, extradata
, fcontents
, checksumtype
, formatspecs
);
1419 catfp
.write(AppendNullBytes([0, 0], formatspecs
[5]).encode("UTF-8"));
1423 def AppendListsWithContent(inlist
, fp
, dirlistfromtxt
=False, filevalues
=[], extradata
=[], followlink
=False, checksumtype
="crc32", formatspecs
=__file_format_list__
, verbose
=False):
1425 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
1426 GetDirList
= inlist
;
1434 inodetocatinode
= {};
1435 numfiles
= int(len(GetDirList
));
1436 fnumfiles
= format(numfiles
, 'x').lower();
1437 AppendFileHeader(fp
, fnumfiles
, checksumtype
, formatspecs
);
1438 for curfname
in GetDirList
:
1439 ftype
= format(curfname
[0], 'x').lower();
1440 if(re
.findall("^[.|/]", curfname
[1])):
1441 fname
= curfname
[1];
1443 fname
= "./"+curfname
[1];
1444 fbasedir
= os
.path
.dirname(fname
);
1445 flinkname
= curfname
[2];
1446 fsize
= format(curfname
[3], 'x').lower();
1447 fatime
= format(curfname
[4], 'x').lower();
1448 fmtime
= format(curfname
[5], 'x').lower();
1449 fctime
= format(curfname
[6], 'x').lower();
1450 fbtime
= format(curfname
[7], 'x').lower();
1451 fmode
= format(curfname
[8], 'x').lower();
1452 fwinattributes
= format(curfname
[9], 'x').lower();
1453 fuid
= format(curfname
[10], 'x').lower();
1454 funame
= curfname
[11];
1455 fgid
= format(curfname
[12], 'x').lower();
1456 fgname
= curfname
[13];
1457 fid
= format(curfname
[14], 'x').lower();
1458 finode
= format(curfname
[15], 'x').lower();
1459 flinkcount
= format(curfname
[16], 'x').lower();
1460 fdev_minor
= format(curfname
[17], 'x').lower();
1461 fdev_major
= format(curfname
[18], 'x').lower();
1462 frdev_minor
= format(curfname
[19], 'x').lower();
1463 frdev_major
= format(curfname
[20], 'x').lower();
1464 extradata
= curfname
[21];
1465 fchecksumtype
= curfname
[22];
1466 fcontents
= curfname
[23];
1467 catoutlist
= [ftype
, fname
, flinkname
, fsize
, fatime
, fmtime
, fctime
, fbtime
, fmode
, fwinattributes
, fuid
, funame
, fgid
, fgname
, fid
, finode
, flinkcount
, fdev_minor
, fdev_major
, frdev_minor
, frdev_major
];
1468 fp
= AppendFileHeaderWithContent(fp
, catoutlist
, extradata
, fcontents
, checksumtype
, formatspecs
);
1470 catfp
.write(AppendNullBytes([0, 0], formatspecs
[5]).encode("UTF-8"));
1474 def AppendInFileWithContent(infile
, fp
, dirlistfromtxt
=False, filevalues
=[], extradata
=[], followlink
=False, checksumtype
="crc32", formatspecs
=__file_format_list__
, verbose
=False):
1475 inlist
= ReadInFileBySizeWithContentToList(infile
, 0, 0, False, False, formatspecs
);
1476 return AppendListsWithContent(inlist
, fp
, dirlistfromtxt
, filevalues
, extradata
, followlink
, checksumtype
, formatspecs
, verbose
);
1478 def AppendFilesWithContentToOutFile(infiles
, outfile
, dirlistfromtxt
=False, compression
="auto", compressionlevel
=None, filevalues
=[], extradata
=[], followlink
=False, checksumtype
="crc32", formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
1479 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
1480 if(os
.path
.exists(outfile
)):
1484 catfpfp
= BytesIO();
1485 elif(hasattr(outfile
, "read") or hasattr(outfile
, "write")):
1487 elif(re
.findall(r
"^(ftp|ftps|sftp)\:\/\/", str(outfile
))):
1490 fbasename
= os
.path
.splitext(outfile
)[0];
1491 fextname
= os
.path
.splitext(outfile
)[1];
1492 catfp
= CompressOpenFile(outfile
, compressionlevel
);
1493 catfp
= AppendFilesWithContent(infiles
, catfp
, dirlistfromtxt
, filevalues
, extradata
, followlink
, checksumtype
, formatspecs
, verbose
);
1494 if(outfile
=="-" or hasattr(outfile
, "read") or hasattr(outfile
, "write")):
1495 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
1498 os
.fsync(catfp
.fileno());
1499 except io
.UnsupportedOperation
:
1501 except AttributeError:
1505 if(hasattr(sys
.stdout
, "buffer")):
1506 shutil
.copyfileobj(catfp
, sys
.stdout
.buffer);
1508 shutil
.copyfileobj(catfp
, sys
.stdout
);
1509 elif(re
.findall(r
"^(ftp|ftps|sftp)\:\/\/", str(outfile
))):
1510 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
1512 upload_file_to_internet_file(catfp
, outfile
);
1520 def AppendListsWithContentToOutFile(inlist
, outfile
, dirlistfromtxt
=False, compression
="auto", compressionlevel
=None, filevalues
=[], extradata
=[], followlink
=False, checksumtype
="crc32", formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
1521 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
1522 if(os
.path
.exists(outfile
)):
1526 catfpfp
= BytesIO();
1527 elif(hasattr(outfile
, "read") or hasattr(outfile
, "write")):
1529 elif(re
.findall(r
"^(ftp|ftps|sftp)\:\/\/", str(outfile
))):
1532 fbasename
= os
.path
.splitext(outfile
)[0];
1533 fextname
= os
.path
.splitext(outfile
)[1];
1534 catfp
= CompressOpenFile(outfile
, compressionlevel
);
1535 catfp
= AppendListsWithContent(inlist
, catfp
, dirlistfromtxt
, filevalues
, extradata
, followlink
, checksumtype
, formatspecs
, verbose
);
1536 if(outfile
=="-" or hasattr(outfile
, "read") or hasattr(outfile
, "write")):
1537 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
1540 os
.fsync(catfp
.fileno());
1541 except io
.UnsupportedOperation
:
1543 except AttributeError:
1547 if(hasattr(sys
.stdout
, "buffer")):
1548 shutil
.copyfileobj(catfp
, sys
.stdout
.buffer);
1550 shutil
.copyfileobj(catfp
, sys
.stdout
);
1551 elif(re
.findall(r
"^(ftp|ftps|sftp)\:\/\/", str(outfile
))):
1552 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
1554 upload_file_to_internet_file(catfp
, outfile
);
1562 def AppendInFileWithContentToOutFile(infile
, outfile
, dirlistfromtxt
=False, compression
="auto", compressionlevel
=None, filevalues
=[], extradata
=[], followlink
=False, checksumtype
="crc32", formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
1563 inlist
= ReadInFileBySizeWithContentToList(infile
, 0, 0, False, False, formatspecs
);
1564 return AppendListsWithContentToOutFile(inlist
, outfile
, dirlistfromtxt
, compression
, compressionlevel
, filevalues
, extradata
, followlink
, checksumtype
, formatspecs
, verbose
, returnfp
);
1566 def PrintPermissionString(fchmode
, ftype
):
1567 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' } };
1569 for fmodval
in str(oct(fchmode
))[-3:]:
1570 permissionstr
= permissionstr
+ permissions
['access'].get(fmodval
, '---');
1571 if(ftype
==0 or ftype
==7):
1572 permissionstr
= "-" + permissionstr
;
1574 permissionstr
= "h" + permissionstr
;
1576 permissionstr
= "l" + permissionstr
;
1578 permissionstr
= "c" + permissionstr
;
1580 permissionstr
= "b" + permissionstr
;
1582 permissionstr
= "d" + permissionstr
;
1584 permissionstr
= "f" + permissionstr
;
1586 permissionstr
= "D" + permissionstr
;
1588 permissionstr
= "p" + permissionstr
;
1590 permissionstr
= "w" + permissionstr
;
1592 permissionoutstr
= stat
.filemode(fchmode
);
1593 except AttributeError:
1594 permissionoutstr
= permissionstr
;
1596 permissionoutstr
= permissionstr
;
1597 return permissionoutstr
;
1599 def PrintPermissionStringAlt(fchmode
, ftype
):
1601 '0': '---', '1': '--x', '2': '-w-', '3': '-wx',
1602 '4': 'r--', '5': 'r-x', '6': 'rw-', '7': 'rwx'
1604 # Translate file mode into permission string
1605 permissionstr
= ''.join([permissions
[i
] for i
in str(oct(fchmode
))[-3:]]);
1606 # Append file type indicator
1608 0: '-', 1: 'h', 2: 'l', 3: 'c', 4: 'b',
1609 5: 'd', 6: 'f', 8: 'D', 9: 'p', 10: 'w'
1611 file_type
= type_indicators
.get(ftype
, '-');
1612 permissionstr
= file_type
+ permissionstr
;
1614 permissionoutstr
= stat
.filemode(fchmode
);
1615 except AttributeError:
1616 permissionoutstr
= permissionstr
;
1617 return permissionoutstr
;
1619 def CompressionSupport():
1620 compression_list
= [];
1623 compression_list
.append("gz");
1624 compression_list
.append("gzip");
1629 compression_list
.append("bz2");
1630 compression_list
.append("bzip2");
1635 compression_list
.append("lz4");
1640 compression_list
.append("lzo");
1641 compression_list
.append("lzop");
1646 compression_list
.append("zstd");
1647 compression_list
.append("zstandard");
1652 compression_list
.append("lzma");
1653 compression_list
.append("xz");
1656 return compression_list
;
1658 def CheckCompressionType(infile
, formatspecs
=__file_format_list__
, closefp
=True):
1659 if(hasattr(infile
, "read") or hasattr(infile
, "write")):
1663 catfp
= open(infile
, "rb");
1664 except FileNotFoundError
:
1667 prefp
= catfp
.read(2);
1669 if(prefp
==binascii
.unhexlify("1f8b")):
1672 prefp
= catfp
.read(3);
1673 if(prefp
==binascii
.unhexlify("425a68")):
1675 if(prefp
==binascii
.unhexlify("5d0000")):
1678 prefp
= catfp
.read(4);
1679 if(prefp
==binascii
.unhexlify("28b52ffd")):
1681 if(prefp
==binascii
.unhexlify("04224d18")):
1683 if(prefp
==binascii
.unhexlify("504B0304")):
1684 filetype
= "zipfile";
1686 prefp
= catfp
.read(5);
1687 if(prefp
==binascii
.unhexlify("7573746172")):
1688 filetype
= "tarfile";
1690 prefp
= catfp
.read(6);
1691 if(prefp
==binascii
.unhexlify("fd377a585a00")):
1693 if(prefp
==binascii
.unhexlify("377abcaf271c")):
1694 filetype
= "7zipfile";
1696 prefp
= catfp
.read(7);
1697 if(prefp
==binascii
.unhexlify("526172211a0700")):
1698 filetype
= "rarfile";
1699 if(prefp
==binascii
.unhexlify("43617446696c65")):
1700 filetype
= "catfile";
1702 prefp
= catfp
.read(8);
1703 if(prefp
==binascii
.unhexlify("526172211a070100")):
1704 filetype
= "rarfile";
1706 prefp
= catfp
.read(formatspecs
[3]);
1707 if(prefp
==binascii
.unhexlify(formatspecs
[4])):
1708 filetype
= formatspecs
[2];
1710 prefp
= catfp
.read(9);
1711 if(prefp
==binascii
.unhexlify("894c5a4f000d0a1a0a")):
1714 prefp
= catfp
.read(10);
1715 if(prefp
==binascii
.unhexlify("7061785f676c6f62616c")):
1716 filetype
= "tarfile";
1722 def CheckCompressionTypeFromString(instring
, formatspecs
=__file_format_list__
, closefp
=True):
1724 instringsfile
= BytesIO(instring
);
1726 instringsfile
= BytesIO(instring
.encode("UTF-8"));
1727 return CheckCompressionType(instringsfile
, formatspecs
, closefp
);
1729 def GetCompressionMimeType(infile
, formatspecs
=__file_format_list__
):
1730 compresscheck
= CheckCompressionType(fp
, formatspecs
, False);
1731 if(compresscheck
=="gzip" or compresscheck
=="gz"):
1732 return archivefile_gzip_mimetype
;
1733 if(compresscheck
=="bzip2" or compresscheck
=="bz2"):
1734 return archivefile_bzip2_mimetype
;
1735 if(compresscheck
=="zstd" or compresscheck
=="zstandard"):
1736 return archivefile_zstandard_mimetype
;
1737 if(compresscheck
=="lz4"):
1738 return archivefile_lz4_mimetype
;
1739 if(compresscheck
=="lzo" or compresscheck
=="lzop"):
1740 return archivefile_lzop_mimetype
;
1741 if(compresscheck
=="lzma"):
1742 return archivefile_lzma_mimetype
;
1743 if(compresscheck
=="xz"):
1744 return archivefile_xz_mimetype
;
1745 if(compresscheck
=="catfile" or compresscheck
=="cat" or compresscheck
==formatspecs
[2]):
1746 return archivefile_cat_mimetype
;
1747 if(not compresscheck
):
1751 def UncompressArchiveFile(fp
, formatspecs
=__file_format_list__
):
1752 if(not hasattr(fp
, "read") and not hasattr(fp
, "write")):
1754 compresscheck
= CheckCompressionType(fp
, formatspecs
, False);
1755 if(compresscheck
=="gzip"):
1760 catfp
= gzip
.GzipFile(fileobj
=fp
, mode
="rb");
1761 if(compresscheck
=="bzip2"):
1767 catfp
.write(bz2
.decompress(fp
.read()));
1768 if(compresscheck
=="zstd"):
1774 catfp
.write(zstandard
.decompress(fp
.read()));
1775 if(compresscheck
=="lz4"):
1781 catfp
.write(lz4
.frame
.decompress(fp
.read()));
1782 if(compresscheck
=="lzo" or compresscheck
=="lzop"):
1788 catfp
.write(lzo
.decompress(fp
.read()));
1789 if(compresscheck
=="lzma" or compresscheck
=="xz"):
1795 catfp
.write(lzma
.decompress(fp
.read()));
1796 if(compresscheck
=="catfile" or compresscheck
==formatspecs
[2]):
1798 if(not compresscheck
):
1804 with fp
as fpcontent
:
1806 catfp
.write(lzma
.decompress(fp
.read()));
1807 except lzma
.LZMAError
:
1811 create_alias_function("Uncompress", __file_format_name__
, "", UncompressArchiveFile
);
1813 def UncompressFile(infile
, formatspecs
=__file_format_list__
, mode
="rb"):
1814 compresscheck
= CheckCompressionType(infile
, formatspecs
, False);
1815 if(sys
.version_info
[0]==2 and compresscheck
):
1821 if(compresscheck
=="gzip"):
1827 filefp
= gzip
.open(infile
, mode
, encoding
="UTF-8");
1828 except (ValueError, TypeError) as e
:
1829 filefp
= gzip
.open(infile
, mode
);
1830 if(compresscheck
=="bzip2"):
1836 filefp
= bz2
.open(infile
, mode
, encoding
="UTF-8");
1837 except (ValueError, TypeError) as e
:
1838 filefp
= bz2
.open(infile
, mode
);
1839 if(compresscheck
=="zstd"):
1845 filefp
= zstandard
.open(infile
, mode
, encoding
="UTF-8");
1846 except (ValueError, TypeError) as e
:
1847 filefp
= zstandard
.open(infile
, mode
);
1848 if(compresscheck
=="lz4"):
1854 filefp
= lz4
.frame
.open(infile
, mode
, encoding
="UTF-8");
1855 except (ValueError, TypeError) as e
:
1856 filefp
= lz4
.frame
.open(infile
, mode
);
1857 if(compresscheck
=="lzo"):
1863 filefp
= lzo
.open(infile
, mode
, encoding
="UTF-8");
1864 except (ValueError, TypeError) as e
:
1865 filefp
= lzo
.open(infile
, mode
);
1866 if(compresscheck
=="lzma"):
1872 filefp
= lzma
.open(infile
, mode
, encoding
="UTF-8");
1873 except (ValueError, TypeError) as e
:
1874 filefp
= lzma
.open(infile
, mode
);
1875 if(compresscheck
=="catfile" or compresscheck
==formatspecs
[2]):
1877 filefp
= open(infile
, mode
, encoding
="UTF-8");
1878 except (ValueError, TypeError) as e
:
1879 filefp
= open(infile
, mode
);
1880 if(not compresscheck
):
1882 filefp
= open(infile
, mode
, encoding
="UTF-8");
1883 except (ValueError, TypeError) as e
:
1884 filefp
= open(infile
, mode
);
1885 except FileNotFoundError
:
1889 def UncompressString(infile
):
1890 compresscheck
= CheckCompressionTypeFromString(infile
, formatspecs
, False);
1891 if(compresscheck
=="gzip"):
1896 fileuz
= gzip
.decompress(infile
);
1897 if(compresscheck
=="bzip2"):
1902 fileuz
= bz2
.decompress(infile
);
1903 if(compresscheck
=="zstd"):
1908 fileuz
= zstandard
.decompress(infile
);
1909 if(compresscheck
=="lz4"):
1914 fileuz
= lz4
.frame
.decompress(infile
);
1915 if(compresscheck
=="lzo"):
1920 fileuz
= lzo
.decompress(infile
);
1921 if(compresscheck
=="lzma"):
1926 fileuz
= lzma
.decompress(infile
);
1927 if(not compresscheck
):
1929 if(hasattr(fileuz
, 'decode')):
1930 fileuz
= fileuz
.decode("UTF-8");
1933 def UncompressStringAlt(infile
):
1934 filefp
= StringIO();
1935 outstring
= UncompressString(infile
);
1936 filefp
.write(outstring
);
1940 def CheckCompressionSubType(infile
, formatspecs
=__file_format_list__
, closefp
=True):
1941 compresscheck
= CheckCompressionType(infile
, formatspecs
, False);
1942 if(not compresscheck
):
1943 fextname
= os
.path
.splitext(infile
)[1];
1944 if(fextname
==".gz"):
1945 compresscheck
= "gzip";
1946 elif(fextname
==".bz2"):
1947 compresscheck
= "bzip2";
1948 elif(fextname
==".zst"):
1949 compresscheck
= "zstd";
1950 elif(fextname
==".lz4"):
1951 compresscheck
= "lz4";
1952 elif(fextname
==".lzo" or fextname
==".lzop"):
1953 compresscheck
= "lzo";
1954 elif(fextname
==".lzma" or fextname
==".xz"):
1955 compresscheck
= "lzma";
1958 if(not compresscheck
):
1960 if(compresscheck
=="catfile"):
1962 if(compresscheck
==formatspecs
[2]):
1963 return formatspecs
[2];
1964 if(compresscheck
=="tarfile"):
1966 if(compresscheck
=="zipfile"):
1968 if(rarfile_support
and compresscheck
=="rarfile"):
1970 if(py7zr_support
and compresscheck
=="7zipfile"):
1972 if(hasattr(infile
, "read") or hasattr(infile
, "write")):
1973 catfp
= UncompressArchiveFile(infile
, formatspecs
[2]);
1976 if(compresscheck
=="gzip"):
1981 catfp
= gzip
.GzipFile(infile
, "rb");
1982 if(compresscheck
=="bzip2"):
1987 catfp
= bz2
.BZ2File(infile
, "rb");
1988 if(compresscheck
=="lz4"):
1993 catfp
= lz4
.frame
.open(infile
, "rb");
1994 if(compresscheck
=="zstd"):
1999 catfp
= zstandard
.open(infile
, "rb");
2000 if(compresscheck
=="lzma" or compresscheck
=="xz"):
2005 catfp
= lzma
.open(infile
, "rb");
2006 except FileNotFoundError
:
2009 prefp
= catfp
.read(5);
2010 if(prefp
==binascii
.unhexlify("7573746172")):
2011 filetype
= "tarfile";
2013 prefp
= catfp
.read(7);
2014 if(prefp
==binascii
.unhexlify("43617446696c65")):
2015 filetype
= "catfile";
2017 prefp
= catfp
.read(formatspecs
[3]);
2018 if(prefp
==binascii
.unhexlify(formatspecs
[4])):
2019 filetype
= formatspecs
[2];
2021 prefp
= catfp
.read(10);
2022 if(prefp
==binascii
.unhexlify("7061785f676c6f62616c")):
2023 filetype
= "tarfile";
2029 def GZipCompress(data
, compresslevel
=9):
2034 tmpfp
= tempfile
.NamedTemporaryFile("wb", delete
=False);
2036 tmpfp
= gzip
.GzipFile(tmpfp
.name
, mode
="wb", compresslevel
=compresslevel
);
2040 catfp
= open(tmpfp
.name
, "rb");
2041 except FileNotFoundError
:
2043 catdata
= catfp
.read();
2047 def CompressArchiveFile(fp
, compression
="auto", compressionlevel
=None, formatspecs
=__file_format_list__
):
2048 if(not hasattr(fp
, "read") and not hasattr(fp
, "write")):
2051 if(not compression
or compression
or compression
=="catfile" or compression
==formatspecs
[2]):
2053 if(compression
not in compressionlist
and compression
is None):
2054 compression
= "auto";
2055 if(compression
=="gzip"):
2061 if(compressionlevel
is None):
2062 compressionlevel
= 9;
2064 compressionlevel
= int(compressionlevel
);
2065 catfp
.write(gzip
.compress(fp
.read(), compresslevel
=compressionlevel
));
2066 if(compression
=="bzip2"):
2072 if(compressionlevel
is None):
2073 compressionlevel
= 9;
2075 compressionlevel
= int(compressionlevel
);
2076 catfp
.write(bz2
.compress(fp
.read(), compresslevel
=compressionlevel
));
2077 if(compression
=="lz4"):
2083 if(compressionlevel
is None):
2084 compressionlevel
= 9;
2086 compressionlevel
= int(compressionlevel
);
2087 catfp
.write(lz4
.frame
.compress(fp
.read(), compression_level
=compressionlevel
));
2088 if(compression
=="lzo" or compression
=="lzop"):
2094 if(compressionlevel
is None):
2095 compressionlevel
= 9;
2097 compressionlevel
= int(compressionlevel
);
2098 catfp
.write(lzo
.compress(fp
.read(), compresslevel
=compressionlevel
));
2099 if(compression
=="zstd"):
2105 if(compressionlevel
is None):
2106 compressionlevel
= 10;
2108 compressionlevel
= int(compressionlevel
);
2109 catfp
.write(zstandard
.compress(fp
.read(), level
=compressionlevel
));
2110 if(compression
=="lzma"):
2116 if(compressionlevel
is None):
2117 compressionlevel
= 9;
2119 compressionlevel
= int(compressionlevel
);
2120 catfp
.write(lzma
.compress(fp
.read(), format
=lzma
.FORMAT_ALONE
, filters
=[{"id": lzma
.FILTER_LZMA1
, "preset": compressionlevel
}]));
2121 if(compression
=="xz"):
2127 if(compressionlevel
is None):
2128 compressionlevel
= 9;
2130 compressionlevel
= int(compressionlevel
);
2131 catfp
.write(lzma
.compress(fp
.read(), format
=lzma
.FORMAT_XZ
, filters
=[{"id": lzma
.FILTER_LZMA2
, "preset": compressionlevel
}]));
2132 if(compression
=="auto" or compression
is None):
2137 create_alias_function("Compress", __file_format_name__
, "", CompressArchiveFile
);
2139 def CompressOpenFile(outfile
, compressionlevel
=None):
2140 if(outfile
is None):
2142 fbasename
= os
.path
.splitext(outfile
)[0];
2143 fextname
= os
.path
.splitext(outfile
)[1];
2144 if(compressionlevel
is None and fextname
!=".zst"):
2145 compressionlevel
= 9;
2146 elif(compressionlevel
is None and fextname
==".zst"):
2147 compressionlevel
= 10;
2149 compressionlevel
= int(compressionlevel
);
2150 if(sys
.version_info
[0]==2):
2155 if(fextname
not in outextlistwd
):
2157 outfp
= open(outfile
, "wb", encoding
="UTF-8");
2158 except (ValueError, TypeError) as e
:
2159 outfp
= open(outfile
, "wb");
2160 elif(fextname
==".gz"):
2166 outfp
= gzip
.open(outfile
, mode
, compressionlevel
, encoding
="UTF-8");
2167 except (ValueError, TypeError) as e
:
2168 outfp
= gzip
.open(outfile
, mode
, compressionlevel
);
2169 elif(fextname
==".bz2"):
2175 outfp
= bz2
.open(outfile
, mode
, compressionlevel
, encoding
="UTF-8");
2176 except (ValueError, TypeError) as e
:
2177 outfp
= bz2
.open(outfile
, mode
, compressionlevel
);
2178 elif(fextname
==".zst"):
2184 outfp
= zstandard
.open(outfile
, mode
, zstandard
.ZstdCompressor(level
=compressionlevel
), encoding
="UTF-8");
2185 except (ValueError, TypeError) as e
:
2186 outfp
= zstandard
.open(outfile
, mode
, zstandard
.ZstdCompressor(level
=compressionlevel
));
2187 elif(fextname
==".xz"):
2193 outfp
= lzma
.open(outfile
, mode
, format
=lzma
.FORMAT_XZ
, filters
=[{"id": lzma
.FILTER_LZMA2
, "preset": compressionlevel
}], encoding
="UTF-8");
2194 except (ValueError, TypeError) as e
:
2195 outfp
= lzma
.open(outfile
, mode
, format
=lzma
.FORMAT_XZ
, filters
=[{"id": lzma
.FILTER_LZMA2
, "preset": compressionlevel
}]);
2196 elif(fextname
==".lz4"):
2202 outfp
= lz4
.frame
.open(outfile
, mode
, compression_level
=compressionlevel
, encoding
="UTF-8");
2203 except (ValueError, TypeError) as e
:
2204 outfp
= lz4
.frame
.open(outfile
, mode
, compression_level
=compressionlevel
);
2205 elif(fextname
==".lzo"):
2211 outfp
= lzo
.open(outfile
, mode
, compresslevel
=compressionlevel
, encoding
="UTF-8");
2212 except (ValueError, TypeError) as e
:
2213 outfp
= lzo
.open(outfile
, mode
, compresslevel
=compressionlevel
);
2214 elif(fextname
==".lzma"):
2220 outfp
= lzma
.open(outfile
, mode
, format
=lzma
.FORMAT_ALONE
, filters
=[{"id": lzma
.FILTER_LZMA1
, "preset": compressionlevel
}], encoding
="UTF-8");
2221 except (ValueError, TypeError) as e
:
2222 outfp
= lzma
.open(outfile
, mode
, format
=lzma
.FORMAT_ALONE
, filters
=[{"id": lzma
.FILTER_LZMA1
, "preset": compressionlevel
}]);
2223 except FileNotFoundError
:
2227 def GetDevMajorMinor(fdev
):
2229 if(hasattr(os
, "minor")):
2230 retdev
.append(os
.minor(fdev
));
2233 if(hasattr(os
, "major")):
2234 retdev
.append(os
.major(fdev
));
2239 def CheckSumSupport(checkfor
, guaranteed
=True):
2241 hash_list
= sorted(list(hashlib
.algorithms_guaranteed
));
2243 hash_list
= sorted(list(hashlib
.algorithms_available
));
2244 checklistout
= sorted(hash_list
+ ['adler32', 'crc16', 'crc16_ansi', 'crc16_ibm', 'crc16_ccitt', 'crc32', 'crc64', 'crc64_ecma', 'crc64_iso', 'none']);
2245 if(checkfor
in checklistout
):
2250 def CheckSumSupportAlt(checkfor
, guaranteed
=True):
2252 hash_list
= sorted(list(hashlib
.algorithms_guaranteed
));
2254 hash_list
= sorted(list(hashlib
.algorithms_available
));
2255 checklistout
= hash_list
;
2256 if(checkfor
in checklistout
):
2261 def PackArchiveFile(infiles
, outfile
, dirlistfromtxt
=False, compression
="auto", compressionlevel
=None, followlink
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
2262 advancedlist
= formatspecs
[8];
2263 altinode
= formatspecs
[9];
2264 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
2265 outfile
= RemoveWindowsPath(outfile
);
2266 checksumtype
= checksumtype
.lower();
2267 if(not CheckSumSupport(checksumtype
, hashlib_guaranteed
)):
2268 checksumtype
="crc32";
2269 if(checksumtype
=="none"):
2271 if(not compression
or compression
or compression
=="catfile" or compression
==formatspecs
[2]):
2273 if(compression
not in compressionlist
and compression
is None):
2274 compression
= "auto";
2276 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
2277 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
2278 if(os
.path
.exists(outfile
)):
2283 elif(hasattr(outfile
, "read") or hasattr(outfile
, "write")):
2285 elif(re
.findall(r
"^(ftp|ftps|sftp)\:\/\/", str(outfile
))):
2288 fbasename
= os
.path
.splitext(outfile
)[0];
2289 fextname
= os
.path
.splitext(outfile
)[1];
2290 catfp
= CompressOpenFile(outfile
, compressionlevel
);
2291 catver
= formatspecs
[6];
2292 fileheaderver
= str(int(catver
.replace(".", "")));
2293 fileheader
= AppendNullByte(formatspecs
[1] + fileheaderver
, formatspecs
[5]);
2294 catfp
.write(fileheader
.encode('UTF-8'));
2297 for line
in sys
.stdin
:
2298 infilelist
.append(line
.strip());
2299 infilelist
= list(filter(None, infilelist
));
2300 elif(infiles
!="-" and dirlistfromtxt
and os
.path
.exists(infiles
) and (os
.path
.isfile(infiles
) or infiles
=="/dev/null" or infiles
=="NUL")):
2301 if(not os
.path
.exists(infiles
) or not os
.path
.isfile(infiles
)):
2303 with
UncompressFile(infiles
, formatspecs
, "r") as finfile
:
2304 for line
in finfile
:
2305 infilelist
.append(line
.strip());
2306 infilelist
= list(filter(None, infilelist
));
2308 if(isinstance(infiles
, (list, tuple, ))):
2309 infilelist
= list(filter(None, infiles
));
2310 elif(isinstance(infiles
, (str, ))):
2311 infilelist
= list(filter(None, [infiles
]));
2313 GetDirList
= ListDirAdvanced(infilelist
, followlink
, False);
2315 GetDirList
= ListDir(infilelist
, followlink
, False);
2323 inodetocatinode
= {};
2324 numfiles
= int(len(GetDirList
));
2325 fnumfiles
= format(int(len(GetDirList
)), 'x').lower();
2326 fnumfilesa
= AppendNullBytes([fnumfiles
, checksumtype
], formatspecs
[5]);
2327 if(checksumtype
=="none" or checksumtype
==""):
2328 catfileheadercshex
= format(0, 'x').lower();
2329 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
2330 catfileheadercshex
= format(crc16(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
2331 elif(checksumtype
=="crc16_ccitt"):
2332 catfileheadercshex
= format(crc16_ccitt(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
2333 elif(checksumtype
=="adler32"):
2334 catfileheadercshex
= format(zlib
.adler32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
2335 elif(checksumtype
=="crc32"):
2336 catfileheadercshex
= format(crc32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
2337 elif(checksumtype
=="crc64_ecma"):
2338 catfileheadercshex
= format(crc64_ecma(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2339 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
2340 catfileheadercshex
= format(crc64_iso(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2341 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
2342 checksumoutstr
= hashlib
.new(checksumtype
);
2343 checksumoutstr
.update(str(fileheader
+ fnumfilesa
).encode('UTF-8'));
2344 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
2346 catfileheadercshex
= format(0, 'x').lower
2347 fnumfilesa
= fnumfilesa
+ AppendNullByte(catfileheadercshex
, formatspecs
[5]);
2348 catfp
.write(fnumfilesa
.encode('UTF-8'));
2351 os
.fsync(catfp
.fileno());
2352 except io
.UnsupportedOperation
:
2354 except AttributeError:
2356 for curfname
in GetDirList
:
2357 catfhstart
= catfp
.tell();
2358 if(re
.findall("^[.|/]", curfname
)):
2361 fname
= "./"+curfname
;
2363 VerbosePrintOut(fname
);
2364 if(not followlink
or followlink
is None):
2365 fstatinfo
= os
.lstat(fname
);
2367 fstatinfo
= os
.stat(fname
);
2368 fpremode
= fstatinfo
.st_mode
;
2369 finode
= fstatinfo
.st_ino
;
2370 flinkcount
= fstatinfo
.st_nlink
;
2372 if(stat
.S_ISREG(fpremode
)):
2374 elif(stat
.S_ISLNK(fpremode
)):
2376 elif(stat
.S_ISCHR(fpremode
)):
2378 elif(stat
.S_ISBLK(fpremode
)):
2380 elif(stat
.S_ISDIR(fpremode
)):
2382 elif(stat
.S_ISFIFO(fpremode
)):
2384 elif(stat
.S_ISSOCK(fpremode
)):
2386 elif(hasattr(stat
, "S_ISDOOR") and stat
.S_ISDOOR(fpremode
)):
2388 elif(hasattr(stat
, "S_ISPORT") and stat
.S_ISPORT(fpremode
)):
2390 elif(hasattr(stat
, "S_ISWHT") and stat
.S_ISWHT(fpremode
)):
2395 fcurfid
= format(int(curfid
), 'x').lower();
2396 if(not followlink
and finode
!=0):
2398 if(finode
in inodelist
):
2400 flinkname
= inodetofile
[finode
];
2402 fcurinode
= format(int(finode
), 'x').lower();
2404 fcurinode
= format(int(inodetocatinode
[finode
]), 'x').lower();
2405 if(finode
not in inodelist
):
2406 inodelist
.append(finode
);
2407 inodetofile
.update({finode
: fname
});
2408 inodetocatinode
.update({finode
: curinode
});
2410 fcurinode
= format(int(finode
), 'x').lower();
2412 fcurinode
= format(int(curinode
), 'x').lower();
2413 curinode
= curinode
+ 1;
2415 fcurinode
= format(int(curinode
), 'x').lower();
2416 curinode
= curinode
+ 1;
2417 curfid
= curfid
+ 1;
2419 flinkname
= os
.readlink(fname
);
2420 fdev
= fstatinfo
.st_dev
;
2421 getfdev
= GetDevMajorMinor(fdev
);
2422 fdev_minor
= getfdev
[0];
2423 fdev_major
= getfdev
[1];
2424 frdev
= fstatinfo
.st_dev
;
2425 if(hasattr(fstatinfo
, "st_rdev")):
2426 frdev
= fstatinfo
.st_rdev
;
2428 frdev
= fstatinfo
.st_dev
;
2429 getfrdev
= GetDevMajorMinor(frdev
);
2430 frdev_minor
= getfrdev
[0];
2431 frdev_major
= getfrdev
[1];
2432 if(ftype
==1 or ftype
==2 or ftype
==3 or ftype
==4 or ftype
==5 or ftype
==6):
2433 fsize
= format(int("0"), 'x').lower();
2434 elif(ftype
==0 or ftype
==7):
2435 fsize
= format(int(fstatinfo
.st_size
), 'x').lower();
2437 fsize
= format(int(fstatinfo
.st_size
)).lower();
2438 fatime
= format(int(fstatinfo
.st_atime
), 'x').lower();
2439 fmtime
= format(int(fstatinfo
.st_mtime
), 'x').lower();
2440 fctime
= format(int(fstatinfo
.st_ctime
), 'x').lower();
2441 if(hasattr(fstatinfo
, "st_birthtime")):
2442 fbtime
= format(int(fstatinfo
.st_birthtime
), 'x').lower();
2444 fbtime
= format(int(fstatinfo
.st_ctime
), 'x').lower();
2445 fmode
= format(int(fstatinfo
.st_mode
), 'x').lower();
2446 fchmode
= format(int(stat
.S_IMODE(fstatinfo
.st_mode
)), 'x').lower();
2447 ftypemod
= format(int(stat
.S_IFMT(fstatinfo
.st_mode
)), 'x').lower();
2448 fuid
= format(int(fstatinfo
.st_uid
), 'x').lower();
2449 fgid
= format(int(fstatinfo
.st_gid
), 'x').lower();
2454 userinfo
= pwd
.getpwuid(fstatinfo
.st_uid
);
2455 funame
= userinfo
.pw_name
;
2464 groupinfo
= grp
.getgrgid(fstatinfo
.st_gid
);
2465 fgname
= groupinfo
.gr_name
;
2470 fdev_minor
= format(int(fdev_minor
), 'x').lower();
2471 fdev_major
= format(int(fdev_major
), 'x').lower();
2472 frdev_minor
= format(int(frdev_minor
), 'x').lower();
2473 frdev_major
= format(int(frdev_major
), 'x').lower();
2474 finode
= format(int(finode
), 'x').lower();
2475 flinkcount
= format(int(flinkcount
), 'x').lower();
2476 if(hasattr(fstatinfo
, "st_file_attributes")):
2477 fwinattributes
= format(int(fstatinfo
.st_file_attributes
), 'x').lower();
2479 fwinattributes
= format(int(0), 'x').lower();
2480 fcontents
= "".encode('UTF-8');
2482 if(ftype
==0 or ftype
==7):
2483 with
open(fname
, "rb") as fpc
:
2485 chunk
= fpc
.read(chunk_size
);
2489 if(followlink
and (ftype
==1 or ftype
==2)):
2490 flstatinfo
= os
.stat(flinkname
);
2491 with
open(flinkname
, "rb") as fpc
:
2493 chunk
= fpc
.read(chunk_size
);
2497 ftypehex
= format(ftype
, 'x').lower();
2498 extrafields
= format(len(extradata
), 'x').lower();
2499 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[5]);
2500 if(len(extradata
)>0):
2501 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[5]);
2502 extrasizelen
= format(len(extrasizestr
), 'x').lower();
2503 catoutlist
= [ftypehex
, fname
, flinkname
, fsize
, fatime
, fmtime
, fctime
, fbtime
, fmode
, fwinattributes
, fuid
, funame
, fgid
, fgname
, fcurfid
, fcurinode
, flinkcount
, fdev_minor
, fdev_major
, frdev_minor
, frdev_major
, extrasizelen
, extrafields
];
2504 catoutlen
= len(catoutlist
) + len(extradata
) + 3;
2505 catoutlenhex
= format(catoutlen
, 'x').lower();
2506 catoutlist
.insert(0, catoutlenhex
);
2507 catfileoutstr
= AppendNullBytes(catoutlist
, formatspecs
[5]);
2508 if(len(extradata
)>0):
2509 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[5]);
2510 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[5]);
2511 if(checksumtype
=="none" or checksumtype
==""):
2512 catfileheadercshex
= format(0, 'x').lower();
2513 catfilecontentcshex
= format(0, 'x').lower();
2514 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
2515 catfileheadercshex
= format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
2516 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
2517 elif(checksumtype
=="crc16_ccitt"):
2518 catfileheadercshex
= format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
2519 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
2520 elif(checksumtype
=="adler32"):
2521 catfileheadercshex
= format(zlib
.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2522 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
2523 elif(checksumtype
=="crc32"):
2524 catfileheadercshex
= format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2525 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
2526 elif(checksumtype
=="crc64_ecma"):
2527 catfileheadercshex
= format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2528 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
2529 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
2530 catfileheadercshex
= format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2531 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
2532 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
2533 checksumoutstr
= hashlib
.new(checksumtype
);
2534 checksumoutstr
.update("".encode('UTF-8'));
2535 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
2536 checksumoutstr
= hashlib
.new(checksumtype
);
2537 checksumoutstr
.update(fcontents
);
2538 catfilecontentcshex
= checksumoutstr
.hexdigest().lower();
2540 catfileheadercshex
= format(0, 'x').lower();
2541 catfilecontentcshex
= format(0, 'x').lower();
2542 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
2543 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
2544 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[5]) + catfileoutstr
;
2545 if(checksumtype
=="none" or checksumtype
==""):
2546 catfileheadercshex
= format(0, 'x').lower();
2547 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
2548 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
2549 elif(checksumtype
=="crc16_ccitt"):
2550 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
2551 elif(checksumtype
=="adler32"):
2552 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
2553 elif(checksumtype
=="crc32"):
2554 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
2555 elif(checksumtype
=="crc64_ecma"):
2556 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2557 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
2558 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2559 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
2560 checksumoutstr
= hashlib
.new(checksumtype
);
2561 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
2562 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
2564 catfileheadercshex
= format(0, 'x').lower();
2565 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
2566 catfhend
= (catfp
.tell() - 1) + len(catfileoutstr
);
2567 catfcontentstart
= catfp
.tell() + len(catfileoutstr
);
2568 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
2569 nullstrecd
= formatspecs
[5].encode('UTF-8');
2570 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
;
2571 catfcontentend
= (catfp
.tell() - 1) + len(catfileout
);
2572 catfp
.write(catfileout
);
2575 os
.fsync(catfp
.fileno());
2576 except io
.UnsupportedOperation
:
2578 except AttributeError:
2581 catfp
.write(AppendNullBytes([0, 0], formatspecs
[5]).encode("UTF-8"));
2582 if(outfile
=="-" or hasattr(outfile
, "read") or hasattr(outfile
, "write")):
2583 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
2586 os
.fsync(catfp
.fileno());
2587 except io
.UnsupportedOperation
:
2589 except AttributeError:
2593 if(hasattr(sys
.stdout
, "buffer")):
2594 shutil
.copyfileobj(catfp
, sys
.stdout
.buffer);
2596 shutil
.copyfileobj(catfp
, sys
.stdout
);
2597 elif(re
.findall(r
"^(ftp|ftps|sftp)\:\/\/", str(outfile
))):
2598 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
2600 upload_file_to_internet_file(catfp
, outfile
);
2608 create_alias_function("Pack", __file_format_name__
, "", PackArchiveFile
);
2610 if(hasattr(shutil
, "register_archive_format")):
2611 def PackArchiveFileFunc(archive_name
, source_dir
, **kwargs
):
2612 return PackArchiveFile(source_dir
, archive_name
, False, "auto", None, False, "crc32", [], __file_format_delimiter__
, False, False);
2613 create_alias_function("Pack", __file_format_name__
, "Func", PackArchiveFileFunc
);
2615 def PackArchiveFileFromDirList(infiles
, outfile
, dirlistfromtxt
=False, compression
="auto", compressionlevel
=None, followlink
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
2616 return PackArchiveFile(infiles
, outfile
, dirlistfromtxt
, compression
, compressionlevel
, followlink
, checksumtype
, extradata
, formatspecs
, verbose
, returnfp
);
2618 create_alias_function("Pack", __file_format_name__
, "FromDirList", PackArchiveFileFromDirList
);
2620 def PackArchiveFileFromTarFile(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
2621 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
2622 outfile
= RemoveWindowsPath(outfile
);
2623 checksumtype
= checksumtype
.lower();
2624 if(not CheckSumSupport(checksumtype
, hashlib_guaranteed
)):
2625 checksumtype
="crc32";
2626 if(checksumtype
=="none"):
2628 if(not compression
or compression
or compression
=="catfile" or compression
==formatspecs
[2]):
2630 if(compression
not in compressionlist
and compression
is None):
2631 compression
= "auto";
2633 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
2634 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
2635 if(os
.path
.exists(outfile
)):
2640 elif(hasattr(outfile
, "read") or hasattr(outfile
, "write")):
2642 elif(re
.findall(r
"^(ftp|ftps|sftp)\:\/\/", str(outfile
))):
2645 fbasename
= os
.path
.splitext(outfile
)[0];
2646 fextname
= os
.path
.splitext(outfile
)[1];
2647 catfp
= CompressOpenFile(outfile
, compressionlevel
);
2648 catver
= formatspecs
[6];
2649 fileheaderver
= str(int(catver
.replace(".", "")));
2650 fileheader
= AppendNullByte(formatspecs
[1] + fileheaderver
, formatspecs
[5]);
2651 catfp
.write(fileheader
.encode('UTF-8'));
2657 inodetocatinode
= {};
2660 if(hasattr(sys
.stdin
, "buffer")):
2661 shutil
.copyfileobj(sys
.stdin
.buffer, infile
);
2663 shutil
.copyfileobj(sys
.stdin
, infile
);
2668 elif(re
.findall(r
"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile
))):
2669 infile
= download_file_from_internet_file(infile
);
2674 elif(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
2676 elif(os
.path
.exists(infile
) and os
.path
.isfile(infile
)):
2678 if(not tarfile
.is_tarfile(infile
)):
2680 except AttributeError:
2681 if(not is_tarfile(infile
)):
2686 if(hasattr(infile
, "read") or hasattr(infile
, "write")):
2687 tarfp
= tarfile
.open(fileobj
=infile
, mode
="r");
2689 tarfp
= tarfile
.open(infile
, "r");
2690 except FileNotFoundError
:
2692 numfiles
= int(len(tarfp
.getmembers()));
2693 fnumfiles
= format(int(len(tarfp
.getmembers())), 'x').lower();
2694 fnumfilesa
= AppendNullBytes([fnumfiles
, checksumtype
], formatspecs
[5]);
2695 if(checksumtype
=="none" or checksumtype
==""):
2696 catfileheadercshex
= format(0, 'x').lower();
2697 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
2698 catfileheadercshex
= format(crc16(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
2699 elif(checksumtype
=="crc16_ccitt"):
2700 catfileheadercshex
= format(crc16_ccitt(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
2701 elif(checksumtype
=="adler32"):
2702 catfileheadercshex
= format(zlib
.adler32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
2703 elif(checksumtype
=="crc32"):
2704 catfileheadercshex
= format(crc32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
2705 elif(checksumtype
=="crc64_ecma"):
2706 catfileheadercshex
= format(crc64_ecma(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2707 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
2708 catfileheadercshex
= format(crc64_iso(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2709 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
2710 checksumoutstr
= hashlib
.new(checksumtype
);
2711 checksumoutstr
.update(str(fileheader
+ fnumfilesa
).encode('UTF-8'));
2712 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
2714 catfileheadercshex
= format(0, 'x').lower();
2715 fnumfilesa
= fnumfilesa
+ AppendNullByte(catfileheadercshex
, formatspecs
[5]);
2716 catfp
.write(fnumfilesa
.encode('UTF-8'));
2719 os
.fsync(catfp
.fileno());
2720 except io
.UnsupportedOperation
:
2722 except AttributeError:
2724 for member
in sorted(tarfp
.getmembers(), key
=lambda x
: x
.name
):
2725 catfhstart
= catfp
.tell();
2726 if(re
.findall("^[.|/]", member
.name
)):
2727 fname
= member
.name
;
2729 fname
= "./"+member
.name
;
2731 VerbosePrintOut(fname
);
2732 fpremode
= member
.mode
;
2733 ffullmode
= member
.mode
;
2737 ffullmode
= member
.mode
+ stat
.S_IFREG
;
2739 elif(member
.isdev()):
2740 ffullmode
= member
.mode
;
2742 elif(member
.islnk()):
2743 ffullmode
= member
.mode
+ stat
.S_IFREG
;
2745 elif(member
.issym()):
2746 ffullmode
= member
.mode
+ stat
.S_IFLNK
;
2748 elif(member
.ischr()):
2749 ffullmode
= member
.mode
+ stat
.S_IFCHR
;
2751 elif(member
.isblk()):
2752 ffullmode
= member
.mode
+ stat
.S_IFBLK
;
2754 elif(member
.isdir()):
2755 ffullmode
= member
.mode
+ stat
.S_IFDIR
;
2757 elif(member
.isfifo()):
2758 ffullmode
= member
.mode
+ stat
.S_IFIFO
;
2760 elif(member
.issparse()):
2761 ffullmode
= member
.mode
;
2764 ffullmode
= member
.mode
;
2767 fcurfid
= format(int(curfid
), 'x').lower();
2768 fcurinode
= format(int(curfid
), 'x').lower();
2769 curfid
= curfid
+ 1;
2771 flinkname
= member
.linkname
;
2772 fdev_minor
= format(int(member
.devminor
), 'x').lower();
2773 fdev_major
= format(int(member
.devmajor
), 'x').lower();
2774 frdev_minor
= format(int(member
.devminor
), 'x').lower();
2775 frdev_major
= format(int(member
.devmajor
), 'x').lower();
2776 if(ftype
==1 or ftype
==2 or ftype
==3 or ftype
==4 or ftype
==5 or ftype
==6):
2777 fsize
= format(int("0"), 'x').lower();
2778 elif(ftype
==0 or ftype
==7):
2779 fsize
= format(int(member
.size
), 'x').lower();
2781 fsize
= format(int(member
.size
), 'x').lower();
2782 fatime
= format(int(member
.mtime
), 'x').lower();
2783 fmtime
= format(int(member
.mtime
), 'x').lower();
2784 fctime
= format(int(member
.mtime
), 'x').lower();
2785 fbtime
= format(int(member
.mtime
), 'x').lower();
2786 fmode
= format(int(ffullmode
), 'x').lower();
2787 fchmode
= format(int(stat
.S_IMODE(ffullmode
)), 'x').lower();
2788 ftypemod
= format(int(stat
.S_IFMT(ffullmode
)), 'x').lower();
2789 fuid
= format(int(member
.uid
), 'x').lower();
2790 fgid
= format(int(member
.gid
), 'x').lower();
2791 funame
= member
.uname
;
2792 fgname
= member
.gname
;
2793 flinkcount
= format(int(flinkcount
), 'x').lower();
2794 fwinattributes
= format(int(0), 'x').lower();
2795 fcontents
= "".encode('UTF-8');
2797 if(ftype
==0 or ftype
==7):
2798 with tarfp
.extractfile(member
) as fpc
:
2800 chunk
= fpc
.read(chunk_size
);
2804 ftypehex
= format(ftype
, 'x').lower();
2805 extrafields
= format(len(extradata
), 'x').lower();
2806 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[5]);
2807 if(len(extradata
)>0):
2808 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[5]);
2809 extrasizelen
= format(len(extrasizestr
), 'x').lower();
2810 catoutlist
= [ftypehex
, fname
, flinkname
, fsize
, fatime
, fmtime
, fctime
, fbtime
, fmode
, fwinattributes
, fuid
, funame
, fgid
, fgname
, fcurfid
, fcurinode
, flinkcount
, fdev_minor
, fdev_major
, frdev_minor
, frdev_major
, extrasizelen
, extrafields
];
2811 catoutlen
= len(catoutlist
) + len(extradata
) + 3;
2812 catoutlenhex
= format(catoutlen
, 'x').lower();
2813 catoutlist
.insert(0, catoutlenhex
);
2814 catfileoutstr
= AppendNullBytes(catoutlist
, formatspecs
[5]);
2815 if(len(extradata
)>0):
2816 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[5]);
2817 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[5]);
2818 catfhend
= (catfp
.tell() - 1) + len(catfileoutstr
);
2819 catfcontentstart
= catfp
.tell() + len(catfileoutstr
);
2820 if(checksumtype
=="none" or checksumtype
==""):
2821 catfileheadercshex
= format(0, 'x').lower();
2822 catfilecontentcshex
= format(0, 'x').lower();
2823 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
2824 catfileheadercshex
= format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
2825 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
2826 elif(checksumtype
=="crc16_ccitt"):
2827 catfileheadercshex
= format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
2828 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
2829 elif(checksumtype
=="adler32"):
2830 catfileheadercshex
= format(zlib
.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2831 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
2832 elif(checksumtype
=="crc32"):
2833 catfileheadercshex
= format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2834 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
2835 elif(checksumtype
=="crc64_ecma"):
2836 catfileheadercshex
= format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2837 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
2838 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
2839 catfileheadercshex
= format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2840 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
2841 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
2842 checksumoutstr
= hashlib
.new(checksumtype
);
2843 checksumoutstr
.update("".encode('UTF-8'));
2844 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
2845 checksumoutstr
= hashlib
.new(checksumtype
);
2846 checksumoutstr
.update(fcontents
);
2847 catfilecontentcshex
= checksumoutstr
.hexdigest().lower();
2849 catfileheadercshex
= format(0, 'x').lower();
2850 catfilecontentcshex
= format(0, 'x').lower();
2851 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
2852 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
2853 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[5]) + catfileoutstr
;
2854 if(checksumtype
=="none" or checksumtype
==""):
2855 catfileheadercshex
= format(0, 'x').lower();
2856 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
2857 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
2858 elif(checksumtype
=="crc16_ccitt"):
2859 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
2860 elif(checksumtype
=="adler32"):
2861 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
2862 elif(checksumtype
=="crc32"):
2863 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
2864 elif(checksumtype
=="crc64_ecma"):
2865 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2866 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
2867 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2868 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
2869 checksumoutstr
= hashlib
.new(checksumtype
);
2870 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
2871 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
2873 catfileheadercshex
= format(0, 'x').lower();
2874 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
2875 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
2876 nullstrecd
= formatspecs
[5].encode('UTF-8');
2877 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
;
2878 catfcontentend
= (catfp
.tell() - 1) + len(catfileout
);
2879 catfp
.write(catfileout
);
2882 os
.fsync(catfp
.fileno());
2883 except io
.UnsupportedOperation
:
2885 except AttributeError:
2888 catfp
.write(AppendNullBytes([0, 0], formatspecs
[5]).encode("UTF-8"));
2889 if(outfile
=="-" or hasattr(outfile
, "read") or hasattr(outfile
, "write")):
2890 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
2893 os
.fsync(catfp
.fileno());
2894 except io
.UnsupportedOperation
:
2896 except AttributeError:
2900 if(hasattr(sys
.stdout
, "buffer")):
2901 shutil
.copyfileobj(catfp
, sys
.stdout
.buffer);
2903 shutil
.copyfileobj(catfp
, sys
.stdout
);
2904 elif(re
.findall(r
"^(ftp|ftps|sftp)\:\/\/", str(outfile
))):
2905 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
2907 upload_file_from_internet_file(catfp
, outfile
);
2915 create_alias_function("Pack", __file_format_name__
, "FromTarFile", PackArchiveFileFromTarFile
);
2917 def PackArchiveFileFromZipFile(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
2918 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
2919 outfile
= RemoveWindowsPath(outfile
);
2920 checksumtype
= checksumtype
.lower();
2921 if(not CheckSumSupport(checksumtype
, hashlib_guaranteed
)):
2922 checksumtype
="crc32";
2923 if(checksumtype
=="none"):
2925 if(not compression
or compression
or compression
=="catfile" or compression
==formatspecs
[2]):
2927 if(compression
not in compressionlist
and compression
is None):
2928 compression
= "auto";
2930 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
2931 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
2932 if(os
.path
.exists(outfile
)):
2937 elif(hasattr(outfile
, "read") or hasattr(outfile
, "write")):
2939 elif(re
.findall(r
"^(ftp|ftps|sftp)\:\/\/", str(outfile
))):
2942 fbasename
= os
.path
.splitext(outfile
)[0];
2943 fextname
= os
.path
.splitext(outfile
)[1];
2944 catfp
= CompressOpenFile(outfile
, compressionlevel
);
2945 catver
= formatspecs
[6];
2946 fileheaderver
= str(int(catver
.replace(".", "")));
2947 fileheader
= AppendNullByte(formatspecs
[1] + fileheaderver
, formatspecs
[5]);
2948 catfp
.write(fileheader
.encode('UTF-8'));
2954 inodetocatinode
= {};
2957 if(hasattr(sys
.stdin
, "buffer")):
2958 shutil
.copyfileobj(sys
.stdin
.buffer, infile
);
2960 shutil
.copyfileobj(sys
.stdin
, infile
);
2965 elif(re
.findall(r
"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile
))):
2966 infile
= download_file_from_internet_file(infile
);
2971 elif(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
2975 if(not zipfile
.is_zipfile(infile
)):
2978 zipfp
= zipfile
.ZipFile(infile
, "r", allowZip64
=True);
2979 except FileNotFoundError
:
2981 ziptest
= zipfp
.testzip();
2983 VerbosePrintOut("Bad file found!");
2984 numfiles
= int(len(zipfp
.infolist()));
2985 fnumfiles
= format(int(len(zipfp
.infolist())), 'x').lower();
2986 fnumfilesa
= AppendNullBytes([fnumfiles
, checksumtype
], formatspecs
[5]);
2987 if(checksumtype
=="none" or checksumtype
==""):
2988 catfileheadercshex
= format(0, 'x').lower();
2989 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
2990 catfileheadercshex
= format(crc16(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
2991 elif(checksumtype
=="crc16_ccitt"):
2992 catfileheadercshex
= format(crc16_ccitt(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
2993 elif(checksumtype
=="adler32"):
2994 catfileheadercshex
= format(zlib
.adler32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
2995 elif(checksumtype
=="crc32"):
2996 catfileheadercshex
= format(crc32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
2997 elif(checksumtype
=="crc64_ecma"):
2998 catfileheadercshex
= format(crc64_ecma(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2999 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3000 catfileheadercshex
= format(crc64_iso(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3001 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3002 checksumoutstr
= hashlib
.new(checksumtype
);
3003 checksumoutstr
.update(str(fileheader
+ fnumfilesa
).encode('UTF-8'));
3004 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3006 catfileheadercshex
= format(0, 'x').lower();
3007 fnumfilesa
= fnumfilesa
+ AppendNullByte(catfileheadercshex
, formatspecs
[5]);
3008 catfp
.write(fnumfilesa
.encode('UTF-8'));
3011 os
.fsync(catfp
.fileno());
3012 except io
.UnsupportedOperation
:
3014 except AttributeError:
3016 for member
in sorted(zipfp
.infolist(), key
=lambda x
: x
.filename
):
3017 catfhstart
= catfp
.tell();
3018 if(re
.findall("^[.|/]", member
.filename
)):
3019 fname
= member
.filename
;
3021 fname
= "./"+member
.filename
;
3022 zipinfo
= zipfp
.getinfo(member
.filename
);
3024 VerbosePrintOut(fname
);
3025 if(not member
.is_dir()):
3026 fpremode
= int(stat
.S_IFREG
+ 438);
3027 elif(member
.is_dir()):
3028 fpremode
= int(stat
.S_IFDIR
+ 511);
3031 if(not member
.is_dir()):
3033 elif(member
.is_dir()):
3036 fcurfid
= format(int(curfid
), 'x').lower();
3037 fcurinode
= format(int(curfid
), 'x').lower();
3038 curfid
= curfid
+ 1;
3039 fdev_minor
= format(int(0), 'x').lower();
3040 fdev_major
= format(int(0), 'x').lower();
3041 frdev_minor
= format(int(0), 'x').lower();
3042 frdev_major
= format(int(0), 'x').lower();
3044 fsize
= format(int("0"), 'x').lower();
3046 fsize
= format(int(member
.file_size
), 'x').lower();
3048 fsize
= format(int(member
.file_size
), 'x').lower();
3049 fatime
= format(int(time
.mktime(member
.date_time
+ (0, 0, -1))), 'x').lower();
3050 fmtime
= format(int(time
.mktime(member
.date_time
+ (0, 0, -1))), 'x').lower();
3051 fctime
= format(int(time
.mktime(member
.date_time
+ (0, 0, -1))), 'x').lower();
3052 fbtime
= format(int(time
.mktime(member
.date_time
+ (0, 0, -1))), 'x').lower();
3053 if(zipinfo
.create_system
==0 or zipinfo
.create_system
==10):
3054 fwinattributes
= format(int(zipinfo
.external_attr
), 'x').lower();
3055 if(not member
.is_dir()):
3056 fmode
= format(int(stat
.S_IFREG
+ 438), 'x').lower();
3057 fchmode
= stat
.S_IMODE(fmode
);
3058 ftypemod
= stat
.S_IFMT(fmode
);
3059 elif(member
.is_dir()):
3060 fmode
= format(int(stat
.S_IFDIR
+ 511), 'x').lower();
3061 fchmode
= stat
.S_IMODE(fmode
);
3062 ftypemod
= stat
.S_IFMT(fmode
);
3063 elif(zipinfo
.create_system
==3):
3064 fwinattributes
= format(int(0), 'x').lower();
3065 fmode
= format(int(zipinfo
.external_attr
), 'x').lower();
3066 fchmode
= stat
.S_IMODE(fmode
);
3067 ftypemod
= stat
.S_IFMT(fmode
);
3069 fwinattributes
= format(int(0), 'x').lower();
3070 if(not member
.is_dir()):
3071 fmode
= format(int(stat
.S_IFREG
+ 438), 'x').lower();
3072 fchmode
= stat
.S_IMODE(fmode
);
3073 ftypemod
= stat
.S_IFMT(fmode
);
3074 elif(member
.is_dir()):
3075 fmode
= format(int(stat
.S_IFDIR
+ 511), 'x').lower();
3076 fchmode
= stat
.S_IMODE(fmode
);
3077 ftypemod
= stat
.S_IFMT(fmode
);
3079 fuid
= format(int(os
.getuid()), 'x').lower();
3080 except AttributeError:
3081 fuid
= format(int(0), 'x').lower();
3083 fuid
= format(int(0), 'x').lower();
3085 fgid
= format(int(os
.getgid()), 'x').lower();
3086 except AttributeError:
3087 fgid
= format(int(0), 'x').lower();
3089 fgid
= format(int(0), 'x').lower();
3093 userinfo
= pwd
.getpwuid(os
.getuid());
3094 funame
= userinfo
.pw_name
;
3097 except AttributeError:
3105 groupinfo
= grp
.getgrgid(os
.getgid());
3106 fgname
= groupinfo
.gr_name
;
3109 except AttributeError:
3113 fcontents
= "".encode('UTF-8');
3115 fcontents
= zipfp
.read(member
.filename
);
3116 ftypehex
= format(ftype
, 'x').lower();
3117 extrafields
= format(len(extradata
), 'x').lower();
3118 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[5]);
3119 if(len(extradata
)>0):
3120 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[5]);
3121 extrasizelen
= format(len(extrasizestr
), 'x').lower();
3122 catoutlist
= [ftypehex
, fname
, flinkname
, fsize
, fatime
, fmtime
, fctime
, fbtime
, fmode
, fwinattributes
, fuid
, funame
, fgid
, fgname
, fcurfid
, fcurinode
, flinkcount
, fdev_minor
, fdev_major
, frdev_minor
, frdev_major
, extrasizelen
, extrafields
];
3123 catoutlen
= len(catoutlist
) + len(extradata
) + 3;
3124 catoutlenhex
= format(catoutlen
, 'x').lower();
3125 catoutlist
.insert(0, catoutlenhex
);
3126 catfileoutstr
= AppendNullBytes(catoutlist
, formatspecs
[5]);
3127 if(len(extradata
)>0):
3128 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[5]);
3129 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[5]);
3130 catfhend
= (catfp
.tell() - 1) + len(catfileoutstr
);
3131 catfcontentstart
= catfp
.tell() + len(catfileoutstr
);
3132 if(checksumtype
=="none" or checksumtype
==""):
3133 catfileheadercshex
= format(0, 'x').lower();
3134 catfilecontentcshex
= format(0, 'x').lower();
3135 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3136 catfileheadercshex
= format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3137 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
3138 elif(checksumtype
=="crc16_ccitt"):
3139 catfileheadercshex
= format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3140 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
3141 elif(checksumtype
=="adler32"):
3142 catfileheadercshex
= format(zlib
.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3143 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
3144 elif(checksumtype
=="crc32"):
3145 catfileheadercshex
= format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3146 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
3147 elif(checksumtype
=="crc64_ecma"):
3148 catfileheadercshex
= format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3149 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
3150 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3151 catfileheadercshex
= format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3152 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
3153 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3154 checksumoutstr
= hashlib
.new(checksumtype
);
3155 checksumoutstr
.update("".encode('UTF-8'));
3156 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3157 checksumoutstr
= hashlib
.new(checksumtype
);
3158 checksumoutstr
.update(fcontents
);
3159 catfilecontentcshex
= checksumoutstr
.hexdigest().lower();
3161 catfileheadercshex
= format(0, 'x').lower();
3162 catfilecontentcshex
= format(0, 'x').lower();
3163 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
3164 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
3165 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[5]) + catfileoutstr
;
3166 if(checksumtype
=="none" or checksumtype
==""):
3167 catfileheadercshex
= format(0, 'x').lower();
3168 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3169 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
3170 elif(checksumtype
=="crc16_ccitt"):
3171 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
3172 elif(checksumtype
=="adler32"):
3173 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3174 elif(checksumtype
=="crc32"):
3175 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3176 elif(checksumtype
=="crc64_ecma"):
3177 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3178 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3179 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3180 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3181 checksumoutstr
= hashlib
.new(checksumtype
);
3182 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
3183 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3185 catfileheadercshex
= format(0, 'x').lower();
3186 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
3187 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
3188 nullstrecd
= formatspecs
[5].encode('UTF-8');
3189 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
;
3190 catfcontentend
= (catfp
.tell() - 1) + len(catfileout
);
3191 catfp
.write(catfileout
);
3194 os
.fsync(catfp
.fileno());
3195 except io
.UnsupportedOperation
:
3197 except AttributeError:
3200 catfp
.write(AppendNullBytes([0, 0], formatspecs
[5]).encode("UTF-8"));
3201 if(outfile
=="-" or hasattr(outfile
, "read") or hasattr(outfile
, "write")):
3202 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
3205 os
.fsync(catfp
.fileno());
3206 except io
.UnsupportedOperation
:
3208 except AttributeError:
3212 if(hasattr(sys
.stdout
, "buffer")):
3213 shutil
.copyfileobj(catfp
, sys
.stdout
.buffer);
3215 shutil
.copyfileobj(catfp
, sys
.stdout
);
3216 elif(re
.findall(r
"^(ftp|ftps|sftp)\:\/\/", str(outfile
))):
3217 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
3219 upload_file_to_internet_file(catfp
, outfile
);
3227 create_alias_function("Pack", __file_format_name__
, "FromZipFile", PackArchiveFileFromZipFile
);
3229 if(not rarfile_support
):
3230 def PackArchiveFileFromRarFile(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
3233 if(rarfile_support
):
3234 def PackArchiveFileFromRarFile(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
3235 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
3236 outfile
= RemoveWindowsPath(outfile
);
3237 checksumtype
= checksumtype
.lower();
3238 if(not CheckSumSupport(checksumtype
, hashlib_guaranteed
)):
3239 checksumtype
="crc32";
3240 if(checksumtype
=="none"):
3242 if(not compression
or compression
or compression
=="catfile" or compression
==formatspecs
[2]):
3244 if(compression
not in compressionlist
and compression
is None):
3245 compression
= "auto";
3247 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
3248 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
3249 if(os
.path
.exists(outfile
)):
3254 elif(hasattr(outfile
, "read") or hasattr(outfile
, "write")):
3256 elif(re
.findall(r
"^(ftp|ftps|sftp)\:\/\/", str(outfile
))):
3259 fbasename
= os
.path
.splitext(outfile
)[0];
3260 fextname
= os
.path
.splitext(outfile
)[1];
3261 catfp
= CompressOpenFile(outfile
, compressionlevel
);
3262 catver
= formatspecs
[6];
3263 fileheaderver
= str(int(catver
.replace(".", "")));
3264 fileheader
= AppendNullByte(formatspecs
[1] + fileheaderver
, formatspecs
[5]);
3265 catfp
.write(fileheader
.encode('UTF-8'));
3271 inodetocatinode
= {};
3272 if(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
3274 if(not rarfile
.is_rarfile(infile
) and not rarfile
.is_rarfile_sfx(infile
)):
3276 rarfp
= rarfile
.RarFile(infile
, "r");
3277 rartest
= rarfp
.testrar();
3279 VerbosePrintOut("Bad file found!");
3280 numfiles
= int(len(rarfp
.infolist()));
3281 fnumfiles
= format(int(len(rarfp
.infolist())), 'x').lower();
3282 fnumfilesa
= AppendNullBytes([fnumfiles
, checksumtype
], formatspecs
[5]);
3283 if(checksumtype
=="none" or checksumtype
==""):
3284 catfileheadercshex
= format(0, 'x').lower();
3285 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3286 catfileheadercshex
= format(crc16(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
3287 elif(checksumtype
=="crc16_ccitt"):
3288 catfileheadercshex
= format(crc16_ccitt(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
3289 elif(checksumtype
=="adler32"):
3290 catfileheadercshex
= format(zlib
.adler32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
3291 elif(checksumtype
=="crc32"):
3292 catfileheadercshex
= format(crc32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
3293 elif(checksumtype
=="crc64_ecma"):
3294 catfileheadercshex
= format(crc64_ecma(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3295 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3296 catfileheadercshex
= format(crc64_iso(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3297 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3298 checksumoutstr
= hashlib
.new(checksumtype
);
3299 checksumoutstr
.update(str(fileheader
+ fnumfilesa
).encode('UTF-8'));
3300 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3302 catfileheadercshex
= format(0, 'x').lower();
3303 fnumfilesa
= fnumfilesa
+ AppendNullByte(catfileheadercshex
, formatspecs
[5]);
3304 catfp
.write(fnumfilesa
.encode('UTF-8'));
3307 os
.fsync(catfp
.fileno());
3308 except io
.UnsupportedOperation
:
3310 except AttributeError:
3312 for member
in sorted(rarfp
.infolist(), key
=lambda x
: x
.filename
):
3315 if(member
.host_os
==rarfile
.RAR_OS_UNIX
):
3318 member
.external_attr
3320 except AttributeError:
3322 elif(member
.host_os
==rarfile
.RAR_OS_WIN32
):
3325 member
.external_attr
3327 except AttributeError:
3332 catfhstart
= catfp
.tell();
3333 if(re
.findall("^[.|/]", member
.filename
)):
3334 fname
= member
.filename
;
3336 fname
= "./"+member
.filename
;
3337 rarinfo
= rarfp
.getinfo(member
.filename
);
3339 VerbosePrintOut(fname
);
3340 if(is_unix
and member
.external_attr
!=0):
3341 fpremode
= int(member
.external_attr
);
3342 elif(member
.is_file()):
3343 fpremode
= int(stat
.S_IFREG
+ 438);
3344 elif(member
.is_symlink()):
3345 fpremode
= int(stat
.S_IFLNK
+ 438);
3346 elif(member
.is_dir()):
3347 fpremode
= int(stat
.S_IFDIR
+ 511);
3348 if(is_windows
and member
.external_attr
!=0):
3349 fwinattributes
= format(int(member
.external_attr
), 'x').lower();
3351 fwinattributes
= format(int(0), 'x').lower();
3354 if(member
.is_file()):
3356 elif(member
.is_symlink()):
3358 elif(member
.is_dir()):
3362 flinkname
= rarfp
.read(member
.filename
).decode("UTF-8");
3363 fcurfid
= format(int(curfid
), 'x').lower();
3364 fcurinode
= format(int(curfid
), 'x').lower();
3365 curfid
= curfid
+ 1;
3366 fdev_minor
= format(int(0), 'x').lower();
3367 fdev_major
= format(int(0), 'x').lower();
3368 frdev_minor
= format(int(0), 'x').lower();
3369 frdev_major
= format(int(0), 'x').lower();
3371 fsize
= format(int("0"), 'x').lower();
3373 fsize
= format(int(member
.file_size
), 'x').lower();
3375 fsize
= format(int(member
.file_size
), 'x').lower();
3378 fatime
= format(int(member
.atime
.timestamp()), 'x').lower();
3380 fatime
= format(int(member
.mtime
.timestamp()), 'x').lower();
3381 except AttributeError:
3382 fatime
= format(int(member
.mtime
.timestamp()), 'x').lower();
3383 fmtime
= format(int(member
.mtime
.timestamp()), 'x').lower();
3386 fctime
= format(int(member
.ctime
.timestamp()), 'x').lower();
3388 fctime
= format(int(member
.mtime
.timestamp()), 'x').lower();
3389 except AttributeError:
3390 fctime
= format(int(member
.mtime
.timestamp()), 'x').lower();
3391 fbtime
= format(int(member
.mtime
.timestamp()), 'x').lower();
3392 if(is_unix
and member
.external_attr
!=0):
3393 fmode
= format(int(member
.external_attr
), 'x').lower();
3394 fchmode
= format(int(stat
.S_IMODE(member
.external_attr
)), 'x').lower();
3395 ftypemod
= format(int(stat
.S_IFMT(member
.external_attr
)), 'x').lower();
3396 elif(member
.is_file()):
3397 fmode
= format(int(stat
.S_IFREG
+ 438), 'x').lower();
3398 fchmode
= format(int(stat
.S_IMODE(int(stat
.S_IFREG
+ 438))), 'x').lower();
3399 ftypemod
= format(int(stat
.S_IFMT(int(stat
.S_IFREG
+ 438))), 'x').lower();
3400 elif(member
.is_symlink()):
3401 fmode
= format(int(stat
.S_IFLNK
+ 438), 'x').lower();
3402 fchmode
= format(int(stat
.S_IMODE(int(stat
.S_IFREG
+ 438))), 'x').lower();
3403 ftypemod
= format(int(stat
.S_IFMT(int(stat
.S_IFREG
+ 438))), 'x').lower();
3404 elif(member
.is_dir()):
3405 fmode
= format(int(stat
.S_IFDIR
+ 511), 'x').lower();
3406 fchmode
= format(int(stat
.S_IMODE(int(stat
.S_IFDIR
+ 511))), 'x').lower();
3407 ftypemod
= format(int(stat
.S_IFMT(int(stat
.S_IFDIR
+ 511))), 'x').lower();
3409 fuid
= format(int(os
.getuid()), 'x').lower();
3410 except AttributeError:
3411 fuid
= format(int(0), 'x').lower();
3413 fuid
= format(int(0), 'x').lower();
3415 fgid
= format(int(os
.getgid()), 'x').lower();
3416 except AttributeError:
3417 fgid
= format(int(0), 'x').lower();
3419 fgid
= format(int(0), 'x').lower();
3423 userinfo
= pwd
.getpwuid(os
.getuid());
3424 funame
= userinfo
.pw_name
;
3427 except AttributeError:
3435 groupinfo
= grp
.getgrgid(os
.getgid());
3436 fgname
= groupinfo
.gr_name
;
3439 except AttributeError:
3443 fcontents
= "".encode('UTF-8');
3445 fcontents
= rarfp
.read(member
.filename
);
3446 ftypehex
= format(ftype
, 'x').lower();
3447 extrafields
= format(len(extradata
), 'x').lower();
3448 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[5]);
3449 if(len(extradata
)>0):
3450 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[5]);
3451 extrasizelen
= format(len(extrasizestr
), 'x').lower();
3452 catoutlist
= [ftypehex
, fname
, flinkname
, fsize
, fatime
, fmtime
, fctime
, fbtime
, fmode
, fwinattributes
, fuid
, funame
, fgid
, fgname
, fcurfid
, fcurinode
, flinkcount
, fdev_minor
, fdev_major
, frdev_minor
, frdev_major
, extrasizelen
, extrafields
];
3453 catoutlen
= len(catoutlist
) + len(extradata
) + 3;
3454 catoutlenhex
= format(catoutlen
, 'x').lower();
3455 catoutlist
.insert(0, catoutlenhex
);
3456 catfileoutstr
= AppendNullBytes(catoutlist
, formatspecs
[5]);
3457 if(len(extradata
)>0):
3458 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[5]);
3459 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[5]);
3460 catfhend
= (catfp
.tell() - 1) + len(catfileoutstr
);
3461 catfcontentstart
= catfp
.tell() + len(catfileoutstr
);
3462 if(checksumtype
=="none" or checksumtype
==""):
3463 catfileheadercshex
= format(0, 'x').lower();
3464 catfilecontentcshex
= format(0, 'x').lower();
3465 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3466 catfileheadercshex
= format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3467 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
3468 elif(checksumtype
=="crc16_ccitt"):
3469 catfileheadercshex
= format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3470 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
3471 elif(checksumtype
=="adler32"):
3472 catfileheadercshex
= format(zlib
.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3473 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
3474 elif(checksumtype
=="crc32"):
3475 catfileheadercshex
= format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3476 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
3477 elif(checksumtype
=="crc64_ecma"):
3478 catfileheadercshex
= format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3479 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
3480 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3481 catfileheadercshex
= format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3482 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
3483 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3484 checksumoutstr
= hashlib
.new(checksumtype
);
3485 checksumoutstr
.update("".encode('UTF-8'));
3486 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3487 checksumoutstr
= hashlib
.new(checksumtype
);
3488 checksumoutstr
.update(fcontents
);
3489 catfilecontentcshex
= checksumoutstr
.hexdigest().lower();
3491 catfileheadercshex
= format(0, 'x').lower();
3492 catfilecontentcshex
= format(0, 'x').lower();
3493 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
3494 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
3495 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[5]) + catfileoutstr
3496 if(checksumtype
=="none" or checksumtype
==""):
3497 catfileheadercshex
= format(0, 'x').lower()
3498 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3499 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower()
3500 elif(checksumtype
=="crc16_ccitt"):
3501 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower()
3502 elif(checksumtype
=="adler32"):
3503 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower()
3504 elif(checksumtype
=="crc32"):
3505 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower()
3506 elif(checksumtype
=="crc64_ecma"):
3507 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
3508 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3509 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
3510 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3511 checksumoutstr
= hashlib
.new(checksumtype
)
3512 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'))
3513 catfileheadercshex
= checksumoutstr
.hexdigest().lower()
3515 catfileheadercshex
= format(0, 'x').lower()
3516 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5])
3517 catfileoutstrecd
= catfileoutstr
.encode('UTF-8')
3518 nullstrecd
= formatspecs
[5].encode('UTF-8')
3519 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
3520 catfcontentend
= (catfp
.tell() - 1) + len(catfileout
)
3521 catfp
.write(catfileout
)
3524 os
.fsync(catfp
.fileno())
3525 except io
.UnsupportedOperation
:
3527 except AttributeError:
3530 catfp
.write(AppendNullBytes([0, 0], formatspecs
[5]).encode("UTF-8"));
3531 if(outfile
=="-" or hasattr(outfile
, "read") or hasattr(outfile
, "write")):
3532 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
)
3535 os
.fsync(catfp
.fileno())
3536 except io
.UnsupportedOperation
:
3538 except AttributeError:
3542 if(hasattr(sys
.stdout
, "buffer")):
3543 shutil
.copyfileobj(catfp
, sys
.stdout
.buffer);
3545 shutil
.copyfileobj(catfp
, sys
.stdout
);
3546 elif(re
.findall(r
"^(ftp|ftps|sftp)\:\/\/", str(outfile
))):
3547 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
3549 upload_file_to_internet_file(catfp
, outfile
);
3557 create_alias_function("Pack", __file_format_name__
, "FromRarFile", PackArchiveFileFromRarFile
);
3559 if(not py7zr_support
):
3560 def PackArchiveFileFromSevenZipFile(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
3564 def PackArchiveFileFromSevenZipFile(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
3565 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
3566 outfile
= RemoveWindowsPath(outfile
);
3567 checksumtype
= checksumtype
.lower();
3568 if(not CheckSumSupport(checksumtype
, hashlib_guaranteed
)):
3569 checksumtype
="crc32";
3570 if(checksumtype
=="none"):
3572 if(not compression
or compression
or compression
=="catfile" or compression
==formatspecs
[2]):
3574 if(compression
not in compressionlist
and compression
is None):
3575 compression
= "auto";
3577 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
3578 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
3579 if(os
.path
.exists(outfile
)):
3584 elif(hasattr(outfile
, "read") or hasattr(outfile
, "write")):
3586 elif(re
.findall(r
"^(ftp|ftps|sftp)\:\/\/", str(outfile
))):
3589 fbasename
= os
.path
.splitext(outfile
)[0];
3590 fextname
= os
.path
.splitext(outfile
)[1];
3591 catfp
= CompressOpenFile(outfile
, compressionlevel
);
3592 catver
= formatspecs
[6];
3593 fileheaderver
= str(int(catver
.replace(".", "")));
3594 fileheader
= AppendNullByte(formatspecs
[1] + fileheaderver
, formatspecs
[5]);
3595 catfp
.write(fileheader
.encode('UTF-8'));
3601 inodetocatinode
= {};
3602 if(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
3604 szpfp
= py7zr
.SevenZipFile(infile
, mode
="r");
3605 file_content
= szpfp
.readall();
3606 #sztest = szpfp.testzip();
3607 sztestalt
= szpfp
.test();
3609 VerbosePrintOut("Bad file found!");
3610 numfiles
= int(len(szpfp
.list()));
3611 fnumfiles
= format(int(len(szpfp
.list())), 'x').lower();
3612 fnumfilesa
= AppendNullBytes([fnumfiles
, checksumtype
], formatspecs
[5]);
3613 if(checksumtype
=="none" or checksumtype
==""):
3614 catfileheadercshex
= format(0, 'x').lower();
3615 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3616 catfileheadercshex
= format(crc16(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
3617 elif(checksumtype
=="crc16_ccitt"):
3618 catfileheadercshex
= format(crc16_ccitt(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
3619 elif(checksumtype
=="adler32"):
3620 catfileheadercshex
= format(zlib
.adler32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
3621 elif(checksumtype
=="crc32"):
3622 catfileheadercshex
= format(crc32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
3623 elif(checksumtype
=="crc64_ecma"):
3624 catfileheadercshex
= format(crc64_ecma(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3625 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3626 catfileheadercshex
= format(crc64_iso(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3627 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3628 checksumoutstr
= hashlib
.new(checksumtype
);
3629 checksumoutstr
.update(str(fileheader
+ fnumfilesa
).encode('UTF-8'));
3630 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3632 catfileheadercshex
= format(0, 'x').lower();
3633 fnumfilesa
= fnumfilesa
+ AppendNullByte(catfileheadercshex
, formatspecs
[5]);
3634 catfp
.write(fnumfilesa
.encode('UTF-8'));
3637 os
.fsync(catfp
.fileno());
3638 except io
.UnsupportedOperation
:
3640 except AttributeError:
3642 for member
in sorted(szpfp
.list(), key
=lambda x
: x
.filename
):
3643 catfhstart
= catfp
.tell();
3644 if(re
.findall("^[.|/]", member
.filename
)):
3645 fname
= member
.filename
;
3647 fname
= "./"+member
.filename
;
3649 VerbosePrintOut(fname
);
3650 if(not member
.is_directory
):
3651 fpremode
= int(stat
.S_IFREG
+ 438);
3652 elif(member
.is_directory
):
3653 fpremode
= int(stat
.S_IFDIR
+ 511);
3654 fwinattributes
= format(int(0), 'x').lower();
3657 if(member
.is_directory
):
3662 fcurfid
= format(int(curfid
), 'x').lower();
3663 fcurinode
= format(int(curfid
), 'x').lower();
3664 curfid
= curfid
+ 1;
3665 fdev_minor
= format(int(0), 'x').lower();
3666 fdev_major
= format(int(0), 'x').lower();
3667 frdev_minor
= format(int(0), 'x').lower();
3668 frdev_major
= format(int(0), 'x').lower();
3670 fsize
= format(int("0"), 'x').lower();
3671 fatime
= format(int(member
.creationtime
.timestamp()), 'x').lower();
3672 fmtime
= format(int(member
.creationtime
.timestamp()), 'x').lower();
3673 fctime
= format(int(member
.creationtime
.timestamp()), 'x').lower();
3674 fbtime
= format(int(member
.creationtime
.timestamp()), 'x').lower();
3675 if(member
.is_directory
):
3676 fmode
= format(int(stat
.S_IFDIR
+ 511), 'x').lower();
3677 fchmode
= format(int(stat
.S_IMODE(int(stat
.S_IFDIR
+ 511))), 'x').lower();
3678 ftypemod
= format(int(stat
.S_IFMT(int(stat
.S_IFDIR
+ 511))), 'x').lower();
3680 fmode
= format(int(stat
.S_IFREG
+ 438), 'x').lower();
3681 fchmode
= format(int(stat
.S_IMODE(int(stat
.S_IFREG
+ 438))), 'x').lower();
3682 ftypemod
= format(int(stat
.S_IFMT(int(stat
.S_IFREG
+ 438))), 'x').lower();
3684 fuid
= format(int(os
.getuid()), 'x').lower();
3685 except AttributeError:
3686 fuid
= format(int(0), 'x').lower();
3688 fuid
= format(int(0), 'x').lower();
3690 fgid
= format(int(os
.getgid()), 'x').lower();
3691 except AttributeError:
3692 fgid
= format(int(0), 'x').lower();
3694 fgid
= format(int(0), 'x').lower();
3698 userinfo
= pwd
.getpwuid(os
.getuid());
3699 funame
= userinfo
.pw_name
;
3702 except AttributeError:
3710 groupinfo
= grp
.getgrgid(os
.getgid());
3711 fgname
= groupinfo
.gr_name
;
3714 except AttributeError:
3718 fcontents
= "".encode('UTF-8');
3720 fcontents
= file_content
[member
.filename
].read();
3721 fsize
= format(len(fcontents
), 'x').lower();
3722 file_content
[member
.filename
].close();
3723 ftypehex
= format(ftype
, 'x').lower();
3724 extrafields
= format(len(extradata
), 'x').lower();
3725 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[5]);
3726 if(len(extradata
)>0):
3727 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[5]);
3728 extrasizelen
= format(len(extrasizestr
), 'x').lower();
3729 catoutlist
= [ftypehex
, fname
, flinkname
, fsize
, fatime
, fmtime
, fctime
, fbtime
, fmode
, fwinattributes
, fuid
, funame
, fgid
, fgname
, fcurfid
, fcurinode
, flinkcount
, fdev_minor
, fdev_major
, frdev_minor
, frdev_major
, extrasizelen
, extrafields
];
3730 catoutlen
= len(catoutlist
) + len(extradata
) + 3;
3731 catoutlenhex
= format(catoutlen
, 'x').lower();
3732 catoutlist
.insert(0, catoutlenhex
);
3733 catfileoutstr
= AppendNullBytes(catoutlist
, formatspecs
[5]);
3734 if(len(extradata
)>0):
3735 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[5]);
3736 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[5]);
3737 catfhend
= (catfp
.tell() - 1) + len(catfileoutstr
);
3738 catfcontentstart
= catfp
.tell() + len(catfileoutstr
);
3739 if(checksumtype
=="none" or checksumtype
==""):
3740 catfileheadercshex
= format(0, 'x').lower();
3741 catfilecontentcshex
= format(0, 'x').lower();
3742 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3743 catfileheadercshex
= format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3744 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
3745 elif(checksumtype
=="crc16_ccitt"):
3746 catfileheadercshex
= format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3747 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
3748 elif(checksumtype
=="adler32"):
3749 catfileheadercshex
= format(zlib
.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3750 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
3751 elif(checksumtype
=="crc32"):
3752 catfileheadercshex
= format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3753 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
3754 elif(checksumtype
=="crc64_ecma"):
3755 catfileheadercshex
= format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3756 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
3757 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3758 catfileheadercshex
= format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3759 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
3760 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3761 checksumoutstr
= hashlib
.new(checksumtype
);
3762 checksumoutstr
.update("".encode('UTF-8'));
3763 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3764 checksumoutstr
= hashlib
.new(checksumtype
);
3765 checksumoutstr
.update(fcontents
);
3766 catfilecontentcshex
= checksumoutstr
.hexdigest().lower();
3768 catfileheadercshex
= format(0, 'x').lower();
3769 catfilecontentcshex
= format(0, 'x').lower();
3770 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
3771 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
3772 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[5]) + catfileoutstr
3773 if(checksumtype
=="none" or checksumtype
==""):
3774 catfileheadercshex
= format(0, 'x').lower()
3775 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3776 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower()
3777 elif(checksumtype
=="crc16_ccitt"):
3778 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower()
3779 elif(checksumtype
=="adler32"):
3780 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower()
3781 elif(checksumtype
=="crc32"):
3782 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower()
3783 elif(checksumtype
=="crc64_ecma"):
3784 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
3785 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3786 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
3787 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3788 checksumoutstr
= hashlib
.new(checksumtype
)
3789 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'))
3790 catfileheadercshex
= checksumoutstr
.hexdigest().lower()
3792 catfileheadercshex
= format(0, 'x').lower()
3793 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5])
3794 catfileoutstrecd
= catfileoutstr
.encode('UTF-8')
3795 nullstrecd
= formatspecs
[5].encode('UTF-8')
3796 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
3797 catfcontentend
= (catfp
.tell() - 1) + len(catfileout
)
3798 catfp
.write(catfileout
)
3801 os
.fsync(catfp
.fileno())
3802 except io
.UnsupportedOperation
:
3804 except AttributeError:
3807 catfp
.write(AppendNullBytes([0, 0], formatspecs
[5]).encode("UTF-8"));
3808 if(outfile
=="-" or hasattr(outfile
, "read") or hasattr(outfile
, "write")):
3809 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
)
3812 os
.fsync(catfp
.fileno())
3813 except io
.UnsupportedOperation
:
3815 except AttributeError:
3819 if(hasattr(sys
.stdout
, "buffer")):
3820 shutil
.copyfileobj(catfp
, sys
.stdout
.buffer);
3822 shutil
.copyfileobj(catfp
, sys
.stdout
);
3823 elif(re
.findall(r
"^(ftp|ftps|sftp)\:\/\/", str(outfile
))):
3824 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
3826 upload_file_to_internet_file(catfp
, outfile
);
3834 create_alias_function("Pack", __file_format_name__
, "FromSevenZipFile", PackArchiveFileFromSevenZipFile
);
3836 def PackArchiveFileFromInFile(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
3837 checkcompressfile
= CheckCompressionSubType(infile
, formatspecs
, True);
3839 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
3840 if(checkcompressfile
=="tarfile"):
3841 return PackArchiveFileFromTarFile(infile
, outfile
, compression
, compressionlevel
, checksumtype
, extradata
, formatspecs
, verbose
, returnfp
);
3842 elif(checkcompressfile
=="zipfile"):
3843 return PackArchiveFileFromZipFile(infile
, outfile
, compression
, compressionlevel
, checksumtype
, extradata
, formatspecs
, verbose
, returnfp
);
3844 elif(checkcompressfile
=="catfile"):
3845 return RePackArchiveFile(infile
, outfile
, compression
, compressionlevel
, False, 0, 0, checksumtype
, False, extradata
, formatspecs
, verbose
, returnfp
);
3846 elif(rarfile_support
and checkcompressfile
=="rarfile"):
3847 return PackArchiveFileFromRarFile(infile
, outfile
, compression
, compressionlevel
, checksumtype
, extradata
, formatspecs
, verbose
, returnfp
);
3848 elif(py7zr_support
and checkcompressfile
=="7zipfile"):
3849 return PackArchiveFileFromSevenZipFile(infile
, outfile
, compression
, compressionlevel
, checksumtype
, extradata
, formatspecs
, verbose
, returnfp
);
3854 create_alias_function("Pack", __file_format_name__
, "FromInFile", PackArchiveFileFromInFile
);
3856 def ArchiveFileSeekToFileNum(infile
, seekto
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
3857 if(hasattr(infile
, "read") or hasattr(infile
, "write")):
3860 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
3861 checkcompressfile
= CheckCompressionSubType(catfp
, formatspecs
, True);
3862 if(checkcompressfile
=="tarfile"):
3863 return TarFileToArray(infile
, seekto
, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
3864 if(checkcompressfile
=="zipfile"):
3865 return ZipFileToArray(infile
, seekto
, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
3866 if(rarfile_support
and checkcompressfile
=="rarfile"):
3867 return RarFileToArray(infile
, seekto
, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
3868 if(py7zr_support
and checkcompressfile
=="7zipfile"):
3869 return SevenZipFileToArray(infile
, seekto
, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
3870 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[2]):
3877 if(hasattr(sys
.stdin
, "buffer")):
3878 shutil
.copyfileobj(sys
.stdin
.buffer, catfp
);
3880 shutil
.copyfileobj(sys
.stdin
, catfp
);
3882 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
3886 elif(re
.findall(r
"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile
))):
3887 catfp
= download_file_from_internet_file(infile
);
3889 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
3894 infile
= RemoveWindowsPath(infile
);
3895 checkcompressfile
= CheckCompressionSubType(infile
, formatspecs
, True);
3896 if(checkcompressfile
=="tarfile"):
3897 return TarFileToArray(infile
, seekto
, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
3898 if(checkcompressfile
=="zipfile"):
3899 return ZipFileToArray(infile
, seekto
, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
3900 if(rarfile_support
and checkcompressfile
=="rarfile"):
3901 return RarFileToArray(infile
, seekto
, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
3902 if(py7zr_support
and checkcompressfile
=="7zipfile"):
3903 return SevenZipFileToArray(infile
, seekto
, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
3904 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[2]):
3906 compresscheck
= CheckCompressionType(infile
, formatspecs
, True);
3907 if(not compresscheck
):
3908 fextname
= os
.path
.splitext(infile
)[1];
3909 if(fextname
==".gz"):
3910 compresscheck
= "gzip";
3911 elif(fextname
==".bz2"):
3912 compresscheck
= "bzip2";
3913 elif(fextname
==".zst"):
3914 compresscheck
= "zstd";
3915 elif(fextname
==".lz4" or fextname
==".clz4"):
3916 compresscheck
= "lz4";
3917 elif(fextname
==".lzo" or fextname
==".lzop"):
3918 compresscheck
= "lzo";
3919 elif(fextname
==".lzma" or fextname
==".xz"):
3920 compresscheck
= "lzma";
3923 if(not compresscheck
):
3925 catfp
= UncompressFile(infile
, formatspecs
, "rb");
3930 SeekToEndOfFile(catfp);
3932 SeekToEndOfFile(catfp);
3933 CatSize = catfp.tell();
3934 CatSizeEnd = CatSize;
3942 curloc
= catfp
.tell();
3945 catheader
= ReadFileHeaderData(catfp
, 4, formatspecs
[5]);
3947 catfp
.seek(curloc
, 0);
3948 catstring
= catheader
[0];
3949 catversion
= re
.findall(r
"([\d]+)$", catstring
);
3950 fprenumfiles
= catheader
[1];
3951 fnumfiles
= int(fprenumfiles
, 16);
3952 fprechecksumtype
= catheader
[2];
3953 fprechecksum
= catheader
[3];
3954 fileheader
= AppendNullByte(catstring
, formatspecs
[5]);
3955 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
3956 fileheader
= fileheader
+ AppendNullBytes([fnumfileshex
, fprechecksumtype
], formatspecs
[5]);
3957 if(fprechecksumtype
=="none" or fprechecksumtype
==""):
3958 catfileheadercshex
= format(0, 'x').lower();
3959 elif(fprechecksumtype
=="crc16" or fprechecksumtype
=="crc16_ansi" or fprechecksumtype
=="crc16_ibm"):
3960 catfileheadercshex
= format(crc16(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
3961 elif(fprechecksumtype
=="crc16_ccitt"):
3962 catfileheadercshex
= format(crc16_ccitt(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
3963 elif(fprechecksumtype
=="adler32"):
3964 catfileheadercshex
= format(zlib
.adler32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3965 elif(fprechecksumtype
=="crc32"):
3966 catfileheadercshex
= format(crc32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3967 elif(fprechecksumtype
=="crc64_ecma"):
3968 catfileheadercshex
= format(crc64_ecma(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3969 elif(fprechecksumtype
=="crc64" or fprechecksumtype
=="crc64_iso"):
3970 catfileheadercshex
= format(crc64_iso(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3971 elif(CheckSumSupportAlt(fprechecksumtype
, hashlib_guaranteed
)):
3972 checksumoutstr
= hashlib
.new(fprechecksumtype
);
3973 checksumoutstr
.update(fileheader
.encode('UTF-8'));
3974 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3976 catfileheadercshex
= format(0, 'x').lower();
3977 fileheader
= fileheader
+ AppendNullByte(catfileheadercshex
, formatspecs
[5]);
3978 fheadtell
= len(fileheader
);
3979 if(fprechecksum
!=catfileheadercshex
and not skipchecksum
):
3980 VerbosePrintOut("File Header Checksum Error with file " + infile
+ " at offset " + str(0));
3982 catversions
= re
.search(r
'(.*?)(\d+)$', catstring
).groups();
3983 catlist
= {'fnumfiles': fnumfiles
, 'fformat': catversions
[0], 'fversion': catversions
[1], 'fformatspecs': formatspecs
, 'fchecksumtype': fprechecksumtype
, 'fheaderchecksum': fprechecksum
, 'ffilelist': {}};
3984 if(seekto
>=fnumfiles
):
3985 seekto
= fnumfiles
- 1;
3991 prefhstart
= catfp
.tell();
3993 preheaderdata
= ReadFileHeaderDataBySize(catfp
, formatspecs
[5]);
3995 preheaderdata
= ReadFileHeaderDataWoSize(catfp
, formatspecs
[5]);
3996 if(len(preheaderdata
)==0):
3998 prefheadsize
= int(preheaderdata
[0], 16);
3999 prefnumfields
= int(preheaderdata
[1], 16);
4000 preftype
= int(preheaderdata
[2], 16);
4001 if(re
.findall("^[.|/]", preheaderdata
[3])):
4002 prefname
= preheaderdata
[3];
4004 prefname
= "./"+preheaderdata
[3];
4005 prefbasedir
= os
.path
.dirname(prefname
);
4006 preflinkname
= preheaderdata
[4];
4007 prefsize
= int(preheaderdata
[5], 16);
4008 prefatime
= int(preheaderdata
[6], 16);
4009 prefmtime
= int(preheaderdata
[7], 16);
4010 prefctime
= int(preheaderdata
[8], 16);
4011 prefbtime
= int(preheaderdata
[9], 16);
4012 prefmode
= int(preheaderdata
[10], 16);
4013 prefchmode
= stat
.S_IMODE(prefmode
);
4014 preftypemod
= stat
.S_IFMT(prefmode
);
4015 prefwinattributes
= int(preheaderdata
[11], 16);
4016 prefuid
= int(preheaderdata
[12], 16);
4017 prefuname
= preheaderdata
[13];
4018 prefgid
= int(preheaderdata
[14], 16);
4019 prefgname
= preheaderdata
[15];
4020 fid
= int(preheaderdata
[16], 16);
4021 finode
= int(preheaderdata
[17], 16);
4022 flinkcount
= int(preheaderdata
[18], 16);
4023 prefdev_minor
= int(preheaderdata
[19], 16);
4024 prefdev_major
= int(preheaderdata
[20], 16);
4025 prefrdev_minor
= int(preheaderdata
[22], 16);
4026 prefrdev_major
= int(preheaderdata
[23], 16);
4027 prefextrasize
= int(preheaderdata
[24], 16);
4028 prefextrafields
= int(preheaderdata
[25], 16);
4029 extrafieldslist
= [];
4031 extraend
= extrastart
+ prefextrafields
;
4032 extrafieldslist
= [];
4033 if(extrastart
<extraend
):
4034 extrafieldslist
.append(preheaderdata
[extrastart
]);
4035 extrastart
= extrastart
+ 1;
4036 prefchecksumtype
= preheaderdata
[extrastart
].lower();
4037 prefcs
= preheaderdata
[extrastart
+ 1].lower();
4038 prefccs
= preheaderdata
[extrastart
+ 2].lower();
4040 hcmax
= len(preheaderdata
) - 2;
4043 hout
= hout
+ AppendNullByte(preheaderdata
[hc
], formatspecs
[5]);
4045 prenewfcs
= GetFileChecksum(hout
, preheaderdata
[-3].lower(), True, formatspecs
);
4046 if(prefcs
!=prenewfcs
and not skipchecksum
):
4047 VerbosePrintOut("File Header Checksum Error with file " + prefname
+ " at offset " + str(prefhstart
));
4049 valid_archive
= False;
4050 invalid_archive
= True;
4051 prefhend
= catfp
.tell() - 1;
4052 prefcontentstart
= catfp
.tell();
4054 pyhascontents
= False;
4056 prefcontents
= catfp
.read(prefsize
);
4057 prenewfccs
= GetFileChecksum(prefcontents
, preheaderdata
[-3].lower(), False, formatspecs
);
4058 pyhascontents
= True;
4059 if(prefccs
!=prenewfccs
and not skipchecksum
):
4060 VerbosePrintOut("File Content Checksum Error with file " + prefname
+ " at offset " + str(prefcontentstart
));
4064 catfp
.seek(seekstart
, 0);
4066 catfheadsize
= int(preheaderdata
[0], 16);
4067 catfnumfields
= int(preheaderdata
[1], 16);
4068 catftype
= int(preheaderdata
[2], 16);
4069 if(re
.findall("^[.|/]", preheaderdata
[3])):
4070 catfname
= preheaderdata
[3];
4072 catfname
= "./"+preheaderdata
[3];
4073 catflinkname
= preheaderdata
[4];
4074 catfsize
= int(preheaderdata
[5], 16);
4075 catfbasedir
= os
.path
.dirname(catfname
);
4076 catlist
= {'fid': fileidnum
, 'foffset': catfp
.tell(), 'ftype': catftype
, 'fname': catfname
, 'fbasedir': catfbasedir
, 'flinkname': catflinkname
, 'fsize': catfsize
};
4078 catlist
.update({'catfp': catfp
});
4083 create_alias_function("", __file_format_name__
, "SeekToFileNum", ArchiveFileSeekToFileNum
);
4085 def ArchiveFileSeekToFileName(infile
, seekfile
=None, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
4086 if(hasattr(infile
, "read") or hasattr(infile
, "write")):
4089 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
4090 checkcompressfile
= CheckCompressionSubType(catfp
, formatspecs
, True);
4091 if(checkcompressfile
=="tarfile"):
4092 return TarFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
4093 if(checkcompressfile
=="zipfile"):
4094 return ZipFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
4095 if(rarfile_support
and checkcompressfile
=="rarfile"):
4096 return RarFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
4097 if(py7zr_support
and checkcompressfile
=="7zipfile"):
4098 return SevenZipFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
4099 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[2]):
4106 if(hasattr(sys
.stdin
, "buffer")):
4107 shutil
.copyfileobj(sys
.stdin
.buffer, catfp
);
4109 shutil
.copyfileobj(sys
.stdin
, catfp
);
4111 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
4115 elif(re
.findall(r
"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile
))):
4116 catfp
= download_file_from_internet_file(infile
);
4117 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
4123 infile
= RemoveWindowsPath(infile
);
4124 checkcompressfile
= CheckCompressionSubType(infile
, formatspecs
, True);
4125 if(checkcompressfile
=="tarfile"):
4126 return TarFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
4127 if(checkcompressfile
=="zipfile"):
4128 return ZipFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
4129 if(rarfile_support
and checkcompressfile
=="rarfile"):
4130 return RarFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
4131 if(py7zr_support
and checkcompressfile
=="7zipfile"):
4132 return SevenZipFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
4133 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[2]):
4135 compresscheck
= CheckCompressionType(infile
, formatspecs
, True);
4136 if(not compresscheck
):
4137 fextname
= os
.path
.splitext(infile
)[1];
4138 if(fextname
==".gz"):
4139 compresscheck
= "gzip";
4140 elif(fextname
==".bz2"):
4141 compresscheck
= "bzip2";
4142 elif(fextname
==".zst"):
4143 compresscheck
= "zstd";
4144 elif(fextname
==".lz4" or fextname
==".clz4"):
4145 compresscheck
= "lz4";
4146 elif(fextname
==".lzo" or fextname
==".lzop"):
4147 compresscheck
= "lzo";
4148 elif(fextname
==".lzma" or fextname
==".xz"):
4149 compresscheck
= "lzma";
4152 if(not compresscheck
):
4154 catfp
= UncompressFile(infile
, formatspecs
, "rb");
4159 SeekToEndOfFile(catfp);
4161 SeekToEndOfFile(catfp);
4162 CatSize = catfp.tell();
4163 CatSizeEnd = CatSize;
4171 curloc
= catfp
.tell();
4174 catheader
= ReadFileHeaderData(catfp
, 4, formatspecs
[5]);
4176 catfp
.seek(curloc
, 0);
4177 catstring
= catheader
[0];
4178 catversion
= re
.findall(r
"([\d]+)$", catstring
);
4179 fprenumfiles
= catheader
[1];
4180 fnumfiles
= int(fprenumfiles
, 16);
4181 fprechecksumtype
= catheader
[2];
4182 fprechecksum
= catheader
[3];
4183 fileheader
= AppendNullByte(catstring
, formatspecs
[5]);
4184 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
4185 fileheader
= fileheader
+ AppendNullBytes([fnumfileshex
, fprechecksumtype
], formatspecs
[5]);
4186 if(fprechecksumtype
=="none" or fprechecksumtype
==""):
4187 catfileheadercshex
= format(0, 'x').lower();
4188 elif(fprechecksumtype
=="crc16" or fprechecksumtype
=="crc16_ansi" or fprechecksumtype
=="crc16_ibm"):
4189 catfileheadercshex
= format(crc16(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
4190 elif(fprechecksumtype
=="crc16_ccitt"):
4191 catfileheadercshex
= format(crc16_ccitt(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
4192 elif(fprechecksumtype
=="adler32"):
4193 catfileheadercshex
= format(zlib
.adler32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
4194 elif(fprechecksumtype
=="crc32"):
4195 catfileheadercshex
= format(crc32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
4196 elif(fprechecksumtype
=="crc64_ecma"):
4197 catfileheadercshex
= format(crc64_ecma(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4198 elif(fprechecksumtype
=="crc64" or fprechecksumtype
=="crc64_iso"):
4199 catfileheadercshex
= format(crc64_iso(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4200 elif(CheckSumSupportAlt(fprechecksumtype
, hashlib_guaranteed
)):
4201 checksumoutstr
= hashlib
.new(fprechecksumtype
);
4202 checksumoutstr
.update(fileheader
.encode('UTF-8'));
4203 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
4205 catfileheadercshex
= format(0, 'x').lower();
4206 fileheader
= fileheader
+ AppendNullByte(catfileheadercshex
, formatspecs
[5]);
4207 fheadtell
= len(fileheader
);
4208 if(fprechecksum
!=catfileheadercshex
and not skipchecksum
):
4209 VerbosePrintOut("File Header Checksum Error with file " + infile
+ " at offset " + str(0));
4211 catversions
= re
.search(r
'(.*?)(\d+)$', catstring
).groups();
4212 catlist
= {'fnumfiles': fnumfiles
, 'fformat': catversions
[0], 'fversion': catversions
[1], 'fformatspecs': formatspecs
, 'fchecksumtype': fprechecksumtype
, 'fheaderchecksum': fprechecksum
, 'ffilelist': {}};
4213 seekto
= fnumfiles
- 1
4218 prefhstart
= catfp
.tell();
4220 preheaderdata
= ReadFileHeaderDataBySize(catfp
, formatspecs
[5]);
4222 preheaderdata
= ReadFileHeaderDataWoSize(catfp
, formatspecs
[5]);
4223 if(len(preheaderdata
)==0):
4225 prefheadsize
= int(preheaderdata
[0], 16);
4226 prefnumfields
= int(preheaderdata
[1], 16);
4227 preftype
= int(preheaderdata
[2], 16);
4228 if(re
.findall("^[.|/]", preheaderdata
[3])):
4229 prefname
= preheaderdata
[3];
4231 prefname
= "./"+preheaderdata
[3];
4232 prefbasedir
= os
.path
.dirname(prefname
);
4233 preflinkname
= preheaderdata
[4];
4234 prefsize
= int(preheaderdata
[5], 16);
4235 prefatime
= int(preheaderdata
[6], 16);
4236 prefmtime
= int(preheaderdata
[7], 16);
4237 prefctime
= int(preheaderdata
[8], 16);
4238 prefbtime
= int(preheaderdata
[9], 16);
4239 prefmode
= int(preheaderdata
[10], 16);
4240 prefchmode
= stat
.S_IMODE(prefmode
);
4241 preftypemod
= stat
.S_IFMT(prefmode
);
4242 prefwinattributes
= int(preheaderdata
[11], 16);
4243 prefuid
= int(preheaderdata
[12], 16);
4244 prefuname
= preheaderdata
[13];
4245 prefgid
= int(preheaderdata
[14], 16);
4246 prefgname
= preheaderdata
[15];
4247 fid
= int(preheaderdata
[16], 16);
4248 finode
= int(preheaderdata
[17], 16);
4249 flinkcount
= int(preheaderdata
[18], 16);
4250 prefdev_minor
= int(preheaderdata
[19], 16);
4251 prefdev_major
= int(preheaderdata
[20], 16);
4252 prefrdev_minor
= int(preheaderdata
[22], 16);
4253 prefrdev_major
= int(preheaderdata
[23], 16);
4254 prefextrasize
= int(preheaderdata
[24], 16);
4255 prefextrafields
= int(preheaderdata
[25], 16);
4256 extrafieldslist
= [];
4258 extraend
= extrastart
+ prefextrafields
;
4259 extrafieldslist
= [];
4260 if(extrastart
<extraend
):
4261 extrafieldslist
.append(preheaderdata
[extrastart
]);
4262 extrastart
= extrastart
+ 1;
4263 prefchecksumtype
= preheaderdata
[extrastart
].lower();
4264 prefcs
= preheaderdata
[extrastart
+ 1].lower();
4265 prefccs
= preheaderdata
[extrastart
+ 2].lower();
4267 hcmax
= len(preheaderdata
) - 2;
4270 hout
= hout
+ AppendNullByte(preheaderdata
[hc
], formatspecs
[5]);
4272 prenewfcs
= GetFileChecksum(hout
, preheaderdata
[-3].lower(), True, formatspecs
);
4273 if(prefcs
!=prenewfcs
and not skipchecksum
):
4274 VerbosePrintOut("File Header Checksum Error with file " + prefname
+ " at offset " + str(prefhstart
));
4276 valid_archive
= False;
4277 invalid_archive
= True;
4278 prefhend
= catfp
.tell() - 1;
4279 prefcontentstart
= catfp
.tell();
4281 pyhascontents
= False;
4283 prefcontents
= catfp
.read(prefsize
);
4284 prenewfccs
= GetFileChecksum(prefcontents
, preheaderdata
[-3].lower(), False, formatspecs
);
4285 pyhascontents
= True;
4286 if(prefccs
!=prenewfccs
and not skipchecksum
):
4287 VerbosePrintOut("File Content Checksum Error with file " + prefname
+ " at offset " + str(prefcontentstart
));
4292 prefname
= preheaderdata
[2];
4293 if(re
.findall("^[.|/]", preheaderdata
[2])):
4294 prefname
= preheaderdata
[2];
4296 prefname
= "./"+preheaderdata
[2];
4297 if(prefname
==seekfile
):
4300 catfp
.seek(seekstart
, 0);
4302 catfheadsize
= int(preheaderdata
[0], 16);
4303 catfnumfields
= int(preheaderdata
[1], 16);
4304 catftype
= int(preheaderdata
[2], 16);
4305 if(re
.findall("^[.|/]", preheaderdata
[3])):
4306 catfname
= preheaderdata
[3];
4308 catfname
= "./"+preheaderdata
[3];
4309 catflinkname
= preheaderdata
[4];
4310 catfsize
= int(preheaderdata
[5], 16);
4311 catfbasedir
= os
.path
.dirname(catfname
);
4313 catlist
= {'fid': fileidnum
, 'foffset': catfp
.tell(), 'ftype': catftype
, 'fname': catfname
, 'fbasedir': catfbasedir
, 'flinkname': catflinkname
, 'fsize': catfsize
};
4317 catlist
.update({'catfp': catfp
});
4322 create_alias_function("", __file_format_name__
, "SeekToFileName", ArchiveFileSeekToFileName
);
4324 def ArchiveFileValidate(infile
, formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
4326 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
4327 if(hasattr(infile
, "read") or hasattr(infile
, "write")):
4330 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
4331 checkcompressfile
= CheckCompressionSubType(catfp
, formatspecs
, True);
4332 if(checkcompressfile
=="tarfile"):
4333 return TarFileToArray(infile
, 0, 0, False, False, formatspecs
, returnfp
);
4334 if(checkcompressfile
=="zipfile"):
4335 return ZipFileToArray(infile
, 0, 0, False, False, formatspecs
, returnfp
);
4336 if(rarfile_support
and checkcompressfile
=="rarfile"):
4337 return RarFileToArray(infile
, 0, 0, False, False, formatspecs
, returnfp
);
4338 if(py7zr_support
and checkcompressfile
=="7zipfile"):
4339 return SevenZipFileToArray(infile
, 0, 0, False, False, formatspecs
, returnfp
);
4340 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[2]):
4347 if(hasattr(sys
.stdin
, "buffer")):
4348 shutil
.copyfileobj(sys
.stdin
.buffer, catfp
);
4350 shutil
.copyfileobj(sys
.stdin
, catfp
);
4352 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
4356 elif(re
.findall(r
"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile
))):
4357 catfp
= download_file_from_internet_file(infile
);
4358 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
4364 infile
= RemoveWindowsPath(infile
);
4365 checkcompressfile
= CheckCompressionSubType(infile
, formatspecs
, True);
4366 if(checkcompressfile
=="tarfile"):
4367 return TarFileToArray(infile
, 0, 0, False, False, formatspecs
, returnfp
);
4368 if(checkcompressfile
=="zipfile"):
4369 return ZipFileToArray(infile
, 0, 0, False, False, formatspecs
, returnfp
);
4370 if(rarfile_support
and checkcompressfile
=="rarfile"):
4371 return RarFileToArray(infile
, 0, 0, False, False, formatspecs
, returnfp
);
4372 if(py7zr_support
and checkcompressfile
=="7zipfile"):
4373 return SevenZipFileToArray(infile
, 0, 0, False, False, formatspecs
, returnfp
);
4374 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[2]):
4376 compresscheck
= CheckCompressionType(infile
, formatspecs
, True);
4377 if(not compresscheck
):
4378 fextname
= os
.path
.splitext(infile
)[1];
4379 if(fextname
==".gz"):
4380 compresscheck
= "gzip";
4381 elif(fextname
==".bz2"):
4382 compresscheck
= "bzip2";
4383 elif(fextname
==".zst"):
4384 compresscheck
= "zstd";
4385 elif(fextname
==".lz4" or fextname
==".clz4"):
4386 compresscheck
= "lz4";
4387 elif(fextname
==".lzo" or fextname
==".lzop"):
4388 compresscheck
= "lzo";
4389 elif(fextname
==".lzma" or fextname
==".xz"):
4390 compresscheck
= "lzma";
4393 if(not compresscheck
):
4395 catfp
= UncompressFile(infile
, formatspecs
, "rb");
4400 SeekToEndOfFile(catfp);
4402 SeekToEndOfFile(catfp);
4403 CatSize = catfp.tell();
4404 CatSizeEnd = CatSize;
4412 curloc
= catfp
.tell();
4415 catheader
= ReadFileHeaderData(catfp
, 4, formatspecs
[5]);
4417 catfp
.seek(curloc
, 0);
4418 catstring
= catheader
[0];
4419 catversion
= re
.findall(r
"([\d]+)$", catstring
);
4420 fprenumfiles
= catheader
[1];
4421 fnumfiles
= int(fprenumfiles
, 16);
4422 fprechecksumtype
= catheader
[2];
4423 fprechecksum
= catheader
[3];
4425 fileheader
= AppendNullByte(catstring
, formatspecs
[5]);
4426 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
4427 fileheader
= fileheader
+ AppendNullBytes([fnumfileshex
, fprechecksumtype
], formatspecs
[5]);
4428 if(fprechecksumtype
=="none" or fprechecksumtype
==""):
4429 catfileheadercshex
= format(0, 'x').lower();
4430 elif(fprechecksumtype
=="crc16" or fprechecksumtype
=="crc16_ansi" or fprechecksumtype
=="crc16_ibm"):
4431 catfileheadercshex
= format(crc16(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
4432 elif(fprechecksumtype
=="crc16_ccitt"):
4433 catfileheadercshex
= format(crc16_ccitt(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
4434 elif(fprechecksumtype
=="adler32"):
4435 catfileheadercshex
= format(zlib
.adler32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
4436 elif(fprechecksumtype
=="crc32"):
4437 catfileheadercshex
= format(crc32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
4438 elif(fprechecksumtype
=="crc64_ecma"):
4439 catfileheadercshex
= format(crc64_ecma(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4440 elif(fprechecksumtype
=="crc64" or fprechecksumtype
=="crc64_iso"):
4441 catfileheadercshex
= format(crc64_iso(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4442 elif(CheckSumSupportAlt(fprechecksumtype
, hashlib_guaranteed
)):
4443 checksumoutstr
= hashlib
.new(fprechecksumtype
);
4444 checksumoutstr
.update(fileheader
.encode('UTF-8'));
4445 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
4447 catfileheadercshex
= format(0, 'x').lower();
4448 fileheader
= fileheader
+ AppendNullByte(catfileheadercshex
, formatspecs
[5]);
4449 valid_archive
= True;
4450 invalid_archive
= False;
4452 VerbosePrintOut(infile
);
4453 VerbosePrintOut("Number of Records " + str(fnumfiles
));
4454 if(fprechecksum
==catfileheadercshex
):
4456 VerbosePrintOut("File Header Checksum Passed at offset " + str(0));
4459 VerbosePrintOut("File Header Checksum Failed at offset " + str(0));
4460 valid_archive
= False;
4461 invalid_archive
= True;
4463 VerbosePrintOut("");
4464 while(il
<fnumfiles
):
4465 catfhstart
= catfp
.tell();
4467 catheaderdata
= ReadFileHeaderDataBySize(catfp
, formatspecs
[5]);
4469 catheaderdata
= ReadFileHeaderDataWoSize(catfp
, formatspecs
[5]);
4470 if(len(catheaderdata
)==0):
4472 catfheadsize
= int(catheaderdata
[0], 16);
4473 catfnumfields
= int(catheaderdata
[1], 16);
4474 catftype
= int(catheaderdata
[2], 16);
4475 if(re
.findall("^[.|/]", catheaderdata
[3])):
4476 catfname
= catheaderdata
[3];
4478 catfname
= "./"+catheaderdata
[3];
4479 catfbasedir
= os
.path
.dirname(catfname
);
4480 catflinkname
= catheaderdata
[4];
4481 catfsize
= int(catheaderdata
[5], 16);
4482 catfatime
= int(catheaderdata
[6], 16);
4483 catfmtime
= int(catheaderdata
[7], 16);
4484 catfctime
= int(catheaderdata
[8], 16);
4485 catfbtime
= int(catheaderdata
[9], 16);
4486 catfmode
= int(catheaderdata
[10], 16);
4487 catfchmode
= stat
.S_IMODE(catfmode
);
4488 catftypemod
= stat
.S_IFMT(catfmode
);
4489 prefwinattributes
= int(catheaderdata
[11], 16);
4490 catfuid
= int(catheaderdata
[12], 16);
4491 catfuname
= catheaderdata
[13];
4492 catfgid
= int(catheaderdata
[14], 16);
4493 catfgname
= catheaderdata
[15];
4494 fid
= int(catheaderdata
[16], 16);
4495 finode
= int(catheaderdata
[17], 16);
4496 flinkcount
= int(catheaderdata
[18], 16);
4497 catfdev_minor
= int(catheaderdata
[19], 16);
4498 catfdev_major
= int(catheaderdata
[20], 16);
4499 catfrdev_minor
= int(catheaderdata
[21], 16);
4500 catfrdev_major
= int(catheaderdata
[22], 16);
4501 catfextrasize
= int(catheaderdata
[23], 16);
4502 catfextrafields
= int(catheaderdata
[24], 16);
4503 extrafieldslist
= [];
4505 extraend
= extrastart
+ catfextrafields
;
4506 extrafieldslist
= [];
4507 if(extrastart
<extraend
):
4508 extrafieldslist
.append(catheaderdata
[extrastart
]);
4509 extrastart
= extrastart
+ 1;
4510 catfchecksumtype
= catheaderdata
[extrastart
].lower();
4511 catfcs
= catheaderdata
[extrastart
+ 1].lower();
4512 catfccs
= catheaderdata
[extrastart
+ 2].lower();
4514 hcmax
= len(catheaderdata
) - 2;
4517 hout
= hout
+ AppendNullByte(catheaderdata
[hc
], formatspecs
[5]);
4519 catnewfcs
= GetFileChecksum(hout
, catheaderdata
[-3].lower(), True, formatspecs
);
4521 VerbosePrintOut(catfname
);
4522 VerbosePrintOut("Record Number " + str(il
) + "; File ID " + str(fid
) + "; iNode Number " + str(finode
));
4523 if(catfcs
==catnewfcs
):
4525 VerbosePrintOut("File Header Checksum Passed at offset " + str(catfhstart
));
4528 VerbosePrintOut("File Header Checksum Failed at offset " + str(catfhstart
));
4529 valid_archive
= False;
4530 invalid_archive
= True;
4531 catfhend
= catfp
.tell() - 1;
4532 catfcontentstart
= catfp
.tell();
4534 pyhascontents
= False;
4536 catfcontents
= catfp
.read(catfsize
);
4537 catnewfccs
= GetFileChecksum(catfcontents
, catheaderdata
[-3].lower(), False, formatspecs
);
4538 pyhascontents
= True;
4539 if(catfccs
==catnewfccs
):
4541 VerbosePrintOut("File Content Checksum Passed at offset " + str(catfcontentstart
));
4544 VerbosePrintOut("File Content Checksum Failed at offset " + str(catfcontentstart
));
4545 valid_archive
= False;
4546 invalid_archive
= True;
4548 VerbosePrintOut("");
4561 create_alias_function("", __file_format_name__
, "Validate", ArchiveFileValidate
);
4563 def ArchiveFileToArray(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
4564 if(hasattr(infile
, "read") or hasattr(infile
, "write")):
4567 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
4568 checkcompressfile
= CheckCompressionSubType(catfp
, formatspecs
, True);
4569 if(checkcompressfile
=="tarfile"):
4570 return TarFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4571 if(checkcompressfile
=="zipfile"):
4572 return ZipFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4573 if(rarfile_support
and checkcompressfile
=="rarfile"):
4574 return RarFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4575 if(py7zr_support
and checkcompressfile
=="7zipfile"):
4576 return SevenZipFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4577 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[2]):
4584 if(hasattr(sys
.stdin
, "buffer")):
4585 shutil
.copyfileobj(sys
.stdin
.buffer, catfp
);
4587 shutil
.copyfileobj(sys
.stdin
, catfp
);
4589 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
4593 elif(re
.findall(r
"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile
))):
4594 catfp
= download_file_from_internet_file(infile
);
4595 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
4601 infile
= RemoveWindowsPath(infile
);
4602 checkcompressfile
= CheckCompressionSubType(infile
, formatspecs
, True);
4603 if(checkcompressfile
=="tarfile"):
4604 return TarFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4605 if(checkcompressfile
=="zipfile"):
4606 return ZipFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4607 if(rarfile_support
and checkcompressfile
=="rarfile"):
4608 return RarFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4609 if(py7zr_support
and checkcompressfile
=="7zipfile"):
4610 return SevenZipFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4611 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[2]):
4613 compresscheck
= CheckCompressionType(infile
, formatspecs
, True);
4614 if(not compresscheck
):
4615 fextname
= os
.path
.splitext(infile
)[1];
4616 if(fextname
==".gz"):
4617 compresscheck
= "gzip";
4618 elif(fextname
==".bz2"):
4619 compresscheck
= "bzip2";
4620 elif(fextname
==".zst"):
4621 compresscheck
= "zstd";
4622 elif(fextname
==".lz4" or fextname
==".clz4"):
4623 compresscheck
= "lz4";
4624 elif(fextname
==".lzo" or fextname
==".lzop"):
4625 compresscheck
= "lzo";
4626 elif(fextname
==".lzma" or fextname
==".xz"):
4627 compresscheck
= "lzma";
4630 if(not compresscheck
):
4632 catfp
= UncompressFile(infile
, formatspecs
, "rb");
4637 SeekToEndOfFile(catfp);
4639 SeekToEndOfFile(catfp);
4640 CatSize = catfp.tell();
4641 CatSizeEnd = CatSize;
4649 curloc
= catfp
.tell();
4652 catheader
= ReadFileHeaderData(catfp
, 4, formatspecs
[5]);
4654 catfp
.seek(curloc
, 0);
4655 catstring
= catheader
[0];
4656 catversion
= re
.findall(r
"([\d]+)$", catstring
);
4657 fprenumfiles
= catheader
[1];
4658 fnumfiles
= int(fprenumfiles
, 16);
4659 fprechecksumtype
= catheader
[2];
4660 fprechecksum
= catheader
[3];
4661 fileheader
= AppendNullByte(catstring
, formatspecs
[5]);
4662 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
4663 fileheader
= fileheader
+ AppendNullBytes([fnumfileshex
, fprechecksumtype
], formatspecs
[5]);
4664 if(fprechecksumtype
=="none" or fprechecksumtype
==""):
4665 catfileheadercshex
= format(0, 'x').lower();
4666 elif(fprechecksumtype
=="crc16" or fprechecksumtype
=="crc16_ansi" or fprechecksumtype
=="crc16_ibm"):
4667 catfileheadercshex
= format(crc16(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
4668 elif(fprechecksumtype
=="crc16_ccitt"):
4669 catfileheadercshex
= format(crc16_ccitt(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
4670 elif(fprechecksumtype
=="adler32"):
4671 catfileheadercshex
= format(zlib
.adler32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
4672 elif(fprechecksumtype
=="crc32"):
4673 catfileheadercshex
= format(crc32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
4674 elif(fprechecksumtype
=="crc64_ecma"):
4675 catfileheadercshex
= format(crc64_ecma(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4676 elif(fprechecksumtype
=="crc64" or fprechecksumtype
=="crc64_iso"):
4677 catfileheadercshex
= format(crc64_iso(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4678 elif(CheckSumSupportAlt(fprechecksumtype
, hashlib_guaranteed
)):
4679 checksumoutstr
= hashlib
.new(fprechecksumtype
);
4680 checksumoutstr
.update(fileheader
.encode('UTF-8'));
4681 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
4683 catfileheadercshex
= format(0, 'x').lower();
4684 fileheader
= fileheader
+ AppendNullByte(catfileheadercshex
, formatspecs
[5]);
4685 fheadtell
= len(fileheader
);
4686 if(fprechecksum
!=catfileheadercshex
and not skipchecksum
):
4687 VerbosePrintOut("File Header Checksum Error with file " + infile
+ " at offset " + str(0));
4689 catversions
= re
.search(r
'(.*?)(\d+)$', catstring
).groups();
4690 catlist
= {'fnumfiles': fnumfiles
, 'fformat': catversions
[0], 'fversion': catversions
[1], 'fformatspecs': formatspecs
, 'fchecksumtype': fprechecksumtype
, 'fheaderchecksum': fprechecksum
, 'ffilelist': {}};
4691 if(seekstart
<0 and seekstart
>fnumfiles
):
4693 if(seekend
==0 or seekend
>fnumfiles
and seekend
<seekstart
):
4694 seekend
= fnumfiles
;
4695 elif(seekend
<0 and abs(seekend
)<=fnumfiles
and abs(seekend
)>=seekstart
):
4696 seekend
= fnumfiles
- abs(seekend
);
4699 while(il
< seekstart
):
4700 prefhstart
= catfp
.tell();
4702 preheaderdata
= ReadFileHeaderDataBySize(catfp
, formatspecs
[5]);
4704 preheaderdata
= ReadFileHeaderDataWoSize(catfp
, formatspecs
[5]);
4705 if(len(preheaderdata
)==0):
4707 prefheadsize
= int(preheaderdata
[0], 16);
4708 prefnumfields
= int(preheaderdata
[1], 16);
4709 if(re
.findall("^[.|/]", preheaderdata
[3])):
4710 prefname
= preheaderdata
[3];
4712 prefname
= "./"+preheaderdata
[3];
4713 prefsize
= int(preheaderdata
[5], 16);
4714 prefextrasize
= int(preheaderdata
[23], 16);
4715 prefextrafields
= int(preheaderdata
[24], 16);
4716 extrafieldslist
= [];
4718 extraend
= extrastart
+ prefextrafields
;
4719 extrafieldslist
= [];
4720 if(extrastart
<extraend
):
4721 extrafieldslist
.append(preheaderdata
[extrastart
]);
4722 extrastart
= extrastart
+ 1;
4723 prefchecksumtype
= preheaderdata
[extrastart
].lower();
4724 prefcs
= preheaderdata
[extrastart
+ 1].lower();
4725 prefccs
= preheaderdata
[extrastart
+ 2].lower();
4727 hcmax
= len(preheaderdata
) - 2;
4730 hout
= hout
+ AppendNullByte(preheaderdata
[hc
], formatspecs
[5]);
4732 prenewfcs
= GetFileChecksum(hout
, preheaderdata
[-3].lower(), True, formatspecs
);
4733 if(prefcs
!=prenewfcs
and not skipchecksum
):
4734 VerbosePrintOut("File Header Checksum Error with file " + prefname
+ " at offset " + str(prefhstart
));
4736 valid_archive
= False;
4737 invalid_archive
= True;
4738 prefhend
= catfp
.tell() - 1;
4739 prefcontentstart
= catfp
.tell();
4741 pyhascontents
= False;
4743 prefcontents
= catfp
.read(prefsize
);
4744 prenewfccs
= GetFileChecksum(prefcontents
, preheaderdata
[-3].lower(), False, formatspecs
);
4745 pyhascontents
= True;
4746 if(prefccs
!=prenewfccs
and not skipchecksum
):
4747 VerbosePrintOut("File Content Checksum Error with file " + prefname
+ " at offset " + str(prefcontentstart
));
4751 fileidnum
= seekstart
;
4753 while(fileidnum
<seekend
):
4754 catfhstart
= catfp
.tell();
4756 catheaderdata
= ReadFileHeaderDataBySize(catfp
, formatspecs
[5]);
4758 catheaderdata
= ReadFileHeaderDataWoSize(catfp
, formatspecs
[5]);
4759 if(len(catheaderdata
)==0):
4761 catfheadsize
= int(catheaderdata
[0], 16);
4762 catfnumfields
= int(catheaderdata
[1], 16);
4763 catftype
= int(catheaderdata
[2], 16);
4764 if(re
.findall("^[.|/]", catheaderdata
[3])):
4765 catfname
= catheaderdata
[3];
4767 catfname
= "./"+catheaderdata
[3];
4768 catfbasedir
= os
.path
.dirname(catfname
);
4769 catflinkname
= catheaderdata
[4];
4770 catfsize
= int(catheaderdata
[5], 16);
4771 catfatime
= int(catheaderdata
[6], 16);
4772 catfmtime
= int(catheaderdata
[7], 16);
4773 catfctime
= int(catheaderdata
[8], 16);
4774 catfbtime
= int(catheaderdata
[9], 16);
4775 catfmode
= int(catheaderdata
[10], 16);
4776 catfchmode
= stat
.S_IMODE(catfmode
);
4777 catftypemod
= stat
.S_IFMT(catfmode
);
4778 catfwinattributes
= int(catheaderdata
[11], 16);
4779 catfuid
= int(catheaderdata
[12], 16);
4780 catfuname
= catheaderdata
[13];
4781 catfgid
= int(catheaderdata
[14], 16);
4782 catfgname
= catheaderdata
[15];
4783 fid
= int(catheaderdata
[16], 16);
4784 finode
= int(catheaderdata
[17], 16);
4785 flinkcount
= int(catheaderdata
[18], 16);
4786 catfdev_minor
= int(catheaderdata
[19], 16);
4787 catfdev_major
= int(catheaderdata
[20], 16);
4788 catfrdev_minor
= int(catheaderdata
[21], 16);
4789 catfrdev_major
= int(catheaderdata
[22], 16);
4790 catfextrasize
= int(catheaderdata
[23], 16);
4791 catfextrafields
= int(catheaderdata
[24], 16);
4792 extrafieldslist
= [];
4794 extraend
= extrastart
+ catfextrafields
;
4795 extrafieldslist
= [];
4796 if(extrastart
<extraend
):
4797 extrafieldslist
.append(catheaderdata
[extrastart
]);
4798 extrastart
= extrastart
+ 1;
4799 catfchecksumtype
= catheaderdata
[extrastart
].lower();
4800 catfcs
= catheaderdata
[extrastart
+ 1].lower();
4801 catfccs
= catheaderdata
[extrastart
+ 2].lower();
4803 hcmax
= len(catheaderdata
) - 2;
4806 hout
= hout
+ AppendNullByte(catheaderdata
[hc
], formatspecs
[5]);
4808 catnewfcs
= GetFileChecksum(hout
, catheaderdata
[-3].lower(), True, formatspecs
);
4809 if(catfcs
!=catnewfcs
and not skipchecksum
):
4810 VerbosePrintOut("File Header Checksum Error with file " + catfname
+ " at offset " + str(catfhstart
));
4812 catfhend
= catfp
.tell() - 1;
4813 catfcontentstart
= catfp
.tell();
4815 pyhascontents
= False;
4816 if(catfsize
>0 and not listonly
):
4817 catfcontents
= catfp
.read(catfsize
);
4818 catnewfccs
= GetFileChecksum(catfcontents
, catheaderdata
[-3].lower(), False, formatspecs
);
4819 pyhascontents
= True;
4820 if(catfccs
!=catnewfccs
and skipchecksum
):
4821 VerbosePrintOut("File Content Checksum Error with file " + catfname
+ " at offset " + str(catfcontentstart
));
4823 if(catfsize
>0 and listonly
):
4824 catfp
.seek(catfsize
, 1);
4825 pyhascontents
= False;
4827 catfcontentend
= catfp
.tell() - 1;
4828 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
, 'fwinattributes': catfwinattributes
, '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
+ 2, 'frawheader': catheaderdata
, 'fextrafields': catfextrafields
, 'fextrafieldsize': catfextrasize
, 'fextralist': extrafieldslist
, 'fheaderchecksum': catfcs
, 'fcontentchecksum': catfccs
, 'fhascontents': pyhascontents
, 'fcontentstart': catfcontentstart
, 'fcontentend': catfcontentend
, 'fcontents': catfcontents
} });
4829 fileidnum
= fileidnum
+ 1;
4830 realidnum
= realidnum
+ 1;
4832 catlist
.update({'catfp': catfp
});
4837 create_alias_function("", __file_format_name__
, "ToArray", ArchiveFileToArray
);
4839 def ArchiveFileStringToArray(catstr
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
4840 catfp
= BytesIO(catstr
);
4841 listcatfiles
= ArchiveFileToArray(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4842 return listcatfiles
;
4844 create_alias_function("", __file_format_name__
, "StringToArray", ArchiveFileStringToArray
);
4846 def TarFileToArray(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
4848 catfp
= PackArchiveFileFromTarFile(infile
, catfp
, "auto", None, "crc32", [], formatspecs
, False, True);
4849 listcatfiles
= ArchiveFileToArray(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4850 return listcatfiles
;
4852 def ZipFileToArray(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
4854 catfp
= PackArchiveFileFromZipFile(infile
, catfp
, "auto", None, "crc32", [], formatspecs
, False, True);
4855 listcatfiles
= ArchiveFileToArray(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4856 return listcatfiles
;
4858 if(not rarfile_support
):
4859 def RarFileToArray(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
4862 if(rarfile_support
):
4863 def RarFileToArray(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
4865 catfp
= PackArchiveFileFromSevenZipFile(infile
, catfp
, "auto", None, "crc32", [], formatspecs
, False, True);
4866 listcatfiles
= ArchiveFileToArray(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4867 return listcatfiles
;
4869 if(not py7zr_support
):
4870 def SevenZipFileToArray(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
4874 def SevenZipFileToArray(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
4876 catfp
= PackArchiveFileFromSevenZipFile(infile
, catfp
, "auto", None, "crc32", [], formatspecs
, False, True);
4877 listcatfiles
= ArchiveFileToArray(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4878 return listcatfiles
;
4880 def InFileToArray(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
4881 checkcompressfile
= CheckCompressionSubType(infile
, formatspecs
, True);
4882 if(checkcompressfile
=="tarfile"):
4883 return TarFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4884 elif(checkcompressfile
=="zipfile"):
4885 return ZipFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4886 elif(checkcompressfile
=="catfile"):
4887 return ArchiveFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4888 elif(rarfile_support
and checkcompressfile
=="rarfile"):
4889 return RarFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4890 elif(py7zr_support
and checkcompressfile
=="7zipfile"):
4891 return SevenZipFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
4896 def ListDirToArrayAlt(infiles
, dirlistfromtxt
=False, followlink
=False, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
4897 catver
= formatspecs
[6];
4898 fileheaderver
= str(int(catver
.replace(".", "")));
4899 fileheader
= AppendNullByte(formatspecs
[1] + fileheaderver
, formatspecs
[5]);
4900 advancedlist
= formatspecs
[8];
4901 altinode
= formatspecs
[9];
4904 for line
in sys
.stdin
:
4905 infilelist
.append(line
.strip());
4906 infilelist
= list(filter(None, infilelist
));
4907 elif(infiles
!="-" and dirlistfromtxt
and os
.path
.exists(infiles
) and (os
.path
.isfile(infiles
) or infiles
=="/dev/null" or infiles
=="NUL")):
4908 if(not os
.path
.exists(infiles
) or not os
.path
.isfile(infiles
)):
4910 with
UncompressFile(infiles
, formatspecs
, "r") as finfile
:
4911 for line
in finfile
:
4912 infilelist
.append(line
.strip());
4913 infilelist
= list(filter(None, infilelist
));
4915 if(isinstance(infiles
, (list, tuple, ))):
4916 infilelist
= list(filter(None, infiles
));
4917 elif(isinstance(infiles
, (str, ))):
4918 infilelist
= list(filter(None, [infiles
]));
4920 GetDirList
= ListDirAdvanced(infilelist
, followlink
, False);
4922 GetDirList
= ListDir(infilelist
, followlink
, False);
4930 inodetocatinode
= {};
4932 fnumfiles
= int(len(GetDirList
));
4933 catver
= formatspecs
[6];
4934 fileheaderver
= str(int(catver
.replace(".", "")));
4935 fileheader
= AppendNullByte(formatspecs
[1] + fileheaderver
, formatspecs
[5]);
4936 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
4937 fileheader
= fileheader
+ AppendNullBytes([fnumfileshex
, checksumtype
], formatspecs
[5]);
4938 catversion
= re
.findall(r
"([\d]+)$", fileheader
);
4939 catversions
= re
.search(r
'(.*?)(\d+)$', catstring
).groups();
4940 if(checksumtype
=="none" or checksumtype
==""):
4941 catfileheadercshex
= format(0, 'x').lower();
4942 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
4943 catfileheadercshex
= format(crc16(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
4944 elif(checksumtype
=="crc16_ccitt"):
4945 catfileheadercshex
= format(crc16_ccitt(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
4946 elif(checksumtype
=="adler32"):
4947 catfileheadercshex
= format(zlib
.adler32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
4948 elif(checksumtype
=="crc32"):
4949 catfileheadercshex
= format(crc32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
4950 elif(checksumtype
=="crc64_ecma"):
4951 catfileheadercshex
= format(crc64_ecma(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4952 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
4953 catfileheadercshex
= format(crc64_iso(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4954 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
4955 checksumoutstr
= hashlib
.new(checksumtype
);
4956 checksumoutstr
.update(fileheader
.encode('UTF-8'));
4957 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
4959 catfileheadercshex
= format(0, 'x').lower();
4960 fileheader
= fileheader
+ AppendNullByte(catfileheadercshex
, formatspecs
[5]);
4961 fheadtell
= len(fileheader
);
4962 catlist
= {'fnumfiles': fnumfiles
, 'fformat': catversions
[0], 'fversion': catversions
[1], 'fformatspecs': formatspecs
, 'fchecksumtype': checksumtype
, 'fheaderchecksum': catfileheadercshex
, 'ffilelist': {}};
4963 for curfname
in GetDirList
:
4964 if(re
.findall("^[.|/]", curfname
)):
4967 fname
= "./"+curfname
;
4969 VerbosePrintOut(fname
);
4970 if(not followlink
or followlink
is None):
4971 fstatinfo
= os
.lstat(fname
);
4973 fstatinfo
= os
.stat(fname
);
4974 fpremode
= fstatinfo
.st_mode
;
4975 finode
= fstatinfo
.st_ino
;
4976 flinkcount
= fstatinfo
.st_nlink
;
4978 if(stat
.S_ISREG(fpremode
)):
4980 elif(stat
.S_ISLNK(fpremode
)):
4982 elif(stat
.S_ISCHR(fpremode
)):
4984 elif(stat
.S_ISBLK(fpremode
)):
4986 elif(stat
.S_ISDIR(fpremode
)):
4988 elif(stat
.S_ISFIFO(fpremode
)):
4990 elif(stat
.S_ISSOCK(fpremode
)):
4992 elif(hasattr(stat
, "S_ISDOOR") and stat
.S_ISDOOR(fpremode
)):
4994 elif(hasattr(stat
, "S_ISPORT") and stat
.S_ISPORT(fpremode
)):
4996 elif(hasattr(stat
, "S_ISWHT") and stat
.S_ISWHT(fpremode
)):
5001 fbasedir
= os
.path
.dirname(fname
);
5003 if(not followlink
and finode
!=0):
5005 if(finode
in inodelist
):
5007 flinkname
= inodetofile
[finode
];
5011 fcurinode
= inodetocatinode
[finode
];
5012 if(finode
not in inodelist
):
5013 inodelist
.append(finode
);
5014 inodetofile
.update({finode
: fname
});
5015 inodetocatinode
.update({finode
: curinode
});
5019 fcurinode
= curinode
;
5020 curinode
= curinode
+ 1;
5022 fcurinode
= curinode
;
5023 curinode
= curinode
+ 1;
5024 curfid
= curfid
+ 1;
5026 flinkname
= os
.readlink(fname
);
5027 fdev
= fstatinfo
.st_dev
;
5028 getfdev
= GetDevMajorMinor(fdev
);
5029 fdev_minor
= getfdev
[0];
5030 fdev_major
= getfdev
[1];
5031 frdev
= fstatinfo
.st_dev
;
5032 if(hasattr(fstatinfo
, "st_rdev")):
5033 frdev
= fstatinfo
.st_rdev
;
5035 frdev
= fstatinfo
.st_dev
;
5036 getfrdev
= GetDevMajorMinor(frdev
);
5037 frdev_minor
= getfrdev
[0];
5038 frdev_major
= getfrdev
[1];
5039 if(ftype
==1 or ftype
==2 or ftype
==3 or ftype
==4 or ftype
==5 or ftype
==6):
5041 if(ftype
==0 or ftype
==7):
5042 fsize
= fstatinfo
.st_size
;
5043 fatime
= fstatinfo
.st_atime
;
5044 fmtime
= fstatinfo
.st_mtime
;
5045 fctime
= fstatinfo
.st_ctime
;
5046 if(hasattr(fstatinfo
, "st_birthtime")):
5047 fbtime
= fstatinfo
.st_birthtime
;
5049 fbtime
= fstatinfo
.st_ctime
;
5050 fmode
= fstatinfo
.st_mode
;
5051 fchmode
= stat
.S_IMODE(fstatinfo
.st_mode
);
5052 ftypemod
= stat
.S_IFMT(fstatinfo
.st_mode
);
5053 fuid
= fstatinfo
.st_uid
;
5054 fgid
= fstatinfo
.st_gid
;
5059 userinfo
= pwd
.getpwuid(fstatinfo
.st_uid
);
5060 funame
= userinfo
.pw_name
;
5069 groupinfo
= grp
.getgrgid(fstatinfo
.st_gid
);
5070 fgname
= groupinfo
.gr_name
;
5075 fdev_minor
= fdev_minor
;
5076 fdev_major
= fdev_major
;
5077 frdev_minor
= frdev_minor
;
5078 frdev_major
= frdev_major
;
5080 flinkcount
= flinkcount
;
5081 if(hasattr(fstatinfo
, "st_file_attributes")):
5082 fwinattributes
= fstatinfo
.st_file_attributes
;
5085 fcontents
= "".encode('UTF-8');
5087 if(ftype
==0 or ftype
==7):
5088 with
open(fname
, "rb") as fpc
:
5090 chunk
= fpc
.read(chunk_size
);
5094 if(followlink
and (ftype
==1 or ftype
==2)):
5095 flstatinfo
= os
.stat(flinkname
);
5096 with
open(flinkname
, "rb") as fpc
:
5098 chunk
= fpc
.read(chunk_size
);
5102 ftypehex
= format(ftype
, 'x').lower();
5103 extrafields
= len(extradata
);
5104 extrafieldslist
= extradata
;
5105 catfextrafields
= extrafields
;
5106 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[5]);
5107 if(len(extradata
)>0):
5108 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[5]);
5109 extrasizelen
= len(extrasizestr
);
5110 extrasizelenhex
= format(extrasizelen
, 'x').lower();
5111 catoutlist
= [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(fwinattributes
), '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()];
5112 catoutlen
= len(catoutlist
) + len(extradata
) + 3;
5113 catoutlenhex
= format(catoutlen
, 'x').lower();
5114 catoutlist
.insert(0, catoutlenhex
);
5115 catfileoutstr
= AppendNullBytes(catoutlist
, formatspecs
[5]);
5116 if(len(extradata
)>0):
5117 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[5]);
5118 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[5]);
5119 catfnumfields
= catoutlen
;
5120 if(checksumtype
=="none" or checksumtype
==""):
5121 catfileheadercshex
= format(0, 'x').lower();
5122 catfilecontentcshex
= format(0, 'x').lower();
5123 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
5124 catfileheadercshex
= format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
5125 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
5126 elif(checksumtype
=="crc16_ccitt"):
5127 catfileheadercshex
= format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
5128 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
5129 elif(checksumtype
=="adler32"):
5130 catfileheadercshex
= format(zlib
.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5131 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
5132 elif(checksumtype
=="crc32"):
5133 catfileheadercshex
= format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5134 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
5135 elif(checksumtype
=="crc64_ecma"):
5136 catfileheadercshex
= format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5137 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
5138 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
5139 catfileheadercshex
= format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5140 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
5141 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
5142 checksumoutstr
= hashlib
.new(checksumtype
);
5143 checksumoutstr
.update("".encode('UTF-8'));
5144 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
5145 checksumoutstr
= hashlib
.new(checksumtype
);
5146 checksumoutstr
.update(fcontents
);
5147 catfilecontentcshex
= checksumoutstr
.hexdigest().lower();
5149 catfileheadercshex
= format(0, 'x').lower();
5150 catfilecontentcshex
= format(0, 'x').lower();
5151 catfhstart
= fheadtell
;
5152 fheadtell
+= len(catfileoutstr
);
5153 catfhend
= fheadtell
- 1;
5154 catfcontentstart
= fheadtell
;
5155 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
5156 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
5157 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[5]) + catfileoutstr
;
5158 catheaderdata
= [catheaersize
] + catoutlist
+ extradata
+ [checksumtype
, catfileheadercshex
, catfilecontentcshex
]
5159 if(checksumtype
=="none" or checksumtype
==""):
5160 catfileheadercshex
= format(0, 'x').lower();
5161 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
5162 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
5163 elif(checksumtype
=="crc16_ccitt"):
5164 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
5165 elif(checksumtype
=="adler32"):
5166 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
5167 elif(checksumtype
=="crc32"):
5168 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
5169 elif(checksumtype
=="crc64_ecma"):
5170 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5171 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
5172 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5173 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
5174 checksumoutstr
= hashlib
.new(checksumtype
);
5175 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
5176 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
5178 catfileheadercshex
= format(0, 'x').lower();
5179 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
5180 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
5181 nullstrecd
= formatspecs
[5].encode('UTF-8');
5182 fheadtell
+= len(catfileoutstr
) + 1;
5183 catfcontentend
= fheadtell
- 1;
5184 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
;
5185 pyhascontents
= False;
5186 if(int(fsize
)>0 and not listonly
):
5187 pyhascontents
= True;
5188 if(int(fsize
)>0 and listonly
):
5190 pyhascontents
= False;
5191 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
, 'fwinattributes': fwinattributes
, '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
+ 2, 'frawheader': catheaderdata
, 'fextrafields': catfextrafields
, 'fextrafieldsize': extrasizelen
, 'fextralist': extrafieldslist
, 'fheaderchecksum': int(catfileheadercshex
, 16), 'fcontentchecksum': int(catfilecontentcshex
, 16), 'fhascontents': pyhascontents
, 'fcontentstart': catfcontentstart
, 'fcontentend': catfcontentend
, 'fcontents': fcontents
} });
5192 fileidnum
= fileidnum
+ 1;
5195 def TarFileToArrayAlt(infiles
, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
5201 inodetocatinode
= {};
5205 if(hasattr(sys
.stdin
, "buffer")):
5206 shutil
.copyfileobj(sys
.stdin
.buffer, infile
);
5208 shutil
.copyfileobj(sys
.stdin
, infile
);
5213 elif(re
.findall(r
"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile
))):
5214 infile
= download_file_from_internet_file(infile
);
5219 elif(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
5221 elif(os
.path
.exists(infile
) and os
.path
.isfile(infile
)):
5223 if(not tarfile
.is_tarfile(infile
)):
5225 except AttributeError:
5226 if(not is_tarfile(infile
)):
5231 if(hasattr(infile
, "read") or hasattr(infile
, "write")):
5232 tarfp
= tarfile
.open(fileobj
=infile
, mode
="r");
5234 tarfp
= tarfile
.open(infile
, "r");
5235 except FileNotFoundError
:
5237 fnumfiles
= int(len(tarfp
.getmembers()));
5238 catver
= formatspecs
[6];
5239 fileheaderver
= str(int(catver
.replace(".", "")));
5240 fileheader
= AppendNullByte(formatspecs
[1] + fileheaderver
, formatspecs
[5]);
5241 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
5242 fileheader
= fileheader
+ AppendNullBytes([fnumfileshex
, checksumtype
], formatspecs
[5]);
5243 catversion
= re
.findall(r
"([\d]+)$", fileheader
);
5244 catversions
= re
.search(r
'(.*?)(\d+)$', catstring
).groups();
5245 if(checksumtype
=="none" or checksumtype
==""):
5246 catfileheadercshex
= format(0, 'x').lower();
5247 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
5248 catfileheadercshex
= format(crc16(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
5249 elif(checksumtype
=="crc16_ccitt"):
5250 catfileheadercshex
= format(crc16_ccitt(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
5251 elif(checksumtype
=="adler32"):
5252 catfileheadercshex
= format(zlib
.adler32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
5253 elif(checksumtype
=="crc32"):
5254 catfileheadercshex
= format(crc32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
5255 elif(checksumtype
=="crc64_ecma"):
5256 catfileheadercshex
= format(crc64_ecma(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5257 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
5258 catfileheadercshex
= format(crc64_iso(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5259 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
5260 checksumoutstr
= hashlib
.new(checksumtype
);
5261 checksumoutstr
.update(fileheader
.encode('UTF-8'));
5262 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
5264 catfileheadercshex
= format(0, 'x').lower();
5265 fileheader
= fileheader
+ AppendNullByte(catfileheadercshex
, formatspecs
[5]);
5266 fheadtell
= len(fileheader
);
5267 catlist
= {'fnumfiles': fnumfiles
, 'fformat': catversions
[0], 'fversion': catversions
[1], 'fformatspecs': formatspecs
, 'fchecksumtype': checksumtype
, 'fheaderchecksum': catfileheadercshex
, 'ffilelist': {}};
5268 for member
in sorted(tarfp
.getmembers(), key
=lambda x
: x
.name
):
5269 if(re
.findall("^[.|/]", member
.name
)):
5270 fname
= member
.name
;
5272 fname
= "./"+member
.name
;
5274 VerbosePrintOut(fname
);
5275 fpremode
= member
.mode
;
5276 ffullmode
= member
.mode
;
5280 ffullmode
= member
.mode
+ stat
.S_IFREG
;
5282 elif(member
.isdev()):
5283 ffullmode
= member
.mode
;
5285 elif(member
.islnk()):
5286 ffullmode
= member
.mode
+ stat
.S_IFREG
;
5288 elif(member
.issym()):
5289 ffullmode
= member
.mode
+ stat
.S_IFLNK
;
5291 elif(member
.ischr()):
5292 ffullmode
= member
.mode
+ stat
.S_IFCHR
;
5294 elif(member
.isblk()):
5295 ffullmode
= member
.mode
+ stat
.S_IFBLK
;
5297 elif(member
.isdir()):
5298 ffullmode
= member
.mode
+ stat
.S_IFDIR
;
5300 elif(member
.isfifo()):
5301 ffullmode
= member
.mode
+ stat
.S_IFIFO
;
5303 elif(member
.issparse()):
5304 ffullmode
= member
.mode
;
5307 ffullmode
= member
.mode
;
5310 fbasedir
= os
.path
.dirname(fname
);
5314 curfid
= curfid
+ 1;
5316 flinkname
= member
.linkname
;
5317 fdev_minor
= member
.devminor
;
5318 fdev_major
= member
.devmajor
;
5319 frdev_minor
= member
.devminor
;
5320 frdev_major
= member
.devmajor
;
5321 if(ftype
==1 or ftype
==2 or ftype
==3 or ftype
==4 or ftype
==5 or ftype
==6):
5323 elif(ftype
==0 or ftype
==7):
5324 fsize
= member
.size
;
5326 fsize
= member
.size
;
5327 fatime
= member
.mtime
;
5328 fmtime
= member
.mtime
;
5329 fctime
= member
.mtime
;
5330 fbtime
= member
.mtime
;
5332 fchmode
= stat
.S_IMODE(ffullmode
);
5333 ftypemod
= stat
.S_IFMT(ffullmode
);
5336 funame
= member
.uname
;
5337 fgname
= member
.gname
;
5338 flinkcount
= flinkcount
;
5339 fwinattributes
= int(0);
5340 fcontents
= "".encode('UTF-8');
5342 if(ftype
==0 or ftype
==7):
5343 with tarfp
.extractfile(member
) as fpc
:
5345 chunk
= fpc
.read(chunk_size
);
5349 ftypehex
= format(ftype
, 'x').lower();
5350 extrafields
= len(extradata
);
5351 extrafieldslist
= extradata
;
5352 catfextrafields
= extrafields
;
5353 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[5]);
5354 if(len(extradata
)>0):
5355 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[5]);
5356 extrasizelen
= len(extrasizestr
);
5357 extrasizelenhex
= format(extrasizelen
, 'x').lower();
5358 catoutlist
= [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(fwinattributes
), '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()];
5359 catoutlen
= len(catoutlist
) + len(extradata
) + 3;
5360 catoutlenhex
= format(catoutlen
, 'x').lower();
5361 catoutlist
.insert(0, catoutlenhex
);
5362 catfileoutstr
= AppendNullBytes(catoutlist
, formatspecs
[5]);
5363 if(len(extradata
)>0):
5364 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[5]);
5365 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[5]);
5366 catfnumfields
= catoutlen
;
5367 if(checksumtype
=="none" or checksumtype
==""):
5368 catfileheadercshex
= format(0, 'x').lower();
5369 catfilecontentcshex
= format(0, 'x').lower();
5370 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
5371 catfileheadercshex
= format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
5372 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
5373 elif(checksumtype
=="crc16_ccitt"):
5374 catfileheadercshex
= format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
5375 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
5376 elif(checksumtype
=="adler32"):
5377 catfileheadercshex
= format(zlib
.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5378 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
5379 elif(checksumtype
=="crc32"):
5380 catfileheadercshex
= format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5381 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
5382 elif(checksumtype
=="crc64_ecma"):
5383 catfileheadercshex
= format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5384 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
5385 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
5386 catfileheadercshex
= format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5387 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
5388 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
5389 checksumoutstr
= hashlib
.new(checksumtype
);
5390 checksumoutstr
.update("".encode('UTF-8'));
5391 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
5392 checksumoutstr
= hashlib
.new(checksumtype
);
5393 checksumoutstr
.update(fcontents
);
5394 catfilecontentcshex
= checksumoutstr
.hexdigest().lower();
5396 catfileheadercshex
= format(0, 'x').lower();
5397 catfilecontentcshex
= format(0, 'x').lower();
5398 catfhstart
= fheadtell
;
5399 fheadtell
+= len(catfileoutstr
);
5400 catfhend
= fheadtell
- 1;
5401 catfcontentstart
= fheadtell
;
5402 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
5403 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
5404 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[5]) + catfileoutstr
;
5405 catheaderdata
= [catheaersize
] + catoutlist
+ extradata
+ [checksumtype
, catfileheadercshex
, catfilecontentcshex
]
5406 if(checksumtype
=="none" or checksumtype
==""):
5407 catfileheadercshex
= format(0, 'x').lower();
5408 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
5409 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
5410 elif(checksumtype
=="crc16_ccitt"):
5411 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
5412 elif(checksumtype
=="adler32"):
5413 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
5414 elif(checksumtype
=="crc32"):
5415 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
5416 elif(checksumtype
=="crc64_ecma"):
5417 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5418 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
5419 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5420 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
5421 checksumoutstr
= hashlib
.new(checksumtype
);
5422 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
5423 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
5425 catfileheadercshex
= format(0, 'x').lower();
5426 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
5427 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
5428 nullstrecd
= formatspecs
[5].encode('UTF-8');
5429 fheadtell
+= len(catfileoutstr
) + 1;
5430 catfcontentend
= fheadtell
- 1;
5431 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
;
5432 pyhascontents
= False;
5433 if(int(fsize
)>0 and not listonly
):
5434 pyhascontents
= True;
5435 if(int(fsize
)>0 and listonly
):
5437 pyhascontents
= False;
5438 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
, 'fwinattributes': fwinattributes
, '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
+ 2, 'frawheader': catheaderdata
, 'fextrafields': catfextrafields
, 'fextrafieldsize': extrasizelen
, 'fextralist': extrafieldslist
, 'fheaderchecksum': int(catfileheadercshex
, 16), 'fcontentchecksum': int(catfilecontentcshex
, 16), 'fhascontents': pyhascontents
, 'fcontentstart': catfcontentstart
, 'fcontentend': catfcontentend
, 'fcontents': fcontents
} });
5439 fileidnum
= fileidnum
+ 1;
5442 def ZipFileToArrayAlt(infiles
, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
5448 inodetocatinode
= {};
5452 if(hasattr(sys
.stdin
, "buffer")):
5453 shutil
.copyfileobj(sys
.stdin
.buffer, infile
);
5455 shutil
.copyfileobj(sys
.stdin
, infile
);
5460 elif(re
.findall(r
"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile
))):
5461 infile
= download_file_from_internet_file(infile
);
5466 elif(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
5470 if(not zipfile
.is_zipfile(infile
)):
5473 zipfp
= zipfile
.ZipFile(infile
, "r", allowZip64
=True);
5474 except FileNotFoundError
:
5476 ziptest
= zipfp
.testzip();
5478 VerbosePrintOut("Bad file found!");
5479 fnumfiles
= int(len(zipfp
.infolist()));
5480 catver
= formatspecs
[6];
5481 fileheaderver
= str(int(catver
.replace(".", "")));
5482 fileheader
= AppendNullByte(formatspecs
[1] + fileheaderver
, formatspecs
[5]);
5483 catversion
= re
.findall(r
"([\d]+)$", fileheader
);
5484 catversions
= re
.search(r
'(.*?)(\d+)$', catstring
).groups();
5485 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
5486 fileheader
= fileheader
+ AppendNullBytes([fnumfileshex
, checksumtype
], formatspecs
[5]);
5487 if(checksumtype
=="none" or checksumtype
==""):
5488 catfileheadercshex
= format(0, 'x').lower();
5489 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
5490 catfileheadercshex
= format(crc16(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
5491 elif(checksumtype
=="crc16_ccitt"):
5492 catfileheadercshex
= format(crc16_ccitt(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
5493 elif(checksumtype
=="adler32"):
5494 catfileheadercshex
= format(zlib
.adler32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
5495 elif(checksumtype
=="crc32"):
5496 catfileheadercshex
= format(crc32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
5497 elif(checksumtype
=="crc64_ecma"):
5498 catfileheadercshex
= format(crc64_ecma(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5499 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
5500 catfileheadercshex
= format(crc64_iso(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5501 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
5502 checksumoutstr
= hashlib
.new(checksumtype
);
5503 checksumoutstr
.update(fileheader
.encode('UTF-8'));
5504 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
5506 catfileheadercshex
= format(0, 'x').lower();
5507 fileheader
= fileheader
+ AppendNullByte(catfileheadercshex
, formatspecs
[5]);
5508 fheadtell
= len(fileheader
);
5509 catlist
= {'fnumfiles': fnumfiles
, 'fformat': catversions
[0], 'fversion': catversions
[1], 'fformatspecs': formatspecs
, 'fchecksumtype': checksumtype
, 'fheaderchecksum': catfileheadercshex
, 'ffilelist': {}};
5510 for member
in sorted(zipfp
.infolist(), key
=lambda x
: x
.filename
):
5511 if(re
.findall("^[.|/]", member
.filename
)):
5512 fname
= member
.filename
;
5514 fname
= "./"+member
.filename
;
5515 zipinfo
= zipfp
.getinfo(member
.filename
);
5517 VerbosePrintOut(fname
);
5518 if(not member
.is_dir()):
5519 fpremode
= stat
.S_IFREG
+ 438;
5520 elif(member
.is_dir()):
5521 fpremode
= stat
.S_IFDIR
+ 511;
5524 if(not member
.is_dir()):
5526 elif(member
.is_dir()):
5529 fbasedir
= os
.path
.dirname(fname
);
5533 curfid
= curfid
+ 1;
5541 fsize
= member
.file_size
;
5543 fsize
= member
.file_size
;
5544 fatime
= time
.mktime(member
.date_time
+ (0, 0, -1));
5545 fmtime
= time
.mktime(member
.date_time
+ (0, 0, -1));
5546 fctime
= time
.mktime(member
.date_time
+ (0, 0, -1));
5547 fbtime
= time
.mktime(member
.date_time
+ (0, 0, -1));
5548 if(zipinfo
.create_system
==0 or zipinfo
.create_system
==10):
5549 fwinattributes
= int(zipinfo
.external_attr
);
5550 if(not member
.is_dir()):
5551 fmode
= int(stat
.S_IFREG
+ 438);
5552 fchmode
= int(stat
.S_IMODE(int(stat
.S_IFREG
+ 438)));
5553 ftypemod
= int(stat
.S_IFMT(int(stat
.S_IFREG
+ 438)));
5554 elif(member
.is_dir()):
5555 fmode
= int(stat
.S_IFDIR
+ 511);
5556 fchmode
= int(stat
.S_IMODE(int(stat
.S_IFDIR
+ 511)));
5557 ftypemod
= int(stat
.S_IFMT(int(stat
.S_IFDIR
+ 511)));
5558 elif(zipinfo
.create_system
==3):
5559 fwinattributes
= int(0);
5560 fmode
= int(zipinfo
.external_attr
);
5562 fwinattributes
= int(0);
5563 if(not member
.is_dir()):
5564 fmode
= int(stat
.S_IFREG
+ 438);
5565 fchmode
= int(stat
.S_IMODE(int(stat
.S_IFREG
+ 438)));
5566 ftypemod
= int(stat
.S_IFMT(int(stat
.S_IFREG
+ 438)));
5567 elif(member
.is_dir()):
5568 fmode
= int(stat
.S_IFDIR
+ 511);
5569 fchmode
= int(stat
.S_IMODE(int(stat
.S_IFDIR
+ 511)));
5570 ftypemod
= int(stat
.S_IFMT(int(stat
.S_IFDIR
+ 511)));
5573 except AttributeError:
5579 except AttributeError:
5586 userinfo
= pwd
.getpwuid(os
.getuid());
5587 funame
= userinfo
.pw_name
;
5590 except AttributeError:
5598 groupinfo
= grp
.getgrgid(os
.getgid());
5599 fgname
= groupinfo
.gr_name
;
5602 except AttributeError:
5606 fcontents
= "".encode('UTF-8');
5608 fcontents
= zipfp
.read(member
.filename
);
5609 ftypehex
= format(ftype
, 'x').lower();
5610 extrafields
= len(extradata
);
5611 extrafieldslist
= extradata
;
5612 catfextrafields
= extrafields
;
5613 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[5]);
5614 if(len(extradata
)>0):
5615 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[5]);
5616 extrasizelen
= len(extrasizestr
);
5617 extrasizelenhex
= format(extrasizelen
, 'x').lower();
5618 catoutlist
= [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(fwinattributes
), '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()];
5619 catoutlen
= len(catoutlist
) + len(extradata
) + 3;
5620 catoutlenhex
= format(catoutlen
, 'x').lower();
5621 catoutlist
.insert(0, catoutlenhex
);
5622 catfileoutstr
= AppendNullBytes(catoutlist
, formatspecs
[5]);
5623 if(len(extradata
)>0):
5624 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[5]);
5625 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[5]);
5626 catfnumfields
= catoutlen
;
5627 if(checksumtype
=="none" or checksumtype
==""):
5628 catfileheadercshex
= format(0, 'x').lower();
5629 catfilecontentcshex
= format(0, 'x').lower();
5630 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
5631 catfileheadercshex
= format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
5632 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
5633 elif(checksumtype
=="crc16_ccitt"):
5634 catfileheadercshex
= format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
5635 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
5636 elif(checksumtype
=="adler32"):
5637 catfileheadercshex
= format(zlib
.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5638 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
5639 elif(checksumtype
=="crc32"):
5640 catfileheadercshex
= format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
5641 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
5642 elif(checksumtype
=="crc64_ecma"):
5643 catfileheadercshex
= format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5644 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
5645 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
5646 catfileheadercshex
= format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5647 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
5648 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
5649 checksumoutstr
= hashlib
.new(checksumtype
);
5650 checksumoutstr
.update("".encode('UTF-8'));
5651 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
5652 checksumoutstr
= hashlib
.new(checksumtype
);
5653 checksumoutstr
.update(fcontents
);
5654 catfilecontentcshex
= checksumoutstr
.hexdigest().lower();
5656 catfileheadercshex
= format(0, 'x').lower();
5657 catfilecontentcshex
= format(0, 'x').lower();
5658 catfhstart
= fheadtell
;
5659 fheadtell
+= len(catfileoutstr
);
5660 catfhend
= fheadtell
- 1;
5661 catfcontentstart
= fheadtell
;
5662 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
5663 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
5664 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[5]) + catfileoutstr
;
5665 catheaderdata
= [catheaersize
] + catoutlist
+ extradata
+ [checksumtype
, catfileheadercshex
, catfilecontentcshex
];
5666 if(checksumtype
=="none" or checksumtype
==""):
5667 catfileheadercshex
= format(0, 'x').lower();
5668 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
5669 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
5670 elif(checksumtype
=="crc16_ccitt"):
5671 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
5672 elif(checksumtype
=="adler32"):
5673 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
5674 elif(checksumtype
=="crc32"):
5675 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
5676 elif(checksumtype
=="crc64_ecma"):
5677 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5678 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
5679 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5680 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
5681 checksumoutstr
= hashlib
.new(checksumtype
);
5682 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
5683 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
5685 catfileheadercshex
= format(0, 'x').lower();
5686 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
5687 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
5688 nullstrecd
= formatspecs
[5].encode('UTF-8');
5689 fheadtell
+= len(catfileoutstr
) + 1;
5690 catfcontentend
= fheadtell
- 1;
5691 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
;
5692 pyhascontents
= False;
5693 if(int(fsize
)>0 and not listonly
):
5694 pyhascontents
= True;
5695 if(int(fsize
)>0 and listonly
):
5697 pyhascontents
= False;
5698 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
, 'fwinattributes': fwinattributes
, '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
+ 2, 'frawheader': catheaderdata
, 'fextrafields': catfextrafields
, 'fextrafieldsize': extrasizelen
, 'fextralist': extrafieldslist
, 'fheaderchecksum': int(catfileheadercshex
, 16), 'fcontentchecksum': int(catfilecontentcshex
, 16), 'fhascontents': pyhascontents
, 'fcontentstart': catfcontentstart
, 'fcontentend': catfcontentend
, 'fcontents': fcontents
} });
5699 fileidnum
= fileidnum
+ 1;
5702 if(not rarfile_support
):
5703 def RarFileToArrayAlt(infiles
, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
5706 if(rarfile_support
):
5707 def RarFileToArrayAlt(infiles
, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
5713 inodetocatinode
= {};
5715 if(not os
.path
.exists(infiles
) or not os
.path
.isfile(infiles
)):
5717 if(not rarfile
.is_rarfile(infile
) and not rarfile
.is_rarfile_sfx(infile
)):
5719 rarfp
= rarfile
.RarFile(infile
, "r");
5720 rartest
= rarfp
.testrar();
5722 VerbosePrintOut("Bad file found!");
5723 fnumfiles
= int(len(rarfp
.infolist()));
5724 catver
= formatspecs
[6];
5725 fileheaderver
= str(int(catver
.replace(".", "")));
5726 fileheader
= AppendNullByte(formatspecs
[1] + fileheaderver
, formatspecs
[5]);
5727 catversion
= re
.findall(r
"([\d]+)$", fileheader
);
5728 catversions
= re
.search(r
'(.*?)(\d+)$', catstring
).groups();
5729 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
5730 fileheader
= fileheader
+ AppendNullBytes([fnumfileshex
, checksumtype
], formatspecs
[5]);
5731 if(checksumtype
=="none" or checksumtype
==""):
5732 catfileheadercshex
= format(0, 'x').lower();
5733 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
5734 catfileheadercshex
= format(crc16(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
5735 elif(checksumtype
=="crc16_ccitt"):
5736 catfileheadercshex
= format(crc16_ccitt(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
5737 elif(checksumtype
=="adler32"):
5738 catfileheadercshex
= format(zlib
.adler32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
5739 elif(checksumtype
=="crc32"):
5740 catfileheadercshex
= format(crc32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
5741 elif(checksumtype
=="crc64_ecma"):
5742 catfileheadercshex
= format(crc64_ecma(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5743 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
5744 catfileheadercshex
= format(crc64_iso(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5745 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
5746 checksumoutstr
= hashlib
.new(checksumtype
);
5747 checksumoutstr
.update(fileheader
.encode('UTF-8'));
5748 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
5750 catfileheadercshex
= format(0, 'x').lower();
5751 fileheader
= fileheader
+ AppendNullByte(catfileheadercshex
, formatspecs
[5]);
5752 fheadtell
= len(fileheader
);
5753 catlist
= {'fnumfiles': fnumfiles
, 'fformat': catversions
[0], 'fversion': catversions
[1], 'fformatspecs': formatspecs
, 'fchecksumtype': checksumtype
, 'fheaderchecksum': catfileheadercshex
, 'ffilelist': {}};
5754 for member
in sorted(rarfp
.infolist(), key
=lambda x
: x
.filename
):
5757 if(member
.host_os
==rarfile
.RAR_OS_UNIX
):
5760 member
.external_attr
5762 except AttributeError:
5764 elif(member
.host_os
==rarfile
.RAR_OS_WIN32
):
5767 member
.external_attr
5769 except AttributeError:
5774 if(re
.findall("^[.|/]", member
.filename
)):
5775 fname
= member
.filename
;
5777 fname
= "./"+member
.filename
;
5778 rarinfo
= rarfp
.getinfo(member
.filename
);
5780 VerbosePrintOut(fname
);
5781 if(is_unix
and member
.external_attr
!=0):
5782 fpremode
= int(member
.external_attr
);
5783 elif(member
.is_file()):
5784 fpremode
= stat
.S_IFREG
+ 438;
5785 elif(member
.is_symlink()):
5786 fpremode
= stat
.S_IFLNK
+ 438;
5787 elif(member
.is_dir()):
5788 fpremode
= stat
.S_IFDIR
+ 511;
5789 if(is_windows
and member
.external_attr
!=0):
5790 fwinattributes
= int(member
.external_attr
);
5792 fwinattributes
= int(0);
5795 if(member
.is_file()):
5797 elif(member
.is_symlink()):
5799 elif(member
.is_dir()):
5803 flinkname
= rarfp
.read(member
.filename
).decode("UTF-8");
5804 fbasedir
= os
.path
.dirname(fname
);
5808 curfid
= curfid
+ 1;
5816 fsize
= member
.file_size
;
5819 fatime
= int(member
.atime
.timestamp());
5821 fatime
= int(member
.mtime
.timestamp());
5822 except AttributeError:
5823 fatime
= int(member
.mtime
.timestamp());
5824 fmtime
= int(member
.mtime
.timestamp());
5827 fctime
= int(member
.ctime
.timestamp());
5829 fctime
= int(member
.mtime
.timestamp());
5830 except AttributeError:
5831 fctime
= int(member
.mtime
.timestamp());
5832 fbtime
= int(member
.mtime
.timestamp());
5833 if(is_unix
and member
.external_attr
!=0):
5834 fmode
= int(member
.external_attr
);
5835 fchmode
= int(stat
.S_IMODE(member
.external_attr
));
5836 ftypemod
= int(stat
.S_IFMT(member
.external_attr
));
5837 elif(member
.is_file()):
5838 fmode
= int(stat
.S_IFREG
+ 438)
5839 fchmode
= int(stat
.S_IMODE(stat
.S_IFREG
+ 438));
5840 ftypemod
= int(stat
.S_IFMT(stat
.S_IFREG
+ 438));
5841 elif(member
.is_symlink()):
5842 fmode
= int(stat
.S_IFLNK
+ 438)
5843 fchmode
= int(stat
.S_IMODE(stat
.S_IFREG
+ 438));
5844 ftypemod
= int(stat
.S_IFMT(stat
.S_IFREG
+ 438));
5845 elif(member
.is_dir()):
5846 fmode
= int(stat
.S_IFDIR
+ 511)
5847 fchmode
= int(stat
.S_IMODE(stat
.S_IFDIR
+ 511));
5848 ftypemod
= int(stat
.S_IFMT(stat
.S_IFDIR
+ 511));
5851 except AttributeError:
5857 except AttributeError:
5864 userinfo
= pwd
.getpwuid(os
.getuid());
5865 funame
= userinfo
.pw_name
;
5868 except AttributeError:
5876 groupinfo
= grp
.getgrgid(os
.getgid());
5877 fgname
= groupinfo
.gr_name
;
5880 except AttributeError:
5884 fcontents
= "".encode('UTF-8');
5886 fcontents
= rarfp
.read(member
.filename
);
5887 ftypehex
= format(ftype
, 'x').lower();
5888 extrafields
= len(extradata
);
5889 extrafieldslist
= extradata
;
5890 catfextrafields
= extrafields
;
5891 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[5]);
5892 if(len(extradata
)>0):
5893 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[5]);
5894 extrasizelen
= len(extrasizestr
);
5895 extrasizelenhex
= format(extrasizelen
, 'x').lower();
5896 catoutlist
= [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(fwinattributes
), '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()];
5897 catoutlen
= len(catoutlist
) + len(extradata
) + 3;
5898 catoutlenhex
= format(catoutlen
, 'x').lower();
5899 catoutlist
.insert(0, catoutlenhex
);
5900 catfileoutstr
= AppendNullBytes(catoutlist
, formatspecs
[5]);
5901 if(len(extradata
)>0):
5902 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[5]);
5903 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[5]);
5904 catfnumfields
= 24 + catfextrafields
;
5905 if(checksumtype
=="none" or checksumtype
==""):
5906 catfileheadercshex
= format(0, 'x').lower();
5907 catfilecontentcshex
= format(0, 'x').lower();
5908 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
5909 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
5910 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
5911 elif(checksumtype
=="crc16_ccitt"):
5912 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
5913 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
5914 elif(checksumtype
=="adler32"):
5915 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
5916 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
5917 elif(checksumtype
=="crc32"):
5918 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
5919 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
5920 elif(checksumtype
=="crc64_ecma"):
5921 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5922 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
5923 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
5924 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5925 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
5926 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
5927 checksumoutstr
= hashlib
.new(checksumtype
);
5928 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
5929 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
5931 catfileheadercshex
= format(0, 'x').lower();
5932 catfilecontentcshex
= format(0, 'x').lower();
5933 catfhstart
= fheadtell
;
5934 fheadtell
+= len(catfileoutstr
);
5935 catfhend
= fheadtell
- 1;
5936 catfcontentstart
= fheadtell
;
5937 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
5938 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
5939 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[5]) + catfileoutstr
;
5940 catheaderdata
= [catheaersize
] + catoutlist
+ extradata
+ [checksumtype
, catfileheadercshex
, catfilecontentcshex
];
5941 if(checksumtype
=="none" or checksumtype
==""):
5942 catfileheadercshex
= format(0, 'x').lower();
5943 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
5944 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
5945 elif(checksumtype
=="crc16_ccitt"):
5946 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
5947 elif(checksumtype
=="adler32"):
5948 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
5949 elif(checksumtype
=="crc32"):
5950 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
5951 elif(checksumtype
=="crc64_ecma"):
5952 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5953 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
5954 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
5955 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
5956 checksumoutstr
= hashlib
.new(checksumtype
);
5957 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
5958 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
5960 catfileheadercshex
= format(0, 'x').lower();
5961 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
5962 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
5963 nullstrecd
= formatspecs
[5].encode('UTF-8');
5964 fheadtell
+= len(catfileoutstr
) + 1;
5965 catfcontentend
= fheadtell
- 1;
5966 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
;
5967 pyhascontents
= False;
5968 if(int(fsize
)>0 and not listonly
):
5969 pyhascontents
= True;
5970 if(int(fsize
)>0 and listonly
):
5972 pyhascontents
= False;
5973 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
, 'fwinattributes': fwinattributes
, '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
+ 2, 'frawheader': catheaderdata
, 'fextrafields': catfextrafields
, 'fextrafieldsize': extrasizelen
, 'fextralist': extrafieldslist
, 'fheaderchecksum': int(catfileheadercshex
, 16), 'fcontentchecksum': int(catfilecontentcshex
, 16), 'fhascontents': pyhascontents
, 'fcontentstart': catfcontentstart
, 'fcontentend': catfcontentend
, 'fcontents': fcontents
} });
5974 fileidnum
= fileidnum
+ 1;
5977 if(not py7zr_support
):
5978 def SevenZipFileToArrayAlt(infiles
, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
5982 def SevenZipFileToArrayAlt(infiles
, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
5988 inodetocatinode
= {};
5990 szpfp
= py7zr
.SevenZipFile(infile
, mode
="r");
5991 file_content
= szpfp
.readall();
5992 #sztest = szpfp.testzip();
5993 sztestalt
= szpfp
.test();
5995 VerbosePrintOut("Bad file found!");
5996 numfiles
= int(len(szpfp
.list()));
5997 catver
= formatspecs
[6];
5998 fileheaderver
= str(int(catver
.replace(".", "")));
5999 fileheader
= AppendNullByte(formatspecs
[1] + fileheaderver
, formatspecs
[5]);
6000 catversion
= re
.findall(r
"([\d]+)$", fileheader
);
6001 catversions
= re
.search(r
'(.*?)(\d+)$', catstring
).groups();
6002 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
6003 fileheader
= fileheader
+ AppendNullBytes([fnumfileshex
, checksumtype
], formatspecs
[5]);
6004 if(checksumtype
=="none" or checksumtype
==""):
6005 catfileheadercshex
= format(0, 'x').lower();
6006 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
6007 catfileheadercshex
= format(crc16(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
6008 elif(checksumtype
=="crc16_ccitt"):
6009 catfileheadercshex
= format(crc16_ccitt(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
6010 elif(checksumtype
=="adler32"):
6011 catfileheadercshex
= format(zlib
.adler32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
6012 elif(checksumtype
=="crc32"):
6013 catfileheadercshex
= format(crc32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
6014 elif(checksumtype
=="crc64_ecma"):
6015 catfileheadercshex
= format(crc64_ecma(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6016 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
6017 catfileheadercshex
= format(crc64_iso(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6018 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
6019 checksumoutstr
= hashlib
.new(checksumtype
);
6020 checksumoutstr
.update(fileheader
.encode('UTF-8'));
6021 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
6023 catfileheadercshex
= format(0, 'x').lower();
6024 fileheader
= fileheader
+ AppendNullByte(catfileheadercshex
, formatspecs
[5]);
6025 fheadtell
= len(fileheader
);
6026 catlist
= {'fnumfiles': fnumfiles
, 'fformat': catversions
[0], 'fversion': catversions
[1], 'fformatspecs': formatspecs
, 'fchecksumtype': checksumtype
, 'fheaderchecksum': catfileheadercshex
, 'ffilelist': {}};
6027 for member
in sorted(szpfp
.list(), key
=lambda x
: x
.filename
):
6028 if(re
.findall("^[.|/]", member
.filename
)):
6029 fname
= member
.filename
;
6031 fname
= "./"+member
.filename
;
6032 if(not member
.is_directory
):
6033 fpremode
= int(stat
.S_IFREG
+ 438);
6034 elif(member
.is_directory
):
6035 fpremode
= int(stat
.S_IFDIR
+ 511);
6036 fwinattributes
= int(0);
6039 if(member
.is_directory
):
6044 fbasedir
= os
.path
.dirname(fname
);
6048 curfid
= curfid
+ 1;
6055 fatime
= int(member
.creationtime
.timestamp());
6056 fmtime
= int(member
.creationtime
.timestamp());
6057 fctime
= int(member
.creationtime
.timestamp());
6058 fbtime
= int(member
.creationtime
.timestamp());
6059 if(member
.is_directory
):
6060 fmode
= int(stat
.S_IFDIR
+ 511)
6061 fchmode
= int(stat
.S_IMODE(stat
.S_IFDIR
+ 511));
6062 ftypemod
= int(stat
.S_IFMT(stat
.S_IFDIR
+ 511));
6064 fmode
= int(stat
.S_IFLNK
+ 438)
6065 fchmode
= int(stat
.S_IMODE(stat
.S_IFREG
+ 438));
6066 ftypemod
= int(stat
.S_IFMT(stat
.S_IFREG
+ 438));
6069 except AttributeError:
6075 except AttributeError:
6082 userinfo
= pwd
.getpwuid(os
.getuid());
6083 funame
= userinfo
.pw_name
;
6086 except AttributeError:
6094 groupinfo
= grp
.getgrgid(os
.getgid());
6095 fgname
= groupinfo
.gr_name
;
6098 except AttributeError:
6102 fcontents
= "".encode('UTF-8');
6104 fcontents
= file_content
[member
.filename
].read();
6105 fsize
= format(len(fcontents
), 'x').lower();
6107 ftypehex
= format(ftype
, 'x').lower();
6108 extrafields
= len(extradata
);
6109 extrafieldslist
= extradata
;
6110 catfextrafields
= extrafields
;
6111 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[5]);
6112 if(len(extradata
)>0):
6113 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[5]);
6114 extrasizelen
= len(extrasizestr
);
6115 extrasizelenhex
= format(extrasizelen
, 'x').lower();
6116 catoutlist
= [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(fwinattributes
), '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()];
6117 catoutlen
= len(catoutlist
) + len(extradata
) + 3;
6118 catoutlenhex
= format(catoutlen
, 'x').lower();
6119 catoutlist
.insert(0, catoutlenhex
);
6120 catfileoutstr
= AppendNullBytes(catoutlist
, formatspecs
[5]);
6121 if(len(extradata
)>0):
6122 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[5]);
6123 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[5]);
6124 catfnumfields
= 24 + catfextrafields
;
6125 if(checksumtype
=="none" or checksumtype
==""):
6126 catfileheadercshex
= format(0, 'x').lower();
6127 catfilecontentcshex
= format(0, 'x').lower();
6128 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
6129 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
6130 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
6131 elif(checksumtype
=="crc16_ccitt"):
6132 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
6133 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
6134 elif(checksumtype
=="adler32"):
6135 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
6136 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
6137 elif(checksumtype
=="crc32"):
6138 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
6139 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
6140 elif(checksumtype
=="crc64_ecma"):
6141 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6142 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
6143 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
6144 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6145 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
6146 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
6147 checksumoutstr
= hashlib
.new(checksumtype
);
6148 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
6149 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
6151 catfileheadercshex
= format(0, 'x').lower();
6152 catfilecontentcshex
= format(0, 'x').lower();
6153 catfhstart
= fheadtell
;
6154 fheadtell
+= len(catfileoutstr
);
6155 catfhend
= fheadtell
- 1;
6156 catfcontentstart
= fheadtell
;
6157 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
6158 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
6159 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[5]) + catfileoutstr
;
6160 catheaderdata
= [catheaersize
] + catoutlist
+ extradata
+ [checksumtype
, catfileheadercshex
, catfilecontentcshex
];
6161 if(checksumtype
=="none" or checksumtype
==""):
6162 catfileheadercshex
= format(0, 'x').lower();
6163 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
6164 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
6165 elif(checksumtype
=="crc16_ccitt"):
6166 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
6167 elif(checksumtype
=="adler32"):
6168 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
6169 elif(checksumtype
=="crc32"):
6170 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
6171 elif(checksumtype
=="crc64_ecma"):
6172 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6173 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
6174 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6175 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
6176 checksumoutstr
= hashlib
.new(checksumtype
);
6177 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
6178 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
6180 catfileheadercshex
= format(0, 'x').lower();
6181 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
6182 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
6183 nullstrecd
= formatspecs
[5].encode('UTF-8');
6184 fheadtell
+= len(catfileoutstr
) + 1;
6185 catfcontentend
= fheadtell
- 1;
6186 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
;
6187 pyhascontents
= False;
6188 if(int(fsize
)>0 and not listonly
):
6189 pyhascontents
= True;
6190 if(int(fsize
)>0 and listonly
):
6192 pyhascontents
= False;
6193 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
, 'fwinattributes': fwinattributes
, '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
+ 2, 'frawheader': catheaderdata
, 'fextrafields': catfextrafields
, 'fextrafieldsize': extrasizelen
, 'fextralist': extrafieldslist
, 'fheaderchecksum': int(catfileheadercshex
, 16), 'fcontentchecksum': int(catfilecontentcshex
, 16), 'fhascontents': pyhascontents
, 'fcontentstart': catfcontentstart
, 'fcontentend': catfcontentend
, 'fcontents': fcontents
} });
6194 fileidnum
= fileidnum
+ 1;
6197 def InFileToArrayAlt(infiles
, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
6198 checkcompressfile
= CheckCompressionSubType(infiles
, formatspecs
, True);
6199 if(checkcompressfile
=="tarfile"):
6200 return TarFileToArrayAlt(infiles
, listonly
, checksumtype
, extradata
, formatspecs
, verbose
);
6201 elif(checkcompressfile
=="zipfile"):
6202 return ZipFileToArrayAlt(infiles
, listonly
, checksumtype
, extradata
, formatspecs
, verbose
);
6203 elif(checkcompressfile
=="catfile"):
6204 return ArchiveFileToArray(infile
, 0, 0, listonly
, False, formatspecs
, False);
6205 elif(rarfile_support
and checkcompressfile
=="rarfile"):
6206 return RarFileToArrayAlt(infiles
, listonly
, checksumtype
, extradata
, formatspecs
, verbose
);
6207 elif(py7zr_support
and checkcompressfile
=="7zipfile"):
6208 return SevenZipFileToArrayAlt(infiles
, listonly
, checksumtype
, extradata
, formatspecs
, verbose
);
6213 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):
6214 outarray
= BytesIO();
6215 packcat
= PackArchiveFile(infiles
, outarray
, dirlistfromtxt
, compression
, compressionlevel
, followlink
, checksumtype
, extradata
, formatspecs
, verbose
, True);
6216 listcatfiles
= ArchiveFileToArray(outarray
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
6217 return listcatfiles
;
6219 def ArchiveFileToArrayIndex(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
6220 if(isinstance(infile
, dict)):
6221 listcatfiles
= infile
;
6223 if(infile
!="-" and not hasattr(infile
, "read") and not hasattr(infile
, "write")):
6224 infile
= RemoveWindowsPath(infile
);
6225 listcatfiles
= ArchiveFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
6226 if(not listcatfiles
):
6228 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': {}}}};
6230 catarray
.update({'catfp': listcatfiles
['catfp']});
6231 lenlist
= len(listcatfiles
['ffilelist']);
6233 lcfx
= int(listcatfiles
['fnumfiles']);
6234 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
6235 lcfx
= int(lenlist
);
6237 lcfx
= int(listcatfiles
['fnumfiles']);
6239 filetoidarray
= {listcatfiles
['ffilelist'][lcfi
]['fname']: listcatfiles
['ffilelist'][lcfi
]['fid']};
6240 idtofilearray
= {listcatfiles
['ffilelist'][lcfi
]['fid']: listcatfiles
['ffilelist'][lcfi
]['fname']};
6241 catarray
['filetoid'].update(filetoidarray
);
6242 catarray
['idtofile'].update(idtofilearray
);
6243 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==0 or listcatfiles
['ffilelist'][lcfi
]['ftype']==7):
6244 catarray
['filetypes']['files']['filetoid'].update(filetoidarray
);
6245 catarray
['filetypes']['files']['idtofile'].update(idtofilearray
);
6246 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==1):
6247 catarray
['filetypes']['hardlinks']['filetoid'].update(filetoidarray
);
6248 catarray
['filetypes']['hardlinks']['idtofile'].update(idtofilearray
);
6249 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
6250 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
6251 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==2):
6252 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
6253 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
6254 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
6255 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
6256 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==3):
6257 catarray
['filetypes']['character']['filetoid'].update(filetoidarray
);
6258 catarray
['filetypes']['character']['idtofile'].update(idtofilearray
);
6259 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6260 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6261 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==4):
6262 catarray
['filetypes']['block']['filetoid'].update(filetoidarray
);
6263 catarray
['filetypes']['block']['idtofile'].update(idtofilearray
);
6264 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6265 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6266 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==5):
6267 catarray
['filetypes']['directories']['filetoid'].update(filetoidarray
);
6268 catarray
['filetypes']['directories']['idtofile'].update(idtofilearray
);
6269 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==6):
6270 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
6271 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
6272 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6273 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6277 create_alias_function("", __file_format_name__
, "ToArrayIndex", ArchiveFileToArrayIndex
);
6279 def ListDirToArrayIndexAlt(infiles
, dirlistfromtxt
=False, followlink
=False, seekstart
=0, seekend
=0, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
6280 listcatfiles
= ListDirToArrayAlt(infiles
, dirlistfromtxt
, followlink
, listonly
, checksumtype
, extradata
, formatspecs
, verbose
);
6281 if(not listcatfiles
):
6283 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': {}}}};
6284 lenlist
= len(listcatfiles
['ffilelist']);
6286 lcfx
= int(listcatfiles
['fnumfiles']);
6287 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
6288 lcfx
= int(lenlist
);
6290 lcfx
= int(listcatfiles
['fnumfiles']);
6292 filetoidarray
= {listcatfiles
['ffilelist'][lcfi
]['fname']: listcatfiles
['ffilelist'][lcfi
]['fid']};
6293 idtofilearray
= {listcatfiles
['ffilelist'][lcfi
]['fid']: listcatfiles
['ffilelist'][lcfi
]['fname']};
6294 catarray
['filetoid'].update(filetoidarray
);
6295 catarray
['idtofile'].update(idtofilearray
);
6296 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==0 or listcatfiles
['ffilelist'][lcfi
]['ftype']==7):
6297 catarray
['filetypes']['files']['filetoid'].update(filetoidarray
);
6298 catarray
['filetypes']['files']['idtofile'].update(idtofilearray
);
6299 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==1):
6300 catarray
['filetypes']['hardlinks']['filetoid'].update(filetoidarray
);
6301 catarray
['filetypes']['hardlinks']['idtofile'].update(idtofilearray
);
6302 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
6303 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
6304 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==2):
6305 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
6306 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
6307 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
6308 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
6309 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==3):
6310 catarray
['filetypes']['character']['filetoid'].update(filetoidarray
);
6311 catarray
['filetypes']['character']['idtofile'].update(idtofilearray
);
6312 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6313 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6314 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==4):
6315 catarray
['filetypes']['block']['filetoid'].update(filetoidarray
);
6316 catarray
['filetypes']['block']['idtofile'].update(idtofilearray
);
6317 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6318 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6319 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==5):
6320 catarray
['filetypes']['directories']['filetoid'].update(filetoidarray
);
6321 catarray
['filetypes']['directories']['idtofile'].update(idtofilearray
);
6322 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==6):
6323 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
6324 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
6325 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6326 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6330 def TarFileToArrayIndexAlt(infiles
, seekstart
=0, seekend
=0, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
6331 listcatfiles
= TarFileToArrayAlt(infiles
, listonly
, checksumtype
, extradata
, formatspecs
, verbose
);
6332 if(not listcatfiles
):
6334 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': {}}}};
6335 lenlist
= len(listcatfiles
['ffilelist']);
6337 lcfx
= int(listcatfiles
['fnumfiles']);
6338 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
6339 lcfx
= int(lenlist
);
6341 lcfx
= int(listcatfiles
['fnumfiles']);
6343 filetoidarray
= {listcatfiles
['ffilelist'][lcfi
]['fname']: listcatfiles
['ffilelist'][lcfi
]['fid']};
6344 idtofilearray
= {listcatfiles
['ffilelist'][lcfi
]['fid']: listcatfiles
['ffilelist'][lcfi
]['fname']};
6345 catarray
['filetoid'].update(filetoidarray
);
6346 catarray
['idtofile'].update(idtofilearray
);
6347 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==0 or listcatfiles
['ffilelist'][lcfi
]['ftype']==7):
6348 catarray
['filetypes']['files']['filetoid'].update(filetoidarray
);
6349 catarray
['filetypes']['files']['idtofile'].update(idtofilearray
);
6350 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==1):
6351 catarray
['filetypes']['hardlinks']['filetoid'].update(filetoidarray
);
6352 catarray
['filetypes']['hardlinks']['idtofile'].update(idtofilearray
);
6353 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
6354 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
6355 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==2):
6356 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
6357 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
6358 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
6359 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
6360 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==3):
6361 catarray
['filetypes']['character']['filetoid'].update(filetoidarray
);
6362 catarray
['filetypes']['character']['idtofile'].update(idtofilearray
);
6363 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6364 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6365 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==4):
6366 catarray
['filetypes']['block']['filetoid'].update(filetoidarray
);
6367 catarray
['filetypes']['block']['idtofile'].update(idtofilearray
);
6368 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6369 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6370 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==5):
6371 catarray
['filetypes']['directories']['filetoid'].update(filetoidarray
);
6372 catarray
['filetypes']['directories']['idtofile'].update(idtofilearray
);
6373 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==6):
6374 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
6375 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
6376 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6377 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6381 def ZipFileToArrayIndexAlt(infiles
, seekstart
=0, seekend
=0, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
6382 listcatfiles
= ZipFileToArrayAlt(infiles
, listonly
, checksumtype
, extradata
, formatspecs
, verbose
);
6383 if(not listcatfiles
):
6385 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': {}}}};
6386 lenlist
= len(listcatfiles
['ffilelist']);
6388 lcfx
= int(listcatfiles
['fnumfiles']);
6389 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
6390 lcfx
= int(lenlist
);
6392 lcfx
= int(listcatfiles
['fnumfiles']);
6394 filetoidarray
= {listcatfiles
['ffilelist'][lcfi
]['fname']: listcatfiles
['ffilelist'][lcfi
]['fid']};
6395 idtofilearray
= {listcatfiles
['ffilelist'][lcfi
]['fid']: listcatfiles
['ffilelist'][lcfi
]['fname']};
6396 catarray
['filetoid'].update(filetoidarray
);
6397 catarray
['idtofile'].update(idtofilearray
);
6398 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==0 or listcatfiles
['ffilelist'][lcfi
]['ftype']==7):
6399 catarray
['filetypes']['files']['filetoid'].update(filetoidarray
);
6400 catarray
['filetypes']['files']['idtofile'].update(idtofilearray
);
6401 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==1):
6402 catarray
['filetypes']['hardlinks']['filetoid'].update(filetoidarray
);
6403 catarray
['filetypes']['hardlinks']['idtofile'].update(idtofilearray
);
6404 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
6405 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
6406 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==2):
6407 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
6408 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
6409 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
6410 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
6411 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==3):
6412 catarray
['filetypes']['character']['filetoid'].update(filetoidarray
);
6413 catarray
['filetypes']['character']['idtofile'].update(idtofilearray
);
6414 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6415 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6416 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==4):
6417 catarray
['filetypes']['block']['filetoid'].update(filetoidarray
);
6418 catarray
['filetypes']['block']['idtofile'].update(idtofilearray
);
6419 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6420 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6421 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==5):
6422 catarray
['filetypes']['directories']['filetoid'].update(filetoidarray
);
6423 catarray
['filetypes']['directories']['idtofile'].update(idtofilearray
);
6424 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==6):
6425 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
6426 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
6427 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6428 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6432 if(not rarfile_support
):
6433 def RarFileToArrayIndexAlt(infiles
, seekstart
=0, seekend
=0, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
6436 if(rarfile_support
):
6437 def RarFileToArrayIndexAlt(infiles
, seekstart
=0, seekend
=0, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
6438 listcatfiles
= RarFileToArrayAlt(infiles
, listonly
, checksumtype
, extradata
, formatspecs
, verbose
);
6439 if(not listcatfiles
):
6441 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': {}}}};
6442 lenlist
= len(listcatfiles
['ffilelist']);
6444 lcfx
= int(listcatfiles
['fnumfiles']);
6445 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
6446 lcfx
= int(lenlist
);
6448 lcfx
= int(listcatfiles
['fnumfiles']);
6450 filetoidarray
= {listcatfiles
['ffilelist'][lcfi
]['fname']: listcatfiles
['ffilelist'][lcfi
]['fid']};
6451 idtofilearray
= {listcatfiles
['ffilelist'][lcfi
]['fid']: listcatfiles
['ffilelist'][lcfi
]['fname']};
6452 catarray
['filetoid'].update(filetoidarray
);
6453 catarray
['idtofile'].update(idtofilearray
);
6454 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==0 or listcatfiles
['ffilelist'][lcfi
]['ftype']==7):
6455 catarray
['filetypes']['files']['filetoid'].update(filetoidarray
);
6456 catarray
['filetypes']['files']['idtofile'].update(idtofilearray
);
6457 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==1):
6458 catarray
['filetypes']['hardlinks']['filetoid'].update(filetoidarray
);
6459 catarray
['filetypes']['hardlinks']['idtofile'].update(idtofilearray
);
6460 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
6461 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
6462 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==2):
6463 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
6464 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
6465 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
6466 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
6467 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==3):
6468 catarray
['filetypes']['character']['filetoid'].update(filetoidarray
);
6469 catarray
['filetypes']['character']['idtofile'].update(idtofilearray
);
6470 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6471 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6472 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==4):
6473 catarray
['filetypes']['block']['filetoid'].update(filetoidarray
);
6474 catarray
['filetypes']['block']['idtofile'].update(idtofilearray
);
6475 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6476 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6477 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==5):
6478 catarray
['filetypes']['directories']['filetoid'].update(filetoidarray
);
6479 catarray
['filetypes']['directories']['idtofile'].update(idtofilearray
);
6480 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==6):
6481 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
6482 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
6483 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6484 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6488 if(not py7zr_support
):
6489 def SevenZipFileToArrayIndexAlt(infiles
, seekstart
=0, seekend
=0, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
6493 def SevenZipFileToArrayIndexAlt(infiles
, seekstart
=0, seekend
=0, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
6494 listcatfiles
= SevenZipFileToArrayAlt(infiles
, listonly
, checksumtype
, extradata
, formatspecs
, verbose
);
6495 if(not listcatfiles
):
6497 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': {}}}};
6498 lenlist
= len(listcatfiles
['ffilelist']);
6500 lcfx
= int(listcatfiles
['fnumfiles']);
6501 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
6502 lcfx
= int(lenlist
);
6504 lcfx
= int(listcatfiles
['fnumfiles']);
6506 filetoidarray
= {listcatfiles
['ffilelist'][lcfi
]['fname']: listcatfiles
['ffilelist'][lcfi
]['fid']};
6507 idtofilearray
= {listcatfiles
['ffilelist'][lcfi
]['fid']: listcatfiles
['ffilelist'][lcfi
]['fname']};
6508 catarray
['filetoid'].update(filetoidarray
);
6509 catarray
['idtofile'].update(idtofilearray
);
6510 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==0 or listcatfiles
['ffilelist'][lcfi
]['ftype']==7):
6511 catarray
['filetypes']['files']['filetoid'].update(filetoidarray
);
6512 catarray
['filetypes']['files']['idtofile'].update(idtofilearray
);
6513 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==1):
6514 catarray
['filetypes']['hardlinks']['filetoid'].update(filetoidarray
);
6515 catarray
['filetypes']['hardlinks']['idtofile'].update(idtofilearray
);
6516 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
6517 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
6518 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==2):
6519 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
6520 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
6521 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
6522 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
6523 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==3):
6524 catarray
['filetypes']['character']['filetoid'].update(filetoidarray
);
6525 catarray
['filetypes']['character']['idtofile'].update(idtofilearray
);
6526 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6527 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6528 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==4):
6529 catarray
['filetypes']['block']['filetoid'].update(filetoidarray
);
6530 catarray
['filetypes']['block']['idtofile'].update(idtofilearray
);
6531 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6532 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6533 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==5):
6534 catarray
['filetypes']['directories']['filetoid'].update(filetoidarray
);
6535 catarray
['filetypes']['directories']['idtofile'].update(idtofilearray
);
6536 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==6):
6537 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
6538 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
6539 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
6540 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
6544 def ArchiveFileStringToArrayIndex(catstr
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
6545 catfp
= BytesIO(catstr
);
6546 listcatfiles
= ArchiveFileToArrayIndex(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
6547 return listcatfiles
;
6549 create_alias_function("", __file_format_name__
, "StringToArrayIndex", ArchiveFileStringToArrayIndex
);
6551 def TarFileToArrayIndex(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
6553 catfp
= PackArchiveFileFromTarFile(infile
, catfp
, "auto", None, "crc32", [], formatspecs
, False, True);
6554 listcatfiles
= ArchiveFileToArrayIndex(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
6555 return listcatfiles
;
6557 def ZipFileToArrayIndex(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
6559 catfp
= PackArchiveFileFromZipFile(infile
, catfp
, "auto", None, "crc32", [], formatspecs
, False, True);
6560 listcatfiles
= ArchiveFileToArrayIndex(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
6561 return listcatfiles
;
6563 if(not rarfile_support
):
6564 def RarFileToArrayIndex(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
6567 if(rarfile_support
):
6568 def RarFileToArrayIndex(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
6570 catfp
= PackArchiveFileFromRarFile(infile
, catfp
, "auto", None, "crc32", [], formatspecs
, False, True);
6571 listcatfiles
= ArchiveFileToArrayIndex(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
6572 return listcatfiles
;
6574 if(not py7zr_support
):
6575 def SevenZipFileToArrayIndex(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
6579 def SevenZipFileToArrayIndex(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
6581 catfp
= PackArchiveFileFromSevenZipFile(infile
, catfp
, "auto", None, "crc32", [], formatspecs
, False, True);
6582 listcatfiles
= ArchiveFileToArrayIndex(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
6583 return listcatfiles
;
6585 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):
6586 outarray
= BytesIO();
6587 packcat
= PackArchiveFile(infiles
, outarray
, dirlistfromtxt
, compression
, compressionlevel
, followlink
, checksumtype
, formatspecs
, verbose
, True);
6588 listcatfiles
= ArchiveFileToArrayIndex(outarray
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
)
6589 return listcatfiles
;
6591 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):
6592 if(isinstance(infile
, dict)):
6593 prelistcatfiles
= ArchiveFileToArrayIndex(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, returnfp
);
6594 listcatfiles
= prelistcatfiles
['list'];
6596 if(infile
!="-" and not hasattr(infile
, "read") and not hasattr(infile
, "write")):
6597 infile
= RemoveWindowsPath(infile
);
6599 prelistcatfiles
= ArchiveFileToArrayIndex(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, returnfp
);
6600 listcatfiles
= prelistcatfiles
['list'];
6602 listcatfiles
= ArchiveFileToArray(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, returnfp
);
6603 if(outfile
!="-" and not hasattr(infile
, "read") and not hasattr(outfile
, "write")):
6604 outfile
= RemoveWindowsPath(outfile
);
6605 checksumtype
= checksumtype
.lower();
6606 if(not CheckSumSupport(checksumtype
, hashlib_guaranteed
)):
6607 checksumtype
="crc32";
6608 if(checksumtype
=="none"):
6610 if(not compression
or compression
or compression
=="catfile" or compression
==formatspecs
[2]):
6612 if(compression
not in compressionlist
and compression
is None):
6613 compression
= "auto";
6615 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
6616 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
6617 if(os
.path
.exists(outfile
)):
6619 if(not listcatfiles
):
6624 elif(hasattr(outfile
, "read") or hasattr(outfile
, "write")):
6626 elif(re
.findall(r
"^(ftp|ftps|sftp)\:\/\/", str(outfile
))):
6629 fbasename
= os
.path
.splitext(outfile
)[0];
6630 fextname
= os
.path
.splitext(outfile
)[1];
6631 catfp
= CompressOpenFile(outfile
, compressionlevel
);
6632 catver
= formatspecs
[6];
6633 fileheaderver
= str(int(catver
.replace(".", "")));
6634 fileheader
= AppendNullByte(formatspecs
[1] + fileheaderver
, formatspecs
[5]);
6635 catfp
.write(fileheader
.encode('UTF-8'));
6636 lenlist
= len(listcatfiles
['ffilelist']);
6637 fnumfiles
= int(listcatfiles
['fnumfiles']);
6638 if(lenlist
>fnumfiles
or lenlist
<fnumfiles
):
6639 fnumfiles
= lenlist
;
6640 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
6641 fnumfilesa
= AppendNullBytes([fnumfileshex
, checksumtype
], formatspecs
[5]);
6642 if(checksumtype
=="none" or checksumtype
==""):
6643 catfileheadercshex
= format(0, 'x').lower();
6644 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
6645 catfileheadercshex
= format(crc16(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
6646 elif(checksumtype
=="crc16_ccitt"):
6647 catfileheadercshex
= format(crc16_ccitt(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
6648 elif(checksumtype
=="adler32"):
6649 catfileheadercshex
= format(zlib
.adler32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
6650 elif(checksumtype
=="crc32"):
6651 catfileheadercshex
= format(crc32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
6652 elif(checksumtype
=="crc64_ecma"):
6653 catfileheadercshex
= format(crc64_ecma(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6654 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
6655 catfileheadercshex
= format(crc64_iso(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6656 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
6657 checksumoutstr
= hashlib
.new(checksumtype
);
6658 checksumoutstr
.update(str(fileheader
+ fnumfilesa
).encode('UTF-8'));
6659 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
6661 catfileheadercshex
= format(0, 'x').lower();
6662 fnumfilesa
= fnumfilesa
+ AppendNullByte(catfileheadercshex
, formatspecs
[5]);
6663 catfp
.write(fnumfilesa
.encode('UTF-8'));
6666 os
.fsync(catfp
.fileno());
6667 except io
.UnsupportedOperation
:
6669 except AttributeError:
6671 lenlist
= len(listcatfiles
['ffilelist']);
6672 fnumfiles
= int(listcatfiles
['fnumfiles']);
6674 lcfx
= int(listcatfiles
['fnumfiles']);
6675 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
6676 lcfx
= int(lenlist
);
6678 lcfx
= int(listcatfiles
['fnumfiles']);
6686 catfhstart
= catfp
.tell();
6687 if(re
.findall("^[.|/]", listcatfiles
['ffilelist'][reallcfi
]['fname'])):
6688 fname
= listcatfiles
['ffilelist'][reallcfi
]['fname'];
6690 fname
= "./"+listcatfiles
['ffilelist'][reallcfi
]['fname'];
6692 VerbosePrintOut(fname
);
6693 fheadersize
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fheadersize']), 'x').lower();
6694 fsize
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fsize']), 'x').lower();
6695 flinkname
= listcatfiles
['ffilelist'][reallcfi
]['flinkname'];
6696 fatime
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fatime']), 'x').lower();
6697 fmtime
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fmtime']), 'x').lower();
6698 fctime
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fctime']), 'x').lower();
6699 fbtime
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fbtime']), 'x').lower();
6700 fmode
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fmode']), 'x').lower();
6701 fchmode
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fchmode']), 'x').lower();
6702 fuid
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fuid']), 'x').lower();
6703 funame
= listcatfiles
['ffilelist'][reallcfi
]['funame'];
6704 fgid
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fgid']), 'x').lower();
6705 fgname
= listcatfiles
['ffilelist'][reallcfi
]['fgname'];
6706 finode
= listcatfiles
['ffilelist'][reallcfi
]['finode'];
6707 flinkcount
= listcatfiles
['ffilelist'][reallcfi
]['flinkcount'];
6708 fwinattributes
= flinkinfo
['ffilelist'][reallcfi
]['fwinattributes'];
6709 fdev_minor
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fminor']), 'x').lower();
6710 fdev_major
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fmajor']), 'x').lower();
6711 frdev_minor
= format(int(listcatfiles
['ffilelist'][reallcfi
]['frminor']), 'x').lower();
6712 frdev_major
= format(int(listcatfiles
['ffilelist'][reallcfi
]['frmajor']), 'x').lower();
6713 if(len(listcatfiles
['ffilelist'][reallcfi
]['fextralist'])>listcatfiles
['ffilelist'][reallcfi
]['fextrafields'] and len(listcatfiles
['ffilelist'][reallcfi
]['fextralist'])>0):
6714 listcatfiles
['ffilelist'][reallcfi
]['fextrafields'] = len(listcatfiles
['ffilelist'][reallcfi
]['fextralist']);
6715 if(len(extradata
)>0):
6716 listcatfiles
['ffilelist'][reallcfi
]['fextrafields'] = len(extradata
);
6717 listcatfiles
['ffilelist'][reallcfi
]['fextralist'] = extradata
;
6718 extrafields
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fextrafields']), 'x').lower();
6719 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[5]);
6720 if(len(extradata
)>0):
6721 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[5]);
6722 extrasizelen
= format(len(extrasizestr
), 'x').lower();
6723 fcontents
= listcatfiles
['ffilelist'][reallcfi
]['fcontents'];
6725 if(listcatfiles
['ffilelist'][reallcfi
]['ftype']==1 or listcatfiles
['ffilelist'][reallcfi
]['ftype']==2):
6726 getflinkpath
= listcatfiles
['ffilelist'][reallcfi
]['flinkname'];
6727 flinkid
= prelistcatfiles
['filetoid'][getflinkpath
];
6728 flinkinfo
= listcatfiles
['ffilelist'][flinkid
];
6729 fheadersize
= format(int(flinkinfo
['fheadersize']), 'x').lower();
6730 fsize
= format(int(flinkinfo
['fsize']), 'x').lower();
6731 flinkname
= flinkinfo
['flinkname'];
6732 fatime
= format(int(flinkinfo
['fatime']), 'x').lower();
6733 fmtime
= format(int(flinkinfo
['fmtime']), 'x').lower();
6734 fctime
= format(int(flinkinfo
['fctime']), 'x').lower();
6735 fbtime
= format(int(flinkinfo
['fbtime']), 'x').lower();
6736 fmode
= format(int(flinkinfo
['fmode']), 'x').lower();
6737 fchmode
= format(int(flinkinfo
['fchmode']), 'x').lower();
6738 fuid
= format(int(flinkinfo
['fuid']), 'x').lower();
6739 funame
= flinkinfo
['funame'];
6740 fgid
= format(int(flinkinfo
['fgid']), 'x').lower();
6741 fgname
= flinkinfo
['fgname'];
6742 finode
= flinkinfo
['finode'];
6743 flinkcount
= flinkinfo
['flinkcount'];
6744 fwinattributes
= flinkinfo
['fwinattributes'];
6745 fdev_minor
= format(int(flinkinfo
['fminor']), 'x').lower();
6746 fdev_major
= format(int(flinkinfo
['fmajor']), 'x').lower();
6747 frdev_minor
= format(int(flinkinfo
['frminor']), 'x').lower();
6748 frdev_major
= format(int(flinkinfo
['frmajor']), 'x').lower();
6749 if(len(flinkinfo
['fextralist'])>flinkinfo
['fextrafields'] and len(flinkinfo
['fextralist'])>0):
6750 flinkinfo
['fextrafields'] = len(flinkinfo
['fextralist']);
6751 if(len(extradata
)>0):
6752 flinkinfo
['fextrafields'] = len(extradata
);
6753 flinkinfo
['fextralist'] = extradata
;
6754 extrafields
= format(int(flinkinfo
['fextrafields']), 'x').lower();
6755 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[5]);
6756 if(len(extradata
)>0):
6757 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[5]);
6758 extrasizelen
= format(len(extrasizestr
), 'x').lower();
6759 fcontents
= flinkinfo
['fcontents'];
6760 if(flinkinfo
['ftype']!=0 and flinkinfo
['ftype']!=7):
6762 fcontents
= fcontents
.encode('UTF-8');
6763 except AttributeError:
6765 ftypehex
= format(flinkinfo
['ftype'], 'x').lower();
6767 if(listcatfiles
['ffilelist'][reallcfi
]['ftype']!=0 and listcatfiles
['ffilelist'][reallcfi
]['ftype']!=7):
6769 fcontents
= fcontents
.encode('UTF-8');
6770 except AttributeError:
6772 ftypehex
= format(listcatfiles
['ffilelist'][reallcfi
]['ftype'], 'x').lower();
6773 fcurfid
= format(curfid
, 'x').lower();
6774 if(not followlink
and finode
!=0):
6775 if(listcatfiles
['ffilelist'][reallcfi
]['ftype']!=1):
6776 fcurinode
= format(int(curinode
), 'x').lower();
6777 inodetofile
.update({curinode
: fname
});
6778 filetoinode
.update({fname
: curinode
});
6779 curinode
= curinode
+ 1;
6781 fcurinode
= format(int(filetoinode
[flinkname
]), 'x').lower();
6783 fcurinode
= format(int(curinode
), 'x').lower();
6784 curinode
= curinode
+ 1;
6785 curfid
= curfid
+ 1;
6786 catoutlist
= [ftypehex
, fname
, flinkname
, fsize
, fatime
, fmtime
, fctime
, fbtime
, fmode
, fwinattributes
, fuid
, funame
, fgid
, fgname
, fcurfid
, fcurinode
, flinkcount
, fdev_minor
, fdev_major
, frdev_minor
, frdev_major
, extrasizelen
, extrafields
];
6787 catoutlen
= len(catoutlist
) + len(extradata
) + 3;
6788 catoutlenhex
= format(catoutlen
, 'x').lower();
6789 catoutlist
.insert(0, catoutlenhex
);
6790 catfileoutstr
= AppendNullBytes(catoutlist
, formatspecs
[5]);
6791 if(listcatfiles
['ffilelist'][reallcfi
]['fextrafields']>0):
6792 extrafieldslist
= [];
6794 exil
= listcatfiles
['ffilelist'][reallcfi
]['fextrafields'];
6796 extrafieldslist
.append(listcatfiles
['ffilelist'][reallcfi
]['fextralist']);
6798 catfileoutstr
+= AppendNullBytes([extrafieldslist
], formatspecs
[5]);
6799 catfileoutstr
+= AppendNullBytes([checksumtype
], formatspecs
[5]);
6800 catfhend
= (catfp
.tell() - 1) + len(catfileoutstr
);
6801 catfcontentstart
= catfp
.tell() + len(catfileoutstr
);
6802 if(checksumtype
=="none" or checksumtype
==""):
6803 catfileheadercshex
= format(0, 'x').lower();
6804 catfilecontentcshex
= format(0, 'x').lower();
6805 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
6806 catfileheadercshex
= format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
6807 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
6808 elif(checksumtype
=="crc16_ccitt"):
6809 catfileheadercshex
= format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
6810 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
6811 elif(checksumtype
=="adler32"):
6812 catfileheadercshex
= format(zlib
.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
6813 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
6814 elif(checksumtype
=="crc32"):
6815 catfileheadercshex
= format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
6816 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
6817 elif(checksumtype
=="crc64_ecma"):
6818 catfileheadercshex
= format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6819 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
6820 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
6821 catfileheadercshex
= format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6822 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
6823 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
6824 checksumoutstr
= hashlib
.new(checksumtype
);
6825 checksumoutstr
.update("".encode('UTF-8'));
6826 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
6827 checksumoutstr
= hashlib
.new(checksumtype
);
6828 checksumoutstr
.update(fcontents
);
6829 catfilecontentcshex
= checksumoutstr
.hexdigest().lower();
6831 catfileheadercshex
= format(0, 'x').lower();
6832 catfilecontentcshex
= format(0, 'x').lower();
6833 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
6834 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
6835 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[5]) + catfileoutstr
;
6836 if(checksumtype
=="none" or checksumtype
==""):
6837 catfileheadercshex
= format(0, 'x').lower();
6838 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
6839 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
6840 elif(checksumtype
=="crc16_ccitt"):
6841 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
6842 elif(checksumtype
=="adler32"):
6843 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
6844 elif(checksumtype
=="crc32"):
6845 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
6846 elif(checksumtype
=="crc64_ecma"):
6847 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6848 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
6849 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
6850 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
6851 checksumoutstr
= hashlib
.new(checksumtype
);
6852 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
6853 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
6855 catfileheadercshex
= format(0, 'x').lower();
6856 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[5]);
6857 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
6858 nullstrecd
= formatspecs
[5].encode('UTF-8');
6859 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
;
6860 catfcontentend
= (catfp
.tell() - 1) + len(catfileout
);
6861 catfp
.write(catfileout
);
6864 os
.fsync(catfp
.fileno());
6865 except io
.UnsupportedOperation
:
6867 except AttributeError:
6870 reallcfi
= reallcfi
+ 1;
6872 catfp
.write(AppendNullBytes([0, 0], formatspecs
[5]).encode("UTF-8"));
6873 if(outfile
=="-" or hasattr(outfile
, "read") or hasattr(outfile
, "write")):
6874 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
6877 os
.fsync(catfp
.fileno());
6878 except io
.UnsupportedOperation
:
6880 except AttributeError:
6884 if(hasattr(sys
.stdout
, "buffer")):
6885 shutil
.copyfileobj(catfp
, sys
.stdout
.buffer);
6887 shutil
.copyfileobj(catfp
, sys
.stdout
);
6888 elif(re
.findall(r
"^(ftp|ftps|sftp)\:\/\/", str(outfile
))):
6889 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
6891 upload_file_to_internet_file(catfp
, outfile
);
6899 create_alias_function("RePack", __file_format_name__
, "", RePackArchiveFile
);
6901 def RePackArchiveFileFromString(catstr
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", skipchecksum
=False, extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
6902 catfp
= BytesIO(catstr
);
6903 listcatfiles
= RePackArchiveFile(catfp
, compression
, compressionlevel
, checksumtype
, skipchecksum
, extradata
, formatspecs
, verbose
, returnfp
);
6904 return listcatfiles
;
6906 create_alias_function("RePack", __file_format_name__
, "FromString", RePackArchiveFileFromString
);
6908 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):
6909 outarray
= BytesIO();
6910 packcat
= PackArchiveFile(infiles
, outarray
, dirlistfromtxt
, compression
, compressionlevel
, followlink
, checksumtype
, extradata
, formatspecs
, verbose
, True);
6911 listcatfiles
= RePackArchiveFile(outarray
, outfile
, compression
, compressionlevel
, checksumtype
, skipchecksum
, extradata
, formatspecs
, verbose
, returnfp
);
6912 return listcatfiles
;
6914 create_alias_function("Pack", __file_format_name__
, "FromListDir", PackArchiveFileFromListDir
);
6916 def ArchiveFileArrayBase64Encode(infile
, followlink
=False, seekstart
=0, seekend
=0, skipchecksum
=False, formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
6918 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
6919 if(isinstance(infile
, dict)):
6920 prelistcatfiles
= ArchiveFileToArrayIndex(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, returnfp
);
6921 listcatfiles
= prelistcatfiles
['list'];
6923 if(infile
!="-" and not hasattr(infile
, "read") and not hasattr(infile
, "write")):
6924 infile
= RemoveWindowsPath(infile
);
6926 prelistcatfiles
= ArchiveFileToArrayIndex(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, returnfp
);
6927 listcatfiles
= prelistcatfiles
['list'];
6929 listcatfiles
= ArchiveFileToArray(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, returnfp
);
6930 if(not listcatfiles
):
6932 lenlist
= len(listcatfiles
['ffilelist']);
6933 fnumfiles
= int(listcatfiles
['fnumfiles']);
6935 lcfx
= int(listcatfiles
['fnumfiles']);
6936 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
6937 lcfx
= int(lenlist
);
6939 lcfx
= int(listcatfiles
['fnumfiles']);
6941 if(listcatfiles
['ffilelist'][lcfi
]['fhascontents']):
6942 listcatfiles
['ffilelist'][lcfi
]['fcontents'] = base64
.b64encode(listcatfiles
['ffilelist'][lcfi
]['fcontents']).decode("UTF-8");
6944 return listcatfiles
;
6946 create_alias_function("", __file_format_name__
, "ArrayBase64Encode", ArchiveFileArrayBase64Encode
);
6948 def ArchiveFileArrayBase64Decode(infile
, followlink
=False, seekstart
=0, seekend
=0, skipchecksum
=False, formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
6950 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
6951 if(isinstance(infile
, dict)):
6952 prelistcatfiles
= ArchiveFileToArrayIndex(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, returnfp
);
6953 listcatfiles
= prelistcatfiles
['list'];
6955 if(infile
!="-" and not hasattr(infile
, "read") and not hasattr(infile
, "write")):
6956 infile
= RemoveWindowsPath(infile
);
6958 prelistcatfiles
= ArchiveFileToArrayIndex(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, returnfp
);
6959 listcatfiles
= prelistcatfiles
['list'];
6961 listcatfiles
= ArchiveFileToArray(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, returnfp
);
6962 if(not listcatfiles
):
6964 lenlist
= len(listcatfiles
['ffilelist']);
6965 fnumfiles
= int(listcatfiles
['fnumfiles']);
6967 lcfx
= int(listcatfiles
['fnumfiles']);
6968 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
6969 lcfx
= int(lenlist
);
6971 lcfx
= int(listcatfiles
['fnumfiles']);
6973 if(listcatfiles
['ffilelist'][lcfi
]['fhascontents']):
6974 listcatfiles
['ffilelist'][lcfi
]['fcontents'] = base64
.b64decode(listcatfiles
['ffilelist'][lcfi
]['fcontents'].encode("UTF-8"));
6976 return listcatfiles
;
6978 create_alias_function("", __file_format_name__
, "ArrayBase64Decode", ArchiveFileArrayBase64Decode
);
6980 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):
6981 if(outdir
is not None):
6982 outdir
= RemoveWindowsPath(outdir
);
6984 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
6985 if(isinstance(infile
, dict)):
6986 prelistcatfiles
= ArchiveFileToArrayIndex(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, returnfp
);
6987 listcatfiles
= prelistcatfiles
['list'];
6989 if(infile
!="-" and not hasattr(infile
, "read") and not hasattr(infile
, "write")):
6990 infile
= RemoveWindowsPath(infile
);
6992 prelistcatfiles
= ArchiveFileToArrayIndex(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, returnfp
);
6993 listcatfiles
= prelistcatfiles
['list'];
6995 listcatfiles
= ArchiveFileToArray(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, returnfp
);
6996 if(not listcatfiles
):
6998 lenlist
= len(listcatfiles
['ffilelist']);
6999 fnumfiles
= int(listcatfiles
['fnumfiles']);
7001 lcfx
= int(listcatfiles
['fnumfiles']);
7002 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
7003 lcfx
= int(lenlist
);
7005 lcfx
= int(listcatfiles
['fnumfiles']);
7011 userinfo
= pwd
.getpwuid(listcatfiles
['ffilelist'][lcfi
]['fuid']);
7012 funame
= userinfo
.pw_name
;
7021 groupinfo
= grp
.getgrgid(listcatfiles
['ffilelist'][lcfi
]['fgid']);
7022 fgname
= groupinfo
.gr_name
;
7028 VerbosePrintOut(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']));
7029 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==0 or listcatfiles
['ffilelist'][lcfi
]['ftype']==7):
7030 with
open(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), "wb") as fpc
:
7031 fpc
.write(listcatfiles
['ffilelist'][lcfi
]['fcontents'])
7034 os
.fsync(fpc
.fileno())
7035 except io
.UnsupportedOperation
:
7037 except AttributeError:
7039 if(hasattr(os
, "chown") and funame
==listcatfiles
['ffilelist'][lcfi
]['funame'] and fgname
==listcatfiles
['ffilelist'][lcfi
]['fgname'] and preservepermissions
):
7040 os
.chown(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), listcatfiles
['ffilelist'][lcfi
]['fuid'], listcatfiles
['ffilelist'][lcfi
]['fgid']);
7041 if(preservepermissions
):
7042 os
.chmod(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), listcatfiles
['ffilelist'][lcfi
]['fchmode']);
7044 os
.utime(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), (listcatfiles
['ffilelist'][lcfi
]['fatime'], listcatfiles
['ffilelist'][lcfi
]['fmtime']));
7045 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==1):
7047 getflinkpath
= listcatfiles
['ffilelist'][lcfi
]['flinkname'];
7048 flinkid
= prelistcatfiles
['filetoid'][getflinkpath
];
7049 flinkinfo
= listcatfiles
['ffilelist'][flinkid
];
7054 userinfo
= pwd
.getpwuid(flinkinfo
['fuid']);
7055 funame
= userinfo
.pw_name
;
7064 groupinfo
= grp
.getgrgid(flinkinfo
['fgid']);
7065 fgname
= groupinfo
.gr_name
;
7070 if(flinkinfo
['ftype']==0 or flinkinfo
['ftype']==7):
7071 with
open(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), "wb") as fpc
:
7072 fpc
.write(flinkinfo
['fcontents'])
7075 os
.fsync(fpc
.fileno())
7076 except io
.UnsupportedOperation
:
7078 except AttributeError:
7080 if(hasattr(os
, "chown") and funame
==flinkinfo
['funame'] and fgname
==flinkinfo
['fgname'] and preservepermissions
):
7081 os
.chown(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), flinkinfo
['fuid'], flinkinfo
['fgid']);
7082 if(preservepermissions
):
7083 os
.chmod(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), flinkinfo
['fchmode']);
7085 os
.utime(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), (flinkinfo
['fatime'], flinkinfo
['fmtime']));
7086 if(flinkinfo
['ftype']==1):
7087 os
.link(flinkinfo
['flinkname'], PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']));
7088 if(flinkinfo
['ftype']==2):
7089 os
.symlink(flinkinfo
['flinkname'], PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']));
7090 if(flinkinfo
['ftype']==5):
7091 if(preservepermissions
):
7092 os
.mkdir(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), flinkinfo
['fchmode']);
7094 os
.mkdir(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']));
7095 if(hasattr(os
, "chown") and funame
==flinkinfo
['funame'] and fgname
==flinkinfo
['fgname'] and preservepermissions
):
7096 os
.chown(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), flinkinfo
['fuid'], flinkinfo
['fgid']);
7097 if(preservepermissions
):
7098 os
.chmod(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), flinkinfo
['fchmode']);
7100 os
.utime(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), (flinkinfo
['fatime'], flinkinfo
['fmtime']));
7101 if(flinkinfo
['ftype']==6 and hasattr(os
, "mkfifo")):
7102 os
.mkfifo(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), flinkinfo
['fchmode']);
7104 os
.link(listcatfiles
['ffilelist'][lcfi
]['flinkname'], PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']));
7105 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==2):
7107 getflinkpath
= listcatfiles
['ffilelist'][lcfi
]['flinkname'];
7108 flinkid
= prelistcatfiles
['filetoid'][getflinkpath
];
7109 flinkinfo
= listcatfiles
['ffilelist'][flinkid
];
7114 userinfo
= pwd
.getpwuid(flinkinfo
['fuid']);
7115 funame
= userinfo
.pw_name
;
7124 groupinfo
= grp
.getgrgid(flinkinfo
['fgid']);
7125 fgname
= groupinfo
.gr_name
;
7130 if(flinkinfo
['ftype']==0 or flinkinfo
['ftype']==7):
7131 with
open(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), "wb") as fpc
:
7132 fpc
.write(flinkinfo
['fcontents'])
7135 os
.fsync(fpc
.fileno())
7136 except io
.UnsupportedOperation
:
7138 except AttributeError:
7140 if(hasattr(os
, "chown") and funame
==flinkinfo
['funame'] and fgname
==flinkinfo
['fgname'] and preservepermissions
):
7141 os
.chown(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), flinkinfo
['fuid'], flinkinfo
['fgid']);
7142 if(preservepermissions
):
7143 os
.chmod(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), flinkinfo
['fchmode']);
7145 os
.utime(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), (flinkinfo
['fatime'], flinkinfo
['fmtime']));
7146 if(flinkinfo
['ftype']==1):
7147 os
.link(flinkinfo
['flinkname'], PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']));
7148 if(flinkinfo
['ftype']==2):
7149 os
.symlink(flinkinfo
['flinkname'], PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']));
7150 if(flinkinfo
['ftype']==5):
7151 if(preservepermissions
):
7152 os
.mkdir(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), flinkinfo
['fchmode']);
7154 os
.mkdir(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']));
7155 if(hasattr(os
, "chown") and funame
==flinkinfo
['funame'] and fgname
==flinkinfo
['fgname'] and preservepermissions
):
7156 os
.chown(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), flinkinfo
['fuid'], flinkinfo
['fgid']);
7157 if(preservepermissions
):
7158 os
.chmod(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), flinkinfo
['fchmode']);
7160 os
.utime(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), (flinkinfo
['fatime'], flinkinfo
['fmtime']));
7161 if(flinkinfo
['ftype']==6 and hasattr(os
, "mkfifo")):
7162 os
.mkfifo(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), flinkinfo
['fchmode']);
7164 os
.symlink(listcatfiles
['ffilelist'][lcfi
]['flinkname'], PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']));
7165 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==5):
7166 if(preservepermissions
):
7167 os
.mkdir(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), listcatfiles
['ffilelist'][lcfi
]['fchmode']);
7169 os
.mkdir(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']));
7170 if(hasattr(os
, "chown") and funame
==listcatfiles
['ffilelist'][lcfi
]['funame'] and fgname
==listcatfiles
['ffilelist'][lcfi
]['fgname'] and preservepermissions
):
7171 os
.chown(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), listcatfiles
['ffilelist'][lcfi
]['fuid'], listcatfiles
['ffilelist'][lcfi
]['fgid']);
7172 if(preservepermissions
):
7173 os
.chmod(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), listcatfiles
['ffilelist'][lcfi
]['fchmode']);
7175 os
.utime(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), (listcatfiles
['ffilelist'][lcfi
]['fatime'], listcatfiles
['ffilelist'][lcfi
]['fmtime']));
7176 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==6 and hasattr(os
, "mkfifo")):
7177 os
.mkfifo(PrependPath(outdir
, listcatfiles
['ffilelist'][lcfi
]['fname']), listcatfiles
['ffilelist'][lcfi
]['fchmode']);
7180 return listcatfiles
['ffilelist']['catfp'];
7184 create_alias_function("UnPack", __file_format_name__
, "", UnPackArchiveFile
);
7186 if(hasattr(shutil
, "register_unpack_format")):
7187 def UnPackArchiveFileFunc(archive_name
, extract_dir
=None, **kwargs
):
7188 return UnPackArchiveFile(archive_name
, extract_dir
, False, 0, 0, False, __file_format_delimiter__
, False, False);
7189 create_alias_function("UnPack", __file_format_name__
, "Func", UnPackArchiveFileFunc
);
7191 def UnPackArchiveFileString(catstr
, outdir
=None, followlink
=False, seekstart
=0, seekend
=0, skipchecksum
=False, formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
7192 catfp
= BytesIO(catstr
);
7193 listcatfiles
= UnPackArchiveFile(catfp
, outdir
, followlink
, seekstart
, seekend
, skipchecksum
, formatspecs
, verbose
, returnfp
);
7194 return listcatfiles
;
7196 create_alias_function("UnPack", __file_format_name__
, "String", UnPackArchiveFileString
);
7198 def ArchiveFileListFiles(infile
, seekstart
=0, seekend
=0, skipchecksum
=False, formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
7199 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
7200 if(isinstance(infile
, dict)):
7201 listcatfiles
= infile
;
7203 if(infile
!="-" and not hasattr(infile
, "read") and not hasattr(infile
, "write")):
7204 infile
= RemoveWindowsPath(infile
);
7205 listcatfiles
= ArchiveFileToArray(infile
, seekstart
, seekend
, True, skipchecksum
, formatspecs
, returnfp
);
7206 if(not listcatfiles
):
7208 lenlist
= len(listcatfiles
['ffilelist']);
7209 fnumfiles
= int(listcatfiles
['fnumfiles']);
7211 lcfx
= int(listcatfiles
['fnumfiles']);
7212 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
7213 lcfx
= int(lenlist
);
7215 lcfx
= int(listcatfiles
['fnumfiles']);
7218 returnval
.update({lcfi
: listcatfiles
['ffilelist'][lcfi
]['fname']});
7220 VerbosePrintOut(listcatfiles
['ffilelist'][lcfi
]['fname']);
7222 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' } };
7223 printfname
= listcatfiles
['ffilelist'][lcfi
]['fname'];
7224 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==1):
7225 printfname
= listcatfiles
['ffilelist'][lcfi
]['fname'] + " link to " + listcatfiles
['ffilelist'][lcfi
]['flinkname'];
7226 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==2):
7227 printfname
= listcatfiles
['ffilelist'][lcfi
]['fname'] + " -> " + listcatfiles
['ffilelist'][lcfi
]['flinkname'];
7228 fuprint
= listcatfiles
['ffilelist'][lcfi
]['funame'];
7229 if(len(fuprint
)<=0):
7230 fuprint
= listcatfiles
['ffilelist'][lcfi
]['fuid'];
7231 fgprint
= listcatfiles
['ffilelist'][lcfi
]['fgname'];
7232 if(len(fgprint
)<=0):
7233 fgprint
= listcatfiles
['ffilelist'][lcfi
]['fgid'];
7234 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
));
7237 return listcatfiles
['catfp'];
7241 create_alias_function("", __file_format_name__
, "ListFiles", ArchiveFileListFiles
);
7243 def ArchiveFileStringListFiles(catstr
, seekstart
=0, seekend
=0, skipchecksum
=False, formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
7244 catfp
= BytesIO(catstr
);
7245 listcatfiles
= ArchiveFileListFiles(catstr
, seekstart
, seekend
, skipchecksum
, formatspecs
, verbose
, returnfp
);
7246 return listcatfiles
;
7248 create_alias_function("", __file_format_name__
, "StringListFiles", ArchiveFileStringListFiles
);
7250 def TarFileListFiles(infile
, verbose
=False, returnfp
=False):
7251 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
7254 if(hasattr(sys
.stdin
, "buffer")):
7255 shutil
.copyfileobj(sys
.stdin
.buffer, infile
);
7257 shutil
.copyfileobj(sys
.stdin
, infile
);
7262 elif(re
.findall(r
"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile
))):
7263 infile
= download_file_from_internet_file(infile
);
7268 elif(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
7270 elif(os
.path
.exists(infile
) and os
.path
.isfile(infile
)):
7272 if(not tarfile
.is_tarfile(infile
)):
7274 except AttributeError:
7275 if(not is_tarfile(infile
)):
7280 if(hasattr(infile
, "read") or hasattr(infile
, "write")):
7281 tarfp
= tarfile
.open(fileobj
=infile
, mode
="r");
7283 tarfp
= tarfile
.open(infile
, "r");
7284 except FileNotFoundError
:
7288 for member
in sorted(tarfp
.getmembers(), key
=lambda x
: x
.name
):
7289 returnval
.update({lcfi
: member
.name
});
7290 fpremode
= member
.mode
;
7291 ffullmode
= member
.mode
;
7295 ffullmode
= member
.mode
+ stat
.S_IFREG
;
7297 elif(member
.isdev()):
7298 ffullmode
= member
.mode
;
7300 elif(member
.islnk()):
7301 ffullmode
= member
.mode
+ stat
.S_IFREG
;
7303 elif(member
.issym()):
7304 ffullmode
= member
.mode
+ stat
.S_IFLNK
;
7306 elif(member
.ischr()):
7307 ffullmode
= member
.mode
+ stat
.S_IFCHR
;
7309 elif(member
.isblk()):
7310 ffullmode
= member
.mode
+ stat
.S_IFBLK
;
7312 elif(member
.isdir()):
7313 ffullmode
= member
.mode
+ stat
.S_IFDIR
;
7315 elif(member
.isfifo()):
7316 ffullmode
= member
.mode
+ stat
.S_IFIFO
;
7318 elif(member
.issparse()):
7319 ffullmode
= member
.mode
;
7322 VerbosePrintOut(member
.name
);
7324 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' } };
7325 printfname
= member
.name
;
7327 printfname
= member
.name
+ " link to " + member
.linkname
;
7328 elif(member
.issym()):
7329 printfname
= member
.name
+ " -> " + member
.linkname
;
7330 fuprint
= member
.uname
;
7331 if(len(fuprint
)<=0):
7332 fuprint
= member
.uid
;
7333 fgprint
= member
.gname
;
7334 if(len(fgprint
)<=0):
7335 fgprint
= member
.gid
;
7336 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
));
7339 return listcatfiles
['catfp'];
7343 def ZipFileListFiles(infile
, verbose
=False, returnfp
=False):
7344 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
7347 if(hasattr(sys
.stdin
, "buffer")):
7348 shutil
.copyfileobj(sys
.stdin
.buffer, infile
);
7350 shutil
.copyfileobj(sys
.stdin
, infile
);
7355 elif(re
.findall(r
"^(http|https|ftp|ftps|sftp)\:\/\/", str(infile
))):
7356 infile
= download_file_from_internet_file(infile
);
7361 elif(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
7365 if(not zipfile
.is_zipfile(infile
)):
7368 zipfp
= zipfile
.ZipFile(infile
, "r", allowZip64
=True);
7369 except FileNotFoundError
:
7373 ziptest
= zipfp
.testzip();
7375 VerbosePrintOut("Bad file found!");
7376 for member
in sorted(zipfp
.infolist(), key
=lambda x
: x
.filename
):
7377 if(zipinfo
.create_system
==0 or zipinfo
.create_system
==10):
7378 fwinattributes
= int(zipinfo
.external_attr
);
7379 if(not member
.is_dir()):
7380 fmode
= int(stat
.S_IFREG
+ 438);
7381 fchmode
= int(stat
.S_IMODE(fmode
));
7382 ftypemod
= int(stat
.S_IFMT(fmode
));
7383 elif(member
.is_dir()):
7384 fmode
= int(stat
.S_IFDIR
+ 511);
7385 fchmode
= int(stat
.S_IMODE(int(stat
.S_IFDIR
+ 511)));
7386 ftypemod
= int(stat
.S_IFMT(int(stat
.S_IFDIR
+ 511)));
7387 elif(zipinfo
.create_system
==3):
7388 fwinattributes
=int(0);
7389 fmode
= int(zipinfo
.external_attr
);
7390 fchmode
= int(stat
.S_IMODE(fmode
));
7391 ftypemod
= int(stat
.S_IFMT(fmode
));
7393 fwinattributes
= int(0);
7394 if(not member
.is_dir()):
7395 fmode
= int(stat
.S_IFREG
+ 438);
7396 fchmode
= int(stat
.S_IMODE(fmode
));
7397 ftypemod
= int(stat
.S_IFMT(fmode
));
7398 elif(member
.is_dir()):
7399 fmode
= int(stat
.S_IFDIR
+ 511);
7400 fchmode
= int(stat
.S_IMODE(int(stat
.S_IFDIR
+ 511)));
7401 ftypemod
= int(stat
.S_IFMT(int(stat
.S_IFDIR
+ 511)));
7402 returnval
.update({lcfi
: member
.filename
});
7404 VerbosePrintOut(member
.filename
);
7406 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' } };
7408 for fmodval
in str(oct(fmode
))[-3:]:
7409 permissionstr
= permissionstr
+ permissions
['access'].get(fmodval
, '---');
7410 if(not member
.is_dir()):
7412 permissionstr
= "-" + permissionstr
;
7413 elif(member
.is_dir()):
7415 permissionstr
= "d" + permissionstr
;
7416 printfname
= member
.filename
;
7418 fuid
= int(os
.getuid());
7419 except AttributeError:
7424 fgid
= int(os
.getgid());
7425 except AttributeError:
7432 userinfo
= pwd
.getpwuid(os
.getuid());
7433 funame
= userinfo
.pw_name
;
7436 except AttributeError:
7444 groupinfo
= grp
.getgrgid(os
.getgid());
7445 fgname
= groupinfo
.gr_name
;
7448 except AttributeError:
7453 if(len(fuprint
)<=0):
7454 fuprint
= str(fuid
);
7456 if(len(fgprint
)<=0):
7457 fgprint
= str(fgid
);
7458 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
));
7461 return listcatfiles
['catfp'];
7465 if(not rarfile_support
):
7466 def RarFileListFiles(infile
, verbose
=False, returnfp
=False):
7467 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
7468 if(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
7471 if(rarfile_support
):
7472 def RarFileListFiles(infile
, verbose
=False, returnfp
=False):
7473 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
7474 if(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
7476 if(not rarfile
.is_rarfile(infile
) and not rarfile
.is_rarfile_sfx(infile
)):
7480 rarfp
= rarfile
.RarFile(infile
, "r");
7481 rartest
= rarfp
.testrar();
7483 VerbosePrintOut("Bad file found!");
7484 for member
in sorted(rarfp
.infolist(), key
=lambda x
: x
.filename
):
7487 if(member
.host_os
==rarfile
.RAR_OS_UNIX
):
7490 member
.external_attr
7492 except AttributeError:
7494 elif(member
.host_os
==rarfile
.RAR_OS_WIN32
):
7497 member
.external_attr
7499 except AttributeError:
7504 if(is_unix
and member
.external_attr
!=0):
7505 fpremode
= int(member
.external_attr
);
7506 elif(member
.is_file()):
7507 fpremode
= int(stat
.S_IFREG
+ 438);
7508 elif(member
.is_symlink()):
7509 fpremode
= int(stat
.S_IFLNK
+ 438);
7510 elif(member
.is_dir()):
7511 fpremode
= int(stat
.S_IFDIR
+ 511);
7512 if(is_windows
and member
.external_attr
!=0):
7513 fwinattributes
= int(member
.external_attr
);
7515 fwinattributes
= int(0);
7516 if(is_unix
and member
.external_attr
!=0):
7517 fmode
= int(member
.external_attr
);
7518 fchmode
= int(stat
.S_IMODE(member
.external_attr
));
7519 ftypemod
= int(stat
.S_IFMT(member
.external_attr
));
7520 elif(member
.is_file()):
7521 fmode
= int(stat
.S_IFREG
+ 438);
7522 fchmode
= int(stat
.S_IMODE(int(stat
.S_IFREG
+ 438)));
7523 ftypemod
= int(stat
.S_IFMT(int(stat
.S_IFREG
+ 438)));
7524 elif(member
.is_symlink()):
7525 fmode
= int(stat
.S_IFLNK
+ 438);
7526 fchmode
= int(stat
.S_IMODE(int(stat
.S_IFLNK
+ 438)));
7527 ftypemod
= int(stat
.S_IFMT(int(stat
.S_IFLNK
+ 438)));
7528 elif(member
.is_dir()):
7529 fmode
= int(stat
.S_IFDIR
+ 511);
7530 fchmode
= int(stat
.S_IMODE(int(stat
.S_IFDIR
+ 511)));
7531 ftypemod
= int(stat
.S_IFMT(int(stat
.S_IFDIR
+ 511)));
7532 returnval
.update({lcfi
: member
.filename
});
7534 VerbosePrintOut(member
.filename
);
7536 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' } };
7538 for fmodval
in str(oct(fmode
))[-3:]:
7539 permissionstr
= permissionstr
+ permissions
['access'].get(fmodval
, '---');
7540 if(member
.is_file()):
7542 permissionstr
= "-" + permissionstr
;
7543 printfname
= member
.filename
;
7544 elif(member
.is_symlink()):
7546 permissionstr
= "l" + permissionstr
;
7547 printfname
= member
.name
+ " -> " + member
.read().decode("UTF-8");
7548 elif(member
.is_dir()):
7550 permissionstr
= "d" + permissionstr
;
7551 printfname
= member
.filename
;
7553 fuid
= int(os
.getuid());
7554 except AttributeError:
7559 fgid
= int(os
.getgid());
7560 except AttributeError:
7567 userinfo
= pwd
.getpwuid(os
.getuid());
7568 funame
= userinfo
.pw_name
;
7571 except AttributeError:
7579 groupinfo
= grp
.getgrgid(os
.getgid());
7580 fgname
= groupinfo
.gr_name
;
7583 except AttributeError:
7588 if(len(fuprint
)<=0):
7589 fuprint
= str(fuid
);
7591 if(len(fgprint
)<=0):
7592 fgprint
= str(fgid
);
7593 VerbosePrintOut(PrintPermissionString(fmode
, ftype
) + " " + str(str(fuprint
) + "/" + str(fgprint
) + " " + str(member
.file_size
).rjust(15) + " " + member
.mtime
.strftime('%Y-%m-%d %H:%M') + " " + printfname
));
7596 return listcatfiles
['catfp'];
7600 if(not py7zr_support
):
7601 def SevenZipFileListFiles(infile
, verbose
=False, returnfp
=False):
7602 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
7603 if(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
7607 def SevenZipFileListFiles(infile
, verbose
=False, returnfp
=False):
7608 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
7609 if(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
7613 szpfp
= py7zr
.SevenZipFile(infile
, mode
="r");
7614 file_content
= szpfp
.readall();
7615 #sztest = szpfp.testzip();
7616 sztestalt
= szpfp
.test();
7618 VerbosePrintOut("Bad file found!");
7619 for member
in sorted(szpfp
.list(), key
=lambda x
: x
.filename
):
7620 if(re
.findall("^[.|/]", member
.filename
)):
7621 fname
= member
.filename
;
7623 fname
= "./"+member
.filename
;
7624 if(not member
.is_directory
):
7625 fpremode
= int(stat
.S_IFREG
+ 438);
7626 elif(member
.is_directory
):
7627 fpremode
= int(stat
.S_IFDIR
+ 511);
7628 fwinattributes
= int(0);
7629 if(member
.is_directory
):
7630 fmode
= int(stat
.S_IFDIR
+ 511);
7631 fchmode
= int(stat
.S_IMODE(int(stat
.S_IFDIR
+ 511)));
7632 ftypemod
= int(stat
.S_IFMT(int(stat
.S_IFDIR
+ 511)));
7634 fmode
= int(stat
.S_IFLNK
+ 438);
7635 fchmode
= int(stat
.S_IMODE(int(stat
.S_IFLNK
+ 438)));
7636 ftypemod
= int(stat
.S_IFMT(int(stat
.S_IFLNK
+ 438)));
7637 returnval
.update({lcfi
: member
.filename
});
7639 VerbosePrintOut(member
.filename
);
7641 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' } };
7643 for fmodval
in str(oct(fmode
))[-3:]:
7644 permissionstr
= permissionstr
+ permissions
['access'].get(fmodval
, '---');
7646 if(not member
.is_directory
):
7648 permissionstr
= "-" + permissionstr
;
7649 printfname
= member
.filename
;
7650 elif(member
.is_directory
):
7652 permissionstr
= "d" + permissionstr
;
7653 printfname
= member
.filename
;
7655 fsize
= len(file_content
[member
.filename
].read());
7656 file_content
[member
.filename
].close();
7658 fuid
= int(os
.getuid());
7659 except AttributeError:
7664 fgid
= int(os
.getgid());
7665 except AttributeError:
7672 userinfo
= pwd
.getpwuid(os
.getuid());
7673 funame
= userinfo
.pw_name
;
7676 except AttributeError:
7684 groupinfo
= grp
.getgrgid(os
.getgid());
7685 fgname
= groupinfo
.gr_name
;
7688 except AttributeError:
7693 if(len(fuprint
)<=0):
7694 fuprint
= str(fuid
);
7696 if(len(fgprint
)<=0):
7697 fgprint
= str(fgid
);
7698 VerbosePrintOut(PrintPermissionString(fmode
, ftype
) + " " + str(str(fuprint
) + "/" + str(fgprint
) + " " + str(fsize
).rjust(15) + " " + member
.creationtime
.strftime('%Y-%m-%d %H:%M') + " " + printfname
));
7701 return listcatfiles
['catfp'];
7705 def InFileListFiles(infile
, verbose
=False, formatspecs
=__file_format_list__
, returnfp
=False):
7706 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
7707 checkcompressfile
= CheckCompressionSubType(infile
, formatspecs
, True);
7708 if(checkcompressfile
=="tarfile"):
7709 return TarFileListFiles(infile
, verbose
, returnfp
);
7710 elif(checkcompressfile
=="zipfile"):
7711 return ZipFileListFiles(infile
, verbose
, returnfp
);
7712 elif(checkcompressfile
=="catfile"):
7713 return ArchiveFileListFiles(infile
, 0, 0, False, formatspecs
, verbose
, returnfp
);
7714 elif(rarfile_support
and checkcompressfile
=="rarfile"):
7715 return RarFileListFiles(infile
, verbose
, returnfp
);
7716 elif(py7zr_support
and checkcompressfile
=="7zipfile"):
7717 return SevenZipFileListFiles(infile
, verbose
, returnfp
);
7722 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):
7723 outarray
= BytesIO();
7724 packcat
= PackArchiveFile(infiles
, outarray
, dirlistfromtxt
, compression
, compressionlevel
, followlink
, checksumtype
, formatspecs
, False, True);
7725 listcatfiles
= ArchiveFileListFiles(outarray
, seekstart
, seekend
, skipchecksum
, formatspecs
, verbose
, returnfp
);
7726 return listcatfiles
;
7728 def ListDirListFilesAlt(infiles
, dirlistfromtxt
=False, followlink
=False, listonly
=False, seekstart
=0, seekend
=0, skipchecksum
=False, checksumtype
="crc32", formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
7729 outarray
= ListDirToArrayAlt(infiles
, dirlistfromtxt
, followlink
, listonly
, checksumtype
, formatspecs
, verbose
);
7730 listcatfiles
= ArchiveFileListFiles(outarray
, seekstart
, seekend
, skipchecksum
, formatspecs
, verbose
, returnfp
);
7731 return listcatfiles
;
7733 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):
7734 outarray
= ListDirToArrayAlt(infiles
, dirlistfromtxt
, followlink
, False, checksumtype
, extradata
, formatspecs
, False);
7735 listcatfiles
= RePackArchiveFile(outarray
, outfile
, compression
, compressionlevel
, followlink
, checksumtype
, skipchecksum
, extradata
, formatspecs
, verbose
, returnfp
);
7736 return listcatfiles
;
7738 create_alias_function("Pack", __file_format_name__
, "FromListDirAlt", PackArchiveFileFromListDirAlt
);
7740 def PackArchiveFileFromTarFileAlt(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
7741 outarray
= TarFileToArrayAlt(infile
, False, checksumtype
, extradata
, formatspecs
, False);
7742 listcatfiles
= RePackArchiveFile(outarray
, outfile
, compression
, compressionlevel
, False, checksumtype
, False, extradata
, formatspecs
, verbose
, returnfp
);
7743 return listcatfiles
;
7745 create_alias_function("Pack", __file_format_name__
, "FromTarFileAlt", PackArchiveFileFromTarFileAlt
);
7747 def PackArchiveFileFromZipFileAlt(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
7748 outarray
= ZipFileToArrayAlt(infile
, False, checksumtype
, extradata
, formatspecs
, False);
7749 listcatfiles
= RePackArchiveFile(outarray
, outfile
, compression
, compressionlevel
, False, checksumtype
, False, extradata
, formatspecs
, verbose
, returnfp
);
7750 return listcatfiles
;
7752 create_alias_function("Pack", __file_format_name__
, "FromZipFileAlt", PackArchiveFileFromZipFileAlt
);
7754 if(not rarfile_support
):
7755 def PackArchiveFileFromRarFileAlt(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
7758 if(rarfile_support
):
7759 def PackArchiveFileFromRarFileAlt(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
7760 outarray
= RarFileToArrayAlt(infile
, False, checksumtype
, extradata
, formatspecs
, False);
7761 listcatfiles
= RePackArchiveFile(outarray
, outfile
, compression
, compressionlevel
, False, checksumtype
, False, extradata
, formatspecs
, verbose
, returnfp
);
7762 return listcatfiles
;
7764 create_alias_function("Pack", __file_format_name__
, "FromRarFileAlt", PackArchiveFileFromRarFileAlt
);
7766 if(not py7zr_support
):
7767 def PackArchiveFileFromSevenZipFileAlt(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
7771 def PackArchiveFileFromSevenZipFileAlt(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
7772 outarray
= SevenZipFileToArrayAlt(infile
, False, checksumtype
, extradata
, formatspecs
, False);
7773 listcatfiles
= RePackArchiveFile(outarray
, outfile
, compression
, compressionlevel
, False, checksumtype
, False, extradata
, formatspecs
, verbose
, returnfp
);
7774 return listcatfiles
;
7776 create_alias_function("Pack", __file_format_name__
, "FromSevenZipFileAlt", PackArchiveFileFromSevenZipFileAlt
);
7778 def download_file_from_ftp_file(url
):
7779 urlparts
= urlparse(url
);
7780 file_name
= os
.path
.basename(urlparts
.path
);
7781 file_dir
= os
.path
.dirname(urlparts
.path
);
7782 if(urlparts
.username
is not None):
7783 ftp_username
= urlparts
.username
;
7785 ftp_username
= "anonymous";
7786 if(urlparts
.password
is not None):
7787 ftp_password
= urlparts
.password
;
7788 elif(urlparts
.password
is None and urlparts
.username
=="anonymous"):
7789 ftp_password
= "anonymous";
7792 if(urlparts
.scheme
=="ftp"):
7794 elif(urlparts
.scheme
=="ftps"):
7798 if(urlparts
.scheme
=="sftp"):
7800 return download_file_from_pysftp_file(url
);
7802 return download_file_from_sftp_file(url
);
7803 elif(urlparts
.scheme
=="http" or urlparts
.scheme
=="https"):
7804 return download_file_from_http_file(url
);
7805 ftp_port
= urlparts
.port
;
7806 if(urlparts
.port
is None):
7809 ftp
.connect(urlparts
.hostname
, ftp_port
);
7810 except socket
.gaierror
:
7811 log
.info("Error With URL "+url
);
7813 except socket
.timeout
:
7814 log
.info("Error With URL "+url
);
7816 ftp
.login(urlparts
.username
, urlparts
.password
);
7817 if(urlparts
.scheme
=="ftps"):
7819 ftpfile
= BytesIO();
7820 ftp
.retrbinary("RETR "+urlparts
.path
, ftpfile
.write
);
7821 #ftp.storbinary("STOR "+urlparts.path, ftpfile.write);
7826 def download_file_from_ftp_string(url
):
7827 ftpfile
= download_file_from_ftp_file(url
);
7828 return ftpfile
.read();
7830 def upload_file_to_ftp_file(ftpfile
, url
):
7831 urlparts
= urlparse(url
);
7832 file_name
= os
.path
.basename(urlparts
.path
);
7833 file_dir
= os
.path
.dirname(urlparts
.path
);
7834 if(urlparts
.username
is not None):
7835 ftp_username
= urlparts
.username
;
7837 ftp_username
= "anonymous";
7838 if(urlparts
.password
is not None):
7839 ftp_password
= urlparts
.password
;
7840 elif(urlparts
.password
is None and urlparts
.username
=="anonymous"):
7841 ftp_password
= "anonymous";
7844 if(urlparts
.scheme
=="ftp"):
7846 elif(urlparts
.scheme
=="ftps"):
7850 if(urlparts
.scheme
=="sftp"):
7852 return upload_file_from_pysftp_file(url
);
7854 return upload_file_from_sftp_file(url
);
7855 elif(urlparts
.scheme
=="http" or urlparts
.scheme
=="https"):
7857 ftp_port
= urlparts
.port
;
7858 if(urlparts
.port
is None):
7861 ftp
.connect(urlparts
.hostname
, ftp_port
);
7862 except socket
.gaierror
:
7863 log
.info("Error With URL "+url
);
7865 except socket
.timeout
:
7866 log
.info("Error With URL "+url
);
7868 ftp
.login(urlparts
.username
, urlparts
.password
);
7869 if(urlparts
.scheme
=="ftps"):
7871 ftp
.storbinary("STOR "+urlparts
.path
, ftpfile
);
7876 def upload_file_to_ftp_string(ftpstring
, url
):
7877 ftpfileo
= BytesIO(ftpstring
);
7878 ftpfile
= upload_file_to_ftp_file(ftpfileo
, url
);
7882 def download_file_from_http_file(url
, headers
=geturls_headers_pycatfile_python_alt
):
7883 # Parse the URL to extract username and password if present
7884 urlparts
= urlparse(url
);
7885 username
= urlparts
.username
;
7886 password
= urlparts
.password
;
7887 # Rebuild the URL without the username and password
7888 netloc
= urlparts
.hostname
;
7889 if(urlparts
.scheme
=="sftp"):
7891 return download_file_from_pysftp_file(url
);
7893 return download_file_from_sftp_file(url
);
7894 elif(urlparts
.scheme
=="ftp" or urlparts
.scheme
=="ftps"):
7895 return download_file_from_ftp_file(url
);
7897 netloc
+= ':' + str(urlparts
.port
);
7898 rebuilt_url
= urlunparse((urlparts
.scheme
, netloc
, urlparts
.path
, urlparts
.params
, urlparts
.query
, urlparts
.fragment
));
7899 # Create a temporary file object
7900 httpfile
= BytesIO();
7902 # Use the requests library if available
7903 if username
and password
:
7904 response
= requests
.get(rebuilt_url
, headers
=headers
, auth
=(username
, password
), stream
=True);
7906 response
= requests
.get(rebuilt_url
, headers
=headers
, stream
=True);
7907 response
.raw
.decode_content
= True
7908 shutil
.copyfileobj(response
.raw
, httpfile
);
7910 # Build a Request object for urllib
7911 request
= Request(rebuilt_url
, headers
=headers
);
7912 # Create an opener object for handling URLs
7913 if username
and password
:
7914 # Create a password manager
7915 password_mgr
= HTTPPasswordMgrWithDefaultRealm();
7916 # Add the username and password
7917 password_mgr
.add_password(None, rebuilt_url
, username
, password
);
7918 # Create an authentication handler using the password manager
7919 auth_handler
= HTTPBasicAuthHandler(password_mgr
);
7920 # Build the opener with the authentication handler
7921 opener
= build_opener(auth_handler
);
7923 opener
= build_opener();
7924 with opener
.open(request
) as response
:
7925 shutil
.copyfileobj(response
, httpfile
);
7926 # Reset file pointer to the start
7927 httpfile
.seek(0, 0);
7928 # Return the temporary file object
7931 def download_file_from_http_string(url
, headers
=geturls_headers_pycatfile_python_alt
):
7932 httpfile
= download_file_from_http_file(url
, headers
);
7933 return ftpfile
.read();
7936 def download_file_from_sftp_file(url
):
7937 urlparts
= urlparse(url
);
7938 file_name
= os
.path
.basename(urlparts
.path
);
7939 file_dir
= os
.path
.dirname(urlparts
.path
);
7940 sftp_port
= urlparts
.port
;
7941 if(urlparts
.port
is None):
7944 sftp_port
= urlparts
.port
;
7945 if(urlparts
.username
is not None):
7946 sftp_username
= urlparts
.username
;
7948 sftp_username
= "anonymous";
7949 if(urlparts
.password
is not None):
7950 sftp_password
= urlparts
.password
;
7951 elif(urlparts
.password
is None and urlparts
.username
=="anonymous"):
7952 sftp_password
= "anonymous";
7955 if(urlparts
.scheme
=="ftp"):
7956 return download_file_from_ftp_file(url
);
7957 elif(urlparts
.scheme
=="http" or urlparts
.scheme
=="https"):
7958 return download_file_from_http_file(url
);
7959 if(urlparts
.scheme
!="sftp"):
7961 ssh
= paramiko
.SSHClient();
7962 ssh
.load_system_host_keys();
7963 ssh
.set_missing_host_key_policy(paramiko
.AutoAddPolicy());
7965 ssh
.connect(urlparts
.hostname
, port
=sftp_port
, username
=urlparts
.username
, password
=urlparts
.password
);
7966 except paramiko
.ssh_exception
.SSHException
:
7968 except socket
.gaierror
:
7969 log
.info("Error With URL "+url
);
7971 except socket
.timeout
:
7972 log
.info("Error With URL "+url
);
7974 sftp
= ssh
.open_sftp();
7975 sftpfile
= BytesIO();
7976 sftp
.getfo(urlparts
.path
, sftpfile
);
7979 sftpfile
.seek(0, 0);
7982 def download_file_from_sftp_file(url
):
7986 def download_file_from_sftp_string(url
):
7987 sftpfile
= download_file_from_sftp_file(url
);
7988 return sftpfile
.read();
7990 def download_file_from_ftp_string(url
):
7994 def upload_file_to_sftp_file(sftpfile
, url
):
7995 urlparts
= urlparse(url
);
7996 file_name
= os
.path
.basename(urlparts
.path
);
7997 file_dir
= os
.path
.dirname(urlparts
.path
);
7998 sftp_port
= urlparts
.port
;
7999 if(urlparts
.port
is None):
8002 sftp_port
= urlparts
.port
;
8003 if(urlparts
.username
is not None):
8004 sftp_username
= urlparts
.username
;
8006 sftp_username
= "anonymous";
8007 if(urlparts
.password
is not None):
8008 sftp_password
= urlparts
.password
;
8009 elif(urlparts
.password
is None and urlparts
.username
=="anonymous"):
8010 sftp_password
= "anonymous";
8013 if(urlparts
.scheme
=="ftp"):
8014 return upload_file_from_ftp_file(url
);
8015 elif(urlparts
.scheme
=="http" or urlparts
.scheme
=="https"):
8017 if(urlparts
.scheme
!="sftp"):
8019 ssh
= paramiko
.SSHClient();
8020 ssh
.load_system_host_keys();
8021 ssh
.set_missing_host_key_policy(paramiko
.AutoAddPolicy());
8023 ssh
.connect(urlparts
.hostname
, port
=sftp_port
, username
=urlparts
.username
, password
=urlparts
.password
);
8024 except paramiko
.ssh_exception
.SSHException
:
8026 except socket
.gaierror
:
8027 log
.info("Error With URL "+url
);
8029 except socket
.timeout
:
8030 log
.info("Error With URL "+url
);
8032 sftp
= ssh
.open_sftp();
8033 sftp
.putfo(sftpfile
, urlparts
.path
);
8036 sftpfile
.seek(0, 0);
8039 def upload_file_to_sftp_file(sftpfile
, url
):
8043 def upload_file_to_sftp_string(sftpstring
, url
):
8044 sftpfileo
= BytesIO(sftpstring
);
8045 sftpfile
= upload_file_to_sftp_files(ftpfileo
, url
);
8049 def upload_file_to_sftp_string(url
):
8053 def download_file_from_pysftp_file(url
):
8054 urlparts
= urlparse(url
);
8055 file_name
= os
.path
.basename(urlparts
.path
);
8056 file_dir
= os
.path
.dirname(urlparts
.path
);
8057 sftp_port
= urlparts
.port
;
8058 if(urlparts
.port
is None):
8061 sftp_port
= urlparts
.port
;
8062 if(urlparts
.username
is not None):
8063 sftp_username
= urlparts
.username
;
8065 sftp_username
= "anonymous";
8066 if(urlparts
.password
is not None):
8067 sftp_password
= urlparts
.password
;
8068 elif(urlparts
.password
is None and urlparts
.username
=="anonymous"):
8069 sftp_password
= "anonymous";
8072 if(urlparts
.scheme
=="ftp"):
8073 return download_file_from_ftp_file(url
);
8074 elif(urlparts
.scheme
=="http" or urlparts
.scheme
=="https"):
8075 return download_file_from_http_file(url
);
8076 if(urlparts
.scheme
!="sftp"):
8079 pysftp
.Connection(urlparts
.hostname
, port
=sftp_port
, username
=urlparts
.username
, password
=urlparts
.password
);
8080 except paramiko
.ssh_exception
.SSHException
:
8082 except socket
.gaierror
:
8083 log
.info("Error With URL "+url
);
8085 except socket
.timeout
:
8086 log
.info("Error With URL "+url
);
8088 sftp
= ssh
.open_sftp();
8089 sftpfile
= BytesIO();
8090 sftp
.getfo(urlparts
.path
, sftpfile
);
8093 sftpfile
.seek(0, 0);
8096 def download_file_from_pysftp_file(url
):
8100 def download_file_from_pysftp_string(url
):
8101 sftpfile
= download_file_from_pysftp_file(url
);
8102 return sftpfile
.read();
8104 def download_file_from_ftp_string(url
):
8108 def upload_file_to_pysftp_file(sftpfile
, url
):
8109 urlparts
= urlparse(url
);
8110 file_name
= os
.path
.basename(urlparts
.path
);
8111 file_dir
= os
.path
.dirname(urlparts
.path
);
8112 sftp_port
= urlparts
.port
;
8113 if(urlparts
.port
is None):
8116 sftp_port
= urlparts
.port
;
8117 if(urlparts
.username
is not None):
8118 sftp_username
= urlparts
.username
;
8120 sftp_username
= "anonymous";
8121 if(urlparts
.password
is not None):
8122 sftp_password
= urlparts
.password
;
8123 elif(urlparts
.password
is None and urlparts
.username
=="anonymous"):
8124 sftp_password
= "anonymous";
8127 if(urlparts
.scheme
=="ftp"):
8128 return upload_file_from_ftp_file(url
);
8129 elif(urlparts
.scheme
=="http" or urlparts
.scheme
=="https"):
8131 if(urlparts
.scheme
!="sftp"):
8134 pysftp
.Connection(urlparts
.hostname
, port
=sftp_port
, username
=urlparts
.username
, password
=urlparts
.password
);
8135 except paramiko
.ssh_exception
.SSHException
:
8137 except socket
.gaierror
:
8138 log
.info("Error With URL "+url
);
8140 except socket
.timeout
:
8141 log
.info("Error With URL "+url
);
8143 sftp
= ssh
.open_sftp();
8144 sftp
.putfo(sftpfile
, urlparts
.path
);
8147 sftpfile
.seek(0, 0);
8150 def upload_file_to_pysftp_file(sftpfile
, url
):
8154 def upload_file_to_pysftp_string(sftpstring
, url
):
8155 sftpfileo
= BytesIO(sftpstring
);
8156 sftpfile
= upload_file_to_pysftp_files(ftpfileo
, url
);
8160 def upload_file_to_pysftp_string(url
):
8163 def download_file_from_internet_file(url
, headers
=geturls_headers_pycatfile_python_alt
):
8164 urlparts
= urlparse(url
);
8165 if(urlparts
.scheme
=="http" or urlparts
.scheme
=="https"):
8166 return download_file_from_http_file(url
, headers
);
8167 elif(urlparts
.scheme
=="ftp" or urlparts
.scheme
=="ftps"):
8168 return download_file_from_ftp_file(url
);
8169 elif(urlparts
.scheme
=="sftp"):
8170 if(__use_pysftp__
and havepysftp
):
8171 return download_file_from_pysftp_file(url
);
8173 return download_file_from_sftp_file(url
);
8178 def download_file_from_internet_uncompress_file(url
, headers
=geturls_headers_pycatfile_python_alt
, formatspecs
=__file_format_list__
):
8179 fp
= download_file_from_internet_file(url
);
8180 fp
= UncompressArchiveFile(fp
, formatspecs
);
8186 def download_file_from_internet_string(url
, headers
=geturls_headers_pycatfile_python_alt
):
8187 urlparts
= urlparse(url
);
8188 if(urlparts
.scheme
=="http" or urlparts
.scheme
=="https"):
8189 return download_file_from_http_string(url
, headers
);
8190 elif(urlparts
.scheme
=="ftp" or urlparts
.scheme
=="ftps"):
8191 return download_file_from_ftp_string(url
);
8192 elif(urlparts
.scheme
=="sftp"):
8193 if(__use_pysftp__
and havepysftp
):
8194 return download_file_from_pysftp_string(url
);
8196 return download_file_from_sftp_string(url
);
8201 def download_file_from_internet_uncompress_string(url
, headers
=geturls_headers_pycatfile_python_alt
, formatspecs
=__file_format_list__
):
8202 fp
= download_file_from_internet_string(url
);
8203 fp
= UncompressArchiveFile(fp
, formatspecs
);
8209 def upload_file_to_internet_file(ifp
, url
):
8210 urlparts
= urlparse(url
);
8211 if(urlparts
.scheme
=="http" or urlparts
.scheme
=="https"):
8213 elif(urlparts
.scheme
=="ftp" or urlparts
.scheme
=="ftps"):
8214 return upload_file_from_ftp_file(ifp
, url
);
8215 elif(urlparts
.scheme
=="sftp"):
8216 if(__use_pysftp__
and havepysftp
):
8217 return upload_file_from_pysftp_file(ifp
, url
);
8219 return download_file_from_sftp_file(ifp
, url
);
8224 def upload_file_to_internet_compress_file(ifp
, url
, formatspecs
=__file_format_list__
):
8225 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
8229 upload_file_to_internet_file(catfp
, outfile
);
8232 def upload_file_to_internet_string(ifp
, url
):
8233 urlparts
= urlparse(url
);
8234 if(urlparts
.scheme
=="http" or urlparts
.scheme
=="https"):
8236 elif(urlparts
.scheme
=="ftp" or urlparts
.scheme
=="ftps"):
8237 return upload_file_from_ftp_string(ifp
, url
);
8238 elif(urlparts
.scheme
=="sftp"):
8239 if(__use_pysftp__
and havepysftp
):
8240 return upload_file_from_pysftp_string(ifp
, url
);
8242 return download_file_from_sftp_string(ifp
, url
);
8247 def upload_file_to_internet_compress_string(ifp
, url
, formatspecs
=__file_format_list__
):
8248 catfp
= CompressArchiveFile(BytesIO(ifp
), compression
, formatspecs
);
8252 upload_file_to_internet_file(catfp
, outfile
);
8256 if(hasattr(shutil
, "register_archive_format")):
8257 # Register the packing format
8258 shutil
.register_archive_format(__file_format_name__
, PackArchiveFileFunc
, description
='Pack concatenated files');
8259 except shutil
.RegistryError
:
8263 if(hasattr(shutil
, "register_unpack_format")):
8264 # Register the unpacking format
8265 shutil
.register_unpack_format(__file_format_name__
, archivefile_extensions
, UnPackArchiveFileFunc
, description
='UnPack concatenated files');
8266 except shutil
.RegistryError
: