SWFStream.h

Go to the documentation of this file.

// stream.h - SWF stream reading class, for Gnash
// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc
// 
// This program 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.
// 
// This program 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 this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef GNASH_STREAM_H
#define GNASH_STREAM_H

#include "SWF.h"
#include "dsodefs.h" // still neded ?
#include "GnashException.h"

#include <string>
#include <sstream>
#include <vector> // for composition
#include <boost/cstdint.hpp> // for boost::?int??_t 

// Define the following macro if you want to want Gnash parser
// to assume the underlying SWF is well-formed. It would make
// parsing faster, but might result in horrible behaviour with
// malformed SWFs (like taking up all system memory, keeping
// CPU busy for a long long time, or simply corrupting memory)
//
// This might be eventually set by a --disable-swf-checks or similar
// configure switch...
//
//#define GNASH_TRUST_SWF_INPUT

namespace gnash {
        class IOChannel;
}

namespace gnash {

//
class DSOEXPORT SWFStream
{
public:
        SWFStream(IOChannel* input);
        ~SWFStream();

        //
        unsigned read_uint(unsigned short bitcount);

        //
        bool read_bit();

        //
        int     read_sint(unsigned short bitcount);

        //
        float   read_fixed();

        //
        float   read_ufixed();

        //
        float   read_short_ufixed();

        //
        float   read_short_sfixed();

        //
        float   read_short_float();

        //
        float   read_long_float();

        //
        double read_d64();

        //
        void    align()
        {
                m_unused_bits=0;
                // m_current_byte = 0; // this is not needed
        }

        //
        unsigned read(char *buf, unsigned count);
        
        //
        boost::uint8_t  read_u8();

        //
    boost::int8_t read_s8();

        //
        boost::uint16_t read_u16();

        //
        boost::int16_t  read_s16();

        //
        boost::uint32_t read_u32();

        //
        boost::int32_t  read_s32();

        //
        boost::uint32_t read_V32()
        {
        ensureBytes(1);
                boost::uint32_t res = read_u8();
                if (!(res & 0x00000080)) return res;
        
        ensureBytes(1);
                res = (res & 0x0000007F) | read_u8() << 7;
                if (!(res & 0x00004000)) return res;
        
        ensureBytes(1);
                res = (res & 0x00003FFF) | read_u8() << 14;
                if (!(res & 0x00200000)) return res;
        
        ensureBytes(1);
                res = (res & 0x001FFFFF) | read_u8() << 21;
                if (!(res & 0x10000000)) return res;
        
        ensureBytes(1);
                res = (res & 0x0FFFFFFF) | read_u8() << 28;
                return res;
        }

        void skip_V32()
        {
        ensureBytes(1);
                if (!(read_u8() & 0x80)) return;
        ensureBytes(1);
                if (!(read_u8() & 0x80)) return;
        ensureBytes(1);
                if (!(read_u8() & 0x80)) return;
        ensureBytes(1);
                if (!(read_u8() & 0x80)) return;
        ensureBytes(1);
                static_cast<void> (read_u8());
        }

        //
        unsigned read_variable_count()
        {
                ensureBytes(1);
                unsigned count = read_u8();
                if (count == 0xFF)
                {
                        ensureBytes(2);
                        count = read_u16();
                }
                return count;
        };

        void read_string(std::string& to);

        //
        void    read_string_with_length(std::string& to);

        //
        void    read_string_with_length(unsigned len, std::string& to);

        //
        unsigned long tell();

        //
        bool seek(unsigned long pos);

        unsigned long get_tag_end_position();

        //
        SWF::TagType    open_tag();

        void    close_tag();

        //
        bool skip_bytes(unsigned num)
        {
                // there's probably a better way, but
                // it's the interface that counts atm
                size_t curpos = tell();
                return seek(curpos+num);
        }

        void skip_to_tag_end()
        {
                // seek will call align...
                seek(get_tag_end_position());
        }

        //
        void ensureBytes(unsigned long needed);

        //
        void ensureBits(unsigned long needed)
        {
#ifndef GNASH_TRUST_SWF_INPUT
                if ( _tagBoundsStack.empty() ) return; // not in a tag (should we check file length ?)
                unsigned long int bytesLeft = get_tag_end_position() - tell();
                unsigned long int bitsLeft = (bytesLeft*8)+m_unused_bits;
                if ( bitsLeft < needed )
                {
                        std::stringstream ss;
                        ss << "premature end of tag: need to read " << needed << " bytes, but only " << bitsLeft << " left in this tag";
                        throw ParserException(ss.str());
                }
#endif
        }

        //
        void consumeInput();

private:

        IOChannel*      m_input;
        boost::uint8_t  m_current_byte;
        boost::uint8_t  m_unused_bits;

        typedef std::pair<unsigned long,unsigned long> TagBoundaries;
        // position of start and end of tag
        std::vector<TagBoundaries> _tagBoundsStack;
};


} // namespace gnash


#endif // GNASH_STREAM_H


// Local Variables:
// mode: C++
// c-basic-offset: 8 
// tab-width: 8
// indent-tabs-mode: t
// End: