erffile.h

Go to the documentation of this file.

/* xoreos - A reimplementation of BioWare's Aurora engine
 *
 * xoreos is the legal property of its developers, whose names
 * can be found in the AUTHORS file distributed with this source
 * distribution.
 *
 * xoreos is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or (at your option) any later version.
 *
 * xoreos is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with xoreos. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef AURORA_ERFFILE_H
#define AURORA_ERFFILE_H

#include <vector>

#include "src/common/types.h"
#include "src/common/scopedptr.h"
#include "src/common/ustring.h"

#include "src/aurora/types.h"
#include "src/aurora/archive.h"
#include "src/aurora/aurorafile.h"
#include "src/aurora/locstring.h"

namespace Common {
    class SeekableReadStream;
}

namespace Aurora {

class ERFFile : public Archive, public AuroraFile {
public:
    ERFFile(Common::SeekableReadStream *erf, const std::vector<byte> &password = std::vector<byte>());
    ~ERFFile();

    const ResourceList &getResources() const;

    uint32 getResourceSize(uint32 index) const;

    Common::SeekableReadStream *getResource(uint32 index, bool tryNoCopy = false) const;

    uint32 getBuildYear() const;
    uint32 getBuildDay() const;

    const LocString &getDescription() const;

    Common::HashAlgo getNameHashAlgo() const;

    static LocString getDescription(Common::SeekableReadStream &erf);
    static LocString getDescription(const Common::UString &fileName);

private:
    enum Encryption {
        kEncryptionNone        =  0, 
        kEncryptionXOR         =  1, 
        kEncryptionBlowfishDAO =  2, 
        kEncryptionBlowfishDA2 =  3, 
        kEncryptionBlowfishNWN = 16  
    };

    enum Compression {
        kCompressionNone           = 0, 
        kCompressionBioWareZlib    = 1, 
        kCompressionHeaderlessZlib = 7, 
        kCompressionStandardZlib   = 8  
    };

    struct ERFHeader {
        uint32 resCount;         

        uint32 langCount;        
        uint32 descriptionID;    

        uint32 offDescription;   
        uint32 offKeyList;       
        uint32 offResList;       

        uint32 descriptionSize;  

        uint32 buildYear;        
        uint32 buildDay;         

        bool   isNWNPremium;     

        Common::ScopedArray<char> stringTable; 
        uint32 stringTableSize;                

        uint32 moduleID;         

        Encryption  encryption;  
        Compression compression; 

        std::vector<byte> passwordDigest;

        ERFHeader();
        ~ERFHeader();

        void clear();
        void clearStringTable();

        bool isSensible(size_t fileSize = SIZE_MAX);
    };

    struct IResource {
        uint32 offset;       
        uint32 packedSize;   
        uint32 unpackedSize; 
    };

    typedef std::vector<IResource> IResourceList;

    Common::ScopedPtr<Common::SeekableReadStream> _erf;

    ERFHeader _header;

    LocString _description;

    ResourceList _resources;

    IResourceList _iResources;

    std::vector<byte> _password;

    void load();

    // .--- Header
    static void verifyVersion(uint32 id, uint32 version, bool utf16le);

    static void readERFHeader(Common::SeekableReadStream &erf, ERFHeader &header, uint32 version,
                              std::vector<byte> &password);
    static void readDescription(LocString &description, Common::SeekableReadStream &erf,
                              const ERFHeader &header);

    void readResources(Common::SeekableReadStream &erf, const ERFHeader &header);
    // '---

    // .--- V1.0
    static void readV10Header(Common::SeekableReadStream &erf, ERFHeader &header);
    void readV10ResList(Common::SeekableReadStream &erf, const ERFHeader &header);
    void readV10KeyList(Common::SeekableReadStream &erf, const ERFHeader &header);
    // '---

    // .--- V1.1
    static void readV11Header(Common::SeekableReadStream &erf, ERFHeader &header);
    void readV11KeyList(Common::SeekableReadStream &erf, const ERFHeader &header);
    // '---

    // .--- V2.0
    static void readV20Header(Common::SeekableReadStream &erf, ERFHeader &header);
    void readV20ResList(Common::SeekableReadStream &erf, const ERFHeader &header);
    // '---

    // .--- V2.1
    static void readV21Header(Common::SeekableReadStream &erf, ERFHeader &header);
    void readV21ResList(Common::SeekableReadStream &erf, const ERFHeader &header);
    // '---

    // .--- V2.2
    static void readV22Header(Common::SeekableReadStream &erf, ERFHeader &header, uint32 &flags);
    void readV22ResList(Common::SeekableReadStream &erf, const ERFHeader &header);
    // '---

    // .--- V3.0
    static void readV30Header(Common::SeekableReadStream &erf, ERFHeader &header, uint32 &flags);
    void readV30ResList(Common::SeekableReadStream &erf, const ERFHeader &header);
    // '---

    // .--- Encryption
    void verifyPasswordDigest();

    static Common::MemoryReadStream *decrypt(Common::SeekableReadStream &cryptStream,
                                             Encryption encryption, const std::vector<byte> &password);
    static Common::MemoryReadStream *decrypt(Common::SeekableReadStream *cryptStream,
                                             Encryption encryption, const std::vector<byte> &password);

    static Common::SeekableReadStream *decrypt(Common::SeekableReadStream &erf, size_t pos, size_t size,
                                               Encryption encryption, const std::vector<byte> &password);
    static Common::SeekableReadStream *decrypt(Common::SeekableReadStream &erf, size_t size,
                                               Encryption encryption, const std::vector<byte> &password);

    static bool decryptNWNPremiumHeader(Common::SeekableReadStream &erf, ERFHeader &header,
                                        const std::vector<byte> &password);
    static bool findNWNPremiumKey      (Common::SeekableReadStream &erf, ERFHeader &header,
                                        const std::vector<byte> &md5, std::vector<byte> &password);
    static void readNWNPremiumHeader   (Common::SeekableReadStream &erf, ERFHeader &header,
                                        std::vector<byte> &password);

    void decryptNWNPremium();
    // '---

    // .--- Compression
    Common::SeekableReadStream *decompress(Common::MemoryReadStream *packedStream,
                                           uint32 unpackedSize) const;

    Common::SeekableReadStream *decompressBiowareZlib   (Common::MemoryReadStream *packedStream,
                                                         uint32 unpackedSize) const;
    Common::SeekableReadStream *decompressHeaderlessZlib(Common::MemoryReadStream *packedStream,
                                                         uint32 unpackedSize) const;
    Common::SeekableReadStream *decompressStandardZlib  (Common::MemoryReadStream *packedStream,
                                                         uint32 unpackedSize) const;

    Common::SeekableReadStream *decompressZlib(const byte *compressedData, uint32 packedSize,
                                               uint32 unpackedSize, int windowBits) const;
    // '---

    const IResource &getIResource(uint32 index) const;
};

} // End of namespace Aurora

#endif // AURORA_ERFFILE_H