| Server IP : 127.0.0.1 / Your IP : 216.73.216.109 Web Server : Apache/2.4.54 (Win64) OpenSSL/1.1.1q PHP/8.1.10 System : Windows NT DESKTOP-E5T4RUN 10.0 build 19045 (Windows 10) AMD64 User : SERVERWEB ( 0) PHP Version : 8.1.10 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : C:/cygwin64/lib/python3.9/site-packages/olefile/__pycache__/ |
Upload File : |
a
��a_� � @ s� d Z ddlmZ dZdZdZg d�ZddlZddlZddl Z ddl
Z
ddl Z ddl
Z
ddlZeeurheZzeZW n eZY n0 e
�
d�jd kr�dZn4e
�
d
�jd kr�d
Zn e
�
d �jd kr�d Zned ��ze W n ey� eZY n0 d
Zej d dk �rdZ ndZ ej d fdd�Z e d�Z dd� Z!dZ"dZ#dZ$dZ%dZ&dZ'dZ(dZ)dZ*dZ+d Z,dZ-d Z.d Z/d Z0dZ1dZ2d Z3dZ4d Z5d Z6d Z7d Z8d!Z9d"Z:d#Z;d$Z<d%Z=d&Z>d'Z?d(Z@d)ZAd*ZBd+ZCd,ZDd-ZEd.ZFd/ZGd0ZHd1ZId2ZJd3ZKd4ZLd5ZMd6ZNd7ZOd8ZPd9ZQd:ZRd;ZSd<ZTd=ZUd>ZVd?ZWd@ZXdAZYdBZZd#Z[d,Z\d6Z]dCZ^dDZ_dEdF� Z`eeu �r@dGdH� ZandIdH� Zad]dJdK�Zbd^dLdM�ZcdNdO� ZddPdQ� ZeG dRdS� dS�ZfG dTdU� dUejg�ZhG dVdW� dW�ZiG dXdY� dY�ZjdZd[� Zkeld\k�r�ek� dS )_a:
olefile (formerly OleFileIO_PL)
Module to read/write Microsoft OLE2 files (also called Structured Storage or
Microsoft Compound Document File Format), such as Microsoft Office 97-2003
documents, Image Composer and FlashPix files, Outlook messages, ...
This version is compatible with Python 2.7 and 3.4+
Project website: https://www.decalage.info/olefile
olefile is copyright (c) 2005-2018 Philippe Lagadec
(https://www.decalage.info)
olefile is based on the OleFileIO module from the PIL library v1.1.7
See: http://www.pythonware.com/products/pil/index.htm
and http://svn.effbot.org/public/tags/pil-1.1.7/PIL/OleFileIO.py
The Python Imaging Library (PIL) is
Copyright (c) 1997-2009 by Secret Labs AB
Copyright (c) 1995-2009 by Fredrik Lundh
See source code and LICENSE.txt for information on usage and redistribution.
� )�print_functionz
2018-09-09z0.46zPhilippe Lagadec)� isOleFile� OleFileIO� OleMetadata�enable_logging�MAGIC� STGTY_EMPTY�KEEP_UNICODE_NAMES� STGTY_STREAM�
STGTY_STORAGE�
STGTY_ROOT�STGTY_PROPERTY�STGTY_LOCKBYTES�MINIMAL_OLEFILE_SIZE�
DEFECT_UNSURE�DEFECT_POTENTIAL�DEFECT_INCORRECT� DEFECT_FATAL�DEFAULT_PATH_ENCODING�
MAXREGSECT�DIFSECT�FATSECT�
ENDOFCHAIN�FREESECT� MAXREGSID�NOSTREAM� UNKNOWN_SIZE�
WORD_CLSIDN�L� �I�iz>Need to fix a bug with 32 bit arrays, please contact author...T� zutf-8� c C sL | t jjjv r&t �| �}|�|� |S t �| �}|�t �� � |�|� |S )an
Create a suitable logger object for this module.
The goal is not to change settings of the root logger, to avoid getting
other modules' logs on the screen.
If a logger exists with same name, reuse it. (Else it would have duplicate
handlers and messages would be doubled.)
The level is set to CRITICAL+1 by default, to avoid any logging.
)�loggingZLogger�managerZ
loggerDictZ getLogger�setLevelZ
addHandlerZ NullHandler)�name�level�logger� r* �3/usr/lib/python3.9/site-packages/olefile/olefile.py�
get_logger� s
r, �olefilec C s t �tj� dS )z�
Enable logging for this module (disabled by default).
This will set the module-specific logger level to NOTSET, which
means the main application controls the actual logging level.
N)�logr& r$ ZNOTSETr* r* r* r+ r � s r s ��ࡱ�l �� l �� l �� l �� � �� � � i���� � � � �
� � �
� � � � � � � � � � � � � � � � � �@ �A �B �C �D �E �F �G �H � z$00020900-0000-0000-C000-000000000046�( i c C s� t | d�r$| �tt��}| �d� n`t| t�rLt| �tkrL| dtt�� }n8t| d�� }|�tt��}W d � n1 sz0 Y |tkr�dS dS dS )aJ
Test if a file is an OLE container (according to the magic bytes in its header).
.. note::
This function only checks the first 8 bytes of the file, not the
rest of the OLE structure.
.. versionadded:: 0.16
:param filename: filename, contents or file-like object of the OLE file (string-like or file-like object)
- if filename is a string smaller than 1536 bytes, it is the path
of the file to open. (bytes or unicode string)
- if filename is a string longer than 1535 bytes, it is parsed
as the content of an OLE file in memory. (bytes type only)
- if filename is a file-like object (with read and seek methods),
it is parsed as-is.
:type filename: bytes or str or unicode or file
:returns: True if OLE, False otherwise.
:rtype: bool
�readr N�rbTF) �hasattrrV �lenr �seek�
isinstance�bytesr �open)�filename�header�fpr* r* r+ r s
,r c C s t | �S �N)�ord��cr* r* r+ �i8? s re c C s | j tu r| S | d S �Nr )� __class__�intrc r* r* r+ re C s c C s t �d| ||d � �d S )z�
Converts a 2-bytes (16 bits) string to an integer.
:param c: string containing bytes to convert
:param o: offset of bytes to convert in string
z<Hr0 r ��struct�unpack�rd �or* r* r+ �i16G s rn c C s t �d| ||d � �d S )z�
Converts a 4-bytes (32 bits) string to an integer.
:param c: string containing bytes to convert
:param o: offset of bytes to convert in string
z<Ir r ri rl r* r* r+ �i32Q s ro c C sD | � d�sdS dt| d�t| d�t| d�fttt| dd� �� S ) z^
Converts a CLSID to a human-readable string.
:param clsid: string of length 16.
� � z0%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02Xr r r2 r4 r; )�stripro rn �tuple�mapre )�clsidr* r* r+ �_clsid[ s
��rv c C s( t � dddddd�}|t j| d d� S )zL
convert FILETIME (64 bits int) to Python datetime.datetime
�A r# r r6 �Z microseconds)�datetime� timedelta)Zfiletime�_FILETIME_null_dater* r* r+ �filetime2datetimel s r| c @ s8 e Zd ZdZg d�Zg d�Zdd� Zdd� Zdd � Zd
S ) r aT
class to parse and store metadata from standard properties of OLE files.
Available attributes:
codepage, title, subject, author, keywords, comments, template,
last_saved_by, revision_number, total_edit_time, last_printed, create_time,
last_saved_time, num_pages, num_words, num_chars, thumbnail,
creating_application, security, codepage_doc, category, presentation_target,
bytes, lines, paragraphs, slides, notes, hidden_slides, mm_clips,
scale_crop, heading_pairs, titles_of_parts, manager, company, links_dirty,
chars_with_spaces, unused, shared_doc, link_base, hlinks, hlinks_changed,
version, dig_sig, content_type, content_status, language, doc_version
Note: an attribute is set to None when not present in the properties of the
OLE file.
References for SummaryInformation stream:
- https://msdn.microsoft.com/en-us/library/dd942545.aspx
- https://msdn.microsoft.com/en-us/library/dd925819%28v=office.12%29.aspx
- https://msdn.microsoft.com/en-us/library/windows/desktop/aa380376%28v=vs.85%29.aspx
- https://msdn.microsoft.com/en-us/library/aa372045.aspx
- http://sedna-soft.de/articles/summary-information-stream/
- https://poi.apache.org/apidocs/org/apache/poi/hpsf/SummaryInformation.html
References for DocumentSummaryInformation stream:
- https://msdn.microsoft.com/en-us/library/dd945671%28v=office.12%29.aspx
- https://msdn.microsoft.com/en-us/library/windows/desktop/aa380374%28v=vs.85%29.aspx
- https://poi.apache.org/apidocs/org/apache/poi/hpsf/DocumentSummaryInformation.html
new in version 0.25
)�codepage�title�subject�author�keywords�comments�template�
last_saved_by�revision_number�total_edit_time� last_printed� create_time�last_saved_time� num_pages� num_words� num_chars� thumbnail�creating_application�security) � codepage_doc�category�presentation_targetr\ �lines�
paragraphs�slides�notes�
hidden_slides�mm_clips�
scale_crop�
heading_pairs�titles_of_partsr% �company� links_dirty�chars_with_spaces�unused�
shared_doc� link_base�hlinks�hlinks_changed�version�dig_sig� content_type�content_status�language� doc_versionc C s d| _ d| _d| _d| _d| _d| _d| _d| _d| _d| _ d| _
d| _ d| _ d| _
d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _ d| _ d| _ d| _ d| _ d| _!d| _"d| _#d| _$d| _%d| _&d| _'d| _(d| _)d| _*d| _+d| _,d| _-d| _.dS )z_
Constructor for OleMetadata
All attributes are set to None by default
N)/r} r~ r r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r\ r� r� r� r� r� r� r� r� r� r% r� r� r� r� r� r� r� r� r� r� r� r� r� r� ��selfr* r* r+ �__init__� s^ zOleMetadata.__init__c C s� | j | j D ]}t| |d� q |�d�rp|jdddgd�}tt| j ��D ]&}|�|d d�}t| | j | |� qH|�d�r�|jddd�}tt| j��D ]&}|�|d d�}t| | j| |� q�dS ) a=
Parse standard properties of an OLE file, from the streams
``\x05SummaryInformation`` and ``\x05DocumentSummaryInformation``,
if present.
Properties are converted to strings, integers or python datetime objects.
If a property is not present, its value is set to None.
NzSummaryInformationTr6 )� convert_time�
no_conversionr# zDocumentSummaryInformation�r� )�SUMMARY_ATTRIBS�DOCSUM_ATTRIBS�setattr�exists�
getproperties�rangerY �get)r� r- Zattrib�propsr! �valuer* r* r+ �parse_properties� s
�
�z OleMetadata.parse_propertiesc C sh t d� | jD ]"}t| |�}t d|t|�f � qt d� | jD ]"}t| |�}t d|t|�f � q@dS )z<
Dump all metadata, for debugging purposes.
z*Properties from SummaryInformation stream:�- %s: %sz2Properties from DocumentSummaryInformation stream:N)�printr� �getattr�reprr� )r� Zpropr� r* r* r+ �dump s
zOleMetadata.dumpN) �__name__�
__module__� __qualname__�__doc__r� r� r� r� r� r* r* r* r+ r z s $8 r c @ s e Zd ZdZdd� ZdS )� OleStreama�
OLE2 Stream
Returns a read-only file object which can be used to read
the contents of a OLE stream (instance of the BytesIO class).
To open a stream, use the openstream method in the OleFile class.
This function can be used with either ordinary streams,
or ministreams, depending on the offset, sectorsize, and
fat table arguments.
Attributes:
- size: actual size of data stream, after it was opened.
c C sB t �d� t �d|||||t|�t|�f � || _| jjjrFtd��d} |tkrlt|�| }d} t �d� ||d | }
t �d|
� |
t|�kr�| j� t
d � g } |d
kr�|t kr�t �d � | j� t
d � t |
�D �]�} t �d
| |f � |t k�r*| �rt �d� �q�nt �d� | j� t
d� |d
k �sB|t|�k�r�t �d||t|�f � t �d| |
f � | j� t
d� �q�z|�
||| � W n> t �d|||| |f � | j� t
d� Y �q�Y n0 |�|�}
t|
�|k�rT|t|�d k�rTt �d|t|�||| |t|
�f � t �d||| t|
� � | j� t
d� | �|
� z|| d@ }W q� t�y� | j� t
d� Y �q�Y q�0 q�d�| �} t| �|k�r�t �dt| �|f � | d |� } || _nR| �rt �d t| � � t| �| _n.t �d t| �|f � t| �| _| j� t
d � tj�| | � d S ) a_
Constructor for OleStream class.
:param fp: file object, the OLE container or the MiniFAT stream
:param sect: sector index of first sector in the stream
:param size: total size of the stream
:param offset: offset in bytes for the first FAT or MiniFAT sector
:param sectorsize: size of one sector
:param fat: array/list of sector indexes (FAT or MiniFAT)
:param filesize: size of OLE file (for debugging)
:param olefileio: OleFileIO object containing this stream
:returns: a BytesIO instance containing the OLE stream
zOleStream.__init__:zE sect=%d (%X), size=%d, offset=%d, sectorsize=%d, len(fat)=%d, fp=%sz2Attempting to open a stream from a closed OLE FileFTz stream with UNKNOWN SIZEr# �nb_sectors = %dz(malformed OLE document, stream too larger z!size == 0 and sect != ENDOFCHAIN:z+incorrect OLE sector index for empty streamz Reading stream sector[%d] = %Xhz6Reached ENDOFCHAIN sector for stream with unknown sizez$sect=ENDOFCHAIN before expected sizezincomplete OLE streamzsect=%d (%X) / len(fat)=%dzi=%d / nb_sectors=%d�,incorrect OLE FAT, sector index out of rangez sect=%d, seek=%d, filesize=%d� OLE sector index out of rangez9sect=%d / len(fat)=%d, seek=%d / filesize=%d, len read=%dzseek+len(read)=%d�incomplete OLE sectorr/ � z3Read data of length %d, truncated to stream size %dNz3Read data of length %d, the stream size was unknownz9Read data of length %d, less than expected stream size %dz%OLE stream size is less than declared)r. �debugrY r� �oler` �closed�OSErrorr �
_raise_defectr r r� rZ rV �append�
IndexError�join�size�io�BytesIOr� )r� r` �sectr� �offset�
sectorsize�fat�filesize� olefileioZ unknown_size�
nb_sectors�datar! Z sector_datar* r* r+ r� * s�
�
�
�
zOleStream.__init__N)r� r� r� r� r� r* r* r* r+ r� s r� c @ sr e Zd ZdZdZdZdd� Zdd� Zdd � Zd
d � Z d d
� Z
dd� Z dd� Z dd� Z
d dd�Zdd� Zdd� ZdS ) �OleDirectoryEntryz
OLE2 Directory Entry
z<64sHBBIII16sIQQIII� c C sj || _ || _g | _i | _d| _t�tj|�\| _ | _
| _ | _ | _
| _| _}| _| _| _| _| _| _| j ttttfvr�|�td� | j tkr�|dkr�|�td� |dkr�| j tkr�|�td� | j
dkr�|�td� d| _
| j d| j
d � | _ |� | j �| _ t � d
| j t!| j �f � t � d | j � t � d | j � t � d
| j
| j| jf � |j"dk�r�| jdk�r�| jdk�r�t � d|j"| j| j| jf � |�t#d� | j| _$n| jt%| j�d> | _$t � d| j$| j| jf � t&|�| _'| j tk�r| j$dk�r|�t(d� d| _)| j ttfv �r`| j$dk�r`| j$|j*k �rJ| j tk�rJd| _)nd| _)|�+| j| j)� d| _,dS )aI
Constructor for an OleDirectoryEntry object.
Parses a 128-bytes entry from the OLE Directory stream.
:param entry : string (must be 128 bytes long)
:param sid : index of this directory entry in the OLE file directory
:param olefile: OleFileIO containing this directory entry
Fzunhandled OLE storage typer zduplicate OLE root entryzincorrect OLE root entryrK z(incorrect DirEntry name length >64 bytesNr0 zDirEntry SID=%d: %sz - type: %dz - sect: %Xhz% - SID left: %d, right: %d, child: %d� r/ z+sectorsize=%d, sizeLow=%d, sizeHigh=%d (%X)zincorrect OLE stream size� z% - size: %d (sizeLow=%d, sizeHigh=%d)zOLE storage with size>0T)-�sidr- �kids� kids_dict�usedrj rk r� �STRUCT_DIRENTRYZname_rawZ
namelength�
entry_typeZcolor�sid_left� sid_right� sid_childZ dwUserFlags�
createTime�
modifyTime�
isectStartZsizeLowZsizeHighr r r
r r� r Z
name_utf16�_decode_utf16_strr' r. r� r� r� r r� �longrv ru r �
is_minifat�minisectorcutoff�_check_duplicate_stream�
sect_chain)r� �entryr� r- ru r* r* r+ r� � sv �
� �
�zOleDirectoryEntry.__init__c C s~ | j r
d S | jttfvs"| jdkr&d S t� | _ | jrB|jsB|�� | j }|t
krz| j � |� | jrn|j| }qH|j | }qHd S rf )
r� r� r r
r� �listr� �minifat� loadminifatr� r r� r� )r� r- Z next_sectr* r* r+ �build_sect_chain- s z"OleDirectoryEntry.build_sect_chainc C sB t �d| jt| j�| jf � | jtkr>| �| j� | j� � dS )z�
Read and build the red-black tree attached to this OleDirectoryEntry
object, if it is a storage.
Note that this method builds a tree of all subentries, so it should
only be called for the root object once.
z.build_storage_tree: SID=%d - %s - sid_child=%dN)
r. r� r� r� r' r� r � append_kidsr� �sortr� r* r* r+ �build_storage_tree@ s �
z$OleDirectoryEntry.build_storage_treec C s� t �d| � |tkrdS |dk s2|t| jj�krB| j�td� n�| j�|�}t �d|j t
|j �|j |j
|jf � |jr�| j�td� dS d|_| �|j � |j �� }|| jv r�| j�td� | j�|� || j|< | �|j
� |�� dS ) a)
Walk through red-black tree of children of this directory entry to add
all of them to the kids list. (recursive method)
:param child_sid: index of child directory entry to use, or None when called
first time for the root. (only used during recursion)
zappend_kids: child_sid=%dNr z OLE DirEntry index out of rangezHappend_kids: child_sid=%d - %s - sid_left=%d, sid_right=%d, sid_child=%dz#OLE Entry referenced more than onceTz!Duplicate filename in OLE storage)r. r� r rY r- �
direntriesr� r �_load_direntryr� r� r' r� r� r� r� r� �lowerr� r� r� r� )r� Z child_sid�childZ
name_lowerr* r* r+ r� X s2 ��
�
z OleDirectoryEntry.append_kidsc C s | j |j kS �zCompare entries by name�r' �r� �otherr* r* r+ �__eq__� s zOleDirectoryEntry.__eq__c C s | j |j k S r� r� r r* r* r+ �__lt__� s zOleDirectoryEntry.__lt__c C s | � |� S ra )r r r* r* r+ �__ne__� s zOleDirectoryEntry.__ne__c C s | � |�p| �|�S ra )r r r r* r* r+ �__le__� s zOleDirectoryEntry.__le__r c C s� g d�}z|| j }W n ty, d}Y n0 td| t| j� |dd� | j ttfv rht| jddd� t� | j ttfv r�| j r�td| d| j � | j
D ]}|� |d � q�dS ) zADump this entry, and all its subentries (for debug purposes only))z (invalid)z (storage)z(stream)z (lockbytes)z
(property)z(root)z (UNKNOWN)� ��endr\ z{%s}r0 N) r� r� r� r� r' r
r r� r ru r� r� )r� �tabZTYPES� type_name�kidr* r* r+ r� � s
zOleDirectoryEntry.dumpc C s | j dkrdS t| j �S )z�
Return modification time of a directory entry.
:returns: None if modification time is null, a python datetime object
otherwise (UTC timezone)
new in version 0.26
r N)r� r| r� r* r* r+ �getmtime� s
zOleDirectoryEntry.getmtimec C s | j dkrdS t| j �S )z�
Return creation time of a directory entry.
:returns: None if modification time is null, a python datetime object
otherwise (UTC timezone)
new in version 0.26
r N)r� r| r� r* r* r+ �getctime� s
zOleDirectoryEntry.getctimeN)r )r� r� r� r� r� Z
DIRENTRY_SIZEr� r� r� r� r r r r r� r r
r* r* r* r+ r� � s b/
r� c @ sZ e Zd ZdZdeddefdd�Zdd� Zdd � Ze fd
d �Z
dPd
d�Z dQdd�Z dd� Z
dRdd�ZdSdd�ZdTdd�Zdd� Zd d � Zd d � Zd d!� Zd"d#� ZdUd%d&�ZdVd'd(�Zd)d*� Zd+d,� Zd-d.� Zedfd/d0�Z dWd2d3�Z dXd4d5�Z d6d7� Z d8d9� Z d:d;� Z!d<d=� Z"d>d?� Z#d@dA� Z$dBdC� Z%dDdE� Z&dFdG� Z'dHdI� Z(dJdK� Z)dYdLdM�Z*dNdO� Z+dS )Zr a�
OLE container object
This class encapsulates the interface to an OLE 2 structured
storage file. Use the listdir and openstream methods to
access the contents of this file.
Object names are given as a list of strings, one for each subentry
level. The root entry should be omitted. For example, the following
code extracts all image streams from a Microsoft Image Composer file::
ole = OleFileIO("fan.mic")
for entry in ole.listdir():
if entry[1:2] == "Image":
fin = ole.openstream(entry)
fout = open(entry[0:1], "wb")
while True:
s = fin.read(8192)
if not s:
break
fout.write(s)
You can use the viewer application provided with the Python Imaging
Library to view the resulting files (which happens to be standard
TIFF files).
NFc C s || _ g | _|| _|| _d| _d| _g | _g | _d| _d| _ d| _
d| _ d| _ d| _
d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _d| _ d| _ d| _ d| _ d| _ d| _!d| _"d| _#d| _$d| _%d| _&|�r| j'||d� dS )a�
Constructor for the OleFileIO class.
:param filename: file to open.
- if filename is a string smaller than 1536 bytes, it is the path
of the file to open. (bytes or unicode string)
- if filename is a string longer than 1535 bytes, it is parsed
as the content of an OLE file in memory. (bytes type only)
- if filename is a file-like object (with read, seek and tell methods),
it is parsed as-is.
:param raise_defects: minimal level for defects to be raised as exceptions.
(use DEFECT_FATAL for a typical application, DEFECT_INCORRECT for a
security-oriented application, see source code for details)
:param write_mode: bool, if True the file is opened in read/write mode instead
of read-only by default.
:param debug: bool, set debug mode (deprecated, not used anymore)
:param path_encoding: None or str, name of the codec to use for path
names (streams and storages), or None for Unicode.
Unicode by default on Python 3+, UTF-8 on Python 2.x.
(new in olefile 0.42, was hardcoded to Latin-1 until olefile v0.41)
N)�
write_mode)(�_raise_defects_level�parsing_issuesr �
path_encoding� _filesize�
ministream�_used_streams_fat�_used_streams_minifat�
byte_order� directory_fpr� � dll_versionr� �first_difat_sector�first_dir_sector�first_mini_fat_sectorr` � header_clsid�header_signature�metadata�mini_sector_shift�mini_sector_size�mini_stream_cutoff_sizer� � minifatsectr� �minisectorsize�
minor_version�nb_sect�num_difat_sectors�num_dir_sectors�num_fat_sectors�num_mini_fat_sectors� reserved1� reserved2�root� sector_shift� sector_size� transaction_signature_numberr] )r� r^ Z
raise_defectsr r� r r* r* r+ r� � sT zOleFileIO.__init__c C s | S ra r* r� r* r* r+ � __enter__6 s zOleFileIO.__enter__c G s | � � d S ra )�close)r� �argsr* r* r+ �__exit__: s zOleFileIO.__exit__c C s< || j kr t�|� ||��n| j�||f� t�|� dS )a�
This method should be called for any defect found during file parsing.
It may raise an IOError exception according to the minimal level chosen
for the OleFileIO object.
:param defect_level: defect level, possible values are:
- DEFECT_UNSURE : a case which looks weird, but not sure it's a defect
- DEFECT_POTENTIAL : a potential defect
- DEFECT_INCORRECT : an error according to specifications, but parsing can go on
- DEFECT_FATAL : an error which cannot be ignored, parsing is impossible
:param message: string describing the defect, used with raised exception.
:param exception_type: exception class to be raised, IOError by default
N)r r. �errorr r� �warning)r� Z defect_level�messageZexception_typer* r* r+ r� > s
zOleFileIO._raise_defect�replacec C s( |� d|�}| jr |�| j|�S |S dS )a�
Decode a string encoded in UTF-16 LE format, as found in the OLE
directory or in property streams. Return a string encoded
according to the path_encoding specified for the OleFileIO object.
:param utf16_str: bytes string encoded in UTF-16 LE format
:param errors: str, see python documentation for str.decode()
:return: str, encoded according to path_encoding
zUTF-16LEN)�decoder �encode)r� Z utf16_str�errorsZ unicode_strr* r* r+ r� X s
zOleFileIO._decode_utf16_strc C s� || _ t|d�r|| _n@t|t�r<t|�tkr<t�|�| _n | j rHd}nd}t ||�| _d}| j�
dt j � z| j�
� }W | j�
d� n| j�
d� 0 || _t�d| j| jf � g | _g | _| j�d�}t|�dks�|dd� tk�rt�d |dd� tf � | �td
� d }t�|�}t�d ||d
f � |d|� }t�||�\| _| _| _ | _ | _ | _ | _ | _!| _"| _#| _$| _%| _&| _'| _(| _)| _*| _+t�t�||�� | jtk�r�| �td� | jt,d�k�r�| �t-d� t�d| j � t�d| j � | j dv�r| �t-d� t�d| j � | j dk�r8| �t-d� d| j | _.t�d| j. � | j.dv�rl| �t-d� | j d k�r�| j.dk�s�| j d k�r�| j.d k�r�| �t-d � d| j | _/t�d | j/ � | j/d!v�r�| �t-d"� | j!dk�s�| j"dk�r | �t-d#� t�d$| j# � | j.dk�r4| j#dk�r4| �t-d%� t�d&| j$ � t�d'| j% � t�d(| j& � | j&dk�r|| �t0d)� t�d*| j' � | j'd k�r�| �t-d+� t�1d,| j' � d | _'t�d-| j( � t�d.| j) � t�d/| j* � t�d0| j+ � || j. d1 | j. d1 | _2t�d2| j2| j2f � t3|dd3� �| _| j.| _4| j/| _5| j'| _6| �7| j%� | j)�rt| �7| j(� | j+�r�| �7| j*� | �8|� | �9| j%� | j(| _:dS )4a�
Open an OLE2 file in read-only or read/write mode.
Read and parse the header, FAT and directory.
:param filename: string-like or file-like object, OLE file to parse
- if filename is a string smaller than 1536 bytes, it is the path
of the file to open. (bytes or unicode string)
- if filename is a string longer than 1535 bytes, it is parsed
as the content of an OLE file in memory. (bytes type only)
- if filename is a file-like object (with read, seek and tell methods),
it is parsed as-is.
:param write_mode: bool, if True the file is opened in read/write mode instead
of read-only by default. (ignored if filename is not a path)
rV zr+brW r zFile size: %d bytes (%Xh)r� Nr4 zMagic = %r instead of %rz#not an OLE2 structured storage filez<8s16sHHHHHHLLLLLLLLLLz fmt_header size = %d, +FAT = %di� zincorrect OLE signaturer; z incorrect CLSID in OLE headerzMinor Version = %dz%DLL Version = %d (expected: 3 or 4))r" r z"incorrect DllVersion in OLE headerz#Byte Order = %X (expected: FFFE)i�� z!incorrect ByteOrder in OLE headerr0 z0Sector Size = %d bytes (expected: 512 or 4096))r� rT z#incorrect sector_size in OLE headerr" r rT z3sector_size does not match DllVersion in OLE headerz/MiniFAT Sector Size = %d bytes (expected: 64))rK z(incorrect mini_sector_size in OLE headerz.incorrect OLE header (non-null reserved bytes)z Number of Directory sectors = %dz3incorrect number of directory sectors in OLE headerzNumber of FAT sectors = %dz First Directory sector = %Xhz$Transaction Signature Number = %dz5incorrect OLE header (transaction_signature_number>0)z/Mini Stream cutoff size = %Xh (expected: 1000h)z/incorrect mini_stream_cutoff_size in OLE headerzJFixing the mini_stream_cutoff_size to 4096 (mandatory value) instead of %dz First MiniFAT sector = %Xhz Number of MiniFAT sectors = %dz First DIFAT sector = %Xhz Number of DIFAT sectors = %dr# z/Maximum number of sectors in the file: %d (%Xh)rC );r rX r` r[ r\ rY r r� r� r] rZ �os�SEEK_END�tellr r. r� r r rV r r� r rj �calcsizerk r r r$ r r r- r r* r+ r' r( r r/ r! r r) r r& � bytearrayr r. r r r5 r% rv r� r# r� r� �loadfat�
loaddirectoryr" ) r� r^ r �moder� r_ Z
fmt_header� header_sizeZheader1r* r* r+ r] k s�
'
� �� �
zOleFileIO.openc C s | j �� dS )z@
close the OLE file, to release the file object
N)r` r1 r� r* r* r+ r1 K s zOleFileIO.closec C sf |rt �d| � | j}n(t �d| � |ttttfv r<dS | j}||v rX| �t d� n
|�
|� dS )ag
Checks if a stream has not been already referenced elsewhere.
This method should only be called once for each known stream, and only
if stream size is not null.
:param first_sect: int, index of first sector of the stream in FAT
:param minifat: bool, if True, stream is located in the MiniFAT, else in the FAT
z,_check_duplicate_stream: sect=%Xh in MiniFATz(_check_duplicate_stream: sect=%Xh in FATNzStream referenced twice) r. r� r r r r r r r� r r� )r� Z
first_sectr� Z used_streamsr* r* r+ r� R s z!OleFileIO._check_duplicate_streamr c
C s� d}t dtdtdtdi}t|�}|| d | }tddd � t|�D ]}td
| dd � qDt� t|�D ]�}|| } td || dd � t| | | �D ]X}||kr� q�|| }
|
d @ } | |v r�|| } n|
|d kr�d
} nd
|
} t| dd � q�t� qhdS )zU
Display a part of FAT in human-readable form for debugging purposes
r4 z..free..z[ END. ]zFATSECT zDIFSECT r# �indexr r �%8X�%6X:r/ z --->N)r r r r rY r� r� )
r� r� �
firstindex�VPLZfatnames�nbsect�nlinesr! �lrD r� Zauxr' r* r* r+ �dumpfatl s6 �
zOleFileIO.dumpfatc C s� d}t � t|�}tjdkr"|�� t|�}|| d | }tddd� t|�D ]}td| dd� qNt� t|�D ]b}|| } td|| dd� t| | | �D ],}||kr� q�|| }
d|
} t| dd� q�t� qrd S )
zS
Display a sector in a human-readable form, for debugging purposes
r4 �bigr# rD r r rE rF N)�array�UINT32�sys� byteorder�byteswaprY r� r� ) r� �sectorrG rH r rI rJ r! rK rD r� r' r* r* r+ �dumpsect� s(
zOleFileIO.dumpsectc C s" t � t|�}tjdkr |�� |S )z�
convert a sector to an array of 32 bits unsigned integers,
swapping bytes on big endian CPUs such as PowerPC (old Macs)
rM )rN rO rP rQ rR )r� r� �ar* r* r+ �
sect2array� s
zOleFileIO.sect2arrayc C s� t |tj�r|}n | �|�}t�tj�r2| �|� d}|D ]X}|d@ }t�d| � |t ksd|t
krrt�d� q�| � |�}| �|�}| j | | _ q:|S )z�
Adds the indexes of the given sector to the FAT
:param sect: string containing the first FAT sector, or array of long integers
:returns: index of last FAT sector.
Nr/ z
isect = %Xzfound end of sector chain)
r[ rN rV r. � isEnabledForr$ �DEBUGrT r� r r �getsectr� )r� r� Zfat1Zisect�sZnextfatr* r* r+ � loadfat_sect� s
zOleFileIO.loadfat_sectc C s� t �d� |dd� }t �dt|�t|�d f � t�t�| _| �|� | jdk�rnt �d� | jdkrv| � t
d � | j | j kr�| � t
d
� t �d � | jd d }| jd | d | }t �d
| � | j|kr�td��| j }t|�D ]j}t �d||f � | �|�}| �|�}t �tj��r,| �|� | �|d|� � || }t �d| � q�|ttfv�rxtd��n
t �d� t| j�| j k�r�t �dt| j�| j f � | jd| j � | _t �dt| j�| j f � t �tj��r�t �d� | �| j� dS )z%
Load the FAT table.
zDLoading the FAT table, starting with the 1st sector after the header�L r� z len(sect)=%d, so %d integersr r z)DIFAT is used, because file size > 6.8MB.�m z#incorrect DIFAT, not enough sectorsz)incorrect DIFAT, first index out of rangezDIFAT analysis...r# z
nb_difat = %dzincorrect DIFATzDIFAT block %d, sector %XNznext DIFAT sector: %Xzincorrect end of DIFATz$No DIFAT, because file size < 6.8MB.z!len(fat)=%d, shrunk to nb_sect=%dz6FAT references %d sectors / Maximum %d sectors in filez
FAT:)r. r� rY rN rO r� r[ r& r( r� r r r% r r� �IOError� iterrangerY rV rW r$ rX rT r r rL ) r� r_ r� Znb_difat_sectorsZnb_difatZ isect_difatr! Z sector_difatZdifatr* r* r+ r@ � sJ
zOleFileIO.loadfatc C s� | j | j }| jj| j d | j }|d }t�d| j| j |||f � ||kr\| �t d� | j
| j|dd�� � }| � |�| _
t�dt| j
�|f � | j
d|� | _
t�d t| j
� � t�tj�r�t�d
� | �| j
� dS ) z)
Load the MiniFAT table.
r# r zaloadminifat(): minifatsect=%d, nb FAT sectors=%d, used_size=%d, stream_size=%d, nb MiniSectors=%dz%OLE MiniStream is larger than MiniFATT�� force_FATz$MiniFAT shrunk from %d to %d sectorsNzloadminifat(): len=%dz
MiniFAT:)r) r. r, r� r r. r� r" r� r �_openrV rV r� rY rW r$ rX rL )r� Z stream_sizeZnb_minisectorsZ used_sizerZ r* r* r+ r� . s �
zOleFileIO.loadminifatc
C s� z| j �| j|d � W n8 t�d|| j|d | jf � | �td� Y n0 | j �| j�}t |�| jkr�t�d|t |�| jf � | �td� |S )z�
Read given sector from file on disk.
:param sect: int, sector index
:returns: a string containing the sector data.
r# z(getsect(): sect=%X, seek=%d, filesize=%dr� z*getsect(): sect=%X, read=%d, sectorsize=%dr� )
r` rZ r� r. r� r r� r rV rY )r� r� rS r* r* r+ rY R s �� zOleFileIO.getsectrp c
C s� t |t�std��t |t�r(t|�dkr0td��z| j�| j|d � W n8 t�d|| j|d | j f � | �
t d� Y n0 t|�| jk r�||| jt|� 7 }nt|�| jk r�t d��| j�
|� dS )z�
Write given sector to file on disk.
:param sect: int, sector index
:param data: bytes, sector data
:param padding: single byte, padding character if data < sector size
z'write_sect: data must be a bytes stringr# z4write_sect: padding must be a bytes string of 1 charz+write_sect(): sect=%X, seek=%d, filesize=%dr� � Data is larger than sector sizeN)r[ r\ � TypeErrorrY r` rZ r� r. r� r r� r �
ValueError�write)r� r� r� �paddingr* r* r+ �
write_sectr s
�zOleFileIO.write_sectc C s� t |t�std��t |t�r(t|�dkr0td��z| j�|� W n, t�d|| jf � | � t
d� Y n0 t|�}|| j k r�||| j | 7 }| j |k r�t d��| j�
|� dS )z�
Write given sector to file on disk.
:param fp_pos: int, file position
:param data: bytes, sector data
:param padding: single byte, padding character if data < sector size
z,write_mini_sect: data must be a bytes stringr# z9write_mini_sect: padding must be a bytes string of 1 charz)write_mini_sect(): fp_pos=%d, filesize=%dr� rc N)r[ r\ rd rY r` rZ r. r� r r� r r re rf )r� �fp_posr� rg Zlen_datar* r* r+ �_write_mini_sect� s"
�
zOleFileIO._write_mini_sectc C sl t �d� | j|dd�| _| jjd }t �d| jj|f � dg| | _| �d�}| jd | _| j�� dS )z]
Load the directory.
:param sect: sector index of directory stream.
zLoading the Directory:Tr` r� z&loaddirectory: size=%d, max_entries=%dNr ) r. r� rb r r� r� r� r, r� )r� r� Z max_entriesZ
root_entryr* r* r+ rA � s
�
zOleFileIO.loaddirectoryc C s~ |dk s|t | j�kr"| �td� | j| durF| �td� | j| S | j�|d � | j�d�}t||| �| j|< | j| S )aY
Load a directory entry from the directory.
This method should only be called once for each storage/stream when
loading the directory.
:param sid: index of storage/stream in the directory.
:returns: a OleDirectoryEntry object
:exception IOError: if the entry has always been referenced.
r z OLE directory index out of rangeNz'double reference for OLE stream/storager� ) rY r� r� r r r rZ rV r� )r� r� r� r* r* r+ r� � s �
zOleFileIO._load_direntryc C s | j �� dS )z5
Dump directory (for debugging only)
N)r, r� r� r* r* r+ �
dumpdirectory� s zOleFileIO.dumpdirectoryc
C s� t �d||t|�f � || jk r�|s�| jsh| �� | jj}t �d| jj|f � | j | jj|dd�| _t
| j||d| j | j | jj| d�S t
| j
||| j| j| j| j| d�S dS )a|
Open a stream, either in FAT or MiniFAT according to its size.
(openstream helper)
:param start: index of first sector
:param size: size of stream (or nothing if size is unknown)
:param force_FAT: if False (default), stream will be opened in FAT or MiniFAT
according to size. If True, it will always be opened in FAT.
z1OleFileIO.open(): sect=%Xh, size=%d, force_FAT=%sz%Opening MiniStream: sect=%Xh, size=%dTr` r )r` r� r� r� r� r� r� r� N)r. r� �strr� r r� r, r� r� rb r� r# r� r` r� r� r )r� �startr� ra Zsize_ministreamr* r* r+ rb � s0
�
�
�
�
�zOleFileIO._openTc C s� ||j g }|jD ]v}|jtkrR|r>|�|dd� |j g � | �|||||� q|jtkr||r�|�|dd� |j g � q| �td� qdS )a�
listdir helper
:param files: list of files to fill in
:param prefix: current location in storage tree (list of names)
:param node: current node (OleDirectoryEntry object)
:param streams: bool, include streams if True (True by default) - new in v0.26
:param storages: bool, include storages if True (False by default) - new in v0.26
(note: the root storage is never included)
r# NzIThe directory tree contains an entry which is not a stream nor a storage.) r' r� r� r r� �_listr
r� r )r� �files�prefix�node�streams�storagesr� r* r* r+ rn s
zOleFileIO._listc C s g }| � |g | j||� |S )am
Return a list of streams and/or storages stored in this file
:param streams: bool, include streams if True (True by default) - new in v0.26
:param storages: bool, include storages if True (False by default) - new in v0.26
(note: the root storage is never included)
:returns: list of stream and/or storage paths
)rn r, )r� rr rs ro r* r* r+ �listdir3 s zOleFileIO.listdirc C sX t |t�r|�d�}| j}|D ]2}|jD ]}|j�� |�� kr( qLq(td��|}q |jS )a*
Returns directory entry of given filename. (openstream helper)
Note: this method is case-insensitive.
:param filename: path of stream in storage tree (except root entry), either:
- a string using Unix path syntax, for example:
'storage_1/storage_1.2/stream'
- or a list of storage filenames, path to the desired stream/storage.
Example: ['storage_1', 'storage_1.2', 'stream']
:returns: sid of requested filename
:exception IOError: if file not found
�/zfile not found) r[ �
basestring�splitr, r� r' r� r^ r� )r� r^ rq r' r r* r* r+ �_findA s
zOleFileIO._findc C s6 | � |�}| j| }|jtkr&td��| �|j|j�S )a;
Open a stream as a read-only file object (BytesIO).
Note: filename is case-insensitive.
:param filename: path of stream in storage tree (except root entry), either:
- a string using Unix path syntax, for example:
'storage_1/storage_1.2/stream'
- or a list of storage filenames, path to the desired stream/storage.
Example: ['storage_1', 'storage_1.2', 'stream']
:returns: file object (read-only)
:exception IOError: if filename not found, or if this is not a stream.
zthis file is not a stream)rx r� r� r
r^ rb r� r� �r� r^ r� r� r* r* r+ �
openstreama s
zOleFileIO.openstreamc C s� |j s|�| � t|j �}| jj s.| j�| � | j| j }t|j �D ]�\}}|| }|| }| jj | d | j || j } ||d k r�||| j |d | j � }
n||| j d � }
| �| |
� qDd S )Nr# )r� r� rY r, r. r � enumeraterj ) r� r� �
data_to_writer� Z
block_size�idxr� Z sect_baseZ sect_offsetri Zdata_per_sectorr* r* r+ �_write_mini_streamv s
z OleFileIO._write_mini_streamc
C sV t |t�std��| �|�}| j| }|jtkr8td��|j}|t |�krRt
d��|| j k rt|jt krt| j
||d�S |j}|| jd | j }t�d| � t|�D ]�}||d k r�||| j |d | j � } n4||| j d� } t�d|| jt | �|| j f � | �|| � z| j| }W q� t�y< td ��Y q�0 q�|tk�rRtd
��dS ) aD
Write a stream to disk. For now, it is only possible to replace an
existing stream by data of the same size.
:param stream_name: path of stream in storage tree (except root entry), either:
- a string using Unix path syntax, for example:
'storage_1/storage_1.2/stream'
- or a list of storage filenames, path to the desired stream/storage.
Example: ['storage_1', 'storage_1.2', 'stream']
:param data: bytes, data to be written, must be the same size as the original
stream.
z)write_stream: data must be a bytes stringzthis is not a streamz?write_stream: data must be the same size as the existing stream)r� r| r# r� NzGwrite_stream: size=%d sectorsize=%d data_sector=%Xh size%%sectorsize=%dr� z)incorrect last sector index in OLE stream)r[ r\ rd rx r� r� r
r^ r� rY re r� r r~ r� r� r. r� r� rh r� r� r )
r� Z stream_namer� r� r� r� r� r� r! Z data_sectorr* r* r+ � write_stream� s:
�
zOleFileIO.write_streamc C s0 z | � |�}| j| }|jW S Y dS 0 dS )a�
Test if given filename exists as a stream or a storage in the OLE
container, and return its type.
:param filename: path of stream in storage tree. (see openstream for syntax)
:returns: False if object does not exist, its entry type (>0) otherwise:
- STGTY_STREAM: a stream
- STGTY_STORAGE: a storage
- STGTY_ROOT: the root entry
FN)rx r� r� ry r* r* r+ �get_type� s
zOleFileIO.get_typec C s | � |�}| j| }|jS )a
Return clsid of a stream/storage.
:param filename: path of stream/storage in storage tree. (see openstream for
syntax)
:returns: Empty string if clsid is null, a printable representation of the clsid otherwise
new in version 0.44
)rx r� ru ry r* r* r+ �getclsid� s
zOleFileIO.getclsidc C s | � |�}| j| }|�� S )a9
Return modification time of a stream/storage.
:param filename: path of stream/storage in storage tree. (see openstream for
syntax)
:returns: None if modification time is null, a python datetime object
otherwise (UTC timezone)
new in version 0.26
)rx r� r ry r* r* r+ r � s
zOleFileIO.getmtimec C s | � |�}| j| }|�� S )a1
Return creation time of a stream/storage.
:param filename: path of stream/storage in storage tree. (see openstream for
syntax)
:returns: None if creation time is null, a python datetime object
otherwise (UTC timezone)
new in version 0.26
)rx r� r
ry r* r* r+ r
� s
zOleFileIO.getctimec C s$ z| � |�}W dS Y dS 0 dS )a
Test if given filename exists as a stream or a storage in the OLE
container.
Note: filename is case-insensitive.
:param filename: path of stream in storage tree. (see openstream for syntax)
:returns: True if object exist, else False.
TFN)rx )r� r^ r� r* r* r+ r� s
zOleFileIO.existsc C s, | � |�}| j| }|jtkr&td��|jS )a2
Return size of a stream in the OLE container, in bytes.
:param filename: path of stream in storage tree (see openstream for syntax)
:returns: size in bytes (long integer)
:exception IOError: if file not found
:exception TypeError: if this is not a stream.
zobject is not an OLE stream)rx r� r� r
rd r� ry r* r* r+ �get_size s
zOleFileIO.get_sizec C s | j jS )zp
Return root entry name. Should usually be 'Root Entry' or 'R' in most
implementations.
)r, r' r� r* r* r+ �get_rootentry_name* s z OleFileIO.get_rootentry_namec C sH |dkr g }|}t |t�s$d�|�}| �|�}i }zn|�d�}t|dd� �}|�d�}t|dd� �} |�t|d�� d|�t|�d ��d � }t|d �}
W nJ ty� } z2d
t |�| f } | �
t | t | �� |W Y d} ~ S d} ~ 0 0 t
|
tt|�d ��}
t|
�D �]6}
d }�z�t|d|
d �}t|d |
d �}t||�}t�d
|||f � |tk�r�t||d �}|dk�r�|d }�nb|tk�r�t||d �}�nF|tttfv �r�t||d �}�n$|ttfv �r�t||d �}�n|tt fv �r.t||d �}||d |d | d � }|� dd�}�n�|t k�rbt||d �}||d |d | � }�n�|t k�r�t||d �}| � ||d |d |d � �}�nJ|t!k�rDt"t||d ��t"t||d ��d> }|�r:||v�r:t�d||t#|�d f � t$�$dddd d d �}t�d|d � |t$j%|d d� }n|d }n�|t&k�r`t'||d �}n�|t(k�r�t||d |d � �}nf|t)k�r�t||d �}||d |d | � }n4|t*k�r�t+t||d ��}nd}t�d ||f � |||< W nJ t�y> } z0d |t |�| f } | �
t | t | �� W Y d} ~ n
d} ~ 0 0 �q
|S ) a�
Return properties described in substream.
:param filename: path of stream in storage tree (see openstream for syntax)
:param convert_time: bool, if True timestamps will be converted to Python datetime
:param no_conversion: None or list of int, timestamps not to be converted
(for example total editing time is not a real timestamp)
:returns: a dictionary of values indexed by id (integer)
Nru rG r4 rC r? r; s ****r z6Error while parsing properties header in stream %s: %sr r8 z!property id=%d: type=%d offset=%Xi � i r# rp r� r0 r� z8Converting property #%d to python datetime, value=%d=%fsi��� rw ztimedelta days=%dl @�T$r6 rx z5property id=%d: type=%d not implemented in parser yetz3Error while parsing property id %d in stream %s: %s),r[ rl r� rz rV rv rZ ro �
BaseExceptionr� r� r �type�minrh rY r_ r. r� �VT_I2rn �VT_UI2�VT_I4�VT_INT�VT_ERROR�VT_UI4�VT_UINT�VT_BSTR�VT_LPSTRr7 �VT_BLOB� VT_LPWSTRr� � VT_FILETIMEr� �floatry rz �VT_UI1re �VT_CLSID�VT_CF�VT_BOOL�bool)r� r^ r� r� Z
streampathr` r� rZ ru ZfmtidZ num_props�exc�msgr! Z property_idr� Z
property_typer� �countr{ r* r* r+ r� 2 s�
�
&
(�
�,zOleFileIO.getpropertiesc C s t � | _| j�| � | jS )z�
Parse standard properties streams, return an OleMetadata object
containing all the available metadata.
(also stored in the metadata attribute of the OleFileIO object)
new in version 0.25
)r r r� r� r* r* r+ � get_metadata� s zOleFileIO.get_metadata)r7 )F)F)r )r )rp )rp )TF)TF)FN),r� r� r� r� r r r� r0 r3 r^ r� r� r] r1 r� rL rT rV r[ r@ r� rY rh rj rA r� rk r rb rn rt rx rz r~ r r� r� r r
r� r� r� r� r� r* r* r* r+ r � sR �
M
a
%
$T$
)&
>
r c C s� ddl } ddl}d}tjtjtjtjtjd�}d}|j|d�}|j ddd d
d � |j d dd
dd � |j dddd|dd� |�
� \}}t dt t
f � t|�dkr�t t� |�� | �� |jr�d|_tj||j dd� t� |D �]�}�z�t|�} t d� t |� t d� | �� | �� D ]�}
|
d d dk�r t d |
� z�| j|
d d �} t| �� �} | D ]p\} }
t |
t t f��r�t|
�d k�r�|
dd � }
t |
t ��r�d D ] }|t |
�v �r�d!}
�q��q�t d"| |
� �q^W n t �!d#|
� Y n0 �q |j"�rpt d$� | �� D ]^}
t d%t#d&�$|
��d%d'd(� | �%|
�}|t&k�rZt d)| �'|
� � | �(|
� n t d*| � �q
t � t d+� | j)D ],}|du�r~t d,|j*|�+� |�,� f � �q~t � z| �-� }|�.� W n t �!d-� Y n0 t � | �/� }t d.| � | �0d/��r@t d0� t d1| �%d/�� t d2| �'d/�� | �0d3��r@t d4� t d5� | j1�rv| j1D ] \}}t d6|j2|f � �qVnt d7� W q� t �!d8| � Y q�0 q�dS )9z�
Main function when olefile is runs as a script from the command line.
This will open an OLE2 file and display its structure and properties
:return: nothing
r Nr5 )r� �infor5 r4 Zcriticalz1usage: %prog [options] <filename> [filename2 ...])�usagez-c�
store_true�
check_streamsz*check all streams (for debugging purposes))�action�dest�helpz-d�
debug_modez\debug mode, shortcut for -l debug (displays a lot of debug information, for developers only)z-lz
--loglevel�loglevel�storezBlogging level debug/info/warning/error/critical (default=%default))r� r� �defaultr� z=olefile version %s %s - https://www.decalage.info/en/olefile
r� z%(levelname)-8s %(message)s)r( �formatzD--------------------------------------------------------------------����z%r: propertiesTr� �2 )r# r0 r" r r1 r2 r3 r7 r8 r: � r; r< r= r> r? r@ rA rB rC rD rE rF rG rH rI rJ z
(binary data)z z&Error while parsing property stream %rz
Checking streams...�-ru r r zsize %dzNOT a stream : type=%dz5Modification/Creation times of all directory entries:z- %s: mtime=%s ctime=%sz Error while parsing metadatazRoot entry name: "%s"Z worddocumentzThis is a Word document.z type of stream 'WordDocument':zsize :z
macros/vbaz%This document may contain VBA macros.z(
Non-fatal issues raised during parsing:r� �NonezError while parsing file %r)3rP �optparser$ rX �INFOZWARNINGZERROR�CRITICALZ OptionParserZ
add_option�
parse_argsr� � __version__�__date__rY r� �
print_help�exitr� r� Z basicConfigr r rk rt r� �sorted�itemsr[ rv r\ r? r. � exceptionr� r� r� r� r
r� rz r� r' r r
r� r� r� r� r r� )rP r� ZDEFAULT_LOG_LEVELZ
LOG_LEVELSr� �parser�optionsr2 r^ r� Z
streamnamer� �k�vrd Zst_typer� �metar, �exctyper� r* r* r+ �main� s� �
�
��
� r� �__main__)r )r )mr� Z
__future__r r� r� �
__author__�__all__r� rP rj rN Zos.pathr; ry r$ rl r\ rh r� Zxranger_ r� �itemsizerO re rv � NameErrorr � version_infor r� r, r. r r r r r r r r r r r r
r r
r r ZVT_EMPTYZVT_NULLr� r� ZVT_R4ZVT_R8ZVT_CYZVT_DATEr� Z VT_DISPATCHr� r� Z
VT_VARIANTZ
VT_UNKNOWNZ
VT_DECIMALZVT_I1r� r� r� ZVT_I8ZVT_UI8r� r� ZVT_VOIDZ
VT_HRESULTZVT_PTRZ VT_SAFEARRAYZ VT_CARRAYZVT_USERDEFINEDr� r� r� r� Z VT_STREAMZ
VT_STORAGEZVT_STREAMED_OBJECTZVT_STORED_OBJECTZVT_BLOB_OBJECTr� r� Z VT_VECTORr r r r r r r re rn ro rv r| r r� r� r� r r� r� r* r* r* r+ �<module> s� <
(
*
"