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: 3/8/2024 Ver. 0.3.4 RC 1 - Author: cooldude2k $
20 from __future__
import absolute_import
, division
, print_function
, unicode_literals
;
21 import os
, re
, sys
, time
, stat
, zlib
, base64
, shutil
, hashlib
, datetime
, logging
, binascii
, tempfile
, zipfile
, ftplib
;
23 hashlib_guaranteed
= False;
24 os
.environ
["PYTHONIOENCODING"] = "UTF-8";
25 os
.environ
["LC_CTYPE"] = "UTF-8";
29 sys
.setdefaultencoding('UTF-8');
32 except AttributeError:
36 except AttributeError:
38 if(hasattr(sys
, "setdefaultencoding")):
39 sys
.setdefaultencoding('UTF-8');
40 if(hasattr(sys
.stdout
, "detach")):
42 sys
.stdout
= io
.TextIOWrapper(sys
.stdout
.detach(), encoding
= 'UTF-8');
43 if(hasattr(sys
.stderr
, "detach")):
45 sys
.stderr
= io
.TextIOWrapper(sys
.stderr
.detach(), encoding
= 'UTF-8');
46 from io
import open as open;
49 import simplejson
as json
;
54 from zlib
import crc32
;
56 from binascii
import crc32
;
58 rarfile_support
= False;
61 rarfile_support
= True;
63 rarfile_support
= False;
66 from safetar
import is_tarfile
;
69 from xtarfile
import is_tarfile
;
71 from tarfile
import is_tarfile
;
74 import safetar
as tarfile
;
77 import xtarfile
as tarfile
;
81 if(sys
.version
[0]=="2"):
83 from io
import StringIO
, BytesIO
;
86 from cStringIO
import StringIO
;
87 from cStringIO
import StringIO
as BytesIO
;
89 from StringIO
import StringIO
;
90 from StringIO
import StringIO
as BytesIO
;
91 elif(sys
.version
[0]>="3"):
92 from io
import StringIO
, BytesIO
;
97 from cStringIO
import StringIO
as BytesIO
;
103 from StringIO
import StringIO
as BytesIO
;
109 from io
import BytesIO
;
114 __file_format_name__
= "CatFile";
115 __program_name__
= "Py"+__file_format_name__
;
116 __file_format_lower__
= __file_format_name__
.lower();
117 __file_format_len__
= len(__file_format_name__
);
118 __file_format_hex__
= binascii
.hexlify(__file_format_name__
.encode("UTF-8")).decode("UTF-8");
119 __file_format_delimiter__
= "\x00";
120 __file_format_ver__
= "001";
121 __file_format_list__
= [__file_format_name__
, __file_format_lower__
, __file_format_len__
, __file_format_hex__
, __file_format_delimiter__
, __file_format_ver__
];
122 __project__
= __program_name__
;
123 __project_url__
= "https://github.com/GameMaker2k/PyCatFile";
124 __version_info__
= (0, 3, 4, "RC 1", 1);
125 __version_date_info__
= (2024, 3, 3, "RC 1", 1);
126 __version_date__
= str(__version_date_info__
[0]) + "." + str(__version_date_info__
[1]).zfill(2) + "." + str(__version_date_info__
[2]).zfill(2);
127 __revision__
= __version_info__
[3];
128 __revision_id__
= "$Id$";
129 if(__version_info__
[4] is not None):
130 __version_date_plusrc__
= __version_date__
+ "-" + str(__version_date_info__
[4]);
131 if(__version_info__
[4] is None):
132 __version_date_plusrc__
= __version_date__
;
133 if(__version_info__
[3] is not None):
134 __version__
= str(__version_info__
[0]) + "." + str(__version_info__
[1]) + "." + str(__version_info__
[2]) + " " + str(__version_info__
[3]);
135 if(__version_info__
[3] is None):
136 __version__
= str(__version_info__
[0]) + "." + str(__version_info__
[1]) + "." + str(__version_info__
[2]);
138 compressionlist
= ['auto', 'gzip', 'bzip2', 'zstd', 'xz', 'lz4', 'lzo', 'lzma'];
139 outextlist
= ['gz', 'bz2', 'zst', 'xz', 'lz4', 'lzo', 'lzma'];
140 outextlistwd
= ['.gz', '.bz2', '.zst', '.xz', '.lz4', '.lzo', '.lzma'];
142 tarfile_mimetype
= "application/tar";
143 tarfile_tar_mimetype
= tarfile_mimetype
;
144 zipfile_mimetype
= "application/zip";
145 zipfile_zip_mimetype
= zipfile_mimetype
;
146 rarfile_mimetype
= "application/rar";
147 rarfile_rar_mimetype
= rarfile_mimetype
;
148 archivefile_mimetype
= "application/x-"+__file_format_list__
[1]+"";
149 archivefile_cat_mimetype
= archivefile_mimetype
;
150 archivefile_gzip_mimetype
= "application/x-"+__file_format_list__
[1]+"+gzip";
151 archivefile_gz_mimetype
= archivefile_gzip_mimetype
;
152 archivefile_bzip2_mimetype
= "application/x-"+__file_format_list__
[1]+"+bzip2";
153 archivefile_bz2_mimetype
= archivefile_bzip2_mimetype
;
154 archivefile_lz4_mimetype
= "application/x-"+__file_format_list__
[1]+"+lz4";
155 archivefile_lzop_mimetype
= "application/x-"+__file_format_list__
[1]+"+lzop";
156 archivefile_lzo_mimetype
= archivefile_lzop_mimetype
;
157 archivefile_zstandard_mimetype
= "application/x-"+__file_format_list__
[1]+"+zstandard";
158 archivefile_zstd_mimetype
= archivefile_zstandard_mimetype
;
159 archivefile_lzma_mimetype
= "application/x-"+__file_format_list__
[1]+"+lzma";
160 archivefile_xz_mimetype
= "application/x-"+__file_format_list__
[1]+"+xz";
161 archivefile_extensions
= ['.cat', '.cat.gz', '.cat.bz2', '.cat.zst', '.cat.lz4', '.cat.lzo', '.cat.lzop', '.cat.lzma', '.cat.xz'];
163 if __name__
== "__main__":
165 curscrpath
= os
.path
.dirname(sys
.argv
[0]);
169 curscrpath
= curscrpath
.replace(os
.sep
, "/");
170 curscrpath
= curscrpath
+ "/";
171 scrfile
= curscrpath
+ "catfile.py";
172 if(os
.path
.exists(scrfile
) and os
.path
.isfile(scrfile
)):
173 scrcmd
= subprocess
.Popen([sys
.executable
, scrfile
] + sys
.argv
[1:]);
176 def VerbosePrintOut(dbgtxt
, outtype
="log", dbgenable
=True, dgblevel
=20):
182 "warning": logging
.warning
,
183 "error": logging
.error
,
184 "critical": logging
.critical
,
185 "exception": logging
.exception
,
186 "logalt": lambda x
: logging
.log(dgblevel
, x
),
187 "debug": logging
.debug
189 log_function
= log_functions
.get(outtype
);
191 log_function(dbgtxt
);
195 def VerbosePrintOutReturn(dbgtxt
, outtype
="log", dbgenable
=True, dgblevel
=20):
196 VerbosePrintOut(dbgtxt
, outtype
, dbgenable
, dgblevel
);
199 def RemoveWindowsPath(dpath
):
203 dpath
= dpath
.replace(os
.path
.sep
, "/");
204 dpath
= dpath
.rstrip("/");
205 if(dpath
=="." or dpath
==".."):
209 def NormalizeRelativePath(inpath
):
210 inpath
= RemoveWindowsPath(inpath
);
211 if(os
.path
.isabs(inpath
)):
214 if(inpath
.startswith("./") or inpath
.startswith("../")):
217 outpath
= "./" + inpath
;
220 def ListDir(dirpath
, followlink
=False, duplicates
=False):
221 if(isinstance(dirpath
, (list, tuple, ))):
222 dirpath
= list(filter(None, dirpath
));
223 elif(isinstance(dirpath
, (str, ))):
224 dirpath
= list(filter(None, [dirpath
]));
226 for mydirfile
in dirpath
:
227 if(not os
.path
.exists(mydirfile
)):
229 mydirfile
= NormalizeRelativePath(mydirfile
);
230 if(os
.path
.exists(mydirfile
) and os
.path
.islink(mydirfile
)):
231 mydirfile
= RemoveWindowsPath(os
.path
.realpath(mydirfile
));
232 if(os
.path
.exists(mydirfile
) and os
.path
.isdir(mydirfile
)):
233 for root
, dirs
, filenames
in os
.walk(mydirfile
):
235 dpath
= RemoveWindowsPath(dpath
);
236 if(dpath
not in retlist
and not duplicates
):
237 retlist
.append(dpath
);
239 retlist
.append(dpath
);
240 for file in filenames
:
241 fpath
= os
.path
.join(root
, file);
242 fpath
= RemoveWindowsPath(fpath
);
243 if(fpath
not in retlist
and not duplicates
):
244 retlist
.append(fpath
);
246 retlist
.append(fpath
);
248 retlist
.append(RemoveWindowsPath(mydirfile
));
251 def ListDirAdvanced(dirpath
, followlink
=False, duplicates
=False):
252 if isinstance(dirpath
, (list, tuple)):
253 dirpath
= list(filter(None, dirpath
));
254 elif isinstance(dirpath
, str):
255 dirpath
= list(filter(None, [dirpath
]));
257 for mydirfile
in dirpath
:
258 if not os
.path
.exists(mydirfile
):
260 mydirfile
= NormalizeRelativePath(mydirfile
);
261 if os
.path
.exists(mydirfile
) and os
.path
.islink(mydirfile
) and followlink
:
262 mydirfile
= RemoveWindowsPath(os
.path
.realpath(mydirfile
))
263 if os
.path
.exists(mydirfile
) and os
.path
.isdir(mydirfile
):
264 for root
, dirs
, filenames
in os
.walk(mydirfile
):
265 # Sort dirs and filenames alphabetically in place
266 dirs
.sort(key
=lambda x
: x
.lower());
267 filenames
.sort(key
=lambda x
: x
.lower());
268 dpath
= RemoveWindowsPath(root
);
269 if not duplicates
and dpath
not in retlist
:
270 retlist
.append(dpath
);
272 retlist
.append(dpath
);
273 for file in filenames
:
274 fpath
= os
.path
.join(root
, file);
275 fpath
= RemoveWindowsPath(fpath
);
276 if not duplicates
and fpath
not in retlist
:
277 retlist
.append(fpath
);
279 retlist
.append(fpath
);
281 retlist
.append(RemoveWindowsPath(mydirfile
));
284 def create_alias_function(prefix
, base_name
, suffix
, target_function
):
285 # Define a new function that wraps the target function
286 def alias_function(*args
, **kwargs
):
287 return target_function(*args
, **kwargs
);
289 # Create the function name by combining the prefix, base name, and the suffix
290 function_name
= "{}{}{}".format(prefix
, base_name
, suffix
);
292 # Add the new function to the global namespace
293 globals()[function_name
] = alias_function
;
295 # initial_value can be 0xFFFF or 0x0000
296 def crc16_ansi(msg
, initial_value
=0xFFFF):
297 # CRC-16-IBM / CRC-16-ANSI polynomial and initial value
298 poly
= 0x8005; # Polynomial for CRC-16-IBM / CRC-16-ANSI
299 crc
= initial_value
; # Initial value
301 crc ^
= b
<< 8; # XOR byte into CRC top byte
302 for _
in range(8): # Process each bit
303 if crc
& 0x8000: # If the top bit is set
304 crc
= (crc
<< 1) ^ poly
; # Shift left and XOR with the polynomial
306 crc
= crc
<< 1; # Just shift left
307 crc
&= 0xFFFF; # Ensure CRC remains 16-bit
310 # initial_value can be 0xFFFF or 0x0000
311 def crc16_ibm(msg
, initial_value
=0xFFFF):
312 return crc16_ansi(msg
, initial_value
);
314 # initial_value is 0xFFFF
316 return crc16_ansi(msg
, 0xFFFF);
318 # initial_value can be 0xFFFF, 0x1D0F or 0x0000
319 def crc16_ccitt(msg
, initial_value
=0xFFFF):
320 # CRC-16-CCITT polynomial
321 poly
= 0x1021; # Polynomial for CRC-16-CCITT
322 # Use the specified initial value
325 crc ^
= b
<< 8; # XOR byte into CRC top byte
326 for _
in range(8): # Process each bit
327 if crc
& 0x8000: # If the top bit is set
328 crc
= (crc
<< 1) ^ poly
; # Shift left and XOR with the polynomial
330 crc
= crc
<< 1; # Just shift left
331 crc
&= 0xFFFF; # Ensure CRC remains 16-bit
334 # initial_value can be 0x42F0E1EBA9EA3693 or 0x0000000000000000
335 def crc64_ecma(msg
, initial_value
=0x0000000000000000):
336 # CRC-64-ECMA polynomial and initial value
337 poly
= 0x42F0E1EBA9EA3693;
338 crc
= initial_value
; # Initial value for CRC-64-ECMA
340 crc ^
= b
<< 56; # XOR byte into the most significant byte of the CRC
341 for _
in range(8): # Process each bit
342 if crc
& (1 << 63): # Check if the leftmost (most significant) bit is set
343 crc
= (crc
<< 1) ^ poly
; # Shift left and XOR with poly if the MSB is 1
345 crc
<<= 1; # Just shift left if the MSB is 0
346 crc
&= 0xFFFFFFFFFFFFFFFF; # Ensure CRC remains 64-bit
349 # initial_value can be 0x000000000000001B or 0xFFFFFFFFFFFFFFFF
350 def crc64_iso(msg
, initial_value
=0xFFFFFFFFFFFFFFFF):
351 # CRC-64-ISO polynomial and initial value
352 poly
= 0x000000000000001B;
353 crc
= initial_value
; # Common initial value for CRC-64-ISO
355 crc ^
= b
<< 56; # XOR byte into the most significant byte of the CRC
356 for _
in range(8): # Process each bit
357 if crc
& (1 << 63): # Check if the leftmost (most significant) bit is set
358 crc
= (crc
<< 1) ^ poly
; # Shift left and XOR with poly if the MSB is 1
360 crc
<<= 1; # Just shift left if the MSB is 0
361 crc
&= 0xFFFFFFFFFFFFFFFF; # Ensure CRC remains 64-bit
364 def ReadTillNullByte(fp
, delimiter
=__file_format_delimiter__
):
367 nullbyte
= delimiter
.encode("UTF-8");
369 curbyte
= fp
.read(1);
370 if(curbyte
==nullbyte
or not curbyte
):
372 curfullbyte
= curfullbyte
+ curbyte
;
373 return curfullbyte
.decode('UTF-8');
375 def ReadUntilNullByte(fp
, delimiter
=__file_format_delimiter__
):
376 return ReadTillNullByte(fp
, delimiter
);
378 def SeekToEndOfFile(fp
):
382 if(lasttell
==fp
.tell()):
384 lasttell
= fp
.tell();
387 def ReadFileHeaderData(fp
, rounds
=0, delimiter
=__file_format_delimiter__
):
391 while(rocount
<roend
):
392 HeaderOut
.append(ReadTillNullByte(fp
, delimiter
));
393 rocount
= rocount
+ 1;
396 def ReadFileHeaderDataBySize(fp
, delimiter
=__file_format_delimiter__
):
397 headerpresize
= ReadTillNullByte(fp
, delimiter
);
398 headersize
= int(headerpresize
, 16);
399 headercontent
= str(fp
.read(headersize
).decode('UTF-8')).split(delimiter
);
402 roend
= int(len(headercontent
));
403 HeaderOut
= [headerpresize
];
404 while(rocount
<roend
):
405 HeaderOut
.append(headercontent
[rocount
]);
406 rocount
= rocount
+ 1;
409 def ReadFileHeaderDataByList(fp
, listval
=[], delimiter
=__file_format_delimiter__
):
411 roend
= int(len(listval
));
413 while(rocount
<roend
):
414 RoundArray
= {listval
[rocount
]: ReadTillNullByte(fp
, delimiter
)};
415 HeaderOut
.update(RoundArray
);
416 rocount
= rocount
+ 1;
419 def ReadFileHeaderDataByListSize(fp
, listval
=[], delimiter
=__file_format_delimiter__
):
420 headerpresize
= ReadTillNullByte(fp
, delimiter
);
421 headersize
= int(headerpresize
, 16);
422 headercontent
= str(fp
.read(headersize
).decode('UTF-8')).split(delimiter
);
426 roend
= int(len(headercontent
));
427 HeaderOut
= {listval
[0]: headerpresize
};
428 while(rocount
<roend
):
429 RoundArray
= {listval
[rocount
]: headercontent
[rocount
]};
430 HeaderOut
.update(RoundArray
);
431 rocount
= rocount
+ 1;
432 listcount
= listcount
+ 1;
435 def AppendNullByte(indata
, delimiter
=__file_format_delimiter__
):
436 outdata
= str(indata
) + delimiter
;
439 def AppendNullBytes(indata
=[], delimiter
=__file_format_delimiter__
):
444 outdata
= outdata
+ AppendNullByte(indata
[inum
], delimiter
);
448 def ReadTillNullByteAlt(fp
, delimiter
=__file_format_delimiter__
):
449 """Read bytes from file pointer until a null byte is encountered."""
450 bytes_list
= [] # Use list for efficient append operation.
452 cur_byte
= fp
.read(1);
453 if cur_byte
== delimiter
.encode() or not cur_byte
:
455 bytes_list
.append(cur_byte
);
456 return b
''.join(bytes_list
).decode('UTF-8');
458 def ReadUntilNullByteAlt(fp
, delimiter
=__file_format_delimiter__
):
459 return ReadTillNullByteAlt(fp
, delimiter
);
461 def ReadFileHeaderDataAlt(fp
, rounds
=0, delimiter
=__file_format_delimiter__
):
462 """Read multiple null-byte terminated strings from a file."""
464 for round_count
in range(rounds
):
465 header_out
[round_count
] = ReadTillNullByteAlt(fp
, delimiter
);
468 def ReadFileHeaderDataBySizeAlt(fp
, delimiter
=__file_format_delimiter__
):
469 # Read and convert header size from hexadecimal to integer
470 header_pre_size
= ReadTillNullByte(fp
, delimiter
);
471 header_size
= int(header_pre_size
, 16);
472 # Read and split the header content
473 header_content
= str(fp
.read(header_size
).decode('UTF-8')).split(delimiter
);
475 # Prepend the pre-size and return the combined list
476 return [header_pre_size
] + header_content
;
478 def ReadFileHeaderDataByListSizeAlt(fp
, listval
=[], delimiter
=__file_format_delimiter__
):
479 # Read the size and content from the header
480 header_pre_size
= ReadTillNullByte(fp
, delimiter
);
481 header_size
= int(header_pre_size
, 16);
482 header_content
= str(fp
.read(header_size
).decode('UTF-8')).split(delimiter
);
484 # Initialize HeaderOut with the header pre-size if listval is not empty
485 HeaderOut
= {listval
[0]: header_pre_size
} if listval
else {};
486 # Map the remaining listval items to their corresponding header content, starting from the second item
487 for i
in range(1, min(len(header_content
) + 1, len(listval
))):
488 HeaderOut
[listval
[i
]] = header_content
[i
- 1]; # -1 because header_content is 0-indexed
491 def ReadFileHeaderDataByListAlt(fp
, listval
=[], delimiter
=__file_format_delimiter__
):
492 """Read multiple null-byte terminated strings from a file."""
494 for round_count
in listval
:
495 header_out
.append(ReadTillNullByteAlt(fp
, delimiter
));
498 def AppendNullByteAlt(indata
, delimiter
=__file_format_delimiter__
):
499 """Append a null byte to the given data."""
500 return str(indata
) + delimiter
;
502 def AppendNullBytesAlt(indata
=[], delimiter
=__file_format_delimiter__
):
503 """Append a null byte to each element in the list and concatenate."""
504 return delimiter
.join(map(str, indata
)) + delimiter
; # Efficient concatenation with null byte.
506 def PrintPermissionString(fchmode
, ftype
):
507 permissions
= { 'access': { '0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': ('r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx') }, 'roles': { 0: 'owner', 1: 'group', 2: 'other' } };
509 for fmodval
in str(oct(fchmode
))[-3:]:
510 permissionstr
= permissionstr
+ permissions
['access'].get(fmodval
, '---');
511 if(ftype
==0 or ftype
==7):
512 permissionstr
= "-" + permissionstr
;
514 permissionstr
= "h" + permissionstr
;
516 permissionstr
= "l" + permissionstr
;
518 permissionstr
= "c" + permissionstr
;
520 permissionstr
= "b" + permissionstr
;
522 permissionstr
= "d" + permissionstr
;
524 permissionstr
= "f" + permissionstr
;
526 permissionstr
= "D" + permissionstr
;
528 permissionstr
= "p" + permissionstr
;
530 permissionstr
= "w" + permissionstr
;
532 permissionoutstr
= stat
.filemode(fchmode
);
533 except AttributeError:
534 permissionoutstr
= permissionstr
;
536 permissionoutstr
= permissionstr
;
537 return permissionoutstr
;
539 def PrintPermissionStringAlt(fchmode
, ftype
):
541 '0': '---', '1': '--x', '2': '-w-', '3': '-wx',
542 '4': 'r--', '5': 'r-x', '6': 'rw-', '7': 'rwx'
544 # Translate file mode into permission string
545 permissionstr
= ''.join([permissions
[i
] for i
in str(oct(fchmode
))[-3:]]);
546 # Append file type indicator
548 0: '-', 1: 'h', 2: 'l', 3: 'c', 4: 'b',
549 5: 'd', 6: 'f', 8: 'D', 9: 'p', 10: 'w'
551 file_type
= type_indicators
.get(ftype
, '-');
552 permissionstr
= file_type
+ permissionstr
;
554 permissionoutstr
= stat
.filemode(fchmode
);
555 except AttributeError:
556 permissionoutstr
= permissionstr
;
557 return permissionoutstr
;
559 def CompressionSupport():
560 compression_list
= [];
563 compression_list
.append("gz");
564 compression_list
.append("gzip");
569 compression_list
.append("bz2");
570 compression_list
.append("bzip2");
575 compression_list
.append("lz4");
580 compression_list
.append("lzo");
581 compression_list
.append("lzop");
586 compression_list
.append("zstd");
587 compression_list
.append("zstandard");
592 compression_list
.append("lzma");
593 compression_list
.append("xz");
596 return compression_list
;
598 def CheckCompressionType(infile
, formatspecs
=__file_format_list__
, closefp
=True):
599 if(hasattr(infile
, "read") or hasattr(infile
, "write")):
602 catfp
= open(infile
, "rb");
604 prefp
= catfp
.read(2);
606 if(prefp
==binascii
.unhexlify("1f8b")):
609 prefp
= catfp
.read(3);
610 if(prefp
==binascii
.unhexlify("425a68")):
613 prefp
= catfp
.read(4);
614 if(prefp
==binascii
.unhexlify("28b52ffd")):
616 if(prefp
==binascii
.unhexlify("04224d18")):
618 if(prefp
==binascii
.unhexlify("504B0304")):
619 filetype
= "zipfile";
621 prefp
= catfp
.read(5);
622 if(prefp
==binascii
.unhexlify("7573746172")):
623 filetype
= "tarfile";
625 prefp
= catfp
.read(7);
626 if(prefp
==binascii
.unhexlify("fd377a585a0000")):
628 if(prefp
==binascii
.unhexlify("526172211a0700")):
629 filetype
= "rarfile";
630 if(prefp
==binascii
.unhexlify("43617446696c65")):
631 filetype
= "catfile";
633 prefp
= catfp
.read(8);
634 if(prefp
==binascii
.unhexlify("526172211a070100")):
635 filetype
= "rarfile";
637 prefp
= catfp
.read(formatspecs
[2]);
638 if(prefp
==binascii
.unhexlify(formatspecs
[3])):
639 filetype
= formatspecs
[1];
641 prefp
= catfp
.read(9);
642 if(prefp
==binascii
.unhexlify("894c5a4f000d0a1a0a")):
645 prefp
= catfp
.read(10);
646 if(prefp
==binascii
.unhexlify("7061785f676c6f62616c")):
647 filetype
= "tarfile";
653 def CheckCompressionTypeFromString(instring
, formatspecs
=__file_format_list__
, closefp
=True):
655 instringsfile
= BytesIO(instring
);
657 instringsfile
= BytesIO(instring
.encode("UTF-8"));
658 return CheckCompressionType(instringsfile
, formatspecs
, closefp
);
660 def GetCompressionMimeType(infile
, formatspecs
=__file_format_list__
):
661 compresscheck
= CheckCompressionType(fp
, formatspecs
, False);
662 if(compresscheck
=="gzip" or compresscheck
=="gz"):
663 return archivefile_gzip_mimetype
;
664 if(compresscheck
=="bzip2" or compresscheck
=="bz2"):
665 return archivefile_bzip2_mimetype
;
666 if(compresscheck
=="zstd" or compresscheck
=="zstandard"):
667 return archivefile_zstandard_mimetype
;
668 if(compresscheck
=="lz4"):
669 return archivefile_lz4_mimetype
;
670 if(compresscheck
=="lzo" or compresscheck
=="lzop"):
671 return archivefile_lzop_mimetype
;
672 if(compresscheck
=="lzma"):
673 return archivefile_lzma_mimetype
;
674 if(compresscheck
=="xz"):
675 return archivefile_xz_mimetype
;
676 if(compresscheck
=="catfile" or compresscheck
=="cat" or compresscheck
==formatspecs
[1]):
677 return archivefile_cat_mimetype
;
678 if(not compresscheck
):
682 def UncompressArchiveFile(fp
, formatspecs
=__file_format_list__
):
683 if(not hasattr(fp
, "read") and not hasattr(fp
, "write")):
685 compresscheck
= CheckCompressionType(fp
, formatspecs
, False);
686 if(compresscheck
=="gzip"):
691 catfp
= gzip
.GzipFile(fileobj
=fp
, mode
="rb");
692 if(compresscheck
=="bzip2"):
698 catfp
.write(bz2
.decompress(fp
.read()));
699 if(compresscheck
=="zstd"):
705 catfp
.write(zstandard
.decompress(fp
.read()));
706 if(compresscheck
=="lz4"):
712 catfp
.write(lz4
.frame
.decompress(fp
.read()));
713 if(compresscheck
=="lzo" or compresscheck
=="lzop"):
719 catfp
.write(lzo
.decompress(fp
.read()));
720 if(compresscheck
=="lzma" or compresscheck
=="xz"):
726 catfp
.write(lzma
.decompress(fp
.read()));
727 if(compresscheck
=="catfile" or compresscheck
==formatspecs
[1]):
729 if(not compresscheck
):
735 with fp
as fpcontent
:
737 catfp
.write(lzma
.decompress(fp
.read()));
738 except lzma
.LZMAError
:
742 create_alias_function("Uncompress", __file_format_name__
, "", UncompressArchiveFile
);
744 def UncompressFile(infile
, formatspecs
=__file_format_list__
, mode
="rb"):
745 compresscheck
= CheckCompressionType(infile
, formatspecs
, False);
746 if(sys
.version_info
[0]==2 and compresscheck
):
751 if(compresscheck
=="gzip"):
757 filefp
= gzip
.open(infile
, mode
, encoding
="UTF-8");
758 except (ValueError, TypeError) as e
:
759 filefp
= gzip
.open(infile
, mode
);
760 if(compresscheck
=="bzip2"):
766 filefp
= bz2
.open(infile
, mode
, encoding
="UTF-8");
767 except (ValueError, TypeError) as e
:
768 filefp
= bz2
.open(infile
, mode
);
769 if(compresscheck
=="zstd"):
775 filefp
= zstandard
.open(infile
, mode
, encoding
="UTF-8");
776 except (ValueError, TypeError) as e
:
777 filefp
= zstandard
.open(infile
, mode
);
778 if(compresscheck
=="lz4"):
784 filefp
= lz4
.frame
.open(infile
, mode
, encoding
="UTF-8");
785 except (ValueError, TypeError) as e
:
786 filefp
= lz4
.frame
.open(infile
, mode
);
787 if(compresscheck
=="lzo"):
793 filefp
= lzo
.open(infile
, mode
, encoding
="UTF-8");
794 except (ValueError, TypeError) as e
:
795 filefp
= lzo
.open(infile
, mode
);
796 if(compresscheck
=="lzma"):
802 filefp
= lzma
.open(infile
, mode
, encoding
="UTF-8");
803 except (ValueError, TypeError) as e
:
804 filefp
= lzma
.open(infile
, mode
);
805 if(compresscheck
=="catfile" or compresscheck
==formatspecs
[1]):
807 filefp
= open(infile
, mode
, encoding
="UTF-8");
808 except (ValueError, TypeError) as e
:
809 filefp
= open(infile
, mode
);
810 if(not compresscheck
):
812 filefp
= open(infile
, mode
, encoding
="UTF-8");
813 except (ValueError, TypeError) as e
:
814 filefp
= open(infile
, mode
);
817 def UncompressString(infile
):
818 compresscheck
= CheckCompressionTypeFromString(infile
, formatspecs
, False);
819 if(compresscheck
=="gzip"):
824 fileuz
= gzip
.decompress(infile
);
825 if(compresscheck
=="bzip2"):
830 fileuz
= bz2
.decompress(infile
);
831 if(compresscheck
=="zstd"):
836 fileuz
= zstandard
.decompress(infile
);
837 if(compresscheck
=="lz4"):
842 fileuz
= lz4
.frame
.decompress(infile
);
843 if(compresscheck
=="lzo"):
848 fileuz
= lzo
.decompress(infile
);
849 if(compresscheck
=="lzma"):
854 fileuz
= lzma
.decompress(infile
);
855 if(not compresscheck
):
857 if(hasattr(fileuz
, 'decode')):
858 fileuz
= fileuz
.decode("UTF-8");
861 def UncompressStringAlt(infile
):
863 outstring
= UncompressString(infile
);
864 filefp
.write(outstring
);
868 def CheckCompressionSubType(infile
, formatspecs
=__file_format_list__
):
869 compresscheck
= CheckCompressionType(infile
, formatspecs
, False);
870 if(not compresscheck
):
871 fextname
= os
.path
.splitext(infile
)[1];
873 compresscheck
= "gzip";
874 if(fextname
==".bz2"):
875 compresscheck
= "bzip2";
876 if(fextname
==".zst"):
877 compresscheck
= "zstd";
878 if(fextname
==".lz4"):
879 compresscheck
= "lz4";
880 if(fextname
==".lzo" or fextname
==".lzop"):
881 compresscheck
= "lzo";
882 if(fextname
==".lzma" or fextname
==".xz"):
883 compresscheck
= "lzma";
884 if(not compresscheck
):
886 if(compresscheck
=="catfile"):
888 if(compresscheck
==formatspecs
[1]):
889 return formatspecs
[1];
890 if(compresscheck
=="tarfile"):
892 if(compresscheck
=="zipfile"):
894 if(hasattr(infile
, "read") or hasattr(infile
, "write")):
895 catfp
= UncompressArchiveFile(infile
, formatspecs
[1]);
897 if(compresscheck
=="gzip"):
902 catfp
= gzip
.GzipFile(infile
, "rb");
903 if(compresscheck
=="bzip2"):
908 catfp
= bz2
.BZ2File(infile
, "rb");
909 if(compresscheck
=="lz4"):
914 catfp
= lz4
.frame
.open(infile
, "rb");
915 if(compresscheck
=="zstd"):
920 catfp
= zstandard
.open(infile
, "rb");
921 if(compresscheck
=="lzma" or compresscheck
=="xz"):
926 catfp
= lzma
.open(infile
, "rb");
928 prefp
= catfp
.read(5);
929 if(prefp
==binascii
.unhexlify("7573746172")):
930 filetype
= "tarfile";
932 prefp
= catfp
.read(7);
933 if(prefp
==binascii
.unhexlify("43617446696c65")):
934 filetype
= "catfile";
936 prefp
= catfp
.read(formatspecs
[2]);
937 if(prefp
==binascii
.unhexlify(formatspecs
[3])):
938 filetype
= formatspecs
[1];
940 prefp
= catfp
.read(10);
941 if(prefp
==binascii
.unhexlify("7061785f676c6f62616c")):
942 filetype
= "tarfile";
947 def GZipCompress(data
, compresslevel
=9):
952 tmpfp
= tempfile
.NamedTemporaryFile("wb", delete
=False);
954 tmpfp
= gzip
.GzipFile(tmpfp
.name
, mode
="wb", compresslevel
=compresslevel
);
957 catfp
= open(tmpfp
.name
, "rb");
958 catdata
= catfp
.read();
962 def CompressArchiveFile(fp
, compression
="auto", compressionlevel
=None, formatspecs
=__file_format_list__
):
963 compressionlist
= ['auto', 'gzip', 'bzip2', 'zstd', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
964 if(not hasattr(fp
, "read") and not hasattr(fp
, "write")):
967 if(not compression
or compression
or compression
=="catfile" or compression
==formatspecs
[1]):
969 if(compression
not in compressionlist
and compression
is None):
970 compression
= "auto";
971 if(compression
=="gzip"):
977 if(compressionlevel
is None):
978 compressionlevel
= 9;
980 compressionlevel
= int(compressionlevel
);
981 catfp
.write(gzip
.compress(fp
.read(), compresslevel
=compressionlevel
));
982 if(compression
=="bzip2"):
988 if(compressionlevel
is None):
989 compressionlevel
= 9;
991 compressionlevel
= int(compressionlevel
);
992 catfp
.write(bz2
.compress(fp
.read(), compresslevel
=compressionlevel
));
993 if(compression
=="lz4"):
999 if(compressionlevel
is None):
1000 compressionlevel
= 9;
1002 compressionlevel
= int(compressionlevel
);
1003 catfp
.write(lz4
.frame
.compress(fp
.read(), compression_level
=compressionlevel
));
1004 if(compression
=="lzo" or compression
=="lzop"):
1010 if(compressionlevel
is None):
1011 compressionlevel
= 9;
1013 compressionlevel
= int(compressionlevel
);
1014 catfp
.write(lzo
.compress(fp
.read(), compresslevel
=compressionlevel
));
1015 if(compression
=="zstd"):
1021 if(compressionlevel
is None):
1022 compressionlevel
= 10;
1024 compressionlevel
= int(compressionlevel
);
1025 catfp
.write(zstandard
.compress(fp
.read(), level
=compressionlevel
));
1026 if(compression
=="lzma"):
1032 if(compressionlevel
is None):
1033 compressionlevel
= 9;
1035 compressionlevel
= int(compressionlevel
);
1036 catfp
.write(lzma
.compress(fp
.read(), format
=lzma
.FORMAT_ALONE
, preset
=compressionlevel
));
1037 if(compression
=="xz"):
1043 if(compressionlevel
is None):
1044 compressionlevel
= 9;
1046 compressionlevel
= int(compressionlevel
);
1047 catfp
.write(lzma
.compress(fp
.read(), format
=lzma
.FORMAT_XZ
, preset
=compressionlevel
));
1048 if(compression
=="auto" or compression
is None):
1053 create_alias_function("Compress", __file_format_name__
, "", CompressArchiveFile
);
1055 def CompressOpenFile(outfile
, compressionlevel
=None):
1056 if(outfile
is None):
1058 fbasename
= os
.path
.splitext(outfile
)[0];
1059 fextname
= os
.path
.splitext(outfile
)[1];
1060 if(compressionlevel
is None and fextname
!=".zst"):
1061 compressionlevel
= 9;
1062 elif(compressionlevel
is None and fextname
==".zst"):
1063 compressionlevel
= 10;
1065 compressionlevel
= int(compressionlevel
);
1066 if(sys
.version_info
[0]==2):
1070 if(fextname
not in outextlistwd
):
1072 outfp
= open(outfile
, "wb", encoding
="UTF-8");
1073 except (ValueError, TypeError) as e
:
1074 outfp
= open(outfile
, "wb");
1075 elif(fextname
==".gz"):
1081 outfp
= gzip
.open(outfile
, mode
, compressionlevel
, encoding
="UTF-8");
1082 except (ValueError, TypeError) as e
:
1083 outfp
= gzip
.open(outfile
, mode
, compressionlevel
);
1084 elif(fextname
==".bz2"):
1090 outfp
= bz2
.open(outfile
, mode
, compressionlevel
, encoding
="UTF-8");
1091 except (ValueError, TypeError) as e
:
1092 outfp
= bz2
.open(outfile
, mode
, compressionlevel
);
1093 elif(fextname
==".zst"):
1099 outfp
= zstandard
.open(outfile
, mode
, zstandard
.ZstdCompressor(level
=compressionlevel
), encoding
="UTF-8");
1100 except (ValueError, TypeError) as e
:
1101 outfp
= zstandard
.open(outfile
, mode
, zstandard
.ZstdCompressor(level
=compressionlevel
));
1102 elif(fextname
==".xz"):
1108 outfp
= lzma
.open(outfile
, mode
, format
=lzma
.FORMAT_XZ
, preset
=compressionlevel
, encoding
="UTF-8");
1109 except (ValueError, TypeError) as e
:
1110 outfp
= lzma
.open(outfile
, mode
, format
=lzma
.FORMAT_XZ
, preset
=compressionlevel
);
1111 elif(fextname
==".lz4"):
1117 outfp
= lz4
.frame
.open(outfile
, mode
, compression_level
=compressionlevel
, encoding
="UTF-8");
1118 except (ValueError, TypeError) as e
:
1119 outfp
= lz4
.frame
.open(outfile
, mode
, compression_level
=compressionlevel
);
1120 elif(fextname
==".lzo"):
1126 outfp
= lzo
.open(outfile
, mode
, compresslevel
=compressionlevel
, encoding
="UTF-8");
1127 except (ValueError, TypeError) as e
:
1128 outfp
= lzo
.open(outfile
, mode
, compresslevel
=compressionlevel
);
1129 elif(fextname
==".lzma"):
1135 outfp
= lzma
.open(outfile
, mode
, format
=lzma
.FORMAT_ALONE
, preset
=compressionlevel
, encoding
="UTF-8");
1136 except (ValueError, TypeError) as e
:
1137 outfp
= lzma
.open(outfile
, mode
, format
=lzma
.FORMAT_ALONE
, preset
=compressionlevel
);
1140 def GetDevMajorMinor(fdev
):
1142 if(hasattr(os
, "minor")):
1143 retdev
.append(os
.minor(fdev
));
1146 if(hasattr(os
, "major")):
1147 retdev
.append(os
.major(fdev
));
1152 def CheckSumSupport(checkfor
, guaranteed
=True):
1154 hash_list
= sorted(list(hashlib
.algorithms_guaranteed
));
1156 hash_list
= sorted(list(hashlib
.algorithms_available
));
1157 checklistout
= sorted(hash_list
+ ['adler32', 'crc16', 'crc16_ansi', 'crc16_ibm', 'crc16_ccitt', 'crc32', 'crc64', 'crc64_ecma', 'crc64_iso', 'none']);
1158 if(checkfor
in checklistout
):
1163 def CheckSumSupportAlt(checkfor
, guaranteed
=True):
1165 hash_list
= sorted(list(hashlib
.algorithms_guaranteed
));
1167 hash_list
= sorted(list(hashlib
.algorithms_available
));
1168 checklistout
= hash_list
;
1169 if(checkfor
in checklistout
):
1174 def PackArchiveFile(infiles
, outfile
, dirlistfromtxt
=False, compression
="auto", compressionlevel
=None, followlink
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
1175 compressionlist
= ['auto', 'gzip', 'bzip2', 'zstd', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
1176 outextlist
= ['gz', 'bz2', 'zst', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
1177 outextlistwd
= ['.gz', '.bz2', '.zst', '.lz4', '.lzo', '.lzop', '.lzma', '.xz'];
1178 advancedlist
= True;
1179 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
1180 outfile
= RemoveWindowsPath(outfile
);
1181 checksumtype
= checksumtype
.lower();
1182 if(not CheckSumSupport(checksumtype
, hashlib_guaranteed
)):
1183 checksumtype
="crc32";
1184 if(checksumtype
=="none"):
1186 if(not compression
or compression
or compression
=="catfile" or compression
==formatspecs
[1]):
1188 if(compression
not in compressionlist
and compression
is None):
1189 compression
= "auto";
1191 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
1192 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
1193 if(os
.path
.exists(outfile
)):
1198 elif(hasattr(outfile
, "read") or hasattr(outfile
, "write")):
1201 fbasename
= os
.path
.splitext(outfile
)[0];
1202 fextname
= os
.path
.splitext(outfile
)[1];
1203 catfp
= CompressOpenFile(outfile
, compressionlevel
);
1204 catver
= formatspecs
[5];
1205 fileheaderver
= str(int(catver
.replace(".", "")));
1206 fileheader
= AppendNullByte(formatspecs
[0] + fileheaderver
, formatspecs
[4]);
1207 catfp
.write(fileheader
.encode('UTF-8'));
1210 for line
in sys
.stdin
:
1211 infilelist
.append(line
.strip());
1212 infilelist
= list(filter(None, infilelist
));
1213 elif(infiles
!="-" and dirlistfromtxt
and os
.path
.exists(infiles
) and (os
.path
.isfile(infiles
) or infiles
=="/dev/null" or infiles
=="NUL")):
1214 if(not os
.path
.exists(infiles
) or not os
.path
.isfile(infiles
)):
1216 with
open(infiles
, "r") as finfile
:
1217 for line
in finfile
:
1218 infilelist
.append(line
.strip());
1219 infilelist
= list(filter(None, infilelist
));
1221 if(isinstance(infiles
, (list, tuple, ))):
1222 infilelist
= list(filter(None, infiles
));
1223 elif(isinstance(infiles
, (str, ))):
1224 infilelist
= list(filter(None, [infiles
]));
1226 GetDirList
= ListDirAdvanced(infilelist
, followlink
, False);
1228 GetDirList
= ListDir(infilelist
, followlink
, False);
1236 inodetocatinode
= {};
1237 fnumfiles
= format(int(len(GetDirList
)), 'x').lower();
1238 fnumfilesa
= AppendNullBytes([fnumfiles
, checksumtype
], formatspecs
[4]);
1239 if(checksumtype
=="none" or checksumtype
==""):
1240 catfileheadercshex
= format(0, 'x').lower();
1241 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
1242 catfileheadercshex
= format(crc16(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
1243 elif(checksumtype
=="crc16_ccitt"):
1244 catfileheadercshex
= format(crc16_ccitt(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
1245 elif(checksumtype
=="adler32"):
1246 catfileheadercshex
= format(zlib
.adler32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
1247 elif(checksumtype
=="crc32"):
1248 catfileheadercshex
= format(crc32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
1249 elif(checksumtype
=="crc64_ecma"):
1250 catfileheadercshex
= format(crc64_ecma(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1251 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
1252 catfileheadercshex
= format(crc64_iso(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1253 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
1254 checksumoutstr
= hashlib
.new(checksumtype
);
1255 checksumoutstr
.update(str(fileheader
+ fnumfilesa
).encode('UTF-8'));
1256 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
1258 catfileheadercshex
= format(0, 'x').lower
1259 fnumfilesa
= fnumfilesa
+ AppendNullByte(catfileheadercshex
, formatspecs
[4]);
1260 catfp
.write(fnumfilesa
.encode('UTF-8'));
1263 os
.fsync(catfp
.fileno());
1264 except io
.UnsupportedOperation
:
1266 except AttributeError:
1268 for curfname
in GetDirList
:
1269 catfhstart
= catfp
.tell();
1270 if(re
.findall("^[.|/]", curfname
)):
1273 fname
= "./"+curfname
;
1275 VerbosePrintOut(fname
);
1276 if(not followlink
or followlink
is None):
1277 fstatinfo
= os
.lstat(fname
);
1279 fstatinfo
= os
.stat(fname
);
1280 fpremode
= fstatinfo
.st_mode
;
1281 finode
= fstatinfo
.st_ino
;
1282 flinkcount
= fstatinfo
.st_nlink
;
1284 if(stat
.S_ISREG(fpremode
)):
1286 elif(stat
.S_ISLNK(fpremode
)):
1288 elif(stat
.S_ISCHR(fpremode
)):
1290 elif(stat
.S_ISBLK(fpremode
)):
1292 elif(stat
.S_ISDIR(fpremode
)):
1294 elif(stat
.S_ISFIFO(fpremode
)):
1296 elif(hasattr(stat
, "S_ISDOOR") and stat
.S_ISDOOR(fpremode
)):
1298 elif(hasattr(stat
, "S_ISPORT") and stat
.S_ISPORT(fpremode
)):
1300 elif(hasattr(stat
, "S_ISWHT") and stat
.S_ISWHT(fpremode
)):
1305 fcurfid
= format(int(curfid
), 'x').lower();
1306 if(not followlink
and finode
!=0):
1308 if(finode
in inodelist
):
1310 flinkname
= inodetofile
[finode
];
1311 fcurinode
= format(int(inodetocatinode
[finode
]), 'x').lower();
1312 if(finode
not in inodelist
):
1313 inodelist
.append(finode
);
1314 inodetofile
.update({finode
: fname
});
1315 inodetocatinode
.update({finode
: curinode
});
1316 fcurinode
= format(int(curinode
), 'x').lower();
1317 curinode
= curinode
+ 1;
1319 fcurinode
= format(int(curinode
), 'x').lower();
1320 curinode
= curinode
+ 1;
1321 curfid
= curfid
+ 1;
1323 flinkname
= os
.readlink(fname
);
1324 fdev
= fstatinfo
.st_dev
;
1325 getfdev
= GetDevMajorMinor(fdev
);
1326 fdev_minor
= getfdev
[0];
1327 fdev_major
= getfdev
[1];
1328 frdev
= fstatinfo
.st_dev
;
1329 if(hasattr(fstatinfo
, "st_rdev")):
1330 frdev
= fstatinfo
.st_rdev
;
1332 frdev
= fstatinfo
.st_dev
;
1333 getfrdev
= GetDevMajorMinor(frdev
);
1334 frdev_minor
= getfrdev
[0];
1335 frdev_major
= getfrdev
[1];
1336 if(ftype
==1 or ftype
==2 or ftype
==3 or ftype
==4 or ftype
==5 or ftype
==6):
1337 fsize
= format(int("0"), 'x').lower();
1338 elif(ftype
==0 or ftype
==7):
1339 fsize
= format(int(fstatinfo
.st_size
), 'x').lower();
1341 fsize
= format(int(fstatinfo
.st_size
)).lower();
1342 fatime
= format(int(fstatinfo
.st_atime
), 'x').lower();
1343 fmtime
= format(int(fstatinfo
.st_mtime
), 'x').lower();
1344 fctime
= format(int(fstatinfo
.st_ctime
), 'x').lower();
1345 if(hasattr(fstatinfo
, "st_birthtime")):
1346 fbtime
= format(int(fstatinfo
.st_birthtime
), 'x').lower();
1348 fbtime
= format(int(fstatinfo
.st_ctime
), 'x').lower();
1349 fmode
= format(int(fstatinfo
.st_mode
), 'x').lower();
1350 fchmode
= format(int(stat
.S_IMODE(fstatinfo
.st_mode
)), 'x').lower();
1351 ftypemod
= format(int(stat
.S_IFMT(fstatinfo
.st_mode
)), 'x').lower();
1352 fuid
= format(int(fstatinfo
.st_uid
), 'x').lower();
1353 fgid
= format(int(fstatinfo
.st_gid
), 'x').lower();
1358 userinfo
= pwd
.getpwuid(fstatinfo
.st_uid
);
1359 funame
= userinfo
.pw_name
;
1368 groupinfo
= grp
.getgrgid(fstatinfo
.st_gid
);
1369 fgname
= groupinfo
.gr_name
;
1374 fdev_minor
= format(int(fdev_minor
), 'x').lower();
1375 fdev_major
= format(int(fdev_major
), 'x').lower();
1376 frdev_minor
= format(int(frdev_minor
), 'x').lower();
1377 frdev_major
= format(int(frdev_major
), 'x').lower();
1378 finode
= format(int(finode
), 'x').lower();
1379 flinkcount
= format(int(flinkcount
), 'x').lower();
1380 if(hasattr(fstatinfo
, "st_file_attributes")):
1381 fwinattributes
= format(int(fstatinfo
.st_file_attributes
), 'x').lower();
1383 fwinattributes
= format(int(0), 'x').lower();
1384 fcontents
= "".encode('UTF-8');
1386 if(ftype
== 0 or ftype
== 7):
1387 with(open(fname
, "rb") as fpc
):
1389 chunk
= fpc
.read(chunk_size
);
1393 if(followlink
and (ftype
== 1 or ftype
== 2)):
1394 flstatinfo
= os
.stat(flinkname
);
1395 with(open(flinkname
, "rb") as fpc
):
1397 chunk
= fpc
.read(chunk_size
);
1401 ftypehex
= format(ftype
, 'x').lower();
1402 extrafields
= format(len(extradata
), 'x').lower();
1403 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[4]);
1404 if(len(extradata
)>0):
1405 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[4]);
1406 extrasizelen
= format(len(extrasizestr
), 'x').lower();
1407 catfileoutstr
= AppendNullBytes([ftypehex
, fname
, flinkname
, fsize
, fatime
, fmtime
, fctime
, fbtime
, fmode
, fuid
, funame
, fgid
, fgname
, fcurfid
, fcurinode
, flinkcount
, fdev_minor
, fdev_major
, frdev_minor
, frdev_major
, extrasizelen
, extrafields
], formatspecs
[4]);
1408 if(len(extradata
)>0):
1409 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[4]);
1410 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[4]);
1411 if(checksumtype
=="none" or checksumtype
==""):
1412 catfileheadercshex
= format(0, 'x').lower();
1413 catfilecontentcshex
= format(0, 'x').lower();
1414 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
1415 catfileheadercshex
= format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
1416 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
1417 elif(checksumtype
=="crc16_ccitt"):
1418 catfileheadercshex
= format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
1419 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
1420 elif(checksumtype
=="adler32"):
1421 catfileheadercshex
= format(zlib
.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
1422 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
1423 elif(checksumtype
=="crc32"):
1424 catfileheadercshex
= format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
1425 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
1426 elif(checksumtype
=="crc64_ecma"):
1427 catfileheadercshex
= format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1428 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
1429 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
1430 catfileheadercshex
= format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1431 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
1432 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
1433 checksumoutstr
= hashlib
.new(checksumtype
);
1434 checksumoutstr
.update("".encode('UTF-8'));
1435 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
1436 checksumoutstr
= hashlib
.new(checksumtype
);
1437 checksumoutstr
.update(fcontents
);
1438 catfilecontentcshex
= checksumoutstr
.hexdigest().lower();
1440 catfileheadercshex
= format(0, 'x').lower();
1441 catfilecontentcshex
= format(0, 'x').lower();
1442 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4]);
1443 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
1444 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[4]) + catfileoutstr
;
1445 if(checksumtype
=="none" or checksumtype
==""):
1446 catfileheadercshex
= format(0, 'x').lower();
1447 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
1448 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
1449 elif(checksumtype
=="crc16_ccitt"):
1450 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
1451 elif(checksumtype
=="adler32"):
1452 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
1453 elif(checksumtype
=="crc32"):
1454 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
1455 elif(checksumtype
=="crc64_ecma"):
1456 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1457 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
1458 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1459 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
1460 checksumoutstr
= hashlib
.new(checksumtype
);
1461 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
1462 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
1464 catfileheadercshex
= format(0, 'x').lower();
1465 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4]);
1466 catfhend
= (catfp
.tell() - 1) + len(catfileoutstr
);
1467 catfcontentstart
= catfp
.tell() + len(catfileoutstr
);
1468 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
1469 nullstrecd
= formatspecs
[4].encode('UTF-8');
1470 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
;
1471 catfcontentend
= (catfp
.tell() - 1) + len(catfileout
);
1472 catfp
.write(catfileout
);
1475 os
.fsync(catfp
.fileno());
1476 except io
.UnsupportedOperation
:
1478 except AttributeError:
1480 if(outfile
=="-" or hasattr(outfile
, "read") or hasattr(outfile
, "write")):
1481 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
1484 os
.fsync(catfp
.fileno());
1485 except io
.UnsupportedOperation
:
1487 except AttributeError:
1491 if(hasattr(sys
.stdout
, "buffer")):
1492 shutil
.copyfileobj(catfp
, sys
.stdout
.buffer);
1494 shutil
.copyfileobj(catfp
, sys
.stdout
);
1502 create_alias_function("Pack", __file_format_name__
, "", PackArchiveFile
);
1504 if(hasattr(shutil
, "register_archive_format")):
1505 def PackArchiveFileFunc(archive_name
, source_dir
, **kwargs
):
1506 return PackArchiveFile(source_dir
, archive_name
, False, "auto", None, False, "crc32", [], __file_format_delimiter__
, False, False);
1507 create_alias_function("Pack", __file_format_name__
, "Func", PackArchiveFileFunc
);
1509 def PackArchiveFileFromDirList(infiles
, outfile
, dirlistfromtxt
=False, compression
="auto", compressionlevel
=None, followlink
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
1510 return PackArchiveFile(infiles
, outfile
, dirlistfromtxt
, compression
, compressionlevel
, followlink
, checksumtype
, extradata
, formatspecs
, verbose
, returnfp
);
1512 def PackArchiveFileFromTarFile(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
1513 compressionlist
= ['auto', 'gzip', 'bzip2', 'zstd', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
1514 outextlist
= ['gz', 'bz2', 'zst', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
1515 outextlistwd
= ['.gz', '.bz2', '.zst', '.lz4', '.lzo', '.lzop', '.lzma', '.xz'];
1516 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
1517 outfile
= RemoveWindowsPath(outfile
);
1518 checksumtype
= checksumtype
.lower();
1519 if(not CheckSumSupport(checksumtype
, hashlib_guaranteed
)):
1520 checksumtype
="crc32";
1521 if(checksumtype
=="none"):
1523 if(not compression
or compression
or compression
=="catfile" or compression
==formatspecs
[1]):
1525 if(compression
not in compressionlist
and compression
is None):
1526 compression
= "auto";
1528 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
1529 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
1530 if(os
.path
.exists(outfile
)):
1535 elif(hasattr(outfile
, "read") or hasattr(outfile
, "write")):
1538 fbasename
= os
.path
.splitext(outfile
)[0];
1539 fextname
= os
.path
.splitext(outfile
)[1];
1540 catfp
= CompressOpenFile(outfile
, compressionlevel
);
1541 catver
= formatspecs
[5];
1542 fileheaderver
= str(int(catver
.replace(".", "")));
1543 fileheader
= AppendNullByte(formatspecs
[0] + fileheaderver
, formatspecs
[4]);
1544 catfp
.write(fileheader
.encode('UTF-8'));
1550 inodetocatinode
= {};
1551 if(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
1554 if(not tarfile
.is_tarfile(infile
)):
1556 except AttributeError:
1557 if(not is_tarfile(infile
)):
1559 tarfp
= tarfile
.open(infile
, "r");
1560 fnumfiles
= format(int(len(tarfp
.getmembers())), 'x').lower();
1561 fnumfilesa
= AppendNullBytes([fnumfiles
, checksumtype
], formatspecs
[4]);
1562 if(checksumtype
=="none" or checksumtype
==""):
1563 catfileheadercshex
= format(0, 'x').lower();
1564 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
1565 catfileheadercshex
= format(crc16(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
1566 elif(checksumtype
=="crc16_ccitt"):
1567 catfileheadercshex
= format(crc16_ccitt(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
1568 elif(checksumtype
=="adler32"):
1569 catfileheadercshex
= format(zlib
.adler32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
1570 elif(checksumtype
=="crc32"):
1571 catfileheadercshex
= format(crc32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
1572 elif(checksumtype
=="crc64_ecma"):
1573 catfileheadercshex
= format(crc64_ecma(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1574 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
1575 catfileheadercshex
= format(crc64_iso(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1576 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
1577 checksumoutstr
= hashlib
.new(checksumtype
);
1578 checksumoutstr
.update(str(fileheader
+ fnumfilesa
).encode('UTF-8'));
1579 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
1581 catfileheadercshex
= format(0, 'x').lower();
1582 fnumfilesa
= fnumfilesa
+ AppendNullByte(catfileheadercshex
, formatspecs
[4]);
1583 catfp
.write(fnumfilesa
.encode('UTF-8'));
1586 os
.fsync(catfp
.fileno());
1587 except io
.UnsupportedOperation
:
1589 except AttributeError:
1591 for member
in sorted(tarfp
.getmembers(), key
=lambda x
: x
.name
):
1592 catfhstart
= catfp
.tell();
1593 if(re
.findall("^[.|/]", member
.name
)):
1594 fname
= member
.name
;
1596 fname
= "./"+member
.name
;
1598 VerbosePrintOut(fname
);
1599 fpremode
= member
.mode
;
1600 ffullmode
= member
.mode
;
1604 ffullmode
= member
.mode
+ stat
.S_IFREG
;
1606 elif(member
.isdev()):
1607 ffullmode
= member
.mode
;
1609 elif(member
.islnk()):
1610 ffullmode
= member
.mode
+ stat
.S_IFREG
;
1612 elif(member
.issym()):
1613 ffullmode
= member
.mode
+ stat
.S_IFLNK
;
1615 elif(member
.ischr()):
1616 ffullmode
= member
.mode
+ stat
.S_IFCHR
;
1618 elif(member
.isblk()):
1619 ffullmode
= member
.mode
+ stat
.S_IFBLK
;
1621 elif(member
.isdir()):
1622 ffullmode
= member
.mode
+ stat
.S_IFDIR
;
1624 elif(member
.isfifo()):
1625 ffullmode
= member
.mode
+ stat
.S_IFIFO
;
1627 elif(member
.issparse()):
1628 ffullmode
= member
.mode
;
1631 ffullmode
= member
.mode
;
1634 fcurfid
= format(int(curfid
), 'x').lower();
1635 fcurinode
= format(int(0), 'x').lower();
1636 curfid
= curfid
+ 1;
1638 flinkname
= member
.linkname
;
1639 fdev_minor
= format(int(member
.devminor
), 'x').lower();
1640 fdev_major
= format(int(member
.devmajor
), 'x').lower();
1641 frdev_minor
= format(int(member
.devminor
), 'x').lower();
1642 frdev_major
= format(int(member
.devmajor
), 'x').lower();
1643 if(ftype
==1 or ftype
==2 or ftype
==3 or ftype
==4 or ftype
==5 or ftype
==6):
1644 fsize
= format(int("0"), 'x').lower();
1645 elif(ftype
==0 or ftype
==7):
1646 fsize
= format(int(member
.size
), 'x').lower();
1648 fsize
= format(int(member
.size
), 'x').lower();
1649 fatime
= format(int(member
.mtime
), 'x').lower();
1650 fmtime
= format(int(member
.mtime
), 'x').lower();
1651 fctime
= format(int(member
.mtime
), 'x').lower();
1652 fbtime
= format(int(member
.mtime
), 'x').lower();
1653 fmode
= format(int(ffullmode
), 'x').lower();
1654 fchmode
= format(int(stat
.S_IMODE(ffullmode
)), 'x').lower();
1655 ftypemod
= format(int(stat
.S_IFMT(ffullmode
)), 'x').lower();
1656 fuid
= format(int(member
.uid
), 'x').lower();
1657 fgid
= format(int(member
.gid
), 'x').lower();
1658 funame
= member
.uname
;
1659 fgname
= member
.gname
;
1660 flinkcount
= format(int(flinkcount
), 'x').lower();
1661 fcontents
= "".encode('UTF-8');
1663 if(ftype
== 0 or ftype
== 7):
1664 with(tarfp
.extractfile(member
) as fpc
):
1666 chunk
= fpc
.read(chunk_size
);
1670 ftypehex
= format(ftype
, 'x').lower();
1671 extrafields
= format(len(extradata
), 'x').lower();
1672 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[4]);
1673 if(len(extradata
)>0):
1674 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[4]);
1675 extrasizelen
= format(len(extrasizestr
), 'x').lower();
1676 catfileoutstr
= AppendNullBytes([ftypehex
, fname
, flinkname
, fsize
, fatime
, fmtime
, fctime
, fbtime
, fmode
, fuid
, funame
, fgid
, fgname
, fcurfid
, fcurinode
, flinkcount
, fdev_minor
, fdev_major
, frdev_minor
, frdev_major
, extrasizelen
, extrafields
], formatspecs
[4]);
1677 if(len(extradata
)>0):
1678 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[4]);
1679 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[4]);
1680 catfhend
= (catfp
.tell() - 1) + len(catfileoutstr
);
1681 catfcontentstart
= catfp
.tell() + len(catfileoutstr
);
1682 if(checksumtype
=="none" or checksumtype
==""):
1683 catfileheadercshex
= format(0, 'x').lower();
1684 catfilecontentcshex
= format(0, 'x').lower();
1685 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
1686 catfileheadercshex
= format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
1687 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
1688 elif(checksumtype
=="crc16_ccitt"):
1689 catfileheadercshex
= format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
1690 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
1691 elif(checksumtype
=="adler32"):
1692 catfileheadercshex
= format(zlib
.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
1693 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
1694 elif(checksumtype
=="crc32"):
1695 catfileheadercshex
= format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
1696 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
1697 elif(checksumtype
=="crc64_ecma"):
1698 catfileheadercshex
= format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1699 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
1700 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
1701 catfileheadercshex
= format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1702 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
1703 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
1704 checksumoutstr
= hashlib
.new(checksumtype
);
1705 checksumoutstr
.update("".encode('UTF-8'));
1706 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
1707 checksumoutstr
= hashlib
.new(checksumtype
);
1708 checksumoutstr
.update(fcontents
);
1709 catfilecontentcshex
= checksumoutstr
.hexdigest().lower();
1711 catfileheadercshex
= format(0, 'x').lower();
1712 catfilecontentcshex
= format(0, 'x').lower();
1713 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4]);
1714 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
1715 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[4]) + catfileoutstr
;
1716 if(checksumtype
=="none" or checksumtype
==""):
1717 catfileheadercshex
= format(0, 'x').lower();
1718 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
1719 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
1720 elif(checksumtype
=="crc16_ccitt"):
1721 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
1722 elif(checksumtype
=="adler32"):
1723 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
1724 elif(checksumtype
=="crc32"):
1725 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
1726 elif(checksumtype
=="crc64_ecma"):
1727 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1728 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
1729 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1730 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
1731 checksumoutstr
= hashlib
.new(checksumtype
);
1732 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
1733 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
1735 catfileheadercshex
= format(0, 'x').lower();
1736 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4]);
1737 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
1738 nullstrecd
= formatspecs
[4].encode('UTF-8');
1739 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
;
1740 catfcontentend
= (catfp
.tell() - 1) + len(catfileout
);
1741 catfp
.write(catfileout
);
1744 os
.fsync(catfp
.fileno());
1745 except io
.UnsupportedOperation
:
1747 except AttributeError:
1749 if(outfile
=="-" or hasattr(outfile
, "read") or hasattr(outfile
, "write")):
1750 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
1753 os
.fsync(catfp
.fileno());
1754 except io
.UnsupportedOperation
:
1756 except AttributeError:
1760 if(hasattr(sys
.stdout
, "buffer")):
1761 shutil
.copyfileobj(catfp
, sys
.stdout
.buffer);
1763 shutil
.copyfileobj(catfp
, sys
.stdout
);
1771 create_alias_function("Pack", __file_format_name__
, "FromTarFile", PackArchiveFileFromTarFile
);
1773 def PackArchiveFileFromZipFile(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
1774 compressionlist
= ['auto', 'gzip', 'bzip2', 'zstd', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
1775 outextlist
= ['gz', 'bz2', 'zst', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
1776 outextlistwd
= ['.gz', '.bz2', '.zst', '.lz4', '.lzo', '.lzop', '.lzma', '.xz'];
1777 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
1778 outfile
= RemoveWindowsPath(outfile
);
1779 checksumtype
= checksumtype
.lower();
1780 if(not CheckSumSupport(checksumtype
, hashlib_guaranteed
)):
1781 checksumtype
="crc32";
1782 if(checksumtype
=="none"):
1784 if(not compression
or compression
or compression
=="catfile" or compression
==formatspecs
[1]):
1786 if(compression
not in compressionlist
and compression
is None):
1787 compression
= "auto";
1789 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
1790 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
1791 if(os
.path
.exists(outfile
)):
1796 elif(hasattr(outfile
, "read") or hasattr(outfile
, "write")):
1799 fbasename
= os
.path
.splitext(outfile
)[0];
1800 fextname
= os
.path
.splitext(outfile
)[1];
1801 catfp
= CompressOpenFile(outfile
, compressionlevel
);
1802 catver
= formatspecs
[5];
1803 fileheaderver
= str(int(catver
.replace(".", "")));
1804 fileheader
= AppendNullByte(formatspecs
[0] + fileheaderver
, formatspecs
[4]);
1805 catfp
.write(fileheader
.encode('UTF-8'));
1811 inodetocatinode
= {};
1812 if(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
1814 if(not zipfile
.is_zipfile(infile
)):
1816 zipfp
= zipfile
.ZipFile(infile
, "r", allowZip64
=True);
1817 ziptest
= zipfp
.testzip();
1819 VerbosePrintOut("Bad file found!");
1820 fnumfiles
= format(int(len(zipfp
.infolist())), 'x').lower();
1821 fnumfilesa
= AppendNullBytes([fnumfiles
, checksumtype
], formatspecs
[4]);
1822 if(checksumtype
=="none" or checksumtype
==""):
1823 catfileheadercshex
= format(0, 'x').lower();
1824 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
1825 catfileheadercshex
= format(crc16(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
1826 elif(checksumtype
=="crc16_ccitt"):
1827 catfileheadercshex
= format(crc16_ccitt(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
1828 elif(checksumtype
=="adler32"):
1829 catfileheadercshex
= format(zlib
.adler32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
1830 elif(checksumtype
=="crc32"):
1831 catfileheadercshex
= format(crc32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
1832 elif(checksumtype
=="crc64_ecma"):
1833 catfileheadercshex
= format(crc64_ecma(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1834 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
1835 catfileheadercshex
= format(crc64_iso(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1836 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
1837 checksumoutstr
= hashlib
.new(checksumtype
);
1838 checksumoutstr
.update(str(fileheader
+ fnumfilesa
).encode('UTF-8'));
1839 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
1841 catfileheadercshex
= format(0, 'x').lower();
1842 fnumfilesa
= fnumfilesa
+ AppendNullByte(catfileheadercshex
, formatspecs
[4]);
1843 catfp
.write(fnumfilesa
.encode('UTF-8'));
1846 os
.fsync(catfp
.fileno());
1847 except io
.UnsupportedOperation
:
1849 except AttributeError:
1851 for member
in sorted(zipfp
.infolist(), key
=lambda x
: x
.filename
):
1852 catfhstart
= catfp
.tell();
1853 if(re
.findall("^[.|/]", member
.filename
)):
1854 fname
= member
.filename
;
1856 fname
= "./"+member
.filename
;
1857 zipinfo
= zipfp
.getinfo(member
.filename
);
1859 VerbosePrintOut(fname
);
1860 if(not member
.is_dir()):
1861 fpremode
= int(stat
.S_IFREG
+ 438);
1862 elif(member
.is_dir()):
1863 fpremode
= int(stat
.S_IFDIR
+ 511);
1866 if(not member
.is_dir()):
1868 elif(member
.is_dir()):
1871 fcurfid
= format(int(curfid
), 'x').lower();
1872 fcurinode
= format(int(0), 'x').lower();
1873 curfid
= curfid
+ 1;
1874 fdev_minor
= format(int(0), 'x').lower();
1875 fdev_major
= format(int(0), 'x').lower();
1876 frdev_minor
= format(int(0), 'x').lower();
1877 frdev_major
= format(int(0), 'x').lower();
1879 fsize
= format(int("0"), 'x').lower();
1881 fsize
= format(int(member
.file_size
), 'x').lower();
1883 fsize
= format(int(member
.file_size
), 'x').lower();
1884 fatime
= format(int(time
.mktime(member
.date_time
+ (0, 0, -1))), 'x').lower();
1885 fmtime
= format(int(time
.mktime(member
.date_time
+ (0, 0, -1))), 'x').lower();
1886 fctime
= format(int(time
.mktime(member
.date_time
+ (0, 0, -1))), 'x').lower();
1887 fbtime
= format(int(time
.mktime(member
.date_time
+ (0, 0, -1))), 'x').lower();
1888 if(not member
.is_dir()):
1889 fmode
= format(int(stat
.S_IFREG
+ 438), 'x').lower();
1890 fchmode
= format(int(stat
.S_IMODE(int(stat
.S_IFREG
+ 438))), 'x').lower();
1891 ftypemod
= format(int(stat
.S_IFMT(int(stat
.S_IFREG
+ 438))), 'x').lower();
1892 if(member
.is_dir()):
1893 fmode
= format(int(stat
.S_IFDIR
+ 511), 'x').lower();
1894 fchmode
= format(int(stat
.S_IMODE(int(stat
.S_IFDIR
+ 511))), 'x').lower();
1895 ftypemod
= format(int(stat
.S_IFMT(int(stat
.S_IFDIR
+ 511))), 'x').lower();
1897 fuid
= format(int(os
.getuid()), 'x').lower();
1898 except AttributeError:
1899 fuid
= format(int(0), 'x').lower();
1901 fuid
= format(int(0), 'x').lower();
1903 fgid
= format(int(os
.getgid()), 'x').lower();
1904 except AttributeError:
1905 fgid
= format(int(0), 'x').lower();
1907 fgid
= format(int(0), 'x').lower();
1911 userinfo
= pwd
.getpwuid(os
.getuid());
1912 funame
= userinfo
.pw_name
;
1915 except AttributeError:
1923 groupinfo
= grp
.getgrgid(os
.getgid());
1924 fgname
= groupinfo
.gr_name
;
1927 except AttributeError:
1931 fcontents
= "".encode('UTF-8');
1933 fcontents
= zipfp
.read(member
.filename
);
1934 ftypehex
= format(ftype
, 'x').lower();
1935 extrafields
= format(len(extradata
), 'x').lower();
1936 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[4]);
1937 if(len(extradata
)>0):
1938 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[4]);
1939 extrasizelen
= format(len(extrasizestr
), 'x').lower();
1940 catfileoutstr
= AppendNullBytes([ftypehex
, fname
, flinkname
, fsize
, fatime
, fmtime
, fctime
, fbtime
, fmode
, fuid
, funame
, fgid
, fgname
, fcurfid
, fcurinode
, flinkcount
, fdev_minor
, fdev_major
, frdev_minor
, frdev_major
, extrasizelen
, extrafields
], formatspecs
[4]);
1941 if(len(extradata
)>0):
1942 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[4]);
1943 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[4]);
1944 catfhend
= (catfp
.tell() - 1) + len(catfileoutstr
);
1945 catfcontentstart
= catfp
.tell() + len(catfileoutstr
);
1946 if(checksumtype
=="none" or checksumtype
==""):
1947 catfileheadercshex
= format(0, 'x').lower();
1948 catfilecontentcshex
= format(0, 'x').lower();
1949 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
1950 catfileheadercshex
= format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
1951 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
1952 elif(checksumtype
=="crc16_ccitt"):
1953 catfileheadercshex
= format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
1954 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
1955 elif(checksumtype
=="adler32"):
1956 catfileheadercshex
= format(zlib
.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
1957 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
1958 elif(checksumtype
=="crc32"):
1959 catfileheadercshex
= format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
1960 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
1961 elif(checksumtype
=="crc64_ecma"):
1962 catfileheadercshex
= format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1963 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
1964 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
1965 catfileheadercshex
= format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1966 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
1967 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
1968 checksumoutstr
= hashlib
.new(checksumtype
);
1969 checksumoutstr
.update("".encode('UTF-8'));
1970 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
1971 checksumoutstr
= hashlib
.new(checksumtype
);
1972 checksumoutstr
.update(fcontents
);
1973 catfilecontentcshex
= checksumoutstr
.hexdigest().lower();
1975 catfileheadercshex
= format(0, 'x').lower();
1976 catfilecontentcshex
= format(0, 'x').lower();
1977 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4]);
1978 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
1979 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[4]) + catfileoutstr
;
1980 if(checksumtype
=="none" or checksumtype
==""):
1981 catfileheadercshex
= format(0, 'x').lower();
1982 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
1983 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
1984 elif(checksumtype
=="crc16_ccitt"):
1985 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
1986 elif(checksumtype
=="adler32"):
1987 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
1988 elif(checksumtype
=="crc32"):
1989 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
1990 elif(checksumtype
=="crc64_ecma"):
1991 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1992 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
1993 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
1994 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
1995 checksumoutstr
= hashlib
.new(checksumtype
);
1996 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
1997 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
1999 catfileheadercshex
= format(0, 'x').lower();
2000 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4]);
2001 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
2002 nullstrecd
= formatspecs
[4].encode('UTF-8');
2003 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
;
2004 catfcontentend
= (catfp
.tell() - 1) + len(catfileout
);
2005 catfp
.write(catfileout
);
2008 os
.fsync(catfp
.fileno());
2009 except io
.UnsupportedOperation
:
2011 except AttributeError:
2013 if(outfile
=="-" or hasattr(outfile
, "read") or hasattr(outfile
, "write")):
2014 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
2017 os
.fsync(catfp
.fileno());
2018 except io
.UnsupportedOperation
:
2020 except AttributeError:
2024 if(hasattr(sys
.stdout
, "buffer")):
2025 shutil
.copyfileobj(catfp
, sys
.stdout
.buffer);
2027 shutil
.copyfileobj(catfp
, sys
.stdout
);
2035 create_alias_function("Pack", __file_format_name__
, "FromZipFile", PackArchiveFileFromZipFile
);
2037 if(not rarfile_support
):
2038 def PackArchiveFileFromRarFile(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
2041 if(rarfile_support
):
2042 def PackArchiveFileFromRarFile(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
2043 compressionlist
= ['auto', 'gzip', 'bzip2', 'zstd', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
2044 outextlist
= ['gz', 'bz2', 'zst', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
2045 outextlistwd
= ['.gz', '.bz2', '.zst', '.lz4', '.lzo', '.lzop', '.lzma', '.xz'];
2046 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
2047 outfile
= RemoveWindowsPath(outfile
);
2048 checksumtype
= checksumtype
.lower();
2049 if(not CheckSumSupport(checksumtype
, hashlib_guaranteed
)):
2050 checksumtype
="crc32";
2051 if(checksumtype
=="none"):
2053 if(not compression
or compression
or compression
=="catfile" or compression
==formatspecs
[1]):
2055 if(compression
not in compressionlist
and compression
is None):
2056 compression
= "auto";
2058 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
2059 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
2060 if(os
.path
.exists(outfile
)):
2065 elif(hasattr(outfile
, "read") or hasattr(outfile
, "write")):
2068 fbasename
= os
.path
.splitext(outfile
)[0];
2069 fextname
= os
.path
.splitext(outfile
)[1];
2070 catfp
= CompressOpenFile(outfile
, compressionlevel
);
2071 catver
= formatspecs
[5];
2072 fileheaderver
= str(int(catver
.replace(".", "")));
2073 fileheader
= AppendNullByte(formatspecs
[0] + fileheaderver
, formatspecs
[4]);
2074 catfp
.write(fileheader
.encode('UTF-8'));
2080 inodetocatinode
= {};
2081 if(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
2083 if(not rarfile
.is_rarfile(infile
) and not rarfile
.is_rarfile_sfx(infile
)):
2085 rarfp
= rarfile
.RarFile(infile
, "r");
2086 rartest
= rarfp
.testrar();
2088 VerbosePrintOut("Bad file found!");
2089 fnumfiles
= format(int(len(rarfp
.infolist())), 'x').lower();
2090 fnumfilesa
= AppendNullBytes([fnumfiles
, checksumtype
], formatspecs
[4]);
2091 if(checksumtype
=="none" or checksumtype
==""):
2092 catfileheadercshex
= format(0, 'x').lower();
2093 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
2094 catfileheadercshex
= format(crc16(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
2095 elif(checksumtype
=="crc16_ccitt"):
2096 catfileheadercshex
= format(crc16_ccitt(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
2097 elif(checksumtype
=="adler32"):
2098 catfileheadercshex
= format(zlib
.adler32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
2099 elif(checksumtype
=="crc32"):
2100 catfileheadercshex
= format(crc32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
2101 elif(checksumtype
=="crc64_ecma"):
2102 catfileheadercshex
= format(crc64_ecma(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2103 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
2104 catfileheadercshex
= format(crc64_iso(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2105 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
2106 checksumoutstr
= hashlib
.new(checksumtype
);
2107 checksumoutstr
.update(str(fileheader
+ fnumfilesa
).encode('UTF-8'));
2108 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
2110 catfileheadercshex
= format(0, 'x').lower();
2111 fnumfilesa
= fnumfilesa
+ AppendNullByte(catfileheadercshex
, formatspecs
[4]);
2112 catfp
.write(fnumfilesa
.encode('UTF-8'));
2115 os
.fsync(catfp
.fileno());
2116 except io
.UnsupportedOperation
:
2118 except AttributeError:
2120 for member
in sorted(rarfp
.infolist(), key
=lambda x
: x
.filename
):
2123 if(member
.host_os
== rarfile
.RAR_OS_UNIX
):
2126 member
.external_attr
2128 except AttributeError:
2130 elif(member
.host_os
== rarfile
.RAR_OS_WIN32
):
2133 member
.external_attr
2135 except AttributeError:
2140 catfhstart
= catfp
.tell();
2141 if(re
.findall("^[.|/]", member
.filename
)):
2142 fname
= member
.filename
;
2144 fname
= "./"+member
.filename
;
2145 rarinfo
= rarfp
.getinfo(member
.filename
);
2147 VerbosePrintOut(fname
);
2148 if(is_unix
and member
.external_attr
!=0):
2149 fpremode
= int(member
.external_attr
);
2150 elif(member
.is_file()):
2151 fpremode
= int(stat
.S_IFREG
+ 438);
2152 elif(member
.is_symlink()):
2153 fpremode
= int(stat
.S_IFLNK
+ 438);
2154 elif(member
.is_dir()):
2155 fpremode
= int(stat
.S_IFDIR
+ 511);
2156 if(is_windows
and member
.external_attr
!=0):
2157 fwinattributes
= format(int(member
.external_attr
), 'x').lower();
2159 fwinattributes
= format(int(0), 'x').lower();
2162 if(member
.is_file()):
2164 elif(member
.is_symlink()):
2166 elif(member
.is_dir()):
2170 flinkname
= rarfp
.read(member
.filename
).decode("UTF-8");
2171 fcurfid
= format(int(curfid
), 'x').lower();
2172 fcurinode
= format(int(0), 'x').lower();
2173 curfid
= curfid
+ 1;
2174 fdev_minor
= format(int(0), 'x').lower();
2175 fdev_major
= format(int(0), 'x').lower();
2176 frdev_minor
= format(int(0), 'x').lower();
2177 frdev_major
= format(int(0), 'x').lower();
2179 fsize
= format(int("0"), 'x').lower();
2181 fsize
= format(int(member
.file_size
), 'x').lower();
2183 fsize
= format(int(member
.file_size
), 'x').lower();
2186 fatime
= format(int(member
.atime
.timestamp()), 'x').lower();
2188 fatime
= format(int(member
.mtime
.timestamp()), 'x').lower();
2189 except AttributeError:
2190 fatime
= format(int(member
.mtime
.timestamp()), 'x').lower();
2191 fmtime
= format(int(member
.mtime
.timestamp()), 'x').lower();
2194 fctime
= format(int(member
.ctime
.timestamp()), 'x').lower();
2196 fctime
= format(int(member
.mtime
.timestamp()), 'x').lower();
2197 except AttributeError:
2198 fctime
= format(int(member
.mtime
.timestamp()), 'x').lower();
2199 fbtime
= format(int(member
.mtime
.timestamp()), 'x').lower();
2200 if(is_unix
and member
.external_attr
!=0):
2201 fmode
= format(int(member
.external_attr
), 'x').lower();
2202 fchmode
= format(int(stat
.S_IMODE(member
.external_attr
)), 'x').lower();
2203 ftypemod
= format(int(stat
.S_IFMT(member
.external_attr
)), 'x').lower();
2204 elif(member
.is_file()):
2205 fmode
= format(int(stat
.S_IFREG
+ 438), 'x').lower();
2206 fchmode
= format(int(stat
.S_IMODE(int(stat
.S_IFREG
+ 438))), 'x').lower();
2207 ftypemod
= format(int(stat
.S_IFMT(int(stat
.S_IFREG
+ 438))), 'x').lower();
2208 elif(member
.is_symlink()):
2209 fmode
= format(int(stat
.S_IFLNK
+ 438), 'x').lower();
2210 fchmode
= format(int(stat
.S_IMODE(int(stat
.S_IFREG
+ 438))), 'x').lower();
2211 ftypemod
= format(int(stat
.S_IFMT(int(stat
.S_IFREG
+ 438))), 'x').lower();
2212 elif(member
.is_dir()):
2213 fmode
= format(int(stat
.S_IFDIR
+ 511), 'x').lower();
2214 fchmode
= format(int(stat
.S_IMODE(int(stat
.S_IFDIR
+ 511))), 'x').lower();
2215 ftypemod
= format(int(stat
.S_IFMT(int(stat
.S_IFDIR
+ 511))), 'x').lower();
2217 fuid
= format(int(os
.getuid()), 'x').lower();
2218 except AttributeError:
2219 fuid
= format(int(0), 'x').lower();
2221 fuid
= format(int(0), 'x').lower();
2223 fgid
= format(int(os
.getgid()), 'x').lower();
2224 except AttributeError:
2225 fgid
= format(int(0), 'x').lower();
2227 fgid
= format(int(0), 'x').lower();
2231 userinfo
= pwd
.getpwuid(os
.getuid());
2232 funame
= userinfo
.pw_name
;
2235 except AttributeError:
2243 groupinfo
= grp
.getgrgid(os
.getgid());
2244 fgname
= groupinfo
.gr_name
;
2247 except AttributeError:
2251 fcontents
= "".encode('UTF-8');
2253 fcontents
= rarfp
.read(member
.filename
);
2254 ftypehex
= format(ftype
, 'x').lower();
2255 extrafields
= format(len(extradata
), 'x').lower();
2256 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[4]);
2257 if(len(extradata
)>0):
2258 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[4]);
2259 extrasizelen
= format(len(extrasizestr
), 'x').lower();
2260 catfileoutstr
= AppendNullBytes([ftypehex
, fname
, flinkname
, fsize
, fatime
, fmtime
, fctime
, fbtime
, fmode
, fuid
, funame
, fgid
, fgname
, fcurfid
, fcurinode
, flinkcount
, fdev_minor
, fdev_major
, frdev_minor
, frdev_major
, extrasizelen
, extrafields
], formatspecs
[4]);
2261 if(len(extradata
)>0):
2262 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[4]);
2263 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[4]);
2264 catfhend
= (catfp
.tell() - 1) + len(catfileoutstr
);
2265 catfcontentstart
= catfp
.tell() + len(catfileoutstr
);
2266 if(checksumtype
=="none" or checksumtype
==""):
2267 catfileheadercshex
= format(0, 'x').lower();
2268 catfilecontentcshex
= format(0, 'x').lower();
2269 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
2270 catfileheadercshex
= format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
2271 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
2272 elif(checksumtype
=="crc16_ccitt"):
2273 catfileheadercshex
= format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
2274 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
2275 elif(checksumtype
=="adler32"):
2276 catfileheadercshex
= format(zlib
.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2277 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
2278 elif(checksumtype
=="crc32"):
2279 catfileheadercshex
= format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
2280 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
2281 elif(checksumtype
=="crc64_ecma"):
2282 catfileheadercshex
= format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2283 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
2284 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
2285 catfileheadercshex
= format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2286 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
2287 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
2288 checksumoutstr
= hashlib
.new(checksumtype
);
2289 checksumoutstr
.update("".encode('UTF-8'));
2290 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
2291 checksumoutstr
= hashlib
.new(checksumtype
);
2292 checksumoutstr
.update(fcontents
);
2293 catfilecontentcshex
= checksumoutstr
.hexdigest().lower();
2295 catfileheadercshex
= format(0, 'x').lower();
2296 catfilecontentcshex
= format(0, 'x').lower();
2297 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4]);
2298 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
2299 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[4]) + catfileoutstr
2300 if(checksumtype
=="none" or checksumtype
==""):
2301 catfileheadercshex
= format(0, 'x').lower()
2302 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
2303 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower()
2304 elif(checksumtype
=="crc16_ccitt"):
2305 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower()
2306 elif(checksumtype
=="adler32"):
2307 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower()
2308 elif(checksumtype
=="crc32"):
2309 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower()
2310 elif(checksumtype
=="crc64_ecma"):
2311 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
2312 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
2313 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower()
2314 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
2315 checksumoutstr
= hashlib
.new(checksumtype
)
2316 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'))
2317 catfileheadercshex
= checksumoutstr
.hexdigest().lower()
2319 catfileheadercshex
= format(0, 'x').lower()
2320 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4])
2321 catfileoutstrecd
= catfileoutstr
.encode('UTF-8')
2322 nullstrecd
= formatspecs
[4].encode('UTF-8')
2323 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
2324 catfcontentend
= (catfp
.tell() - 1) + len(catfileout
)
2325 catfp
.write(catfileout
)
2328 os
.fsync(catfp
.fileno())
2329 except io
.UnsupportedOperation
:
2331 except AttributeError:
2333 if(outfile
=="-" or hasattr(outfile
, "read") or hasattr(outfile
, "write")):
2334 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
)
2337 os
.fsync(catfp
.fileno())
2338 except io
.UnsupportedOperation
:
2340 except AttributeError:
2344 if(hasattr(sys
.stdout
, "buffer")):
2345 shutil
.copyfileobj(catfp
, sys
.stdout
.buffer)
2347 shutil
.copyfileobj(catfp
, sys
.stdout
)
2355 create_alias_function("Pack", __file_format_name__
, "FromRarFile", PackArchiveFileFromRarFile
);
2357 def ArchiveFileSeekToFileNum(infile
, seekto
=0, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
2358 if(hasattr(infile
, "read") or hasattr(infile
, "write")):
2361 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
2362 checkcompressfile
= CheckCompressionSubType(catfp
, formatspecs
);
2363 if(checkcompressfile
=="tarfile"):
2364 return TarFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
2365 if(checkcompressfile
=="zipfile"):
2366 return ZipFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
2367 if(rarfile_support
and checkcompressfile
=="rarfile"):
2368 return RarFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
2369 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[1]):
2376 if(hasattr(sys
.stdin
, "buffer")):
2377 shutil
.copyfileobj(sys
.stdin
.buffer, catfp
);
2379 shutil
.copyfileobj(sys
.stdin
, catfp
);
2381 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
2386 infile
= RemoveWindowsPath(infile
);
2387 checkcompressfile
= CheckCompressionSubType(infile
, formatspecs
);
2388 if(checkcompressfile
=="tarfile"):
2389 return TarFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
2390 if(checkcompressfile
=="zipfile"):
2391 return ZipFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
2392 if(rarfile_support
and checkcompressfile
=="rarfile"):
2393 return RarFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
2394 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[1]):
2396 compresscheck
= CheckCompressionType(infile
, formatspecs
, True);
2397 if(not compresscheck
):
2398 fextname
= os
.path
.splitext(infile
)[1];
2399 if(fextname
==".gz"):
2400 compresscheck
= "gzip";
2401 if(fextname
==".bz2"):
2402 compresscheck
= "bzip2";
2403 if(fextname
==".zst"):
2404 compresscheck
= "zstd";
2405 if(fextname
==".lz4" or fextname
==".clz4"):
2406 compresscheck
= "lz4";
2407 if(fextname
==".lzo" or fextname
==".lzop"):
2408 compresscheck
= "lzo";
2409 if(fextname
==".lzma" or fextname
==".xz"):
2410 compresscheck
= "lzma";
2411 if(not compresscheck
):
2413 catfp
= UncompressFile(infile
, formatspecs
, "rb");
2418 SeekToEndOfFile(catfp);
2420 SeekToEndOfFile(catfp);
2421 CatSize = catfp.tell();
2422 CatSizeEnd = CatSize;
2430 catheader
= ReadFileHeaderData(catfp
, 4, formatspecs
[4]);
2431 catstring
= catheader
[0];
2432 catversion
= re
.findall(r
"([\d]+)$", catstring
);
2433 fprenumfiles
= catheader
[1];
2434 fnumfiles
= int(fprenumfiles
, 16);
2435 fprechecksumtype
= catheader
[2];
2436 fprechecksum
= catheader
[3];
2437 fileheader
= AppendNullByte(catstring
, formatspecs
[4]);
2438 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
2439 fileheader
= fileheader
+ AppendNullBytes([fnumfileshex
, fprechecksumtype
], formatspecs
[4]);
2440 if(fprechecksumtype
=="none" or fprechecksumtype
==""):
2441 catfileheadercshex
= format(0, 'x').lower();
2442 elif(fprechecksumtype
=="crc16" or fprechecksumtype
=="crc16_ansi" or fprechecksumtype
=="crc16_ibm"):
2443 catfileheadercshex
= format(crc16(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
2444 elif(fprechecksumtype
=="crc16_ccitt"):
2445 catfileheadercshex
= format(crc16_ccitt(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
2446 elif(fprechecksumtype
=="adler32"):
2447 catfileheadercshex
= format(zlib
.adler32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
2448 elif(fprechecksumtype
=="crc32"):
2449 catfileheadercshex
= format(crc32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
2450 elif(fprechecksumtype
=="crc64_ecma"):
2451 catfileheadercshex
= format(crc64_ecma(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2452 elif(fprechecksumtype
=="crc64" or fprechecksumtype
=="crc64_iso"):
2453 catfileheadercshex
= format(crc64_iso(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2454 elif(CheckSumSupportAlt(fprechecksumtype
, hashlib_guaranteed
)):
2455 checksumoutstr
= hashlib
.new(fprechecksumtype
);
2456 checksumoutstr
.update(fileheader
.encode('UTF-8'));
2457 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
2459 catfileheadercshex
= format(0, 'x').lower();
2460 fileheader
= fileheader
+ AppendNullByte(catfileheadercshex
, formatspecs
[4]);
2461 fheadtell
= len(fileheader
);
2462 if(fprechecksum
!=catfileheadercshex
and not skipchecksum
):
2463 VerbosePrintOut("File Header Checksum Error with file " + infile
+ " at offset " + str(catfp
.tell()));
2465 catversions
= re
.search(r
'(.*?)(\d+)$', catstring
).groups();
2466 catlist
= {'fnumfiles': fnumfiles
, 'fformat': catversions
[0], 'fversion': catversions
[1], 'fformatspecs': formatspecs
, 'fchecksumtype': fprechecksumtype
, 'fheaderchecksum': fprechecksum
, 'ffilelist': {}};
2467 if(seekto
>=fnumfiles
):
2468 seekto
= fnumfiles
- 1;
2474 seekstart
= catfp
.tell();
2475 preheaderdata
= ReadFileHeaderData(catfp
, 5, formatspecs
[4]);
2476 prefheadsize
= int(preheaderdata
[0], 16);
2477 prefseek
= prefheadsize
- (int(len(preheaderdata
[1]) + 1) + int(len(preheaderdata
[2]) + 1) + int(len(preheaderdata
[3]) + 1) + int(len(preheaderdata
[4]) + 1));
2478 preftype
= int(preheaderdata
[1], 16);
2479 prefsize
= int(preheaderdata
[4], 16);
2480 catfp
.seek(prefseek
, 1);
2482 catfp
.seek(prefsize
, 1);
2485 catfp
.seek(seekstart
, 0);
2487 catfheadsize
= int(preheaderdata
[0], 16);
2488 catftype
= int(preheaderdata
[1], 16);
2489 if(re
.findall("^[.|/]", preheaderdata
[2])):
2490 catfname
= preheaderdata
[2];
2492 catfname
= "./"+preheaderdata
[2];
2493 catflinkname
= preheaderdata
[3];
2494 catfsize
= int(preheaderdata
[4], 16);
2495 catfbasedir
= os
.path
.dirname(catfname
);
2496 catlist
= {'fid': fileidnum
, 'foffset': catfp
.tell(), 'ftype': catftype
, 'fname': catfname
, 'fbasedir': catfbasedir
, 'flinkname': catflinkname
, 'fsize': catfsize
};
2498 catlist
.update({'catfp': catfp
});
2503 create_alias_function("", __file_format_name__
, "SeekToFileNum", ArchiveFileSeekToFileNum
);
2505 def ArchiveFileSeekToFileName(infile
, seekfile
=None, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
2506 if(hasattr(infile
, "read") or hasattr(infile
, "write")):
2509 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
2510 checkcompressfile
= CheckCompressionSubType(catfp
, formatspecs
);
2511 if(checkcompressfile
=="tarfile"):
2512 return TarFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
2513 if(checkcompressfile
=="zipfile"):
2514 return ZipFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
2515 if(rarfile_support
and checkcompressfile
=="rarfile"):
2516 return RarFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
2517 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[1]):
2524 if(hasattr(sys
.stdin
, "buffer")):
2525 shutil
.copyfileobj(sys
.stdin
.buffer, catfp
);
2527 shutil
.copyfileobj(sys
.stdin
, catfp
);
2529 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
2534 infile
= RemoveWindowsPath(infile
);
2535 checkcompressfile
= CheckCompressionSubType(infile
, formatspecs
);
2536 if(checkcompressfile
=="tarfile"):
2537 return TarFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
2538 if(checkcompressfile
=="zipfile"):
2539 return ZipFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
2540 if(rarfile_support
and checkcompressfile
=="rarfile"):
2541 return RarFileToArray(infile
, 0, 0, listonly
, skipchecksum
, formatspecs
, returnfp
);
2542 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[1]):
2544 compresscheck
= CheckCompressionType(infile
, formatspecs
, True);
2545 if(not compresscheck
):
2546 fextname
= os
.path
.splitext(infile
)[1];
2547 if(fextname
==".gz"):
2548 compresscheck
= "gzip";
2549 if(fextname
==".bz2"):
2550 compresscheck
= "bzip2";
2551 if(fextname
==".zst"):
2552 compresscheck
= "zstd";
2553 if(fextname
==".lz4" or fextname
==".clz4"):
2554 compresscheck
= "lz4";
2555 if(fextname
==".lzo" or fextname
==".lzop"):
2556 compresscheck
= "lzo";
2557 if(fextname
==".lzma" or fextname
==".xz"):
2558 compresscheck
= "lzma";
2559 if(not compresscheck
):
2561 catfp
= UncompressFile(infile
, formatspecs
, "rb");
2566 SeekToEndOfFile(catfp);
2568 SeekToEndOfFile(catfp);
2569 CatSize = catfp.tell();
2570 CatSizeEnd = CatSize;
2578 catheader
= ReadFileHeaderData(catfp
, 4, formatspecs
[4]);
2579 catstring
= catheader
[0];
2580 catversion
= re
.findall(r
"([\d]+)$", catstring
);
2581 fprenumfiles
= catheader
[1];
2582 fnumfiles
= int(fprenumfiles
, 16);
2583 fprechecksumtype
= catheader
[2];
2584 fprechecksum
= catheader
[3];
2585 fileheader
= AppendNullByte(catstring
, formatspecs
[4]);
2586 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
2587 fileheader
= fileheader
+ AppendNullBytes([fnumfileshex
, fprechecksumtype
], formatspecs
[4]);
2588 if(fprechecksumtype
=="none" or fprechecksumtype
==""):
2589 catfileheadercshex
= format(0, 'x').lower();
2590 elif(fprechecksumtype
=="crc16" or fprechecksumtype
=="crc16_ansi" or fprechecksumtype
=="crc16_ibm"):
2591 catfileheadercshex
= format(crc16(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
2592 elif(fprechecksumtype
=="crc16_ccitt"):
2593 catfileheadercshex
= format(crc16_ccitt(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
2594 elif(fprechecksumtype
=="adler32"):
2595 catfileheadercshex
= format(zlib
.adler32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
2596 elif(fprechecksumtype
=="crc32"):
2597 catfileheadercshex
= format(crc32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
2598 elif(fprechecksumtype
=="crc64_ecma"):
2599 catfileheadercshex
= format(crc64_ecma(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2600 elif(fprechecksumtype
=="crc64" or fprechecksumtype
=="crc64_iso"):
2601 catfileheadercshex
= format(crc64_iso(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2602 elif(CheckSumSupportAlt(fprechecksumtype
, hashlib_guaranteed
)):
2603 checksumoutstr
= hashlib
.new(fprechecksumtype
);
2604 checksumoutstr
.update(fileheader
.encode('UTF-8'));
2605 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
2607 catfileheadercshex
= format(0, 'x').lower();
2608 fileheader
= fileheader
+ AppendNullByte(catfileheadercshex
, formatspecs
[4]);
2609 fheadtell
= len(fileheader
);
2610 if(fprechecksum
!=catfileheadercshex
and not skipchecksum
):
2611 VerbosePrintOut("File Header Checksum Error with file " + infile
+ " at offset " + str(catfp
.tell()));
2613 catversions
= re
.search(r
'(.*?)(\d+)$', catstring
).groups();
2614 catlist
= {'fnumfiles': fnumfiles
, 'fformat': catversions
[0], 'fversion': catversions
[1], 'fformatspecs': formatspecs
, 'fchecksumtype': fprechecksumtype
, 'fheaderchecksum': fprechecksum
, 'ffilelist': {}};
2615 seekto
= fnumfiles
- 1
2620 seekstart
= catfp
.tell();
2621 preheaderdata
= ReadFileHeaderData(catfp
, 5, formatspecs
[4]);
2622 prefheadsize
= int(preheaderdata
[0], 16);
2623 prefseek
= prefheadsize
- (int(len(preheaderdata
[1]) + 1) + int(len(preheaderdata
[2]) + 1) + int(len(preheaderdata
[3]) + 1) + int(len(preheaderdata
[4]) + 1));
2624 preftype
= int(preheaderdata
[1], 16);
2625 prefsize
= int(preheaderdata
[4], 16);
2626 catfp
.seek(prefseek
, 1);
2628 catfp
.seek(prefsize
, 1);
2632 prefname
= preheaderdata
[2];
2633 if(re
.findall("^[.|/]", preheaderdata
[2])):
2634 prefname
= preheaderdata
[2];
2636 prefname
= "./"+preheaderdata
[2];
2637 if(prefname
==seekfile
):
2640 catfp
.seek(seekstart
, 0);
2642 catfheadsize
= int(preheaderdata
[0], 16);
2643 catftype
= int(preheaderdata
[1], 16);
2644 if(re
.findall("^[.|/]", preheaderdata
[2])):
2645 catfname
= preheaderdata
[2];
2647 catfname
= "./"+preheaderdata
[2];
2648 catflinkname
= preheaderdata
[3];
2649 catfsize
= int(preheaderdata
[4], 16);
2650 catfbasedir
= os
.path
.dirname(catfname
);
2652 catlist
= {'fid': fileidnum
, 'foffset': catfp
.tell(), 'ftype': catftype
, 'fname': catfname
, 'fbasedir': catfbasedir
, 'flinkname': catflinkname
, 'fsize': catfsize
};
2656 catlist
.update({'catfp': catfp
});
2661 create_alias_function("", __file_format_name__
, "SeekToFileName", ArchiveFileSeekToFileName
);
2663 def ArchiveFileToArray(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, usenewstyle
=True, returnfp
=False):
2664 if(hasattr(infile
, "read") or hasattr(infile
, "write")):
2667 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
2668 checkcompressfile
= CheckCompressionSubType(catfp
, formatspecs
);
2669 if(checkcompressfile
=="tarfile"):
2670 return TarFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
2671 if(checkcompressfile
=="zipfile"):
2672 return ZipFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
2673 if(rarfile_support
and checkcompressfile
=="rarfile"):
2674 return RarFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
2675 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[1]):
2682 if(hasattr(sys
.stdin
, "buffer")):
2683 shutil
.copyfileobj(sys
.stdin
.buffer, catfp
);
2685 shutil
.copyfileobj(sys
.stdin
, catfp
);
2687 catfp
= UncompressArchiveFile(catfp
, formatspecs
);
2692 infile
= RemoveWindowsPath(infile
);
2693 checkcompressfile
= CheckCompressionSubType(infile
, formatspecs
);
2694 if(checkcompressfile
=="tarfile"):
2695 return TarFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
2696 if(checkcompressfile
=="zipfile"):
2697 return ZipFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
2698 if(rarfile_support
and checkcompressfile
=="rarfile"):
2699 return ZipFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, returnfp
);
2700 if(checkcompressfile
!="catfile" and checkcompressfile
!=formatspecs
[1]):
2702 compresscheck
= CheckCompressionType(infile
, formatspecs
, True);
2703 if(not compresscheck
):
2704 fextname
= os
.path
.splitext(infile
)[1];
2705 if(fextname
==".gz"):
2706 compresscheck
= "gzip";
2707 if(fextname
==".bz2"):
2708 compresscheck
= "bzip2";
2709 if(fextname
==".zst"):
2710 compresscheck
= "zstd";
2711 if(fextname
==".lz4" or fextname
==".clz4"):
2712 compresscheck
= "lz4";
2713 if(fextname
==".lzo" or fextname
==".lzop"):
2714 compresscheck
= "lzo";
2715 if(fextname
==".lzma" or fextname
==".xz"):
2716 compresscheck
= "lzma";
2717 if(not compresscheck
):
2719 catfp
= UncompressFile(infile
, formatspecs
, "rb");
2724 SeekToEndOfFile(catfp);
2726 SeekToEndOfFile(catfp);
2727 CatSize = catfp.tell();
2728 CatSizeEnd = CatSize;
2736 catheader
= ReadFileHeaderData(catfp
, 4, formatspecs
[4]);
2737 catstring
= catheader
[0];
2738 catversion
= re
.findall(r
"([\d]+)$", catstring
);
2739 fprenumfiles
= catheader
[1];
2740 fnumfiles
= int(fprenumfiles
, 16);
2741 fprechecksumtype
= catheader
[2];
2742 fprechecksum
= catheader
[3];
2743 fileheader
= AppendNullByte(catstring
, formatspecs
[4]);
2744 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
2745 fileheader
= fileheader
+ AppendNullBytes([fnumfileshex
, fprechecksumtype
], formatspecs
[4]);
2746 if(fprechecksumtype
=="none" or fprechecksumtype
==""):
2747 catfileheadercshex
= format(0, 'x').lower();
2748 elif(fprechecksumtype
=="crc16" or fprechecksumtype
=="crc16_ansi" or fprechecksumtype
=="crc16_ibm"):
2749 catfileheadercshex
= format(crc16(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
2750 elif(fprechecksumtype
=="crc16_ccitt"):
2751 catfileheadercshex
= format(crc16_ccitt(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
2752 elif(fprechecksumtype
=="adler32"):
2753 catfileheadercshex
= format(zlib
.adler32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
2754 elif(fprechecksumtype
=="crc32"):
2755 catfileheadercshex
= format(crc32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
2756 elif(fprechecksumtype
=="crc64_ecma"):
2757 catfileheadercshex
= format(crc64_ecma(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2758 elif(fprechecksumtype
=="crc64" or fprechecksumtype
=="crc64_iso"):
2759 catfileheadercshex
= format(crc64_iso(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2760 elif(CheckSumSupportAlt(fprechecksumtype
, hashlib_guaranteed
)):
2761 checksumoutstr
= hashlib
.new(fprechecksumtype
);
2762 checksumoutstr
.update(fileheader
.encode('UTF-8'));
2763 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
2765 catfileheadercshex
= format(0, 'x').lower();
2766 fileheader
= fileheader
+ AppendNullByte(catfileheadercshex
, formatspecs
[4]);
2767 fheadtell
= len(fileheader
);
2768 if(fprechecksum
!=catfileheadercshex
and not skipchecksum
):
2769 VerbosePrintOut("File Header Checksum Error with file " + infile
+ " at offset " + str(catfp
.tell()));
2771 catversions
= re
.search(r
'(.*?)(\d+)$', catstring
).groups();
2772 catlist
= {'fnumfiles': fnumfiles
, 'fformat': catversions
[0], 'fversion': catversions
[1], 'fformatspecs': formatspecs
, 'fchecksumtype': fprechecksumtype
, 'fheaderchecksum': fprechecksum
, 'ffilelist': {}};
2775 if(seekend
<=0 or seekend
>fnumfiles
):
2776 seekend
= fnumfiles
;
2779 while(il
< seekstart
):
2780 preheaderdata
= ReadFileHeaderData(catfp
, 5, formatspecs
[4]);
2781 prefheadsize
= int(preheaderdata
[0], 16);
2782 prefseek
= prefheadsize
- (int(len(preheaderdata
[1]) + 1) + int(len(preheaderdata
[2]) + 1) + int(len(preheaderdata
[3]) + 1) + int(len(preheaderdata
[4]) + 1));
2783 preftype
= int(preheaderdata
[1], 16);
2784 prefsize
= int(preheaderdata
[4], 16);
2785 catfp
.seek(prefseek
, 1);
2787 catfp
.seek(prefsize
, 1);
2790 fileidnum
= seekstart
;
2792 while(fileidnum
<seekend
):
2793 catfhstart
= catfp
.tell();
2795 catheaderdata
= ReadFileHeaderDataBySize(catfp
, formatspecs
[4]);
2797 catheaderdata
= ReadFileHeaderData(catfp
, 23, formatspecs
[4]);
2798 catfheadsize
= int(catheaderdata
[0], 16);
2799 catftype
= int(catheaderdata
[1], 16);
2800 if(re
.findall("^[.|/]", catheaderdata
[2])):
2801 catfname
= catheaderdata
[2];
2803 catfname
= "./"+catheaderdata
[2];
2804 catfbasedir
= os
.path
.dirname(catfname
);
2805 catflinkname
= catheaderdata
[3];
2806 catfsize
= int(catheaderdata
[4], 16);
2807 catfatime
= int(catheaderdata
[5], 16);
2808 catfmtime
= int(catheaderdata
[6], 16);
2809 catfctime
= int(catheaderdata
[7], 16);
2810 catfbtime
= int(catheaderdata
[8], 16);
2811 catfmode
= int(catheaderdata
[9], 16);
2812 catfchmode
= stat
.S_IMODE(catfmode
);
2813 catftypemod
= stat
.S_IFMT(catfmode
);
2814 catfuid
= int(catheaderdata
[10], 16);
2815 catfuname
= catheaderdata
[11];
2816 catfgid
= int(catheaderdata
[12], 16);
2817 catfgname
= catheaderdata
[13];
2818 fid
= int(catheaderdata
[14], 16);
2819 finode
= int(catheaderdata
[15], 16);
2820 flinkcount
= int(catheaderdata
[16], 16);
2821 catfdev_minor
= int(catheaderdata
[17], 16);
2822 catfdev_major
= int(catheaderdata
[18], 16);
2823 catfrdev_minor
= int(catheaderdata
[19], 16);
2824 catfrdev_major
= int(catheaderdata
[20], 16);
2825 catfextrasize
= int(catheaderdata
[21], 16);
2826 catfextrafields
= int(catheaderdata
[22], 16);
2827 extrafieldslist
= [];
2830 extraend
= extrastart
+ catfextrafields
;
2831 extrafieldslist
= [];
2832 if(extrastart
<extraend
):
2833 extrafieldslist
.append(catheaderdata
[extrastart
]);
2834 extrastart
= extrastart
+ 1;
2835 catfchecksumtype
= catheaderdata
[extrastart
].lower();
2836 catfcs
= catheaderdata
[extrastart
+ 1].lower();
2837 catfccs
= catheaderdata
[extrastart
+ 2].lower();
2839 extrafieldslist
= [];
2840 if(catfextrafields
>0):
2841 extrafieldslist
= ReadFileHeaderData(catfp
, catfextrafields
, formatspecs
[4]);
2842 checksumsval
= ReadFileHeaderData(catfp
, 3, formatspecs
[4]);
2843 catfchecksumtype
= checksumsval
[0].lower();
2844 catfcs
= checksumsval
[1].lower();
2845 catfccs
= checksumsval
[2].lower();
2848 hcmax
= len(catheaderdata
) - 2;
2850 hcmax
= len(catheaderdata
);
2853 hout
= hout
+ AppendNullByte(catheaderdata
[hc
], formatspecs
[4]);
2855 catfnumfields
= 24 + catfextrafields
;
2856 if(catfchecksumtype
=="none" or catfchecksumtype
==""):
2858 elif(catfchecksumtype
=="crc16" or catfchecksumtype
=="crc16_ansi" or catfchecksumtype
=="crc16_ibm"):
2859 catnewfcs
= format(crc16(hout
.encode('UTF-8')) & 0xffff, '04x').lower();
2860 elif(catfchecksumtype
=="adler32"):
2861 catnewfcs
= format(zlib
.adler32(hout
.encode('UTF-8')) & 0xffffffff, '08x').lower();
2862 elif(catfchecksumtype
=="crc32"):
2863 catnewfcs
= format(crc32(hout
.encode('UTF-8')) & 0xffffffff, '08x').lower();
2864 elif(catfchecksumtype
=="crc64_ecma"):
2865 catnewfcs
= format(crc64_ecma(hout
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2866 elif(catfchecksumtype
=="crc64" or catfchecksumtype
=="crc64_iso"):
2867 catnewfcs
= format(crc64_iso(hout
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
2868 elif(CheckSumSupportAlt(catfchecksumtype
, hashlib_guaranteed
)):
2869 checksumoutstr
= hashlib
.new(catfchecksumtype
);
2870 checksumoutstr
.update(hout
.encode('UTF-8'));
2871 catnewfcs
= checksumoutstr
.hexdigest().lower();
2872 if(catfcs
!=catnewfcs
and not skipchecksum
):
2873 VerbosePrintOut("File Header Checksum Error with file " + catfname
+ " at offset " + str(catfhstart
));
2875 catfhend
= catfp
.tell() - 1;
2876 catfcontentstart
= catfp
.tell();
2878 pyhascontents
= False;
2879 if(catfsize
>0 and not listonly
):
2880 catfcontents
= catfp
.read(catfsize
);
2881 if(catfchecksumtype
=="none" or catfchecksumtype
==""):
2883 elif(catfchecksumtype
=="crc16" or catfchecksumtype
=="crc16_ansi" or catfchecksumtype
=="crc16_ibm"):
2884 catnewfccs
= format(crc16(catfcontents
) & 0xffff, '04x').lower();
2885 elif(catfchecksumtype
=="crc16_ccitt"):
2886 catnewfcs
= format(crc16_ccitt(catfcontents
) & 0xffff, '04x').lower();
2887 elif(catfchecksumtype
=="adler32"):
2888 catnewfccs
= format(zlib
.adler32(catfcontents
) & 0xffffffff, '08x').lower();
2889 elif(catfchecksumtype
=="crc32"):
2890 catnewfccs
= format(crc32(catfcontents
) & 0xffffffff, '08x').lower();
2891 elif(catfchecksumtype
=="crc64_ecma"):
2892 catnewfcs
= format(crc64_ecma(catfcontents
) & 0xffffffffffffffff, '016x').lower();
2893 elif(catfchecksumtype
=="crc64" or catfchecksumtype
=="crc64_iso"):
2894 catnewfcs
= format(crc64_iso(catfcontents
) & 0xffffffffffffffff, '016x').lower();
2895 elif(CheckSumSupportAlt(catfchecksumtype
, hashlib_guaranteed
)):
2896 checksumoutstr
= hashlib
.new(catfchecksumtype
);
2897 checksumoutstr
.update(catfcontents
);
2898 catnewfccs
= checksumoutstr
.hexdigest().lower();
2899 pyhascontents
= True;
2900 if(catfccs
!=catnewfccs
and skipchecksum
):
2901 VerbosePrintOut("File Content Checksum Error with file " + catfname
+ " at offset " + str(catfhstart
));
2903 if(catfsize
>0 and listonly
):
2904 catfp
.seek(catfsize
, 1);
2905 pyhascontents
= False;
2907 catfcontentend
= catfp
.tell() - 1;
2908 catlist
['ffilelist'].update({realidnum
: {'fid': realidnum
, 'fidalt': fileidnum
, 'fheadersize': catfheadsize
, 'fhstart': catfhstart
, 'fhend': catfhend
, 'ftype': catftype
, 'fname': catfname
, 'fbasedir': catfbasedir
, 'flinkname': catflinkname
, 'fsize': catfsize
, 'fatime': catfatime
, 'fmtime': catfmtime
, 'fctime': catfctime
, 'fbtime': catfbtime
, 'fmode': catfmode
, 'fchmode': catfchmode
, 'ftypemod': catftypemod
, 'fuid': catfuid
, 'funame': catfuname
, 'fgid': catfgid
, 'fgname': catfgname
, 'finode': finode
, 'flinkcount': flinkcount
, 'fminor': catfdev_minor
, 'fmajor': catfdev_major
, 'frminor': catfrdev_minor
, 'frmajor': catfrdev_major
, 'fchecksumtype': catfchecksumtype
, 'fnumfields': catfnumfields
, 'fextrafields': catfextrafields
, 'fextrafieldsize': catfextrasize
, 'fextralist': extrafieldslist
, 'fheaderchecksum': catfcs
, 'fcontentchecksum': catfccs
, 'fhascontents': pyhascontents
, 'fcontentstart': catfcontentstart
, 'fcontentend': catfcontentend
, 'fcontents': catfcontents
} });
2909 fileidnum
= fileidnum
+ 1;
2910 realidnum
= realidnum
+ 1;
2912 catlist
.update({'catfp': catfp
});
2917 create_alias_function("", __file_format_name__
, "ToArray", ArchiveFileToArray
);
2919 def ArchiveFileStringToArray(catstr
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, usenewstyle
=True, returnfp
=False):
2920 catfp
= BytesIO(catstr
);
2921 listcatfiles
= ArchiveFileToArray(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
2922 return listcatfiles
;
2924 create_alias_function("", __file_format_name__
, "StringToArray", ArchiveFileStringToArray
);
2926 def TarFileToArray(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, usenewstyle
=True, returnfp
=False):
2928 catfp
= PackArchiveFileFromTarFile(infile
, catfp
, "auto", None, "crc32", [], formatspecs
, False, True);
2929 listcatfiles
= ArchiveFileToArray(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
2930 return listcatfiles
;
2932 def ZipFileToArray(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, usenewstyle
=True, returnfp
=False):
2934 catfp
= PackArchiveFileFromZipFile(infile
, catfp
, "auto", None, "crc32", [], formatspecs
, False, True);
2935 listcatfiles
= ArchiveFileToArray(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
2936 return listcatfiles
;
2938 if(not rarfile_support
):
2939 def RarFileToArray(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
2942 if(rarfile_support
):
2943 def RarFileToArray(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, usenewstyle
=True, returnfp
=False):
2945 catfp
= PackArchiveFileFromRarFile(infile
, catfp
, "auto", None, "crc32", [], formatspecs
, False, True);
2946 listcatfiles
= ArchiveFileToArray(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
2947 return listcatfiles
;
2949 def ListDirToArrayAlt(infiles
, dirlistfromtxt
=False, followlink
=False, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
2950 catver
= formatspecs
[5];
2951 fileheaderver
= str(int(catver
.replace(".", "")));
2952 fileheader
= AppendNullByte(formatspecs
[0] + fileheaderver
, formatspecs
[4]);
2953 advancedlist
= True;
2956 for line
in sys
.stdin
:
2957 infilelist
.append(line
.strip());
2958 infilelist
= list(filter(None, infilelist
));
2959 elif(infiles
!="-" and dirlistfromtxt
and os
.path
.exists(infiles
) and (os
.path
.isfile(infiles
) or infiles
=="/dev/null" or infiles
=="NUL")):
2960 if(not os
.path
.exists(infiles
) or not os
.path
.isfile(infiles
)):
2962 with
open(infiles
, "r") as finfile
:
2963 for line
in finfile
:
2964 infilelist
.append(line
.strip());
2965 infilelist
= list(filter(None, infilelist
));
2967 if(isinstance(infiles
, (list, tuple, ))):
2968 infilelist
= list(filter(None, infiles
));
2969 elif(isinstance(infiles
, (str, ))):
2970 infilelist
= list(filter(None, [infiles
]));
2972 GetDirList
= ListDirAdvanced(infilelist
, followlink
, False);
2974 GetDirList
= ListDir(infilelist
, followlink
, False);
2982 inodetocatinode
= {};
2984 fnumfiles
= int(len(GetDirList
));
2985 catver
= formatspecs
[5];
2986 fileheaderver
= str(int(catver
.replace(".", "")));
2987 fileheader
= AppendNullByte(formatspecs
[0] + fileheaderver
, formatspecs
[4]);
2988 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
2989 fileheader
= fileheader
+ AppendNullBytes([fnumfileshex
, checksumtype
], formatspecs
[4]);
2990 catversion
= fileheaderver
;
2991 if(checksumtype
=="none" or checksumtype
==""):
2992 catfileheadercshex
= format(0, 'x').lower();
2993 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
2994 catfileheadercshex
= format(crc16(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
2995 elif(checksumtype
=="crc16_ccitt"):
2996 catfileheadercshex
= format(crc16_ccitt(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
2997 elif(checksumtype
=="adler32"):
2998 catfileheadercshex
= format(zlib
.adler32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
2999 elif(checksumtype
=="crc32"):
3000 catfileheadercshex
= format(crc32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3001 elif(checksumtype
=="crc64_ecma"):
3002 catfileheadercshex
= format(crc64_ecma(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3003 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3004 catfileheadercshex
= format(crc64_iso(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3005 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3006 checksumoutstr
= hashlib
.new(checksumtype
);
3007 checksumoutstr
.update(fileheader
.encode('UTF-8'));
3008 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3010 catfileheadercshex
= format(0, 'x').lower();
3011 fileheader
= fileheader
+ AppendNullByte(catfileheadercshex
, formatspecs
[4]);
3012 fheadtell
= len(fileheader
);
3013 catlist
= {'fnumfiles': fnumfiles
, 'fformat': formatspecs
[0], 'fversion': catversion
, 'fformatspecs': formatspecs
, 'fchecksumtype': checksumtype
, 'fheaderchecksum': catfileheadercshex
, 'ffilelist': {}};
3014 for curfname
in GetDirList
:
3015 if(re
.findall("^[.|/]", curfname
)):
3018 fname
= "./"+curfname
;
3020 VerbosePrintOut(fname
);
3021 if(not followlink
or followlink
is None):
3022 fstatinfo
= os
.lstat(fname
);
3024 fstatinfo
= os
.stat(fname
);
3025 fpremode
= fstatinfo
.st_mode
;
3026 finode
= fstatinfo
.st_ino
;
3027 flinkcount
= fstatinfo
.st_nlink
;
3029 if(stat
.S_ISREG(fpremode
)):
3031 elif(stat
.S_ISLNK(fpremode
)):
3033 elif(stat
.S_ISCHR(fpremode
)):
3035 elif(stat
.S_ISBLK(fpremode
)):
3037 elif(stat
.S_ISDIR(fpremode
)):
3039 elif(stat
.S_ISFIFO(fpremode
)):
3041 elif(hasattr(stat
, "S_ISDOOR") and stat
.S_ISDOOR(fpremode
)):
3043 elif(hasattr(stat
, "S_ISPORT") and stat
.S_ISPORT(fpremode
)):
3045 elif(hasattr(stat
, "S_ISWHT") and stat
.S_ISWHT(fpremode
)):
3050 fbasedir
= os
.path
.dirname(fname
);
3052 if(not followlink
and finode
!=0):
3054 if(finode
in inodelist
):
3056 flinkname
= inodetofile
[finode
];
3057 fcurinode
= inodetocatinode
[finode
];
3058 if(finode
not in inodelist
):
3059 inodelist
.append(finode
);
3060 inodetofile
.update({finode
: fname
});
3061 inodetocatinode
.update({finode
: curinode
});
3062 fcurinode
= curinode
;
3063 curinode
= curinode
+ 1;
3065 fcurinode
= curinode
;
3066 curinode
= curinode
+ 1;
3067 curfid
= curfid
+ 1;
3069 flinkname
= os
.readlink(fname
);
3070 fdev
= fstatinfo
.st_dev
;
3071 getfdev
= GetDevMajorMinor(fdev
);
3072 fdev_minor
= getfdev
[0];
3073 fdev_major
= getfdev
[1];
3074 frdev
= fstatinfo
.st_dev
;
3075 if(hasattr(fstatinfo
, "st_rdev")):
3076 frdev
= fstatinfo
.st_rdev
;
3078 frdev
= fstatinfo
.st_dev
;
3079 getfrdev
= GetDevMajorMinor(frdev
);
3080 frdev_minor
= getfrdev
[0];
3081 frdev_major
= getfrdev
[1];
3082 if(ftype
==1 or ftype
==2 or ftype
==3 or ftype
==4 or ftype
==5 or ftype
==6):
3084 if(ftype
==0 or ftype
==7):
3085 fsize
= fstatinfo
.st_size
;
3086 fatime
= fstatinfo
.st_atime
;
3087 fmtime
= fstatinfo
.st_mtime
;
3088 fctime
= fstatinfo
.st_ctime
;
3089 if(hasattr(fstatinfo
, "st_birthtime")):
3090 fbtime
= fstatinfo
.st_birthtime
;
3092 fbtime
= fstatinfo
.st_ctime
;
3093 fmode
= fstatinfo
.st_mode
;
3094 fchmode
= stat
.S_IMODE(fstatinfo
.st_mode
);
3095 ftypemod
= stat
.S_IFMT(fstatinfo
.st_mode
);
3096 fuid
= fstatinfo
.st_uid
;
3097 fgid
= fstatinfo
.st_gid
;
3102 userinfo
= pwd
.getpwuid(fstatinfo
.st_uid
);
3103 funame
= userinfo
.pw_name
;
3112 groupinfo
= grp
.getgrgid(fstatinfo
.st_gid
);
3113 fgname
= groupinfo
.gr_name
;
3118 fdev_minor
= fdev_minor
;
3119 fdev_major
= fdev_major
;
3120 frdev_minor
= frdev_minor
;
3121 frdev_major
= frdev_major
;
3123 flinkcount
= flinkcount
;
3124 if(hasattr(fstatinfo
, "st_file_attributes")):
3125 fwinattributes
= fstatinfo
.st_file_attributes
;
3128 fcontents
= "".encode('UTF-8');
3130 if(ftype
== 0 or ftype
== 7):
3131 with(open(fname
, "rb") as fpc
):
3133 chunk
= fpc
.read(chunk_size
);
3137 if(followlink
and (ftype
== 1 or ftype
== 2)):
3138 flstatinfo
= os
.stat(flinkname
);
3139 with(open(flinkname
, "rb") as fpc
):
3141 chunk
= fpc
.read(chunk_size
);
3145 ftypehex
= format(ftype
, 'x').lower();
3146 extrafields
= len(extradata
);
3147 extrafieldslist
= extradata
;
3148 catfextrafields
= extrafields
;
3149 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[4]);
3150 if(len(extradata
)>0):
3151 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[4]);
3152 extrasizelen
= len(extrasizestr
);
3153 extrasizelenhex
= format(extrasizelen
, 'x').lower();
3154 catfileoutstr
= AppendNullBytes([ftypehex
, fname
, flinkname
, format(int(fsize
), 'x').lower(), format(int(fatime
), 'x').lower(), format(int(fmtime
), 'x').lower(), format(int(fctime
), 'x').lower(), format(int(fbtime
), 'x').lower(), format(int(fmode
), 'x').lower(), format(int(fuid
), 'x').lower(), funame
, format(int(fgid
), 'x').lower(), fgname
, format(int(fcurfid
), 'x').lower(), format(int(fcurinode
), 'x').lower(), format(int(flinkcount
), 'x').lower(), format(int(fdev_minor
), 'x').lower(), format(int(fdev_major
), 'x').lower(), format(int(frdev_minor
), 'x').lower(), format(int(frdev_major
), 'x').lower(), extrasizelenhex
, format(catfextrafields
, 'x').lower()], formatspecs
[4]);
3155 if(len(extradata
)>0):
3156 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[4]);
3157 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[4]);
3158 catfnumfields
= 24 + catfextrafields
;
3159 if(checksumtype
=="none" or checksumtype
==""):
3160 catfileheadercshex
= format(0, 'x').lower();
3161 catfilecontentcshex
= format(0, 'x').lower();
3162 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3163 catfileheadercshex
= format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3164 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
3165 elif(checksumtype
=="crc16_ccitt"):
3166 catfileheadercshex
= format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3167 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
3168 elif(checksumtype
=="adler32"):
3169 catfileheadercshex
= format(zlib
.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3170 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
3171 elif(checksumtype
=="crc32"):
3172 catfileheadercshex
= format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3173 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
3174 elif(checksumtype
=="crc64_ecma"):
3175 catfileheadercshex
= format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3176 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
3177 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3178 catfileheadercshex
= format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3179 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
3180 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3181 checksumoutstr
= hashlib
.new(checksumtype
);
3182 checksumoutstr
.update("".encode('UTF-8'));
3183 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3184 checksumoutstr
= hashlib
.new(checksumtype
);
3185 checksumoutstr
.update(fcontents
);
3186 catfilecontentcshex
= checksumoutstr
.hexdigest().lower();
3188 catfileheadercshex
= format(0, 'x').lower();
3189 catfilecontentcshex
= format(0, 'x').lower();
3190 catfhstart
= fheadtell
;
3191 fheadtell
+= len(catfileoutstr
);
3192 catfhend
= fheadtell
- 1;
3193 catfcontentstart
= fheadtell
;
3194 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4]);
3195 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
3196 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[4]) + catfileoutstr
;
3197 if(checksumtype
=="none" or checksumtype
==""):
3198 catfileheadercshex
= format(0, 'x').lower();
3199 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3200 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
3201 elif(checksumtype
=="crc16_ccitt"):
3202 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
3203 elif(checksumtype
=="adler32"):
3204 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3205 elif(checksumtype
=="crc32"):
3206 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3207 elif(checksumtype
=="crc64_ecma"):
3208 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3209 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3210 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3211 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3212 checksumoutstr
= hashlib
.new(checksumtype
);
3213 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
3214 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3216 catfileheadercshex
= format(0, 'x').lower();
3217 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4]);
3218 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
3219 nullstrecd
= formatspecs
[4].encode('UTF-8');
3220 fheadtell
+= len(catfileoutstr
) + 1;
3221 catfcontentend
= fheadtell
- 1;
3222 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
;
3223 pyhascontents
= False;
3224 if(int(fsize
)>0 and not listonly
):
3225 pyhascontents
= True;
3226 if(int(fsize
)>0 and listonly
):
3228 pyhascontents
= False;
3229 catlist
['ffilelist'].update({fileidnum
: {'fid': fileidnum
, 'fidalt': fileidnum
, 'fheadersize': int(catheaersize
, 16), 'fhstart': catfhstart
, 'fhend': catfhend
, 'ftype': ftype
, 'fname': fname
, 'fbasedir': fbasedir
, 'flinkname': flinkname
, 'fsize': fsize
, 'fatime': fatime
, 'fmtime': fmtime
, 'fctime': fctime
, 'fbtime': fbtime
, 'fmode': fmode
, 'fchmode': fchmode
, 'ftypemod': ftypemod
, 'fuid': fuid
, 'funame': funame
, 'fgid': fgid
, 'fgname': fgname
, 'finode': finode
, 'flinkcount': flinkcount
, 'fminor': fdev_minor
, 'fmajor': fdev_major
, 'frminor': frdev_minor
, 'frmajor': frdev_major
, 'fchecksumtype': checksumtype
, 'fnumfields': catfnumfields
, 'fextrafields': catfextrafields
, 'fextrafieldsize': extrasizelen
, 'fextralist': extrafieldslist
, 'fheaderchecksum': int(catfileheadercshex
, 16), 'fcontentchecksum': int(catfilecontentcshex
, 16), 'fhascontents': pyhascontents
, 'fcontentstart': catfcontentstart
, 'fcontentend': catfcontentend
, 'fcontents': fcontents
} });
3230 fileidnum
= fileidnum
+ 1;
3233 def TarFileToArrayAlt(infiles
, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
3239 inodetocatinode
= {};
3241 if(not os
.path
.exists(infiles
) or not os
.path
.isfile(infiles
)):
3244 if(not tarfile
.is_tarfile(infiles
)):
3246 except AttributeError:
3247 if(not is_tarfile(infiles
)):
3249 tarfp
= tarfile
.open(infiles
, "r");
3250 fnumfiles
= int(len(tarfp
.getmembers()));
3251 catver
= formatspecs
[5];
3252 fileheaderver
= str(int(catver
.replace(".", "")));
3253 fileheader
= AppendNullByte(formatspecs
[0] + fileheaderver
, formatspecs
[4]);
3254 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
3255 fileheader
= fileheader
+ AppendNullBytes([fnumfileshex
, checksumtype
], formatspecs
[4]);
3256 catversion
= fileheaderver
;
3257 if(checksumtype
=="none" or checksumtype
==""):
3258 catfileheadercshex
= format(0, 'x').lower();
3259 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3260 catfileheadercshex
= format(crc16(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
3261 elif(checksumtype
=="crc16_ccitt"):
3262 catfileheadercshex
= format(crc16_ccitt(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
3263 elif(checksumtype
=="adler32"):
3264 catfileheadercshex
= format(zlib
.adler32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3265 elif(checksumtype
=="crc32"):
3266 catfileheadercshex
= format(crc32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3267 elif(checksumtype
=="crc64_ecma"):
3268 catfileheadercshex
= format(crc64_ecma(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3269 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3270 catfileheadercshex
= format(crc64_iso(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3271 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3272 checksumoutstr
= hashlib
.new(checksumtype
);
3273 checksumoutstr
.update(fileheader
.encode('UTF-8'));
3274 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3276 catfileheadercshex
= format(0, 'x').lower();
3277 fileheader
= fileheader
+ AppendNullByte(catfileheadercshex
, formatspecs
[4]);
3278 fheadtell
= len(fileheader
);
3279 catlist
= {'fnumfiles': fnumfiles
, 'fformat': formatspecs
[0], 'fversion': catversion
, 'fformatspecs': formatspecs
, 'fchecksumtype': checksumtype
, 'fheaderchecksum': catfileheadercshex
, 'ffilelist': {}};
3280 for member
in sorted(tarfp
.getmembers(), key
=lambda x
: x
.name
):
3281 if(re
.findall("^[.|/]", member
.name
)):
3282 fname
= member
.name
;
3284 fname
= "./"+member
.name
;
3286 VerbosePrintOut(fname
);
3287 fpremode
= member
.mode
;
3288 ffullmode
= member
.mode
;
3292 ffullmode
= member
.mode
+ stat
.S_IFREG
;
3294 elif(member
.isdev()):
3295 ffullmode
= member
.mode
;
3297 elif(member
.islnk()):
3298 ffullmode
= member
.mode
+ stat
.S_IFREG
;
3300 elif(member
.issym()):
3301 ffullmode
= member
.mode
+ stat
.S_IFLNK
;
3303 elif(member
.ischr()):
3304 ffullmode
= member
.mode
+ stat
.S_IFCHR
;
3306 elif(member
.isblk()):
3307 ffullmode
= member
.mode
+ stat
.S_IFBLK
;
3309 elif(member
.isdir()):
3310 ffullmode
= member
.mode
+ stat
.S_IFDIR
;
3312 elif(member
.isfifo()):
3313 ffullmode
= member
.mode
+ stat
.S_IFIFO
;
3315 elif(member
.issparse()):
3316 ffullmode
= member
.mode
;
3319 ffullmode
= member
.mode
;
3322 fbasedir
= os
.path
.dirname(fname
);
3326 curfid
= curfid
+ 1;
3328 flinkname
= member
.linkname
;
3329 fdev_minor
= member
.devminor
;
3330 fdev_major
= member
.devmajor
;
3331 frdev_minor
= member
.devminor
;
3332 frdev_major
= member
.devmajor
;
3333 if(ftype
==1 or ftype
==2 or ftype
==3 or ftype
==4 or ftype
==5 or ftype
==6):
3335 elif(ftype
==0 or ftype
==7):
3336 fsize
= member
.size
;
3338 fsize
= member
.size
;
3339 fatime
= member
.mtime
;
3340 fmtime
= member
.mtime
;
3341 fctime
= member
.mtime
;
3342 fbtime
= member
.mtime
;
3344 fchmode
= stat
.S_IMODE(ffullmode
);
3345 ftypemod
= stat
.S_IFMT(ffullmode
);
3348 funame
= member
.uname
;
3349 fgname
= member
.gname
;
3350 flinkcount
= flinkcount
;
3351 fcontents
= "".encode('UTF-8');
3353 if(ftype
== 0 or ftype
== 7):
3354 with(tarfp
.extractfile(member
) as fpc
):
3356 chunk
= fpc
.read(chunk_size
);
3360 ftypehex
= format(ftype
, 'x').lower();
3361 extrafields
= len(extradata
);
3362 extrafieldslist
= extradata
;
3363 catfextrafields
= extrafields
;
3364 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[4]);
3365 if(len(extradata
)>0):
3366 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[4]);
3367 extrasizelen
= len(extrasizestr
);
3368 extrasizelenhex
= format(extrasizelen
, 'x').lower();
3369 catfileoutstr
= AppendNullBytes([ftypehex
, fname
, flinkname
, format(int(fsize
), 'x').lower(), format(int(fatime
), 'x').lower(), format(int(fmtime
), 'x').lower(), format(int(fctime
), 'x').lower(), format(int(fbtime
), 'x').lower(), format(int(fmode
), 'x').lower(), format(int(fuid
), 'x').lower(), funame
, format(int(fgid
), 'x').lower(), fgname
, format(int(fcurfid
), 'x').lower(), format(int(fcurinode
), 'x').lower(), format(int(flinkcount
), 'x').lower(), format(int(fdev_minor
), 'x').lower(), format(int(fdev_major
), 'x').lower(), format(int(frdev_minor
), 'x').lower(), format(int(frdev_major
), 'x').lower(), extrasizelenhex
, format(catfextrafields
, 'x').lower()], formatspecs
[4]);
3370 if(len(extradata
)>0):
3371 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[4]);
3372 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[4]);
3373 catfnumfields
= 24 + catfextrafields
;
3374 if(checksumtype
=="none" or checksumtype
==""):
3375 catfileheadercshex
= format(0, 'x').lower();
3376 catfilecontentcshex
= format(0, 'x').lower();
3377 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3378 catfileheadercshex
= format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3379 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
3380 elif(checksumtype
=="crc16_ccitt"):
3381 catfileheadercshex
= format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3382 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
3383 elif(checksumtype
=="adler32"):
3384 catfileheadercshex
= format(zlib
.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3385 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
3386 elif(checksumtype
=="crc32"):
3387 catfileheadercshex
= format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3388 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
3389 elif(checksumtype
=="crc64_ecma"):
3390 catfileheadercshex
= format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3391 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
3392 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3393 catfileheadercshex
= format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3394 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
3395 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3396 checksumoutstr
= hashlib
.new(checksumtype
);
3397 checksumoutstr
.update("".encode('UTF-8'));
3398 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3399 checksumoutstr
= hashlib
.new(checksumtype
);
3400 checksumoutstr
.update(fcontents
);
3401 catfilecontentcshex
= checksumoutstr
.hexdigest().lower();
3403 catfileheadercshex
= format(0, 'x').lower();
3404 catfilecontentcshex
= format(0, 'x').lower();
3405 catfhstart
= fheadtell
;
3406 fheadtell
+= len(catfileoutstr
);
3407 catfhend
= fheadtell
- 1;
3408 catfcontentstart
= fheadtell
;
3409 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4]);
3410 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
3411 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[4]) + catfileoutstr
;
3412 if(checksumtype
=="none" or checksumtype
==""):
3413 catfileheadercshex
= format(0, 'x').lower();
3414 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3415 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
3416 elif(checksumtype
=="crc16_ccitt"):
3417 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
3418 elif(checksumtype
=="adler32"):
3419 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3420 elif(checksumtype
=="crc32"):
3421 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3422 elif(checksumtype
=="crc64_ecma"):
3423 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3424 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3425 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3426 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3427 checksumoutstr
= hashlib
.new(checksumtype
);
3428 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
3429 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3431 catfileheadercshex
= format(0, 'x').lower();
3432 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4]);
3433 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
3434 nullstrecd
= formatspecs
[4].encode('UTF-8');
3435 fheadtell
+= len(catfileoutstr
) + 1;
3436 catfcontentend
= fheadtell
- 1;
3437 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
;
3438 pyhascontents
= False;
3439 if(int(fsize
)>0 and not listonly
):
3440 pyhascontents
= True;
3441 if(int(fsize
)>0 and listonly
):
3443 pyhascontents
= False;
3444 catlist
['ffilelist'].update({fileidnum
: {'fid': fileidnum
, 'fidalt': fileidnum
, 'fheadersize': int(catheaersize
, 16), 'fhstart': catfhstart
, 'fhend': catfhend
, 'ftype': ftype
, 'fname': fname
, 'fbasedir': fbasedir
, 'flinkname': flinkname
, 'fsize': fsize
, 'fatime': fatime
, 'fmtime': fmtime
, 'fctime': fctime
, 'fbtime': fbtime
, 'fmode': fmode
, 'fchmode': fchmode
, 'ftypemod': ftypemod
, 'fuid': fuid
, 'funame': funame
, 'fgid': fgid
, 'fgname': fgname
, 'finode': finode
, 'flinkcount': flinkcount
, 'fminor': fdev_minor
, 'fmajor': fdev_major
, 'frminor': frdev_minor
, 'frmajor': frdev_major
, 'fchecksumtype': checksumtype
, 'fnumfields': catfnumfields
, 'fextrafields': catfextrafields
, 'fextrafieldsize': extrasizelen
, 'fextralist': extrafieldslist
, 'fheaderchecksum': int(catfileheadercshex
, 16), 'fcontentchecksum': int(catfilecontentcshex
, 16), 'fhascontents': pyhascontents
, 'fcontentstart': catfcontentstart
, 'fcontentend': catfcontentend
, 'fcontents': fcontents
} });
3445 fileidnum
= fileidnum
+ 1;
3448 def ZipFileToArrayAlt(infiles
, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
3449 advancedlist
= True;
3455 inodetocatinode
= {};
3457 if(not os
.path
.exists(infiles
) or not os
.path
.isfile(infiles
)):
3459 if(not zipfile
.is_zipfile(infiles
)):
3461 zipfp
= zipfile
.ZipFile(infiles
, "r", allowZip64
=True);
3462 ziptest
= zipfp
.testzip();
3464 VerbosePrintOut("Bad file found!");
3465 fnumfiles
= int(len(zipfp
.infolist()));
3466 catver
= formatspecs
[5];
3467 fileheaderver
= str(int(catver
.replace(".", "")));
3468 fileheader
= AppendNullByte(formatspecs
[0] + fileheaderver
, formatspecs
[4]);
3469 catversion
= fileheaderver
;
3470 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
3471 fileheader
= fileheader
+ AppendNullBytes([fnumfileshex
, checksumtype
], formatspecs
[4]);
3472 if(checksumtype
=="none" or checksumtype
==""):
3473 catfileheadercshex
= format(0, 'x').lower();
3474 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3475 catfileheadercshex
= format(crc16(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
3476 elif(checksumtype
=="crc16_ccitt"):
3477 catfileheadercshex
= format(crc16_ccitt(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
3478 elif(checksumtype
=="adler32"):
3479 catfileheadercshex
= format(zlib
.adler32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3480 elif(checksumtype
=="crc32"):
3481 catfileheadercshex
= format(crc32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3482 elif(checksumtype
=="crc64_ecma"):
3483 catfileheadercshex
= format(crc64_ecma(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3484 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3485 catfileheadercshex
= format(crc64_iso(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3486 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3487 checksumoutstr
= hashlib
.new(checksumtype
);
3488 checksumoutstr
.update(fileheader
.encode('UTF-8'));
3489 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3491 catfileheadercshex
= format(0, 'x').lower();
3492 fileheader
= fileheader
+ AppendNullByte(catfileheadercshex
, formatspecs
[4]);
3493 fheadtell
= len(fileheader
);
3494 catlist
= {'fnumfiles': fnumfiles
, 'fformat': formatspecs
[0], 'fversion': catversion
, 'fformatspecs': formatspecs
, 'fchecksumtype': checksumtype
, 'fheaderchecksum': catfileheadercshex
, 'ffilelist': {}};
3495 for member
in sorted(zipfp
.infolist(), key
=lambda x
: x
.filename
):
3496 if(re
.findall("^[.|/]", member
.filename
)):
3497 fname
= member
.filename
;
3499 fname
= "./"+member
.filename
;
3500 zipinfo
= zipfp
.getinfo(member
.filename
);
3502 VerbosePrintOut(fname
);
3503 if(not member
.is_dir()):
3504 fpremode
= stat
.S_IFREG
+ 438;
3505 elif(member
.is_dir()):
3506 fpremode
= stat
.S_IFDIR
+ 511;
3509 if(not member
.is_dir()):
3511 elif(member
.is_dir()):
3514 fbasedir
= os
.path
.dirname(fname
);
3518 curfid
= curfid
+ 1;
3526 fsize
= member
.file_size
;
3528 fsize
= member
.file_size
;
3529 fatime
= time
.mktime(member
.date_time
+ (0, 0, -1));
3530 fmtime
= time
.mktime(member
.date_time
+ (0, 0, -1));
3531 fctime
= time
.mktime(member
.date_time
+ (0, 0, -1));
3532 fbtime
= time
.mktime(member
.date_time
+ (0, 0, -1));
3533 if(not member
.is_dir()):
3534 fmode
= stat
.S_IFREG
+ 438;
3535 fchmode
= stat
.S_IMODE(int(stat
.S_IFREG
+ 438));
3536 ftypemod
= stat
.S_IFMT(int(stat
.S_IFREG
+ 438));
3537 if(member
.is_dir()):
3538 fmode
= stat
.S_IFDIR
+ 511;
3539 fchmode
= stat
.S_IMODE(int(stat
.S_IFDIR
+ 511));
3540 ftypemod
= stat
.S_IFMT(int(stat
.S_IFDIR
+ 511));
3543 except AttributeError:
3549 except AttributeError:
3556 userinfo
= pwd
.getpwuid(os
.getuid());
3557 funame
= userinfo
.pw_name
;
3560 except AttributeError:
3568 groupinfo
= grp
.getgrgid(os
.getgid());
3569 fgname
= groupinfo
.gr_name
;
3572 except AttributeError:
3576 fcontents
= "".encode('UTF-8');
3578 fcontents
= zipfp
.read(member
.filename
);
3579 ftypehex
= format(ftype
, 'x').lower();
3580 extrafields
= len(extradata
);
3581 extrafieldslist
= extradata
;
3582 catfextrafields
= extrafields
;
3583 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[4]);
3584 if(len(extradata
)>0):
3585 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[4]);
3586 extrasizelen
= len(extrasizestr
);
3587 extrasizelenhex
= format(extrasizelen
, 'x').lower();
3588 catfileoutstr
= AppendNullBytes([ftypehex
, fname
, flinkname
, format(int(fsize
), 'x').lower(), format(int(fatime
), 'x').lower(), format(int(fmtime
), 'x').lower(), format(int(fctime
), 'x').lower(), format(int(fbtime
), 'x').lower(), format(int(fmode
), 'x').lower(), format(int(fuid
), 'x').lower(), funame
, format(int(fgid
), 'x').lower(), fgname
, format(int(fcurfid
), 'x').lower(), format(int(fcurinode
), 'x').lower(), format(int(flinkcount
), 'x').lower(), format(int(fdev_minor
), 'x').lower(), format(int(fdev_major
), 'x').lower(), format(int(frdev_minor
), 'x').lower(), format(int(frdev_major
), 'x').lower(), extrasizelenhex
, format(catfextrafields
, 'x').lower()], formatspecs
[4]);
3589 if(len(extradata
)>0):
3590 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[4]);
3591 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[4]);
3592 catfnumfields
= 24 + catfextrafields
;
3593 if(checksumtype
=="none" or checksumtype
==""):
3594 catfileheadercshex
= format(0, 'x').lower();
3595 catfilecontentcshex
= format(0, 'x').lower();
3596 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3597 catfileheadercshex
= format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
3598 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
3599 elif(checksumtype
=="crc16_ccitt"):
3600 catfileheadercshex
= format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
3601 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
3602 elif(checksumtype
=="adler32"):
3603 catfileheadercshex
= format(zlib
.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3604 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
3605 elif(checksumtype
=="crc32"):
3606 catfileheadercshex
= format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
3607 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
3608 elif(checksumtype
=="crc64_ecma"):
3609 catfileheadercshex
= format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3610 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
3611 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3612 catfileheadercshex
= format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3613 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
3614 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3615 checksumoutstr
= hashlib
.new(checksumtype
);
3616 checksumoutstr
.update("".encode('UTF-8'));
3617 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3618 checksumoutstr
= hashlib
.new(checksumtype
);
3619 checksumoutstr
.update(fcontents
);
3620 catfilecontentcshex
= checksumoutstr
.hexdigest().lower();
3622 catfileheadercshex
= format(0, 'x').lower();
3623 catfilecontentcshex
= format(0, 'x').lower();
3624 catfhstart
= fheadtell
;
3625 fheadtell
+= len(catfileoutstr
);
3626 catfhend
= fheadtell
- 1;
3627 catfcontentstart
= fheadtell
;
3628 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4]);
3629 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
3630 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[4]) + catfileoutstr
;
3631 if(checksumtype
=="none" or checksumtype
==""):
3632 catfileheadercshex
= format(0, 'x').lower();
3633 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3634 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
3635 elif(checksumtype
=="crc16_ccitt"):
3636 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
3637 elif(checksumtype
=="adler32"):
3638 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3639 elif(checksumtype
=="crc32"):
3640 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3641 elif(checksumtype
=="crc64_ecma"):
3642 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3643 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3644 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3645 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3646 checksumoutstr
= hashlib
.new(checksumtype
);
3647 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
3648 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3650 catfileheadercshex
= format(0, 'x').lower();
3651 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4]);
3652 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
3653 nullstrecd
= formatspecs
[4].encode('UTF-8');
3654 fheadtell
+= len(catfileoutstr
) + 1;
3655 catfcontentend
= fheadtell
- 1;
3656 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
;
3657 pyhascontents
= False;
3658 if(int(fsize
)>0 and not listonly
):
3659 pyhascontents
= True;
3660 if(int(fsize
)>0 and listonly
):
3662 pyhascontents
= False;
3663 catlist
['ffilelist'].update({fileidnum
: {'fid': fileidnum
, 'fidalt': fileidnum
, 'fheadersize': int(catheaersize
, 16), 'fhstart': catfhstart
, 'fhend': catfhend
, 'ftype': ftype
, 'fname': fname
, 'fbasedir': fbasedir
, 'flinkname': flinkname
, 'fsize': fsize
, 'fatime': fatime
, 'fmtime': fmtime
, 'fctime': fctime
, 'fbtime': fbtime
, 'fmode': fmode
, 'fchmode': fchmode
, 'ftypemod': ftypemod
, 'fuid': fuid
, 'funame': funame
, 'fgid': fgid
, 'fgname': fgname
, 'finode': finode
, 'flinkcount': flinkcount
, 'fminor': fdev_minor
, 'fmajor': fdev_major
, 'frminor': frdev_minor
, 'frmajor': frdev_major
, 'fchecksumtype': checksumtype
, 'fnumfields': catfnumfields
, 'fextrafields': catfextrafields
, 'fextrafieldsize': extrasizelen
, 'fextralist': extrafieldslist
, 'fheaderchecksum': int(catfileheadercshex
, 16), 'fcontentchecksum': int(catfilecontentcshex
, 16), 'fhascontents': pyhascontents
, 'fcontentstart': catfcontentstart
, 'fcontentend': catfcontentend
, 'fcontents': fcontents
} });
3664 fileidnum
= fileidnum
+ 1;
3667 if(not rarfile_support
):
3668 def RarFileToArrayAlt(infiles
, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
3671 if(rarfile_support
):
3672 def RarFileToArrayAlt(infiles
, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
3673 advancedlist
= True;
3679 inodetocatinode
= {};
3681 if(not os
.path
.exists(infiles
) or not os
.path
.isfile(infiles
)):
3683 if(not rarfile
.is_rarfile(infile
) and not rarfile
.is_rarfile_sfx(infile
)):
3685 rarfp
= rarfile
.RarFile(infile
, "r");
3686 rartest
= rarfp
.testrar();
3688 VerbosePrintOut("Bad file found!");
3689 fnumfiles
= int(len(rarfp
.infolist()));
3690 catver
= formatspecs
[5];
3691 fileheaderver
= str(int(catver
.replace(".", "")));
3692 fileheader
= AppendNullByte(formatspecs
[0] + fileheaderver
, formatspecs
[4]);
3693 catversion
= fileheaderver
;
3694 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
3695 fileheader
= fileheader
+ AppendNullBytes([fnumfileshex
, checksumtype
], formatspecs
[4]);
3696 if(checksumtype
=="none" or checksumtype
==""):
3697 catfileheadercshex
= format(0, 'x').lower();
3698 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3699 catfileheadercshex
= format(crc16(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
3700 elif(checksumtype
=="crc16_ccitt"):
3701 catfileheadercshex
= format(crc16_ccitt(fileheader
.encode('UTF-8')) & 0xffff, '04x').lower();
3702 elif(checksumtype
=="adler32"):
3703 catfileheadercshex
= format(zlib
.adler32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3704 elif(checksumtype
=="crc32"):
3705 catfileheadercshex
= format(crc32(fileheader
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3706 elif(checksumtype
=="crc64_ecma"):
3707 catfileheadercshex
= format(crc64_ecma(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3708 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3709 catfileheadercshex
= format(crc64_iso(fileheader
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3710 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3711 checksumoutstr
= hashlib
.new(checksumtype
);
3712 checksumoutstr
.update(fileheader
.encode('UTF-8'));
3713 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3715 catfileheadercshex
= format(0, 'x').lower();
3716 fileheader
= fileheader
+ AppendNullByte(catfileheadercshex
, formatspecs
[4]);
3717 fheadtell
= len(fileheader
);
3718 catlist
= {'fnumfiles': fnumfiles
, 'fformat': formatspecs
[0], 'fversion': catversion
, 'fformatspecs': formatspecs
, 'fchecksumtype': checksumtype
, 'fheaderchecksum': catfileheadercshex
, 'ffilelist': {}};
3719 for member
in sorted(rarfp
.infolist(), key
=lambda x
: x
.filename
):
3722 if(member
.host_os
== rarfile
.RAR_OS_UNIX
):
3725 member
.external_attr
3727 except AttributeError:
3729 elif(member
.host_os
== rarfile
.RAR_OS_WIN32
):
3732 member
.external_attr
3734 except AttributeError:
3739 if(re
.findall("^[.|/]", member
.filename
)):
3740 fname
= member
.filename
;
3742 fname
= "./"+member
.filename
;
3743 rarinfo
= rarfp
.getinfo(member
.filename
);
3745 VerbosePrintOut(fname
);
3746 if(is_unix
and member
.external_attr
!=0):
3747 fpremode
= int(member
.external_attr
);
3748 elif(member
.is_file()):
3749 fpremode
= stat
.S_IFREG
+ 438;
3750 elif(member
.is_symlink()):
3751 fpremode
= stat
.S_IFLNK
+ 438;
3752 elif(member
.is_dir()):
3753 fpremode
= stat
.S_IFDIR
+ 511;
3754 if(is_windows
and member
.external_attr
!=0):
3755 fwinattributes
= int(member
.external_attr
);
3757 fwinattributes
= int(0);
3760 if(member
.is_file()):
3762 elif(member
.is_symlink()):
3764 elif(member
.is_dir()):
3768 flinkname
= rarfp
.read(member
.filename
).decode("UTF-8");
3769 fbasedir
= os
.path
.dirname(fname
);
3773 curfid
= curfid
+ 1;
3781 fsize
= member
.file_size
;
3784 fatime
= int(member
.atime
.timestamp());
3786 fatime
= int(member
.mtime
.timestamp());
3787 except AttributeError:
3788 fatime
= int(member
.mtime
.timestamp());
3789 fmtime
= int(member
.mtime
.timestamp());
3792 fctime
= int(member
.ctime
.timestamp());
3794 fctime
= int(member
.mtime
.timestamp());
3795 except AttributeError:
3796 fctime
= int(member
.mtime
.timestamp());
3797 fbtime
= int(member
.mtime
.timestamp());
3798 if(is_unix
and member
.external_attr
!=0):
3799 fmode
= format(int(member
.external_attr
), 'x').lower();
3800 fchmode
= format(int(stat
.S_IMODE(member
.external_attr
)), 'x').lower();
3801 ftypemod
= format(int(stat
.S_IFMT(member
.external_attr
)), 'x').lower();
3802 elif(member
.is_file()):
3803 fmode
= int(stat
.S_IFREG
+ 438)
3804 fchmode
= int(stat
.S_IMODE(stat
.S_IFREG
+ 438));
3805 ftypemod
= int(stat
.S_IFMT(stat
.S_IFREG
+ 438));
3806 elif(member
.is_symlink()):
3807 fmode
= int(stat
.S_IFLNK
+ 438)
3808 fchmode
= int(stat
.S_IMODE(stat
.S_IFREG
+ 438));
3809 ftypemod
= int(stat
.S_IFMT(stat
.S_IFREG
+ 438));
3810 elif(member
.is_dir()):
3811 fmode
= int(stat
.S_IFDIR
+ 511)
3812 fchmode
= int(stat
.S_IMODE(stat
.S_IFDIR
+ 511));
3813 ftypemod
= int(stat
.S_IFMT(stat
.S_IFDIR
+ 511));
3816 except AttributeError:
3822 except AttributeError:
3829 userinfo
= pwd
.getpwuid(os
.getuid());
3830 funame
= userinfo
.pw_name
;
3833 except AttributeError:
3841 groupinfo
= grp
.getgrgid(os
.getgid());
3842 fgname
= groupinfo
.gr_name
;
3845 except AttributeError:
3849 fcontents
= "".encode('UTF-8');
3851 fcontents
= rarfp
.read(member
.filename
);
3852 ftypehex
= format(ftype
, 'x').lower();
3853 extrafields
= len(extradata
);
3854 extrafieldslist
= extradata
;
3855 catfextrafields
= extrafields
;
3856 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[4]);
3857 if(len(extradata
)>0):
3858 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[4]);
3859 extrasizelen
= len(extrasizestr
);
3860 extrasizelenhex
= format(extrasizelen
, 'x').lower();
3861 catfileoutstr
= AppendNullBytes([ftypehex
, fname
, flinkname
, format(int(fsize
), 'x').lower(), format(int(fatime
), 'x').lower(), format(int(fmtime
), 'x').lower(), format(int(fctime
), 'x').lower(), format(int(fbtime
), 'x').lower(), format(int(fmode
), 'x').lower(), format(int(fuid
), 'x').lower(), funame
, format(int(fgid
), 'x').lower(), fgname
, format(int(fcurfid
), 'x').lower(), format(int(fcurinode
), 'x').lower(), format(int(flinkcount
), 'x').lower(), format(int(fdev_minor
), 'x').lower(), format(int(fdev_major
), 'x').lower(), format(int(frdev_minor
), 'x').lower(), format(int(frdev_major
), 'x').lower(), extrasizelenhex
, format(catfextrafields
, 'x').lower()], formatspecs
[4]);
3862 if(len(extradata
)>0):
3863 catfileoutstr
= catfileoutstr
+ AppendNullBytes(extradata
, formatspecs
[4]);
3864 catfileoutstr
= catfileoutstr
+ AppendNullByte(checksumtype
, formatspecs
[4]);
3865 catfnumfields
= 24 + catfextrafields
;
3866 if(checksumtype
=="none" or checksumtype
==""):
3867 catfileheadercshex
= format(0, 'x').lower();
3868 catfilecontentcshex
= format(0, 'x').lower();
3869 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3870 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
3871 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
3872 elif(checksumtype
=="crc16_ccitt"):
3873 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
3874 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
3875 elif(checksumtype
=="adler32"):
3876 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3877 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
3878 elif(checksumtype
=="crc32"):
3879 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3880 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
3881 elif(checksumtype
=="crc64_ecma"):
3882 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3883 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
3884 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3885 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3886 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
3887 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3888 checksumoutstr
= hashlib
.new(checksumtype
);
3889 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
3890 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3892 catfileheadercshex
= format(0, 'x').lower();
3893 catfilecontentcshex
= format(0, 'x').lower();
3894 catfhstart
= fheadtell
;
3895 fheadtell
+= len(catfileoutstr
);
3896 catfhend
= fheadtell
- 1;
3897 catfcontentstart
= fheadtell
;
3898 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4]);
3899 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
3900 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[4]) + catfileoutstr
;
3901 if(checksumtype
=="none" or checksumtype
==""):
3902 catfileheadercshex
= format(0, 'x').lower();
3903 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
3904 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
3905 elif(checksumtype
=="crc16_ccitt"):
3906 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
3907 elif(checksumtype
=="adler32"):
3908 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3909 elif(checksumtype
=="crc32"):
3910 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
3911 elif(checksumtype
=="crc64_ecma"):
3912 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3913 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
3914 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
3915 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
3916 checksumoutstr
= hashlib
.new(checksumtype
);
3917 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
3918 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
3920 catfileheadercshex
= format(0, 'x').lower();
3921 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4]);
3922 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
3923 nullstrecd
= formatspecs
[4].encode('UTF-8');
3924 fheadtell
+= len(catfileoutstr
) + 1;
3925 catfcontentend
= fheadtell
- 1;
3926 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
;
3927 pyhascontents
= False;
3928 if(int(fsize
)>0 and not listonly
):
3929 pyhascontents
= True;
3930 if(int(fsize
)>0 and listonly
):
3932 pyhascontents
= False;
3933 catlist
['ffilelist'].update({fileidnum
: {'fid': fileidnum
, 'fidalt': fileidnum
, 'fheadersize': int(catheaersize
, 16), 'fhstart': catfhstart
, 'fhend': catfhend
, 'ftype': ftype
, 'fname': fname
, 'fbasedir': fbasedir
, 'flinkname': flinkname
, 'fsize': fsize
, 'fatime': fatime
, 'fmtime': fmtime
, 'fctime': fctime
, 'fbtime': fbtime
, 'fmode': fmode
, 'fchmode': fchmode
, 'ftypemod': ftypemod
, 'fuid': fuid
, 'funame': funame
, 'fgid': fgid
, 'fgname': fgname
, 'finode': finode
, 'flinkcount': flinkcount
, 'fminor': fdev_minor
, 'fmajor': fdev_major
, 'frminor': frdev_minor
, 'frmajor': frdev_major
, 'fchecksumtype': checksumtype
, 'fnumfields': catfnumfields
, 'fextrafields': catfextrafields
, 'fextrafieldsize': extrasizelen
, 'fextralist': extrafieldslist
, 'fheaderchecksum': int(catfileheadercshex
, 16), 'fcontentchecksum': int(catfilecontentcshex
, 16), 'fhascontents': pyhascontents
, 'fcontentstart': catfcontentstart
, 'fcontentend': catfcontentend
, 'fcontents': fcontents
} });
3934 fileidnum
= fileidnum
+ 1;
3937 def ListDirToArray(infiles
, dirlistfromtxt
=False, compression
="auto", compressionlevel
=None, followlink
=False, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, usenewstyle
=True, returnfp
=False):
3938 outarray
= BytesIO();
3939 packcat
= PackArchiveFile(infiles
, outarray
, dirlistfromtxt
, compression
, compressionlevel
, followlink
, checksumtype
, extradata
, formatspecs
, verbose
, True);
3940 listcatfiles
= ArchiveFileToArray(outarray
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
3941 return listcatfiles
;
3943 def ArchiveFileToArrayIndex(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, usenewstyle
=True, returnfp
=False):
3944 if(isinstance(infile
, dict)):
3945 listcatfiles
= infile
;
3947 if(infile
!="-" and not hasattr(infile
, "read") and not hasattr(infile
, "write")):
3948 infile
= RemoveWindowsPath(infile
);
3949 listcatfiles
= ArchiveFileToArray(infile
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
3950 if(not listcatfiles
):
3952 catarray
= {'list': listcatfiles
, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {}, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}};
3954 catarray
.update({'catfp': listcatfiles
['catfp']});
3955 lenlist
= len(listcatfiles
['ffilelist']);
3960 if(seekend
>0 and seekend
<listcatfiles
['fnumfiles']):
3963 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
3964 lcfx
= listcatfiles
['fnumfiles'];
3966 lcfx
= int(listcatfiles
['fnumfiles']);
3968 filetoidarray
= {listcatfiles
['ffilelist'][lcfi
]['fname']: listcatfiles
['ffilelist'][lcfi
]['fid']};
3969 idtofilearray
= {listcatfiles
['ffilelist'][lcfi
]['fid']: listcatfiles
['ffilelist'][lcfi
]['fname']};
3970 catarray
['filetoid'].update(filetoidarray
);
3971 catarray
['idtofile'].update(idtofilearray
);
3972 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==0 or listcatfiles
['ffilelist'][lcfi
]['ftype']==7):
3973 catarray
['filetypes']['files']['filetoid'].update(filetoidarray
);
3974 catarray
['filetypes']['files']['idtofile'].update(idtofilearray
);
3975 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==1):
3976 catarray
['filetypes']['hardlinks']['filetoid'].update(filetoidarray
);
3977 catarray
['filetypes']['hardlinks']['idtofile'].update(idtofilearray
);
3978 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
3979 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
3980 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==2):
3981 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
3982 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
3983 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
3984 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
3985 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==3):
3986 catarray
['filetypes']['character']['filetoid'].update(filetoidarray
);
3987 catarray
['filetypes']['character']['idtofile'].update(idtofilearray
);
3988 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
3989 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
3990 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==4):
3991 catarray
['filetypes']['block']['filetoid'].update(filetoidarray
);
3992 catarray
['filetypes']['block']['idtofile'].update(idtofilearray
);
3993 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
3994 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
3995 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==5):
3996 catarray
['filetypes']['directories']['filetoid'].update(filetoidarray
);
3997 catarray
['filetypes']['directories']['idtofile'].update(idtofilearray
);
3998 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==6):
3999 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
4000 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
4001 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
4002 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
4006 create_alias_function("", __file_format_name__
, "ToArrayIndex", ArchiveFileToArrayIndex
);
4008 def ListDirToArrayIndexAlt(infiles
, dirlistfromtxt
=False, followlink
=False, seekstart
=0, seekend
=0, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
4009 listcatfiles
= ListDirToArrayAlt(infiles
, dirlistfromtxt
, followlink
, listonly
, checksumtype
, extradata
, formatspecs
, verbose
);
4010 if(not listcatfiles
):
4012 catarray
= {'list': listcatfiles
, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {}, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}};
4013 lenlist
= len(listcatfiles
['ffilelist']);
4018 if(seekend
>0 and seekend
<listcatfiles
['fnumfiles']):
4021 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
4022 lcfx
= listcatfiles
['fnumfiles'];
4024 lcfx
= int(listcatfiles
['fnumfiles']);
4026 filetoidarray
= {listcatfiles
['ffilelist'][lcfi
]['fname']: listcatfiles
['ffilelist'][lcfi
]['fid']};
4027 idtofilearray
= {listcatfiles
['ffilelist'][lcfi
]['fid']: listcatfiles
['ffilelist'][lcfi
]['fname']};
4028 catarray
['filetoid'].update(filetoidarray
);
4029 catarray
['idtofile'].update(idtofilearray
);
4030 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==0 or listcatfiles
['ffilelist'][lcfi
]['ftype']==7):
4031 catarray
['filetypes']['files']['filetoid'].update(filetoidarray
);
4032 catarray
['filetypes']['files']['idtofile'].update(idtofilearray
);
4033 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==1):
4034 catarray
['filetypes']['hardlinks']['filetoid'].update(filetoidarray
);
4035 catarray
['filetypes']['hardlinks']['idtofile'].update(idtofilearray
);
4036 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
4037 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
4038 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==2):
4039 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
4040 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
4041 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
4042 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
4043 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==3):
4044 catarray
['filetypes']['character']['filetoid'].update(filetoidarray
);
4045 catarray
['filetypes']['character']['idtofile'].update(idtofilearray
);
4046 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
4047 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
4048 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==4):
4049 catarray
['filetypes']['block']['filetoid'].update(filetoidarray
);
4050 catarray
['filetypes']['block']['idtofile'].update(idtofilearray
);
4051 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
4052 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
4053 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==5):
4054 catarray
['filetypes']['directories']['filetoid'].update(filetoidarray
);
4055 catarray
['filetypes']['directories']['idtofile'].update(idtofilearray
);
4056 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==6):
4057 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
4058 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
4059 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
4060 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
4064 def TarFileToArrayIndexAlt(infiles
, seekstart
=0, seekend
=0, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
4065 listcatfiles
= TarFileToArrayAlt(infiles
, listonly
, checksumtype
, extradata
, formatspecs
, verbose
);
4066 if(not listcatfiles
):
4068 catarray
= {'list': listcatfiles
, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {}, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}};
4069 lenlist
= len(listcatfiles
['ffilelist']);
4074 if(seekend
>0 and seekend
<listcatfiles
['fnumfiles']):
4077 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
4078 lcfx
= listcatfiles
['fnumfiles'];
4080 lcfx
= int(listcatfiles
['fnumfiles']);
4082 filetoidarray
= {listcatfiles
['ffilelist'][lcfi
]['fname']: listcatfiles
['ffilelist'][lcfi
]['fid']};
4083 idtofilearray
= {listcatfiles
['ffilelist'][lcfi
]['fid']: listcatfiles
['ffilelist'][lcfi
]['fname']};
4084 catarray
['filetoid'].update(filetoidarray
);
4085 catarray
['idtofile'].update(idtofilearray
);
4086 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==0 or listcatfiles
['ffilelist'][lcfi
]['ftype']==7):
4087 catarray
['filetypes']['files']['filetoid'].update(filetoidarray
);
4088 catarray
['filetypes']['files']['idtofile'].update(idtofilearray
);
4089 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==1):
4090 catarray
['filetypes']['hardlinks']['filetoid'].update(filetoidarray
);
4091 catarray
['filetypes']['hardlinks']['idtofile'].update(idtofilearray
);
4092 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
4093 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
4094 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==2):
4095 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
4096 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
4097 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
4098 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
4099 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==3):
4100 catarray
['filetypes']['character']['filetoid'].update(filetoidarray
);
4101 catarray
['filetypes']['character']['idtofile'].update(idtofilearray
);
4102 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
4103 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
4104 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==4):
4105 catarray
['filetypes']['block']['filetoid'].update(filetoidarray
);
4106 catarray
['filetypes']['block']['idtofile'].update(idtofilearray
);
4107 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
4108 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
4109 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==5):
4110 catarray
['filetypes']['directories']['filetoid'].update(filetoidarray
);
4111 catarray
['filetypes']['directories']['idtofile'].update(idtofilearray
);
4112 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==6):
4113 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
4114 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
4115 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
4116 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
4120 def ZipFileToArrayIndexAlt(infiles
, seekstart
=0, seekend
=0, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
4121 listcatfiles
= ZipFileToArrayAlt(infiles
, listonly
, checksumtype
, extradata
, formatspecs
, verbose
);
4122 if(not listcatfiles
):
4124 catarray
= {'list': listcatfiles
, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {}, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}};
4125 lenlist
= len(listcatfiles
['ffilelist']);
4130 if(seekend
>0 and seekend
<listcatfiles
['fnumfiles']):
4133 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
4134 lcfx
= listcatfiles
['fnumfiles'];
4136 lcfx
= int(listcatfiles
['fnumfiles']);
4138 filetoidarray
= {listcatfiles
['ffilelist'][lcfi
]['fname']: listcatfiles
['ffilelist'][lcfi
]['fid']};
4139 idtofilearray
= {listcatfiles
['ffilelist'][lcfi
]['fid']: listcatfiles
['ffilelist'][lcfi
]['fname']};
4140 catarray
['filetoid'].update(filetoidarray
);
4141 catarray
['idtofile'].update(idtofilearray
);
4142 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==0 or listcatfiles
['ffilelist'][lcfi
]['ftype']==7):
4143 catarray
['filetypes']['files']['filetoid'].update(filetoidarray
);
4144 catarray
['filetypes']['files']['idtofile'].update(idtofilearray
);
4145 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==1):
4146 catarray
['filetypes']['hardlinks']['filetoid'].update(filetoidarray
);
4147 catarray
['filetypes']['hardlinks']['idtofile'].update(idtofilearray
);
4148 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
4149 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
4150 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==2):
4151 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
4152 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
4153 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
4154 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
4155 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==3):
4156 catarray
['filetypes']['character']['filetoid'].update(filetoidarray
);
4157 catarray
['filetypes']['character']['idtofile'].update(idtofilearray
);
4158 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
4159 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
4160 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==4):
4161 catarray
['filetypes']['block']['filetoid'].update(filetoidarray
);
4162 catarray
['filetypes']['block']['idtofile'].update(idtofilearray
);
4163 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
4164 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
4165 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==5):
4166 catarray
['filetypes']['directories']['filetoid'].update(filetoidarray
);
4167 catarray
['filetypes']['directories']['idtofile'].update(idtofilearray
);
4168 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==6):
4169 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
4170 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
4171 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
4172 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
4176 if(not rarfile_support
):
4177 def RarFileToArrayIndexAlt(infiles
, seekstart
=0, seekend
=0, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
4180 if(rarfile_support
):
4181 def RarFileToArrayIndexAlt(infiles
, seekstart
=0, seekend
=0, listonly
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False):
4182 listcatfiles
= RarFileToArrayAlt(infiles
, listonly
, checksumtype
, extradata
, formatspecs
, verbose
);
4183 if(not listcatfiles
):
4185 catarray
= {'list': listcatfiles
, 'filetoid': {}, 'idtofile': {}, 'filetypes': {'directories': {'filetoid': {}, 'idtofile': {}}, 'files': {'filetoid': {}, 'idtofile': {}}, 'links': {'filetoid': {}, 'idtofile': {}}, 'symlinks': {'filetoid': {}, 'idtofile': {}}, 'hardlinks': {'filetoid': {}, 'idtofile': {}}, 'character': {'filetoid': {}, 'idtofile': {}}, 'block': {'filetoid': {}, 'idtofile': {}}, 'fifo': {'filetoid': {}, 'idtofile': {}}, 'devices': {'filetoid': {}, 'idtofile': {}}}};
4186 lenlist
= len(listcatfiles
['ffilelist']);
4191 if(seekend
>0 and seekend
<listcatfiles
['fnumfiles']):
4194 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
4195 lcfx
= listcatfiles
['fnumfiles'];
4197 lcfx
= int(listcatfiles
['fnumfiles']);
4199 filetoidarray
= {listcatfiles
['ffilelist'][lcfi
]['fname']: listcatfiles
['ffilelist'][lcfi
]['fid']};
4200 idtofilearray
= {listcatfiles
['ffilelist'][lcfi
]['fid']: listcatfiles
['ffilelist'][lcfi
]['fname']};
4201 catarray
['filetoid'].update(filetoidarray
);
4202 catarray
['idtofile'].update(idtofilearray
);
4203 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==0 or listcatfiles
['ffilelist'][lcfi
]['ftype']==7):
4204 catarray
['filetypes']['files']['filetoid'].update(filetoidarray
);
4205 catarray
['filetypes']['files']['idtofile'].update(idtofilearray
);
4206 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==1):
4207 catarray
['filetypes']['hardlinks']['filetoid'].update(filetoidarray
);
4208 catarray
['filetypes']['hardlinks']['idtofile'].update(idtofilearray
);
4209 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
4210 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
4211 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==2):
4212 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
4213 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
4214 catarray
['filetypes']['links']['filetoid'].update(filetoidarray
);
4215 catarray
['filetypes']['links']['idtofile'].update(idtofilearray
);
4216 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==3):
4217 catarray
['filetypes']['character']['filetoid'].update(filetoidarray
);
4218 catarray
['filetypes']['character']['idtofile'].update(idtofilearray
);
4219 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
4220 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
4221 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==4):
4222 catarray
['filetypes']['block']['filetoid'].update(filetoidarray
);
4223 catarray
['filetypes']['block']['idtofile'].update(idtofilearray
);
4224 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
4225 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
4226 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==5):
4227 catarray
['filetypes']['directories']['filetoid'].update(filetoidarray
);
4228 catarray
['filetypes']['directories']['idtofile'].update(idtofilearray
);
4229 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==6):
4230 catarray
['filetypes']['symlinks']['filetoid'].update(filetoidarray
);
4231 catarray
['filetypes']['symlinks']['idtofile'].update(idtofilearray
);
4232 catarray
['filetypes']['devices']['filetoid'].update(filetoidarray
);
4233 catarray
['filetypes']['devices']['idtofile'].update(idtofilearray
);
4237 def ArchiveFileStringToArrayIndex(catstr
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, usenewstyle
=True, returnfp
=False):
4238 catfp
= BytesIO(catstr
);
4239 listcatfiles
= ArchiveFileToArrayIndex(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
4240 return listcatfiles
;
4242 create_alias_function("", __file_format_name__
, "StringToArrayIndex", ArchiveFileStringToArrayIndex
);
4244 def TarFileToArrayIndex(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, usenewstyle
=True, returnfp
=False):
4246 catfp
= PackArchiveFileFromTarFile(infile
, catfp
, "auto", None, "crc32", [], formatspecs
, False, True);
4247 listcatfiles
= ArchiveFileToArrayIndex(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
4248 return listcatfiles
;
4250 def ZipFileToArrayIndex(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, usenewstyle
=True, returnfp
=False):
4252 catfp
= PackArchiveFileFromZipFile(infile
, catfp
, "auto", None, "crc32", [], formatspecs
, False, True);
4253 listcatfiles
= ArchiveFileToArrayIndex(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
4254 return listcatfiles
;
4256 if(not rarfile_support
):
4257 def RarFileToArrayIndex(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, returnfp
=False):
4260 if(rarfile_support
):
4261 def RarFileToArrayIndex(infile
, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, usenewstyle
=True, returnfp
=False):
4263 catfp
= PackArchiveFileFromRarFile(infile
, catfp
, "auto", None, "crc32", [], formatspecs
, False, True);
4264 listcatfiles
= ArchiveFileToArrayIndex(catfp
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
4265 return listcatfiles
;
4267 def ListDirToArrayIndex(infiles
, dirlistfromtxt
=False, compression
="auto", compressionlevel
=None, followlink
=False, seekstart
=0, seekend
=0, listonly
=False, skipchecksum
=False, checksumtype
="crc32", formatspecs
=__file_format_list__
, verbose
=False, usenewstyle
=True, returnfp
=False):
4268 outarray
= BytesIO();
4269 packcat
= PackArchiveFile(infiles
, outarray
, dirlistfromtxt
, compression
, compressionlevel
, followlink
, checksumtype
, formatspecs
, verbose
, True);
4270 listcatfiles
= ArchiveFileToArrayIndex(outarray
, seekstart
, seekend
, listonly
, skipchecksum
, formatspecs
, usenewstyle
, returnfp
)
4271 return listcatfiles
;
4273 def RePackArchiveFile(infile
, outfile
, compression
="auto", compressionlevel
=None, followlink
=False, seekstart
=0, seekend
=0, checksumtype
="crc32", skipchecksum
=False, extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, usenewstyle
=True, returnfp
=False):
4274 compressionlist
= ['auto', 'gzip', 'bzip2', 'zstd', 'lz4', 'lzo', 'lzop', 'lzma', 'xz'];
4275 outextlist
= ['gz', 'cgz', 'bz2', 'cbz', 'zst', 'czst', 'lz4', 'lzop', 'clz4', 'lzo', 'clzo', 'lzma', 'xz', 'cxz'];
4276 outextlistwd
= ['.gz', '.cgz', '.bz2', '.cbz', '.zst', '.czst', '.lz4', 'lzop', '.clz4', '.lzo', '.clzo', '.lzma', '.xz', '.cxz'];
4277 if(isinstance(infile
, dict)):
4278 prelistcatfiles
= ArchiveFileToArrayIndex(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
4279 listcatfiles
= prelistcatfiles
['list'];
4281 if(infile
!="-" and not hasattr(infile
, "read") and not hasattr(infile
, "write")):
4282 infile
= RemoveWindowsPath(infile
);
4284 prelistcatfiles
= ArchiveFileToArrayIndex(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
4285 listcatfiles
= prelistcatfiles
['list'];
4287 listcatfiles
= ArchiveFileToArray(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
4288 if(outfile
!="-" and not hasattr(infile
, "read") and not hasattr(outfile
, "write")):
4289 outfile
= RemoveWindowsPath(outfile
);
4290 checksumtype
= checksumtype
.lower();
4291 if(not CheckSumSupport(checksumtype
, hashlib_guaranteed
)):
4292 checksumtype
="crc32";
4293 if(checksumtype
=="none"):
4295 if(not compression
or compression
or compression
=="catfile" or compression
==formatspecs
[1]):
4297 if(compression
not in compressionlist
and compression
is None):
4298 compression
= "auto";
4300 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
4301 if(outfile
!="-" and not hasattr(outfile
, "read") and not hasattr(outfile
, "write")):
4302 if(os
.path
.exists(outfile
)):
4304 if(not listcatfiles
):
4309 elif(hasattr(outfile
, "read") or hasattr(outfile
, "write")):
4312 fbasename
= os
.path
.splitext(outfile
)[0];
4313 fextname
= os
.path
.splitext(outfile
)[1];
4314 catfp
= CompressOpenFile(outfile
, compressionlevel
);
4315 catver
= formatspecs
[5];
4316 fileheaderver
= str(int(catver
.replace(".", "")));
4317 fileheader
= AppendNullByte(formatspecs
[0] + fileheaderver
, formatspecs
[4]);
4318 catfp
.write(fileheader
.encode('UTF-8'));
4319 lenlist
= len(listcatfiles
['ffilelist']);
4320 fnumfiles
= int(listcatfiles
['fnumfiles']);
4321 if(lenlist
>fnumfiles
or lenlist
<fnumfiles
):
4322 fnumfiles
= lenlist
;
4323 fnumfileshex
= format(int(fnumfiles
), 'x').lower();
4324 fnumfilesa
= AppendNullBytes([fnumfileshex
, checksumtype
], formatspecs
[4]);
4325 if(checksumtype
=="none" or checksumtype
==""):
4326 catfileheadercshex
= format(0, 'x').lower();
4327 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
4328 catfileheadercshex
= format(crc16(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
4329 elif(checksumtype
=="crc16_ccitt"):
4330 catfileheadercshex
= format(crc16_ccitt(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffff, '04x').lower();
4331 elif(checksumtype
=="adler32"):
4332 catfileheadercshex
= format(zlib
.adler32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
4333 elif(checksumtype
=="crc32"):
4334 catfileheadercshex
= format(crc32(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffff, '08x').lower();
4335 elif(checksumtype
=="crc64_ecma"):
4336 catfileheadercshex
= format(crc64_ecma(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4337 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
4338 catfileheadercshex
= format(crc64_iso(str(fileheader
+ fnumfilesa
).encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4339 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
4340 checksumoutstr
= hashlib
.new(checksumtype
);
4341 checksumoutstr
.update(str(fileheader
+ fnumfilesa
).encode('UTF-8'));
4342 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
4344 catfileheadercshex
= format(0, 'x').lower();
4345 fnumfilesa
= fnumfilesa
+ AppendNullByte(catfileheadercshex
, formatspecs
[4]);
4346 catfp
.write(fnumfilesa
.encode('UTF-8'));
4349 os
.fsync(catfp
.fileno());
4350 except io
.UnsupportedOperation
:
4352 except AttributeError:
4358 if(seekend
>0 and seekend
<listcatfiles
['fnumfiles']):
4361 lcfx
= int(listcatfiles
['fnumfiles']);
4369 catfhstart
= catfp
.tell();
4370 if(re
.findall("^[.|/]", listcatfiles
['ffilelist'][reallcfi
]['fname'])):
4371 fname
= listcatfiles
['ffilelist'][reallcfi
]['fname'];
4373 fname
= "./"+listcatfiles
['ffilelist'][reallcfi
]['fname'];
4375 VerbosePrintOut(fname
);
4376 fheadersize
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fheadersize']), 'x').lower();
4377 fsize
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fsize']), 'x').lower();
4378 flinkname
= listcatfiles
['ffilelist'][reallcfi
]['flinkname'];
4379 fatime
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fatime']), 'x').lower();
4380 fmtime
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fmtime']), 'x').lower();
4381 fctime
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fctime']), 'x').lower();
4382 fbtime
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fbtime']), 'x').lower();
4383 fmode
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fmode']), 'x').lower();
4384 fchmode
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fchmode']), 'x').lower();
4385 fuid
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fuid']), 'x').lower();
4386 funame
= listcatfiles
['ffilelist'][reallcfi
]['funame'];
4387 fgid
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fgid']), 'x').lower();
4388 fgname
= listcatfiles
['ffilelist'][reallcfi
]['fgname'];
4389 finode
= listcatfiles
['ffilelist'][reallcfi
]['finode'];
4390 flinkcount
= listcatfiles
['ffilelist'][reallcfi
]['flinkcount'];
4391 fdev_minor
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fminor']), 'x').lower();
4392 fdev_major
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fmajor']), 'x').lower();
4393 frdev_minor
= format(int(listcatfiles
['ffilelist'][reallcfi
]['frminor']), 'x').lower();
4394 frdev_major
= format(int(listcatfiles
['ffilelist'][reallcfi
]['frmajor']), 'x').lower();
4395 if(len(listcatfiles
['ffilelist'][reallcfi
]['fextralist'])>listcatfiles
['ffilelist'][reallcfi
]['fextrafields'] and len(listcatfiles
['ffilelist'][reallcfi
]['fextralist'])>0):
4396 listcatfiles
['ffilelist'][reallcfi
]['fextrafields'] = len(listcatfiles
['ffilelist'][reallcfi
]['fextralist']);
4397 if(len(extradata
) > 0):
4398 listcatfiles
['ffilelist'][reallcfi
]['fextrafields'] = len(extradata
);
4399 listcatfiles
['ffilelist'][reallcfi
]['fextralist'] = extradata
;
4400 extrafields
= format(int(listcatfiles
['ffilelist'][reallcfi
]['fextrafields']), 'x').lower();
4401 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[4]);
4402 if(len(extradata
)>0):
4403 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[4]);
4404 extrasizelen
= format(len(extrasizestr
), 'x').lower();
4405 fcontents
= listcatfiles
['ffilelist'][reallcfi
]['fcontents'];
4407 if(listcatfiles
['ffilelist'][reallcfi
]['ftype']==1 or listcatfiles
['ffilelist'][reallcfi
]['ftype']==2):
4408 getflinkpath
= listcatfiles
['ffilelist'][reallcfi
]['flinkname'];
4409 flinkid
= prelistcatfiles
['filetoid'][getflinkpath
];
4410 flinkinfo
= listcatfiles
['ffilelist'][flinkid
];
4411 fheadersize
= format(int(flinkinfo
['fheadersize']), 'x').lower();
4412 fsize
= format(int(flinkinfo
['fsize']), 'x').lower();
4413 flinkname
= flinkinfo
['flinkname'];
4414 fatime
= format(int(flinkinfo
['fatime']), 'x').lower();
4415 fmtime
= format(int(flinkinfo
['fmtime']), 'x').lower();
4416 fctime
= format(int(flinkinfo
['fctime']), 'x').lower();
4417 fbtime
= format(int(flinkinfo
['fbtime']), 'x').lower();
4418 fmode
= format(int(flinkinfo
['fmode']), 'x').lower();
4419 fchmode
= format(int(flinkinfo
['fchmode']), 'x').lower();
4420 fuid
= format(int(flinkinfo
['fuid']), 'x').lower();
4421 funame
= flinkinfo
['funame'];
4422 fgid
= format(int(flinkinfo
['fgid']), 'x').lower();
4423 fgname
= flinkinfo
['fgname'];
4424 finode
= flinkinfo
['finode'];
4425 flinkcount
= flinkinfo
['flinkcount'];
4426 fdev_minor
= format(int(flinkinfo
['fminor']), 'x').lower();
4427 fdev_major
= format(int(flinkinfo
['fmajor']), 'x').lower();
4428 frdev_minor
= format(int(flinkinfo
['frminor']), 'x').lower();
4429 frdev_major
= format(int(flinkinfo
['frmajor']), 'x').lower();
4430 if(len(flinkinfo
['fextralist'])>flinkinfo
['fextrafields'] and len(flinkinfo
['fextralist'])>0):
4431 flinkinfo
['fextrafields'] = len(flinkinfo
['fextralist']);
4432 if(len(extradata
) > 0):
4433 flinkinfo
['fextrafields'] = len(extradata
);
4434 flinkinfo
['fextralist'] = extradata
;
4435 extrafields
= format(int(flinkinfo
['fextrafields']), 'x').lower();
4436 extrasizestr
= AppendNullByte(extrafields
, formatspecs
[4]);
4437 if(len(extradata
)>0):
4438 extrasizestr
= extrasizestr
+ AppendNullBytes(extradata
, formatspecs
[4]);
4439 extrasizelen
= format(len(extrasizestr
), 'x').lower();
4440 fcontents
= flinkinfo
['fcontents'];
4441 if(flinkinfo
['ftype']!=0 and flinkinfo
['ftype']!=7):
4443 fcontents
= fcontents
.encode('UTF-8');
4444 except AttributeError:
4446 ftypehex
= format(flinkinfo
['ftype'], 'x').lower();
4448 if(listcatfiles
['ffilelist'][reallcfi
]['ftype']!=0 and listcatfiles
['ffilelist'][reallcfi
]['ftype']!=7):
4450 fcontents
= fcontents
.encode('UTF-8');
4451 except AttributeError:
4453 ftypehex
= format(listcatfiles
['ffilelist'][reallcfi
]['ftype'], 'x').lower();
4454 fcurfid
= format(curfid
, 'x').lower();
4455 if(not followlink
and finode
!=0):
4456 if(listcatfiles
['ffilelist'][reallcfi
]['ftype']!=1):
4457 fcurinode
= format(int(curinode
), 'x').lower();
4458 inodetofile
.update({curinode
: fname
});
4459 filetoinode
.update({fname
: curinode
});
4460 curinode
= curinode
+ 1;
4462 fcurinode
= format(int(filetoinode
[flinkname
]), 'x').lower();
4464 fcurinode
= format(int(curinode
), 'x').lower();
4465 curinode
= curinode
+ 1;
4466 curfid
= curfid
+ 1;
4467 catfileoutstr
= AppendNullBytes([ftypehex
, fname
, flinkname
, fsize
, fatime
, fmtime
, fctime
, fbtime
, fmode
, fuid
, funame
, fgid
, fgname
, fcurfid
, fcurinode
, flinkcount
, fdev_minor
, fdev_major
, frdev_minor
, frdev_major
, extrasizelen
, extrafields
], formatspecs
[4]);
4468 if(listcatfiles
['ffilelist'][reallcfi
]['fextrafields']>0):
4469 extrafieldslist
= [];
4471 exil
= listcatfiles
['ffilelist'][reallcfi
]['fextrafields'];
4473 extrafieldslist
.append(listcatfiles
['ffilelist'][reallcfi
]['fextralist']);
4475 catfileoutstr
+= AppendNullBytes([extrafieldslist
], formatspecs
[4]);
4476 catfileoutstr
+= AppendNullBytes([checksumtype
], formatspecs
[4]);
4477 catfhend
= (catfp
.tell() - 1) + len(catfileoutstr
);
4478 catfcontentstart
= catfp
.tell() + len(catfileoutstr
);
4479 if(checksumtype
=="none" or checksumtype
==""):
4480 catfileheadercshex
= format(0, 'x').lower();
4481 catfilecontentcshex
= format(0, 'x').lower();
4482 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
4483 catfileheadercshex
= format(crc16("".encode('UTF-8')) & 0xffff, '04x').lower();
4484 catfilecontentcshex
= format(crc16(fcontents
) & 0xffff, '04x').lower();
4485 elif(checksumtype
=="crc16_ccitt"):
4486 catfileheadercshex
= format(crc16_ccitt("".encode('UTF-8')) & 0xffff, '04x').lower();
4487 catfilecontentcshex
= format(crc16_ccitt(fcontents
) & 0xffff, '04x').lower();
4488 elif(checksumtype
=="adler32"):
4489 catfileheadercshex
= format(zlib
.adler32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
4490 catfilecontentcshex
= format(zlib
.adler32(fcontents
) & 0xffffffff, '08x').lower();
4491 elif(checksumtype
=="crc32"):
4492 catfileheadercshex
= format(crc32("".encode('UTF-8')) & 0xffffffff, '08x').lower();
4493 catfilecontentcshex
= format(crc32(fcontents
) & 0xffffffff, '08x').lower();
4494 elif(checksumtype
=="crc64_ecma"):
4495 catfileheadercshex
= format(crc64_ecma("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4496 catfilecontentcshex
= format(crc64_ecma(fcontents
) & 0xffffffffffffffff, '016x').lower();
4497 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
4498 catfileheadercshex
= format(crc64_iso("".encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4499 catfilecontentcshex
= format(crc64_iso(fcontents
) & 0xffffffffffffffff, '016x').lower();
4500 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
4501 checksumoutstr
= hashlib
.new(checksumtype
);
4502 checksumoutstr
.update("".encode('UTF-8'));
4503 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
4504 checksumoutstr
= hashlib
.new(checksumtype
);
4505 checksumoutstr
.update(fcontents
);
4506 catfilecontentcshex
= checksumoutstr
.hexdigest().lower();
4508 catfileheadercshex
= format(0, 'x').lower();
4509 catfilecontentcshex
= format(0, 'x').lower();
4510 tmpfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4]);
4511 catheaersize
= format(int(len(tmpfileoutstr
) - 1), 'x').lower()
4512 catfileoutstr
= AppendNullByte(catheaersize
, formatspecs
[4]) + catfileoutstr
;
4513 if(checksumtype
=="none" or checksumtype
==""):
4514 catfileheadercshex
= format(0, 'x').lower();
4515 elif(checksumtype
=="crc16" or checksumtype
=="crc16_ansi" or checksumtype
=="crc16_ibm"):
4516 catfileheadercshex
= format(crc16(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
4517 elif(checksumtype
=="crc16_ccitt"):
4518 catfileheadercshex
= format(crc16_ccitt(catfileoutstr
.encode('UTF-8')) & 0xffff, '04x').lower();
4519 elif(checksumtype
=="adler32"):
4520 catfileheadercshex
= format(zlib
.adler32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
4521 elif(checksumtype
=="crc32"):
4522 catfileheadercshex
= format(crc32(catfileoutstr
.encode('UTF-8')) & 0xffffffff, '08x').lower();
4523 elif(checksumtype
=="crc64_ecma"):
4524 catfileheadercshex
= format(crc64_ecma(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4525 elif(checksumtype
=="crc64" or checksumtype
=="crc64_iso"):
4526 catfileheadercshex
= format(crc64_iso(catfileoutstr
.encode('UTF-8')) & 0xffffffffffffffff, '016x').lower();
4527 elif(CheckSumSupportAlt(checksumtype
, hashlib_guaranteed
)):
4528 checksumoutstr
= hashlib
.new(checksumtype
);
4529 checksumoutstr
.update(catfileoutstr
.encode('UTF-8'));
4530 catfileheadercshex
= checksumoutstr
.hexdigest().lower();
4532 catfileheadercshex
= format(0, 'x').lower();
4533 catfileoutstr
= catfileoutstr
+ AppendNullBytes([catfileheadercshex
, catfilecontentcshex
], formatspecs
[4]);
4534 catfileoutstrecd
= catfileoutstr
.encode('UTF-8');
4535 nullstrecd
= formatspecs
[4].encode('UTF-8');
4536 catfileout
= catfileoutstrecd
+ fcontents
+ nullstrecd
;
4537 catfcontentend
= (catfp
.tell() - 1) + len(catfileout
);
4538 catfp
.write(catfileout
);
4541 os
.fsync(catfp
.fileno());
4542 except io
.UnsupportedOperation
:
4544 except AttributeError:
4547 reallcfi
= reallcfi
+ 1;
4548 if(outfile
=="-" or hasattr(outfile
, "read") or hasattr(outfile
, "write")):
4549 catfp
= CompressArchiveFile(catfp
, compression
, formatspecs
);
4552 os
.fsync(catfp
.fileno());
4553 except io
.UnsupportedOperation
:
4555 except AttributeError:
4559 if(hasattr(sys
.stdout
, "buffer")):
4560 shutil
.copyfileobj(catfp
, sys
.stdout
.buffer);
4562 shutil
.copyfileobj(catfp
, sys
.stdout
);
4570 create_alias_function("RePack", __file_format_name__
, "", RePackArchiveFile
);
4572 def RePackArchiveFileFromString(catstr
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", skipchecksum
=False, extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
4573 catfp
= BytesIO(catstr
);
4574 listcatfiles
= RePackArchiveFile(catfp
, compression
, compressionlevel
, checksumtype
, skipchecksum
, extradata
, formatspecs
, verbose
, returnfp
);
4575 return listcatfiles
;
4577 create_alias_function("RePack", __file_format_name__
, "FromString", RePackArchiveFileFromString
);
4579 def PackArchiveFileFromListDir(infiles
, outfile
, dirlistfromtxt
=False, compression
="auto", compressionlevel
=None, followlink
=False, skipchecksum
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
4580 outarray
= BytesIO();
4581 packcat
= PackArchiveFile(infiles
, outarray
, dirlistfromtxt
, compression
, compressionlevel
, followlink
, checksumtype
, extradata
, formatspecs
, verbose
, True);
4582 listcatfiles
= RePackArchiveFile(outarray
, outfile
, compression
, compressionlevel
, checksumtype
, skipchecksum
, extradata
, formatspecs
, verbose
, returnfp
);
4583 return listcatfiles
;
4585 create_alias_function("Pack", __file_format_name__
, "FromListDir", PackArchiveFileFromListDir
);
4587 def ArchiveFileArrayBase64Encode(infile
, followlink
=False, seekstart
=0, seekend
=0, skipchecksum
=False, formatspecs
=__file_format_list__
, verbose
=False, usenewstyle
=True, returnfp
=False):
4589 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
4590 if(isinstance(infile
, dict)):
4591 prelistcatfiles
= ArchiveFileToArrayIndex(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
4592 listcatfiles
= prelistcatfiles
['list'];
4594 if(infile
!="-" and not hasattr(infile
, "read") and not hasattr(infile
, "write")):
4595 infile
= RemoveWindowsPath(infile
);
4597 prelistcatfiles
= ArchiveFileToArrayIndex(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
4598 listcatfiles
= prelistcatfiles
['list'];
4600 listcatfiles
= ArchiveFileToArray(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
4601 if(not listcatfiles
):
4603 lenlist
= len(listcatfiles
['ffilelist']);
4608 if(seekend
>0 and seekend
<listcatfiles
['fnumfiles']):
4611 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
4612 lcfx
= listcatfiles
['fnumfiles'];
4614 lcfx
= int(listcatfiles
['fnumfiles']);
4615 if(lenlist
>lcfx
or lenlist
<lcfx
):
4618 if(listcatfiles
['ffilelist'][lcfi
]['fhascontents']):
4619 listcatfiles
['ffilelist'][lcfi
]['fcontents'] = base64
.b64encode(listcatfiles
['ffilelist'][lcfi
]['fcontents']).decode("UTF-8");
4621 return listcatfiles
;
4623 create_alias_function("", __file_format_name__
, "ArrayBase64Encode", ArchiveFileArrayBase64Encode
);
4625 def ArchiveFileArrayBase64Decode(infile
, followlink
=False, seekstart
=0, seekend
=0, skipchecksum
=False, formatspecs
=__file_format_list__
, verbose
=False, usenewstyle
=True, returnfp
=False):
4627 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
4628 if(isinstance(infile
, dict)):
4629 prelistcatfiles
= ArchiveFileToArrayIndex(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
4630 listcatfiles
= prelistcatfiles
['list'];
4632 if(infile
!="-" and not hasattr(infile
, "read") and not hasattr(infile
, "write")):
4633 infile
= RemoveWindowsPath(infile
);
4635 prelistcatfiles
= ArchiveFileToArrayIndex(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
4636 listcatfiles
= prelistcatfiles
['list'];
4638 listcatfiles
= ArchiveFileToArray(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
4639 if(not listcatfiles
):
4641 lenlist
= len(listcatfiles
['ffilelist']);
4646 if(seekend
>0 and seekend
<listcatfiles
['fnumfiles']):
4649 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
4650 lcfx
= listcatfiles
['fnumfiles'];
4652 lcfx
= int(listcatfiles
['fnumfiles']);
4653 if(lenlist
>lcfx
or lenlist
<lcfx
):
4656 if(listcatfiles
['ffilelist'][lcfi
]['fhascontents']):
4657 listcatfiles
['ffilelist'][lcfi
]['fcontents'] = base64
.b64decode(listcatfiles
['ffilelist'][lcfi
]['fcontents'].encode("UTF-8"));
4659 return listcatfiles
;
4661 create_alias_function("", __file_format_name__
, "ArrayBase64Decode", ArchiveFileArrayBase64Decode
);
4663 def UnPackArchiveFile(infile
, outdir
=None, followlink
=False, seekstart
=0, seekend
=0, skipchecksum
=False, formatspecs
=__file_format_list__
, verbose
=False, usenewstyle
=True, returnfp
=False):
4664 if(outdir
is not None):
4665 outdir
= RemoveWindowsPath(outdir
);
4667 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
4668 if(isinstance(infile
, dict)):
4669 prelistcatfiles
= ArchiveFileToArrayIndex(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
4670 listcatfiles
= prelistcatfiles
['list'];
4672 if(infile
!="-" and not hasattr(infile
, "read") and not hasattr(infile
, "write")):
4673 infile
= RemoveWindowsPath(infile
);
4675 prelistcatfiles
= ArchiveFileToArrayIndex(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
4676 listcatfiles
= prelistcatfiles
['list'];
4678 listcatfiles
= ArchiveFileToArray(infile
, seekstart
, seekend
, False, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
4679 if(not listcatfiles
):
4681 lenlist
= len(listcatfiles
['ffilelist']);
4686 if(seekend
>0 and seekend
<listcatfiles
['fnumfiles']):
4689 if(lenlist
>listcatfiles
['fnumfiles'] or lenlist
<listcatfiles
['fnumfiles']):
4690 lcfx
= listcatfiles
['fnumfiles'];
4692 lcfx
= int(listcatfiles
['fnumfiles']);
4693 if(lenlist
>lcfx
or lenlist
<lcfx
):
4700 userinfo
= pwd
.getpwuid(listcatfiles
['ffilelist'][lcfi
]['fuid']);
4701 funame
= userinfo
.pw_name
;
4710 groupinfo
= grp
.getgrgid(listcatfiles
['ffilelist'][lcfi
]['fgid']);
4711 fgname
= groupinfo
.gr_name
;
4717 VerbosePrintOut(listcatfiles
['ffilelist'][lcfi
]['fname']);
4718 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==0 or listcatfiles
['ffilelist'][lcfi
]['ftype']==7):
4719 fpc
= open(listcatfiles
['ffilelist'][lcfi
]['fname'], "wb");
4720 fpc
.write(listcatfiles
['ffilelist'][lcfi
]['fcontents']);
4723 os
.fsync(fpc
.fileno());
4724 except io
.UnsupportedOperation
:
4726 except AttributeError:
4729 if(hasattr(os
, "chown") and funame
==listcatfiles
['ffilelist'][lcfi
]['funame'] and fgname
==listcatfiles
['ffilelist'][lcfi
]['fgname']):
4730 os
.chown(listcatfiles
['ffilelist'][lcfi
]['fname'], listcatfiles
['ffilelist'][lcfi
]['fuid'], listcatfiles
['ffilelist'][lcfi
]['fgid']);
4731 os
.chmod(listcatfiles
['ffilelist'][lcfi
]['fname'], int(listcatfiles
['ffilelist'][lcfi
]['fchmode'], 8));
4732 os
.utime(listcatfiles
['ffilelist'][lcfi
]['fname'], (listcatfiles
['ffilelist'][lcfi
]['fatime'], listcatfiles
['ffilelist'][lcfi
]['fmtime']));
4733 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==1):
4735 getflinkpath
= listcatfiles
['ffilelist'][lcfi
]['flinkname'];
4736 flinkid
= prelistcatfiles
['filetoid'][getflinkpath
];
4737 flinkinfo
= listcatfiles
['ffilelist'][flinkid
];
4742 userinfo
= pwd
.getpwuid(flinkinfo
['fuid']);
4743 funame
= userinfo
.pw_name
;
4752 groupinfo
= grp
.getgrgid(flinkinfo
['fgid']);
4753 fgname
= groupinfo
.gr_name
;
4758 if(flinkinfo
['ftype'] == 0 or flinkinfo
['ftype'] == 7):
4759 with(open(listcatfiles
['ffilelist'][lcfi
]['fname'], "wb") as fpc
):
4760 fcontents
= flinkinfo
['fcontents'];
4763 while(offset
< len(fcontents
)):
4764 chunk
= fcontents
[offset
:offset
+ chunk_size
];
4768 os
.fsync(fpc
.fileno());
4769 except (io
.UnsupportedOperation
, AttributeError):
4771 offset
+= len(chunk
);
4772 if(hasattr(os
, "chown") and funame
==flinkinfo
['funame'] and fgname
==flinkinfo
['fgname']):
4773 os
.chown(listcatfiles
['ffilelist'][lcfi
]['fname'], flinkinfo
['fuid'], flinkinfo
['fgid']);
4774 os
.chmod(listcatfiles
['ffilelist'][lcfi
]['fname'], int(flinkinfo
['fchmode'], 8));
4775 os
.utime(listcatfiles
['ffilelist'][lcfi
]['fname'], (flinkinfo
['fatime'], flinkinfo
['fmtime']));
4776 if(flinkinfo
['ftype']==1):
4777 os
.link(flinkinfo
['flinkname'], listcatfiles
['ffilelist'][lcfi
]['fname']);
4778 if(flinkinfo
['ftype']==2):
4779 os
.symlink(flinkinfo
['flinkname'], listcatfiles
['ffilelist'][lcfi
]['fname']);
4780 if(flinkinfo
['ftype']==5):
4781 os
.mkdir(listcatfiles
['ffilelist'][lcfi
]['fname'], int(flinkinfo
['fchmode'], 8));
4782 if(hasattr(os
, "chown") and funame
==flinkinfo
['funame'] and fgname
==flinkinfo
['fgname']):
4783 os
.chown(listcatfiles
['ffilelist'][lcfi
]['fname'], flinkinfo
['fuid'], flinkinfo
['fgid']);
4784 os
.chmod(listcatfiles
['ffilelist'][lcfi
]['fname'], int(flinkinfo
['fchmode'], 8));
4785 os
.utime(listcatfiles
['ffilelist'][lcfi
]['fname'], (flinkinfo
['fatime'], flinkinfo
['fmtime']));
4786 if(flinkinfo
['ftype']==6 and hasattr(os
, "mkfifo")):
4787 os
.mkfifo(listcatfiles
['ffilelist'][lcfi
]['fname'], int(flinkinfo
['fchmode'], 8));
4789 os
.link(listcatfiles
['ffilelist'][lcfi
]['flinkname'], listcatfiles
['ffilelist'][lcfi
]['fname']);
4790 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==2):
4792 getflinkpath
= listcatfiles
['ffilelist'][lcfi
]['flinkname'];
4793 flinkid
= prelistcatfiles
['filetoid'][getflinkpath
];
4794 flinkinfo
= listcatfiles
['ffilelist'][flinkid
];
4799 userinfo
= pwd
.getpwuid(flinkinfo
['fuid']);
4800 funame
= userinfo
.pw_name
;
4809 groupinfo
= grp
.getgrgid(flinkinfo
['fgid']);
4810 fgname
= groupinfo
.gr_name
;
4815 if(flinkinfo
['ftype']==0 or flinkinfo
['ftype']==7):
4816 fpc
= open(listcatfiles
['ffilelist'][lcfi
]['fname'], "wb");
4817 fpc
.write(flinkinfo
['fcontents']);
4819 if(hasattr(os
, "chown") and funame
==flinkinfo
['funame'] and fgname
==flinkinfo
['fgname']):
4820 os
.chown(listcatfiles
['ffilelist'][lcfi
]['fname'], flinkinfo
['fuid'], flinkinfo
['fgid']);
4821 os
.chmod(listcatfiles
['ffilelist'][lcfi
]['fname'], int(flinkinfo
['fchmode'], 8));
4822 os
.utime(listcatfiles
['ffilelist'][lcfi
]['fname'], (flinkinfo
['fatime'], flinkinfo
['fmtime']));
4823 if(flinkinfo
['ftype']==1):
4824 os
.link(flinkinfo
['flinkname'], listcatfiles
['ffilelist'][lcfi
]['fname']);
4825 if(flinkinfo
['ftype']==2):
4826 os
.symlink(flinkinfo
['flinkname'], listcatfiles
['ffilelist'][lcfi
]['fname']);
4827 if(flinkinfo
['ftype']==5):
4828 os
.mkdir(listcatfiles
['ffilelist'][lcfi
]['fname'], int(flinkinfo
['fchmode'], 8));
4829 if(hasattr(os
, "chown") and funame
==flinkinfo
['funame'] and fgname
==flinkinfo
['fgname']):
4830 os
.chown(listcatfiles
['ffilelist'][lcfi
]['fname'], flinkinfo
['fuid'], flinkinfo
['fgid']);
4831 os
.chmod(listcatfiles
['ffilelist'][lcfi
]['fname'], int(flinkinfo
['fchmode'], 8));
4832 os
.utime(listcatfiles
['ffilelist'][lcfi
]['fname'], (flinkinfo
['fatime'], flinkinfo
['fmtime']));
4833 if(flinkinfo
['ftype']==6 and hasattr(os
, "mkfifo")):
4834 os
.mkfifo(listcatfiles
['ffilelist'][lcfi
]['fname'], int(flinkinfo
['fchmode'], 8));
4836 os
.symlink(listcatfiles
['ffilelist'][lcfi
]['flinkname'], listcatfiles
['ffilelist'][lcfi
]['fname']);
4837 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==5):
4838 os
.mkdir(listcatfiles
['ffilelist'][lcfi
]['fname'], int(listcatfiles
['ffilelist'][lcfi
]['fchmode'], 8));
4839 if(hasattr(os
, "chown") and funame
==listcatfiles
['ffilelist'][lcfi
]['funame'] and fgname
==listcatfiles
['ffilelist'][lcfi
]['fgname']):
4840 os
.chown(listcatfiles
['ffilelist'][lcfi
]['fname'], listcatfiles
['ffilelist'][lcfi
]['fuid'], listcatfiles
['ffilelist'][lcfi
]['fgid']);
4841 os
.chmod(listcatfiles
['ffilelist'][lcfi
]['fname'], int(listcatfiles
['ffilelist'][lcfi
]['fchmode'], 8));
4842 os
.utime(listcatfiles
['ffilelist'][lcfi
]['fname'], (listcatfiles
['ffilelist'][lcfi
]['fatime'], listcatfiles
['ffilelist'][lcfi
]['fmtime']));
4843 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==6 and hasattr(os
, "mkfifo")):
4844 os
.mkfifo(listcatfiles
['ffilelist'][lcfi
]['fname'], int(listcatfiles
['ffilelist'][lcfi
]['fchmode'], 8));
4847 return listcatfiles
['ffilelist']['catfp'];
4851 create_alias_function("UnPack", __file_format_name__
, "", UnPackArchiveFile
);
4853 if(hasattr(shutil
, "register_unpack_format")):
4854 def UnPackArchiveFileFunc(archive_name
, extract_dir
=None, **kwargs
):
4855 return UnPackArchiveFile(archive_name
, extract_dir
, False, 0, 0, False, __file_format_delimiter__
, False, False);
4856 create_alias_function("UnPack", __file_format_name__
, "Func", UnPackArchiveFileFunc
);
4858 def UnPackArchiveFileString(catstr
, outdir
=None, followlink
=False, seekstart
=0, seekend
=0, skipchecksum
=False, formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
4859 catfp
= BytesIO(catstr
);
4860 listcatfiles
= UnPackArchiveFile(catfp
, outdir
, followlink
, seekstart
, seekend
, skipchecksum
, formatspecs
, verbose
, returnfp
);
4861 return listcatfiles
;
4863 create_alias_function("UnPack", __file_format_name__
, "String", UnPackArchiveFileString
);
4865 def ArchiveFileListFiles(infile
, seekstart
=0, seekend
=0, skipchecksum
=False, formatspecs
=__file_format_list__
, verbose
=False, usenewstyle
=True, returnfp
=False):
4866 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
4867 if(isinstance(infile
, dict)):
4868 listcatfiles
= infile
;
4870 if(infile
!="-" and not hasattr(infile
, "read") and not hasattr(infile
, "write")):
4871 infile
= RemoveWindowsPath(infile
);
4872 listcatfiles
= ArchiveFileToArray(infile
, seekstart
, seekend
, True, skipchecksum
, formatspecs
, usenewstyle
, returnfp
);
4873 if(not listcatfiles
):
4875 lenlist
= len(listcatfiles
['ffilelist']);
4880 returnval
.update({lcfi
: listcatfiles
['ffilelist'][lcfi
]['fname']});
4882 VerbosePrintOut(listcatfiles
['ffilelist'][lcfi
]['fname']);
4884 permissions
= { 'access': { '0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': ('r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx') }, 'roles': { 0: 'owner', 1: 'group', 2: 'other' } };
4885 printfname
= listcatfiles
['ffilelist'][lcfi
]['fname'];
4886 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==1):
4887 printfname
= listcatfiles
['ffilelist'][lcfi
]['fname'] + " link to " + listcatfiles
['ffilelist'][lcfi
]['flinkname'];
4888 if(listcatfiles
['ffilelist'][lcfi
]['ftype']==2):
4889 printfname
= listcatfiles
['ffilelist'][lcfi
]['fname'] + " -> " + listcatfiles
['ffilelist'][lcfi
]['flinkname'];
4890 fuprint
= listcatfiles
['ffilelist'][lcfi
]['funame'];
4891 if(len(fuprint
)<=0):
4892 fuprint
= listcatfiles
['ffilelist'][lcfi
]['fuid'];
4893 fgprint
= listcatfiles
['ffilelist'][lcfi
]['fgname'];
4894 if(len(fgprint
)<=0):
4895 fgprint
= listcatfiles
['ffilelist'][lcfi
]['fgid'];
4896 VerbosePrintOut(PrintPermissionString(listcatfiles
['ffilelist'][lcfi
]['fmode'], listcatfiles
['ffilelist'][lcfi
]['ftype']) + " " + str(str(fuprint
) + "/" + str(fgprint
) + " " + str(listcatfiles
['ffilelist'][lcfi
]['fsize']).rjust(15) + " " + datetime
.datetime
.utcfromtimestamp(listcatfiles
['ffilelist'][lcfi
]['fmtime']).strftime('%Y-%m-%d %H:%M') + " " + printfname
));
4899 return listcatfiles
['catfp'];
4903 create_alias_function("", __file_format_name__
, "ListFiles", ArchiveFileListFiles
);
4905 def ArchiveFileStringListFiles(catstr
, followlink
=False, skipchecksum
=False, formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
4906 catfp
= BytesIO(catstr
);
4907 listcatfiles
= UnPackArchiveFile(catfp
, None, followlink
, skipchecksum
, formatspecs
, verbose
, returnfp
);
4908 return listcatfiles
;
4910 create_alias_function("", __file_format_name__
, "StringListFiles", ArchiveFileListFiles
);
4912 def TarFileListFiles(infile
, verbose
=False, returnfp
=False):
4913 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
4914 if(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
4917 if(not tarfile
.is_tarfile(infile
)):
4919 except AttributeError:
4920 if(not is_tarfile(infile
)):
4924 tarfp
= tarfile
.open(infile
, "r");
4925 for member
in sorted(tarfp
.getmembers(), key
=lambda x
: x
.name
):
4926 returnval
.update({lcfi
: member
.name
});
4927 fpremode
= member
.mode
;
4928 ffullmode
= member
.mode
;
4932 ffullmode
= member
.mode
+ stat
.S_IFREG
;
4934 elif(member
.isdev()):
4935 ffullmode
= member
.mode
;
4937 elif(member
.islnk()):
4938 ffullmode
= member
.mode
+ stat
.S_IFREG
;
4940 elif(member
.issym()):
4941 ffullmode
= member
.mode
+ stat
.S_IFLNK
;
4943 elif(member
.ischr()):
4944 ffullmode
= member
.mode
+ stat
.S_IFCHR
;
4946 elif(member
.isblk()):
4947 ffullmode
= member
.mode
+ stat
.S_IFBLK
;
4949 elif(member
.isdir()):
4950 ffullmode
= member
.mode
+ stat
.S_IFDIR
;
4952 elif(member
.isfifo()):
4953 ffullmode
= member
.mode
+ stat
.S_IFIFO
;
4955 elif(member
.issparse()):
4956 ffullmode
= member
.mode
;
4959 VerbosePrintOut(member
.name
);
4961 permissions
= { 'access': { '0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': ('r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx') }, 'roles': { 0: 'owner', 1: 'group', 2: 'other' } };
4962 printfname
= member
.name
;
4964 printfname
= member
.name
+ " link to " + member
.linkname
;
4965 elif(member
.issym()):
4966 printfname
= member
.name
+ " -> " + member
.linkname
;
4967 fuprint
= member
.uname
;
4968 if(len(fuprint
)<=0):
4969 fuprint
= member
.uid
;
4970 fgprint
= member
.gname
;
4971 if(len(fgprint
)<=0):
4972 fgprint
= member
.gid
;
4973 VerbosePrintOut(PrintPermissionString(ffullmode
, ftype
) + " " + str(str(fuprint
) + "/" + str(fgprint
) + " " + str(member
.size
).rjust(15) + " " + datetime
.datetime
.utcfromtimestamp(member
.mtime
).strftime('%Y-%m-%d %H:%M') + " " + printfname
));
4976 return listcatfiles
['catfp'];
4980 def ZipFileListFiles(infile
, verbose
=False, returnfp
=False):
4981 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
4982 if(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
4984 if(not zipfile
.is_zipfile(infile
)):
4988 zipfp
= zipfile
.ZipFile(infile
, "r", allowZip64
=True);
4989 ziptest
= zipfp
.testzip();
4991 VerbosePrintOut("Bad file found!");
4992 for member
in sorted(zipfp
.infolist(), key
=lambda x
: x
.filename
):
4993 if(not member
.is_dir()):
4994 fpremode
= int(stat
.S_IFREG
+ 438);
4995 elif(member
.is_dir()):
4996 fpremode
= int(stat
.S_IFDIR
+ 511);
4997 if(not member
.is_dir()):
4998 fmode
= int(stat
.S_IFREG
+ 438);
4999 fchmode
= int(stat
.S_IMODE(int(stat
.S_IFREG
+ 438)));
5000 ftypemod
= int(stat
.S_IFMT(int(stat
.S_IFREG
+ 438)));
5001 elif(member
.is_dir()):
5002 fmode
= int(stat
.S_IFDIR
+ 511);
5003 fchmode
= int(stat
.S_IMODE(int(stat
.S_IFDIR
+ 511)));
5004 ftypemod
= int(stat
.S_IFMT(int(stat
.S_IFDIR
+ 511)));
5005 returnval
.update({lcfi
: member
.filename
});
5007 VerbosePrintOut(member
.filename
);
5009 permissions
= { 'access': { '0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': ('r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx') }, 'roles': { 0: 'owner', 1: 'group', 2: 'other' } };
5011 for fmodval
in str(oct(fmode
))[-3:]:
5012 permissionstr
= permissionstr
+ permissions
['access'].get(fmodval
, '---');
5013 if(not member
.is_dir()):
5015 permissionstr
= "-" + permissionstr
;
5016 elif(member
.is_dir()):
5018 permissionstr
= "d" + permissionstr
;
5019 printfname
= member
.filename
;
5021 fuid
= int(os
.getuid());
5022 except AttributeError:
5027 fgid
= int(os
.getgid());
5028 except AttributeError:
5035 userinfo
= pwd
.getpwuid(os
.getuid());
5036 funame
= userinfo
.pw_name
;
5039 except AttributeError:
5047 groupinfo
= grp
.getgrgid(os
.getgid());
5048 fgname
= groupinfo
.gr_name
;
5051 except AttributeError:
5056 if(len(fuprint
)<=0):
5057 fuprint
= str(fuid
);
5059 if(len(fgprint
)<=0):
5060 fgprint
= str(fgid
);
5061 VerbosePrintOut(PrintPermissionString(fmode
, ftype
) + " " + str(str(fuprint
) + "/" + str(fgprint
) + " " + str(member
.file_size
).rjust(15) + " " + datetime
.datetime
.utcfromtimestamp(int(time
.mktime(member
.date_time
+ (0, 0, -1)))).strftime('%Y-%m-%d %H:%M') + " " + printfname
));
5064 return listcatfiles
['catfp'];
5068 if(not rarfile_support
):
5069 def RarFileListFiles(infile
, verbose
=False, returnfp
=False):
5070 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
5071 if(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
5074 if(rarfile_support
):
5075 def RarFileListFiles(infile
, verbose
=False, returnfp
=False):
5076 logging
.basicConfig(format
="%(message)s", stream
=sys
.stdout
, level
=logging
.DEBUG
);
5077 if(not os
.path
.exists(infile
) or not os
.path
.isfile(infile
)):
5079 if(not rarfile
.is_rarfile(infile
) and not rarfile
.is_rarfile_sfx(infile
)):
5083 rarfp
= rarfile
.RarFile(infile
, "r");
5084 rartest
= rarfp
.testrar();
5086 VerbosePrintOut("Bad file found!");
5087 for member
in sorted(rarfp
.infolist(), key
=lambda x
: x
.filename
):
5090 if(member
.host_os
== rarfile
.RAR_OS_UNIX
):
5093 member
.external_attr
5095 except AttributeError:
5097 elif(member
.host_os
== rarfile
.RAR_OS_WIN32
):
5100 member
.external_attr
5102 except AttributeError:
5107 if(is_unix
and member
.external_attr
!=0):
5108 fpremode
= int(member
.external_attr
);
5109 elif(member
.is_file()):
5110 fpremode
= int(stat
.S_IFREG
+ 438);
5111 elif(member
.is_symlink()):
5112 fpremode
= int(stat
.S_IFLNK
+ 438);
5113 elif(member
.is_dir()):
5114 fpremode
= int(stat
.S_IFDIR
+ 511);
5115 if(is_windows
and member
.external_attr
!=0):
5116 fwinattributes
= int(member
.external_attr
);
5118 fwinattributes
= int(0);
5119 if(is_unix
and member
.external_attr
!=0):
5120 fmode
= int(member
.external_attr
);
5121 fchmode
= int(stat
.S_IMODE(member
.external_attr
));
5122 ftypemod
= int(stat
.S_IFMT(member
.external_attr
));
5123 elif(member
.is_file()):
5124 fmode
= int(stat
.S_IFREG
+ 438);
5125 fchmode
= int(stat
.S_IMODE(int(stat
.S_IFREG
+ 438)));
5126 ftypemod
= int(stat
.S_IFMT(int(stat
.S_IFREG
+ 438)));
5127 elif(member
.is_symlink()):
5128 fmode
= int(stat
.S_IFLNK
+ 438);
5129 fchmode
= int(stat
.S_IMODE(int(stat
.S_IFLNK
+ 438)));
5130 ftypemod
= int(stat
.S_IFMT(int(stat
.S_IFLNK
+ 438)));
5131 elif(member
.is_dir()):
5132 fmode
= int(stat
.S_IFDIR
+ 511);
5133 fchmode
= int(stat
.S_IMODE(int(stat
.S_IFDIR
+ 511)));
5134 ftypemod
= int(stat
.S_IFMT(int(stat
.S_IFDIR
+ 511)));
5135 returnval
.update({lcfi
: member
.filename
});
5137 VerbosePrintOut(member
.filename
);
5139 permissions
= { 'access': { '0': ('---'), '1': ('--x'), '2': ('-w-'), '3': ('-wx'), '4': ('r--'), '5': ('r-x'), '6': ('rw-'), '7': ('rwx') }, 'roles': { 0: 'owner', 1: 'group', 2: 'other' } };
5141 for fmodval
in str(oct(fmode
))[-3:]:
5142 permissionstr
= permissionstr
+ permissions
['access'].get(fmodval
, '---');
5143 if(member
.is_file()):
5145 permissionstr
= "-" + permissionstr
;
5146 printfname
= member
.filename
;
5147 elif(member
.is_symlink()):
5149 permissionstr
= "l" + permissionstr
;
5150 printfname
= member
.name
+ " -> " + member
.read().decode("UTF-8");
5151 elif(member
.is_dir()):
5153 permissionstr
= "d" + permissionstr
;
5154 printfname
= member
.filename
;
5156 fuid
= int(os
.getuid());
5157 except AttributeError:
5162 fgid
= int(os
.getgid());
5163 except AttributeError:
5170 userinfo
= pwd
.getpwuid(os
.getuid());
5171 funame
= userinfo
.pw_name
;
5174 except AttributeError:
5182 groupinfo
= grp
.getgrgid(os
.getgid());
5183 fgname
= groupinfo
.gr_name
;
5186 except AttributeError:
5191 if(len(fuprint
)<=0):
5192 fuprint
= str(fuid
);
5194 if(len(fgprint
)<=0):
5195 fgprint
= str(fgid
);
5196 VerbosePrintOut(PrintPermissionString(fmode
, ftype
) + " " + str(str(fuprint
) + "/" + str(fgprint
) + " " + str(member
.file_size
).rjust(15) + " " + member
.mtime
.strftime('%Y-%m-%d %H:%M') + " " + printfname
));
5199 return listcatfiles
['catfp'];
5203 def ListDirListFiles(infiles
, dirlistfromtxt
=False, compression
="auto", compressionlevel
=None, followlink
=False, seekstart
=0, seekend
=0, skipchecksum
=False, checksumtype
="crc32", formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
5204 outarray
= BytesIO();
5205 packcat
= PackArchiveFile(infiles
, outarray
, dirlistfromtxt
, compression
, compressionlevel
, followlink
, checksumtype
, formatspecs
, False, True);
5206 listcatfiles
= ArchiveFileListFiles(outarray
, seekstart
, seekend
, skipchecksum
, formatspecs
, verbose
, returnfp
);
5207 return listcatfiles
;
5209 def ListDirListFilesAlt(infiles
, dirlistfromtxt
=False, followlink
=False, listonly
=True, seekstart
=0, seekend
=0, skipchecksum
=False, checksumtype
="crc32", formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
5210 outarray
= ListDirToArrayAlt(infiles
, dirlistfromtxt
, followlink
, listonly
, checksumtype
, formatspecs
, verbose
);
5211 listcatfiles
= ArchiveFileListFiles(outarray
, seekstart
, seekend
, skipchecksum
, formatspecs
, verbose
, returnfp
);
5212 return listcatfiles
;
5214 def PackArchiveFileFromListDirAlt(infiles
, outfile
, dirlistfromtxt
=False, compression
="auto", compressionlevel
=None, followlink
=False, skipchecksum
=False, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
5215 outarray
= ListDirToArrayAlt(infiles
, dirlistfromtxt
, followlink
, False, checksumtype
, extradata
, formatspecs
, False);
5216 listcatfiles
= RePackArchiveFile(outarray
, outfile
, compression
, compressionlevel
, followlink
, checksumtype
, skipchecksum
, extradata
, formatspecs
, verbose
, returnfp
);
5217 return listcatfiles
;
5219 create_alias_function("Pack", __file_format_name__
, "FromListDirAlt", PackArchiveFileFromListDirAlt
);
5221 def PackArchiveFileFromTarFileAlt(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
5222 outarray
= TarFileToArrayAlt(infile
, False, checksumtype
, extradata
, formatspecs
, False);
5223 listcatfiles
= RePackArchiveFile(outarray
, outfile
, compression
, compressionlevel
, False, checksumtype
, False, extradata
, formatspecs
, verbose
, returnfp
);
5224 return listcatfiles
;
5226 create_alias_function("Pack", __file_format_name__
, "FromTarFileAlt", PackArchiveFileFromTarFileAlt
);
5228 def PackArchiveFileFromZipFileAlt(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
5229 outarray
= ZipFileToArrayAlt(infile
, False, checksumtype
, extradata
, formatspecs
, False);
5230 listcatfiles
= RePackArchiveFile(outarray
, outfile
, compression
, compressionlevel
, False, checksumtype
, False, extradata
, formatspecs
, verbose
, returnfp
);
5231 return listcatfiles
;
5233 create_alias_function("Pack", __file_format_name__
, "FromZipFileAlt", PackArchiveFileFromZipFileAlt
);
5235 if(not rarfile_support
):
5236 def PackArchiveFileFromRarFileAlt(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
5239 if(rarfile_support
):
5240 def PackArchiveFileFromRarFileAlt(infile
, outfile
, compression
="auto", compressionlevel
=None, checksumtype
="crc32", extradata
=[], formatspecs
=__file_format_list__
, verbose
=False, returnfp
=False):
5241 outarray
= RarFileToArrayAlt(infile
, False, checksumtype
, extradata
, formatspecs
, False);
5242 listcatfiles
= RePackArchiveFile(outarray
, outfile
, compression
, compressionlevel
, False, checksumtype
, False, extradata
, formatspecs
, verbose
, returnfp
);
5243 return listcatfiles
;
5245 create_alias_function("Pack", __file_format_name__
, "FromRarFileAlt", PackArchiveFileFromRarFileAlt
);
5247 def download_file_from_ftp_file(url
):
5248 urlparts
= urlparse
.urlparse(url
);
5249 file_name
= os
.path
.basename(urlparts
.path
);
5250 file_dir
= os
.path
.dirname(urlparts
.path
);
5251 if(urlparts
.username
is not None):
5252 ftp_username
= urlparts
.username
;
5254 ftp_username
= "anonymous";
5255 if(urlparts
.password
is not None):
5256 ftp_password
= urlparts
.password
;
5257 elif(urlparts
.password
is None and urlparts
.username
=="anonymous"):
5258 ftp_password
= "anonymous";
5261 if(urlparts
.scheme
=="ftp"):
5263 elif(urlparts
.scheme
=="ftps"):
5267 if(urlparts
.scheme
=="http" or urlparts
.scheme
=="https"):
5269 ftp_port
= urlparts
.port
;
5270 if(urlparts
.port
is None):
5273 ftp
.connect(urlparts
.hostname
, ftp_port
);
5274 except socket
.gaierror
:
5275 log
.info("Error With URL "+httpurl
);
5277 except socket
.timeout
:
5278 log
.info("Error With URL "+httpurl
);
5280 ftp
.login(urlparts
.username
, urlparts
.password
);
5281 if(urlparts
.scheme
=="ftps"):
5283 ftpfile
= BytesIO();
5284 ftp
.retrbinary("RETR "+urlparts
.path
, ftpfile
.write
);
5285 #ftp.storbinary("STOR "+urlparts.path, ftpfile.write);
5290 def download_file_from_ftp_string(url
):
5291 ftpfile
= download_file_from_ftp_file(url
);
5292 return ftpfile
.read();
5294 def upload_file_to_ftp_file(ftpfile
, url
):
5295 urlparts
= urlparse
.urlparse(url
);
5296 file_name
= os
.path
.basename(urlparts
.path
);
5297 file_dir
= os
.path
.dirname(urlparts
.path
);
5298 if(urlparts
.username
is not None):
5299 ftp_username
= urlparts
.username
;
5301 ftp_username
= "anonymous";
5302 if(urlparts
.password
is not None):
5303 ftp_password
= urlparts
.password
;
5304 elif(urlparts
.password
is None and urlparts
.username
=="anonymous"):
5305 ftp_password
= "anonymous";
5308 if(urlparts
.scheme
=="ftp"):
5310 elif(urlparts
.scheme
=="ftps"):
5314 if(urlparts
.scheme
=="http" or urlparts
.scheme
=="https"):
5316 ftp_port
= urlparts
.port
;
5317 if(urlparts
.port
is None):
5320 ftp
.connect(urlparts
.hostname
, ftp_port
);
5321 except socket
.gaierror
:
5322 log
.info("Error With URL "+httpurl
);
5324 except socket
.timeout
:
5325 log
.info("Error With URL "+httpurl
);
5327 ftp
.login(urlparts
.username
, urlparts
.password
);
5328 if(urlparts
.scheme
=="ftps"):
5330 ftp
.storbinary("STOR "+urlparts
.path
, ftpfile
);
5335 def upload_file_to_ftp_string(ftpstring
, url
):
5336 ftpfileo
= BytesIO(ftpstring
);
5337 ftpfile
= upload_file_to_ftp_file(ftpfileo
, url
);
5341 if(hasattr(shutil
, "register_archive_format")):
5342 # Register the packing format
5343 shutil
.register_archive_format(__file_format_name__
, PackArchiveFileFunc
, description
='Pack concatenated files');
5345 if(hasattr(shutil
, "register_unpack_format")):
5346 # Register the unpacking format
5347 shutil
.register_unpack_format(__file_format_name__
, archivefile_extensions
, UnPackArchiveFileFunc
, description
='UnPack concatenated files');