Anonymous avatar Anonymous committed 3b14088

Original version of OleFileIO.py from PIL, dated 2005-03-25, still current in PIL 1.1.7 on the 2011-10-20

Comments (0)

Files changed (6)

OleFileIO_PL/LICENSE.txt

+LICENSE for the OleFileIO_PL module:
+
+
+OleFileIO_PL is an improved version of the OleFileIO module from the
+Python Imaging Library (PIL).
+
+OleFileIO_PL changes are Copyright (c) 2005-2011 by Philippe Lagadec
+
+The Python Imaging Library (PIL) is
+   Copyright (c) 1997-2005 by Secret Labs AB
+   Copyright (c) 1995-2005 by Fredrik Lundh
+
+By obtaining, using, and/or copying this software and/or its associated
+documentation, you agree that you have read, understood, and will comply with
+the following terms and conditions:
+
+Permission to use, copy, modify, and distribute this software and its
+associated documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appears in all copies, and that both
+that copyright notice and this permission notice appear in supporting
+documentation, and that the name of Secret Labs AB or the author(s) not be used
+in advertising or publicity pertaining to distribution of the software
+without specific, written prior permission.
+
+SECRET LABS AB AND THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+IN NO EVENT SHALL SECRET LABS AB OR THE AUTHORS BE LIABLE FOR ANY SPECIAL,
+INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

OleFileIO_PL/OleFileIO_PL.py

+#
+# THIS IS WORK IN PROGRESS
+#
+# The Python Imaging Library
+# $Id: OleFileIO.py 2339 2005-03-25 08:02:17Z fredrik $
+#
+# stuff to deal with OLE2 Structured Storage files.  this module is
+# used by PIL to read Image Composer and FlashPix files, but can also
+# be used to read other files of this type.
+#
+# History:
+# 1997-01-20 fl   Created
+# 1997-01-22 fl   Fixed 64-bit portability quirk
+# 2003-09-09 fl   Fixed typo in OleFileIO.loadfat (noted by Daniel Haertle)
+# 2004-02-29 fl   Changed long hex constants to signed integers
+#
+# Notes:
+# FIXME: sort out sign problem (eliminate long hex constants)
+# FIXME: change filename to use "a/b/c" instead of ["a", "b", "c"]
+# FIXME: provide a glob mechanism function (using fnmatchcase)
+#
+# Literature:
+#
+# "FlashPix Format Specification, Appendix A", Kodak and Microsoft,
+#  September 1996.
+#
+# Quotes:
+#
+# "If this document and functionality of the Software conflict,
+#  the actual functionality of the Software represents the correct
+#  functionality" -- Microsoft, in the OLE format specification
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1997.
+#
+# See the README file for information on usage and redistribution.
+#
+
+import string, StringIO
+
+
+def i16(c, o = 0):
+    return ord(c[o])+(ord(c[o+1])<<8)
+
+def i32(c, o = 0):
+    return ord(c[o])+(ord(c[o+1])<<8)+(ord(c[o+2])<<16)+(ord(c[o+3])<<24)
+
+
+MAGIC = '\320\317\021\340\241\261\032\341'
+
+#
+# --------------------------------------------------------------------
+# property types
+
+VT_EMPTY=0; VT_NULL=1; VT_I2=2; VT_I4=3; VT_R4=4; VT_R8=5; VT_CY=6;
+VT_DATE=7; VT_BSTR=8; VT_DISPATCH=9; VT_ERROR=10; VT_BOOL=11;
+VT_VARIANT=12; VT_UNKNOWN=13; VT_DECIMAL=14; VT_I1=16; VT_UI1=17;
+VT_UI2=18; VT_UI4=19; VT_I8=20; VT_UI8=21; VT_INT=22; VT_UINT=23;
+VT_VOID=24; VT_HRESULT=25; VT_PTR=26; VT_SAFEARRAY=27; VT_CARRAY=28;
+VT_USERDEFINED=29; VT_LPSTR=30; VT_LPWSTR=31; VT_FILETIME=64;
+VT_BLOB=65; VT_STREAM=66; VT_STORAGE=67; VT_STREAMED_OBJECT=68;
+VT_STORED_OBJECT=69; VT_BLOB_OBJECT=70; VT_CF=71; VT_CLSID=72;
+VT_VECTOR=0x1000;
+
+# map property id to name (for debugging purposes)
+
+VT = {}
+for k, v in vars().items():
+    if k[:3] == "VT_":
+        VT[v] = k
+
+#
+# --------------------------------------------------------------------
+# Some common document types (root.clsid fields)
+
+WORD_CLSID = "00020900-0000-0000-C000-000000000046"
+
+
+#
+# --------------------------------------------------------------------
+
+class _OleStream(StringIO.StringIO):
+
+    """OLE2 Stream
+
+    Returns a read-only file object which can be used to read
+    the contents of a OLE stream.  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.
+    """
+
+    # FIXME: should store the list of sects obtained by following
+    # the fat chain, and load new sectors on demand instead of
+    # loading it all in one go.
+
+    def __init__(self, fp, sect, size, offset, sectorsize, fat):
+
+        data = []
+
+        while sect != -2: # 0xFFFFFFFEL:
+            fp.seek(offset + sectorsize * sect)
+            data.append(fp.read(sectorsize))
+            sect = fat[sect]
+
+        data = string.join(data, "")
+
+        # print len(data), size
+
+        StringIO.StringIO.__init__(self, data[:size])
+
+#
+# --------------------------------------------------------------------
+
+# FIXME: should add a counter in here to avoid looping forever
+# if the tree is broken.
+
+class _OleDirectoryEntry:
+
+    """OLE2 Directory Entry
+
+    Encapsulates a stream directory entry.  Note that the
+    constructor builds a tree of all subentries, so we only
+    have to call it with the root object.
+    """
+
+    def __init__(self, sidlist, sid):
+
+        # store directory parameters.  the caller provides
+        # a complete list of directory entries, as read from
+        # the directory stream.
+
+        name, type, sect, size, sids, clsid = sidlist[sid]
+
+        self.sid  = sid
+        self.name = name
+        self.type = type # 1=storage 2=stream
+        self.sect = sect
+        self.size = size
+        self.clsid = clsid
+
+        # process child nodes, if any
+
+        self.kids = []
+
+        sid = sidlist[sid][4][2]
+
+        if sid != -1:
+
+            # the directory entries are organized as a red-black tree.
+            # the following piece of code does an ordered traversal of
+            # such a tree (at least that's what I hope ;-)
+
+            stack = [self.sid]
+
+            # start at leftmost position
+
+            left, right, child = sidlist[sid][4]
+
+            while left != -1: # 0xFFFFFFFFL:
+                stack.append(sid)
+                sid = left
+                left, right, child = sidlist[sid][4]
+
+            while sid != self.sid:
+
+                self.kids.append(_OleDirectoryEntry(sidlist, sid))
+
+                # try to move right
+                left, right, child = sidlist[sid][4]
+                if right != -1: # 0xFFFFFFFFL:
+                    # and then back to the left
+                    sid = right
+                    while 1:
+                        left, right, child = sidlist[sid][4]
+                        if left == -1: # 0xFFFFFFFFL:
+                            break
+                        stack.append(sid)
+                        sid = left
+                else:
+                    # couldn't move right; move up instead
+                    while 1:
+                        ptr = stack[-1]
+                        del stack[-1]
+                        left, right, child = sidlist[ptr][4]
+                        if right != sid:
+                            break
+                        sid = right
+                    left, right, child = sidlist[sid][4]
+                    if right != ptr:
+                        sid = ptr
+
+            # in the OLE file, entries are sorted on (length, name).
+            # for convenience, we sort them on name instead.
+
+            self.kids.sort()
+
+    def __cmp__(self, other):
+        "Compare entries by name"
+
+        return cmp(self.name, other.name)
+
+    def dump(self, tab = 0):
+        "Dump this entry, and all its subentries (for debug purposes only)"
+
+        TYPES = ["(invalid)", "(storage)", "(stream)", "(lockbytes)",
+                 "(property)", "(root)"]
+
+        print " "*tab + repr(self.name), TYPES[self.type],
+        if self.type in (2, 5):
+            print self.size, "bytes",
+        print
+        if self.type in (1, 5) and self.clsid:
+            print " "*tab + "{%s}" % self.clsid
+
+        for kid in self.kids:
+            kid.dump(tab + 2)
+
+#
+# --------------------------------------------------------------------
+
+##
+# This class encapsulates the interface to an OLE 2 structured
+# storage file.  Use the {@link listdir} and {@link openstream}
+# methods to access the contents of this file.
+
+class OleFileIO:
+    """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 1:
+                    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).
+    """
+
+    def __init__(self, filename = None):
+
+        if filename:
+            self.open(filename)
+
+    ##
+    # Open an OLE2 file.
+
+    def open(self, filename):
+        """Open an OLE2 file"""
+
+        if type(filename) == type(""):
+            self.fp = open(filename, "rb")
+        else:
+            self.fp = filename
+
+        header = self.fp.read(512)
+
+        if len(header) != 512 or header[:8] != MAGIC:
+            raise IOError, "not an OLE2 structured storage file"
+
+        # file clsid (probably never used, so we don't store it)
+        clsid = self._clsid(header[8:24])
+
+        # FIXME: could check version and byte order fields
+
+        self.sectorsize = 1 << i16(header, 30)
+        self.minisectorsize = 1 << i16(header, 32)
+
+        self.minisectorcutoff = i32(header, 56)
+
+        # Load file allocation tables
+        self.loadfat(header)
+
+        # Load direcory.  This sets both the sidlist (ordered by id)
+        # and the root (ordered by hierarchy) members.
+        self.loaddirectory(i32(header, 48))
+
+        self.ministream = None
+        self.minifatsect = i32(header, 60)
+
+    def loadfat(self, header):
+        # Load the FAT table.  The header contains a sector numbers
+        # for the first 109 FAT sectors.  Additional sectors are
+        # described by DIF blocks (FIXME: not yet implemented)
+
+        sect = header[76:512]
+        fat = []
+        for i in range(0, len(sect), 4):
+            ix = i32(sect, i)
+            if ix == -2 or ix == -1: # ix == 0xFFFFFFFEL or ix == 0xFFFFFFFFL:
+                break
+            s = self.getsect(ix)
+            fat = fat + map(lambda i, s=s: i32(s, i), range(0, len(s), 4))
+        self.fat = fat
+
+    def loadminifat(self):
+        # Load the MINIFAT table.  This is stored in a standard sub-
+        # stream, pointed to by a header field.
+
+        s = self._open(self.minifatsect).read()
+
+        self.minifat = map(lambda i, s=s: i32(s, i), range(0, len(s), 4))
+
+    def getsect(self, sect):
+        # Read given sector
+
+        self.fp.seek(512 + self.sectorsize * sect)
+        return self.fp.read(self.sectorsize)
+
+    def _unicode(self, s):
+        # Map unicode string to Latin 1
+
+        # FIXME: some day, Python will provide an official way to handle
+        # Unicode strings, but until then, this will have to do...
+        return filter(ord, s)
+
+    def loaddirectory(self, sect):
+        # Load the directory.  The directory is stored in a standard
+        # substream, independent of its size.
+
+        # read directory stream
+        fp = self._open(sect)
+
+        # create list of sid entries
+        self.sidlist = []
+        while 1:
+            entry = fp.read(128)
+            if not entry:
+                break
+            type = ord(entry[66])
+            name = self._unicode(entry[0:0+i16(entry, 64)])
+            ptrs = i32(entry, 68), i32(entry, 72), i32(entry, 76)
+            sect, size = i32(entry, 116), i32(entry, 120)
+            clsid = self._clsid(entry[80:96])
+            self.sidlist.append((name, type, sect, size, ptrs, clsid))
+
+        # create hierarchical list of directory entries
+        self.root = _OleDirectoryEntry(self.sidlist, 0)
+
+    def dumpdirectory(self):
+        # Dump directory (for debugging only)
+
+        self.root.dump()
+
+    def _clsid(self, clsid):
+        if clsid == "\0" * len(clsid):
+            return ""
+        return (("%08X-%04X-%04X-%02X%02X-" + "%02X" * 6) %
+                ((i32(clsid, 0), i16(clsid, 4), i16(clsid, 6)) +
+                tuple(map(ord, clsid[8:16]))))
+
+    def _list(self, files, prefix, node):
+        # listdir helper
+
+        prefix = prefix + [node.name]
+        for entry in node.kids:
+            if entry.kids:
+                self._list(files, prefix, entry)
+            else:
+                files.append(prefix[1:] + [entry.name])
+
+    def _find(self, filename):
+        # openstream helper
+
+        node = self.root
+        for name in filename:
+            for kid in node.kids:
+                if kid.name == name:
+                    break
+            else:
+                raise IOError, "file not found"
+            node = kid
+        return node.sid
+
+    def _open(self, start, size = 0x7FFFFFFF):
+        # openstream helper.
+
+        if size < self.minisectorcutoff:
+            # ministream object
+            if not self.ministream:
+                self.loadminifat()
+                self.ministream = self._open(self.sidlist[0][2])
+            return _OleStream(self.ministream, start, size, 0,
+                              self.minisectorsize, self.minifat)
+
+        # standard stream
+        return _OleStream(self.fp, start, size, 512,
+                          self.sectorsize, self.fat)
+
+    ##
+    # Returns a list of streams stored in this file.
+
+    def listdir(self):
+        """Return a list of streams stored in this file"""
+
+        files = []
+        self._list(files, [], self.root)
+        return files
+
+    ##
+    # Opens a stream as a read-only file object.
+
+    def openstream(self, filename):
+        """Open a stream as a read-only file object"""
+
+        slot = self._find(filename)
+        name, type, sect, size, sids, clsid = self.sidlist[slot]
+        if type != 2:
+            raise IOError, "this file is not a stream"
+        return self._open(sect, size)
+
+    ##
+    # Gets a list of properties described in substream.
+
+    def getproperties(self, filename):
+        """Return properties described in substream"""
+
+        fp = self.openstream(filename)
+
+        data = {}
+
+        # header
+        s = fp.read(28)
+        clsid = self._clsid(s[8:24])
+
+        # format id
+        s = fp.read(20)
+        fmtid = self._clsid(s[:16])
+        fp.seek(i32(s, 16))
+
+        # get section
+        s = "****" + fp.read(i32(fp.read(4))-4)
+
+        for i in range(i32(s, 4)):
+
+            id = i32(s, 8+i*8)
+            offset = i32(s, 12+i*8)
+            type = i32(s, offset)
+
+            # test for common types first (should perhaps use
+            # a dictionary instead?)
+
+            if type == VT_I2:
+                value = i16(s, offset+4)
+                if value >= 32768:
+                    value = value - 65536
+            elif type == VT_UI2:
+                value = i16(s, offset+4)
+            elif type in (VT_I4, VT_ERROR):
+                value = i32(s, offset+4)
+            elif type == VT_UI4:
+                value = i32(s, offset+4) # FIXME
+            elif type in (VT_BSTR, VT_LPSTR):
+                count = i32(s, offset+4)
+                value = s[offset+8:offset+8+count-1]
+            elif type == VT_BLOB:
+                count = i32(s, offset+4)
+                value = s[offset+8:offset+8+count]
+            elif type == VT_LPWSTR:
+                count = i32(s, offset+4)
+                value = self._unicode(s[offset+8:offset+8+count*2])
+            elif type == VT_FILETIME:
+                value = long(i32(s, offset+4)) + (long(i32(s, offset+8))<<32)
+                # FIXME: this is a 64-bit int: "number of 100ns periods
+                # since Jan 1,1601".  Should map this to Python time
+                value = value / 10000000L # seconds
+            elif type == VT_UI1:
+                value = ord(s[offset+4])
+            elif type == VT_CLSID:
+                value = self._clsid(s[offset+4:offset+20])
+            elif type == VT_CF:
+                count = i32(s, offset+4)
+                value = s[offset+8:offset+8+count]
+            else:
+                value = None # everything else yields "None"
+
+            # FIXME: add support for VT_VECTOR
+
+            #print "%08x" % id, repr(value),
+            #print "(%s)" % VT[i32(s, offset) & 0xFFF]
+
+            data[id] = value
+
+        return data
+
+#
+# --------------------------------------------------------------------
+# This script can be used to dump the directory of any OLE2 structured
+# storage file.
+
+if __name__ == "__main__":
+
+    import sys
+
+    for file in sys.argv[1:]:
+        try:
+            ole = OleFileIO(file)
+            print "-" * 68
+            print file
+            print "-" * 68
+            ole.dumpdirectory()
+            for file in ole.listdir():
+                if file[-1][0] == "\005":
+                    print file
+                    props = ole.getproperties(file)
+                    props = props.items()
+                    props.sort()
+                    for k, v in props:
+                        print "   ", k, v
+        except IOError, v:
+            print "***", "cannot read", file, "-", v

OleFileIO_PL/README.txt

+OleFileIO_PL module:
+
+OleFileIO_PL is a Python module to read Microsoft OLE2 files (Structured 
+Storage), such as Microsoft Office documents, Image Composer and FlashPix files,
+ Outlook messages, ...
+
+This is an improved version of the OleFileIO module from PIL library v1.1.6 
+(See: http://www.pythonware.com/products/pil/index.htm)
+
+WARNING: THIS IS (STILL) WORK IN PROGRESS.
+
+
+
+INSTALLATION:
+
+- on Windows, launch install.bat
+- on other systems, launch: setup.py install
+
+
+
+HOW TO USE THIS MODULE:
+
+See http://www.decalage.info/python/olefileio
+See main at the end of the module, and also docstrings.
+
+
+
+LICENSE:
+
+See LICENSE.txt.
Add a comment to this file

OleFileIO_PL/__init__.py

Empty file added.

OleFileIO_PL/install.bat

+@echo off
+rem INSTALL.BAT - Easy installer for Python modules on Windows
+
+rem version 0.02 2009-02-27 Philippe Lagadec - http://www.decalage.info
+
+rem License: 
+rem This file install.bat can freely used, modified and redistributed, as 
+rem long as credit to the author is kept intact. Please send any feedback,
+rem issues or improvements to decalage at laposte.net.
+
+rem CHANGELOG:
+rem 2007-09-04 v0.01 PL: - first version, for Python 2.3 to 2.5
+rem 2009-02-27 v0.02 PL: - added support for Python 2.6
+
+rem 1) test if python.exe is in the path:
+
+python.exe --version >NUL 2>&1
+if errorlevel 1 goto notpath
+echo Python.exe found in the path.
+python setup.py install
+if errorlevel 1 goto error
+goto end
+:NOTPATH
+
+rem 2) test for usual python.exe paths:
+
+REM Python 2.6: 
+c:\python26\python.exe --version >NUL 2>&1
+if errorlevel 1 goto notpy26
+echo Python.exe found in C:\Python26
+c:\python26\python.exe setup.py install
+if errorlevel 1 goto error
+goto end 
+:NOTPY26
+
+c:\python25\python.exe --version >NUL 2>&1
+if errorlevel 1 goto notpy25
+echo Python.exe found in C:\Python25
+c:\python25\python.exe setup.py install
+if errorlevel 1 goto error
+goto end 
+:NOTPY25
+
+c:\python24\python.exe --version >NUL 2>&1
+if errorlevel 1 goto notpy24
+echo Python.exe found in C:\Python24
+c:\python24\python.exe setup.py install
+if errorlevel 1 goto error
+goto end 
+:NOTPY24
+
+c:\python23\python.exe --version >NUL 2>&1
+if errorlevel 1 goto notpy23
+echo Python.exe found in C:\Python23
+c:\python23\python.exe setup.py install
+if errorlevel 1 goto error
+goto end 
+:NOTPY23
+
+"c:\program files\python\python.exe" --version >NUL 2>&1
+if errorlevel 1 goto notpf
+echo Python.exe found in C:\Program Files\Python
+"c:\program files\python\python.exe" setup.py install
+if errorlevel 1 goto error
+goto end 
+:NOTPF
+
+rem 3) last we just try to launch the script, if .py is associated to python.exe
+echo Python.exe not found, trying to launch setup.py directly.
+setup.py install
+if errorlevel 1 goto error
+goto end
+
+:ERROR
+echo.
+echo If the installation is not successful, try to run "python setup.py install"
+echo or simply "setup.py install" in the script directory.
+echo You can also copy files by hand in the site-package directory of your
+echo Python directory.
+REM pause
+
+:END
+pause

OleFileIO_PL/setup.py

+# Setup script for OleFileIO_PL - Philippe Lagadec
+
+# History:
+# 2007-09-13 v0.01 PL: - first version
+# 2007-11-10 v0.02 PL: - updated website URL
+# 2007-12-04 v0.03 PL: - updated description, added debug_mode test
+# 2009-09-11 v0.04 PL: - updated URL, e-mail, licence, disabled e-mail
+
+import distutils.core
+
+from OleFileIO_PL import __version__, __author__, DEBUG_MODE
+
+# debug mode should be off for usual releases:
+if DEBUG_MODE:
+    raise ValueError, "WARNING: DEBUG_MODE should be False !"
+
+kw = {
+    'name': "OleFileIO_PL",
+    'version': __version__,
+    'description': "A Python module to parse and read Microsoft OLE2 files (Structured Storage or Compound Document, Microsoft Office) - Improved version of the OleFileIO module from PIL, the Python Image Library.",
+    'author': __author__,
+    #'author_email': "decalage(a)laposte.net",
+    'url': "http://www.decalage.info/python/olefileio",
+    'license': "updated PIL license (see source code or LICENCE.txt)",
+    'py_modules': ['OleFileIO_PL'],
+    }
+
+
+# If we're running Python 2.3, add extra information
+if hasattr(distutils.core, 'setup_keywords'):
+    if 'classifiers' in distutils.core.setup_keywords:
+        kw['classifiers'] = [
+            'Development Status :: 4 - Beta',
+            'License :: OSI Approved', #'License :: PIL license (see source code)',
+            'Intended Audience :: Developers',
+            'Operating System :: OS Independent',
+            'Programming Language :: Python',
+            'Topic :: Software Development :: Libraries :: Python Modules'
+          ]
+    if 'download_url' in distutils.core.setup_keywords:
+        kw['download_url'] = "http://www.decalage.info/python/olefileio"
+
+distutils.core.setup(**kw)
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.