herostats 0.1.0

data/lib/heroprotocol/heroprotocol.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2015 Blizzard Entertainment
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+import sys
+import argparse
+import pprint
+import json
+
+from mpyq import mpyq
+import protocol29406
+
+class EventLogger:
+    def __init__(self):
+        self._event_stats = {}
+
+    def log(self, output, event):
+        # update stats
+        if '_event' in event and '_bits' in event:
+            stat = self._event_stats.get(event['_event'], [0, 0])
+            stat[0] += 1  # count of events
+            stat[1] += event['_bits']  # count of bits
+            self._event_stats[event['_event']] = stat
+        # write structure
+        if args.json:
+            s = json.dumps(event, encoding="ISO-8859-1");
+            print(s);
+        else:
+            pprint.pprint(event, stream=output)
+
+    def log_stats(self, output):
+        for name, stat in sorted(self._event_stats.iteritems(), key=lambda x: x[1][1]):
+            print >> output, '"%s", %d, %d,' % (name, stat[0], stat[1] / 8)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('replay_file', help='.StormReplay file to load')
+    parser.add_argument("--gameevents", help="print game events",
+                        action="store_true")
+    parser.add_argument("--messageevents", help="print message events",
+                        action="store_true")
+    parser.add_argument("--trackerevents", help="print tracker events",
+                        action="store_true")
+    parser.add_argument("--attributeevents", help="print attributes events",
+                        action="store_true")
+    parser.add_argument("--header", help="print protocol header",
+                        action="store_true")
+    parser.add_argument("--details", help="print protocol details",
+                        action="store_true")
+    parser.add_argument("--initdata", help="print protocol initdata",
+                        action="store_true")
+    parser.add_argument("--stats", help="print stats",
+                        action="store_true")
+    parser.add_argument("--json", help="protocol information is printed in json format.",
+                        action="store_true")
+    args = parser.parse_args()
+
+    archive = mpyq.MPQArchive(args.replay_file)
+
+    logger = EventLogger()
+    logger.args = args;
+
+    # Read the protocol header, this can be read with any protocol
+    contents = archive.header['user_data_header']['content']
+    header = protocol29406.decode_replay_header(contents)
+    if args.header:
+        logger.log(sys.stdout, header)
+
+    # The header's baseBuild determines which protocol to use
+    baseBuild = header['m_version']['m_baseBuild']
+    try:
+        protocol = __import__('protocol%s' % (baseBuild,))
+    except:
+        print >> sys.stderr, 'Unsupported base build: %d' % baseBuild
+        sys.exit(1)
+
+    # Print protocol details
+    if args.details:
+        contents = archive.read_file('replay.details')
+        details = protocol.decode_replay_details(contents)
+        logger.log(sys.stdout, details)
+
+    # Print protocol init data
+    if args.initdata:
+        contents = archive.read_file('replay.initData')
+        initdata = protocol.decode_replay_initdata(contents)
+        logger.log(sys.stdout, initdata['m_syncLobbyState']['m_gameDescription']['m_cacheHandles'])
+        logger.log(sys.stdout, initdata)
+
+    # Print game events and/or game events stats
+    if args.gameevents:
+        contents = archive.read_file('replay.game.events')
+        for event in protocol.decode_replay_game_events(contents):
+            logger.log(sys.stdout, event)
+
+    # Print message events
+    if args.messageevents:
+        contents = archive.read_file('replay.message.events')
+        for event in protocol.decode_replay_message_events(contents):
+            logger.log(sys.stdout, event)
+
+    # Print tracker events
+    if args.trackerevents:
+        if hasattr(protocol, 'decode_replay_tracker_events'):
+            contents = archive.read_file('replay.tracker.events')
+            for event in protocol.decode_replay_tracker_events(contents):
+                logger.log(sys.stdout, event)
+
+    # Print attributes events
+    if args.attributeevents:
+        contents = archive.read_file('replay.attributes.events')
+        attributes = protocol.decode_replay_attributes_events(contents)
+        logger.log(sys.stdout, attributes)
+
+    # Print stats
+    if args.stats:
+        logger.log_stats(sys.stderr)

data/lib/heroprotocol/mpyq/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2010, 2011 Aku Kotkavuo. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/lib/heroprotocol/mpyq/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+include MANIFEST.in

data/lib/heroprotocol/mpyq/README.md

@@ -0,0 +1,202 @@
+# mpyq
+
+mpyq is a Python library for reading MPQ (MoPaQ) archives used in many of
+Blizzard's games. It was originally developed for data mining Starcraft II
+replay files.
+
+In addition to being a library, mpyq also has a command line interface that
+exposes some of the library's core functionality such as extracting archives.
+
+At this early stage in development only files compressed with DEFLATE or bzip2
+are uncompressed. This means that this library can not be used to extract most
+big game asset archives that Blizzard's games use. More compression formats
+will be supported in the future.
+
+Also, as mpyq is so far pure Python code, it might be unfeasible to try to
+extract very large MPQ archives, even if all the compression methods used
+inside the archive were supported.
+
+Note that listing files inside an archive does not require full extraction.
+You can safely take a peek inside any MPQ archive with this library.
+
+## Installation
+
+A stable version of mpyq is available from PyPI and can be installed with
+either `easy_install` or `pip`.
+
+    $ easy_install mpyq
+    $ pip install mpyq
+
+mpyq can be installed manually with the included setup.py script.
+
+    $ python setup.py install
+
+Running this command will install mpyq both as a library and a stand-alone
+script that can be run from anywhere, provided that you have added Python's
+bin directory to your PATH environment variable.
+
+Alternative way to install mpyq is to clone this git repository somewhere on
+your filesystem and then either adjust your PYTHONPATH environment variable to
+point to the directory that contains the repository or create a symbolic link
+to your Python's site-packages directory pointing at the repository.
+
+Note that the command line interface part of mpyq uses the argparse module,
+which was included into Python's standard library in version 2.7. If you
+didn't install mpyq from PyPI and you wish to use the command line interface
+part with Python 2.6, you should install argparse from PyPI manually.
+
+## Usage
+
+### As a library
+
+    >>> from mpyq import MPQArchive
+    >>> archive = MPQArchive('game.SC2Replay')
+
+Now you have a MPQArchive object of the file you opened. One common thing
+to do now is to extract the files from the archive.
+
+    >>> files = archive.extract()
+
+This will extract and return the archive's contents in memory. Be advised
+that you might not want to do this with multi-gigabyte MPQ files from
+World of Warcraft, for example.
+
+Files inside the archive can be also extracted and written to disk.
+
+    >>> archive.extract_to_disk()
+
+If you want to skip reading the (listfile) inside the archive, you can do
+so by passing `listfile=False` to the constructor.
+
+    >>> archive = MPQArchive('bad_listfile.SC2Replay', listfile=False)
+
+This might be required if the (listfile) is encrypted or has been tampered
+with. Note that you can't list files or extract the whole archive if you do
+this -- you need to know in advance which files you want to read.
+
+    >>> archive.read('replay.details')
+    '\x05\x1c\x00\x04\x01\x00\x04\x05...'
+
+For more information, consult `help(mpyq)` in your Python console.
+
+### From the command line
+
+    usage: mpyq.py [-h] [-I] [-H] [-b] [-s] [-t] [-x] file
+
+    mpyq reads and extracts MPQ archives.
+
+    positional arguments:
+      file                 path to the archive
+
+    optional arguments:
+      -h, --help           show this help message and exit
+      -I, --headers        print header information from the archive
+      -H, --hash-table     print hash table
+      -b, --block-table    print block table
+      -s, --skip-listfile  skip reading (listfile)
+      -t, --list-files     list files inside the archive
+      -x, --extract        extract files from the archive
+
+You can extract all the files inside the archive with `-x/--extract`.
+
+    $ mpyq -x game.SC2Replay
+
+This will create a directory called 'game' with the files inside.
+
+You can print the header information from a given archive with `-I/--headers`.
+
+    $ mpyq -I game.SC2Replay
+    MPQ archive header
+    ------------------
+    magic                          'MPQ\x1a'
+    header_size                    44
+    arhive_size                    19801
+    format_version                 1
+    sector_size_shift              3
+    hash_table_offset              19385
+    block_table_offset             19641
+    hash_table_entries             16
+    block_table_entries            10
+    extended_block_table_offset    0
+    hash_table_offset_high         0
+    block_table_offset_high        0
+    offset                         1024
+
+    MPQ user data header
+    --------------------
+    magic                          'MPQ\x1b'
+    user_data_size                 512
+    mpq_header_offset              1024
+    user_data_header_size          60
+    content                        '\x05\x08\x00\x02,StarCraft II replay\x1b
+                                    11\x02\x05\x0c\x00\t\x02\x02\t\x00\x04\t
+                                    (\x06\t\x00\x08\t\xc8\xfa\x01\n\t\xc8\xf
+                                    a\x01\x04\t\x04\x06\t\xa2\x99\x01'
+
+You can display the archive's hash table with `-H/--hash-table`.
+
+    $ mpyq -H game.SC2Replay
+    MPQ archive hash table
+    ----------------------
+     Hash A   Hash B  Locl Plat BlockIdx
+    D38437CB 07DFEAEC 0000 0000 00000009
+    AAC2A54B F4762B95 0000 0000 00000002
+    FFFFFFFF FFFFFFFF FFFF FFFF FFFFFFFF
+    FFFFFFFF FFFFFFFF FFFF FFFF FFFFFFFF
+    FFFFFFFF FFFFFFFF FFFF FFFF FFFFFFFF
+    C9E5B770 3B18F6B6 0000 0000 00000005
+    343C087B 278E3682 0000 0000 00000004
+    3B2B1EA0 B72EF057 0000 0000 00000006
+    5A7E8BDC FF253F5C 0000 0000 00000001
+    FD657910 4E9B98A7 0000 0000 00000008
+    D383C29C EF402E92 0000 0000 00000000
+    FFFFFFFF FFFFFFFF FFFF FFFF FFFFFFFF
+    FFFFFFFF FFFFFFFF FFFF FFFF FFFFFFFF
+    FFFFFFFF FFFFFFFF FFFF FFFF FFFFFFFF
+    1DA8B0CF A2CEFF28 0000 0000 00000007
+    31952289 6A5FFAA3 0000 0000 00000003
+
+You can display the archive's block table with `-b/--block-table`.
+
+    $ mpyq -b game.SC2Replay
+    MPQ archive block table
+    -----------------------
+     Offset  ArchSize RealSize  Flags
+    0000002C      443      443 81000200
+    000001E7      609     1082 81000200
+    00000448    16077    42859 81000200
+    00004315       94       94 81000200
+    00004373       96       96 81000200
+    000043D3      591      765 81000200
+    00004622      802     1444 81000200
+    00004944      247      580 81000200
+    00004A3B      120      164 81000200
+    00004AB3      262      288 81000200
+
+You can list all files inside the archive with `-t/--list-files`.
+
+    $ mpyq -t game.SC2Replay
+    replay.attributes.events            580 bytes
+    replay.details                      443 bytes
+    replay.game.events                42859 bytes
+    replay.initData                    1082 bytes
+    replay.load.info                     96 bytes
+    replay.message.events                94 bytes
+    replay.smartcam.events             1444 bytes
+    replay.sync.events                  765 bytes
+
+You can skip reading the listfile with `-s/--skip-listfile`. This might be
+necessarry if the listfile is encrypted or corrupted. Note that you cannot
+list files or extract the whole archive without the listfile.
+
+## References
+
+The following two documents were used as references for the MPQ format:
+
+ * [http://www.zezula.net/en/mpq/mpqformat.html](http://www.zezula.net/en/mpq/mpqformat.html)
+ * [http://wiki.devklog.net/index.php?title=The_MoPaQ_Archive_Format](http://wiki.devklog.net/index.php?title=The_MoPaQ_Archive_Format)
+
+
+## Copyright
+
+Copyright 2010, 2011 Aku Kotkavuo. See LICENSE for details.

data/lib/heroprotocol/mpyq/mpyq.py

@@ -0,0 +1,406 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+"""
+mpyq is a Python library for reading MPQ (MoPaQ) archives.
+"""
+
+import bz2
+import cStringIO
+import os
+import struct
+import zlib
+from collections import namedtuple
+
+
+__author__ = "Aku Kotkavuo"
+__version__ = "0.2.0"
+
+
+MPQ_FILE_IMPLODE        = 0x00000100
+MPQ_FILE_COMPRESS       = 0x00000200
+MPQ_FILE_ENCRYPTED      = 0x00010000
+MPQ_FILE_FIX_KEY        = 0x00020000
+MPQ_FILE_SINGLE_UNIT    = 0x01000000
+MPQ_FILE_DELETE_MARKER  = 0x02000000
+MPQ_FILE_SECTOR_CRC     = 0x04000000
+MPQ_FILE_EXISTS         = 0x80000000
+
+MPQFileHeader = namedtuple('MPQFileHeader',
+    '''
+    magic
+    header_size
+    archive_size
+    format_version
+    sector_size_shift
+    hash_table_offset
+    block_table_offset
+    hash_table_entries
+    block_table_entries
+    '''
+)
+MPQFileHeader.struct_format = '<4s2I2H4I'
+
+MPQFileHeaderExt = namedtuple('MPQFileHeaderExt',
+    '''
+    extended_block_table_offset
+    hash_table_offset_high
+    block_table_offset_high
+    '''
+)
+MPQFileHeaderExt.struct_format = 'q2h'
+
+MPQUserDataHeader = namedtuple('MPQUserDataHeader',
+    '''
+    magic
+    user_data_size
+    mpq_header_offset
+    user_data_header_size
+    '''
+)
+MPQUserDataHeader.struct_format = '<4s3I'
+
+MPQHashTableEntry = namedtuple('MPQHashTableEntry',
+    '''
+    hash_a
+    hash_b
+    locale
+    platform
+    block_table_index
+    '''
+)
+MPQHashTableEntry.struct_format = '2I2HI'
+
+MPQBlockTableEntry = namedtuple('MPQBlockTableEntry',
+    '''
+    offset
+    archived_size
+    size
+    flags
+    '''
+)
+MPQBlockTableEntry.struct_format = '4I'
+
+
+class MPQArchive(object):
+
+    def __init__(self, filename, listfile=True):
+        """Create a MPQArchive object.
+
+        You can skip reading the listfile if you pass listfile=False
+        to the constructor. The 'files' attribute will be unavailable
+        if you do this.
+        """
+        if hasattr(filename, 'read'):
+            self.file = filename
+        else:
+            self.file = open(filename, 'rb')
+        self.header = self.read_header()
+        self.hash_table = self.read_table('hash')
+        self.block_table = self.read_table('block')
+        if listfile:
+            self.files = self.read_file('(listfile)').splitlines()
+        else:
+            self.files = None
+
+    def read_header(self):
+        """Read the header of a MPQ archive."""
+
+        def read_mpq_header(offset=None):
+            if offset:
+                self.file.seek(offset)
+            data = self.file.read(32)
+            header = MPQFileHeader._make(
+                struct.unpack(MPQFileHeader.struct_format, data))
+            header = header._asdict()
+            if header['format_version'] == 1:
+                data = self.file.read(12)
+                extended_header = MPQFileHeaderExt._make(
+                    struct.unpack(MPQFileHeaderExt.struct_format, data))
+                header.update(extended_header._asdict())
+            return header
+
+        def read_mpq_user_data_header():
+            data = self.file.read(16)
+            header = MPQUserDataHeader._make(
+                struct.unpack(MPQUserDataHeader.struct_format, data))
+            header = header._asdict()
+            header['content'] = self.file.read(header['user_data_header_size'])
+            return header
+
+        magic = self.file.read(4)
+        self.file.seek(0)
+
+        if magic == 'MPQ\x1a':
+            header = read_mpq_header()
+            header['offset'] = 0
+        elif magic == 'MPQ\x1b':
+            user_data_header = read_mpq_user_data_header()
+            header = read_mpq_header(user_data_header['mpq_header_offset'])
+            header['offset'] = user_data_header['mpq_header_offset']
+            header['user_data_header'] = user_data_header
+
+        return header
+
+    def read_table(self, table_type):
+        """Read either the hash or block table of a MPQ archive."""
+
+        if table_type == 'hash':
+            entry_class = MPQHashTableEntry
+        elif table_type == 'block':
+            entry_class = MPQBlockTableEntry
+        else:
+            raise ValueError("Invalid table type.")
+
+        table_offset = self.header['%s_table_offset' % table_type]
+        table_entries = self.header['%s_table_entries' % table_type]
+        key = self._hash('(%s table)' % table_type, 'TABLE')
+
+        self.file.seek(table_offset + self.header['offset'])
+        data = self.file.read(table_entries * 16)
+        data = self._decrypt(data, key)
+
+        def unpack_entry(position):
+            entry_data = data[position*16:position*16+16]
+            return entry_class._make(
+                struct.unpack(entry_class.struct_format, entry_data))
+
+        return [unpack_entry(i) for i in range(table_entries)]
+
+    def get_hash_table_entry(self, filename):
+        """Get the hash table entry corresponding to a given filename."""
+        hash_a = self._hash(filename, 'HASH_A')
+        hash_b = self._hash(filename, 'HASH_B')
+        for entry in self.hash_table:
+            if (entry.hash_a == hash_a and entry.hash_b == hash_b):
+                return entry
+
+    def read_file(self, filename, force_decompress=False):
+        """Read a file from the MPQ archive."""
+
+        def decompress(data):
+            """Read the compression type and decompress file data."""
+            compression_type = ord(data[0])
+            if compression_type == 0:
+                return data
+            elif compression_type == 2:
+                return zlib.decompress(data[1:], 15)
+            elif compression_type == 16:
+                return bz2.decompress(data[1:])
+            else:
+                raise RuntimeError("Unsupported compression type.")
+
+        hash_entry = self.get_hash_table_entry(filename)
+        if hash_entry is None:
+            return None
+        block_entry = self.block_table[hash_entry.block_table_index]
+
+        # Read the block.
+        if block_entry.flags & MPQ_FILE_EXISTS:
+            if block_entry.archived_size == 0:
+                return None
+
+            offset = block_entry.offset + self.header['offset']
+            self.file.seek(offset)
+            file_data = self.file.read(block_entry.archived_size)
+
+            if block_entry.flags & MPQ_FILE_ENCRYPTED:
+                raise NotImplementedError("Encryption is not supported yet.")
+
+            if not block_entry.flags & MPQ_FILE_SINGLE_UNIT:
+                # File consist of many sectors. They all need to be
+                # decompressed separately and united.
+                sector_size = 512 << self.header['sector_size_shift']
+                sectors = block_entry.size / sector_size + 1
+                if block_entry.flags & MPQ_FILE_SECTOR_CRC:
+                    crc = True
+                    sectors += 1
+                else:
+                    crc = False
+                positions = struct.unpack('<%dI' % (sectors + 1),
+                                          file_data[:4*(sectors+1)])
+                result = cStringIO.StringIO()
+                for i in range(len(positions) - (2 if crc else 1)):
+                    sector = file_data[positions[i]:positions[i+1]]
+                    if (block_entry.flags & MPQ_FILE_COMPRESS and
+                        (force_decompress or block_entry.size > block_entry.archived_size)):
+                        sector = decompress(sector)
+                    result.write(sector)
+                file_data = result.getvalue()
+            else:
+                # Single unit files only need to be decompressed, but
+                # compression only happens when at least one byte is gained.
+                if (block_entry.flags & MPQ_FILE_COMPRESS and
+                    (force_decompress or block_entry.size > block_entry.archived_size)):
+                    file_data = decompress(file_data)
+
+            return file_data
+
+    def extract(self):
+        """Extract all the files inside the MPQ archive in memory."""
+        if self.files:
+            return dict((f, self.read_file(f)) for f in self.files)
+        else:
+            raise RuntimeError("Can't extract whole archive without listfile.")
+
+    def extract_to_disk(self):
+        """Extract all files and write them to disk."""
+        archive_name, extension = os.path.splitext(os.path.basename(self.file.name))
+        if not os.path.isdir(os.path.join(os.getcwd(), archive_name)):
+            os.mkdir(archive_name)
+        os.chdir(archive_name)
+        for filename, data in self.extract().items():
+            f = open(filename, 'wb')
+            f.write(data)
+            f.close()
+
+    def extract_files(self, *filenames):
+        """Extract given files from the archive to disk."""
+        for filename in filenames:
+            data = self.read_file(filename)
+            f = open(filename, 'wb')
+            f.write(data)
+            f.close()
+
+    def print_headers(self):
+        print "MPQ archive header"
+        print "------------------"
+        for key, value in self.header.iteritems():
+            if key == "user_data_header":
+                continue
+            print "{0:30} {1!r}".format(key, value)
+        if self.header.get('user_data_header'):
+            print
+            print "MPQ user data header"
+            print "--------------------"
+            for key, value in self.header['user_data_header'].iteritems():
+                print "{0:30} {1!r}".format(key, value)
+        print
+
+    def print_hash_table(self):
+        print "MPQ archive hash table"
+        print "----------------------"
+        print " Hash A   Hash B  Locl Plat BlockIdx"
+        for entry in self.hash_table:
+            print '%08X %08X %04X %04X %08X' % entry
+        print
+
+    def print_block_table(self):
+        print "MPQ archive block table"
+        print "-----------------------"
+        print " Offset  ArchSize RealSize  Flags"
+        for entry in self.block_table:
+            print '%08X %8d %8d %8X' % entry
+        print
+
+    def print_files(self):
+        if self.files:
+            print "Files"
+            print "-----"
+            width = max(len(name) for name in self.files) + 2
+            for filename in self.files:
+                hash_entry = self.get_hash_table_entry(filename)
+                block_entry = self.block_table[hash_entry.block_table_index]
+                print "{0:{width}} {1:>8} bytes".format(filename,
+                                                        block_entry.size,
+                                                        width=width)
+
+    def _hash(self, string, hash_type):
+        """Hash a string using MPQ's hash function."""
+        hash_types = {
+            'TABLE_OFFSET': 0,
+            'HASH_A': 1,
+            'HASH_B': 2,
+            'TABLE': 3
+        }
+        seed1 = 0x7FED7FED
+        seed2 = 0xEEEEEEEE
+
+        for ch in string:
+            ch = ord(ch.upper())
+            value = self.encryption_table[(hash_types[hash_type] << 8) + ch]
+            seed1 = (value ^ (seed1 + seed2)) & 0xFFFFFFFF
+            seed2 = ch + seed1 + seed2 + (seed2 << 5) + 3 & 0xFFFFFFFF
+
+        return seed1
+
+    def _decrypt(self, data, key):
+        """Decrypt hash or block table or a sector."""
+        seed1 = key
+        seed2 = 0xEEEEEEEE
+        result = cStringIO.StringIO()
+
+        for i in range(len(data) // 4):
+            seed2 += self.encryption_table[0x400 + (seed1 & 0xFF)]
+            seed2 &= 0xFFFFFFFF
+            value = struct.unpack("<I", data[i*4:i*4+4])[0]
+            value = (value ^ (seed1 + seed2)) & 0xFFFFFFFF
+
+            seed1 = ((~seed1 << 0x15) + 0x11111111) | (seed1 >> 0x0B)
+            seed1 &= 0xFFFFFFFF
+            seed2 = value + seed2 + (seed2 << 5) + 3 & 0xFFFFFFFF
+
+            result.write(struct.pack("<I", value))
+
+        return result.getvalue()
+
+    def _prepare_encryption_table():
+        """Prepare encryption table for MPQ hash function."""
+        seed = 0x00100001
+        crypt_table = {}
+
+        for i in range(256):
+            index = i
+            for j in range(5):
+                seed = (seed * 125 + 3) % 0x2AAAAB
+                temp1 = (seed & 0xFFFF) << 0x10
+
+                seed = (seed * 125 + 3) % 0x2AAAAB
+                temp2 = (seed & 0xFFFF)
+
+                crypt_table[index] = (temp1 | temp2)
+
+                index += 0x100
+
+        return crypt_table
+
+    encryption_table = _prepare_encryption_table()
+
+
+def main():
+    import argparse
+    description = "mpyq reads and extracts MPQ archives."
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument("file", action="store", help="path to the archive")
+    parser.add_argument("-I", "--headers", action="store_true", dest="headers",
+                        help="print header information from the archive")
+    parser.add_argument("-H", "--hash-table", action="store_true",
+                        dest="hash_table", help="print hash table"),
+    parser.add_argument("-b", "--block-table", action="store_true",
+                        dest="block_table", help="print block table"),
+    parser.add_argument("-s", "--skip-listfile", action="store_true",
+                        dest="skip_listfile", help="skip reading (listfile)"),
+    parser.add_argument("-t", "--list-files", action="store_true", dest="list",
+                        help="list files inside the archive")
+    parser.add_argument("-x", "--extract", action="store_true", dest="extract",
+                        help="extract files from the archive")
+    args = parser.parse_args()
+    if args.file:
+        if not args.skip_listfile:
+            archive = MPQArchive(args.file)
+        else:
+            archive = MPQArchive(args.file, listfile=False)
+        if args.headers:
+            archive.print_headers()
+        if args.hash_table:
+            archive.print_hash_table()
+        if args.block_table:
+            archive.print_block_table()
+        if args.list:
+            archive.print_files()
+        if args.extract:
+            archive.extract_to_disk()
+
+
+if __name__ == '__main__':
+    main()