Spade

Mini Shell

Directory:~$ /proc/self/root/usr/lib64/python3.6/__pycache__/
Upload File
[Home] [System Details] [Kill Me]
Current File:~$ //proc/self/root/usr/lib64/python3.6/__pycache__/tarfile.cpython-36.pyc

3

k��h���'@s dZdZdZdZdZdZddlmZddl	Z	ddl
Z
ddlZddlZddl
Z
ddlZddlZddlZddlZddlZyddlZWnek
r�dZYnXyddlZWnek
r�dZYnXeefZyeef7ZWnek
r�YnXd	d
ddd
ddddddddddgZdZdZedZdZdZ
dZ!dZ"dZ#dZ$dZ%d
Z&d!Z'd"Z(d#Z)d$Z*d%Z+d&Z,d'Z-d(Z.d)Z/d*Z0d+Z1d,Z2dZ3d-Z4d.Z5e4Z6e$e%e&e'e*e+e,e(e)e-e.e/fZ7e$e%e,e/fZ8e-e.e/fZ9d�Z:d/d0d5d6hZ;e<e<e<e=e=e=d7�Z>e
j?d8k�r�d9Z@ne	jA�Z@d:d;�ZBd<d=�ZCd>d?�ZDd@e6fdAdB�ZEdCdD�ZFdedfdEdF�ZGdGdH�ZHdIdJ�ZIGdKd�deJ�ZKGdLd�deK�ZLGdMd
�d
eK�ZMGdNd�deK�ZNGdOd�deK�ZOGdPd�deK�ZPGdQdR�dReP�ZQGdSdT�dTeP�ZRGdUdV�dVeP�ZSGdWdX�dXeP�ZTGdYdZ�dZeP�ZUGd[d\�d\�ZVGd]d^�d^�ZWGd_d`�d`eX�ZYGdadb�dbeX�ZZGdcdd�ddej[�Z\ej]de�Z^Gdfdg�dgeK�Z_Gdhdi�die_�Z`Gdjdk�dke_�ZaGdldm�dme_�ZbGdndo�doe_�ZcGdpdq�dqe_�Zdd�dsdt�Zedudv�Zfdwdx�Zgdydz�Zhefegehd{�ZieX�ZjGd|d
�d
eX�ZkGd}d	�d	eX�Zld~d�ZmeljZdd��Zneod�k�ren�dS)�z,Read
from and write to tar format archives.
z0.9.0u"Lars Gustäbel (lars@gustaebel.de)z5$Date: 2011-02-25
17:42:01 +0200 (Fri, 25 Feb 2011) $z?$Id: tarfile.py 88586 2011-02-25
15:42:01Z marc-andre.lemburg $u4Gustavo Niemeyer, Niels Gustäbel, Richard
Townsend.�)�openN�TarFile�TarInfo�
is_tarfile�TarError�	ReadError�CompressionError�StreamError�ExtractError�HeaderError�ENCODING�USTAR_FORMAT�
GNU_FORMAT�
PAX_FORMAT�DEFAULT_FORMATr�i�sustar 
sustar00�d��0�1�2�3�4�5�6�7�L�K�S�x�g�X���path�linkpath�size�mtime�uid�gid�uname�gname)ZatimeZctimer(r)r*r'�ntzutf-8cCs8|dkrtd��|j||�}|d|�|t|�tS)z8Convert
a string to a null-terminated bytes object.
    Nzmetadata cannot contain None)�
ValueError�encode�len�NUL)�s�length�encoding�errors�r6�/usr/lib64/python3.6/tarfile.py�stn�sr8cCs*|jd�}|dkr|d|�}|j||�S)z8Convert
a null-terminated bytes object to a string.
    rr#N���)�find�decode)r2r4r5�pr6r6r7�nts�s
r=cCs�|ddkrfd}x0tt|�d�D]}|dK}|||d7}q"W|ddkr�dt|�d|}n@y"t|dd�}t|j�p�d	d�}Wntk
r�td
��YnX|S)z/Convert a number field to a python number.
    r��r#���ascii�strict�0zinvalid
header)r>r?)�ranger0r=�int�stripr.�InvalidHeaderError)r2�n�ir6r6r7�nti�srKr@cCs�t|�}d|ko"d|dknrDtd|d|fd�t}n�|tkr�d|d|kopd|dknr�|dkr�tdg�}ntdg�}d||}x6t|d�D]}|jd|d@�|dL}q�Wntd	��|S)
z/Convert a python number to a number field.
    rr@r#z%0*orBrAr>r?zoverflow in number
field)rF�bytesr1r�	bytearrayrE�insertr.)rI�digits�formatr2rJr6r6r7�itn�s
2
rQcCs0dttjd|��}dttjd|��}||fS)a�Calculate
the checksum for a member's header by summing up all
       characters except for the chksum field which is treated as if
       it was filled with spaces. According to the GNU tar sources,
       some tars (Sun and NeXT) calculate chksum with signed char,
       which will be different if there are chars in the buffer with
       the high bit set. So we calculate two checksums, unsigned and
       signed.
    rAZ
148B8x356BZ
148b8x356b)�sum�struct�unpack_from)�bufZunsigned_chksumZ
signed_chksumr6r6r7�calc_chksums�s	rVc	Cs�|pd}|dkrdS|dkr.tj|||�dSt||�\}}x8t|�D],}|j|�}t|�|krh|d��|j|�qFW|dkr�|j|�}t|�|kr�|d��|j|�dS)zjCopy
length bytes from fileobj src to fileobj dst.
       If length is None, copy the entire content.
    �irNzunexpected end of
datai@)�shutil�copyfileobj�divmodrE�readr0�write)	�src�dstr3�	exception�bufsize�blocks�	remainder�brUr6r6r7rY�s$


rYcCs ddl}|jdtd�tj|�S)z/Deprecated in this location;
use stat.filemode.rNz$deprecated in favor of
stat.filemoder$)�warnings�warn�DeprecationWarning�stat�filemode)�moderdr6r6r7rh	srhcCs8ttjdd�}|dk	r(|j|d�j|�}t|dd�dS)Nr4�backslashreplace�
)�end)�getattr�sys�stdoutr/r;�print)r2r4r6r6r7�_safe_printsrqc@seZdZdZdS)rzBase
exception.N)�__name__�
__module__�__qualname__�__doc__r6r6r6r7rsc@seZdZdZdS)r
z%General exception for extract errors.N)rrrsrtrur6r6r6r7r
sc@seZdZdZdS)rz&Exception for unreadable tar
archives.N)rrrsrtrur6r6r6r7rsc@seZdZdZdS)rz.Exception for
unavailable compression methods.N)rrrsrtrur6r6r6r7r
sc@seZdZdZdS)r	z=Exception for unsupported operations on
stream-like
TarFiles.N)rrrsrtrur6r6r6r7r	#sc@seZdZdZdS)rz!Base
exception for header
errors.N)rrrsrtrur6r6r6r7r&sc@seZdZdZdS)�EmptyHeaderErrorzException
for empty
headers.N)rrrsrtrur6r6r6r7rv)srvc@seZdZdZdS)�TruncatedHeaderErrorz
Exception for truncated
headers.N)rrrsrtrur6r6r6r7rw,srwc@seZdZdZdS)�EOFHeaderErrorz"Exception
for end of file
headers.N)rrrsrtrur6r6r6r7rx/srxc@seZdZdZdS)rHzException
for invalid
headers.N)rrrsrtrur6r6r6r7rH2srHc@seZdZdZdS)�SubsequentHeaderErrorz3Exception
for missing and invalid extended
headers.N)rrrsrtrur6r6r6r7ry5sryc@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�
_LowLevelFilez�Low-level file object. Supports reading and
writing.
       It is used instead of a regular file object for streaming
       access.
   
cCsFtjtjtjBtjBd�|}ttd�r2|tjO}tj||d�|_dS)N)�r�w�O_BINARYi�)	�os�O_RDONLY�O_WRONLY�O_CREAT�O_TRUNC�hasattrr}r�fd)�self�namerir6r6r7�__init__Bs

z_LowLevelFile.__init__cCstj|j�dS)N)r~�closer�)r�r6r6r7r�Ksz_LowLevelFile.closecCstj|j|�S)N)r~r[r�)r�r'r6r6r7r[Nsz_LowLevelFile.readcCstj|j|�dS)N)r~r\r�)r�r2r6r6r7r\Qsz_LowLevelFile.writeN)rrrsrtrur�r�r[r\r6r6r6r7rz<s
	rzc@steZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zddd�Zddd�Z
dd�Zdd�ZdS)�_Streama�Class
that serves as an adapter between TarFile and
       a stream-like object.  The stream-like object only
       needs to have a read() or write() method and is accessed
       blockwise.  Use of gzip or bzip2 compression is possible.
       A stream-like object could be for example: sys.stdin,
       sys.stdout, a socket, a tape device etc.

       _Stream is intended to be used only internally.
   
c	Cs�d|_|dkrt||�}d|_|dkr6t|�}|j�}|p<d|_||_||_||_||_d|_	d|_
d|_�yL|dkr�yddl}Wnt
k
r�td	��YnX||_|jd�|_|d
kr�|j�|j|_n|j�n�|dk�r:yddl}Wnt
k
�r
td��YnX|d
k�r.d|_|j�|_t|_n
|j�|_n||d
k�r�yddl}Wnt
k
�rntd��YnX|d
k�r�d|_|j�|_|j|_n
|j�|_n|dk�r�td|��Wn&|j�s�|jj�d|_�YnXdS)z$Construct
a _Stream object.
        TNF�*��r�gzzzlib module is not availabler{�bz2zbz2
module is not available�xzzlzma module is not available�tarzunknown
compression type %r)
�_extfileobjrz�_StreamProxy�getcomptyper�ri�comptype�fileobjr`rU�pos�closed�zlib�ImportErrorr�crc32�crc�
_init_read_gz�errorr_�_init_write_gzr��dbufZBZ2Decompressor�cmp�OSErrorZ
BZ2Compressor�lzmaZLZMADecompressor�	LZMAErrorZLZMACompressorr�)	r�r�rir�r�r`r�r�r�r6r6r7r�_sl












z_Stream.__init__cCst|d�r|jr|j�dS)Nr�)r�r�r�)r�r6r6r7�__del__�sz_Stream.__del__cCs�|jjd|jj|jj|jjd�|_tjdtt	j	���}|j
d|d�|jjd�rf|jdd�|_|j
|jj
d	d
�t�dS)z6Initialize for writing with gzip compression.
        �	rz<Ls�s�z.gzN�z
iso-8859-1�replace���)r�ZcompressobjZDEFLATED�	MAX_WBITSZ
DEF_MEM_LEVELr�rS�packrF�time�_Stream__writer��endswithr/r1)r�Z	timestampr6r6r7r��sz_Stream._init_write_gzcCsR|jdkr|jj||j�|_|jt|�7_|jdkrD|jj|�}|j|�dS)z&Write
string s to the stream.
       
r�r�N)	r�r�r�r�r�r0r��compressr�)r�r2r6r6r7r\�s

z
_Stream.writecCsR|j|7_x>t|j�|jkrL|jj|jd|j��|j|jd�|_qWdS)z]Write
string s to the stream if a whole new block
           is ready to be written.
       
N)rUr0r`r�r\)r�r2r6r6r7Z__write�sz_Stream.__writecCs�|jr
dSd|_z�|jdkr:|jdkr:|j|jj�7_|jdkr�|jr�|jj|j�d|_|jdkr�|jjtj	d|j
��|jjtj	d|jd@��Wd|js�|jj
�XdS)	z[Close the
_Stream object. No operation should be
           done on it afterwards.
       
NTr|r�r�r�z<Ll��)r�rir�rUr��flushr�r\rSr�r�r�r�r�)r�r6r6r7r��s
z
_Stream.closecCs�|jj|jj�|_d|_|jd�dkr0td��|jd�dkrFtd��t|jd��}|jd�|d	@r�t|jd��d
t|jd��}|j	|�|d@r�x|jd�}|s�|t
kr�Pq�W|d@r�x|jd�}|s�|t
kr�Pq�W|d@r�|jd�d
S)z:Initialize for reading a gzip
compressed fileobj.
        r�r$s�znot a gzip filer#�zunsupported compression
method��rAr@rWN)r�Z
decompressobjr�r�r��
_Stream__readrr�ordr[r1)r��flagZxlenr2r6r6r7r��s.
 


z_Stream._init_read_gzcCs|jS)z3Return the stream's file
pointer position.
       
)r�)r�r6r6r7�tell�sz_Stream.tellrcCs\||jdkrNt||j|j�\}}xt|�D]}|j|j�q.W|j|�ntd��|jS)zXSet
the stream's file pointer to pos. Negative seeking
           is forbidden.
        rz seeking backwards is not
allowed)r�rZr`rEr[r	)r�r�rarbrJr6r6r7�seeksz_Stream.seekNcCsZ|dkr:g}x
|j|j�}|s P|j|�qWdj|�}n
|j|�}|jt|�7_|S)z�Return the next size number of bytes
from the stream.
           If size is not defined, return all bytes of the stream
           up to EOF.
       
Nr�)�_readr`�append�joinr�r0)r�r'�trUr6r6r7r[s
z_Stream.readcCs�|jdkr|j|�St|j�}|jg}xd||kr�|j|j�}|sBPy|jj|�}Wn|jk
rptd��YnX|j	|�|t|�7}q(Wdj
|�}||d�|_|d|�S)z+Return size bytes from the stream.
        r�zinvalid compressed datar�N)r�r�r0r�r`r�Z
decompressr_rr�r�)r�r'�cr�rUr6r6r7r�#s"





z
_Stream._readcCsnt|j�}|jg}x6||krH|jj|j�}|s0P|j|�|t|�7}qWdj|�}||d�|_|d|�S)zsReturn
size bytes from stream. If internal buffer is empty,
           read another block from the stream.
       
r�N)r0rUr�r[r`r�r�)r�r'r�r�rUr6r6r7Z__read9s



z_Stream.__read)r)N)rrrsrtrur�r�r�r\r�r�r�r�r�r[r�r�r6r6r6r7r�Ts	F
	

r�c@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)r�zsSmall proxy class that enables transparent compression
       detection for the Stream interface (mode 'r|*').
   
cCs||_|jjt�|_dS)N)r�r[�	BLOCKSIZErU)r�r�r6r6r7r�Osz_StreamProxy.__init__cCs|jj|_|jS)N)r�r[rU)r�r'r6r6r7r[Ss
z_StreamProxy.readcCsP|jjd�rdS|jdd�dkr8|jdd�dkr8d	S|jjd�rHdSd
SdS)Ns�r�rr�sBZhr��
s1AY&SYr��]���7zXZr�r�)r�r�)rU�
startswith)r�r6r6r7r�Ws$z_StreamProxy.getcomptypecCs|jj�dS)N)r�r�)r�r6r6r7r�asz_StreamProxy.closeN)rrrsrtrur�r[r�r�r6r6r6r7r�Js

r�c@sjeZdZdZddd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	e
jfdd�Zddd�Z
dd�Zdd�ZdS)�_FileInFilezA thin
wrapper around an existing file object that
       provides a part of its data as an individual file
       object.
   
NcCs�||_||_||_d|_t|dd�|_d|_|dkr>d|fg}d|_g|_d}|j}xT|D]L\}}||kr~|jj	d||df�|jj	d||||f�||7}||}qZW||jkr�|jj	d||jdf�dS)Nrr�FT)
r��offsetr'�positionrmr�r��	map_index�mapr�)r�r�r�r'Z	blockinfoZlastposZrealposr6r6r7r�ns(

z_FileInFile.__init__cCsdS)Nr6)r�r6r6r7r��sz_FileInFile.flushcCsdS)NTr6)r�r6r6r7�readable�sz_FileInFile.readablecCsdS)NFr6)r�r6r6r7�writable�sz_FileInFile.writablecCs
|jj�S)N)r��seekable)r�r6r6r7r��sz_FileInFile.seekablecCs|jS)z*Return
the current file position.
        )r�)r�r6r6r7r��sz_FileInFile.tellcCs�|tjkr
tt|d�|j�|_nj|tjkr\|dkrFt|j|d�|_q�t|j||j�|_n.|tjkr�tt|j||j�d�|_ntd��|jS)z(Seek
to a position in the file.
        rzInvalid
argument)	�io�SEEK_SET�min�maxr'r��SEEK_CUR�SEEK_ENDr.)r�r��whencer6r6r7r��s


z_FileInFile.seekc	Cs|dkr|j|j}nt||j|j�}d}x�|dk�rxZ|j|j\}}}}||jkob|knrlPq:|jd7_|jt|j�kr:d|_q:Wt|||j�}|r�|jj||j|�|jj|�}t|�|kr�t	d��||7}n|t
|7}||8}|j|7_q.W|S)z!Read data from the file.
        Nr�rr#zunexpected end of
data)r'r�r�r�r�r0r�r�r[rr1)	r�r'rU�data�start�stopr�r3rcr6r6r7r[�s.

z_FileInFile.readcCs&|jt|��}||dt|��<t|�S)N)r[r0)r�rcrUr6r6r7�readinto�sz_FileInFile.readintocCs
d|_dS)NT)r�)r�r6r6r7r��sz_FileInFile.close)N)N)rrrsrtrur�r�r�r�r�r�r�r�r�r[r�r�r6r6r6r7r�hs

r�cseZdZ�fdd�Z�ZS)�ExFileObjectcs&t|j|j|j|j�}t�j|�dS)N)r�r��offset_datar'�sparse�superr�)r��tarfile�tarinfor�)�	__class__r6r7r��s
zExFileObject.__init__)rrrsrtr��
__classcell__r6r6)r�r7r��sr�s([0-9]{1,20})
c@seZdZdS)�FilterErrorN)rrrsrtr6r6r6r7r��sr�cseZdZ�fdd�Z�ZS)�AbsolutePathErrorcs
||_t�jd|j�d��dS)Nzmember z has an absolute
path)r�r�r�r�)r�r�)r�r6r7r��szAbsolutePathError.__init__)rrrsrtr�r�r6r6)r�r7r��sr�cseZdZ�fdd�Z�ZS)�OutsideDestinationErrorcs.||_||_t�j|j�d|�d�d�dS)Nz
would be extracted to z, z which is outside the
destination)r��_pathr�r�r�)r�r�r%)r�r6r7r��sz
OutsideDestinationError.__init__)rrrsrtr�r�r6r6)r�r7r��sr�cseZdZ�fdd�Z�ZS)�SpecialFileErrorcs||_t�j|j�d��dS)Nz
is a special
file)r�r�r�r�)r�r�)r�r6r7r��szSpecialFileError.__init__)rrrsrtr�r�r6r6)r�r7r��sr�cseZdZ�fdd�Z�ZS)�AbsoluteLinkErrorcs||_t�j|j�d��dS)Nz!
is a symlink to an absolute
path)r�r�r�r�)r�r�)r�r6r7r��szAbsoluteLinkError.__init__)rrrsrtr�r�r6r6)r�r7r��sr�cseZdZ�fdd�Z�ZS)�LinkOutsideDestinationErrorcs.||_||_t�j|j�d|�d�d�dS)Nz
would link to z, z which is outside the
destination)r�r�r�r�r�)r�r�r%)r�r6r7r��sz$LinkOutsideDestinationError.__init__)rrrsrtr�r�r6r6)r�r7r��sr�TcCs�i}|j}tjj|�}|jdtjf�r@|jjdtj�}|d<tjj|�rTt|��tjjtjj	||��}tjj
||g�|kr�t||��|j}|dk	�r|d@}|r�|j
�s�|j�r�|d@s�|dM}|dO}n|j�s�|j�r�d}nt|��||jk�r||d<|�r�|jdk	�rd|d<|jdk	�r.d|d	<|jdk	�rBd|d
<|jdk	�rVd|d<|j��sj|j��r�tjj|j��r�t|��tjjtjj	||j��}tjj
||g�|k�r�t||��|S)
N�/r�i��@�Ii�rir)r*r+r,i����)r�r~r%�realpathr��sep�lstrip�isabsr�r��
commonpathr�ri�isreg�islnk�isdir�issymr�r)r*r+r,�linknamer�r�)�member�	dest_pathZfor_data�	new_attrsr�Ztarget_pathrir6r6r7�_get_filtered_attrssN



r�cCs|S)Nr6)r�r�r6r6r7�fully_trusted_filter8sr�cCs(t||d�}|r$|jf|ddi��S|S)NF�deep)r�r�)r�r�r�r6r6r7�
tar_filter;sr�cCs(t||d�}|r$|jf|ddi��S|S)NTr�F)r�r�)r�r�r�r6r6r7�data_filterAsr�)Z
fully_trustedr�r�c@s�eZdZdZdmZdndd�Zdd�Zdd�Zeee�Z	dd�Z
dd �Zee
e�Zd!d"�Z
eeeeeeeed#ed$�
d%d&�Zd'd(�Zeed)fd*d+�Zd,d-�Zd.d/�Zd0d1�Zed2d3��Zd4d5�Zed6d7��Zed8d9��Zed:d;��Zed<d=��Zed>d?��Zed@dA��Z
dBdC�Z!dDdE�Z"dFdG�Z#dHdI�Z$dJdK�Z%dLdM�Z&dNdO�Z'dPdQ�Z(dRdS�Z)dTdU�Z*dVdW�Z+dXdY�Z,dZd[�Z-d\d]�Z.d^d_�Z/d`da�Z0dbdc�Z1ddde�Z2dfdg�Z3dhdi�Z4djdk�Z5dlS)oraInformational
class which holds the details about an
       archive member given by a tar header block.
       TarInfo objects are returned by TarFile.getmember(),
       TarFile.getmembers() and TarFile.gettarinfo() and are
       usually created internally.
   
r�rir)r*r'r(�chksum�typer�r+r,�devmajor�devminorr�r��pax_headersr�r��_sparse_structs�_link_targetr�cCsj||_d|_d|_d|_d|_d|_d|_t|_d|_	d|_
d|_d|_d|_
d|_d|_d|_i|_dS)zXConstruct a TarInfo object. name
is the optional name
           of the member.
       
i�rr�N)r�rir)r*r'r(r��REGTYPEr�r�r+r,r�r�r�r�r�r�)r�r�r6r6r7r�bs"zTarInfo.__init__cCs|jS)N)r�)r�r6r6r7�_getpath|szTarInfo._getpathcCs
||_dS)N)r�)r�r�r6r6r7�_setpath~szTarInfo._setpathcCs|jS)N)r�)r�r6r6r7�_getlinkpath�szTarInfo._getlinkpathcCs
||_dS)N)r�)r�r�r6r6r7�_setlinkpath�szTarInfo._setlinkpathcCsd|jj|jt|�fS)Nz<%s
%r at
%#x>)r�rrr��id)r�r6r6r7�__repr__�szTarInfo.__repr__T)
r�r(rir�r)r*r+r,r��_KEEPc
Cs�|	rtj|�}n
tj|�}||
k	r(||_||
k	r6||_||
k	rD||_||
k	rR||_||
k	r`||_||
k	rn||_||
k	r|||_||
k	r�||_	|S)zGReturn a deep copy of self with the given attributes
replaced.
        )
�copy�deepcopyr�r(rir�r)r*r+r,)r�r�r(rir�r)r*r+r,r�r�resultr6r6r7r��s(
zTarInfo.replacecCs�|jdkrd}n
|jd@}|j||j|j|j|j|j|j|j|j	|j
|j|jd�
}|dt
kr~|djd�r~|dd7<|S)z9Return the
TarInfo's attributes as a dictionary.
       
Ni�)
r�rir)r*r'r(r�r�r�r+r,r�r�r�r�r�)rir�r)r*r'r(r�r�r�r+r,r�r��DIRTYPEr�)r�ri�infor6r6r7�get_info�s&


zTarInfo.get_info�surrogateescapecCs~|j�}x(|j�D]\}}|dkrtd|��qW|tkrH|j|||�S|tkr^|j|||�S|tkrr|j||�Std��dS)z<Return
a tar header as a string of 512 byte blocks.
        Nz%s may not be Nonezinvalid
format)	r
�itemsr.r
�create_ustar_headerr�create_gnu_headerr�create_pax_header)r�rPr4r5rr��valuer6r6r7�tobuf�sz
TarInfo.tobufcCsnt|d<t|dj||��tkr(td��t|dj||��tkr^|j|d||�\|d<|d<|j|t||�S)z3Return
the object as a ustar header block.
        �magicr�zlinkname is too
longr��prefix)	�POSIX_MAGICr0r/�LENGTH_LINKr.�LENGTH_NAME�_posix_split_name�_create_headerr
)r�rr4r5r6r6r7r�szTarInfo.create_ustar_headercCs�t|d<d}t|dj||��tkr<||j|dt||�7}t|dj||��tkrl||j|dt||�7}||j|t	||�S)z:Return
the object as a GNU header block sequence.
        rr�r�r�)
�	GNU_MAGICr0r/r�_create_gnu_long_header�GNUTYPE_LONGLINKr�GNUTYPE_LONGNAMErr)r�rr4r5rUr6r6r7r�szTarInfo.create_gnu_headerc
Cs4t|d<|jj�}x�ddtfddtfddfD]h\}}}||kr@q,y||jd	d
�Wn"tk
rv||||<w,YnXt||�|kr,||||<q,WxldD]d\}}||kr�d||<q�||}d|ko�d|dkn�s�t|t	�r�t
|�||<d||<q�W|�r|j|t|�}	nd}	|	|j
|td	d�S)z�Return
the object as a ustar header block. If it cannot be
           represented this way, prepend a pax extended header sequence
           with supplement information.
        rr�r%r�r&r+�
r,rBrCr)r@r*r'�r(rr#r�r�)r+r+r )r,r,r
�r)r@�r*r@�r'r!�r(r!)r"r#r$r%)rr�rrrr/�UnicodeEncodeErrorr0�
isinstance�float�str�_create_pax_generic_header�XHDTYPErr
)
r�rr4r�r�Zhnamer3rO�valrUr6r6r7r�s4
.zTarInfo.create_pax_headercCs|j|td�S)zAReturn
the object as a pax global header block sequence.
       
zutf-8)r*�XGLTYPE)�clsr�r6r6r7�create_pax_global_header
sz
TarInfo.create_pax_global_headercCs�|jd�}xltdt|��D]R}dj|d|��}dj||d��}t|j||��tkrt|j||��tkrPqWtd��||fS)zUSplit
a name longer than 100 chars into a prefix
           and a name part.
        r�r#Nzname is too
long)�splitrEr0r�r/�
LENGTH_PREFIXrr.)r�r�r4r5Z
componentsrJrr6r6r7r&s
zTarInfo._posix_split_namecCs�|jd�ttfk}|r@t|jdd�d|�}t|jdd�d|�}ntdd||�}tdd||�}|jdt�}|dkrxtd��t|jd	d�d
||�t|jdd�d@d|�t|jd
d�d|�t|jdd�d|�t|jdd�d|�t|jdd�d|�d|t|jdd�d
||�|jdt�t|jdd�d||�t|jdd�d||�t|jdd�d|�t|jdd�d|�t|jdd�d||�g}tj	dt
dj|��}	t|	t
d��d}
|	dd �t
d|
d�|	d!d�}	|	S)"z�Return a header block. info is a
dictionary with file
           information, format must be one of the *_FORMAT constants.
        r�r�rr@r�r�NzTarInfo.type must not be
Noner�rrii�r)r*r'r!r(s        r�rr+r
r,rrz%dsr�ilz%06orBiei����i����)�get�CHRTYPE�BLKTYPErQr8rr.rrSr�r�r�rVrL)rrPr4r5Zhas_device_fieldsr�r�Zfiletype�partsrUr�r6r6r7r6s8
&zTarInfo._create_headercCs.tt|�t�\}}|dkr*|t|t7}|S)zdReturn
the string payload filled with zero bytes
           up to the next 512 byte border.
       
r)rZr0r�r1)Zpayloadrarbr6r6r7�_create_payload`szTarInfo._create_payloadcCsR|j||�t}i}d|d<||d<t|�|d<t|d<|j|t||�|j|�S)zTReturn
a GNUTYPE_LONGNAME or GNUTYPE_LONGLINK sequence
           for name.
       
z
././@LongLinkr�r�r'r)r/r1r0rrr
r6)r.r�r�r4r5rr6r6r7rjszTarInfo._create_gnu_long_headercCs:d}x@|j�D]4\}}y|jdd�Wqtk
r@d}PYqXqWd}|rV|d7}x�|j�D]�\}}|jd�}|r�|j|d�}n
|jd�}t|�t|�d}d	}	}
x"|tt|
��}	|	|
kr�P|	}
q�W|tt|
�d
�d|d|d
7}q`Wi}d|d<||d<t|�|d<t|d<|j|td
d�|j	|�S)z�Return a POSIX.1-2008 extended or global header
sequence
           that contains a list of keyword, value pairs. The values
           must be strings.
        Fzutf-8rCTr�s21 hdrcharset=BINARY
rr�rrB� �=�
z././@PaxHeaderr�r�r'rr�)
rr/r&r0r)rLrrr
r6)r.r�r�r4Zbinary�keywordrZrecords�lrIr<rr6r6r7r*{s<

*z"TarInfo._create_pax_generic_headercCstt|�dkrtd��t|�tkr(td��|jt�tkr>td��t|dd��}|t|�krbt	d��|�}t
|dd�||�|_t|dd	��|_t|d	d
��|_
t|d
d��|_t|dd��|_t|dd��|_||_|dd
�|_t
|d
d�||�|_t
|dd�||�|_t
|dd�||�|_t|dd��|_t|dd��|_t
|dd�||�}|jtk�r�|jjd��r�t|_|jtk�r6d}g}xrtd�D]f}	y0t|||d��}
t||d|d��}Wntk
�r�PYnX|j|
|f�|d7}�q�Wt|d�}t|dd��}
|||
f|_
|j!��rN|jj"d�|_|�rp|jt#k�rp|d|j|_|S)zAConstruct
a TarInfo object from a 512 byte bytes object.
        rzempty headerztruncated headerzend of file header��zbad
checksumr�l�t�|��ii	i)iIiQiYi�r�i�r�r!�i�i�i�)$r0rvr�rw�countr1rxrKrVrHr=r�rir)r*r'r(r�r�r�r+r,r�r��AREGTYPEr�r�GNUTYPE_SPARSErEr.r��boolr�r��rstrip�	GNU_TYPES)r.rUr4r5r��objrr��structsrJr��numbytes�
isextended�origsizer6r6r7�frombuf�sZ
zTarInfo.frombufcCs8|jjt�}|j||j|j�}|jj�t|_|j|�S)zOReturn
the next TarInfo object from TarFile object
           tarfile.
       
)	r�r[r�rOr4r5r�r��_proc_member)r.r�rUrJr6r6r7�fromtarfile�szTarInfo.fromtarfilecCsT|jttfkr|j|�S|jtkr,|j|�S|jtttfkrF|j	|�S|j
|�SdS)zYChoose the right processing method depending on
           the type and call it.
       
N)r�rr�
_proc_gnulongrF�_proc_sparser+r-�SOLARIS_XHDTYPE�	_proc_pax�
_proc_builtin)r�r�r6r6r7rPs



zTarInfo._proc_membercCsR|jj�|_|j}|j�s$|jtkr4||j|j�7}||_|j	|j
|j|j�|S)zfProcess a builtin type or an unknown type which
           will be treated as a regular file.
       
)
r�r�r�r�r��SUPPORTED_TYPES�_blockr'r��_apply_pax_infor�r4r5)r�r�r�r6r6r7rVszTarInfo._proc_builtincCs�|jj|j|j��}y|j|�}Wntk
r>td��YnX|j|_|jt	krft
||j|j�|_
n|jtkr�t
||j|j�|_|S)zSProcess the blocks that hold a GNU longname
           or longlink member.
        z missing or bad subsequent
header)r�r[rXr'rQrryr�r�rr=r4r5r�rr�)r�r�rU�nextr6r6r7rR
s

zTarInfo._proc_gnulongc
Cs�|j\}}}|`x�|r�|jjt�}d}xvtd�D]j}y0t|||d��}t||d|d��}	Wntk
rzPYnX|r�|	r�|j||	f�|d7}q0Wt|d�}qW||_	|jj
�|_|j|j|j
�|_||_
|S)z8Process a GNU sparse header plus extra
headers.
       
r�r!rCi�)r�r�r[r�rErKr.r�rGr�r�r�rXr'r�)
r�r�rKrMrNrUr�rJr�rLr6r6r7rS6s(zTarInfo._proc_sparsecCs�|jj|j|j��}|jtkr&|j}n
|jj�}d}d}g}�x0t|�|koV||dk�rnt	j
||�}|srtd��yt|j
d��}Wntk
r�td��YnX|dkr�td��||t|�kr�td��|jd�|d}	||jd�d|	�}
|
jd�\}}}
|�s"|dk�s"||	dk�r*td��|j|||
f�|dk�rd|dk�rd|
d	k�r`|j}nd
}||7}q@W|dk�r~d
}x`|D]X\}}}
|j|d
d
|j�}|tk�r�|j|
||j|j�}n|j|
d
d
|j�}|||<�q�Wy|j|�}Wntk
�rtd��YnXd|k�r&|j||�nFd
|k�r>|j||�n.|jd�dk�rl|jd�dk�rl|j|||�|jttfk�r�|j
||j|j�|j!|_!d|k�r�|j"}|j#��s�|jt$k�r�||j|j�7}||_!|S)zVProcess
an extended or global header as described in
           POSIX.1-2008.
        rNzinvalid headerr#�r8r�s
hdrcharsetsBINARYzutf-8z missing or bad subsequent
headerzGNU.sparse.mapzGNU.sparse.sizezGNU.sparse.major�1zGNU.sparse.minorrDr')%r�r[rXr'r�r-r�rr0�_header_length_prefix_re�matchrHrF�groupr.r�rl�	partitionr�r4�_decode_pax_fieldr5�PAX_NAME_FIELDSrQrry�_proc_gnusparse_01�_proc_gnusparse_00r2�_proc_gnusparse_10r+rTrYr�r�r�rW)r�r�rUr�r�r4�raw_headersr_r3Zheader_value_end_offsetZkeyword_and_valueZraw_keywordZequalsZ	raw_valuer:rrZr�r6r6r7rURsx

 







 
zTarInfo._proc_paxcCs�g}g}x�|D]�\}}}|dkrVy|jt|j���Wq�tk
rRtd��Yq�Xq|dkry|jt|j���Wqtk
r�td��YqXqWtt||��|_dS)z?Process a GNU tar
extended sparse header, version 0.0.
        sGNU.sparse.offsetzinvalid
headersGNU.sparse.numbytesN)r�rFr;r.rH�list�zipr�)r�rZrgZoffsetsrL�_r:rr6r6r7re�szTarInfo._proc_gnusparse_00cCs@dd�|djd�D�}tt|ddd�|ddd���|_dS)z?Process
a GNU tar extended sparse header, version 0.1.
        cSsg|]}t|��qSr6)rF)�.0�xr6r6r7�
<listcomp>�sz.TarInfo._proc_gnusparse_01.<locals>.<listcomp>zGNU.sparse.map�,Nr$r#)r0rhrir�)r�rZr�r�r6r6r7rd�szTarInfo._proc_gnusparse_01cCs�d}g}|jjt�}|jdd�\}}t|�}xJt|�|dkrvd|krV||jjt�7}|jdd�\}}|jt|��q.W|jj�|_t	t
|ddd�|ddd���|_dS)z?Process a GNU tar extended
sparse header, version 1.0.
       
Nr9r#r$)r�r[r�r0rFr0r�r�r�rhrir�)r�rZr�r�Zfieldsr�rUZnumberr6r6r7rf�szTarInfo._proc_gnusparse_10c
Cs�x�|j�D]�\}}|dkr(t|d|�q
|dkrBt|dt|��q
|dkr\t|dt|��q
|tkr
|tkr�yt||�}Wntk
r�d}YnX|dkr�|jd�}t|||�q
W|j�|_dS)	zoReplace fields with supplemental information from a
previous
           pax extended or global header.
       
zGNU.sparse.namer%zGNU.sparse.sizer'zGNU.sparse.realsizerr�N)	r�setattrrF�
PAX_FIELDS�PAX_NUMBER_FIELDSr.rHrr�)r�r�r4r5r:rr6r6r7rY�s"

zTarInfo._apply_pax_infocCs.y|j|d�Stk
r(|j||�SXdS)z1Decode a single field from a pax record.
       
rCN)r;�UnicodeDecodeError)r�rr4Zfallback_encodingZfallback_errorsr6r6r7rb
szTarInfo._decode_pax_fieldcCs"t|t�\}}|r|d7}|tS)z_Round
up a byte count by BLOCKSIZE and return it,
           e.g. _block(834) => 1024.
        r#)rZr�)r�rDrarbr6r6r7rXszTarInfo._blockcCs
|jtkS)N)r��
REGULAR_TYPES)r�r6r6r7r�sz
TarInfo.isregcCs|j�S)N)r�)r�r6r6r7�isfile
szTarInfo.isfilecCs
|jtkS)N)r�r)r�r6r6r7r�"sz
TarInfo.isdircCs
|jtkS)N)r��SYMTYPE)r�r6r6r7r�$sz
TarInfo.issymcCs
|jtkS)N)r��LNKTYPE)r�r6r6r7r�&sz
TarInfo.islnkcCs
|jtkS)N)r�r3)r�r6r6r7�ischr(sz
TarInfo.ischrcCs
|jtkS)N)r�r4)r�r6r6r7�isblk*sz
TarInfo.isblkcCs
|jtkS)N)r��FIFOTYPE)r�r6r6r7�isfifo,szTarInfo.isfifocCs
|jdk	S)N)r�)r�r6r6r7�issparse.szTarInfo.issparsecCs|jtttfkS)N)r�r3r4ry)r�r6r6r7�isdev0sz
TarInfo.isdevN)r�rir)r*r'r(r�r�r�r+r,r�r�r�r�r�r�r�r�r�)r�)6rrrsrtru�	__slots__r�rr�propertyr%rrr&rrr�r
rrrrrr�classmethodr/r�staticmethodrr6rr*rOrQrPrVrRrSrUrerdrfrYrbrXr�rtr�r�r�rwrxrzr{r|r6r6r6r7rTsf



1*
3?
z	c
@s�eZdZdZdZdZdZdZeZ	e
ZdZe
ZeZdZdfdd	�Zedddefd
d��Zedgdd
��Zedhdd��Zedidd��Zedjdd��Zddddd�Zdd�Zdd�Zdd�Zd
d!�Zdkd"d#�Zdldd%�d&d'�Z
dmdd(�d)d*�Z!dnd+d,�Z"d-d.�Z#doddd0�d1d2�Z$dpddd0�d4d5�Z%d6d7�Z&d8d9�Z'd:d;�Z(d<d=�Z)d>d?�Z*dqd@dA�Z+dBdC�Z,dDdE�Z-dFdG�Z.dHdI�Z/dJdK�Z0dLdM�Z1dNdO�Z2dPdQ�Z3dRdS�Z4dTdU�Z5drdVdW�Z6dXdY�Z7dsdZd[�Z8d\d]�Z9d^d_�Z:d`da�Z;dbdc�Z<ddde�Z=dS)trz=The
TarFile Class provides an interface to tar archives.
   
rFr#Nr{rcCs�ddddd�}||krtd��||_|||_|sj|jdkrVtjj|�rVd|_d|_t||j�}d	|_n@|d
kr�t|d�r�t	|j
ttf�r�|j
}t|d�r�|j|_d
|_|r�tjj
|�nd
|_
||_|d
k	r�||_|d
k	r�||_|d
k	r�||_|d
k	�r||_|d
k	�r||_|	|_|
d
k	�r4|jtk�r4|
|_ni|_|d
k	�rJ||_|d
k	�rZ||_|
|_d	|_g|_d	|_|jj�|_i|_�y�|jdk�r�d
|_ |j!�|_
|jdk�r8x�|jj"|j�y|jj#|�}|jj$|�WnTt%k
�r|jj"|j�PYn0t&k
�r0}zt't|���WYd
d
}~XnX�q�W|jdk�r�d
|_|j�r�|jj(|jj)��}|jj*|�|jt+|�7_Wn&|j�s�|jj,�d
|_�YnXd
S)a�Open an (uncompressed) tar archive `name'. `mode' is
either 'r' to
           read from an existing archive, 'a' to append data to
an existing
           file or 'w' to create a new file overwriting an
existing one. `mode'
           defaults to 'r'.
           If `fileobj' is given, it is used for reading or writing
data. If it
           can be determined, `mode' is overridden by `fileobj's
mode.
           `fileobj' is not closed, when TarFile is closed.
        �rbzr+b�wbZxb)r{�ar|rlz!mode must be 'r',
'a', 'w' or
'x'r�r|FNr�riTr{rl)r�r|rl)-r.ri�_moder~r%�exists�	bltn_openr�r�r'r�r)rL�abspathr�rPr��dereference�ignore_zerosr4r5rr��debug�
errorlevel�copybufsizer��members�_loadedr�r��inodes�firstmemberrZr�rQr�rxrrr/rr\r0r�)r�r�rir�rPr�r�r�r4r5r�r�r�r�Zmodes�erUr6r6r7r�Ps�






$
zTarFile.__init__c

s�|r|rtd��|dkr��fdd�}xtt�j|d�D]b}t��j|�}|dk	r\|j�}	y||d|f|�Sttfk
r�|dk	r�|j|	�w8Yq8Xq8Wtd���nd	|k�r|jd	d
�\}
}|
p�d}
|p�d}|�jkr�t��j|�}ntd|��|||
|f|�Sd
|k�r�|jd
d
�\}
}|
�p.d}
|�p8d}|
dk�rLtd��t	||
|||�}y�||
|f|�}Wn|j
��YnXd|_|S|dk�r��j|||f|�Std��dS)a�Open
a tar archive for reading, writing or appending. Return
           an appropriate TarFile class.

           mode:
           'r' or 'r:*' open for reading with
transparent compression
           'r:'         open for reading exclusively uncompressed
           'r:gz'       open for reading with gzip compression
           'r:bz2'      open for reading with bzip2 compression
           'r:xz'       open for reading with lzma compression
           'a' or 'a:'  open for appending, creating
the file if necessary
           'w' or 'w:'  open for writing without
compression
           'w:gz'       open for writing with gzip compression
           'w:bz2'      open for writing with bzip2 compression
           'w:xz'       open for writing with lzma compression

           'x' or 'x:'  create a tarfile exclusively
without compression, raise
                        an exception if the file is already created
           'x:gz'       create a gzip compressed tarfile, raise
an exception
                        if the file is already created
           'x:bz2'      create a bzip2 compressed tarfile, raise
an exception
                        if the file is already created
           'x:xz'       create an lzma compressed tarfile, raise
an exception
                        if the file is already created

           'r|*'        open a stream of tar blocks with
transparent compression
           'r|'         open an uncompressed stream of tar blocks
for reading
           'r|gz'       open a gzip compressed stream of tar
blocks
           'r|bz2'      open a bzip2 compressed stream of tar
blocks
           'r|xz'       open an lzma compressed stream of tar
blocks
           'w|'         open an uncompressed stream for writing
           'w|gz'       open a gzip compressed stream for writing
           'w|bz2'      open a bzip2 compressed stream for
writing
           'w|xz'       open an lzma compressed stream for
writing
        znothing to
openr{�r:*cs�j|dkS)N�taropen)�	OPEN_METH)r�)r.r6r7�not_compressed�sz$TarFile.open.<locals>.not_compressed)�keyNz%file
could not be opened successfully�:r#r�zunknown compression type
%r�|r|zmode must be 'r' or
'w'Fr�rlzundiscernible
mode)r{r�)r{r|)r�r|rl)
r.�sortedr�rmr�rrr�r0r�r�r�r�)
r.r�rir�r`�kwargsr�r��funcZ	saved_posrh�streamr�r6)r.r7r�sP%







zTarFile.opencKs |dkrtd��||||f|�S)zCOpen
uncompressed tar archive name for reading or writing.
        r{r�r|rlz!mode must be 'r', 'a',
'w' or
'x')r{r�r|rl)r.)r.r�rir�r�r6r6r7r�szTarFile.taropenr�cKs�|dkrtd��yddl}|jWn
ttfk
rBtd��YnXy|j||d||�}Wn.tk
r�|dk	r�|dkr�td	���YnXy|j|||f|�}WnBtk
r�|j	�|dkr�td	���Yn|j	��YnXd
|_
|S)zkOpen gzip compressed tar archive name for reading or writing.
           Appending is not allowed.
        r{r|rlzmode must be 'r', 'w' or
'x'rNzgzip module is not availablercznot a gzip
fileF)r{r|rl)r.�gzipZGzipFiler��AttributeErrorrr�rr�r�r�)r.r�rir��
compresslevelr�r�r�r6r6r7�gzopen"s2
zTarFile.gzopencKs�|dkrtd��yddl}Wntk
r8td��YnX|j|pD|||d�}y|j|||f|�}WnFttfk
r�|j�|dkr�t	d	���Yn|j��YnXd
|_
|S)zlOpen bzip2 compressed tar archive name for reading or writing.
           Appending is not allowed.
        r{r|rlzmode must be 'r', 'w' or
'x'rNzbz2 module is not available)r�znot a bzip2
fileF)r{r|rl)r.r�r�rZBZ2Filer�r��EOFErrorr�rr�)r.r�rir�r�r�r�r�r6r6r7�bz2openDs(zTarFile.bz2opencKs�|dkrtd��yddl}Wntk
r8td��YnX|j|pD|||d�}y|j|||f|�}WnH|jtfk
r�|j�|dkr�t	d	���Yn|j��YnXd
|_
|S)zkOpen lzma compressed tar archive name for reading or writing.
           Appending is not allowed.
        r{r|rlzmode must be 'r', 'w' or
'x'rNzlzma module is not available)�presetznot an lzma
fileF)r{r|rl)r.r�r�rZLZMAFiler�r�r�r�rr�)r.r�rir�r�r�r�r�r6r6r7�xzopenas&zTarFile.xzopenr�r�r�r�)r�r�r�r�c
Cs�|jr
dSd|_z`|jdkrn|jjttd�|jtd7_t|jt�\}}|dkrn|jjtt|�Wd|j	s�|jj
�XdS)	zlClose the TarFile. In write-mode, two finishing zero blocks are
           appended to the archive.
        NTr�r|rlr$r)r�r|rl)r�rir�r\r1r�r�rZ�
RECORDSIZEr�r�)r�rarbr6r6r7r��s
z
TarFile.closecCs"|j|�}|dkrtd|��|S)aReturn
a TarInfo object for member `name'. If `name' can not be
           found in the archive, KeyError is raised. If a member occurs
more
           than once in the archive, its last occurrence is assumed to be
the
           most up-to-date version.
        Nzfilename %r not found)�
_getmember�KeyError)r�r�r�r6r6r7�	getmember�s
zTarFile.getmembercCs|j�|js|j�|jS)z�Return the
members of the archive as a list of TarInfo objects. The
           list has the same order as the members in the archive.
        )�_checkr��_loadr�)r�r6r6r7�
getmembers�szTarFile.getmemberscCsdd�|j�D�S)z�Return
the members of the archive as a list of their names. It has
           the same order as the list returned by getmembers().
        cSsg|]
}|j�qSr6)r�)rkr�r6r6r7rm�sz$TarFile.getnames.<locals>.<listcomp>)r�)r�r6r6r7�getnames�szTarFile.getnamescCsp|jd�|dk	r|j}|dkr$|}tjj|�\}}|jtjd�}|jd�}|j�}||_	|dkr�t
td�r�|jr�tj|�}q�tj
|�}ntj|j��}d}|j}t
j|��r|j|jf}	|jr�|jdkr�|	|jkr�||j|	kr�t}
|j|	}nt}
|	d�rx||j|	<nht
j|��r"t}
nVt
j|��r4t}
nDt
j|��rPt}
tj|�}n(t
j|��rbt }
nt
j!|��rtt"}
ndS||_||_#|j$|_%|j&|_'|
tk�r�|j(|_)nd|_)|j*|_+|
|_,||_-t.�r�yt.j/|j%�d|_0Wnt1k
�r�YnXt2�r*yt2j3|j'�d|_4Wnt1k
�r(YnX|
t t"fk�rlt
td��rlt
td	��rltj5|j6�|_7tj8|j6�|_9|S)
a�Create a TarInfo object from the result of os.stat or equivalent
           on an existing file. The file is either named by `name', or
           specified as a file object `fileobj' with a file
descriptor. If
           given, `arcname' specifies an alternative name for the file
in the
           archive, otherwise, the name is taken from the 'name'
attribute of
           'fileobj', or the 'name' argument. The name
should be a text
           string.
        �awxNr��lstatr�r#r�major�minor):r�r�r~r%�
splitdriver�r�r�r�r�r�r�r�rg�fstat�fileno�st_mode�S_ISREG�st_ino�st_dev�st_nlinkr�rvr�S_ISDIRr�S_ISFIFOry�S_ISLNKru�readlink�S_ISCHRr3�S_ISBLKr4ri�st_uidr)�st_gidr*�st_sizer'�st_mtimer(r�r��pwd�getpwuidr+r��grpZgetgrgidr,r��st_rdevr�r�r�)r�r��arcnamer�Zdrvr�Zstatresr�Zstmd�inoder�r6r6r7�
gettarinfo�s~	




zTarFile.gettarinfoT)r�cCs0|j�|dkr|}�x|D�]
}|r�|jdkr:td�nttj|j��td|jpX|j|jpb|jf�|j	�sz|j
�r�tdd|j|jf�ntd|j
�|jdkr�td�ntdtj|j�dd	��t|j|j�r�d
nd�|�r"|j��r
td|j�|j��r"td
|j�t�qWdS)aPrint a
table of contents to sys.stdout. If `verbose' is False, only
           the names of the members are printed. If it is True, an `ls
-l'-like
           output is produced. `members' is optional and must be a
subset of the
           list returned by getmembers().
        Nz
??????????z%s/%sz%10sz%d,%dz%10dz????-??-?? ??:??:??z%d-%02d-%02d
%02d:%02d:%02dr�r�r�z-> zlink to
)r�rirqrgrhr+r)r,r*rwrxr�r�r'r(r�Z	localtimer�r�r�r�r�rp)r��verboser�r�r6r6r7rhs2





zTarFile.list)�filterc	
Csv|jd�|dkr|}|dk	rPddl}|jdtd�||�rP|jdd|�dS|jdk	r�tjj|�|jkr�|jdd|�dS|jd|�|j	||�}|dkr�|jdd	|�dS|dk	r�||�}|dkr�|jdd|�dS|j
��rt|d
��}|j||�WdQRXnd|j
��rh|j|�|�rrxHtj|�D].}|jtjj||�tjj||�|||d��q4Wn
|j|�dS)a~Add the file `name' to the archive. `name' may
be any type of file
           (directory, fifo, symbolic link, etc.). If given, `arcname'
           specifies an alternative name for the file in the archive.
           Directories are added recursively by default. This can be
avoided by
           setting `recursive' to False. `exclude' is a function
that should
           return True for each filename to be excluded. `filter' is a
function
           that expects a TarInfo object argument and returns the changed
           TarInfo object, if it returns None the TarInfo object will be
           excluded from the archive.
        r�Nrzuse the filter argument insteadr$ztarfile: Excluded
%rztarfile: Skipped %rr#ztarfile: Unsupported type
%rr�)r�)r�rdrerf�_dbgr�r~r%r�r�r�r��addfiler��listdir�addr�)	r�r�r��	recursiveZexcluder�rdr��fr6r6r7r�BsB



zTarFile.addcCs�|jd�tj|�}|j|j|j|j�}|jj|�|jt	|�7_|j
}|dk	r�t||j|j|d�t
|jt�\}}|dkr�|jjtt|�|d7}|j|t7_|jj|�dS)aAdd
the TarInfo object `tarinfo' to the archive. If `fileobj' is
           given, it should be a binary file, and tarinfo.size bytes are
read
           from it and added to the archive. You can create TarInfo objects
           directly, or by using gettarinfo().
       
r�N)r`rr#)r�rrrPr4r5r�r\r�r0r�rYr'rZr�r1r�r�)r�r�r�rUr`rarbr6r6r7r�s

zTarFile.addfilecCsp|dkr0|j}|dkrtSt|t�r,td��|St|�r<|Syt|Stk
rjtd|�d��d�YnXdS)Nz#String names are not supported for
z2TarFile.extraction_filter. Use a function such as ztarfile.data_filter
directly.zfilter z
 not foundzUString names are not supported for TarFile.extraction_filter.
Use a function such as zrString names are not supported for
TarFile.extraction_filter. Use a function such as tarfile.data_filter
directly.)	�extraction_filterr�r'r)�	TypeError�callable�_NAMED_FILTERSr�r.)r�r�r6r6r7�_get_filter_function�s
zTarFile._get_filter_function�.)�
numeric_ownerr�cCs�g}|j|�}|dkr|}xN|D]F}|j|||�}|dkr<q
|j�rN|j|�|j|||j�|d�q
W|jdd�dd�xv|D]n}tjj||j	�}	y,|j
||	|d�|j||	�|j||	�Wq�t
k
r�}
z|j|
�WYdd}
~
Xq�Xq�WdS)a�Extract all members from the archive to the current
working
           directory and set owner, modification time and permissions on
           directories afterwards. `path' specifies a different
directory
           to extract to. `members' is optional and must be a subset
of the
           list returned by getmembers(). If `numeric_owner` is True, only
           the numbers for user/group names are used and not the names.

           The `filter` function will be called on each member just
           before extraction.
           It can return a changed TarInfo or None to skip the member.
           String names of common filters are accepted.
       
N)�	set_attrsr�cSs|jS)N)r�)r�r6r6r7�<lambda>�sz$TarFile.extractall.<locals>.<lambda>T)r��reverse)r�)r��_get_extract_tarinfor�r��_extract_one�sortr~r%r�r��chown�utime�chmodr
�_handle_nonfatal_error)r�r%r�r�r�Zdirectories�filter_functionr�r��dirpathr�r6r6r7�
extractall�s*



zTarFile.extractallr�cCs4|j|�}|j|||�}|dk	r0|j||||�dS)a�Extract
a member from the archive to the current working directory,
           using its full name. Its file information is extracted as
accurately
           as possible. `member' may be a filename or a TarInfo
object. You can
           specify a different directory using `path'. File attributes
(owner,
           mtime, mode) are set unless `set_attrs' is False. If
`numeric_owner`
           is True, only the numbers for user/group names are used and not
           the names.

           The `filter` function will be called before extraction.
           It can return a changed TarInfo or None to skip the member.
           String names of common filters are accepted.
       
N)r�r�r�)r�r�r%r�r�r�r�r�r6r6r7�extract�s
zTarFile.extractcCs�t|t�r|j|�}n|}|}y|||�}WnZttfk
r\}z|j|�WYdd}~Xn,tk
r�}z|j|�WYdd}~XnX|dkr�|jdd|j	�dS|j
�r�tj|�}tj
j||j�|_|S)z@Get filtered TarInfo (or
None) from member, which might be a strNr$ztarfile: Excluded
%r)r'r)r�r�r��_handle_fatal_errorr
r�r�r�r�rr~r%r�r�r�)r�r�r�r%r�Z
unfilteredr�r6r6r7r��s"

zTarFile._get_extract_tarinfocCs�|jd�y"|j|tjj||j�||d�WnVtk
rX}z|j|�WYdd}~Xn,tk
r�}z|j	|�WYdd}~XnXdS)z%Extract from filtered tarinfo to
diskr{)r�r�N)
r��_extract_memberr~r%r�r�r�r�r
r�)r�r�r%r�r�r�r6r6r7r�	s
zTarFile._extract_onecCs"|jdkr�n|jdd|�dS)z=Handle
non-fatal error (ExtractError) according to errorlevelr#ztarfile:
%sN)r�r�)r�r�r6r6r7r�	s
zTarFile._handle_nonfatal_errorcCsn|jdkr�n\t|t�rP|jdkr6|jdd|j�qj|jdd|j|jf�n|jddt|�j|f�dS)z1Handle
"fatal" error according to self.errorlevelrNr#ztarfile:
%sztarfile: %s %rztarfile: %s
%s)r�r'r��filenamer��strerrorr�rr)r�r�r6r6r7r�	s


zTarFile._handle_fatal_errorcCs�|jd�t|t�r
|j|�}n|}|j�s6|jtkrB|j||�S|j�sR|j	�rzt|j
t�rhtd��q~|j
|j|��SndSdS)z�Extract a member from
the archive as a file object. `member' may be
           a filename or a TarInfo object. If `member' is a regular
file or a
           link, an io.BufferedReader object is returned. Otherwise, None
is
           returned.
        r{z'cannot extract (sym)link as file
objectN)r�r'r)r�r�r�rW�
fileobjectr�r�r�r�r	�extractfile�_find_link_target)r�r�r�r6r6r7r�!	s


zTarFile.extractfilecCsV|jd�}|jdtj�}tjj|�}|r@tjj|�r@tj|�|j�sP|j	�rj|j
dd|j|jf�n|j
d|j�|j
�r�|j||�n�|j�r�|j||�nx|j�r�|j||�nb|j�s�|j�r�|j||�nD|j�s�|j	�r�|j||�n&|jtk�r|j||�n|j||�|�rR|j|||�|j	��sR|j||�|j||�dS)z\Extract
the TarInfo object tarinfo to a physical
           file called targetpath.
        r�r#z%s ->
%sN)rHr�r~r�r%�dirnamer��makedirsr�r�r�r�r�r��makefiler��makedirrz�makefiforwrx�makedev�makelinkr�rW�makeunknownr�r�r�)r�r��
targetpathr�r�Z	upperdirsr6r6r7r�@	s4


zTarFile._extract_membercCs@y&|jdkrtj|�ntj|d�Wntk
r:YnXdS)z,Make a directory called targetpath.
       
Ni�)rir~�mkdir�FileExistsError)r�r�r�r6r6r7r�q	s
zTarFile.makedircCs�|j}|j|j�|j}t|d��f}|jdk	rrx,|jD]"\}}|j|�t|||t|�q6W|j|j�|j	�nt|||jt|�WdQRXdS)z'Make
a file called targetpath.
        r�N)
r�r�r�r�r�r�rYrr'�truncate)r�r�r��sourcer`�targetr�r'r6r6r7r�	s


zTarFile.makefilecCs"|j||�|jdd|j�dS)zYMake a
file from a TarInfo object with an unknown type
           at targetpath.
        r#z9tarfile: Unknown file type %r, extracted as regular
file.N)r�r�r�)r�r�r�r6r6r7r��	szTarFile.makeunknowncCs"ttd�rtj|�ntd��dS)z'Make
a fifo called targetpath.
        �mkfifozfifo not supported by systemN)r�r~r�r
)r�r�r�r6r6r7r��	s
zTarFile.makefifocCsnttd�sttd�r
td��|j}|dkr2d}|j�rF|tjO}n
|tjO}tj||tj	|j
|j��dS)z<Make a character or block device called targetpath.
        �mknodr�z'special devices not supported by
systemNi�)r�r~r
rirxrg�S_IFBLK�S_IFCHRr�r�r�r�)r�r�r�rir6r6r7r��	s
zTarFile.makedevcCs�yL|j�rtj|j|�n0tjj|j�r8tj|j|�n|j|j	|�|�WnHt
k
r�y|j|j	|�|�Wntk
r�td��YnXYnXdS)z�Make a (symbolic) link called
targetpath. If it cannot be created
          (platform limitation), we try to make a copy of the referenced
file
          instead of a link.
        z%unable to resolve link inside
archiveN)
r�r~�symlinkr�r%r�r��linkr�r��symlink_exceptionr�r
)r�r�r�r6r6r7r��	s

zTarFile.makelinkcCs�ttd�r�tj�dkr�|j}|j}|s�ytrB|jrBtj|j�d}Wntk
rXYnXyt	rv|j
rvt	j|j
�d}Wntk
r�YnX|dkr�d}|dkr�d	}y4|j�r�ttd�r�tj
|||�ntj|||�Wntk
r�td��YnXdS)
z�Set owner of targetpath according to tarinfo. If numeric_owner
           is True, use .gid/.uid instead of .gname/.uname. If
numeric_owner
           is False, fall back to .gid/.uid when the search based on name
           fails.
        �geteuidrr$Nr#�lchownzcould not change
ownerr9r9)r�r~rr*r)r�r,Zgetgrnamr�r�r+�getpwnamr�rr�r�r
)r�r�r�r��g�ur6r6r7r��	s0

z
TarFile.chowncCsL|jdkrdSttd�rHytj||j�Wntk
rFtd��YnXdS)zASet file permissions of targetpath according to
tarinfo.
        Nr�zcould not change mode)rir�r~r�r�r
)r�r�r�r6r6r7r��	s

z
TarFile.chmodcCsV|j}|dkrdSttd�s
dSytj|||f�Wntk
rPtd��YnXdS)zBSet modification time of targetpath according
to tarinfo.
        Nr�z"could not change modification time)r(r�r~r�r�r
)r�r�r�r(r6r6r7r��	s
z
TarFile.utimecCs�|jd�|jdk	r$|j}d|_|S|j|jj�krZ|jj|jd�|jjd�sZtd��d}�xby|jj	|�}W�nHt
k
r�}z2|jr�|jdd|j|f�|jt
7_wbWYdd}~Xn�tk
�r,}zN|j�r|jdd|j|f�|jt
7_wbn|jdk�rtt|���WYdd}~Xn�tk
�rT|jdk�rPtd��Ynjtk
�r�}z|jdk�r~tt|���WYdd}~Xn0tk
�r�}ztt|���WYdd}~XnXPqbW|dk	�r�|jj|�nd	|_|S)
z�Return the next member of the archive as a TarInfo object, when
           TarFile is opened for reading. Return None if there is no more
           available.
        ZraNr#zunexpected end of datar$z0x%X: %srz
empty
fileT)r�r�r�r�r�r�r[rr�rQrxr�r�r�rHr)rvrwryr�r�r�)r��mr�r�r6r6r7rZ
sL


zTarFile.nextc	Cs�|j�}d}|dk	rHy|j|�}Wntk
r:d}YnX|d|�}|rXtjj|�}xLt|�D]@}|r||j|jkrbd}qb|r�tjj|j�}n|j}||krb|SqbW|r�t|��dS)z}Find
an archive member by name from bottom to top.
           If tarinfo is given, it is used as the starting point.
       
FNT)	r��indexr.r~r%�normpath�reversedr�r�)	r�r�r��	normalizer�Zskippingr	r��member_namer6r6r7r�7
s,
zTarFile._getmembercCs"x|j�}|dkrPqWd|_dS)zWRead
through the entire archive file and look for readable
           members.
        NT)rZr�)r�r�r6r6r7r�_
s
z
TarFile._loadcCs:|jrtd|jj��|dk	r6|j|kr6td|j��dS)znCheck
if TarFile is still open, and if the operation's mode
           corresponds to TarFile's mode.
        z%s is closedNzbad operation for mode
%r)r�r�r�rrri)r�rir6r6r7r�i
szTarFile._checkcCs`|j�r.djtdtjj|j�|jf��}d}n
|j}|}|j||dd�}|dkr\t	d|��|S)zZFind the target
member of a symlink or hardlink member in the
           archive.
        r�NT)r�rzlinkname %r not found)
r�r�r�r~r%r�r�r�r�r�)r�r�r��limitr�r6r6r7r�r
s
zTarFile._find_link_targetccs�|jr|jEdHdSd}|jdk	r:|j�}|d7}|VxN|t|j�krV|j|}n"|jst|j�}|sxd|_dSndS|d7}|Vq<WdS)z$Provide
an iterator object.
        Nrr#T)r�r�r�rZr0)r�r	r�r6r6r7�__iter__�
s&
zTarFile.__iter__cCs||jkrt|tjd�dS)z.Write
debugging output to sys.stderr.
       
)�fileN)r�rprn�stderr)r��level�msgr6r6r7r��
s
zTarFile._dbgcCs|j�|S)N)r�)r�r6r6r7�	__enter__�
szTarFile.__enter__cCs,|dkr|j�n|js"|jj�d|_dS)NT)r�r�r�r�)r�r�r�	tracebackr6r6r7�__exit__�
s


zTarFile.__exit__)
Nr{NNNNNNrNNNN)r{N)r{Nr�)r{Nr�)r{NN)NNN)T)NTN)N)r�N)r�T)TF)NF)N)>rrrsrtrur�r�r�r�rrPrr4r5rr�r�r�r�r�rr�rr�r�r�r�r�r�r�r�r�r�rhr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rZr�r�r�r�rr�rrr6r6r6r7r4s�
lZ!

d&=
,

0!6
(

	cCs.yt|�}|j�dStk
r(dSXdS)zfReturn True if name points to a tar archive that we
       are able to handle, else return False.
    TFN)rr�r)r�r�r6r6r7r�
scCsddl}d}|j|d�}|jdddddd	�|jd
dtdd
�|j�}|jddddd�|jdddd5dd�|jdddd6dd�|jdddd
d�|j�}|jr�|jr�|jd!d"�|j	�r*|j	}t
|��rt|d#��
}|j�t
|j�tjd$�WdQRX|j�r&t
d%j|��n|jd!d&j|���n�|j�r�|j}t
|��rjtj|d'��}|j|jd(�WdQRXn|jd!d&j|���n�|j�rPt|j�d!k�r�|jd}tj}n,t|j�d)k�r�|j\}}n|jd!|j��t
|��r<tj|d'��}|j||jd*�WdQRX|j�rN|d+k�r&d,j|�}	nd-j||�}	t
|	�n|jd!d&j|��n�|j�r�|jjd�}
tjj|
�\}}d.d.d/d/d0d0d0d0d1�}
||
k�r�d2|
|nd3}|j}tj|
|�� }x|D]}|j|��q�WWdQRX|j�rt
d4j|
��n|jd!|j��dS)7Nrz3A simple command line interface for
tarfile module.)�descriptionz-vz	--verbose�
store_trueFzVerbose
output)�action�default�helpz--filterz<filtername>zFilter
for
extraction)�metavar�choicesrz-lz--list�	<tarfile>zShow
listing of a
tarfile)rrz-ez	--extract�+�<output_dir>zExtract tarfile
into target
dir)�nargsrrz-cz--create�<name>�<file>zCreate
tarfile from sourcesz-tz--testzTest if a tarfile is
validr#z&--filter is only valid for extraction
r{)rz{!r} is a tar archive.z{!r} is not a tar archive.
zr:*)r�r$)r%r�r�z{!r} file is extracted.z+{!r} file is
extracted into {!r}
directory.r�r�r�)z.gzz.tgzz.xzz.txzz.bz2z.tbzz.tbz2z.tb2zw:r|z{!r}
file created.)rr
)r"r#)�argparse�ArgumentParser�add_argumentr�Zadd_mutually_exclusive_group�
parse_argsr�r��exitZtestrrr�rprnrr�rPrhrr0r~�curdirZformat_helpr�Zcreate�popr%�splitextr�)r$r�parserr`�argsr]r�Ztfr)rZtar_namerjZextZcompressionsZtar_modeZ	tar_files�	file_namer6r6r7�main�
s�










r/�__main__)r%r&r'r(r)r*r+r,)T)pru�version�
__author__Z__date__Z	__cvsid__�__credits__�builtinsrr�rnr~r�rXrgr�rSr�rerdr�r�r�r��NotImplementedErrorrr��	NameError�__all__r1r�r�rrrrr1rrErvrur3r4rryZCONTTYPErrrFr+r-rTr
rrrrWrsrIrprcr(rFrqr�r�getfilesystemencodingr8r=rKrQrVrYrhrq�	Exceptionrr
rrr	rrvrwrxrHryrzr��objectr�r��BufferedReaderr��compiler^r�r�r�r�r�r�r�r�r�r�r�rrrrr/rrr6r6r6r7�<module>s



wh	

8eb