/* [<][>][^][v][top][bottom][index][help] */
// AMF.h Low level functions for manipulating and reading AMF buffers.
//
// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010,
// 2011 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
// This file provides low-level manipulators for AMF buffers. It can be used
// without reliance on libcore.
#ifndef GNASH_AMF_H
#define GNASH_AMF_H
#include <string>
#include <boost/cstdint.hpp>
#include "dsodefs.h"
#include "GnashException.h"
namespace gnash {
class SimpleBuffer;
}
namespace gnash {
/// Functions and classes for handling AMF.
//
/// AMF is a simple serialization format for ActionScript objects and values,
/// allowing them to be stored and transmitted. The AMF namespace provides
/// both low-level and high-level conversion to and from AMF buffers.
namespace amf {
enum Type {
NOTYPE = -1,
NUMBER_AMF0 = 0x00,
BOOLEAN_AMF0 = 0x01,
STRING_AMF0 = 0x02,
OBJECT_AMF0 = 0x03,
MOVIECLIP_AMF0 = 0x04,
NULL_AMF0 = 0x05,
UNDEFINED_AMF0 = 0x06,
REFERENCE_AMF0 = 0x07,
ECMA_ARRAY_AMF0 = 0x08,
OBJECT_END_AMF0 = 0x09,
STRICT_ARRAY_AMF0 = 0x0a,
DATE_AMF0 = 0x0b,
LONG_STRING_AMF0 = 0x0c,
UNSUPPORTED_AMF0 = 0x0d,
RECORD_SET_AMF0 = 0x0e,
XML_OBJECT_AMF0 = 0x0f,
TYPED_OBJECT_AMF0 = 0x10
};
/// Exception for handling malformed buffers.
//
/// All low-level reading operations can throw this error.
class DSOEXPORT
AMFException : public GnashException
{
public:
AMFException(const std::string& msg)
:
GnashException(msg)
{}
};
/// Read a number from an AMF buffer
//
/// This does not read a type byte; use AMF::Reader when the type should
/// be determined from the buffer.
//
/// This function will throw an AMFException if it encounters ill-formed AMF.
DSOEXPORT double readNumber(const boost::uint8_t*& pos,
const boost::uint8_t* end);
/// Read a boolean value from the buffer.
//
/// This does not read a type byte; use AMF::Reader when the type should
/// be determined from the buffer.
//
/// This function will throw an AMFException if it encounters ill-formed AMF.
DSOEXPORT bool readBoolean(const boost::uint8_t*& pos,
const boost::uint8_t* end);
/// Read a string value from the buffer.
//
/// This does not read a type byte; use AMF::Reader when the type should
/// be determined from the buffer.
//
/// This function will throw an AMFException if it encounters ill-formed AMF.
DSOEXPORT std::string readString(const boost::uint8_t*& pos,
const boost::uint8_t* end);
/// Read a long string value from the buffer.
//
/// This does not read a type byte; use AMF::Reader when the type should
/// be determined from the buffer.
//
/// This function will throw an AMFException if it encounters ill-formed AMF.
DSOEXPORT std::string readLongString(const boost::uint8_t*& pos,
const boost::uint8_t* end);
/// Read an unsigned 16-bit value in network byte order.
//
/// You must ensure that the buffer contains at least 2 bytes!
inline boost::uint16_t
readNetworkShort(const boost::uint8_t* buf)
{
const boost::uint16_t s = buf[0] << 8 | buf[1];
return s;
}
/// Read an unsigned 32-bit value in network byte order.
//
/// You must ensure that the buffer contains at least 4 bytes!
inline boost::uint32_t
readNetworkLong(const boost::uint8_t* buf)
{
const boost::uint32_t s = buf[0] << 24 | buf[1] << 16 |
buf[2] << 8 | buf[3];
return s;
}
/// Write a string to an AMF buffer.
//
/// This function writes the type byte and the string value. It also handles
/// both long and short strings automatically.
//
/// This is overloaded for automatic type deduction to allow the use of
/// a template for more complex operations. You must be careful when using
/// it!
DSOEXPORT void write(SimpleBuffer& buf, const std::string& str);
/// Write a C string to an AMF buffer.
//
/// The overload is necessary to prevent const char* being resolved to the
/// boolean overload.
inline void write(SimpleBuffer& buf, const char* str) {
return write(buf, std::string(str));
}
/// Write a number to an AMF buffer.
//
/// This function writes the type byte and the double value.
//
/// This is overloaded for automatic type deduction to allow the use of
/// a template for more complex operations. You must be careful when using
/// it!
DSOEXPORT void write(SimpleBuffer& buf, double d);
/// Write a boolean value to an AMF buffer.
//
/// This function writes the type byte and the boolean value.
//
/// This is overloaded for automatic type deduction to allow the use of
/// a template for more complex operations. You must be careful when using
/// it!
DSOEXPORT void write(SimpleBuffer& buf, bool b);
/// Encode a plain short string to an AMF buffer.
//
/// This does not encode a type byte; it is used for cases where a string is
/// required, such as for the name of an object property, and therefore does
/// not use a type byte.
DSOEXPORT void writePlainString(SimpleBuffer& buf, const std::string& str,
Type t);
/// Write a number to an AMF buffer.
//
/// This function writes the double value without a type byte.
DSOEXPORT void writePlainNumber(SimpleBuffer& buf, double d);
/// Encode a string-value pair.
//
/// This is used for object properties; the string is always encoded with
/// a 2-byte length.
template<typename T>
void
writeProperty(SimpleBuffer& buf, const std::string& name, const T& t)
{
writePlainString(buf, name, STRING_AMF0);
write(buf, t);
}
} // namespace amf
} // namespace gnash
#endif