TlsDirectory.h

/*
* TlsDirectory.h - Part of the PeLib library.
*
* Copyright (c) 2004 Sebastian Porst (webmaster@the-interweb.com)
* All rights reserved.
*
* This software is licensed under the zlib/libpng License.
* For more details see http://www.opensource.org/licenses/zlib-license.php
* or the license information file (license.htm) in the root directory 
* of PeLib.
*/

#ifndef TLSDIRECTORY_H
#define TLSDIRECTORY_H

namespace PeLib
{

        template<int bits>
        class TlsDirectory
        {
                private:
                  PELIB_IMAGE_TLS_DIRECTORY<bits> m_tls; 

                public:
                  int read(const std::string& strFilename, unsigned int uiOffset, unsigned int uiSize);
                  void rebuild(std::vector<byte>& vBuffer) const;
                  unsigned int size() const;
                  int write(const std::string& strFilename, unsigned int dwOffset) const;

                  dword getStartAddressOfRawData() const;
                  dword getEndAddressOfRawData() const;
                  dword getAddressOfIndex() const;
                  dword getAddressOfCallBacks() const;
                  dword getSizeOfZeroFill() const;
                  dword getCharacteristics() const;
                  
                  void setStartAddressOfRawData(dword dwValue);
                  void setEndAddressOfRawData(dword dwValue);
                  void setAddressOfIndex(dword dwValue);
                  void setAddressOfCallBacks(dword dwValue);
                  void setSizeOfZeroFill(dword dwValue);
                  void setCharacteristics(dword dwValue);
        };
        template<int bits>
        int TlsDirectory<bits>::read(const std::string& strFilename, unsigned int uiOffset, unsigned int uiSize)
        {
//              if (uiSize < PELIB_IMAGE_TLS_DIRECTORY<bits>::size())
                if (uiSize < PELIB_IMAGE_TLS_DIRECTORY<bits>::size)
                {
//                      throw Exceptions::InvalidFormat(TlsDirectoryId, __LINE__);
                        return 1;
                }

                std::ifstream ifFile(strFilename.c_str(), std::ios::binary);
                unsigned int ulFileSize = fileSize(ifFile);

                if (!ifFile)
                {
//                      throw Exceptions::CannotOpenFile(TlsDirectoryId, __LINE__);
                        return 1;
                }
                
                if (ulFileSize < uiOffset + uiSize)
                {
//                      throw Exceptions::InvalidFormat(TlsDirectoryId, __LINE__);
                        return 1;
                }

                ifFile.seekg(uiOffset, std::ios::beg);

                std::vector<byte> vTlsDirectory(uiSize);
                ifFile.read(reinterpret_cast<char*>(&vTlsDirectory[0]), uiSize);
                
                InputBuffer ibBuffer(vTlsDirectory);
                
                PELIB_IMAGE_TLS_DIRECTORY<bits> itdCurr;
                
                ibBuffer >> itdCurr.StartAddressOfRawData;
                ibBuffer >> itdCurr.EndAddressOfRawData;
                ibBuffer >> itdCurr.AddressOfIndex;
                ibBuffer >> itdCurr.AddressOfCallBacks;
                ibBuffer >> itdCurr.SizeOfZeroFill;
                ibBuffer >> itdCurr.Characteristics;
                
                std::swap(itdCurr, m_tls);
                
                return 0;
        }
        
        template<int bits>
        void TlsDirectory<bits>::rebuild(std::vector<byte>& vBuffer) const
        {
                OutputBuffer obBuffer(vBuffer);
                
                obBuffer << m_tls.StartAddressOfRawData;
                obBuffer << m_tls.EndAddressOfRawData;
                obBuffer << m_tls.AddressOfIndex;
                obBuffer << m_tls.AddressOfCallBacks;
                obBuffer << m_tls.SizeOfZeroFill;
                obBuffer << m_tls.Characteristics;
        }

        template<int bits>
        unsigned int TlsDirectory<bits>::size() const
        {
                return PELIB_IMAGE_TLS_DIRECTORY<bits>::size();
        }

        template<int bits>
        int TlsDirectory<bits>::write(const std::string& strFilename, unsigned int dwOffset) const
        {
                std::fstream ofFile(strFilename.c_str(), std::ios::in | std::ios::out | std::ios::binary);

                if (!ofFile)
                {
                        ofFile.clear();
                        ofFile.open(strFilename.c_str(), std::ios_base::binary | std::ios_base::in | std::ios_base::out | std::ios_base::trunc);
                        if (!ofFile)
                        {
                                return 1;
                                // throw Exceptions::CannotOpenFile(TlsDirectoryId, __LINE__);
                        }
                }

                ofFile.seekp(dwOffset, std::ios::beg);

                std::vector<unsigned char> vBuffer;
                rebuild(vBuffer);

                ofFile.write(reinterpret_cast<const char*>(&vBuffer[0]), vBuffer.size());

                ofFile.close();
                
                return 0;
        }

        template<int bits>
        dword TlsDirectory<bits>::getStartAddressOfRawData() const
        {
                return m_tls.StartAddressOfRawData;
        }
        
        template<int bits>
        dword TlsDirectory<bits>::getEndAddressOfRawData() const
        {
                return m_tls.EndAddressOfRawData;
        }
        
        template<int bits>
        dword TlsDirectory<bits>::getAddressOfIndex() const
        {
                return m_tls.AddressOfIndex;
        }
        
        template<int bits>
        dword TlsDirectory<bits>::getAddressOfCallBacks() const
        {
                return m_tls.AddressOfCallBacks;
        }
        
        template<int bits>
        dword TlsDirectory<bits>::getSizeOfZeroFill() const
        {
                return m_tls.SizeOfZeroFill;
        }
        
        template<int bits>
        dword TlsDirectory<bits>::getCharacteristics() const
        {
                return m_tls.Characteristics;
        }

        template<int bits>
        void TlsDirectory<bits>::setStartAddressOfRawData(dword dwValue)
        {
                m_tls.StartAddressOfRawData = dwValue;
        }
        
        template<int bits>
        void TlsDirectory<bits>::setEndAddressOfRawData(dword dwValue)
        {
                m_tls.EndAddressOfRawData = dwValue;
        }
        
        template<int bits>
        void TlsDirectory<bits>::setAddressOfIndex(dword dwValue)
        {
                m_tls.AddressOfIndex = dwValue;
        }
        
        template<int bits>
        void TlsDirectory<bits>::setAddressOfCallBacks(dword dwValue)
        {
                m_tls.AddressOfCallBacks = dwValue;
        }
        
        template<int bits>
        void TlsDirectory<bits>::setSizeOfZeroFill(dword dwValue)
        {
                m_tls.SizeOfZeroFill = dwValue;
        }
        
        template<int bits>
        void TlsDirectory<bits>::setCharacteristics(dword dwValue)
        {
                m_tls.Characteristics = dwValue;
        }
        
}
#endif

---